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