gdb/linux-tdep.c

   1 /* Target-dependent code for GNU/Linux, architecture independent.
   2
   3    Copyright (C) 2009-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbtypes.h"
  22 #include "linux-tdep.h"
  23 #include "auxv.h"
  24 #include "target.h"
  25 #include "gdbthread.h"
  26 #include "gdbcore.h"
  27 #include "regcache.h"
  28 #include "regset.h"
  29 #include "elf/common.h"
  30 #include "elf-bfd.h"            /* for elfcore_write_* */
  31 #include "inferior.h"
  32 #include "cli/cli-utils.h"
  33 #include "arch-utils.h"
  34 #include "gdb_obstack.h"
  35 #include "observer.h"
  36 #include "objfiles.h"
  37 #include "infcall.h"
  38 #include "gdbcmd.h"
  39 #include "gdb_regex.h"
  40 #include "common/enum-flags.h"
  41
  42 #include <ctype.h>
  43
  44 /* This enum represents the values that the user can choose when
  45    informing the Linux kernel about which memory mappings will be
  46    dumped in a corefile.  They are described in the file
  47    Documentation/filesystems/proc.txt, inside the Linux kernel
  48    tree.  */
  49
  50 enum filter_flag
  51   {
  52     COREFILTER_ANON_PRIVATE = 1 << 0,
  53     COREFILTER_ANON_SHARED = 1 << 1,
  54     COREFILTER_MAPPED_PRIVATE = 1 << 2,
  55     COREFILTER_MAPPED_SHARED = 1 << 3,
  56     COREFILTER_ELF_HEADERS = 1 << 4,
  57     COREFILTER_HUGETLB_PRIVATE = 1 << 5,
  58     COREFILTER_HUGETLB_SHARED = 1 << 6,
  59   };
  60 DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
  61
  62 /* This struct is used to map flags found in the "VmFlags:" field (in
  63    the /proc/<PID>/smaps file).  */
  64
  65 struct smaps_vmflags
  66   {
  67     /* Zero if this structure has not been initialized yet.  It
  68        probably means that the Linux kernel being used does not emit
  69        the "VmFlags:" field on "/proc/PID/smaps".  */
  70
  71     unsigned int initialized_p : 1;
  72
  73     /* Memory mapped I/O area (VM_IO, "io").  */
  74
  75     unsigned int io_page : 1;
  76
  77     /* Area uses huge TLB pages (VM_HUGETLB, "ht").  */
  78
  79     unsigned int uses_huge_tlb : 1;
  80
  81     /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd").  */
  82
  83     unsigned int exclude_coredump : 1;
  84
  85     /* Is this a MAP_SHARED mapping (VM_SHARED, "sh").  */
  86
  87     unsigned int shared_mapping : 1;
  88   };
  89
  90 /* Whether to take the /proc/PID/coredump_filter into account when
  91    generating a corefile.  */
  92
  93 static int use_coredump_filter = 1;
  94
  95 /* This enum represents the signals' numbers on a generic architecture
  96    running the Linux kernel.  The definition of "generic" comes from
  97    the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
  98    tree, which is the "de facto" implementation of signal numbers to
  99    be used by new architecture ports.
 100
 101    For those architectures which have differences between the generic
 102    standard (e.g., Alpha), we define the different signals (and *only*
 103    those) in the specific target-dependent file (e.g.,
 104    alpha-linux-tdep.c, for Alpha).  Please refer to the architecture's
 105    tdep file for more information.
 106
 107    ARM deserves a special mention here.  On the file
 108    <arch/arm/include/uapi/asm/signal.h>, it defines only one different
 109    (and ARM-only) signal, which is SIGSWI, with the same number as
 110    SIGRTMIN.  This signal is used only for a very specific target,
 111    called ArthurOS (from RISCOS).  Therefore, we do not handle it on
 112    the ARM-tdep file, and we can safely use the generic signal handler
 113    here for ARM targets.
 114
 115    As stated above, this enum is derived from
 116    <include/uapi/asm-generic/signal.h>, from the Linux kernel
 117    tree.  */
 118
 119 enum
 120   {
 121     LINUX_SIGHUP = 1,
 122     LINUX_SIGINT = 2,
 123     LINUX_SIGQUIT = 3,
 124     LINUX_SIGILL = 4,
 125     LINUX_SIGTRAP = 5,
 126     LINUX_SIGABRT = 6,
 127     LINUX_SIGIOT = 6,
 128     LINUX_SIGBUS = 7,
 129     LINUX_SIGFPE = 8,
 130     LINUX_SIGKILL = 9,
 131     LINUX_SIGUSR1 = 10,
 132     LINUX_SIGSEGV = 11,
 133     LINUX_SIGUSR2 = 12,
 134     LINUX_SIGPIPE = 13,
 135     LINUX_SIGALRM = 14,
 136     LINUX_SIGTERM = 15,
 137     LINUX_SIGSTKFLT = 16,
 138     LINUX_SIGCHLD = 17,
 139     LINUX_SIGCONT = 18,
 140     LINUX_SIGSTOP = 19,
 141     LINUX_SIGTSTP = 20,
 142     LINUX_SIGTTIN = 21,
 143     LINUX_SIGTTOU = 22,
 144     LINUX_SIGURG = 23,
 145     LINUX_SIGXCPU = 24,
 146     LINUX_SIGXFSZ = 25,
 147     LINUX_SIGVTALRM = 26,
 148     LINUX_SIGPROF = 27,
 149     LINUX_SIGWINCH = 28,
 150     LINUX_SIGIO = 29,
 151     LINUX_SIGPOLL = LINUX_SIGIO,
 152     LINUX_SIGPWR = 30,
 153     LINUX_SIGSYS = 31,
 154     LINUX_SIGUNUSED = 31,
 155
 156     LINUX_SIGRTMIN = 32,
 157     LINUX_SIGRTMAX = 64,
 158   };
 159
 160 static struct gdbarch_data *linux_gdbarch_data_handle;
 161
 162 struct linux_gdbarch_data
 163   {
 164     struct type *siginfo_type;
 165   };
 166
 167 static void *
 168 init_linux_gdbarch_data (struct gdbarch *gdbarch)
 169 {
 170   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
 171 }
 172
 173 static struct linux_gdbarch_data *
 174 get_linux_gdbarch_data (struct gdbarch *gdbarch)
 175 {
 176   return ((struct linux_gdbarch_data *)
 177           gdbarch_data (gdbarch, linux_gdbarch_data_handle));
 178 }
 179
 180 /* Per-inferior data key.  */
 181 static const struct inferior_data *linux_inferior_data;
 182
 183 /* Linux-specific cached data.  This is used by GDB for caching
 184    purposes for each inferior.  This helps reduce the overhead of
 185    transfering data from a remote target to the local host.  */
 186 struct linux_info
 187 {
 188   /* Cache of the inferior's vsyscall/vDSO mapping range.  Only valid
 189      if VSYSCALL_RANGE_P is positive.  This is cached because getting
 190      at this info requires an auxv lookup (which is itself cached),
 191      and looking through the inferior's mappings (which change
 192      throughout execution and therefore cannot be cached).  */
 193   struct mem_range vsyscall_range;
 194
 195   /* Zero if we haven't tried looking up the vsyscall's range before
 196      yet.  Positive if we tried looking it up, and found it.  Negative
 197      if we tried looking it up but failed.  */
 198   int vsyscall_range_p;
 199 };
 200
 201 /* Frees whatever allocated space there is to be freed and sets INF's
 202    linux cache data pointer to NULL.  */
 203
 204 static void
 205 invalidate_linux_cache_inf (struct inferior *inf)
 206 {
 207   struct linux_info *info;
 208
 209   info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
 210   if (info != NULL)
 211     {
 212       xfree (info);
 213       set_inferior_data (inf, linux_inferior_data, NULL);
 214     }
 215 }
 216
 217 /* Handles the cleanup of the linux cache for inferior INF.  ARG is
 218    ignored.  Callback for the inferior_appeared and inferior_exit
 219    events.  */
 220
 221 static void
 222 linux_inferior_data_cleanup (struct inferior *inf, void *arg)
 223 {
 224   invalidate_linux_cache_inf (inf);
 225 }
 226
 227 /* Fetch the linux cache info for INF.  This function always returns a
 228    valid INFO pointer.  */
 229
 230 static struct linux_info *
 231 get_linux_inferior_data (void)
 232 {
 233   struct linux_info *info;
 234   struct inferior *inf = current_inferior ();
 235
 236   info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
 237   if (info == NULL)
 238     {
 239       info = XCNEW (struct linux_info);
 240       set_inferior_data (inf, linux_inferior_data, info);
 241     }
 242
 243   return info;
 244 }
 245
 246 /* See linux-tdep.h.  */
 247
 248 struct type *
 249 linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
 250                                     linux_siginfo_extra_fields extra_fields)
 251 {
 252   struct linux_gdbarch_data *linux_gdbarch_data;
 253   struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
 254   struct type *uid_type, *pid_type;
 255   struct type *sigval_type, *clock_type;
 256   struct type *siginfo_type, *sifields_type;
 257   struct type *type;
 258
 259   linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
 260   if (linux_gdbarch_data->siginfo_type != NULL)
 261     return linux_gdbarch_data->siginfo_type;
 262
 263   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
 264                                 0, "int");
 265   uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
 266                                  1, "unsigned int");
 267   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
 268                                  0, "long");
 269   short_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
 270                                  0, "short");
 271   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
 272
 273   /* sival_t */
 274   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 275   TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
 276   append_composite_type_field (sigval_type, "sival_int", int_type);
 277   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
 278
 279   /* __pid_t */
 280   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 281                         TYPE_LENGTH (int_type), "__pid_t");
 282   TYPE_TARGET_TYPE (pid_type) = int_type;
 283   TYPE_TARGET_STUB (pid_type) = 1;
 284
 285   /* __uid_t */
 286   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 287                         TYPE_LENGTH (uint_type), "__uid_t");
 288   TYPE_TARGET_TYPE (uid_type) = uint_type;
 289   TYPE_TARGET_STUB (uid_type) = 1;
 290
 291   /* __clock_t */
 292   clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 293                           TYPE_LENGTH (long_type), "__clock_t");
 294   TYPE_TARGET_TYPE (clock_type) = long_type;
 295   TYPE_TARGET_STUB (clock_type) = 1;
 296
 297   /* _sifields */
 298   sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 299
 300   {
 301     const int si_max_size = 128;
 302     int si_pad_size;
 303     int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
 304
 305     /* _pad */
 306     if (gdbarch_ptr_bit (gdbarch) == 64)
 307       si_pad_size = (si_max_size / size_of_int) - 4;
 308     else
 309       si_pad_size = (si_max_size / size_of_int) - 3;
 310     append_composite_type_field (sifields_type, "_pad",
 311                                  init_vector_type (int_type, si_pad_size));
 312   }
 313
 314   /* _kill */
 315   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 316   append_composite_type_field (type, "si_pid", pid_type);
 317   append_composite_type_field (type, "si_uid", uid_type);
 318   append_composite_type_field (sifields_type, "_kill", type);
 319
 320   /* _timer */
 321   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 322   append_composite_type_field (type, "si_tid", int_type);
 323   append_composite_type_field (type, "si_overrun", int_type);
 324   append_composite_type_field (type, "si_sigval", sigval_type);
 325   append_composite_type_field (sifields_type, "_timer", type);
 326
 327   /* _rt */
 328   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 329   append_composite_type_field (type, "si_pid", pid_type);
 330   append_composite_type_field (type, "si_uid", uid_type);
 331   append_composite_type_field (type, "si_sigval", sigval_type);
 332   append_composite_type_field (sifields_type, "_rt", type);
 333
 334   /* _sigchld */
 335   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 336   append_composite_type_field (type, "si_pid", pid_type);
 337   append_composite_type_field (type, "si_uid", uid_type);
 338   append_composite_type_field (type, "si_status", int_type);
 339   append_composite_type_field (type, "si_utime", clock_type);
 340   append_composite_type_field (type, "si_stime", clock_type);
 341   append_composite_type_field (sifields_type, "_sigchld", type);
 342
 343   /* _sigfault */
 344   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 345   append_composite_type_field (type, "si_addr", void_ptr_type);
 346
 347   /* Additional bound fields for _sigfault in case they were requested.  */
 348   if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
 349     {
 350       struct type *sigfault_bnd_fields;
 351
 352       append_composite_type_field (type, "_addr_lsb", short_type);
 353       sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 354       append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
 355       append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
 356       append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
 357     }
 358   append_composite_type_field (sifields_type, "_sigfault", type);
 359
 360   /* _sigpoll */
 361   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 362   append_composite_type_field (type, "si_band", long_type);
 363   append_composite_type_field (type, "si_fd", int_type);
 364   append_composite_type_field (sifields_type, "_sigpoll", type);
 365
 366   /* struct siginfo */
 367   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 368   TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
 369   append_composite_type_field (siginfo_type, "si_signo", int_type);
 370   append_composite_type_field (siginfo_type, "si_errno", int_type);
 371   append_composite_type_field (siginfo_type, "si_code", int_type);
 372   append_composite_type_field_aligned (siginfo_type,
 373                                        "_sifields", sifields_type,
 374                                        TYPE_LENGTH (long_type));
 375
 376   linux_gdbarch_data->siginfo_type = siginfo_type;
 377
 378   return siginfo_type;
 379 }
 380
 381 /* This function is suitable for architectures that don't
 382    extend/override the standard siginfo structure.  */
 383
 384 static struct type *
 385 linux_get_siginfo_type (struct gdbarch *gdbarch)
 386 {
 387   return linux_get_siginfo_type_with_fields (gdbarch, 0);
 388 }
 389
 390 /* Return true if the target is running on uClinux instead of normal
 391    Linux kernel.  */
 392
 393 int
 394 linux_is_uclinux (void)
 395 {
 396   CORE_ADDR dummy;
 397
 398   return (target_auxv_search (&current_target, AT_NULL, &dummy) > 0
 399           && target_auxv_search (&current_target, AT_PAGESZ, &dummy) == 0);
 400 }
 401
 402 static int
 403 linux_has_shared_address_space (struct gdbarch *gdbarch)
 404 {
 405   return linux_is_uclinux ();
 406 }
 407
 408 /* This is how we want PTIDs from core files to be printed.  */
 409
 410 static char *
 411 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
 412 {
 413   static char buf[80];
 414
 415   if (ptid_get_lwp (ptid) != 0)
 416     {
 417       snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
 418       return buf;
 419     }
 420
 421   return normal_pid_to_str (ptid);
 422 }
 423
 424 /* Service function for corefiles and info proc.  */
 425
 426 static void
 427 read_mapping (const char *line,
 428               ULONGEST *addr, ULONGEST *endaddr,
 429               const char **permissions, size_t *permissions_len,
 430               ULONGEST *offset,
 431               const char **device, size_t *device_len,
 432               ULONGEST *inode,
 433               const char **filename)
 434 {
 435   const char *p = line;
 436
 437   *addr = strtoulst (p, &p, 16);
 438   if (*p == '-')
 439     p++;
 440   *endaddr = strtoulst (p, &p, 16);
 441
 442   p = skip_spaces_const (p);
 443   *permissions = p;
 444   while (*p && !isspace (*p))
 445     p++;
 446   *permissions_len = p - *permissions;
 447
 448   *offset = strtoulst (p, &p, 16);
 449
 450   p = skip_spaces_const (p);
 451   *device = p;
 452   while (*p && !isspace (*p))
 453     p++;
 454   *device_len = p - *device;
 455
 456   *inode = strtoulst (p, &p, 10);
 457
 458   p = skip_spaces_const (p);
 459   *filename = p;
 460 }
 461
 462 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
 463
 464    This function was based on the documentation found on
 465    <Documentation/filesystems/proc.txt>, on the Linux kernel.
 466
 467    Linux kernels before commit
 468    834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
 469    field on smaps.  */
 470
 471 static void
 472 decode_vmflags (char *p, struct smaps_vmflags *v)
 473 {
 474   char *saveptr = NULL;
 475   const char *s;
 476
 477   v->initialized_p = 1;
 478   p = skip_to_space (p);
 479   p = skip_spaces (p);
 480
 481   for (s = strtok_r (p, " ", &saveptr);
 482        s != NULL;
 483        s = strtok_r (NULL, " ", &saveptr))
 484     {
 485       if (strcmp (s, "io") == 0)
 486         v->io_page = 1;
 487       else if (strcmp (s, "ht") == 0)
 488         v->uses_huge_tlb = 1;
 489       else if (strcmp (s, "dd") == 0)
 490         v->exclude_coredump = 1;
 491       else if (strcmp (s, "sh") == 0)
 492         v->shared_mapping = 1;
 493     }
 494 }
 495
 496 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
 497
 498    FILENAME is the name of the file present in the first line of the
 499    memory mapping, in the "/proc/PID/smaps" output.  For example, if
 500    the first line is:
 501
 502    7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770   /path/to/file
 503
 504    Then FILENAME will be "/path/to/file".  */
 505
 506 static int
 507 mapping_is_anonymous_p (const char *filename)
 508 {
 509   static regex_t dev_zero_regex, shmem_file_regex, file_deleted_regex;
 510   static int init_regex_p = 0;
 511
 512   if (!init_regex_p)
 513     {
 514       struct cleanup *c = make_cleanup (null_cleanup, NULL);
 515
 516       /* Let's be pessimistic and assume there will be an error while
 517          compiling the regex'es.  */
 518       init_regex_p = -1;
 519
 520       /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
 521          without the "(deleted)" string in the end).  We know for
 522          sure, based on the Linux kernel code, that memory mappings
 523          whose associated filename is "/dev/zero" are guaranteed to be
 524          MAP_ANONYMOUS.  */
 525       compile_rx_or_error (&dev_zero_regex, "^/dev/zero\\( (deleted)\\)\\?$",
 526                            _("Could not compile regex to match /dev/zero "
 527                              "filename"));
 528       /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
 529          without the "(deleted)" string in the end).  These filenames
 530          refer to shared memory (shmem), and memory mappings
 531          associated with them are MAP_ANONYMOUS as well.  */
 532       compile_rx_or_error (&shmem_file_regex,
 533                            "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
 534                            _("Could not compile regex to match shmem "
 535                              "filenames"));
 536       /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
 537          Linux kernel's 'n_link == 0' code, which is responsible to
 538          decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
 539          mapping.  In other words, if FILE_DELETED_REGEX matches, it
 540          does not necessarily mean that we are dealing with an
 541          anonymous shared mapping.  However, there is no easy way to
 542          detect this currently, so this is the best approximation we
 543          have.
 544
 545          As a result, GDB will dump readonly pages of deleted
 546          executables when using the default value of coredump_filter
 547          (0x33), while the Linux kernel will not dump those pages.
 548          But we can live with that.  */
 549       compile_rx_or_error (&file_deleted_regex, " (deleted)$",
 550                            _("Could not compile regex to match "
 551                              "'<file> (deleted)'"));
 552       /* We will never release these regexes, so just discard the
 553          cleanups.  */
 554       discard_cleanups (c);
 555
 556       /* If we reached this point, then everything succeeded.  */
 557       init_regex_p = 1;
 558     }
 559
 560   if (init_regex_p == -1)
 561     {
 562       const char deleted[] = " (deleted)";
 563       size_t del_len = sizeof (deleted) - 1;
 564       size_t filename_len = strlen (filename);
 565
 566       /* There was an error while compiling the regex'es above.  In
 567          order to try to give some reliable information to the caller,
 568          we just try to find the string " (deleted)" in the filename.
 569          If we managed to find it, then we assume the mapping is
 570          anonymous.  */
 571       return (filename_len >= del_len
 572               && strcmp (filename + filename_len - del_len, deleted) == 0);
 573     }
 574
 575   if (*filename == '\0'
 576       || regexec (&dev_zero_regex, filename, 0, NULL, 0) == 0
 577       || regexec (&shmem_file_regex, filename, 0, NULL, 0) == 0
 578       || regexec (&file_deleted_regex, filename, 0, NULL, 0) == 0)
 579     return 1;
 580
 581   return 0;
 582 }
 583
 584 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
 585    MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
 586    greater than 0 if it should.
 587
 588    In a nutshell, this is the logic that we follow in order to decide
 589    if a mapping should be dumped or not.
 590
 591    - If the mapping is associated to a file whose name ends with
 592      " (deleted)", or if the file is "/dev/zero", or if it is
 593      "/SYSV%08x" (shared memory), or if there is no file associated
 594      with it, or if the AnonHugePages: or the Anonymous: fields in the
 595      /proc/PID/smaps have contents, then GDB considers this mapping to
 596      be anonymous.  Otherwise, GDB considers this mapping to be a
 597      file-backed mapping (because there will be a file associated with
 598      it).
 599
 600      It is worth mentioning that, from all those checks described
 601      above, the most fragile is the one to see if the file name ends
 602      with " (deleted)".  This does not necessarily mean that the
 603      mapping is anonymous, because the deleted file associated with
 604      the mapping may have been a hard link to another file, for
 605      example.  The Linux kernel checks to see if "i_nlink == 0", but
 606      GDB cannot easily (and normally) do this check (iff running as
 607      root, it could find the mapping in /proc/PID/map_files/ and
 608      determine whether there still are other hard links to the
 609      inode/file).  Therefore, we made a compromise here, and we assume
 610      that if the file name ends with " (deleted)", then the mapping is
 611      indeed anonymous.  FWIW, this is something the Linux kernel could
 612      do better: expose this information in a more direct way.
 613
 614    - If we see the flag "sh" in the "VmFlags:" field (in
 615      /proc/PID/smaps), then certainly the memory mapping is shared
 616      (VM_SHARED).  If we have access to the VmFlags, and we don't see
 617      the "sh" there, then certainly the mapping is private.  However,
 618      Linux kernels before commit
 619      834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
 620      "VmFlags:" field; in that case, we use another heuristic: if we
 621      see 'p' in the permission flags, then we assume that the mapping
 622      is private, even though the presence of the 's' flag there would
 623      mean VM_MAYSHARE, which means the mapping could still be private.
 624      This should work OK enough, however.  */
 625
 626 static int
 627 dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
 628                 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
 629                 const char *filename)
 630 {
 631   /* Initially, we trust in what we received from our caller.  This
 632      value may not be very precise (i.e., it was probably gathered
 633      from the permission line in the /proc/PID/smaps list, which
 634      actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
 635      what we have until we take a look at the "VmFlags:" field
 636      (assuming that the version of the Linux kernel being used
 637      supports it, of course).  */
 638   int private_p = maybe_private_p;
 639
 640   /* We always dump vDSO and vsyscall mappings, because it's likely that
 641      there'll be no file to read the contents from at core load time.
 642      The kernel does the same.  */
 643   if (strcmp ("[vdso]", filename) == 0
 644       || strcmp ("[vsyscall]", filename) == 0)
 645     return 1;
 646
 647   if (v->initialized_p)
 648     {
 649       /* We never dump I/O mappings.  */
 650       if (v->io_page)
 651         return 0;
 652
 653       /* Check if we should exclude this mapping.  */
 654       if (v->exclude_coredump)
 655         return 0;
 656
 657       /* Update our notion of whether this mapping is shared or
 658          private based on a trustworthy value.  */
 659       private_p = !v->shared_mapping;
 660
 661       /* HugeTLB checking.  */
 662       if (v->uses_huge_tlb)
 663         {
 664           if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
 665               || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
 666             return 1;
 667
 668           return 0;
 669         }
 670     }
 671
 672   if (private_p)
 673     {
 674       if (mapping_anon_p && mapping_file_p)
 675         {
 676           /* This is a special situation.  It can happen when we see a
 677              mapping that is file-backed, but that contains anonymous
 678              pages.  */
 679           return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
 680                   || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
 681         }
 682       else if (mapping_anon_p)
 683         return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
 684       else
 685         return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
 686     }
 687   else
 688     {
 689       if (mapping_anon_p && mapping_file_p)
 690         {
 691           /* This is a special situation.  It can happen when we see a
 692              mapping that is file-backed, but that contains anonymous
 693              pages.  */
 694           return ((filterflags & COREFILTER_ANON_SHARED) != 0
 695                   || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
 696         }
 697       else if (mapping_anon_p)
 698         return (filterflags & COREFILTER_ANON_SHARED) != 0;
 699       else
 700         return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
 701     }
 702 }
 703
 704 /* Implement the "info proc" command.  */
 705
 706 static void
 707 linux_info_proc (struct gdbarch *gdbarch, const char *args,
 708                  enum info_proc_what what)
 709 {
 710   /* A long is used for pid instead of an int to avoid a loss of precision
 711      compiler warning from the output of strtoul.  */
 712   long pid;
 713   int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
 714   int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
 715   int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
 716   int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
 717   int status_f = (what == IP_STATUS || what == IP_ALL);
 718   int stat_f = (what == IP_STAT || what == IP_ALL);
 719   char filename[100];
 720   char *data;
 721   int target_errno;
 722
 723   if (args && isdigit (args[0]))
 724     {
 725       char *tem;
 726
 727       pid = strtoul (args, &tem, 10);
 728       args = tem;
 729     }
 730   else
 731     {
 732       if (!target_has_execution)
 733         error (_("No current process: you must name one."));
 734       if (current_inferior ()->fake_pid_p)
 735         error (_("Can't determine the current process's PID: you must name one."));
 736
 737       pid = current_inferior ()->pid;
 738     }
 739
 740   args = skip_spaces_const (args);
 741   if (args && args[0])
 742     error (_("Too many parameters: %s"), args);
 743
 744   printf_filtered (_("process %ld\n"), pid);
 745   if (cmdline_f)
 746     {
 747       xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
 748       data = target_fileio_read_stralloc (NULL, filename);
 749       if (data)
 750         {
 751           struct cleanup *cleanup = make_cleanup (xfree, data);
 752           printf_filtered ("cmdline = '%s'\n", data);
 753           do_cleanups (cleanup);
 754         }
 755       else
 756         warning (_("unable to open /proc file '%s'"), filename);
 757     }
 758   if (cwd_f)
 759     {
 760       xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
 761       data = target_fileio_readlink (NULL, filename, &target_errno);
 762       if (data)
 763         {
 764           struct cleanup *cleanup = make_cleanup (xfree, data);
 765           printf_filtered ("cwd = '%s'\n", data);
 766           do_cleanups (cleanup);
 767         }
 768       else
 769         warning (_("unable to read link '%s'"), filename);
 770     }
 771   if (exe_f)
 772     {
 773       xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
 774       data = target_fileio_readlink (NULL, filename, &target_errno);
 775       if (data)
 776         {
 777           struct cleanup *cleanup = make_cleanup (xfree, data);
 778           printf_filtered ("exe = '%s'\n", data);
 779           do_cleanups (cleanup);
 780         }
 781       else
 782         warning (_("unable to read link '%s'"), filename);
 783     }
 784   if (mappings_f)
 785     {
 786       xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
 787       data = target_fileio_read_stralloc (NULL, filename);
 788       if (data)
 789         {
 790           struct cleanup *cleanup = make_cleanup (xfree, data);
 791           char *line;
 792
 793           printf_filtered (_("Mapped address spaces:\n\n"));
 794           if (gdbarch_addr_bit (gdbarch) == 32)
 795             {
 796               printf_filtered ("\t%10s %10s %10s %10s %s\n",
 797                            "Start Addr",
 798                            "  End Addr",
 799                            "      Size", "    Offset", "objfile");
 800             }
 801           else
 802             {
 803               printf_filtered ("  %18s %18s %10s %10s %s\n",
 804                            "Start Addr",
 805                            "  End Addr",
 806                            "      Size", "    Offset", "objfile");
 807             }
 808
 809           for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
 810             {
 811               ULONGEST addr, endaddr, offset, inode;
 812               const char *permissions, *device, *filename;
 813               size_t permissions_len, device_len;
 814
 815               read_mapping (line, &addr, &endaddr,
 816                             &permissions, &permissions_len,
 817                             &offset, &device, &device_len,
 818                             &inode, &filename);
 819
 820               if (gdbarch_addr_bit (gdbarch) == 32)
 821                 {
 822                   printf_filtered ("\t%10s %10s %10s %10s %s\n",
 823                                    paddress (gdbarch, addr),
 824                                    paddress (gdbarch, endaddr),
 825                                    hex_string (endaddr - addr),
 826                                    hex_string (offset),
 827                                    *filename? filename : "");
 828                 }
 829               else
 830                 {
 831                   printf_filtered ("  %18s %18s %10s %10s %s\n",
 832                                    paddress (gdbarch, addr),
 833                                    paddress (gdbarch, endaddr),
 834                                    hex_string (endaddr - addr),
 835                                    hex_string (offset),
 836                                    *filename? filename : "");
 837                 }
 838             }
 839
 840           do_cleanups (cleanup);
 841         }
 842       else
 843         warning (_("unable to open /proc file '%s'"), filename);
 844     }
 845   if (status_f)
 846     {
 847       xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
 848       data = target_fileio_read_stralloc (NULL, filename);
 849       if (data)
 850         {
 851           struct cleanup *cleanup = make_cleanup (xfree, data);
 852           puts_filtered (data);
 853           do_cleanups (cleanup);
 854         }
 855       else
 856         warning (_("unable to open /proc file '%s'"), filename);
 857     }
 858   if (stat_f)
 859     {
 860       xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
 861       data = target_fileio_read_stralloc (NULL, filename);
 862       if (data)
 863         {
 864           struct cleanup *cleanup = make_cleanup (xfree, data);
 865           const char *p = data;
 866
 867           printf_filtered (_("Process: %s\n"),
 868                            pulongest (strtoulst (p, &p, 10)));
 869
 870           p = skip_spaces_const (p);
 871           if (*p == '(')
 872             {
 873               /* ps command also relies on no trailing fields
 874                  ever contain ')'.  */
 875               const char *ep = strrchr (p, ')');
 876               if (ep != NULL)
 877                 {
 878                   printf_filtered ("Exec file: %.*s\n",
 879                                    (int) (ep - p - 1), p + 1);
 880                   p = ep + 1;
 881                 }
 882             }
 883
 884           p = skip_spaces_const (p);
 885           if (*p)
 886             printf_filtered (_("State: %c\n"), *p++);
 887
 888           if (*p)
 889             printf_filtered (_("Parent process: %s\n"),
 890                              pulongest (strtoulst (p, &p, 10)));
 891           if (*p)
 892             printf_filtered (_("Process group: %s\n"),
 893                              pulongest (strtoulst (p, &p, 10)));
 894           if (*p)
 895             printf_filtered (_("Session id: %s\n"),
 896                              pulongest (strtoulst (p, &p, 10)));
 897           if (*p)
 898             printf_filtered (_("TTY: %s\n"),
 899                              pulongest (strtoulst (p, &p, 10)));
 900           if (*p)
 901             printf_filtered (_("TTY owner process group: %s\n"),
 902                              pulongest (strtoulst (p, &p, 10)));
 903
 904           if (*p)
 905             printf_filtered (_("Flags: %s\n"),
 906                              hex_string (strtoulst (p, &p, 10)));
 907           if (*p)
 908             printf_filtered (_("Minor faults (no memory page): %s\n"),
 909                              pulongest (strtoulst (p, &p, 10)));
 910           if (*p)
 911             printf_filtered (_("Minor faults, children: %s\n"),
 912                              pulongest (strtoulst (p, &p, 10)));
 913           if (*p)
 914             printf_filtered (_("Major faults (memory page faults): %s\n"),
 915                              pulongest (strtoulst (p, &p, 10)));
 916           if (*p)
 917             printf_filtered (_("Major faults, children: %s\n"),
 918                              pulongest (strtoulst (p, &p, 10)));
 919           if (*p)
 920             printf_filtered (_("utime: %s\n"),
 921                              pulongest (strtoulst (p, &p, 10)));
 922           if (*p)
 923             printf_filtered (_("stime: %s\n"),
 924                              pulongest (strtoulst (p, &p, 10)));
 925           if (*p)
 926             printf_filtered (_("utime, children: %s\n"),
 927                              pulongest (strtoulst (p, &p, 10)));
 928           if (*p)
 929             printf_filtered (_("stime, children: %s\n"),
 930                              pulongest (strtoulst (p, &p, 10)));
 931           if (*p)
 932             printf_filtered (_("jiffies remaining in current "
 933                                "time slice: %s\n"),
 934                              pulongest (strtoulst (p, &p, 10)));
 935           if (*p)
 936             printf_filtered (_("'nice' value: %s\n"),
 937                              pulongest (strtoulst (p, &p, 10)));
 938           if (*p)
 939             printf_filtered (_("jiffies until next timeout: %s\n"),
 940                              pulongest (strtoulst (p, &p, 10)));
 941           if (*p)
 942             printf_filtered (_("jiffies until next SIGALRM: %s\n"),
 943                              pulongest (strtoulst (p, &p, 10)));
 944           if (*p)
 945             printf_filtered (_("start time (jiffies since "
 946                                "system boot): %s\n"),
 947                              pulongest (strtoulst (p, &p, 10)));
 948           if (*p)
 949             printf_filtered (_("Virtual memory size: %s\n"),
 950                              pulongest (strtoulst (p, &p, 10)));
 951           if (*p)
 952             printf_filtered (_("Resident set size: %s\n"),
 953                              pulongest (strtoulst (p, &p, 10)));
 954           if (*p)
 955             printf_filtered (_("rlim: %s\n"),
 956                              pulongest (strtoulst (p, &p, 10)));
 957           if (*p)
 958             printf_filtered (_("Start of text: %s\n"),
 959                              hex_string (strtoulst (p, &p, 10)));
 960           if (*p)
 961             printf_filtered (_("End of text: %s\n"),
 962                              hex_string (strtoulst (p, &p, 10)));
 963           if (*p)
 964             printf_filtered (_("Start of stack: %s\n"),
 965                              hex_string (strtoulst (p, &p, 10)));
 966 #if 0   /* Don't know how architecture-dependent the rest is...
 967            Anyway the signal bitmap info is available from "status".  */
 968           if (*p)
 969             printf_filtered (_("Kernel stack pointer: %s\n"),
 970                              hex_string (strtoulst (p, &p, 10)));
 971           if (*p)
 972             printf_filtered (_("Kernel instr pointer: %s\n"),
 973                              hex_string (strtoulst (p, &p, 10)));
 974           if (*p)
 975             printf_filtered (_("Pending signals bitmap: %s\n"),
 976                              hex_string (strtoulst (p, &p, 10)));
 977           if (*p)
 978             printf_filtered (_("Blocked signals bitmap: %s\n"),
 979                              hex_string (strtoulst (p, &p, 10)));
 980           if (*p)
 981             printf_filtered (_("Ignored signals bitmap: %s\n"),
 982                              hex_string (strtoulst (p, &p, 10)));
 983           if (*p)
 984             printf_filtered (_("Catched signals bitmap: %s\n"),
 985                              hex_string (strtoulst (p, &p, 10)));
 986           if (*p)
 987             printf_filtered (_("wchan (system call): %s\n"),
 988                              hex_string (strtoulst (p, &p, 10)));
 989 #endif
 990           do_cleanups (cleanup);
 991         }
 992       else
 993         warning (_("unable to open /proc file '%s'"), filename);
 994     }
 995 }
 996
 997 /* Implement "info proc mappings" for a corefile.  */
 998
 999 static void
1000 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1001 {
1002   asection *section;
1003   ULONGEST count, page_size;
1004   unsigned char *descdata, *filenames, *descend, *contents;
1005   size_t note_size;
1006   unsigned int addr_size_bits, addr_size;
1007   struct cleanup *cleanup;
1008   struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
1009   /* We assume this for reading 64-bit core files.  */
1010   gdb_static_assert (sizeof (ULONGEST) >= 8);
1011
1012   section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
1013   if (section == NULL)
1014     {
1015       warning (_("unable to find mappings in core file"));
1016       return;
1017     }
1018
1019   addr_size_bits = gdbarch_addr_bit (core_gdbarch);
1020   addr_size = addr_size_bits / 8;
1021   note_size = bfd_get_section_size (section);
1022
1023   if (note_size < 2 * addr_size)
1024     error (_("malformed core note - too short for header"));
1025
1026   contents = (unsigned char *) xmalloc (note_size);
1027   cleanup = make_cleanup (xfree, contents);
1028   if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
1029     error (_("could not get core note contents"));
1030
1031   descdata = contents;
1032   descend = descdata + note_size;
1033
1034   if (descdata[note_size - 1] != '\0')
1035     error (_("malformed note - does not end with \\0"));
1036
1037   count = bfd_get (addr_size_bits, core_bfd, descdata);
1038   descdata += addr_size;
1039
1040   page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1041   descdata += addr_size;
1042
1043   if (note_size < 2 * addr_size + count * 3 * addr_size)
1044     error (_("malformed note - too short for supplied file count"));
1045
1046   printf_filtered (_("Mapped address spaces:\n\n"));
1047   if (gdbarch_addr_bit (gdbarch) == 32)
1048     {
1049       printf_filtered ("\t%10s %10s %10s %10s %s\n",
1050                        "Start Addr",
1051                        "  End Addr",
1052                        "      Size", "    Offset", "objfile");
1053     }
1054   else
1055     {
1056       printf_filtered ("  %18s %18s %10s %10s %s\n",
1057                        "Start Addr",
1058                        "  End Addr",
1059                        "      Size", "    Offset", "objfile");
1060     }
1061
1062   filenames = descdata + count * 3 * addr_size;
1063   while (--count > 0)
1064     {
1065       ULONGEST start, end, file_ofs;
1066
1067       if (filenames == descend)
1068         error (_("malformed note - filenames end too early"));
1069
1070       start = bfd_get (addr_size_bits, core_bfd, descdata);
1071       descdata += addr_size;
1072       end = bfd_get (addr_size_bits, core_bfd, descdata);
1073       descdata += addr_size;
1074       file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1075       descdata += addr_size;
1076
1077       file_ofs *= page_size;
1078
1079       if (gdbarch_addr_bit (gdbarch) == 32)
1080         printf_filtered ("\t%10s %10s %10s %10s %s\n",
1081                          paddress (gdbarch, start),
1082                          paddress (gdbarch, end),
1083                          hex_string (end - start),
1084                          hex_string (file_ofs),
1085                          filenames);
1086       else
1087         printf_filtered ("  %18s %18s %10s %10s %s\n",
1088                          paddress (gdbarch, start),
1089                          paddress (gdbarch, end),
1090                          hex_string (end - start),
1091                          hex_string (file_ofs),
1092                          filenames);
1093
1094       filenames += 1 + strlen ((char *) filenames);
1095     }
1096
1097   do_cleanups (cleanup);
1098 }
1099
1100 /* Implement "info proc" for a corefile.  */
1101
1102 static void
1103 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1104                       enum info_proc_what what)
1105 {
1106   int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1107   int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1108
1109   if (exe_f)
1110     {
1111       const char *exe;
1112
1113       exe = bfd_core_file_failing_command (core_bfd);
1114       if (exe != NULL)
1115         printf_filtered ("exe = '%s'\n", exe);
1116       else
1117         warning (_("unable to find command name in core file"));
1118     }
1119
1120   if (mappings_f)
1121     linux_core_info_proc_mappings (gdbarch, args);
1122
1123   if (!exe_f && !mappings_f)
1124     error (_("unable to handle request"));
1125 }
1126
1127 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1128                                             ULONGEST offset, ULONGEST inode,
1129                                             int read, int write,
1130                                             int exec, int modified,
1131                                             const char *filename,
1132                                             void *data);
1133
1134 /* List memory regions in the inferior for a corefile.  */
1135
1136 static int
1137 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1138                                 linux_find_memory_region_ftype *func,
1139                                 void *obfd)
1140 {
1141   char mapsfilename[100];
1142   char coredumpfilter_name[100];
1143   char *data, *coredumpfilterdata;
1144   pid_t pid;
1145   /* Default dump behavior of coredump_filter (0x33), according to
1146      Documentation/filesystems/proc.txt from the Linux kernel
1147      tree.  */
1148   filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1149                               | COREFILTER_ANON_SHARED
1150                               | COREFILTER_ELF_HEADERS
1151                               | COREFILTER_HUGETLB_PRIVATE);
1152
1153   /* We need to know the real target PID to access /proc.  */
1154   if (current_inferior ()->fake_pid_p)
1155     return 1;
1156
1157   pid = current_inferior ()->pid;
1158
1159   if (use_coredump_filter)
1160     {
1161       xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1162                  "/proc/%d/coredump_filter", pid);
1163       coredumpfilterdata = target_fileio_read_stralloc (NULL,
1164                                                         coredumpfilter_name);
1165       if (coredumpfilterdata != NULL)
1166         {
1167           unsigned int flags;
1168
1169           sscanf (coredumpfilterdata, "%x", &flags);
1170           filterflags = (enum filter_flag) flags;
1171           xfree (coredumpfilterdata);
1172         }
1173     }
1174
1175   xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1176   data = target_fileio_read_stralloc (NULL, mapsfilename);
1177   if (data == NULL)
1178     {
1179       /* Older Linux kernels did not support /proc/PID/smaps.  */
1180       xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1181       data = target_fileio_read_stralloc (NULL, mapsfilename);
1182     }
1183
1184   if (data != NULL)
1185     {
1186       struct cleanup *cleanup = make_cleanup (xfree, data);
1187       char *line, *t;
1188
1189       line = strtok_r (data, "\n", &t);
1190       while (line != NULL)
1191         {
1192           ULONGEST addr, endaddr, offset, inode;
1193           const char *permissions, *device, *filename;
1194           struct smaps_vmflags v;
1195           size_t permissions_len, device_len;
1196           int read, write, exec, priv;
1197           int has_anonymous = 0;
1198           int should_dump_p = 0;
1199           int mapping_anon_p;
1200           int mapping_file_p;
1201
1202           memset (&v, 0, sizeof (v));
1203           read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1204                         &offset, &device, &device_len, &inode, &filename);
1205           mapping_anon_p = mapping_is_anonymous_p (filename);
1206           /* If the mapping is not anonymous, then we can consider it
1207              to be file-backed.  These two states (anonymous or
1208              file-backed) seem to be exclusive, but they can actually
1209              coexist.  For example, if a file-backed mapping has
1210              "Anonymous:" pages (see more below), then the Linux
1211              kernel will dump this mapping when the user specified
1212              that she only wants anonymous mappings in the corefile
1213              (*even* when she explicitly disabled the dumping of
1214              file-backed mappings).  */
1215           mapping_file_p = !mapping_anon_p;
1216
1217           /* Decode permissions.  */
1218           read = (memchr (permissions, 'r', permissions_len) != 0);
1219           write = (memchr (permissions, 'w', permissions_len) != 0);
1220           exec = (memchr (permissions, 'x', permissions_len) != 0);
1221           /* 'private' here actually means VM_MAYSHARE, and not
1222              VM_SHARED.  In order to know if a mapping is really
1223              private or not, we must check the flag "sh" in the
1224              VmFlags field.  This is done by decode_vmflags.  However,
1225              if we are using a Linux kernel released before the commit
1226              834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1227              not have the VmFlags there.  In this case, there is
1228              really no way to know if we are dealing with VM_SHARED,
1229              so we just assume that VM_MAYSHARE is enough.  */
1230           priv = memchr (permissions, 'p', permissions_len) != 0;
1231
1232           /* Try to detect if region should be dumped by parsing smaps
1233              counters.  */
1234           for (line = strtok_r (NULL, "\n", &t);
1235                line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1236                line = strtok_r (NULL, "\n", &t))
1237             {
1238               char keyword[64 + 1];
1239
1240               if (sscanf (line, "%64s", keyword) != 1)
1241                 {
1242                   warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1243                   break;
1244                 }
1245
1246               if (strcmp (keyword, "Anonymous:") == 0)
1247                 {
1248                   /* Older Linux kernels did not support the
1249                      "Anonymous:" counter.  Check it here.  */
1250                   has_anonymous = 1;
1251                 }
1252               else if (strcmp (keyword, "VmFlags:") == 0)
1253                 decode_vmflags (line, &v);
1254
1255               if (strcmp (keyword, "AnonHugePages:") == 0
1256                   || strcmp (keyword, "Anonymous:") == 0)
1257                 {
1258                   unsigned long number;
1259
1260                   if (sscanf (line, "%*s%lu", &number) != 1)
1261                     {
1262                       warning (_("Error parsing {s,}maps file '%s' number"),
1263                                mapsfilename);
1264                       break;
1265                     }
1266                   if (number > 0)
1267                     {
1268                       /* Even if we are dealing with a file-backed
1269                          mapping, if it contains anonymous pages we
1270                          consider it to be *also* an anonymous
1271                          mapping, because this is what the Linux
1272                          kernel does:
1273
1274                          // Dump segments that have been written to.
1275                          if (vma->anon_vma && FILTER(ANON_PRIVATE))
1276                                 goto whole;
1277
1278                          Note that if the mapping is already marked as
1279                          file-backed (i.e., mapping_file_p is
1280                          non-zero), then this is a special case, and
1281                          this mapping will be dumped either when the
1282                          user wants to dump file-backed *or* anonymous
1283                          mappings.  */
1284                       mapping_anon_p = 1;
1285                     }
1286                 }
1287             }
1288
1289           if (has_anonymous)
1290             should_dump_p = dump_mapping_p (filterflags, &v, priv,
1291                                             mapping_anon_p, mapping_file_p,
1292                                             filename);
1293           else
1294             {
1295               /* Older Linux kernels did not support the "Anonymous:" counter.
1296                  If it is missing, we can't be sure - dump all the pages.  */
1297               should_dump_p = 1;
1298             }
1299
1300           /* Invoke the callback function to create the corefile segment.  */
1301           if (should_dump_p)
1302             func (addr, endaddr - addr, offset, inode,
1303                   read, write, exec, 1, /* MODIFIED is true because we
1304                                            want to dump the mapping.  */
1305                   filename, obfd);
1306         }
1307
1308       do_cleanups (cleanup);
1309       return 0;
1310     }
1311
1312   return 1;
1313 }
1314
1315 /* A structure for passing information through
1316    linux_find_memory_regions_full.  */
1317
1318 struct linux_find_memory_regions_data
1319 {
1320   /* The original callback.  */
1321
1322   find_memory_region_ftype func;
1323
1324   /* The original datum.  */
1325
1326   void *obfd;
1327 };
1328
1329 /* A callback for linux_find_memory_regions that converts between the
1330    "full"-style callback and find_memory_region_ftype.  */
1331
1332 static int
1333 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1334                                  ULONGEST offset, ULONGEST inode,
1335                                  int read, int write, int exec, int modified,
1336                                  const char *filename, void *arg)
1337 {
1338   struct linux_find_memory_regions_data *data
1339     = (struct linux_find_memory_regions_data *) arg;
1340
1341   return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1342 }
1343
1344 /* A variant of linux_find_memory_regions_full that is suitable as the
1345    gdbarch find_memory_regions method.  */
1346
1347 static int
1348 linux_find_memory_regions (struct gdbarch *gdbarch,
1349                            find_memory_region_ftype func, void *obfd)
1350 {
1351   struct linux_find_memory_regions_data data;
1352
1353   data.func = func;
1354   data.obfd = obfd;
1355
1356   return linux_find_memory_regions_full (gdbarch,
1357                                          linux_find_memory_regions_thunk,
1358                                          &data);
1359 }
1360
1361 /* Determine which signal stopped execution.  */
1362
1363 static int
1364 find_signalled_thread (struct thread_info *info, void *data)
1365 {
1366   if (info->suspend.stop_signal != GDB_SIGNAL_0
1367       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1368     return 1;
1369
1370   return 0;
1371 }
1372
1373 /* Generate corefile notes for SPU contexts.  */
1374
1375 static char *
1376 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1377 {
1378   static const char *spu_files[] =
1379     {
1380       "object-id",
1381       "mem",
1382       "regs",
1383       "fpcr",
1384       "lslr",
1385       "decr",
1386       "decr_status",
1387       "signal1",
1388       "signal1_type",
1389       "signal2",
1390       "signal2_type",
1391       "event_mask",
1392       "event_status",
1393       "mbox_info",
1394       "ibox_info",
1395       "wbox_info",
1396       "dma_info",
1397       "proxydma_info",
1398    };
1399
1400   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1401   gdb_byte *spu_ids;
1402   LONGEST i, j, size;
1403
1404   /* Determine list of SPU ids.  */
1405   size = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
1406                             NULL, &spu_ids);
1407
1408   /* Generate corefile notes for each SPU file.  */
1409   for (i = 0; i < size; i += 4)
1410     {
1411       int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1412
1413       for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1414         {
1415           char annex[32], note_name[32];
1416           gdb_byte *spu_data;
1417           LONGEST spu_len;
1418
1419           xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1420           spu_len = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
1421                                        annex, &spu_data);
1422           if (spu_len > 0)
1423             {
1424               xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1425               note_data = elfcore_write_note (obfd, note_data, note_size,
1426                                               note_name, NT_SPU,
1427                                               spu_data, spu_len);
1428               xfree (spu_data);
1429
1430               if (!note_data)
1431                 {
1432                   xfree (spu_ids);
1433                   return NULL;
1434                 }
1435             }
1436         }
1437     }
1438
1439   if (size > 0)
1440     xfree (spu_ids);
1441
1442   return note_data;
1443 }
1444
1445 /* This is used to pass information from
1446    linux_make_mappings_corefile_notes through
1447    linux_find_memory_regions_full.  */
1448
1449 struct linux_make_mappings_data
1450 {
1451   /* Number of files mapped.  */
1452   ULONGEST file_count;
1453
1454   /* The obstack for the main part of the data.  */
1455   struct obstack *data_obstack;
1456
1457   /* The filename obstack.  */
1458   struct obstack *filename_obstack;
1459
1460   /* The architecture's "long" type.  */
1461   struct type *long_type;
1462 };
1463
1464 static linux_find_memory_region_ftype linux_make_mappings_callback;
1465
1466 /* A callback for linux_find_memory_regions_full that updates the
1467    mappings data for linux_make_mappings_corefile_notes.  */
1468
1469 static int
1470 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1471                               ULONGEST offset, ULONGEST inode,
1472                               int read, int write, int exec, int modified,
1473                               const char *filename, void *data)
1474 {
1475   struct linux_make_mappings_data *map_data
1476     = (struct linux_make_mappings_data *) data;
1477   gdb_byte buf[sizeof (ULONGEST)];
1478
1479   if (*filename == '\0' || inode == 0)
1480     return 0;
1481
1482   ++map_data->file_count;
1483
1484   pack_long (buf, map_data->long_type, vaddr);
1485   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1486   pack_long (buf, map_data->long_type, vaddr + size);
1487   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1488   pack_long (buf, map_data->long_type, offset);
1489   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1490
1491   obstack_grow_str0 (map_data->filename_obstack, filename);
1492
1493   return 0;
1494 }
1495
1496 /* Write the file mapping data to the core file, if possible.  OBFD is
1497    the output BFD.  NOTE_DATA is the current note data, and NOTE_SIZE
1498    is a pointer to the note size.  Returns the new NOTE_DATA and
1499    updates NOTE_SIZE.  */
1500
1501 static char *
1502 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1503                                     char *note_data, int *note_size)
1504 {
1505   struct cleanup *cleanup;
1506   struct obstack data_obstack, filename_obstack;
1507   struct linux_make_mappings_data mapping_data;
1508   struct type *long_type
1509     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1510   gdb_byte buf[sizeof (ULONGEST)];
1511
1512   obstack_init (&data_obstack);
1513   cleanup = make_cleanup_obstack_free (&data_obstack);
1514   obstack_init (&filename_obstack);
1515   make_cleanup_obstack_free (&filename_obstack);
1516
1517   mapping_data.file_count = 0;
1518   mapping_data.data_obstack = &data_obstack;
1519   mapping_data.filename_obstack = &filename_obstack;
1520   mapping_data.long_type = long_type;
1521
1522   /* Reserve space for the count.  */
1523   obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1524   /* We always write the page size as 1 since we have no good way to
1525      determine the correct value.  */
1526   pack_long (buf, long_type, 1);
1527   obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1528
1529   linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1530                                   &mapping_data);
1531
1532   if (mapping_data.file_count != 0)
1533     {
1534       /* Write the count to the obstack.  */
1535       pack_long ((gdb_byte *) obstack_base (&data_obstack),
1536                  long_type, mapping_data.file_count);
1537
1538       /* Copy the filenames to the data obstack.  */
1539       obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1540                     obstack_object_size (&filename_obstack));
1541
1542       note_data = elfcore_write_note (obfd, note_data, note_size,
1543                                       "CORE", NT_FILE,
1544                                       obstack_base (&data_obstack),
1545                                       obstack_object_size (&data_obstack));
1546     }
1547
1548   do_cleanups (cleanup);
1549   return note_data;
1550 }
1551
1552 /* Structure for passing information from
1553    linux_collect_thread_registers via an iterator to
1554    linux_collect_regset_section_cb. */
1555
1556 struct linux_collect_regset_section_cb_data
1557 {
1558   struct gdbarch *gdbarch;
1559   const struct regcache *regcache;
1560   bfd *obfd;
1561   char *note_data;
1562   int *note_size;
1563   unsigned long lwp;
1564   enum gdb_signal stop_signal;
1565   int abort_iteration;
1566 };
1567
1568 /* Callback for iterate_over_regset_sections that records a single
1569    regset in the corefile note section.  */
1570
1571 static void
1572 linux_collect_regset_section_cb (const char *sect_name, int size,
1573                                  const struct regset *regset,
1574                                  const char *human_name, void *cb_data)
1575 {
1576   char *buf;
1577   struct linux_collect_regset_section_cb_data *data
1578     = (struct linux_collect_regset_section_cb_data *) cb_data;
1579
1580   if (data->abort_iteration)
1581     return;
1582
1583   gdb_assert (regset && regset->collect_regset);
1584
1585   buf = (char *) xmalloc (size);
1586   regset->collect_regset (regset, data->regcache, -1, buf, size);
1587
1588   /* PRSTATUS still needs to be treated specially.  */
1589   if (strcmp (sect_name, ".reg") == 0)
1590     data->note_data = (char *) elfcore_write_prstatus
1591       (data->obfd, data->note_data, data->note_size, data->lwp,
1592        gdb_signal_to_host (data->stop_signal), buf);
1593   else
1594     data->note_data = (char *) elfcore_write_register_note
1595       (data->obfd, data->note_data, data->note_size,
1596        sect_name, buf, size);
1597   xfree (buf);
1598
1599   if (data->note_data == NULL)
1600     data->abort_iteration = 1;
1601 }
1602
1603 /* Records the thread's register state for the corefile note
1604    section.  */
1605
1606 static char *
1607 linux_collect_thread_registers (const struct regcache *regcache,
1608                                 ptid_t ptid, bfd *obfd,
1609                                 char *note_data, int *note_size,
1610                                 enum gdb_signal stop_signal)
1611 {
1612   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1613   struct linux_collect_regset_section_cb_data data;
1614
1615   data.gdbarch = gdbarch;
1616   data.regcache = regcache;
1617   data.obfd = obfd;
1618   data.note_data = note_data;
1619   data.note_size = note_size;
1620   data.stop_signal = stop_signal;
1621   data.abort_iteration = 0;
1622
1623   /* For remote targets the LWP may not be available, so use the TID.  */
1624   data.lwp = ptid_get_lwp (ptid);
1625   if (!data.lwp)
1626     data.lwp = ptid_get_tid (ptid);
1627
1628   gdbarch_iterate_over_regset_sections (gdbarch,
1629                                         linux_collect_regset_section_cb,
1630                                         &data, regcache);
1631   return data.note_data;
1632 }
1633
1634 /* Fetch the siginfo data for the current thread, if it exists.  If
1635    there is no data, or we could not read it, return NULL.  Otherwise,
1636    return a newly malloc'd buffer holding the data and fill in *SIZE
1637    with the size of the data.  The caller is responsible for freeing
1638    the data.  */
1639
1640 static gdb_byte *
1641 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1642 {
1643   struct type *siginfo_type;
1644   gdb_byte *buf;
1645   LONGEST bytes_read;
1646   struct cleanup *cleanups;
1647
1648   if (!gdbarch_get_siginfo_type_p (gdbarch))
1649     return NULL;
1650
1651   siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1652
1653   buf = (gdb_byte *) xmalloc (TYPE_LENGTH (siginfo_type));
1654   cleanups = make_cleanup (xfree, buf);
1655
1656   bytes_read = target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1657                             buf, 0, TYPE_LENGTH (siginfo_type));
1658   if (bytes_read == TYPE_LENGTH (siginfo_type))
1659     {
1660       discard_cleanups (cleanups);
1661       *size = bytes_read;
1662     }
1663   else
1664     {
1665       do_cleanups (cleanups);
1666       buf = NULL;
1667     }
1668
1669   return buf;
1670 }
1671
1672 struct linux_corefile_thread_data
1673 {
1674   struct gdbarch *gdbarch;
1675   bfd *obfd;
1676   char *note_data;
1677   int *note_size;
1678   enum gdb_signal stop_signal;
1679 };
1680
1681 /* Records the thread's register state for the corefile note
1682    section.  */
1683
1684 static void
1685 linux_corefile_thread (struct thread_info *info,
1686                        struct linux_corefile_thread_data *args)
1687 {
1688   struct cleanup *old_chain;
1689   struct regcache *regcache;
1690   gdb_byte *siginfo_data;
1691   LONGEST siginfo_size = 0;
1692
1693   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1694
1695   old_chain = save_inferior_ptid ();
1696   inferior_ptid = info->ptid;
1697   target_fetch_registers (regcache, -1);
1698   siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1699   do_cleanups (old_chain);
1700
1701   old_chain = make_cleanup (xfree, siginfo_data);
1702
1703   args->note_data = linux_collect_thread_registers
1704     (regcache, info->ptid, args->obfd, args->note_data,
1705      args->note_size, args->stop_signal);
1706
1707   /* Don't return anything if we got no register information above,
1708      such a core file is useless.  */
1709   if (args->note_data != NULL)
1710     if (siginfo_data != NULL)
1711       args->note_data = elfcore_write_note (args->obfd,
1712                                             args->note_data,
1713                                             args->note_size,
1714                                             "CORE", NT_SIGINFO,
1715                                             siginfo_data, siginfo_size);
1716
1717   do_cleanups (old_chain);
1718 }
1719
1720 /* Fill the PRPSINFO structure with information about the process being
1721    debugged.  Returns 1 in case of success, 0 for failures.  Please note that
1722    even if the structure cannot be entirely filled (e.g., GDB was unable to
1723    gather information about the process UID/GID), this function will still
1724    return 1 since some information was already recorded.  It will only return
1725    0 iff nothing can be gathered.  */
1726
1727 static int
1728 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1729 {
1730   /* The filename which we will use to obtain some info about the process.
1731      We will basically use this to store the `/proc/PID/FILENAME' file.  */
1732   char filename[100];
1733   /* The full name of the program which generated the corefile.  */
1734   char *fname;
1735   /* The basename of the executable.  */
1736   const char *basename;
1737   /* The arguments of the program.  */
1738   char *psargs;
1739   char *infargs;
1740   /* The contents of `/proc/PID/stat' and `/proc/PID/status' files.  */
1741   char *proc_stat, *proc_status;
1742   /* Temporary buffer.  */
1743   char *tmpstr;
1744   /* The valid states of a process, according to the Linux kernel.  */
1745   const char valid_states[] = "RSDTZW";
1746   /* The program state.  */
1747   const char *prog_state;
1748   /* The state of the process.  */
1749   char pr_sname;
1750   /* The PID of the program which generated the corefile.  */
1751   pid_t pid;
1752   /* Process flags.  */
1753   unsigned int pr_flag;
1754   /* Process nice value.  */
1755   long pr_nice;
1756   /* The number of fields read by `sscanf'.  */
1757   int n_fields = 0;
1758   /* Cleanups.  */
1759   struct cleanup *c;
1760
1761   gdb_assert (p != NULL);
1762
1763   /* Obtaining PID and filename.  */
1764   pid = ptid_get_pid (inferior_ptid);
1765   xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1766   fname = target_fileio_read_stralloc (NULL, filename);
1767
1768   if (fname == NULL || *fname == '\0')
1769     {
1770       /* No program name was read, so we won't be able to retrieve more
1771          information about the process.  */
1772       xfree (fname);
1773       return 0;
1774     }
1775
1776   c = make_cleanup (xfree, fname);
1777   memset (p, 0, sizeof (*p));
1778
1779   /* Defining the PID.  */
1780   p->pr_pid = pid;
1781
1782   /* Copying the program name.  Only the basename matters.  */
1783   basename = lbasename (fname);
1784   strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1785   p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1786
1787   infargs = get_inferior_args ();
1788
1789   psargs = xstrdup (fname);
1790   if (infargs != NULL)
1791     psargs = reconcat (psargs, psargs, " ", infargs, (char *) NULL);
1792
1793   make_cleanup (xfree, psargs);
1794
1795   strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1796   p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1797
1798   xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1799   proc_stat = target_fileio_read_stralloc (NULL, filename);
1800   make_cleanup (xfree, proc_stat);
1801
1802   if (proc_stat == NULL || *proc_stat == '\0')
1803     {
1804       /* Despite being unable to read more information about the
1805          process, we return 1 here because at least we have its
1806          command line, PID and arguments.  */
1807       do_cleanups (c);
1808       return 1;
1809     }
1810
1811   /* Ok, we have the stats.  It's time to do a little parsing of the
1812      contents of the buffer, so that we end up reading what we want.
1813
1814      The following parsing mechanism is strongly based on the
1815      information generated by the `fs/proc/array.c' file, present in
1816      the Linux kernel tree.  More details about how the information is
1817      displayed can be obtained by seeing the manpage of proc(5),
1818      specifically under the entry of `/proc/[pid]/stat'.  */
1819
1820   /* Getting rid of the PID, since we already have it.  */
1821   while (isdigit (*proc_stat))
1822     ++proc_stat;
1823
1824   proc_stat = skip_spaces (proc_stat);
1825
1826   /* ps command also relies on no trailing fields ever contain ')'.  */
1827   proc_stat = strrchr (proc_stat, ')');
1828   if (proc_stat == NULL)
1829     {
1830       do_cleanups (c);
1831       return 1;
1832     }
1833   proc_stat++;
1834
1835   proc_stat = skip_spaces (proc_stat);
1836
1837   n_fields = sscanf (proc_stat,
1838                      "%c"               /* Process state.  */
1839                      "%d%d%d"           /* Parent PID, group ID, session ID.  */
1840                      "%*d%*d"           /* tty_nr, tpgid (not used).  */
1841                      "%u"               /* Flags.  */
1842                      "%*s%*s%*s%*s"     /* minflt, cminflt, majflt,
1843                                            cmajflt (not used).  */
1844                      "%*s%*s%*s%*s"     /* utime, stime, cutime,
1845                                            cstime (not used).  */
1846                      "%*s"              /* Priority (not used).  */
1847                      "%ld",             /* Nice.  */
1848                      &pr_sname,
1849                      &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1850                      &pr_flag,
1851                      &pr_nice);
1852
1853   if (n_fields != 6)
1854     {
1855       /* Again, we couldn't read the complementary information about
1856          the process state.  However, we already have minimal
1857          information, so we just return 1 here.  */
1858       do_cleanups (c);
1859       return 1;
1860     }
1861
1862   /* Filling the structure fields.  */
1863   prog_state = strchr (valid_states, pr_sname);
1864   if (prog_state != NULL)
1865     p->pr_state = prog_state - valid_states;
1866   else
1867     {
1868       /* Zero means "Running".  */
1869       p->pr_state = 0;
1870     }
1871
1872   p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1873   p->pr_zomb = p->pr_sname == 'Z';
1874   p->pr_nice = pr_nice;
1875   p->pr_flag = pr_flag;
1876
1877   /* Finally, obtaining the UID and GID.  For that, we read and parse the
1878      contents of the `/proc/PID/status' file.  */
1879   xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1880   proc_status = target_fileio_read_stralloc (NULL, filename);
1881   make_cleanup (xfree, proc_status);
1882
1883   if (proc_status == NULL || *proc_status == '\0')
1884     {
1885       /* Returning 1 since we already have a bunch of information.  */
1886       do_cleanups (c);
1887       return 1;
1888     }
1889
1890   /* Extracting the UID.  */
1891   tmpstr = strstr (proc_status, "Uid:");
1892   if (tmpstr != NULL)
1893     {
1894       /* Advancing the pointer to the beginning of the UID.  */
1895       tmpstr += sizeof ("Uid:");
1896       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1897         ++tmpstr;
1898
1899       if (isdigit (*tmpstr))
1900         p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1901     }
1902
1903   /* Extracting the GID.  */
1904   tmpstr = strstr (proc_status, "Gid:");
1905   if (tmpstr != NULL)
1906     {
1907       /* Advancing the pointer to the beginning of the GID.  */
1908       tmpstr += sizeof ("Gid:");
1909       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1910         ++tmpstr;
1911
1912       if (isdigit (*tmpstr))
1913         p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1914     }
1915
1916   do_cleanups (c);
1917
1918   return 1;
1919 }
1920
1921 /* Build the note section for a corefile, and return it in a malloc
1922    buffer.  */
1923
1924 static char *
1925 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1926 {
1927   struct linux_corefile_thread_data thread_args;
1928   struct elf_internal_linux_prpsinfo prpsinfo;
1929   char *note_data = NULL;
1930   gdb_byte *auxv;
1931   int auxv_len;
1932   struct thread_info *curr_thr, *signalled_thr, *thr;
1933
1934   if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1935     return NULL;
1936
1937   if (linux_fill_prpsinfo (&prpsinfo))
1938     {
1939       if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1940         {
1941           note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1942                                                             note_data, note_size,
1943                                                             &prpsinfo);
1944         }
1945       else
1946         {
1947           if (gdbarch_ptr_bit (gdbarch) == 64)
1948             note_data = elfcore_write_linux_prpsinfo64 (obfd,
1949                                                         note_data, note_size,
1950                                                         &prpsinfo);
1951           else
1952             note_data = elfcore_write_linux_prpsinfo32 (obfd,
1953                                                         note_data, note_size,
1954                                                         &prpsinfo);
1955         }
1956     }
1957
1958   /* Thread register information.  */
1959   TRY
1960     {
1961       update_thread_list ();
1962     }
1963   CATCH (e, RETURN_MASK_ERROR)
1964     {
1965       exception_print (gdb_stderr, e);
1966     }
1967   END_CATCH
1968
1969   /* Like the kernel, prefer dumping the signalled thread first.
1970      "First thread" is what tools use to infer the signalled thread.
1971      In case there's more than one signalled thread, prefer the
1972      current thread, if it is signalled.  */
1973   curr_thr = inferior_thread ();
1974   if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
1975     signalled_thr = curr_thr;
1976   else
1977     {
1978       signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
1979       if (signalled_thr == NULL)
1980         signalled_thr = curr_thr;
1981     }
1982
1983   thread_args.gdbarch = gdbarch;
1984   thread_args.obfd = obfd;
1985   thread_args.note_data = note_data;
1986   thread_args.note_size = note_size;
1987   thread_args.stop_signal = signalled_thr->suspend.stop_signal;
1988
1989   linux_corefile_thread (signalled_thr, &thread_args);
1990   ALL_NON_EXITED_THREADS (thr)
1991     {
1992       if (thr == signalled_thr)
1993         continue;
1994       if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
1995         continue;
1996
1997       linux_corefile_thread (thr, &thread_args);
1998     }
1999
2000   note_data = thread_args.note_data;
2001   if (!note_data)
2002     return NULL;
2003
2004   /* Auxillary vector.  */
2005   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
2006                                 NULL, &auxv);
2007   if (auxv_len > 0)
2008     {
2009       note_data = elfcore_write_note (obfd, note_data, note_size,
2010                                       "CORE", NT_AUXV, auxv, auxv_len);
2011       xfree (auxv);
2012
2013       if (!note_data)
2014         return NULL;
2015     }
2016
2017   /* SPU information.  */
2018   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
2019   if (!note_data)
2020     return NULL;
2021
2022   /* File mappings.  */
2023   note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
2024                                                   note_data, note_size);
2025
2026   return note_data;
2027 }
2028
2029 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2030    gdbarch.h.  This function is not static because it is exported to
2031    other -tdep files.  */
2032
2033 enum gdb_signal
2034 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2035 {
2036   switch (signal)
2037     {
2038     case 0:
2039       return GDB_SIGNAL_0;
2040
2041     case LINUX_SIGHUP:
2042       return GDB_SIGNAL_HUP;
2043
2044     case LINUX_SIGINT:
2045       return GDB_SIGNAL_INT;
2046
2047     case LINUX_SIGQUIT:
2048       return GDB_SIGNAL_QUIT;
2049
2050     case LINUX_SIGILL:
2051       return GDB_SIGNAL_ILL;
2052
2053     case LINUX_SIGTRAP:
2054       return GDB_SIGNAL_TRAP;
2055
2056     case LINUX_SIGABRT:
2057       return GDB_SIGNAL_ABRT;
2058
2059     case LINUX_SIGBUS:
2060       return GDB_SIGNAL_BUS;
2061
2062     case LINUX_SIGFPE:
2063       return GDB_SIGNAL_FPE;
2064
2065     case LINUX_SIGKILL:
2066       return GDB_SIGNAL_KILL;
2067
2068     case LINUX_SIGUSR1:
2069       return GDB_SIGNAL_USR1;
2070
2071     case LINUX_SIGSEGV:
2072       return GDB_SIGNAL_SEGV;
2073
2074     case LINUX_SIGUSR2:
2075       return GDB_SIGNAL_USR2;
2076
2077     case LINUX_SIGPIPE:
2078       return GDB_SIGNAL_PIPE;
2079
2080     case LINUX_SIGALRM:
2081       return GDB_SIGNAL_ALRM;
2082
2083     case LINUX_SIGTERM:
2084       return GDB_SIGNAL_TERM;
2085
2086     case LINUX_SIGCHLD:
2087       return GDB_SIGNAL_CHLD;
2088
2089     case LINUX_SIGCONT:
2090       return GDB_SIGNAL_CONT;
2091
2092     case LINUX_SIGSTOP:
2093       return GDB_SIGNAL_STOP;
2094
2095     case LINUX_SIGTSTP:
2096       return GDB_SIGNAL_TSTP;
2097
2098     case LINUX_SIGTTIN:
2099       return GDB_SIGNAL_TTIN;
2100
2101     case LINUX_SIGTTOU:
2102       return GDB_SIGNAL_TTOU;
2103
2104     case LINUX_SIGURG:
2105       return GDB_SIGNAL_URG;
2106
2107     case LINUX_SIGXCPU:
2108       return GDB_SIGNAL_XCPU;
2109
2110     case LINUX_SIGXFSZ:
2111       return GDB_SIGNAL_XFSZ;
2112
2113     case LINUX_SIGVTALRM:
2114       return GDB_SIGNAL_VTALRM;
2115
2116     case LINUX_SIGPROF:
2117       return GDB_SIGNAL_PROF;
2118
2119     case LINUX_SIGWINCH:
2120       return GDB_SIGNAL_WINCH;
2121
2122     /* No way to differentiate between SIGIO and SIGPOLL.
2123        Therefore, we just handle the first one.  */
2124     case LINUX_SIGIO:
2125       return GDB_SIGNAL_IO;
2126
2127     case LINUX_SIGPWR:
2128       return GDB_SIGNAL_PWR;
2129
2130     case LINUX_SIGSYS:
2131       return GDB_SIGNAL_SYS;
2132
2133     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2134        therefore we have to handle them here.  */
2135     case LINUX_SIGRTMIN:
2136       return GDB_SIGNAL_REALTIME_32;
2137
2138     case LINUX_SIGRTMAX:
2139       return GDB_SIGNAL_REALTIME_64;
2140     }
2141
2142   if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2143     {
2144       int offset = signal - LINUX_SIGRTMIN + 1;
2145
2146       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2147     }
2148
2149   return GDB_SIGNAL_UNKNOWN;
2150 }
2151
2152 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2153    gdbarch.h.  This function is not static because it is exported to
2154    other -tdep files.  */
2155
2156 int
2157 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2158                             enum gdb_signal signal)
2159 {
2160   switch (signal)
2161     {
2162     case GDB_SIGNAL_0:
2163       return 0;
2164
2165     case GDB_SIGNAL_HUP:
2166       return LINUX_SIGHUP;
2167
2168     case GDB_SIGNAL_INT:
2169       return LINUX_SIGINT;
2170
2171     case GDB_SIGNAL_QUIT:
2172       return LINUX_SIGQUIT;
2173
2174     case GDB_SIGNAL_ILL:
2175       return LINUX_SIGILL;
2176
2177     case GDB_SIGNAL_TRAP:
2178       return LINUX_SIGTRAP;
2179
2180     case GDB_SIGNAL_ABRT:
2181       return LINUX_SIGABRT;
2182
2183     case GDB_SIGNAL_FPE:
2184       return LINUX_SIGFPE;
2185
2186     case GDB_SIGNAL_KILL:
2187       return LINUX_SIGKILL;
2188
2189     case GDB_SIGNAL_BUS:
2190       return LINUX_SIGBUS;
2191
2192     case GDB_SIGNAL_SEGV:
2193       return LINUX_SIGSEGV;
2194
2195     case GDB_SIGNAL_SYS:
2196       return LINUX_SIGSYS;
2197
2198     case GDB_SIGNAL_PIPE:
2199       return LINUX_SIGPIPE;
2200
2201     case GDB_SIGNAL_ALRM:
2202       return LINUX_SIGALRM;
2203
2204     case GDB_SIGNAL_TERM:
2205       return LINUX_SIGTERM;
2206
2207     case GDB_SIGNAL_URG:
2208       return LINUX_SIGURG;
2209
2210     case GDB_SIGNAL_STOP:
2211       return LINUX_SIGSTOP;
2212
2213     case GDB_SIGNAL_TSTP:
2214       return LINUX_SIGTSTP;
2215
2216     case GDB_SIGNAL_CONT:
2217       return LINUX_SIGCONT;
2218
2219     case GDB_SIGNAL_CHLD:
2220       return LINUX_SIGCHLD;
2221
2222     case GDB_SIGNAL_TTIN:
2223       return LINUX_SIGTTIN;
2224
2225     case GDB_SIGNAL_TTOU:
2226       return LINUX_SIGTTOU;
2227
2228     case GDB_SIGNAL_IO:
2229       return LINUX_SIGIO;
2230
2231     case GDB_SIGNAL_XCPU:
2232       return LINUX_SIGXCPU;
2233
2234     case GDB_SIGNAL_XFSZ:
2235       return LINUX_SIGXFSZ;
2236
2237     case GDB_SIGNAL_VTALRM:
2238       return LINUX_SIGVTALRM;
2239
2240     case GDB_SIGNAL_PROF:
2241       return LINUX_SIGPROF;
2242
2243     case GDB_SIGNAL_WINCH:
2244       return LINUX_SIGWINCH;
2245
2246     case GDB_SIGNAL_USR1:
2247       return LINUX_SIGUSR1;
2248
2249     case GDB_SIGNAL_USR2:
2250       return LINUX_SIGUSR2;
2251
2252     case GDB_SIGNAL_PWR:
2253       return LINUX_SIGPWR;
2254
2255     case GDB_SIGNAL_POLL:
2256       return LINUX_SIGPOLL;
2257
2258     /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2259        therefore we have to handle it here.  */
2260     case GDB_SIGNAL_REALTIME_32:
2261       return LINUX_SIGRTMIN;
2262
2263     /* Same comment applies to _64.  */
2264     case GDB_SIGNAL_REALTIME_64:
2265       return LINUX_SIGRTMAX;
2266     }
2267
2268   /* GDB_SIGNAL_REALTIME_33 to _64 are continuous.  */
2269   if (signal >= GDB_SIGNAL_REALTIME_33
2270       && signal <= GDB_SIGNAL_REALTIME_63)
2271     {
2272       int offset = signal - GDB_SIGNAL_REALTIME_33;
2273
2274       return LINUX_SIGRTMIN + 1 + offset;
2275     }
2276
2277   return -1;
2278 }
2279
2280 /* Helper for linux_vsyscall_range that does the real work of finding
2281    the vsyscall's address range.  */
2282
2283 static int
2284 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2285 {
2286   char filename[100];
2287   long pid;
2288   char *data;
2289
2290   /* Can't access /proc if debugging a core file.  */
2291   if (!target_has_execution)
2292     return 0;
2293
2294   /* We need to know the real target PID to access /proc.  */
2295   if (current_inferior ()->fake_pid_p)
2296     return 0;
2297
2298   if (target_auxv_search (&current_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2299     return 0;
2300
2301   pid = current_inferior ()->pid;
2302
2303   /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2304      reading /proc/PID/maps (2).  The later identifies thread stacks
2305      in the output, which requires scanning every thread in the thread
2306      group to check whether a VMA is actually a thread's stack.  With
2307      Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2308      a few thousand threads, (1) takes a few miliseconds, while (2)
2309      takes several seconds.  Also note that "smaps", what we read for
2310      determining core dump mappings, is even slower than "maps".  */
2311   xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2312   data = target_fileio_read_stralloc (NULL, filename);
2313   if (data != NULL)
2314     {
2315       struct cleanup *cleanup = make_cleanup (xfree, data);
2316       char *line;
2317       char *saveptr = NULL;
2318
2319       for (line = strtok_r (data, "\n", &saveptr);
2320            line != NULL;
2321            line = strtok_r (NULL, "\n", &saveptr))
2322         {
2323           ULONGEST addr, endaddr;
2324           const char *p = line;
2325
2326           addr = strtoulst (p, &p, 16);
2327           if (addr == range->start)
2328             {
2329               if (*p == '-')
2330                 p++;
2331               endaddr = strtoulst (p, &p, 16);
2332               range->length = endaddr - addr;
2333               do_cleanups (cleanup);
2334               return 1;
2335             }
2336         }
2337
2338       do_cleanups (cleanup);
2339     }
2340   else
2341     warning (_("unable to open /proc file '%s'"), filename);
2342
2343   return 0;
2344 }
2345
2346 /* Implementation of the "vsyscall_range" gdbarch hook.  Handles
2347    caching, and defers the real work to linux_vsyscall_range_raw.  */
2348
2349 static int
2350 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2351 {
2352   struct linux_info *info = get_linux_inferior_data ();
2353
2354   if (info->vsyscall_range_p == 0)
2355     {
2356       if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2357         info->vsyscall_range_p = 1;
2358       else
2359         info->vsyscall_range_p = -1;
2360     }
2361
2362   if (info->vsyscall_range_p < 0)
2363     return 0;
2364
2365   *range = info->vsyscall_range;
2366   return 1;
2367 }
2368
2369 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2370    definitions would be dependent on compilation host.  */
2371 #define GDB_MMAP_MAP_PRIVATE    0x02            /* Changes are private.  */
2372 #define GDB_MMAP_MAP_ANONYMOUS  0x20            /* Don't use a file.  */
2373
2374 /* See gdbarch.sh 'infcall_mmap'.  */
2375
2376 static CORE_ADDR
2377 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2378 {
2379   struct objfile *objf;
2380   /* Do there still exist any Linux systems without "mmap64"?
2381      "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32.  */
2382   struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2383   struct value *addr_val;
2384   struct gdbarch *gdbarch = get_objfile_arch (objf);
2385   CORE_ADDR retval;
2386   enum
2387     {
2388       ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2389     };
2390   struct value *arg[ARG_LAST];
2391
2392   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2393                                       0);
2394   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2395   arg[ARG_LENGTH] = value_from_ulongest
2396                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2397   gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2398                         | GDB_MMAP_PROT_EXEC))
2399               == 0);
2400   arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2401   arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2402                                        GDB_MMAP_MAP_PRIVATE
2403                                        | GDB_MMAP_MAP_ANONYMOUS);
2404   arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2405   arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2406                                         0);
2407   addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
2408   retval = value_as_address (addr_val);
2409   if (retval == (CORE_ADDR) -1)
2410     error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2411            pulongest (size));
2412   return retval;
2413 }
2414
2415 /* See gdbarch.sh 'infcall_munmap'.  */
2416
2417 static void
2418 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2419 {
2420   struct objfile *objf;
2421   struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2422   struct value *retval_val;
2423   struct gdbarch *gdbarch = get_objfile_arch (objf);
2424   LONGEST retval;
2425   enum
2426     {
2427       ARG_ADDR, ARG_LENGTH, ARG_LAST
2428     };
2429   struct value *arg[ARG_LAST];
2430
2431   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2432                                       addr);
2433   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2434   arg[ARG_LENGTH] = value_from_ulongest
2435                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2436   retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
2437   retval = value_as_long (retval_val);
2438   if (retval != 0)
2439     warning (_("Failed inferior munmap call at %s for %s bytes, "
2440                "errno is changed."),
2441              hex_string (addr), pulongest (size));
2442 }
2443
2444 /* See linux-tdep.h.  */
2445
2446 CORE_ADDR
2447 linux_displaced_step_location (struct gdbarch *gdbarch)
2448 {
2449   CORE_ADDR addr;
2450   int bp_len;
2451
2452   /* Determine entry point from target auxiliary vector.  This avoids
2453      the need for symbols.  Also, when debugging a stand-alone SPU
2454      executable, entry_point_address () will point to an SPU
2455      local-store address and is thus not usable as displaced stepping
2456      location.  The auxiliary vector gets us the PowerPC-side entry
2457      point address instead.  */
2458   if (target_auxv_search (&current_target, AT_ENTRY, &addr) <= 0)
2459     throw_error (NOT_SUPPORTED_ERROR,
2460                  _("Cannot find AT_ENTRY auxiliary vector entry."));
2461
2462   /* Make certain that the address points at real code, and not a
2463      function descriptor.  */
2464   addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2465                                              &current_target);
2466
2467   /* Inferior calls also use the entry point as a breakpoint location.
2468      We don't want displaced stepping to interfere with those
2469      breakpoints, so leave space.  */
2470   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2471   addr += bp_len * 2;
2472
2473   return addr;
2474 }
2475
2476 /* Display whether the gcore command is using the
2477    /proc/PID/coredump_filter file.  */
2478
2479 static void
2480 show_use_coredump_filter (struct ui_file *file, int from_tty,
2481                           struct cmd_list_element *c, const char *value)
2482 {
2483   fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2484                             " corefiles is %s.\n"), value);
2485 }
2486
2487 /* To be called from the various GDB_OSABI_LINUX handlers for the
2488    various GNU/Linux architectures and machine types.  */
2489
2490 void
2491 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2492 {
2493   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2494   set_gdbarch_info_proc (gdbarch, linux_info_proc);
2495   set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2496   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2497   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2498   set_gdbarch_has_shared_address_space (gdbarch,
2499                                         linux_has_shared_address_space);
2500   set_gdbarch_gdb_signal_from_target (gdbarch,
2501                                       linux_gdb_signal_from_target);
2502   set_gdbarch_gdb_signal_to_target (gdbarch,
2503                                     linux_gdb_signal_to_target);
2504   set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2505   set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2506   set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2507   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2508 }
2509
2510 /* Provide a prototype to silence -Wmissing-prototypes.  */
2511 extern initialize_file_ftype _initialize_linux_tdep;
2512
2513 void
2514 _initialize_linux_tdep (void)
2515 {
2516   linux_gdbarch_data_handle =
2517     gdbarch_data_register_post_init (init_linux_gdbarch_data);
2518
2519   /* Set a cache per-inferior.  */
2520   linux_inferior_data
2521     = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2522   /* Observers used to invalidate the cache when needed.  */
2523   observer_attach_inferior_exit (invalidate_linux_cache_inf);
2524   observer_attach_inferior_appeared (invalidate_linux_cache_inf);
2525
2526   add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2527                            &use_coredump_filter, _("\
2528 Set whether gcore should consider /proc/PID/coredump_filter."),
2529                            _("\
2530 Show whether gcore should consider /proc/PID/coredump_filter."),
2531                            _("\
2532 Use this command to set whether gcore should consider the contents\n\
2533 of /proc/PID/coredump_filter when generating the corefile.  For more information\n\
2534 about this file, refer to the manpage of core(5)."),
2535                            NULL, show_use_coredump_filter,
2536                            &setlist, &showlist);
2537 }