1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2022 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 "gdbsupport/gdb_obstack.h"
35 #include "observable.h"
39 #include "gdbsupport/gdb_regex.h"
40 #include "gdbsupport/enum-flags.h"
41 #include "gdbsupport/gdb_optional.h"
43 #include "gcore-elf.h"
44 #include "solib-svr4.h"
48 /* This enum represents the values that the user can choose when
49 informing the Linux kernel about which memory mappings will be
50 dumped in a corefile. They are described in the file
51 Documentation/filesystems/proc.txt, inside the Linux kernel
56 COREFILTER_ANON_PRIVATE
= 1 << 0,
57 COREFILTER_ANON_SHARED
= 1 << 1,
58 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
59 COREFILTER_MAPPED_SHARED
= 1 << 3,
60 COREFILTER_ELF_HEADERS
= 1 << 4,
61 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
62 COREFILTER_HUGETLB_SHARED
= 1 << 6,
64 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
66 /* This struct is used to map flags found in the "VmFlags:" field (in
67 the /proc/<PID>/smaps file). */
71 /* Zero if this structure has not been initialized yet. It
72 probably means that the Linux kernel being used does not emit
73 the "VmFlags:" field on "/proc/PID/smaps". */
75 unsigned int initialized_p
: 1;
77 /* Memory mapped I/O area (VM_IO, "io"). */
79 unsigned int io_page
: 1;
81 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
83 unsigned int uses_huge_tlb
: 1;
85 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
87 unsigned int exclude_coredump
: 1;
89 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
91 unsigned int shared_mapping
: 1;
93 /* Memory map has memory tagging enabled. */
95 unsigned int memory_tagging
: 1;
98 /* Data structure that holds the information contained in the
99 /proc/<pid>/smaps file. */
103 ULONGEST start_address
;
104 ULONGEST end_address
;
105 std::string filename
;
106 struct smaps_vmflags vmflags
;
119 /* Whether to take the /proc/PID/coredump_filter into account when
120 generating a corefile. */
122 static bool use_coredump_filter
= true;
124 /* Whether the value of smaps_vmflags->exclude_coredump should be
125 ignored, including mappings marked with the VM_DONTDUMP flag in
127 static bool dump_excluded_mappings
= false;
129 /* This enum represents the signals' numbers on a generic architecture
130 running the Linux kernel. The definition of "generic" comes from
131 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
132 tree, which is the "de facto" implementation of signal numbers to
133 be used by new architecture ports.
135 For those architectures which have differences between the generic
136 standard (e.g., Alpha), we define the different signals (and *only*
137 those) in the specific target-dependent file (e.g.,
138 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
139 tdep file for more information.
141 ARM deserves a special mention here. On the file
142 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
143 (and ARM-only) signal, which is SIGSWI, with the same number as
144 SIGRTMIN. This signal is used only for a very specific target,
145 called ArthurOS (from RISCOS). Therefore, we do not handle it on
146 the ARM-tdep file, and we can safely use the generic signal handler
147 here for ARM targets.
149 As stated above, this enum is derived from
150 <include/uapi/asm-generic/signal.h>, from the Linux kernel
171 LINUX_SIGSTKFLT
= 16,
181 LINUX_SIGVTALRM
= 26,
185 LINUX_SIGPOLL
= LINUX_SIGIO
,
188 LINUX_SIGUNUSED
= 31,
194 static struct gdbarch_data
*linux_gdbarch_data_handle
;
196 struct linux_gdbarch_data
198 struct type
*siginfo_type
;
199 int num_disp_step_buffers
;
203 init_linux_gdbarch_data (struct obstack
*obstack
)
205 return obstack_zalloc
<linux_gdbarch_data
> (obstack
);
208 static struct linux_gdbarch_data
*
209 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
211 return ((struct linux_gdbarch_data
*)
212 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
215 /* Linux-specific cached data. This is used by GDB for caching
216 purposes for each inferior. This helps reduce the overhead of
217 transfering data from a remote target to the local host. */
220 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
221 if VSYSCALL_RANGE_P is positive. This is cached because getting
222 at this info requires an auxv lookup (which is itself cached),
223 and looking through the inferior's mappings (which change
224 throughout execution and therefore cannot be cached). */
225 struct mem_range vsyscall_range
{};
227 /* Zero if we haven't tried looking up the vsyscall's range before
228 yet. Positive if we tried looking it up, and found it. Negative
229 if we tried looking it up but failed. */
230 int vsyscall_range_p
= 0;
232 /* Inferior's displaced step buffers. */
233 gdb::optional
<displaced_step_buffers
> disp_step_bufs
;
236 /* Per-inferior data key. */
237 static const struct inferior_key
<linux_info
> linux_inferior_data
;
239 /* Frees whatever allocated space there is to be freed and sets INF's
240 linux cache data pointer to NULL. */
243 invalidate_linux_cache_inf (struct inferior
*inf
)
245 linux_inferior_data
.clear (inf
);
248 /* Fetch the linux cache info for INF. This function always returns a
249 valid INFO pointer. */
251 static struct linux_info
*
252 get_linux_inferior_data (inferior
*inf
)
254 linux_info
*info
= linux_inferior_data
.get (inf
);
257 info
= linux_inferior_data
.emplace (inf
);
262 /* See linux-tdep.h. */
265 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
266 linux_siginfo_extra_fields extra_fields
)
268 struct linux_gdbarch_data
*linux_gdbarch_data
;
269 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
270 struct type
*uid_type
, *pid_type
;
271 struct type
*sigval_type
, *clock_type
;
272 struct type
*siginfo_type
, *sifields_type
;
275 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
276 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
277 return linux_gdbarch_data
->siginfo_type
;
279 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
281 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
283 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
285 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
287 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
290 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
291 sigval_type
->set_name (xstrdup ("sigval_t"));
292 append_composite_type_field (sigval_type
, "sival_int", int_type
);
293 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
296 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
297 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
298 TYPE_TARGET_TYPE (pid_type
) = int_type
;
299 pid_type
->set_target_is_stub (true);
302 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
303 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
304 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
305 uid_type
->set_target_is_stub (true);
308 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
309 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
311 TYPE_TARGET_TYPE (clock_type
) = long_type
;
312 clock_type
->set_target_is_stub (true);
315 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
318 const int si_max_size
= 128;
320 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
323 if (gdbarch_ptr_bit (gdbarch
) == 64)
324 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
326 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
327 append_composite_type_field (sifields_type
, "_pad",
328 init_vector_type (int_type
, si_pad_size
));
332 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
333 append_composite_type_field (type
, "si_pid", pid_type
);
334 append_composite_type_field (type
, "si_uid", uid_type
);
335 append_composite_type_field (sifields_type
, "_kill", type
);
338 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
339 append_composite_type_field (type
, "si_tid", int_type
);
340 append_composite_type_field (type
, "si_overrun", int_type
);
341 append_composite_type_field (type
, "si_sigval", sigval_type
);
342 append_composite_type_field (sifields_type
, "_timer", type
);
345 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
346 append_composite_type_field (type
, "si_pid", pid_type
);
347 append_composite_type_field (type
, "si_uid", uid_type
);
348 append_composite_type_field (type
, "si_sigval", sigval_type
);
349 append_composite_type_field (sifields_type
, "_rt", type
);
352 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
353 append_composite_type_field (type
, "si_pid", pid_type
);
354 append_composite_type_field (type
, "si_uid", uid_type
);
355 append_composite_type_field (type
, "si_status", int_type
);
356 append_composite_type_field (type
, "si_utime", clock_type
);
357 append_composite_type_field (type
, "si_stime", clock_type
);
358 append_composite_type_field (sifields_type
, "_sigchld", type
);
361 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
362 append_composite_type_field (type
, "si_addr", void_ptr_type
);
364 /* Additional bound fields for _sigfault in case they were requested. */
365 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
367 struct type
*sigfault_bnd_fields
;
369 append_composite_type_field (type
, "_addr_lsb", short_type
);
370 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
371 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
372 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
373 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
375 append_composite_type_field (sifields_type
, "_sigfault", type
);
378 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
379 append_composite_type_field (type
, "si_band", long_type
);
380 append_composite_type_field (type
, "si_fd", int_type
);
381 append_composite_type_field (sifields_type
, "_sigpoll", type
);
384 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
385 append_composite_type_field (type
, "_call_addr", void_ptr_type
);
386 append_composite_type_field (type
, "_syscall", int_type
);
387 append_composite_type_field (type
, "_arch", uint_type
);
388 append_composite_type_field (sifields_type
, "_sigsys", type
);
391 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
392 siginfo_type
->set_name (xstrdup ("siginfo"));
393 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
394 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
395 append_composite_type_field (siginfo_type
, "si_code", int_type
);
396 append_composite_type_field_aligned (siginfo_type
,
397 "_sifields", sifields_type
,
398 TYPE_LENGTH (long_type
));
400 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
405 /* This function is suitable for architectures that don't
406 extend/override the standard siginfo structure. */
409 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
411 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
414 /* Return true if the target is running on uClinux instead of normal
418 linux_is_uclinux (void)
421 target_ops
*target
= current_inferior ()->top_target ();
423 return (target_auxv_search (target
, AT_NULL
, &dummy
) > 0
424 && target_auxv_search (target
, AT_PAGESZ
, &dummy
) == 0);
428 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
430 return linux_is_uclinux ();
433 /* This is how we want PTIDs from core files to be printed. */
436 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
438 if (ptid
.lwp () != 0)
439 return string_printf ("LWP %ld", ptid
.lwp ());
441 return normal_pid_to_str (ptid
);
444 /* Service function for corefiles and info proc. */
447 read_mapping (const char *line
,
448 ULONGEST
*addr
, ULONGEST
*endaddr
,
449 const char **permissions
, size_t *permissions_len
,
451 const char **device
, size_t *device_len
,
453 const char **filename
)
455 const char *p
= line
;
457 *addr
= strtoulst (p
, &p
, 16);
460 *endaddr
= strtoulst (p
, &p
, 16);
464 while (*p
&& !isspace (*p
))
466 *permissions_len
= p
- *permissions
;
468 *offset
= strtoulst (p
, &p
, 16);
472 while (*p
&& !isspace (*p
))
474 *device_len
= p
- *device
;
476 *inode
= strtoulst (p
, &p
, 10);
482 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
484 This function was based on the documentation found on
485 <Documentation/filesystems/proc.txt>, on the Linux kernel.
487 Linux kernels before commit
488 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
492 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
494 char *saveptr
= NULL
;
497 v
->initialized_p
= 1;
498 p
= skip_to_space (p
);
501 for (s
= strtok_r (p
, " ", &saveptr
);
503 s
= strtok_r (NULL
, " ", &saveptr
))
505 if (strcmp (s
, "io") == 0)
507 else if (strcmp (s
, "ht") == 0)
508 v
->uses_huge_tlb
= 1;
509 else if (strcmp (s
, "dd") == 0)
510 v
->exclude_coredump
= 1;
511 else if (strcmp (s
, "sh") == 0)
512 v
->shared_mapping
= 1;
513 else if (strcmp (s
, "mt") == 0)
514 v
->memory_tagging
= 1;
518 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
519 they're initialized lazily. */
521 struct mapping_regexes
523 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
524 string in the end). We know for sure, based on the Linux kernel
525 code, that memory mappings whose associated filename is
526 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
527 compiled_regex dev_zero
528 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
529 _("Could not compile regex to match /dev/zero filename")};
531 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
532 string in the end). These filenames refer to shared memory
533 (shmem), and memory mappings associated with them are
534 MAP_ANONYMOUS as well. */
535 compiled_regex shmem_file
536 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
537 _("Could not compile regex to match shmem filenames")};
539 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
540 0' code, which is responsible to decide if it is dealing with a
541 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
542 FILE_DELETED matches, it does not necessarily mean that we are
543 dealing with an anonymous shared mapping. However, there is no
544 easy way to detect this currently, so this is the best
545 approximation we have.
547 As a result, GDB will dump readonly pages of deleted executables
548 when using the default value of coredump_filter (0x33), while the
549 Linux kernel will not dump those pages. But we can live with
551 compiled_regex file_deleted
552 {" (deleted)$", REG_NOSUB
,
553 _("Could not compile regex to match '<file> (deleted)'")};
556 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
558 FILENAME is the name of the file present in the first line of the
559 memory mapping, in the "/proc/PID/smaps" output. For example, if
562 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
564 Then FILENAME will be "/path/to/file". */
567 mapping_is_anonymous_p (const char *filename
)
569 static gdb::optional
<mapping_regexes
> regexes
;
570 static int init_regex_p
= 0;
574 /* Let's be pessimistic and assume there will be an error while
575 compiling the regex'es. */
580 /* If we reached this point, then everything succeeded. */
584 if (init_regex_p
== -1)
586 const char deleted
[] = " (deleted)";
587 size_t del_len
= sizeof (deleted
) - 1;
588 size_t filename_len
= strlen (filename
);
590 /* There was an error while compiling the regex'es above. In
591 order to try to give some reliable information to the caller,
592 we just try to find the string " (deleted)" in the filename.
593 If we managed to find it, then we assume the mapping is
595 return (filename_len
>= del_len
596 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
599 if (*filename
== '\0'
600 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
601 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
602 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
608 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
609 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
610 be dumped, or greater than 0 if it should.
612 In a nutshell, this is the logic that we follow in order to decide
613 if a mapping should be dumped or not.
615 - If the mapping is associated to a file whose name ends with
616 " (deleted)", or if the file is "/dev/zero", or if it is
617 "/SYSV%08x" (shared memory), or if there is no file associated
618 with it, or if the AnonHugePages: or the Anonymous: fields in the
619 /proc/PID/smaps have contents, then GDB considers this mapping to
620 be anonymous. Otherwise, GDB considers this mapping to be a
621 file-backed mapping (because there will be a file associated with
624 It is worth mentioning that, from all those checks described
625 above, the most fragile is the one to see if the file name ends
626 with " (deleted)". This does not necessarily mean that the
627 mapping is anonymous, because the deleted file associated with
628 the mapping may have been a hard link to another file, for
629 example. The Linux kernel checks to see if "i_nlink == 0", but
630 GDB cannot easily (and normally) do this check (iff running as
631 root, it could find the mapping in /proc/PID/map_files/ and
632 determine whether there still are other hard links to the
633 inode/file). Therefore, we made a compromise here, and we assume
634 that if the file name ends with " (deleted)", then the mapping is
635 indeed anonymous. FWIW, this is something the Linux kernel could
636 do better: expose this information in a more direct way.
638 - If we see the flag "sh" in the "VmFlags:" field (in
639 /proc/PID/smaps), then certainly the memory mapping is shared
640 (VM_SHARED). If we have access to the VmFlags, and we don't see
641 the "sh" there, then certainly the mapping is private. However,
642 Linux kernels before commit
643 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
644 "VmFlags:" field; in that case, we use another heuristic: if we
645 see 'p' in the permission flags, then we assume that the mapping
646 is private, even though the presence of the 's' flag there would
647 mean VM_MAYSHARE, which means the mapping could still be private.
648 This should work OK enough, however.
650 - Even if, at the end, we decided that we should not dump the
651 mapping, we still have to check if it is something like an ELF
652 header (of a DSO or an executable, for example). If it is, and
653 if the user is interested in dump it, then we should dump it. */
656 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
657 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
658 const char *filename
, ULONGEST addr
, ULONGEST offset
)
660 /* Initially, we trust in what we received from our caller. This
661 value may not be very precise (i.e., it was probably gathered
662 from the permission line in the /proc/PID/smaps list, which
663 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
664 what we have until we take a look at the "VmFlags:" field
665 (assuming that the version of the Linux kernel being used
666 supports it, of course). */
667 int private_p
= maybe_private_p
;
670 /* We always dump vDSO and vsyscall mappings, because it's likely that
671 there'll be no file to read the contents from at core load time.
672 The kernel does the same. */
673 if (strcmp ("[vdso]", filename
) == 0
674 || strcmp ("[vsyscall]", filename
) == 0)
677 if (v
->initialized_p
)
679 /* We never dump I/O mappings. */
683 /* Check if we should exclude this mapping. */
684 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
687 /* Update our notion of whether this mapping is shared or
688 private based on a trustworthy value. */
689 private_p
= !v
->shared_mapping
;
691 /* HugeTLB checking. */
692 if (v
->uses_huge_tlb
)
694 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
695 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
704 if (mapping_anon_p
&& mapping_file_p
)
706 /* This is a special situation. It can happen when we see a
707 mapping that is file-backed, but that contains anonymous
709 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
710 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
712 else if (mapping_anon_p
)
713 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
715 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
719 if (mapping_anon_p
&& mapping_file_p
)
721 /* This is a special situation. It can happen when we see a
722 mapping that is file-backed, but that contains anonymous
724 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
725 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
727 else if (mapping_anon_p
)
728 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
730 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
733 /* Even if we decided that we shouldn't dump this mapping, we still
734 have to check whether (a) the user wants us to dump mappings
735 containing an ELF header, and (b) the mapping in question
736 contains an ELF header. If (a) and (b) are true, then we should
739 A mapping contains an ELF header if it is a private mapping, its
740 offset is zero, and its first word is ELFMAG. */
741 if (!dump_p
&& private_p
&& offset
== 0
742 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
744 /* Useful define specifying the size of the ELF magical
750 /* Let's check if we have an ELF header. */
752 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
754 /* The EI_MAG* and ELFMAG* constants come from
756 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
757 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
759 /* This mapping contains an ELF header, so we
769 /* As above, but return true only when we should dump the NT_FILE
773 dump_note_entry_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
774 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
775 const char *filename
, ULONGEST addr
, ULONGEST offset
)
777 /* vDSO and vsyscall mappings will end up in the core file. Don't
778 put them in the NT_FILE note. */
779 if (strcmp ("[vdso]", filename
) == 0
780 || strcmp ("[vsyscall]", filename
) == 0)
783 /* Otherwise, any other file-based mapping should be placed in the
788 /* Implement the "info proc" command. */
791 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
792 enum info_proc_what what
)
794 /* A long is used for pid instead of an int to avoid a loss of precision
795 compiler warning from the output of strtoul. */
797 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
798 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
799 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
800 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
801 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
802 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
806 if (args
&& isdigit (args
[0]))
810 pid
= strtoul (args
, &tem
, 10);
815 if (!target_has_execution ())
816 error (_("No current process: you must name one."));
817 if (current_inferior ()->fake_pid_p
)
818 error (_("Can't determine the current process's PID: you must name one."));
820 pid
= current_inferior ()->pid
;
823 args
= skip_spaces (args
);
825 error (_("Too many parameters: %s"), args
);
827 printf_filtered (_("process %ld\n"), pid
);
830 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
832 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
836 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
839 for (pos
= 0; pos
< len
- 1; pos
++)
841 if (buffer
[pos
] == '\0')
844 buffer
[len
- 1] = '\0';
845 printf_filtered ("cmdline = '%s'\n", buffer
);
848 warning (_("unable to open /proc file '%s'"), filename
);
852 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
853 gdb::optional
<std::string
> contents
854 = target_fileio_readlink (NULL
, filename
, &target_errno
);
855 if (contents
.has_value ())
856 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
858 warning (_("unable to read link '%s'"), filename
);
862 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
863 gdb::optional
<std::string
> contents
864 = target_fileio_readlink (NULL
, filename
, &target_errno
);
865 if (contents
.has_value ())
866 printf_filtered ("exe = '%s'\n", contents
->c_str ());
868 warning (_("unable to read link '%s'"), filename
);
872 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
873 gdb::unique_xmalloc_ptr
<char> map
874 = target_fileio_read_stralloc (NULL
, filename
);
879 printf_filtered (_("Mapped address spaces:\n\n"));
880 if (gdbarch_addr_bit (gdbarch
) == 32)
882 printf_filtered ("\t%10s %10s %10s %10s %s\n",
885 " Size", " Offset", "objfile");
889 printf_filtered (" %18s %18s %10s %10s %s\n",
892 " Size", " Offset", "objfile");
896 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
898 line
= strtok_r (NULL
, "\n", &saveptr
))
900 ULONGEST addr
, endaddr
, offset
, inode
;
901 const char *permissions
, *device
, *mapping_filename
;
902 size_t permissions_len
, device_len
;
904 read_mapping (line
, &addr
, &endaddr
,
905 &permissions
, &permissions_len
,
906 &offset
, &device
, &device_len
,
907 &inode
, &mapping_filename
);
909 if (gdbarch_addr_bit (gdbarch
) == 32)
911 printf_filtered ("\t%10s %10s %10s %10s %s\n",
912 paddress (gdbarch
, addr
),
913 paddress (gdbarch
, endaddr
),
914 hex_string (endaddr
- addr
),
916 *mapping_filename
? mapping_filename
: "");
920 printf_filtered (" %18s %18s %10s %10s %s\n",
921 paddress (gdbarch
, addr
),
922 paddress (gdbarch
, endaddr
),
923 hex_string (endaddr
- addr
),
925 *mapping_filename
? mapping_filename
: "");
930 warning (_("unable to open /proc file '%s'"), filename
);
934 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
935 gdb::unique_xmalloc_ptr
<char> status
936 = target_fileio_read_stralloc (NULL
, filename
);
938 puts_filtered (status
.get ());
940 warning (_("unable to open /proc file '%s'"), filename
);
944 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
945 gdb::unique_xmalloc_ptr
<char> statstr
946 = target_fileio_read_stralloc (NULL
, filename
);
949 const char *p
= statstr
.get ();
951 printf_filtered (_("Process: %s\n"),
952 pulongest (strtoulst (p
, &p
, 10)));
957 /* ps command also relies on no trailing fields
959 const char *ep
= strrchr (p
, ')');
962 printf_filtered ("Exec file: %.*s\n",
963 (int) (ep
- p
- 1), p
+ 1);
970 printf_filtered (_("State: %c\n"), *p
++);
973 printf_filtered (_("Parent process: %s\n"),
974 pulongest (strtoulst (p
, &p
, 10)));
976 printf_filtered (_("Process group: %s\n"),
977 pulongest (strtoulst (p
, &p
, 10)));
979 printf_filtered (_("Session id: %s\n"),
980 pulongest (strtoulst (p
, &p
, 10)));
982 printf_filtered (_("TTY: %s\n"),
983 pulongest (strtoulst (p
, &p
, 10)));
985 printf_filtered (_("TTY owner process group: %s\n"),
986 pulongest (strtoulst (p
, &p
, 10)));
989 printf_filtered (_("Flags: %s\n"),
990 hex_string (strtoulst (p
, &p
, 10)));
992 printf_filtered (_("Minor faults (no memory page): %s\n"),
993 pulongest (strtoulst (p
, &p
, 10)));
995 printf_filtered (_("Minor faults, children: %s\n"),
996 pulongest (strtoulst (p
, &p
, 10)));
998 printf_filtered (_("Major faults (memory page faults): %s\n"),
999 pulongest (strtoulst (p
, &p
, 10)));
1001 printf_filtered (_("Major faults, children: %s\n"),
1002 pulongest (strtoulst (p
, &p
, 10)));
1004 printf_filtered (_("utime: %s\n"),
1005 pulongest (strtoulst (p
, &p
, 10)));
1007 printf_filtered (_("stime: %s\n"),
1008 pulongest (strtoulst (p
, &p
, 10)));
1010 printf_filtered (_("utime, children: %s\n"),
1011 pulongest (strtoulst (p
, &p
, 10)));
1013 printf_filtered (_("stime, children: %s\n"),
1014 pulongest (strtoulst (p
, &p
, 10)));
1016 printf_filtered (_("jiffies remaining in current "
1017 "time slice: %s\n"),
1018 pulongest (strtoulst (p
, &p
, 10)));
1020 printf_filtered (_("'nice' value: %s\n"),
1021 pulongest (strtoulst (p
, &p
, 10)));
1023 printf_filtered (_("jiffies until next timeout: %s\n"),
1024 pulongest (strtoulst (p
, &p
, 10)));
1026 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
1027 pulongest (strtoulst (p
, &p
, 10)));
1029 printf_filtered (_("start time (jiffies since "
1030 "system boot): %s\n"),
1031 pulongest (strtoulst (p
, &p
, 10)));
1033 printf_filtered (_("Virtual memory size: %s\n"),
1034 pulongest (strtoulst (p
, &p
, 10)));
1036 printf_filtered (_("Resident set size: %s\n"),
1037 pulongest (strtoulst (p
, &p
, 10)));
1039 printf_filtered (_("rlim: %s\n"),
1040 pulongest (strtoulst (p
, &p
, 10)));
1042 printf_filtered (_("Start of text: %s\n"),
1043 hex_string (strtoulst (p
, &p
, 10)));
1045 printf_filtered (_("End of text: %s\n"),
1046 hex_string (strtoulst (p
, &p
, 10)));
1048 printf_filtered (_("Start of stack: %s\n"),
1049 hex_string (strtoulst (p
, &p
, 10)));
1050 #if 0 /* Don't know how architecture-dependent the rest is...
1051 Anyway the signal bitmap info is available from "status". */
1053 printf_filtered (_("Kernel stack pointer: %s\n"),
1054 hex_string (strtoulst (p
, &p
, 10)));
1056 printf_filtered (_("Kernel instr pointer: %s\n"),
1057 hex_string (strtoulst (p
, &p
, 10)));
1059 printf_filtered (_("Pending signals bitmap: %s\n"),
1060 hex_string (strtoulst (p
, &p
, 10)));
1062 printf_filtered (_("Blocked signals bitmap: %s\n"),
1063 hex_string (strtoulst (p
, &p
, 10)));
1065 printf_filtered (_("Ignored signals bitmap: %s\n"),
1066 hex_string (strtoulst (p
, &p
, 10)));
1068 printf_filtered (_("Catched signals bitmap: %s\n"),
1069 hex_string (strtoulst (p
, &p
, 10)));
1071 printf_filtered (_("wchan (system call): %s\n"),
1072 hex_string (strtoulst (p
, &p
, 10)));
1076 warning (_("unable to open /proc file '%s'"), filename
);
1080 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1083 This function reads the NT_FILE note (which BFD turns into the
1084 section ".note.linuxcore.file"). The format of this note / section
1085 is described as follows in the Linux kernel sources in
1088 long count -- how many files are mapped
1089 long page_size -- units for file_ofs
1090 array of [COUNT] elements of
1094 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1096 CBFD is the BFD of the core file.
1098 PRE_LOOP_CB is the callback function to invoke prior to starting
1099 the loop which processes individual entries. This callback will
1100 only be executed after the note has been examined in enough
1101 detail to verify that it's not malformed in some way.
1103 LOOP_CB is the callback function that will be executed once
1104 for each mapping. */
1107 linux_read_core_file_mappings
1108 (struct gdbarch
*gdbarch
,
1110 read_core_file_mappings_pre_loop_ftype pre_loop_cb
,
1111 read_core_file_mappings_loop_ftype loop_cb
)
1113 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1114 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1116 /* It's not required that the NT_FILE note exists, so return silently
1117 if it's not found. Beyond this point though, we'll complain
1118 if problems are found. */
1119 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1120 if (section
== nullptr)
1123 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1124 unsigned int addr_size
= addr_size_bits
/ 8;
1125 size_t note_size
= bfd_section_size (section
);
1127 if (note_size
< 2 * addr_size
)
1129 warning (_("malformed core note - too short for header"));
1133 gdb::def_vector
<gdb_byte
> contents (note_size
);
1134 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1137 warning (_("could not get core note contents"));
1141 gdb_byte
*descdata
= contents
.data ();
1142 char *descend
= (char *) descdata
+ note_size
;
1144 if (descdata
[note_size
- 1] != '\0')
1146 warning (_("malformed note - does not end with \\0"));
1150 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1151 descdata
+= addr_size
;
1153 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1154 descdata
+= addr_size
;
1156 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1158 warning (_("malformed note - too short for supplied file count"));
1162 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1164 /* Make sure that the correct number of filenames exist. Complain
1165 if there aren't enough or are too many. */
1166 char *f
= filenames
;
1167 for (int i
= 0; i
< count
; i
++)
1171 warning (_("malformed note - filename area is too small"));
1174 f
+= strnlen (f
, descend
- f
) + 1;
1176 /* Complain, but don't return early if the filename area is too big. */
1178 warning (_("malformed note - filename area is too big"));
1180 pre_loop_cb (count
);
1182 for (int i
= 0; i
< count
; i
++)
1184 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1185 descdata
+= addr_size
;
1186 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1187 descdata
+= addr_size
;
1189 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1190 descdata
+= addr_size
;
1191 char * filename
= filenames
;
1192 filenames
+= strlen ((char *) filenames
) + 1;
1194 loop_cb (i
, start
, end
, file_ofs
, filename
, nullptr);
1198 /* Implement "info proc mappings" for a corefile. */
1201 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1203 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1204 [=] (ULONGEST count
)
1206 printf_filtered (_("Mapped address spaces:\n\n"));
1207 if (gdbarch_addr_bit (gdbarch
) == 32)
1209 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1212 " Size", " Offset", "objfile");
1216 printf_filtered (" %18s %18s %10s %10s %s\n",
1219 " Size", " Offset", "objfile");
1222 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1223 const char *filename
, const bfd_build_id
*build_id
)
1225 if (gdbarch_addr_bit (gdbarch
) == 32)
1226 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1227 paddress (gdbarch
, start
),
1228 paddress (gdbarch
, end
),
1229 hex_string (end
- start
),
1230 hex_string (file_ofs
),
1233 printf_filtered (" %18s %18s %10s %10s %s\n",
1234 paddress (gdbarch
, start
),
1235 paddress (gdbarch
, end
),
1236 hex_string (end
- start
),
1237 hex_string (file_ofs
),
1242 /* Implement "info proc" for a corefile. */
1245 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1246 enum info_proc_what what
)
1248 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1249 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1255 exe
= bfd_core_file_failing_command (core_bfd
);
1257 printf_filtered ("exe = '%s'\n", exe
);
1259 warning (_("unable to find command name in core file"));
1263 linux_core_info_proc_mappings (gdbarch
, args
);
1265 if (!exe_f
&& !mappings_f
)
1266 error (_("unable to handle request"));
1269 /* Read siginfo data from the core, if possible. Returns -1 on
1270 failure. Otherwise, returns the number of bytes read. READBUF,
1271 OFFSET, and LEN are all as specified by the to_xfer_partial
1275 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1276 ULONGEST offset
, ULONGEST len
)
1278 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1279 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1280 if (section
== NULL
)
1283 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1289 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1290 ULONGEST offset
, ULONGEST inode
,
1291 int read
, int write
,
1292 int exec
, int modified
,
1293 const char *filename
,
1296 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags
,
1297 const struct smaps_vmflags
*v
,
1298 int maybe_private_p
,
1301 const char *filename
,
1305 /* Helper function to parse the contents of /proc/<pid>/smaps into a data
1306 structure, for easy access.
1308 DATA is the contents of the smaps file. The parsed contents are stored
1309 into the SMAPS vector. */
1311 static std::vector
<struct smaps_data
>
1312 parse_smaps_data (const char *data
,
1313 const std::string maps_filename
)
1317 gdb_assert (data
!= nullptr);
1319 line
= strtok_r ((char *) data
, "\n", &t
);
1321 std::vector
<struct smaps_data
> smaps
;
1323 while (line
!= NULL
)
1325 ULONGEST addr
, endaddr
, offset
, inode
;
1326 const char *permissions
, *device
, *filename
;
1327 struct smaps_vmflags v
;
1328 size_t permissions_len
, device_len
;
1329 int read
, write
, exec
, priv
;
1330 int has_anonymous
= 0;
1334 memset (&v
, 0, sizeof (v
));
1335 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1336 &offset
, &device
, &device_len
, &inode
, &filename
);
1337 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1338 /* If the mapping is not anonymous, then we can consider it
1339 to be file-backed. These two states (anonymous or
1340 file-backed) seem to be exclusive, but they can actually
1341 coexist. For example, if a file-backed mapping has
1342 "Anonymous:" pages (see more below), then the Linux
1343 kernel will dump this mapping when the user specified
1344 that she only wants anonymous mappings in the corefile
1345 (*even* when she explicitly disabled the dumping of
1346 file-backed mappings). */
1347 mapping_file_p
= !mapping_anon_p
;
1349 /* Decode permissions. */
1350 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1351 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1352 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1353 /* 'private' here actually means VM_MAYSHARE, and not
1354 VM_SHARED. In order to know if a mapping is really
1355 private or not, we must check the flag "sh" in the
1356 VmFlags field. This is done by decode_vmflags. However,
1357 if we are using a Linux kernel released before the commit
1358 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1359 not have the VmFlags there. In this case, there is
1360 really no way to know if we are dealing with VM_SHARED,
1361 so we just assume that VM_MAYSHARE is enough. */
1362 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1364 /* Try to detect if region should be dumped by parsing smaps
1366 for (line
= strtok_r (NULL
, "\n", &t
);
1367 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1368 line
= strtok_r (NULL
, "\n", &t
))
1370 char keyword
[64 + 1];
1372 if (sscanf (line
, "%64s", keyword
) != 1)
1374 warning (_("Error parsing {s,}maps file '%s'"),
1375 maps_filename
.c_str ());
1379 if (strcmp (keyword
, "Anonymous:") == 0)
1381 /* Older Linux kernels did not support the
1382 "Anonymous:" counter. Check it here. */
1385 else if (strcmp (keyword
, "VmFlags:") == 0)
1386 decode_vmflags (line
, &v
);
1388 if (strcmp (keyword
, "AnonHugePages:") == 0
1389 || strcmp (keyword
, "Anonymous:") == 0)
1391 unsigned long number
;
1393 if (sscanf (line
, "%*s%lu", &number
) != 1)
1395 warning (_("Error parsing {s,}maps file '%s' number"),
1396 maps_filename
.c_str ());
1401 /* Even if we are dealing with a file-backed
1402 mapping, if it contains anonymous pages we
1403 consider it to be *also* an anonymous
1404 mapping, because this is what the Linux
1407 // Dump segments that have been written to.
1408 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1411 Note that if the mapping is already marked as
1412 file-backed (i.e., mapping_file_p is
1413 non-zero), then this is a special case, and
1414 this mapping will be dumped either when the
1415 user wants to dump file-backed *or* anonymous
1421 /* Save the smaps entry to the vector. */
1422 struct smaps_data map
;
1424 map
.start_address
= addr
;
1425 map
.end_address
= endaddr
;
1426 map
.filename
= filename
;
1428 map
.read
= read
? true : false;
1429 map
.write
= write
? true : false;
1430 map
.exec
= exec
? true : false;
1431 map
.priv
= priv
? true : false;
1432 map
.has_anonymous
= has_anonymous
;
1433 map
.mapping_anon_p
= mapping_anon_p
? true : false;
1434 map
.mapping_file_p
= mapping_file_p
? true : false;
1435 map
.offset
= offset
;
1438 smaps
.emplace_back (map
);
1444 /* See linux-tdep.h. */
1447 linux_address_in_memtag_page (CORE_ADDR address
)
1449 if (current_inferior ()->fake_pid_p
)
1452 pid_t pid
= current_inferior ()->pid
;
1454 std::string smaps_file
= string_printf ("/proc/%d/smaps", pid
);
1456 gdb::unique_xmalloc_ptr
<char> data
1457 = target_fileio_read_stralloc (NULL
, smaps_file
.c_str ());
1459 if (data
== nullptr)
1462 /* Parse the contents of smaps into a vector. */
1463 std::vector
<struct smaps_data
> smaps
1464 = parse_smaps_data (data
.get (), smaps_file
);
1466 for (const smaps_data
&map
: smaps
)
1468 /* Is the address within [start_address, end_address) in a page
1469 mapped with memory tagging? */
1470 if (address
>= map
.start_address
1471 && address
< map
.end_address
1472 && map
.vmflags
.memory_tagging
)
1479 /* List memory regions in the inferior for a corefile. */
1482 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1483 linux_dump_mapping_p_ftype
*should_dump_mapping_p
,
1484 linux_find_memory_region_ftype
*func
,
1488 /* Default dump behavior of coredump_filter (0x33), according to
1489 Documentation/filesystems/proc.txt from the Linux kernel
1491 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1492 | COREFILTER_ANON_SHARED
1493 | COREFILTER_ELF_HEADERS
1494 | COREFILTER_HUGETLB_PRIVATE
);
1496 /* We need to know the real target PID to access /proc. */
1497 if (current_inferior ()->fake_pid_p
)
1500 pid
= current_inferior ()->pid
;
1502 if (use_coredump_filter
)
1504 std::string core_dump_filter_name
1505 = string_printf ("/proc/%d/coredump_filter", pid
);
1507 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1508 = target_fileio_read_stralloc (NULL
, core_dump_filter_name
.c_str ());
1510 if (coredumpfilterdata
!= NULL
)
1514 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1515 filterflags
= (enum filter_flag
) flags
;
1519 std::string maps_filename
= string_printf ("/proc/%d/smaps", pid
);
1521 gdb::unique_xmalloc_ptr
<char> data
1522 = target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1526 /* Older Linux kernels did not support /proc/PID/smaps. */
1527 maps_filename
= string_printf ("/proc/%d/maps", pid
);
1528 data
= target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1530 if (data
== nullptr)
1534 /* Parse the contents of smaps into a vector. */
1535 std::vector
<struct smaps_data
> smaps
1536 = parse_smaps_data (data
.get (), maps_filename
.c_str ());
1538 for (const struct smaps_data
&map
: smaps
)
1540 int should_dump_p
= 0;
1542 if (map
.has_anonymous
)
1545 = should_dump_mapping_p (filterflags
, &map
.vmflags
,
1549 map
.filename
.c_str (),
1555 /* Older Linux kernels did not support the "Anonymous:" counter.
1556 If it is missing, we can't be sure - dump all the pages. */
1560 /* Invoke the callback function to create the corefile segment. */
1563 func (map
.start_address
, map
.end_address
- map
.start_address
,
1564 map
.offset
, map
.inode
, map
.read
, map
.write
, map
.exec
,
1565 1, /* MODIFIED is true because we want to dump
1567 map
.filename
.c_str (), obfd
);
1574 /* A structure for passing information through
1575 linux_find_memory_regions_full. */
1577 struct linux_find_memory_regions_data
1579 /* The original callback. */
1581 find_memory_region_ftype func
;
1583 /* The original datum. */
1588 /* A callback for linux_find_memory_regions that converts between the
1589 "full"-style callback and find_memory_region_ftype. */
1592 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1593 ULONGEST offset
, ULONGEST inode
,
1594 int read
, int write
, int exec
, int modified
,
1595 const char *filename
, void *arg
)
1597 struct linux_find_memory_regions_data
*data
1598 = (struct linux_find_memory_regions_data
*) arg
;
1600 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1603 /* A variant of linux_find_memory_regions_full that is suitable as the
1604 gdbarch find_memory_regions method. */
1607 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1608 find_memory_region_ftype func
, void *obfd
)
1610 struct linux_find_memory_regions_data data
;
1615 return linux_find_memory_regions_full (gdbarch
,
1617 linux_find_memory_regions_thunk
,
1621 /* This is used to pass information from
1622 linux_make_mappings_corefile_notes through
1623 linux_find_memory_regions_full. */
1625 struct linux_make_mappings_data
1627 /* Number of files mapped. */
1628 ULONGEST file_count
;
1630 /* The obstack for the main part of the data. */
1631 struct obstack
*data_obstack
;
1633 /* The filename obstack. */
1634 struct obstack
*filename_obstack
;
1636 /* The architecture's "long" type. */
1637 struct type
*long_type
;
1640 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1642 /* A callback for linux_find_memory_regions_full that updates the
1643 mappings data for linux_make_mappings_corefile_notes. */
1646 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1647 ULONGEST offset
, ULONGEST inode
,
1648 int read
, int write
, int exec
, int modified
,
1649 const char *filename
, void *data
)
1651 struct linux_make_mappings_data
*map_data
1652 = (struct linux_make_mappings_data
*) data
;
1653 gdb_byte buf
[sizeof (ULONGEST
)];
1655 if (*filename
== '\0' || inode
== 0)
1658 ++map_data
->file_count
;
1660 pack_long (buf
, map_data
->long_type
, vaddr
);
1661 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1662 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1663 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1664 pack_long (buf
, map_data
->long_type
, offset
);
1665 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1667 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1672 /* Write the file mapping data to the core file, if possible. OBFD is
1673 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1674 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1677 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1678 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1681 struct linux_make_mappings_data mapping_data
;
1682 struct type
*long_type
1683 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1684 gdb_byte buf
[sizeof (ULONGEST
)];
1686 auto_obstack data_obstack
, filename_obstack
;
1688 mapping_data
.file_count
= 0;
1689 mapping_data
.data_obstack
= &data_obstack
;
1690 mapping_data
.filename_obstack
= &filename_obstack
;
1691 mapping_data
.long_type
= long_type
;
1693 /* Reserve space for the count. */
1694 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1695 /* We always write the page size as 1 since we have no good way to
1696 determine the correct value. */
1697 pack_long (buf
, long_type
, 1);
1698 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1700 linux_find_memory_regions_full (gdbarch
,
1702 linux_make_mappings_callback
,
1705 if (mapping_data
.file_count
!= 0)
1707 /* Write the count to the obstack. */
1708 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1709 long_type
, mapping_data
.file_count
);
1711 /* Copy the filenames to the data obstack. */
1712 int size
= obstack_object_size (&filename_obstack
);
1713 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1716 note_data
.reset (elfcore_write_file_note (obfd
, note_data
.release (), note_size
,
1717 obstack_base (&data_obstack
),
1718 obstack_object_size (&data_obstack
)));
1722 /* Fetch the siginfo data for the specified thread, if it exists. If
1723 there is no data, or we could not read it, return an empty
1726 static gdb::byte_vector
1727 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1729 struct type
*siginfo_type
;
1732 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1733 return gdb::byte_vector ();
1735 scoped_restore_current_thread save_current_thread
;
1736 switch_to_thread (thread
);
1738 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1740 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1742 bytes_read
= target_read (current_inferior ()->top_target (),
1743 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1744 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1745 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1751 struct linux_corefile_thread_data
1753 linux_corefile_thread_data (struct gdbarch
*gdbarch
, bfd
*obfd
,
1754 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1755 int *note_size
, gdb_signal stop_signal
)
1756 : gdbarch (gdbarch
), obfd (obfd
), note_data (note_data
),
1757 note_size (note_size
), stop_signal (stop_signal
)
1760 struct gdbarch
*gdbarch
;
1762 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1764 enum gdb_signal stop_signal
;
1767 /* Records the thread's register state for the corefile note
1771 linux_corefile_thread (struct thread_info
*info
,
1772 struct linux_corefile_thread_data
*args
)
1774 gcore_elf_build_thread_register_notes (args
->gdbarch
, info
,
1776 args
->obfd
, &args
->note_data
,
1779 /* Don't return anything if we got no register information above,
1780 such a core file is useless. */
1781 if (args
->note_data
!= NULL
)
1783 gdb::byte_vector siginfo_data
1784 = linux_get_siginfo_data (info
, args
->gdbarch
);
1785 if (!siginfo_data
.empty ())
1786 args
->note_data
.reset (elfcore_write_note (args
->obfd
,
1787 args
->note_data
.release (),
1790 siginfo_data
.data (),
1791 siginfo_data
.size ()));
1795 /* Fill the PRPSINFO structure with information about the process being
1796 debugged. Returns 1 in case of success, 0 for failures. Please note that
1797 even if the structure cannot be entirely filled (e.g., GDB was unable to
1798 gather information about the process UID/GID), this function will still
1799 return 1 since some information was already recorded. It will only return
1800 0 iff nothing can be gathered. */
1803 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1805 /* The filename which we will use to obtain some info about the process.
1806 We will basically use this to store the `/proc/PID/FILENAME' file. */
1808 /* The basename of the executable. */
1809 const char *basename
;
1810 /* Temporary buffer. */
1812 /* The valid states of a process, according to the Linux kernel. */
1813 const char valid_states
[] = "RSDTZW";
1814 /* The program state. */
1815 const char *prog_state
;
1816 /* The state of the process. */
1818 /* The PID of the program which generated the corefile. */
1820 /* Process flags. */
1821 unsigned int pr_flag
;
1822 /* Process nice value. */
1824 /* The number of fields read by `sscanf'. */
1827 gdb_assert (p
!= NULL
);
1829 /* Obtaining PID and filename. */
1830 pid
= inferior_ptid
.pid ();
1831 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1832 /* The full name of the program which generated the corefile. */
1833 gdb::unique_xmalloc_ptr
<char> fname
1834 = target_fileio_read_stralloc (NULL
, filename
);
1836 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1838 /* No program name was read, so we won't be able to retrieve more
1839 information about the process. */
1843 memset (p
, 0, sizeof (*p
));
1845 /* Defining the PID. */
1848 /* Copying the program name. Only the basename matters. */
1849 basename
= lbasename (fname
.get ());
1850 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1851 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1853 const std::string
&infargs
= current_inferior ()->args ();
1855 /* The arguments of the program. */
1856 std::string psargs
= fname
.get ();
1857 if (!infargs
.empty ())
1858 psargs
+= ' ' + infargs
;
1860 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1861 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1863 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1864 /* The contents of `/proc/PID/stat'. */
1865 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1866 = target_fileio_read_stralloc (NULL
, filename
);
1867 char *proc_stat
= proc_stat_contents
.get ();
1869 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1871 /* Despite being unable to read more information about the
1872 process, we return 1 here because at least we have its
1873 command line, PID and arguments. */
1877 /* Ok, we have the stats. It's time to do a little parsing of the
1878 contents of the buffer, so that we end up reading what we want.
1880 The following parsing mechanism is strongly based on the
1881 information generated by the `fs/proc/array.c' file, present in
1882 the Linux kernel tree. More details about how the information is
1883 displayed can be obtained by seeing the manpage of proc(5),
1884 specifically under the entry of `/proc/[pid]/stat'. */
1886 /* Getting rid of the PID, since we already have it. */
1887 while (isdigit (*proc_stat
))
1890 proc_stat
= skip_spaces (proc_stat
);
1892 /* ps command also relies on no trailing fields ever contain ')'. */
1893 proc_stat
= strrchr (proc_stat
, ')');
1894 if (proc_stat
== NULL
)
1898 proc_stat
= skip_spaces (proc_stat
);
1900 n_fields
= sscanf (proc_stat
,
1901 "%c" /* Process state. */
1902 "%d%d%d" /* Parent PID, group ID, session ID. */
1903 "%*d%*d" /* tty_nr, tpgid (not used). */
1905 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1906 cmajflt (not used). */
1907 "%*s%*s%*s%*s" /* utime, stime, cutime,
1908 cstime (not used). */
1909 "%*s" /* Priority (not used). */
1912 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1918 /* Again, we couldn't read the complementary information about
1919 the process state. However, we already have minimal
1920 information, so we just return 1 here. */
1924 /* Filling the structure fields. */
1925 prog_state
= strchr (valid_states
, pr_sname
);
1926 if (prog_state
!= NULL
)
1927 p
->pr_state
= prog_state
- valid_states
;
1930 /* Zero means "Running". */
1934 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1935 p
->pr_zomb
= p
->pr_sname
== 'Z';
1936 p
->pr_nice
= pr_nice
;
1937 p
->pr_flag
= pr_flag
;
1939 /* Finally, obtaining the UID and GID. For that, we read and parse the
1940 contents of the `/proc/PID/status' file. */
1941 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1942 /* The contents of `/proc/PID/status'. */
1943 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1944 = target_fileio_read_stralloc (NULL
, filename
);
1945 char *proc_status
= proc_status_contents
.get ();
1947 if (proc_status
== NULL
|| *proc_status
== '\0')
1949 /* Returning 1 since we already have a bunch of information. */
1953 /* Extracting the UID. */
1954 tmpstr
= strstr (proc_status
, "Uid:");
1957 /* Advancing the pointer to the beginning of the UID. */
1958 tmpstr
+= sizeof ("Uid:");
1959 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1962 if (isdigit (*tmpstr
))
1963 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1966 /* Extracting the GID. */
1967 tmpstr
= strstr (proc_status
, "Gid:");
1970 /* Advancing the pointer to the beginning of the GID. */
1971 tmpstr
+= sizeof ("Gid:");
1972 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1975 if (isdigit (*tmpstr
))
1976 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1982 /* Build the note section for a corefile, and return it in a malloc
1985 static gdb::unique_xmalloc_ptr
<char>
1986 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1988 struct elf_internal_linux_prpsinfo prpsinfo
;
1989 gdb::unique_xmalloc_ptr
<char> note_data
;
1991 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1994 if (linux_fill_prpsinfo (&prpsinfo
))
1996 if (gdbarch_ptr_bit (gdbarch
) == 64)
1997 note_data
.reset (elfcore_write_linux_prpsinfo64 (obfd
,
1998 note_data
.release (),
1999 note_size
, &prpsinfo
));
2001 note_data
.reset (elfcore_write_linux_prpsinfo32 (obfd
,
2002 note_data
.release (),
2003 note_size
, &prpsinfo
));
2006 /* Thread register information. */
2009 update_thread_list ();
2011 catch (const gdb_exception_error
&e
)
2013 exception_print (gdb_stderr
, e
);
2016 /* Like the kernel, prefer dumping the signalled thread first.
2017 "First thread" is what tools use to infer the signalled
2019 thread_info
*signalled_thr
= gcore_find_signalled_thread ();
2020 gdb_signal stop_signal
;
2021 if (signalled_thr
!= nullptr)
2022 stop_signal
= signalled_thr
->stop_signal ();
2024 stop_signal
= GDB_SIGNAL_0
;
2026 linux_corefile_thread_data
thread_args (gdbarch
, obfd
, note_data
, note_size
,
2029 if (signalled_thr
!= nullptr)
2030 linux_corefile_thread (signalled_thr
, &thread_args
);
2031 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
2033 if (thr
== signalled_thr
)
2036 linux_corefile_thread (thr
, &thread_args
);
2042 /* Auxillary vector. */
2043 gdb::optional
<gdb::byte_vector
> auxv
=
2044 target_read_alloc (current_inferior ()->top_target (),
2045 TARGET_OBJECT_AUXV
, NULL
);
2046 if (auxv
&& !auxv
->empty ())
2048 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
2049 note_size
, "CORE", NT_AUXV
,
2050 auxv
->data (), auxv
->size ()));
2056 /* File mappings. */
2057 linux_make_mappings_corefile_notes (gdbarch
, obfd
, note_data
, note_size
);
2059 /* Target description. */
2060 gcore_elf_make_tdesc_note (obfd
, ¬e_data
, note_size
);
2065 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2066 gdbarch.h. This function is not static because it is exported to
2067 other -tdep files. */
2070 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2075 return GDB_SIGNAL_0
;
2078 return GDB_SIGNAL_HUP
;
2081 return GDB_SIGNAL_INT
;
2084 return GDB_SIGNAL_QUIT
;
2087 return GDB_SIGNAL_ILL
;
2090 return GDB_SIGNAL_TRAP
;
2093 return GDB_SIGNAL_ABRT
;
2096 return GDB_SIGNAL_BUS
;
2099 return GDB_SIGNAL_FPE
;
2102 return GDB_SIGNAL_KILL
;
2105 return GDB_SIGNAL_USR1
;
2108 return GDB_SIGNAL_SEGV
;
2111 return GDB_SIGNAL_USR2
;
2114 return GDB_SIGNAL_PIPE
;
2117 return GDB_SIGNAL_ALRM
;
2120 return GDB_SIGNAL_TERM
;
2123 return GDB_SIGNAL_CHLD
;
2126 return GDB_SIGNAL_CONT
;
2129 return GDB_SIGNAL_STOP
;
2132 return GDB_SIGNAL_TSTP
;
2135 return GDB_SIGNAL_TTIN
;
2138 return GDB_SIGNAL_TTOU
;
2141 return GDB_SIGNAL_URG
;
2144 return GDB_SIGNAL_XCPU
;
2147 return GDB_SIGNAL_XFSZ
;
2149 case LINUX_SIGVTALRM
:
2150 return GDB_SIGNAL_VTALRM
;
2153 return GDB_SIGNAL_PROF
;
2155 case LINUX_SIGWINCH
:
2156 return GDB_SIGNAL_WINCH
;
2158 /* No way to differentiate between SIGIO and SIGPOLL.
2159 Therefore, we just handle the first one. */
2161 return GDB_SIGNAL_IO
;
2164 return GDB_SIGNAL_PWR
;
2167 return GDB_SIGNAL_SYS
;
2169 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2170 therefore we have to handle them here. */
2171 case LINUX_SIGRTMIN
:
2172 return GDB_SIGNAL_REALTIME_32
;
2174 case LINUX_SIGRTMAX
:
2175 return GDB_SIGNAL_REALTIME_64
;
2178 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2180 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2182 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2185 return GDB_SIGNAL_UNKNOWN
;
2188 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2189 gdbarch.h. This function is not static because it is exported to
2190 other -tdep files. */
2193 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2194 enum gdb_signal signal
)
2201 case GDB_SIGNAL_HUP
:
2202 return LINUX_SIGHUP
;
2204 case GDB_SIGNAL_INT
:
2205 return LINUX_SIGINT
;
2207 case GDB_SIGNAL_QUIT
:
2208 return LINUX_SIGQUIT
;
2210 case GDB_SIGNAL_ILL
:
2211 return LINUX_SIGILL
;
2213 case GDB_SIGNAL_TRAP
:
2214 return LINUX_SIGTRAP
;
2216 case GDB_SIGNAL_ABRT
:
2217 return LINUX_SIGABRT
;
2219 case GDB_SIGNAL_FPE
:
2220 return LINUX_SIGFPE
;
2222 case GDB_SIGNAL_KILL
:
2223 return LINUX_SIGKILL
;
2225 case GDB_SIGNAL_BUS
:
2226 return LINUX_SIGBUS
;
2228 case GDB_SIGNAL_SEGV
:
2229 return LINUX_SIGSEGV
;
2231 case GDB_SIGNAL_SYS
:
2232 return LINUX_SIGSYS
;
2234 case GDB_SIGNAL_PIPE
:
2235 return LINUX_SIGPIPE
;
2237 case GDB_SIGNAL_ALRM
:
2238 return LINUX_SIGALRM
;
2240 case GDB_SIGNAL_TERM
:
2241 return LINUX_SIGTERM
;
2243 case GDB_SIGNAL_URG
:
2244 return LINUX_SIGURG
;
2246 case GDB_SIGNAL_STOP
:
2247 return LINUX_SIGSTOP
;
2249 case GDB_SIGNAL_TSTP
:
2250 return LINUX_SIGTSTP
;
2252 case GDB_SIGNAL_CONT
:
2253 return LINUX_SIGCONT
;
2255 case GDB_SIGNAL_CHLD
:
2256 return LINUX_SIGCHLD
;
2258 case GDB_SIGNAL_TTIN
:
2259 return LINUX_SIGTTIN
;
2261 case GDB_SIGNAL_TTOU
:
2262 return LINUX_SIGTTOU
;
2267 case GDB_SIGNAL_XCPU
:
2268 return LINUX_SIGXCPU
;
2270 case GDB_SIGNAL_XFSZ
:
2271 return LINUX_SIGXFSZ
;
2273 case GDB_SIGNAL_VTALRM
:
2274 return LINUX_SIGVTALRM
;
2276 case GDB_SIGNAL_PROF
:
2277 return LINUX_SIGPROF
;
2279 case GDB_SIGNAL_WINCH
:
2280 return LINUX_SIGWINCH
;
2282 case GDB_SIGNAL_USR1
:
2283 return LINUX_SIGUSR1
;
2285 case GDB_SIGNAL_USR2
:
2286 return LINUX_SIGUSR2
;
2288 case GDB_SIGNAL_PWR
:
2289 return LINUX_SIGPWR
;
2291 case GDB_SIGNAL_POLL
:
2292 return LINUX_SIGPOLL
;
2294 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2295 therefore we have to handle it here. */
2296 case GDB_SIGNAL_REALTIME_32
:
2297 return LINUX_SIGRTMIN
;
2299 /* Same comment applies to _64. */
2300 case GDB_SIGNAL_REALTIME_64
:
2301 return LINUX_SIGRTMAX
;
2304 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2305 if (signal
>= GDB_SIGNAL_REALTIME_33
2306 && signal
<= GDB_SIGNAL_REALTIME_63
)
2308 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2310 return LINUX_SIGRTMIN
+ 1 + offset
;
2316 /* Helper for linux_vsyscall_range that does the real work of finding
2317 the vsyscall's address range. */
2320 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2325 if (target_auxv_search (current_inferior ()->top_target (),
2326 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_inferior ()->top_target (),
2517 AT_ENTRY
, &addr
) <= 0)
2518 throw_error (NOT_SUPPORTED_ERROR
,
2519 _("Cannot find AT_ENTRY auxiliary vector entry."));
2521 /* Make certain that the address points at real code, and not a
2522 function descriptor. */
2523 addr
= gdbarch_convert_from_func_ptr_addr
2524 (gdbarch
, addr
, current_inferior ()->top_target ());
2526 /* Inferior calls also use the entry point as a breakpoint location.
2527 We don't want displaced stepping to interfere with those
2528 breakpoints, so leave space. */
2529 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2535 /* See linux-tdep.h. */
2537 displaced_step_prepare_status
2538 linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2539 CORE_ADDR
&displaced_pc
)
2541 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2543 if (!per_inferior
->disp_step_bufs
.has_value ())
2545 /* Figure out the location of the buffers. They are contiguous, starting
2546 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2547 CORE_ADDR disp_step_buf_addr
2548 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2549 int buf_len
= gdbarch_max_insn_length (arch
);
2551 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (arch
);
2552 gdb_assert (gdbarch_data
->num_disp_step_buffers
> 0);
2554 std::vector
<CORE_ADDR
> buffers
;
2555 for (int i
= 0; i
< gdbarch_data
->num_disp_step_buffers
; i
++)
2556 buffers
.push_back (disp_step_buf_addr
+ i
* buf_len
);
2558 per_inferior
->disp_step_bufs
.emplace (buffers
);
2561 return per_inferior
->disp_step_bufs
->prepare (thread
, displaced_pc
);
2564 /* See linux-tdep.h. */
2566 displaced_step_finish_status
2567 linux_displaced_step_finish (gdbarch
*arch
, thread_info
*thread
, gdb_signal sig
)
2569 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2571 gdb_assert (per_inferior
->disp_step_bufs
.has_value ());
2573 return per_inferior
->disp_step_bufs
->finish (arch
, thread
, sig
);
2576 /* See linux-tdep.h. */
2578 const displaced_step_copy_insn_closure
*
2579 linux_displaced_step_copy_insn_closure_by_addr (inferior
*inf
, CORE_ADDR addr
)
2581 linux_info
*per_inferior
= linux_inferior_data
.get (inf
);
2583 if (per_inferior
== nullptr
2584 || !per_inferior
->disp_step_bufs
.has_value ())
2587 return per_inferior
->disp_step_bufs
->copy_insn_closure_by_addr (addr
);
2590 /* See linux-tdep.h. */
2593 linux_displaced_step_restore_all_in_ptid (inferior
*parent_inf
, ptid_t ptid
)
2595 linux_info
*per_inferior
= linux_inferior_data
.get (parent_inf
);
2597 if (per_inferior
== nullptr
2598 || !per_inferior
->disp_step_bufs
.has_value ())
2601 per_inferior
->disp_step_bufs
->restore_in_ptid (ptid
);
2604 /* See linux-tdep.h. */
2607 linux_get_hwcap (struct target_ops
*target
)
2610 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2615 /* See linux-tdep.h. */
2618 linux_get_hwcap2 (struct target_ops
*target
)
2621 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2626 /* Display whether the gcore command is using the
2627 /proc/PID/coredump_filter file. */
2630 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2631 struct cmd_list_element
*c
, const char *value
)
2633 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2634 " corefiles is %s.\n"), value
);
2637 /* Display whether the gcore command is dumping mappings marked with
2638 the VM_DONTDUMP flag. */
2641 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2642 struct cmd_list_element
*c
, const char *value
)
2644 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2645 " flag is %s.\n"), value
);
2648 /* To be called from the various GDB_OSABI_LINUX handlers for the
2649 various GNU/Linux architectures and machine types.
2651 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2652 displaced stepping is not supported. */
2655 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
,
2656 int num_disp_step_buffers
)
2658 if (num_disp_step_buffers
> 0)
2660 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
2661 gdbarch_data
->num_disp_step_buffers
= num_disp_step_buffers
;
2663 set_gdbarch_displaced_step_prepare (gdbarch
,
2664 linux_displaced_step_prepare
);
2665 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
2666 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2667 (gdbarch
, linux_displaced_step_copy_insn_closure_by_addr
);
2668 set_gdbarch_displaced_step_restore_all_in_ptid
2669 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
2672 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2673 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2674 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2675 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2676 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2677 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2678 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2679 set_gdbarch_has_shared_address_space (gdbarch
,
2680 linux_has_shared_address_space
);
2681 set_gdbarch_gdb_signal_from_target (gdbarch
,
2682 linux_gdb_signal_from_target
);
2683 set_gdbarch_gdb_signal_to_target (gdbarch
,
2684 linux_gdb_signal_to_target
);
2685 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2686 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2687 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2688 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2691 void _initialize_linux_tdep ();
2693 _initialize_linux_tdep ()
2695 linux_gdbarch_data_handle
=
2696 gdbarch_data_register_pre_init (init_linux_gdbarch_data
);
2698 /* Observers used to invalidate the cache when needed. */
2699 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
,
2701 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
,
2703 gdb::observers::inferior_execd
.attach (invalidate_linux_cache_inf
,
2706 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2707 &use_coredump_filter
, _("\
2708 Set whether gcore should consider /proc/PID/coredump_filter."),
2710 Show whether gcore should consider /proc/PID/coredump_filter."),
2712 Use this command to set whether gcore should consider the contents\n\
2713 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2714 about this file, refer to the manpage of core(5)."),
2715 NULL
, show_use_coredump_filter
,
2716 &setlist
, &showlist
);
2718 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2719 &dump_excluded_mappings
, _("\
2720 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2722 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2724 Use this command to set whether gcore should dump mappings marked with the\n\
2725 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2726 more information about this file, refer to the manpage of proc(5) and core(5)."),
2727 NULL
, show_dump_excluded_mappings
,
2728 &setlist
, &showlist
);
2731 /* Fetch (and possibly build) an appropriate `link_map_offsets' for
2732 ILP32/LP64 Linux systems which don't have the r_ldsomap field. */
2735 linux_ilp32_fetch_link_map_offsets ()
2737 static link_map_offsets lmo
;
2738 static link_map_offsets
*lmp
= nullptr;
2744 lmo
.r_version_offset
= 0;
2745 lmo
.r_version_size
= 4;
2746 lmo
.r_map_offset
= 4;
2747 lmo
.r_brk_offset
= 8;
2748 lmo
.r_ldsomap_offset
= -1;
2750 /* Everything we need is in the first 20 bytes. */
2751 lmo
.link_map_size
= 20;
2752 lmo
.l_addr_offset
= 0;
2753 lmo
.l_name_offset
= 4;
2754 lmo
.l_ld_offset
= 8;
2755 lmo
.l_next_offset
= 12;
2756 lmo
.l_prev_offset
= 16;
2763 linux_lp64_fetch_link_map_offsets ()
2765 static link_map_offsets lmo
;
2766 static link_map_offsets
*lmp
= nullptr;
2772 lmo
.r_version_offset
= 0;
2773 lmo
.r_version_size
= 4;
2774 lmo
.r_map_offset
= 8;
2775 lmo
.r_brk_offset
= 16;
2776 lmo
.r_ldsomap_offset
= -1;
2778 /* Everything we need is in the first 40 bytes. */
2779 lmo
.link_map_size
= 40;
2780 lmo
.l_addr_offset
= 0;
2781 lmo
.l_name_offset
= 8;
2782 lmo
.l_ld_offset
= 16;
2783 lmo
.l_next_offset
= 24;
2784 lmo
.l_prev_offset
= 32;