/* Target-dependent code for GNU/Linux, architecture independent.
- Copyright (C) 2009-2013 Free Software Foundation, Inc.
+ Copyright (C) 2009-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "cli/cli-utils.h"
#include "arch-utils.h"
#include "gdb_obstack.h"
-#include "cli/cli-utils.h"
+#include "observer.h"
+#include "objfiles.h"
+#include "infcall.h"
+#include "gdbcmd.h"
+#include "gdb_regex.h"
+#include "common/enum-flags.h"
+#include "common/gdb_optional.h"
#include <ctype.h>
+/* This enum represents the values that the user can choose when
+ informing the Linux kernel about which memory mappings will be
+ dumped in a corefile. They are described in the file
+ Documentation/filesystems/proc.txt, inside the Linux kernel
+ tree. */
+
+enum filter_flag
+ {
+ COREFILTER_ANON_PRIVATE = 1 << 0,
+ COREFILTER_ANON_SHARED = 1 << 1,
+ COREFILTER_MAPPED_PRIVATE = 1 << 2,
+ COREFILTER_MAPPED_SHARED = 1 << 3,
+ COREFILTER_ELF_HEADERS = 1 << 4,
+ COREFILTER_HUGETLB_PRIVATE = 1 << 5,
+ COREFILTER_HUGETLB_SHARED = 1 << 6,
+ };
+DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
+
+/* This struct is used to map flags found in the "VmFlags:" field (in
+ the /proc/<PID>/smaps file). */
+
+struct smaps_vmflags
+ {
+ /* Zero if this structure has not been initialized yet. It
+ probably means that the Linux kernel being used does not emit
+ the "VmFlags:" field on "/proc/PID/smaps". */
+
+ unsigned int initialized_p : 1;
+
+ /* Memory mapped I/O area (VM_IO, "io"). */
+
+ unsigned int io_page : 1;
+
+ /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
+
+ unsigned int uses_huge_tlb : 1;
+
+ /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
+
+ unsigned int exclude_coredump : 1;
+
+ /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
+
+ unsigned int shared_mapping : 1;
+ };
+
+/* Whether to take the /proc/PID/coredump_filter into account when
+ generating a corefile. */
+
+static int use_coredump_filter = 1;
+
/* This enum represents the signals' numbers on a generic architecture
running the Linux kernel. The definition of "generic" comes from
the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
static struct linux_gdbarch_data *
get_linux_gdbarch_data (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
+ return ((struct linux_gdbarch_data *)
+ gdbarch_data (gdbarch, linux_gdbarch_data_handle));
}
-/* This function is suitable for architectures that don't
- extend/override the standard siginfo structure. */
+/* Per-inferior data key. */
+static const struct inferior_data *linux_inferior_data;
+
+/* Linux-specific cached data. This is used by GDB for caching
+ purposes for each inferior. This helps reduce the overhead of
+ transfering data from a remote target to the local host. */
+struct linux_info
+{
+ /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
+ if VSYSCALL_RANGE_P is positive. This is cached because getting
+ at this info requires an auxv lookup (which is itself cached),
+ and looking through the inferior's mappings (which change
+ throughout execution and therefore cannot be cached). */
+ struct mem_range vsyscall_range;
+
+ /* Zero if we haven't tried looking up the vsyscall's range before
+ yet. Positive if we tried looking it up, and found it. Negative
+ if we tried looking it up but failed. */
+ int vsyscall_range_p;
+};
+
+/* Frees whatever allocated space there is to be freed and sets INF's
+ linux cache data pointer to NULL. */
+
+static void
+invalidate_linux_cache_inf (struct inferior *inf)
+{
+ struct linux_info *info;
+
+ info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
+ if (info != NULL)
+ {
+ xfree (info);
+ set_inferior_data (inf, linux_inferior_data, NULL);
+ }
+}
+
+/* Handles the cleanup of the linux cache for inferior INF. ARG is
+ ignored. Callback for the inferior_appeared and inferior_exit
+ events. */
+
+static void
+linux_inferior_data_cleanup (struct inferior *inf, void *arg)
+{
+ invalidate_linux_cache_inf (inf);
+}
+
+/* Fetch the linux cache info for INF. This function always returns a
+ valid INFO pointer. */
+
+static struct linux_info *
+get_linux_inferior_data (void)
+{
+ struct linux_info *info;
+ struct inferior *inf = current_inferior ();
+
+ info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
+ if (info == NULL)
+ {
+ info = XCNEW (struct linux_info);
+ set_inferior_data (inf, linux_inferior_data, info);
+ }
+
+ return info;
+}
+
+/* See linux-tdep.h. */
struct type *
-linux_get_siginfo_type (struct gdbarch *gdbarch)
+linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
+ linux_siginfo_extra_fields extra_fields)
{
struct linux_gdbarch_data *linux_gdbarch_data;
- struct type *int_type, *uint_type, *long_type, *void_ptr_type;
+ struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
struct type *uid_type, *pid_type;
struct type *sigval_type, *clock_type;
struct type *siginfo_type, *sifields_type;
1, "unsigned int");
long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
0, "long");
+ short_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
+ 0, "short");
void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
/* sival_t */
/* _sigfault */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "si_addr", void_ptr_type);
+
+ /* Additional bound fields for _sigfault in case they were requested. */
+ if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
+ {
+ struct type *sigfault_bnd_fields;
+
+ append_composite_type_field (type, "_addr_lsb", short_type);
+ sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
+ append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
+ append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
+ append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
+ }
append_composite_type_field (sifields_type, "_sigfault", type);
/* _sigpoll */
return siginfo_type;
}
+/* This function is suitable for architectures that don't
+ extend/override the standard siginfo structure. */
+
+static struct type *
+linux_get_siginfo_type (struct gdbarch *gdbarch)
+{
+ return linux_get_siginfo_type_with_fields (gdbarch, 0);
+}
+
/* Return true if the target is running on uClinux instead of normal
Linux kernel. */
/* This is how we want PTIDs from core files to be printed. */
-static char *
+static const char *
linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
{
static char buf[80];
*filename = p;
}
+/* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
+
+ This function was based on the documentation found on
+ <Documentation/filesystems/proc.txt>, on the Linux kernel.
+
+ Linux kernels before commit
+ 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
+ field on smaps. */
+
+static void
+decode_vmflags (char *p, struct smaps_vmflags *v)
+{
+ char *saveptr = NULL;
+ const char *s;
+
+ v->initialized_p = 1;
+ p = skip_to_space (p);
+ p = skip_spaces (p);
+
+ for (s = strtok_r (p, " ", &saveptr);
+ s != NULL;
+ s = strtok_r (NULL, " ", &saveptr))
+ {
+ if (strcmp (s, "io") == 0)
+ v->io_page = 1;
+ else if (strcmp (s, "ht") == 0)
+ v->uses_huge_tlb = 1;
+ else if (strcmp (s, "dd") == 0)
+ v->exclude_coredump = 1;
+ else if (strcmp (s, "sh") == 0)
+ v->shared_mapping = 1;
+ }
+}
+
+/* Regexes used by mapping_is_anonymous_p. Put in a structure because
+ they're initialized lazily. */
+
+struct mapping_regexes
+{
+ /* Matches "/dev/zero" filenames (with or without the "(deleted)"
+ string in the end). We know for sure, based on the Linux kernel
+ code, that memory mappings whose associated filename is
+ "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
+ compiled_regex dev_zero
+ {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB,
+ _("Could not compile regex to match /dev/zero filename")};
+
+ /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
+ string in the end). These filenames refer to shared memory
+ (shmem), and memory mappings associated with them are
+ MAP_ANONYMOUS as well. */
+ compiled_regex shmem_file
+ {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB,
+ _("Could not compile regex to match shmem filenames")};
+
+ /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
+ 0' code, which is responsible to decide if it is dealing with a
+ 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
+ FILE_DELETED matches, it does not necessarily mean that we are
+ dealing with an anonymous shared mapping. However, there is no
+ easy way to detect this currently, so this is the best
+ approximation we have.
+
+ As a result, GDB will dump readonly pages of deleted executables
+ when using the default value of coredump_filter (0x33), while the
+ Linux kernel will not dump those pages. But we can live with
+ that. */
+ compiled_regex file_deleted
+ {" (deleted)$", REG_NOSUB,
+ _("Could not compile regex to match '<file> (deleted)'")};
+};
+
+/* Return 1 if the memory mapping is anonymous, 0 otherwise.
+
+ FILENAME is the name of the file present in the first line of the
+ memory mapping, in the "/proc/PID/smaps" output. For example, if
+ the first line is:
+
+ 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
+
+ Then FILENAME will be "/path/to/file". */
+
+static int
+mapping_is_anonymous_p (const char *filename)
+{
+ static gdb::optional<mapping_regexes> regexes;
+ static int init_regex_p = 0;
+
+ if (!init_regex_p)
+ {
+ /* Let's be pessimistic and assume there will be an error while
+ compiling the regex'es. */
+ init_regex_p = -1;
+
+ regexes.emplace ();
+
+ /* If we reached this point, then everything succeeded. */
+ init_regex_p = 1;
+ }
+
+ if (init_regex_p == -1)
+ {
+ const char deleted[] = " (deleted)";
+ size_t del_len = sizeof (deleted) - 1;
+ size_t filename_len = strlen (filename);
+
+ /* There was an error while compiling the regex'es above. In
+ order to try to give some reliable information to the caller,
+ we just try to find the string " (deleted)" in the filename.
+ If we managed to find it, then we assume the mapping is
+ anonymous. */
+ return (filename_len >= del_len
+ && strcmp (filename + filename_len - del_len, deleted) == 0);
+ }
+
+ if (*filename == '\0'
+ || regexes->dev_zero.exec (filename, 0, NULL, 0) == 0
+ || regexes->shmem_file.exec (filename, 0, NULL, 0) == 0
+ || regexes->file_deleted.exec (filename, 0, NULL, 0) == 0)
+ return 1;
+
+ return 0;
+}
+
+/* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
+ MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
+ greater than 0 if it should.
+
+ In a nutshell, this is the logic that we follow in order to decide
+ if a mapping should be dumped or not.
+
+ - If the mapping is associated to a file whose name ends with
+ " (deleted)", or if the file is "/dev/zero", or if it is
+ "/SYSV%08x" (shared memory), or if there is no file associated
+ with it, or if the AnonHugePages: or the Anonymous: fields in the
+ /proc/PID/smaps have contents, then GDB considers this mapping to
+ be anonymous. Otherwise, GDB considers this mapping to be a
+ file-backed mapping (because there will be a file associated with
+ it).
+
+ It is worth mentioning that, from all those checks described
+ above, the most fragile is the one to see if the file name ends
+ with " (deleted)". This does not necessarily mean that the
+ mapping is anonymous, because the deleted file associated with
+ the mapping may have been a hard link to another file, for
+ example. The Linux kernel checks to see if "i_nlink == 0", but
+ GDB cannot easily (and normally) do this check (iff running as
+ root, it could find the mapping in /proc/PID/map_files/ and
+ determine whether there still are other hard links to the
+ inode/file). Therefore, we made a compromise here, and we assume
+ that if the file name ends with " (deleted)", then the mapping is
+ indeed anonymous. FWIW, this is something the Linux kernel could
+ do better: expose this information in a more direct way.
+
+ - If we see the flag "sh" in the "VmFlags:" field (in
+ /proc/PID/smaps), then certainly the memory mapping is shared
+ (VM_SHARED). If we have access to the VmFlags, and we don't see
+ the "sh" there, then certainly the mapping is private. However,
+ Linux kernels before commit
+ 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
+ "VmFlags:" field; in that case, we use another heuristic: if we
+ see 'p' in the permission flags, then we assume that the mapping
+ is private, even though the presence of the 's' flag there would
+ mean VM_MAYSHARE, which means the mapping could still be private.
+ This should work OK enough, however. */
+
+static int
+dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
+ int maybe_private_p, int mapping_anon_p, int mapping_file_p,
+ const char *filename)
+{
+ /* Initially, we trust in what we received from our caller. This
+ value may not be very precise (i.e., it was probably gathered
+ from the permission line in the /proc/PID/smaps list, which
+ actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
+ what we have until we take a look at the "VmFlags:" field
+ (assuming that the version of the Linux kernel being used
+ supports it, of course). */
+ int private_p = maybe_private_p;
+
+ /* We always dump vDSO and vsyscall mappings, because it's likely that
+ there'll be no file to read the contents from at core load time.
+ The kernel does the same. */
+ if (strcmp ("[vdso]", filename) == 0
+ || strcmp ("[vsyscall]", filename) == 0)
+ return 1;
+
+ if (v->initialized_p)
+ {
+ /* We never dump I/O mappings. */
+ if (v->io_page)
+ return 0;
+
+ /* Check if we should exclude this mapping. */
+ if (v->exclude_coredump)
+ return 0;
+
+ /* Update our notion of whether this mapping is shared or
+ private based on a trustworthy value. */
+ private_p = !v->shared_mapping;
+
+ /* HugeTLB checking. */
+ if (v->uses_huge_tlb)
+ {
+ if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
+ || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
+ return 1;
+
+ return 0;
+ }
+ }
+
+ if (private_p)
+ {
+ if (mapping_anon_p && mapping_file_p)
+ {
+ /* This is a special situation. It can happen when we see a
+ mapping that is file-backed, but that contains anonymous
+ pages. */
+ return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
+ || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
+ }
+ else if (mapping_anon_p)
+ return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
+ else
+ return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
+ }
+ else
+ {
+ if (mapping_anon_p && mapping_file_p)
+ {
+ /* This is a special situation. It can happen when we see a
+ mapping that is file-backed, but that contains anonymous
+ pages. */
+ return ((filterflags & COREFILTER_ANON_SHARED) != 0
+ || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
+ }
+ else if (mapping_anon_p)
+ return (filterflags & COREFILTER_ANON_SHARED) != 0;
+ else
+ return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
+ }
+}
+
/* Implement the "info proc" command. */
static void
-linux_info_proc (struct gdbarch *gdbarch, char *args,
+linux_info_proc (struct gdbarch *gdbarch, const char *args,
enum info_proc_what what)
{
/* A long is used for pid instead of an int to avoid a loss of precision
int target_errno;
if (args && isdigit (args[0]))
- pid = strtoul (args, &args, 10);
+ {
+ char *tem;
+
+ pid = strtoul (args, &tem, 10);
+ args = tem;
+ }
else
{
if (!target_has_execution)
pid = current_inferior ()->pid;
}
- args = skip_spaces (args);
+ args = skip_spaces_const (args);
if (args && args[0])
error (_("Too many parameters: %s"), args);
if (cmdline_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
- data = target_fileio_read_stralloc (filename);
+ data = target_fileio_read_stralloc (NULL, filename);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
if (cwd_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
- data = target_fileio_readlink (filename, &target_errno);
+ data = target_fileio_readlink (NULL, filename, &target_errno);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
if (exe_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
- data = target_fileio_readlink (filename, &target_errno);
+ data = target_fileio_readlink (NULL, filename, &target_errno);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
if (mappings_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
- data = target_fileio_read_stralloc (filename);
+ data = target_fileio_read_stralloc (NULL, filename);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
if (status_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
- data = target_fileio_read_stralloc (filename);
+ data = target_fileio_read_stralloc (NULL, filename);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
if (stat_f)
{
xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
- data = target_fileio_read_stralloc (filename);
+ data = target_fileio_read_stralloc (NULL, filename);
if (data)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
p = skip_spaces_const (p);
if (*p == '(')
{
- const char *ep = strchr (p, ')');
+ /* ps command also relies on no trailing fields
+ ever contain ')'. */
+ const char *ep = strrchr (p, ')');
if (ep != NULL)
{
printf_filtered ("Exec file: %.*s\n",
/* Implement "info proc mappings" for a corefile. */
static void
-linux_core_info_proc_mappings (struct gdbarch *gdbarch, char *args)
+linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
{
asection *section;
ULONGEST count, page_size;
if (note_size < 2 * addr_size)
error (_("malformed core note - too short for header"));
- contents = xmalloc (note_size);
+ contents = (unsigned char *) xmalloc (note_size);
cleanup = make_cleanup (xfree, contents);
if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
error (_("could not get core note contents"));
/* Implement "info proc" for a corefile. */
static void
-linux_core_info_proc (struct gdbarch *gdbarch, char *args,
+linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
enum info_proc_what what)
{
int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
void *obfd)
{
char mapsfilename[100];
- char *data;
+ char coredumpfilter_name[100];
+ char *data, *coredumpfilterdata;
+ pid_t pid;
+ /* Default dump behavior of coredump_filter (0x33), according to
+ Documentation/filesystems/proc.txt from the Linux kernel
+ tree. */
+ filter_flags filterflags = (COREFILTER_ANON_PRIVATE
+ | COREFILTER_ANON_SHARED
+ | COREFILTER_ELF_HEADERS
+ | COREFILTER_HUGETLB_PRIVATE);
/* We need to know the real target PID to access /proc. */
if (current_inferior ()->fake_pid_p)
return 1;
- xsnprintf (mapsfilename, sizeof mapsfilename,
- "/proc/%d/smaps", current_inferior ()->pid);
- data = target_fileio_read_stralloc (mapsfilename);
+ pid = current_inferior ()->pid;
+
+ if (use_coredump_filter)
+ {
+ xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
+ "/proc/%d/coredump_filter", pid);
+ coredumpfilterdata = target_fileio_read_stralloc (NULL,
+ coredumpfilter_name);
+ if (coredumpfilterdata != NULL)
+ {
+ unsigned int flags;
+
+ sscanf (coredumpfilterdata, "%x", &flags);
+ filterflags = (enum filter_flag) flags;
+ xfree (coredumpfilterdata);
+ }
+ }
+
+ xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
+ data = target_fileio_read_stralloc (NULL, mapsfilename);
if (data == NULL)
{
/* Older Linux kernels did not support /proc/PID/smaps. */
- xsnprintf (mapsfilename, sizeof mapsfilename,
- "/proc/%d/maps", current_inferior ()->pid);
- data = target_fileio_read_stralloc (mapsfilename);
+ xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
+ data = target_fileio_read_stralloc (NULL, mapsfilename);
}
- if (data)
+
+ if (data != NULL)
{
struct cleanup *cleanup = make_cleanup (xfree, data);
- char *line;
+ char *line, *t;
- line = strtok (data, "\n");
- while (line)
+ line = strtok_r (data, "\n", &t);
+ while (line != NULL)
{
ULONGEST addr, endaddr, offset, inode;
const char *permissions, *device, *filename;
+ struct smaps_vmflags v;
size_t permissions_len, device_len;
- int read, write, exec;
- int modified = 0, has_anonymous = 0;
+ int read, write, exec, priv;
+ int has_anonymous = 0;
+ int should_dump_p = 0;
+ int mapping_anon_p;
+ int mapping_file_p;
+ memset (&v, 0, sizeof (v));
read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
&offset, &device, &device_len, &inode, &filename);
+ mapping_anon_p = mapping_is_anonymous_p (filename);
+ /* If the mapping is not anonymous, then we can consider it
+ to be file-backed. These two states (anonymous or
+ file-backed) seem to be exclusive, but they can actually
+ coexist. For example, if a file-backed mapping has
+ "Anonymous:" pages (see more below), then the Linux
+ kernel will dump this mapping when the user specified
+ that she only wants anonymous mappings in the corefile
+ (*even* when she explicitly disabled the dumping of
+ file-backed mappings). */
+ mapping_file_p = !mapping_anon_p;
/* Decode permissions. */
read = (memchr (permissions, 'r', permissions_len) != 0);
write = (memchr (permissions, 'w', permissions_len) != 0);
exec = (memchr (permissions, 'x', permissions_len) != 0);
-
- /* Try to detect if region was modified by parsing smaps counters. */
- for (line = strtok (NULL, "\n");
- line && line[0] >= 'A' && line[0] <= 'Z';
- line = strtok (NULL, "\n"))
+ /* 'private' here actually means VM_MAYSHARE, and not
+ VM_SHARED. In order to know if a mapping is really
+ private or not, we must check the flag "sh" in the
+ VmFlags field. This is done by decode_vmflags. However,
+ if we are using a Linux kernel released before the commit
+ 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
+ not have the VmFlags there. In this case, there is
+ really no way to know if we are dealing with VM_SHARED,
+ so we just assume that VM_MAYSHARE is enough. */
+ priv = memchr (permissions, 'p', permissions_len) != 0;
+
+ /* Try to detect if region should be dumped by parsing smaps
+ counters. */
+ for (line = strtok_r (NULL, "\n", &t);
+ line != NULL && line[0] >= 'A' && line[0] <= 'Z';
+ line = strtok_r (NULL, "\n", &t))
{
char keyword[64 + 1];
warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
break;
}
+
if (strcmp (keyword, "Anonymous:") == 0)
- has_anonymous = 1;
- if (strcmp (keyword, "Shared_Dirty:") == 0
- || strcmp (keyword, "Private_Dirty:") == 0
- || strcmp (keyword, "Swap:") == 0
+ {
+ /* Older Linux kernels did not support the
+ "Anonymous:" counter. Check it here. */
+ has_anonymous = 1;
+ }
+ else if (strcmp (keyword, "VmFlags:") == 0)
+ decode_vmflags (line, &v);
+
+ if (strcmp (keyword, "AnonHugePages:") == 0
|| strcmp (keyword, "Anonymous:") == 0)
{
unsigned long number;
mapsfilename);
break;
}
- if (number != 0)
- modified = 1;
+ if (number > 0)
+ {
+ /* Even if we are dealing with a file-backed
+ mapping, if it contains anonymous pages we
+ consider it to be *also* an anonymous
+ mapping, because this is what the Linux
+ kernel does:
+
+ // Dump segments that have been written to.
+ if (vma->anon_vma && FILTER(ANON_PRIVATE))
+ goto whole;
+
+ Note that if the mapping is already marked as
+ file-backed (i.e., mapping_file_p is
+ non-zero), then this is a special case, and
+ this mapping will be dumped either when the
+ user wants to dump file-backed *or* anonymous
+ mappings. */
+ mapping_anon_p = 1;
+ }
}
}
- /* Older Linux kernels did not support the "Anonymous:" counter.
- If it is missing, we can't be sure - dump all the pages. */
- if (!has_anonymous)
- modified = 1;
+ if (has_anonymous)
+ should_dump_p = dump_mapping_p (filterflags, &v, priv,
+ mapping_anon_p, mapping_file_p,
+ filename);
+ else
+ {
+ /* Older Linux kernels did not support the "Anonymous:" counter.
+ If it is missing, we can't be sure - dump all the pages. */
+ should_dump_p = 1;
+ }
/* Invoke the callback function to create the corefile segment. */
- func (addr, endaddr - addr, offset, inode,
- read, write, exec, modified, filename, obfd);
+ if (should_dump_p)
+ func (addr, endaddr - addr, offset, inode,
+ read, write, exec, 1, /* MODIFIED is true because we
+ want to dump the mapping. */
+ filename, obfd);
}
do_cleanups (cleanup);
int read, int write, int exec, int modified,
const char *filename, void *arg)
{
- struct linux_find_memory_regions_data *data = arg;
+ struct linux_find_memory_regions_data *data
+ = (struct linux_find_memory_regions_data *) arg;
return data->func (vaddr, size, read, write, exec, modified, data->obfd);
}
return 0;
}
-static enum gdb_signal
-find_stop_signal (void)
-{
- struct thread_info *info =
- iterate_over_threads (find_signalled_thread, NULL);
-
- if (info)
- return info->suspend.stop_signal;
- else
- return GDB_SIGNAL_0;
-}
-
/* Generate corefile notes for SPU contexts. */
static char *
int read, int write, int exec, int modified,
const char *filename, void *data)
{
- struct linux_make_mappings_data *map_data = data;
+ struct linux_make_mappings_data *map_data
+ = (struct linux_make_mappings_data *) data;
gdb_byte buf[sizeof (ULONGEST)];
if (*filename == '\0' || inode == 0)
return note_data;
}
+/* Structure for passing information from
+ linux_collect_thread_registers via an iterator to
+ linux_collect_regset_section_cb. */
+
+struct linux_collect_regset_section_cb_data
+{
+ struct gdbarch *gdbarch;
+ const struct regcache *regcache;
+ bfd *obfd;
+ char *note_data;
+ int *note_size;
+ unsigned long lwp;
+ enum gdb_signal stop_signal;
+ int abort_iteration;
+};
+
+/* Callback for iterate_over_regset_sections that records a single
+ regset in the corefile note section. */
+
+static void
+linux_collect_regset_section_cb (const char *sect_name, int size,
+ const struct regset *regset,
+ const char *human_name, void *cb_data)
+{
+ char *buf;
+ struct linux_collect_regset_section_cb_data *data
+ = (struct linux_collect_regset_section_cb_data *) cb_data;
+
+ if (data->abort_iteration)
+ return;
+
+ gdb_assert (regset && regset->collect_regset);
+
+ buf = (char *) xmalloc (size);
+ regset->collect_regset (regset, data->regcache, -1, buf, size);
+
+ /* PRSTATUS still needs to be treated specially. */
+ if (strcmp (sect_name, ".reg") == 0)
+ data->note_data = (char *) elfcore_write_prstatus
+ (data->obfd, data->note_data, data->note_size, data->lwp,
+ gdb_signal_to_host (data->stop_signal), buf);
+ else
+ data->note_data = (char *) elfcore_write_register_note
+ (data->obfd, data->note_data, data->note_size,
+ sect_name, buf, size);
+ xfree (buf);
+
+ if (data->note_data == NULL)
+ data->abort_iteration = 1;
+}
+
/* Records the thread's register state for the corefile note
section. */
enum gdb_signal stop_signal)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- struct core_regset_section *sect_list;
- unsigned long lwp;
+ struct linux_collect_regset_section_cb_data data;
- sect_list = gdbarch_core_regset_sections (gdbarch);
- gdb_assert (sect_list);
+ data.gdbarch = gdbarch;
+ data.regcache = regcache;
+ data.obfd = obfd;
+ data.note_data = note_data;
+ data.note_size = note_size;
+ data.stop_signal = stop_signal;
+ data.abort_iteration = 0;
/* For remote targets the LWP may not be available, so use the TID. */
- lwp = ptid_get_lwp (ptid);
- if (!lwp)
- lwp = ptid_get_tid (ptid);
-
- while (sect_list->sect_name != NULL)
- {
- const struct regset *regset;
- char *buf;
-
- regset = gdbarch_regset_from_core_section (gdbarch,
- sect_list->sect_name,
- sect_list->size);
- gdb_assert (regset && regset->collect_regset);
-
- buf = xmalloc (sect_list->size);
- regset->collect_regset (regset, regcache, -1, buf, sect_list->size);
-
- /* PRSTATUS still needs to be treated specially. */
- if (strcmp (sect_list->sect_name, ".reg") == 0)
- note_data = (char *) elfcore_write_prstatus
- (obfd, note_data, note_size, lwp,
- gdb_signal_to_host (stop_signal), buf);
- else
- note_data = (char *) elfcore_write_register_note
- (obfd, note_data, note_size,
- sect_list->sect_name, buf, sect_list->size);
- xfree (buf);
- sect_list++;
-
- if (!note_data)
- return NULL;
- }
-
- return note_data;
+ data.lwp = ptid_get_lwp (ptid);
+ if (!data.lwp)
+ data.lwp = ptid_get_tid (ptid);
+
+ gdbarch_iterate_over_regset_sections (gdbarch,
+ linux_collect_regset_section_cb,
+ &data, regcache);
+ return data.note_data;
}
/* Fetch the siginfo data for the current thread, if it exists. If
siginfo_type = gdbarch_get_siginfo_type (gdbarch);
- buf = xmalloc (TYPE_LENGTH (siginfo_type));
+ buf = (gdb_byte *) xmalloc (TYPE_LENGTH (siginfo_type));
cleanups = make_cleanup (xfree, buf);
bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
struct linux_corefile_thread_data
{
struct gdbarch *gdbarch;
- int pid;
bfd *obfd;
char *note_data;
int *note_size;
enum gdb_signal stop_signal;
- linux_collect_thread_registers_ftype collect;
};
-/* Called by gdbthread.c once per thread. Records the thread's
- register state for the corefile note section. */
+/* Records the thread's register state for the corefile note
+ section. */
-static int
-linux_corefile_thread_callback (struct thread_info *info, void *data)
+static void
+linux_corefile_thread (struct thread_info *info,
+ struct linux_corefile_thread_data *args)
{
- struct linux_corefile_thread_data *args = data;
-
- if (ptid_get_pid (info->ptid) == args->pid)
- {
- struct cleanup *old_chain;
- struct regcache *regcache;
- gdb_byte *siginfo_data;
- LONGEST siginfo_size = 0;
-
- regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
-
- old_chain = save_inferior_ptid ();
- inferior_ptid = info->ptid;
- target_fetch_registers (regcache, -1);
- siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
- do_cleanups (old_chain);
-
- old_chain = make_cleanup (xfree, siginfo_data);
-
- args->note_data = args->collect (regcache, info->ptid, args->obfd,
- args->note_data, args->note_size,
- args->stop_signal);
-
- /* Don't return anything if we got no register information above,
- such a core file is useless. */
- if (args->note_data != NULL)
- if (siginfo_data != NULL)
- args->note_data = elfcore_write_note (args->obfd,
- args->note_data,
- args->note_size,
- "CORE", NT_SIGINFO,
- siginfo_data, siginfo_size);
-
- do_cleanups (old_chain);
- }
-
- return !args->note_data;
+ struct cleanup *old_chain;
+ struct regcache *regcache;
+ gdb_byte *siginfo_data;
+ LONGEST siginfo_size = 0;
+
+ regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
+
+ old_chain = save_inferior_ptid ();
+ inferior_ptid = info->ptid;
+ target_fetch_registers (regcache, -1);
+ siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
+ do_cleanups (old_chain);
+
+ old_chain = make_cleanup (xfree, siginfo_data);
+
+ args->note_data = linux_collect_thread_registers
+ (regcache, info->ptid, args->obfd, args->note_data,
+ args->note_size, args->stop_signal);
+
+ /* Don't return anything if we got no register information above,
+ such a core file is useless. */
+ if (args->note_data != NULL)
+ if (siginfo_data != NULL)
+ args->note_data = elfcore_write_note (args->obfd,
+ args->note_data,
+ args->note_size,
+ "CORE", NT_SIGINFO,
+ siginfo_data, siginfo_size);
+
+ do_cleanups (old_chain);
}
/* Fill the PRPSINFO structure with information about the process being
int n_fields = 0;
/* Cleanups. */
struct cleanup *c;
- int i;
gdb_assert (p != NULL);
/* Obtaining PID and filename. */
pid = ptid_get_pid (inferior_ptid);
xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
- fname = target_fileio_read_stralloc (filename);
+ fname = target_fileio_read_stralloc (NULL, filename);
if (fname == NULL || *fname == '\0')
{
psargs = xstrdup (fname);
if (infargs != NULL)
- psargs = reconcat (psargs, psargs, " ", infargs, NULL);
+ psargs = reconcat (psargs, psargs, " ", infargs, (char *) NULL);
make_cleanup (xfree, psargs);
p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
- proc_stat = target_fileio_read_stralloc (filename);
+ proc_stat = target_fileio_read_stralloc (NULL, filename);
make_cleanup (xfree, proc_stat);
if (proc_stat == NULL || *proc_stat == '\0')
proc_stat = skip_spaces (proc_stat);
- /* Getting rid of the executable name, since we already have it. We
- know that this name will be in parentheses, so we can safely look
- for the close-paren. */
- while (*proc_stat != ')')
- ++proc_stat;
- ++proc_stat;
+ /* ps command also relies on no trailing fields ever contain ')'. */
+ proc_stat = strrchr (proc_stat, ')');
+ if (proc_stat == NULL)
+ {
+ do_cleanups (c);
+ return 1;
+ }
+ proc_stat++;
proc_stat = skip_spaces (proc_stat);
/* Finally, obtaining the UID and GID. For that, we read and parse the
contents of the `/proc/PID/status' file. */
xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
- proc_status = target_fileio_read_stralloc (filename);
+ proc_status = target_fileio_read_stralloc (NULL, filename);
make_cleanup (xfree, proc_status);
if (proc_status == NULL || *proc_status == '\0')
return 1;
}
-/* Fills the "to_make_corefile_note" target vector. Builds the note
- section for a corefile, and returns it in a malloc buffer. */
+/* Build the note section for a corefile, and return it in a malloc
+ buffer. */
-char *
-linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size,
- linux_collect_thread_registers_ftype collect)
+static char *
+linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
{
struct linux_corefile_thread_data thread_args;
struct elf_internal_linux_prpsinfo prpsinfo;
char *note_data = NULL;
gdb_byte *auxv;
int auxv_len;
+ struct thread_info *curr_thr, *signalled_thr, *thr;
+
+ if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
+ return NULL;
if (linux_fill_prpsinfo (&prpsinfo))
{
}
/* Thread register information. */
+ TRY
+ {
+ update_thread_list ();
+ }
+ CATCH (e, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, e);
+ }
+ END_CATCH
+
+ /* Like the kernel, prefer dumping the signalled thread first.
+ "First thread" is what tools use to infer the signalled thread.
+ In case there's more than one signalled thread, prefer the
+ current thread, if it is signalled. */
+ curr_thr = inferior_thread ();
+ if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
+ signalled_thr = curr_thr;
+ else
+ {
+ signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
+ if (signalled_thr == NULL)
+ signalled_thr = curr_thr;
+ }
+
thread_args.gdbarch = gdbarch;
- thread_args.pid = ptid_get_pid (inferior_ptid);
thread_args.obfd = obfd;
thread_args.note_data = note_data;
thread_args.note_size = note_size;
- thread_args.stop_signal = find_stop_signal ();
- thread_args.collect = collect;
- iterate_over_threads (linux_corefile_thread_callback, &thread_args);
+ thread_args.stop_signal = signalled_thr->suspend.stop_signal;
+
+ linux_corefile_thread (signalled_thr, &thread_args);
+ ALL_NON_EXITED_THREADS (thr)
+ {
+ if (thr == signalled_thr)
+ continue;
+ if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
+ continue;
+
+ linux_corefile_thread (thr, &thread_args);
+ }
+
note_data = thread_args.note_data;
if (!note_data)
return NULL;
note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
note_data, note_size);
- make_cleanup (xfree, note_data);
return note_data;
}
-static char *
-linux_make_corefile_notes_1 (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
-{
- /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
- converted to gdbarch_core_regset_sections, we no longer need to fall back
- to the target method at this point. */
-
- if (!gdbarch_core_regset_sections (gdbarch))
- return target_make_corefile_notes (obfd, note_size);
- else
- return linux_make_corefile_notes (gdbarch, obfd, note_size,
- linux_collect_thread_registers);
-}
-
/* Implementation of `gdbarch_gdb_signal_from_target', as defined in
gdbarch.h. This function is not static because it is exported to
other -tdep files. */
return -1;
}
+/* Helper for linux_vsyscall_range that does the real work of finding
+ the vsyscall's address range. */
+
+static int
+linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
+{
+ char filename[100];
+ long pid;
+ char *data;
+
+ if (target_auxv_search (¤t_target, AT_SYSINFO_EHDR, &range->start) <= 0)
+ return 0;
+
+ /* It doesn't make sense to access the host's /proc when debugging a
+ core file. Instead, look for the PT_LOAD segment that matches
+ the vDSO. */
+ if (!target_has_execution)
+ {
+ Elf_Internal_Phdr *phdrs;
+ long phdrs_size;
+ int num_phdrs, i;
+
+ phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
+ if (phdrs_size == -1)
+ return 0;
+
+ phdrs = (Elf_Internal_Phdr *) alloca (phdrs_size);
+ num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs);
+ if (num_phdrs == -1)
+ return 0;
+
+ for (i = 0; i < num_phdrs; i++)
+ if (phdrs[i].p_type == PT_LOAD
+ && phdrs[i].p_vaddr == range->start)
+ {
+ range->length = phdrs[i].p_memsz;
+ return 1;
+ }
+
+ return 0;
+ }
+
+ /* We need to know the real target PID to access /proc. */
+ if (current_inferior ()->fake_pid_p)
+ return 0;
+
+ pid = current_inferior ()->pid;
+
+ /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
+ reading /proc/PID/maps (2). The later identifies thread stacks
+ in the output, which requires scanning every thread in the thread
+ group to check whether a VMA is actually a thread's stack. With
+ Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
+ a few thousand threads, (1) takes a few miliseconds, while (2)
+ takes several seconds. Also note that "smaps", what we read for
+ determining core dump mappings, is even slower than "maps". */
+ xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
+ data = target_fileio_read_stralloc (NULL, filename);
+ if (data != NULL)
+ {
+ struct cleanup *cleanup = make_cleanup (xfree, data);
+ char *line;
+ char *saveptr = NULL;
+
+ for (line = strtok_r (data, "\n", &saveptr);
+ line != NULL;
+ line = strtok_r (NULL, "\n", &saveptr))
+ {
+ ULONGEST addr, endaddr;
+ const char *p = line;
+
+ addr = strtoulst (p, &p, 16);
+ if (addr == range->start)
+ {
+ if (*p == '-')
+ p++;
+ endaddr = strtoulst (p, &p, 16);
+ range->length = endaddr - addr;
+ do_cleanups (cleanup);
+ return 1;
+ }
+ }
+
+ do_cleanups (cleanup);
+ }
+ else
+ warning (_("unable to open /proc file '%s'"), filename);
+
+ return 0;
+}
+
+/* Implementation of the "vsyscall_range" gdbarch hook. Handles
+ caching, and defers the real work to linux_vsyscall_range_raw. */
+
+static int
+linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
+{
+ struct linux_info *info = get_linux_inferior_data ();
+
+ if (info->vsyscall_range_p == 0)
+ {
+ if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
+ info->vsyscall_range_p = 1;
+ else
+ info->vsyscall_range_p = -1;
+ }
+
+ if (info->vsyscall_range_p < 0)
+ return 0;
+
+ *range = info->vsyscall_range;
+ return 1;
+}
+
+/* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
+ definitions would be dependent on compilation host. */
+#define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
+#define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
+
+/* See gdbarch.sh 'infcall_mmap'. */
+
+static CORE_ADDR
+linux_infcall_mmap (CORE_ADDR size, unsigned prot)
+{
+ struct objfile *objf;
+ /* Do there still exist any Linux systems without "mmap64"?
+ "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
+ struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
+ struct value *addr_val;
+ struct gdbarch *gdbarch = get_objfile_arch (objf);
+ CORE_ADDR retval;
+ enum
+ {
+ ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
+ };
+ struct value *arg[ARG_LAST];
+
+ arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
+ 0);
+ /* Assuming sizeof (unsigned long) == sizeof (size_t). */
+ arg[ARG_LENGTH] = value_from_ulongest
+ (builtin_type (gdbarch)->builtin_unsigned_long, size);
+ gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
+ | GDB_MMAP_PROT_EXEC))
+ == 0);
+ arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
+ arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
+ GDB_MMAP_MAP_PRIVATE
+ | GDB_MMAP_MAP_ANONYMOUS);
+ arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
+ arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
+ 0);
+ addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
+ retval = value_as_address (addr_val);
+ if (retval == (CORE_ADDR) -1)
+ error (_("Failed inferior mmap call for %s bytes, errno is changed."),
+ pulongest (size));
+ return retval;
+}
+
+/* See gdbarch.sh 'infcall_munmap'. */
+
+static void
+linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
+{
+ struct objfile *objf;
+ struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
+ struct value *retval_val;
+ struct gdbarch *gdbarch = get_objfile_arch (objf);
+ LONGEST retval;
+ enum
+ {
+ ARG_ADDR, ARG_LENGTH, ARG_LAST
+ };
+ struct value *arg[ARG_LAST];
+
+ arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
+ addr);
+ /* Assuming sizeof (unsigned long) == sizeof (size_t). */
+ arg[ARG_LENGTH] = value_from_ulongest
+ (builtin_type (gdbarch)->builtin_unsigned_long, size);
+ retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
+ retval = value_as_long (retval_val);
+ if (retval != 0)
+ warning (_("Failed inferior munmap call at %s for %s bytes, "
+ "errno is changed."),
+ hex_string (addr), pulongest (size));
+}
+
+/* See linux-tdep.h. */
+
+CORE_ADDR
+linux_displaced_step_location (struct gdbarch *gdbarch)
+{
+ CORE_ADDR addr;
+ int bp_len;
+
+ /* Determine entry point from target auxiliary vector. This avoids
+ the need for symbols. Also, when debugging a stand-alone SPU
+ executable, entry_point_address () will point to an SPU
+ local-store address and is thus not usable as displaced stepping
+ location. The auxiliary vector gets us the PowerPC-side entry
+ point address instead. */
+ if (target_auxv_search (¤t_target, AT_ENTRY, &addr) <= 0)
+ throw_error (NOT_SUPPORTED_ERROR,
+ _("Cannot find AT_ENTRY auxiliary vector entry."));
+
+ /* Make certain that the address points at real code, and not a
+ function descriptor. */
+ addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
+ ¤t_target);
+
+ /* Inferior calls also use the entry point as a breakpoint location.
+ We don't want displaced stepping to interfere with those
+ breakpoints, so leave space. */
+ gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
+ addr += bp_len * 2;
+
+ return addr;
+}
+
+/* Display whether the gcore command is using the
+ /proc/PID/coredump_filter file. */
+
+static void
+show_use_coredump_filter (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
+ " corefiles is %s.\n"), value);
+}
+
/* To be called from the various GDB_OSABI_LINUX handlers for the
various GNU/Linux architectures and machine types. */
set_gdbarch_info_proc (gdbarch, linux_info_proc);
set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
- set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes_1);
+ set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
set_gdbarch_has_shared_address_space (gdbarch,
linux_has_shared_address_space);
set_gdbarch_gdb_signal_from_target (gdbarch,
linux_gdb_signal_from_target);
set_gdbarch_gdb_signal_to_target (gdbarch,
linux_gdb_signal_to_target);
+ set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
+ set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
+ set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
+ set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
}
/* Provide a prototype to silence -Wmissing-prototypes. */
{
linux_gdbarch_data_handle =
gdbarch_data_register_post_init (init_linux_gdbarch_data);
+
+ /* Set a cache per-inferior. */
+ linux_inferior_data
+ = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
+ /* Observers used to invalidate the cache when needed. */
+ observer_attach_inferior_exit (invalidate_linux_cache_inf);
+ observer_attach_inferior_appeared (invalidate_linux_cache_inf);
+
+ add_setshow_boolean_cmd ("use-coredump-filter", class_files,
+ &use_coredump_filter, _("\
+Set whether gcore should consider /proc/PID/coredump_filter."),
+ _("\
+Show whether gcore should consider /proc/PID/coredump_filter."),
+ _("\
+Use this command to set whether gcore should consider the contents\n\
+of /proc/PID/coredump_filter when generating the corefile. For more information\n\
+about this file, refer to the manpage of core(5)."),
+ NULL, show_use_coredump_filter,
+ &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff