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"
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 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
385 siginfo_type
->set_name (xstrdup ("siginfo"));
386 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
387 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
388 append_composite_type_field (siginfo_type
, "si_code", int_type
);
389 append_composite_type_field_aligned (siginfo_type
,
390 "_sifields", sifields_type
,
391 TYPE_LENGTH (long_type
));
393 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
398 /* This function is suitable for architectures that don't
399 extend/override the standard siginfo structure. */
402 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
404 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
407 /* Return true if the target is running on uClinux instead of normal
411 linux_is_uclinux (void)
414 target_ops
*target
= current_inferior ()->top_target ();
416 return (target_auxv_search (target
, AT_NULL
, &dummy
) > 0
417 && target_auxv_search (target
, AT_PAGESZ
, &dummy
) == 0);
421 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
423 return linux_is_uclinux ();
426 /* This is how we want PTIDs from core files to be printed. */
429 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
431 if (ptid
.lwp () != 0)
432 return string_printf ("LWP %ld", ptid
.lwp ());
434 return normal_pid_to_str (ptid
);
437 /* Service function for corefiles and info proc. */
440 read_mapping (const char *line
,
441 ULONGEST
*addr
, ULONGEST
*endaddr
,
442 const char **permissions
, size_t *permissions_len
,
444 const char **device
, size_t *device_len
,
446 const char **filename
)
448 const char *p
= line
;
450 *addr
= strtoulst (p
, &p
, 16);
453 *endaddr
= strtoulst (p
, &p
, 16);
457 while (*p
&& !isspace (*p
))
459 *permissions_len
= p
- *permissions
;
461 *offset
= strtoulst (p
, &p
, 16);
465 while (*p
&& !isspace (*p
))
467 *device_len
= p
- *device
;
469 *inode
= strtoulst (p
, &p
, 10);
475 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
477 This function was based on the documentation found on
478 <Documentation/filesystems/proc.txt>, on the Linux kernel.
480 Linux kernels before commit
481 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
485 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
487 char *saveptr
= NULL
;
490 v
->initialized_p
= 1;
491 p
= skip_to_space (p
);
494 for (s
= strtok_r (p
, " ", &saveptr
);
496 s
= strtok_r (NULL
, " ", &saveptr
))
498 if (strcmp (s
, "io") == 0)
500 else if (strcmp (s
, "ht") == 0)
501 v
->uses_huge_tlb
= 1;
502 else if (strcmp (s
, "dd") == 0)
503 v
->exclude_coredump
= 1;
504 else if (strcmp (s
, "sh") == 0)
505 v
->shared_mapping
= 1;
506 else if (strcmp (s
, "mt") == 0)
507 v
->memory_tagging
= 1;
511 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
512 they're initialized lazily. */
514 struct mapping_regexes
516 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
517 string in the end). We know for sure, based on the Linux kernel
518 code, that memory mappings whose associated filename is
519 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
520 compiled_regex dev_zero
521 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
522 _("Could not compile regex to match /dev/zero filename")};
524 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
525 string in the end). These filenames refer to shared memory
526 (shmem), and memory mappings associated with them are
527 MAP_ANONYMOUS as well. */
528 compiled_regex shmem_file
529 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
530 _("Could not compile regex to match shmem filenames")};
532 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
533 0' code, which is responsible to decide if it is dealing with a
534 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
535 FILE_DELETED matches, it does not necessarily mean that we are
536 dealing with an anonymous shared mapping. However, there is no
537 easy way to detect this currently, so this is the best
538 approximation we have.
540 As a result, GDB will dump readonly pages of deleted executables
541 when using the default value of coredump_filter (0x33), while the
542 Linux kernel will not dump those pages. But we can live with
544 compiled_regex file_deleted
545 {" (deleted)$", REG_NOSUB
,
546 _("Could not compile regex to match '<file> (deleted)'")};
549 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
551 FILENAME is the name of the file present in the first line of the
552 memory mapping, in the "/proc/PID/smaps" output. For example, if
555 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
557 Then FILENAME will be "/path/to/file". */
560 mapping_is_anonymous_p (const char *filename
)
562 static gdb::optional
<mapping_regexes
> regexes
;
563 static int init_regex_p
= 0;
567 /* Let's be pessimistic and assume there will be an error while
568 compiling the regex'es. */
573 /* If we reached this point, then everything succeeded. */
577 if (init_regex_p
== -1)
579 const char deleted
[] = " (deleted)";
580 size_t del_len
= sizeof (deleted
) - 1;
581 size_t filename_len
= strlen (filename
);
583 /* There was an error while compiling the regex'es above. In
584 order to try to give some reliable information to the caller,
585 we just try to find the string " (deleted)" in the filename.
586 If we managed to find it, then we assume the mapping is
588 return (filename_len
>= del_len
589 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
592 if (*filename
== '\0'
593 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
594 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
595 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
601 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
602 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
603 be dumped, or greater than 0 if it should.
605 In a nutshell, this is the logic that we follow in order to decide
606 if a mapping should be dumped or not.
608 - If the mapping is associated to a file whose name ends with
609 " (deleted)", or if the file is "/dev/zero", or if it is
610 "/SYSV%08x" (shared memory), or if there is no file associated
611 with it, or if the AnonHugePages: or the Anonymous: fields in the
612 /proc/PID/smaps have contents, then GDB considers this mapping to
613 be anonymous. Otherwise, GDB considers this mapping to be a
614 file-backed mapping (because there will be a file associated with
617 It is worth mentioning that, from all those checks described
618 above, the most fragile is the one to see if the file name ends
619 with " (deleted)". This does not necessarily mean that the
620 mapping is anonymous, because the deleted file associated with
621 the mapping may have been a hard link to another file, for
622 example. The Linux kernel checks to see if "i_nlink == 0", but
623 GDB cannot easily (and normally) do this check (iff running as
624 root, it could find the mapping in /proc/PID/map_files/ and
625 determine whether there still are other hard links to the
626 inode/file). Therefore, we made a compromise here, and we assume
627 that if the file name ends with " (deleted)", then the mapping is
628 indeed anonymous. FWIW, this is something the Linux kernel could
629 do better: expose this information in a more direct way.
631 - If we see the flag "sh" in the "VmFlags:" field (in
632 /proc/PID/smaps), then certainly the memory mapping is shared
633 (VM_SHARED). If we have access to the VmFlags, and we don't see
634 the "sh" there, then certainly the mapping is private. However,
635 Linux kernels before commit
636 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
637 "VmFlags:" field; in that case, we use another heuristic: if we
638 see 'p' in the permission flags, then we assume that the mapping
639 is private, even though the presence of the 's' flag there would
640 mean VM_MAYSHARE, which means the mapping could still be private.
641 This should work OK enough, however.
643 - Even if, at the end, we decided that we should not dump the
644 mapping, we still have to check if it is something like an ELF
645 header (of a DSO or an executable, for example). If it is, and
646 if the user is interested in dump it, then we should dump it. */
649 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
650 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
651 const char *filename
, ULONGEST addr
, ULONGEST offset
)
653 /* Initially, we trust in what we received from our caller. This
654 value may not be very precise (i.e., it was probably gathered
655 from the permission line in the /proc/PID/smaps list, which
656 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
657 what we have until we take a look at the "VmFlags:" field
658 (assuming that the version of the Linux kernel being used
659 supports it, of course). */
660 int private_p
= maybe_private_p
;
663 /* We always dump vDSO and vsyscall mappings, because it's likely that
664 there'll be no file to read the contents from at core load time.
665 The kernel does the same. */
666 if (strcmp ("[vdso]", filename
) == 0
667 || strcmp ("[vsyscall]", filename
) == 0)
670 if (v
->initialized_p
)
672 /* We never dump I/O mappings. */
676 /* Check if we should exclude this mapping. */
677 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
680 /* Update our notion of whether this mapping is shared or
681 private based on a trustworthy value. */
682 private_p
= !v
->shared_mapping
;
684 /* HugeTLB checking. */
685 if (v
->uses_huge_tlb
)
687 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
688 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
697 if (mapping_anon_p
&& mapping_file_p
)
699 /* This is a special situation. It can happen when we see a
700 mapping that is file-backed, but that contains anonymous
702 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
703 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
705 else if (mapping_anon_p
)
706 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
708 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
712 if (mapping_anon_p
&& mapping_file_p
)
714 /* This is a special situation. It can happen when we see a
715 mapping that is file-backed, but that contains anonymous
717 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
718 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
720 else if (mapping_anon_p
)
721 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
723 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
726 /* Even if we decided that we shouldn't dump this mapping, we still
727 have to check whether (a) the user wants us to dump mappings
728 containing an ELF header, and (b) the mapping in question
729 contains an ELF header. If (a) and (b) are true, then we should
732 A mapping contains an ELF header if it is a private mapping, its
733 offset is zero, and its first word is ELFMAG. */
734 if (!dump_p
&& private_p
&& offset
== 0
735 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
737 /* Useful define specifying the size of the ELF magical
743 /* Let's check if we have an ELF header. */
745 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
747 /* The EI_MAG* and ELFMAG* constants come from
749 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
750 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
752 /* This mapping contains an ELF header, so we
762 /* As above, but return true only when we should dump the NT_FILE
766 dump_note_entry_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
767 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
768 const char *filename
, ULONGEST addr
, ULONGEST offset
)
770 /* vDSO and vsyscall mappings will end up in the core file. Don't
771 put them in the NT_FILE note. */
772 if (strcmp ("[vdso]", filename
) == 0
773 || strcmp ("[vsyscall]", filename
) == 0)
776 /* Otherwise, any other file-based mapping should be placed in the
781 /* Implement the "info proc" command. */
784 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
785 enum info_proc_what what
)
787 /* A long is used for pid instead of an int to avoid a loss of precision
788 compiler warning from the output of strtoul. */
790 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
791 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
792 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
793 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
794 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
795 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
799 if (args
&& isdigit (args
[0]))
803 pid
= strtoul (args
, &tem
, 10);
808 if (!target_has_execution ())
809 error (_("No current process: you must name one."));
810 if (current_inferior ()->fake_pid_p
)
811 error (_("Can't determine the current process's PID: you must name one."));
813 pid
= current_inferior ()->pid
;
816 args
= skip_spaces (args
);
818 error (_("Too many parameters: %s"), args
);
820 printf_filtered (_("process %ld\n"), pid
);
823 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
825 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
829 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
832 for (pos
= 0; pos
< len
- 1; pos
++)
834 if (buffer
[pos
] == '\0')
837 buffer
[len
- 1] = '\0';
838 printf_filtered ("cmdline = '%s'\n", buffer
);
841 warning (_("unable to open /proc file '%s'"), filename
);
845 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
846 gdb::optional
<std::string
> contents
847 = target_fileio_readlink (NULL
, filename
, &target_errno
);
848 if (contents
.has_value ())
849 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
851 warning (_("unable to read link '%s'"), filename
);
855 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
856 gdb::optional
<std::string
> contents
857 = target_fileio_readlink (NULL
, filename
, &target_errno
);
858 if (contents
.has_value ())
859 printf_filtered ("exe = '%s'\n", contents
->c_str ());
861 warning (_("unable to read link '%s'"), filename
);
865 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
866 gdb::unique_xmalloc_ptr
<char> map
867 = target_fileio_read_stralloc (NULL
, filename
);
872 printf_filtered (_("Mapped address spaces:\n\n"));
873 if (gdbarch_addr_bit (gdbarch
) == 32)
875 printf_filtered ("\t%10s %10s %10s %10s %s\n",
878 " Size", " Offset", "objfile");
882 printf_filtered (" %18s %18s %10s %10s %s\n",
885 " Size", " Offset", "objfile");
889 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
891 line
= strtok_r (NULL
, "\n", &saveptr
))
893 ULONGEST addr
, endaddr
, offset
, inode
;
894 const char *permissions
, *device
, *mapping_filename
;
895 size_t permissions_len
, device_len
;
897 read_mapping (line
, &addr
, &endaddr
,
898 &permissions
, &permissions_len
,
899 &offset
, &device
, &device_len
,
900 &inode
, &mapping_filename
);
902 if (gdbarch_addr_bit (gdbarch
) == 32)
904 printf_filtered ("\t%10s %10s %10s %10s %s\n",
905 paddress (gdbarch
, addr
),
906 paddress (gdbarch
, endaddr
),
907 hex_string (endaddr
- addr
),
909 *mapping_filename
? mapping_filename
: "");
913 printf_filtered (" %18s %18s %10s %10s %s\n",
914 paddress (gdbarch
, addr
),
915 paddress (gdbarch
, endaddr
),
916 hex_string (endaddr
- addr
),
918 *mapping_filename
? mapping_filename
: "");
923 warning (_("unable to open /proc file '%s'"), filename
);
927 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
928 gdb::unique_xmalloc_ptr
<char> status
929 = target_fileio_read_stralloc (NULL
, filename
);
931 puts_filtered (status
.get ());
933 warning (_("unable to open /proc file '%s'"), filename
);
937 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
938 gdb::unique_xmalloc_ptr
<char> statstr
939 = target_fileio_read_stralloc (NULL
, filename
);
942 const char *p
= statstr
.get ();
944 printf_filtered (_("Process: %s\n"),
945 pulongest (strtoulst (p
, &p
, 10)));
950 /* ps command also relies on no trailing fields
952 const char *ep
= strrchr (p
, ')');
955 printf_filtered ("Exec file: %.*s\n",
956 (int) (ep
- p
- 1), p
+ 1);
963 printf_filtered (_("State: %c\n"), *p
++);
966 printf_filtered (_("Parent process: %s\n"),
967 pulongest (strtoulst (p
, &p
, 10)));
969 printf_filtered (_("Process group: %s\n"),
970 pulongest (strtoulst (p
, &p
, 10)));
972 printf_filtered (_("Session id: %s\n"),
973 pulongest (strtoulst (p
, &p
, 10)));
975 printf_filtered (_("TTY: %s\n"),
976 pulongest (strtoulst (p
, &p
, 10)));
978 printf_filtered (_("TTY owner process group: %s\n"),
979 pulongest (strtoulst (p
, &p
, 10)));
982 printf_filtered (_("Flags: %s\n"),
983 hex_string (strtoulst (p
, &p
, 10)));
985 printf_filtered (_("Minor faults (no memory page): %s\n"),
986 pulongest (strtoulst (p
, &p
, 10)));
988 printf_filtered (_("Minor faults, children: %s\n"),
989 pulongest (strtoulst (p
, &p
, 10)));
991 printf_filtered (_("Major faults (memory page faults): %s\n"),
992 pulongest (strtoulst (p
, &p
, 10)));
994 printf_filtered (_("Major faults, children: %s\n"),
995 pulongest (strtoulst (p
, &p
, 10)));
997 printf_filtered (_("utime: %s\n"),
998 pulongest (strtoulst (p
, &p
, 10)));
1000 printf_filtered (_("stime: %s\n"),
1001 pulongest (strtoulst (p
, &p
, 10)));
1003 printf_filtered (_("utime, children: %s\n"),
1004 pulongest (strtoulst (p
, &p
, 10)));
1006 printf_filtered (_("stime, children: %s\n"),
1007 pulongest (strtoulst (p
, &p
, 10)));
1009 printf_filtered (_("jiffies remaining in current "
1010 "time slice: %s\n"),
1011 pulongest (strtoulst (p
, &p
, 10)));
1013 printf_filtered (_("'nice' value: %s\n"),
1014 pulongest (strtoulst (p
, &p
, 10)));
1016 printf_filtered (_("jiffies until next timeout: %s\n"),
1017 pulongest (strtoulst (p
, &p
, 10)));
1019 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
1020 pulongest (strtoulst (p
, &p
, 10)));
1022 printf_filtered (_("start time (jiffies since "
1023 "system boot): %s\n"),
1024 pulongest (strtoulst (p
, &p
, 10)));
1026 printf_filtered (_("Virtual memory size: %s\n"),
1027 pulongest (strtoulst (p
, &p
, 10)));
1029 printf_filtered (_("Resident set size: %s\n"),
1030 pulongest (strtoulst (p
, &p
, 10)));
1032 printf_filtered (_("rlim: %s\n"),
1033 pulongest (strtoulst (p
, &p
, 10)));
1035 printf_filtered (_("Start of text: %s\n"),
1036 hex_string (strtoulst (p
, &p
, 10)));
1038 printf_filtered (_("End of text: %s\n"),
1039 hex_string (strtoulst (p
, &p
, 10)));
1041 printf_filtered (_("Start of stack: %s\n"),
1042 hex_string (strtoulst (p
, &p
, 10)));
1043 #if 0 /* Don't know how architecture-dependent the rest is...
1044 Anyway the signal bitmap info is available from "status". */
1046 printf_filtered (_("Kernel stack pointer: %s\n"),
1047 hex_string (strtoulst (p
, &p
, 10)));
1049 printf_filtered (_("Kernel instr pointer: %s\n"),
1050 hex_string (strtoulst (p
, &p
, 10)));
1052 printf_filtered (_("Pending signals bitmap: %s\n"),
1053 hex_string (strtoulst (p
, &p
, 10)));
1055 printf_filtered (_("Blocked signals bitmap: %s\n"),
1056 hex_string (strtoulst (p
, &p
, 10)));
1058 printf_filtered (_("Ignored signals bitmap: %s\n"),
1059 hex_string (strtoulst (p
, &p
, 10)));
1061 printf_filtered (_("Catched signals bitmap: %s\n"),
1062 hex_string (strtoulst (p
, &p
, 10)));
1064 printf_filtered (_("wchan (system call): %s\n"),
1065 hex_string (strtoulst (p
, &p
, 10)));
1069 warning (_("unable to open /proc file '%s'"), filename
);
1073 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1076 This function reads the NT_FILE note (which BFD turns into the
1077 section ".note.linuxcore.file"). The format of this note / section
1078 is described as follows in the Linux kernel sources in
1081 long count -- how many files are mapped
1082 long page_size -- units for file_ofs
1083 array of [COUNT] elements of
1087 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1089 CBFD is the BFD of the core file.
1091 PRE_LOOP_CB is the callback function to invoke prior to starting
1092 the loop which processes individual entries. This callback will
1093 only be executed after the note has been examined in enough
1094 detail to verify that it's not malformed in some way.
1096 LOOP_CB is the callback function that will be executed once
1097 for each mapping. */
1100 linux_read_core_file_mappings
1101 (struct gdbarch
*gdbarch
,
1103 read_core_file_mappings_pre_loop_ftype pre_loop_cb
,
1104 read_core_file_mappings_loop_ftype loop_cb
)
1106 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1107 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1109 /* It's not required that the NT_FILE note exists, so return silently
1110 if it's not found. Beyond this point though, we'll complain
1111 if problems are found. */
1112 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1113 if (section
== nullptr)
1116 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1117 unsigned int addr_size
= addr_size_bits
/ 8;
1118 size_t note_size
= bfd_section_size (section
);
1120 if (note_size
< 2 * addr_size
)
1122 warning (_("malformed core note - too short for header"));
1126 gdb::def_vector
<gdb_byte
> contents (note_size
);
1127 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1130 warning (_("could not get core note contents"));
1134 gdb_byte
*descdata
= contents
.data ();
1135 char *descend
= (char *) descdata
+ note_size
;
1137 if (descdata
[note_size
- 1] != '\0')
1139 warning (_("malformed note - does not end with \\0"));
1143 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1144 descdata
+= addr_size
;
1146 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1147 descdata
+= addr_size
;
1149 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1151 warning (_("malformed note - too short for supplied file count"));
1155 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1157 /* Make sure that the correct number of filenames exist. Complain
1158 if there aren't enough or are too many. */
1159 char *f
= filenames
;
1160 for (int i
= 0; i
< count
; i
++)
1164 warning (_("malformed note - filename area is too small"));
1167 f
+= strnlen (f
, descend
- f
) + 1;
1169 /* Complain, but don't return early if the filename area is too big. */
1171 warning (_("malformed note - filename area is too big"));
1173 pre_loop_cb (count
);
1175 for (int i
= 0; i
< count
; i
++)
1177 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1178 descdata
+= addr_size
;
1179 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1180 descdata
+= addr_size
;
1182 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1183 descdata
+= addr_size
;
1184 char * filename
= filenames
;
1185 filenames
+= strlen ((char *) filenames
) + 1;
1187 loop_cb (i
, start
, end
, file_ofs
, filename
, nullptr);
1191 /* Implement "info proc mappings" for a corefile. */
1194 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1196 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1197 [=] (ULONGEST count
)
1199 printf_filtered (_("Mapped address spaces:\n\n"));
1200 if (gdbarch_addr_bit (gdbarch
) == 32)
1202 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1205 " Size", " Offset", "objfile");
1209 printf_filtered (" %18s %18s %10s %10s %s\n",
1212 " Size", " Offset", "objfile");
1215 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1216 const char *filename
, const bfd_build_id
*build_id
)
1218 if (gdbarch_addr_bit (gdbarch
) == 32)
1219 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1220 paddress (gdbarch
, start
),
1221 paddress (gdbarch
, end
),
1222 hex_string (end
- start
),
1223 hex_string (file_ofs
),
1226 printf_filtered (" %18s %18s %10s %10s %s\n",
1227 paddress (gdbarch
, start
),
1228 paddress (gdbarch
, end
),
1229 hex_string (end
- start
),
1230 hex_string (file_ofs
),
1235 /* Implement "info proc" for a corefile. */
1238 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1239 enum info_proc_what what
)
1241 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1242 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1248 exe
= bfd_core_file_failing_command (core_bfd
);
1250 printf_filtered ("exe = '%s'\n", exe
);
1252 warning (_("unable to find command name in core file"));
1256 linux_core_info_proc_mappings (gdbarch
, args
);
1258 if (!exe_f
&& !mappings_f
)
1259 error (_("unable to handle request"));
1262 /* Read siginfo data from the core, if possible. Returns -1 on
1263 failure. Otherwise, returns the number of bytes read. READBUF,
1264 OFFSET, and LEN are all as specified by the to_xfer_partial
1268 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1269 ULONGEST offset
, ULONGEST len
)
1271 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1272 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1273 if (section
== NULL
)
1276 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1282 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1283 ULONGEST offset
, ULONGEST inode
,
1284 int read
, int write
,
1285 int exec
, int modified
,
1286 const char *filename
,
1289 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags
,
1290 const struct smaps_vmflags
*v
,
1291 int maybe_private_p
,
1294 const char *filename
,
1298 /* Helper function to parse the contents of /proc/<pid>/smaps into a data
1299 structure, for easy access.
1301 DATA is the contents of the smaps file. The parsed contents are stored
1302 into the SMAPS vector. */
1304 static std::vector
<struct smaps_data
>
1305 parse_smaps_data (const char *data
,
1306 const std::string maps_filename
)
1310 gdb_assert (data
!= nullptr);
1312 line
= strtok_r ((char *) data
, "\n", &t
);
1314 std::vector
<struct smaps_data
> smaps
;
1316 while (line
!= NULL
)
1318 ULONGEST addr
, endaddr
, offset
, inode
;
1319 const char *permissions
, *device
, *filename
;
1320 struct smaps_vmflags v
;
1321 size_t permissions_len
, device_len
;
1322 int read
, write
, exec
, priv
;
1323 int has_anonymous
= 0;
1327 memset (&v
, 0, sizeof (v
));
1328 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1329 &offset
, &device
, &device_len
, &inode
, &filename
);
1330 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1331 /* If the mapping is not anonymous, then we can consider it
1332 to be file-backed. These two states (anonymous or
1333 file-backed) seem to be exclusive, but they can actually
1334 coexist. For example, if a file-backed mapping has
1335 "Anonymous:" pages (see more below), then the Linux
1336 kernel will dump this mapping when the user specified
1337 that she only wants anonymous mappings in the corefile
1338 (*even* when she explicitly disabled the dumping of
1339 file-backed mappings). */
1340 mapping_file_p
= !mapping_anon_p
;
1342 /* Decode permissions. */
1343 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1344 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1345 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1346 /* 'private' here actually means VM_MAYSHARE, and not
1347 VM_SHARED. In order to know if a mapping is really
1348 private or not, we must check the flag "sh" in the
1349 VmFlags field. This is done by decode_vmflags. However,
1350 if we are using a Linux kernel released before the commit
1351 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1352 not have the VmFlags there. In this case, there is
1353 really no way to know if we are dealing with VM_SHARED,
1354 so we just assume that VM_MAYSHARE is enough. */
1355 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1357 /* Try to detect if region should be dumped by parsing smaps
1359 for (line
= strtok_r (NULL
, "\n", &t
);
1360 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1361 line
= strtok_r (NULL
, "\n", &t
))
1363 char keyword
[64 + 1];
1365 if (sscanf (line
, "%64s", keyword
) != 1)
1367 warning (_("Error parsing {s,}maps file '%s'"),
1368 maps_filename
.c_str ());
1372 if (strcmp (keyword
, "Anonymous:") == 0)
1374 /* Older Linux kernels did not support the
1375 "Anonymous:" counter. Check it here. */
1378 else if (strcmp (keyword
, "VmFlags:") == 0)
1379 decode_vmflags (line
, &v
);
1381 if (strcmp (keyword
, "AnonHugePages:") == 0
1382 || strcmp (keyword
, "Anonymous:") == 0)
1384 unsigned long number
;
1386 if (sscanf (line
, "%*s%lu", &number
) != 1)
1388 warning (_("Error parsing {s,}maps file '%s' number"),
1389 maps_filename
.c_str ());
1394 /* Even if we are dealing with a file-backed
1395 mapping, if it contains anonymous pages we
1396 consider it to be *also* an anonymous
1397 mapping, because this is what the Linux
1400 // Dump segments that have been written to.
1401 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1404 Note that if the mapping is already marked as
1405 file-backed (i.e., mapping_file_p is
1406 non-zero), then this is a special case, and
1407 this mapping will be dumped either when the
1408 user wants to dump file-backed *or* anonymous
1414 /* Save the smaps entry to the vector. */
1415 struct smaps_data map
;
1417 map
.start_address
= addr
;
1418 map
.end_address
= endaddr
;
1419 map
.filename
= filename
;
1421 map
.read
= read
? true : false;
1422 map
.write
= write
? true : false;
1423 map
.exec
= exec
? true : false;
1424 map
.priv
= priv
? true : false;
1425 map
.has_anonymous
= has_anonymous
;
1426 map
.mapping_anon_p
= mapping_anon_p
? true : false;
1427 map
.mapping_file_p
= mapping_file_p
? true : false;
1428 map
.offset
= offset
;
1431 smaps
.emplace_back (map
);
1437 /* See linux-tdep.h. */
1440 linux_address_in_memtag_page (CORE_ADDR address
)
1442 if (current_inferior ()->fake_pid_p
)
1445 pid_t pid
= current_inferior ()->pid
;
1447 std::string smaps_file
= string_printf ("/proc/%d/smaps", pid
);
1449 gdb::unique_xmalloc_ptr
<char> data
1450 = target_fileio_read_stralloc (NULL
, smaps_file
.c_str ());
1452 if (data
== nullptr)
1455 /* Parse the contents of smaps into a vector. */
1456 std::vector
<struct smaps_data
> smaps
1457 = parse_smaps_data (data
.get (), smaps_file
);
1459 for (const smaps_data
&map
: smaps
)
1461 /* Is the address within [start_address, end_address) in a page
1462 mapped with memory tagging? */
1463 if (address
>= map
.start_address
1464 && address
< map
.end_address
1465 && map
.vmflags
.memory_tagging
)
1472 /* List memory regions in the inferior for a corefile. */
1475 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1476 linux_dump_mapping_p_ftype
*should_dump_mapping_p
,
1477 linux_find_memory_region_ftype
*func
,
1481 /* Default dump behavior of coredump_filter (0x33), according to
1482 Documentation/filesystems/proc.txt from the Linux kernel
1484 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1485 | COREFILTER_ANON_SHARED
1486 | COREFILTER_ELF_HEADERS
1487 | COREFILTER_HUGETLB_PRIVATE
);
1489 /* We need to know the real target PID to access /proc. */
1490 if (current_inferior ()->fake_pid_p
)
1493 pid
= current_inferior ()->pid
;
1495 if (use_coredump_filter
)
1497 std::string core_dump_filter_name
1498 = string_printf ("/proc/%d/coredump_filter", pid
);
1500 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1501 = target_fileio_read_stralloc (NULL
, core_dump_filter_name
.c_str ());
1503 if (coredumpfilterdata
!= NULL
)
1507 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1508 filterflags
= (enum filter_flag
) flags
;
1512 std::string maps_filename
= string_printf ("/proc/%d/smaps", pid
);
1514 gdb::unique_xmalloc_ptr
<char> data
1515 = target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1519 /* Older Linux kernels did not support /proc/PID/smaps. */
1520 maps_filename
= string_printf ("/proc/%d/maps", pid
);
1521 data
= target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1523 if (data
== nullptr)
1527 /* Parse the contents of smaps into a vector. */
1528 std::vector
<struct smaps_data
> smaps
1529 = parse_smaps_data (data
.get (), maps_filename
.c_str ());
1531 for (const struct smaps_data
&map
: smaps
)
1533 int should_dump_p
= 0;
1535 if (map
.has_anonymous
)
1538 = should_dump_mapping_p (filterflags
, &map
.vmflags
,
1542 map
.filename
.c_str (),
1548 /* Older Linux kernels did not support the "Anonymous:" counter.
1549 If it is missing, we can't be sure - dump all the pages. */
1553 /* Invoke the callback function to create the corefile segment. */
1556 func (map
.start_address
, map
.end_address
- map
.start_address
,
1557 map
.offset
, map
.inode
, map
.read
, map
.write
, map
.exec
,
1558 1, /* MODIFIED is true because we want to dump
1560 map
.filename
.c_str (), obfd
);
1567 /* A structure for passing information through
1568 linux_find_memory_regions_full. */
1570 struct linux_find_memory_regions_data
1572 /* The original callback. */
1574 find_memory_region_ftype func
;
1576 /* The original datum. */
1581 /* A callback for linux_find_memory_regions that converts between the
1582 "full"-style callback and find_memory_region_ftype. */
1585 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1586 ULONGEST offset
, ULONGEST inode
,
1587 int read
, int write
, int exec
, int modified
,
1588 const char *filename
, void *arg
)
1590 struct linux_find_memory_regions_data
*data
1591 = (struct linux_find_memory_regions_data
*) arg
;
1593 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1596 /* A variant of linux_find_memory_regions_full that is suitable as the
1597 gdbarch find_memory_regions method. */
1600 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1601 find_memory_region_ftype func
, void *obfd
)
1603 struct linux_find_memory_regions_data data
;
1608 return linux_find_memory_regions_full (gdbarch
,
1610 linux_find_memory_regions_thunk
,
1614 /* This is used to pass information from
1615 linux_make_mappings_corefile_notes through
1616 linux_find_memory_regions_full. */
1618 struct linux_make_mappings_data
1620 /* Number of files mapped. */
1621 ULONGEST file_count
;
1623 /* The obstack for the main part of the data. */
1624 struct obstack
*data_obstack
;
1626 /* The filename obstack. */
1627 struct obstack
*filename_obstack
;
1629 /* The architecture's "long" type. */
1630 struct type
*long_type
;
1633 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1635 /* A callback for linux_find_memory_regions_full that updates the
1636 mappings data for linux_make_mappings_corefile_notes. */
1639 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1640 ULONGEST offset
, ULONGEST inode
,
1641 int read
, int write
, int exec
, int modified
,
1642 const char *filename
, void *data
)
1644 struct linux_make_mappings_data
*map_data
1645 = (struct linux_make_mappings_data
*) data
;
1646 gdb_byte buf
[sizeof (ULONGEST
)];
1648 if (*filename
== '\0' || inode
== 0)
1651 ++map_data
->file_count
;
1653 pack_long (buf
, map_data
->long_type
, vaddr
);
1654 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1655 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1656 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1657 pack_long (buf
, map_data
->long_type
, offset
);
1658 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1660 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1665 /* Write the file mapping data to the core file, if possible. OBFD is
1666 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1667 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1670 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1671 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1674 struct linux_make_mappings_data mapping_data
;
1675 struct type
*long_type
1676 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1677 gdb_byte buf
[sizeof (ULONGEST
)];
1679 auto_obstack data_obstack
, filename_obstack
;
1681 mapping_data
.file_count
= 0;
1682 mapping_data
.data_obstack
= &data_obstack
;
1683 mapping_data
.filename_obstack
= &filename_obstack
;
1684 mapping_data
.long_type
= long_type
;
1686 /* Reserve space for the count. */
1687 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1688 /* We always write the page size as 1 since we have no good way to
1689 determine the correct value. */
1690 pack_long (buf
, long_type
, 1);
1691 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1693 linux_find_memory_regions_full (gdbarch
,
1695 linux_make_mappings_callback
,
1698 if (mapping_data
.file_count
!= 0)
1700 /* Write the count to the obstack. */
1701 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1702 long_type
, mapping_data
.file_count
);
1704 /* Copy the filenames to the data obstack. */
1705 int size
= obstack_object_size (&filename_obstack
);
1706 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1709 note_data
.reset (elfcore_write_file_note (obfd
, note_data
.release (), note_size
,
1710 obstack_base (&data_obstack
),
1711 obstack_object_size (&data_obstack
)));
1715 /* Fetch the siginfo data for the specified thread, if it exists. If
1716 there is no data, or we could not read it, return an empty
1719 static gdb::byte_vector
1720 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1722 struct type
*siginfo_type
;
1725 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1726 return gdb::byte_vector ();
1728 scoped_restore_current_thread save_current_thread
;
1729 switch_to_thread (thread
);
1731 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1733 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1735 bytes_read
= target_read (current_inferior ()->top_target (),
1736 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1737 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1738 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1744 struct linux_corefile_thread_data
1746 linux_corefile_thread_data (struct gdbarch
*gdbarch
, bfd
*obfd
,
1747 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1748 int *note_size
, gdb_signal stop_signal
)
1749 : gdbarch (gdbarch
), obfd (obfd
), note_data (note_data
),
1750 note_size (note_size
), stop_signal (stop_signal
)
1753 struct gdbarch
*gdbarch
;
1755 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1757 enum gdb_signal stop_signal
;
1760 /* Records the thread's register state for the corefile note
1764 linux_corefile_thread (struct thread_info
*info
,
1765 struct linux_corefile_thread_data
*args
)
1767 gcore_elf_build_thread_register_notes (args
->gdbarch
, info
,
1769 args
->obfd
, &args
->note_data
,
1772 /* Don't return anything if we got no register information above,
1773 such a core file is useless. */
1774 if (args
->note_data
!= NULL
)
1776 gdb::byte_vector siginfo_data
1777 = linux_get_siginfo_data (info
, args
->gdbarch
);
1778 if (!siginfo_data
.empty ())
1779 args
->note_data
.reset (elfcore_write_note (args
->obfd
,
1780 args
->note_data
.release (),
1783 siginfo_data
.data (),
1784 siginfo_data
.size ()));
1788 /* Fill the PRPSINFO structure with information about the process being
1789 debugged. Returns 1 in case of success, 0 for failures. Please note that
1790 even if the structure cannot be entirely filled (e.g., GDB was unable to
1791 gather information about the process UID/GID), this function will still
1792 return 1 since some information was already recorded. It will only return
1793 0 iff nothing can be gathered. */
1796 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1798 /* The filename which we will use to obtain some info about the process.
1799 We will basically use this to store the `/proc/PID/FILENAME' file. */
1801 /* The basename of the executable. */
1802 const char *basename
;
1803 /* Temporary buffer. */
1805 /* The valid states of a process, according to the Linux kernel. */
1806 const char valid_states
[] = "RSDTZW";
1807 /* The program state. */
1808 const char *prog_state
;
1809 /* The state of the process. */
1811 /* The PID of the program which generated the corefile. */
1813 /* Process flags. */
1814 unsigned int pr_flag
;
1815 /* Process nice value. */
1817 /* The number of fields read by `sscanf'. */
1820 gdb_assert (p
!= NULL
);
1822 /* Obtaining PID and filename. */
1823 pid
= inferior_ptid
.pid ();
1824 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1825 /* The full name of the program which generated the corefile. */
1826 gdb::unique_xmalloc_ptr
<char> fname
1827 = target_fileio_read_stralloc (NULL
, filename
);
1829 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1831 /* No program name was read, so we won't be able to retrieve more
1832 information about the process. */
1836 memset (p
, 0, sizeof (*p
));
1838 /* Defining the PID. */
1841 /* Copying the program name. Only the basename matters. */
1842 basename
= lbasename (fname
.get ());
1843 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1844 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1846 const std::string
&infargs
= current_inferior ()->args ();
1848 /* The arguments of the program. */
1849 std::string psargs
= fname
.get ();
1850 if (!infargs
.empty ())
1851 psargs
+= ' ' + infargs
;
1853 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1854 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1856 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1857 /* The contents of `/proc/PID/stat'. */
1858 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1859 = target_fileio_read_stralloc (NULL
, filename
);
1860 char *proc_stat
= proc_stat_contents
.get ();
1862 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1864 /* Despite being unable to read more information about the
1865 process, we return 1 here because at least we have its
1866 command line, PID and arguments. */
1870 /* Ok, we have the stats. It's time to do a little parsing of the
1871 contents of the buffer, so that we end up reading what we want.
1873 The following parsing mechanism is strongly based on the
1874 information generated by the `fs/proc/array.c' file, present in
1875 the Linux kernel tree. More details about how the information is
1876 displayed can be obtained by seeing the manpage of proc(5),
1877 specifically under the entry of `/proc/[pid]/stat'. */
1879 /* Getting rid of the PID, since we already have it. */
1880 while (isdigit (*proc_stat
))
1883 proc_stat
= skip_spaces (proc_stat
);
1885 /* ps command also relies on no trailing fields ever contain ')'. */
1886 proc_stat
= strrchr (proc_stat
, ')');
1887 if (proc_stat
== NULL
)
1891 proc_stat
= skip_spaces (proc_stat
);
1893 n_fields
= sscanf (proc_stat
,
1894 "%c" /* Process state. */
1895 "%d%d%d" /* Parent PID, group ID, session ID. */
1896 "%*d%*d" /* tty_nr, tpgid (not used). */
1898 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1899 cmajflt (not used). */
1900 "%*s%*s%*s%*s" /* utime, stime, cutime,
1901 cstime (not used). */
1902 "%*s" /* Priority (not used). */
1905 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1911 /* Again, we couldn't read the complementary information about
1912 the process state. However, we already have minimal
1913 information, so we just return 1 here. */
1917 /* Filling the structure fields. */
1918 prog_state
= strchr (valid_states
, pr_sname
);
1919 if (prog_state
!= NULL
)
1920 p
->pr_state
= prog_state
- valid_states
;
1923 /* Zero means "Running". */
1927 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1928 p
->pr_zomb
= p
->pr_sname
== 'Z';
1929 p
->pr_nice
= pr_nice
;
1930 p
->pr_flag
= pr_flag
;
1932 /* Finally, obtaining the UID and GID. For that, we read and parse the
1933 contents of the `/proc/PID/status' file. */
1934 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1935 /* The contents of `/proc/PID/status'. */
1936 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1937 = target_fileio_read_stralloc (NULL
, filename
);
1938 char *proc_status
= proc_status_contents
.get ();
1940 if (proc_status
== NULL
|| *proc_status
== '\0')
1942 /* Returning 1 since we already have a bunch of information. */
1946 /* Extracting the UID. */
1947 tmpstr
= strstr (proc_status
, "Uid:");
1950 /* Advancing the pointer to the beginning of the UID. */
1951 tmpstr
+= sizeof ("Uid:");
1952 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1955 if (isdigit (*tmpstr
))
1956 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1959 /* Extracting the GID. */
1960 tmpstr
= strstr (proc_status
, "Gid:");
1963 /* Advancing the pointer to the beginning of the GID. */
1964 tmpstr
+= sizeof ("Gid:");
1965 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1968 if (isdigit (*tmpstr
))
1969 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1975 /* Build the note section for a corefile, and return it in a malloc
1978 static gdb::unique_xmalloc_ptr
<char>
1979 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1981 struct elf_internal_linux_prpsinfo prpsinfo
;
1982 gdb::unique_xmalloc_ptr
<char> note_data
;
1984 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1987 if (linux_fill_prpsinfo (&prpsinfo
))
1989 if (gdbarch_ptr_bit (gdbarch
) == 64)
1990 note_data
.reset (elfcore_write_linux_prpsinfo64 (obfd
,
1991 note_data
.release (),
1992 note_size
, &prpsinfo
));
1994 note_data
.reset (elfcore_write_linux_prpsinfo32 (obfd
,
1995 note_data
.release (),
1996 note_size
, &prpsinfo
));
1999 /* Thread register information. */
2002 update_thread_list ();
2004 catch (const gdb_exception_error
&e
)
2006 exception_print (gdb_stderr
, e
);
2009 /* Like the kernel, prefer dumping the signalled thread first.
2010 "First thread" is what tools use to infer the signalled
2012 thread_info
*signalled_thr
= gcore_find_signalled_thread ();
2013 gdb_signal stop_signal
;
2014 if (signalled_thr
!= nullptr)
2015 stop_signal
= signalled_thr
->stop_signal ();
2017 stop_signal
= GDB_SIGNAL_0
;
2019 linux_corefile_thread_data
thread_args (gdbarch
, obfd
, note_data
, note_size
,
2022 if (signalled_thr
!= nullptr)
2023 linux_corefile_thread (signalled_thr
, &thread_args
);
2024 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
2026 if (thr
== signalled_thr
)
2029 linux_corefile_thread (thr
, &thread_args
);
2035 /* Auxillary vector. */
2036 gdb::optional
<gdb::byte_vector
> auxv
=
2037 target_read_alloc (current_inferior ()->top_target (),
2038 TARGET_OBJECT_AUXV
, NULL
);
2039 if (auxv
&& !auxv
->empty ())
2041 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
2042 note_size
, "CORE", NT_AUXV
,
2043 auxv
->data (), auxv
->size ()));
2049 /* File mappings. */
2050 linux_make_mappings_corefile_notes (gdbarch
, obfd
, note_data
, note_size
);
2052 /* Target description. */
2053 gcore_elf_make_tdesc_note (obfd
, ¬e_data
, note_size
);
2058 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2059 gdbarch.h. This function is not static because it is exported to
2060 other -tdep files. */
2063 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2068 return GDB_SIGNAL_0
;
2071 return GDB_SIGNAL_HUP
;
2074 return GDB_SIGNAL_INT
;
2077 return GDB_SIGNAL_QUIT
;
2080 return GDB_SIGNAL_ILL
;
2083 return GDB_SIGNAL_TRAP
;
2086 return GDB_SIGNAL_ABRT
;
2089 return GDB_SIGNAL_BUS
;
2092 return GDB_SIGNAL_FPE
;
2095 return GDB_SIGNAL_KILL
;
2098 return GDB_SIGNAL_USR1
;
2101 return GDB_SIGNAL_SEGV
;
2104 return GDB_SIGNAL_USR2
;
2107 return GDB_SIGNAL_PIPE
;
2110 return GDB_SIGNAL_ALRM
;
2113 return GDB_SIGNAL_TERM
;
2116 return GDB_SIGNAL_CHLD
;
2119 return GDB_SIGNAL_CONT
;
2122 return GDB_SIGNAL_STOP
;
2125 return GDB_SIGNAL_TSTP
;
2128 return GDB_SIGNAL_TTIN
;
2131 return GDB_SIGNAL_TTOU
;
2134 return GDB_SIGNAL_URG
;
2137 return GDB_SIGNAL_XCPU
;
2140 return GDB_SIGNAL_XFSZ
;
2142 case LINUX_SIGVTALRM
:
2143 return GDB_SIGNAL_VTALRM
;
2146 return GDB_SIGNAL_PROF
;
2148 case LINUX_SIGWINCH
:
2149 return GDB_SIGNAL_WINCH
;
2151 /* No way to differentiate between SIGIO and SIGPOLL.
2152 Therefore, we just handle the first one. */
2154 return GDB_SIGNAL_IO
;
2157 return GDB_SIGNAL_PWR
;
2160 return GDB_SIGNAL_SYS
;
2162 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2163 therefore we have to handle them here. */
2164 case LINUX_SIGRTMIN
:
2165 return GDB_SIGNAL_REALTIME_32
;
2167 case LINUX_SIGRTMAX
:
2168 return GDB_SIGNAL_REALTIME_64
;
2171 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2173 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2175 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2178 return GDB_SIGNAL_UNKNOWN
;
2181 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2182 gdbarch.h. This function is not static because it is exported to
2183 other -tdep files. */
2186 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2187 enum gdb_signal signal
)
2194 case GDB_SIGNAL_HUP
:
2195 return LINUX_SIGHUP
;
2197 case GDB_SIGNAL_INT
:
2198 return LINUX_SIGINT
;
2200 case GDB_SIGNAL_QUIT
:
2201 return LINUX_SIGQUIT
;
2203 case GDB_SIGNAL_ILL
:
2204 return LINUX_SIGILL
;
2206 case GDB_SIGNAL_TRAP
:
2207 return LINUX_SIGTRAP
;
2209 case GDB_SIGNAL_ABRT
:
2210 return LINUX_SIGABRT
;
2212 case GDB_SIGNAL_FPE
:
2213 return LINUX_SIGFPE
;
2215 case GDB_SIGNAL_KILL
:
2216 return LINUX_SIGKILL
;
2218 case GDB_SIGNAL_BUS
:
2219 return LINUX_SIGBUS
;
2221 case GDB_SIGNAL_SEGV
:
2222 return LINUX_SIGSEGV
;
2224 case GDB_SIGNAL_SYS
:
2225 return LINUX_SIGSYS
;
2227 case GDB_SIGNAL_PIPE
:
2228 return LINUX_SIGPIPE
;
2230 case GDB_SIGNAL_ALRM
:
2231 return LINUX_SIGALRM
;
2233 case GDB_SIGNAL_TERM
:
2234 return LINUX_SIGTERM
;
2236 case GDB_SIGNAL_URG
:
2237 return LINUX_SIGURG
;
2239 case GDB_SIGNAL_STOP
:
2240 return LINUX_SIGSTOP
;
2242 case GDB_SIGNAL_TSTP
:
2243 return LINUX_SIGTSTP
;
2245 case GDB_SIGNAL_CONT
:
2246 return LINUX_SIGCONT
;
2248 case GDB_SIGNAL_CHLD
:
2249 return LINUX_SIGCHLD
;
2251 case GDB_SIGNAL_TTIN
:
2252 return LINUX_SIGTTIN
;
2254 case GDB_SIGNAL_TTOU
:
2255 return LINUX_SIGTTOU
;
2260 case GDB_SIGNAL_XCPU
:
2261 return LINUX_SIGXCPU
;
2263 case GDB_SIGNAL_XFSZ
:
2264 return LINUX_SIGXFSZ
;
2266 case GDB_SIGNAL_VTALRM
:
2267 return LINUX_SIGVTALRM
;
2269 case GDB_SIGNAL_PROF
:
2270 return LINUX_SIGPROF
;
2272 case GDB_SIGNAL_WINCH
:
2273 return LINUX_SIGWINCH
;
2275 case GDB_SIGNAL_USR1
:
2276 return LINUX_SIGUSR1
;
2278 case GDB_SIGNAL_USR2
:
2279 return LINUX_SIGUSR2
;
2281 case GDB_SIGNAL_PWR
:
2282 return LINUX_SIGPWR
;
2284 case GDB_SIGNAL_POLL
:
2285 return LINUX_SIGPOLL
;
2287 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2288 therefore we have to handle it here. */
2289 case GDB_SIGNAL_REALTIME_32
:
2290 return LINUX_SIGRTMIN
;
2292 /* Same comment applies to _64. */
2293 case GDB_SIGNAL_REALTIME_64
:
2294 return LINUX_SIGRTMAX
;
2297 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2298 if (signal
>= GDB_SIGNAL_REALTIME_33
2299 && signal
<= GDB_SIGNAL_REALTIME_63
)
2301 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2303 return LINUX_SIGRTMIN
+ 1 + offset
;
2309 /* Helper for linux_vsyscall_range that does the real work of finding
2310 the vsyscall's address range. */
2313 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2318 if (target_auxv_search (current_inferior ()->top_target (),
2319 AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2322 /* It doesn't make sense to access the host's /proc when debugging a
2323 core file. Instead, look for the PT_LOAD segment that matches
2325 if (!target_has_execution ())
2330 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2331 if (phdrs_size
== -1)
2334 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2335 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2336 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2337 if (num_phdrs
== -1)
2340 for (i
= 0; i
< num_phdrs
; i
++)
2341 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2342 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2344 range
->length
= phdrs
.get ()[i
].p_memsz
;
2351 /* We need to know the real target PID to access /proc. */
2352 if (current_inferior ()->fake_pid_p
)
2355 pid
= current_inferior ()->pid
;
2357 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2358 reading /proc/PID/maps (2). The later identifies thread stacks
2359 in the output, which requires scanning every thread in the thread
2360 group to check whether a VMA is actually a thread's stack. With
2361 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2362 a few thousand threads, (1) takes a few miliseconds, while (2)
2363 takes several seconds. Also note that "smaps", what we read for
2364 determining core dump mappings, is even slower than "maps". */
2365 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2366 gdb::unique_xmalloc_ptr
<char> data
2367 = target_fileio_read_stralloc (NULL
, filename
);
2371 char *saveptr
= NULL
;
2373 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2375 line
= strtok_r (NULL
, "\n", &saveptr
))
2377 ULONGEST addr
, endaddr
;
2378 const char *p
= line
;
2380 addr
= strtoulst (p
, &p
, 16);
2381 if (addr
== range
->start
)
2385 endaddr
= strtoulst (p
, &p
, 16);
2386 range
->length
= endaddr
- addr
;
2392 warning (_("unable to open /proc file '%s'"), filename
);
2397 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2398 caching, and defers the real work to linux_vsyscall_range_raw. */
2401 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2403 struct linux_info
*info
= get_linux_inferior_data (current_inferior ());
2405 if (info
->vsyscall_range_p
== 0)
2407 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2408 info
->vsyscall_range_p
= 1;
2410 info
->vsyscall_range_p
= -1;
2413 if (info
->vsyscall_range_p
< 0)
2416 *range
= info
->vsyscall_range
;
2420 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2421 definitions would be dependent on compilation host. */
2422 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2423 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2425 /* See gdbarch.sh 'infcall_mmap'. */
2428 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2430 struct objfile
*objf
;
2431 /* Do there still exist any Linux systems without "mmap64"?
2432 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2433 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2434 struct value
*addr_val
;
2435 struct gdbarch
*gdbarch
= objf
->arch ();
2439 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2441 struct value
*arg
[ARG_LAST
];
2443 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2445 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2446 arg
[ARG_LENGTH
] = value_from_ulongest
2447 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2448 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2449 | GDB_MMAP_PROT_EXEC
))
2451 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2452 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2453 GDB_MMAP_MAP_PRIVATE
2454 | GDB_MMAP_MAP_ANONYMOUS
);
2455 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2456 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2458 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2459 retval
= value_as_address (addr_val
);
2460 if (retval
== (CORE_ADDR
) -1)
2461 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2466 /* See gdbarch.sh 'infcall_munmap'. */
2469 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2471 struct objfile
*objf
;
2472 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2473 struct value
*retval_val
;
2474 struct gdbarch
*gdbarch
= objf
->arch ();
2478 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2480 struct value
*arg
[ARG_LAST
];
2482 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2484 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2485 arg
[ARG_LENGTH
] = value_from_ulongest
2486 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2487 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2488 retval
= value_as_long (retval_val
);
2490 warning (_("Failed inferior munmap call at %s for %s bytes, "
2491 "errno is changed."),
2492 hex_string (addr
), pulongest (size
));
2495 /* See linux-tdep.h. */
2498 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2503 /* Determine entry point from target auxiliary vector. This avoids
2504 the need for symbols. Also, when debugging a stand-alone SPU
2505 executable, entry_point_address () will point to an SPU
2506 local-store address and is thus not usable as displaced stepping
2507 location. The auxiliary vector gets us the PowerPC-side entry
2508 point address instead. */
2509 if (target_auxv_search (current_inferior ()->top_target (),
2510 AT_ENTRY
, &addr
) <= 0)
2511 throw_error (NOT_SUPPORTED_ERROR
,
2512 _("Cannot find AT_ENTRY auxiliary vector entry."));
2514 /* Make certain that the address points at real code, and not a
2515 function descriptor. */
2516 addr
= gdbarch_convert_from_func_ptr_addr
2517 (gdbarch
, addr
, current_inferior ()->top_target ());
2519 /* Inferior calls also use the entry point as a breakpoint location.
2520 We don't want displaced stepping to interfere with those
2521 breakpoints, so leave space. */
2522 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2528 /* See linux-tdep.h. */
2530 displaced_step_prepare_status
2531 linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2532 CORE_ADDR
&displaced_pc
)
2534 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2536 if (!per_inferior
->disp_step_bufs
.has_value ())
2538 /* Figure out the location of the buffers. They are contiguous, starting
2539 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2540 CORE_ADDR disp_step_buf_addr
2541 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2542 int buf_len
= gdbarch_max_insn_length (arch
);
2544 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (arch
);
2545 gdb_assert (gdbarch_data
->num_disp_step_buffers
> 0);
2547 std::vector
<CORE_ADDR
> buffers
;
2548 for (int i
= 0; i
< gdbarch_data
->num_disp_step_buffers
; i
++)
2549 buffers
.push_back (disp_step_buf_addr
+ i
* buf_len
);
2551 per_inferior
->disp_step_bufs
.emplace (buffers
);
2554 return per_inferior
->disp_step_bufs
->prepare (thread
, displaced_pc
);
2557 /* See linux-tdep.h. */
2559 displaced_step_finish_status
2560 linux_displaced_step_finish (gdbarch
*arch
, thread_info
*thread
, gdb_signal sig
)
2562 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2564 gdb_assert (per_inferior
->disp_step_bufs
.has_value ());
2566 return per_inferior
->disp_step_bufs
->finish (arch
, thread
, sig
);
2569 /* See linux-tdep.h. */
2571 const displaced_step_copy_insn_closure
*
2572 linux_displaced_step_copy_insn_closure_by_addr (inferior
*inf
, CORE_ADDR addr
)
2574 linux_info
*per_inferior
= linux_inferior_data
.get (inf
);
2576 if (per_inferior
== nullptr
2577 || !per_inferior
->disp_step_bufs
.has_value ())
2580 return per_inferior
->disp_step_bufs
->copy_insn_closure_by_addr (addr
);
2583 /* See linux-tdep.h. */
2586 linux_displaced_step_restore_all_in_ptid (inferior
*parent_inf
, ptid_t ptid
)
2588 linux_info
*per_inferior
= linux_inferior_data
.get (parent_inf
);
2590 if (per_inferior
== nullptr
2591 || !per_inferior
->disp_step_bufs
.has_value ())
2594 per_inferior
->disp_step_bufs
->restore_in_ptid (ptid
);
2597 /* See linux-tdep.h. */
2600 linux_get_hwcap (struct target_ops
*target
)
2603 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2608 /* See linux-tdep.h. */
2611 linux_get_hwcap2 (struct target_ops
*target
)
2614 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2619 /* Display whether the gcore command is using the
2620 /proc/PID/coredump_filter file. */
2623 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2624 struct cmd_list_element
*c
, const char *value
)
2626 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2627 " corefiles is %s.\n"), value
);
2630 /* Display whether the gcore command is dumping mappings marked with
2631 the VM_DONTDUMP flag. */
2634 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2635 struct cmd_list_element
*c
, const char *value
)
2637 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2638 " flag is %s.\n"), value
);
2641 /* To be called from the various GDB_OSABI_LINUX handlers for the
2642 various GNU/Linux architectures and machine types.
2644 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2645 displaced stepping is not supported. */
2648 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
,
2649 int num_disp_step_buffers
)
2651 if (num_disp_step_buffers
> 0)
2653 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
2654 gdbarch_data
->num_disp_step_buffers
= num_disp_step_buffers
;
2656 set_gdbarch_displaced_step_prepare (gdbarch
,
2657 linux_displaced_step_prepare
);
2658 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
2659 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2660 (gdbarch
, linux_displaced_step_copy_insn_closure_by_addr
);
2661 set_gdbarch_displaced_step_restore_all_in_ptid
2662 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
2665 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2666 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2667 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2668 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2669 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2670 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2671 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2672 set_gdbarch_has_shared_address_space (gdbarch
,
2673 linux_has_shared_address_space
);
2674 set_gdbarch_gdb_signal_from_target (gdbarch
,
2675 linux_gdb_signal_from_target
);
2676 set_gdbarch_gdb_signal_to_target (gdbarch
,
2677 linux_gdb_signal_to_target
);
2678 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2679 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2680 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2681 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2684 void _initialize_linux_tdep ();
2686 _initialize_linux_tdep ()
2688 linux_gdbarch_data_handle
=
2689 gdbarch_data_register_pre_init (init_linux_gdbarch_data
);
2691 /* Observers used to invalidate the cache when needed. */
2692 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
,
2694 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
,
2696 gdb::observers::inferior_execd
.attach (invalidate_linux_cache_inf
,
2699 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2700 &use_coredump_filter
, _("\
2701 Set whether gcore should consider /proc/PID/coredump_filter."),
2703 Show whether gcore should consider /proc/PID/coredump_filter."),
2705 Use this command to set whether gcore should consider the contents\n\
2706 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2707 about this file, refer to the manpage of core(5)."),
2708 NULL
, show_use_coredump_filter
,
2709 &setlist
, &showlist
);
2711 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2712 &dump_excluded_mappings
, _("\
2713 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2715 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2717 Use this command to set whether gcore should dump mappings marked with the\n\
2718 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2719 more information about this file, refer to the manpage of proc(5) and core(5)."),
2720 NULL
, show_dump_excluded_mappings
,
2721 &setlist
, &showlist
);
2724 /* Fetch (and possibly build) an appropriate `link_map_offsets' for
2725 ILP32/LP64 Linux systems which don't have the r_ldsomap field. */
2728 linux_ilp32_fetch_link_map_offsets ()
2730 static link_map_offsets lmo
;
2731 static link_map_offsets
*lmp
= nullptr;
2737 lmo
.r_version_offset
= 0;
2738 lmo
.r_version_size
= 4;
2739 lmo
.r_map_offset
= 4;
2740 lmo
.r_brk_offset
= 8;
2741 lmo
.r_ldsomap_offset
= -1;
2743 /* Everything we need is in the first 20 bytes. */
2744 lmo
.link_map_size
= 20;
2745 lmo
.l_addr_offset
= 0;
2746 lmo
.l_name_offset
= 4;
2747 lmo
.l_ld_offset
= 8;
2748 lmo
.l_next_offset
= 12;
2749 lmo
.l_prev_offset
= 16;
2756 linux_lp64_fetch_link_map_offsets ()
2758 static link_map_offsets lmo
;
2759 static link_map_offsets
*lmp
= nullptr;
2765 lmo
.r_version_offset
= 0;
2766 lmo
.r_version_size
= 4;
2767 lmo
.r_map_offset
= 8;
2768 lmo
.r_brk_offset
= 16;
2769 lmo
.r_ldsomap_offset
= -1;
2771 /* Everything we need is in the first 40 bytes. */
2772 lmo
.link_map_size
= 40;
2773 lmo
.l_addr_offset
= 0;
2774 lmo
.l_name_offset
= 8;
2775 lmo
.l_ld_offset
= 16;
2776 lmo
.l_next_offset
= 24;
2777 lmo
.l_prev_offset
= 32;