1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2020 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"
45 /* This enum represents the values that the user can choose when
46 informing the Linux kernel about which memory mappings will be
47 dumped in a corefile. They are described in the file
48 Documentation/filesystems/proc.txt, inside the Linux kernel
53 COREFILTER_ANON_PRIVATE
= 1 << 0,
54 COREFILTER_ANON_SHARED
= 1 << 1,
55 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
56 COREFILTER_MAPPED_SHARED
= 1 << 3,
57 COREFILTER_ELF_HEADERS
= 1 << 4,
58 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
59 COREFILTER_HUGETLB_SHARED
= 1 << 6,
61 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
63 /* This struct is used to map flags found in the "VmFlags:" field (in
64 the /proc/<PID>/smaps file). */
68 /* Zero if this structure has not been initialized yet. It
69 probably means that the Linux kernel being used does not emit
70 the "VmFlags:" field on "/proc/PID/smaps". */
72 unsigned int initialized_p
: 1;
74 /* Memory mapped I/O area (VM_IO, "io"). */
76 unsigned int io_page
: 1;
78 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
80 unsigned int uses_huge_tlb
: 1;
82 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
84 unsigned int exclude_coredump
: 1;
86 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
88 unsigned int shared_mapping
: 1;
91 /* Whether to take the /proc/PID/coredump_filter into account when
92 generating a corefile. */
94 static bool use_coredump_filter
= true;
96 /* Whether the value of smaps_vmflags->exclude_coredump should be
97 ignored, including mappings marked with the VM_DONTDUMP flag in
99 static bool dump_excluded_mappings
= false;
101 /* This enum represents the signals' numbers on a generic architecture
102 running the Linux kernel. The definition of "generic" comes from
103 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
104 tree, which is the "de facto" implementation of signal numbers to
105 be used by new architecture ports.
107 For those architectures which have differences between the generic
108 standard (e.g., Alpha), we define the different signals (and *only*
109 those) in the specific target-dependent file (e.g.,
110 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
111 tdep file for more information.
113 ARM deserves a special mention here. On the file
114 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
115 (and ARM-only) signal, which is SIGSWI, with the same number as
116 SIGRTMIN. This signal is used only for a very specific target,
117 called ArthurOS (from RISCOS). Therefore, we do not handle it on
118 the ARM-tdep file, and we can safely use the generic signal handler
119 here for ARM targets.
121 As stated above, this enum is derived from
122 <include/uapi/asm-generic/signal.h>, from the Linux kernel
143 LINUX_SIGSTKFLT
= 16,
153 LINUX_SIGVTALRM
= 26,
157 LINUX_SIGPOLL
= LINUX_SIGIO
,
160 LINUX_SIGUNUSED
= 31,
166 static struct gdbarch_data
*linux_gdbarch_data_handle
;
168 struct linux_gdbarch_data
170 struct type
*siginfo_type
;
174 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
176 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
179 static struct linux_gdbarch_data
*
180 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
182 return ((struct linux_gdbarch_data
*)
183 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
186 /* Linux-specific cached data. This is used by GDB for caching
187 purposes for each inferior. This helps reduce the overhead of
188 transfering data from a remote target to the local host. */
191 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
192 if VSYSCALL_RANGE_P is positive. This is cached because getting
193 at this info requires an auxv lookup (which is itself cached),
194 and looking through the inferior's mappings (which change
195 throughout execution and therefore cannot be cached). */
196 struct mem_range vsyscall_range
{};
198 /* Zero if we haven't tried looking up the vsyscall's range before
199 yet. Positive if we tried looking it up, and found it. Negative
200 if we tried looking it up but failed. */
201 int vsyscall_range_p
= 0;
204 /* Per-inferior data key. */
205 static const struct inferior_key
<linux_info
> linux_inferior_data
;
207 /* Frees whatever allocated space there is to be freed and sets INF's
208 linux cache data pointer to NULL. */
211 invalidate_linux_cache_inf (struct inferior
*inf
)
213 linux_inferior_data
.clear (inf
);
216 /* Fetch the linux cache info for INF. This function always returns a
217 valid INFO pointer. */
219 static struct linux_info
*
220 get_linux_inferior_data (void)
222 struct linux_info
*info
;
223 struct inferior
*inf
= current_inferior ();
225 info
= linux_inferior_data
.get (inf
);
227 info
= linux_inferior_data
.emplace (inf
);
232 /* See linux-tdep.h. */
235 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
236 linux_siginfo_extra_fields extra_fields
)
238 struct linux_gdbarch_data
*linux_gdbarch_data
;
239 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
240 struct type
*uid_type
, *pid_type
;
241 struct type
*sigval_type
, *clock_type
;
242 struct type
*siginfo_type
, *sifields_type
;
245 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
246 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
247 return linux_gdbarch_data
->siginfo_type
;
249 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
251 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
253 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
255 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
257 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
260 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
261 sigval_type
->set_name (xstrdup ("sigval_t"));
262 append_composite_type_field (sigval_type
, "sival_int", int_type
);
263 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
266 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
267 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
268 TYPE_TARGET_TYPE (pid_type
) = int_type
;
269 TYPE_TARGET_STUB (pid_type
) = 1;
272 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
273 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
274 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
275 TYPE_TARGET_STUB (uid_type
) = 1;
278 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
279 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
281 TYPE_TARGET_TYPE (clock_type
) = long_type
;
282 TYPE_TARGET_STUB (clock_type
) = 1;
285 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
288 const int si_max_size
= 128;
290 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
293 if (gdbarch_ptr_bit (gdbarch
) == 64)
294 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
296 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
297 append_composite_type_field (sifields_type
, "_pad",
298 init_vector_type (int_type
, si_pad_size
));
302 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
303 append_composite_type_field (type
, "si_pid", pid_type
);
304 append_composite_type_field (type
, "si_uid", uid_type
);
305 append_composite_type_field (sifields_type
, "_kill", type
);
308 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
309 append_composite_type_field (type
, "si_tid", int_type
);
310 append_composite_type_field (type
, "si_overrun", int_type
);
311 append_composite_type_field (type
, "si_sigval", sigval_type
);
312 append_composite_type_field (sifields_type
, "_timer", type
);
315 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
316 append_composite_type_field (type
, "si_pid", pid_type
);
317 append_composite_type_field (type
, "si_uid", uid_type
);
318 append_composite_type_field (type
, "si_sigval", sigval_type
);
319 append_composite_type_field (sifields_type
, "_rt", type
);
322 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
323 append_composite_type_field (type
, "si_pid", pid_type
);
324 append_composite_type_field (type
, "si_uid", uid_type
);
325 append_composite_type_field (type
, "si_status", int_type
);
326 append_composite_type_field (type
, "si_utime", clock_type
);
327 append_composite_type_field (type
, "si_stime", clock_type
);
328 append_composite_type_field (sifields_type
, "_sigchld", type
);
331 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
332 append_composite_type_field (type
, "si_addr", void_ptr_type
);
334 /* Additional bound fields for _sigfault in case they were requested. */
335 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
337 struct type
*sigfault_bnd_fields
;
339 append_composite_type_field (type
, "_addr_lsb", short_type
);
340 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
341 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
342 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
343 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
345 append_composite_type_field (sifields_type
, "_sigfault", type
);
348 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
349 append_composite_type_field (type
, "si_band", long_type
);
350 append_composite_type_field (type
, "si_fd", int_type
);
351 append_composite_type_field (sifields_type
, "_sigpoll", type
);
354 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
355 siginfo_type
->set_name (xstrdup ("siginfo"));
356 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
357 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
358 append_composite_type_field (siginfo_type
, "si_code", int_type
);
359 append_composite_type_field_aligned (siginfo_type
,
360 "_sifields", sifields_type
,
361 TYPE_LENGTH (long_type
));
363 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
368 /* This function is suitable for architectures that don't
369 extend/override the standard siginfo structure. */
372 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
374 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
377 /* Return true if the target is running on uClinux instead of normal
381 linux_is_uclinux (void)
385 return (target_auxv_search (current_top_target (), AT_NULL
, &dummy
) > 0
386 && target_auxv_search (current_top_target (), AT_PAGESZ
, &dummy
) == 0);
390 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
392 return linux_is_uclinux ();
395 /* This is how we want PTIDs from core files to be printed. */
398 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
400 if (ptid
.lwp () != 0)
401 return string_printf ("LWP %ld", ptid
.lwp ());
403 return normal_pid_to_str (ptid
);
406 /* Service function for corefiles and info proc. */
409 read_mapping (const char *line
,
410 ULONGEST
*addr
, ULONGEST
*endaddr
,
411 const char **permissions
, size_t *permissions_len
,
413 const char **device
, size_t *device_len
,
415 const char **filename
)
417 const char *p
= line
;
419 *addr
= strtoulst (p
, &p
, 16);
422 *endaddr
= strtoulst (p
, &p
, 16);
426 while (*p
&& !isspace (*p
))
428 *permissions_len
= p
- *permissions
;
430 *offset
= strtoulst (p
, &p
, 16);
434 while (*p
&& !isspace (*p
))
436 *device_len
= p
- *device
;
438 *inode
= strtoulst (p
, &p
, 10);
444 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
446 This function was based on the documentation found on
447 <Documentation/filesystems/proc.txt>, on the Linux kernel.
449 Linux kernels before commit
450 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
454 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
456 char *saveptr
= NULL
;
459 v
->initialized_p
= 1;
460 p
= skip_to_space (p
);
463 for (s
= strtok_r (p
, " ", &saveptr
);
465 s
= strtok_r (NULL
, " ", &saveptr
))
467 if (strcmp (s
, "io") == 0)
469 else if (strcmp (s
, "ht") == 0)
470 v
->uses_huge_tlb
= 1;
471 else if (strcmp (s
, "dd") == 0)
472 v
->exclude_coredump
= 1;
473 else if (strcmp (s
, "sh") == 0)
474 v
->shared_mapping
= 1;
478 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
479 they're initialized lazily. */
481 struct mapping_regexes
483 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
484 string in the end). We know for sure, based on the Linux kernel
485 code, that memory mappings whose associated filename is
486 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
487 compiled_regex dev_zero
488 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
489 _("Could not compile regex to match /dev/zero filename")};
491 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
492 string in the end). These filenames refer to shared memory
493 (shmem), and memory mappings associated with them are
494 MAP_ANONYMOUS as well. */
495 compiled_regex shmem_file
496 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
497 _("Could not compile regex to match shmem filenames")};
499 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
500 0' code, which is responsible to decide if it is dealing with a
501 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
502 FILE_DELETED matches, it does not necessarily mean that we are
503 dealing with an anonymous shared mapping. However, there is no
504 easy way to detect this currently, so this is the best
505 approximation we have.
507 As a result, GDB will dump readonly pages of deleted executables
508 when using the default value of coredump_filter (0x33), while the
509 Linux kernel will not dump those pages. But we can live with
511 compiled_regex file_deleted
512 {" (deleted)$", REG_NOSUB
,
513 _("Could not compile regex to match '<file> (deleted)'")};
516 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
518 FILENAME is the name of the file present in the first line of the
519 memory mapping, in the "/proc/PID/smaps" output. For example, if
522 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
524 Then FILENAME will be "/path/to/file". */
527 mapping_is_anonymous_p (const char *filename
)
529 static gdb::optional
<mapping_regexes
> regexes
;
530 static int init_regex_p
= 0;
534 /* Let's be pessimistic and assume there will be an error while
535 compiling the regex'es. */
540 /* If we reached this point, then everything succeeded. */
544 if (init_regex_p
== -1)
546 const char deleted
[] = " (deleted)";
547 size_t del_len
= sizeof (deleted
) - 1;
548 size_t filename_len
= strlen (filename
);
550 /* There was an error while compiling the regex'es above. In
551 order to try to give some reliable information to the caller,
552 we just try to find the string " (deleted)" in the filename.
553 If we managed to find it, then we assume the mapping is
555 return (filename_len
>= del_len
556 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
559 if (*filename
== '\0'
560 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
561 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
562 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
568 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
569 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
570 be dumped, or greater than 0 if it should.
572 In a nutshell, this is the logic that we follow in order to decide
573 if a mapping should be dumped or not.
575 - If the mapping is associated to a file whose name ends with
576 " (deleted)", or if the file is "/dev/zero", or if it is
577 "/SYSV%08x" (shared memory), or if there is no file associated
578 with it, or if the AnonHugePages: or the Anonymous: fields in the
579 /proc/PID/smaps have contents, then GDB considers this mapping to
580 be anonymous. Otherwise, GDB considers this mapping to be a
581 file-backed mapping (because there will be a file associated with
584 It is worth mentioning that, from all those checks described
585 above, the most fragile is the one to see if the file name ends
586 with " (deleted)". This does not necessarily mean that the
587 mapping is anonymous, because the deleted file associated with
588 the mapping may have been a hard link to another file, for
589 example. The Linux kernel checks to see if "i_nlink == 0", but
590 GDB cannot easily (and normally) do this check (iff running as
591 root, it could find the mapping in /proc/PID/map_files/ and
592 determine whether there still are other hard links to the
593 inode/file). Therefore, we made a compromise here, and we assume
594 that if the file name ends with " (deleted)", then the mapping is
595 indeed anonymous. FWIW, this is something the Linux kernel could
596 do better: expose this information in a more direct way.
598 - If we see the flag "sh" in the "VmFlags:" field (in
599 /proc/PID/smaps), then certainly the memory mapping is shared
600 (VM_SHARED). If we have access to the VmFlags, and we don't see
601 the "sh" there, then certainly the mapping is private. However,
602 Linux kernels before commit
603 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
604 "VmFlags:" field; in that case, we use another heuristic: if we
605 see 'p' in the permission flags, then we assume that the mapping
606 is private, even though the presence of the 's' flag there would
607 mean VM_MAYSHARE, which means the mapping could still be private.
608 This should work OK enough, however.
610 - Even if, at the end, we decided that we should not dump the
611 mapping, we still have to check if it is something like an ELF
612 header (of a DSO or an executable, for example). If it is, and
613 if the user is interested in dump it, then we should dump it. */
616 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
617 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
618 const char *filename
, ULONGEST addr
, ULONGEST offset
)
620 /* Initially, we trust in what we received from our caller. This
621 value may not be very precise (i.e., it was probably gathered
622 from the permission line in the /proc/PID/smaps list, which
623 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
624 what we have until we take a look at the "VmFlags:" field
625 (assuming that the version of the Linux kernel being used
626 supports it, of course). */
627 int private_p
= maybe_private_p
;
630 /* We always dump vDSO and vsyscall mappings, because it's likely that
631 there'll be no file to read the contents from at core load time.
632 The kernel does the same. */
633 if (strcmp ("[vdso]", filename
) == 0
634 || strcmp ("[vsyscall]", filename
) == 0)
637 if (v
->initialized_p
)
639 /* We never dump I/O mappings. */
643 /* Check if we should exclude this mapping. */
644 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
647 /* Update our notion of whether this mapping is shared or
648 private based on a trustworthy value. */
649 private_p
= !v
->shared_mapping
;
651 /* HugeTLB checking. */
652 if (v
->uses_huge_tlb
)
654 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
655 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
664 if (mapping_anon_p
&& mapping_file_p
)
666 /* This is a special situation. It can happen when we see a
667 mapping that is file-backed, but that contains anonymous
669 dump_p
= ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
670 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
672 else if (mapping_anon_p
)
673 dump_p
= (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
675 dump_p
= (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
679 if (mapping_anon_p
&& mapping_file_p
)
681 /* This is a special situation. It can happen when we see a
682 mapping that is file-backed, but that contains anonymous
684 dump_p
= ((filterflags
& COREFILTER_ANON_SHARED
) != 0
685 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
687 else if (mapping_anon_p
)
688 dump_p
= (filterflags
& COREFILTER_ANON_SHARED
) != 0;
690 dump_p
= (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
693 /* Even if we decided that we shouldn't dump this mapping, we still
694 have to check whether (a) the user wants us to dump mappings
695 containing an ELF header, and (b) the mapping in question
696 contains an ELF header. If (a) and (b) are true, then we should
699 A mapping contains an ELF header if it is a private mapping, its
700 offset is zero, and its first word is ELFMAG. */
701 if (!dump_p
&& private_p
&& offset
== 0
702 && (filterflags
& COREFILTER_ELF_HEADERS
) != 0)
704 /* Useful define specifying the size of the ELF magical
710 /* Let's check if we have an ELF header. */
712 if (target_read_memory (addr
, h
, SELFMAG
) == 0)
714 /* The EI_MAG* and ELFMAG* constants come from
716 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
717 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
719 /* This mapping contains an ELF header, so we
729 /* Implement the "info proc" command. */
732 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
733 enum info_proc_what what
)
735 /* A long is used for pid instead of an int to avoid a loss of precision
736 compiler warning from the output of strtoul. */
738 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
739 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
740 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
741 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
742 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
743 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
747 if (args
&& isdigit (args
[0]))
751 pid
= strtoul (args
, &tem
, 10);
756 if (!target_has_execution
)
757 error (_("No current process: you must name one."));
758 if (current_inferior ()->fake_pid_p
)
759 error (_("Can't determine the current process's PID: you must name one."));
761 pid
= current_inferior ()->pid
;
764 args
= skip_spaces (args
);
766 error (_("Too many parameters: %s"), args
);
768 printf_filtered (_("process %ld\n"), pid
);
771 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
773 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
777 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
780 for (pos
= 0; pos
< len
- 1; pos
++)
782 if (buffer
[pos
] == '\0')
785 buffer
[len
- 1] = '\0';
786 printf_filtered ("cmdline = '%s'\n", buffer
);
789 warning (_("unable to open /proc file '%s'"), filename
);
793 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
794 gdb::optional
<std::string
> contents
795 = target_fileio_readlink (NULL
, filename
, &target_errno
);
796 if (contents
.has_value ())
797 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
799 warning (_("unable to read link '%s'"), filename
);
803 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
804 gdb::optional
<std::string
> contents
805 = target_fileio_readlink (NULL
, filename
, &target_errno
);
806 if (contents
.has_value ())
807 printf_filtered ("exe = '%s'\n", contents
->c_str ());
809 warning (_("unable to read link '%s'"), filename
);
813 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
814 gdb::unique_xmalloc_ptr
<char> map
815 = target_fileio_read_stralloc (NULL
, filename
);
820 printf_filtered (_("Mapped address spaces:\n\n"));
821 if (gdbarch_addr_bit (gdbarch
) == 32)
823 printf_filtered ("\t%10s %10s %10s %10s %s\n",
826 " Size", " Offset", "objfile");
830 printf_filtered (" %18s %18s %10s %10s %s\n",
833 " Size", " Offset", "objfile");
837 for (line
= strtok_r (map
.get (), "\n", &saveptr
);
839 line
= strtok_r (NULL
, "\n", &saveptr
))
841 ULONGEST addr
, endaddr
, offset
, inode
;
842 const char *permissions
, *device
, *mapping_filename
;
843 size_t permissions_len
, device_len
;
845 read_mapping (line
, &addr
, &endaddr
,
846 &permissions
, &permissions_len
,
847 &offset
, &device
, &device_len
,
848 &inode
, &mapping_filename
);
850 if (gdbarch_addr_bit (gdbarch
) == 32)
852 printf_filtered ("\t%10s %10s %10s %10s %s\n",
853 paddress (gdbarch
, addr
),
854 paddress (gdbarch
, endaddr
),
855 hex_string (endaddr
- addr
),
857 *mapping_filename
? mapping_filename
: "");
861 printf_filtered (" %18s %18s %10s %10s %s\n",
862 paddress (gdbarch
, addr
),
863 paddress (gdbarch
, endaddr
),
864 hex_string (endaddr
- addr
),
866 *mapping_filename
? mapping_filename
: "");
871 warning (_("unable to open /proc file '%s'"), filename
);
875 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
876 gdb::unique_xmalloc_ptr
<char> status
877 = target_fileio_read_stralloc (NULL
, filename
);
879 puts_filtered (status
.get ());
881 warning (_("unable to open /proc file '%s'"), filename
);
885 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
886 gdb::unique_xmalloc_ptr
<char> statstr
887 = target_fileio_read_stralloc (NULL
, filename
);
890 const char *p
= statstr
.get ();
892 printf_filtered (_("Process: %s\n"),
893 pulongest (strtoulst (p
, &p
, 10)));
898 /* ps command also relies on no trailing fields
900 const char *ep
= strrchr (p
, ')');
903 printf_filtered ("Exec file: %.*s\n",
904 (int) (ep
- p
- 1), p
+ 1);
911 printf_filtered (_("State: %c\n"), *p
++);
914 printf_filtered (_("Parent process: %s\n"),
915 pulongest (strtoulst (p
, &p
, 10)));
917 printf_filtered (_("Process group: %s\n"),
918 pulongest (strtoulst (p
, &p
, 10)));
920 printf_filtered (_("Session id: %s\n"),
921 pulongest (strtoulst (p
, &p
, 10)));
923 printf_filtered (_("TTY: %s\n"),
924 pulongest (strtoulst (p
, &p
, 10)));
926 printf_filtered (_("TTY owner process group: %s\n"),
927 pulongest (strtoulst (p
, &p
, 10)));
930 printf_filtered (_("Flags: %s\n"),
931 hex_string (strtoulst (p
, &p
, 10)));
933 printf_filtered (_("Minor faults (no memory page): %s\n"),
934 pulongest (strtoulst (p
, &p
, 10)));
936 printf_filtered (_("Minor faults, children: %s\n"),
937 pulongest (strtoulst (p
, &p
, 10)));
939 printf_filtered (_("Major faults (memory page faults): %s\n"),
940 pulongest (strtoulst (p
, &p
, 10)));
942 printf_filtered (_("Major faults, children: %s\n"),
943 pulongest (strtoulst (p
, &p
, 10)));
945 printf_filtered (_("utime: %s\n"),
946 pulongest (strtoulst (p
, &p
, 10)));
948 printf_filtered (_("stime: %s\n"),
949 pulongest (strtoulst (p
, &p
, 10)));
951 printf_filtered (_("utime, children: %s\n"),
952 pulongest (strtoulst (p
, &p
, 10)));
954 printf_filtered (_("stime, children: %s\n"),
955 pulongest (strtoulst (p
, &p
, 10)));
957 printf_filtered (_("jiffies remaining in current "
959 pulongest (strtoulst (p
, &p
, 10)));
961 printf_filtered (_("'nice' value: %s\n"),
962 pulongest (strtoulst (p
, &p
, 10)));
964 printf_filtered (_("jiffies until next timeout: %s\n"),
965 pulongest (strtoulst (p
, &p
, 10)));
967 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
968 pulongest (strtoulst (p
, &p
, 10)));
970 printf_filtered (_("start time (jiffies since "
971 "system boot): %s\n"),
972 pulongest (strtoulst (p
, &p
, 10)));
974 printf_filtered (_("Virtual memory size: %s\n"),
975 pulongest (strtoulst (p
, &p
, 10)));
977 printf_filtered (_("Resident set size: %s\n"),
978 pulongest (strtoulst (p
, &p
, 10)));
980 printf_filtered (_("rlim: %s\n"),
981 pulongest (strtoulst (p
, &p
, 10)));
983 printf_filtered (_("Start of text: %s\n"),
984 hex_string (strtoulst (p
, &p
, 10)));
986 printf_filtered (_("End of text: %s\n"),
987 hex_string (strtoulst (p
, &p
, 10)));
989 printf_filtered (_("Start of stack: %s\n"),
990 hex_string (strtoulst (p
, &p
, 10)));
991 #if 0 /* Don't know how architecture-dependent the rest is...
992 Anyway the signal bitmap info is available from "status". */
994 printf_filtered (_("Kernel stack pointer: %s\n"),
995 hex_string (strtoulst (p
, &p
, 10)));
997 printf_filtered (_("Kernel instr pointer: %s\n"),
998 hex_string (strtoulst (p
, &p
, 10)));
1000 printf_filtered (_("Pending signals bitmap: %s\n"),
1001 hex_string (strtoulst (p
, &p
, 10)));
1003 printf_filtered (_("Blocked signals bitmap: %s\n"),
1004 hex_string (strtoulst (p
, &p
, 10)));
1006 printf_filtered (_("Ignored signals bitmap: %s\n"),
1007 hex_string (strtoulst (p
, &p
, 10)));
1009 printf_filtered (_("Catched signals bitmap: %s\n"),
1010 hex_string (strtoulst (p
, &p
, 10)));
1012 printf_filtered (_("wchan (system call): %s\n"),
1013 hex_string (strtoulst (p
, &p
, 10)));
1017 warning (_("unable to open /proc file '%s'"), filename
);
1021 /* Implementation of `gdbarch_read_core_file_mappings', as defined in
1024 This function reads the NT_FILE note (which BFD turns into the
1025 section ".note.linuxcore.file"). The format of this note / section
1026 is described as follows in the Linux kernel sources in
1029 long count -- how many files are mapped
1030 long page_size -- units for file_ofs
1031 array of [COUNT] elements of
1035 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1037 CBFD is the BFD of the core file.
1039 PRE_LOOP_CB is the callback function to invoke prior to starting
1040 the loop which processes individual entries. This callback will
1041 only be executed after the note has been examined in enough
1042 detail to verify that it's not malformed in some way.
1044 LOOP_CB is the callback function that will be executed once
1045 for each mapping. */
1048 linux_read_core_file_mappings (struct gdbarch
*gdbarch
,
1050 gdb::function_view
<void (ULONGEST count
)>
1052 gdb::function_view
<void (int num
,
1056 const char *filename
,
1060 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1061 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1063 /* It's not required that the NT_FILE note exists, so return silently
1064 if it's not found. Beyond this point though, we'll complain
1065 if problems are found. */
1066 asection
*section
= bfd_get_section_by_name (cbfd
, ".note.linuxcore.file");
1067 if (section
== nullptr)
1070 unsigned int addr_size_bits
= gdbarch_addr_bit (gdbarch
);
1071 unsigned int addr_size
= addr_size_bits
/ 8;
1072 size_t note_size
= bfd_section_size (section
);
1074 if (note_size
< 2 * addr_size
)
1076 warning (_("malformed core note - too short for header"));
1080 gdb::def_vector
<gdb_byte
> contents (note_size
);
1081 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1084 warning (_("could not get core note contents"));
1088 gdb_byte
*descdata
= contents
.data ();
1089 char *descend
= (char *) descdata
+ note_size
;
1091 if (descdata
[note_size
- 1] != '\0')
1093 warning (_("malformed note - does not end with \\0"));
1097 ULONGEST count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1098 descdata
+= addr_size
;
1100 ULONGEST page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1101 descdata
+= addr_size
;
1103 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1105 warning (_("malformed note - too short for supplied file count"));
1109 char *filenames
= (char *) descdata
+ count
* 3 * addr_size
;
1111 /* Make sure that the correct number of filenames exist. Complain
1112 if there aren't enough or are too many. */
1113 char *f
= filenames
;
1114 for (int i
= 0; i
< count
; i
++)
1118 warning (_("malformed note - filename area is too small"));
1121 f
+= strnlen (f
, descend
- f
) + 1;
1123 /* Complain, but don't return early if the filename area is too big. */
1125 warning (_("malformed note - filename area is too big"));
1127 pre_loop_cb (count
);
1129 for (int i
= 0; i
< count
; i
++)
1131 ULONGEST start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1132 descdata
+= addr_size
;
1133 ULONGEST end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1134 descdata
+= addr_size
;
1136 = bfd_get (addr_size_bits
, core_bfd
, descdata
) * page_size
;
1137 descdata
+= addr_size
;
1138 char * filename
= filenames
;
1139 filenames
+= strlen ((char *) filenames
) + 1;
1141 loop_cb (i
, start
, end
, file_ofs
, filename
, nullptr);
1145 /* Implement "info proc mappings" for a corefile. */
1148 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1150 linux_read_core_file_mappings (gdbarch
, core_bfd
,
1151 [=] (ULONGEST count
)
1153 printf_filtered (_("Mapped address spaces:\n\n"));
1154 if (gdbarch_addr_bit (gdbarch
) == 32)
1156 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1159 " Size", " Offset", "objfile");
1163 printf_filtered (" %18s %18s %10s %10s %s\n",
1166 " Size", " Offset", "objfile");
1169 [=] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
1170 const char *filename
, const void *other
)
1172 if (gdbarch_addr_bit (gdbarch
) == 32)
1173 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1174 paddress (gdbarch
, start
),
1175 paddress (gdbarch
, end
),
1176 hex_string (end
- start
),
1177 hex_string (file_ofs
),
1180 printf_filtered (" %18s %18s %10s %10s %s\n",
1181 paddress (gdbarch
, start
),
1182 paddress (gdbarch
, end
),
1183 hex_string (end
- start
),
1184 hex_string (file_ofs
),
1189 /* Implement "info proc" for a corefile. */
1192 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1193 enum info_proc_what what
)
1195 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1196 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1202 exe
= bfd_core_file_failing_command (core_bfd
);
1204 printf_filtered ("exe = '%s'\n", exe
);
1206 warning (_("unable to find command name in core file"));
1210 linux_core_info_proc_mappings (gdbarch
, args
);
1212 if (!exe_f
&& !mappings_f
)
1213 error (_("unable to handle request"));
1216 /* Read siginfo data from the core, if possible. Returns -1 on
1217 failure. Otherwise, returns the number of bytes read. READBUF,
1218 OFFSET, and LEN are all as specified by the to_xfer_partial
1222 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1223 ULONGEST offset
, ULONGEST len
)
1225 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1226 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1227 if (section
== NULL
)
1230 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1236 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1237 ULONGEST offset
, ULONGEST inode
,
1238 int read
, int write
,
1239 int exec
, int modified
,
1240 const char *filename
,
1243 /* List memory regions in the inferior for a corefile. */
1246 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1247 linux_find_memory_region_ftype
*func
,
1250 char mapsfilename
[100];
1251 char coredumpfilter_name
[100];
1253 /* Default dump behavior of coredump_filter (0x33), according to
1254 Documentation/filesystems/proc.txt from the Linux kernel
1256 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1257 | COREFILTER_ANON_SHARED
1258 | COREFILTER_ELF_HEADERS
1259 | COREFILTER_HUGETLB_PRIVATE
);
1261 /* We need to know the real target PID to access /proc. */
1262 if (current_inferior ()->fake_pid_p
)
1265 pid
= current_inferior ()->pid
;
1267 if (use_coredump_filter
)
1269 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1270 "/proc/%d/coredump_filter", pid
);
1271 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1272 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1273 if (coredumpfilterdata
!= NULL
)
1277 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1278 filterflags
= (enum filter_flag
) flags
;
1282 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1283 gdb::unique_xmalloc_ptr
<char> data
1284 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1287 /* Older Linux kernels did not support /proc/PID/smaps. */
1288 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1289 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1296 line
= strtok_r (data
.get (), "\n", &t
);
1297 while (line
!= NULL
)
1299 ULONGEST addr
, endaddr
, offset
, inode
;
1300 const char *permissions
, *device
, *filename
;
1301 struct smaps_vmflags v
;
1302 size_t permissions_len
, device_len
;
1303 int read
, write
, exec
, priv
;
1304 int has_anonymous
= 0;
1305 int should_dump_p
= 0;
1309 memset (&v
, 0, sizeof (v
));
1310 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1311 &offset
, &device
, &device_len
, &inode
, &filename
);
1312 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1313 /* If the mapping is not anonymous, then we can consider it
1314 to be file-backed. These two states (anonymous or
1315 file-backed) seem to be exclusive, but they can actually
1316 coexist. For example, if a file-backed mapping has
1317 "Anonymous:" pages (see more below), then the Linux
1318 kernel will dump this mapping when the user specified
1319 that she only wants anonymous mappings in the corefile
1320 (*even* when she explicitly disabled the dumping of
1321 file-backed mappings). */
1322 mapping_file_p
= !mapping_anon_p
;
1324 /* Decode permissions. */
1325 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1326 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1327 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1328 /* 'private' here actually means VM_MAYSHARE, and not
1329 VM_SHARED. In order to know if a mapping is really
1330 private or not, we must check the flag "sh" in the
1331 VmFlags field. This is done by decode_vmflags. However,
1332 if we are using a Linux kernel released before the commit
1333 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1334 not have the VmFlags there. In this case, there is
1335 really no way to know if we are dealing with VM_SHARED,
1336 so we just assume that VM_MAYSHARE is enough. */
1337 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1339 /* Try to detect if region should be dumped by parsing smaps
1341 for (line
= strtok_r (NULL
, "\n", &t
);
1342 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1343 line
= strtok_r (NULL
, "\n", &t
))
1345 char keyword
[64 + 1];
1347 if (sscanf (line
, "%64s", keyword
) != 1)
1349 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1353 if (strcmp (keyword
, "Anonymous:") == 0)
1355 /* Older Linux kernels did not support the
1356 "Anonymous:" counter. Check it here. */
1359 else if (strcmp (keyword
, "VmFlags:") == 0)
1360 decode_vmflags (line
, &v
);
1362 if (strcmp (keyword
, "AnonHugePages:") == 0
1363 || strcmp (keyword
, "Anonymous:") == 0)
1365 unsigned long number
;
1367 if (sscanf (line
, "%*s%lu", &number
) != 1)
1369 warning (_("Error parsing {s,}maps file '%s' number"),
1375 /* Even if we are dealing with a file-backed
1376 mapping, if it contains anonymous pages we
1377 consider it to be *also* an anonymous
1378 mapping, because this is what the Linux
1381 // Dump segments that have been written to.
1382 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1385 Note that if the mapping is already marked as
1386 file-backed (i.e., mapping_file_p is
1387 non-zero), then this is a special case, and
1388 this mapping will be dumped either when the
1389 user wants to dump file-backed *or* anonymous
1397 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1398 mapping_anon_p
, mapping_file_p
,
1399 filename
, addr
, offset
);
1402 /* Older Linux kernels did not support the "Anonymous:" counter.
1403 If it is missing, we can't be sure - dump all the pages. */
1407 /* Invoke the callback function to create the corefile segment. */
1409 func (addr
, endaddr
- addr
, offset
, inode
,
1410 read
, write
, exec
, 1, /* MODIFIED is true because we
1411 want to dump the mapping. */
1421 /* A structure for passing information through
1422 linux_find_memory_regions_full. */
1424 struct linux_find_memory_regions_data
1426 /* The original callback. */
1428 find_memory_region_ftype func
;
1430 /* The original datum. */
1435 /* A callback for linux_find_memory_regions that converts between the
1436 "full"-style callback and find_memory_region_ftype. */
1439 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1440 ULONGEST offset
, ULONGEST inode
,
1441 int read
, int write
, int exec
, int modified
,
1442 const char *filename
, void *arg
)
1444 struct linux_find_memory_regions_data
*data
1445 = (struct linux_find_memory_regions_data
*) arg
;
1447 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1450 /* A variant of linux_find_memory_regions_full that is suitable as the
1451 gdbarch find_memory_regions method. */
1454 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1455 find_memory_region_ftype func
, void *obfd
)
1457 struct linux_find_memory_regions_data data
;
1462 return linux_find_memory_regions_full (gdbarch
,
1463 linux_find_memory_regions_thunk
,
1467 /* This is used to pass information from
1468 linux_make_mappings_corefile_notes through
1469 linux_find_memory_regions_full. */
1471 struct linux_make_mappings_data
1473 /* Number of files mapped. */
1474 ULONGEST file_count
;
1476 /* The obstack for the main part of the data. */
1477 struct obstack
*data_obstack
;
1479 /* The filename obstack. */
1480 struct obstack
*filename_obstack
;
1482 /* The architecture's "long" type. */
1483 struct type
*long_type
;
1486 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1488 /* A callback for linux_find_memory_regions_full that updates the
1489 mappings data for linux_make_mappings_corefile_notes. */
1492 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1493 ULONGEST offset
, ULONGEST inode
,
1494 int read
, int write
, int exec
, int modified
,
1495 const char *filename
, void *data
)
1497 struct linux_make_mappings_data
*map_data
1498 = (struct linux_make_mappings_data
*) data
;
1499 gdb_byte buf
[sizeof (ULONGEST
)];
1501 if (*filename
== '\0' || inode
== 0)
1504 ++map_data
->file_count
;
1506 pack_long (buf
, map_data
->long_type
, vaddr
);
1507 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1508 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1509 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1510 pack_long (buf
, map_data
->long_type
, offset
);
1511 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1513 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1518 /* Write the file mapping data to the core file, if possible. OBFD is
1519 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1520 is a pointer to the note size. Returns the new NOTE_DATA and
1521 updates NOTE_SIZE. */
1524 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1525 char *note_data
, int *note_size
)
1527 struct linux_make_mappings_data mapping_data
;
1528 struct type
*long_type
1529 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1530 gdb_byte buf
[sizeof (ULONGEST
)];
1532 auto_obstack data_obstack
, filename_obstack
;
1534 mapping_data
.file_count
= 0;
1535 mapping_data
.data_obstack
= &data_obstack
;
1536 mapping_data
.filename_obstack
= &filename_obstack
;
1537 mapping_data
.long_type
= long_type
;
1539 /* Reserve space for the count. */
1540 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1541 /* We always write the page size as 1 since we have no good way to
1542 determine the correct value. */
1543 pack_long (buf
, long_type
, 1);
1544 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1546 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1549 if (mapping_data
.file_count
!= 0)
1551 /* Write the count to the obstack. */
1552 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1553 long_type
, mapping_data
.file_count
);
1555 /* Copy the filenames to the data obstack. */
1556 int size
= obstack_object_size (&filename_obstack
);
1557 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1560 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1562 obstack_base (&data_obstack
),
1563 obstack_object_size (&data_obstack
));
1569 /* Structure for passing information from
1570 linux_collect_thread_registers via an iterator to
1571 linux_collect_regset_section_cb. */
1573 struct linux_collect_regset_section_cb_data
1575 struct gdbarch
*gdbarch
;
1576 const struct regcache
*regcache
;
1581 enum gdb_signal stop_signal
;
1582 int abort_iteration
;
1585 /* Callback for iterate_over_regset_sections that records a single
1586 regset in the corefile note section. */
1589 linux_collect_regset_section_cb (const char *sect_name
, int supply_size
,
1590 int collect_size
, const struct regset
*regset
,
1591 const char *human_name
, void *cb_data
)
1593 struct linux_collect_regset_section_cb_data
*data
1594 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1595 bool variable_size_section
= (regset
!= NULL
1596 && regset
->flags
& REGSET_VARIABLE_SIZE
);
1598 if (!variable_size_section
)
1599 gdb_assert (supply_size
== collect_size
);
1601 if (data
->abort_iteration
)
1604 gdb_assert (regset
&& regset
->collect_regset
);
1606 /* This is intentionally zero-initialized by using std::vector, so
1607 that any padding bytes in the core file will show as 0. */
1608 std::vector
<gdb_byte
> buf (collect_size
);
1610 regset
->collect_regset (regset
, data
->regcache
, -1, buf
.data (),
1613 /* PRSTATUS still needs to be treated specially. */
1614 if (strcmp (sect_name
, ".reg") == 0)
1615 data
->note_data
= (char *) elfcore_write_prstatus
1616 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1617 gdb_signal_to_host (data
->stop_signal
), buf
.data ());
1619 data
->note_data
= (char *) elfcore_write_register_note
1620 (data
->obfd
, data
->note_data
, data
->note_size
,
1621 sect_name
, buf
.data (), collect_size
);
1623 if (data
->note_data
== NULL
)
1624 data
->abort_iteration
= 1;
1627 /* Records the thread's register state for the corefile note
1631 linux_collect_thread_registers (const struct regcache
*regcache
,
1632 ptid_t ptid
, bfd
*obfd
,
1633 char *note_data
, int *note_size
,
1634 enum gdb_signal stop_signal
)
1636 struct gdbarch
*gdbarch
= regcache
->arch ();
1637 struct linux_collect_regset_section_cb_data data
;
1639 data
.gdbarch
= gdbarch
;
1640 data
.regcache
= regcache
;
1642 data
.note_data
= note_data
;
1643 data
.note_size
= note_size
;
1644 data
.stop_signal
= stop_signal
;
1645 data
.abort_iteration
= 0;
1647 /* For remote targets the LWP may not be available, so use the TID. */
1648 data
.lwp
= ptid
.lwp ();
1650 data
.lwp
= ptid
.tid ();
1652 gdbarch_iterate_over_regset_sections (gdbarch
,
1653 linux_collect_regset_section_cb
,
1655 return data
.note_data
;
1658 /* Fetch the siginfo data for the specified thread, if it exists. If
1659 there is no data, or we could not read it, return an empty
1662 static gdb::byte_vector
1663 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1665 struct type
*siginfo_type
;
1668 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1669 return gdb::byte_vector ();
1671 scoped_restore_current_thread save_current_thread
;
1672 switch_to_thread (thread
);
1674 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1676 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1678 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1679 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1680 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1686 struct linux_corefile_thread_data
1688 struct gdbarch
*gdbarch
;
1692 enum gdb_signal stop_signal
;
1695 /* Records the thread's register state for the corefile note
1699 linux_corefile_thread (struct thread_info
*info
,
1700 struct linux_corefile_thread_data
*args
)
1702 struct regcache
*regcache
;
1704 regcache
= get_thread_arch_regcache (info
->inf
->process_target (),
1705 info
->ptid
, args
->gdbarch
);
1707 target_fetch_registers (regcache
, -1);
1708 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1710 args
->note_data
= linux_collect_thread_registers
1711 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1712 args
->note_size
, args
->stop_signal
);
1714 /* Don't return anything if we got no register information above,
1715 such a core file is useless. */
1716 if (args
->note_data
!= NULL
)
1717 if (!siginfo_data
.empty ())
1718 args
->note_data
= elfcore_write_note (args
->obfd
,
1722 siginfo_data
.data (),
1723 siginfo_data
.size ());
1726 /* Fill the PRPSINFO structure with information about the process being
1727 debugged. Returns 1 in case of success, 0 for failures. Please note that
1728 even if the structure cannot be entirely filled (e.g., GDB was unable to
1729 gather information about the process UID/GID), this function will still
1730 return 1 since some information was already recorded. It will only return
1731 0 iff nothing can be gathered. */
1734 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1736 /* The filename which we will use to obtain some info about the process.
1737 We will basically use this to store the `/proc/PID/FILENAME' file. */
1739 /* The basename of the executable. */
1740 const char *basename
;
1741 const char *infargs
;
1742 /* Temporary buffer. */
1744 /* The valid states of a process, according to the Linux kernel. */
1745 const char valid_states
[] = "RSDTZW";
1746 /* The program state. */
1747 const char *prog_state
;
1748 /* The state of the process. */
1750 /* The PID of the program which generated the corefile. */
1752 /* Process flags. */
1753 unsigned int pr_flag
;
1754 /* Process nice value. */
1756 /* The number of fields read by `sscanf'. */
1759 gdb_assert (p
!= NULL
);
1761 /* Obtaining PID and filename. */
1762 pid
= inferior_ptid
.pid ();
1763 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1764 /* The full name of the program which generated the corefile. */
1765 gdb::unique_xmalloc_ptr
<char> fname
1766 = target_fileio_read_stralloc (NULL
, filename
);
1768 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1770 /* No program name was read, so we won't be able to retrieve more
1771 information about the process. */
1775 memset (p
, 0, sizeof (*p
));
1777 /* Defining the PID. */
1780 /* Copying the program name. Only the basename matters. */
1781 basename
= lbasename (fname
.get ());
1782 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1783 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1785 infargs
= get_inferior_args ();
1787 /* The arguments of the program. */
1788 std::string psargs
= fname
.get ();
1789 if (infargs
!= NULL
)
1790 psargs
= psargs
+ " " + infargs
;
1792 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1793 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1795 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1796 /* The contents of `/proc/PID/stat'. */
1797 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1798 = target_fileio_read_stralloc (NULL
, filename
);
1799 char *proc_stat
= proc_stat_contents
.get ();
1801 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1803 /* Despite being unable to read more information about the
1804 process, we return 1 here because at least we have its
1805 command line, PID and arguments. */
1809 /* Ok, we have the stats. It's time to do a little parsing of the
1810 contents of the buffer, so that we end up reading what we want.
1812 The following parsing mechanism is strongly based on the
1813 information generated by the `fs/proc/array.c' file, present in
1814 the Linux kernel tree. More details about how the information is
1815 displayed can be obtained by seeing the manpage of proc(5),
1816 specifically under the entry of `/proc/[pid]/stat'. */
1818 /* Getting rid of the PID, since we already have it. */
1819 while (isdigit (*proc_stat
))
1822 proc_stat
= skip_spaces (proc_stat
);
1824 /* ps command also relies on no trailing fields ever contain ')'. */
1825 proc_stat
= strrchr (proc_stat
, ')');
1826 if (proc_stat
== NULL
)
1830 proc_stat
= skip_spaces (proc_stat
);
1832 n_fields
= sscanf (proc_stat
,
1833 "%c" /* Process state. */
1834 "%d%d%d" /* Parent PID, group ID, session ID. */
1835 "%*d%*d" /* tty_nr, tpgid (not used). */
1837 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1838 cmajflt (not used). */
1839 "%*s%*s%*s%*s" /* utime, stime, cutime,
1840 cstime (not used). */
1841 "%*s" /* Priority (not used). */
1844 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1850 /* Again, we couldn't read the complementary information about
1851 the process state. However, we already have minimal
1852 information, so we just return 1 here. */
1856 /* Filling the structure fields. */
1857 prog_state
= strchr (valid_states
, pr_sname
);
1858 if (prog_state
!= NULL
)
1859 p
->pr_state
= prog_state
- valid_states
;
1862 /* Zero means "Running". */
1866 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1867 p
->pr_zomb
= p
->pr_sname
== 'Z';
1868 p
->pr_nice
= pr_nice
;
1869 p
->pr_flag
= pr_flag
;
1871 /* Finally, obtaining the UID and GID. For that, we read and parse the
1872 contents of the `/proc/PID/status' file. */
1873 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1874 /* The contents of `/proc/PID/status'. */
1875 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1876 = target_fileio_read_stralloc (NULL
, filename
);
1877 char *proc_status
= proc_status_contents
.get ();
1879 if (proc_status
== NULL
|| *proc_status
== '\0')
1881 /* Returning 1 since we already have a bunch of information. */
1885 /* Extracting the UID. */
1886 tmpstr
= strstr (proc_status
, "Uid:");
1889 /* Advancing the pointer to the beginning of the UID. */
1890 tmpstr
+= sizeof ("Uid:");
1891 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1894 if (isdigit (*tmpstr
))
1895 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1898 /* Extracting the GID. */
1899 tmpstr
= strstr (proc_status
, "Gid:");
1902 /* Advancing the pointer to the beginning of the GID. */
1903 tmpstr
+= sizeof ("Gid:");
1904 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1907 if (isdigit (*tmpstr
))
1908 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1914 /* Find the signalled thread. In case there's more than one signalled
1915 thread, prefer the current thread, if it is signalled. If no
1916 thread was signalled, default to the current thread, unless it has
1917 exited, in which case return NULL. */
1919 static thread_info
*
1920 find_signalled_thread ()
1922 thread_info
*curr_thr
= inferior_thread ();
1923 if (curr_thr
->state
!= THREAD_EXITED
1924 && curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1927 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1928 if (thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1931 /* Default to the current thread, unless it has exited. */
1932 if (curr_thr
->state
!= THREAD_EXITED
)
1938 /* Build the note section for a corefile, and return it in a malloc
1942 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1944 struct linux_corefile_thread_data thread_args
;
1945 struct elf_internal_linux_prpsinfo prpsinfo
;
1946 char *note_data
= NULL
;
1948 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1951 if (linux_fill_prpsinfo (&prpsinfo
))
1953 if (gdbarch_ptr_bit (gdbarch
) == 64)
1954 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1955 note_data
, note_size
,
1958 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1959 note_data
, note_size
,
1963 /* Thread register information. */
1966 update_thread_list ();
1968 catch (const gdb_exception_error
&e
)
1970 exception_print (gdb_stderr
, e
);
1973 /* Like the kernel, prefer dumping the signalled thread first.
1974 "First thread" is what tools use to infer the signalled
1976 thread_info
*signalled_thr
= find_signalled_thread ();
1978 thread_args
.gdbarch
= gdbarch
;
1979 thread_args
.obfd
= obfd
;
1980 thread_args
.note_data
= note_data
;
1981 thread_args
.note_size
= note_size
;
1982 if (signalled_thr
!= nullptr)
1983 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1985 thread_args
.stop_signal
= GDB_SIGNAL_0
;
1987 if (signalled_thr
!= nullptr)
1988 linux_corefile_thread (signalled_thr
, &thread_args
);
1989 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1991 if (thr
== signalled_thr
)
1994 linux_corefile_thread (thr
, &thread_args
);
1997 note_data
= thread_args
.note_data
;
2001 /* Auxillary vector. */
2002 gdb::optional
<gdb::byte_vector
> auxv
=
2003 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
2004 if (auxv
&& !auxv
->empty ())
2006 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
2007 "CORE", NT_AUXV
, auxv
->data (),
2014 /* File mappings. */
2015 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
2016 note_data
, note_size
);
2021 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2022 gdbarch.h. This function is not static because it is exported to
2023 other -tdep files. */
2026 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2031 return GDB_SIGNAL_0
;
2034 return GDB_SIGNAL_HUP
;
2037 return GDB_SIGNAL_INT
;
2040 return GDB_SIGNAL_QUIT
;
2043 return GDB_SIGNAL_ILL
;
2046 return GDB_SIGNAL_TRAP
;
2049 return GDB_SIGNAL_ABRT
;
2052 return GDB_SIGNAL_BUS
;
2055 return GDB_SIGNAL_FPE
;
2058 return GDB_SIGNAL_KILL
;
2061 return GDB_SIGNAL_USR1
;
2064 return GDB_SIGNAL_SEGV
;
2067 return GDB_SIGNAL_USR2
;
2070 return GDB_SIGNAL_PIPE
;
2073 return GDB_SIGNAL_ALRM
;
2076 return GDB_SIGNAL_TERM
;
2079 return GDB_SIGNAL_CHLD
;
2082 return GDB_SIGNAL_CONT
;
2085 return GDB_SIGNAL_STOP
;
2088 return GDB_SIGNAL_TSTP
;
2091 return GDB_SIGNAL_TTIN
;
2094 return GDB_SIGNAL_TTOU
;
2097 return GDB_SIGNAL_URG
;
2100 return GDB_SIGNAL_XCPU
;
2103 return GDB_SIGNAL_XFSZ
;
2105 case LINUX_SIGVTALRM
:
2106 return GDB_SIGNAL_VTALRM
;
2109 return GDB_SIGNAL_PROF
;
2111 case LINUX_SIGWINCH
:
2112 return GDB_SIGNAL_WINCH
;
2114 /* No way to differentiate between SIGIO and SIGPOLL.
2115 Therefore, we just handle the first one. */
2117 return GDB_SIGNAL_IO
;
2120 return GDB_SIGNAL_PWR
;
2123 return GDB_SIGNAL_SYS
;
2125 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2126 therefore we have to handle them here. */
2127 case LINUX_SIGRTMIN
:
2128 return GDB_SIGNAL_REALTIME_32
;
2130 case LINUX_SIGRTMAX
:
2131 return GDB_SIGNAL_REALTIME_64
;
2134 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2136 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2138 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2141 return GDB_SIGNAL_UNKNOWN
;
2144 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2145 gdbarch.h. This function is not static because it is exported to
2146 other -tdep files. */
2149 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2150 enum gdb_signal signal
)
2157 case GDB_SIGNAL_HUP
:
2158 return LINUX_SIGHUP
;
2160 case GDB_SIGNAL_INT
:
2161 return LINUX_SIGINT
;
2163 case GDB_SIGNAL_QUIT
:
2164 return LINUX_SIGQUIT
;
2166 case GDB_SIGNAL_ILL
:
2167 return LINUX_SIGILL
;
2169 case GDB_SIGNAL_TRAP
:
2170 return LINUX_SIGTRAP
;
2172 case GDB_SIGNAL_ABRT
:
2173 return LINUX_SIGABRT
;
2175 case GDB_SIGNAL_FPE
:
2176 return LINUX_SIGFPE
;
2178 case GDB_SIGNAL_KILL
:
2179 return LINUX_SIGKILL
;
2181 case GDB_SIGNAL_BUS
:
2182 return LINUX_SIGBUS
;
2184 case GDB_SIGNAL_SEGV
:
2185 return LINUX_SIGSEGV
;
2187 case GDB_SIGNAL_SYS
:
2188 return LINUX_SIGSYS
;
2190 case GDB_SIGNAL_PIPE
:
2191 return LINUX_SIGPIPE
;
2193 case GDB_SIGNAL_ALRM
:
2194 return LINUX_SIGALRM
;
2196 case GDB_SIGNAL_TERM
:
2197 return LINUX_SIGTERM
;
2199 case GDB_SIGNAL_URG
:
2200 return LINUX_SIGURG
;
2202 case GDB_SIGNAL_STOP
:
2203 return LINUX_SIGSTOP
;
2205 case GDB_SIGNAL_TSTP
:
2206 return LINUX_SIGTSTP
;
2208 case GDB_SIGNAL_CONT
:
2209 return LINUX_SIGCONT
;
2211 case GDB_SIGNAL_CHLD
:
2212 return LINUX_SIGCHLD
;
2214 case GDB_SIGNAL_TTIN
:
2215 return LINUX_SIGTTIN
;
2217 case GDB_SIGNAL_TTOU
:
2218 return LINUX_SIGTTOU
;
2223 case GDB_SIGNAL_XCPU
:
2224 return LINUX_SIGXCPU
;
2226 case GDB_SIGNAL_XFSZ
:
2227 return LINUX_SIGXFSZ
;
2229 case GDB_SIGNAL_VTALRM
:
2230 return LINUX_SIGVTALRM
;
2232 case GDB_SIGNAL_PROF
:
2233 return LINUX_SIGPROF
;
2235 case GDB_SIGNAL_WINCH
:
2236 return LINUX_SIGWINCH
;
2238 case GDB_SIGNAL_USR1
:
2239 return LINUX_SIGUSR1
;
2241 case GDB_SIGNAL_USR2
:
2242 return LINUX_SIGUSR2
;
2244 case GDB_SIGNAL_PWR
:
2245 return LINUX_SIGPWR
;
2247 case GDB_SIGNAL_POLL
:
2248 return LINUX_SIGPOLL
;
2250 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2251 therefore we have to handle it here. */
2252 case GDB_SIGNAL_REALTIME_32
:
2253 return LINUX_SIGRTMIN
;
2255 /* Same comment applies to _64. */
2256 case GDB_SIGNAL_REALTIME_64
:
2257 return LINUX_SIGRTMAX
;
2260 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2261 if (signal
>= GDB_SIGNAL_REALTIME_33
2262 && signal
<= GDB_SIGNAL_REALTIME_63
)
2264 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2266 return LINUX_SIGRTMIN
+ 1 + offset
;
2272 /* Helper for linux_vsyscall_range that does the real work of finding
2273 the vsyscall's address range. */
2276 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2281 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2284 /* It doesn't make sense to access the host's /proc when debugging a
2285 core file. Instead, look for the PT_LOAD segment that matches
2287 if (!target_has_execution
)
2292 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2293 if (phdrs_size
== -1)
2296 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2297 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2298 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2299 if (num_phdrs
== -1)
2302 for (i
= 0; i
< num_phdrs
; i
++)
2303 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2304 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2306 range
->length
= phdrs
.get ()[i
].p_memsz
;
2313 /* We need to know the real target PID to access /proc. */
2314 if (current_inferior ()->fake_pid_p
)
2317 pid
= current_inferior ()->pid
;
2319 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2320 reading /proc/PID/maps (2). The later identifies thread stacks
2321 in the output, which requires scanning every thread in the thread
2322 group to check whether a VMA is actually a thread's stack. With
2323 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2324 a few thousand threads, (1) takes a few miliseconds, while (2)
2325 takes several seconds. Also note that "smaps", what we read for
2326 determining core dump mappings, is even slower than "maps". */
2327 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2328 gdb::unique_xmalloc_ptr
<char> data
2329 = target_fileio_read_stralloc (NULL
, filename
);
2333 char *saveptr
= NULL
;
2335 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2337 line
= strtok_r (NULL
, "\n", &saveptr
))
2339 ULONGEST addr
, endaddr
;
2340 const char *p
= line
;
2342 addr
= strtoulst (p
, &p
, 16);
2343 if (addr
== range
->start
)
2347 endaddr
= strtoulst (p
, &p
, 16);
2348 range
->length
= endaddr
- addr
;
2354 warning (_("unable to open /proc file '%s'"), filename
);
2359 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2360 caching, and defers the real work to linux_vsyscall_range_raw. */
2363 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2365 struct linux_info
*info
= get_linux_inferior_data ();
2367 if (info
->vsyscall_range_p
== 0)
2369 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2370 info
->vsyscall_range_p
= 1;
2372 info
->vsyscall_range_p
= -1;
2375 if (info
->vsyscall_range_p
< 0)
2378 *range
= info
->vsyscall_range
;
2382 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2383 definitions would be dependent on compilation host. */
2384 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2385 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2387 /* See gdbarch.sh 'infcall_mmap'. */
2390 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2392 struct objfile
*objf
;
2393 /* Do there still exist any Linux systems without "mmap64"?
2394 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2395 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2396 struct value
*addr_val
;
2397 struct gdbarch
*gdbarch
= objf
->arch ();
2401 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2403 struct value
*arg
[ARG_LAST
];
2405 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2407 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2408 arg
[ARG_LENGTH
] = value_from_ulongest
2409 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2410 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2411 | GDB_MMAP_PROT_EXEC
))
2413 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2414 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2415 GDB_MMAP_MAP_PRIVATE
2416 | GDB_MMAP_MAP_ANONYMOUS
);
2417 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2418 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2420 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2421 retval
= value_as_address (addr_val
);
2422 if (retval
== (CORE_ADDR
) -1)
2423 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2428 /* See gdbarch.sh 'infcall_munmap'. */
2431 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2433 struct objfile
*objf
;
2434 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2435 struct value
*retval_val
;
2436 struct gdbarch
*gdbarch
= objf
->arch ();
2440 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2442 struct value
*arg
[ARG_LAST
];
2444 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2446 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2447 arg
[ARG_LENGTH
] = value_from_ulongest
2448 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2449 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2450 retval
= value_as_long (retval_val
);
2452 warning (_("Failed inferior munmap call at %s for %s bytes, "
2453 "errno is changed."),
2454 hex_string (addr
), pulongest (size
));
2457 /* See linux-tdep.h. */
2460 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2465 /* Determine entry point from target auxiliary vector. This avoids
2466 the need for symbols. Also, when debugging a stand-alone SPU
2467 executable, entry_point_address () will point to an SPU
2468 local-store address and is thus not usable as displaced stepping
2469 location. The auxiliary vector gets us the PowerPC-side entry
2470 point address instead. */
2471 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2472 throw_error (NOT_SUPPORTED_ERROR
,
2473 _("Cannot find AT_ENTRY auxiliary vector entry."));
2475 /* Make certain that the address points at real code, and not a
2476 function descriptor. */
2477 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2478 current_top_target ());
2480 /* Inferior calls also use the entry point as a breakpoint location.
2481 We don't want displaced stepping to interfere with those
2482 breakpoints, so leave space. */
2483 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2489 /* See linux-tdep.h. */
2492 linux_get_hwcap (struct target_ops
*target
)
2495 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2500 /* See linux-tdep.h. */
2503 linux_get_hwcap2 (struct target_ops
*target
)
2506 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2511 /* Display whether the gcore command is using the
2512 /proc/PID/coredump_filter file. */
2515 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2516 struct cmd_list_element
*c
, const char *value
)
2518 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2519 " corefiles is %s.\n"), value
);
2522 /* Display whether the gcore command is dumping mappings marked with
2523 the VM_DONTDUMP flag. */
2526 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2527 struct cmd_list_element
*c
, const char *value
)
2529 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2530 " flag is %s.\n"), value
);
2533 /* To be called from the various GDB_OSABI_LINUX handlers for the
2534 various GNU/Linux architectures and machine types. */
2537 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2539 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2540 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2541 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2542 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2543 set_gdbarch_read_core_file_mappings (gdbarch
, linux_read_core_file_mappings
);
2544 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2545 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2546 set_gdbarch_has_shared_address_space (gdbarch
,
2547 linux_has_shared_address_space
);
2548 set_gdbarch_gdb_signal_from_target (gdbarch
,
2549 linux_gdb_signal_from_target
);
2550 set_gdbarch_gdb_signal_to_target (gdbarch
,
2551 linux_gdb_signal_to_target
);
2552 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2553 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2554 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2555 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2558 void _initialize_linux_tdep ();
2560 _initialize_linux_tdep ()
2562 linux_gdbarch_data_handle
=
2563 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2565 /* Observers used to invalidate the cache when needed. */
2566 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2567 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2569 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2570 &use_coredump_filter
, _("\
2571 Set whether gcore should consider /proc/PID/coredump_filter."),
2573 Show whether gcore should consider /proc/PID/coredump_filter."),
2575 Use this command to set whether gcore should consider the contents\n\
2576 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2577 about this file, refer to the manpage of core(5)."),
2578 NULL
, show_use_coredump_filter
,
2579 &setlist
, &showlist
);
2581 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2582 &dump_excluded_mappings
, _("\
2583 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2585 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2587 Use this command to set whether gcore should dump mappings marked with the\n\
2588 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2589 more information about this file, refer to the manpage of proc(5) and core(5)."),
2590 NULL
, show_dump_excluded_mappings
,
2591 &setlist
, &showlist
);