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