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