gdb/linux-tdep.c

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