1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2023 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 #include <unordered_map>
50 /* This enum represents the values that the user can choose when
51 informing the Linux kernel about which memory mappings will be
52 dumped in a corefile. They are described in the file
53 Documentation/filesystems/proc.txt, inside the Linux kernel
58 COREFILTER_ANON_PRIVATE = 1 << 0,
59 COREFILTER_ANON_SHARED = 1 << 1,
60 COREFILTER_MAPPED_PRIVATE = 1 << 2,
61 COREFILTER_MAPPED_SHARED = 1 << 3,
62 COREFILTER_ELF_HEADERS = 1 << 4,
63 COREFILTER_HUGETLB_PRIVATE = 1 << 5,
64 COREFILTER_HUGETLB_SHARED = 1 << 6,
66 DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
68 /* This struct is used to map flags found in the "VmFlags:" field (in
69 the /proc/<PID>/smaps file). */
73 /* Zero if this structure has not been initialized yet. It
74 probably means that the Linux kernel being used does not emit
75 the "VmFlags:" field on "/proc/PID/smaps". */
77 unsigned int initialized_p : 1;
79 /* Memory mapped I/O area (VM_IO, "io"). */
81 unsigned int io_page : 1;
83 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
85 unsigned int uses_huge_tlb : 1;
87 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
89 unsigned int exclude_coredump : 1;
91 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
93 unsigned int shared_mapping : 1;
95 /* Memory map has memory tagging enabled. */
97 unsigned int memory_tagging : 1;
100 /* Data structure that holds the information contained in the
101 /proc/<pid>/smaps file. */
105 ULONGEST start_address;
106 ULONGEST end_address;
107 std::string filename;
108 struct smaps_vmflags vmflags;
121 /* Whether to take the /proc/PID/coredump_filter into account when
122 generating a corefile. */
124 static bool use_coredump_filter = true;
126 /* Whether the value of smaps_vmflags->exclude_coredump should be
127 ignored, including mappings marked with the VM_DONTDUMP flag in
129 static bool dump_excluded_mappings = false;
131 /* This enum represents the signals' numbers on a generic architecture
132 running the Linux kernel. The definition of "generic" comes from
133 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
134 tree, which is the "de facto" implementation of signal numbers to
135 be used by new architecture ports.
137 For those architectures which have differences between the generic
138 standard (e.g., Alpha), we define the different signals (and *only*
139 those) in the specific target-dependent file (e.g.,
140 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
141 tdep file for more information.
143 ARM deserves a special mention here. On the file
144 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
145 (and ARM-only) signal, which is SIGSWI, with the same number as
146 SIGRTMIN. This signal is used only for a very specific target,
147 called ArthurOS (from RISCOS). Therefore, we do not handle it on
148 the ARM-tdep file, and we can safely use the generic signal handler
149 here for ARM targets.
151 As stated above, this enum is derived from
152 <include/uapi/asm-generic/signal.h>, from the Linux kernel
173 LINUX_SIGSTKFLT = 16,
183 LINUX_SIGVTALRM = 26,
187 LINUX_SIGPOLL = LINUX_SIGIO,
190 LINUX_SIGUNUSED = 31,
196 struct linux_gdbarch_data
198 struct type *siginfo_type = nullptr;
199 int num_disp_step_buffers = 0;
202 static const registry<gdbarch>::key<linux_gdbarch_data>
203 linux_gdbarch_data_handle;
205 static struct linux_gdbarch_data *
206 get_linux_gdbarch_data (struct gdbarch *gdbarch)
208 struct linux_gdbarch_data *result = linux_gdbarch_data_handle.get (gdbarch);
209 if (result == nullptr)
210 result = linux_gdbarch_data_handle.emplace (gdbarch);
214 /* Linux-specific cached data. This is used by GDB for caching
215 purposes for each inferior. This helps reduce the overhead of
216 transfering data from a remote target to the local host. */
219 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
220 if VSYSCALL_RANGE_P is positive. This is cached because getting
221 at this info requires an auxv lookup (which is itself cached),
222 and looking through the inferior's mappings (which change
223 throughout execution and therefore cannot be cached). */
224 struct mem_range vsyscall_range {};
226 /* Zero if we haven't tried looking up the vsyscall's range before
227 yet. Positive if we tried looking it up, and found it. Negative
228 if we tried looking it up but failed. */
229 int vsyscall_range_p = 0;
231 /* Inferior's displaced step buffers. */
232 gdb::optional<displaced_step_buffers> disp_step_bufs;
235 /* Per-inferior data key. */
236 static const registry<inferior>::key<linux_info> linux_inferior_data;
238 /* Frees whatever allocated space there is to be freed and sets INF's
239 linux cache data pointer to NULL. */
242 invalidate_linux_cache_inf (struct inferior *inf)
244 linux_inferior_data.clear (inf);
247 /* Fetch the linux cache info for INF. This function always returns a
248 valid INFO pointer. */
250 static struct linux_info *
251 get_linux_inferior_data (inferior *inf)
253 linux_info *info = linux_inferior_data.get (inf);
256 info = linux_inferior_data.emplace (inf);
261 /* See linux-tdep.h. */
264 linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
265 linux_siginfo_extra_fields extra_fields)
267 struct linux_gdbarch_data *linux_gdbarch_data;
268 struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
269 struct type *uid_type, *pid_type;
270 struct type *sigval_type, *clock_type;
271 struct type *siginfo_type, *sifields_type;
274 linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
275 if (linux_gdbarch_data->siginfo_type != NULL)
276 return linux_gdbarch_data->siginfo_type;
278 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
280 uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
282 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
284 short_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
286 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
289 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
290 sigval_type->set_name (xstrdup ("sigval_t"));
291 append_composite_type_field (sigval_type, "sival_int", int_type);
292 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
295 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
296 int_type->length () * TARGET_CHAR_BIT, "__pid_t");
297 pid_type->set_target_type (int_type);
298 pid_type->set_target_is_stub (true);
301 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
302 uint_type->length () * TARGET_CHAR_BIT, "__uid_t");
303 uid_type->set_target_type (uint_type);
304 uid_type->set_target_is_stub (true);
307 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
308 long_type->length () * TARGET_CHAR_BIT,
310 clock_type->set_target_type (long_type);
311 clock_type->set_target_is_stub (true);
314 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
317 const int si_max_size = 128;
319 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
322 if (gdbarch_ptr_bit (gdbarch) == 64)
323 si_pad_size = (si_max_size / size_of_int) - 4;
325 si_pad_size = (si_max_size / size_of_int) - 3;
326 append_composite_type_field (sifields_type, "_pad",
327 init_vector_type (int_type, si_pad_size));
331 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
332 append_composite_type_field (type, "si_pid", pid_type);
333 append_composite_type_field (type, "si_uid", uid_type);
334 append_composite_type_field (sifields_type, "_kill", type);
337 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
338 append_composite_type_field (type, "si_tid", int_type);
339 append_composite_type_field (type, "si_overrun", int_type);
340 append_composite_type_field (type, "si_sigval", sigval_type);
341 append_composite_type_field (sifields_type, "_timer", type);
344 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
345 append_composite_type_field (type, "si_pid", pid_type);
346 append_composite_type_field (type, "si_uid", uid_type);
347 append_composite_type_field (type, "si_sigval", sigval_type);
348 append_composite_type_field (sifields_type, "_rt", type);
351 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
352 append_composite_type_field (type, "si_pid", pid_type);
353 append_composite_type_field (type, "si_uid", uid_type);
354 append_composite_type_field (type, "si_status", int_type);
355 append_composite_type_field (type, "si_utime", clock_type);
356 append_composite_type_field (type, "si_stime", clock_type);
357 append_composite_type_field (sifields_type, "_sigchld", type);
360 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
361 append_composite_type_field (type, "si_addr", void_ptr_type);
363 /* Additional bound fields for _sigfault in case they were requested. */
364 if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
366 struct type *sigfault_bnd_fields;
368 append_composite_type_field (type, "_addr_lsb", short_type);
369 sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
370 append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
371 append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
372 append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
374 append_composite_type_field (sifields_type, "_sigfault", type);
377 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
378 append_composite_type_field (type, "si_band", long_type);
379 append_composite_type_field (type, "si_fd", int_type);
380 append_composite_type_field (sifields_type, "_sigpoll", type);
383 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
384 append_composite_type_field (type, "_call_addr", void_ptr_type);
385 append_composite_type_field (type, "_syscall", int_type);
386 append_composite_type_field (type, "_arch", uint_type);
387 append_composite_type_field (sifields_type, "_sigsys", type);
390 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
391 siginfo_type->set_name (xstrdup ("siginfo"));
392 append_composite_type_field (siginfo_type, "si_signo", int_type);
393 append_composite_type_field (siginfo_type, "si_errno", int_type);
394 append_composite_type_field (siginfo_type, "si_code", int_type);
395 append_composite_type_field_aligned (siginfo_type,
396 "_sifields", sifields_type,
397 long_type->length ());
399 linux_gdbarch_data->siginfo_type = siginfo_type;
404 /* This function is suitable for architectures that don't
405 extend/override the standard siginfo structure. */
408 linux_get_siginfo_type (struct gdbarch *gdbarch)
410 return linux_get_siginfo_type_with_fields (gdbarch, 0);
413 /* Return true if the target is running on uClinux instead of normal
417 linux_is_uclinux (void)
421 return (target_auxv_search (AT_NULL, &dummy) > 0
422 && target_auxv_search (AT_PAGESZ, &dummy) == 0);
426 linux_has_shared_address_space (struct gdbarch *gdbarch)
428 return linux_is_uclinux ();
431 /* This is how we want PTIDs from core files to be printed. */
434 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
436 if (ptid.lwp () != 0)
437 return string_printf ("LWP %ld", ptid.lwp ());
439 return normal_pid_to_str (ptid);
442 /* Data from one mapping from /proc/PID/maps. */
448 gdb::string_view permissions;
450 gdb::string_view device;
453 /* This field is guaranteed to be NULL-terminated, hence it is not a
455 const char *filename;
458 /* Service function for corefiles and info proc. */
461 read_mapping (const char *line)
463 struct mapping mapping;
464 const char *p = line;
466 mapping.addr = strtoulst (p, &p, 16);
469 mapping.endaddr = strtoulst (p, &p, 16);
472 const char *permissions_start = p;
473 while (*p && !isspace (*p))
475 mapping.permissions = {permissions_start, (size_t) (p - permissions_start)};
477 mapping.offset = strtoulst (p, &p, 16);
480 const char *device_start = p;
481 while (*p && !isspace (*p))
483 mapping.device = {device_start, (size_t) (p - device_start)};
485 mapping.inode = strtoulst (p, &p, 10);
488 mapping.filename = p;
493 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
495 This function was based on the documentation found on
496 <Documentation/filesystems/proc.txt>, on the Linux kernel.
498 Linux kernels before commit
499 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
503 decode_vmflags (char *p, struct smaps_vmflags *v)
505 char *saveptr = NULL;
508 v->initialized_p = 1;
509 p = skip_to_space (p);
512 for (s = strtok_r (p, " ", &saveptr);
514 s = strtok_r (NULL, " ", &saveptr))
516 if (strcmp (s, "io") == 0)
518 else if (strcmp (s, "ht") == 0)
519 v->uses_huge_tlb = 1;
520 else if (strcmp (s, "dd") == 0)
521 v->exclude_coredump = 1;
522 else if (strcmp (s, "sh") == 0)
523 v->shared_mapping = 1;
524 else if (strcmp (s, "mt") == 0)
525 v->memory_tagging = 1;
529 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
530 they're initialized lazily. */
532 struct mapping_regexes
534 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
535 string in the end). We know for sure, based on the Linux kernel
536 code, that memory mappings whose associated filename is
537 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
538 compiled_regex dev_zero
539 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB,
540 _("Could not compile regex to match /dev/zero filename")};
542 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
543 string in the end). These filenames refer to shared memory
544 (shmem), and memory mappings associated with them are
545 MAP_ANONYMOUS as well. */
546 compiled_regex shmem_file
547 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB,
548 _("Could not compile regex to match shmem filenames")};
550 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
551 0' code, which is responsible to decide if it is dealing with a
552 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
553 FILE_DELETED matches, it does not necessarily mean that we are
554 dealing with an anonymous shared mapping. However, there is no
555 easy way to detect this currently, so this is the best
556 approximation we have.
558 As a result, GDB will dump readonly pages of deleted executables
559 when using the default value of coredump_filter (0x33), while the
560 Linux kernel will not dump those pages. But we can live with
562 compiled_regex file_deleted
563 {" (deleted)$", REG_NOSUB,
564 _("Could not compile regex to match '<file> (deleted)'")};
567 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
569 FILENAME is the name of the file present in the first line of the
570 memory mapping, in the "/proc/PID/smaps" output. For example, if
573 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
575 Then FILENAME will be "/path/to/file". */
578 mapping_is_anonymous_p (const char *filename)
580 static gdb::optional<mapping_regexes> regexes;
581 static int init_regex_p = 0;
585 /* Let's be pessimistic and assume there will be an error while
586 compiling the regex'es. */
591 /* If we reached this point, then everything succeeded. */
595 if (init_regex_p == -1)
597 const char deleted[] = " (deleted)";
598 size_t del_len = sizeof (deleted) - 1;
599 size_t filename_len = strlen (filename);
601 /* There was an error while compiling the regex'es above. In
602 order to try to give some reliable information to the caller,
603 we just try to find the string " (deleted)" in the filename.
604 If we managed to find it, then we assume the mapping is
606 return (filename_len >= del_len
607 && strcmp (filename + filename_len - del_len, deleted) == 0);
610 if (*filename == '\0'
611 || regexes->dev_zero.exec (filename, 0, NULL, 0) == 0
612 || regexes->shmem_file.exec (filename, 0, NULL, 0) == 0
613 || regexes->file_deleted.exec (filename, 0, NULL, 0) == 0)
619 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
620 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
621 be dumped, or greater than 0 if it should.
623 In a nutshell, this is the logic that we follow in order to decide
624 if a mapping should be dumped or not.
626 - If the mapping is associated to a file whose name ends with
627 " (deleted)", or if the file is "/dev/zero", or if it is
628 "/SYSV%08x" (shared memory), or if there is no file associated
629 with it, or if the AnonHugePages: or the Anonymous: fields in the
630 /proc/PID/smaps have contents, then GDB considers this mapping to
631 be anonymous. Otherwise, GDB considers this mapping to be a
632 file-backed mapping (because there will be a file associated with
635 It is worth mentioning that, from all those checks described
636 above, the most fragile is the one to see if the file name ends
637 with " (deleted)". This does not necessarily mean that the
638 mapping is anonymous, because the deleted file associated with
639 the mapping may have been a hard link to another file, for
640 example. The Linux kernel checks to see if "i_nlink == 0", but
641 GDB cannot easily (and normally) do this check (iff running as
642 root, it could find the mapping in /proc/PID/map_files/ and
643 determine whether there still are other hard links to the
644 inode/file). Therefore, we made a compromise here, and we assume
645 that if the file name ends with " (deleted)", then the mapping is
646 indeed anonymous. FWIW, this is something the Linux kernel could
647 do better: expose this information in a more direct way.
649 - If we see the flag "sh" in the "VmFlags:" field (in
650 /proc/PID/smaps), then certainly the memory mapping is shared
651 (VM_SHARED). If we have access to the VmFlags, and we don't see
652 the "sh" there, then certainly the mapping is private. However,
653 Linux kernels before commit
654 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
655 "VmFlags:" field; in that case, we use another heuristic: if we
656 see 'p' in the permission flags, then we assume that the mapping
657 is private, even though the presence of the 's' flag there would
658 mean VM_MAYSHARE, which means the mapping could still be private.
659 This should work OK enough, however.
661 - Even if, at the end, we decided that we should not dump the
662 mapping, we still have to check if it is something like an ELF
663 header (of a DSO or an executable, for example). If it is, and
664 if the user is interested in dump it, then we should dump it. */
667 dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
668 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
669 const char *filename, ULONGEST addr, ULONGEST offset)
671 /* Initially, we trust in what we received from our caller. This
672 value may not be very precise (i.e., it was probably gathered
673 from the permission line in the /proc/PID/smaps list, which
674 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
675 what we have until we take a look at the "VmFlags:" field
676 (assuming that the version of the Linux kernel being used
677 supports it, of course). */
678 int private_p = maybe_private_p;
681 /* We always dump vDSO and vsyscall mappings, because it's likely that
682 there'll be no file to read the contents from at core load time.
683 The kernel does the same. */
684 if (strcmp ("[vdso]", filename) == 0
685 || strcmp ("[vsyscall]", filename) == 0)
688 if (v->initialized_p)
690 /* We never dump I/O mappings. */
694 /* Check if we should exclude this mapping. */
695 if (!dump_excluded_mappings && v->exclude_coredump)
698 /* Update our notion of whether this mapping is shared or
699 private based on a trustworthy value. */
700 private_p = !v->shared_mapping;
702 /* HugeTLB checking. */
703 if (v->uses_huge_tlb)
705 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
706 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
715 if (mapping_anon_p && mapping_file_p)
717 /* This is a special situation. It can happen when we see a
718 mapping that is file-backed, but that contains anonymous
720 dump_p = ((filterflags & COREFILTER_ANON_PRIVATE) != 0
721 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
723 else if (mapping_anon_p)
724 dump_p = (filterflags & COREFILTER_ANON_PRIVATE) != 0;
726 dump_p = (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
730 if (mapping_anon_p && mapping_file_p)
732 /* This is a special situation. It can happen when we see a
733 mapping that is file-backed, but that contains anonymous
735 dump_p = ((filterflags & COREFILTER_ANON_SHARED) != 0
736 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
738 else if (mapping_anon_p)
739 dump_p = (filterflags & COREFILTER_ANON_SHARED) != 0;
741 dump_p = (filterflags & COREFILTER_MAPPED_SHARED) != 0;
744 /* Even if we decided that we shouldn't dump this mapping, we still
745 have to check whether (a) the user wants us to dump mappings
746 containing an ELF header, and (b) the mapping in question
747 contains an ELF header. If (a) and (b) are true, then we should
750 A mapping contains an ELF header if it is a private mapping, its
751 offset is zero, and its first word is ELFMAG. */
752 if (!dump_p && private_p && offset == 0
753 && (filterflags & COREFILTER_ELF_HEADERS) != 0)
755 /* Useful define specifying the size of the ELF magical
761 /* Let's check if we have an ELF header. */
763 if (target_read_memory (addr, h, SELFMAG) == 0)
765 /* The EI_MAG* and ELFMAG* constants come from
767 if (h[EI_MAG0] == ELFMAG0 && h[EI_MAG1] == ELFMAG1
768 && h[EI_MAG2] == ELFMAG2 && h[EI_MAG3] == ELFMAG3)
770 /* This mapping contains an ELF header, so we
780 /* As above, but return true only when we should dump the NT_FILE
784 dump_note_entry_p (filter_flags filterflags, const struct smaps_vmflags *v,
785 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
786 const char *filename, ULONGEST addr, ULONGEST offset)
788 /* vDSO and vsyscall mappings will end up in the core file. Don't
789 put them in the NT_FILE note. */
790 if (strcmp ("[vdso]", filename) == 0
791 || strcmp ("[vsyscall]", filename) == 0)
794 /* Otherwise, any other file-based mapping should be placed in the
799 /* Implement the "info proc" command. */
802 linux_info_proc (struct gdbarch *gdbarch, const char *args,
803 enum info_proc_what what)
805 /* A long is used for pid instead of an int to avoid a loss of precision
806 compiler warning from the output of strtoul. */
808 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
809 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
810 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
811 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
812 int status_f = (what == IP_STATUS || what == IP_ALL);
813 int stat_f = (what == IP_STAT || what == IP_ALL);
815 fileio_error target_errno;
817 if (args && isdigit (args[0]))
821 pid = strtoul (args, &tem, 10);
826 if (!target_has_execution ())
827 error (_("No current process: you must name one."));
828 if (current_inferior ()->fake_pid_p)
829 error (_("Can't determine the current process's PID: you must name one."));
831 pid = current_inferior ()->pid;
834 args = skip_spaces (args);
836 error (_("Too many parameters: %s"), args);
838 gdb_printf (_("process %ld\n"), pid);
841 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
843 ssize_t len = target_fileio_read_alloc (NULL, filename, &buffer);
847 gdb::unique_xmalloc_ptr<char> cmdline ((char *) buffer);
850 for (pos = 0; pos < len - 1; pos++)
852 if (buffer[pos] == '\0')
855 buffer[len - 1] = '\0';
856 gdb_printf ("cmdline = '%s'\n", buffer);
859 warning (_("unable to open /proc file '%s'"), filename);
863 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
864 gdb::optional<std::string> contents
865 = target_fileio_readlink (NULL, filename, &target_errno);
866 if (contents.has_value ())
867 gdb_printf ("cwd = '%s'\n", contents->c_str ());
869 warning (_("unable to read link '%s'"), filename);
873 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
874 gdb::optional<std::string> contents
875 = target_fileio_readlink (NULL, filename, &target_errno);
876 if (contents.has_value ())
877 gdb_printf ("exe = '%s'\n", contents->c_str ());
879 warning (_("unable to read link '%s'"), filename);
883 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
884 gdb::unique_xmalloc_ptr<char> map
885 = target_fileio_read_stralloc (NULL, filename);
890 gdb_printf (_("Mapped address spaces:\n\n"));
891 if (gdbarch_addr_bit (gdbarch) == 32)
893 gdb_printf ("\t%10s %10s %10s %10s %s %s\n",
894 "Start Addr", " End Addr", " Size",
895 " Offset", "Perms ", "objfile");
899 gdb_printf (" %18s %18s %10s %10s %s %s\n",
900 "Start Addr", " End Addr", " Size",
901 " Offset", "Perms ", "objfile");
905 for (line = strtok_r (map.get (), "\n", &saveptr);
907 line = strtok_r (NULL, "\n", &saveptr))
909 struct mapping m = read_mapping (line);
911 if (gdbarch_addr_bit (gdbarch) == 32)
913 gdb_printf ("\t%10s %10s %10s %10s %-5.*s %s\n",
914 paddress (gdbarch, m.addr),
915 paddress (gdbarch, m.endaddr),
916 hex_string (m.endaddr - m.addr),
917 hex_string (m.offset),
918 (int) m.permissions.size (),
919 m.permissions.data (),
924 gdb_printf (" %18s %18s %10s %10s %-5.*s %s\n",
925 paddress (gdbarch, m.addr),
926 paddress (gdbarch, m.endaddr),
927 hex_string (m.endaddr - m.addr),
928 hex_string (m.offset),
929 (int) m.permissions.size (),
930 m.permissions.data (),
936 warning (_("unable to open /proc file '%s'"), filename);
940 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
941 gdb::unique_xmalloc_ptr<char> status
942 = target_fileio_read_stralloc (NULL, filename);
944 gdb_puts (status.get ());
946 warning (_("unable to open /proc file '%s'"), filename);
950 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
951 gdb::unique_xmalloc_ptr<char> statstr
952 = target_fileio_read_stralloc (NULL, filename);
955 const char *p = statstr.get ();
957 gdb_printf (_("Process: %s\n"),
958 pulongest (strtoulst (p, &p, 10)));
963 /* ps command also relies on no trailing fields
965 const char *ep = strrchr (p, ')');
968 gdb_printf ("Exec file: %.*s\n",
969 (int) (ep - p - 1), p + 1);
976 gdb_printf (_("State: %c\n"), *p++);
979 gdb_printf (_("Parent process: %s\n"),
980 pulongest (strtoulst (p, &p, 10)));
982 gdb_printf (_("Process group: %s\n"),
983 pulongest (strtoulst (p, &p, 10)));
985 gdb_printf (_("Session id: %s\n"),
986 pulongest (strtoulst (p, &p, 10)));
988 gdb_printf (_("TTY: %s\n"),
989 pulongest (strtoulst (p, &p, 10)));
991 gdb_printf (_("TTY owner process group: %s\n"),
992 pulongest (strtoulst (p, &p, 10)));
995 gdb_printf (_("Flags: %s\n"),
996 hex_string (strtoulst (p, &p, 10)));
998 gdb_printf (_("Minor faults (no memory page): %s\n"),
999 pulongest (strtoulst (p, &p, 10)));
1001 gdb_printf (_("Minor faults, children: %s\n"),
1002 pulongest (strtoulst (p, &p, 10)));
1004 gdb_printf (_("Major faults (memory page faults): %s\n"),
1005 pulongest (strtoulst (p, &p, 10)));
1007 gdb_printf (_("Major faults, children: %s\n"),
1008 pulongest (strtoulst (p, &p, 10)));
1010 gdb_printf (_("utime: %s\n"),
1011 pulongest (strtoulst (p, &p, 10)));
1013 gdb_printf (_("stime: %s\n"),
1014 pulongest (strtoulst (p, &p, 10)));
1016 gdb_printf (_("utime, children: %s\n"),
1017 pulongest (strtoulst (p, &p, 10)));
1019 gdb_printf (_("stime, children: %s\n"),
1020 pulongest (strtoulst (p, &p, 10)));
1022 gdb_printf (_("jiffies remaining in current "
1023 "time slice: %s\n"),
1024 pulongest (strtoulst (p, &p, 10)));
1026 gdb_printf (_("'nice' value: %s\n"),
1027 pulongest (strtoulst (p, &p, 10)));
1029 gdb_printf (_("jiffies until next timeout: %s\n"),
1030 pulongest (strtoulst (p, &p, 10)));
1032 gdb_printf (_("jiffies until next SIGALRM: %s\n"),
1033 pulongest (strtoulst (p, &p, 10)));
1035 gdb_printf (_("start time (jiffies since "
1036 "system boot): %s\n"),
1037 pulongest (strtoulst (p, &p, 10)));
1039 gdb_printf (_("Virtual memory size: %s\n"),
1040 pulongest (strtoulst (p, &p, 10)));
1042 gdb_printf (_("Resident set size: %s\n"),
1043 pulongest (strtoulst (p, &p, 10)));
1045 gdb_printf (_("rlim: %s\n"),
1046 pulongest (strtoulst (p, &p, 10)));
1048 gdb_printf (_("Start of text: %s\n"),
1049 hex_string (strtoulst (p, &p, 10)));
1051 gdb_printf (_("End of text: %s\n"),
1052 hex_string (strtoulst (p, &p, 10)));
1054 gdb_printf (_("Start of stack: %s\n"),
1055 hex_string (strtoulst (p, &p, 10)));
1056 #if 0 /* Don't know how architecture-dependent the rest is...
1057 Anyway the signal bitmap info is available from "status". */
1059 gdb_printf (_("Kernel stack pointer: %s\n"),
1060 hex_string (strtoulst (p, &p, 10)));
1062 gdb_printf (_("Kernel instr pointer: %s\n"),
1063 hex_string (strtoulst (p, &p, 10)));
1065 gdb_printf (_("Pending signals bitmap: %s\n"),
1066 hex_string (strtoulst (p, &p, 10)));
1068 gdb_printf (_("Blocked signals bitmap: %s\n"),
1069 hex_string (strtoulst (p, &p, 10)));
1071 gdb_printf (_("Ignored signals bitmap: %s\n"),
1072 hex_string (strtoulst (p, &p, 10)));
1074 gdb_printf (_("Catched signals bitmap: %s\n"),
1075 hex_string (strtoulst (p, &p, 10)));
1077 gdb_printf (_("wchan (system call): %s\n"),
1078 hex_string (strtoulst (p, &p, 10)));
1082 warning (_("unable to open /proc file '%s'"), filename);
1086 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1089 This function reads the NT_FILE note (which BFD turns into the
1090 section ".note.linuxcore.file"). The format of this note / section
1091 is described as follows in the Linux kernel sources in
1094 long count -- how many files are mapped
1095 long page_size -- units for file_ofs
1096 array of [COUNT] elements of
1100 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1102 CBFD is the BFD of the core file.
1104 PRE_LOOP_CB is the callback function to invoke prior to starting
1105 the loop which processes individual entries. This callback will
1106 only be executed after the note has been examined in enough
1107 detail to verify that it's not malformed in some way.
1109 LOOP_CB is the callback function that will be executed once
1110 for each mapping. */
1113 linux_read_core_file_mappings
1114 (struct gdbarch *gdbarch,
1116 read_core_file_mappings_pre_loop_ftype pre_loop_cb,
1117 read_core_file_mappings_loop_ftype loop_cb)
1119 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1120 gdb_static_assert (sizeof (ULONGEST) >= 8);
1122 /* It's not required that the NT_FILE note exists, so return silently
1123 if it's not found. Beyond this point though, we'll complain
1124 if problems are found. */
1125 asection *section = bfd_get_section_by_name (cbfd, ".note.linuxcore.file");
1126 if (section == nullptr)
1129 unsigned int addr_size_bits = gdbarch_addr_bit (gdbarch);
1130 unsigned int addr_size = addr_size_bits / 8;
1131 size_t note_size = bfd_section_size (section);
1133 if (note_size < 2 * addr_size)
1135 warning (_("malformed core note - too short for header"));
1139 gdb::def_vector<gdb_byte> contents (note_size);
1140 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1143 warning (_("could not get core note contents"));
1147 gdb_byte *descdata = contents.data ();
1148 char *descend = (char *) descdata + note_size;
1150 if (descdata[note_size - 1] != '\0')
1152 warning (_("malformed note - does not end with \\0"));
1156 ULONGEST count = bfd_get (addr_size_bits, core_bfd, descdata);
1157 descdata += addr_size;
1159 ULONGEST page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1160 descdata += addr_size;
1162 if (note_size < 2 * addr_size + count * 3 * addr_size)
1164 warning (_("malformed note - too short for supplied file count"));
1168 char *filenames = (char *) descdata + count * 3 * addr_size;
1170 /* Make sure that the correct number of filenames exist. Complain
1171 if there aren't enough or are too many. */
1172 char *f = filenames;
1173 for (int i = 0; i < count; i++)
1177 warning (_("malformed note - filename area is too small"));
1180 f += strnlen (f, descend - f) + 1;
1182 /* Complain, but don't return early if the filename area is too big. */
1184 warning (_("malformed note - filename area is too big"));
1186 const bfd_build_id *orig_build_id = cbfd->build_id;
1187 std::unordered_map<ULONGEST, const bfd_build_id *> vma_map;
1189 /* Search for solib build-ids in the core file. Each time one is found,
1190 map the start vma of the corresponding elf header to the build-id. */
1191 for (bfd_section *sec = cbfd->sections; sec != nullptr; sec = sec->next)
1193 cbfd->build_id = nullptr;
1195 if (sec->flags & SEC_LOAD
1196 && (get_elf_backend_data (cbfd)->elf_backend_core_find_build_id
1197 (cbfd, (bfd_vma) sec->filepos)))
1198 vma_map[sec->vma] = cbfd->build_id;
1201 cbfd->build_id = orig_build_id;
1202 pre_loop_cb (count);
1204 for (int i = 0; i < count; i++)
1206 ULONGEST start = bfd_get (addr_size_bits, core_bfd, descdata);
1207 descdata += addr_size;
1208 ULONGEST end = bfd_get (addr_size_bits, core_bfd, descdata);
1209 descdata += addr_size;
1211 = bfd_get (addr_size_bits, core_bfd, descdata) * page_size;
1212 descdata += addr_size;
1213 char * filename = filenames;
1214 filenames += strlen ((char *) filenames) + 1;
1215 const bfd_build_id *build_id = nullptr;
1216 auto vma_map_it = vma_map.find (start);
1218 if (vma_map_it != vma_map.end ())
1219 build_id = vma_map_it->second;
1221 loop_cb (i, start, end, file_ofs, filename, build_id);
1225 /* Implement "info proc mappings" for a corefile. */
1228 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1230 linux_read_core_file_mappings (gdbarch, core_bfd,
1231 [=] (ULONGEST count)
1233 gdb_printf (_("Mapped address spaces:\n\n"));
1234 if (gdbarch_addr_bit (gdbarch) == 32)
1236 gdb_printf ("\t%10s %10s %10s %10s %s\n",
1239 " Size", " Offset", "objfile");
1243 gdb_printf (" %18s %18s %10s %10s %s\n",
1246 " Size", " Offset", "objfile");
1249 [=] (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs,
1250 const char *filename, const bfd_build_id *build_id)
1252 if (gdbarch_addr_bit (gdbarch) == 32)
1253 gdb_printf ("\t%10s %10s %10s %10s %s\n",
1254 paddress (gdbarch, start),
1255 paddress (gdbarch, end),
1256 hex_string (end - start),
1257 hex_string (file_ofs),
1260 gdb_printf (" %18s %18s %10s %10s %s\n",
1261 paddress (gdbarch, start),
1262 paddress (gdbarch, end),
1263 hex_string (end - start),
1264 hex_string (file_ofs),
1269 /* Implement "info proc" for a corefile. */
1272 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1273 enum info_proc_what what)
1275 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1276 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1282 exe = bfd_core_file_failing_command (core_bfd);
1284 gdb_printf ("exe = '%s'\n", exe);
1286 warning (_("unable to find command name in core file"));
1290 linux_core_info_proc_mappings (gdbarch, args);
1292 if (!exe_f && !mappings_f)
1293 error (_("unable to handle request"));
1296 /* Read siginfo data from the core, if possible. Returns -1 on
1297 failure. Otherwise, returns the number of bytes read. READBUF,
1298 OFFSET, and LEN are all as specified by the to_xfer_partial
1302 linux_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
1303 ULONGEST offset, ULONGEST len)
1305 thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
1306 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
1307 if (section == NULL)
1310 if (!bfd_get_section_contents (core_bfd, section, readbuf, offset, len))
1316 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1317 ULONGEST offset, ULONGEST inode,
1318 int read, int write,
1319 int exec, int modified,
1321 const char *filename,
1324 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags,
1325 const struct smaps_vmflags *v,
1326 int maybe_private_p,
1329 const char *filename,
1333 /* Helper function to parse the contents of /proc/<pid>/smaps into a data
1334 structure, for easy access.
1336 DATA is the contents of the smaps file. The parsed contents are stored
1337 into the SMAPS vector. */
1339 static std::vector<struct smaps_data>
1340 parse_smaps_data (const char *data,
1341 const std::string maps_filename)
1345 gdb_assert (data != nullptr);
1347 line = strtok_r ((char *) data, "\n", &t);
1349 std::vector<struct smaps_data> smaps;
1351 while (line != NULL)
1353 struct smaps_vmflags v;
1354 int read, write, exec, priv;
1355 int has_anonymous = 0;
1359 memset (&v, 0, sizeof (v));
1360 struct mapping m = read_mapping (line);
1361 mapping_anon_p = mapping_is_anonymous_p (m.filename);
1362 /* If the mapping is not anonymous, then we can consider it
1363 to be file-backed. These two states (anonymous or
1364 file-backed) seem to be exclusive, but they can actually
1365 coexist. For example, if a file-backed mapping has
1366 "Anonymous:" pages (see more below), then the Linux
1367 kernel will dump this mapping when the user specified
1368 that she only wants anonymous mappings in the corefile
1369 (*even* when she explicitly disabled the dumping of
1370 file-backed mappings). */
1371 mapping_file_p = !mapping_anon_p;
1373 /* Decode permissions. */
1374 auto has_perm = [&m] (char c)
1375 { return m.permissions.find (c) != gdb::string_view::npos; };
1376 read = has_perm ('r');
1377 write = has_perm ('w');
1378 exec = has_perm ('x');
1380 /* 'private' here actually means VM_MAYSHARE, and not
1381 VM_SHARED. In order to know if a mapping is really
1382 private or not, we must check the flag "sh" in the
1383 VmFlags field. This is done by decode_vmflags. However,
1384 if we are using a Linux kernel released before the commit
1385 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1386 not have the VmFlags there. In this case, there is
1387 really no way to know if we are dealing with VM_SHARED,
1388 so we just assume that VM_MAYSHARE is enough. */
1389 priv = has_perm ('p');
1391 /* Try to detect if region should be dumped by parsing smaps
1393 for (line = strtok_r (NULL, "\n", &t);
1394 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1395 line = strtok_r (NULL, "\n", &t))
1397 char keyword[64 + 1];
1399 if (sscanf (line, "%64s", keyword) != 1)
1401 warning (_("Error parsing {s,}maps file '%s'"),
1402 maps_filename.c_str ());
1406 if (strcmp (keyword, "Anonymous:") == 0)
1408 /* Older Linux kernels did not support the
1409 "Anonymous:" counter. Check it here. */
1412 else if (strcmp (keyword, "VmFlags:") == 0)
1413 decode_vmflags (line, &v);
1415 if (strcmp (keyword, "AnonHugePages:") == 0
1416 || strcmp (keyword, "Anonymous:") == 0)
1418 unsigned long number;
1420 if (sscanf (line, "%*s%lu", &number) != 1)
1422 warning (_("Error parsing {s,}maps file '%s' number"),
1423 maps_filename.c_str ());
1428 /* Even if we are dealing with a file-backed
1429 mapping, if it contains anonymous pages we
1430 consider it to be *also* an anonymous
1431 mapping, because this is what the Linux
1434 // Dump segments that have been written to.
1435 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1438 Note that if the mapping is already marked as
1439 file-backed (i.e., mapping_file_p is
1440 non-zero), then this is a special case, and
1441 this mapping will be dumped either when the
1442 user wants to dump file-backed *or* anonymous
1448 /* Save the smaps entry to the vector. */
1449 struct smaps_data map;
1451 map.start_address = m.addr;
1452 map.end_address = m.endaddr;
1453 map.filename = m.filename;
1455 map.read = read? true : false;
1456 map.write = write? true : false;
1457 map.exec = exec? true : false;
1458 map.priv = priv? true : false;
1459 map.has_anonymous = has_anonymous;
1460 map.mapping_anon_p = mapping_anon_p? true : false;
1461 map.mapping_file_p = mapping_file_p? true : false;
1462 map.offset = m.offset;
1463 map.inode = m.inode;
1465 smaps.emplace_back (map);
1471 /* Helper that checks if an address is in a memory tag page for a live
1475 linux_process_address_in_memtag_page (CORE_ADDR address)
1477 if (current_inferior ()->fake_pid_p)
1480 pid_t pid = current_inferior ()->pid;
1482 std::string smaps_file = string_printf ("/proc/%d/smaps", pid);
1484 gdb::unique_xmalloc_ptr<char> data
1485 = target_fileio_read_stralloc (NULL, smaps_file.c_str ());
1487 if (data == nullptr)
1490 /* Parse the contents of smaps into a vector. */
1491 std::vector<struct smaps_data> smaps
1492 = parse_smaps_data (data.get (), smaps_file);
1494 for (const smaps_data &map : smaps)
1496 /* Is the address within [start_address, end_address) in a page
1497 mapped with memory tagging? */
1498 if (address >= map.start_address
1499 && address < map.end_address
1500 && map.vmflags.memory_tagging)
1507 /* Helper that checks if an address is in a memory tag page for a core file
1511 linux_core_file_address_in_memtag_page (CORE_ADDR address)
1513 if (core_bfd == nullptr)
1516 memtag_section_info info;
1517 return get_next_core_memtag_section (core_bfd, nullptr, address, info);
1520 /* See linux-tdep.h. */
1523 linux_address_in_memtag_page (CORE_ADDR address)
1525 if (!target_has_execution ())
1526 return linux_core_file_address_in_memtag_page (address);
1528 return linux_process_address_in_memtag_page (address);
1531 /* List memory regions in the inferior for a corefile. */
1534 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1535 linux_dump_mapping_p_ftype *should_dump_mapping_p,
1536 linux_find_memory_region_ftype *func,
1540 /* Default dump behavior of coredump_filter (0x33), according to
1541 Documentation/filesystems/proc.txt from the Linux kernel
1543 filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1544 | COREFILTER_ANON_SHARED
1545 | COREFILTER_ELF_HEADERS
1546 | COREFILTER_HUGETLB_PRIVATE);
1548 /* We need to know the real target PID to access /proc. */
1549 if (current_inferior ()->fake_pid_p)
1552 pid = current_inferior ()->pid;
1554 if (use_coredump_filter)
1556 std::string core_dump_filter_name
1557 = string_printf ("/proc/%d/coredump_filter", pid);
1559 gdb::unique_xmalloc_ptr<char> coredumpfilterdata
1560 = target_fileio_read_stralloc (NULL, core_dump_filter_name.c_str ());
1562 if (coredumpfilterdata != NULL)
1566 sscanf (coredumpfilterdata.get (), "%x", &flags);
1567 filterflags = (enum filter_flag) flags;
1571 std::string maps_filename = string_printf ("/proc/%d/smaps", pid);
1573 gdb::unique_xmalloc_ptr<char> data
1574 = target_fileio_read_stralloc (NULL, maps_filename.c_str ());
1578 /* Older Linux kernels did not support /proc/PID/smaps. */
1579 maps_filename = string_printf ("/proc/%d/maps", pid);
1580 data = target_fileio_read_stralloc (NULL, maps_filename.c_str ());
1582 if (data == nullptr)
1586 /* Parse the contents of smaps into a vector. */
1587 std::vector<struct smaps_data> smaps
1588 = parse_smaps_data (data.get (), maps_filename.c_str ());
1590 for (const struct smaps_data &map : smaps)
1592 int should_dump_p = 0;
1594 if (map.has_anonymous)
1597 = should_dump_mapping_p (filterflags, &map.vmflags,
1601 map.filename.c_str (),
1607 /* Older Linux kernels did not support the "Anonymous:" counter.
1608 If it is missing, we can't be sure - dump all the pages. */
1612 /* Invoke the callback function to create the corefile segment. */
1615 func (map.start_address, map.end_address - map.start_address,
1616 map.offset, map.inode, map.read, map.write, map.exec,
1617 1, /* MODIFIED is true because we want to dump
1619 map.vmflags.memory_tagging != 0,
1620 map.filename.c_str (), obfd);
1627 /* A structure for passing information through
1628 linux_find_memory_regions_full. */
1630 struct linux_find_memory_regions_data
1632 /* The original callback. */
1634 find_memory_region_ftype func;
1636 /* The original datum. */
1641 /* A callback for linux_find_memory_regions that converts between the
1642 "full"-style callback and find_memory_region_ftype. */
1645 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1646 ULONGEST offset, ULONGEST inode,
1647 int read, int write, int exec, int modified,
1649 const char *filename, void *arg)
1651 struct linux_find_memory_regions_data *data
1652 = (struct linux_find_memory_regions_data *) arg;
1654 return data->func (vaddr, size, read, write, exec, modified, memory_tagged,
1658 /* A variant of linux_find_memory_regions_full that is suitable as the
1659 gdbarch find_memory_regions method. */
1662 linux_find_memory_regions (struct gdbarch *gdbarch,
1663 find_memory_region_ftype func, void *obfd)
1665 struct linux_find_memory_regions_data data;
1670 return linux_find_memory_regions_full (gdbarch,
1672 linux_find_memory_regions_thunk,
1676 /* This is used to pass information from
1677 linux_make_mappings_corefile_notes through
1678 linux_find_memory_regions_full. */
1680 struct linux_make_mappings_data
1682 /* Number of files mapped. */
1683 ULONGEST file_count;
1685 /* The obstack for the main part of the data. */
1686 struct obstack *data_obstack;
1688 /* The filename obstack. */
1689 struct obstack *filename_obstack;
1691 /* The architecture's "long" type. */
1692 struct type *long_type;
1695 static linux_find_memory_region_ftype linux_make_mappings_callback;
1697 /* A callback for linux_find_memory_regions_full that updates the
1698 mappings data for linux_make_mappings_corefile_notes.
1700 MEMORY_TAGGED is true if the memory region contains memory tags, false
1704 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1705 ULONGEST offset, ULONGEST inode,
1706 int read, int write, int exec, int modified,
1708 const char *filename, void *data)
1710 struct linux_make_mappings_data *map_data
1711 = (struct linux_make_mappings_data *) data;
1712 gdb_byte buf[sizeof (ULONGEST)];
1714 if (*filename == '\0' || inode == 0)
1717 ++map_data->file_count;
1719 pack_long (buf, map_data->long_type, vaddr);
1720 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1721 pack_long (buf, map_data->long_type, vaddr + size);
1722 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1723 pack_long (buf, map_data->long_type, offset);
1724 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1726 obstack_grow_str0 (map_data->filename_obstack, filename);
1731 /* Write the file mapping data to the core file, if possible. OBFD is
1732 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1733 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1736 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1737 gdb::unique_xmalloc_ptr<char> ¬e_data,
1740 struct linux_make_mappings_data mapping_data;
1741 struct type *long_type
1742 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1743 gdb_byte buf[sizeof (ULONGEST)];
1745 auto_obstack data_obstack, filename_obstack;
1747 mapping_data.file_count = 0;
1748 mapping_data.data_obstack = &data_obstack;
1749 mapping_data.filename_obstack = &filename_obstack;
1750 mapping_data.long_type = long_type;
1752 /* Reserve space for the count. */
1753 obstack_blank (&data_obstack, long_type->length ());
1754 /* We always write the page size as 1 since we have no good way to
1755 determine the correct value. */
1756 pack_long (buf, long_type, 1);
1757 obstack_grow (&data_obstack, buf, long_type->length ());
1759 linux_find_memory_regions_full (gdbarch,
1761 linux_make_mappings_callback,
1764 if (mapping_data.file_count != 0)
1766 /* Write the count to the obstack. */
1767 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1768 long_type, mapping_data.file_count);
1770 /* Copy the filenames to the data obstack. */
1771 int size = obstack_object_size (&filename_obstack);
1772 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1775 note_data.reset (elfcore_write_file_note (obfd, note_data.release (), note_size,
1776 obstack_base (&data_obstack),
1777 obstack_object_size (&data_obstack)));
1781 /* Fetch the siginfo data for the specified thread, if it exists. If
1782 there is no data, or we could not read it, return an empty
1785 static gdb::byte_vector
1786 linux_get_siginfo_data (thread_info *thread, struct gdbarch *gdbarch)
1788 struct type *siginfo_type;
1791 if (!gdbarch_get_siginfo_type_p (gdbarch))
1792 return gdb::byte_vector ();
1794 scoped_restore_current_thread save_current_thread;
1795 switch_to_thread (thread);
1797 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1799 gdb::byte_vector buf (siginfo_type->length ());
1801 bytes_read = target_read (current_inferior ()->top_target (),
1802 TARGET_OBJECT_SIGNAL_INFO, NULL,
1803 buf.data (), 0, siginfo_type->length ());
1804 if (bytes_read != siginfo_type->length ())
1810 struct linux_corefile_thread_data
1812 linux_corefile_thread_data (struct gdbarch *gdbarch, bfd *obfd,
1813 gdb::unique_xmalloc_ptr<char> ¬e_data,
1814 int *note_size, gdb_signal stop_signal)
1815 : gdbarch (gdbarch), obfd (obfd), note_data (note_data),
1816 note_size (note_size), stop_signal (stop_signal)
1819 struct gdbarch *gdbarch;
1821 gdb::unique_xmalloc_ptr<char> ¬e_data;
1823 enum gdb_signal stop_signal;
1826 /* Records the thread's register state for the corefile note
1830 linux_corefile_thread (struct thread_info *info,
1831 struct linux_corefile_thread_data *args)
1833 gcore_elf_build_thread_register_notes (args->gdbarch, info,
1835 args->obfd, &args->note_data,
1838 /* Don't return anything if we got no register information above,
1839 such a core file is useless. */
1840 if (args->note_data != NULL)
1842 gdb::byte_vector siginfo_data
1843 = linux_get_siginfo_data (info, args->gdbarch);
1844 if (!siginfo_data.empty ())
1845 args->note_data.reset (elfcore_write_note (args->obfd,
1846 args->note_data.release (),
1849 siginfo_data.data (),
1850 siginfo_data.size ()));
1854 /* Fill the PRPSINFO structure with information about the process being
1855 debugged. Returns 1 in case of success, 0 for failures. Please note that
1856 even if the structure cannot be entirely filled (e.g., GDB was unable to
1857 gather information about the process UID/GID), this function will still
1858 return 1 since some information was already recorded. It will only return
1859 0 iff nothing can be gathered. */
1862 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1864 /* The filename which we will use to obtain some info about the process.
1865 We will basically use this to store the `/proc/PID/FILENAME' file. */
1867 /* The basename of the executable. */
1868 const char *basename;
1869 /* Temporary buffer. */
1871 /* The valid states of a process, according to the Linux kernel. */
1872 const char valid_states[] = "RSDTZW";
1873 /* The program state. */
1874 const char *prog_state;
1875 /* The state of the process. */
1877 /* The PID of the program which generated the corefile. */
1879 /* Process flags. */
1880 unsigned int pr_flag;
1881 /* Process nice value. */
1883 /* The number of fields read by `sscanf'. */
1886 gdb_assert (p != NULL);
1888 /* Obtaining PID and filename. */
1889 pid = inferior_ptid.pid ();
1890 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1891 /* The full name of the program which generated the corefile. */
1892 gdb::unique_xmalloc_ptr<char> fname
1893 = target_fileio_read_stralloc (NULL, filename);
1895 if (fname == NULL || fname.get ()[0] == '\0')
1897 /* No program name was read, so we won't be able to retrieve more
1898 information about the process. */
1902 memset (p, 0, sizeof (*p));
1904 /* Defining the PID. */
1907 /* Copying the program name. Only the basename matters. */
1908 basename = lbasename (fname.get ());
1909 strncpy (p->pr_fname, basename, sizeof (p->pr_fname) - 1);
1910 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1912 const std::string &infargs = current_inferior ()->args ();
1914 /* The arguments of the program. */
1915 std::string psargs = fname.get ();
1916 if (!infargs.empty ())
1917 psargs += ' ' + infargs;
1919 strncpy (p->pr_psargs, psargs.c_str (), sizeof (p->pr_psargs) - 1);
1920 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1922 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1923 /* The contents of `/proc/PID/stat'. */
1924 gdb::unique_xmalloc_ptr<char> proc_stat_contents
1925 = target_fileio_read_stralloc (NULL, filename);
1926 char *proc_stat = proc_stat_contents.get ();
1928 if (proc_stat == NULL || *proc_stat == '\0')
1930 /* Despite being unable to read more information about the
1931 process, we return 1 here because at least we have its
1932 command line, PID and arguments. */
1936 /* Ok, we have the stats. It's time to do a little parsing of the
1937 contents of the buffer, so that we end up reading what we want.
1939 The following parsing mechanism is strongly based on the
1940 information generated by the `fs/proc/array.c' file, present in
1941 the Linux kernel tree. More details about how the information is
1942 displayed can be obtained by seeing the manpage of proc(5),
1943 specifically under the entry of `/proc/[pid]/stat'. */
1945 /* Getting rid of the PID, since we already have it. */
1946 while (isdigit (*proc_stat))
1949 proc_stat = skip_spaces (proc_stat);
1951 /* ps command also relies on no trailing fields ever contain ')'. */
1952 proc_stat = strrchr (proc_stat, ')');
1953 if (proc_stat == NULL)
1957 proc_stat = skip_spaces (proc_stat);
1959 n_fields = sscanf (proc_stat,
1960 "%c" /* Process state. */
1961 "%d%d%d" /* Parent PID, group ID, session ID. */
1962 "%*d%*d" /* tty_nr, tpgid (not used). */
1964 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1965 cmajflt (not used). */
1966 "%*s%*s%*s%*s" /* utime, stime, cutime,
1967 cstime (not used). */
1968 "%*s" /* Priority (not used). */
1971 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1977 /* Again, we couldn't read the complementary information about
1978 the process state. However, we already have minimal
1979 information, so we just return 1 here. */
1983 /* Filling the structure fields. */
1984 prog_state = strchr (valid_states, pr_sname);
1985 if (prog_state != NULL)
1986 p->pr_state = prog_state - valid_states;
1989 /* Zero means "Running". */
1993 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1994 p->pr_zomb = p->pr_sname == 'Z';
1995 p->pr_nice = pr_nice;
1996 p->pr_flag = pr_flag;
1998 /* Finally, obtaining the UID and GID. For that, we read and parse the
1999 contents of the `/proc/PID/status' file. */
2000 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
2001 /* The contents of `/proc/PID/status'. */
2002 gdb::unique_xmalloc_ptr<char> proc_status_contents
2003 = target_fileio_read_stralloc (NULL, filename);
2004 char *proc_status = proc_status_contents.get ();
2006 if (proc_status == NULL || *proc_status == '\0')
2008 /* Returning 1 since we already have a bunch of information. */
2012 /* Extracting the UID. */
2013 tmpstr = strstr (proc_status, "Uid:");
2016 /* Advancing the pointer to the beginning of the UID. */
2017 tmpstr += sizeof ("Uid:");
2018 while (*tmpstr != '\0' && !isdigit (*tmpstr))
2021 if (isdigit (*tmpstr))
2022 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
2025 /* Extracting the GID. */
2026 tmpstr = strstr (proc_status, "Gid:");
2029 /* Advancing the pointer to the beginning of the GID. */
2030 tmpstr += sizeof ("Gid:");
2031 while (*tmpstr != '\0' && !isdigit (*tmpstr))
2034 if (isdigit (*tmpstr))
2035 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
2041 /* Build the note section for a corefile, and return it in a malloc
2044 static gdb::unique_xmalloc_ptr<char>
2045 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
2047 struct elf_internal_linux_prpsinfo prpsinfo;
2048 gdb::unique_xmalloc_ptr<char> note_data;
2050 if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
2053 if (linux_fill_prpsinfo (&prpsinfo))
2055 if (gdbarch_ptr_bit (gdbarch) == 64)
2056 note_data.reset (elfcore_write_linux_prpsinfo64 (obfd,
2057 note_data.release (),
2058 note_size, &prpsinfo));
2060 note_data.reset (elfcore_write_linux_prpsinfo32 (obfd,
2061 note_data.release (),
2062 note_size, &prpsinfo));
2065 /* Thread register information. */
2068 update_thread_list ();
2070 catch (const gdb_exception_error &e)
2072 exception_print (gdb_stderr, e);
2075 /* Like the kernel, prefer dumping the signalled thread first.
2076 "First thread" is what tools use to infer the signalled
2078 thread_info *signalled_thr = gcore_find_signalled_thread ();
2079 gdb_signal stop_signal;
2080 if (signalled_thr != nullptr)
2081 stop_signal = signalled_thr->stop_signal ();
2083 stop_signal = GDB_SIGNAL_0;
2085 linux_corefile_thread_data thread_args (gdbarch, obfd, note_data, note_size,
2088 if (signalled_thr != nullptr)
2089 linux_corefile_thread (signalled_thr, &thread_args);
2090 for (thread_info *thr : current_inferior ()->non_exited_threads ())
2092 if (thr == signalled_thr)
2095 linux_corefile_thread (thr, &thread_args);
2101 /* Auxillary vector. */
2102 gdb::optional<gdb::byte_vector> auxv =
2103 target_read_alloc (current_inferior ()->top_target (),
2104 TARGET_OBJECT_AUXV, NULL);
2105 if (auxv && !auxv->empty ())
2107 note_data.reset (elfcore_write_note (obfd, note_data.release (),
2108 note_size, "CORE", NT_AUXV,
2109 auxv->data (), auxv->size ()));
2115 /* File mappings. */
2116 linux_make_mappings_corefile_notes (gdbarch, obfd, note_data, note_size);
2118 /* Target description. */
2119 gcore_elf_make_tdesc_note (obfd, ¬e_data, note_size);
2124 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2125 gdbarch.h. This function is not static because it is exported to
2126 other -tdep files. */
2129 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2134 return GDB_SIGNAL_0;
2137 return GDB_SIGNAL_HUP;
2140 return GDB_SIGNAL_INT;
2143 return GDB_SIGNAL_QUIT;
2146 return GDB_SIGNAL_ILL;
2149 return GDB_SIGNAL_TRAP;
2152 return GDB_SIGNAL_ABRT;
2155 return GDB_SIGNAL_BUS;
2158 return GDB_SIGNAL_FPE;
2161 return GDB_SIGNAL_KILL;
2164 return GDB_SIGNAL_USR1;
2167 return GDB_SIGNAL_SEGV;
2170 return GDB_SIGNAL_USR2;
2173 return GDB_SIGNAL_PIPE;
2176 return GDB_SIGNAL_ALRM;
2179 return GDB_SIGNAL_TERM;
2182 return GDB_SIGNAL_CHLD;
2185 return GDB_SIGNAL_CONT;
2188 return GDB_SIGNAL_STOP;
2191 return GDB_SIGNAL_TSTP;
2194 return GDB_SIGNAL_TTIN;
2197 return GDB_SIGNAL_TTOU;
2200 return GDB_SIGNAL_URG;
2203 return GDB_SIGNAL_XCPU;
2206 return GDB_SIGNAL_XFSZ;
2208 case LINUX_SIGVTALRM:
2209 return GDB_SIGNAL_VTALRM;
2212 return GDB_SIGNAL_PROF;
2214 case LINUX_SIGWINCH:
2215 return GDB_SIGNAL_WINCH;
2217 /* No way to differentiate between SIGIO and SIGPOLL.
2218 Therefore, we just handle the first one. */
2220 return GDB_SIGNAL_IO;
2223 return GDB_SIGNAL_PWR;
2226 return GDB_SIGNAL_SYS;
2228 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2229 therefore we have to handle them here. */
2230 case LINUX_SIGRTMIN:
2231 return GDB_SIGNAL_REALTIME_32;
2233 case LINUX_SIGRTMAX:
2234 return GDB_SIGNAL_REALTIME_64;
2237 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2239 int offset = signal - LINUX_SIGRTMIN + 1;
2241 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2244 return GDB_SIGNAL_UNKNOWN;
2247 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2248 gdbarch.h. This function is not static because it is exported to
2249 other -tdep files. */
2252 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2253 enum gdb_signal signal)
2260 case GDB_SIGNAL_HUP:
2261 return LINUX_SIGHUP;
2263 case GDB_SIGNAL_INT:
2264 return LINUX_SIGINT;
2266 case GDB_SIGNAL_QUIT:
2267 return LINUX_SIGQUIT;
2269 case GDB_SIGNAL_ILL:
2270 return LINUX_SIGILL;
2272 case GDB_SIGNAL_TRAP:
2273 return LINUX_SIGTRAP;
2275 case GDB_SIGNAL_ABRT:
2276 return LINUX_SIGABRT;
2278 case GDB_SIGNAL_FPE:
2279 return LINUX_SIGFPE;
2281 case GDB_SIGNAL_KILL:
2282 return LINUX_SIGKILL;
2284 case GDB_SIGNAL_BUS:
2285 return LINUX_SIGBUS;
2287 case GDB_SIGNAL_SEGV:
2288 return LINUX_SIGSEGV;
2290 case GDB_SIGNAL_SYS:
2291 return LINUX_SIGSYS;
2293 case GDB_SIGNAL_PIPE:
2294 return LINUX_SIGPIPE;
2296 case GDB_SIGNAL_ALRM:
2297 return LINUX_SIGALRM;
2299 case GDB_SIGNAL_TERM:
2300 return LINUX_SIGTERM;
2302 case GDB_SIGNAL_URG:
2303 return LINUX_SIGURG;
2305 case GDB_SIGNAL_STOP:
2306 return LINUX_SIGSTOP;
2308 case GDB_SIGNAL_TSTP:
2309 return LINUX_SIGTSTP;
2311 case GDB_SIGNAL_CONT:
2312 return LINUX_SIGCONT;
2314 case GDB_SIGNAL_CHLD:
2315 return LINUX_SIGCHLD;
2317 case GDB_SIGNAL_TTIN:
2318 return LINUX_SIGTTIN;
2320 case GDB_SIGNAL_TTOU:
2321 return LINUX_SIGTTOU;
2326 case GDB_SIGNAL_XCPU:
2327 return LINUX_SIGXCPU;
2329 case GDB_SIGNAL_XFSZ:
2330 return LINUX_SIGXFSZ;
2332 case GDB_SIGNAL_VTALRM:
2333 return LINUX_SIGVTALRM;
2335 case GDB_SIGNAL_PROF:
2336 return LINUX_SIGPROF;
2338 case GDB_SIGNAL_WINCH:
2339 return LINUX_SIGWINCH;
2341 case GDB_SIGNAL_USR1:
2342 return LINUX_SIGUSR1;
2344 case GDB_SIGNAL_USR2:
2345 return LINUX_SIGUSR2;
2347 case GDB_SIGNAL_PWR:
2348 return LINUX_SIGPWR;
2350 case GDB_SIGNAL_POLL:
2351 return LINUX_SIGPOLL;
2353 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2354 therefore we have to handle it here. */
2355 case GDB_SIGNAL_REALTIME_32:
2356 return LINUX_SIGRTMIN;
2358 /* Same comment applies to _64. */
2359 case GDB_SIGNAL_REALTIME_64:
2360 return LINUX_SIGRTMAX;
2363 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2364 if (signal >= GDB_SIGNAL_REALTIME_33
2365 && signal <= GDB_SIGNAL_REALTIME_63)
2367 int offset = signal - GDB_SIGNAL_REALTIME_33;
2369 return LINUX_SIGRTMIN + 1 + offset;
2375 /* Helper for linux_vsyscall_range that does the real work of finding
2376 the vsyscall's address range. */
2379 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2384 if (target_auxv_search (AT_SYSINFO_EHDR, &range->start) <= 0)
2387 /* It doesn't make sense to access the host's /proc when debugging a
2388 core file. Instead, look for the PT_LOAD segment that matches
2390 if (!target_has_execution ())
2395 phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
2396 if (phdrs_size == -1)
2399 gdb::unique_xmalloc_ptr<Elf_Internal_Phdr>
2400 phdrs ((Elf_Internal_Phdr *) xmalloc (phdrs_size));
2401 num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs.get ());
2402 if (num_phdrs == -1)
2405 for (i = 0; i < num_phdrs; i++)
2406 if (phdrs.get ()[i].p_type == PT_LOAD
2407 && phdrs.get ()[i].p_vaddr == range->start)
2409 range->length = phdrs.get ()[i].p_memsz;
2416 /* We need to know the real target PID to access /proc. */
2417 if (current_inferior ()->fake_pid_p)
2420 pid = current_inferior ()->pid;
2422 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2423 reading /proc/PID/maps (2). The later identifies thread stacks
2424 in the output, which requires scanning every thread in the thread
2425 group to check whether a VMA is actually a thread's stack. With
2426 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2427 a few thousand threads, (1) takes a few miliseconds, while (2)
2428 takes several seconds. Also note that "smaps", what we read for
2429 determining core dump mappings, is even slower than "maps". */
2430 xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2431 gdb::unique_xmalloc_ptr<char> data
2432 = target_fileio_read_stralloc (NULL, filename);
2436 char *saveptr = NULL;
2438 for (line = strtok_r (data.get (), "\n", &saveptr);
2440 line = strtok_r (NULL, "\n", &saveptr))
2442 ULONGEST addr, endaddr;
2443 const char *p = line;
2445 addr = strtoulst (p, &p, 16);
2446 if (addr == range->start)
2450 endaddr = strtoulst (p, &p, 16);
2451 range->length = endaddr - addr;
2457 warning (_("unable to open /proc file '%s'"), filename);
2462 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2463 caching, and defers the real work to linux_vsyscall_range_raw. */
2466 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2468 struct linux_info *info = get_linux_inferior_data (current_inferior ());
2470 if (info->vsyscall_range_p == 0)
2472 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2473 info->vsyscall_range_p = 1;
2475 info->vsyscall_range_p = -1;
2478 if (info->vsyscall_range_p < 0)
2481 *range = info->vsyscall_range;
2485 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2486 definitions would be dependent on compilation host. */
2487 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2488 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2490 /* See gdbarch.sh 'infcall_mmap'. */
2493 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2495 struct objfile *objf;
2496 /* Do there still exist any Linux systems without "mmap64"?
2497 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2498 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2499 struct value *addr_val;
2500 struct gdbarch *gdbarch = objf->arch ();
2504 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2506 struct value *arg[ARG_LAST];
2508 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2510 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2511 arg[ARG_LENGTH] = value_from_ulongest
2512 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2513 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2514 | GDB_MMAP_PROT_EXEC))
2516 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2517 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2518 GDB_MMAP_MAP_PRIVATE
2519 | GDB_MMAP_MAP_ANONYMOUS);
2520 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2521 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2523 addr_val = call_function_by_hand (mmap_val, NULL, arg);
2524 retval = value_as_address (addr_val);
2525 if (retval == (CORE_ADDR) -1)
2526 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2531 /* See gdbarch.sh 'infcall_munmap'. */
2534 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2536 struct objfile *objf;
2537 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2538 struct value *retval_val;
2539 struct gdbarch *gdbarch = objf->arch ();
2543 ARG_ADDR, ARG_LENGTH, ARG_LAST
2545 struct value *arg[ARG_LAST];
2547 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2549 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2550 arg[ARG_LENGTH] = value_from_ulongest
2551 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2552 retval_val = call_function_by_hand (munmap_val, NULL, arg);
2553 retval = value_as_long (retval_val);
2555 warning (_("Failed inferior munmap call at %s for %s bytes, "
2556 "errno is changed."),
2557 hex_string (addr), pulongest (size));
2560 /* See linux-tdep.h. */
2563 linux_displaced_step_location (struct gdbarch *gdbarch)
2568 /* Determine entry point from target auxiliary vector. This avoids
2569 the need for symbols. Also, when debugging a stand-alone SPU
2570 executable, entry_point_address () will point to an SPU
2571 local-store address and is thus not usable as displaced stepping
2572 location. The auxiliary vector gets us the PowerPC-side entry
2573 point address instead. */
2574 if (target_auxv_search (AT_ENTRY, &addr) <= 0)
2575 throw_error (NOT_SUPPORTED_ERROR,
2576 _("Cannot find AT_ENTRY auxiliary vector entry."));
2578 /* Make certain that the address points at real code, and not a
2579 function descriptor. */
2580 addr = gdbarch_convert_from_func_ptr_addr
2581 (gdbarch, addr, current_inferior ()->top_target ());
2583 /* Inferior calls also use the entry point as a breakpoint location.
2584 We don't want displaced stepping to interfere with those
2585 breakpoints, so leave space. */
2586 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2592 /* See linux-tdep.h. */
2594 displaced_step_prepare_status
2595 linux_displaced_step_prepare (gdbarch *arch, thread_info *thread,
2596 CORE_ADDR &displaced_pc)
2598 linux_info *per_inferior = get_linux_inferior_data (thread->inf);
2600 if (!per_inferior->disp_step_bufs.has_value ())
2602 /* Figure out the location of the buffers. They are contiguous, starting
2603 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2604 CORE_ADDR disp_step_buf_addr
2605 = linux_displaced_step_location (thread->inf->gdbarch);
2606 int buf_len = gdbarch_max_insn_length (arch);
2608 linux_gdbarch_data *gdbarch_data = get_linux_gdbarch_data (arch);
2609 gdb_assert (gdbarch_data->num_disp_step_buffers > 0);
2611 std::vector<CORE_ADDR> buffers;
2612 for (int i = 0; i < gdbarch_data->num_disp_step_buffers; i++)
2613 buffers.push_back (disp_step_buf_addr + i * buf_len);
2615 per_inferior->disp_step_bufs.emplace (buffers);
2618 return per_inferior->disp_step_bufs->prepare (thread, displaced_pc);
2621 /* See linux-tdep.h. */
2623 displaced_step_finish_status
2624 linux_displaced_step_finish (gdbarch *arch, thread_info *thread, gdb_signal sig)
2626 linux_info *per_inferior = get_linux_inferior_data (thread->inf);
2628 gdb_assert (per_inferior->disp_step_bufs.has_value ());
2630 return per_inferior->disp_step_bufs->finish (arch, thread, sig);
2633 /* See linux-tdep.h. */
2635 const displaced_step_copy_insn_closure *
2636 linux_displaced_step_copy_insn_closure_by_addr (inferior *inf, CORE_ADDR addr)
2638 linux_info *per_inferior = linux_inferior_data.get (inf);
2640 if (per_inferior == nullptr
2641 || !per_inferior->disp_step_bufs.has_value ())
2644 return per_inferior->disp_step_bufs->copy_insn_closure_by_addr (addr);
2647 /* See linux-tdep.h. */
2650 linux_displaced_step_restore_all_in_ptid (inferior *parent_inf, ptid_t ptid)
2652 linux_info *per_inferior = linux_inferior_data.get (parent_inf);
2654 if (per_inferior == nullptr
2655 || !per_inferior->disp_step_bufs.has_value ())
2658 per_inferior->disp_step_bufs->restore_in_ptid (ptid);
2661 /* Helper for linux_get_hwcap and linux_get_hwcap2. */
2664 linux_get_hwcap_helper (const gdb::optional<gdb::byte_vector> &auxv,
2665 target_ops *target, gdbarch *gdbarch, CORE_ADDR match)
2668 if (!auxv.has_value ()
2669 || target_auxv_search (*auxv, target, gdbarch, match, &field) != 1)
2674 /* See linux-tdep.h. */
2677 linux_get_hwcap (const gdb::optional<gdb::byte_vector> &auxv,
2678 target_ops *target, gdbarch *gdbarch)
2680 return linux_get_hwcap_helper (auxv, target, gdbarch, AT_HWCAP);
2683 /* See linux-tdep.h. */
2688 return linux_get_hwcap (target_read_auxv (),
2689 current_inferior ()->top_target (),
2690 current_inferior ()->gdbarch);
2693 /* See linux-tdep.h. */
2696 linux_get_hwcap2 (const gdb::optional<gdb::byte_vector> &auxv,
2697 target_ops *target, gdbarch *gdbarch)
2699 return linux_get_hwcap_helper (auxv, target, gdbarch, AT_HWCAP2);
2702 /* See linux-tdep.h. */
2707 return linux_get_hwcap2 (target_read_auxv (),
2708 current_inferior ()->top_target (),
2709 current_inferior ()->gdbarch);
2712 /* Display whether the gcore command is using the
2713 /proc/PID/coredump_filter file. */
2716 show_use_coredump_filter (struct ui_file *file, int from_tty,
2717 struct cmd_list_element *c, const char *value)
2719 gdb_printf (file, _("Use of /proc/PID/coredump_filter file to generate"
2720 " corefiles is %s.\n"), value);
2723 /* Display whether the gcore command is dumping mappings marked with
2724 the VM_DONTDUMP flag. */
2727 show_dump_excluded_mappings (struct ui_file *file, int from_tty,
2728 struct cmd_list_element *c, const char *value)
2730 gdb_printf (file, _("Dumping of mappings marked with the VM_DONTDUMP"
2731 " flag is %s.\n"), value);
2734 /* To be called from the various GDB_OSABI_LINUX handlers for the
2735 various GNU/Linux architectures and machine types.
2737 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2738 displaced stepping is not supported. */
2741 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch,
2742 int num_disp_step_buffers)
2744 if (num_disp_step_buffers > 0)
2746 linux_gdbarch_data *gdbarch_data = get_linux_gdbarch_data (gdbarch);
2747 gdbarch_data->num_disp_step_buffers = num_disp_step_buffers;
2749 set_gdbarch_displaced_step_prepare (gdbarch,
2750 linux_displaced_step_prepare);
2751 set_gdbarch_displaced_step_finish (gdbarch, linux_displaced_step_finish);
2752 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2753 (gdbarch, linux_displaced_step_copy_insn_closure_by_addr);
2754 set_gdbarch_displaced_step_restore_all_in_ptid
2755 (gdbarch, linux_displaced_step_restore_all_in_ptid);
2758 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2759 set_gdbarch_info_proc (gdbarch, linux_info_proc);
2760 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2761 set_gdbarch_core_xfer_siginfo (gdbarch, linux_core_xfer_siginfo);
2762 set_gdbarch_read_core_file_mappings (gdbarch, linux_read_core_file_mappings);
2763 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2764 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2765 set_gdbarch_has_shared_address_space (gdbarch,
2766 linux_has_shared_address_space);
2767 set_gdbarch_gdb_signal_from_target (gdbarch,
2768 linux_gdb_signal_from_target);
2769 set_gdbarch_gdb_signal_to_target (gdbarch,
2770 linux_gdb_signal_to_target);
2771 set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2772 set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2773 set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2774 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2777 void _initialize_linux_tdep ();
2779 _initialize_linux_tdep ()
2781 /* Observers used to invalidate the cache when needed. */
2782 gdb::observers::inferior_exit.attach (invalidate_linux_cache_inf,
2784 gdb::observers::inferior_appeared.attach (invalidate_linux_cache_inf,
2786 gdb::observers::inferior_execd.attach (invalidate_linux_cache_inf,
2789 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2790 &use_coredump_filter, _("\
2791 Set whether gcore should consider /proc/PID/coredump_filter."),
2793 Show whether gcore should consider /proc/PID/coredump_filter."),
2795 Use this command to set whether gcore should consider the contents\n\
2796 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2797 about this file, refer to the manpage of core(5)."),
2798 NULL, show_use_coredump_filter,
2799 &setlist, &showlist);
2801 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files,
2802 &dump_excluded_mappings, _("\
2803 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2805 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2807 Use this command to set whether gcore should dump mappings marked with the\n\
2808 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2809 more information about this file, refer to the manpage of proc(5) and core(5)."),
2810 NULL, show_dump_excluded_mappings,
2811 &setlist, &showlist);
2814 /* Fetch (and possibly build) an appropriate `link_map_offsets' for
2815 ILP32/LP64 Linux systems which don't have the r_ldsomap field. */
2818 linux_ilp32_fetch_link_map_offsets ()
2820 static link_map_offsets lmo;
2821 static link_map_offsets *lmp = nullptr;
2827 lmo.r_version_offset = 0;
2828 lmo.r_version_size = 4;
2829 lmo.r_map_offset = 4;
2830 lmo.r_brk_offset = 8;
2831 lmo.r_ldsomap_offset = -1;
2832 lmo.r_next_offset = 20;
2834 /* Everything we need is in the first 20 bytes. */
2835 lmo.link_map_size = 20;
2836 lmo.l_addr_offset = 0;
2837 lmo.l_name_offset = 4;
2838 lmo.l_ld_offset = 8;
2839 lmo.l_next_offset = 12;
2840 lmo.l_prev_offset = 16;
2847 linux_lp64_fetch_link_map_offsets ()
2849 static link_map_offsets lmo;
2850 static link_map_offsets *lmp = nullptr;
2856 lmo.r_version_offset = 0;
2857 lmo.r_version_size = 4;
2858 lmo.r_map_offset = 8;
2859 lmo.r_brk_offset = 16;
2860 lmo.r_ldsomap_offset = -1;
2861 lmo.r_next_offset = 40;
2863 /* Everything we need is in the first 40 bytes. */
2864 lmo.link_map_size = 40;
2865 lmo.l_addr_offset = 0;
2866 lmo.l_name_offset = 8;
2867 lmo.l_ld_offset = 16;
2868 lmo.l_next_offset = 24;
2869 lmo.l_prev_offset = 32;