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