1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2017 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"
39 #include "gdb_regex.h"
40 #include "common/enum-flags.h"
41 #include "common/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 int use_coredump_filter
= 1;
96 /* This enum represents the signals' numbers on a generic architecture
97 running the Linux kernel. The definition of "generic" comes from
98 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
99 tree, which is the "de facto" implementation of signal numbers to
100 be used by new architecture ports.
102 For those architectures which have differences between the generic
103 standard (e.g., Alpha), we define the different signals (and *only*
104 those) in the specific target-dependent file (e.g.,
105 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
106 tdep file for more information.
108 ARM deserves a special mention here. On the file
109 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
110 (and ARM-only) signal, which is SIGSWI, with the same number as
111 SIGRTMIN. This signal is used only for a very specific target,
112 called ArthurOS (from RISCOS). Therefore, we do not handle it on
113 the ARM-tdep file, and we can safely use the generic signal handler
114 here for ARM targets.
116 As stated above, this enum is derived from
117 <include/uapi/asm-generic/signal.h>, from the Linux kernel
138 LINUX_SIGSTKFLT
= 16,
148 LINUX_SIGVTALRM
= 26,
152 LINUX_SIGPOLL
= LINUX_SIGIO
,
155 LINUX_SIGUNUSED
= 31,
161 static struct gdbarch_data
*linux_gdbarch_data_handle
;
163 struct linux_gdbarch_data
165 struct type
*siginfo_type
;
169 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
171 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
174 static struct linux_gdbarch_data
*
175 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
177 return ((struct linux_gdbarch_data
*)
178 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
181 /* Per-inferior data key. */
182 static const struct inferior_data
*linux_inferior_data
;
184 /* Linux-specific cached data. This is used by GDB for caching
185 purposes for each inferior. This helps reduce the overhead of
186 transfering data from a remote target to the local host. */
189 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
190 if VSYSCALL_RANGE_P is positive. This is cached because getting
191 at this info requires an auxv lookup (which is itself cached),
192 and looking through the inferior's mappings (which change
193 throughout execution and therefore cannot be cached). */
194 struct mem_range vsyscall_range
;
196 /* Zero if we haven't tried looking up the vsyscall's range before
197 yet. Positive if we tried looking it up, and found it. Negative
198 if we tried looking it up but failed. */
199 int vsyscall_range_p
;
202 /* Frees whatever allocated space there is to be freed and sets INF's
203 linux cache data pointer to NULL. */
206 invalidate_linux_cache_inf (struct inferior
*inf
)
208 struct linux_info
*info
;
210 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
214 set_inferior_data (inf
, linux_inferior_data
, NULL
);
218 /* Handles the cleanup of the linux cache for inferior INF. ARG is
219 ignored. Callback for the inferior_appeared and inferior_exit
223 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
225 invalidate_linux_cache_inf (inf
);
228 /* Fetch the linux cache info for INF. This function always returns a
229 valid INFO pointer. */
231 static struct linux_info
*
232 get_linux_inferior_data (void)
234 struct linux_info
*info
;
235 struct inferior
*inf
= current_inferior ();
237 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
240 info
= XCNEW (struct linux_info
);
241 set_inferior_data (inf
, linux_inferior_data
, info
);
247 /* See linux-tdep.h. */
250 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
251 linux_siginfo_extra_fields extra_fields
)
253 struct linux_gdbarch_data
*linux_gdbarch_data
;
254 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
255 struct type
*uid_type
, *pid_type
;
256 struct type
*sigval_type
, *clock_type
;
257 struct type
*siginfo_type
, *sifields_type
;
260 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
261 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
262 return linux_gdbarch_data
->siginfo_type
;
264 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
266 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
268 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
270 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
272 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
275 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
276 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
277 append_composite_type_field (sigval_type
, "sival_int", int_type
);
278 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
281 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
282 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
283 TYPE_TARGET_TYPE (pid_type
) = int_type
;
284 TYPE_TARGET_STUB (pid_type
) = 1;
287 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
288 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
289 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
290 TYPE_TARGET_STUB (uid_type
) = 1;
293 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
294 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
296 TYPE_TARGET_TYPE (clock_type
) = long_type
;
297 TYPE_TARGET_STUB (clock_type
) = 1;
300 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
303 const int si_max_size
= 128;
305 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
308 if (gdbarch_ptr_bit (gdbarch
) == 64)
309 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
311 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
312 append_composite_type_field (sifields_type
, "_pad",
313 init_vector_type (int_type
, si_pad_size
));
317 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
318 append_composite_type_field (type
, "si_pid", pid_type
);
319 append_composite_type_field (type
, "si_uid", uid_type
);
320 append_composite_type_field (sifields_type
, "_kill", type
);
323 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
324 append_composite_type_field (type
, "si_tid", int_type
);
325 append_composite_type_field (type
, "si_overrun", int_type
);
326 append_composite_type_field (type
, "si_sigval", sigval_type
);
327 append_composite_type_field (sifields_type
, "_timer", type
);
330 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
331 append_composite_type_field (type
, "si_pid", pid_type
);
332 append_composite_type_field (type
, "si_uid", uid_type
);
333 append_composite_type_field (type
, "si_sigval", sigval_type
);
334 append_composite_type_field (sifields_type
, "_rt", type
);
337 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
338 append_composite_type_field (type
, "si_pid", pid_type
);
339 append_composite_type_field (type
, "si_uid", uid_type
);
340 append_composite_type_field (type
, "si_status", int_type
);
341 append_composite_type_field (type
, "si_utime", clock_type
);
342 append_composite_type_field (type
, "si_stime", clock_type
);
343 append_composite_type_field (sifields_type
, "_sigchld", type
);
346 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
347 append_composite_type_field (type
, "si_addr", void_ptr_type
);
349 /* Additional bound fields for _sigfault in case they were requested. */
350 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
352 struct type
*sigfault_bnd_fields
;
354 append_composite_type_field (type
, "_addr_lsb", short_type
);
355 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
356 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
357 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
358 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
360 append_composite_type_field (sifields_type
, "_sigfault", type
);
363 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
364 append_composite_type_field (type
, "si_band", long_type
);
365 append_composite_type_field (type
, "si_fd", int_type
);
366 append_composite_type_field (sifields_type
, "_sigpoll", type
);
369 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
370 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
371 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
372 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
373 append_composite_type_field (siginfo_type
, "si_code", int_type
);
374 append_composite_type_field_aligned (siginfo_type
,
375 "_sifields", sifields_type
,
376 TYPE_LENGTH (long_type
));
378 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
383 /* This function is suitable for architectures that don't
384 extend/override the standard siginfo structure. */
387 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
389 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
392 /* Return true if the target is running on uClinux instead of normal
396 linux_is_uclinux (void)
400 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
401 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
405 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
407 return linux_is_uclinux ();
410 /* This is how we want PTIDs from core files to be printed. */
413 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
417 if (ptid_get_lwp (ptid
) != 0)
419 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
423 return normal_pid_to_str (ptid
);
426 /* Service function for corefiles and info proc. */
429 read_mapping (const char *line
,
430 ULONGEST
*addr
, ULONGEST
*endaddr
,
431 const char **permissions
, size_t *permissions_len
,
433 const char **device
, size_t *device_len
,
435 const char **filename
)
437 const char *p
= line
;
439 *addr
= strtoulst (p
, &p
, 16);
442 *endaddr
= strtoulst (p
, &p
, 16);
446 while (*p
&& !isspace (*p
))
448 *permissions_len
= p
- *permissions
;
450 *offset
= strtoulst (p
, &p
, 16);
454 while (*p
&& !isspace (*p
))
456 *device_len
= p
- *device
;
458 *inode
= strtoulst (p
, &p
, 10);
464 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
466 This function was based on the documentation found on
467 <Documentation/filesystems/proc.txt>, on the Linux kernel.
469 Linux kernels before commit
470 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
474 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
476 char *saveptr
= NULL
;
479 v
->initialized_p
= 1;
480 p
= skip_to_space (p
);
483 for (s
= strtok_r (p
, " ", &saveptr
);
485 s
= strtok_r (NULL
, " ", &saveptr
))
487 if (strcmp (s
, "io") == 0)
489 else if (strcmp (s
, "ht") == 0)
490 v
->uses_huge_tlb
= 1;
491 else if (strcmp (s
, "dd") == 0)
492 v
->exclude_coredump
= 1;
493 else if (strcmp (s
, "sh") == 0)
494 v
->shared_mapping
= 1;
498 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
499 they're initialized lazily. */
501 struct mapping_regexes
503 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
504 string in the end). We know for sure, based on the Linux kernel
505 code, that memory mappings whose associated filename is
506 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
507 compiled_regex dev_zero
508 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
509 _("Could not compile regex to match /dev/zero filename")};
511 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
512 string in the end). These filenames refer to shared memory
513 (shmem), and memory mappings associated with them are
514 MAP_ANONYMOUS as well. */
515 compiled_regex shmem_file
516 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
517 _("Could not compile regex to match shmem filenames")};
519 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
520 0' code, which is responsible to decide if it is dealing with a
521 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
522 FILE_DELETED matches, it does not necessarily mean that we are
523 dealing with an anonymous shared mapping. However, there is no
524 easy way to detect this currently, so this is the best
525 approximation we have.
527 As a result, GDB will dump readonly pages of deleted executables
528 when using the default value of coredump_filter (0x33), while the
529 Linux kernel will not dump those pages. But we can live with
531 compiled_regex file_deleted
532 {" (deleted)$", REG_NOSUB
,
533 _("Could not compile regex to match '<file> (deleted)'")};
536 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
538 FILENAME is the name of the file present in the first line of the
539 memory mapping, in the "/proc/PID/smaps" output. For example, if
542 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
544 Then FILENAME will be "/path/to/file". */
547 mapping_is_anonymous_p (const char *filename
)
549 static gdb::optional
<mapping_regexes
> regexes
;
550 static int init_regex_p
= 0;
554 /* Let's be pessimistic and assume there will be an error while
555 compiling the regex'es. */
560 /* If we reached this point, then everything succeeded. */
564 if (init_regex_p
== -1)
566 const char deleted
[] = " (deleted)";
567 size_t del_len
= sizeof (deleted
) - 1;
568 size_t filename_len
= strlen (filename
);
570 /* There was an error while compiling the regex'es above. In
571 order to try to give some reliable information to the caller,
572 we just try to find the string " (deleted)" in the filename.
573 If we managed to find it, then we assume the mapping is
575 return (filename_len
>= del_len
576 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
579 if (*filename
== '\0'
580 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
581 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
582 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
588 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
589 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
590 greater than 0 if it should.
592 In a nutshell, this is the logic that we follow in order to decide
593 if a mapping should be dumped or not.
595 - If the mapping is associated to a file whose name ends with
596 " (deleted)", or if the file is "/dev/zero", or if it is
597 "/SYSV%08x" (shared memory), or if there is no file associated
598 with it, or if the AnonHugePages: or the Anonymous: fields in the
599 /proc/PID/smaps have contents, then GDB considers this mapping to
600 be anonymous. Otherwise, GDB considers this mapping to be a
601 file-backed mapping (because there will be a file associated with
604 It is worth mentioning that, from all those checks described
605 above, the most fragile is the one to see if the file name ends
606 with " (deleted)". This does not necessarily mean that the
607 mapping is anonymous, because the deleted file associated with
608 the mapping may have been a hard link to another file, for
609 example. The Linux kernel checks to see if "i_nlink == 0", but
610 GDB cannot easily (and normally) do this check (iff running as
611 root, it could find the mapping in /proc/PID/map_files/ and
612 determine whether there still are other hard links to the
613 inode/file). Therefore, we made a compromise here, and we assume
614 that if the file name ends with " (deleted)", then the mapping is
615 indeed anonymous. FWIW, this is something the Linux kernel could
616 do better: expose this information in a more direct way.
618 - If we see the flag "sh" in the "VmFlags:" field (in
619 /proc/PID/smaps), then certainly the memory mapping is shared
620 (VM_SHARED). If we have access to the VmFlags, and we don't see
621 the "sh" there, then certainly the mapping is private. However,
622 Linux kernels before commit
623 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
624 "VmFlags:" field; in that case, we use another heuristic: if we
625 see 'p' in the permission flags, then we assume that the mapping
626 is private, even though the presence of the 's' flag there would
627 mean VM_MAYSHARE, which means the mapping could still be private.
628 This should work OK enough, however. */
631 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
632 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
633 const char *filename
)
635 /* Initially, we trust in what we received from our caller. This
636 value may not be very precise (i.e., it was probably gathered
637 from the permission line in the /proc/PID/smaps list, which
638 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
639 what we have until we take a look at the "VmFlags:" field
640 (assuming that the version of the Linux kernel being used
641 supports it, of course). */
642 int private_p
= maybe_private_p
;
644 /* We always dump vDSO and vsyscall mappings, because it's likely that
645 there'll be no file to read the contents from at core load time.
646 The kernel does the same. */
647 if (strcmp ("[vdso]", filename
) == 0
648 || strcmp ("[vsyscall]", filename
) == 0)
651 if (v
->initialized_p
)
653 /* We never dump I/O mappings. */
657 /* Check if we should exclude this mapping. */
658 if (v
->exclude_coredump
)
661 /* Update our notion of whether this mapping is shared or
662 private based on a trustworthy value. */
663 private_p
= !v
->shared_mapping
;
665 /* HugeTLB checking. */
666 if (v
->uses_huge_tlb
)
668 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
669 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
678 if (mapping_anon_p
&& mapping_file_p
)
680 /* This is a special situation. It can happen when we see a
681 mapping that is file-backed, but that contains anonymous
683 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
684 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
686 else if (mapping_anon_p
)
687 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
689 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
693 if (mapping_anon_p
&& mapping_file_p
)
695 /* This is a special situation. It can happen when we see a
696 mapping that is file-backed, but that contains anonymous
698 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
699 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
701 else if (mapping_anon_p
)
702 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
704 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
708 /* Implement the "info proc" command. */
711 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
712 enum info_proc_what what
)
714 /* A long is used for pid instead of an int to avoid a loss of precision
715 compiler warning from the output of strtoul. */
717 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
718 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
719 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
720 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
721 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
722 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
727 if (args
&& isdigit (args
[0]))
731 pid
= strtoul (args
, &tem
, 10);
736 if (!target_has_execution
)
737 error (_("No current process: you must name one."));
738 if (current_inferior ()->fake_pid_p
)
739 error (_("Can't determine the current process's PID: you must name one."));
741 pid
= current_inferior ()->pid
;
744 args
= skip_spaces (args
);
746 error (_("Too many parameters: %s"), args
);
748 printf_filtered (_("process %ld\n"), pid
);
751 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
752 gdb::unique_xmalloc_ptr
<char> cmdline
753 = target_fileio_read_stralloc (NULL
, filename
);
755 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
757 warning (_("unable to open /proc file '%s'"), filename
);
761 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
762 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
765 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
766 printf_filtered ("cwd = '%s'\n", data
);
767 do_cleanups (cleanup
);
770 warning (_("unable to read link '%s'"), filename
);
774 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
775 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
778 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
779 printf_filtered ("exe = '%s'\n", data
);
780 do_cleanups (cleanup
);
783 warning (_("unable to read link '%s'"), filename
);
787 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
788 gdb::unique_xmalloc_ptr
<char> map
789 = target_fileio_read_stralloc (NULL
, filename
);
794 printf_filtered (_("Mapped address spaces:\n\n"));
795 if (gdbarch_addr_bit (gdbarch
) == 32)
797 printf_filtered ("\t%10s %10s %10s %10s %s\n",
800 " Size", " Offset", "objfile");
804 printf_filtered (" %18s %18s %10s %10s %s\n",
807 " Size", " Offset", "objfile");
810 for (line
= strtok (map
.get (), "\n");
812 line
= strtok (NULL
, "\n"))
814 ULONGEST addr
, endaddr
, offset
, inode
;
815 const char *permissions
, *device
, *filename
;
816 size_t permissions_len
, device_len
;
818 read_mapping (line
, &addr
, &endaddr
,
819 &permissions
, &permissions_len
,
820 &offset
, &device
, &device_len
,
823 if (gdbarch_addr_bit (gdbarch
) == 32)
825 printf_filtered ("\t%10s %10s %10s %10s %s\n",
826 paddress (gdbarch
, addr
),
827 paddress (gdbarch
, endaddr
),
828 hex_string (endaddr
- addr
),
830 *filename
? filename
: "");
834 printf_filtered (" %18s %18s %10s %10s %s\n",
835 paddress (gdbarch
, addr
),
836 paddress (gdbarch
, endaddr
),
837 hex_string (endaddr
- addr
),
839 *filename
? filename
: "");
844 warning (_("unable to open /proc file '%s'"), filename
);
848 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
849 gdb::unique_xmalloc_ptr
<char> status
850 = target_fileio_read_stralloc (NULL
, filename
);
852 puts_filtered (status
.get ());
854 warning (_("unable to open /proc file '%s'"), filename
);
858 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
859 gdb::unique_xmalloc_ptr
<char> statstr
860 = target_fileio_read_stralloc (NULL
, filename
);
863 const char *p
= statstr
.get ();
865 printf_filtered (_("Process: %s\n"),
866 pulongest (strtoulst (p
, &p
, 10)));
871 /* ps command also relies on no trailing fields
873 const char *ep
= strrchr (p
, ')');
876 printf_filtered ("Exec file: %.*s\n",
877 (int) (ep
- p
- 1), p
+ 1);
884 printf_filtered (_("State: %c\n"), *p
++);
887 printf_filtered (_("Parent process: %s\n"),
888 pulongest (strtoulst (p
, &p
, 10)));
890 printf_filtered (_("Process group: %s\n"),
891 pulongest (strtoulst (p
, &p
, 10)));
893 printf_filtered (_("Session id: %s\n"),
894 pulongest (strtoulst (p
, &p
, 10)));
896 printf_filtered (_("TTY: %s\n"),
897 pulongest (strtoulst (p
, &p
, 10)));
899 printf_filtered (_("TTY owner process group: %s\n"),
900 pulongest (strtoulst (p
, &p
, 10)));
903 printf_filtered (_("Flags: %s\n"),
904 hex_string (strtoulst (p
, &p
, 10)));
906 printf_filtered (_("Minor faults (no memory page): %s\n"),
907 pulongest (strtoulst (p
, &p
, 10)));
909 printf_filtered (_("Minor faults, children: %s\n"),
910 pulongest (strtoulst (p
, &p
, 10)));
912 printf_filtered (_("Major faults (memory page faults): %s\n"),
913 pulongest (strtoulst (p
, &p
, 10)));
915 printf_filtered (_("Major faults, children: %s\n"),
916 pulongest (strtoulst (p
, &p
, 10)));
918 printf_filtered (_("utime: %s\n"),
919 pulongest (strtoulst (p
, &p
, 10)));
921 printf_filtered (_("stime: %s\n"),
922 pulongest (strtoulst (p
, &p
, 10)));
924 printf_filtered (_("utime, children: %s\n"),
925 pulongest (strtoulst (p
, &p
, 10)));
927 printf_filtered (_("stime, children: %s\n"),
928 pulongest (strtoulst (p
, &p
, 10)));
930 printf_filtered (_("jiffies remaining in current "
932 pulongest (strtoulst (p
, &p
, 10)));
934 printf_filtered (_("'nice' value: %s\n"),
935 pulongest (strtoulst (p
, &p
, 10)));
937 printf_filtered (_("jiffies until next timeout: %s\n"),
938 pulongest (strtoulst (p
, &p
, 10)));
940 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
941 pulongest (strtoulst (p
, &p
, 10)));
943 printf_filtered (_("start time (jiffies since "
944 "system boot): %s\n"),
945 pulongest (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("Virtual memory size: %s\n"),
948 pulongest (strtoulst (p
, &p
, 10)));
950 printf_filtered (_("Resident set size: %s\n"),
951 pulongest (strtoulst (p
, &p
, 10)));
953 printf_filtered (_("rlim: %s\n"),
954 pulongest (strtoulst (p
, &p
, 10)));
956 printf_filtered (_("Start of text: %s\n"),
957 hex_string (strtoulst (p
, &p
, 10)));
959 printf_filtered (_("End of text: %s\n"),
960 hex_string (strtoulst (p
, &p
, 10)));
962 printf_filtered (_("Start of stack: %s\n"),
963 hex_string (strtoulst (p
, &p
, 10)));
964 #if 0 /* Don't know how architecture-dependent the rest is...
965 Anyway the signal bitmap info is available from "status". */
967 printf_filtered (_("Kernel stack pointer: %s\n"),
968 hex_string (strtoulst (p
, &p
, 10)));
970 printf_filtered (_("Kernel instr pointer: %s\n"),
971 hex_string (strtoulst (p
, &p
, 10)));
973 printf_filtered (_("Pending signals bitmap: %s\n"),
974 hex_string (strtoulst (p
, &p
, 10)));
976 printf_filtered (_("Blocked signals bitmap: %s\n"),
977 hex_string (strtoulst (p
, &p
, 10)));
979 printf_filtered (_("Ignored signals bitmap: %s\n"),
980 hex_string (strtoulst (p
, &p
, 10)));
982 printf_filtered (_("Catched signals bitmap: %s\n"),
983 hex_string (strtoulst (p
, &p
, 10)));
985 printf_filtered (_("wchan (system call): %s\n"),
986 hex_string (strtoulst (p
, &p
, 10)));
990 warning (_("unable to open /proc file '%s'"), filename
);
994 /* Implement "info proc mappings" for a corefile. */
997 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1000 ULONGEST count
, page_size
;
1001 unsigned char *descdata
, *filenames
, *descend
;
1003 unsigned int addr_size_bits
, addr_size
;
1004 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
1005 /* We assume this for reading 64-bit core files. */
1006 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1008 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1009 if (section
== NULL
)
1011 warning (_("unable to find mappings in core file"));
1015 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1016 addr_size
= addr_size_bits
/ 8;
1017 note_size
= bfd_get_section_size (section
);
1019 if (note_size
< 2 * addr_size
)
1020 error (_("malformed core note - too short for header"));
1022 gdb::def_vector
<unsigned char> contents (note_size
);
1023 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1025 error (_("could not get core note contents"));
1027 descdata
= contents
.data ();
1028 descend
= descdata
+ note_size
;
1030 if (descdata
[note_size
- 1] != '\0')
1031 error (_("malformed note - does not end with \\0"));
1033 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1034 descdata
+= addr_size
;
1036 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1037 descdata
+= addr_size
;
1039 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1040 error (_("malformed note - too short for supplied file count"));
1042 printf_filtered (_("Mapped address spaces:\n\n"));
1043 if (gdbarch_addr_bit (gdbarch
) == 32)
1045 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1048 " Size", " Offset", "objfile");
1052 printf_filtered (" %18s %18s %10s %10s %s\n",
1055 " Size", " Offset", "objfile");
1058 filenames
= descdata
+ count
* 3 * addr_size
;
1061 ULONGEST start
, end
, file_ofs
;
1063 if (filenames
== descend
)
1064 error (_("malformed note - filenames end too early"));
1066 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1067 descdata
+= addr_size
;
1068 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1069 descdata
+= addr_size
;
1070 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1071 descdata
+= addr_size
;
1073 file_ofs
*= page_size
;
1075 if (gdbarch_addr_bit (gdbarch
) == 32)
1076 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1077 paddress (gdbarch
, start
),
1078 paddress (gdbarch
, end
),
1079 hex_string (end
- start
),
1080 hex_string (file_ofs
),
1083 printf_filtered (" %18s %18s %10s %10s %s\n",
1084 paddress (gdbarch
, start
),
1085 paddress (gdbarch
, end
),
1086 hex_string (end
- start
),
1087 hex_string (file_ofs
),
1090 filenames
+= 1 + strlen ((char *) filenames
);
1094 /* Implement "info proc" for a corefile. */
1097 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1098 enum info_proc_what what
)
1100 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1101 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1107 exe
= bfd_core_file_failing_command (core_bfd
);
1109 printf_filtered ("exe = '%s'\n", exe
);
1111 warning (_("unable to find command name in core file"));
1115 linux_core_info_proc_mappings (gdbarch
, args
);
1117 if (!exe_f
&& !mappings_f
)
1118 error (_("unable to handle request"));
1121 /* Read siginfo data from the core, if possible. Returns -1 on
1122 failure. Otherwise, returns the number of bytes read. READBUF,
1123 OFFSET, and LEN are all as specified by the to_xfer_partial
1127 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1128 ULONGEST offset
, ULONGEST len
)
1130 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1131 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1132 if (section
== NULL
)
1135 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1141 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1142 ULONGEST offset
, ULONGEST inode
,
1143 int read
, int write
,
1144 int exec
, int modified
,
1145 const char *filename
,
1148 /* List memory regions in the inferior for a corefile. */
1151 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1152 linux_find_memory_region_ftype
*func
,
1155 char mapsfilename
[100];
1156 char coredumpfilter_name
[100];
1158 /* Default dump behavior of coredump_filter (0x33), according to
1159 Documentation/filesystems/proc.txt from the Linux kernel
1161 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1162 | COREFILTER_ANON_SHARED
1163 | COREFILTER_ELF_HEADERS
1164 | COREFILTER_HUGETLB_PRIVATE
);
1166 /* We need to know the real target PID to access /proc. */
1167 if (current_inferior ()->fake_pid_p
)
1170 pid
= current_inferior ()->pid
;
1172 if (use_coredump_filter
)
1174 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1175 "/proc/%d/coredump_filter", pid
);
1176 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1177 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1178 if (coredumpfilterdata
!= NULL
)
1182 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1183 filterflags
= (enum filter_flag
) flags
;
1187 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1188 gdb::unique_xmalloc_ptr
<char> data
1189 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1192 /* Older Linux kernels did not support /proc/PID/smaps. */
1193 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1194 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1201 line
= strtok_r (data
.get (), "\n", &t
);
1202 while (line
!= NULL
)
1204 ULONGEST addr
, endaddr
, offset
, inode
;
1205 const char *permissions
, *device
, *filename
;
1206 struct smaps_vmflags v
;
1207 size_t permissions_len
, device_len
;
1208 int read
, write
, exec
, priv
;
1209 int has_anonymous
= 0;
1210 int should_dump_p
= 0;
1214 memset (&v
, 0, sizeof (v
));
1215 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1216 &offset
, &device
, &device_len
, &inode
, &filename
);
1217 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1218 /* If the mapping is not anonymous, then we can consider it
1219 to be file-backed. These two states (anonymous or
1220 file-backed) seem to be exclusive, but they can actually
1221 coexist. For example, if a file-backed mapping has
1222 "Anonymous:" pages (see more below), then the Linux
1223 kernel will dump this mapping when the user specified
1224 that she only wants anonymous mappings in the corefile
1225 (*even* when she explicitly disabled the dumping of
1226 file-backed mappings). */
1227 mapping_file_p
= !mapping_anon_p
;
1229 /* Decode permissions. */
1230 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1231 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1232 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1233 /* 'private' here actually means VM_MAYSHARE, and not
1234 VM_SHARED. In order to know if a mapping is really
1235 private or not, we must check the flag "sh" in the
1236 VmFlags field. This is done by decode_vmflags. However,
1237 if we are using a Linux kernel released before the commit
1238 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1239 not have the VmFlags there. In this case, there is
1240 really no way to know if we are dealing with VM_SHARED,
1241 so we just assume that VM_MAYSHARE is enough. */
1242 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1244 /* Try to detect if region should be dumped by parsing smaps
1246 for (line
= strtok_r (NULL
, "\n", &t
);
1247 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1248 line
= strtok_r (NULL
, "\n", &t
))
1250 char keyword
[64 + 1];
1252 if (sscanf (line
, "%64s", keyword
) != 1)
1254 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1258 if (strcmp (keyword
, "Anonymous:") == 0)
1260 /* Older Linux kernels did not support the
1261 "Anonymous:" counter. Check it here. */
1264 else if (strcmp (keyword
, "VmFlags:") == 0)
1265 decode_vmflags (line
, &v
);
1267 if (strcmp (keyword
, "AnonHugePages:") == 0
1268 || strcmp (keyword
, "Anonymous:") == 0)
1270 unsigned long number
;
1272 if (sscanf (line
, "%*s%lu", &number
) != 1)
1274 warning (_("Error parsing {s,}maps file '%s' number"),
1280 /* Even if we are dealing with a file-backed
1281 mapping, if it contains anonymous pages we
1282 consider it to be *also* an anonymous
1283 mapping, because this is what the Linux
1286 // Dump segments that have been written to.
1287 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1290 Note that if the mapping is already marked as
1291 file-backed (i.e., mapping_file_p is
1292 non-zero), then this is a special case, and
1293 this mapping will be dumped either when the
1294 user wants to dump file-backed *or* anonymous
1302 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1303 mapping_anon_p
, mapping_file_p
,
1307 /* Older Linux kernels did not support the "Anonymous:" counter.
1308 If it is missing, we can't be sure - dump all the pages. */
1312 /* Invoke the callback function to create the corefile segment. */
1314 func (addr
, endaddr
- addr
, offset
, inode
,
1315 read
, write
, exec
, 1, /* MODIFIED is true because we
1316 want to dump the mapping. */
1326 /* A structure for passing information through
1327 linux_find_memory_regions_full. */
1329 struct linux_find_memory_regions_data
1331 /* The original callback. */
1333 find_memory_region_ftype func
;
1335 /* The original datum. */
1340 /* A callback for linux_find_memory_regions that converts between the
1341 "full"-style callback and find_memory_region_ftype. */
1344 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1345 ULONGEST offset
, ULONGEST inode
,
1346 int read
, int write
, int exec
, int modified
,
1347 const char *filename
, void *arg
)
1349 struct linux_find_memory_regions_data
*data
1350 = (struct linux_find_memory_regions_data
*) arg
;
1352 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1355 /* A variant of linux_find_memory_regions_full that is suitable as the
1356 gdbarch find_memory_regions method. */
1359 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1360 find_memory_region_ftype func
, void *obfd
)
1362 struct linux_find_memory_regions_data data
;
1367 return linux_find_memory_regions_full (gdbarch
,
1368 linux_find_memory_regions_thunk
,
1372 /* Determine which signal stopped execution. */
1375 find_signalled_thread (struct thread_info
*info
, void *data
)
1377 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1378 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
1384 /* Generate corefile notes for SPU contexts. */
1387 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1389 static const char *spu_files
[] =
1411 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1415 /* Determine list of SPU ids. */
1416 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1419 /* Generate corefile notes for each SPU file. */
1420 for (i
= 0; i
< size
; i
+= 4)
1422 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
1424 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1426 char annex
[32], note_name
[32];
1430 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1431 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1435 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1436 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1456 /* This is used to pass information from
1457 linux_make_mappings_corefile_notes through
1458 linux_find_memory_regions_full. */
1460 struct linux_make_mappings_data
1462 /* Number of files mapped. */
1463 ULONGEST file_count
;
1465 /* The obstack for the main part of the data. */
1466 struct obstack
*data_obstack
;
1468 /* The filename obstack. */
1469 struct obstack
*filename_obstack
;
1471 /* The architecture's "long" type. */
1472 struct type
*long_type
;
1475 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1477 /* A callback for linux_find_memory_regions_full that updates the
1478 mappings data for linux_make_mappings_corefile_notes. */
1481 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1482 ULONGEST offset
, ULONGEST inode
,
1483 int read
, int write
, int exec
, int modified
,
1484 const char *filename
, void *data
)
1486 struct linux_make_mappings_data
*map_data
1487 = (struct linux_make_mappings_data
*) data
;
1488 gdb_byte buf
[sizeof (ULONGEST
)];
1490 if (*filename
== '\0' || inode
== 0)
1493 ++map_data
->file_count
;
1495 pack_long (buf
, map_data
->long_type
, vaddr
);
1496 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1497 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1498 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1499 pack_long (buf
, map_data
->long_type
, offset
);
1500 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1502 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1507 /* Write the file mapping data to the core file, if possible. OBFD is
1508 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1509 is a pointer to the note size. Returns the new NOTE_DATA and
1510 updates NOTE_SIZE. */
1513 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1514 char *note_data
, int *note_size
)
1516 struct linux_make_mappings_data mapping_data
;
1517 struct type
*long_type
1518 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1519 gdb_byte buf
[sizeof (ULONGEST
)];
1521 auto_obstack data_obstack
, filename_obstack
;
1523 mapping_data
.file_count
= 0;
1524 mapping_data
.data_obstack
= &data_obstack
;
1525 mapping_data
.filename_obstack
= &filename_obstack
;
1526 mapping_data
.long_type
= long_type
;
1528 /* Reserve space for the count. */
1529 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1530 /* We always write the page size as 1 since we have no good way to
1531 determine the correct value. */
1532 pack_long (buf
, long_type
, 1);
1533 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1535 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1538 if (mapping_data
.file_count
!= 0)
1540 /* Write the count to the obstack. */
1541 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1542 long_type
, mapping_data
.file_count
);
1544 /* Copy the filenames to the data obstack. */
1545 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1546 obstack_object_size (&filename_obstack
));
1548 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1550 obstack_base (&data_obstack
),
1551 obstack_object_size (&data_obstack
));
1557 /* Structure for passing information from
1558 linux_collect_thread_registers via an iterator to
1559 linux_collect_regset_section_cb. */
1561 struct linux_collect_regset_section_cb_data
1563 struct gdbarch
*gdbarch
;
1564 const struct regcache
*regcache
;
1569 enum gdb_signal stop_signal
;
1570 int abort_iteration
;
1573 /* Callback for iterate_over_regset_sections that records a single
1574 regset in the corefile note section. */
1577 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1578 const struct regset
*regset
,
1579 const char *human_name
, void *cb_data
)
1582 struct linux_collect_regset_section_cb_data
*data
1583 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1585 if (data
->abort_iteration
)
1588 gdb_assert (regset
&& regset
->collect_regset
);
1590 buf
= (char *) xmalloc (size
);
1591 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1593 /* PRSTATUS still needs to be treated specially. */
1594 if (strcmp (sect_name
, ".reg") == 0)
1595 data
->note_data
= (char *) elfcore_write_prstatus
1596 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1597 gdb_signal_to_host (data
->stop_signal
), buf
);
1599 data
->note_data
= (char *) elfcore_write_register_note
1600 (data
->obfd
, data
->note_data
, data
->note_size
,
1601 sect_name
, buf
, size
);
1604 if (data
->note_data
== NULL
)
1605 data
->abort_iteration
= 1;
1608 /* Records the thread's register state for the corefile note
1612 linux_collect_thread_registers (const struct regcache
*regcache
,
1613 ptid_t ptid
, bfd
*obfd
,
1614 char *note_data
, int *note_size
,
1615 enum gdb_signal stop_signal
)
1617 struct gdbarch
*gdbarch
= regcache
->arch ();
1618 struct linux_collect_regset_section_cb_data data
;
1620 data
.gdbarch
= gdbarch
;
1621 data
.regcache
= regcache
;
1623 data
.note_data
= note_data
;
1624 data
.note_size
= note_size
;
1625 data
.stop_signal
= stop_signal
;
1626 data
.abort_iteration
= 0;
1628 /* For remote targets the LWP may not be available, so use the TID. */
1629 data
.lwp
= ptid_get_lwp (ptid
);
1631 data
.lwp
= ptid_get_tid (ptid
);
1633 gdbarch_iterate_over_regset_sections (gdbarch
,
1634 linux_collect_regset_section_cb
,
1636 return data
.note_data
;
1639 /* Fetch the siginfo data for the specified thread, if it exists. If
1640 there is no data, or we could not read it, return an empty
1643 static gdb::byte_vector
1644 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1646 struct type
*siginfo_type
;
1649 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1650 return gdb::byte_vector ();
1652 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1653 inferior_ptid
= thread
->ptid
;
1655 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1657 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1659 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1660 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1661 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1667 struct linux_corefile_thread_data
1669 struct gdbarch
*gdbarch
;
1673 enum gdb_signal stop_signal
;
1676 /* Records the thread's register state for the corefile note
1680 linux_corefile_thread (struct thread_info
*info
,
1681 struct linux_corefile_thread_data
*args
)
1683 struct regcache
*regcache
;
1685 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1687 target_fetch_registers (regcache
, -1);
1688 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1690 args
->note_data
= linux_collect_thread_registers
1691 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1692 args
->note_size
, args
->stop_signal
);
1694 /* Don't return anything if we got no register information above,
1695 such a core file is useless. */
1696 if (args
->note_data
!= NULL
)
1697 if (!siginfo_data
.empty ())
1698 args
->note_data
= elfcore_write_note (args
->obfd
,
1702 siginfo_data
.data (),
1703 siginfo_data
.size ());
1706 /* Fill the PRPSINFO structure with information about the process being
1707 debugged. Returns 1 in case of success, 0 for failures. Please note that
1708 even if the structure cannot be entirely filled (e.g., GDB was unable to
1709 gather information about the process UID/GID), this function will still
1710 return 1 since some information was already recorded. It will only return
1711 0 iff nothing can be gathered. */
1714 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1716 /* The filename which we will use to obtain some info about the process.
1717 We will basically use this to store the `/proc/PID/FILENAME' file. */
1719 /* The basename of the executable. */
1720 const char *basename
;
1722 /* Temporary buffer. */
1724 /* The valid states of a process, according to the Linux kernel. */
1725 const char valid_states
[] = "RSDTZW";
1726 /* The program state. */
1727 const char *prog_state
;
1728 /* The state of the process. */
1730 /* The PID of the program which generated the corefile. */
1732 /* Process flags. */
1733 unsigned int pr_flag
;
1734 /* Process nice value. */
1736 /* The number of fields read by `sscanf'. */
1739 gdb_assert (p
!= NULL
);
1741 /* Obtaining PID and filename. */
1742 pid
= ptid_get_pid (inferior_ptid
);
1743 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1744 /* The full name of the program which generated the corefile. */
1745 gdb::unique_xmalloc_ptr
<char> fname
1746 = target_fileio_read_stralloc (NULL
, filename
);
1748 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1750 /* No program name was read, so we won't be able to retrieve more
1751 information about the process. */
1755 memset (p
, 0, sizeof (*p
));
1757 /* Defining the PID. */
1760 /* Copying the program name. Only the basename matters. */
1761 basename
= lbasename (fname
.get ());
1762 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1763 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1765 infargs
= get_inferior_args ();
1767 /* The arguments of the program. */
1768 std::string psargs
= fname
.get ();
1769 if (infargs
!= NULL
)
1770 psargs
= psargs
+ " " + infargs
;
1772 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
));
1773 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1775 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1776 /* The contents of `/proc/PID/stat'. */
1777 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1778 = target_fileio_read_stralloc (NULL
, filename
);
1779 char *proc_stat
= proc_stat_contents
.get ();
1781 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1783 /* Despite being unable to read more information about the
1784 process, we return 1 here because at least we have its
1785 command line, PID and arguments. */
1789 /* Ok, we have the stats. It's time to do a little parsing of the
1790 contents of the buffer, so that we end up reading what we want.
1792 The following parsing mechanism is strongly based on the
1793 information generated by the `fs/proc/array.c' file, present in
1794 the Linux kernel tree. More details about how the information is
1795 displayed can be obtained by seeing the manpage of proc(5),
1796 specifically under the entry of `/proc/[pid]/stat'. */
1798 /* Getting rid of the PID, since we already have it. */
1799 while (isdigit (*proc_stat
))
1802 proc_stat
= skip_spaces (proc_stat
);
1804 /* ps command also relies on no trailing fields ever contain ')'. */
1805 proc_stat
= strrchr (proc_stat
, ')');
1806 if (proc_stat
== NULL
)
1810 proc_stat
= skip_spaces (proc_stat
);
1812 n_fields
= sscanf (proc_stat
,
1813 "%c" /* Process state. */
1814 "%d%d%d" /* Parent PID, group ID, session ID. */
1815 "%*d%*d" /* tty_nr, tpgid (not used). */
1817 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1818 cmajflt (not used). */
1819 "%*s%*s%*s%*s" /* utime, stime, cutime,
1820 cstime (not used). */
1821 "%*s" /* Priority (not used). */
1824 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1830 /* Again, we couldn't read the complementary information about
1831 the process state. However, we already have minimal
1832 information, so we just return 1 here. */
1836 /* Filling the structure fields. */
1837 prog_state
= strchr (valid_states
, pr_sname
);
1838 if (prog_state
!= NULL
)
1839 p
->pr_state
= prog_state
- valid_states
;
1842 /* Zero means "Running". */
1846 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1847 p
->pr_zomb
= p
->pr_sname
== 'Z';
1848 p
->pr_nice
= pr_nice
;
1849 p
->pr_flag
= pr_flag
;
1851 /* Finally, obtaining the UID and GID. For that, we read and parse the
1852 contents of the `/proc/PID/status' file. */
1853 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1854 /* The contents of `/proc/PID/status'. */
1855 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1856 = target_fileio_read_stralloc (NULL
, filename
);
1857 char *proc_status
= proc_status_contents
.get ();
1859 if (proc_status
== NULL
|| *proc_status
== '\0')
1861 /* Returning 1 since we already have a bunch of information. */
1865 /* Extracting the UID. */
1866 tmpstr
= strstr (proc_status
, "Uid:");
1869 /* Advancing the pointer to the beginning of the UID. */
1870 tmpstr
+= sizeof ("Uid:");
1871 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1874 if (isdigit (*tmpstr
))
1875 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1878 /* Extracting the GID. */
1879 tmpstr
= strstr (proc_status
, "Gid:");
1882 /* Advancing the pointer to the beginning of the GID. */
1883 tmpstr
+= sizeof ("Gid:");
1884 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1887 if (isdigit (*tmpstr
))
1888 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1894 /* Build the note section for a corefile, and return it in a malloc
1898 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1900 struct linux_corefile_thread_data thread_args
;
1901 struct elf_internal_linux_prpsinfo prpsinfo
;
1902 char *note_data
= NULL
;
1905 struct thread_info
*curr_thr
, *signalled_thr
, *thr
;
1907 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1910 if (linux_fill_prpsinfo (&prpsinfo
))
1912 if (gdbarch_ptr_bit (gdbarch
) == 64)
1913 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1914 note_data
, note_size
,
1917 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1918 note_data
, note_size
,
1922 /* Thread register information. */
1925 update_thread_list ();
1927 CATCH (e
, RETURN_MASK_ERROR
)
1929 exception_print (gdb_stderr
, e
);
1933 /* Like the kernel, prefer dumping the signalled thread first.
1934 "First thread" is what tools use to infer the signalled thread.
1935 In case there's more than one signalled thread, prefer the
1936 current thread, if it is signalled. */
1937 curr_thr
= inferior_thread ();
1938 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1939 signalled_thr
= curr_thr
;
1942 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
1943 if (signalled_thr
== NULL
)
1944 signalled_thr
= curr_thr
;
1947 thread_args
.gdbarch
= gdbarch
;
1948 thread_args
.obfd
= obfd
;
1949 thread_args
.note_data
= note_data
;
1950 thread_args
.note_size
= note_size
;
1951 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1953 linux_corefile_thread (signalled_thr
, &thread_args
);
1954 ALL_NON_EXITED_THREADS (thr
)
1956 if (thr
== signalled_thr
)
1958 if (ptid_get_pid (thr
->ptid
) != ptid_get_pid (inferior_ptid
))
1961 linux_corefile_thread (thr
, &thread_args
);
1964 note_data
= thread_args
.note_data
;
1968 /* Auxillary vector. */
1969 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
1973 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1974 "CORE", NT_AUXV
, auxv
, auxv_len
);
1981 /* SPU information. */
1982 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
1986 /* File mappings. */
1987 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1988 note_data
, note_size
);
1993 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1994 gdbarch.h. This function is not static because it is exported to
1995 other -tdep files. */
1998 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2003 return GDB_SIGNAL_0
;
2006 return GDB_SIGNAL_HUP
;
2009 return GDB_SIGNAL_INT
;
2012 return GDB_SIGNAL_QUIT
;
2015 return GDB_SIGNAL_ILL
;
2018 return GDB_SIGNAL_TRAP
;
2021 return GDB_SIGNAL_ABRT
;
2024 return GDB_SIGNAL_BUS
;
2027 return GDB_SIGNAL_FPE
;
2030 return GDB_SIGNAL_KILL
;
2033 return GDB_SIGNAL_USR1
;
2036 return GDB_SIGNAL_SEGV
;
2039 return GDB_SIGNAL_USR2
;
2042 return GDB_SIGNAL_PIPE
;
2045 return GDB_SIGNAL_ALRM
;
2048 return GDB_SIGNAL_TERM
;
2051 return GDB_SIGNAL_CHLD
;
2054 return GDB_SIGNAL_CONT
;
2057 return GDB_SIGNAL_STOP
;
2060 return GDB_SIGNAL_TSTP
;
2063 return GDB_SIGNAL_TTIN
;
2066 return GDB_SIGNAL_TTOU
;
2069 return GDB_SIGNAL_URG
;
2072 return GDB_SIGNAL_XCPU
;
2075 return GDB_SIGNAL_XFSZ
;
2077 case LINUX_SIGVTALRM
:
2078 return GDB_SIGNAL_VTALRM
;
2081 return GDB_SIGNAL_PROF
;
2083 case LINUX_SIGWINCH
:
2084 return GDB_SIGNAL_WINCH
;
2086 /* No way to differentiate between SIGIO and SIGPOLL.
2087 Therefore, we just handle the first one. */
2089 return GDB_SIGNAL_IO
;
2092 return GDB_SIGNAL_PWR
;
2095 return GDB_SIGNAL_SYS
;
2097 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2098 therefore we have to handle them here. */
2099 case LINUX_SIGRTMIN
:
2100 return GDB_SIGNAL_REALTIME_32
;
2102 case LINUX_SIGRTMAX
:
2103 return GDB_SIGNAL_REALTIME_64
;
2106 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2108 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2110 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2113 return GDB_SIGNAL_UNKNOWN
;
2116 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2117 gdbarch.h. This function is not static because it is exported to
2118 other -tdep files. */
2121 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2122 enum gdb_signal signal
)
2129 case GDB_SIGNAL_HUP
:
2130 return LINUX_SIGHUP
;
2132 case GDB_SIGNAL_INT
:
2133 return LINUX_SIGINT
;
2135 case GDB_SIGNAL_QUIT
:
2136 return LINUX_SIGQUIT
;
2138 case GDB_SIGNAL_ILL
:
2139 return LINUX_SIGILL
;
2141 case GDB_SIGNAL_TRAP
:
2142 return LINUX_SIGTRAP
;
2144 case GDB_SIGNAL_ABRT
:
2145 return LINUX_SIGABRT
;
2147 case GDB_SIGNAL_FPE
:
2148 return LINUX_SIGFPE
;
2150 case GDB_SIGNAL_KILL
:
2151 return LINUX_SIGKILL
;
2153 case GDB_SIGNAL_BUS
:
2154 return LINUX_SIGBUS
;
2156 case GDB_SIGNAL_SEGV
:
2157 return LINUX_SIGSEGV
;
2159 case GDB_SIGNAL_SYS
:
2160 return LINUX_SIGSYS
;
2162 case GDB_SIGNAL_PIPE
:
2163 return LINUX_SIGPIPE
;
2165 case GDB_SIGNAL_ALRM
:
2166 return LINUX_SIGALRM
;
2168 case GDB_SIGNAL_TERM
:
2169 return LINUX_SIGTERM
;
2171 case GDB_SIGNAL_URG
:
2172 return LINUX_SIGURG
;
2174 case GDB_SIGNAL_STOP
:
2175 return LINUX_SIGSTOP
;
2177 case GDB_SIGNAL_TSTP
:
2178 return LINUX_SIGTSTP
;
2180 case GDB_SIGNAL_CONT
:
2181 return LINUX_SIGCONT
;
2183 case GDB_SIGNAL_CHLD
:
2184 return LINUX_SIGCHLD
;
2186 case GDB_SIGNAL_TTIN
:
2187 return LINUX_SIGTTIN
;
2189 case GDB_SIGNAL_TTOU
:
2190 return LINUX_SIGTTOU
;
2195 case GDB_SIGNAL_XCPU
:
2196 return LINUX_SIGXCPU
;
2198 case GDB_SIGNAL_XFSZ
:
2199 return LINUX_SIGXFSZ
;
2201 case GDB_SIGNAL_VTALRM
:
2202 return LINUX_SIGVTALRM
;
2204 case GDB_SIGNAL_PROF
:
2205 return LINUX_SIGPROF
;
2207 case GDB_SIGNAL_WINCH
:
2208 return LINUX_SIGWINCH
;
2210 case GDB_SIGNAL_USR1
:
2211 return LINUX_SIGUSR1
;
2213 case GDB_SIGNAL_USR2
:
2214 return LINUX_SIGUSR2
;
2216 case GDB_SIGNAL_PWR
:
2217 return LINUX_SIGPWR
;
2219 case GDB_SIGNAL_POLL
:
2220 return LINUX_SIGPOLL
;
2222 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2223 therefore we have to handle it here. */
2224 case GDB_SIGNAL_REALTIME_32
:
2225 return LINUX_SIGRTMIN
;
2227 /* Same comment applies to _64. */
2228 case GDB_SIGNAL_REALTIME_64
:
2229 return LINUX_SIGRTMAX
;
2232 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2233 if (signal
>= GDB_SIGNAL_REALTIME_33
2234 && signal
<= GDB_SIGNAL_REALTIME_63
)
2236 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2238 return LINUX_SIGRTMIN
+ 1 + offset
;
2244 /* Helper for linux_vsyscall_range that does the real work of finding
2245 the vsyscall's address range. */
2248 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2253 if (target_auxv_search (¤t_target
, AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2256 /* It doesn't make sense to access the host's /proc when debugging a
2257 core file. Instead, look for the PT_LOAD segment that matches
2259 if (!target_has_execution
)
2261 Elf_Internal_Phdr
*phdrs
;
2265 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2266 if (phdrs_size
== -1)
2269 phdrs
= (Elf_Internal_Phdr
*) alloca (phdrs_size
);
2270 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
);
2271 if (num_phdrs
== -1)
2274 for (i
= 0; i
< num_phdrs
; i
++)
2275 if (phdrs
[i
].p_type
== PT_LOAD
2276 && phdrs
[i
].p_vaddr
== range
->start
)
2278 range
->length
= phdrs
[i
].p_memsz
;
2285 /* We need to know the real target PID to access /proc. */
2286 if (current_inferior ()->fake_pid_p
)
2289 pid
= current_inferior ()->pid
;
2291 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2292 reading /proc/PID/maps (2). The later identifies thread stacks
2293 in the output, which requires scanning every thread in the thread
2294 group to check whether a VMA is actually a thread's stack. With
2295 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2296 a few thousand threads, (1) takes a few miliseconds, while (2)
2297 takes several seconds. Also note that "smaps", what we read for
2298 determining core dump mappings, is even slower than "maps". */
2299 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2300 gdb::unique_xmalloc_ptr
<char> data
2301 = target_fileio_read_stralloc (NULL
, filename
);
2305 char *saveptr
= NULL
;
2307 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2309 line
= strtok_r (NULL
, "\n", &saveptr
))
2311 ULONGEST addr
, endaddr
;
2312 const char *p
= line
;
2314 addr
= strtoulst (p
, &p
, 16);
2315 if (addr
== range
->start
)
2319 endaddr
= strtoulst (p
, &p
, 16);
2320 range
->length
= endaddr
- addr
;
2326 warning (_("unable to open /proc file '%s'"), filename
);
2331 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2332 caching, and defers the real work to linux_vsyscall_range_raw. */
2335 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2337 struct linux_info
*info
= get_linux_inferior_data ();
2339 if (info
->vsyscall_range_p
== 0)
2341 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2342 info
->vsyscall_range_p
= 1;
2344 info
->vsyscall_range_p
= -1;
2347 if (info
->vsyscall_range_p
< 0)
2350 *range
= info
->vsyscall_range
;
2354 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2355 definitions would be dependent on compilation host. */
2356 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2357 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2359 /* See gdbarch.sh 'infcall_mmap'. */
2362 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2364 struct objfile
*objf
;
2365 /* Do there still exist any Linux systems without "mmap64"?
2366 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2367 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2368 struct value
*addr_val
;
2369 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2373 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2375 struct value
*arg
[ARG_LAST
];
2377 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2379 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2380 arg
[ARG_LENGTH
] = value_from_ulongest
2381 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2382 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2383 | GDB_MMAP_PROT_EXEC
))
2385 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2386 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2387 GDB_MMAP_MAP_PRIVATE
2388 | GDB_MMAP_MAP_ANONYMOUS
);
2389 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2390 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2392 addr_val
= call_function_by_hand (mmap_val
, NULL
, ARG_LAST
, arg
);
2393 retval
= value_as_address (addr_val
);
2394 if (retval
== (CORE_ADDR
) -1)
2395 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2400 /* See gdbarch.sh 'infcall_munmap'. */
2403 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2405 struct objfile
*objf
;
2406 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2407 struct value
*retval_val
;
2408 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2412 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2414 struct value
*arg
[ARG_LAST
];
2416 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2418 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2419 arg
[ARG_LENGTH
] = value_from_ulongest
2420 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2421 retval_val
= call_function_by_hand (munmap_val
, NULL
, ARG_LAST
, arg
);
2422 retval
= value_as_long (retval_val
);
2424 warning (_("Failed inferior munmap call at %s for %s bytes, "
2425 "errno is changed."),
2426 hex_string (addr
), pulongest (size
));
2429 /* See linux-tdep.h. */
2432 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2437 /* Determine entry point from target auxiliary vector. This avoids
2438 the need for symbols. Also, when debugging a stand-alone SPU
2439 executable, entry_point_address () will point to an SPU
2440 local-store address and is thus not usable as displaced stepping
2441 location. The auxiliary vector gets us the PowerPC-side entry
2442 point address instead. */
2443 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
2444 throw_error (NOT_SUPPORTED_ERROR
,
2445 _("Cannot find AT_ENTRY auxiliary vector entry."));
2447 /* Make certain that the address points at real code, and not a
2448 function descriptor. */
2449 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2452 /* Inferior calls also use the entry point as a breakpoint location.
2453 We don't want displaced stepping to interfere with those
2454 breakpoints, so leave space. */
2455 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2461 /* Display whether the gcore command is using the
2462 /proc/PID/coredump_filter file. */
2465 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2466 struct cmd_list_element
*c
, const char *value
)
2468 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2469 " corefiles is %s.\n"), value
);
2472 /* To be called from the various GDB_OSABI_LINUX handlers for the
2473 various GNU/Linux architectures and machine types. */
2476 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2478 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2479 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2480 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2481 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2482 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2483 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2484 set_gdbarch_has_shared_address_space (gdbarch
,
2485 linux_has_shared_address_space
);
2486 set_gdbarch_gdb_signal_from_target (gdbarch
,
2487 linux_gdb_signal_from_target
);
2488 set_gdbarch_gdb_signal_to_target (gdbarch
,
2489 linux_gdb_signal_to_target
);
2490 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2491 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2492 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2493 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2497 _initialize_linux_tdep (void)
2499 linux_gdbarch_data_handle
=
2500 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2502 /* Set a cache per-inferior. */
2504 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2505 /* Observers used to invalidate the cache when needed. */
2506 observer_attach_inferior_exit (invalidate_linux_cache_inf
);
2507 observer_attach_inferior_appeared (invalidate_linux_cache_inf
);
2509 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2510 &use_coredump_filter
, _("\
2511 Set whether gcore should consider /proc/PID/coredump_filter."),
2513 Show whether gcore should consider /proc/PID/coredump_filter."),
2515 Use this command to set whether gcore should consider the contents\n\
2516 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2517 about this file, refer to the manpage of core(5)."),
2518 NULL
, show_use_coredump_filter
,
2519 &setlist
, &showlist
);