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 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 static 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 (enum filterflags 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 (NULL, 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 (NULL, 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 (NULL, 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 (NULL, 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 (NULL, 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 (NULL, 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 = (unsigned char *) 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   enum filterflags 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 (NULL,
1138                                                         coredumpfilter_name);
1139       if (coredumpfilterdata != NULL)
1140         {
1141           sscanf (coredumpfilterdata, "%x", &filterflags);
1142           xfree (coredumpfilterdata);
1143         }
1144     }
1145
1146   xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1147   data = target_fileio_read_stralloc (NULL, mapsfilename);
1148   if (data == NULL)
1149     {
1150       /* Older Linux kernels did not support /proc/PID/smaps.  */
1151       xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1152       data = target_fileio_read_stralloc (NULL, mapsfilename);
1153     }
1154
1155   if (data != NULL)
1156     {
1157       struct cleanup *cleanup = make_cleanup (xfree, data);
1158       char *line, *t;
1159
1160       line = strtok_r (data, "\n", &t);
1161       while (line != NULL)
1162         {
1163           ULONGEST addr, endaddr, offset, inode;
1164           const char *permissions, *device, *filename;
1165           struct smaps_vmflags v;
1166           size_t permissions_len, device_len;
1167           int read, write, exec, priv;
1168           int has_anonymous = 0;
1169           int should_dump_p = 0;
1170           int mapping_anon_p;
1171           int mapping_file_p;
1172
1173           memset (&v, 0, sizeof (v));
1174           read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1175                         &offset, &device, &device_len, &inode, &filename);
1176           mapping_anon_p = mapping_is_anonymous_p (filename);
1177           /* If the mapping is not anonymous, then we can consider it
1178              to be file-backed.  These two states (anonymous or
1179              file-backed) seem to be exclusive, but they can actually
1180              coexist.  For example, if a file-backed mapping has
1181              "Anonymous:" pages (see more below), then the Linux
1182              kernel will dump this mapping when the user specified
1183              that she only wants anonymous mappings in the corefile
1184              (*even* when she explicitly disabled the dumping of
1185              file-backed mappings).  */
1186           mapping_file_p = !mapping_anon_p;
1187
1188           /* Decode permissions.  */
1189           read = (memchr (permissions, 'r', permissions_len) != 0);
1190           write = (memchr (permissions, 'w', permissions_len) != 0);
1191           exec = (memchr (permissions, 'x', permissions_len) != 0);
1192           /* 'private' here actually means VM_MAYSHARE, and not
1193              VM_SHARED.  In order to know if a mapping is really
1194              private or not, we must check the flag "sh" in the
1195              VmFlags field.  This is done by decode_vmflags.  However,
1196              if we are using a Linux kernel released before the commit
1197              834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1198              not have the VmFlags there.  In this case, there is
1199              really no way to know if we are dealing with VM_SHARED,
1200              so we just assume that VM_MAYSHARE is enough.  */
1201           priv = memchr (permissions, 'p', permissions_len) != 0;
1202
1203           /* Try to detect if region should be dumped by parsing smaps
1204              counters.  */
1205           for (line = strtok_r (NULL, "\n", &t);
1206                line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1207                line = strtok_r (NULL, "\n", &t))
1208             {
1209               char keyword[64 + 1];
1210
1211               if (sscanf (line, "%64s", keyword) != 1)
1212                 {
1213                   warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1214                   break;
1215                 }
1216
1217               if (strcmp (keyword, "Anonymous:") == 0)
1218                 {
1219                   /* Older Linux kernels did not support the
1220                      "Anonymous:" counter.  Check it here.  */
1221                   has_anonymous = 1;
1222                 }
1223               else if (strcmp (keyword, "VmFlags:") == 0)
1224                 decode_vmflags (line, &v);
1225
1226               if (strcmp (keyword, "AnonHugePages:") == 0
1227                   || strcmp (keyword, "Anonymous:") == 0)
1228                 {
1229                   unsigned long number;
1230
1231                   if (sscanf (line, "%*s%lu", &number) != 1)
1232                     {
1233                       warning (_("Error parsing {s,}maps file '%s' number"),
1234                                mapsfilename);
1235                       break;
1236                     }
1237                   if (number > 0)
1238                     {
1239                       /* Even if we are dealing with a file-backed
1240                          mapping, if it contains anonymous pages we
1241                          consider it to be *also* an anonymous
1242                          mapping, because this is what the Linux
1243                          kernel does:
1244
1245                          // Dump segments that have been written to.
1246                          if (vma->anon_vma && FILTER(ANON_PRIVATE))
1247                                 goto whole;
1248
1249                          Note that if the mapping is already marked as
1250                          file-backed (i.e., mapping_file_p is
1251                          non-zero), then this is a special case, and
1252                          this mapping will be dumped either when the
1253                          user wants to dump file-backed *or* anonymous
1254                          mappings.  */
1255                       mapping_anon_p = 1;
1256                     }
1257                 }
1258             }
1259
1260           if (has_anonymous)
1261             should_dump_p = dump_mapping_p (filterflags, &v, priv,
1262                                             mapping_anon_p, mapping_file_p,
1263                                             filename);
1264           else
1265             {
1266               /* Older Linux kernels did not support the "Anonymous:" counter.
1267                  If it is missing, we can't be sure - dump all the pages.  */
1268               should_dump_p = 1;
1269             }
1270
1271           /* Invoke the callback function to create the corefile segment.  */
1272           if (should_dump_p)
1273             func (addr, endaddr - addr, offset, inode,
1274                   read, write, exec, 1, /* MODIFIED is true because we
1275                                            want to dump the mapping.  */
1276                   filename, obfd);
1277         }
1278
1279       do_cleanups (cleanup);
1280       return 0;
1281     }
1282
1283   return 1;
1284 }
1285
1286 /* A structure for passing information through
1287    linux_find_memory_regions_full.  */
1288
1289 struct linux_find_memory_regions_data
1290 {
1291   /* The original callback.  */
1292
1293   find_memory_region_ftype func;
1294
1295   /* The original datum.  */
1296
1297   void *obfd;
1298 };
1299
1300 /* A callback for linux_find_memory_regions that converts between the
1301    "full"-style callback and find_memory_region_ftype.  */
1302
1303 static int
1304 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1305                                  ULONGEST offset, ULONGEST inode,
1306                                  int read, int write, int exec, int modified,
1307                                  const char *filename, void *arg)
1308 {
1309   struct linux_find_memory_regions_data *data = arg;
1310
1311   return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1312 }
1313
1314 /* A variant of linux_find_memory_regions_full that is suitable as the
1315    gdbarch find_memory_regions method.  */
1316
1317 static int
1318 linux_find_memory_regions (struct gdbarch *gdbarch,
1319                            find_memory_region_ftype func, void *obfd)
1320 {
1321   struct linux_find_memory_regions_data data;
1322
1323   data.func = func;
1324   data.obfd = obfd;
1325
1326   return linux_find_memory_regions_full (gdbarch,
1327                                          linux_find_memory_regions_thunk,
1328                                          &data);
1329 }
1330
1331 /* Determine which signal stopped execution.  */
1332
1333 static int
1334 find_signalled_thread (struct thread_info *info, void *data)
1335 {
1336   if (info->suspend.stop_signal != GDB_SIGNAL_0
1337       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1338     return 1;
1339
1340   return 0;
1341 }
1342
1343 static enum gdb_signal
1344 find_stop_signal (void)
1345 {
1346   struct thread_info *info =
1347     iterate_over_threads (find_signalled_thread, NULL);
1348
1349   if (info)
1350     return info->suspend.stop_signal;
1351   else
1352     return GDB_SIGNAL_0;
1353 }
1354
1355 /* Generate corefile notes for SPU contexts.  */
1356
1357 static char *
1358 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1359 {
1360   static const char *spu_files[] =
1361     {
1362       "object-id",
1363       "mem",
1364       "regs",
1365       "fpcr",
1366       "lslr",
1367       "decr",
1368       "decr_status",
1369       "signal1",
1370       "signal1_type",
1371       "signal2",
1372       "signal2_type",
1373       "event_mask",
1374       "event_status",
1375       "mbox_info",
1376       "ibox_info",
1377       "wbox_info",
1378       "dma_info",
1379       "proxydma_info",
1380    };
1381
1382   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1383   gdb_byte *spu_ids;
1384   LONGEST i, j, size;
1385
1386   /* Determine list of SPU ids.  */
1387   size = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
1388                             NULL, &spu_ids);
1389
1390   /* Generate corefile notes for each SPU file.  */
1391   for (i = 0; i < size; i += 4)
1392     {
1393       int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1394
1395       for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1396         {
1397           char annex[32], note_name[32];
1398           gdb_byte *spu_data;
1399           LONGEST spu_len;
1400
1401           xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1402           spu_len = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
1403                                        annex, &spu_data);
1404           if (spu_len > 0)
1405             {
1406               xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1407               note_data = elfcore_write_note (obfd, note_data, note_size,
1408                                               note_name, NT_SPU,
1409                                               spu_data, spu_len);
1410               xfree (spu_data);
1411
1412               if (!note_data)
1413                 {
1414                   xfree (spu_ids);
1415                   return NULL;
1416                 }
1417             }
1418         }
1419     }
1420
1421   if (size > 0)
1422     xfree (spu_ids);
1423
1424   return note_data;
1425 }
1426
1427 /* This is used to pass information from
1428    linux_make_mappings_corefile_notes through
1429    linux_find_memory_regions_full.  */
1430
1431 struct linux_make_mappings_data
1432 {
1433   /* Number of files mapped.  */
1434   ULONGEST file_count;
1435
1436   /* The obstack for the main part of the data.  */
1437   struct obstack *data_obstack;
1438
1439   /* The filename obstack.  */
1440   struct obstack *filename_obstack;
1441
1442   /* The architecture's "long" type.  */
1443   struct type *long_type;
1444 };
1445
1446 static linux_find_memory_region_ftype linux_make_mappings_callback;
1447
1448 /* A callback for linux_find_memory_regions_full that updates the
1449    mappings data for linux_make_mappings_corefile_notes.  */
1450
1451 static int
1452 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1453                               ULONGEST offset, ULONGEST inode,
1454                               int read, int write, int exec, int modified,
1455                               const char *filename, void *data)
1456 {
1457   struct linux_make_mappings_data *map_data = data;
1458   gdb_byte buf[sizeof (ULONGEST)];
1459
1460   if (*filename == '\0' || inode == 0)
1461     return 0;
1462
1463   ++map_data->file_count;
1464
1465   pack_long (buf, map_data->long_type, vaddr);
1466   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1467   pack_long (buf, map_data->long_type, vaddr + size);
1468   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1469   pack_long (buf, map_data->long_type, offset);
1470   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1471
1472   obstack_grow_str0 (map_data->filename_obstack, filename);
1473
1474   return 0;
1475 }
1476
1477 /* Write the file mapping data to the core file, if possible.  OBFD is
1478    the output BFD.  NOTE_DATA is the current note data, and NOTE_SIZE
1479    is a pointer to the note size.  Returns the new NOTE_DATA and
1480    updates NOTE_SIZE.  */
1481
1482 static char *
1483 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1484                                     char *note_data, int *note_size)
1485 {
1486   struct cleanup *cleanup;
1487   struct obstack data_obstack, filename_obstack;
1488   struct linux_make_mappings_data mapping_data;
1489   struct type *long_type
1490     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1491   gdb_byte buf[sizeof (ULONGEST)];
1492
1493   obstack_init (&data_obstack);
1494   cleanup = make_cleanup_obstack_free (&data_obstack);
1495   obstack_init (&filename_obstack);
1496   make_cleanup_obstack_free (&filename_obstack);
1497
1498   mapping_data.file_count = 0;
1499   mapping_data.data_obstack = &data_obstack;
1500   mapping_data.filename_obstack = &filename_obstack;
1501   mapping_data.long_type = long_type;
1502
1503   /* Reserve space for the count.  */
1504   obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1505   /* We always write the page size as 1 since we have no good way to
1506      determine the correct value.  */
1507   pack_long (buf, long_type, 1);
1508   obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1509
1510   linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1511                                   &mapping_data);
1512
1513   if (mapping_data.file_count != 0)
1514     {
1515       /* Write the count to the obstack.  */
1516       pack_long ((gdb_byte *) obstack_base (&data_obstack),
1517                  long_type, mapping_data.file_count);
1518
1519       /* Copy the filenames to the data obstack.  */
1520       obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1521                     obstack_object_size (&filename_obstack));
1522
1523       note_data = elfcore_write_note (obfd, note_data, note_size,
1524                                       "CORE", NT_FILE,
1525                                       obstack_base (&data_obstack),
1526                                       obstack_object_size (&data_obstack));
1527     }
1528
1529   do_cleanups (cleanup);
1530   return note_data;
1531 }
1532
1533 /* Structure for passing information from
1534    linux_collect_thread_registers via an iterator to
1535    linux_collect_regset_section_cb. */
1536
1537 struct linux_collect_regset_section_cb_data
1538 {
1539   struct gdbarch *gdbarch;
1540   const struct regcache *regcache;
1541   bfd *obfd;
1542   char *note_data;
1543   int *note_size;
1544   unsigned long lwp;
1545   enum gdb_signal stop_signal;
1546   int abort_iteration;
1547 };
1548
1549 /* Callback for iterate_over_regset_sections that records a single
1550    regset in the corefile note section.  */
1551
1552 static void
1553 linux_collect_regset_section_cb (const char *sect_name, int size,
1554                                  const struct regset *regset,
1555                                  const char *human_name, void *cb_data)
1556 {
1557   char *buf;
1558   struct linux_collect_regset_section_cb_data *data = cb_data;
1559
1560   if (data->abort_iteration)
1561     return;
1562
1563   gdb_assert (regset && regset->collect_regset);
1564
1565   buf = (char *) xmalloc (size);
1566   regset->collect_regset (regset, data->regcache, -1, buf, size);
1567
1568   /* PRSTATUS still needs to be treated specially.  */
1569   if (strcmp (sect_name, ".reg") == 0)
1570     data->note_data = (char *) elfcore_write_prstatus
1571       (data->obfd, data->note_data, data->note_size, data->lwp,
1572        gdb_signal_to_host (data->stop_signal), buf);
1573   else
1574     data->note_data = (char *) elfcore_write_register_note
1575       (data->obfd, data->note_data, data->note_size,
1576        sect_name, buf, size);
1577   xfree (buf);
1578
1579   if (data->note_data == NULL)
1580     data->abort_iteration = 1;
1581 }
1582
1583 /* Records the thread's register state for the corefile note
1584    section.  */
1585
1586 static char *
1587 linux_collect_thread_registers (const struct regcache *regcache,
1588                                 ptid_t ptid, bfd *obfd,
1589                                 char *note_data, int *note_size,
1590                                 enum gdb_signal stop_signal)
1591 {
1592   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1593   struct linux_collect_regset_section_cb_data data;
1594
1595   data.gdbarch = gdbarch;
1596   data.regcache = regcache;
1597   data.obfd = obfd;
1598   data.note_data = note_data;
1599   data.note_size = note_size;
1600   data.stop_signal = stop_signal;
1601   data.abort_iteration = 0;
1602
1603   /* For remote targets the LWP may not be available, so use the TID.  */
1604   data.lwp = ptid_get_lwp (ptid);
1605   if (!data.lwp)
1606     data.lwp = ptid_get_tid (ptid);
1607
1608   gdbarch_iterate_over_regset_sections (gdbarch,
1609                                         linux_collect_regset_section_cb,
1610                                         &data, regcache);
1611   return data.note_data;
1612 }
1613
1614 /* Fetch the siginfo data for the current thread, if it exists.  If
1615    there is no data, or we could not read it, return NULL.  Otherwise,
1616    return a newly malloc'd buffer holding the data and fill in *SIZE
1617    with the size of the data.  The caller is responsible for freeing
1618    the data.  */
1619
1620 static gdb_byte *
1621 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1622 {
1623   struct type *siginfo_type;
1624   gdb_byte *buf;
1625   LONGEST bytes_read;
1626   struct cleanup *cleanups;
1627
1628   if (!gdbarch_get_siginfo_type_p (gdbarch))
1629     return NULL;
1630
1631   siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1632
1633   buf = (gdb_byte *) xmalloc (TYPE_LENGTH (siginfo_type));
1634   cleanups = make_cleanup (xfree, buf);
1635
1636   bytes_read = target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1637                             buf, 0, TYPE_LENGTH (siginfo_type));
1638   if (bytes_read == TYPE_LENGTH (siginfo_type))
1639     {
1640       discard_cleanups (cleanups);
1641       *size = bytes_read;
1642     }
1643   else
1644     {
1645       do_cleanups (cleanups);
1646       buf = NULL;
1647     }
1648
1649   return buf;
1650 }
1651
1652 struct linux_corefile_thread_data
1653 {
1654   struct gdbarch *gdbarch;
1655   int pid;
1656   bfd *obfd;
1657   char *note_data;
1658   int *note_size;
1659   enum gdb_signal stop_signal;
1660 };
1661
1662 /* Called by gdbthread.c once per thread.  Records the thread's
1663    register state for the corefile note section.  */
1664
1665 static int
1666 linux_corefile_thread_callback (struct thread_info *info, void *data)
1667 {
1668   struct linux_corefile_thread_data *args = data;
1669
1670   /* It can be current thread
1671      which cannot be removed by update_thread_list.  */
1672   if (info->state == THREAD_EXITED)
1673     return 0;
1674
1675   if (ptid_get_pid (info->ptid) == args->pid)
1676     {
1677       struct cleanup *old_chain;
1678       struct regcache *regcache;
1679       gdb_byte *siginfo_data;
1680       LONGEST siginfo_size = 0;
1681
1682       regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1683
1684       old_chain = save_inferior_ptid ();
1685       inferior_ptid = info->ptid;
1686       target_fetch_registers (regcache, -1);
1687       siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1688       do_cleanups (old_chain);
1689
1690       old_chain = make_cleanup (xfree, siginfo_data);
1691
1692       args->note_data = linux_collect_thread_registers
1693         (regcache, info->ptid, args->obfd, args->note_data,
1694          args->note_size, args->stop_signal);
1695
1696       /* Don't return anything if we got no register information above,
1697          such a core file is useless.  */
1698       if (args->note_data != NULL)
1699         if (siginfo_data != NULL)
1700           args->note_data = elfcore_write_note (args->obfd,
1701                                                 args->note_data,
1702                                                 args->note_size,
1703                                                 "CORE", NT_SIGINFO,
1704                                                 siginfo_data, siginfo_size);
1705
1706       do_cleanups (old_chain);
1707     }
1708
1709   return !args->note_data;
1710 }
1711
1712 /* Fill the PRPSINFO structure with information about the process being
1713    debugged.  Returns 1 in case of success, 0 for failures.  Please note that
1714    even if the structure cannot be entirely filled (e.g., GDB was unable to
1715    gather information about the process UID/GID), this function will still
1716    return 1 since some information was already recorded.  It will only return
1717    0 iff nothing can be gathered.  */
1718
1719 static int
1720 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1721 {
1722   /* The filename which we will use to obtain some info about the process.
1723      We will basically use this to store the `/proc/PID/FILENAME' file.  */
1724   char filename[100];
1725   /* The full name of the program which generated the corefile.  */
1726   char *fname;
1727   /* The basename of the executable.  */
1728   const char *basename;
1729   /* The arguments of the program.  */
1730   char *psargs;
1731   char *infargs;
1732   /* The contents of `/proc/PID/stat' and `/proc/PID/status' files.  */
1733   char *proc_stat, *proc_status;
1734   /* Temporary buffer.  */
1735   char *tmpstr;
1736   /* The valid states of a process, according to the Linux kernel.  */
1737   const char valid_states[] = "RSDTZW";
1738   /* The program state.  */
1739   const char *prog_state;
1740   /* The state of the process.  */
1741   char pr_sname;
1742   /* The PID of the program which generated the corefile.  */
1743   pid_t pid;
1744   /* Process flags.  */
1745   unsigned int pr_flag;
1746   /* Process nice value.  */
1747   long pr_nice;
1748   /* The number of fields read by `sscanf'.  */
1749   int n_fields = 0;
1750   /* Cleanups.  */
1751   struct cleanup *c;
1752   int i;
1753
1754   gdb_assert (p != NULL);
1755
1756   /* Obtaining PID and filename.  */
1757   pid = ptid_get_pid (inferior_ptid);
1758   xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1759   fname = target_fileio_read_stralloc (NULL, filename);
1760
1761   if (fname == NULL || *fname == '\0')
1762     {
1763       /* No program name was read, so we won't be able to retrieve more
1764          information about the process.  */
1765       xfree (fname);
1766       return 0;
1767     }
1768
1769   c = make_cleanup (xfree, fname);
1770   memset (p, 0, sizeof (*p));
1771
1772   /* Defining the PID.  */
1773   p->pr_pid = pid;
1774
1775   /* Copying the program name.  Only the basename matters.  */
1776   basename = lbasename (fname);
1777   strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1778   p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1779
1780   infargs = get_inferior_args ();
1781
1782   psargs = xstrdup (fname);
1783   if (infargs != NULL)
1784     psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1785
1786   make_cleanup (xfree, psargs);
1787
1788   strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1789   p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1790
1791   xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1792   proc_stat = target_fileio_read_stralloc (NULL, filename);
1793   make_cleanup (xfree, proc_stat);
1794
1795   if (proc_stat == NULL || *proc_stat == '\0')
1796     {
1797       /* Despite being unable to read more information about the
1798          process, we return 1 here because at least we have its
1799          command line, PID and arguments.  */
1800       do_cleanups (c);
1801       return 1;
1802     }
1803
1804   /* Ok, we have the stats.  It's time to do a little parsing of the
1805      contents of the buffer, so that we end up reading what we want.
1806
1807      The following parsing mechanism is strongly based on the
1808      information generated by the `fs/proc/array.c' file, present in
1809      the Linux kernel tree.  More details about how the information is
1810      displayed can be obtained by seeing the manpage of proc(5),
1811      specifically under the entry of `/proc/[pid]/stat'.  */
1812
1813   /* Getting rid of the PID, since we already have it.  */
1814   while (isdigit (*proc_stat))
1815     ++proc_stat;
1816
1817   proc_stat = skip_spaces (proc_stat);
1818
1819   /* ps command also relies on no trailing fields ever contain ')'.  */
1820   proc_stat = strrchr (proc_stat, ')');
1821   if (proc_stat == NULL)
1822     {
1823       do_cleanups (c);
1824       return 1;
1825     }
1826   proc_stat++;
1827
1828   proc_stat = skip_spaces (proc_stat);
1829
1830   n_fields = sscanf (proc_stat,
1831                      "%c"               /* Process state.  */
1832                      "%d%d%d"           /* Parent PID, group ID, session ID.  */
1833                      "%*d%*d"           /* tty_nr, tpgid (not used).  */
1834                      "%u"               /* Flags.  */
1835                      "%*s%*s%*s%*s"     /* minflt, cminflt, majflt,
1836                                            cmajflt (not used).  */
1837                      "%*s%*s%*s%*s"     /* utime, stime, cutime,
1838                                            cstime (not used).  */
1839                      "%*s"              /* Priority (not used).  */
1840                      "%ld",             /* Nice.  */
1841                      &pr_sname,
1842                      &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1843                      &pr_flag,
1844                      &pr_nice);
1845
1846   if (n_fields != 6)
1847     {
1848       /* Again, we couldn't read the complementary information about
1849          the process state.  However, we already have minimal
1850          information, so we just return 1 here.  */
1851       do_cleanups (c);
1852       return 1;
1853     }
1854
1855   /* Filling the structure fields.  */
1856   prog_state = strchr (valid_states, pr_sname);
1857   if (prog_state != NULL)
1858     p->pr_state = prog_state - valid_states;
1859   else
1860     {
1861       /* Zero means "Running".  */
1862       p->pr_state = 0;
1863     }
1864
1865   p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1866   p->pr_zomb = p->pr_sname == 'Z';
1867   p->pr_nice = pr_nice;
1868   p->pr_flag = pr_flag;
1869
1870   /* Finally, obtaining the UID and GID.  For that, we read and parse the
1871      contents of the `/proc/PID/status' file.  */
1872   xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1873   proc_status = target_fileio_read_stralloc (NULL, filename);
1874   make_cleanup (xfree, proc_status);
1875
1876   if (proc_status == NULL || *proc_status == '\0')
1877     {
1878       /* Returning 1 since we already have a bunch of information.  */
1879       do_cleanups (c);
1880       return 1;
1881     }
1882
1883   /* Extracting the UID.  */
1884   tmpstr = strstr (proc_status, "Uid:");
1885   if (tmpstr != NULL)
1886     {
1887       /* Advancing the pointer to the beginning of the UID.  */
1888       tmpstr += sizeof ("Uid:");
1889       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1890         ++tmpstr;
1891
1892       if (isdigit (*tmpstr))
1893         p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1894     }
1895
1896   /* Extracting the GID.  */
1897   tmpstr = strstr (proc_status, "Gid:");
1898   if (tmpstr != NULL)
1899     {
1900       /* Advancing the pointer to the beginning of the GID.  */
1901       tmpstr += sizeof ("Gid:");
1902       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1903         ++tmpstr;
1904
1905       if (isdigit (*tmpstr))
1906         p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1907     }
1908
1909   do_cleanups (c);
1910
1911   return 1;
1912 }
1913
1914 /* Build the note section for a corefile, and return it in a malloc
1915    buffer.  */
1916
1917 static char *
1918 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1919 {
1920   struct linux_corefile_thread_data thread_args;
1921   struct elf_internal_linux_prpsinfo prpsinfo;
1922   char *note_data = NULL;
1923   gdb_byte *auxv;
1924   int auxv_len;
1925
1926   if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1927     return NULL;
1928
1929   if (linux_fill_prpsinfo (&prpsinfo))
1930     {
1931       if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1932         {
1933           note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1934                                                             note_data, note_size,
1935                                                             &prpsinfo);
1936         }
1937       else
1938         {
1939           if (gdbarch_ptr_bit (gdbarch) == 64)
1940             note_data = elfcore_write_linux_prpsinfo64 (obfd,
1941                                                         note_data, note_size,
1942                                                         &prpsinfo);
1943           else
1944             note_data = elfcore_write_linux_prpsinfo32 (obfd,
1945                                                         note_data, note_size,
1946                                                         &prpsinfo);
1947         }
1948     }
1949
1950   /* Thread register information.  */
1951   TRY
1952     {
1953       update_thread_list ();
1954     }
1955   CATCH (e, RETURN_MASK_ERROR)
1956     {
1957       exception_print (gdb_stderr, e);
1958     }
1959   END_CATCH
1960
1961   thread_args.gdbarch = gdbarch;
1962   thread_args.pid = ptid_get_pid (inferior_ptid);
1963   thread_args.obfd = obfd;
1964   thread_args.note_data = note_data;
1965   thread_args.note_size = note_size;
1966   thread_args.stop_signal = find_stop_signal ();
1967   iterate_over_threads (linux_corefile_thread_callback, &thread_args);
1968   note_data = thread_args.note_data;
1969   if (!note_data)
1970     return NULL;
1971
1972   /* Auxillary vector.  */
1973   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
1974                                 NULL, &auxv);
1975   if (auxv_len > 0)
1976     {
1977       note_data = elfcore_write_note (obfd, note_data, note_size,
1978                                       "CORE", NT_AUXV, auxv, auxv_len);
1979       xfree (auxv);
1980
1981       if (!note_data)
1982         return NULL;
1983     }
1984
1985   /* SPU information.  */
1986   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1987   if (!note_data)
1988     return NULL;
1989
1990   /* File mappings.  */
1991   note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1992                                                   note_data, note_size);
1993
1994   return note_data;
1995 }
1996
1997 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1998    gdbarch.h.  This function is not static because it is exported to
1999    other -tdep files.  */
2000
2001 enum gdb_signal
2002 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2003 {
2004   switch (signal)
2005     {
2006     case 0:
2007       return GDB_SIGNAL_0;
2008
2009     case LINUX_SIGHUP:
2010       return GDB_SIGNAL_HUP;
2011
2012     case LINUX_SIGINT:
2013       return GDB_SIGNAL_INT;
2014
2015     case LINUX_SIGQUIT:
2016       return GDB_SIGNAL_QUIT;
2017
2018     case LINUX_SIGILL:
2019       return GDB_SIGNAL_ILL;
2020
2021     case LINUX_SIGTRAP:
2022       return GDB_SIGNAL_TRAP;
2023
2024     case LINUX_SIGABRT:
2025       return GDB_SIGNAL_ABRT;
2026
2027     case LINUX_SIGBUS:
2028       return GDB_SIGNAL_BUS;
2029
2030     case LINUX_SIGFPE:
2031       return GDB_SIGNAL_FPE;
2032
2033     case LINUX_SIGKILL:
2034       return GDB_SIGNAL_KILL;
2035
2036     case LINUX_SIGUSR1:
2037       return GDB_SIGNAL_USR1;
2038
2039     case LINUX_SIGSEGV:
2040       return GDB_SIGNAL_SEGV;
2041
2042     case LINUX_SIGUSR2:
2043       return GDB_SIGNAL_USR2;
2044
2045     case LINUX_SIGPIPE:
2046       return GDB_SIGNAL_PIPE;
2047
2048     case LINUX_SIGALRM:
2049       return GDB_SIGNAL_ALRM;
2050
2051     case LINUX_SIGTERM:
2052       return GDB_SIGNAL_TERM;
2053
2054     case LINUX_SIGCHLD:
2055       return GDB_SIGNAL_CHLD;
2056
2057     case LINUX_SIGCONT:
2058       return GDB_SIGNAL_CONT;
2059
2060     case LINUX_SIGSTOP:
2061       return GDB_SIGNAL_STOP;
2062
2063     case LINUX_SIGTSTP:
2064       return GDB_SIGNAL_TSTP;
2065
2066     case LINUX_SIGTTIN:
2067       return GDB_SIGNAL_TTIN;
2068
2069     case LINUX_SIGTTOU:
2070       return GDB_SIGNAL_TTOU;
2071
2072     case LINUX_SIGURG:
2073       return GDB_SIGNAL_URG;
2074
2075     case LINUX_SIGXCPU:
2076       return GDB_SIGNAL_XCPU;
2077
2078     case LINUX_SIGXFSZ:
2079       return GDB_SIGNAL_XFSZ;
2080
2081     case LINUX_SIGVTALRM:
2082       return GDB_SIGNAL_VTALRM;
2083
2084     case LINUX_SIGPROF:
2085       return GDB_SIGNAL_PROF;
2086
2087     case LINUX_SIGWINCH:
2088       return GDB_SIGNAL_WINCH;
2089
2090     /* No way to differentiate between SIGIO and SIGPOLL.
2091        Therefore, we just handle the first one.  */
2092     case LINUX_SIGIO:
2093       return GDB_SIGNAL_IO;
2094
2095     case LINUX_SIGPWR:
2096       return GDB_SIGNAL_PWR;
2097
2098     case LINUX_SIGSYS:
2099       return GDB_SIGNAL_SYS;
2100
2101     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2102        therefore we have to handle them here.  */
2103     case LINUX_SIGRTMIN:
2104       return GDB_SIGNAL_REALTIME_32;
2105
2106     case LINUX_SIGRTMAX:
2107       return GDB_SIGNAL_REALTIME_64;
2108     }
2109
2110   if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2111     {
2112       int offset = signal - LINUX_SIGRTMIN + 1;
2113
2114       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2115     }
2116
2117   return GDB_SIGNAL_UNKNOWN;
2118 }
2119
2120 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2121    gdbarch.h.  This function is not static because it is exported to
2122    other -tdep files.  */
2123
2124 int
2125 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2126                             enum gdb_signal signal)
2127 {
2128   switch (signal)
2129     {
2130     case GDB_SIGNAL_0:
2131       return 0;
2132
2133     case GDB_SIGNAL_HUP:
2134       return LINUX_SIGHUP;
2135
2136     case GDB_SIGNAL_INT:
2137       return LINUX_SIGINT;
2138
2139     case GDB_SIGNAL_QUIT:
2140       return LINUX_SIGQUIT;
2141
2142     case GDB_SIGNAL_ILL:
2143       return LINUX_SIGILL;
2144
2145     case GDB_SIGNAL_TRAP:
2146       return LINUX_SIGTRAP;
2147
2148     case GDB_SIGNAL_ABRT:
2149       return LINUX_SIGABRT;
2150
2151     case GDB_SIGNAL_FPE:
2152       return LINUX_SIGFPE;
2153
2154     case GDB_SIGNAL_KILL:
2155       return LINUX_SIGKILL;
2156
2157     case GDB_SIGNAL_BUS:
2158       return LINUX_SIGBUS;
2159
2160     case GDB_SIGNAL_SEGV:
2161       return LINUX_SIGSEGV;
2162
2163     case GDB_SIGNAL_SYS:
2164       return LINUX_SIGSYS;
2165
2166     case GDB_SIGNAL_PIPE:
2167       return LINUX_SIGPIPE;
2168
2169     case GDB_SIGNAL_ALRM:
2170       return LINUX_SIGALRM;
2171
2172     case GDB_SIGNAL_TERM:
2173       return LINUX_SIGTERM;
2174
2175     case GDB_SIGNAL_URG:
2176       return LINUX_SIGURG;
2177
2178     case GDB_SIGNAL_STOP:
2179       return LINUX_SIGSTOP;
2180
2181     case GDB_SIGNAL_TSTP:
2182       return LINUX_SIGTSTP;
2183
2184     case GDB_SIGNAL_CONT:
2185       return LINUX_SIGCONT;
2186
2187     case GDB_SIGNAL_CHLD:
2188       return LINUX_SIGCHLD;
2189
2190     case GDB_SIGNAL_TTIN:
2191       return LINUX_SIGTTIN;
2192
2193     case GDB_SIGNAL_TTOU:
2194       return LINUX_SIGTTOU;
2195
2196     case GDB_SIGNAL_IO:
2197       return LINUX_SIGIO;
2198
2199     case GDB_SIGNAL_XCPU:
2200       return LINUX_SIGXCPU;
2201
2202     case GDB_SIGNAL_XFSZ:
2203       return LINUX_SIGXFSZ;
2204
2205     case GDB_SIGNAL_VTALRM:
2206       return LINUX_SIGVTALRM;
2207
2208     case GDB_SIGNAL_PROF:
2209       return LINUX_SIGPROF;
2210
2211     case GDB_SIGNAL_WINCH:
2212       return LINUX_SIGWINCH;
2213
2214     case GDB_SIGNAL_USR1:
2215       return LINUX_SIGUSR1;
2216
2217     case GDB_SIGNAL_USR2:
2218       return LINUX_SIGUSR2;
2219
2220     case GDB_SIGNAL_PWR:
2221       return LINUX_SIGPWR;
2222
2223     case GDB_SIGNAL_POLL:
2224       return LINUX_SIGPOLL;
2225
2226     /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2227        therefore we have to handle it here.  */
2228     case GDB_SIGNAL_REALTIME_32:
2229       return LINUX_SIGRTMIN;
2230
2231     /* Same comment applies to _64.  */
2232     case GDB_SIGNAL_REALTIME_64:
2233       return LINUX_SIGRTMAX;
2234     }
2235
2236   /* GDB_SIGNAL_REALTIME_33 to _64 are continuous.  */
2237   if (signal >= GDB_SIGNAL_REALTIME_33
2238       && signal <= GDB_SIGNAL_REALTIME_63)
2239     {
2240       int offset = signal - GDB_SIGNAL_REALTIME_33;
2241
2242       return LINUX_SIGRTMIN + 1 + offset;
2243     }
2244
2245   return -1;
2246 }
2247
2248 /* Rummage through mappings to find a mapping's size.  */
2249
2250 static int
2251 find_mapping_size (CORE_ADDR vaddr, unsigned long size,
2252                    int read, int write, int exec, int modified,
2253                    void *data)
2254 {
2255   struct mem_range *range = data;
2256
2257   if (vaddr == range->start)
2258     {
2259       range->length = size;
2260       return 1;
2261     }
2262   return 0;
2263 }
2264
2265 /* Helper for linux_vsyscall_range that does the real work of finding
2266    the vsyscall's address range.  */
2267
2268 static int
2269 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2270 {
2271   if (target_auxv_search (&current_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2272     return 0;
2273
2274   /* This is installed by linux_init_abi below, so should always be
2275      available.  */
2276   gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2277
2278   range->length = 0;
2279   gdbarch_find_memory_regions (gdbarch, find_mapping_size, range);
2280   return 1;
2281 }
2282
2283 /* Implementation of the "vsyscall_range" gdbarch hook.  Handles
2284    caching, and defers the real work to linux_vsyscall_range_raw.  */
2285
2286 static int
2287 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2288 {
2289   struct linux_info *info = get_linux_inferior_data ();
2290
2291   if (info->vsyscall_range_p == 0)
2292     {
2293       if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2294         info->vsyscall_range_p = 1;
2295       else
2296         info->vsyscall_range_p = -1;
2297     }
2298
2299   if (info->vsyscall_range_p < 0)
2300     return 0;
2301
2302   *range = info->vsyscall_range;
2303   return 1;
2304 }
2305
2306 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2307    definitions would be dependent on compilation host.  */
2308 #define GDB_MMAP_MAP_PRIVATE    0x02            /* Changes are private.  */
2309 #define GDB_MMAP_MAP_ANONYMOUS  0x20            /* Don't use a file.  */
2310
2311 /* See gdbarch.sh 'infcall_mmap'.  */
2312
2313 static CORE_ADDR
2314 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2315 {
2316   struct objfile *objf;
2317   /* Do there still exist any Linux systems without "mmap64"?
2318      "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32.  */
2319   struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2320   struct value *addr_val;
2321   struct gdbarch *gdbarch = get_objfile_arch (objf);
2322   CORE_ADDR retval;
2323   enum
2324     {
2325       ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2326     };
2327   struct value *arg[ARG_LAST];
2328
2329   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2330                                       0);
2331   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2332   arg[ARG_LENGTH] = value_from_ulongest
2333                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2334   gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2335                         | GDB_MMAP_PROT_EXEC))
2336               == 0);
2337   arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2338   arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2339                                        GDB_MMAP_MAP_PRIVATE
2340                                        | GDB_MMAP_MAP_ANONYMOUS);
2341   arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2342   arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2343                                         0);
2344   addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
2345   retval = value_as_address (addr_val);
2346   if (retval == (CORE_ADDR) -1)
2347     error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2348            pulongest (size));
2349   return retval;
2350 }
2351
2352 /* See gdbarch.sh 'infcall_munmap'.  */
2353
2354 static void
2355 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2356 {
2357   struct objfile *objf;
2358   struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2359   struct value *retval_val;
2360   struct gdbarch *gdbarch = get_objfile_arch (objf);
2361   LONGEST retval;
2362   enum
2363     {
2364       ARG_ADDR, ARG_LENGTH, ARG_LAST
2365     };
2366   struct value *arg[ARG_LAST];
2367
2368   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2369                                       addr);
2370   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2371   arg[ARG_LENGTH] = value_from_ulongest
2372                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2373   retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
2374   retval = value_as_long (retval_val);
2375   if (retval != 0)
2376     warning (_("Failed inferior munmap call at %s for %s bytes, "
2377                "errno is changed."),
2378              hex_string (addr), pulongest (size));
2379 }
2380
2381 /* See linux-tdep.h.  */
2382
2383 CORE_ADDR
2384 linux_displaced_step_location (struct gdbarch *gdbarch)
2385 {
2386   CORE_ADDR addr;
2387   int bp_len;
2388
2389   /* Determine entry point from target auxiliary vector.  This avoids
2390      the need for symbols.  Also, when debugging a stand-alone SPU
2391      executable, entry_point_address () will point to an SPU
2392      local-store address and is thus not usable as displaced stepping
2393      location.  The auxiliary vector gets us the PowerPC-side entry
2394      point address instead.  */
2395   if (target_auxv_search (&current_target, AT_ENTRY, &addr) <= 0)
2396     error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2397
2398   /* Make certain that the address points at real code, and not a
2399      function descriptor.  */
2400   addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2401                                              &current_target);
2402
2403   /* Inferior calls also use the entry point as a breakpoint location.
2404      We don't want displaced stepping to interfere with those
2405      breakpoints, so leave space.  */
2406   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2407   addr += bp_len * 2;
2408
2409   return addr;
2410 }
2411
2412 /* Display whether the gcore command is using the
2413    /proc/PID/coredump_filter file.  */
2414
2415 static void
2416 show_use_coredump_filter (struct ui_file *file, int from_tty,
2417                           struct cmd_list_element *c, const char *value)
2418 {
2419   fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2420                             " corefiles is %s.\n"), value);
2421 }
2422
2423 /* To be called from the various GDB_OSABI_LINUX handlers for the
2424    various GNU/Linux architectures and machine types.  */
2425
2426 void
2427 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2428 {
2429   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2430   set_gdbarch_info_proc (gdbarch, linux_info_proc);
2431   set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2432   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2433   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2434   set_gdbarch_has_shared_address_space (gdbarch,
2435                                         linux_has_shared_address_space);
2436   set_gdbarch_gdb_signal_from_target (gdbarch,
2437                                       linux_gdb_signal_from_target);
2438   set_gdbarch_gdb_signal_to_target (gdbarch,
2439                                     linux_gdb_signal_to_target);
2440   set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2441   set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2442   set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2443   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2444 }
2445
2446 /* Provide a prototype to silence -Wmissing-prototypes.  */
2447 extern initialize_file_ftype _initialize_linux_tdep;
2448
2449 void
2450 _initialize_linux_tdep (void)
2451 {
2452   linux_gdbarch_data_handle =
2453     gdbarch_data_register_post_init (init_linux_gdbarch_data);
2454
2455   /* Set a cache per-inferior.  */
2456   linux_inferior_data
2457     = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2458   /* Observers used to invalidate the cache when needed.  */
2459   observer_attach_inferior_exit (invalidate_linux_cache_inf);
2460   observer_attach_inferior_appeared (invalidate_linux_cache_inf);
2461
2462   add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2463                            &use_coredump_filter, _("\
2464 Set whether gcore should consider /proc/PID/coredump_filter."),
2465                            _("\
2466 Show whether gcore should consider /proc/PID/coredump_filter."),
2467                            _("\
2468 Use this command to set whether gcore should consider the contents\n\
2469 of /proc/PID/coredump_filter when generating the corefile.  For more information\n\
2470 about this file, refer to the manpage of core(5)."),
2471                            NULL, show_use_coredump_filter,
2472                            &setlist, &showlist);
2473 }