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"
47 /* This enum represents the values that the user can choose when
48 informing the Linux kernel about which memory mappings will be
49 dumped in a corefile. They are described in the file
50 Documentation/filesystems/proc.txt, inside the Linux kernel
55 COREFILTER_ANON_PRIVATE
= 1 << 0,
56 COREFILTER_ANON_SHARED
= 1 << 1,
57 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
58 COREFILTER_MAPPED_SHARED
= 1 << 3,
59 COREFILTER_ELF_HEADERS
= 1 << 4,
60 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
61 COREFILTER_HUGETLB_SHARED
= 1 << 6,
63 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
65 /* This struct is used to map flags found in the "VmFlags:" field (in
66 the /proc/<PID>/smaps file). */
70 /* Zero if this structure has not been initialized yet. It
71 probably means that the Linux kernel being used does not emit
72 the "VmFlags:" field on "/proc/PID/smaps". */
74 unsigned int initialized_p
: 1;
76 /* Memory mapped I/O area (VM_IO, "io"). */
78 unsigned int io_page
: 1;
80 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
82 unsigned int uses_huge_tlb
: 1;
84 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
86 unsigned int exclude_coredump
: 1;
88 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
90 unsigned int shared_mapping
: 1;
93 /* Whether to take the /proc/PID/coredump_filter into account when
94 generating a corefile. */
96 static bool use_coredump_filter
= true;
98 /* Whether the value of smaps_vmflags->exclude_coredump should be
99 ignored, including mappings marked with the VM_DONTDUMP flag in
101 static bool dump_excluded_mappings
= false;
103 /* This enum represents the signals' numbers on a generic architecture
104 running the Linux kernel. The definition of "generic" comes from
105 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
106 tree, which is the "de facto" implementation of signal numbers to
107 be used by new architecture ports.
109 For those architectures which have differences between the generic
110 standard (e.g., Alpha), we define the different signals (and *only*
111 those) in the specific target-dependent file (e.g.,
112 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
113 tdep file for more information.
115 ARM deserves a special mention here. On the file
116 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
117 (and ARM-only) signal, which is SIGSWI, with the same number as
118 SIGRTMIN. This signal is used only for a very specific target,
119 called ArthurOS (from RISCOS). Therefore, we do not handle it on
120 the ARM-tdep file, and we can safely use the generic signal handler
121 here for ARM targets.
123 As stated above, this enum is derived from
124 <include/uapi/asm-generic/signal.h>, from the Linux kernel
145 LINUX_SIGSTKFLT
= 16,
155 LINUX_SIGVTALRM
= 26,
159 LINUX_SIGPOLL
= LINUX_SIGIO
,
162 LINUX_SIGUNUSED
= 31,
168 static struct gdbarch_data
*linux_gdbarch_data_handle
;
170 struct linux_gdbarch_data
172 struct type
*siginfo_type
;
173 int num_disp_step_buffers
;
177 init_linux_gdbarch_data (struct obstack
*obstack
)
179 return obstack_zalloc
<linux_gdbarch_data
> (obstack
);
182 static struct linux_gdbarch_data
*
183 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
185 return ((struct linux_gdbarch_data
*)
186 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
189 /* Linux-specific cached data. This is used by GDB for caching
190 purposes for each inferior. This helps reduce the overhead of
191 transfering data from a remote target to the local host. */
194 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
195 if VSYSCALL_RANGE_P is positive. This is cached because getting
196 at this info requires an auxv lookup (which is itself cached),
197 and looking through the inferior's mappings (which change
198 throughout execution and therefore cannot be cached). */
199 struct mem_range vsyscall_range
{};
201 /* Zero if we haven't tried looking up the vsyscall's range before
202 yet. Positive if we tried looking it up, and found it. Negative
203 if we tried looking it up but failed. */
204 int vsyscall_range_p
= 0;
206 /* Inferior's displaced step buffers. */
207 gdb::optional
<displaced_step_buffers
> disp_step_bufs
;
210 /* Per-inferior data key. */
211 static const struct inferior_key
<linux_info
> linux_inferior_data
;
213 /* Frees whatever allocated space there is to be freed and sets INF's
214 linux cache data pointer to NULL. */
217 invalidate_linux_cache_inf (struct inferior
*inf
)
219 linux_inferior_data
.clear (inf
);
222 /* Fetch the linux cache info for INF. This function always returns a
223 valid INFO pointer. */
225 static struct linux_info
*
226 get_linux_inferior_data (inferior
*inf
)
228 linux_info
*info
= linux_inferior_data
.get (inf
);
231 info
= linux_inferior_data
.emplace (inf
);
236 /* See linux-tdep.h. */
239 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
240 linux_siginfo_extra_fields extra_fields
)
242 struct linux_gdbarch_data
*linux_gdbarch_data
;
243 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
244 struct type
*uid_type
, *pid_type
;
245 struct type
*sigval_type
, *clock_type
;
246 struct type
*siginfo_type
, *sifields_type
;
249 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
250 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
251 return linux_gdbarch_data
->siginfo_type
;
253 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
255 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
257 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
259 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
261 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
264 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
265 sigval_type
->set_name (xstrdup ("sigval_t"));
266 append_composite_type_field (sigval_type
, "sival_int", int_type
);
267 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
270 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
271 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
272 TYPE_TARGET_TYPE (pid_type
) = int_type
;
273 pid_type
->set_target_is_stub (true);
276 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
277 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
278 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
279 uid_type
->set_target_is_stub (true);
282 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
283 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
285 TYPE_TARGET_TYPE (clock_type
) = long_type
;
286 clock_type
->set_target_is_stub (true);
289 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
292 const int si_max_size
= 128;
294 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
297 if (gdbarch_ptr_bit (gdbarch
) == 64)
298 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
300 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
301 append_composite_type_field (sifields_type
, "_pad",
302 init_vector_type (int_type
, si_pad_size
));
306 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
307 append_composite_type_field (type
, "si_pid", pid_type
);
308 append_composite_type_field (type
, "si_uid", uid_type
);
309 append_composite_type_field (sifields_type
, "_kill", type
);
312 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
313 append_composite_type_field (type
, "si_tid", int_type
);
314 append_composite_type_field (type
, "si_overrun", int_type
);
315 append_composite_type_field (type
, "si_sigval", sigval_type
);
316 append_composite_type_field (sifields_type
, "_timer", type
);
319 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
320 append_composite_type_field (type
, "si_pid", pid_type
);
321 append_composite_type_field (type
, "si_uid", uid_type
);
322 append_composite_type_field (type
, "si_sigval", sigval_type
);
323 append_composite_type_field (sifields_type
, "_rt", type
);
326 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
327 append_composite_type_field (type
, "si_pid", pid_type
);
328 append_composite_type_field (type
, "si_uid", uid_type
);
329 append_composite_type_field (type
, "si_status", int_type
);
330 append_composite_type_field (type
, "si_utime", clock_type
);
331 append_composite_type_field (type
, "si_stime", clock_type
);
332 append_composite_type_field (sifields_type
, "_sigchld", type
);
335 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
336 append_composite_type_field (type
, "si_addr", void_ptr_type
);
338 /* Additional bound fields for _sigfault in case they were requested. */
339 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
341 struct type
*sigfault_bnd_fields
;
343 append_composite_type_field (type
, "_addr_lsb", short_type
);
344 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
345 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
346 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
347 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
349 append_composite_type_field (sifields_type
, "_sigfault", type
);
352 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
353 append_composite_type_field (type
, "si_band", long_type
);
354 append_composite_type_field (type
, "si_fd", int_type
);
355 append_composite_type_field (sifields_type
, "_sigpoll", type
);
358 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
359 siginfo_type
->set_name (xstrdup ("siginfo"));
360 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
361 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
362 append_composite_type_field (siginfo_type
, "si_code", int_type
);
363 append_composite_type_field_aligned (siginfo_type
,
364 "_sifields", sifields_type
,
365 TYPE_LENGTH (long_type
));
367 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
372 /* This function is suitable for architectures that don't
373 extend/override the standard siginfo structure. */
376 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
378 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
381 /* Return true if the target is running on uClinux instead of normal
385 linux_is_uclinux (void)
389 return (target_auxv_search (current_top_target (), AT_NULL
, &dummy
) > 0
390 && target_auxv_search (current_top_target (), AT_PAGESZ
, &dummy
) == 0);
394 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
396 return linux_is_uclinux ();
399 /* This is how we want PTIDs from core files to be printed. */
402 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
404 if (ptid
.lwp () != 0)
405 return string_printf ("LWP %ld", ptid
.lwp ());
407 return normal_pid_to_str (ptid
);
410 /* Service function for corefiles and info proc. */
413 read_mapping (const char *line
,
414 ULONGEST
*addr
, ULONGEST
*endaddr
,
415 const char **permissions
, size_t *permissions_len
,
417 const char **device
, size_t *device_len
,
419 const char **filename
)
421 const char *p
= line
;
423 *addr
= strtoulst (p
, &p
, 16);
426 *endaddr
= strtoulst (p
, &p
, 16);
430 while (*p
&& !isspace (*p
))
432 *permissions_len
= p
- *permissions
;
434 *offset
= strtoulst (p
, &p
, 16);
438 while (*p
&& !isspace (*p
))
440 *device_len
= p
- *device
;
442 *inode
= strtoulst (p
, &p
, 10);
448 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
450 This function was based on the documentation found on
451 <Documentation/filesystems/proc.txt>, on the Linux kernel.
453 Linux kernels before commit
454 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
458 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
460 char *saveptr
= NULL
;
463 v
->initialized_p
= 1;
464 p
= skip_to_space (p
);
467 for (s
= strtok_r (p
, " ", &saveptr
);
469 s
= strtok_r (NULL
, " ", &saveptr
))
471 if (strcmp (s
, "io") == 0)
473 else if (strcmp (s
, "ht") == 0)
474 v
->uses_huge_tlb
= 1;
475 else if (strcmp (s
, "dd") == 0)
476 v
->exclude_coredump
= 1;
477 else if (strcmp (s
, "sh") == 0)
478 v
->shared_mapping
= 1;
482 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
483 they're initialized lazily. */
485 struct mapping_regexes
487 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
488 string in the end). We know for sure, based on the Linux kernel
489 code, that memory mappings whose associated filename is
490 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
491 compiled_regex dev_zero
492 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
493 _("Could not compile regex to match /dev/zero filename")};
495 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
496 string in the end). These filenames refer to shared memory
497 (shmem), and memory mappings associated with them are
498 MAP_ANONYMOUS as well. */
499 compiled_regex shmem_file
500 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
501 _("Could not compile regex to match shmem filenames")};
503 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
504 0' code, which is responsible to decide if it is dealing with a
505 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
506 FILE_DELETED matches, it does not necessarily mean that we are
507 dealing with an anonymous shared mapping. However, there is no
508 easy way to detect this currently, so this is the best
509 approximation we have.
511 As a result, GDB will dump readonly pages of deleted executables
512 when using the default value of coredump_filter (0x33), while the
513 Linux kernel will not dump those pages. But we can live with
515 compiled_regex file_deleted
516 {" (deleted)$", REG_NOSUB
,
517 _("Could not compile regex to match '<file> (deleted)'")};
520 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
522 FILENAME is the name of the file present in the first line of the
523 memory mapping, in the "/proc/PID/smaps" output. For example, if
526 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
528 Then FILENAME will be "/path/to/file". */
531 mapping_is_anonymous_p (const char *filename
)
533 static gdb::optional
<mapping_regexes
> regexes
;
534 static int init_regex_p
= 0;
538 /* Let's be pessimistic and assume there will be an error while
539 compiling the regex'es. */
544 /* If we reached this point, then everything succeeded. */
548 if (init_regex_p
== -1)
550 const char deleted
[] = " (deleted)";
551 size_t del_len
= sizeof (deleted
) - 1;
552 size_t filename_len
= strlen (filename
);
554 /* There was an error while compiling the regex'es above. In
555 order to try to give some reliable information to the caller,
556 we just try to find the string " (deleted)" in the filename.
557 If we managed to find it, then we assume the mapping is
559 return (filename_len
>= del_len
560 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
563 if (*filename
== '\0'
564 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
565 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
566 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
572 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
573 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
574 be dumped, or greater than 0 if it should.
576 In a nutshell, this is the logic that we follow in order to decide
577 if a mapping should be dumped or not.
579 - If the mapping is associated to a file whose name ends with
580 " (deleted)", or if the file is "/dev/zero", or if it is
581 "/SYSV%08x" (shared memory), or if there is no file associated
582 with it, or if the AnonHugePages: or the Anonymous: fields in the
583 /proc/PID/smaps have contents, then GDB considers this mapping to
584 be anonymous. Otherwise, GDB considers this mapping to be a
585 file-backed mapping (because there will be a file associated with
588 It is worth mentioning that, from all those checks described
589 above, the most fragile is the one to see if the file name ends
590 with " (deleted)". This does not necessarily mean that the
591 mapping is anonymous, because the deleted file associated with
592 the mapping may have been a hard link to another file, for
593 example. The Linux kernel checks to see if "i_nlink == 0", but
594 GDB cannot easily (and normally) do this check (iff running as
595 root, it could find the mapping in /proc/PID/map_files/ and
596 determine whether there still are other hard links to the
597 inode/file). Therefore, we made a compromise here, and we assume
598 that if the file name ends with " (deleted)", then the mapping is
599 indeed anonymous. FWIW, this is something the Linux kernel could
600 do better: expose this information in a more direct way.
602 - If we see the flag "sh" in the "VmFlags:" field (in
603 /proc/PID/smaps), then certainly the memory mapping is shared
604 (VM_SHARED). If we have access to the VmFlags, and we don't see
605 the "sh" there, then certainly the mapping is private. However,
606 Linux kernels before commit
607 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
608 "VmFlags:" field; in that case, we use another heuristic: if we
609 see 'p' in the permission flags, then we assume that the mapping
610 is private, even though the presence of the 's' flag there would
611 mean VM_MAYSHARE, which means the mapping could still be private.
612 This should work OK enough, however.
614 - Even if, at the end, we decided that we should not dump the
615 mapping, we still have to check if it is something like an ELF
616 header (of a DSO or an executable, for example). If it is, and
617 if the user is interested in dump it, then we should dump it. */
620 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
621 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
622 const char *filename
, ULONGEST addr
, ULONGEST offset
)
624 /* Initially, we trust in what we received from our caller. This
625 value may not be very precise (i.e., it was probably gathered
626 from the permission line in the /proc/PID/smaps list, which
627 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
628 what we have until we take a look at the "VmFlags:" field
629 (assuming that the version of the Linux kernel being used
630 supports it, of course). */
631 int private_p
= maybe_private_p
;
634 /* We always dump vDSO and vsyscall mappings, because it's likely that
635 there'll be no file to read the contents from at core load time.
636 The kernel does the same. */
637 if (strcmp ("[vdso]", filename
) == 0
638 || strcmp ("[vsyscall]", filename
) == 0)
641 if (v
->initialized_p
)
643 /* We never dump I/O mappings. */
647 /* Check if we should exclude this mapping. */
648 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
651 /* Update our notion of whether this mapping is shared or
652 private based on a trustworthy value. */
653 private_p
= !v
->shared_mapping
;
655 /* HugeTLB checking. */
656 if (v
->uses_huge_tlb
)
658 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
659 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
668 if (mapping_anon_p
&& mapping_file_p
)
670 /* This is a special situation. It can happen when we see a
671 mapping that is file-backed, but that contains anonymous
673 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
674 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
676 else if (mapping_anon_p
)
677 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
679 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
683 if (mapping_anon_p
&& mapping_file_p
)
685 /* This is a special situation. It can happen when we see a
686 mapping that is file-backed, but that contains anonymous
688 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
689 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
691 else if (mapping_anon_p
)
692 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
694 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
697 /* Even if we decided that we shouldn't dump this mapping, we still
698 have to check whether (a) the user wants us to dump mappings
699 containing an ELF header, and (b) the mapping in question
700 contains an ELF header. If (a) and (b) are true, then we should
703 A mapping contains an ELF header if it is a private mapping, its
704 offset is zero, and its first word is ELFMAG. */
705 if (!dump_p
&& private_p
&& offset
== 0
706 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
708 /* Useful define specifying the size of the ELF magical
714 /* Let's check if we have an ELF header. */
716 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
718 /* The EI_MAG* and ELFMAG* constants come from
720 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
721 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
723 /* This mapping contains an ELF header, so we
733 /* As above, but return true only when we should dump the NT_FILE
737 dump_note_entry_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
738 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
739 const char *filename
, ULONGEST addr
, ULONGEST offset
)
741 /* vDSO and vsyscall mappings will end up in the core file. Don't
742 put them in the NT_FILE note. */
743 if (strcmp ("[vdso]", filename
) == 0
744 || strcmp ("[vsyscall]", filename
) == 0)
747 /* Otherwise, any other file-based mapping should be placed in the
752 /* Implement the "info proc" command. */
755 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
756 enum info_proc_what what
)
758 /* A long is used for pid instead of an int to avoid a loss of precision
759 compiler warning from the output of strtoul. */
761 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
762 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
763 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
764 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
765 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
766 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
770 if (args
&& isdigit (args
[0]))
774 pid
= strtoul (args
, &tem
, 10);
779 if (!target_has_execution ())
780 error (_("No current process: you must name one."));
781 if (current_inferior ()->fake_pid_p
)
782 error (_("Can't determine the current process's PID: you must name one."));
784 pid
= current_inferior ()->pid
;
787 args
= skip_spaces (args
);
789 error (_("Too many parameters: %s"), args
);
791 printf_filtered (_("process %ld\n"), pid
);
794 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
796 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
800 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
803 for (pos
= 0; pos
< len
- 1; pos
++)
805 if (buffer
[pos
] == '\0')
808 buffer
[len
- 1] = '\0';
809 printf_filtered ("cmdline = '%s'\n", buffer
);
812 warning (_("unable to open /proc file '%s'"), filename
);
816 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
817 gdb::optional
<std::string
> contents
818 = target_fileio_readlink (NULL
, filename
, &target_errno
);
819 if (contents
.has_value ())
820 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
822 warning (_("unable to read link '%s'"), filename
);
826 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
827 gdb::optional
<std::string
> contents
828 = target_fileio_readlink (NULL
, filename
, &target_errno
);
829 if (contents
.has_value ())
830 printf_filtered ("exe = '%s'\n", contents
->c_str ());
832 warning (_("unable to read link '%s'"), filename
);
836 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
837 gdb::unique_xmalloc_ptr
<char> map
838 = target_fileio_read_stralloc (NULL
, filename
);
843 printf_filtered (_("Mapped address spaces:\n\n"));
844 if (gdbarch_addr_bit (gdbarch
) == 32)
846 printf_filtered ("\t%10s %10s %10s %10s %s\n",
849 " Size", " Offset", "objfile");
853 printf_filtered (" %18s %18s %10s %10s %s\n",
856 " Size", " Offset", "objfile");
860 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
862 line
= strtok_r (NULL
, "\n", &saveptr
))
864 ULONGEST addr
, endaddr
, offset
, inode
;
865 const char *permissions
, *device
, *mapping_filename
;
866 size_t permissions_len
, device_len
;
868 read_mapping (line
, &addr
, &endaddr
,
869 &permissions
, &permissions_len
,
870 &offset
, &device
, &device_len
,
871 &inode
, &mapping_filename
);
873 if (gdbarch_addr_bit (gdbarch
) == 32)
875 printf_filtered ("\t%10s %10s %10s %10s %s\n",
876 paddress (gdbarch
, addr
),
877 paddress (gdbarch
, endaddr
),
878 hex_string (endaddr
- addr
),
880 *mapping_filename
? mapping_filename
: "");
884 printf_filtered (" %18s %18s %10s %10s %s\n",
885 paddress (gdbarch
, addr
),
886 paddress (gdbarch
, endaddr
),
887 hex_string (endaddr
- addr
),
889 *mapping_filename
? mapping_filename
: "");
894 warning (_("unable to open /proc file '%s'"), filename
);
898 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
899 gdb::unique_xmalloc_ptr
<char> status
900 = target_fileio_read_stralloc (NULL
, filename
);
902 puts_filtered (status
.get ());
904 warning (_("unable to open /proc file '%s'"), filename
);
908 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
909 gdb::unique_xmalloc_ptr
<char> statstr
910 = target_fileio_read_stralloc (NULL
, filename
);
913 const char *p
= statstr
.get ();
915 printf_filtered (_("Process: %s\n"),
916 pulongest (strtoulst (p
, &p
, 10)));
921 /* ps command also relies on no trailing fields
923 const char *ep
= strrchr (p
, ')');
926 printf_filtered ("Exec file: %.*s\n",
927 (int) (ep
- p
- 1), p
+ 1);
934 printf_filtered (_("State: %c\n"), *p
++);
937 printf_filtered (_("Parent process: %s\n"),
938 pulongest (strtoulst (p
, &p
, 10)));
940 printf_filtered (_("Process group: %s\n"),
941 pulongest (strtoulst (p
, &p
, 10)));
943 printf_filtered (_("Session id: %s\n"),
944 pulongest (strtoulst (p
, &p
, 10)));
946 printf_filtered (_("TTY: %s\n"),
947 pulongest (strtoulst (p
, &p
, 10)));
949 printf_filtered (_("TTY owner process group: %s\n"),
950 pulongest (strtoulst (p
, &p
, 10)));
953 printf_filtered (_("Flags: %s\n"),
954 hex_string (strtoulst (p
, &p
, 10)));
956 printf_filtered (_("Minor faults (no memory page): %s\n"),
957 pulongest (strtoulst (p
, &p
, 10)));
959 printf_filtered (_("Minor faults, children: %s\n"),
960 pulongest (strtoulst (p
, &p
, 10)));
962 printf_filtered (_("Major faults (memory page faults): %s\n"),
963 pulongest (strtoulst (p
, &p
, 10)));
965 printf_filtered (_("Major faults, children: %s\n"),
966 pulongest (strtoulst (p
, &p
, 10)));
968 printf_filtered (_("utime: %s\n"),
969 pulongest (strtoulst (p
, &p
, 10)));
971 printf_filtered (_("stime: %s\n"),
972 pulongest (strtoulst (p
, &p
, 10)));
974 printf_filtered (_("utime, children: %s\n"),
975 pulongest (strtoulst (p
, &p
, 10)));
977 printf_filtered (_("stime, children: %s\n"),
978 pulongest (strtoulst (p
, &p
, 10)));
980 printf_filtered (_("jiffies remaining in current "
982 pulongest (strtoulst (p
, &p
, 10)));
984 printf_filtered (_("'nice' value: %s\n"),
985 pulongest (strtoulst (p
, &p
, 10)));
987 printf_filtered (_("jiffies until next timeout: %s\n"),
988 pulongest (strtoulst (p
, &p
, 10)));
990 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
991 pulongest (strtoulst (p
, &p
, 10)));
993 printf_filtered (_("start time (jiffies since "
994 "system boot): %s\n"),
995 pulongest (strtoulst (p
, &p
, 10)));
997 printf_filtered (_("Virtual memory size: %s\n"),
998 pulongest (strtoulst (p
, &p
, 10)));
1000 printf_filtered (_("Resident set size: %s\n"),
1001 pulongest (strtoulst (p
, &p
, 10)));
1003 printf_filtered (_("rlim: %s\n"),
1004 pulongest (strtoulst (p
, &p
, 10)));
1006 printf_filtered (_("Start of text: %s\n"),
1007 hex_string (strtoulst (p
, &p
, 10)));
1009 printf_filtered (_("End of text: %s\n"),
1010 hex_string (strtoulst (p
, &p
, 10)));
1012 printf_filtered (_("Start of stack: %s\n"),
1013 hex_string (strtoulst (p
, &p
, 10)));
1014 #if 0 /* Don't know how architecture-dependent the rest is...
1015 Anyway the signal bitmap info is available from "status". */
1017 printf_filtered (_("Kernel stack pointer: %s\n"),
1018 hex_string (strtoulst (p
, &p
, 10)));
1020 printf_filtered (_("Kernel instr pointer: %s\n"),
1021 hex_string (strtoulst (p
, &p
, 10)));
1023 printf_filtered (_("Pending signals bitmap: %s\n"),
1024 hex_string (strtoulst (p
, &p
, 10)));
1026 printf_filtered (_("Blocked signals bitmap: %s\n"),
1027 hex_string (strtoulst (p
, &p
, 10)));
1029 printf_filtered (_("Ignored signals bitmap: %s\n"),
1030 hex_string (strtoulst (p
, &p
, 10)));
1032 printf_filtered (_("Catched signals bitmap: %s\n"),
1033 hex_string (strtoulst (p
, &p
, 10)));
1035 printf_filtered (_("wchan (system call): %s\n"),
1036 hex_string (strtoulst (p
, &p
, 10)));
1040 warning (_("unable to open /proc file '%s'"), filename
);
1044 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1047 This function reads the NT_FILE note (which BFD turns into the
1048 section ".note.linuxcore.file"). The format of this note / section
1049 is described as follows in the Linux kernel sources in
1052 long count -- how many files are mapped
1053 long page_size -- units for file_ofs
1054 array of [COUNT] elements of
1058 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1060 CBFD is the BFD of the core file.
1062 PRE_LOOP_CB is the callback function to invoke prior to starting
1063 the loop which processes individual entries. This callback will
1064 only be executed after the note has been examined in enough
1065 detail to verify that it's not malformed in some way.
1067 LOOP_CB is the callback function that will be executed once
1068 for each mapping. */
1071 linux_read_core_file_mappings (struct gdbarch
*gdbarch
,
1073 gdb::function_view
<void (ULONGEST count
)>
1075 gdb::function_view
<void (int num
,
1079 const char *filename
)>
1082 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1083 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1085 /* It's not required that the NT_FILE note exists, so return silently
1086 if it's not found. Beyond this point though, we'll complain
1087 if problems are found. */
1088 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1089 if (section
== nullptr)
1092 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1093 unsigned int addr_size
= addr_size_bits
/ 8;
1094 size_t note_size
= bfd_section_size (section
);
1096 if (note_size
< 2 * addr_size
)
1098 warning (_("malformed core note - too short for header"));
1102 gdb::def_vector
<gdb_byte
> contents (note_size
);
1103 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1106 warning (_("could not get core note contents"));
1110 gdb_byte
*descdata
= contents
.data ();
1111 char *descend
= (char *) descdata
+ note_size
;
1113 if (descdata
[note_size
- 1] != '\0')
1115 warning (_("malformed note - does not end with \\0"));
1119 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1120 descdata
+= addr_size
;
1122 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1123 descdata
+= addr_size
;
1125 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1127 warning (_("malformed note - too short for supplied file count"));
1131 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1133 /* Make sure that the correct number of filenames exist. Complain
1134 if there aren't enough or are too many. */
1135 char *f
= filenames
;
1136 for (int i
= 0; i
< count
; i
++)
1140 warning (_("malformed note - filename area is too small"));
1143 f
+= strnlen (f
, descend
- f
) + 1;
1145 /* Complain, but don't return early if the filename area is too big. */
1147 warning (_("malformed note - filename area is too big"));
1149 pre_loop_cb (count
);
1151 for (int i
= 0; i
< count
; i
++)
1153 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1154 descdata
+= addr_size
;
1155 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1156 descdata
+= addr_size
;
1158 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1159 descdata
+= addr_size
;
1160 char * filename
= filenames
;
1161 filenames
+= strlen ((char *) filenames
) + 1;
1163 loop_cb (i
, start
, end
, file_ofs
, filename
);
1167 /* Implement "info proc mappings" for a corefile. */
1170 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1172 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1173 [=] (ULONGEST count
)
1175 printf_filtered (_("Mapped address spaces:\n\n"));
1176 if (gdbarch_addr_bit (gdbarch
) == 32)
1178 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1181 " Size", " Offset", "objfile");
1185 printf_filtered (" %18s %18s %10s %10s %s\n",
1188 " Size", " Offset", "objfile");
1191 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1192 const char *filename
)
1194 if (gdbarch_addr_bit (gdbarch
) == 32)
1195 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1196 paddress (gdbarch
, start
),
1197 paddress (gdbarch
, end
),
1198 hex_string (end
- start
),
1199 hex_string (file_ofs
),
1202 printf_filtered (" %18s %18s %10s %10s %s\n",
1203 paddress (gdbarch
, start
),
1204 paddress (gdbarch
, end
),
1205 hex_string (end
- start
),
1206 hex_string (file_ofs
),
1211 /* Implement "info proc" for a corefile. */
1214 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1215 enum info_proc_what what
)
1217 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1218 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1224 exe
= bfd_core_file_failing_command (core_bfd
);
1226 printf_filtered ("exe = '%s'\n", exe
);
1228 warning (_("unable to find command name in core file"));
1232 linux_core_info_proc_mappings (gdbarch
, args
);
1234 if (!exe_f
&& !mappings_f
)
1235 error (_("unable to handle request"));
1238 /* Read siginfo data from the core, if possible. Returns -1 on
1239 failure. Otherwise, returns the number of bytes read. READBUF,
1240 OFFSET, and LEN are all as specified by the to_xfer_partial
1244 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1245 ULONGEST offset
, ULONGEST len
)
1247 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1248 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1249 if (section
== NULL
)
1252 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1258 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1259 ULONGEST offset
, ULONGEST inode
,
1260 int read
, int write
,
1261 int exec
, int modified
,
1262 const char *filename
,
1265 typedef int linux_dump_mapping_p_ftype (filter_flags filterflags
,
1266 const struct smaps_vmflags
*v
,
1267 int maybe_private_p
,
1270 const char *filename
,
1274 /* List memory regions in the inferior for a corefile. */
1277 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1278 linux_dump_mapping_p_ftype
*should_dump_mapping_p
,
1279 linux_find_memory_region_ftype
*func
,
1282 char mapsfilename
[100];
1283 char coredumpfilter_name
[100];
1285 /* Default dump behavior of coredump_filter (0x33), according to
1286 Documentation/filesystems/proc.txt from the Linux kernel
1288 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1289 | COREFILTER_ANON_SHARED
1290 | COREFILTER_ELF_HEADERS
1291 | COREFILTER_HUGETLB_PRIVATE
);
1293 /* We need to know the real target PID to access /proc. */
1294 if (current_inferior ()->fake_pid_p
)
1297 pid
= current_inferior ()->pid
;
1299 if (use_coredump_filter
)
1301 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1302 "/proc/%d/coredump_filter", pid
);
1303 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1304 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1305 if (coredumpfilterdata
!= NULL
)
1309 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1310 filterflags
= (enum filter_flag
) flags
;
1314 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1315 gdb::unique_xmalloc_ptr
<char> data
1316 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1319 /* Older Linux kernels did not support /proc/PID/smaps. */
1320 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1321 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1328 line
= strtok_r (data
.get (), "\n", &t
);
1329 while (line
!= NULL
)
1331 ULONGEST addr
, endaddr
, offset
, inode
;
1332 const char *permissions
, *device
, *filename
;
1333 struct smaps_vmflags v
;
1334 size_t permissions_len
, device_len
;
1335 int read
, write
, exec
, priv
;
1336 int has_anonymous
= 0;
1337 int should_dump_p
= 0;
1341 memset (&v
, 0, sizeof (v
));
1342 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1343 &offset
, &device
, &device_len
, &inode
, &filename
);
1344 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1345 /* If the mapping is not anonymous, then we can consider it
1346 to be file-backed. These two states (anonymous or
1347 file-backed) seem to be exclusive, but they can actually
1348 coexist. For example, if a file-backed mapping has
1349 "Anonymous:" pages (see more below), then the Linux
1350 kernel will dump this mapping when the user specified
1351 that she only wants anonymous mappings in the corefile
1352 (*even* when she explicitly disabled the dumping of
1353 file-backed mappings). */
1354 mapping_file_p
= !mapping_anon_p
;
1356 /* Decode permissions. */
1357 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1358 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1359 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1360 /* 'private' here actually means VM_MAYSHARE, and not
1361 VM_SHARED. In order to know if a mapping is really
1362 private or not, we must check the flag "sh" in the
1363 VmFlags field. This is done by decode_vmflags. However,
1364 if we are using a Linux kernel released before the commit
1365 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1366 not have the VmFlags there. In this case, there is
1367 really no way to know if we are dealing with VM_SHARED,
1368 so we just assume that VM_MAYSHARE is enough. */
1369 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1371 /* Try to detect if region should be dumped by parsing smaps
1373 for (line
= strtok_r (NULL
, "\n", &t
);
1374 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1375 line
= strtok_r (NULL
, "\n", &t
))
1377 char keyword
[64 + 1];
1379 if (sscanf (line
, "%64s", keyword
) != 1)
1381 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1385 if (strcmp (keyword
, "Anonymous:") == 0)
1387 /* Older Linux kernels did not support the
1388 "Anonymous:" counter. Check it here. */
1391 else if (strcmp (keyword
, "VmFlags:") == 0)
1392 decode_vmflags (line
, &v
);
1394 if (strcmp (keyword
, "AnonHugePages:") == 0
1395 || strcmp (keyword
, "Anonymous:") == 0)
1397 unsigned long number
;
1399 if (sscanf (line
, "%*s%lu", &number
) != 1)
1401 warning (_("Error parsing {s,}maps file '%s' number"),
1407 /* Even if we are dealing with a file-backed
1408 mapping, if it contains anonymous pages we
1409 consider it to be *also* an anonymous
1410 mapping, because this is what the Linux
1413 // Dump segments that have been written to.
1414 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1417 Note that if the mapping is already marked as
1418 file-backed (i.e., mapping_file_p is
1419 non-zero), then this is a special case, and
1420 this mapping will be dumped either when the
1421 user wants to dump file-backed *or* anonymous
1429 should_dump_p
= should_dump_mapping_p (filterflags
, &v
, priv
,
1432 filename
, addr
, offset
);
1435 /* Older Linux kernels did not support the "Anonymous:" counter.
1436 If it is missing, we can't be sure - dump all the pages. */
1440 /* Invoke the callback function to create the corefile segment. */
1442 func (addr
, endaddr
- addr
, offset
, inode
,
1443 read
, write
, exec
, 1, /* MODIFIED is true because we
1444 want to dump the mapping. */
1454 /* A structure for passing information through
1455 linux_find_memory_regions_full. */
1457 struct linux_find_memory_regions_data
1459 /* The original callback. */
1461 find_memory_region_ftype func
;
1463 /* The original datum. */
1468 /* A callback for linux_find_memory_regions that converts between the
1469 "full"-style callback and find_memory_region_ftype. */
1472 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1473 ULONGEST offset
, ULONGEST inode
,
1474 int read
, int write
, int exec
, int modified
,
1475 const char *filename
, void *arg
)
1477 struct linux_find_memory_regions_data
*data
1478 = (struct linux_find_memory_regions_data
*) arg
;
1480 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1483 /* A variant of linux_find_memory_regions_full that is suitable as the
1484 gdbarch find_memory_regions method. */
1487 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1488 find_memory_region_ftype func
, void *obfd
)
1490 struct linux_find_memory_regions_data data
;
1495 return linux_find_memory_regions_full (gdbarch
,
1497 linux_find_memory_regions_thunk
,
1501 /* This is used to pass information from
1502 linux_make_mappings_corefile_notes through
1503 linux_find_memory_regions_full. */
1505 struct linux_make_mappings_data
1507 /* Number of files mapped. */
1508 ULONGEST file_count
;
1510 /* The obstack for the main part of the data. */
1511 struct obstack
*data_obstack
;
1513 /* The filename obstack. */
1514 struct obstack
*filename_obstack
;
1516 /* The architecture's "long" type. */
1517 struct type
*long_type
;
1520 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1522 /* A callback for linux_find_memory_regions_full that updates the
1523 mappings data for linux_make_mappings_corefile_notes. */
1526 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1527 ULONGEST offset
, ULONGEST inode
,
1528 int read
, int write
, int exec
, int modified
,
1529 const char *filename
, void *data
)
1531 struct linux_make_mappings_data
*map_data
1532 = (struct linux_make_mappings_data
*) data
;
1533 gdb_byte buf
[sizeof (ULONGEST
)];
1535 if (*filename
== '\0' || inode
== 0)
1538 ++map_data
->file_count
;
1540 pack_long (buf
, map_data
->long_type
, vaddr
);
1541 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1542 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1543 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1544 pack_long (buf
, map_data
->long_type
, offset
);
1545 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1547 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1552 /* Write the file mapping data to the core file, if possible. OBFD is
1553 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1554 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1557 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1558 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1561 struct linux_make_mappings_data mapping_data
;
1562 struct type
*long_type
1563 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1564 gdb_byte buf
[sizeof (ULONGEST
)];
1566 auto_obstack data_obstack
, filename_obstack
;
1568 mapping_data
.file_count
= 0;
1569 mapping_data
.data_obstack
= &data_obstack
;
1570 mapping_data
.filename_obstack
= &filename_obstack
;
1571 mapping_data
.long_type
= long_type
;
1573 /* Reserve space for the count. */
1574 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1575 /* We always write the page size as 1 since we have no good way to
1576 determine the correct value. */
1577 pack_long (buf
, long_type
, 1);
1578 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1580 linux_find_memory_regions_full (gdbarch
,
1582 linux_make_mappings_callback
,
1585 if (mapping_data
.file_count
!= 0)
1587 /* Write the count to the obstack. */
1588 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1589 long_type
, mapping_data
.file_count
);
1591 /* Copy the filenames to the data obstack. */
1592 int size
= obstack_object_size (&filename_obstack
);
1593 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1596 note_data
.reset (elfcore_write_file_note (obfd
, note_data
.release (), note_size
,
1597 obstack_base (&data_obstack
),
1598 obstack_object_size (&data_obstack
)));
1602 /* Fetch the siginfo data for the specified thread, if it exists. If
1603 there is no data, or we could not read it, return an empty
1606 static gdb::byte_vector
1607 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1609 struct type
*siginfo_type
;
1612 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1613 return gdb::byte_vector ();
1615 scoped_restore_current_thread save_current_thread
;
1616 switch_to_thread (thread
);
1618 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1620 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1622 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1623 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1624 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1630 struct linux_corefile_thread_data
1632 linux_corefile_thread_data (struct gdbarch
*gdbarch
, bfd
*obfd
,
1633 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1634 int *note_size
, gdb_signal stop_signal
)
1635 : gdbarch (gdbarch
), obfd (obfd
), note_data (note_data
),
1636 note_size (note_size
), stop_signal (stop_signal
)
1639 struct gdbarch
*gdbarch
;
1641 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1643 enum gdb_signal stop_signal
;
1646 /* Records the thread's register state for the corefile note
1650 linux_corefile_thread (struct thread_info
*info
,
1651 struct linux_corefile_thread_data
*args
)
1653 gcore_elf_build_thread_register_notes (args
->gdbarch
, info
,
1655 args
->obfd
, &args
->note_data
,
1658 /* Don't return anything if we got no register information above,
1659 such a core file is useless. */
1660 if (args
->note_data
!= NULL
)
1662 gdb::byte_vector siginfo_data
1663 = linux_get_siginfo_data (info
, args
->gdbarch
);
1664 if (!siginfo_data
.empty ())
1665 args
->note_data
.reset (elfcore_write_note (args
->obfd
,
1666 args
->note_data
.release (),
1669 siginfo_data
.data (),
1670 siginfo_data
.size ()));
1674 /* Fill the PRPSINFO structure with information about the process being
1675 debugged. Returns 1 in case of success, 0 for failures. Please note that
1676 even if the structure cannot be entirely filled (e.g., GDB was unable to
1677 gather information about the process UID/GID), this function will still
1678 return 1 since some information was already recorded. It will only return
1679 0 iff nothing can be gathered. */
1682 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1684 /* The filename which we will use to obtain some info about the process.
1685 We will basically use this to store the `/proc/PID/FILENAME' file. */
1687 /* The basename of the executable. */
1688 const char *basename
;
1689 const char *infargs
;
1690 /* Temporary buffer. */
1692 /* The valid states of a process, according to the Linux kernel. */
1693 const char valid_states
[] = "RSDTZW";
1694 /* The program state. */
1695 const char *prog_state
;
1696 /* The state of the process. */
1698 /* The PID of the program which generated the corefile. */
1700 /* Process flags. */
1701 unsigned int pr_flag
;
1702 /* Process nice value. */
1704 /* The number of fields read by `sscanf'. */
1707 gdb_assert (p
!= NULL
);
1709 /* Obtaining PID and filename. */
1710 pid
= inferior_ptid
.pid ();
1711 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1712 /* The full name of the program which generated the corefile. */
1713 gdb::unique_xmalloc_ptr
<char> fname
1714 = target_fileio_read_stralloc (NULL
, filename
);
1716 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1718 /* No program name was read, so we won't be able to retrieve more
1719 information about the process. */
1723 memset (p
, 0, sizeof (*p
));
1725 /* Defining the PID. */
1728 /* Copying the program name. Only the basename matters. */
1729 basename
= lbasename (fname
.get ());
1730 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1731 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1733 infargs
= get_inferior_args ();
1735 /* The arguments of the program. */
1736 std::string psargs
= fname
.get ();
1737 if (infargs
!= NULL
)
1738 psargs
= psargs
+ " " + infargs
;
1740 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1741 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1743 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1744 /* The contents of `/proc/PID/stat'. */
1745 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1746 = target_fileio_read_stralloc (NULL
, filename
);
1747 char *proc_stat
= proc_stat_contents
.get ();
1749 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1751 /* Despite being unable to read more information about the
1752 process, we return 1 here because at least we have its
1753 command line, PID and arguments. */
1757 /* Ok, we have the stats. It's time to do a little parsing of the
1758 contents of the buffer, so that we end up reading what we want.
1760 The following parsing mechanism is strongly based on the
1761 information generated by the `fs/proc/array.c' file, present in
1762 the Linux kernel tree. More details about how the information is
1763 displayed can be obtained by seeing the manpage of proc(5),
1764 specifically under the entry of `/proc/[pid]/stat'. */
1766 /* Getting rid of the PID, since we already have it. */
1767 while (isdigit (*proc_stat
))
1770 proc_stat
= skip_spaces (proc_stat
);
1772 /* ps command also relies on no trailing fields ever contain ')'. */
1773 proc_stat
= strrchr (proc_stat
, ')');
1774 if (proc_stat
== NULL
)
1778 proc_stat
= skip_spaces (proc_stat
);
1780 n_fields
= sscanf (proc_stat
,
1781 "%c" /* Process state. */
1782 "%d%d%d" /* Parent PID, group ID, session ID. */
1783 "%*d%*d" /* tty_nr, tpgid (not used). */
1785 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1786 cmajflt (not used). */
1787 "%*s%*s%*s%*s" /* utime, stime, cutime,
1788 cstime (not used). */
1789 "%*s" /* Priority (not used). */
1792 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1798 /* Again, we couldn't read the complementary information about
1799 the process state. However, we already have minimal
1800 information, so we just return 1 here. */
1804 /* Filling the structure fields. */
1805 prog_state
= strchr (valid_states
, pr_sname
);
1806 if (prog_state
!= NULL
)
1807 p
->pr_state
= prog_state
- valid_states
;
1810 /* Zero means "Running". */
1814 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1815 p
->pr_zomb
= p
->pr_sname
== 'Z';
1816 p
->pr_nice
= pr_nice
;
1817 p
->pr_flag
= pr_flag
;
1819 /* Finally, obtaining the UID and GID. For that, we read and parse the
1820 contents of the `/proc/PID/status' file. */
1821 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1822 /* The contents of `/proc/PID/status'. */
1823 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1824 = target_fileio_read_stralloc (NULL
, filename
);
1825 char *proc_status
= proc_status_contents
.get ();
1827 if (proc_status
== NULL
|| *proc_status
== '\0')
1829 /* Returning 1 since we already have a bunch of information. */
1833 /* Extracting the UID. */
1834 tmpstr
= strstr (proc_status
, "Uid:");
1837 /* Advancing the pointer to the beginning of the UID. */
1838 tmpstr
+= sizeof ("Uid:");
1839 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1842 if (isdigit (*tmpstr
))
1843 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1846 /* Extracting the GID. */
1847 tmpstr
= strstr (proc_status
, "Gid:");
1850 /* Advancing the pointer to the beginning of the GID. */
1851 tmpstr
+= sizeof ("Gid:");
1852 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1855 if (isdigit (*tmpstr
))
1856 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1862 /* Build the note section for a corefile, and return it in a malloc
1865 static gdb::unique_xmalloc_ptr
<char>
1866 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1868 struct elf_internal_linux_prpsinfo prpsinfo
;
1869 gdb::unique_xmalloc_ptr
<char> note_data
;
1871 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1874 if (linux_fill_prpsinfo (&prpsinfo
))
1876 if (gdbarch_ptr_bit (gdbarch
) == 64)
1877 note_data
.reset (elfcore_write_linux_prpsinfo64 (obfd
,
1878 note_data
.release (),
1879 note_size
, &prpsinfo
));
1881 note_data
.reset (elfcore_write_linux_prpsinfo32 (obfd
,
1882 note_data
.release (),
1883 note_size
, &prpsinfo
));
1886 /* Thread register information. */
1889 update_thread_list ();
1891 catch (const gdb_exception_error
&e
)
1893 exception_print (gdb_stderr
, e
);
1896 /* Like the kernel, prefer dumping the signalled thread first.
1897 "First thread" is what tools use to infer the signalled
1899 thread_info
*signalled_thr
= gcore_find_signalled_thread ();
1900 gdb_signal stop_signal
;
1901 if (signalled_thr
!= nullptr)
1902 stop_signal
= signalled_thr
->suspend
.stop_signal
;
1904 stop_signal
= GDB_SIGNAL_0
;
1906 linux_corefile_thread_data
thread_args (gdbarch
, obfd
, note_data
, note_size
,
1909 if (signalled_thr
!= nullptr)
1910 linux_corefile_thread (signalled_thr
, &thread_args
);
1911 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1913 if (thr
== signalled_thr
)
1916 linux_corefile_thread (thr
, &thread_args
);
1922 /* Auxillary vector. */
1923 gdb::optional
<gdb::byte_vector
> auxv
=
1924 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
1925 if (auxv
&& !auxv
->empty ())
1927 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
1928 note_size
, "CORE", NT_AUXV
,
1929 auxv
->data (), auxv
->size ()));
1935 /* File mappings. */
1936 linux_make_mappings_corefile_notes (gdbarch
, obfd
, note_data
, note_size
);
1938 /* Target description. */
1939 gcore_elf_make_tdesc_note (obfd
, ¬e_data
, note_size
);
1944 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1945 gdbarch.h. This function is not static because it is exported to
1946 other -tdep files. */
1949 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1954 return GDB_SIGNAL_0
;
1957 return GDB_SIGNAL_HUP
;
1960 return GDB_SIGNAL_INT
;
1963 return GDB_SIGNAL_QUIT
;
1966 return GDB_SIGNAL_ILL
;
1969 return GDB_SIGNAL_TRAP
;
1972 return GDB_SIGNAL_ABRT
;
1975 return GDB_SIGNAL_BUS
;
1978 return GDB_SIGNAL_FPE
;
1981 return GDB_SIGNAL_KILL
;
1984 return GDB_SIGNAL_USR1
;
1987 return GDB_SIGNAL_SEGV
;
1990 return GDB_SIGNAL_USR2
;
1993 return GDB_SIGNAL_PIPE
;
1996 return GDB_SIGNAL_ALRM
;
1999 return GDB_SIGNAL_TERM
;
2002 return GDB_SIGNAL_CHLD
;
2005 return GDB_SIGNAL_CONT
;
2008 return GDB_SIGNAL_STOP
;
2011 return GDB_SIGNAL_TSTP
;
2014 return GDB_SIGNAL_TTIN
;
2017 return GDB_SIGNAL_TTOU
;
2020 return GDB_SIGNAL_URG
;
2023 return GDB_SIGNAL_XCPU
;
2026 return GDB_SIGNAL_XFSZ
;
2028 case LINUX_SIGVTALRM
:
2029 return GDB_SIGNAL_VTALRM
;
2032 return GDB_SIGNAL_PROF
;
2034 case LINUX_SIGWINCH
:
2035 return GDB_SIGNAL_WINCH
;
2037 /* No way to differentiate between SIGIO and SIGPOLL.
2038 Therefore, we just handle the first one. */
2040 return GDB_SIGNAL_IO
;
2043 return GDB_SIGNAL_PWR
;
2046 return GDB_SIGNAL_SYS
;
2048 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2049 therefore we have to handle them here. */
2050 case LINUX_SIGRTMIN
:
2051 return GDB_SIGNAL_REALTIME_32
;
2053 case LINUX_SIGRTMAX
:
2054 return GDB_SIGNAL_REALTIME_64
;
2057 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2059 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2061 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2064 return GDB_SIGNAL_UNKNOWN
;
2067 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2068 gdbarch.h. This function is not static because it is exported to
2069 other -tdep files. */
2072 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2073 enum gdb_signal signal
)
2080 case GDB_SIGNAL_HUP
:
2081 return LINUX_SIGHUP
;
2083 case GDB_SIGNAL_INT
:
2084 return LINUX_SIGINT
;
2086 case GDB_SIGNAL_QUIT
:
2087 return LINUX_SIGQUIT
;
2089 case GDB_SIGNAL_ILL
:
2090 return LINUX_SIGILL
;
2092 case GDB_SIGNAL_TRAP
:
2093 return LINUX_SIGTRAP
;
2095 case GDB_SIGNAL_ABRT
:
2096 return LINUX_SIGABRT
;
2098 case GDB_SIGNAL_FPE
:
2099 return LINUX_SIGFPE
;
2101 case GDB_SIGNAL_KILL
:
2102 return LINUX_SIGKILL
;
2104 case GDB_SIGNAL_BUS
:
2105 return LINUX_SIGBUS
;
2107 case GDB_SIGNAL_SEGV
:
2108 return LINUX_SIGSEGV
;
2110 case GDB_SIGNAL_SYS
:
2111 return LINUX_SIGSYS
;
2113 case GDB_SIGNAL_PIPE
:
2114 return LINUX_SIGPIPE
;
2116 case GDB_SIGNAL_ALRM
:
2117 return LINUX_SIGALRM
;
2119 case GDB_SIGNAL_TERM
:
2120 return LINUX_SIGTERM
;
2122 case GDB_SIGNAL_URG
:
2123 return LINUX_SIGURG
;
2125 case GDB_SIGNAL_STOP
:
2126 return LINUX_SIGSTOP
;
2128 case GDB_SIGNAL_TSTP
:
2129 return LINUX_SIGTSTP
;
2131 case GDB_SIGNAL_CONT
:
2132 return LINUX_SIGCONT
;
2134 case GDB_SIGNAL_CHLD
:
2135 return LINUX_SIGCHLD
;
2137 case GDB_SIGNAL_TTIN
:
2138 return LINUX_SIGTTIN
;
2140 case GDB_SIGNAL_TTOU
:
2141 return LINUX_SIGTTOU
;
2146 case GDB_SIGNAL_XCPU
:
2147 return LINUX_SIGXCPU
;
2149 case GDB_SIGNAL_XFSZ
:
2150 return LINUX_SIGXFSZ
;
2152 case GDB_SIGNAL_VTALRM
:
2153 return LINUX_SIGVTALRM
;
2155 case GDB_SIGNAL_PROF
:
2156 return LINUX_SIGPROF
;
2158 case GDB_SIGNAL_WINCH
:
2159 return LINUX_SIGWINCH
;
2161 case GDB_SIGNAL_USR1
:
2162 return LINUX_SIGUSR1
;
2164 case GDB_SIGNAL_USR2
:
2165 return LINUX_SIGUSR2
;
2167 case GDB_SIGNAL_PWR
:
2168 return LINUX_SIGPWR
;
2170 case GDB_SIGNAL_POLL
:
2171 return LINUX_SIGPOLL
;
2173 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2174 therefore we have to handle it here. */
2175 case GDB_SIGNAL_REALTIME_32
:
2176 return LINUX_SIGRTMIN
;
2178 /* Same comment applies to _64. */
2179 case GDB_SIGNAL_REALTIME_64
:
2180 return LINUX_SIGRTMAX
;
2183 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2184 if (signal
>= GDB_SIGNAL_REALTIME_33
2185 && signal
<= GDB_SIGNAL_REALTIME_63
)
2187 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2189 return LINUX_SIGRTMIN
+ 1 + offset
;
2195 /* Helper for linux_vsyscall_range that does the real work of finding
2196 the vsyscall's address range. */
2199 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2204 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2207 /* It doesn't make sense to access the host's /proc when debugging a
2208 core file. Instead, look for the PT_LOAD segment that matches
2210 if (!target_has_execution ())
2215 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2216 if (phdrs_size
== -1)
2219 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2220 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2221 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2222 if (num_phdrs
== -1)
2225 for (i
= 0; i
< num_phdrs
; i
++)
2226 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2227 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2229 range
->length
= phdrs
.get ()[i
].p_memsz
;
2236 /* We need to know the real target PID to access /proc. */
2237 if (current_inferior ()->fake_pid_p
)
2240 pid
= current_inferior ()->pid
;
2242 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2243 reading /proc/PID/maps (2). The later identifies thread stacks
2244 in the output, which requires scanning every thread in the thread
2245 group to check whether a VMA is actually a thread's stack. With
2246 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2247 a few thousand threads, (1) takes a few miliseconds, while (2)
2248 takes several seconds. Also note that "smaps", what we read for
2249 determining core dump mappings, is even slower than "maps". */
2250 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2251 gdb::unique_xmalloc_ptr
<char> data
2252 = target_fileio_read_stralloc (NULL
, filename
);
2256 char *saveptr
= NULL
;
2258 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2260 line
= strtok_r (NULL
, "\n", &saveptr
))
2262 ULONGEST addr
, endaddr
;
2263 const char *p
= line
;
2265 addr
= strtoulst (p
, &p
, 16);
2266 if (addr
== range
->start
)
2270 endaddr
= strtoulst (p
, &p
, 16);
2271 range
->length
= endaddr
- addr
;
2277 warning (_("unable to open /proc file '%s'"), filename
);
2282 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2283 caching, and defers the real work to linux_vsyscall_range_raw. */
2286 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2288 struct linux_info
*info
= get_linux_inferior_data (current_inferior ());
2290 if (info
->vsyscall_range_p
== 0)
2292 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2293 info
->vsyscall_range_p
= 1;
2295 info
->vsyscall_range_p
= -1;
2298 if (info
->vsyscall_range_p
< 0)
2301 *range
= info
->vsyscall_range
;
2305 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2306 definitions would be dependent on compilation host. */
2307 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2308 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2310 /* See gdbarch.sh 'infcall_mmap'. */
2313 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2315 struct objfile
*objf
;
2316 /* Do there still exist any Linux systems without "mmap64"?
2317 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2318 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2319 struct value
*addr_val
;
2320 struct gdbarch
*gdbarch
= objf
->arch ();
2324 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2326 struct value
*arg
[ARG_LAST
];
2328 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2330 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2331 arg
[ARG_LENGTH
] = value_from_ulongest
2332 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2333 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2334 | GDB_MMAP_PROT_EXEC
))
2336 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2337 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2338 GDB_MMAP_MAP_PRIVATE
2339 | GDB_MMAP_MAP_ANONYMOUS
);
2340 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2341 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2343 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2344 retval
= value_as_address (addr_val
);
2345 if (retval
== (CORE_ADDR
) -1)
2346 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2351 /* See gdbarch.sh 'infcall_munmap'. */
2354 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2356 struct objfile
*objf
;
2357 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2358 struct value
*retval_val
;
2359 struct gdbarch
*gdbarch
= objf
->arch ();
2363 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2365 struct value
*arg
[ARG_LAST
];
2367 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2369 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2370 arg
[ARG_LENGTH
] = value_from_ulongest
2371 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2372 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2373 retval
= value_as_long (retval_val
);
2375 warning (_("Failed inferior munmap call at %s for %s bytes, "
2376 "errno is changed."),
2377 hex_string (addr
), pulongest (size
));
2380 /* See linux-tdep.h. */
2383 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2388 /* Determine entry point from target auxiliary vector. This avoids
2389 the need for symbols. Also, when debugging a stand-alone SPU
2390 executable, entry_point_address () will point to an SPU
2391 local-store address and is thus not usable as displaced stepping
2392 location. The auxiliary vector gets us the PowerPC-side entry
2393 point address instead. */
2394 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2395 throw_error (NOT_SUPPORTED_ERROR
,
2396 _("Cannot find AT_ENTRY auxiliary vector entry."));
2398 /* Make certain that the address points at real code, and not a
2399 function descriptor. */
2400 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2401 current_top_target ());
2403 /* Inferior calls also use the entry point as a breakpoint location.
2404 We don't want displaced stepping to interfere with those
2405 breakpoints, so leave space. */
2406 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2412 /* See linux-tdep.h. */
2414 displaced_step_prepare_status
2415 linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2416 CORE_ADDR
&displaced_pc
)
2418 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2420 if (!per_inferior
->disp_step_bufs
.has_value ())
2422 /* Figure out the location of the buffers. They are contiguous, starting
2423 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2424 CORE_ADDR disp_step_buf_addr
2425 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2426 int buf_len
= gdbarch_max_insn_length (arch
);
2428 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (arch
);
2429 gdb_assert (gdbarch_data
->num_disp_step_buffers
> 0);
2431 std::vector
<CORE_ADDR
> buffers
;
2432 for (int i
= 0; i
< gdbarch_data
->num_disp_step_buffers
; i
++)
2433 buffers
.push_back (disp_step_buf_addr
+ i
* buf_len
);
2435 per_inferior
->disp_step_bufs
.emplace (buffers
);
2438 return per_inferior
->disp_step_bufs
->prepare (thread
, displaced_pc
);
2441 /* See linux-tdep.h. */
2443 displaced_step_finish_status
2444 linux_displaced_step_finish (gdbarch
*arch
, thread_info
*thread
, gdb_signal sig
)
2446 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2448 gdb_assert (per_inferior
->disp_step_bufs
.has_value ());
2450 return per_inferior
->disp_step_bufs
->finish (arch
, thread
, sig
);
2453 /* See linux-tdep.h. */
2455 const displaced_step_copy_insn_closure
*
2456 linux_displaced_step_copy_insn_closure_by_addr (inferior
*inf
, CORE_ADDR addr
)
2458 linux_info
*per_inferior
= linux_inferior_data
.get (inf
);
2460 if (per_inferior
== nullptr
2461 || !per_inferior
->disp_step_bufs
.has_value ())
2464 return per_inferior
->disp_step_bufs
->copy_insn_closure_by_addr (addr
);
2467 /* See linux-tdep.h. */
2470 linux_displaced_step_restore_all_in_ptid (inferior
*parent_inf
, ptid_t ptid
)
2472 linux_info
*per_inferior
= linux_inferior_data
.get (parent_inf
);
2474 if (per_inferior
== nullptr
2475 || !per_inferior
->disp_step_bufs
.has_value ())
2478 per_inferior
->disp_step_bufs
->restore_in_ptid (ptid
);
2481 /* See linux-tdep.h. */
2484 linux_get_hwcap (struct target_ops
*target
)
2487 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2492 /* See linux-tdep.h. */
2495 linux_get_hwcap2 (struct target_ops
*target
)
2498 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2503 /* Display whether the gcore command is using the
2504 /proc/PID/coredump_filter file. */
2507 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2508 struct cmd_list_element
*c
, const char *value
)
2510 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2511 " corefiles is %s.\n"), value
);
2514 /* Display whether the gcore command is dumping mappings marked with
2515 the VM_DONTDUMP flag. */
2518 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2519 struct cmd_list_element
*c
, const char *value
)
2521 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2522 " flag is %s.\n"), value
);
2525 /* To be called from the various GDB_OSABI_LINUX handlers for the
2526 various GNU/Linux architectures and machine types.
2528 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2529 displaced stepping is not supported. */
2532 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
,
2533 int num_disp_step_buffers
)
2535 if (num_disp_step_buffers
> 0)
2537 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
2538 gdbarch_data
->num_disp_step_buffers
= num_disp_step_buffers
;
2540 set_gdbarch_displaced_step_prepare (gdbarch
,
2541 linux_displaced_step_prepare
);
2542 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
2543 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2544 (gdbarch
, linux_displaced_step_copy_insn_closure_by_addr
);
2545 set_gdbarch_displaced_step_restore_all_in_ptid
2546 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
2549 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2550 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2551 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2552 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2553 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2554 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2555 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2556 set_gdbarch_has_shared_address_space (gdbarch
,
2557 linux_has_shared_address_space
);
2558 set_gdbarch_gdb_signal_from_target (gdbarch
,
2559 linux_gdb_signal_from_target
);
2560 set_gdbarch_gdb_signal_to_target (gdbarch
,
2561 linux_gdb_signal_to_target
);
2562 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2563 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2564 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2565 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2568 void _initialize_linux_tdep ();
2570 _initialize_linux_tdep ()
2572 linux_gdbarch_data_handle
=
2573 gdbarch_data_register_pre_init (init_linux_gdbarch_data
);
2575 /* Observers used to invalidate the cache when needed. */
2576 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2577 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2578 gdb::observers::inferior_execd
.attach (invalidate_linux_cache_inf
);
2580 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2581 &use_coredump_filter
, _("\
2582 Set whether gcore should consider /proc/PID/coredump_filter."),
2584 Show whether gcore should consider /proc/PID/coredump_filter."),
2586 Use this command to set whether gcore should consider the contents\n\
2587 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2588 about this file, refer to the manpage of core(5)."),
2589 NULL
, show_use_coredump_filter
,
2590 &setlist
, &showlist
);
2592 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2593 &dump_excluded_mappings
, _("\
2594 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2596 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2598 Use this command to set whether gcore should dump mappings marked with the\n\
2599 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2600 more information about this file, refer to the manpage of proc(5) and core(5)."),
2601 NULL
, show_dump_excluded_mappings
,
2602 &setlist
, &showlist
);