Automatic date update in version.in
[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.lwp () != 0)
423     {
424       snprintf (buf, sizeof (buf), "LWP %ld", ptid.lwp ());
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   int target_errno;
730
731   if (args && isdigit (args[0]))
732     {
733       char *tem;
734
735       pid = strtoul (args, &tem, 10);
736       args = tem;
737     }
738   else
739     {
740       if (!target_has_execution)
741         error (_("No current process: you must name one."));
742       if (current_inferior ()->fake_pid_p)
743         error (_("Can't determine the current process's PID: you must name one."));
744
745       pid = current_inferior ()->pid;
746     }
747
748   args = skip_spaces (args);
749   if (args && args[0])
750     error (_("Too many parameters: %s"), args);
751
752   printf_filtered (_("process %ld\n"), pid);
753   if (cmdline_f)
754     {
755       xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
756       gdb_byte *buffer;
757       ssize_t len = target_fileio_read_alloc (NULL, filename, &buffer);
758
759       if (len > 0)
760         {
761           gdb::unique_xmalloc_ptr<char> cmdline ((char *) buffer);
762           ssize_t pos;
763
764           for (pos = 0; pos < len - 1; pos++)
765             {
766               if (buffer[pos] == '\0')
767                 buffer[pos] = ' ';
768             }
769           buffer[len - 1] = '\0';
770           printf_filtered ("cmdline = '%s'\n", buffer);
771         }
772       else
773         warning (_("unable to open /proc file '%s'"), filename);
774     }
775   if (cwd_f)
776     {
777       xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
778       gdb::optional<std::string> contents
779         = target_fileio_readlink (NULL, filename, &target_errno);
780       if (contents.has_value ())
781         printf_filtered ("cwd = '%s'\n", contents->c_str ());
782       else
783         warning (_("unable to read link '%s'"), filename);
784     }
785   if (exe_f)
786     {
787       xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
788       gdb::optional<std::string> contents
789         = target_fileio_readlink (NULL, filename, &target_errno);
790       if (contents.has_value ())
791         printf_filtered ("exe = '%s'\n", contents->c_str ());
792       else
793         warning (_("unable to read link '%s'"), filename);
794     }
795   if (mappings_f)
796     {
797       xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
798       gdb::unique_xmalloc_ptr<char> map
799         = target_fileio_read_stralloc (NULL, filename);
800       if (map != NULL)
801         {
802           char *line;
803
804           printf_filtered (_("Mapped address spaces:\n\n"));
805           if (gdbarch_addr_bit (gdbarch) == 32)
806             {
807               printf_filtered ("\t%10s %10s %10s %10s %s\n",
808                            "Start Addr",
809                            "  End Addr",
810                            "      Size", "    Offset", "objfile");
811             }
812           else
813             {
814               printf_filtered ("  %18s %18s %10s %10s %s\n",
815                            "Start Addr",
816                            "  End Addr",
817                            "      Size", "    Offset", "objfile");
818             }
819
820           for (line = strtok (map.get (), "\n");
821                line;
822                line = strtok (NULL, "\n"))
823             {
824               ULONGEST addr, endaddr, offset, inode;
825               const char *permissions, *device, *mapping_filename;
826               size_t permissions_len, device_len;
827
828               read_mapping (line, &addr, &endaddr,
829                             &permissions, &permissions_len,
830                             &offset, &device, &device_len,
831                             &inode, &mapping_filename);
832
833               if (gdbarch_addr_bit (gdbarch) == 32)
834                 {
835                   printf_filtered ("\t%10s %10s %10s %10s %s\n",
836                                    paddress (gdbarch, addr),
837                                    paddress (gdbarch, endaddr),
838                                    hex_string (endaddr - addr),
839                                    hex_string (offset),
840                                    *mapping_filename ? mapping_filename : "");
841                 }
842               else
843                 {
844                   printf_filtered ("  %18s %18s %10s %10s %s\n",
845                                    paddress (gdbarch, addr),
846                                    paddress (gdbarch, endaddr),
847                                    hex_string (endaddr - addr),
848                                    hex_string (offset),
849                                    *mapping_filename ? mapping_filename : "");
850                 }
851             }
852         }
853       else
854         warning (_("unable to open /proc file '%s'"), filename);
855     }
856   if (status_f)
857     {
858       xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
859       gdb::unique_xmalloc_ptr<char> status
860         = target_fileio_read_stralloc (NULL, filename);
861       if (status)
862         puts_filtered (status.get ());
863       else
864         warning (_("unable to open /proc file '%s'"), filename);
865     }
866   if (stat_f)
867     {
868       xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
869       gdb::unique_xmalloc_ptr<char> statstr
870         = target_fileio_read_stralloc (NULL, filename);
871       if (statstr)
872         {
873           const char *p = statstr.get ();
874
875           printf_filtered (_("Process: %s\n"),
876                            pulongest (strtoulst (p, &p, 10)));
877
878           p = skip_spaces (p);
879           if (*p == '(')
880             {
881               /* ps command also relies on no trailing fields
882                  ever contain ')'.  */
883               const char *ep = strrchr (p, ')');
884               if (ep != NULL)
885                 {
886                   printf_filtered ("Exec file: %.*s\n",
887                                    (int) (ep - p - 1), p + 1);
888                   p = ep + 1;
889                 }
890             }
891
892           p = skip_spaces (p);
893           if (*p)
894             printf_filtered (_("State: %c\n"), *p++);
895
896           if (*p)
897             printf_filtered (_("Parent process: %s\n"),
898                              pulongest (strtoulst (p, &p, 10)));
899           if (*p)
900             printf_filtered (_("Process group: %s\n"),
901                              pulongest (strtoulst (p, &p, 10)));
902           if (*p)
903             printf_filtered (_("Session id: %s\n"),
904                              pulongest (strtoulst (p, &p, 10)));
905           if (*p)
906             printf_filtered (_("TTY: %s\n"),
907                              pulongest (strtoulst (p, &p, 10)));
908           if (*p)
909             printf_filtered (_("TTY owner process group: %s\n"),
910                              pulongest (strtoulst (p, &p, 10)));
911
912           if (*p)
913             printf_filtered (_("Flags: %s\n"),
914                              hex_string (strtoulst (p, &p, 10)));
915           if (*p)
916             printf_filtered (_("Minor faults (no memory page): %s\n"),
917                              pulongest (strtoulst (p, &p, 10)));
918           if (*p)
919             printf_filtered (_("Minor faults, children: %s\n"),
920                              pulongest (strtoulst (p, &p, 10)));
921           if (*p)
922             printf_filtered (_("Major faults (memory page faults): %s\n"),
923                              pulongest (strtoulst (p, &p, 10)));
924           if (*p)
925             printf_filtered (_("Major faults, children: %s\n"),
926                              pulongest (strtoulst (p, &p, 10)));
927           if (*p)
928             printf_filtered (_("utime: %s\n"),
929                              pulongest (strtoulst (p, &p, 10)));
930           if (*p)
931             printf_filtered (_("stime: %s\n"),
932                              pulongest (strtoulst (p, &p, 10)));
933           if (*p)
934             printf_filtered (_("utime, children: %s\n"),
935                              pulongest (strtoulst (p, &p, 10)));
936           if (*p)
937             printf_filtered (_("stime, children: %s\n"),
938                              pulongest (strtoulst (p, &p, 10)));
939           if (*p)
940             printf_filtered (_("jiffies remaining in current "
941                                "time slice: %s\n"),
942                              pulongest (strtoulst (p, &p, 10)));
943           if (*p)
944             printf_filtered (_("'nice' value: %s\n"),
945                              pulongest (strtoulst (p, &p, 10)));
946           if (*p)
947             printf_filtered (_("jiffies until next timeout: %s\n"),
948                              pulongest (strtoulst (p, &p, 10)));
949           if (*p)
950             printf_filtered (_("jiffies until next SIGALRM: %s\n"),
951                              pulongest (strtoulst (p, &p, 10)));
952           if (*p)
953             printf_filtered (_("start time (jiffies since "
954                                "system boot): %s\n"),
955                              pulongest (strtoulst (p, &p, 10)));
956           if (*p)
957             printf_filtered (_("Virtual memory size: %s\n"),
958                              pulongest (strtoulst (p, &p, 10)));
959           if (*p)
960             printf_filtered (_("Resident set size: %s\n"),
961                              pulongest (strtoulst (p, &p, 10)));
962           if (*p)
963             printf_filtered (_("rlim: %s\n"),
964                              pulongest (strtoulst (p, &p, 10)));
965           if (*p)
966             printf_filtered (_("Start of text: %s\n"),
967                              hex_string (strtoulst (p, &p, 10)));
968           if (*p)
969             printf_filtered (_("End of text: %s\n"),
970                              hex_string (strtoulst (p, &p, 10)));
971           if (*p)
972             printf_filtered (_("Start of stack: %s\n"),
973                              hex_string (strtoulst (p, &p, 10)));
974 #if 0   /* Don't know how architecture-dependent the rest is...
975            Anyway the signal bitmap info is available from "status".  */
976           if (*p)
977             printf_filtered (_("Kernel stack pointer: %s\n"),
978                              hex_string (strtoulst (p, &p, 10)));
979           if (*p)
980             printf_filtered (_("Kernel instr pointer: %s\n"),
981                              hex_string (strtoulst (p, &p, 10)));
982           if (*p)
983             printf_filtered (_("Pending signals bitmap: %s\n"),
984                              hex_string (strtoulst (p, &p, 10)));
985           if (*p)
986             printf_filtered (_("Blocked signals bitmap: %s\n"),
987                              hex_string (strtoulst (p, &p, 10)));
988           if (*p)
989             printf_filtered (_("Ignored signals bitmap: %s\n"),
990                              hex_string (strtoulst (p, &p, 10)));
991           if (*p)
992             printf_filtered (_("Catched signals bitmap: %s\n"),
993                              hex_string (strtoulst (p, &p, 10)));
994           if (*p)
995             printf_filtered (_("wchan (system call): %s\n"),
996                              hex_string (strtoulst (p, &p, 10)));
997 #endif
998         }
999       else
1000         warning (_("unable to open /proc file '%s'"), filename);
1001     }
1002 }
1003
1004 /* Implement "info proc mappings" for a corefile.  */
1005
1006 static void
1007 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1008 {
1009   asection *section;
1010   ULONGEST count, page_size;
1011   unsigned char *descdata, *filenames, *descend;
1012   size_t note_size;
1013   unsigned int addr_size_bits, addr_size;
1014   struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
1015   /* We assume this for reading 64-bit core files.  */
1016   gdb_static_assert (sizeof (ULONGEST) >= 8);
1017
1018   section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
1019   if (section == NULL)
1020     {
1021       warning (_("unable to find mappings in core file"));
1022       return;
1023     }
1024
1025   addr_size_bits = gdbarch_addr_bit (core_gdbarch);
1026   addr_size = addr_size_bits / 8;
1027   note_size = bfd_get_section_size (section);
1028
1029   if (note_size < 2 * addr_size)
1030     error (_("malformed core note - too short for header"));
1031
1032   gdb::def_vector<unsigned char> contents (note_size);
1033   if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1034                                  0, note_size))
1035     error (_("could not get core note contents"));
1036
1037   descdata = contents.data ();
1038   descend = descdata + note_size;
1039
1040   if (descdata[note_size - 1] != '\0')
1041     error (_("malformed note - does not end with \\0"));
1042
1043   count = bfd_get (addr_size_bits, core_bfd, descdata);
1044   descdata += addr_size;
1045
1046   page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1047   descdata += addr_size;
1048
1049   if (note_size < 2 * addr_size + count * 3 * addr_size)
1050     error (_("malformed note - too short for supplied file count"));
1051
1052   printf_filtered (_("Mapped address spaces:\n\n"));
1053   if (gdbarch_addr_bit (gdbarch) == 32)
1054     {
1055       printf_filtered ("\t%10s %10s %10s %10s %s\n",
1056                        "Start Addr",
1057                        "  End Addr",
1058                        "      Size", "    Offset", "objfile");
1059     }
1060   else
1061     {
1062       printf_filtered ("  %18s %18s %10s %10s %s\n",
1063                        "Start Addr",
1064                        "  End Addr",
1065                        "      Size", "    Offset", "objfile");
1066     }
1067
1068   filenames = descdata + count * 3 * addr_size;
1069   while (--count > 0)
1070     {
1071       ULONGEST start, end, file_ofs;
1072
1073       if (filenames == descend)
1074         error (_("malformed note - filenames end too early"));
1075
1076       start = bfd_get (addr_size_bits, core_bfd, descdata);
1077       descdata += addr_size;
1078       end = bfd_get (addr_size_bits, core_bfd, descdata);
1079       descdata += addr_size;
1080       file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1081       descdata += addr_size;
1082
1083       file_ofs *= page_size;
1084
1085       if (gdbarch_addr_bit (gdbarch) == 32)
1086         printf_filtered ("\t%10s %10s %10s %10s %s\n",
1087                          paddress (gdbarch, start),
1088                          paddress (gdbarch, end),
1089                          hex_string (end - start),
1090                          hex_string (file_ofs),
1091                          filenames);
1092       else
1093         printf_filtered ("  %18s %18s %10s %10s %s\n",
1094                          paddress (gdbarch, start),
1095                          paddress (gdbarch, end),
1096                          hex_string (end - start),
1097                          hex_string (file_ofs),
1098                          filenames);
1099
1100       filenames += 1 + strlen ((char *) filenames);
1101     }
1102 }
1103
1104 /* Implement "info proc" for a corefile.  */
1105
1106 static void
1107 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1108                       enum info_proc_what what)
1109 {
1110   int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1111   int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1112
1113   if (exe_f)
1114     {
1115       const char *exe;
1116
1117       exe = bfd_core_file_failing_command (core_bfd);
1118       if (exe != NULL)
1119         printf_filtered ("exe = '%s'\n", exe);
1120       else
1121         warning (_("unable to find command name in core file"));
1122     }
1123
1124   if (mappings_f)
1125     linux_core_info_proc_mappings (gdbarch, args);
1126
1127   if (!exe_f && !mappings_f)
1128     error (_("unable to handle request"));
1129 }
1130
1131 /* Read siginfo data from the core, if possible.  Returns -1 on
1132    failure.  Otherwise, returns the number of bytes read.  READBUF,
1133    OFFSET, and LEN are all as specified by the to_xfer_partial
1134    interface.  */
1135
1136 static LONGEST
1137 linux_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
1138                          ULONGEST offset, ULONGEST len)
1139 {
1140   thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
1141   asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
1142   if (section == NULL)
1143     return -1;
1144
1145   if (!bfd_get_section_contents (core_bfd, section, readbuf, offset, len))
1146     return -1;
1147
1148   return len;
1149 }
1150
1151 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1152                                             ULONGEST offset, ULONGEST inode,
1153                                             int read, int write,
1154                                             int exec, int modified,
1155                                             const char *filename,
1156                                             void *data);
1157
1158 /* List memory regions in the inferior for a corefile.  */
1159
1160 static int
1161 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1162                                 linux_find_memory_region_ftype *func,
1163                                 void *obfd)
1164 {
1165   char mapsfilename[100];
1166   char coredumpfilter_name[100];
1167   pid_t pid;
1168   /* Default dump behavior of coredump_filter (0x33), according to
1169      Documentation/filesystems/proc.txt from the Linux kernel
1170      tree.  */
1171   filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1172                               | COREFILTER_ANON_SHARED
1173                               | COREFILTER_ELF_HEADERS
1174                               | COREFILTER_HUGETLB_PRIVATE);
1175
1176   /* We need to know the real target PID to access /proc.  */
1177   if (current_inferior ()->fake_pid_p)
1178     return 1;
1179
1180   pid = current_inferior ()->pid;
1181
1182   if (use_coredump_filter)
1183     {
1184       xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1185                  "/proc/%d/coredump_filter", pid);
1186       gdb::unique_xmalloc_ptr<char> coredumpfilterdata
1187         = target_fileio_read_stralloc (NULL, coredumpfilter_name);
1188       if (coredumpfilterdata != NULL)
1189         {
1190           unsigned int flags;
1191
1192           sscanf (coredumpfilterdata.get (), "%x", &flags);
1193           filterflags = (enum filter_flag) flags;
1194         }
1195     }
1196
1197   xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1198   gdb::unique_xmalloc_ptr<char> data
1199     = target_fileio_read_stralloc (NULL, mapsfilename);
1200   if (data == NULL)
1201     {
1202       /* Older Linux kernels did not support /proc/PID/smaps.  */
1203       xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1204       data = target_fileio_read_stralloc (NULL, mapsfilename);
1205     }
1206
1207   if (data != NULL)
1208     {
1209       char *line, *t;
1210
1211       line = strtok_r (data.get (), "\n", &t);
1212       while (line != NULL)
1213         {
1214           ULONGEST addr, endaddr, offset, inode;
1215           const char *permissions, *device, *filename;
1216           struct smaps_vmflags v;
1217           size_t permissions_len, device_len;
1218           int read, write, exec, priv;
1219           int has_anonymous = 0;
1220           int should_dump_p = 0;
1221           int mapping_anon_p;
1222           int mapping_file_p;
1223
1224           memset (&v, 0, sizeof (v));
1225           read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1226                         &offset, &device, &device_len, &inode, &filename);
1227           mapping_anon_p = mapping_is_anonymous_p (filename);
1228           /* If the mapping is not anonymous, then we can consider it
1229              to be file-backed.  These two states (anonymous or
1230              file-backed) seem to be exclusive, but they can actually
1231              coexist.  For example, if a file-backed mapping has
1232              "Anonymous:" pages (see more below), then the Linux
1233              kernel will dump this mapping when the user specified
1234              that she only wants anonymous mappings in the corefile
1235              (*even* when she explicitly disabled the dumping of
1236              file-backed mappings).  */
1237           mapping_file_p = !mapping_anon_p;
1238
1239           /* Decode permissions.  */
1240           read = (memchr (permissions, 'r', permissions_len) != 0);
1241           write = (memchr (permissions, 'w', permissions_len) != 0);
1242           exec = (memchr (permissions, 'x', permissions_len) != 0);
1243           /* 'private' here actually means VM_MAYSHARE, and not
1244              VM_SHARED.  In order to know if a mapping is really
1245              private or not, we must check the flag "sh" in the
1246              VmFlags field.  This is done by decode_vmflags.  However,
1247              if we are using a Linux kernel released before the commit
1248              834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1249              not have the VmFlags there.  In this case, there is
1250              really no way to know if we are dealing with VM_SHARED,
1251              so we just assume that VM_MAYSHARE is enough.  */
1252           priv = memchr (permissions, 'p', permissions_len) != 0;
1253
1254           /* Try to detect if region should be dumped by parsing smaps
1255              counters.  */
1256           for (line = strtok_r (NULL, "\n", &t);
1257                line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1258                line = strtok_r (NULL, "\n", &t))
1259             {
1260               char keyword[64 + 1];
1261
1262               if (sscanf (line, "%64s", keyword) != 1)
1263                 {
1264                   warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1265                   break;
1266                 }
1267
1268               if (strcmp (keyword, "Anonymous:") == 0)
1269                 {
1270                   /* Older Linux kernels did not support the
1271                      "Anonymous:" counter.  Check it here.  */
1272                   has_anonymous = 1;
1273                 }
1274               else if (strcmp (keyword, "VmFlags:") == 0)
1275                 decode_vmflags (line, &v);
1276
1277               if (strcmp (keyword, "AnonHugePages:") == 0
1278                   || strcmp (keyword, "Anonymous:") == 0)
1279                 {
1280                   unsigned long number;
1281
1282                   if (sscanf (line, "%*s%lu", &number) != 1)
1283                     {
1284                       warning (_("Error parsing {s,}maps file '%s' number"),
1285                                mapsfilename);
1286                       break;
1287                     }
1288                   if (number > 0)
1289                     {
1290                       /* Even if we are dealing with a file-backed
1291                          mapping, if it contains anonymous pages we
1292                          consider it to be *also* an anonymous
1293                          mapping, because this is what the Linux
1294                          kernel does:
1295
1296                          // Dump segments that have been written to.
1297                          if (vma->anon_vma && FILTER(ANON_PRIVATE))
1298                                 goto whole;
1299
1300                          Note that if the mapping is already marked as
1301                          file-backed (i.e., mapping_file_p is
1302                          non-zero), then this is a special case, and
1303                          this mapping will be dumped either when the
1304                          user wants to dump file-backed *or* anonymous
1305                          mappings.  */
1306                       mapping_anon_p = 1;
1307                     }
1308                 }
1309             }
1310
1311           if (has_anonymous)
1312             should_dump_p = dump_mapping_p (filterflags, &v, priv,
1313                                             mapping_anon_p, mapping_file_p,
1314                                             filename);
1315           else
1316             {
1317               /* Older Linux kernels did not support the "Anonymous:" counter.
1318                  If it is missing, we can't be sure - dump all the pages.  */
1319               should_dump_p = 1;
1320             }
1321
1322           /* Invoke the callback function to create the corefile segment.  */
1323           if (should_dump_p)
1324             func (addr, endaddr - addr, offset, inode,
1325                   read, write, exec, 1, /* MODIFIED is true because we
1326                                            want to dump the mapping.  */
1327                   filename, obfd);
1328         }
1329
1330       return 0;
1331     }
1332
1333   return 1;
1334 }
1335
1336 /* A structure for passing information through
1337    linux_find_memory_regions_full.  */
1338
1339 struct linux_find_memory_regions_data
1340 {
1341   /* The original callback.  */
1342
1343   find_memory_region_ftype func;
1344
1345   /* The original datum.  */
1346
1347   void *obfd;
1348 };
1349
1350 /* A callback for linux_find_memory_regions that converts between the
1351    "full"-style callback and find_memory_region_ftype.  */
1352
1353 static int
1354 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1355                                  ULONGEST offset, ULONGEST inode,
1356                                  int read, int write, int exec, int modified,
1357                                  const char *filename, void *arg)
1358 {
1359   struct linux_find_memory_regions_data *data
1360     = (struct linux_find_memory_regions_data *) arg;
1361
1362   return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1363 }
1364
1365 /* A variant of linux_find_memory_regions_full that is suitable as the
1366    gdbarch find_memory_regions method.  */
1367
1368 static int
1369 linux_find_memory_regions (struct gdbarch *gdbarch,
1370                            find_memory_region_ftype func, void *obfd)
1371 {
1372   struct linux_find_memory_regions_data data;
1373
1374   data.func = func;
1375   data.obfd = obfd;
1376
1377   return linux_find_memory_regions_full (gdbarch,
1378                                          linux_find_memory_regions_thunk,
1379                                          &data);
1380 }
1381
1382 /* Determine which signal stopped execution.  */
1383
1384 static int
1385 find_signalled_thread (struct thread_info *info, void *data)
1386 {
1387   if (info->suspend.stop_signal != GDB_SIGNAL_0
1388       && info->ptid.pid () == inferior_ptid.pid ())
1389     return 1;
1390
1391   return 0;
1392 }
1393
1394 /* Generate corefile notes for SPU contexts.  */
1395
1396 static char *
1397 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1398 {
1399   static const char *spu_files[] =
1400     {
1401       "object-id",
1402       "mem",
1403       "regs",
1404       "fpcr",
1405       "lslr",
1406       "decr",
1407       "decr_status",
1408       "signal1",
1409       "signal1_type",
1410       "signal2",
1411       "signal2_type",
1412       "event_mask",
1413       "event_status",
1414       "mbox_info",
1415       "ibox_info",
1416       "wbox_info",
1417       "dma_info",
1418       "proxydma_info",
1419    };
1420
1421   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1422
1423   /* Determine list of SPU ids.  */
1424   gdb::optional<gdb::byte_vector>
1425     spu_ids = target_read_alloc (current_top_target (),
1426                                  TARGET_OBJECT_SPU, NULL);
1427
1428   if (!spu_ids)
1429     return note_data;
1430
1431   /* Generate corefile notes for each SPU file.  */
1432   for (size_t i = 0; i < spu_ids->size (); i += 4)
1433     {
1434       int fd = extract_unsigned_integer (spu_ids->data () + i, 4, byte_order);
1435
1436       for (size_t j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1437         {
1438           char annex[32], note_name[32];
1439
1440           xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1441           gdb::optional<gdb::byte_vector> spu_data
1442             = target_read_alloc (current_top_target (), TARGET_OBJECT_SPU, annex);
1443
1444           if (spu_data && !spu_data->empty ())
1445             {
1446               xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1447               note_data = elfcore_write_note (obfd, note_data, note_size,
1448                                               note_name, NT_SPU,
1449                                               spu_data->data (),
1450                                               spu_data->size ());
1451
1452               if (!note_data)
1453                 return nullptr;
1454             }
1455         }
1456     }
1457
1458   return note_data;
1459 }
1460
1461 /* This is used to pass information from
1462    linux_make_mappings_corefile_notes through
1463    linux_find_memory_regions_full.  */
1464
1465 struct linux_make_mappings_data
1466 {
1467   /* Number of files mapped.  */
1468   ULONGEST file_count;
1469
1470   /* The obstack for the main part of the data.  */
1471   struct obstack *data_obstack;
1472
1473   /* The filename obstack.  */
1474   struct obstack *filename_obstack;
1475
1476   /* The architecture's "long" type.  */
1477   struct type *long_type;
1478 };
1479
1480 static linux_find_memory_region_ftype linux_make_mappings_callback;
1481
1482 /* A callback for linux_find_memory_regions_full that updates the
1483    mappings data for linux_make_mappings_corefile_notes.  */
1484
1485 static int
1486 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1487                               ULONGEST offset, ULONGEST inode,
1488                               int read, int write, int exec, int modified,
1489                               const char *filename, void *data)
1490 {
1491   struct linux_make_mappings_data *map_data
1492     = (struct linux_make_mappings_data *) data;
1493   gdb_byte buf[sizeof (ULONGEST)];
1494
1495   if (*filename == '\0' || inode == 0)
1496     return 0;
1497
1498   ++map_data->file_count;
1499
1500   pack_long (buf, map_data->long_type, vaddr);
1501   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1502   pack_long (buf, map_data->long_type, vaddr + size);
1503   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1504   pack_long (buf, map_data->long_type, offset);
1505   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1506
1507   obstack_grow_str0 (map_data->filename_obstack, filename);
1508
1509   return 0;
1510 }
1511
1512 /* Write the file mapping data to the core file, if possible.  OBFD is
1513    the output BFD.  NOTE_DATA is the current note data, and NOTE_SIZE
1514    is a pointer to the note size.  Returns the new NOTE_DATA and
1515    updates NOTE_SIZE.  */
1516
1517 static char *
1518 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1519                                     char *note_data, int *note_size)
1520 {
1521   struct linux_make_mappings_data mapping_data;
1522   struct type *long_type
1523     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1524   gdb_byte buf[sizeof (ULONGEST)];
1525
1526   auto_obstack data_obstack, filename_obstack;
1527
1528   mapping_data.file_count = 0;
1529   mapping_data.data_obstack = &data_obstack;
1530   mapping_data.filename_obstack = &filename_obstack;
1531   mapping_data.long_type = long_type;
1532
1533   /* Reserve space for the count.  */
1534   obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1535   /* We always write the page size as 1 since we have no good way to
1536      determine the correct value.  */
1537   pack_long (buf, long_type, 1);
1538   obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1539
1540   linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1541                                   &mapping_data);
1542
1543   if (mapping_data.file_count != 0)
1544     {
1545       /* Write the count to the obstack.  */
1546       pack_long ((gdb_byte *) obstack_base (&data_obstack),
1547                  long_type, mapping_data.file_count);
1548
1549       /* Copy the filenames to the data obstack.  */
1550       int size = obstack_object_size (&filename_obstack);
1551       obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1552                     size);
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 supply_size,
1584                                  int collect_size, const struct regset *regset,
1585                                  const char *human_name, void *cb_data)
1586 {
1587   struct linux_collect_regset_section_cb_data *data
1588     = (struct linux_collect_regset_section_cb_data *) cb_data;
1589   bool variable_size_section = (regset != NULL
1590                                 && regset->flags & REGSET_VARIABLE_SIZE);
1591
1592   if (!variable_size_section)
1593     gdb_assert (supply_size == collect_size);
1594
1595   if (data->abort_iteration)
1596     return;
1597
1598   gdb_assert (regset && regset->collect_regset);
1599
1600   /* This is intentionally zero-initialized by using std::vector, so
1601      that any padding bytes in the core file will show as 0.  */
1602   std::vector<gdb_byte> buf (collect_size);
1603
1604   regset->collect_regset (regset, data->regcache, -1, buf.data (),
1605                           collect_size);
1606
1607   /* PRSTATUS still needs to be treated specially.  */
1608   if (strcmp (sect_name, ".reg") == 0)
1609     data->note_data = (char *) elfcore_write_prstatus
1610       (data->obfd, data->note_data, data->note_size, data->lwp,
1611        gdb_signal_to_host (data->stop_signal), buf.data ());
1612   else
1613     data->note_data = (char *) elfcore_write_register_note
1614       (data->obfd, data->note_data, data->note_size,
1615        sect_name, buf.data (), collect_size);
1616
1617   if (data->note_data == NULL)
1618     data->abort_iteration = 1;
1619 }
1620
1621 /* Records the thread's register state for the corefile note
1622    section.  */
1623
1624 static char *
1625 linux_collect_thread_registers (const struct regcache *regcache,
1626                                 ptid_t ptid, bfd *obfd,
1627                                 char *note_data, int *note_size,
1628                                 enum gdb_signal stop_signal)
1629 {
1630   struct gdbarch *gdbarch = regcache->arch ();
1631   struct linux_collect_regset_section_cb_data data;
1632
1633   data.gdbarch = gdbarch;
1634   data.regcache = regcache;
1635   data.obfd = obfd;
1636   data.note_data = note_data;
1637   data.note_size = note_size;
1638   data.stop_signal = stop_signal;
1639   data.abort_iteration = 0;
1640
1641   /* For remote targets the LWP may not be available, so use the TID.  */
1642   data.lwp = ptid.lwp ();
1643   if (!data.lwp)
1644     data.lwp = ptid.tid ();
1645
1646   gdbarch_iterate_over_regset_sections (gdbarch,
1647                                         linux_collect_regset_section_cb,
1648                                         &data, regcache);
1649   return data.note_data;
1650 }
1651
1652 /* Fetch the siginfo data for the specified thread, if it exists.  If
1653    there is no data, or we could not read it, return an empty
1654    buffer.  */
1655
1656 static gdb::byte_vector
1657 linux_get_siginfo_data (thread_info *thread, struct gdbarch *gdbarch)
1658 {
1659   struct type *siginfo_type;
1660   LONGEST bytes_read;
1661
1662   if (!gdbarch_get_siginfo_type_p (gdbarch))
1663     return gdb::byte_vector ();
1664
1665   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1666   inferior_ptid = thread->ptid;
1667
1668   siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1669
1670   gdb::byte_vector buf (TYPE_LENGTH (siginfo_type));
1671
1672   bytes_read = target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
1673                             buf.data (), 0, TYPE_LENGTH (siginfo_type));
1674   if (bytes_read != TYPE_LENGTH (siginfo_type))
1675     buf.clear ();
1676
1677   return buf;
1678 }
1679
1680 struct linux_corefile_thread_data
1681 {
1682   struct gdbarch *gdbarch;
1683   bfd *obfd;
1684   char *note_data;
1685   int *note_size;
1686   enum gdb_signal stop_signal;
1687 };
1688
1689 /* Records the thread's register state for the corefile note
1690    section.  */
1691
1692 static void
1693 linux_corefile_thread (struct thread_info *info,
1694                        struct linux_corefile_thread_data *args)
1695 {
1696   struct regcache *regcache;
1697
1698   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1699
1700   target_fetch_registers (regcache, -1);
1701   gdb::byte_vector siginfo_data = linux_get_siginfo_data (info, args->gdbarch);
1702
1703   args->note_data = linux_collect_thread_registers
1704     (regcache, info->ptid, args->obfd, args->note_data,
1705      args->note_size, args->stop_signal);
1706
1707   /* Don't return anything if we got no register information above,
1708      such a core file is useless.  */
1709   if (args->note_data != NULL)
1710     if (!siginfo_data.empty ())
1711       args->note_data = elfcore_write_note (args->obfd,
1712                                             args->note_data,
1713                                             args->note_size,
1714                                             "CORE", NT_SIGINFO,
1715                                             siginfo_data.data (),
1716                                             siginfo_data.size ());
1717 }
1718
1719 /* Fill the PRPSINFO structure with information about the process being
1720    debugged.  Returns 1 in case of success, 0 for failures.  Please note that
1721    even if the structure cannot be entirely filled (e.g., GDB was unable to
1722    gather information about the process UID/GID), this function will still
1723    return 1 since some information was already recorded.  It will only return
1724    0 iff nothing can be gathered.  */
1725
1726 static int
1727 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1728 {
1729   /* The filename which we will use to obtain some info about the process.
1730      We will basically use this to store the `/proc/PID/FILENAME' file.  */
1731   char filename[100];
1732   /* The basename of the executable.  */
1733   const char *basename;
1734   const char *infargs;
1735   /* Temporary buffer.  */
1736   char *tmpstr;
1737   /* The valid states of a process, according to the Linux kernel.  */
1738   const char valid_states[] = "RSDTZW";
1739   /* The program state.  */
1740   const char *prog_state;
1741   /* The state of the process.  */
1742   char pr_sname;
1743   /* The PID of the program which generated the corefile.  */
1744   pid_t pid;
1745   /* Process flags.  */
1746   unsigned int pr_flag;
1747   /* Process nice value.  */
1748   long pr_nice;
1749   /* The number of fields read by `sscanf'.  */
1750   int n_fields = 0;
1751
1752   gdb_assert (p != NULL);
1753
1754   /* Obtaining PID and filename.  */
1755   pid = inferior_ptid.pid ();
1756   xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1757   /* The full name of the program which generated the corefile.  */
1758   gdb::unique_xmalloc_ptr<char> fname
1759     = target_fileio_read_stralloc (NULL, filename);
1760
1761   if (fname == NULL || fname.get ()[0] == '\0')
1762     {
1763       /* No program name was read, so we won't be able to retrieve more
1764          information about the process.  */
1765       return 0;
1766     }
1767
1768   memset (p, 0, sizeof (*p));
1769
1770   /* Defining the PID.  */
1771   p->pr_pid = pid;
1772
1773   /* Copying the program name.  Only the basename matters.  */
1774   basename = lbasename (fname.get ());
1775   strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1776   p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1777
1778   infargs = get_inferior_args ();
1779
1780   /* The arguments of the program.  */
1781   std::string psargs = fname.get ();
1782   if (infargs != NULL)
1783     psargs = psargs + " " + infargs;
1784
1785   strncpy (p->pr_psargs, psargs.c_str (), sizeof (p->pr_psargs));
1786   p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1787
1788   xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1789   /* The contents of `/proc/PID/stat'.  */
1790   gdb::unique_xmalloc_ptr<char> proc_stat_contents
1791     = target_fileio_read_stralloc (NULL, filename);
1792   char *proc_stat = proc_stat_contents.get ();
1793
1794   if (proc_stat == NULL || *proc_stat == '\0')
1795     {
1796       /* Despite being unable to read more information about the
1797          process, we return 1 here because at least we have its
1798          command line, PID and arguments.  */
1799       return 1;
1800     }
1801
1802   /* Ok, we have the stats.  It's time to do a little parsing of the
1803      contents of the buffer, so that we end up reading what we want.
1804
1805      The following parsing mechanism is strongly based on the
1806      information generated by the `fs/proc/array.c' file, present in
1807      the Linux kernel tree.  More details about how the information is
1808      displayed can be obtained by seeing the manpage of proc(5),
1809      specifically under the entry of `/proc/[pid]/stat'.  */
1810
1811   /* Getting rid of the PID, since we already have it.  */
1812   while (isdigit (*proc_stat))
1813     ++proc_stat;
1814
1815   proc_stat = skip_spaces (proc_stat);
1816
1817   /* ps command also relies on no trailing fields ever contain ')'.  */
1818   proc_stat = strrchr (proc_stat, ')');
1819   if (proc_stat == NULL)
1820     return 1;
1821   proc_stat++;
1822
1823   proc_stat = skip_spaces (proc_stat);
1824
1825   n_fields = sscanf (proc_stat,
1826                      "%c"               /* Process state.  */
1827                      "%d%d%d"           /* Parent PID, group ID, session ID.  */
1828                      "%*d%*d"           /* tty_nr, tpgid (not used).  */
1829                      "%u"               /* Flags.  */
1830                      "%*s%*s%*s%*s"     /* minflt, cminflt, majflt,
1831                                            cmajflt (not used).  */
1832                      "%*s%*s%*s%*s"     /* utime, stime, cutime,
1833                                            cstime (not used).  */
1834                      "%*s"              /* Priority (not used).  */
1835                      "%ld",             /* Nice.  */
1836                      &pr_sname,
1837                      &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1838                      &pr_flag,
1839                      &pr_nice);
1840
1841   if (n_fields != 6)
1842     {
1843       /* Again, we couldn't read the complementary information about
1844          the process state.  However, we already have minimal
1845          information, so we just return 1 here.  */
1846       return 1;
1847     }
1848
1849   /* Filling the structure fields.  */
1850   prog_state = strchr (valid_states, pr_sname);
1851   if (prog_state != NULL)
1852     p->pr_state = prog_state - valid_states;
1853   else
1854     {
1855       /* Zero means "Running".  */
1856       p->pr_state = 0;
1857     }
1858
1859   p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1860   p->pr_zomb = p->pr_sname == 'Z';
1861   p->pr_nice = pr_nice;
1862   p->pr_flag = pr_flag;
1863
1864   /* Finally, obtaining the UID and GID.  For that, we read and parse the
1865      contents of the `/proc/PID/status' file.  */
1866   xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1867   /* The contents of `/proc/PID/status'.  */
1868   gdb::unique_xmalloc_ptr<char> proc_status_contents
1869     = target_fileio_read_stralloc (NULL, filename);
1870   char *proc_status = proc_status_contents.get ();
1871
1872   if (proc_status == NULL || *proc_status == '\0')
1873     {
1874       /* Returning 1 since we already have a bunch of information.  */
1875       return 1;
1876     }
1877
1878   /* Extracting the UID.  */
1879   tmpstr = strstr (proc_status, "Uid:");
1880   if (tmpstr != NULL)
1881     {
1882       /* Advancing the pointer to the beginning of the UID.  */
1883       tmpstr += sizeof ("Uid:");
1884       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1885         ++tmpstr;
1886
1887       if (isdigit (*tmpstr))
1888         p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1889     }
1890
1891   /* Extracting the GID.  */
1892   tmpstr = strstr (proc_status, "Gid:");
1893   if (tmpstr != NULL)
1894     {
1895       /* Advancing the pointer to the beginning of the GID.  */
1896       tmpstr += sizeof ("Gid:");
1897       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1898         ++tmpstr;
1899
1900       if (isdigit (*tmpstr))
1901         p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1902     }
1903
1904   return 1;
1905 }
1906
1907 /* Build the note section for a corefile, and return it in a malloc
1908    buffer.  */
1909
1910 static char *
1911 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1912 {
1913   struct linux_corefile_thread_data thread_args;
1914   struct elf_internal_linux_prpsinfo prpsinfo;
1915   char *note_data = NULL;
1916   struct thread_info *curr_thr, *signalled_thr;
1917
1918   if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1919     return NULL;
1920
1921   if (linux_fill_prpsinfo (&prpsinfo))
1922     {
1923       if (gdbarch_ptr_bit (gdbarch) == 64)
1924         note_data = elfcore_write_linux_prpsinfo64 (obfd,
1925                                                     note_data, note_size,
1926                                                     &prpsinfo);
1927       else
1928         note_data = elfcore_write_linux_prpsinfo32 (obfd,
1929                                                     note_data, note_size,
1930                                                     &prpsinfo);
1931     }
1932
1933   /* Thread register information.  */
1934   TRY
1935     {
1936       update_thread_list ();
1937     }
1938   CATCH (e, RETURN_MASK_ERROR)
1939     {
1940       exception_print (gdb_stderr, e);
1941     }
1942   END_CATCH
1943
1944   /* Like the kernel, prefer dumping the signalled thread first.
1945      "First thread" is what tools use to infer the signalled thread.
1946      In case there's more than one signalled thread, prefer the
1947      current thread, if it is signalled.  */
1948   curr_thr = inferior_thread ();
1949   if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
1950     signalled_thr = curr_thr;
1951   else
1952     {
1953       signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
1954       if (signalled_thr == NULL)
1955         signalled_thr = curr_thr;
1956     }
1957
1958   thread_args.gdbarch = gdbarch;
1959   thread_args.obfd = obfd;
1960   thread_args.note_data = note_data;
1961   thread_args.note_size = note_size;
1962   thread_args.stop_signal = signalled_thr->suspend.stop_signal;
1963
1964   linux_corefile_thread (signalled_thr, &thread_args);
1965   for (thread_info *thr : current_inferior ()->non_exited_threads ())
1966     {
1967       if (thr == signalled_thr)
1968         continue;
1969
1970       linux_corefile_thread (thr, &thread_args);
1971     }
1972
1973   note_data = thread_args.note_data;
1974   if (!note_data)
1975     return NULL;
1976
1977   /* Auxillary vector.  */
1978   gdb::optional<gdb::byte_vector> auxv =
1979     target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV, NULL);
1980   if (auxv && !auxv->empty ())
1981     {
1982       note_data = elfcore_write_note (obfd, note_data, note_size,
1983                                       "CORE", NT_AUXV, auxv->data (),
1984                                       auxv->size ());
1985
1986       if (!note_data)
1987         return NULL;
1988     }
1989
1990   /* SPU information.  */
1991   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1992   if (!note_data)
1993     return NULL;
1994
1995   /* File mappings.  */
1996   note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1997                                                   note_data, note_size);
1998
1999   return note_data;
2000 }
2001
2002 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2003    gdbarch.h.  This function is not static because it is exported to
2004    other -tdep files.  */
2005
2006 enum gdb_signal
2007 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2008 {
2009   switch (signal)
2010     {
2011     case 0:
2012       return GDB_SIGNAL_0;
2013
2014     case LINUX_SIGHUP:
2015       return GDB_SIGNAL_HUP;
2016
2017     case LINUX_SIGINT:
2018       return GDB_SIGNAL_INT;
2019
2020     case LINUX_SIGQUIT:
2021       return GDB_SIGNAL_QUIT;
2022
2023     case LINUX_SIGILL:
2024       return GDB_SIGNAL_ILL;
2025
2026     case LINUX_SIGTRAP:
2027       return GDB_SIGNAL_TRAP;
2028
2029     case LINUX_SIGABRT:
2030       return GDB_SIGNAL_ABRT;
2031
2032     case LINUX_SIGBUS:
2033       return GDB_SIGNAL_BUS;
2034
2035     case LINUX_SIGFPE:
2036       return GDB_SIGNAL_FPE;
2037
2038     case LINUX_SIGKILL:
2039       return GDB_SIGNAL_KILL;
2040
2041     case LINUX_SIGUSR1:
2042       return GDB_SIGNAL_USR1;
2043
2044     case LINUX_SIGSEGV:
2045       return GDB_SIGNAL_SEGV;
2046
2047     case LINUX_SIGUSR2:
2048       return GDB_SIGNAL_USR2;
2049
2050     case LINUX_SIGPIPE:
2051       return GDB_SIGNAL_PIPE;
2052
2053     case LINUX_SIGALRM:
2054       return GDB_SIGNAL_ALRM;
2055
2056     case LINUX_SIGTERM:
2057       return GDB_SIGNAL_TERM;
2058
2059     case LINUX_SIGCHLD:
2060       return GDB_SIGNAL_CHLD;
2061
2062     case LINUX_SIGCONT:
2063       return GDB_SIGNAL_CONT;
2064
2065     case LINUX_SIGSTOP:
2066       return GDB_SIGNAL_STOP;
2067
2068     case LINUX_SIGTSTP:
2069       return GDB_SIGNAL_TSTP;
2070
2071     case LINUX_SIGTTIN:
2072       return GDB_SIGNAL_TTIN;
2073
2074     case LINUX_SIGTTOU:
2075       return GDB_SIGNAL_TTOU;
2076
2077     case LINUX_SIGURG:
2078       return GDB_SIGNAL_URG;
2079
2080     case LINUX_SIGXCPU:
2081       return GDB_SIGNAL_XCPU;
2082
2083     case LINUX_SIGXFSZ:
2084       return GDB_SIGNAL_XFSZ;
2085
2086     case LINUX_SIGVTALRM:
2087       return GDB_SIGNAL_VTALRM;
2088
2089     case LINUX_SIGPROF:
2090       return GDB_SIGNAL_PROF;
2091
2092     case LINUX_SIGWINCH:
2093       return GDB_SIGNAL_WINCH;
2094
2095     /* No way to differentiate between SIGIO and SIGPOLL.
2096        Therefore, we just handle the first one.  */
2097     case LINUX_SIGIO:
2098       return GDB_SIGNAL_IO;
2099
2100     case LINUX_SIGPWR:
2101       return GDB_SIGNAL_PWR;
2102
2103     case LINUX_SIGSYS:
2104       return GDB_SIGNAL_SYS;
2105
2106     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2107        therefore we have to handle them here.  */
2108     case LINUX_SIGRTMIN:
2109       return GDB_SIGNAL_REALTIME_32;
2110
2111     case LINUX_SIGRTMAX:
2112       return GDB_SIGNAL_REALTIME_64;
2113     }
2114
2115   if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2116     {
2117       int offset = signal - LINUX_SIGRTMIN + 1;
2118
2119       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2120     }
2121
2122   return GDB_SIGNAL_UNKNOWN;
2123 }
2124
2125 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2126    gdbarch.h.  This function is not static because it is exported to
2127    other -tdep files.  */
2128
2129 int
2130 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2131                             enum gdb_signal signal)
2132 {
2133   switch (signal)
2134     {
2135     case GDB_SIGNAL_0:
2136       return 0;
2137
2138     case GDB_SIGNAL_HUP:
2139       return LINUX_SIGHUP;
2140
2141     case GDB_SIGNAL_INT:
2142       return LINUX_SIGINT;
2143
2144     case GDB_SIGNAL_QUIT:
2145       return LINUX_SIGQUIT;
2146
2147     case GDB_SIGNAL_ILL:
2148       return LINUX_SIGILL;
2149
2150     case GDB_SIGNAL_TRAP:
2151       return LINUX_SIGTRAP;
2152
2153     case GDB_SIGNAL_ABRT:
2154       return LINUX_SIGABRT;
2155
2156     case GDB_SIGNAL_FPE:
2157       return LINUX_SIGFPE;
2158
2159     case GDB_SIGNAL_KILL:
2160       return LINUX_SIGKILL;
2161
2162     case GDB_SIGNAL_BUS:
2163       return LINUX_SIGBUS;
2164
2165     case GDB_SIGNAL_SEGV:
2166       return LINUX_SIGSEGV;
2167
2168     case GDB_SIGNAL_SYS:
2169       return LINUX_SIGSYS;
2170
2171     case GDB_SIGNAL_PIPE:
2172       return LINUX_SIGPIPE;
2173
2174     case GDB_SIGNAL_ALRM:
2175       return LINUX_SIGALRM;
2176
2177     case GDB_SIGNAL_TERM:
2178       return LINUX_SIGTERM;
2179
2180     case GDB_SIGNAL_URG:
2181       return LINUX_SIGURG;
2182
2183     case GDB_SIGNAL_STOP:
2184       return LINUX_SIGSTOP;
2185
2186     case GDB_SIGNAL_TSTP:
2187       return LINUX_SIGTSTP;
2188
2189     case GDB_SIGNAL_CONT:
2190       return LINUX_SIGCONT;
2191
2192     case GDB_SIGNAL_CHLD:
2193       return LINUX_SIGCHLD;
2194
2195     case GDB_SIGNAL_TTIN:
2196       return LINUX_SIGTTIN;
2197
2198     case GDB_SIGNAL_TTOU:
2199       return LINUX_SIGTTOU;
2200
2201     case GDB_SIGNAL_IO:
2202       return LINUX_SIGIO;
2203
2204     case GDB_SIGNAL_XCPU:
2205       return LINUX_SIGXCPU;
2206
2207     case GDB_SIGNAL_XFSZ:
2208       return LINUX_SIGXFSZ;
2209
2210     case GDB_SIGNAL_VTALRM:
2211       return LINUX_SIGVTALRM;
2212
2213     case GDB_SIGNAL_PROF:
2214       return LINUX_SIGPROF;
2215
2216     case GDB_SIGNAL_WINCH:
2217       return LINUX_SIGWINCH;
2218
2219     case GDB_SIGNAL_USR1:
2220       return LINUX_SIGUSR1;
2221
2222     case GDB_SIGNAL_USR2:
2223       return LINUX_SIGUSR2;
2224
2225     case GDB_SIGNAL_PWR:
2226       return LINUX_SIGPWR;
2227
2228     case GDB_SIGNAL_POLL:
2229       return LINUX_SIGPOLL;
2230
2231     /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2232        therefore we have to handle it here.  */
2233     case GDB_SIGNAL_REALTIME_32:
2234       return LINUX_SIGRTMIN;
2235
2236     /* Same comment applies to _64.  */
2237     case GDB_SIGNAL_REALTIME_64:
2238       return LINUX_SIGRTMAX;
2239     }
2240
2241   /* GDB_SIGNAL_REALTIME_33 to _64 are continuous.  */
2242   if (signal >= GDB_SIGNAL_REALTIME_33
2243       && signal <= GDB_SIGNAL_REALTIME_63)
2244     {
2245       int offset = signal - GDB_SIGNAL_REALTIME_33;
2246
2247       return LINUX_SIGRTMIN + 1 + offset;
2248     }
2249
2250   return -1;
2251 }
2252
2253 /* Helper for linux_vsyscall_range that does the real work of finding
2254    the vsyscall's address range.  */
2255
2256 static int
2257 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2258 {
2259   char filename[100];
2260   long pid;
2261
2262   if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR, &range->start) <= 0)
2263     return 0;
2264
2265   /* It doesn't make sense to access the host's /proc when debugging a
2266      core file.  Instead, look for the PT_LOAD segment that matches
2267      the vDSO.  */
2268   if (!target_has_execution)
2269     {
2270       long phdrs_size;
2271       int num_phdrs, i;
2272
2273       phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
2274       if (phdrs_size == -1)
2275         return 0;
2276
2277       gdb::unique_xmalloc_ptr<Elf_Internal_Phdr>
2278         phdrs ((Elf_Internal_Phdr *) xmalloc (phdrs_size));
2279       num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs.get ());
2280       if (num_phdrs == -1)
2281         return 0;
2282
2283       for (i = 0; i < num_phdrs; i++)
2284         if (phdrs.get ()[i].p_type == PT_LOAD
2285             && phdrs.get ()[i].p_vaddr == range->start)
2286           {
2287             range->length = phdrs.get ()[i].p_memsz;
2288             return 1;
2289           }
2290
2291       return 0;
2292     }
2293
2294   /* We need to know the real target PID to access /proc.  */
2295   if (current_inferior ()->fake_pid_p)
2296     return 0;
2297
2298   pid = current_inferior ()->pid;
2299
2300   /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2301      reading /proc/PID/maps (2).  The later identifies thread stacks
2302      in the output, which requires scanning every thread in the thread
2303      group to check whether a VMA is actually a thread's stack.  With
2304      Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2305      a few thousand threads, (1) takes a few miliseconds, while (2)
2306      takes several seconds.  Also note that "smaps", what we read for
2307      determining core dump mappings, is even slower than "maps".  */
2308   xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2309   gdb::unique_xmalloc_ptr<char> data
2310     = target_fileio_read_stralloc (NULL, filename);
2311   if (data != NULL)
2312     {
2313       char *line;
2314       char *saveptr = NULL;
2315
2316       for (line = strtok_r (data.get (), "\n", &saveptr);
2317            line != NULL;
2318            line = strtok_r (NULL, "\n", &saveptr))
2319         {
2320           ULONGEST addr, endaddr;
2321           const char *p = line;
2322
2323           addr = strtoulst (p, &p, 16);
2324           if (addr == range->start)
2325             {
2326               if (*p == '-')
2327                 p++;
2328               endaddr = strtoulst (p, &p, 16);
2329               range->length = endaddr - addr;
2330               return 1;
2331             }
2332         }
2333     }
2334   else
2335     warning (_("unable to open /proc file '%s'"), filename);
2336
2337   return 0;
2338 }
2339
2340 /* Implementation of the "vsyscall_range" gdbarch hook.  Handles
2341    caching, and defers the real work to linux_vsyscall_range_raw.  */
2342
2343 static int
2344 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2345 {
2346   struct linux_info *info = get_linux_inferior_data ();
2347
2348   if (info->vsyscall_range_p == 0)
2349     {
2350       if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2351         info->vsyscall_range_p = 1;
2352       else
2353         info->vsyscall_range_p = -1;
2354     }
2355
2356   if (info->vsyscall_range_p < 0)
2357     return 0;
2358
2359   *range = info->vsyscall_range;
2360   return 1;
2361 }
2362
2363 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2364    definitions would be dependent on compilation host.  */
2365 #define GDB_MMAP_MAP_PRIVATE    0x02            /* Changes are private.  */
2366 #define GDB_MMAP_MAP_ANONYMOUS  0x20            /* Don't use a file.  */
2367
2368 /* See gdbarch.sh 'infcall_mmap'.  */
2369
2370 static CORE_ADDR
2371 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2372 {
2373   struct objfile *objf;
2374   /* Do there still exist any Linux systems without "mmap64"?
2375      "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32.  */
2376   struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2377   struct value *addr_val;
2378   struct gdbarch *gdbarch = get_objfile_arch (objf);
2379   CORE_ADDR retval;
2380   enum
2381     {
2382       ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2383     };
2384   struct value *arg[ARG_LAST];
2385
2386   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2387                                       0);
2388   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2389   arg[ARG_LENGTH] = value_from_ulongest
2390                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2391   gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2392                         | GDB_MMAP_PROT_EXEC))
2393               == 0);
2394   arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2395   arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2396                                        GDB_MMAP_MAP_PRIVATE
2397                                        | GDB_MMAP_MAP_ANONYMOUS);
2398   arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2399   arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2400                                         0);
2401   addr_val = call_function_by_hand (mmap_val, NULL, arg);
2402   retval = value_as_address (addr_val);
2403   if (retval == (CORE_ADDR) -1)
2404     error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2405            pulongest (size));
2406   return retval;
2407 }
2408
2409 /* See gdbarch.sh 'infcall_munmap'.  */
2410
2411 static void
2412 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2413 {
2414   struct objfile *objf;
2415   struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2416   struct value *retval_val;
2417   struct gdbarch *gdbarch = get_objfile_arch (objf);
2418   LONGEST retval;
2419   enum
2420     {
2421       ARG_ADDR, ARG_LENGTH, ARG_LAST
2422     };
2423   struct value *arg[ARG_LAST];
2424
2425   arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2426                                       addr);
2427   /* Assuming sizeof (unsigned long) == sizeof (size_t).  */
2428   arg[ARG_LENGTH] = value_from_ulongest
2429                     (builtin_type (gdbarch)->builtin_unsigned_long, size);
2430   retval_val = call_function_by_hand (munmap_val, NULL, arg);
2431   retval = value_as_long (retval_val);
2432   if (retval != 0)
2433     warning (_("Failed inferior munmap call at %s for %s bytes, "
2434                "errno is changed."),
2435              hex_string (addr), pulongest (size));
2436 }
2437
2438 /* See linux-tdep.h.  */
2439
2440 CORE_ADDR
2441 linux_displaced_step_location (struct gdbarch *gdbarch)
2442 {
2443   CORE_ADDR addr;
2444   int bp_len;
2445
2446   /* Determine entry point from target auxiliary vector.  This avoids
2447      the need for symbols.  Also, when debugging a stand-alone SPU
2448      executable, entry_point_address () will point to an SPU
2449      local-store address and is thus not usable as displaced stepping
2450      location.  The auxiliary vector gets us the PowerPC-side entry
2451      point address instead.  */
2452   if (target_auxv_search (current_top_target (), AT_ENTRY, &addr) <= 0)
2453     throw_error (NOT_SUPPORTED_ERROR,
2454                  _("Cannot find AT_ENTRY auxiliary vector entry."));
2455
2456   /* Make certain that the address points at real code, and not a
2457      function descriptor.  */
2458   addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2459                                              current_top_target ());
2460
2461   /* Inferior calls also use the entry point as a breakpoint location.
2462      We don't want displaced stepping to interfere with those
2463      breakpoints, so leave space.  */
2464   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2465   addr += bp_len * 2;
2466
2467   return addr;
2468 }
2469
2470 /* Display whether the gcore command is using the
2471    /proc/PID/coredump_filter file.  */
2472
2473 static void
2474 show_use_coredump_filter (struct ui_file *file, int from_tty,
2475                           struct cmd_list_element *c, const char *value)
2476 {
2477   fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2478                             " corefiles is %s.\n"), value);
2479 }
2480
2481 /* Display whether the gcore command is dumping mappings marked with
2482    the VM_DONTDUMP flag.  */
2483
2484 static void
2485 show_dump_excluded_mappings (struct ui_file *file, int from_tty,
2486                              struct cmd_list_element *c, const char *value)
2487 {
2488   fprintf_filtered (file, _("Dumping of mappings marked with the VM_DONTDUMP"
2489                             " flag is %s.\n"), value);
2490 }
2491
2492 /* To be called from the various GDB_OSABI_LINUX handlers for the
2493    various GNU/Linux architectures and machine types.  */
2494
2495 void
2496 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2497 {
2498   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2499   set_gdbarch_info_proc (gdbarch, linux_info_proc);
2500   set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2501   set_gdbarch_core_xfer_siginfo (gdbarch, linux_core_xfer_siginfo);
2502   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2503   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2504   set_gdbarch_has_shared_address_space (gdbarch,
2505                                         linux_has_shared_address_space);
2506   set_gdbarch_gdb_signal_from_target (gdbarch,
2507                                       linux_gdb_signal_from_target);
2508   set_gdbarch_gdb_signal_to_target (gdbarch,
2509                                     linux_gdb_signal_to_target);
2510   set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2511   set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2512   set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2513   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2514 }
2515
2516 void
2517 _initialize_linux_tdep (void)
2518 {
2519   linux_gdbarch_data_handle =
2520     gdbarch_data_register_post_init (init_linux_gdbarch_data);
2521
2522   /* Set a cache per-inferior.  */
2523   linux_inferior_data
2524     = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2525   /* Observers used to invalidate the cache when needed.  */
2526   gdb::observers::inferior_exit.attach (invalidate_linux_cache_inf);
2527   gdb::observers::inferior_appeared.attach (invalidate_linux_cache_inf);
2528
2529   add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2530                            &use_coredump_filter, _("\
2531 Set whether gcore should consider /proc/PID/coredump_filter."),
2532                            _("\
2533 Show whether gcore should consider /proc/PID/coredump_filter."),
2534                            _("\
2535 Use this command to set whether gcore should consider the contents\n\
2536 of /proc/PID/coredump_filter when generating the corefile.  For more information\n\
2537 about this file, refer to the manpage of core(5)."),
2538                            NULL, show_use_coredump_filter,
2539                            &setlist, &showlist);
2540
2541   add_setshow_boolean_cmd ("dump-excluded-mappings", class_files,
2542                            &dump_excluded_mappings, _("\
2543 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2544                            _("\
2545 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2546                            _("\
2547 Use this command to set whether gcore should dump mappings marked with the\n\
2548 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile.  For\n\
2549 more information about this file, refer to the manpage of proc(5) and core(5)."),
2550                            NULL, show_dump_excluded_mappings,
2551                            &setlist, &showlist);
2552 }