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