1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
35 #include "observable.h"
39 #include "gdb_regex.h"
40 #include "gdbsupport/enum-flags.h"
41 #include "gdbsupport/gdb_optional.h"
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
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,
61 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
63 /* This struct is used to map flags found in the "VmFlags:" field (in
64 the /proc/<PID>/smaps file). */
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". */
72 unsigned int initialized_p
: 1;
74 /* Memory mapped I/O area (VM_IO, "io"). */
76 unsigned int io_page
: 1;
78 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
80 unsigned int uses_huge_tlb
: 1;
82 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
84 unsigned int exclude_coredump
: 1;
86 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
88 unsigned int shared_mapping
: 1;
91 /* Whether to take the /proc/PID/coredump_filter into account when
92 generating a corefile. */
94 static bool use_coredump_filter
= true;
96 /* Whether the value of smaps_vmflags->exclude_coredump should be
97 ignored, including mappings marked with the VM_DONTDUMP flag in
99 static bool dump_excluded_mappings
= false;
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.
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.
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.
121 As stated above, this enum is derived from
122 <include/uapi/asm-generic/signal.h>, from the Linux kernel
143 LINUX_SIGSTKFLT
= 16,
153 LINUX_SIGVTALRM
= 26,
157 LINUX_SIGPOLL
= LINUX_SIGIO
,
160 LINUX_SIGUNUSED
= 31,
166 static struct gdbarch_data
*linux_gdbarch_data_handle
;
168 struct linux_gdbarch_data
170 struct type
*siginfo_type
;
174 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
176 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
179 static struct linux_gdbarch_data
*
180 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
182 return ((struct linux_gdbarch_data
*)
183 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
186 /* Linux-specific cached data. This is used by GDB for caching
187 purposes for each inferior. This helps reduce the overhead of
188 transfering data from a remote target to the local host. */
191 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
192 if VSYSCALL_RANGE_P is positive. This is cached because getting
193 at this info requires an auxv lookup (which is itself cached),
194 and looking through the inferior's mappings (which change
195 throughout execution and therefore cannot be cached). */
196 struct mem_range vsyscall_range
{};
198 /* Zero if we haven't tried looking up the vsyscall's range before
199 yet. Positive if we tried looking it up, and found it. Negative
200 if we tried looking it up but failed. */
201 int vsyscall_range_p
= 0;
204 /* Per-inferior data key. */
205 static const struct inferior_key
<linux_info
> linux_inferior_data
;
207 /* Frees whatever allocated space there is to be freed and sets INF's
208 linux cache data pointer to NULL. */
211 invalidate_linux_cache_inf (struct inferior
*inf
)
213 linux_inferior_data
.clear (inf
);
216 /* Fetch the linux cache info for INF. This function always returns a
217 valid INFO pointer. */
219 static struct linux_info
*
220 get_linux_inferior_data (void)
222 struct linux_info
*info
;
223 struct inferior
*inf
= current_inferior ();
225 info
= linux_inferior_data
.get (inf
);
227 info
= linux_inferior_data
.emplace (inf
);
232 /* See linux-tdep.h. */
235 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
236 linux_siginfo_extra_fields extra_fields
)
238 struct linux_gdbarch_data
*linux_gdbarch_data
;
239 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
240 struct type
*uid_type
, *pid_type
;
241 struct type
*sigval_type
, *clock_type
;
242 struct type
*siginfo_type
, *sifields_type
;
245 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
246 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
247 return linux_gdbarch_data
->siginfo_type
;
249 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
251 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
253 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
255 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
257 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
260 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
261 sigval_type
->set_name (xstrdup ("sigval_t"));
262 append_composite_type_field (sigval_type
, "sival_int", int_type
);
263 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
266 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
267 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
268 TYPE_TARGET_TYPE (pid_type
) = int_type
;
269 pid_type
->set_target_is_stub (true);
272 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
273 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
274 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
275 uid_type
->set_target_is_stub (true);
278 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
279 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
281 TYPE_TARGET_TYPE (clock_type
) = long_type
;
282 clock_type
->set_target_is_stub (true);
285 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
288 const int si_max_size
= 128;
290 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
293 if (gdbarch_ptr_bit (gdbarch
) == 64)
294 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
296 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
297 append_composite_type_field (sifields_type
, "_pad",
298 init_vector_type (int_type
, si_pad_size
));
302 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
303 append_composite_type_field (type
, "si_pid", pid_type
);
304 append_composite_type_field (type
, "si_uid", uid_type
);
305 append_composite_type_field (sifields_type
, "_kill", type
);
308 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
309 append_composite_type_field (type
, "si_tid", int_type
);
310 append_composite_type_field (type
, "si_overrun", int_type
);
311 append_composite_type_field (type
, "si_sigval", sigval_type
);
312 append_composite_type_field (sifields_type
, "_timer", type
);
315 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
316 append_composite_type_field (type
, "si_pid", pid_type
);
317 append_composite_type_field (type
, "si_uid", uid_type
);
318 append_composite_type_field (type
, "si_sigval", sigval_type
);
319 append_composite_type_field (sifields_type
, "_rt", type
);
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 (type
, "si_status", int_type
);
326 append_composite_type_field (type
, "si_utime", clock_type
);
327 append_composite_type_field (type
, "si_stime", clock_type
);
328 append_composite_type_field (sifields_type
, "_sigchld", type
);
331 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
332 append_composite_type_field (type
, "si_addr", void_ptr_type
);
334 /* Additional bound fields for _sigfault in case they were requested. */
335 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
337 struct type
*sigfault_bnd_fields
;
339 append_composite_type_field (type
, "_addr_lsb", short_type
);
340 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
341 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
342 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
343 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
345 append_composite_type_field (sifields_type
, "_sigfault", type
);
348 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
349 append_composite_type_field (type
, "si_band", long_type
);
350 append_composite_type_field (type
, "si_fd", int_type
);
351 append_composite_type_field (sifields_type
, "_sigpoll", type
);
354 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
355 siginfo_type
->set_name (xstrdup ("siginfo"));
356 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
357 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
358 append_composite_type_field (siginfo_type
, "si_code", int_type
);
359 append_composite_type_field_aligned (siginfo_type
,
360 "_sifields", sifields_type
,
361 TYPE_LENGTH (long_type
));
363 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
368 /* This function is suitable for architectures that don't
369 extend/override the standard siginfo structure. */
372 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
374 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
377 /* Return true if the target is running on uClinux instead of normal
381 linux_is_uclinux (void)
385 return (target_auxv_search (current_top_target (), AT_NULL
, &dummy
) > 0
386 && target_auxv_search (current_top_target (), AT_PAGESZ
, &dummy
) == 0);
390 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
392 return linux_is_uclinux ();
395 /* This is how we want PTIDs from core files to be printed. */
398 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
400 if (ptid
.lwp () != 0)
401 return string_printf ("LWP %ld", ptid
.lwp ());
403 return normal_pid_to_str (ptid
);
406 /* Service function for corefiles and info proc. */
409 read_mapping (const char *line
,
410 ULONGEST
*addr
, ULONGEST
*endaddr
,
411 const char **permissions
, size_t *permissions_len
,
413 const char **device
, size_t *device_len
,
415 const char **filename
)
417 const char *p
= line
;
419 *addr
= strtoulst (p
, &p
, 16);
422 *endaddr
= strtoulst (p
, &p
, 16);
426 while (*p
&& !isspace (*p
))
428 *permissions_len
= p
- *permissions
;
430 *offset
= strtoulst (p
, &p
, 16);
434 while (*p
&& !isspace (*p
))
436 *device_len
= p
- *device
;
438 *inode
= strtoulst (p
, &p
, 10);
444 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
446 This function was based on the documentation found on
447 <Documentation/filesystems/proc.txt>, on the Linux kernel.
449 Linux kernels before commit
450 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
454 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
456 char *saveptr
= NULL
;
459 v
->initialized_p
= 1;
460 p
= skip_to_space (p
);
463 for (s
= strtok_r (p
, " ", &saveptr
);
465 s
= strtok_r (NULL
, " ", &saveptr
))
467 if (strcmp (s
, "io") == 0)
469 else if (strcmp (s
, "ht") == 0)
470 v
->uses_huge_tlb
= 1;
471 else if (strcmp (s
, "dd") == 0)
472 v
->exclude_coredump
= 1;
473 else if (strcmp (s
, "sh") == 0)
474 v
->shared_mapping
= 1;
478 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
479 they're initialized lazily. */
481 struct mapping_regexes
483 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
484 string in the end). We know for sure, based on the Linux kernel
485 code, that memory mappings whose associated filename is
486 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
487 compiled_regex dev_zero
488 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
489 _("Could not compile regex to match /dev/zero filename")};
491 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
492 string in the end). These filenames refer to shared memory
493 (shmem), and memory mappings associated with them are
494 MAP_ANONYMOUS as well. */
495 compiled_regex shmem_file
496 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
497 _("Could not compile regex to match shmem filenames")};
499 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
500 0' code, which is responsible to decide if it is dealing with a
501 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
502 FILE_DELETED matches, it does not necessarily mean that we are
503 dealing with an anonymous shared mapping. However, there is no
504 easy way to detect this currently, so this is the best
505 approximation we have.
507 As a result, GDB will dump readonly pages of deleted executables
508 when using the default value of coredump_filter (0x33), while the
509 Linux kernel will not dump those pages. But we can live with
511 compiled_regex file_deleted
512 {" (deleted)$", REG_NOSUB
,
513 _("Could not compile regex to match '<file> (deleted)'")};
516 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
518 FILENAME is the name of the file present in the first line of the
519 memory mapping, in the "/proc/PID/smaps" output. For example, if
522 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
524 Then FILENAME will be "/path/to/file". */
527 mapping_is_anonymous_p (const char *filename
)
529 static gdb::optional
<mapping_regexes
> regexes
;
530 static int init_regex_p
= 0;
534 /* Let's be pessimistic and assume there will be an error while
535 compiling the regex'es. */
540 /* If we reached this point, then everything succeeded. */
544 if (init_regex_p
== -1)
546 const char deleted
[] = " (deleted)";
547 size_t del_len
= sizeof (deleted
) - 1;
548 size_t filename_len
= strlen (filename
);
550 /* There was an error while compiling the regex'es above. In
551 order to try to give some reliable information to the caller,
552 we just try to find the string " (deleted)" in the filename.
553 If we managed to find it, then we assume the mapping is
555 return (filename_len
>= del_len
556 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
559 if (*filename
== '\0'
560 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
561 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
562 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
568 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
569 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
570 be dumped, or greater than 0 if it should.
572 In a nutshell, this is the logic that we follow in order to decide
573 if a mapping should be dumped or not.
575 - If the mapping is associated to a file whose name ends with
576 " (deleted)", or if the file is "/dev/zero", or if it is
577 "/SYSV%08x" (shared memory), or if there is no file associated
578 with it, or if the AnonHugePages: or the Anonymous: fields in the
579 /proc/PID/smaps have contents, then GDB considers this mapping to
580 be anonymous. Otherwise, GDB considers this mapping to be a
581 file-backed mapping (because there will be a file associated with
584 It is worth mentioning that, from all those checks described
585 above, the most fragile is the one to see if the file name ends
586 with " (deleted)". This does not necessarily mean that the
587 mapping is anonymous, because the deleted file associated with
588 the mapping may have been a hard link to another file, for
589 example. The Linux kernel checks to see if "i_nlink == 0", but
590 GDB cannot easily (and normally) do this check (iff running as
591 root, it could find the mapping in /proc/PID/map_files/ and
592 determine whether there still are other hard links to the
593 inode/file). Therefore, we made a compromise here, and we assume
594 that if the file name ends with " (deleted)", then the mapping is
595 indeed anonymous. FWIW, this is something the Linux kernel could
596 do better: expose this information in a more direct way.
598 - If we see the flag "sh" in the "VmFlags:" field (in
599 /proc/PID/smaps), then certainly the memory mapping is shared
600 (VM_SHARED). If we have access to the VmFlags, and we don't see
601 the "sh" there, then certainly the mapping is private. However,
602 Linux kernels before commit
603 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
604 "VmFlags:" field; in that case, we use another heuristic: if we
605 see 'p' in the permission flags, then we assume that the mapping
606 is private, even though the presence of the 's' flag there would
607 mean VM_MAYSHARE, which means the mapping could still be private.
608 This should work OK enough, however.
610 - Even if, at the end, we decided that we should not dump the
611 mapping, we still have to check if it is something like an ELF
612 header (of a DSO or an executable, for example). If it is, and
613 if the user is interested in dump it, then we should dump it. */
616 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
617 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
618 const char *filename
, ULONGEST addr
, ULONGEST offset
)
620 /* Initially, we trust in what we received from our caller. This
621 value may not be very precise (i.e., it was probably gathered
622 from the permission line in the /proc/PID/smaps list, which
623 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
624 what we have until we take a look at the "VmFlags:" field
625 (assuming that the version of the Linux kernel being used
626 supports it, of course). */
627 int private_p
= maybe_private_p
;
630 /* We always dump vDSO and vsyscall mappings, because it's likely that
631 there'll be no file to read the contents from at core load time.
632 The kernel does the same. */
633 if (strcmp ("[vdso]", filename
) == 0
634 || strcmp ("[vsyscall]", filename
) == 0)
637 if (v
->initialized_p
)
639 /* We never dump I/O mappings. */
643 /* Check if we should exclude this mapping. */
644 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
647 /* Update our notion of whether this mapping is shared or
648 private based on a trustworthy value. */
649 private_p
= !v
->shared_mapping
;
651 /* HugeTLB checking. */
652 if (v
->uses_huge_tlb
)
654 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
655 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
664 if (mapping_anon_p
&& mapping_file_p
)
666 /* This is a special situation. It can happen when we see a
667 mapping that is file-backed, but that contains anonymous
669 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
670 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
672 else if (mapping_anon_p
)
673 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
675 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
679 if (mapping_anon_p
&& mapping_file_p
)
681 /* This is a special situation. It can happen when we see a
682 mapping that is file-backed, but that contains anonymous
684 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
685 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
687 else if (mapping_anon_p
)
688 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
690 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
693 /* Even if we decided that we shouldn't dump this mapping, we still
694 have to check whether (a) the user wants us to dump mappings
695 containing an ELF header, and (b) the mapping in question
696 contains an ELF header. If (a) and (b) are true, then we should
699 A mapping contains an ELF header if it is a private mapping, its
700 offset is zero, and its first word is ELFMAG. */
701 if (!dump_p
&& private_p
&& offset
== 0
702 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
704 /* Useful define specifying the size of the ELF magical
710 /* Let's check if we have an ELF header. */
712 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
714 /* The EI_MAG* and ELFMAG* constants come from
716 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
717 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
719 /* This mapping contains an ELF header, so we
729 /* As above, but return true only when we should dump the NT_FILE
733 dump_note_entry_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
734 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
735 const char *filename
, ULONGEST addr
, ULONGEST offset
)
737 /* vDSO and vsyscall mappings will end up in the core file. Don't
738 put them in the NT_FILE note. */
739 if (strcmp ("[vdso]", filename
) == 0
740 || strcmp ("[vsyscall]", filename
) == 0)
743 /* Otherwise, any other file-based mapping should be placed in the
748 /* Implement the "info proc" command. */
751 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
752 enum info_proc_what what
)
754 /* A long is used for pid instead of an int to avoid a loss of precision
755 compiler warning from the output of strtoul. */
757 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
758 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
759 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
760 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
761 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
762 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
766 if (args
&& isdigit (args
[0]))
770 pid
= strtoul (args
, &tem
, 10);
775 if (!target_has_execution ())
776 error (_("No current process: you must name one."));
777 if (current_inferior ()->fake_pid_p
)
778 error (_("Can't determine the current process's PID: you must name one."));
780 pid
= current_inferior ()->pid
;
783 args
= skip_spaces (args
);
785 error (_("Too many parameters: %s"), args
);
787 printf_filtered (_("process %ld\n"), pid
);
790 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
792 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
796 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
799 for (pos
= 0; pos
< len
- 1; pos
++)
801 if (buffer
[pos
] == '\0')
804 buffer
[len
- 1] = '\0';
805 printf_filtered ("cmdline = '%s'\n", buffer
);
808 warning (_("unable to open /proc file '%s'"), filename
);
812 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
813 gdb::optional
<std::string
> contents
814 = target_fileio_readlink (NULL
, filename
, &target_errno
);
815 if (contents
.has_value ())
816 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
818 warning (_("unable to read link '%s'"), filename
);
822 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
823 gdb::optional
<std::string
> contents
824 = target_fileio_readlink (NULL
, filename
, &target_errno
);
825 if (contents
.has_value ())
826 printf_filtered ("exe = '%s'\n", contents
->c_str ());
828 warning (_("unable to read link '%s'"), filename
);
832 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
833 gdb::unique_xmalloc_ptr
<char> map
834 = target_fileio_read_stralloc (NULL
, filename
);
839 printf_filtered (_("Mapped address spaces:\n\n"));
840 if (gdbarch_addr_bit (gdbarch
) == 32)
842 printf_filtered ("\t%10s %10s %10s %10s %s\n",
845 " Size", " Offset", "objfile");
849 printf_filtered (" %18s %18s %10s %10s %s\n",
852 " Size", " Offset", "objfile");
856 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
858 line
= strtok_r (NULL
, "\n", &saveptr
))
860 ULONGEST addr
, endaddr
, offset
, inode
;
861 const char *permissions
, *device
, *mapping_filename
;
862 size_t permissions_len
, device_len
;
864 read_mapping (line
, &addr
, &endaddr
,
865 &permissions
, &permissions_len
,
866 &offset
, &device
, &device_len
,
867 &inode
, &mapping_filename
);
869 if (gdbarch_addr_bit (gdbarch
) == 32)
871 printf_filtered ("\t%10s %10s %10s %10s %s\n",
872 paddress (gdbarch
, addr
),
873 paddress (gdbarch
, endaddr
),
874 hex_string (endaddr
- addr
),
876 *mapping_filename
? mapping_filename
: "");
880 printf_filtered (" %18s %18s %10s %10s %s\n",
881 paddress (gdbarch
, addr
),
882 paddress (gdbarch
, endaddr
),
883 hex_string (endaddr
- addr
),
885 *mapping_filename
? mapping_filename
: "");
890 warning (_("unable to open /proc file '%s'"), filename
);
894 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
895 gdb::unique_xmalloc_ptr
<char> status
896 = target_fileio_read_stralloc (NULL
, filename
);
898 puts_filtered (status
.get ());
900 warning (_("unable to open /proc file '%s'"), filename
);
904 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
905 gdb::unique_xmalloc_ptr
<char> statstr
906 = target_fileio_read_stralloc (NULL
, filename
);
909 const char *p
= statstr
.get ();
911 printf_filtered (_("Process: %s\n"),
912 pulongest (strtoulst (p
, &p
, 10)));
917 /* ps command also relies on no trailing fields
919 const char *ep
= strrchr (p
, ')');
922 printf_filtered ("Exec file: %.*s\n",
923 (int) (ep
- p
- 1), p
+ 1);
930 printf_filtered (_("State: %c\n"), *p
++);
933 printf_filtered (_("Parent process: %s\n"),
934 pulongest (strtoulst (p
, &p
, 10)));
936 printf_filtered (_("Process group: %s\n"),
937 pulongest (strtoulst (p
, &p
, 10)));
939 printf_filtered (_("Session id: %s\n"),
940 pulongest (strtoulst (p
, &p
, 10)));
942 printf_filtered (_("TTY: %s\n"),
943 pulongest (strtoulst (p
, &p
, 10)));
945 printf_filtered (_("TTY owner process group: %s\n"),
946 pulongest (strtoulst (p
, &p
, 10)));
949 printf_filtered (_("Flags: %s\n"),
950 hex_string (strtoulst (p
, &p
, 10)));
952 printf_filtered (_("Minor faults (no memory page): %s\n"),
953 pulongest (strtoulst (p
, &p
, 10)));
955 printf_filtered (_("Minor faults, children: %s\n"),
956 pulongest (strtoulst (p
, &p
, 10)));
958 printf_filtered (_("Major faults (memory page faults): %s\n"),
959 pulongest (strtoulst (p
, &p
, 10)));
961 printf_filtered (_("Major faults, children: %s\n"),
962 pulongest (strtoulst (p
, &p
, 10)));
964 printf_filtered (_("utime: %s\n"),
965 pulongest (strtoulst (p
, &p
, 10)));
967 printf_filtered (_("stime: %s\n"),
968 pulongest (strtoulst (p
, &p
, 10)));
970 printf_filtered (_("utime, children: %s\n"),
971 pulongest (strtoulst (p
, &p
, 10)));
973 printf_filtered (_("stime, children: %s\n"),
974 pulongest (strtoulst (p
, &p
, 10)));
976 printf_filtered (_("jiffies remaining in current "
978 pulongest (strtoulst (p
, &p
, 10)));
980 printf_filtered (_("'nice' value: %s\n"),
981 pulongest (strtoulst (p
, &p
, 10)));
983 printf_filtered (_("jiffies until next timeout: %s\n"),
984 pulongest (strtoulst (p
, &p
, 10)));
986 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
987 pulongest (strtoulst (p
, &p
, 10)));
989 printf_filtered (_("start time (jiffies since "
990 "system boot): %s\n"),
991 pulongest (strtoulst (p
, &p
, 10)));
993 printf_filtered (_("Virtual memory size: %s\n"),
994 pulongest (strtoulst (p
, &p
, 10)));
996 printf_filtered (_("Resident set size: %s\n"),
997 pulongest (strtoulst (p
, &p
, 10)));
999 printf_filtered (_("rlim: %s\n"),
1000 pulongest (strtoulst (p
, &p
, 10)));
1002 printf_filtered (_("Start of text: %s\n"),
1003 hex_string (strtoulst (p
, &p
, 10)));
1005 printf_filtered (_("End of text: %s\n"),
1006 hex_string (strtoulst (p
, &p
, 10)));
1008 printf_filtered (_("Start of stack: %s\n"),
1009 hex_string (strtoulst (p
, &p
, 10)));
1010 #if 0 /* Don't know how architecture-dependent the rest is...
1011 Anyway the signal bitmap info is available from "status". */
1013 printf_filtered (_("Kernel stack pointer: %s\n"),
1014 hex_string (strtoulst (p
, &p
, 10)));
1016 printf_filtered (_("Kernel instr pointer: %s\n"),
1017 hex_string (strtoulst (p
, &p
, 10)));
1019 printf_filtered (_("Pending signals bitmap: %s\n"),
1020 hex_string (strtoulst (p
, &p
, 10)));
1022 printf_filtered (_("Blocked signals bitmap: %s\n"),
1023 hex_string (strtoulst (p
, &p
, 10)));
1025 printf_filtered (_("Ignored signals bitmap: %s\n"),
1026 hex_string (strtoulst (p
, &p
, 10)));
1028 printf_filtered (_("Catched signals bitmap: %s\n"),
1029 hex_string (strtoulst (p
, &p
, 10)));
1031 printf_filtered (_("wchan (system call): %s\n"),
1032 hex_string (strtoulst (p
, &p
, 10)));
1036 warning (_("unable to open /proc file '%s'"), filename
);
1040 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1043 This function reads the NT_FILE note (which BFD turns into the
1044 section ".note.linuxcore.file"). The format of this note / section
1045 is described as follows in the Linux kernel sources in
1048 long count -- how many files are mapped
1049 long page_size -- units for file_ofs
1050 array of [COUNT] elements of
1054 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1056 CBFD is the BFD of the core file.
1058 PRE_LOOP_CB is the callback function to invoke prior to starting
1059 the loop which processes individual entries. This callback will
1060 only be executed after the note has been examined in enough
1061 detail to verify that it's not malformed in some way.
1063 LOOP_CB is the callback function that will be executed once
1064 for each mapping. */
1067 linux_read_core_file_mappings (struct gdbarch
*gdbarch
,
1069 gdb::function_view
<void (ULONGEST count
)>
1071 gdb::function_view
<void (int num
,
1075 const char *filename
)>
1078 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1079 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1081 /* It's not required that the NT_FILE note exists, so return silently
1082 if it's not found. Beyond this point though, we'll complain
1083 if problems are found. */
1084 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1085 if (section
== nullptr)
1088 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1089 unsigned int addr_size
= addr_size_bits
/ 8;
1090 size_t note_size
= bfd_section_size (section
);
1092 if (note_size
< 2 * addr_size
)
1094 warning (_("malformed core note - too short for header"));
1098 gdb::def_vector
<gdb_byte
> contents (note_size
);
1099 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1102 warning (_("could not get core note contents"));
1106 gdb_byte
*descdata
= contents
.data ();
1107 char *descend
= (char *) descdata
+ note_size
;
1109 if (descdata
[note_size
- 1] != '\0')
1111 warning (_("malformed note - does not end with \\0"));
1115 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1116 descdata
+= addr_size
;
1118 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1119 descdata
+= addr_size
;
1121 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1123 warning (_("malformed note - too short for supplied file count"));
1127 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1129 /* Make sure that the correct number of filenames exist. Complain
1130 if there aren't enough or are too many. */
1131 char *f
= filenames
;
1132 for (int i
= 0; i
< count
; i
++)
1136 warning (_("malformed note - filename area is too small"));
1139 f
+= strnlen (f
, descend
- f
) + 1;
1141 /* Complain, but don't return early if the filename area is too big. */
1143 warning (_("malformed note - filename area is too big"));
1145 pre_loop_cb (count
);
1147 for (int i
= 0; i
< count
; i
++)
1149 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1150 descdata
+= addr_size
;
1151 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1152 descdata
+= addr_size
;
1154 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1155 descdata
+= addr_size
;
1156 char * filename
= filenames
;
1157 filenames
+= strlen ((char *) filenames
) + 1;
1159 loop_cb (i
, start
, end
, file_ofs
, filename
);
1163 /* Implement "info proc mappings" for a corefile. */
1166 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1168 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1169 [=] (ULONGEST count
)
1171 printf_filtered (_("Mapped address spaces:\n\n"));
1172 if (gdbarch_addr_bit (gdbarch
) == 32)
1174 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1177 " Size", " Offset", "objfile");
1181 printf_filtered (" %18s %18s %10s %10s %s\n",
1184 " Size", " Offset", "objfile");
1187 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1188 const char *filename
)
1190 if (gdbarch_addr_bit (gdbarch
) == 32)
1191 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1192 paddress (gdbarch
, start
),
1193 paddress (gdbarch
, end
),
1194 hex_string (end
- start
),
1195 hex_string (file_ofs
),
1198 printf_filtered (" %18s %18s %10s %10s %s\n",
1199 paddress (gdbarch
, start
),
1200 paddress (gdbarch
, end
),
1201 hex_string (end
- start
),
1202 hex_string (file_ofs
),
1207 /* Implement "info proc" for a corefile. */
1210 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1211 enum info_proc_what what
)
1213 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1214 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1220 exe
= bfd_core_file_failing_command (core_bfd
);
1222 printf_filtered ("exe = '%s'\n", exe
);
1224 warning (_("unable to find command name in core file"));
1228 linux_core_info_proc_mappings (gdbarch
, args
);
1230 if (!exe_f
&& !mappings_f
)
1231 error (_("unable to handle request"));
1234 /* Read siginfo data from the core, if possible. Returns -1 on
1235 failure. Otherwise, returns the number of bytes read. READBUF,
1236 OFFSET, and LEN are all as specified by the to_xfer_partial
1240 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1241 ULONGEST offset
, ULONGEST len
)
1243 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1244 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1245 if (section
== NULL
)
1248 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1254 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1255 ULONGEST offset
, ULONGEST inode
,
1256 int read
, int write
,
1257 int exec
, int modified
,
1258 const char *filename
,
1261 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags
,
1262 const struct smaps_vmflags
*v
,
1263 int maybe_private_p
,
1266 const char *filename
,
1270 /* List memory regions in the inferior for a corefile. */
1273 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1274 linux_dump_mapping_p_ftype
*should_dump_mapping_p
,
1275 linux_find_memory_region_ftype
*func
,
1278 char mapsfilename
[100];
1279 char coredumpfilter_name
[100];
1281 /* Default dump behavior of coredump_filter (0x33), according to
1282 Documentation/filesystems/proc.txt from the Linux kernel
1284 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1285 | COREFILTER_ANON_SHARED
1286 | COREFILTER_ELF_HEADERS
1287 | COREFILTER_HUGETLB_PRIVATE
);
1289 /* We need to know the real target PID to access /proc. */
1290 if (current_inferior ()->fake_pid_p
)
1293 pid
= current_inferior ()->pid
;
1295 if (use_coredump_filter
)
1297 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1298 "/proc/%d/coredump_filter", pid
);
1299 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1300 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1301 if (coredumpfilterdata
!= NULL
)
1305 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1306 filterflags
= (enum filter_flag
) flags
;
1310 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1311 gdb::unique_xmalloc_ptr
<char> data
1312 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1315 /* Older Linux kernels did not support /proc/PID/smaps. */
1316 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1317 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1324 line
= strtok_r (data
.get (), "\n", &t
);
1325 while (line
!= NULL
)
1327 ULONGEST addr
, endaddr
, offset
, inode
;
1328 const char *permissions
, *device
, *filename
;
1329 struct smaps_vmflags v
;
1330 size_t permissions_len
, device_len
;
1331 int read
, write
, exec
, priv
;
1332 int has_anonymous
= 0;
1333 int should_dump_p
= 0;
1337 memset (&v
, 0, sizeof (v
));
1338 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1339 &offset
, &device
, &device_len
, &inode
, &filename
);
1340 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1341 /* If the mapping is not anonymous, then we can consider it
1342 to be file-backed. These two states (anonymous or
1343 file-backed) seem to be exclusive, but they can actually
1344 coexist. For example, if a file-backed mapping has
1345 "Anonymous:" pages (see more below), then the Linux
1346 kernel will dump this mapping when the user specified
1347 that she only wants anonymous mappings in the corefile
1348 (*even* when she explicitly disabled the dumping of
1349 file-backed mappings). */
1350 mapping_file_p
= !mapping_anon_p
;
1352 /* Decode permissions. */
1353 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1354 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1355 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1356 /* 'private' here actually means VM_MAYSHARE, and not
1357 VM_SHARED. In order to know if a mapping is really
1358 private or not, we must check the flag "sh" in the
1359 VmFlags field. This is done by decode_vmflags. However,
1360 if we are using a Linux kernel released before the commit
1361 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1362 not have the VmFlags there. In this case, there is
1363 really no way to know if we are dealing with VM_SHARED,
1364 so we just assume that VM_MAYSHARE is enough. */
1365 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1367 /* Try to detect if region should be dumped by parsing smaps
1369 for (line
= strtok_r (NULL
, "\n", &t
);
1370 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1371 line
= strtok_r (NULL
, "\n", &t
))
1373 char keyword
[64 + 1];
1375 if (sscanf (line
, "%64s", keyword
) != 1)
1377 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1381 if (strcmp (keyword
, "Anonymous:") == 0)
1383 /* Older Linux kernels did not support the
1384 "Anonymous:" counter. Check it here. */
1387 else if (strcmp (keyword
, "VmFlags:") == 0)
1388 decode_vmflags (line
, &v
);
1390 if (strcmp (keyword
, "AnonHugePages:") == 0
1391 || strcmp (keyword
, "Anonymous:") == 0)
1393 unsigned long number
;
1395 if (sscanf (line
, "%*s%lu", &number
) != 1)
1397 warning (_("Error parsing {s,}maps file '%s' number"),
1403 /* Even if we are dealing with a file-backed
1404 mapping, if it contains anonymous pages we
1405 consider it to be *also* an anonymous
1406 mapping, because this is what the Linux
1409 // Dump segments that have been written to.
1410 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1413 Note that if the mapping is already marked as
1414 file-backed (i.e., mapping_file_p is
1415 non-zero), then this is a special case, and
1416 this mapping will be dumped either when the
1417 user wants to dump file-backed *or* anonymous
1425 should_dump_p
= should_dump_mapping_p (filterflags
, &v
, priv
,
1428 filename
, addr
, offset
);
1431 /* Older Linux kernels did not support the "Anonymous:" counter.
1432 If it is missing, we can't be sure - dump all the pages. */
1436 /* Invoke the callback function to create the corefile segment. */
1438 func (addr
, endaddr
- addr
, offset
, inode
,
1439 read
, write
, exec
, 1, /* MODIFIED is true because we
1440 want to dump the mapping. */
1450 /* A structure for passing information through
1451 linux_find_memory_regions_full. */
1453 struct linux_find_memory_regions_data
1455 /* The original callback. */
1457 find_memory_region_ftype func
;
1459 /* The original datum. */
1464 /* A callback for linux_find_memory_regions that converts between the
1465 "full"-style callback and find_memory_region_ftype. */
1468 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1469 ULONGEST offset
, ULONGEST inode
,
1470 int read
, int write
, int exec
, int modified
,
1471 const char *filename
, void *arg
)
1473 struct linux_find_memory_regions_data
*data
1474 = (struct linux_find_memory_regions_data
*) arg
;
1476 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1479 /* A variant of linux_find_memory_regions_full that is suitable as the
1480 gdbarch find_memory_regions method. */
1483 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1484 find_memory_region_ftype func
, void *obfd
)
1486 struct linux_find_memory_regions_data data
;
1491 return linux_find_memory_regions_full (gdbarch
,
1493 linux_find_memory_regions_thunk
,
1497 /* This is used to pass information from
1498 linux_make_mappings_corefile_notes through
1499 linux_find_memory_regions_full. */
1501 struct linux_make_mappings_data
1503 /* Number of files mapped. */
1504 ULONGEST file_count
;
1506 /* The obstack for the main part of the data. */
1507 struct obstack
*data_obstack
;
1509 /* The filename obstack. */
1510 struct obstack
*filename_obstack
;
1512 /* The architecture's "long" type. */
1513 struct type
*long_type
;
1516 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1518 /* A callback for linux_find_memory_regions_full that updates the
1519 mappings data for linux_make_mappings_corefile_notes. */
1522 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1523 ULONGEST offset
, ULONGEST inode
,
1524 int read
, int write
, int exec
, int modified
,
1525 const char *filename
, void *data
)
1527 struct linux_make_mappings_data
*map_data
1528 = (struct linux_make_mappings_data
*) data
;
1529 gdb_byte buf
[sizeof (ULONGEST
)];
1531 if (*filename
== '\0' || inode
== 0)
1534 ++map_data
->file_count
;
1536 pack_long (buf
, map_data
->long_type
, vaddr
);
1537 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1538 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1539 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1540 pack_long (buf
, map_data
->long_type
, offset
);
1541 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1543 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1548 /* Write the file mapping data to the core file, if possible. OBFD is
1549 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1550 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1553 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1554 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1557 struct linux_make_mappings_data mapping_data
;
1558 struct type
*long_type
1559 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1560 gdb_byte buf
[sizeof (ULONGEST
)];
1562 auto_obstack data_obstack
, filename_obstack
;
1564 mapping_data
.file_count
= 0;
1565 mapping_data
.data_obstack
= &data_obstack
;
1566 mapping_data
.filename_obstack
= &filename_obstack
;
1567 mapping_data
.long_type
= long_type
;
1569 /* Reserve space for the count. */
1570 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1571 /* We always write the page size as 1 since we have no good way to
1572 determine the correct value. */
1573 pack_long (buf
, long_type
, 1);
1574 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1576 linux_find_memory_regions_full (gdbarch
,
1578 linux_make_mappings_callback
,
1581 if (mapping_data
.file_count
!= 0)
1583 /* Write the count to the obstack. */
1584 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1585 long_type
, mapping_data
.file_count
);
1587 /* Copy the filenames to the data obstack. */
1588 int size
= obstack_object_size (&filename_obstack
);
1589 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1592 note_data
.reset (elfcore_write_note
1593 (obfd
, note_data
.release (),
1594 note_size
, "CORE", NT_FILE
,
1595 obstack_base (&data_obstack
),
1596 obstack_object_size (&data_obstack
)));
1600 /* Structure for passing information from
1601 linux_collect_thread_registers via an iterator to
1602 linux_collect_regset_section_cb. */
1604 struct linux_collect_regset_section_cb_data
1606 linux_collect_regset_section_cb_data (struct gdbarch
*gdbarch
,
1607 const struct regcache
*regcache
,
1609 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1612 gdb_signal stop_signal
)
1613 : gdbarch (gdbarch
), regcache (regcache
), obfd (obfd
),
1614 note_data (note_data
), note_size (note_size
), lwp (lwp
),
1615 stop_signal (stop_signal
)
1618 struct gdbarch
*gdbarch
;
1619 const struct regcache
*regcache
;
1621 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1624 enum gdb_signal stop_signal
;
1625 bool abort_iteration
= false;
1628 /* Callback for iterate_over_regset_sections that records a single
1629 regset in the corefile note section. */
1632 linux_collect_regset_section_cb (const char *sect_name
, int supply_size
,
1633 int collect_size
, const struct regset
*regset
,
1634 const char *human_name
, void *cb_data
)
1636 struct linux_collect_regset_section_cb_data
*data
1637 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1638 bool variable_size_section
= (regset
!= NULL
1639 && regset
->flags
& REGSET_VARIABLE_SIZE
);
1641 if (!variable_size_section
)
1642 gdb_assert (supply_size
== collect_size
);
1644 if (data
->abort_iteration
)
1647 gdb_assert (regset
&& regset
->collect_regset
);
1649 /* This is intentionally zero-initialized by using std::vector, so
1650 that any padding bytes in the core file will show as 0. */
1651 std::vector
<gdb_byte
> buf (collect_size
);
1653 regset
->collect_regset (regset
, data
->regcache
, -1, buf
.data (),
1656 /* PRSTATUS still needs to be treated specially. */
1657 if (strcmp (sect_name
, ".reg") == 0)
1658 data
->note_data
.reset (elfcore_write_prstatus
1659 (data
->obfd
, data
->note_data
.release (),
1660 data
->note_size
, data
->lwp
,
1661 gdb_signal_to_host (data
->stop_signal
),
1664 data
->note_data
.reset (elfcore_write_register_note
1665 (data
->obfd
, data
->note_data
.release (),
1666 data
->note_size
, sect_name
, buf
.data (),
1669 if (data
->note_data
== NULL
)
1670 data
->abort_iteration
= true;
1673 /* Records the thread's register state for the corefile note
1677 linux_collect_thread_registers (const struct regcache
*regcache
,
1678 ptid_t ptid
, bfd
*obfd
,
1679 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1681 enum gdb_signal stop_signal
)
1683 struct gdbarch
*gdbarch
= regcache
->arch ();
1685 /* For remote targets the LWP may not be available, so use the TID. */
1686 long lwp
= ptid
.lwp ();
1690 linux_collect_regset_section_cb_data
data (gdbarch
, regcache
, obfd
, note_data
,
1691 note_size
, lwp
, stop_signal
);
1693 gdbarch_iterate_over_regset_sections (gdbarch
,
1694 linux_collect_regset_section_cb
,
1698 /* Fetch the siginfo data for the specified thread, if it exists. If
1699 there is no data, or we could not read it, return an empty
1702 static gdb::byte_vector
1703 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1705 struct type
*siginfo_type
;
1708 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1709 return gdb::byte_vector ();
1711 scoped_restore_current_thread save_current_thread
;
1712 switch_to_thread (thread
);
1714 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1716 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1718 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1719 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1720 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1726 struct linux_corefile_thread_data
1728 linux_corefile_thread_data (struct gdbarch
*gdbarch
, bfd
*obfd
,
1729 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1730 int *note_size
, gdb_signal stop_signal
)
1731 : gdbarch (gdbarch
), obfd (obfd
), note_data (note_data
),
1732 note_size (note_size
), stop_signal (stop_signal
)
1735 struct gdbarch
*gdbarch
;
1737 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1739 enum gdb_signal stop_signal
;
1742 /* Records the thread's register state for the corefile note
1746 linux_corefile_thread (struct thread_info
*info
,
1747 struct linux_corefile_thread_data
*args
)
1749 struct regcache
*regcache
;
1751 regcache
= get_thread_arch_regcache (info
->inf
->process_target (),
1752 info
->ptid
, args
->gdbarch
);
1754 target_fetch_registers (regcache
, -1);
1755 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1757 linux_collect_thread_registers (regcache
, info
->ptid
, args
->obfd
,
1758 args
->note_data
, args
->note_size
,
1761 /* Don't return anything if we got no register information above,
1762 such a core file is useless. */
1763 if (args
->note_data
!= NULL
)
1765 if (!siginfo_data
.empty ())
1766 args
->note_data
.reset (elfcore_write_note (args
->obfd
,
1767 args
->note_data
.release (),
1770 siginfo_data
.data (),
1771 siginfo_data
.size ()));
1775 /* Fill the PRPSINFO structure with information about the process being
1776 debugged. Returns 1 in case of success, 0 for failures. Please note that
1777 even if the structure cannot be entirely filled (e.g., GDB was unable to
1778 gather information about the process UID/GID), this function will still
1779 return 1 since some information was already recorded. It will only return
1780 0 iff nothing can be gathered. */
1783 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1785 /* The filename which we will use to obtain some info about the process.
1786 We will basically use this to store the `/proc/PID/FILENAME' file. */
1788 /* The basename of the executable. */
1789 const char *basename
;
1790 const char *infargs
;
1791 /* Temporary buffer. */
1793 /* The valid states of a process, according to the Linux kernel. */
1794 const char valid_states
[] = "RSDTZW";
1795 /* The program state. */
1796 const char *prog_state
;
1797 /* The state of the process. */
1799 /* The PID of the program which generated the corefile. */
1801 /* Process flags. */
1802 unsigned int pr_flag
;
1803 /* Process nice value. */
1805 /* The number of fields read by `sscanf'. */
1808 gdb_assert (p
!= NULL
);
1810 /* Obtaining PID and filename. */
1811 pid
= inferior_ptid
.pid ();
1812 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1813 /* The full name of the program which generated the corefile. */
1814 gdb::unique_xmalloc_ptr
<char> fname
1815 = target_fileio_read_stralloc (NULL
, filename
);
1817 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1819 /* No program name was read, so we won't be able to retrieve more
1820 information about the process. */
1824 memset (p
, 0, sizeof (*p
));
1826 /* Defining the PID. */
1829 /* Copying the program name. Only the basename matters. */
1830 basename
= lbasename (fname
.get ());
1831 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1832 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1834 infargs
= get_inferior_args ();
1836 /* The arguments of the program. */
1837 std::string psargs
= fname
.get ();
1838 if (infargs
!= NULL
)
1839 psargs
= psargs
+ " " + infargs
;
1841 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1842 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1844 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1845 /* The contents of `/proc/PID/stat'. */
1846 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1847 = target_fileio_read_stralloc (NULL
, filename
);
1848 char *proc_stat
= proc_stat_contents
.get ();
1850 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1852 /* Despite being unable to read more information about the
1853 process, we return 1 here because at least we have its
1854 command line, PID and arguments. */
1858 /* Ok, we have the stats. It's time to do a little parsing of the
1859 contents of the buffer, so that we end up reading what we want.
1861 The following parsing mechanism is strongly based on the
1862 information generated by the `fs/proc/array.c' file, present in
1863 the Linux kernel tree. More details about how the information is
1864 displayed can be obtained by seeing the manpage of proc(5),
1865 specifically under the entry of `/proc/[pid]/stat'. */
1867 /* Getting rid of the PID, since we already have it. */
1868 while (isdigit (*proc_stat
))
1871 proc_stat
= skip_spaces (proc_stat
);
1873 /* ps command also relies on no trailing fields ever contain ')'. */
1874 proc_stat
= strrchr (proc_stat
, ')');
1875 if (proc_stat
== NULL
)
1879 proc_stat
= skip_spaces (proc_stat
);
1881 n_fields
= sscanf (proc_stat
,
1882 "%c" /* Process state. */
1883 "%d%d%d" /* Parent PID, group ID, session ID. */
1884 "%*d%*d" /* tty_nr, tpgid (not used). */
1886 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1887 cmajflt (not used). */
1888 "%*s%*s%*s%*s" /* utime, stime, cutime,
1889 cstime (not used). */
1890 "%*s" /* Priority (not used). */
1893 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1899 /* Again, we couldn't read the complementary information about
1900 the process state. However, we already have minimal
1901 information, so we just return 1 here. */
1905 /* Filling the structure fields. */
1906 prog_state
= strchr (valid_states
, pr_sname
);
1907 if (prog_state
!= NULL
)
1908 p
->pr_state
= prog_state
- valid_states
;
1911 /* Zero means "Running". */
1915 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1916 p
->pr_zomb
= p
->pr_sname
== 'Z';
1917 p
->pr_nice
= pr_nice
;
1918 p
->pr_flag
= pr_flag
;
1920 /* Finally, obtaining the UID and GID. For that, we read and parse the
1921 contents of the `/proc/PID/status' file. */
1922 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1923 /* The contents of `/proc/PID/status'. */
1924 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1925 = target_fileio_read_stralloc (NULL
, filename
);
1926 char *proc_status
= proc_status_contents
.get ();
1928 if (proc_status
== NULL
|| *proc_status
== '\0')
1930 /* Returning 1 since we already have a bunch of information. */
1934 /* Extracting the UID. */
1935 tmpstr
= strstr (proc_status
, "Uid:");
1938 /* Advancing the pointer to the beginning of the UID. */
1939 tmpstr
+= sizeof ("Uid:");
1940 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1943 if (isdigit (*tmpstr
))
1944 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1947 /* Extracting the GID. */
1948 tmpstr
= strstr (proc_status
, "Gid:");
1951 /* Advancing the pointer to the beginning of the GID. */
1952 tmpstr
+= sizeof ("Gid:");
1953 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1956 if (isdigit (*tmpstr
))
1957 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1963 /* Find the signalled thread. In case there's more than one signalled
1964 thread, prefer the current thread, if it is signalled. If no
1965 thread was signalled, default to the current thread, unless it has
1966 exited, in which case return NULL. */
1968 static thread_info
*
1969 find_signalled_thread ()
1971 thread_info
*curr_thr
= inferior_thread ();
1972 if (curr_thr
->state
!= THREAD_EXITED
1973 && curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1976 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1977 if (thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1980 /* Default to the current thread, unless it has exited. */
1981 if (curr_thr
->state
!= THREAD_EXITED
)
1987 /* Build the note section for a corefile, and return it in a malloc
1990 static gdb::unique_xmalloc_ptr
<char>
1991 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1993 struct elf_internal_linux_prpsinfo prpsinfo
;
1994 gdb::unique_xmalloc_ptr
<char> note_data
;
1996 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1999 if (linux_fill_prpsinfo (&prpsinfo
))
2001 if (gdbarch_ptr_bit (gdbarch
) == 64)
2002 note_data
.reset (elfcore_write_linux_prpsinfo64 (obfd
,
2003 note_data
.release (),
2004 note_size
, &prpsinfo
));
2006 note_data
.reset (elfcore_write_linux_prpsinfo32 (obfd
,
2007 note_data
.release (),
2008 note_size
, &prpsinfo
));
2011 /* Thread register information. */
2014 update_thread_list ();
2016 catch (const gdb_exception_error
&e
)
2018 exception_print (gdb_stderr
, e
);
2021 /* Like the kernel, prefer dumping the signalled thread first.
2022 "First thread" is what tools use to infer the signalled
2024 thread_info
*signalled_thr
= find_signalled_thread ();
2025 gdb_signal stop_signal
;
2026 if (signalled_thr
!= nullptr)
2027 stop_signal
= signalled_thr
->suspend
.stop_signal
;
2029 stop_signal
= GDB_SIGNAL_0
;
2031 linux_corefile_thread_data
thread_args (gdbarch
, obfd
, note_data
, note_size
,
2034 if (signalled_thr
!= nullptr)
2035 linux_corefile_thread (signalled_thr
, &thread_args
);
2036 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
2038 if (thr
== signalled_thr
)
2041 linux_corefile_thread (thr
, &thread_args
);
2047 /* Auxillary vector. */
2048 gdb::optional
<gdb::byte_vector
> auxv
=
2049 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
2050 if (auxv
&& !auxv
->empty ())
2052 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
2053 note_size
, "CORE", NT_AUXV
,
2054 auxv
->data (), auxv
->size ()));
2060 /* File mappings. */
2061 linux_make_mappings_corefile_notes (gdbarch
, obfd
, note_data
, note_size
);
2066 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2067 gdbarch.h. This function is not static because it is exported to
2068 other -tdep files. */
2071 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2076 return GDB_SIGNAL_0
;
2079 return GDB_SIGNAL_HUP
;
2082 return GDB_SIGNAL_INT
;
2085 return GDB_SIGNAL_QUIT
;
2088 return GDB_SIGNAL_ILL
;
2091 return GDB_SIGNAL_TRAP
;
2094 return GDB_SIGNAL_ABRT
;
2097 return GDB_SIGNAL_BUS
;
2100 return GDB_SIGNAL_FPE
;
2103 return GDB_SIGNAL_KILL
;
2106 return GDB_SIGNAL_USR1
;
2109 return GDB_SIGNAL_SEGV
;
2112 return GDB_SIGNAL_USR2
;
2115 return GDB_SIGNAL_PIPE
;
2118 return GDB_SIGNAL_ALRM
;
2121 return GDB_SIGNAL_TERM
;
2124 return GDB_SIGNAL_CHLD
;
2127 return GDB_SIGNAL_CONT
;
2130 return GDB_SIGNAL_STOP
;
2133 return GDB_SIGNAL_TSTP
;
2136 return GDB_SIGNAL_TTIN
;
2139 return GDB_SIGNAL_TTOU
;
2142 return GDB_SIGNAL_URG
;
2145 return GDB_SIGNAL_XCPU
;
2148 return GDB_SIGNAL_XFSZ
;
2150 case LINUX_SIGVTALRM
:
2151 return GDB_SIGNAL_VTALRM
;
2154 return GDB_SIGNAL_PROF
;
2156 case LINUX_SIGWINCH
:
2157 return GDB_SIGNAL_WINCH
;
2159 /* No way to differentiate between SIGIO and SIGPOLL.
2160 Therefore, we just handle the first one. */
2162 return GDB_SIGNAL_IO
;
2165 return GDB_SIGNAL_PWR
;
2168 return GDB_SIGNAL_SYS
;
2170 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2171 therefore we have to handle them here. */
2172 case LINUX_SIGRTMIN
:
2173 return GDB_SIGNAL_REALTIME_32
;
2175 case LINUX_SIGRTMAX
:
2176 return GDB_SIGNAL_REALTIME_64
;
2179 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2181 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2183 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2186 return GDB_SIGNAL_UNKNOWN
;
2189 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2190 gdbarch.h. This function is not static because it is exported to
2191 other -tdep files. */
2194 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2195 enum gdb_signal signal
)
2202 case GDB_SIGNAL_HUP
:
2203 return LINUX_SIGHUP
;
2205 case GDB_SIGNAL_INT
:
2206 return LINUX_SIGINT
;
2208 case GDB_SIGNAL_QUIT
:
2209 return LINUX_SIGQUIT
;
2211 case GDB_SIGNAL_ILL
:
2212 return LINUX_SIGILL
;
2214 case GDB_SIGNAL_TRAP
:
2215 return LINUX_SIGTRAP
;
2217 case GDB_SIGNAL_ABRT
:
2218 return LINUX_SIGABRT
;
2220 case GDB_SIGNAL_FPE
:
2221 return LINUX_SIGFPE
;
2223 case GDB_SIGNAL_KILL
:
2224 return LINUX_SIGKILL
;
2226 case GDB_SIGNAL_BUS
:
2227 return LINUX_SIGBUS
;
2229 case GDB_SIGNAL_SEGV
:
2230 return LINUX_SIGSEGV
;
2232 case GDB_SIGNAL_SYS
:
2233 return LINUX_SIGSYS
;
2235 case GDB_SIGNAL_PIPE
:
2236 return LINUX_SIGPIPE
;
2238 case GDB_SIGNAL_ALRM
:
2239 return LINUX_SIGALRM
;
2241 case GDB_SIGNAL_TERM
:
2242 return LINUX_SIGTERM
;
2244 case GDB_SIGNAL_URG
:
2245 return LINUX_SIGURG
;
2247 case GDB_SIGNAL_STOP
:
2248 return LINUX_SIGSTOP
;
2250 case GDB_SIGNAL_TSTP
:
2251 return LINUX_SIGTSTP
;
2253 case GDB_SIGNAL_CONT
:
2254 return LINUX_SIGCONT
;
2256 case GDB_SIGNAL_CHLD
:
2257 return LINUX_SIGCHLD
;
2259 case GDB_SIGNAL_TTIN
:
2260 return LINUX_SIGTTIN
;
2262 case GDB_SIGNAL_TTOU
:
2263 return LINUX_SIGTTOU
;
2268 case GDB_SIGNAL_XCPU
:
2269 return LINUX_SIGXCPU
;
2271 case GDB_SIGNAL_XFSZ
:
2272 return LINUX_SIGXFSZ
;
2274 case GDB_SIGNAL_VTALRM
:
2275 return LINUX_SIGVTALRM
;
2277 case GDB_SIGNAL_PROF
:
2278 return LINUX_SIGPROF
;
2280 case GDB_SIGNAL_WINCH
:
2281 return LINUX_SIGWINCH
;
2283 case GDB_SIGNAL_USR1
:
2284 return LINUX_SIGUSR1
;
2286 case GDB_SIGNAL_USR2
:
2287 return LINUX_SIGUSR2
;
2289 case GDB_SIGNAL_PWR
:
2290 return LINUX_SIGPWR
;
2292 case GDB_SIGNAL_POLL
:
2293 return LINUX_SIGPOLL
;
2295 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2296 therefore we have to handle it here. */
2297 case GDB_SIGNAL_REALTIME_32
:
2298 return LINUX_SIGRTMIN
;
2300 /* Same comment applies to _64. */
2301 case GDB_SIGNAL_REALTIME_64
:
2302 return LINUX_SIGRTMAX
;
2305 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2306 if (signal
>= GDB_SIGNAL_REALTIME_33
2307 && signal
<= GDB_SIGNAL_REALTIME_63
)
2309 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2311 return LINUX_SIGRTMIN
+ 1 + offset
;
2317 /* Helper for linux_vsyscall_range that does the real work of finding
2318 the vsyscall's address range. */
2321 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2326 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2329 /* It doesn't make sense to access the host's /proc when debugging a
2330 core file. Instead, look for the PT_LOAD segment that matches
2332 if (!target_has_execution ())
2337 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2338 if (phdrs_size
== -1)
2341 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2342 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2343 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2344 if (num_phdrs
== -1)
2347 for (i
= 0; i
< num_phdrs
; i
++)
2348 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2349 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2351 range
->length
= phdrs
.get ()[i
].p_memsz
;
2358 /* We need to know the real target PID to access /proc. */
2359 if (current_inferior ()->fake_pid_p
)
2362 pid
= current_inferior ()->pid
;
2364 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2365 reading /proc/PID/maps (2). The later identifies thread stacks
2366 in the output, which requires scanning every thread in the thread
2367 group to check whether a VMA is actually a thread's stack. With
2368 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2369 a few thousand threads, (1) takes a few miliseconds, while (2)
2370 takes several seconds. Also note that "smaps", what we read for
2371 determining core dump mappings, is even slower than "maps". */
2372 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2373 gdb::unique_xmalloc_ptr
<char> data
2374 = target_fileio_read_stralloc (NULL
, filename
);
2378 char *saveptr
= NULL
;
2380 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2382 line
= strtok_r (NULL
, "\n", &saveptr
))
2384 ULONGEST addr
, endaddr
;
2385 const char *p
= line
;
2387 addr
= strtoulst (p
, &p
, 16);
2388 if (addr
== range
->start
)
2392 endaddr
= strtoulst (p
, &p
, 16);
2393 range
->length
= endaddr
- addr
;
2399 warning (_("unable to open /proc file '%s'"), filename
);
2404 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2405 caching, and defers the real work to linux_vsyscall_range_raw. */
2408 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2410 struct linux_info
*info
= get_linux_inferior_data ();
2412 if (info
->vsyscall_range_p
== 0)
2414 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2415 info
->vsyscall_range_p
= 1;
2417 info
->vsyscall_range_p
= -1;
2420 if (info
->vsyscall_range_p
< 0)
2423 *range
= info
->vsyscall_range
;
2427 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2428 definitions would be dependent on compilation host. */
2429 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2430 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2432 /* See gdbarch.sh 'infcall_mmap'. */
2435 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2437 struct objfile
*objf
;
2438 /* Do there still exist any Linux systems without "mmap64"?
2439 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2440 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2441 struct value
*addr_val
;
2442 struct gdbarch
*gdbarch
= objf
->arch ();
2446 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2448 struct value
*arg
[ARG_LAST
];
2450 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2452 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2453 arg
[ARG_LENGTH
] = value_from_ulongest
2454 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2455 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2456 | GDB_MMAP_PROT_EXEC
))
2458 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2459 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2460 GDB_MMAP_MAP_PRIVATE
2461 | GDB_MMAP_MAP_ANONYMOUS
);
2462 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2463 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2465 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2466 retval
= value_as_address (addr_val
);
2467 if (retval
== (CORE_ADDR
) -1)
2468 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2473 /* See gdbarch.sh 'infcall_munmap'. */
2476 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2478 struct objfile
*objf
;
2479 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2480 struct value
*retval_val
;
2481 struct gdbarch
*gdbarch
= objf
->arch ();
2485 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2487 struct value
*arg
[ARG_LAST
];
2489 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2491 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2492 arg
[ARG_LENGTH
] = value_from_ulongest
2493 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2494 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2495 retval
= value_as_long (retval_val
);
2497 warning (_("Failed inferior munmap call at %s for %s bytes, "
2498 "errno is changed."),
2499 hex_string (addr
), pulongest (size
));
2502 /* See linux-tdep.h. */
2505 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2510 /* Determine entry point from target auxiliary vector. This avoids
2511 the need for symbols. Also, when debugging a stand-alone SPU
2512 executable, entry_point_address () will point to an SPU
2513 local-store address and is thus not usable as displaced stepping
2514 location. The auxiliary vector gets us the PowerPC-side entry
2515 point address instead. */
2516 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2517 throw_error (NOT_SUPPORTED_ERROR
,
2518 _("Cannot find AT_ENTRY auxiliary vector entry."));
2520 /* Make certain that the address points at real code, and not a
2521 function descriptor. */
2522 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2523 current_top_target ());
2525 /* Inferior calls also use the entry point as a breakpoint location.
2526 We don't want displaced stepping to interfere with those
2527 breakpoints, so leave space. */
2528 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2534 /* See linux-tdep.h. */
2537 linux_get_hwcap (struct target_ops
*target
)
2540 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2545 /* See linux-tdep.h. */
2548 linux_get_hwcap2 (struct target_ops
*target
)
2551 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2556 /* Display whether the gcore command is using the
2557 /proc/PID/coredump_filter file. */
2560 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2561 struct cmd_list_element
*c
, const char *value
)
2563 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2564 " corefiles is %s.\n"), value
);
2567 /* Display whether the gcore command is dumping mappings marked with
2568 the VM_DONTDUMP flag. */
2571 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2572 struct cmd_list_element
*c
, const char *value
)
2574 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2575 " flag is %s.\n"), value
);
2578 /* To be called from the various GDB_OSABI_LINUX handlers for the
2579 various GNU/Linux architectures and machine types. */
2582 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2584 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2585 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2586 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2587 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2588 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2589 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2590 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2591 set_gdbarch_has_shared_address_space (gdbarch
,
2592 linux_has_shared_address_space
);
2593 set_gdbarch_gdb_signal_from_target (gdbarch
,
2594 linux_gdb_signal_from_target
);
2595 set_gdbarch_gdb_signal_to_target (gdbarch
,
2596 linux_gdb_signal_to_target
);
2597 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2598 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2599 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2600 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2603 void _initialize_linux_tdep ();
2605 _initialize_linux_tdep ()
2607 linux_gdbarch_data_handle
=
2608 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2610 /* Observers used to invalidate the cache when needed. */
2611 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2612 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2614 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2615 &use_coredump_filter
, _("\
2616 Set whether gcore should consider /proc/PID/coredump_filter."),
2618 Show whether gcore should consider /proc/PID/coredump_filter."),
2620 Use this command to set whether gcore should consider the contents\n\
2621 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2622 about this file, refer to the manpage of core(5)."),
2623 NULL
, show_use_coredump_filter
,
2624 &setlist
, &showlist
);
2626 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2627 &dump_excluded_mappings
, _("\
2628 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2630 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2632 Use this command to set whether gcore should dump mappings marked with the\n\
2633 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2634 more information about this file, refer to the manpage of proc(5) and core(5)."),
2635 NULL
, show_dump_excluded_mappings
,
2636 &setlist
, &showlist
);