1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2019 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 TYPE_NAME (sigval_type
) = 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 TYPE_NAME (siginfo_type
) = 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 /* Let's check if we have an ELF header. */
705 gdb::unique_xmalloc_ptr
<char> header
;
708 /* Useful define specifying the size of the ELF magical
714 /* Read the first SELFMAG bytes and check if it is ELFMAG. */
715 if (target_read_string (addr
, &header
, SELFMAG
, &errcode
) == SELFMAG
718 const char *h
= header
.get ();
720 /* The EI_MAG* and ELFMAG* constants come from
722 if (h
[EI_MAG0
] == ELFMAG0
&& h
[EI_MAG1
] == ELFMAG1
723 && h
[EI_MAG2
] == ELFMAG2
&& h
[EI_MAG3
] == ELFMAG3
)
725 /* This mapping contains an ELF header, so we
735 /* Implement the "info proc" command. */
738 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
739 enum info_proc_what what
)
741 /* A long is used for pid instead of an int to avoid a loss of precision
742 compiler warning from the output of strtoul. */
744 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
745 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
746 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
747 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
748 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
749 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
753 if (args
&& isdigit (args
[0]))
757 pid
= strtoul (args
, &tem
, 10);
762 if (!target_has_execution
)
763 error (_("No current process: you must name one."));
764 if (current_inferior ()->fake_pid_p
)
765 error (_("Can't determine the current process's PID: you must name one."));
767 pid
= current_inferior ()->pid
;
770 args
= skip_spaces (args
);
772 error (_("Too many parameters: %s"), args
);
774 printf_filtered (_("process %ld\n"), pid
);
777 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
779 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
783 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
786 for (pos
= 0; pos
< len
- 1; pos
++)
788 if (buffer
[pos
] == '\0')
791 buffer
[len
- 1] = '\0';
792 printf_filtered ("cmdline = '%s'\n", buffer
);
795 warning (_("unable to open /proc file '%s'"), filename
);
799 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
800 gdb::optional
<std::string
> contents
801 = target_fileio_readlink (NULL
, filename
, &target_errno
);
802 if (contents
.has_value ())
803 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
805 warning (_("unable to read link '%s'"), filename
);
809 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
810 gdb::optional
<std::string
> contents
811 = target_fileio_readlink (NULL
, filename
, &target_errno
);
812 if (contents
.has_value ())
813 printf_filtered ("exe = '%s'\n", contents
->c_str ());
815 warning (_("unable to read link '%s'"), filename
);
819 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
820 gdb::unique_xmalloc_ptr
<char> map
821 = target_fileio_read_stralloc (NULL
, filename
);
826 printf_filtered (_("Mapped address spaces:\n\n"));
827 if (gdbarch_addr_bit (gdbarch
) == 32)
829 printf_filtered ("\t%10s %10s %10s %10s %s\n",
832 " Size", " Offset", "objfile");
836 printf_filtered (" %18s %18s %10s %10s %s\n",
839 " Size", " Offset", "objfile");
842 for (line
= strtok (map
.get (), "\n");
844 line
= strtok (NULL
, "\n"))
846 ULONGEST addr
, endaddr
, offset
, inode
;
847 const char *permissions
, *device
, *mapping_filename
;
848 size_t permissions_len
, device_len
;
850 read_mapping (line
, &addr
, &endaddr
,
851 &permissions
, &permissions_len
,
852 &offset
, &device
, &device_len
,
853 &inode
, &mapping_filename
);
855 if (gdbarch_addr_bit (gdbarch
) == 32)
857 printf_filtered ("\t%10s %10s %10s %10s %s\n",
858 paddress (gdbarch
, addr
),
859 paddress (gdbarch
, endaddr
),
860 hex_string (endaddr
- addr
),
862 *mapping_filename
? mapping_filename
: "");
866 printf_filtered (" %18s %18s %10s %10s %s\n",
867 paddress (gdbarch
, addr
),
868 paddress (gdbarch
, endaddr
),
869 hex_string (endaddr
- addr
),
871 *mapping_filename
? mapping_filename
: "");
876 warning (_("unable to open /proc file '%s'"), filename
);
880 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
881 gdb::unique_xmalloc_ptr
<char> status
882 = target_fileio_read_stralloc (NULL
, filename
);
884 puts_filtered (status
.get ());
886 warning (_("unable to open /proc file '%s'"), filename
);
890 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
891 gdb::unique_xmalloc_ptr
<char> statstr
892 = target_fileio_read_stralloc (NULL
, filename
);
895 const char *p
= statstr
.get ();
897 printf_filtered (_("Process: %s\n"),
898 pulongest (strtoulst (p
, &p
, 10)));
903 /* ps command also relies on no trailing fields
905 const char *ep
= strrchr (p
, ')');
908 printf_filtered ("Exec file: %.*s\n",
909 (int) (ep
- p
- 1), p
+ 1);
916 printf_filtered (_("State: %c\n"), *p
++);
919 printf_filtered (_("Parent process: %s\n"),
920 pulongest (strtoulst (p
, &p
, 10)));
922 printf_filtered (_("Process group: %s\n"),
923 pulongest (strtoulst (p
, &p
, 10)));
925 printf_filtered (_("Session id: %s\n"),
926 pulongest (strtoulst (p
, &p
, 10)));
928 printf_filtered (_("TTY: %s\n"),
929 pulongest (strtoulst (p
, &p
, 10)));
931 printf_filtered (_("TTY owner process group: %s\n"),
932 pulongest (strtoulst (p
, &p
, 10)));
935 printf_filtered (_("Flags: %s\n"),
936 hex_string (strtoulst (p
, &p
, 10)));
938 printf_filtered (_("Minor faults (no memory page): %s\n"),
939 pulongest (strtoulst (p
, &p
, 10)));
941 printf_filtered (_("Minor faults, children: %s\n"),
942 pulongest (strtoulst (p
, &p
, 10)));
944 printf_filtered (_("Major faults (memory page faults): %s\n"),
945 pulongest (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("Major faults, children: %s\n"),
948 pulongest (strtoulst (p
, &p
, 10)));
950 printf_filtered (_("utime: %s\n"),
951 pulongest (strtoulst (p
, &p
, 10)));
953 printf_filtered (_("stime: %s\n"),
954 pulongest (strtoulst (p
, &p
, 10)));
956 printf_filtered (_("utime, children: %s\n"),
957 pulongest (strtoulst (p
, &p
, 10)));
959 printf_filtered (_("stime, children: %s\n"),
960 pulongest (strtoulst (p
, &p
, 10)));
962 printf_filtered (_("jiffies remaining in current "
964 pulongest (strtoulst (p
, &p
, 10)));
966 printf_filtered (_("'nice' value: %s\n"),
967 pulongest (strtoulst (p
, &p
, 10)));
969 printf_filtered (_("jiffies until next timeout: %s\n"),
970 pulongest (strtoulst (p
, &p
, 10)));
972 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
973 pulongest (strtoulst (p
, &p
, 10)));
975 printf_filtered (_("start time (jiffies since "
976 "system boot): %s\n"),
977 pulongest (strtoulst (p
, &p
, 10)));
979 printf_filtered (_("Virtual memory size: %s\n"),
980 pulongest (strtoulst (p
, &p
, 10)));
982 printf_filtered (_("Resident set size: %s\n"),
983 pulongest (strtoulst (p
, &p
, 10)));
985 printf_filtered (_("rlim: %s\n"),
986 pulongest (strtoulst (p
, &p
, 10)));
988 printf_filtered (_("Start of text: %s\n"),
989 hex_string (strtoulst (p
, &p
, 10)));
991 printf_filtered (_("End of text: %s\n"),
992 hex_string (strtoulst (p
, &p
, 10)));
994 printf_filtered (_("Start of stack: %s\n"),
995 hex_string (strtoulst (p
, &p
, 10)));
996 #if 0 /* Don't know how architecture-dependent the rest is...
997 Anyway the signal bitmap info is available from "status". */
999 printf_filtered (_("Kernel stack pointer: %s\n"),
1000 hex_string (strtoulst (p
, &p
, 10)));
1002 printf_filtered (_("Kernel instr pointer: %s\n"),
1003 hex_string (strtoulst (p
, &p
, 10)));
1005 printf_filtered (_("Pending signals bitmap: %s\n"),
1006 hex_string (strtoulst (p
, &p
, 10)));
1008 printf_filtered (_("Blocked signals bitmap: %s\n"),
1009 hex_string (strtoulst (p
, &p
, 10)));
1011 printf_filtered (_("Ignored signals bitmap: %s\n"),
1012 hex_string (strtoulst (p
, &p
, 10)));
1014 printf_filtered (_("Catched signals bitmap: %s\n"),
1015 hex_string (strtoulst (p
, &p
, 10)));
1017 printf_filtered (_("wchan (system call): %s\n"),
1018 hex_string (strtoulst (p
, &p
, 10)));
1022 warning (_("unable to open /proc file '%s'"), filename
);
1026 /* Implement "info proc mappings" for a corefile. */
1029 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1032 ULONGEST count
, page_size
;
1033 unsigned char *descdata
, *filenames
, *descend
;
1035 unsigned int addr_size_bits
, addr_size
;
1036 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
1037 /* We assume this for reading 64-bit core files. */
1038 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1040 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1041 if (section
== NULL
)
1043 warning (_("unable to find mappings in core file"));
1047 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1048 addr_size
= addr_size_bits
/ 8;
1049 note_size
= bfd_section_size (section
);
1051 if (note_size
< 2 * addr_size
)
1052 error (_("malformed core note - too short for header"));
1054 gdb::def_vector
<unsigned char> contents (note_size
);
1055 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1057 error (_("could not get core note contents"));
1059 descdata
= contents
.data ();
1060 descend
= descdata
+ note_size
;
1062 if (descdata
[note_size
- 1] != '\0')
1063 error (_("malformed note - does not end with \\0"));
1065 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1066 descdata
+= addr_size
;
1068 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1069 descdata
+= addr_size
;
1071 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1072 error (_("malformed note - too short for supplied file count"));
1074 printf_filtered (_("Mapped address spaces:\n\n"));
1075 if (gdbarch_addr_bit (gdbarch
) == 32)
1077 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1080 " Size", " Offset", "objfile");
1084 printf_filtered (" %18s %18s %10s %10s %s\n",
1087 " Size", " Offset", "objfile");
1090 filenames
= descdata
+ count
* 3 * addr_size
;
1093 ULONGEST start
, end
, file_ofs
;
1095 if (filenames
== descend
)
1096 error (_("malformed note - filenames end too early"));
1098 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1099 descdata
+= addr_size
;
1100 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1101 descdata
+= addr_size
;
1102 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1103 descdata
+= addr_size
;
1105 file_ofs
*= page_size
;
1107 if (gdbarch_addr_bit (gdbarch
) == 32)
1108 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1109 paddress (gdbarch
, start
),
1110 paddress (gdbarch
, end
),
1111 hex_string (end
- start
),
1112 hex_string (file_ofs
),
1115 printf_filtered (" %18s %18s %10s %10s %s\n",
1116 paddress (gdbarch
, start
),
1117 paddress (gdbarch
, end
),
1118 hex_string (end
- start
),
1119 hex_string (file_ofs
),
1122 filenames
+= 1 + strlen ((char *) filenames
);
1126 /* Implement "info proc" for a corefile. */
1129 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1130 enum info_proc_what what
)
1132 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1133 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1139 exe
= bfd_core_file_failing_command (core_bfd
);
1141 printf_filtered ("exe = '%s'\n", exe
);
1143 warning (_("unable to find command name in core file"));
1147 linux_core_info_proc_mappings (gdbarch
, args
);
1149 if (!exe_f
&& !mappings_f
)
1150 error (_("unable to handle request"));
1153 /* Read siginfo data from the core, if possible. Returns -1 on
1154 failure. Otherwise, returns the number of bytes read. READBUF,
1155 OFFSET, and LEN are all as specified by the to_xfer_partial
1159 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1160 ULONGEST offset
, ULONGEST len
)
1162 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1163 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1164 if (section
== NULL
)
1167 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1173 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1174 ULONGEST offset
, ULONGEST inode
,
1175 int read
, int write
,
1176 int exec
, int modified
,
1177 const char *filename
,
1180 /* List memory regions in the inferior for a corefile. */
1183 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1184 linux_find_memory_region_ftype
*func
,
1187 char mapsfilename
[100];
1188 char coredumpfilter_name
[100];
1190 /* Default dump behavior of coredump_filter (0x33), according to
1191 Documentation/filesystems/proc.txt from the Linux kernel
1193 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1194 | COREFILTER_ANON_SHARED
1195 | COREFILTER_ELF_HEADERS
1196 | COREFILTER_HUGETLB_PRIVATE
);
1198 /* We need to know the real target PID to access /proc. */
1199 if (current_inferior ()->fake_pid_p
)
1202 pid
= current_inferior ()->pid
;
1204 if (use_coredump_filter
)
1206 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1207 "/proc/%d/coredump_filter", pid
);
1208 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1209 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1210 if (coredumpfilterdata
!= NULL
)
1214 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1215 filterflags
= (enum filter_flag
) flags
;
1219 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1220 gdb::unique_xmalloc_ptr
<char> data
1221 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1224 /* Older Linux kernels did not support /proc/PID/smaps. */
1225 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1226 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1233 line
= strtok_r (data
.get (), "\n", &t
);
1234 while (line
!= NULL
)
1236 ULONGEST addr
, endaddr
, offset
, inode
;
1237 const char *permissions
, *device
, *filename
;
1238 struct smaps_vmflags v
;
1239 size_t permissions_len
, device_len
;
1240 int read
, write
, exec
, priv
;
1241 int has_anonymous
= 0;
1242 int should_dump_p
= 0;
1246 memset (&v
, 0, sizeof (v
));
1247 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1248 &offset
, &device
, &device_len
, &inode
, &filename
);
1249 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1250 /* If the mapping is not anonymous, then we can consider it
1251 to be file-backed. These two states (anonymous or
1252 file-backed) seem to be exclusive, but they can actually
1253 coexist. For example, if a file-backed mapping has
1254 "Anonymous:" pages (see more below), then the Linux
1255 kernel will dump this mapping when the user specified
1256 that she only wants anonymous mappings in the corefile
1257 (*even* when she explicitly disabled the dumping of
1258 file-backed mappings). */
1259 mapping_file_p
= !mapping_anon_p
;
1261 /* Decode permissions. */
1262 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1263 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1264 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1265 /* 'private' here actually means VM_MAYSHARE, and not
1266 VM_SHARED. In order to know if a mapping is really
1267 private or not, we must check the flag "sh" in the
1268 VmFlags field. This is done by decode_vmflags. However,
1269 if we are using a Linux kernel released before the commit
1270 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1271 not have the VmFlags there. In this case, there is
1272 really no way to know if we are dealing with VM_SHARED,
1273 so we just assume that VM_MAYSHARE is enough. */
1274 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1276 /* Try to detect if region should be dumped by parsing smaps
1278 for (line
= strtok_r (NULL
, "\n", &t
);
1279 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1280 line
= strtok_r (NULL
, "\n", &t
))
1282 char keyword
[64 + 1];
1284 if (sscanf (line
, "%64s", keyword
) != 1)
1286 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1290 if (strcmp (keyword
, "Anonymous:") == 0)
1292 /* Older Linux kernels did not support the
1293 "Anonymous:" counter. Check it here. */
1296 else if (strcmp (keyword
, "VmFlags:") == 0)
1297 decode_vmflags (line
, &v
);
1299 if (strcmp (keyword
, "AnonHugePages:") == 0
1300 || strcmp (keyword
, "Anonymous:") == 0)
1302 unsigned long number
;
1304 if (sscanf (line
, "%*s%lu", &number
) != 1)
1306 warning (_("Error parsing {s,}maps file '%s' number"),
1312 /* Even if we are dealing with a file-backed
1313 mapping, if it contains anonymous pages we
1314 consider it to be *also* an anonymous
1315 mapping, because this is what the Linux
1318 // Dump segments that have been written to.
1319 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1322 Note that if the mapping is already marked as
1323 file-backed (i.e., mapping_file_p is
1324 non-zero), then this is a special case, and
1325 this mapping will be dumped either when the
1326 user wants to dump file-backed *or* anonymous
1334 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1335 mapping_anon_p
, mapping_file_p
,
1336 filename
, addr
, offset
);
1339 /* Older Linux kernels did not support the "Anonymous:" counter.
1340 If it is missing, we can't be sure - dump all the pages. */
1344 /* Invoke the callback function to create the corefile segment. */
1346 func (addr
, endaddr
- addr
, offset
, inode
,
1347 read
, write
, exec
, 1, /* MODIFIED is true because we
1348 want to dump the mapping. */
1358 /* A structure for passing information through
1359 linux_find_memory_regions_full. */
1361 struct linux_find_memory_regions_data
1363 /* The original callback. */
1365 find_memory_region_ftype func
;
1367 /* The original datum. */
1372 /* A callback for linux_find_memory_regions that converts between the
1373 "full"-style callback and find_memory_region_ftype. */
1376 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1377 ULONGEST offset
, ULONGEST inode
,
1378 int read
, int write
, int exec
, int modified
,
1379 const char *filename
, void *arg
)
1381 struct linux_find_memory_regions_data
*data
1382 = (struct linux_find_memory_regions_data
*) arg
;
1384 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1387 /* A variant of linux_find_memory_regions_full that is suitable as the
1388 gdbarch find_memory_regions method. */
1391 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1392 find_memory_region_ftype func
, void *obfd
)
1394 struct linux_find_memory_regions_data data
;
1399 return linux_find_memory_regions_full (gdbarch
,
1400 linux_find_memory_regions_thunk
,
1404 /* Determine which signal stopped execution. */
1407 find_signalled_thread (struct thread_info
*info
, void *data
)
1409 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1410 && info
->ptid
.pid () == inferior_ptid
.pid ())
1416 /* This is used to pass information from
1417 linux_make_mappings_corefile_notes through
1418 linux_find_memory_regions_full. */
1420 struct linux_make_mappings_data
1422 /* Number of files mapped. */
1423 ULONGEST file_count
;
1425 /* The obstack for the main part of the data. */
1426 struct obstack
*data_obstack
;
1428 /* The filename obstack. */
1429 struct obstack
*filename_obstack
;
1431 /* The architecture's "long" type. */
1432 struct type
*long_type
;
1435 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1437 /* A callback for linux_find_memory_regions_full that updates the
1438 mappings data for linux_make_mappings_corefile_notes. */
1441 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1442 ULONGEST offset
, ULONGEST inode
,
1443 int read
, int write
, int exec
, int modified
,
1444 const char *filename
, void *data
)
1446 struct linux_make_mappings_data
*map_data
1447 = (struct linux_make_mappings_data
*) data
;
1448 gdb_byte buf
[sizeof (ULONGEST
)];
1450 if (*filename
== '\0' || inode
== 0)
1453 ++map_data
->file_count
;
1455 pack_long (buf
, map_data
->long_type
, vaddr
);
1456 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1457 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1458 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1459 pack_long (buf
, map_data
->long_type
, offset
);
1460 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1462 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1467 /* Write the file mapping data to the core file, if possible. OBFD is
1468 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1469 is a pointer to the note size. Returns the new NOTE_DATA and
1470 updates NOTE_SIZE. */
1473 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1474 char *note_data
, int *note_size
)
1476 struct linux_make_mappings_data mapping_data
;
1477 struct type
*long_type
1478 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1479 gdb_byte buf
[sizeof (ULONGEST
)];
1481 auto_obstack data_obstack
, filename_obstack
;
1483 mapping_data
.file_count
= 0;
1484 mapping_data
.data_obstack
= &data_obstack
;
1485 mapping_data
.filename_obstack
= &filename_obstack
;
1486 mapping_data
.long_type
= long_type
;
1488 /* Reserve space for the count. */
1489 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1490 /* We always write the page size as 1 since we have no good way to
1491 determine the correct value. */
1492 pack_long (buf
, long_type
, 1);
1493 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1495 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1498 if (mapping_data
.file_count
!= 0)
1500 /* Write the count to the obstack. */
1501 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1502 long_type
, mapping_data
.file_count
);
1504 /* Copy the filenames to the data obstack. */
1505 int size
= obstack_object_size (&filename_obstack
);
1506 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1509 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1511 obstack_base (&data_obstack
),
1512 obstack_object_size (&data_obstack
));
1518 /* Structure for passing information from
1519 linux_collect_thread_registers via an iterator to
1520 linux_collect_regset_section_cb. */
1522 struct linux_collect_regset_section_cb_data
1524 struct gdbarch
*gdbarch
;
1525 const struct regcache
*regcache
;
1530 enum gdb_signal stop_signal
;
1531 int abort_iteration
;
1534 /* Callback for iterate_over_regset_sections that records a single
1535 regset in the corefile note section. */
1538 linux_collect_regset_section_cb (const char *sect_name
, int supply_size
,
1539 int collect_size
, const struct regset
*regset
,
1540 const char *human_name
, void *cb_data
)
1542 struct linux_collect_regset_section_cb_data
*data
1543 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1544 bool variable_size_section
= (regset
!= NULL
1545 && regset
->flags
& REGSET_VARIABLE_SIZE
);
1547 if (!variable_size_section
)
1548 gdb_assert (supply_size
== collect_size
);
1550 if (data
->abort_iteration
)
1553 gdb_assert (regset
&& regset
->collect_regset
);
1555 /* This is intentionally zero-initialized by using std::vector, so
1556 that any padding bytes in the core file will show as 0. */
1557 std::vector
<gdb_byte
> buf (collect_size
);
1559 regset
->collect_regset (regset
, data
->regcache
, -1, buf
.data (),
1562 /* PRSTATUS still needs to be treated specially. */
1563 if (strcmp (sect_name
, ".reg") == 0)
1564 data
->note_data
= (char *) elfcore_write_prstatus
1565 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1566 gdb_signal_to_host (data
->stop_signal
), buf
.data ());
1568 data
->note_data
= (char *) elfcore_write_register_note
1569 (data
->obfd
, data
->note_data
, data
->note_size
,
1570 sect_name
, buf
.data (), collect_size
);
1572 if (data
->note_data
== NULL
)
1573 data
->abort_iteration
= 1;
1576 /* Records the thread's register state for the corefile note
1580 linux_collect_thread_registers (const struct regcache
*regcache
,
1581 ptid_t ptid
, bfd
*obfd
,
1582 char *note_data
, int *note_size
,
1583 enum gdb_signal stop_signal
)
1585 struct gdbarch
*gdbarch
= regcache
->arch ();
1586 struct linux_collect_regset_section_cb_data data
;
1588 data
.gdbarch
= gdbarch
;
1589 data
.regcache
= regcache
;
1591 data
.note_data
= note_data
;
1592 data
.note_size
= note_size
;
1593 data
.stop_signal
= stop_signal
;
1594 data
.abort_iteration
= 0;
1596 /* For remote targets the LWP may not be available, so use the TID. */
1597 data
.lwp
= ptid
.lwp ();
1599 data
.lwp
= ptid
.tid ();
1601 gdbarch_iterate_over_regset_sections (gdbarch
,
1602 linux_collect_regset_section_cb
,
1604 return data
.note_data
;
1607 /* Fetch the siginfo data for the specified thread, if it exists. If
1608 there is no data, or we could not read it, return an empty
1611 static gdb::byte_vector
1612 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1614 struct type
*siginfo_type
;
1617 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1618 return gdb::byte_vector ();
1620 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1621 inferior_ptid
= thread
->ptid
;
1623 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1625 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1627 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1628 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1629 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1635 struct linux_corefile_thread_data
1637 struct gdbarch
*gdbarch
;
1641 enum gdb_signal stop_signal
;
1644 /* Records the thread's register state for the corefile note
1648 linux_corefile_thread (struct thread_info
*info
,
1649 struct linux_corefile_thread_data
*args
)
1651 struct regcache
*regcache
;
1653 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1655 target_fetch_registers (regcache
, -1);
1656 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1658 args
->note_data
= linux_collect_thread_registers
1659 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1660 args
->note_size
, args
->stop_signal
);
1662 /* Don't return anything if we got no register information above,
1663 such a core file is useless. */
1664 if (args
->note_data
!= NULL
)
1665 if (!siginfo_data
.empty ())
1666 args
->note_data
= elfcore_write_note (args
->obfd
,
1670 siginfo_data
.data (),
1671 siginfo_data
.size ());
1674 /* Fill the PRPSINFO structure with information about the process being
1675 debugged. Returns 1 in case of success, 0 for failures. Please note that
1676 even if the structure cannot be entirely filled (e.g., GDB was unable to
1677 gather information about the process UID/GID), this function will still
1678 return 1 since some information was already recorded. It will only return
1679 0 iff nothing can be gathered. */
1682 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1684 /* The filename which we will use to obtain some info about the process.
1685 We will basically use this to store the `/proc/PID/FILENAME' file. */
1687 /* The basename of the executable. */
1688 const char *basename
;
1689 const char *infargs
;
1690 /* Temporary buffer. */
1692 /* The valid states of a process, according to the Linux kernel. */
1693 const char valid_states
[] = "RSDTZW";
1694 /* The program state. */
1695 const char *prog_state
;
1696 /* The state of the process. */
1698 /* The PID of the program which generated the corefile. */
1700 /* Process flags. */
1701 unsigned int pr_flag
;
1702 /* Process nice value. */
1704 /* The number of fields read by `sscanf'. */
1707 gdb_assert (p
!= NULL
);
1709 /* Obtaining PID and filename. */
1710 pid
= inferior_ptid
.pid ();
1711 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1712 /* The full name of the program which generated the corefile. */
1713 gdb::unique_xmalloc_ptr
<char> fname
1714 = target_fileio_read_stralloc (NULL
, filename
);
1716 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1718 /* No program name was read, so we won't be able to retrieve more
1719 information about the process. */
1723 memset (p
, 0, sizeof (*p
));
1725 /* Defining the PID. */
1728 /* Copying the program name. Only the basename matters. */
1729 basename
= lbasename (fname
.get ());
1730 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1731 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1733 infargs
= get_inferior_args ();
1735 /* The arguments of the program. */
1736 std::string psargs
= fname
.get ();
1737 if (infargs
!= NULL
)
1738 psargs
= psargs
+ " " + infargs
;
1740 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
));
1741 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1743 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1744 /* The contents of `/proc/PID/stat'. */
1745 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1746 = target_fileio_read_stralloc (NULL
, filename
);
1747 char *proc_stat
= proc_stat_contents
.get ();
1749 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1751 /* Despite being unable to read more information about the
1752 process, we return 1 here because at least we have its
1753 command line, PID and arguments. */
1757 /* Ok, we have the stats. It's time to do a little parsing of the
1758 contents of the buffer, so that we end up reading what we want.
1760 The following parsing mechanism is strongly based on the
1761 information generated by the `fs/proc/array.c' file, present in
1762 the Linux kernel tree. More details about how the information is
1763 displayed can be obtained by seeing the manpage of proc(5),
1764 specifically under the entry of `/proc/[pid]/stat'. */
1766 /* Getting rid of the PID, since we already have it. */
1767 while (isdigit (*proc_stat
))
1770 proc_stat
= skip_spaces (proc_stat
);
1772 /* ps command also relies on no trailing fields ever contain ')'. */
1773 proc_stat
= strrchr (proc_stat
, ')');
1774 if (proc_stat
== NULL
)
1778 proc_stat
= skip_spaces (proc_stat
);
1780 n_fields
= sscanf (proc_stat
,
1781 "%c" /* Process state. */
1782 "%d%d%d" /* Parent PID, group ID, session ID. */
1783 "%*d%*d" /* tty_nr, tpgid (not used). */
1785 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1786 cmajflt (not used). */
1787 "%*s%*s%*s%*s" /* utime, stime, cutime,
1788 cstime (not used). */
1789 "%*s" /* Priority (not used). */
1792 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1798 /* Again, we couldn't read the complementary information about
1799 the process state. However, we already have minimal
1800 information, so we just return 1 here. */
1804 /* Filling the structure fields. */
1805 prog_state
= strchr (valid_states
, pr_sname
);
1806 if (prog_state
!= NULL
)
1807 p
->pr_state
= prog_state
- valid_states
;
1810 /* Zero means "Running". */
1814 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1815 p
->pr_zomb
= p
->pr_sname
== 'Z';
1816 p
->pr_nice
= pr_nice
;
1817 p
->pr_flag
= pr_flag
;
1819 /* Finally, obtaining the UID and GID. For that, we read and parse the
1820 contents of the `/proc/PID/status' file. */
1821 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1822 /* The contents of `/proc/PID/status'. */
1823 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1824 = target_fileio_read_stralloc (NULL
, filename
);
1825 char *proc_status
= proc_status_contents
.get ();
1827 if (proc_status
== NULL
|| *proc_status
== '\0')
1829 /* Returning 1 since we already have a bunch of information. */
1833 /* Extracting the UID. */
1834 tmpstr
= strstr (proc_status
, "Uid:");
1837 /* Advancing the pointer to the beginning of the UID. */
1838 tmpstr
+= sizeof ("Uid:");
1839 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1842 if (isdigit (*tmpstr
))
1843 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1846 /* Extracting the GID. */
1847 tmpstr
= strstr (proc_status
, "Gid:");
1850 /* Advancing the pointer to the beginning of the GID. */
1851 tmpstr
+= sizeof ("Gid:");
1852 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1855 if (isdigit (*tmpstr
))
1856 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1862 /* Build the note section for a corefile, and return it in a malloc
1866 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1868 struct linux_corefile_thread_data thread_args
;
1869 struct elf_internal_linux_prpsinfo prpsinfo
;
1870 char *note_data
= NULL
;
1871 struct thread_info
*curr_thr
, *signalled_thr
;
1873 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1876 if (linux_fill_prpsinfo (&prpsinfo
))
1878 if (gdbarch_ptr_bit (gdbarch
) == 64)
1879 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1880 note_data
, note_size
,
1883 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1884 note_data
, note_size
,
1888 /* Thread register information. */
1891 update_thread_list ();
1893 catch (const gdb_exception_error
&e
)
1895 exception_print (gdb_stderr
, e
);
1898 /* Like the kernel, prefer dumping the signalled thread first.
1899 "First thread" is what tools use to infer the signalled thread.
1900 In case there's more than one signalled thread, prefer the
1901 current thread, if it is signalled. */
1902 curr_thr
= inferior_thread ();
1903 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1904 signalled_thr
= curr_thr
;
1907 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
1908 if (signalled_thr
== NULL
)
1909 signalled_thr
= curr_thr
;
1912 thread_args
.gdbarch
= gdbarch
;
1913 thread_args
.obfd
= obfd
;
1914 thread_args
.note_data
= note_data
;
1915 thread_args
.note_size
= note_size
;
1916 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1918 linux_corefile_thread (signalled_thr
, &thread_args
);
1919 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
1921 if (thr
== signalled_thr
)
1924 linux_corefile_thread (thr
, &thread_args
);
1927 note_data
= thread_args
.note_data
;
1931 /* Auxillary vector. */
1932 gdb::optional
<gdb::byte_vector
> auxv
=
1933 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
1934 if (auxv
&& !auxv
->empty ())
1936 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1937 "CORE", NT_AUXV
, auxv
->data (),
1944 /* File mappings. */
1945 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1946 note_data
, note_size
);
1951 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1952 gdbarch.h. This function is not static because it is exported to
1953 other -tdep files. */
1956 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1961 return GDB_SIGNAL_0
;
1964 return GDB_SIGNAL_HUP
;
1967 return GDB_SIGNAL_INT
;
1970 return GDB_SIGNAL_QUIT
;
1973 return GDB_SIGNAL_ILL
;
1976 return GDB_SIGNAL_TRAP
;
1979 return GDB_SIGNAL_ABRT
;
1982 return GDB_SIGNAL_BUS
;
1985 return GDB_SIGNAL_FPE
;
1988 return GDB_SIGNAL_KILL
;
1991 return GDB_SIGNAL_USR1
;
1994 return GDB_SIGNAL_SEGV
;
1997 return GDB_SIGNAL_USR2
;
2000 return GDB_SIGNAL_PIPE
;
2003 return GDB_SIGNAL_ALRM
;
2006 return GDB_SIGNAL_TERM
;
2009 return GDB_SIGNAL_CHLD
;
2012 return GDB_SIGNAL_CONT
;
2015 return GDB_SIGNAL_STOP
;
2018 return GDB_SIGNAL_TSTP
;
2021 return GDB_SIGNAL_TTIN
;
2024 return GDB_SIGNAL_TTOU
;
2027 return GDB_SIGNAL_URG
;
2030 return GDB_SIGNAL_XCPU
;
2033 return GDB_SIGNAL_XFSZ
;
2035 case LINUX_SIGVTALRM
:
2036 return GDB_SIGNAL_VTALRM
;
2039 return GDB_SIGNAL_PROF
;
2041 case LINUX_SIGWINCH
:
2042 return GDB_SIGNAL_WINCH
;
2044 /* No way to differentiate between SIGIO and SIGPOLL.
2045 Therefore, we just handle the first one. */
2047 return GDB_SIGNAL_IO
;
2050 return GDB_SIGNAL_PWR
;
2053 return GDB_SIGNAL_SYS
;
2055 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2056 therefore we have to handle them here. */
2057 case LINUX_SIGRTMIN
:
2058 return GDB_SIGNAL_REALTIME_32
;
2060 case LINUX_SIGRTMAX
:
2061 return GDB_SIGNAL_REALTIME_64
;
2064 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2066 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2068 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2071 return GDB_SIGNAL_UNKNOWN
;
2074 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2075 gdbarch.h. This function is not static because it is exported to
2076 other -tdep files. */
2079 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2080 enum gdb_signal signal
)
2087 case GDB_SIGNAL_HUP
:
2088 return LINUX_SIGHUP
;
2090 case GDB_SIGNAL_INT
:
2091 return LINUX_SIGINT
;
2093 case GDB_SIGNAL_QUIT
:
2094 return LINUX_SIGQUIT
;
2096 case GDB_SIGNAL_ILL
:
2097 return LINUX_SIGILL
;
2099 case GDB_SIGNAL_TRAP
:
2100 return LINUX_SIGTRAP
;
2102 case GDB_SIGNAL_ABRT
:
2103 return LINUX_SIGABRT
;
2105 case GDB_SIGNAL_FPE
:
2106 return LINUX_SIGFPE
;
2108 case GDB_SIGNAL_KILL
:
2109 return LINUX_SIGKILL
;
2111 case GDB_SIGNAL_BUS
:
2112 return LINUX_SIGBUS
;
2114 case GDB_SIGNAL_SEGV
:
2115 return LINUX_SIGSEGV
;
2117 case GDB_SIGNAL_SYS
:
2118 return LINUX_SIGSYS
;
2120 case GDB_SIGNAL_PIPE
:
2121 return LINUX_SIGPIPE
;
2123 case GDB_SIGNAL_ALRM
:
2124 return LINUX_SIGALRM
;
2126 case GDB_SIGNAL_TERM
:
2127 return LINUX_SIGTERM
;
2129 case GDB_SIGNAL_URG
:
2130 return LINUX_SIGURG
;
2132 case GDB_SIGNAL_STOP
:
2133 return LINUX_SIGSTOP
;
2135 case GDB_SIGNAL_TSTP
:
2136 return LINUX_SIGTSTP
;
2138 case GDB_SIGNAL_CONT
:
2139 return LINUX_SIGCONT
;
2141 case GDB_SIGNAL_CHLD
:
2142 return LINUX_SIGCHLD
;
2144 case GDB_SIGNAL_TTIN
:
2145 return LINUX_SIGTTIN
;
2147 case GDB_SIGNAL_TTOU
:
2148 return LINUX_SIGTTOU
;
2153 case GDB_SIGNAL_XCPU
:
2154 return LINUX_SIGXCPU
;
2156 case GDB_SIGNAL_XFSZ
:
2157 return LINUX_SIGXFSZ
;
2159 case GDB_SIGNAL_VTALRM
:
2160 return LINUX_SIGVTALRM
;
2162 case GDB_SIGNAL_PROF
:
2163 return LINUX_SIGPROF
;
2165 case GDB_SIGNAL_WINCH
:
2166 return LINUX_SIGWINCH
;
2168 case GDB_SIGNAL_USR1
:
2169 return LINUX_SIGUSR1
;
2171 case GDB_SIGNAL_USR2
:
2172 return LINUX_SIGUSR2
;
2174 case GDB_SIGNAL_PWR
:
2175 return LINUX_SIGPWR
;
2177 case GDB_SIGNAL_POLL
:
2178 return LINUX_SIGPOLL
;
2180 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2181 therefore we have to handle it here. */
2182 case GDB_SIGNAL_REALTIME_32
:
2183 return LINUX_SIGRTMIN
;
2185 /* Same comment applies to _64. */
2186 case GDB_SIGNAL_REALTIME_64
:
2187 return LINUX_SIGRTMAX
;
2190 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2191 if (signal
>= GDB_SIGNAL_REALTIME_33
2192 && signal
<= GDB_SIGNAL_REALTIME_63
)
2194 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2196 return LINUX_SIGRTMIN
+ 1 + offset
;
2202 /* Helper for linux_vsyscall_range that does the real work of finding
2203 the vsyscall's address range. */
2206 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2211 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2214 /* It doesn't make sense to access the host's /proc when debugging a
2215 core file. Instead, look for the PT_LOAD segment that matches
2217 if (!target_has_execution
)
2222 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2223 if (phdrs_size
== -1)
2226 gdb::unique_xmalloc_ptr
<Elf_Internal_Phdr
>
2227 phdrs ((Elf_Internal_Phdr
*) xmalloc (phdrs_size
));
2228 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
.get ());
2229 if (num_phdrs
== -1)
2232 for (i
= 0; i
< num_phdrs
; i
++)
2233 if (phdrs
.get ()[i
].p_type
== PT_LOAD
2234 && phdrs
.get ()[i
].p_vaddr
== range
->start
)
2236 range
->length
= phdrs
.get ()[i
].p_memsz
;
2243 /* We need to know the real target PID to access /proc. */
2244 if (current_inferior ()->fake_pid_p
)
2247 pid
= current_inferior ()->pid
;
2249 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2250 reading /proc/PID/maps (2). The later identifies thread stacks
2251 in the output, which requires scanning every thread in the thread
2252 group to check whether a VMA is actually a thread's stack. With
2253 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2254 a few thousand threads, (1) takes a few miliseconds, while (2)
2255 takes several seconds. Also note that "smaps", what we read for
2256 determining core dump mappings, is even slower than "maps". */
2257 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2258 gdb::unique_xmalloc_ptr
<char> data
2259 = target_fileio_read_stralloc (NULL
, filename
);
2263 char *saveptr
= NULL
;
2265 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2267 line
= strtok_r (NULL
, "\n", &saveptr
))
2269 ULONGEST addr
, endaddr
;
2270 const char *p
= line
;
2272 addr
= strtoulst (p
, &p
, 16);
2273 if (addr
== range
->start
)
2277 endaddr
= strtoulst (p
, &p
, 16);
2278 range
->length
= endaddr
- addr
;
2284 warning (_("unable to open /proc file '%s'"), filename
);
2289 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2290 caching, and defers the real work to linux_vsyscall_range_raw. */
2293 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2295 struct linux_info
*info
= get_linux_inferior_data ();
2297 if (info
->vsyscall_range_p
== 0)
2299 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2300 info
->vsyscall_range_p
= 1;
2302 info
->vsyscall_range_p
= -1;
2305 if (info
->vsyscall_range_p
< 0)
2308 *range
= info
->vsyscall_range
;
2312 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2313 definitions would be dependent on compilation host. */
2314 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2315 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2317 /* See gdbarch.sh 'infcall_mmap'. */
2320 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2322 struct objfile
*objf
;
2323 /* Do there still exist any Linux systems without "mmap64"?
2324 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2325 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2326 struct value
*addr_val
;
2327 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2331 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2333 struct value
*arg
[ARG_LAST
];
2335 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2337 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2338 arg
[ARG_LENGTH
] = value_from_ulongest
2339 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2340 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2341 | GDB_MMAP_PROT_EXEC
))
2343 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2344 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2345 GDB_MMAP_MAP_PRIVATE
2346 | GDB_MMAP_MAP_ANONYMOUS
);
2347 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2348 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2350 addr_val
= call_function_by_hand (mmap_val
, NULL
, arg
);
2351 retval
= value_as_address (addr_val
);
2352 if (retval
== (CORE_ADDR
) -1)
2353 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2358 /* See gdbarch.sh 'infcall_munmap'. */
2361 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2363 struct objfile
*objf
;
2364 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2365 struct value
*retval_val
;
2366 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2370 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2372 struct value
*arg
[ARG_LAST
];
2374 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2376 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2377 arg
[ARG_LENGTH
] = value_from_ulongest
2378 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2379 retval_val
= call_function_by_hand (munmap_val
, NULL
, arg
);
2380 retval
= value_as_long (retval_val
);
2382 warning (_("Failed inferior munmap call at %s for %s bytes, "
2383 "errno is changed."),
2384 hex_string (addr
), pulongest (size
));
2387 /* See linux-tdep.h. */
2390 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2395 /* Determine entry point from target auxiliary vector. This avoids
2396 the need for symbols. Also, when debugging a stand-alone SPU
2397 executable, entry_point_address () will point to an SPU
2398 local-store address and is thus not usable as displaced stepping
2399 location. The auxiliary vector gets us the PowerPC-side entry
2400 point address instead. */
2401 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2402 throw_error (NOT_SUPPORTED_ERROR
,
2403 _("Cannot find AT_ENTRY auxiliary vector entry."));
2405 /* Make certain that the address points at real code, and not a
2406 function descriptor. */
2407 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2408 current_top_target ());
2410 /* Inferior calls also use the entry point as a breakpoint location.
2411 We don't want displaced stepping to interfere with those
2412 breakpoints, so leave space. */
2413 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2419 /* See linux-tdep.h. */
2422 linux_get_hwcap (struct target_ops
*target
)
2425 if (target_auxv_search (target
, AT_HWCAP
, &field
) != 1)
2430 /* See linux-tdep.h. */
2433 linux_get_hwcap2 (struct target_ops
*target
)
2436 if (target_auxv_search (target
, AT_HWCAP2
, &field
) != 1)
2441 /* Display whether the gcore command is using the
2442 /proc/PID/coredump_filter file. */
2445 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2446 struct cmd_list_element
*c
, const char *value
)
2448 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2449 " corefiles is %s.\n"), value
);
2452 /* Display whether the gcore command is dumping mappings marked with
2453 the VM_DONTDUMP flag. */
2456 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2457 struct cmd_list_element
*c
, const char *value
)
2459 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2460 " flag is %s.\n"), value
);
2463 /* To be called from the various GDB_OSABI_LINUX handlers for the
2464 various GNU/Linux architectures and machine types. */
2467 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2469 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2470 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2471 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2472 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2473 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2474 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2475 set_gdbarch_has_shared_address_space (gdbarch
,
2476 linux_has_shared_address_space
);
2477 set_gdbarch_gdb_signal_from_target (gdbarch
,
2478 linux_gdb_signal_from_target
);
2479 set_gdbarch_gdb_signal_to_target (gdbarch
,
2480 linux_gdb_signal_to_target
);
2481 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2482 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2483 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2484 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2488 _initialize_linux_tdep (void)
2490 linux_gdbarch_data_handle
=
2491 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2493 /* Observers used to invalidate the cache when needed. */
2494 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2495 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2497 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2498 &use_coredump_filter
, _("\
2499 Set whether gcore should consider /proc/PID/coredump_filter."),
2501 Show whether gcore should consider /proc/PID/coredump_filter."),
2503 Use this command to set whether gcore should consider the contents\n\
2504 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2505 about this file, refer to the manpage of core(5)."),
2506 NULL
, show_use_coredump_filter
,
2507 &setlist
, &showlist
);
2509 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2510 &dump_excluded_mappings
, _("\
2511 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2513 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2515 Use this command to set whether gcore should dump mappings marked with the\n\
2516 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2517 more information about this file, refer to the manpage of proc(5) and core(5)."),
2518 NULL
, show_dump_excluded_mappings
,
2519 &setlist
, &showlist
);