1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2021 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
;
171 int num_disp_step_buffers
;
175 init_linux_gdbarch_data (struct obstack
*obstack
)
177 return obstack_zalloc
<linux_gdbarch_data
> (obstack
);
180 static struct linux_gdbarch_data
*
181 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
183 return ((struct linux_gdbarch_data
*)
184 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
187 /* Linux-specific cached data. This is used by GDB for caching
188 purposes for each inferior. This helps reduce the overhead of
189 transfering data from a remote target to the local host. */
192 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
193 if VSYSCALL_RANGE_P is positive. This is cached because getting
194 at this info requires an auxv lookup (which is itself cached),
195 and looking through the inferior's mappings (which change
196 throughout execution and therefore cannot be cached). */
197 struct mem_range vsyscall_range
{};
199 /* Zero if we haven't tried looking up the vsyscall's range before
200 yet. Positive if we tried looking it up, and found it. Negative
201 if we tried looking it up but failed. */
202 int vsyscall_range_p
= 0;
204 /* Inferior's displaced step buffers. */
205 gdb::optional
<displaced_step_buffers
> disp_step_bufs
;
208 /* Per-inferior data key. */
209 static const struct inferior_key
<linux_info
> linux_inferior_data
;
211 /* Frees whatever allocated space there is to be freed and sets INF's
212 linux cache data pointer to NULL. */
215 invalidate_linux_cache_inf (struct inferior
*inf
)
217 linux_inferior_data
.clear (inf
);
220 /* Fetch the linux cache info for INF. This function always returns a
221 valid INFO pointer. */
223 static struct linux_info
*
224 get_linux_inferior_data (inferior
*inf
)
226 linux_info
*info
= linux_inferior_data
.get (inf
);
229 info
= linux_inferior_data
.emplace (inf
);
234 /* See linux-tdep.h. */
237 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
238 linux_siginfo_extra_fields extra_fields
)
240 struct linux_gdbarch_data
*linux_gdbarch_data
;
241 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
242 struct type
*uid_type
, *pid_type
;
243 struct type
*sigval_type
, *clock_type
;
244 struct type
*siginfo_type
, *sifields_type
;
247 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
248 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
249 return linux_gdbarch_data
->siginfo_type
;
251 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
253 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
255 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
257 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
259 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
262 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
263 sigval_type
->set_name (xstrdup ("sigval_t"));
264 append_composite_type_field (sigval_type
, "sival_int", int_type
);
265 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
268 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
269 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
270 TYPE_TARGET_TYPE (pid_type
) = int_type
;
271 pid_type
->set_target_is_stub (true);
274 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
275 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
276 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
277 uid_type
->set_target_is_stub (true);
280 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
281 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
283 TYPE_TARGET_TYPE (clock_type
) = long_type
;
284 clock_type
->set_target_is_stub (true);
287 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
290 const int si_max_size
= 128;
292 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
295 if (gdbarch_ptr_bit (gdbarch
) == 64)
296 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
298 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
299 append_composite_type_field (sifields_type
, "_pad",
300 init_vector_type (int_type
, si_pad_size
));
304 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
305 append_composite_type_field (type
, "si_pid", pid_type
);
306 append_composite_type_field (type
, "si_uid", uid_type
);
307 append_composite_type_field (sifields_type
, "_kill", type
);
310 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
311 append_composite_type_field (type
, "si_tid", int_type
);
312 append_composite_type_field (type
, "si_overrun", int_type
);
313 append_composite_type_field (type
, "si_sigval", sigval_type
);
314 append_composite_type_field (sifields_type
, "_timer", type
);
317 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
318 append_composite_type_field (type
, "si_pid", pid_type
);
319 append_composite_type_field (type
, "si_uid", uid_type
);
320 append_composite_type_field (type
, "si_sigval", sigval_type
);
321 append_composite_type_field (sifields_type
, "_rt", type
);
324 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
325 append_composite_type_field (type
, "si_pid", pid_type
);
326 append_composite_type_field (type
, "si_uid", uid_type
);
327 append_composite_type_field (type
, "si_status", int_type
);
328 append_composite_type_field (type
, "si_utime", clock_type
);
329 append_composite_type_field (type
, "si_stime", clock_type
);
330 append_composite_type_field (sifields_type
, "_sigchld", type
);
333 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
334 append_composite_type_field (type
, "si_addr", void_ptr_type
);
336 /* Additional bound fields for _sigfault in case they were requested. */
337 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
339 struct type
*sigfault_bnd_fields
;
341 append_composite_type_field (type
, "_addr_lsb", short_type
);
342 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
343 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
344 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
345 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
347 append_composite_type_field (sifields_type
, "_sigfault", type
);
350 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
351 append_composite_type_field (type
, "si_band", long_type
);
352 append_composite_type_field (type
, "si_fd", int_type
);
353 append_composite_type_field (sifields_type
, "_sigpoll", type
);
356 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
357 siginfo_type
->set_name (xstrdup ("siginfo"));
358 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
359 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
360 append_composite_type_field (siginfo_type
, "si_code", int_type
);
361 append_composite_type_field_aligned (siginfo_type
,
362 "_sifields", sifields_type
,
363 TYPE_LENGTH (long_type
));
365 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
370 /* This function is suitable for architectures that don't
371 extend/override the standard siginfo structure. */
374 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
376 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
379 /* Return true if the target is running on uClinux instead of normal
383 linux_is_uclinux (void)
387 return (target_auxv_search (current_top_target (), AT_NULL
, &dummy
) > 0
388 && target_auxv_search (current_top_target (), AT_PAGESZ
, &dummy
) == 0);
392 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
394 return linux_is_uclinux ();
397 /* This is how we want PTIDs from core files to be printed. */
400 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
402 if (ptid
.lwp () != 0)
403 return string_printf ("LWP %ld", ptid
.lwp ());
405 return normal_pid_to_str (ptid
);
408 /* Service function for corefiles and info proc. */
411 read_mapping (const char *line
,
412 ULONGEST
*addr
, ULONGEST
*endaddr
,
413 const char **permissions
, size_t *permissions_len
,
415 const char **device
, size_t *device_len
,
417 const char **filename
)
419 const char *p
= line
;
421 *addr
= strtoulst (p
, &p
, 16);
424 *endaddr
= strtoulst (p
, &p
, 16);
428 while (*p
&& !isspace (*p
))
430 *permissions_len
= p
- *permissions
;
432 *offset
= strtoulst (p
, &p
, 16);
436 while (*p
&& !isspace (*p
))
438 *device_len
= p
- *device
;
440 *inode
= strtoulst (p
, &p
, 10);
446 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
448 This function was based on the documentation found on
449 <Documentation/filesystems/proc.txt>, on the Linux kernel.
451 Linux kernels before commit
452 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
456 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
458 char *saveptr
= NULL
;
461 v
->initialized_p
= 1;
462 p
= skip_to_space (p
);
465 for (s
= strtok_r (p
, " ", &saveptr
);
467 s
= strtok_r (NULL
, " ", &saveptr
))
469 if (strcmp (s
, "io") == 0)
471 else if (strcmp (s
, "ht") == 0)
472 v
->uses_huge_tlb
= 1;
473 else if (strcmp (s
, "dd") == 0)
474 v
->exclude_coredump
= 1;
475 else if (strcmp (s
, "sh") == 0)
476 v
->shared_mapping
= 1;
480 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
481 they're initialized lazily. */
483 struct mapping_regexes
485 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
486 string in the end). We know for sure, based on the Linux kernel
487 code, that memory mappings whose associated filename is
488 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
489 compiled_regex dev_zero
490 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
491 _("Could not compile regex to match /dev/zero filename")};
493 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
494 string in the end). These filenames refer to shared memory
495 (shmem), and memory mappings associated with them are
496 MAP_ANONYMOUS as well. */
497 compiled_regex shmem_file
498 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
499 _("Could not compile regex to match shmem filenames")};
501 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
502 0' code, which is responsible to decide if it is dealing with a
503 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
504 FILE_DELETED matches, it does not necessarily mean that we are
505 dealing with an anonymous shared mapping. However, there is no
506 easy way to detect this currently, so this is the best
507 approximation we have.
509 As a result, GDB will dump readonly pages of deleted executables
510 when using the default value of coredump_filter (0x33), while the
511 Linux kernel will not dump those pages. But we can live with
513 compiled_regex file_deleted
514 {" (deleted)$", REG_NOSUB
,
515 _("Could not compile regex to match '<file> (deleted)'")};
518 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
520 FILENAME is the name of the file present in the first line of the
521 memory mapping, in the "/proc/PID/smaps" output. For example, if
524 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
526 Then FILENAME will be "/path/to/file". */
529 mapping_is_anonymous_p (const char *filename
)
531 static gdb::optional
<mapping_regexes
> regexes
;
532 static int init_regex_p
= 0;
536 /* Let's be pessimistic and assume there will be an error while
537 compiling the regex'es. */
542 /* If we reached this point, then everything succeeded. */
546 if (init_regex_p
== -1)
548 const char deleted
[] = " (deleted)";
549 size_t del_len
= sizeof (deleted
) - 1;
550 size_t filename_len
= strlen (filename
);
552 /* There was an error while compiling the regex'es above. In
553 order to try to give some reliable information to the caller,
554 we just try to find the string " (deleted)" in the filename.
555 If we managed to find it, then we assume the mapping is
557 return (filename_len
>= del_len
558 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
561 if (*filename
== '\0'
562 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
563 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
564 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
570 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
571 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
572 be dumped, or greater than 0 if it should.
574 In a nutshell, this is the logic that we follow in order to decide
575 if a mapping should be dumped or not.
577 - If the mapping is associated to a file whose name ends with
578 " (deleted)", or if the file is "/dev/zero", or if it is
579 "/SYSV%08x" (shared memory), or if there is no file associated
580 with it, or if the AnonHugePages: or the Anonymous: fields in the
581 /proc/PID/smaps have contents, then GDB considers this mapping to
582 be anonymous. Otherwise, GDB considers this mapping to be a
583 file-backed mapping (because there will be a file associated with
586 It is worth mentioning that, from all those checks described
587 above, the most fragile is the one to see if the file name ends
588 with " (deleted)". This does not necessarily mean that the
589 mapping is anonymous, because the deleted file associated with
590 the mapping may have been a hard link to another file, for
591 example. The Linux kernel checks to see if "i_nlink == 0", but
592 GDB cannot easily (and normally) do this check (iff running as
593 root, it could find the mapping in /proc/PID/map_files/ and
594 determine whether there still are other hard links to the
595 inode/file). Therefore, we made a compromise here, and we assume
596 that if the file name ends with " (deleted)", then the mapping is
597 indeed anonymous. FWIW, this is something the Linux kernel could
598 do better: expose this information in a more direct way.
600 - If we see the flag "sh" in the "VmFlags:" field (in
601 /proc/PID/smaps), then certainly the memory mapping is shared
602 (VM_SHARED). If we have access to the VmFlags, and we don't see
603 the "sh" there, then certainly the mapping is private. However,
604 Linux kernels before commit
605 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
606 "VmFlags:" field; in that case, we use another heuristic: if we
607 see 'p' in the permission flags, then we assume that the mapping
608 is private, even though the presence of the 's' flag there would
609 mean VM_MAYSHARE, which means the mapping could still be private.
610 This should work OK enough, however.
612 - Even if, at the end, we decided that we should not dump the
613 mapping, we still have to check if it is something like an ELF
614 header (of a DSO or an executable, for example). If it is, and
615 if the user is interested in dump it, then we should dump it. */
618 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
619 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
620 const char *filename
, ULONGEST addr
, ULONGEST offset
)
622 /* Initially, we trust in what we received from our caller. This
623 value may not be very precise (i.e., it was probably gathered
624 from the permission line in the /proc/PID/smaps list, which
625 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
626 what we have until we take a look at the "VmFlags:" field
627 (assuming that the version of the Linux kernel being used
628 supports it, of course). */
629 int private_p
= maybe_private_p
;
632 /* We always dump vDSO and vsyscall mappings, because it's likely that
633 there'll be no file to read the contents from at core load time.
634 The kernel does the same. */
635 if (strcmp ("[vdso]", filename
) == 0
636 || strcmp ("[vsyscall]", filename
) == 0)
639 if (v
->initialized_p
)
641 /* We never dump I/O mappings. */
645 /* Check if we should exclude this mapping. */
646 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
649 /* Update our notion of whether this mapping is shared or
650 private based on a trustworthy value. */
651 private_p
= !v
->shared_mapping
;
653 /* HugeTLB checking. */
654 if (v
->uses_huge_tlb
)
656 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
657 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
666 if (mapping_anon_p
&& mapping_file_p
)
668 /* This is a special situation. It can happen when we see a
669 mapping that is file-backed, but that contains anonymous
671 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
672 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
674 else if (mapping_anon_p
)
675 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
677 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
681 if (mapping_anon_p
&& mapping_file_p
)
683 /* This is a special situation. It can happen when we see a
684 mapping that is file-backed, but that contains anonymous
686 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
687 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
689 else if (mapping_anon_p
)
690 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
692 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
695 /* Even if we decided that we shouldn't dump this mapping, we still
696 have to check whether (a) the user wants us to dump mappings
697 containing an ELF header, and (b) the mapping in question
698 contains an ELF header. If (a) and (b) are true, then we should
701 A mapping contains an ELF header if it is a private mapping, its
702 offset is zero, and its first word is ELFMAG. */
703 if (!dump_p
&& private_p
&& offset
== 0
704 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
706 /* Useful define specifying the size of the ELF magical
712 /* Let's check if we have an ELF header. */
714 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
716 /* The EI_MAG* and ELFMAG* constants come from
718 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
719 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
721 /* This mapping contains an ELF header, so we
731 /* As above, but return true only when we should dump the NT_FILE
735 dump_note_entry_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
736 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
737 const char *filename
, ULONGEST addr
, ULONGEST offset
)
739 /* vDSO and vsyscall mappings will end up in the core file. Don't
740 put them in the NT_FILE note. */
741 if (strcmp ("[vdso]", filename
) == 0
742 || strcmp ("[vsyscall]", filename
) == 0)
745 /* Otherwise, any other file-based mapping should be placed in the
750 /* Implement the "info proc" command. */
753 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
754 enum info_proc_what what
)
756 /* A long is used for pid instead of an int to avoid a loss of precision
757 compiler warning from the output of strtoul. */
759 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
760 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
761 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
762 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
763 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
764 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
768 if (args
&& isdigit (args
[0]))
772 pid
= strtoul (args
, &tem
, 10);
777 if (!target_has_execution ())
778 error (_("No current process: you must name one."));
779 if (current_inferior ()->fake_pid_p
)
780 error (_("Can't determine the current process's PID: you must name one."));
782 pid
= current_inferior ()->pid
;
785 args
= skip_spaces (args
);
787 error (_("Too many parameters: %s"), args
);
789 printf_filtered (_("process %ld\n"), pid
);
792 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
794 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
798 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
801 for (pos
= 0; pos
< len
- 1; pos
++)
803 if (buffer
[pos
] == '\0')
806 buffer
[len
- 1] = '\0';
807 printf_filtered ("cmdline = '%s'\n", buffer
);
810 warning (_("unable to open /proc file '%s'"), filename
);
814 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
815 gdb::optional
<std::string
> contents
816 = target_fileio_readlink (NULL
, filename
, &target_errno
);
817 if (contents
.has_value ())
818 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
820 warning (_("unable to read link '%s'"), filename
);
824 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
825 gdb::optional
<std::string
> contents
826 = target_fileio_readlink (NULL
, filename
, &target_errno
);
827 if (contents
.has_value ())
828 printf_filtered ("exe = '%s'\n", contents
->c_str ());
830 warning (_("unable to read link '%s'"), filename
);
834 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
835 gdb::unique_xmalloc_ptr
<char> map
836 = target_fileio_read_stralloc (NULL
, filename
);
841 printf_filtered (_("Mapped address spaces:\n\n"));
842 if (gdbarch_addr_bit (gdbarch
) == 32)
844 printf_filtered ("\t%10s %10s %10s %10s %s\n",
847 " Size", " Offset", "objfile");
851 printf_filtered (" %18s %18s %10s %10s %s\n",
854 " Size", " Offset", "objfile");
858 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
860 line
= strtok_r (NULL
, "\n", &saveptr
))
862 ULONGEST addr
, endaddr
, offset
, inode
;
863 const char *permissions
, *device
, *mapping_filename
;
864 size_t permissions_len
, device_len
;
866 read_mapping (line
, &addr
, &endaddr
,
867 &permissions
, &permissions_len
,
868 &offset
, &device
, &device_len
,
869 &inode
, &mapping_filename
);
871 if (gdbarch_addr_bit (gdbarch
) == 32)
873 printf_filtered ("\t%10s %10s %10s %10s %s\n",
874 paddress (gdbarch
, addr
),
875 paddress (gdbarch
, endaddr
),
876 hex_string (endaddr
- addr
),
878 *mapping_filename
? mapping_filename
: "");
882 printf_filtered (" %18s %18s %10s %10s %s\n",
883 paddress (gdbarch
, addr
),
884 paddress (gdbarch
, endaddr
),
885 hex_string (endaddr
- addr
),
887 *mapping_filename
? mapping_filename
: "");
892 warning (_("unable to open /proc file '%s'"), filename
);
896 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
897 gdb::unique_xmalloc_ptr
<char> status
898 = target_fileio_read_stralloc (NULL
, filename
);
900 puts_filtered (status
.get ());
902 warning (_("unable to open /proc file '%s'"), filename
);
906 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
907 gdb::unique_xmalloc_ptr
<char> statstr
908 = target_fileio_read_stralloc (NULL
, filename
);
911 const char *p
= statstr
.get ();
913 printf_filtered (_("Process: %s\n"),
914 pulongest (strtoulst (p
, &p
, 10)));
919 /* ps command also relies on no trailing fields
921 const char *ep
= strrchr (p
, ')');
924 printf_filtered ("Exec file: %.*s\n",
925 (int) (ep
- p
- 1), p
+ 1);
932 printf_filtered (_("State: %c\n"), *p
++);
935 printf_filtered (_("Parent process: %s\n"),
936 pulongest (strtoulst (p
, &p
, 10)));
938 printf_filtered (_("Process group: %s\n"),
939 pulongest (strtoulst (p
, &p
, 10)));
941 printf_filtered (_("Session id: %s\n"),
942 pulongest (strtoulst (p
, &p
, 10)));
944 printf_filtered (_("TTY: %s\n"),
945 pulongest (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("TTY owner process group: %s\n"),
948 pulongest (strtoulst (p
, &p
, 10)));
951 printf_filtered (_("Flags: %s\n"),
952 hex_string (strtoulst (p
, &p
, 10)));
954 printf_filtered (_("Minor faults (no memory page): %s\n"),
955 pulongest (strtoulst (p
, &p
, 10)));
957 printf_filtered (_("Minor faults, children: %s\n"),
958 pulongest (strtoulst (p
, &p
, 10)));
960 printf_filtered (_("Major faults (memory page faults): %s\n"),
961 pulongest (strtoulst (p
, &p
, 10)));
963 printf_filtered (_("Major faults, children: %s\n"),
964 pulongest (strtoulst (p
, &p
, 10)));
966 printf_filtered (_("utime: %s\n"),
967 pulongest (strtoulst (p
, &p
, 10)));
969 printf_filtered (_("stime: %s\n"),
970 pulongest (strtoulst (p
, &p
, 10)));
972 printf_filtered (_("utime, children: %s\n"),
973 pulongest (strtoulst (p
, &p
, 10)));
975 printf_filtered (_("stime, children: %s\n"),
976 pulongest (strtoulst (p
, &p
, 10)));
978 printf_filtered (_("jiffies remaining in current "
980 pulongest (strtoulst (p
, &p
, 10)));
982 printf_filtered (_("'nice' value: %s\n"),
983 pulongest (strtoulst (p
, &p
, 10)));
985 printf_filtered (_("jiffies until next timeout: %s\n"),
986 pulongest (strtoulst (p
, &p
, 10)));
988 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
989 pulongest (strtoulst (p
, &p
, 10)));
991 printf_filtered (_("start time (jiffies since "
992 "system boot): %s\n"),
993 pulongest (strtoulst (p
, &p
, 10)));
995 printf_filtered (_("Virtual memory size: %s\n"),
996 pulongest (strtoulst (p
, &p
, 10)));
998 printf_filtered (_("Resident set size: %s\n"),
999 pulongest (strtoulst (p
, &p
, 10)));
1001 printf_filtered (_("rlim: %s\n"),
1002 pulongest (strtoulst (p
, &p
, 10)));
1004 printf_filtered (_("Start of text: %s\n"),
1005 hex_string (strtoulst (p
, &p
, 10)));
1007 printf_filtered (_("End of text: %s\n"),
1008 hex_string (strtoulst (p
, &p
, 10)));
1010 printf_filtered (_("Start of stack: %s\n"),
1011 hex_string (strtoulst (p
, &p
, 10)));
1012 #if 0 /* Don't know how architecture-dependent the rest is...
1013 Anyway the signal bitmap info is available from "status". */
1015 printf_filtered (_("Kernel stack pointer: %s\n"),
1016 hex_string (strtoulst (p
, &p
, 10)));
1018 printf_filtered (_("Kernel instr pointer: %s\n"),
1019 hex_string (strtoulst (p
, &p
, 10)));
1021 printf_filtered (_("Pending signals bitmap: %s\n"),
1022 hex_string (strtoulst (p
, &p
, 10)));
1024 printf_filtered (_("Blocked signals bitmap: %s\n"),
1025 hex_string (strtoulst (p
, &p
, 10)));
1027 printf_filtered (_("Ignored signals bitmap: %s\n"),
1028 hex_string (strtoulst (p
, &p
, 10)));
1030 printf_filtered (_("Catched signals bitmap: %s\n"),
1031 hex_string (strtoulst (p
, &p
, 10)));
1033 printf_filtered (_("wchan (system call): %s\n"),
1034 hex_string (strtoulst (p
, &p
, 10)));
1038 warning (_("unable to open /proc file '%s'"), filename
);
1042 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1045 This function reads the NT_FILE note (which BFD turns into the
1046 section ".note.linuxcore.file"). The format of this note / section
1047 is described as follows in the Linux kernel sources in
1050 long count -- how many files are mapped
1051 long page_size -- units for file_ofs
1052 array of [COUNT] elements of
1056 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1058 CBFD is the BFD of the core file.
1060 PRE_LOOP_CB is the callback function to invoke prior to starting
1061 the loop which processes individual entries. This callback will
1062 only be executed after the note has been examined in enough
1063 detail to verify that it's not malformed in some way.
1065 LOOP_CB is the callback function that will be executed once
1066 for each mapping. */
1069 linux_read_core_file_mappings (struct gdbarch
*gdbarch
,
1071 gdb::function_view
<void (ULONGEST count
)>
1073 gdb::function_view
<void (int num
,
1077 const char *filename
)>
1080 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1081 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1083 /* It's not required that the NT_FILE note exists, so return silently
1084 if it's not found. Beyond this point though, we'll complain
1085 if problems are found. */
1086 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1087 if (section
== nullptr)
1090 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1091 unsigned int addr_size
= addr_size_bits
/ 8;
1092 size_t note_size
= bfd_section_size (section
);
1094 if (note_size
< 2 * addr_size
)
1096 warning (_("malformed core note - too short for header"));
1100 gdb::def_vector
<gdb_byte
> contents (note_size
);
1101 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1104 warning (_("could not get core note contents"));
1108 gdb_byte
*descdata
= contents
.data ();
1109 char *descend
= (char *) descdata
+ note_size
;
1111 if (descdata
[note_size
- 1] != '\0')
1113 warning (_("malformed note - does not end with \\0"));
1117 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1118 descdata
+= addr_size
;
1120 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1121 descdata
+= addr_size
;
1123 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1125 warning (_("malformed note - too short for supplied file count"));
1129 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1131 /* Make sure that the correct number of filenames exist. Complain
1132 if there aren't enough or are too many. */
1133 char *f
= filenames
;
1134 for (int i
= 0; i
< count
; i
++)
1138 warning (_("malformed note - filename area is too small"));
1141 f
+= strnlen (f
, descend
- f
) + 1;
1143 /* Complain, but don't return early if the filename area is too big. */
1145 warning (_("malformed note - filename area is too big"));
1147 pre_loop_cb (count
);
1149 for (int i
= 0; i
< count
; i
++)
1151 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1152 descdata
+= addr_size
;
1153 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1154 descdata
+= addr_size
;
1156 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1157 descdata
+= addr_size
;
1158 char * filename
= filenames
;
1159 filenames
+= strlen ((char *) filenames
) + 1;
1161 loop_cb (i
, start
, end
, file_ofs
, filename
);
1165 /* Implement "info proc mappings" for a corefile. */
1168 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1170 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1171 [=] (ULONGEST count
)
1173 printf_filtered (_("Mapped address spaces:\n\n"));
1174 if (gdbarch_addr_bit (gdbarch
) == 32)
1176 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1179 " Size", " Offset", "objfile");
1183 printf_filtered (" %18s %18s %10s %10s %s\n",
1186 " Size", " Offset", "objfile");
1189 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1190 const char *filename
)
1192 if (gdbarch_addr_bit (gdbarch
) == 32)
1193 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1194 paddress (gdbarch
, start
),
1195 paddress (gdbarch
, end
),
1196 hex_string (end
- start
),
1197 hex_string (file_ofs
),
1200 printf_filtered (" %18s %18s %10s %10s %s\n",
1201 paddress (gdbarch
, start
),
1202 paddress (gdbarch
, end
),
1203 hex_string (end
- start
),
1204 hex_string (file_ofs
),
1209 /* Implement "info proc" for a corefile. */
1212 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1213 enum info_proc_what what
)
1215 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1216 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1222 exe
= bfd_core_file_failing_command (core_bfd
);
1224 printf_filtered ("exe = '%s'\n", exe
);
1226 warning (_("unable to find command name in core file"));
1230 linux_core_info_proc_mappings (gdbarch
, args
);
1232 if (!exe_f
&& !mappings_f
)
1233 error (_("unable to handle request"));
1236 /* Read siginfo data from the core, if possible. Returns -1 on
1237 failure. Otherwise, returns the number of bytes read. READBUF,
1238 OFFSET, and LEN are all as specified by the to_xfer_partial
1242 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1243 ULONGEST offset
, ULONGEST len
)
1245 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1246 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1247 if (section
== NULL
)
1250 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1256 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1257 ULONGEST offset
, ULONGEST inode
,
1258 int read
, int write
,
1259 int exec
, int modified
,
1260 const char *filename
,
1263 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags
,
1264 const struct smaps_vmflags
*v
,
1265 int maybe_private_p
,
1268 const char *filename
,
1272 /* List memory regions in the inferior for a corefile. */
1275 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1276 linux_dump_mapping_p_ftype
*should_dump_mapping_p
,
1277 linux_find_memory_region_ftype
*func
,
1280 char mapsfilename
[100];
1281 char coredumpfilter_name
[100];
1283 /* Default dump behavior of coredump_filter (0x33), according to
1284 Documentation/filesystems/proc.txt from the Linux kernel
1286 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1287 | COREFILTER_ANON_SHARED
1288 | COREFILTER_ELF_HEADERS
1289 | COREFILTER_HUGETLB_PRIVATE
);
1291 /* We need to know the real target PID to access /proc. */
1292 if (current_inferior ()->fake_pid_p
)
1295 pid
= current_inferior ()->pid
;
1297 if (use_coredump_filter
)
1299 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1300 "/proc/%d/coredump_filter", pid
);
1301 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1302 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1303 if (coredumpfilterdata
!= NULL
)
1307 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1308 filterflags
= (enum filter_flag
) flags
;
1312 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1313 gdb::unique_xmalloc_ptr
<char> data
1314 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1317 /* Older Linux kernels did not support /proc/PID/smaps. */
1318 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1319 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1326 line
= strtok_r (data
.get (), "\n", &t
);
1327 while (line
!= NULL
)
1329 ULONGEST addr
, endaddr
, offset
, inode
;
1330 const char *permissions
, *device
, *filename
;
1331 struct smaps_vmflags v
;
1332 size_t permissions_len
, device_len
;
1333 int read
, write
, exec
, priv
;
1334 int has_anonymous
= 0;
1335 int should_dump_p
= 0;
1339 memset (&v
, 0, sizeof (v
));
1340 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1341 &offset
, &device
, &device_len
, &inode
, &filename
);
1342 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1343 /* If the mapping is not anonymous, then we can consider it
1344 to be file-backed. These two states (anonymous or
1345 file-backed) seem to be exclusive, but they can actually
1346 coexist. For example, if a file-backed mapping has
1347 "Anonymous:" pages (see more below), then the Linux
1348 kernel will dump this mapping when the user specified
1349 that she only wants anonymous mappings in the corefile
1350 (*even* when she explicitly disabled the dumping of
1351 file-backed mappings). */
1352 mapping_file_p
= !mapping_anon_p
;
1354 /* Decode permissions. */
1355 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1356 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1357 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1358 /* 'private' here actually means VM_MAYSHARE, and not
1359 VM_SHARED. In order to know if a mapping is really
1360 private or not, we must check the flag "sh" in the
1361 VmFlags field. This is done by decode_vmflags. However,
1362 if we are using a Linux kernel released before the commit
1363 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1364 not have the VmFlags there. In this case, there is
1365 really no way to know if we are dealing with VM_SHARED,
1366 so we just assume that VM_MAYSHARE is enough. */
1367 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1369 /* Try to detect if region should be dumped by parsing smaps
1371 for (line
= strtok_r (NULL
, "\n", &t
);
1372 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1373 line
= strtok_r (NULL
, "\n", &t
))
1375 char keyword
[64 + 1];
1377 if (sscanf (line
, "%64s", keyword
) != 1)
1379 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1383 if (strcmp (keyword
, "Anonymous:") == 0)
1385 /* Older Linux kernels did not support the
1386 "Anonymous:" counter. Check it here. */
1389 else if (strcmp (keyword
, "VmFlags:") == 0)
1390 decode_vmflags (line
, &v
);
1392 if (strcmp (keyword
, "AnonHugePages:") == 0
1393 || strcmp (keyword
, "Anonymous:") == 0)
1395 unsigned long number
;
1397 if (sscanf (line
, "%*s%lu", &number
) != 1)
1399 warning (_("Error parsing {s,}maps file '%s' number"),
1405 /* Even if we are dealing with a file-backed
1406 mapping, if it contains anonymous pages we
1407 consider it to be *also* an anonymous
1408 mapping, because this is what the Linux
1411 // Dump segments that have been written to.
1412 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1415 Note that if the mapping is already marked as
1416 file-backed (i.e., mapping_file_p is
1417 non-zero), then this is a special case, and
1418 this mapping will be dumped either when the
1419 user wants to dump file-backed *or* anonymous
1427 should_dump_p
= should_dump_mapping_p (filterflags
, &v
, priv
,
1430 filename
, addr
, offset
);
1433 /* Older Linux kernels did not support the "Anonymous:" counter.
1434 If it is missing, we can't be sure - dump all the pages. */
1438 /* Invoke the callback function to create the corefile segment. */
1440 func (addr
, endaddr
- addr
, offset
, inode
,
1441 read
, write
, exec
, 1, /* MODIFIED is true because we
1442 want to dump the mapping. */
1452 /* A structure for passing information through
1453 linux_find_memory_regions_full. */
1455 struct linux_find_memory_regions_data
1457 /* The original callback. */
1459 find_memory_region_ftype func
;
1461 /* The original datum. */
1466 /* A callback for linux_find_memory_regions that converts between the
1467 "full"-style callback and find_memory_region_ftype. */
1470 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1471 ULONGEST offset
, ULONGEST inode
,
1472 int read
, int write
, int exec
, int modified
,
1473 const char *filename
, void *arg
)
1475 struct linux_find_memory_regions_data
*data
1476 = (struct linux_find_memory_regions_data
*) arg
;
1478 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1481 /* A variant of linux_find_memory_regions_full that is suitable as the
1482 gdbarch find_memory_regions method. */
1485 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1486 find_memory_region_ftype func
, void *obfd
)
1488 struct linux_find_memory_regions_data data
;
1493 return linux_find_memory_regions_full (gdbarch
,
1495 linux_find_memory_regions_thunk
,
1499 /* This is used to pass information from
1500 linux_make_mappings_corefile_notes through
1501 linux_find_memory_regions_full. */
1503 struct linux_make_mappings_data
1505 /* Number of files mapped. */
1506 ULONGEST file_count
;
1508 /* The obstack for the main part of the data. */
1509 struct obstack
*data_obstack
;
1511 /* The filename obstack. */
1512 struct obstack
*filename_obstack
;
1514 /* The architecture's "long" type. */
1515 struct type
*long_type
;
1518 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1520 /* A callback for linux_find_memory_regions_full that updates the
1521 mappings data for linux_make_mappings_corefile_notes. */
1524 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1525 ULONGEST offset
, ULONGEST inode
,
1526 int read
, int write
, int exec
, int modified
,
1527 const char *filename
, void *data
)
1529 struct linux_make_mappings_data
*map_data
1530 = (struct linux_make_mappings_data
*) data
;
1531 gdb_byte buf
[sizeof (ULONGEST
)];
1533 if (*filename
== '\0' || inode
== 0)
1536 ++map_data
->file_count
;
1538 pack_long (buf
, map_data
->long_type
, vaddr
);
1539 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1540 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1541 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1542 pack_long (buf
, map_data
->long_type
, offset
);
1543 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1545 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1550 /* Write the file mapping data to the core file, if possible. OBFD is
1551 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1552 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1555 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1556 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1559 struct linux_make_mappings_data mapping_data
;
1560 struct type
*long_type
1561 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1562 gdb_byte buf
[sizeof (ULONGEST
)];
1564 auto_obstack data_obstack
, filename_obstack
;
1566 mapping_data
.file_count
= 0;
1567 mapping_data
.data_obstack
= &data_obstack
;
1568 mapping_data
.filename_obstack
= &filename_obstack
;
1569 mapping_data
.long_type
= long_type
;
1571 /* Reserve space for the count. */
1572 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1573 /* We always write the page size as 1 since we have no good way to
1574 determine the correct value. */
1575 pack_long (buf
, long_type
, 1);
1576 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1578 linux_find_memory_regions_full (gdbarch
,
1580 linux_make_mappings_callback
,
1583 if (mapping_data
.file_count
!= 0)
1585 /* Write the count to the obstack. */
1586 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1587 long_type
, mapping_data
.file_count
);
1589 /* Copy the filenames to the data obstack. */
1590 int size
= obstack_object_size (&filename_obstack
);
1591 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1594 note_data
.reset (elfcore_write_file_note (obfd
, note_data
.release (), note_size
,
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 (current_inferior ());
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. */
2536 displaced_step_prepare_status
2537 linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2538 CORE_ADDR
&displaced_pc
)
2540 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2542 if (!per_inferior
->disp_step_bufs
.has_value ())
2544 /* Figure out the location of the buffers. They are contiguous, starting
2545 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2546 CORE_ADDR disp_step_buf_addr
2547 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2548 int buf_len
= gdbarch_max_insn_length (arch
);
2550 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (arch
);
2551 gdb_assert (gdbarch_data
->num_disp_step_buffers
> 0);
2553 std::vector
<CORE_ADDR
> buffers
;
2554 for (int i
= 0; i
< gdbarch_data
->num_disp_step_buffers
; i
++)
2555 buffers
.push_back (disp_step_buf_addr
+ i
* buf_len
);
2557 per_inferior
->disp_step_bufs
.emplace (buffers
);
2560 return per_inferior
->disp_step_bufs
->prepare (thread
, displaced_pc
);
2563 /* See linux-tdep.h. */
2565 displaced_step_finish_status
2566 linux_displaced_step_finish (gdbarch
*arch
, thread_info
*thread
, gdb_signal sig
)
2568 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2570 gdb_assert (per_inferior
->disp_step_bufs
.has_value ());
2572 return per_inferior
->disp_step_bufs
->finish (arch
, thread
, sig
);
2575 /* See linux-tdep.h. */
2577 const displaced_step_copy_insn_closure
*
2578 linux_displaced_step_copy_insn_closure_by_addr (inferior
*inf
, CORE_ADDR addr
)
2580 linux_info
*per_inferior
= linux_inferior_data
.get (inf
);
2582 if (per_inferior
== nullptr
2583 || !per_inferior
->disp_step_bufs
.has_value ())
2586 return per_inferior
->disp_step_bufs
->copy_insn_closure_by_addr (addr
);
2589 /* See linux-tdep.h. */
2592 linux_displaced_step_restore_all_in_ptid (inferior
*parent_inf
, ptid_t ptid
)
2594 linux_info
*per_inferior
= linux_inferior_data
.get (parent_inf
);
2596 if (per_inferior
== nullptr
2597 || !per_inferior
->disp_step_bufs
.has_value ())
2600 per_inferior
->disp_step_bufs
->restore_in_ptid (ptid
);
2603 /* See linux-tdep.h. */
2606 linux_get_hwcap (struct target_ops
*target
)
2609 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2614 /* See linux-tdep.h. */
2617 linux_get_hwcap2 (struct target_ops
*target
)
2620 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2625 /* Display whether the gcore command is using the
2626 /proc/PID/coredump_filter file. */
2629 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2630 struct cmd_list_element
*c
, const char *value
)
2632 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2633 " corefiles is %s.\n"), value
);
2636 /* Display whether the gcore command is dumping mappings marked with
2637 the VM_DONTDUMP flag. */
2640 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2641 struct cmd_list_element
*c
, const char *value
)
2643 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2644 " flag is %s.\n"), value
);
2647 /* To be called from the various GDB_OSABI_LINUX handlers for the
2648 various GNU/Linux architectures and machine types.
2650 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2651 displaced stepping is not supported. */
2654 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
,
2655 int num_disp_step_buffers
)
2657 if (num_disp_step_buffers
> 0)
2659 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
2660 gdbarch_data
->num_disp_step_buffers
= num_disp_step_buffers
;
2662 set_gdbarch_displaced_step_prepare (gdbarch
,
2663 linux_displaced_step_prepare
);
2664 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
2665 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2666 (gdbarch
, linux_displaced_step_copy_insn_closure_by_addr
);
2667 set_gdbarch_displaced_step_restore_all_in_ptid
2668 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
2671 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2672 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2673 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2674 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2675 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2676 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2677 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2678 set_gdbarch_has_shared_address_space (gdbarch
,
2679 linux_has_shared_address_space
);
2680 set_gdbarch_gdb_signal_from_target (gdbarch
,
2681 linux_gdb_signal_from_target
);
2682 set_gdbarch_gdb_signal_to_target (gdbarch
,
2683 linux_gdb_signal_to_target
);
2684 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2685 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2686 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2687 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2690 void _initialize_linux_tdep ();
2692 _initialize_linux_tdep ()
2694 linux_gdbarch_data_handle
=
2695 gdbarch_data_register_pre_init (init_linux_gdbarch_data
);
2697 /* Observers used to invalidate the cache when needed. */
2698 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2699 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2700 gdb::observers::inferior_execd
.attach (invalidate_linux_cache_inf
);
2702 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2703 &use_coredump_filter
, _("\
2704 Set whether gcore should consider /proc/PID/coredump_filter."),
2706 Show whether gcore should consider /proc/PID/coredump_filter."),
2708 Use this command to set whether gcore should consider the contents\n\
2709 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2710 about this file, refer to the manpage of core(5)."),
2711 NULL
, show_use_coredump_filter
,
2712 &setlist
, &showlist
);
2714 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2715 &dump_excluded_mappings
, _("\
2716 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2718 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2720 Use this command to set whether gcore should dump mappings marked with the\n\
2721 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2722 more information about this file, refer to the manpage of proc(5) and core(5)."),
2723 NULL
, show_dump_excluded_mappings
,
2724 &setlist
, &showlist
);