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
,
1283 /* Default dump behavior of coredump_filter (0x33), according to
1284 Documentation/filesystems/proc.txt from the Linux kernel
1286 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1287 | COREFILTER_ANON_SHARED
1288 | COREFILTER_ELF_HEADERS
1289 | COREFILTER_HUGETLB_PRIVATE
);
1291 /* We need to know the real target PID to access /proc. */
1292 if (current_inferior ()->fake_pid_p
)
1295 pid
= current_inferior ()->pid
;
1297 if (use_coredump_filter
)
1299 std::string core_dump_filter_name
1300 = string_printf ("/proc/%d/coredump_filter", pid
);
1302 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1303 = target_fileio_read_stralloc (NULL
, core_dump_filter_name
.c_str ());
1305 if (coredumpfilterdata
!= NULL
)
1309 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1310 filterflags
= (enum filter_flag
) flags
;
1314 std::string maps_filename
= string_printf ("/proc/%d/smaps", pid
);
1316 gdb::unique_xmalloc_ptr
<char> data
1317 = target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1321 /* Older Linux kernels did not support /proc/PID/smaps. */
1322 maps_filename
= string_printf ("/proc/%d/maps", pid
);
1323 data
= target_fileio_read_stralloc (NULL
, maps_filename
.c_str ());
1330 line
= strtok_r (data
.get (), "\n", &t
);
1331 while (line
!= NULL
)
1333 ULONGEST addr
, endaddr
, offset
, inode
;
1334 const char *permissions
, *device
, *filename
;
1335 struct smaps_vmflags v
;
1336 size_t permissions_len
, device_len
;
1337 int read
, write
, exec
, priv
;
1338 int has_anonymous
= 0;
1339 int should_dump_p
= 0;
1343 memset (&v
, 0, sizeof (v
));
1344 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1345 &offset
, &device
, &device_len
, &inode
, &filename
);
1346 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1347 /* If the mapping is not anonymous, then we can consider it
1348 to be file-backed. These two states (anonymous or
1349 file-backed) seem to be exclusive, but they can actually
1350 coexist. For example, if a file-backed mapping has
1351 "Anonymous:" pages (see more below), then the Linux
1352 kernel will dump this mapping when the user specified
1353 that she only wants anonymous mappings in the corefile
1354 (*even* when she explicitly disabled the dumping of
1355 file-backed mappings). */
1356 mapping_file_p
= !mapping_anon_p
;
1358 /* Decode permissions. */
1359 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1360 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1361 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1362 /* 'private' here actually means VM_MAYSHARE, and not
1363 VM_SHARED. In order to know if a mapping is really
1364 private or not, we must check the flag "sh" in the
1365 VmFlags field. This is done by decode_vmflags. However,
1366 if we are using a Linux kernel released before the commit
1367 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1368 not have the VmFlags there. In this case, there is
1369 really no way to know if we are dealing with VM_SHARED,
1370 so we just assume that VM_MAYSHARE is enough. */
1371 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1373 /* Try to detect if region should be dumped by parsing smaps
1375 for (line
= strtok_r (NULL
, "\n", &t
);
1376 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1377 line
= strtok_r (NULL
, "\n", &t
))
1379 char keyword
[64 + 1];
1381 if (sscanf (line
, "%64s", keyword
) != 1)
1383 warning (_("Error parsing {s,}maps file '%s'"),
1384 maps_filename
.c_str ());
1388 if (strcmp (keyword
, "Anonymous:") == 0)
1390 /* Older Linux kernels did not support the
1391 "Anonymous:" counter. Check it here. */
1394 else if (strcmp (keyword
, "VmFlags:") == 0)
1395 decode_vmflags (line
, &v
);
1397 if (strcmp (keyword
, "AnonHugePages:") == 0
1398 || strcmp (keyword
, "Anonymous:") == 0)
1400 unsigned long number
;
1402 if (sscanf (line
, "%*s%lu", &number
) != 1)
1404 warning (_("Error parsing {s,}maps file '%s' number"),
1405 maps_filename
.c_str ());
1410 /* Even if we are dealing with a file-backed
1411 mapping, if it contains anonymous pages we
1412 consider it to be *also* an anonymous
1413 mapping, because this is what the Linux
1416 // Dump segments that have been written to.
1417 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1420 Note that if the mapping is already marked as
1421 file-backed (i.e., mapping_file_p is
1422 non-zero), then this is a special case, and
1423 this mapping will be dumped either when the
1424 user wants to dump file-backed *or* anonymous
1432 should_dump_p
= should_dump_mapping_p (filterflags
, &v
, priv
,
1435 filename
, addr
, offset
);
1438 /* Older Linux kernels did not support the "Anonymous:" counter.
1439 If it is missing, we can't be sure - dump all the pages. */
1443 /* Invoke the callback function to create the corefile segment. */
1445 func (addr
, endaddr
- addr
, offset
, inode
,
1446 read
, write
, exec
, 1, /* MODIFIED is true because we
1447 want to dump the mapping. */
1457 /* A structure for passing information through
1458 linux_find_memory_regions_full. */
1460 struct linux_find_memory_regions_data
1462 /* The original callback. */
1464 find_memory_region_ftype func
;
1466 /* The original datum. */
1471 /* A callback for linux_find_memory_regions that converts between the
1472 "full"-style callback and find_memory_region_ftype. */
1475 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1476 ULONGEST offset
, ULONGEST inode
,
1477 int read
, int write
, int exec
, int modified
,
1478 const char *filename
, void *arg
)
1480 struct linux_find_memory_regions_data
*data
1481 = (struct linux_find_memory_regions_data
*) arg
;
1483 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1486 /* A variant of linux_find_memory_regions_full that is suitable as the
1487 gdbarch find_memory_regions method. */
1490 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1491 find_memory_region_ftype func
, void *obfd
)
1493 struct linux_find_memory_regions_data data
;
1498 return linux_find_memory_regions_full (gdbarch
,
1500 linux_find_memory_regions_thunk
,
1504 /* This is used to pass information from
1505 linux_make_mappings_corefile_notes through
1506 linux_find_memory_regions_full. */
1508 struct linux_make_mappings_data
1510 /* Number of files mapped. */
1511 ULONGEST file_count
;
1513 /* The obstack for the main part of the data. */
1514 struct obstack
*data_obstack
;
1516 /* The filename obstack. */
1517 struct obstack
*filename_obstack
;
1519 /* The architecture's "long" type. */
1520 struct type
*long_type
;
1523 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1525 /* A callback for linux_find_memory_regions_full that updates the
1526 mappings data for linux_make_mappings_corefile_notes. */
1529 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1530 ULONGEST offset
, ULONGEST inode
,
1531 int read
, int write
, int exec
, int modified
,
1532 const char *filename
, void *data
)
1534 struct linux_make_mappings_data
*map_data
1535 = (struct linux_make_mappings_data
*) data
;
1536 gdb_byte buf
[sizeof (ULONGEST
)];
1538 if (*filename
== '\0' || inode
== 0)
1541 ++map_data
->file_count
;
1543 pack_long (buf
, map_data
->long_type
, vaddr
);
1544 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1545 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1546 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1547 pack_long (buf
, map_data
->long_type
, offset
);
1548 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1550 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1555 /* Write the file mapping data to the core file, if possible. OBFD is
1556 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1557 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1560 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1561 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1564 struct linux_make_mappings_data mapping_data
;
1565 struct type
*long_type
1566 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1567 gdb_byte buf
[sizeof (ULONGEST
)];
1569 auto_obstack data_obstack
, filename_obstack
;
1571 mapping_data
.file_count
= 0;
1572 mapping_data
.data_obstack
= &data_obstack
;
1573 mapping_data
.filename_obstack
= &filename_obstack
;
1574 mapping_data
.long_type
= long_type
;
1576 /* Reserve space for the count. */
1577 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1578 /* We always write the page size as 1 since we have no good way to
1579 determine the correct value. */
1580 pack_long (buf
, long_type
, 1);
1581 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1583 linux_find_memory_regions_full (gdbarch
,
1585 linux_make_mappings_callback
,
1588 if (mapping_data
.file_count
!= 0)
1590 /* Write the count to the obstack. */
1591 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1592 long_type
, mapping_data
.file_count
);
1594 /* Copy the filenames to the data obstack. */
1595 int size
= obstack_object_size (&filename_obstack
);
1596 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1599 note_data
.reset (elfcore_write_file_note (obfd
, note_data
.release (), note_size
,
1600 obstack_base (&data_obstack
),
1601 obstack_object_size (&data_obstack
)));
1605 /* Fetch the siginfo data for the specified thread, if it exists. If
1606 there is no data, or we could not read it, return an empty
1609 static gdb::byte_vector
1610 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1612 struct type
*siginfo_type
;
1615 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1616 return gdb::byte_vector ();
1618 scoped_restore_current_thread save_current_thread
;
1619 switch_to_thread (thread
);
1621 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1623 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1625 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1626 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1627 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1633 struct linux_corefile_thread_data
1635 linux_corefile_thread_data (struct gdbarch
*gdbarch
, bfd
*obfd
,
1636 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
1637 int *note_size
, gdb_signal stop_signal
)
1638 : gdbarch (gdbarch
), obfd (obfd
), note_data (note_data
),
1639 note_size (note_size
), stop_signal (stop_signal
)
1642 struct gdbarch
*gdbarch
;
1644 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
1646 enum gdb_signal stop_signal
;
1649 /* Records the thread's register state for the corefile note
1653 linux_corefile_thread (struct thread_info
*info
,
1654 struct linux_corefile_thread_data
*args
)
1656 gcore_elf_build_thread_register_notes (args
->gdbarch
, info
,
1658 args
->obfd
, &args
->note_data
,
1661 /* Don't return anything if we got no register information above,
1662 such a core file is useless. */
1663 if (args
->note_data
!= NULL
)
1665 gdb::byte_vector siginfo_data
1666 = linux_get_siginfo_data (info
, args
->gdbarch
);
1667 if (!siginfo_data
.empty ())
1668 args
->note_data
.reset (elfcore_write_note (args
->obfd
,
1669 args
->note_data
.release (),
1672 siginfo_data
.data (),
1673 siginfo_data
.size ()));
1677 /* Fill the PRPSINFO structure with information about the process being
1678 debugged. Returns 1 in case of success, 0 for failures. Please note that
1679 even if the structure cannot be entirely filled (e.g., GDB was unable to
1680 gather information about the process UID/GID), this function will still
1681 return 1 since some information was already recorded. It will only return
1682 0 iff nothing can be gathered. */
1685 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1687 /* The filename which we will use to obtain some info about the process.
1688 We will basically use this to store the `/proc/PID/FILENAME' file. */
1690 /* The basename of the executable. */
1691 const char *basename
;
1692 const char *infargs
;
1693 /* Temporary buffer. */
1695 /* The valid states of a process, according to the Linux kernel. */
1696 const char valid_states
[] = "RSDTZW";
1697 /* The program state. */
1698 const char *prog_state
;
1699 /* The state of the process. */
1701 /* The PID of the program which generated the corefile. */
1703 /* Process flags. */
1704 unsigned int pr_flag
;
1705 /* Process nice value. */
1707 /* The number of fields read by `sscanf'. */
1710 gdb_assert (p
!= NULL
);
1712 /* Obtaining PID and filename. */
1713 pid
= inferior_ptid
.pid ();
1714 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1715 /* The full name of the program which generated the corefile. */
1716 gdb::unique_xmalloc_ptr
<char> fname
1717 = target_fileio_read_stralloc (NULL
, filename
);
1719 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1721 /* No program name was read, so we won't be able to retrieve more
1722 information about the process. */
1726 memset (p
, 0, sizeof (*p
));
1728 /* Defining the PID. */
1731 /* Copying the program name. Only the basename matters. */
1732 basename
= lbasename (fname
.get ());
1733 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1734 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1736 infargs
= get_inferior_args ();
1738 /* The arguments of the program. */
1739 std::string psargs
= fname
.get ();
1740 if (infargs
!= NULL
)
1741 psargs
= psargs
+ " " + infargs
;
1743 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1744 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1746 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1747 /* The contents of `/proc/PID/stat'. */
1748 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1749 = target_fileio_read_stralloc (NULL
, filename
);
1750 char *proc_stat
= proc_stat_contents
.get ();
1752 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1754 /* Despite being unable to read more information about the
1755 process, we return 1 here because at least we have its
1756 command line, PID and arguments. */
1760 /* Ok, we have the stats. It's time to do a little parsing of the
1761 contents of the buffer, so that we end up reading what we want.
1763 The following parsing mechanism is strongly based on the
1764 information generated by the `fs/proc/array.c' file, present in
1765 the Linux kernel tree. More details about how the information is
1766 displayed can be obtained by seeing the manpage of proc(5),
1767 specifically under the entry of `/proc/[pid]/stat'. */
1769 /* Getting rid of the PID, since we already have it. */
1770 while (isdigit (*proc_stat
))
1773 proc_stat
= skip_spaces (proc_stat
);
1775 /* ps command also relies on no trailing fields ever contain ')'. */
1776 proc_stat
= strrchr (proc_stat
, ')');
1777 if (proc_stat
== NULL
)
1781 proc_stat
= skip_spaces (proc_stat
);
1783 n_fields
= sscanf (proc_stat
,
1784 "%c" /* Process state. */
1785 "%d%d%d" /* Parent PID, group ID, session ID. */
1786 "%*d%*d" /* tty_nr, tpgid (not used). */
1788 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1789 cmajflt (not used). */
1790 "%*s%*s%*s%*s" /* utime, stime, cutime,
1791 cstime (not used). */
1792 "%*s" /* Priority (not used). */
1795 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1801 /* Again, we couldn't read the complementary information about
1802 the process state. However, we already have minimal
1803 information, so we just return 1 here. */
1807 /* Filling the structure fields. */
1808 prog_state
= strchr (valid_states
, pr_sname
);
1809 if (prog_state
!= NULL
)
1810 p
->pr_state
= prog_state
- valid_states
;
1813 /* Zero means "Running". */
1817 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1818 p
->pr_zomb
= p
->pr_sname
== 'Z';
1819 p
->pr_nice
= pr_nice
;
1820 p
->pr_flag
= pr_flag
;
1822 /* Finally, obtaining the UID and GID. For that, we read and parse the
1823 contents of the `/proc/PID/status' file. */
1824 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1825 /* The contents of `/proc/PID/status'. */
1826 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1827 = target_fileio_read_stralloc (NULL
, filename
);
1828 char *proc_status
= proc_status_contents
.get ();
1830 if (proc_status
== NULL
|| *proc_status
== '\0')
1832 /* Returning 1 since we already have a bunch of information. */
1836 /* Extracting the UID. */
1837 tmpstr
= strstr (proc_status
, "Uid:");
1840 /* Advancing the pointer to the beginning of the UID. */
1841 tmpstr
+= sizeof ("Uid:");
1842 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1845 if (isdigit (*tmpstr
))
1846 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1849 /* Extracting the GID. */
1850 tmpstr
= strstr (proc_status
, "Gid:");
1853 /* Advancing the pointer to the beginning of the GID. */
1854 tmpstr
+= sizeof ("Gid:");
1855 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1858 if (isdigit (*tmpstr
))
1859 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1865 /* Build the note section for a corefile, and return it in a malloc
1868 static gdb::unique_xmalloc_ptr
<char>
1869 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1871 struct elf_internal_linux_prpsinfo prpsinfo
;
1872 gdb::unique_xmalloc_ptr
<char> note_data
;
1874 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1877 if (linux_fill_prpsinfo (&prpsinfo
))
1879 if (gdbarch_ptr_bit (gdbarch
) == 64)
1880 note_data
.reset (elfcore_write_linux_prpsinfo64 (obfd
,
1881 note_data
.release (),
1882 note_size
, &prpsinfo
));
1884 note_data
.reset (elfcore_write_linux_prpsinfo32 (obfd
,
1885 note_data
.release (),
1886 note_size
, &prpsinfo
));
1889 /* Thread register information. */
1892 update_thread_list ();
1894 catch (const gdb_exception_error
&e
)
1896 exception_print (gdb_stderr
, e
);
1899 /* Like the kernel, prefer dumping the signalled thread first.
1900 "First thread" is what tools use to infer the signalled
1902 thread_info
*signalled_thr
= gcore_find_signalled_thread ();
1903 gdb_signal stop_signal
;
1904 if (signalled_thr
!= nullptr)
1905 stop_signal
= signalled_thr
->suspend
.stop_signal
;
1907 stop_signal
= GDB_SIGNAL_0
;
1909 linux_corefile_thread_data
thread_args (gdbarch
, obfd
, note_data
, note_size
,
1912 if (signalled_thr
!= nullptr)
1913 linux_corefile_thread (signalled_thr
, &thread_args
);
1914 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1916 if (thr
== signalled_thr
)
1919 linux_corefile_thread (thr
, &thread_args
);
1925 /* Auxillary vector. */
1926 gdb::optional
<gdb::byte_vector
> auxv
=
1927 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
1928 if (auxv
&& !auxv
->empty ())
1930 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
1931 note_size
, "CORE", NT_AUXV
,
1932 auxv
->data (), auxv
->size ()));
1938 /* File mappings. */
1939 linux_make_mappings_corefile_notes (gdbarch
, obfd
, note_data
, note_size
);
1941 /* Target description. */
1942 gcore_elf_make_tdesc_note (obfd
, ¬e_data
, note_size
);
1947 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1948 gdbarch.h. This function is not static because it is exported to
1949 other -tdep files. */
1952 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1957 return GDB_SIGNAL_0
;
1960 return GDB_SIGNAL_HUP
;
1963 return GDB_SIGNAL_INT
;
1966 return GDB_SIGNAL_QUIT
;
1969 return GDB_SIGNAL_ILL
;
1972 return GDB_SIGNAL_TRAP
;
1975 return GDB_SIGNAL_ABRT
;
1978 return GDB_SIGNAL_BUS
;
1981 return GDB_SIGNAL_FPE
;
1984 return GDB_SIGNAL_KILL
;
1987 return GDB_SIGNAL_USR1
;
1990 return GDB_SIGNAL_SEGV
;
1993 return GDB_SIGNAL_USR2
;
1996 return GDB_SIGNAL_PIPE
;
1999 return GDB_SIGNAL_ALRM
;
2002 return GDB_SIGNAL_TERM
;
2005 return GDB_SIGNAL_CHLD
;
2008 return GDB_SIGNAL_CONT
;
2011 return GDB_SIGNAL_STOP
;
2014 return GDB_SIGNAL_TSTP
;
2017 return GDB_SIGNAL_TTIN
;
2020 return GDB_SIGNAL_TTOU
;
2023 return GDB_SIGNAL_URG
;
2026 return GDB_SIGNAL_XCPU
;
2029 return GDB_SIGNAL_XFSZ
;
2031 case LINUX_SIGVTALRM
:
2032 return GDB_SIGNAL_VTALRM
;
2035 return GDB_SIGNAL_PROF
;
2037 case LINUX_SIGWINCH
:
2038 return GDB_SIGNAL_WINCH
;
2040 /* No way to differentiate between SIGIO and SIGPOLL.
2041 Therefore, we just handle the first one. */
2043 return GDB_SIGNAL_IO
;
2046 return GDB_SIGNAL_PWR
;
2049 return GDB_SIGNAL_SYS
;
2051 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2052 therefore we have to handle them here. */
2053 case LINUX_SIGRTMIN
:
2054 return GDB_SIGNAL_REALTIME_32
;
2056 case LINUX_SIGRTMAX
:
2057 return GDB_SIGNAL_REALTIME_64
;
2060 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2062 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2064 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2067 return GDB_SIGNAL_UNKNOWN
;
2070 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2071 gdbarch.h. This function is not static because it is exported to
2072 other -tdep files. */
2075 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2076 enum gdb_signal signal
)
2083 case GDB_SIGNAL_HUP
:
2084 return LINUX_SIGHUP
;
2086 case GDB_SIGNAL_INT
:
2087 return LINUX_SIGINT
;
2089 case GDB_SIGNAL_QUIT
:
2090 return LINUX_SIGQUIT
;
2092 case GDB_SIGNAL_ILL
:
2093 return LINUX_SIGILL
;
2095 case GDB_SIGNAL_TRAP
:
2096 return LINUX_SIGTRAP
;
2098 case GDB_SIGNAL_ABRT
:
2099 return LINUX_SIGABRT
;
2101 case GDB_SIGNAL_FPE
:
2102 return LINUX_SIGFPE
;
2104 case GDB_SIGNAL_KILL
:
2105 return LINUX_SIGKILL
;
2107 case GDB_SIGNAL_BUS
:
2108 return LINUX_SIGBUS
;
2110 case GDB_SIGNAL_SEGV
:
2111 return LINUX_SIGSEGV
;
2113 case GDB_SIGNAL_SYS
:
2114 return LINUX_SIGSYS
;
2116 case GDB_SIGNAL_PIPE
:
2117 return LINUX_SIGPIPE
;
2119 case GDB_SIGNAL_ALRM
:
2120 return LINUX_SIGALRM
;
2122 case GDB_SIGNAL_TERM
:
2123 return LINUX_SIGTERM
;
2125 case GDB_SIGNAL_URG
:
2126 return LINUX_SIGURG
;
2128 case GDB_SIGNAL_STOP
:
2129 return LINUX_SIGSTOP
;
2131 case GDB_SIGNAL_TSTP
:
2132 return LINUX_SIGTSTP
;
2134 case GDB_SIGNAL_CONT
:
2135 return LINUX_SIGCONT
;
2137 case GDB_SIGNAL_CHLD
:
2138 return LINUX_SIGCHLD
;
2140 case GDB_SIGNAL_TTIN
:
2141 return LINUX_SIGTTIN
;
2143 case GDB_SIGNAL_TTOU
:
2144 return LINUX_SIGTTOU
;
2149 case GDB_SIGNAL_XCPU
:
2150 return LINUX_SIGXCPU
;
2152 case GDB_SIGNAL_XFSZ
:
2153 return LINUX_SIGXFSZ
;
2155 case GDB_SIGNAL_VTALRM
:
2156 return LINUX_SIGVTALRM
;
2158 case GDB_SIGNAL_PROF
:
2159 return LINUX_SIGPROF
;
2161 case GDB_SIGNAL_WINCH
:
2162 return LINUX_SIGWINCH
;
2164 case GDB_SIGNAL_USR1
:
2165 return LINUX_SIGUSR1
;
2167 case GDB_SIGNAL_USR2
:
2168 return LINUX_SIGUSR2
;
2170 case GDB_SIGNAL_PWR
:
2171 return LINUX_SIGPWR
;
2173 case GDB_SIGNAL_POLL
:
2174 return LINUX_SIGPOLL
;
2176 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2177 therefore we have to handle it here. */
2178 case GDB_SIGNAL_REALTIME_32
:
2179 return LINUX_SIGRTMIN
;
2181 /* Same comment applies to _64. */
2182 case GDB_SIGNAL_REALTIME_64
:
2183 return LINUX_SIGRTMAX
;
2186 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2187 if (signal
>= GDB_SIGNAL_REALTIME_33
2188 && signal
<= GDB_SIGNAL_REALTIME_63
)
2190 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2192 return LINUX_SIGRTMIN
+ 1 + offset
;
2198 /* Helper for linux_vsyscall_range that does the real work of finding
2199 the vsyscall's address range. */
2202 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2207 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2210 /* It doesn't make sense to access the host's /proc when debugging a
2211 core file. Instead, look for the PT_LOAD segment that matches
2213 if (!target_has_execution ())
2218 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2219 if (phdrs_size
== -1)
2222 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2223 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2224 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2225 if (num_phdrs
== -1)
2228 for (i
= 0; i
< num_phdrs
; i
++)
2229 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2230 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2232 range
->length
= phdrs
.get ()[i
].p_memsz
;
2239 /* We need to know the real target PID to access /proc. */
2240 if (current_inferior ()->fake_pid_p
)
2243 pid
= current_inferior ()->pid
;
2245 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2246 reading /proc/PID/maps (2). The later identifies thread stacks
2247 in the output, which requires scanning every thread in the thread
2248 group to check whether a VMA is actually a thread's stack. With
2249 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2250 a few thousand threads, (1) takes a few miliseconds, while (2)
2251 takes several seconds. Also note that "smaps", what we read for
2252 determining core dump mappings, is even slower than "maps". */
2253 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2254 gdb::unique_xmalloc_ptr
<char> data
2255 = target_fileio_read_stralloc (NULL
, filename
);
2259 char *saveptr
= NULL
;
2261 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2263 line
= strtok_r (NULL
, "\n", &saveptr
))
2265 ULONGEST addr
, endaddr
;
2266 const char *p
= line
;
2268 addr
= strtoulst (p
, &p
, 16);
2269 if (addr
== range
->start
)
2273 endaddr
= strtoulst (p
, &p
, 16);
2274 range
->length
= endaddr
- addr
;
2280 warning (_("unable to open /proc file '%s'"), filename
);
2285 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2286 caching, and defers the real work to linux_vsyscall_range_raw. */
2289 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2291 struct linux_info
*info
= get_linux_inferior_data (current_inferior ());
2293 if (info
->vsyscall_range_p
== 0)
2295 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2296 info
->vsyscall_range_p
= 1;
2298 info
->vsyscall_range_p
= -1;
2301 if (info
->vsyscall_range_p
< 0)
2304 *range
= info
->vsyscall_range
;
2308 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2309 definitions would be dependent on compilation host. */
2310 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2311 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2313 /* See gdbarch.sh 'infcall_mmap'. */
2316 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2318 struct objfile
*objf
;
2319 /* Do there still exist any Linux systems without "mmap64"?
2320 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2321 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2322 struct value
*addr_val
;
2323 struct gdbarch
*gdbarch
= objf
->arch ();
2327 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2329 struct value
*arg
[ARG_LAST
];
2331 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2333 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2334 arg
[ARG_LENGTH
] = value_from_ulongest
2335 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2336 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2337 | GDB_MMAP_PROT_EXEC
))
2339 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2340 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2341 GDB_MMAP_MAP_PRIVATE
2342 | GDB_MMAP_MAP_ANONYMOUS
);
2343 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2344 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2346 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2347 retval
= value_as_address (addr_val
);
2348 if (retval
== (CORE_ADDR
) -1)
2349 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2354 /* See gdbarch.sh 'infcall_munmap'. */
2357 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2359 struct objfile
*objf
;
2360 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2361 struct value
*retval_val
;
2362 struct gdbarch
*gdbarch
= objf
->arch ();
2366 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2368 struct value
*arg
[ARG_LAST
];
2370 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2372 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2373 arg
[ARG_LENGTH
] = value_from_ulongest
2374 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2375 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2376 retval
= value_as_long (retval_val
);
2378 warning (_("Failed inferior munmap call at %s for %s bytes, "
2379 "errno is changed."),
2380 hex_string (addr
), pulongest (size
));
2383 /* See linux-tdep.h. */
2386 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2391 /* Determine entry point from target auxiliary vector. This avoids
2392 the need for symbols. Also, when debugging a stand-alone SPU
2393 executable, entry_point_address () will point to an SPU
2394 local-store address and is thus not usable as displaced stepping
2395 location. The auxiliary vector gets us the PowerPC-side entry
2396 point address instead. */
2397 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2398 throw_error (NOT_SUPPORTED_ERROR
,
2399 _("Cannot find AT_ENTRY auxiliary vector entry."));
2401 /* Make certain that the address points at real code, and not a
2402 function descriptor. */
2403 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2404 current_top_target ());
2406 /* Inferior calls also use the entry point as a breakpoint location.
2407 We don't want displaced stepping to interfere with those
2408 breakpoints, so leave space. */
2409 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2415 /* See linux-tdep.h. */
2417 displaced_step_prepare_status
2418 linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2419 CORE_ADDR
&displaced_pc
)
2421 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2423 if (!per_inferior
->disp_step_bufs
.has_value ())
2425 /* Figure out the location of the buffers. They are contiguous, starting
2426 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2427 CORE_ADDR disp_step_buf_addr
2428 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2429 int buf_len
= gdbarch_max_insn_length (arch
);
2431 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (arch
);
2432 gdb_assert (gdbarch_data
->num_disp_step_buffers
> 0);
2434 std::vector
<CORE_ADDR
> buffers
;
2435 for (int i
= 0; i
< gdbarch_data
->num_disp_step_buffers
; i
++)
2436 buffers
.push_back (disp_step_buf_addr
+ i
* buf_len
);
2438 per_inferior
->disp_step_bufs
.emplace (buffers
);
2441 return per_inferior
->disp_step_bufs
->prepare (thread
, displaced_pc
);
2444 /* See linux-tdep.h. */
2446 displaced_step_finish_status
2447 linux_displaced_step_finish (gdbarch
*arch
, thread_info
*thread
, gdb_signal sig
)
2449 linux_info
*per_inferior
= get_linux_inferior_data (thread
->inf
);
2451 gdb_assert (per_inferior
->disp_step_bufs
.has_value ());
2453 return per_inferior
->disp_step_bufs
->finish (arch
, thread
, sig
);
2456 /* See linux-tdep.h. */
2458 const displaced_step_copy_insn_closure
*
2459 linux_displaced_step_copy_insn_closure_by_addr (inferior
*inf
, CORE_ADDR addr
)
2461 linux_info
*per_inferior
= linux_inferior_data
.get (inf
);
2463 if (per_inferior
== nullptr
2464 || !per_inferior
->disp_step_bufs
.has_value ())
2467 return per_inferior
->disp_step_bufs
->copy_insn_closure_by_addr (addr
);
2470 /* See linux-tdep.h. */
2473 linux_displaced_step_restore_all_in_ptid (inferior
*parent_inf
, ptid_t ptid
)
2475 linux_info
*per_inferior
= linux_inferior_data
.get (parent_inf
);
2477 if (per_inferior
== nullptr
2478 || !per_inferior
->disp_step_bufs
.has_value ())
2481 per_inferior
->disp_step_bufs
->restore_in_ptid (ptid
);
2484 /* See linux-tdep.h. */
2487 linux_get_hwcap (struct target_ops
*target
)
2490 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2495 /* See linux-tdep.h. */
2498 linux_get_hwcap2 (struct target_ops
*target
)
2501 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2506 /* Display whether the gcore command is using the
2507 /proc/PID/coredump_filter file. */
2510 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2511 struct cmd_list_element
*c
, const char *value
)
2513 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2514 " corefiles is %s.\n"), value
);
2517 /* Display whether the gcore command is dumping mappings marked with
2518 the VM_DONTDUMP flag. */
2521 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2522 struct cmd_list_element
*c
, const char *value
)
2524 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2525 " flag is %s.\n"), value
);
2528 /* To be called from the various GDB_OSABI_LINUX handlers for the
2529 various GNU/Linux architectures and machine types.
2531 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2532 displaced stepping is not supported. */
2535 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
,
2536 int num_disp_step_buffers
)
2538 if (num_disp_step_buffers
> 0)
2540 linux_gdbarch_data
*gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
2541 gdbarch_data
->num_disp_step_buffers
= num_disp_step_buffers
;
2543 set_gdbarch_displaced_step_prepare (gdbarch
,
2544 linux_displaced_step_prepare
);
2545 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
2546 set_gdbarch_displaced_step_copy_insn_closure_by_addr
2547 (gdbarch
, linux_displaced_step_copy_insn_closure_by_addr
);
2548 set_gdbarch_displaced_step_restore_all_in_ptid
2549 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
2552 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2553 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2554 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2555 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2556 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2557 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2558 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2559 set_gdbarch_has_shared_address_space (gdbarch
,
2560 linux_has_shared_address_space
);
2561 set_gdbarch_gdb_signal_from_target (gdbarch
,
2562 linux_gdb_signal_from_target
);
2563 set_gdbarch_gdb_signal_to_target (gdbarch
,
2564 linux_gdb_signal_to_target
);
2565 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2566 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2567 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2568 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2571 void _initialize_linux_tdep ();
2573 _initialize_linux_tdep ()
2575 linux_gdbarch_data_handle
=
2576 gdbarch_data_register_pre_init (init_linux_gdbarch_data
);
2578 /* Observers used to invalidate the cache when needed. */
2579 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2580 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2581 gdb::observers::inferior_execd
.attach (invalidate_linux_cache_inf
);
2583 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2584 &use_coredump_filter
, _("\
2585 Set whether gcore should consider /proc/PID/coredump_filter."),
2587 Show whether gcore should consider /proc/PID/coredump_filter."),
2589 Use this command to set whether gcore should consider the contents\n\
2590 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2591 about this file, refer to the manpage of core(5)."),
2592 NULL
, show_use_coredump_filter
,
2593 &setlist
, &showlist
);
2595 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2596 &dump_excluded_mappings
, _("\
2597 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2599 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2601 Use this command to set whether gcore should dump mappings marked with the\n\
2602 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2603 more information about this file, refer to the manpage of proc(5) and core(5)."),
2604 NULL
, show_dump_excluded_mappings
,
2605 &setlist
, &showlist
);