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 /* Implement "info proc mappings" for a corefile. */
1024 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1027 ULONGEST count
, page_size
;
1028 unsigned char *descdata
, *filenames
, *descend
;
1030 unsigned int addr_size_bits
, addr_size
;
1031 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
1032 /* We assume this for reading 64-bit core files. */
1033 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1035 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1036 if (section
== NULL
)
1038 warning (_("unable to find mappings in core file"));
1042 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1043 addr_size
= addr_size_bits
/ 8;
1044 note_size
= bfd_section_size (section
);
1046 if (note_size
< 2 * addr_size
)
1047 error (_("malformed core note - too short for header"));
1049 gdb::def_vector
<unsigned char> contents (note_size
);
1050 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1052 error (_("could not get core note contents"));
1054 descdata
= contents
.data ();
1055 descend
= descdata
+ note_size
;
1057 if (descdata
[note_size
- 1] != '\0')
1058 error (_("malformed note - does not end with \\0"));
1060 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1061 descdata
+= addr_size
;
1063 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1064 descdata
+= addr_size
;
1066 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1067 error (_("malformed note - too short for supplied file count"));
1069 printf_filtered (_("Mapped address spaces:\n\n"));
1070 if (gdbarch_addr_bit (gdbarch
) == 32)
1072 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1075 " Size", " Offset", "objfile");
1079 printf_filtered (" %18s %18s %10s %10s %s\n",
1082 " Size", " Offset", "objfile");
1085 filenames
= descdata
+ count
* 3 * addr_size
;
1088 ULONGEST start
, end
, file_ofs
;
1090 if (filenames
== descend
)
1091 error (_("malformed note - filenames end too early"));
1093 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1094 descdata
+= addr_size
;
1095 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1096 descdata
+= addr_size
;
1097 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1098 descdata
+= addr_size
;
1100 file_ofs
*= page_size
;
1102 if (gdbarch_addr_bit (gdbarch
) == 32)
1103 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1104 paddress (gdbarch
, start
),
1105 paddress (gdbarch
, end
),
1106 hex_string (end
- start
),
1107 hex_string (file_ofs
),
1110 printf_filtered (" %18s %18s %10s %10s %s\n",
1111 paddress (gdbarch
, start
),
1112 paddress (gdbarch
, end
),
1113 hex_string (end
- start
),
1114 hex_string (file_ofs
),
1117 filenames
+= 1 + strlen ((char *) filenames
);
1121 /* Implement "info proc" for a corefile. */
1124 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1125 enum info_proc_what what
)
1127 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1128 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1134 exe
= bfd_core_file_failing_command (core_bfd
);
1136 printf_filtered ("exe = '%s'\n", exe
);
1138 warning (_("unable to find command name in core file"));
1142 linux_core_info_proc_mappings (gdbarch
, args
);
1144 if (!exe_f
&& !mappings_f
)
1145 error (_("unable to handle request"));
1148 /* Read siginfo data from the core, if possible. Returns -1 on
1149 failure. Otherwise, returns the number of bytes read. READBUF,
1150 OFFSET, and LEN are all as specified by the to_xfer_partial
1154 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1155 ULONGEST offset
, ULONGEST len
)
1157 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1158 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1159 if (section
== NULL
)
1162 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1168 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1169 ULONGEST offset
, ULONGEST inode
,
1170 int read
, int write
,
1171 int exec
, int modified
,
1172 const char *filename
,
1175 /* List memory regions in the inferior for a corefile. */
1178 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1179 linux_find_memory_region_ftype
*func
,
1182 char mapsfilename
[100];
1183 char coredumpfilter_name
[100];
1185 /* Default dump behavior of coredump_filter (0x33), according to
1186 Documentation/filesystems/proc.txt from the Linux kernel
1188 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1189 | COREFILTER_ANON_SHARED
1190 | COREFILTER_ELF_HEADERS
1191 | COREFILTER_HUGETLB_PRIVATE
);
1193 /* We need to know the real target PID to access /proc. */
1194 if (current_inferior ()->fake_pid_p
)
1197 pid
= current_inferior ()->pid
;
1199 if (use_coredump_filter
)
1201 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1202 "/proc/%d/coredump_filter", pid
);
1203 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1204 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1205 if (coredumpfilterdata
!= NULL
)
1209 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1210 filterflags
= (enum filter_flag
) flags
;
1214 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1215 gdb::unique_xmalloc_ptr
<char> data
1216 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1219 /* Older Linux kernels did not support /proc/PID/smaps. */
1220 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1221 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1228 line
= strtok_r (data
.get (), "\n", &t
);
1229 while (line
!= NULL
)
1231 ULONGEST addr
, endaddr
, offset
, inode
;
1232 const char *permissions
, *device
, *filename
;
1233 struct smaps_vmflags v
;
1234 size_t permissions_len
, device_len
;
1235 int read
, write
, exec
, priv
;
1236 int has_anonymous
= 0;
1237 int should_dump_p
= 0;
1241 memset (&v
, 0, sizeof (v
));
1242 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1243 &offset
, &device
, &device_len
, &inode
, &filename
);
1244 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1245 /* If the mapping is not anonymous, then we can consider it
1246 to be file-backed. These two states (anonymous or
1247 file-backed) seem to be exclusive, but they can actually
1248 coexist. For example, if a file-backed mapping has
1249 "Anonymous:" pages (see more below), then the Linux
1250 kernel will dump this mapping when the user specified
1251 that she only wants anonymous mappings in the corefile
1252 (*even* when she explicitly disabled the dumping of
1253 file-backed mappings). */
1254 mapping_file_p
= !mapping_anon_p
;
1256 /* Decode permissions. */
1257 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1258 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1259 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1260 /* 'private' here actually means VM_MAYSHARE, and not
1261 VM_SHARED. In order to know if a mapping is really
1262 private or not, we must check the flag "sh" in the
1263 VmFlags field. This is done by decode_vmflags. However,
1264 if we are using a Linux kernel released before the commit
1265 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1266 not have the VmFlags there. In this case, there is
1267 really no way to know if we are dealing with VM_SHARED,
1268 so we just assume that VM_MAYSHARE is enough. */
1269 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1271 /* Try to detect if region should be dumped by parsing smaps
1273 for (line
= strtok_r (NULL
, "\n", &t
);
1274 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1275 line
= strtok_r (NULL
, "\n", &t
))
1277 char keyword
[64 + 1];
1279 if (sscanf (line
, "%64s", keyword
) != 1)
1281 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1285 if (strcmp (keyword
, "Anonymous:") == 0)
1287 /* Older Linux kernels did not support the
1288 "Anonymous:" counter. Check it here. */
1291 else if (strcmp (keyword
, "VmFlags:") == 0)
1292 decode_vmflags (line
, &v
);
1294 if (strcmp (keyword
, "AnonHugePages:") == 0
1295 || strcmp (keyword
, "Anonymous:") == 0)
1297 unsigned long number
;
1299 if (sscanf (line
, "%*s%lu", &number
) != 1)
1301 warning (_("Error parsing {s,}maps file '%s' number"),
1307 /* Even if we are dealing with a file-backed
1308 mapping, if it contains anonymous pages we
1309 consider it to be *also* an anonymous
1310 mapping, because this is what the Linux
1313 // Dump segments that have been written to.
1314 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1317 Note that if the mapping is already marked as
1318 file-backed (i.e., mapping_file_p is
1319 non-zero), then this is a special case, and
1320 this mapping will be dumped either when the
1321 user wants to dump file-backed *or* anonymous
1329 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1330 mapping_anon_p
, mapping_file_p
,
1331 filename
, addr
, offset
);
1334 /* Older Linux kernels did not support the "Anonymous:" counter.
1335 If it is missing, we can't be sure - dump all the pages. */
1339 /* Invoke the callback function to create the corefile segment. */
1341 func (addr
, endaddr
- addr
, offset
, inode
,
1342 read
, write
, exec
, 1, /* MODIFIED is true because we
1343 want to dump the mapping. */
1353 /* A structure for passing information through
1354 linux_find_memory_regions_full. */
1356 struct linux_find_memory_regions_data
1358 /* The original callback. */
1360 find_memory_region_ftype func
;
1362 /* The original datum. */
1367 /* A callback for linux_find_memory_regions that converts between the
1368 "full"-style callback and find_memory_region_ftype. */
1371 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1372 ULONGEST offset
, ULONGEST inode
,
1373 int read
, int write
, int exec
, int modified
,
1374 const char *filename
, void *arg
)
1376 struct linux_find_memory_regions_data
*data
1377 = (struct linux_find_memory_regions_data
*) arg
;
1379 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1382 /* A variant of linux_find_memory_regions_full that is suitable as the
1383 gdbarch find_memory_regions method. */
1386 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1387 find_memory_region_ftype func
, void *obfd
)
1389 struct linux_find_memory_regions_data data
;
1394 return linux_find_memory_regions_full (gdbarch
,
1395 linux_find_memory_regions_thunk
,
1399 /* This is used to pass information from
1400 linux_make_mappings_corefile_notes through
1401 linux_find_memory_regions_full. */
1403 struct linux_make_mappings_data
1405 /* Number of files mapped. */
1406 ULONGEST file_count
;
1408 /* The obstack for the main part of the data. */
1409 struct obstack
*data_obstack
;
1411 /* The filename obstack. */
1412 struct obstack
*filename_obstack
;
1414 /* The architecture's "long" type. */
1415 struct type
*long_type
;
1418 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1420 /* A callback for linux_find_memory_regions_full that updates the
1421 mappings data for linux_make_mappings_corefile_notes. */
1424 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1425 ULONGEST offset
, ULONGEST inode
,
1426 int read
, int write
, int exec
, int modified
,
1427 const char *filename
, void *data
)
1429 struct linux_make_mappings_data
*map_data
1430 = (struct linux_make_mappings_data
*) data
;
1431 gdb_byte buf
[sizeof (ULONGEST
)];
1433 if (*filename
== '\0' || inode
== 0)
1436 ++map_data
->file_count
;
1438 pack_long (buf
, map_data
->long_type
, vaddr
);
1439 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1440 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1441 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1442 pack_long (buf
, map_data
->long_type
, offset
);
1443 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1445 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1450 /* Write the file mapping data to the core file, if possible. OBFD is
1451 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1452 is a pointer to the note size. Returns the new NOTE_DATA and
1453 updates NOTE_SIZE. */
1456 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1457 char *note_data
, int *note_size
)
1459 struct linux_make_mappings_data mapping_data
;
1460 struct type
*long_type
1461 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1462 gdb_byte buf
[sizeof (ULONGEST
)];
1464 auto_obstack data_obstack
, filename_obstack
;
1466 mapping_data
.file_count
= 0;
1467 mapping_data
.data_obstack
= &data_obstack
;
1468 mapping_data
.filename_obstack
= &filename_obstack
;
1469 mapping_data
.long_type
= long_type
;
1471 /* Reserve space for the count. */
1472 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1473 /* We always write the page size as 1 since we have no good way to
1474 determine the correct value. */
1475 pack_long (buf
, long_type
, 1);
1476 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1478 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1481 if (mapping_data
.file_count
!= 0)
1483 /* Write the count to the obstack. */
1484 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1485 long_type
, mapping_data
.file_count
);
1487 /* Copy the filenames to the data obstack. */
1488 int size
= obstack_object_size (&filename_obstack
);
1489 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1492 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1494 obstack_base (&data_obstack
),
1495 obstack_object_size (&data_obstack
));
1501 /* Structure for passing information from
1502 linux_collect_thread_registers via an iterator to
1503 linux_collect_regset_section_cb. */
1505 struct linux_collect_regset_section_cb_data
1507 struct gdbarch
*gdbarch
;
1508 const struct regcache
*regcache
;
1513 enum gdb_signal stop_signal
;
1514 int abort_iteration
;
1517 /* Callback for iterate_over_regset_sections that records a single
1518 regset in the corefile note section. */
1521 linux_collect_regset_section_cb (const char *sect_name
, int supply_size
,
1522 int collect_size
, const struct regset
*regset
,
1523 const char *human_name
, void *cb_data
)
1525 struct linux_collect_regset_section_cb_data
*data
1526 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1527 bool variable_size_section
= (regset
!= NULL
1528 && regset
->flags
& REGSET_VARIABLE_SIZE
);
1530 if (!variable_size_section
)
1531 gdb_assert (supply_size
== collect_size
);
1533 if (data
->abort_iteration
)
1536 gdb_assert (regset
&& regset
->collect_regset
);
1538 /* This is intentionally zero-initialized by using std::vector, so
1539 that any padding bytes in the core file will show as 0. */
1540 std::vector
<gdb_byte
> buf (collect_size
);
1542 regset
->collect_regset (regset
, data
->regcache
, -1, buf
.data (),
1545 /* PRSTATUS still needs to be treated specially. */
1546 if (strcmp (sect_name
, ".reg") == 0)
1547 data
->note_data
= (char *) elfcore_write_prstatus
1548 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1549 gdb_signal_to_host (data
->stop_signal
), buf
.data ());
1551 data
->note_data
= (char *) elfcore_write_register_note
1552 (data
->obfd
, data
->note_data
, data
->note_size
,
1553 sect_name
, buf
.data (), collect_size
);
1555 if (data
->note_data
== NULL
)
1556 data
->abort_iteration
= 1;
1559 /* Records the thread's register state for the corefile note
1563 linux_collect_thread_registers (const struct regcache
*regcache
,
1564 ptid_t ptid
, bfd
*obfd
,
1565 char *note_data
, int *note_size
,
1566 enum gdb_signal stop_signal
)
1568 struct gdbarch
*gdbarch
= regcache
->arch ();
1569 struct linux_collect_regset_section_cb_data data
;
1571 data
.gdbarch
= gdbarch
;
1572 data
.regcache
= regcache
;
1574 data
.note_data
= note_data
;
1575 data
.note_size
= note_size
;
1576 data
.stop_signal
= stop_signal
;
1577 data
.abort_iteration
= 0;
1579 /* For remote targets the LWP may not be available, so use the TID. */
1580 data
.lwp
= ptid
.lwp ();
1582 data
.lwp
= ptid
.tid ();
1584 gdbarch_iterate_over_regset_sections (gdbarch
,
1585 linux_collect_regset_section_cb
,
1587 return data
.note_data
;
1590 /* Fetch the siginfo data for the specified thread, if it exists. If
1591 there is no data, or we could not read it, return an empty
1594 static gdb::byte_vector
1595 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1597 struct type
*siginfo_type
;
1600 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1601 return gdb::byte_vector ();
1603 scoped_restore_current_thread save_current_thread
;
1604 switch_to_thread (thread
);
1606 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1608 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1610 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1611 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1612 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1618 struct linux_corefile_thread_data
1620 struct gdbarch
*gdbarch
;
1624 enum gdb_signal stop_signal
;
1627 /* Records the thread's register state for the corefile note
1631 linux_corefile_thread (struct thread_info
*info
,
1632 struct linux_corefile_thread_data
*args
)
1634 struct regcache
*regcache
;
1636 regcache
= get_thread_arch_regcache (info
->inf
->process_target (),
1637 info
->ptid
, args
->gdbarch
);
1639 target_fetch_registers (regcache
, -1);
1640 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1642 args
->note_data
= linux_collect_thread_registers
1643 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1644 args
->note_size
, args
->stop_signal
);
1646 /* Don't return anything if we got no register information above,
1647 such a core file is useless. */
1648 if (args
->note_data
!= NULL
)
1649 if (!siginfo_data
.empty ())
1650 args
->note_data
= elfcore_write_note (args
->obfd
,
1654 siginfo_data
.data (),
1655 siginfo_data
.size ());
1658 /* Fill the PRPSINFO structure with information about the process being
1659 debugged. Returns 1 in case of success, 0 for failures. Please note that
1660 even if the structure cannot be entirely filled (e.g., GDB was unable to
1661 gather information about the process UID/GID), this function will still
1662 return 1 since some information was already recorded. It will only return
1663 0 iff nothing can be gathered. */
1666 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1668 /* The filename which we will use to obtain some info about the process.
1669 We will basically use this to store the `/proc/PID/FILENAME' file. */
1671 /* The basename of the executable. */
1672 const char *basename
;
1673 const char *infargs
;
1674 /* Temporary buffer. */
1676 /* The valid states of a process, according to the Linux kernel. */
1677 const char valid_states
[] = "RSDTZW";
1678 /* The program state. */
1679 const char *prog_state
;
1680 /* The state of the process. */
1682 /* The PID of the program which generated the corefile. */
1684 /* Process flags. */
1685 unsigned int pr_flag
;
1686 /* Process nice value. */
1688 /* The number of fields read by `sscanf'. */
1691 gdb_assert (p
!= NULL
);
1693 /* Obtaining PID and filename. */
1694 pid
= inferior_ptid
.pid ();
1695 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1696 /* The full name of the program which generated the corefile. */
1697 gdb::unique_xmalloc_ptr
<char> fname
1698 = target_fileio_read_stralloc (NULL
, filename
);
1700 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1702 /* No program name was read, so we won't be able to retrieve more
1703 information about the process. */
1707 memset (p
, 0, sizeof (*p
));
1709 /* Defining the PID. */
1712 /* Copying the program name. Only the basename matters. */
1713 basename
= lbasename (fname
.get ());
1714 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
) - 1);
1715 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1717 infargs
= get_inferior_args ();
1719 /* The arguments of the program. */
1720 std::string psargs
= fname
.get ();
1721 if (infargs
!= NULL
)
1722 psargs
= psargs
+ " " + infargs
;
1724 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
) - 1);
1725 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1727 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1728 /* The contents of `/proc/PID/stat'. */
1729 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1730 = target_fileio_read_stralloc (NULL
, filename
);
1731 char *proc_stat
= proc_stat_contents
.get ();
1733 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1735 /* Despite being unable to read more information about the
1736 process, we return 1 here because at least we have its
1737 command line, PID and arguments. */
1741 /* Ok, we have the stats. It's time to do a little parsing of the
1742 contents of the buffer, so that we end up reading what we want.
1744 The following parsing mechanism is strongly based on the
1745 information generated by the `fs/proc/array.c' file, present in
1746 the Linux kernel tree. More details about how the information is
1747 displayed can be obtained by seeing the manpage of proc(5),
1748 specifically under the entry of `/proc/[pid]/stat'. */
1750 /* Getting rid of the PID, since we already have it. */
1751 while (isdigit (*proc_stat
))
1754 proc_stat
= skip_spaces (proc_stat
);
1756 /* ps command also relies on no trailing fields ever contain ')'. */
1757 proc_stat
= strrchr (proc_stat
, ')');
1758 if (proc_stat
== NULL
)
1762 proc_stat
= skip_spaces (proc_stat
);
1764 n_fields
= sscanf (proc_stat
,
1765 "%c" /* Process state. */
1766 "%d%d%d" /* Parent PID, group ID, session ID. */
1767 "%*d%*d" /* tty_nr, tpgid (not used). */
1769 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1770 cmajflt (not used). */
1771 "%*s%*s%*s%*s" /* utime, stime, cutime,
1772 cstime (not used). */
1773 "%*s" /* Priority (not used). */
1776 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1782 /* Again, we couldn't read the complementary information about
1783 the process state. However, we already have minimal
1784 information, so we just return 1 here. */
1788 /* Filling the structure fields. */
1789 prog_state
= strchr (valid_states
, pr_sname
);
1790 if (prog_state
!= NULL
)
1791 p
->pr_state
= prog_state
- valid_states
;
1794 /* Zero means "Running". */
1798 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1799 p
->pr_zomb
= p
->pr_sname
== 'Z';
1800 p
->pr_nice
= pr_nice
;
1801 p
->pr_flag
= pr_flag
;
1803 /* Finally, obtaining the UID and GID. For that, we read and parse the
1804 contents of the `/proc/PID/status' file. */
1805 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1806 /* The contents of `/proc/PID/status'. */
1807 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1808 = target_fileio_read_stralloc (NULL
, filename
);
1809 char *proc_status
= proc_status_contents
.get ();
1811 if (proc_status
== NULL
|| *proc_status
== '\0')
1813 /* Returning 1 since we already have a bunch of information. */
1817 /* Extracting the UID. */
1818 tmpstr
= strstr (proc_status
, "Uid:");
1821 /* Advancing the pointer to the beginning of the UID. */
1822 tmpstr
+= sizeof ("Uid:");
1823 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1826 if (isdigit (*tmpstr
))
1827 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1830 /* Extracting the GID. */
1831 tmpstr
= strstr (proc_status
, "Gid:");
1834 /* Advancing the pointer to the beginning of the GID. */
1835 tmpstr
+= sizeof ("Gid:");
1836 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1839 if (isdigit (*tmpstr
))
1840 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1846 /* Find the signalled thread. In case there's more than one signalled
1847 thread, prefer the current thread, if it is signalled. If no
1848 thread was signalled, default to the current thread, unless it has
1849 exited, in which case return NULL. */
1851 static thread_info
*
1852 find_signalled_thread ()
1854 thread_info
*curr_thr
= inferior_thread ();
1855 if (curr_thr
->state
!= THREAD_EXITED
1856 && curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1859 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1860 if (thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1863 /* Default to the current thread, unless it has exited. */
1864 if (curr_thr
->state
!= THREAD_EXITED
)
1870 /* Build the note section for a corefile, and return it in a malloc
1874 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1876 struct linux_corefile_thread_data thread_args
;
1877 struct elf_internal_linux_prpsinfo prpsinfo
;
1878 char *note_data
= NULL
;
1880 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1883 if (linux_fill_prpsinfo (&prpsinfo
))
1885 if (gdbarch_ptr_bit (gdbarch
) == 64)
1886 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1887 note_data
, note_size
,
1890 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1891 note_data
, note_size
,
1895 /* Thread register information. */
1898 update_thread_list ();
1900 catch (const gdb_exception_error
&e
)
1902 exception_print (gdb_stderr
, e
);
1905 /* Like the kernel, prefer dumping the signalled thread first.
1906 "First thread" is what tools use to infer the signalled
1908 thread_info
*signalled_thr
= find_signalled_thread ();
1910 thread_args
.gdbarch
= gdbarch
;
1911 thread_args
.obfd
= obfd
;
1912 thread_args
.note_data
= note_data
;
1913 thread_args
.note_size
= note_size
;
1914 if (signalled_thr
!= nullptr)
1915 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1917 thread_args
.stop_signal
= GDB_SIGNAL_0
;
1919 if (signalled_thr
!= nullptr)
1920 linux_corefile_thread (signalled_thr
, &thread_args
);
1921 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1923 if (thr
== signalled_thr
)
1926 linux_corefile_thread (thr
, &thread_args
);
1929 note_data
= thread_args
.note_data
;
1933 /* Auxillary vector. */
1934 gdb::optional
<gdb::byte_vector
> auxv
=
1935 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
1936 if (auxv
&& !auxv
->empty ())
1938 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1939 "CORE", NT_AUXV
, auxv
->data (),
1946 /* File mappings. */
1947 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1948 note_data
, note_size
);
1953 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1954 gdbarch.h. This function is not static because it is exported to
1955 other -tdep files. */
1958 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1963 return GDB_SIGNAL_0
;
1966 return GDB_SIGNAL_HUP
;
1969 return GDB_SIGNAL_INT
;
1972 return GDB_SIGNAL_QUIT
;
1975 return GDB_SIGNAL_ILL
;
1978 return GDB_SIGNAL_TRAP
;
1981 return GDB_SIGNAL_ABRT
;
1984 return GDB_SIGNAL_BUS
;
1987 return GDB_SIGNAL_FPE
;
1990 return GDB_SIGNAL_KILL
;
1993 return GDB_SIGNAL_USR1
;
1996 return GDB_SIGNAL_SEGV
;
1999 return GDB_SIGNAL_USR2
;
2002 return GDB_SIGNAL_PIPE
;
2005 return GDB_SIGNAL_ALRM
;
2008 return GDB_SIGNAL_TERM
;
2011 return GDB_SIGNAL_CHLD
;
2014 return GDB_SIGNAL_CONT
;
2017 return GDB_SIGNAL_STOP
;
2020 return GDB_SIGNAL_TSTP
;
2023 return GDB_SIGNAL_TTIN
;
2026 return GDB_SIGNAL_TTOU
;
2029 return GDB_SIGNAL_URG
;
2032 return GDB_SIGNAL_XCPU
;
2035 return GDB_SIGNAL_XFSZ
;
2037 case LINUX_SIGVTALRM
:
2038 return GDB_SIGNAL_VTALRM
;
2041 return GDB_SIGNAL_PROF
;
2043 case LINUX_SIGWINCH
:
2044 return GDB_SIGNAL_WINCH
;
2046 /* No way to differentiate between SIGIO and SIGPOLL.
2047 Therefore, we just handle the first one. */
2049 return GDB_SIGNAL_IO
;
2052 return GDB_SIGNAL_PWR
;
2055 return GDB_SIGNAL_SYS
;
2057 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2058 therefore we have to handle them here. */
2059 case LINUX_SIGRTMIN
:
2060 return GDB_SIGNAL_REALTIME_32
;
2062 case LINUX_SIGRTMAX
:
2063 return GDB_SIGNAL_REALTIME_64
;
2066 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2068 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2070 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2073 return GDB_SIGNAL_UNKNOWN
;
2076 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2077 gdbarch.h. This function is not static because it is exported to
2078 other -tdep files. */
2081 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2082 enum gdb_signal signal
)
2089 case GDB_SIGNAL_HUP
:
2090 return LINUX_SIGHUP
;
2092 case GDB_SIGNAL_INT
:
2093 return LINUX_SIGINT
;
2095 case GDB_SIGNAL_QUIT
:
2096 return LINUX_SIGQUIT
;
2098 case GDB_SIGNAL_ILL
:
2099 return LINUX_SIGILL
;
2101 case GDB_SIGNAL_TRAP
:
2102 return LINUX_SIGTRAP
;
2104 case GDB_SIGNAL_ABRT
:
2105 return LINUX_SIGABRT
;
2107 case GDB_SIGNAL_FPE
:
2108 return LINUX_SIGFPE
;
2110 case GDB_SIGNAL_KILL
:
2111 return LINUX_SIGKILL
;
2113 case GDB_SIGNAL_BUS
:
2114 return LINUX_SIGBUS
;
2116 case GDB_SIGNAL_SEGV
:
2117 return LINUX_SIGSEGV
;
2119 case GDB_SIGNAL_SYS
:
2120 return LINUX_SIGSYS
;
2122 case GDB_SIGNAL_PIPE
:
2123 return LINUX_SIGPIPE
;
2125 case GDB_SIGNAL_ALRM
:
2126 return LINUX_SIGALRM
;
2128 case GDB_SIGNAL_TERM
:
2129 return LINUX_SIGTERM
;
2131 case GDB_SIGNAL_URG
:
2132 return LINUX_SIGURG
;
2134 case GDB_SIGNAL_STOP
:
2135 return LINUX_SIGSTOP
;
2137 case GDB_SIGNAL_TSTP
:
2138 return LINUX_SIGTSTP
;
2140 case GDB_SIGNAL_CONT
:
2141 return LINUX_SIGCONT
;
2143 case GDB_SIGNAL_CHLD
:
2144 return LINUX_SIGCHLD
;
2146 case GDB_SIGNAL_TTIN
:
2147 return LINUX_SIGTTIN
;
2149 case GDB_SIGNAL_TTOU
:
2150 return LINUX_SIGTTOU
;
2155 case GDB_SIGNAL_XCPU
:
2156 return LINUX_SIGXCPU
;
2158 case GDB_SIGNAL_XFSZ
:
2159 return LINUX_SIGXFSZ
;
2161 case GDB_SIGNAL_VTALRM
:
2162 return LINUX_SIGVTALRM
;
2164 case GDB_SIGNAL_PROF
:
2165 return LINUX_SIGPROF
;
2167 case GDB_SIGNAL_WINCH
:
2168 return LINUX_SIGWINCH
;
2170 case GDB_SIGNAL_USR1
:
2171 return LINUX_SIGUSR1
;
2173 case GDB_SIGNAL_USR2
:
2174 return LINUX_SIGUSR2
;
2176 case GDB_SIGNAL_PWR
:
2177 return LINUX_SIGPWR
;
2179 case GDB_SIGNAL_POLL
:
2180 return LINUX_SIGPOLL
;
2182 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2183 therefore we have to handle it here. */
2184 case GDB_SIGNAL_REALTIME_32
:
2185 return LINUX_SIGRTMIN
;
2187 /* Same comment applies to _64. */
2188 case GDB_SIGNAL_REALTIME_64
:
2189 return LINUX_SIGRTMAX
;
2192 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2193 if (signal
>= GDB_SIGNAL_REALTIME_33
2194 && signal
<= GDB_SIGNAL_REALTIME_63
)
2196 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2198 return LINUX_SIGRTMIN
+ 1 + offset
;
2204 /* Helper for linux_vsyscall_range that does the real work of finding
2205 the vsyscall's address range. */
2208 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2213 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2216 /* It doesn't make sense to access the host's /proc when debugging a
2217 core file. Instead, look for the PT_LOAD segment that matches
2219 if (!target_has_execution
)
2224 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2225 if (phdrs_size
== -1)
2228 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2229 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2230 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2231 if (num_phdrs
== -1)
2234 for (i
= 0; i
< num_phdrs
; i
++)
2235 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2236 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2238 range
->length
= phdrs
.get ()[i
].p_memsz
;
2245 /* We need to know the real target PID to access /proc. */
2246 if (current_inferior ()->fake_pid_p
)
2249 pid
= current_inferior ()->pid
;
2251 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2252 reading /proc/PID/maps (2). The later identifies thread stacks
2253 in the output, which requires scanning every thread in the thread
2254 group to check whether a VMA is actually a thread's stack. With
2255 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2256 a few thousand threads, (1) takes a few miliseconds, while (2)
2257 takes several seconds. Also note that "smaps", what we read for
2258 determining core dump mappings, is even slower than "maps". */
2259 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2260 gdb::unique_xmalloc_ptr
<char> data
2261 = target_fileio_read_stralloc (NULL
, filename
);
2265 char *saveptr
= NULL
;
2267 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2269 line
= strtok_r (NULL
, "\n", &saveptr
))
2271 ULONGEST addr
, endaddr
;
2272 const char *p
= line
;
2274 addr
= strtoulst (p
, &p
, 16);
2275 if (addr
== range
->start
)
2279 endaddr
= strtoulst (p
, &p
, 16);
2280 range
->length
= endaddr
- addr
;
2286 warning (_("unable to open /proc file '%s'"), filename
);
2291 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2292 caching, and defers the real work to linux_vsyscall_range_raw. */
2295 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2297 struct linux_info
*info
= get_linux_inferior_data ();
2299 if (info
->vsyscall_range_p
== 0)
2301 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2302 info
->vsyscall_range_p
= 1;
2304 info
->vsyscall_range_p
= -1;
2307 if (info
->vsyscall_range_p
< 0)
2310 *range
= info
->vsyscall_range
;
2314 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2315 definitions would be dependent on compilation host. */
2316 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2317 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2319 /* See gdbarch.sh 'infcall_mmap'. */
2322 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2324 struct objfile
*objf
;
2325 /* Do there still exist any Linux systems without "mmap64"?
2326 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2327 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2328 struct value
*addr_val
;
2329 struct gdbarch
*gdbarch
= objf
->arch ();
2333 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2335 struct value
*arg
[ARG_LAST
];
2337 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2339 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2340 arg
[ARG_LENGTH
] = value_from_ulongest
2341 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2342 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2343 | GDB_MMAP_PROT_EXEC
))
2345 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2346 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2347 GDB_MMAP_MAP_PRIVATE
2348 | GDB_MMAP_MAP_ANONYMOUS
);
2349 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2350 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2352 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2353 retval
= value_as_address (addr_val
);
2354 if (retval
== (CORE_ADDR
) -1)
2355 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2360 /* See gdbarch.sh 'infcall_munmap'. */
2363 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2365 struct objfile
*objf
;
2366 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2367 struct value
*retval_val
;
2368 struct gdbarch
*gdbarch
= objf
->arch ();
2372 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2374 struct value
*arg
[ARG_LAST
];
2376 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2378 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2379 arg
[ARG_LENGTH
] = value_from_ulongest
2380 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2381 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2382 retval
= value_as_long (retval_val
);
2384 warning (_("Failed inferior munmap call at %s for %s bytes, "
2385 "errno is changed."),
2386 hex_string (addr
), pulongest (size
));
2389 /* See linux-tdep.h. */
2392 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2397 /* Determine entry point from target auxiliary vector. This avoids
2398 the need for symbols. Also, when debugging a stand-alone SPU
2399 executable, entry_point_address () will point to an SPU
2400 local-store address and is thus not usable as displaced stepping
2401 location. The auxiliary vector gets us the PowerPC-side entry
2402 point address instead. */
2403 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2404 throw_error (NOT_SUPPORTED_ERROR
,
2405 _("Cannot find AT_ENTRY auxiliary vector entry."));
2407 /* Make certain that the address points at real code, and not a
2408 function descriptor. */
2409 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2410 current_top_target ());
2412 /* Inferior calls also use the entry point as a breakpoint location.
2413 We don't want displaced stepping to interfere with those
2414 breakpoints, so leave space. */
2415 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2421 /* See linux-tdep.h. */
2424 linux_get_hwcap (struct target_ops
*target
)
2427 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2432 /* See linux-tdep.h. */
2435 linux_get_hwcap2 (struct target_ops
*target
)
2438 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2443 /* Display whether the gcore command is using the
2444 /proc/PID/coredump_filter file. */
2447 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2448 struct cmd_list_element
*c
, const char *value
)
2450 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2451 " corefiles is %s.\n"), value
);
2454 /* Display whether the gcore command is dumping mappings marked with
2455 the VM_DONTDUMP flag. */
2458 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2459 struct cmd_list_element
*c
, const char *value
)
2461 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2462 " flag is %s.\n"), value
);
2465 /* To be called from the various GDB_OSABI_LINUX handlers for the
2466 various GNU/Linux architectures and machine types. */
2469 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2471 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2472 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2473 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2474 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2475 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2476 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2477 set_gdbarch_has_shared_address_space (gdbarch
,
2478 linux_has_shared_address_space
);
2479 set_gdbarch_gdb_signal_from_target (gdbarch
,
2480 linux_gdb_signal_from_target
);
2481 set_gdbarch_gdb_signal_to_target (gdbarch
,
2482 linux_gdb_signal_to_target
);
2483 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2484 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2485 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2486 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2489 void _initialize_linux_tdep ();
2491 _initialize_linux_tdep ()
2493 linux_gdbarch_data_handle
=
2494 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2496 /* Observers used to invalidate the cache when needed. */
2497 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2498 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2500 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2501 &use_coredump_filter
, _("\
2502 Set whether gcore should consider /proc/PID/coredump_filter."),
2504 Show whether gcore should consider /proc/PID/coredump_filter."),
2506 Use this command to set whether gcore should consider the contents\n\
2507 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2508 about this file, refer to the manpage of core(5)."),
2509 NULL
, show_use_coredump_filter
,
2510 &setlist
, &showlist
);
2512 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2513 &dump_excluded_mappings
, _("\
2514 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2516 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2518 Use this command to set whether gcore should dump mappings marked with the\n\
2519 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2520 more information about this file, refer to the manpage of proc(5) and core(5)."),
2521 NULL
, show_dump_excluded_mappings
,
2522 &setlist
, &showlist
);