1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2018 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 "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 /* Whether the value of smaps_vmflags->exclude_coredump should be
97 ignored, including mappings marked with the VM_DONTDUMP flag in
99 static int dump_excluded_mappings
= 0;
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 /* Per-inferior data key. */
187 static const struct inferior_data
*linux_inferior_data
;
189 /* Linux-specific cached data. This is used by GDB for caching
190 purposes for each inferior. This helps reduce the overhead of
191 transfering data from a remote target to the local host. */
194 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
195 if VSYSCALL_RANGE_P is positive. This is cached because getting
196 at this info requires an auxv lookup (which is itself cached),
197 and looking through the inferior's mappings (which change
198 throughout execution and therefore cannot be cached). */
199 struct mem_range vsyscall_range
;
201 /* Zero if we haven't tried looking up the vsyscall's range before
202 yet. Positive if we tried looking it up, and found it. Negative
203 if we tried looking it up but failed. */
204 int vsyscall_range_p
;
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 struct linux_info
*info
;
215 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
219 set_inferior_data (inf
, linux_inferior_data
, NULL
);
223 /* Handles the cleanup of the linux cache for inferior INF. ARG is
224 ignored. Callback for the inferior_appeared and inferior_exit
228 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
230 invalidate_linux_cache_inf (inf
);
233 /* Fetch the linux cache info for INF. This function always returns a
234 valid INFO pointer. */
236 static struct linux_info
*
237 get_linux_inferior_data (void)
239 struct linux_info
*info
;
240 struct inferior
*inf
= current_inferior ();
242 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
245 info
= XCNEW (struct linux_info
);
246 set_inferior_data (inf
, linux_inferior_data
, info
);
252 /* See linux-tdep.h. */
255 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
256 linux_siginfo_extra_fields extra_fields
)
258 struct linux_gdbarch_data
*linux_gdbarch_data
;
259 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
260 struct type
*uid_type
, *pid_type
;
261 struct type
*sigval_type
, *clock_type
;
262 struct type
*siginfo_type
, *sifields_type
;
265 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
266 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
267 return linux_gdbarch_data
->siginfo_type
;
269 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
271 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
273 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
275 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
277 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
280 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
281 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
282 append_composite_type_field (sigval_type
, "sival_int", int_type
);
283 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
286 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
287 TYPE_LENGTH (int_type
) * TARGET_CHAR_BIT
, "__pid_t");
288 TYPE_TARGET_TYPE (pid_type
) = int_type
;
289 TYPE_TARGET_STUB (pid_type
) = 1;
292 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
293 TYPE_LENGTH (uint_type
) * TARGET_CHAR_BIT
, "__uid_t");
294 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
295 TYPE_TARGET_STUB (uid_type
) = 1;
298 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
299 TYPE_LENGTH (long_type
) * TARGET_CHAR_BIT
,
301 TYPE_TARGET_TYPE (clock_type
) = long_type
;
302 TYPE_TARGET_STUB (clock_type
) = 1;
305 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
308 const int si_max_size
= 128;
310 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
313 if (gdbarch_ptr_bit (gdbarch
) == 64)
314 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
316 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
317 append_composite_type_field (sifields_type
, "_pad",
318 init_vector_type (int_type
, si_pad_size
));
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 (sifields_type
, "_kill", type
);
328 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
329 append_composite_type_field (type
, "si_tid", int_type
);
330 append_composite_type_field (type
, "si_overrun", int_type
);
331 append_composite_type_field (type
, "si_sigval", sigval_type
);
332 append_composite_type_field (sifields_type
, "_timer", type
);
335 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
336 append_composite_type_field (type
, "si_pid", pid_type
);
337 append_composite_type_field (type
, "si_uid", uid_type
);
338 append_composite_type_field (type
, "si_sigval", sigval_type
);
339 append_composite_type_field (sifields_type
, "_rt", type
);
342 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
343 append_composite_type_field (type
, "si_pid", pid_type
);
344 append_composite_type_field (type
, "si_uid", uid_type
);
345 append_composite_type_field (type
, "si_status", int_type
);
346 append_composite_type_field (type
, "si_utime", clock_type
);
347 append_composite_type_field (type
, "si_stime", clock_type
);
348 append_composite_type_field (sifields_type
, "_sigchld", type
);
351 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
352 append_composite_type_field (type
, "si_addr", void_ptr_type
);
354 /* Additional bound fields for _sigfault in case they were requested. */
355 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
357 struct type
*sigfault_bnd_fields
;
359 append_composite_type_field (type
, "_addr_lsb", short_type
);
360 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
361 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
362 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
363 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
365 append_composite_type_field (sifields_type
, "_sigfault", type
);
368 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
369 append_composite_type_field (type
, "si_band", long_type
);
370 append_composite_type_field (type
, "si_fd", int_type
);
371 append_composite_type_field (sifields_type
, "_sigpoll", type
);
374 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
375 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
376 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
377 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
378 append_composite_type_field (siginfo_type
, "si_code", int_type
);
379 append_composite_type_field_aligned (siginfo_type
,
380 "_sifields", sifields_type
,
381 TYPE_LENGTH (long_type
));
383 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
388 /* This function is suitable for architectures that don't
389 extend/override the standard siginfo structure. */
392 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
394 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
397 /* Return true if the target is running on uClinux instead of normal
401 linux_is_uclinux (void)
405 return (target_auxv_search (current_top_target (), AT_NULL
, &dummy
) > 0
406 && target_auxv_search (current_top_target (), AT_PAGESZ
, &dummy
) == 0);
410 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
412 return linux_is_uclinux ();
415 /* This is how we want PTIDs from core files to be printed. */
418 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
422 if (ptid
.lwp () != 0)
424 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid
.lwp ());
428 return normal_pid_to_str (ptid
);
431 /* Service function for corefiles and info proc. */
434 read_mapping (const char *line
,
435 ULONGEST
*addr
, ULONGEST
*endaddr
,
436 const char **permissions
, size_t *permissions_len
,
438 const char **device
, size_t *device_len
,
440 const char **filename
)
442 const char *p
= line
;
444 *addr
= strtoulst (p
, &p
, 16);
447 *endaddr
= strtoulst (p
, &p
, 16);
451 while (*p
&& !isspace (*p
))
453 *permissions_len
= p
- *permissions
;
455 *offset
= strtoulst (p
, &p
, 16);
459 while (*p
&& !isspace (*p
))
461 *device_len
= p
- *device
;
463 *inode
= strtoulst (p
, &p
, 10);
469 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
471 This function was based on the documentation found on
472 <Documentation/filesystems/proc.txt>, on the Linux kernel.
474 Linux kernels before commit
475 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
479 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
481 char *saveptr
= NULL
;
484 v
->initialized_p
= 1;
485 p
= skip_to_space (p
);
488 for (s
= strtok_r (p
, " ", &saveptr
);
490 s
= strtok_r (NULL
, " ", &saveptr
))
492 if (strcmp (s
, "io") == 0)
494 else if (strcmp (s
, "ht") == 0)
495 v
->uses_huge_tlb
= 1;
496 else if (strcmp (s
, "dd") == 0)
497 v
->exclude_coredump
= 1;
498 else if (strcmp (s
, "sh") == 0)
499 v
->shared_mapping
= 1;
503 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
504 they're initialized lazily. */
506 struct mapping_regexes
508 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
509 string in the end). We know for sure, based on the Linux kernel
510 code, that memory mappings whose associated filename is
511 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
512 compiled_regex dev_zero
513 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
514 _("Could not compile regex to match /dev/zero filename")};
516 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
517 string in the end). These filenames refer to shared memory
518 (shmem), and memory mappings associated with them are
519 MAP_ANONYMOUS as well. */
520 compiled_regex shmem_file
521 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
522 _("Could not compile regex to match shmem filenames")};
524 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
525 0' code, which is responsible to decide if it is dealing with a
526 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
527 FILE_DELETED matches, it does not necessarily mean that we are
528 dealing with an anonymous shared mapping. However, there is no
529 easy way to detect this currently, so this is the best
530 approximation we have.
532 As a result, GDB will dump readonly pages of deleted executables
533 when using the default value of coredump_filter (0x33), while the
534 Linux kernel will not dump those pages. But we can live with
536 compiled_regex file_deleted
537 {" (deleted)$", REG_NOSUB
,
538 _("Could not compile regex to match '<file> (deleted)'")};
541 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
543 FILENAME is the name of the file present in the first line of the
544 memory mapping, in the "/proc/PID/smaps" output. For example, if
547 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
549 Then FILENAME will be "/path/to/file". */
552 mapping_is_anonymous_p (const char *filename
)
554 static gdb::optional
<mapping_regexes
> regexes
;
555 static int init_regex_p
= 0;
559 /* Let's be pessimistic and assume there will be an error while
560 compiling the regex'es. */
565 /* If we reached this point, then everything succeeded. */
569 if (init_regex_p
== -1)
571 const char deleted
[] = " (deleted)";
572 size_t del_len
= sizeof (deleted
) - 1;
573 size_t filename_len
= strlen (filename
);
575 /* There was an error while compiling the regex'es above. In
576 order to try to give some reliable information to the caller,
577 we just try to find the string " (deleted)" in the filename.
578 If we managed to find it, then we assume the mapping is
580 return (filename_len
>= del_len
581 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
584 if (*filename
== '\0'
585 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
586 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
587 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
593 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
594 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
595 greater than 0 if it should.
597 In a nutshell, this is the logic that we follow in order to decide
598 if a mapping should be dumped or not.
600 - If the mapping is associated to a file whose name ends with
601 " (deleted)", or if the file is "/dev/zero", or if it is
602 "/SYSV%08x" (shared memory), or if there is no file associated
603 with it, or if the AnonHugePages: or the Anonymous: fields in the
604 /proc/PID/smaps have contents, then GDB considers this mapping to
605 be anonymous. Otherwise, GDB considers this mapping to be a
606 file-backed mapping (because there will be a file associated with
609 It is worth mentioning that, from all those checks described
610 above, the most fragile is the one to see if the file name ends
611 with " (deleted)". This does not necessarily mean that the
612 mapping is anonymous, because the deleted file associated with
613 the mapping may have been a hard link to another file, for
614 example. The Linux kernel checks to see if "i_nlink == 0", but
615 GDB cannot easily (and normally) do this check (iff running as
616 root, it could find the mapping in /proc/PID/map_files/ and
617 determine whether there still are other hard links to the
618 inode/file). Therefore, we made a compromise here, and we assume
619 that if the file name ends with " (deleted)", then the mapping is
620 indeed anonymous. FWIW, this is something the Linux kernel could
621 do better: expose this information in a more direct way.
623 - If we see the flag "sh" in the "VmFlags:" field (in
624 /proc/PID/smaps), then certainly the memory mapping is shared
625 (VM_SHARED). If we have access to the VmFlags, and we don't see
626 the "sh" there, then certainly the mapping is private. However,
627 Linux kernels before commit
628 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
629 "VmFlags:" field; in that case, we use another heuristic: if we
630 see 'p' in the permission flags, then we assume that the mapping
631 is private, even though the presence of the 's' flag there would
632 mean VM_MAYSHARE, which means the mapping could still be private.
633 This should work OK enough, however. */
636 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
637 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
638 const char *filename
)
640 /* Initially, we trust in what we received from our caller. This
641 value may not be very precise (i.e., it was probably gathered
642 from the permission line in the /proc/PID/smaps list, which
643 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
644 what we have until we take a look at the "VmFlags:" field
645 (assuming that the version of the Linux kernel being used
646 supports it, of course). */
647 int private_p
= maybe_private_p
;
649 /* We always dump vDSO and vsyscall mappings, because it's likely that
650 there'll be no file to read the contents from at core load time.
651 The kernel does the same. */
652 if (strcmp ("[vdso]", filename
) == 0
653 || strcmp ("[vsyscall]", filename
) == 0)
656 if (v
->initialized_p
)
658 /* We never dump I/O mappings. */
662 /* Check if we should exclude this mapping. */
663 if (!dump_excluded_mappings
&& v
->exclude_coredump
)
666 /* Update our notion of whether this mapping is shared or
667 private based on a trustworthy value. */
668 private_p
= !v
->shared_mapping
;
670 /* HugeTLB checking. */
671 if (v
->uses_huge_tlb
)
673 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
674 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
683 if (mapping_anon_p
&& mapping_file_p
)
685 /* This is a special situation. It can happen when we see a
686 mapping that is file-backed, but that contains anonymous
688 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
689 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
691 else if (mapping_anon_p
)
692 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
694 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
698 if (mapping_anon_p
&& mapping_file_p
)
700 /* This is a special situation. It can happen when we see a
701 mapping that is file-backed, but that contains anonymous
703 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
704 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
706 else if (mapping_anon_p
)
707 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
709 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
713 /* Implement the "info proc" command. */
716 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
717 enum info_proc_what what
)
719 /* A long is used for pid instead of an int to avoid a loss of precision
720 compiler warning from the output of strtoul. */
722 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
723 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
724 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
725 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
726 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
727 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
731 if (args
&& isdigit (args
[0]))
735 pid
= strtoul (args
, &tem
, 10);
740 if (!target_has_execution
)
741 error (_("No current process: you must name one."));
742 if (current_inferior ()->fake_pid_p
)
743 error (_("Can't determine the current process's PID: you must name one."));
745 pid
= current_inferior ()->pid
;
748 args
= skip_spaces (args
);
750 error (_("Too many parameters: %s"), args
);
752 printf_filtered (_("process %ld\n"), pid
);
755 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
757 ssize_t len
= target_fileio_read_alloc (NULL
, filename
, &buffer
);
761 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) buffer
);
764 for (pos
= 0; pos
< len
- 1; pos
++)
766 if (buffer
[pos
] == '\0')
769 buffer
[len
- 1] = '\0';
770 printf_filtered ("cmdline = '%s'\n", buffer
);
773 warning (_("unable to open /proc file '%s'"), filename
);
777 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
778 gdb::optional
<std::string
> contents
779 = target_fileio_readlink (NULL
, filename
, &target_errno
);
780 if (contents
.has_value ())
781 printf_filtered ("cwd = '%s'\n", contents
->c_str ());
783 warning (_("unable to read link '%s'"), filename
);
787 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
788 gdb::optional
<std::string
> contents
789 = target_fileio_readlink (NULL
, filename
, &target_errno
);
790 if (contents
.has_value ())
791 printf_filtered ("exe = '%s'\n", contents
->c_str ());
793 warning (_("unable to read link '%s'"), filename
);
797 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
798 gdb::unique_xmalloc_ptr
<char> map
799 = target_fileio_read_stralloc (NULL
, filename
);
804 printf_filtered (_("Mapped address spaces:\n\n"));
805 if (gdbarch_addr_bit (gdbarch
) == 32)
807 printf_filtered ("\t%10s %10s %10s %10s %s\n",
810 " Size", " Offset", "objfile");
814 printf_filtered (" %18s %18s %10s %10s %s\n",
817 " Size", " Offset", "objfile");
820 for (line
= strtok (map
.get (), "\n");
822 line
= strtok (NULL
, "\n"))
824 ULONGEST addr
, endaddr
, offset
, inode
;
825 const char *permissions
, *device
, *filename
;
826 size_t permissions_len
, device_len
;
828 read_mapping (line
, &addr
, &endaddr
,
829 &permissions
, &permissions_len
,
830 &offset
, &device
, &device_len
,
833 if (gdbarch_addr_bit (gdbarch
) == 32)
835 printf_filtered ("\t%10s %10s %10s %10s %s\n",
836 paddress (gdbarch
, addr
),
837 paddress (gdbarch
, endaddr
),
838 hex_string (endaddr
- addr
),
840 *filename
? filename
: "");
844 printf_filtered (" %18s %18s %10s %10s %s\n",
845 paddress (gdbarch
, addr
),
846 paddress (gdbarch
, endaddr
),
847 hex_string (endaddr
- addr
),
849 *filename
? filename
: "");
854 warning (_("unable to open /proc file '%s'"), filename
);
858 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
859 gdb::unique_xmalloc_ptr
<char> status
860 = target_fileio_read_stralloc (NULL
, filename
);
862 puts_filtered (status
.get ());
864 warning (_("unable to open /proc file '%s'"), filename
);
868 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
869 gdb::unique_xmalloc_ptr
<char> statstr
870 = target_fileio_read_stralloc (NULL
, filename
);
873 const char *p
= statstr
.get ();
875 printf_filtered (_("Process: %s\n"),
876 pulongest (strtoulst (p
, &p
, 10)));
881 /* ps command also relies on no trailing fields
883 const char *ep
= strrchr (p
, ')');
886 printf_filtered ("Exec file: %.*s\n",
887 (int) (ep
- p
- 1), p
+ 1);
894 printf_filtered (_("State: %c\n"), *p
++);
897 printf_filtered (_("Parent process: %s\n"),
898 pulongest (strtoulst (p
, &p
, 10)));
900 printf_filtered (_("Process group: %s\n"),
901 pulongest (strtoulst (p
, &p
, 10)));
903 printf_filtered (_("Session id: %s\n"),
904 pulongest (strtoulst (p
, &p
, 10)));
906 printf_filtered (_("TTY: %s\n"),
907 pulongest (strtoulst (p
, &p
, 10)));
909 printf_filtered (_("TTY owner process group: %s\n"),
910 pulongest (strtoulst (p
, &p
, 10)));
913 printf_filtered (_("Flags: %s\n"),
914 hex_string (strtoulst (p
, &p
, 10)));
916 printf_filtered (_("Minor faults (no memory page): %s\n"),
917 pulongest (strtoulst (p
, &p
, 10)));
919 printf_filtered (_("Minor faults, children: %s\n"),
920 pulongest (strtoulst (p
, &p
, 10)));
922 printf_filtered (_("Major faults (memory page faults): %s\n"),
923 pulongest (strtoulst (p
, &p
, 10)));
925 printf_filtered (_("Major faults, children: %s\n"),
926 pulongest (strtoulst (p
, &p
, 10)));
928 printf_filtered (_("utime: %s\n"),
929 pulongest (strtoulst (p
, &p
, 10)));
931 printf_filtered (_("stime: %s\n"),
932 pulongest (strtoulst (p
, &p
, 10)));
934 printf_filtered (_("utime, children: %s\n"),
935 pulongest (strtoulst (p
, &p
, 10)));
937 printf_filtered (_("stime, children: %s\n"),
938 pulongest (strtoulst (p
, &p
, 10)));
940 printf_filtered (_("jiffies remaining in current "
942 pulongest (strtoulst (p
, &p
, 10)));
944 printf_filtered (_("'nice' value: %s\n"),
945 pulongest (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("jiffies until next timeout: %s\n"),
948 pulongest (strtoulst (p
, &p
, 10)));
950 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
951 pulongest (strtoulst (p
, &p
, 10)));
953 printf_filtered (_("start time (jiffies since "
954 "system boot): %s\n"),
955 pulongest (strtoulst (p
, &p
, 10)));
957 printf_filtered (_("Virtual memory size: %s\n"),
958 pulongest (strtoulst (p
, &p
, 10)));
960 printf_filtered (_("Resident set size: %s\n"),
961 pulongest (strtoulst (p
, &p
, 10)));
963 printf_filtered (_("rlim: %s\n"),
964 pulongest (strtoulst (p
, &p
, 10)));
966 printf_filtered (_("Start of text: %s\n"),
967 hex_string (strtoulst (p
, &p
, 10)));
969 printf_filtered (_("End of text: %s\n"),
970 hex_string (strtoulst (p
, &p
, 10)));
972 printf_filtered (_("Start of stack: %s\n"),
973 hex_string (strtoulst (p
, &p
, 10)));
974 #if 0 /* Don't know how architecture-dependent the rest is...
975 Anyway the signal bitmap info is available from "status". */
977 printf_filtered (_("Kernel stack pointer: %s\n"),
978 hex_string (strtoulst (p
, &p
, 10)));
980 printf_filtered (_("Kernel instr pointer: %s\n"),
981 hex_string (strtoulst (p
, &p
, 10)));
983 printf_filtered (_("Pending signals bitmap: %s\n"),
984 hex_string (strtoulst (p
, &p
, 10)));
986 printf_filtered (_("Blocked signals bitmap: %s\n"),
987 hex_string (strtoulst (p
, &p
, 10)));
989 printf_filtered (_("Ignored signals bitmap: %s\n"),
990 hex_string (strtoulst (p
, &p
, 10)));
992 printf_filtered (_("Catched signals bitmap: %s\n"),
993 hex_string (strtoulst (p
, &p
, 10)));
995 printf_filtered (_("wchan (system call): %s\n"),
996 hex_string (strtoulst (p
, &p
, 10)));
1000 warning (_("unable to open /proc file '%s'"), filename
);
1004 /* Implement "info proc mappings" for a corefile. */
1007 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1010 ULONGEST count
, page_size
;
1011 unsigned char *descdata
, *filenames
, *descend
;
1013 unsigned int addr_size_bits
, addr_size
;
1014 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
1015 /* We assume this for reading 64-bit core files. */
1016 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1018 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1019 if (section
== NULL
)
1021 warning (_("unable to find mappings in core file"));
1025 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1026 addr_size
= addr_size_bits
/ 8;
1027 note_size
= bfd_get_section_size (section
);
1029 if (note_size
< 2 * addr_size
)
1030 error (_("malformed core note - too short for header"));
1032 gdb::def_vector
<unsigned char> contents (note_size
);
1033 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1035 error (_("could not get core note contents"));
1037 descdata
= contents
.data ();
1038 descend
= descdata
+ note_size
;
1040 if (descdata
[note_size
- 1] != '\0')
1041 error (_("malformed note - does not end with \\0"));
1043 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1044 descdata
+= addr_size
;
1046 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1047 descdata
+= addr_size
;
1049 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1050 error (_("malformed note - too short for supplied file count"));
1052 printf_filtered (_("Mapped address spaces:\n\n"));
1053 if (gdbarch_addr_bit (gdbarch
) == 32)
1055 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1058 " Size", " Offset", "objfile");
1062 printf_filtered (" %18s %18s %10s %10s %s\n",
1065 " Size", " Offset", "objfile");
1068 filenames
= descdata
+ count
* 3 * addr_size
;
1071 ULONGEST start
, end
, file_ofs
;
1073 if (filenames
== descend
)
1074 error (_("malformed note - filenames end too early"));
1076 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1077 descdata
+= addr_size
;
1078 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1079 descdata
+= addr_size
;
1080 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1081 descdata
+= addr_size
;
1083 file_ofs
*= page_size
;
1085 if (gdbarch_addr_bit (gdbarch
) == 32)
1086 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1087 paddress (gdbarch
, start
),
1088 paddress (gdbarch
, end
),
1089 hex_string (end
- start
),
1090 hex_string (file_ofs
),
1093 printf_filtered (" %18s %18s %10s %10s %s\n",
1094 paddress (gdbarch
, start
),
1095 paddress (gdbarch
, end
),
1096 hex_string (end
- start
),
1097 hex_string (file_ofs
),
1100 filenames
+= 1 + strlen ((char *) filenames
);
1104 /* Implement "info proc" for a corefile. */
1107 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1108 enum info_proc_what what
)
1110 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1111 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1117 exe
= bfd_core_file_failing_command (core_bfd
);
1119 printf_filtered ("exe = '%s'\n", exe
);
1121 warning (_("unable to find command name in core file"));
1125 linux_core_info_proc_mappings (gdbarch
, args
);
1127 if (!exe_f
&& !mappings_f
)
1128 error (_("unable to handle request"));
1131 /* Read siginfo data from the core, if possible. Returns -1 on
1132 failure. Otherwise, returns the number of bytes read. READBUF,
1133 OFFSET, and LEN are all as specified by the to_xfer_partial
1137 linux_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
1138 ULONGEST offset
, ULONGEST len
)
1140 thread_section_name
section_name (".note.linuxcore.siginfo", inferior_ptid
);
1141 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
1142 if (section
== NULL
)
1145 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
, offset
, len
))
1151 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1152 ULONGEST offset
, ULONGEST inode
,
1153 int read
, int write
,
1154 int exec
, int modified
,
1155 const char *filename
,
1158 /* List memory regions in the inferior for a corefile. */
1161 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1162 linux_find_memory_region_ftype
*func
,
1165 char mapsfilename
[100];
1166 char coredumpfilter_name
[100];
1168 /* Default dump behavior of coredump_filter (0x33), according to
1169 Documentation/filesystems/proc.txt from the Linux kernel
1171 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1172 | COREFILTER_ANON_SHARED
1173 | COREFILTER_ELF_HEADERS
1174 | COREFILTER_HUGETLB_PRIVATE
);
1176 /* We need to know the real target PID to access /proc. */
1177 if (current_inferior ()->fake_pid_p
)
1180 pid
= current_inferior ()->pid
;
1182 if (use_coredump_filter
)
1184 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1185 "/proc/%d/coredump_filter", pid
);
1186 gdb::unique_xmalloc_ptr
<char> coredumpfilterdata
1187 = target_fileio_read_stralloc (NULL
, coredumpfilter_name
);
1188 if (coredumpfilterdata
!= NULL
)
1192 sscanf (coredumpfilterdata
.get (), "%x", &flags
);
1193 filterflags
= (enum filter_flag
) flags
;
1197 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1198 gdb::unique_xmalloc_ptr
<char> data
1199 = target_fileio_read_stralloc (NULL
, mapsfilename
);
1202 /* Older Linux kernels did not support /proc/PID/smaps. */
1203 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1204 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1211 line
= strtok_r (data
.get (), "\n", &t
);
1212 while (line
!= NULL
)
1214 ULONGEST addr
, endaddr
, offset
, inode
;
1215 const char *permissions
, *device
, *filename
;
1216 struct smaps_vmflags v
;
1217 size_t permissions_len
, device_len
;
1218 int read
, write
, exec
, priv
;
1219 int has_anonymous
= 0;
1220 int should_dump_p
= 0;
1224 memset (&v
, 0, sizeof (v
));
1225 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1226 &offset
, &device
, &device_len
, &inode
, &filename
);
1227 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1228 /* If the mapping is not anonymous, then we can consider it
1229 to be file-backed. These two states (anonymous or
1230 file-backed) seem to be exclusive, but they can actually
1231 coexist. For example, if a file-backed mapping has
1232 "Anonymous:" pages (see more below), then the Linux
1233 kernel will dump this mapping when the user specified
1234 that she only wants anonymous mappings in the corefile
1235 (*even* when she explicitly disabled the dumping of
1236 file-backed mappings). */
1237 mapping_file_p
= !mapping_anon_p
;
1239 /* Decode permissions. */
1240 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1241 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1242 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1243 /* 'private' here actually means VM_MAYSHARE, and not
1244 VM_SHARED. In order to know if a mapping is really
1245 private or not, we must check the flag "sh" in the
1246 VmFlags field. This is done by decode_vmflags. However,
1247 if we are using a Linux kernel released before the commit
1248 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1249 not have the VmFlags there. In this case, there is
1250 really no way to know if we are dealing with VM_SHARED,
1251 so we just assume that VM_MAYSHARE is enough. */
1252 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1254 /* Try to detect if region should be dumped by parsing smaps
1256 for (line
= strtok_r (NULL
, "\n", &t
);
1257 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1258 line
= strtok_r (NULL
, "\n", &t
))
1260 char keyword
[64 + 1];
1262 if (sscanf (line
, "%64s", keyword
) != 1)
1264 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1268 if (strcmp (keyword
, "Anonymous:") == 0)
1270 /* Older Linux kernels did not support the
1271 "Anonymous:" counter. Check it here. */
1274 else if (strcmp (keyword
, "VmFlags:") == 0)
1275 decode_vmflags (line
, &v
);
1277 if (strcmp (keyword
, "AnonHugePages:") == 0
1278 || strcmp (keyword
, "Anonymous:") == 0)
1280 unsigned long number
;
1282 if (sscanf (line
, "%*s%lu", &number
) != 1)
1284 warning (_("Error parsing {s,}maps file '%s' number"),
1290 /* Even if we are dealing with a file-backed
1291 mapping, if it contains anonymous pages we
1292 consider it to be *also* an anonymous
1293 mapping, because this is what the Linux
1296 // Dump segments that have been written to.
1297 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1300 Note that if the mapping is already marked as
1301 file-backed (i.e., mapping_file_p is
1302 non-zero), then this is a special case, and
1303 this mapping will be dumped either when the
1304 user wants to dump file-backed *or* anonymous
1312 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1313 mapping_anon_p
, mapping_file_p
,
1317 /* Older Linux kernels did not support the "Anonymous:" counter.
1318 If it is missing, we can't be sure - dump all the pages. */
1322 /* Invoke the callback function to create the corefile segment. */
1324 func (addr
, endaddr
- addr
, offset
, inode
,
1325 read
, write
, exec
, 1, /* MODIFIED is true because we
1326 want to dump the mapping. */
1336 /* A structure for passing information through
1337 linux_find_memory_regions_full. */
1339 struct linux_find_memory_regions_data
1341 /* The original callback. */
1343 find_memory_region_ftype func
;
1345 /* The original datum. */
1350 /* A callback for linux_find_memory_regions that converts between the
1351 "full"-style callback and find_memory_region_ftype. */
1354 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1355 ULONGEST offset
, ULONGEST inode
,
1356 int read
, int write
, int exec
, int modified
,
1357 const char *filename
, void *arg
)
1359 struct linux_find_memory_regions_data
*data
1360 = (struct linux_find_memory_regions_data
*) arg
;
1362 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1365 /* A variant of linux_find_memory_regions_full that is suitable as the
1366 gdbarch find_memory_regions method. */
1369 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1370 find_memory_region_ftype func
, void *obfd
)
1372 struct linux_find_memory_regions_data data
;
1377 return linux_find_memory_regions_full (gdbarch
,
1378 linux_find_memory_regions_thunk
,
1382 /* Determine which signal stopped execution. */
1385 find_signalled_thread (struct thread_info
*info
, void *data
)
1387 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1388 && info
->ptid
.pid () == inferior_ptid
.pid ())
1394 /* Generate corefile notes for SPU contexts. */
1397 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1399 static const char *spu_files
[] =
1421 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1423 /* Determine list of SPU ids. */
1424 gdb::optional
<gdb::byte_vector
>
1425 spu_ids
= target_read_alloc (current_top_target (),
1426 TARGET_OBJECT_SPU
, NULL
);
1431 /* Generate corefile notes for each SPU file. */
1432 for (size_t i
= 0; i
< spu_ids
->size (); i
+= 4)
1434 int fd
= extract_unsigned_integer (spu_ids
->data () + i
, 4, byte_order
);
1436 for (size_t j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1438 char annex
[32], note_name
[32];
1440 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1441 gdb::optional
<gdb::byte_vector
> spu_data
1442 = target_read_alloc (current_top_target (), TARGET_OBJECT_SPU
, annex
);
1444 if (spu_data
&& !spu_data
->empty ())
1446 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1447 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1461 /* This is used to pass information from
1462 linux_make_mappings_corefile_notes through
1463 linux_find_memory_regions_full. */
1465 struct linux_make_mappings_data
1467 /* Number of files mapped. */
1468 ULONGEST file_count
;
1470 /* The obstack for the main part of the data. */
1471 struct obstack
*data_obstack
;
1473 /* The filename obstack. */
1474 struct obstack
*filename_obstack
;
1476 /* The architecture's "long" type. */
1477 struct type
*long_type
;
1480 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1482 /* A callback for linux_find_memory_regions_full that updates the
1483 mappings data for linux_make_mappings_corefile_notes. */
1486 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1487 ULONGEST offset
, ULONGEST inode
,
1488 int read
, int write
, int exec
, int modified
,
1489 const char *filename
, void *data
)
1491 struct linux_make_mappings_data
*map_data
1492 = (struct linux_make_mappings_data
*) data
;
1493 gdb_byte buf
[sizeof (ULONGEST
)];
1495 if (*filename
== '\0' || inode
== 0)
1498 ++map_data
->file_count
;
1500 pack_long (buf
, map_data
->long_type
, vaddr
);
1501 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1502 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1503 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1504 pack_long (buf
, map_data
->long_type
, offset
);
1505 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1507 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1512 /* Write the file mapping data to the core file, if possible. OBFD is
1513 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1514 is a pointer to the note size. Returns the new NOTE_DATA and
1515 updates NOTE_SIZE. */
1518 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1519 char *note_data
, int *note_size
)
1521 struct linux_make_mappings_data mapping_data
;
1522 struct type
*long_type
1523 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1524 gdb_byte buf
[sizeof (ULONGEST
)];
1526 auto_obstack data_obstack
, filename_obstack
;
1528 mapping_data
.file_count
= 0;
1529 mapping_data
.data_obstack
= &data_obstack
;
1530 mapping_data
.filename_obstack
= &filename_obstack
;
1531 mapping_data
.long_type
= long_type
;
1533 /* Reserve space for the count. */
1534 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1535 /* We always write the page size as 1 since we have no good way to
1536 determine the correct value. */
1537 pack_long (buf
, long_type
, 1);
1538 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1540 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1543 if (mapping_data
.file_count
!= 0)
1545 /* Write the count to the obstack. */
1546 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1547 long_type
, mapping_data
.file_count
);
1549 /* Copy the filenames to the data obstack. */
1550 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1551 obstack_object_size (&filename_obstack
));
1553 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1555 obstack_base (&data_obstack
),
1556 obstack_object_size (&data_obstack
));
1562 /* Structure for passing information from
1563 linux_collect_thread_registers via an iterator to
1564 linux_collect_regset_section_cb. */
1566 struct linux_collect_regset_section_cb_data
1568 struct gdbarch
*gdbarch
;
1569 const struct regcache
*regcache
;
1574 enum gdb_signal stop_signal
;
1575 int abort_iteration
;
1578 /* Callback for iterate_over_regset_sections that records a single
1579 regset in the corefile note section. */
1582 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1583 const struct regset
*regset
,
1584 const char *human_name
, void *cb_data
)
1587 struct linux_collect_regset_section_cb_data
*data
1588 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1590 if (data
->abort_iteration
)
1593 gdb_assert (regset
&& regset
->collect_regset
);
1595 buf
= (char *) xmalloc (size
);
1596 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1598 /* PRSTATUS still needs to be treated specially. */
1599 if (strcmp (sect_name
, ".reg") == 0)
1600 data
->note_data
= (char *) elfcore_write_prstatus
1601 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1602 gdb_signal_to_host (data
->stop_signal
), buf
);
1604 data
->note_data
= (char *) elfcore_write_register_note
1605 (data
->obfd
, data
->note_data
, data
->note_size
,
1606 sect_name
, buf
, size
);
1609 if (data
->note_data
== NULL
)
1610 data
->abort_iteration
= 1;
1613 /* Records the thread's register state for the corefile note
1617 linux_collect_thread_registers (const struct regcache
*regcache
,
1618 ptid_t ptid
, bfd
*obfd
,
1619 char *note_data
, int *note_size
,
1620 enum gdb_signal stop_signal
)
1622 struct gdbarch
*gdbarch
= regcache
->arch ();
1623 struct linux_collect_regset_section_cb_data data
;
1625 data
.gdbarch
= gdbarch
;
1626 data
.regcache
= regcache
;
1628 data
.note_data
= note_data
;
1629 data
.note_size
= note_size
;
1630 data
.stop_signal
= stop_signal
;
1631 data
.abort_iteration
= 0;
1633 /* For remote targets the LWP may not be available, so use the TID. */
1634 data
.lwp
= ptid
.lwp ();
1636 data
.lwp
= ptid
.tid ();
1638 gdbarch_iterate_over_regset_sections (gdbarch
,
1639 linux_collect_regset_section_cb
,
1641 return data
.note_data
;
1644 /* Fetch the siginfo data for the specified thread, if it exists. If
1645 there is no data, or we could not read it, return an empty
1648 static gdb::byte_vector
1649 linux_get_siginfo_data (thread_info
*thread
, struct gdbarch
*gdbarch
)
1651 struct type
*siginfo_type
;
1654 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1655 return gdb::byte_vector ();
1657 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1658 inferior_ptid
= thread
->ptid
;
1660 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1662 gdb::byte_vector
buf (TYPE_LENGTH (siginfo_type
));
1664 bytes_read
= target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1665 buf
.data (), 0, TYPE_LENGTH (siginfo_type
));
1666 if (bytes_read
!= TYPE_LENGTH (siginfo_type
))
1672 struct linux_corefile_thread_data
1674 struct gdbarch
*gdbarch
;
1678 enum gdb_signal stop_signal
;
1681 /* Records the thread's register state for the corefile note
1685 linux_corefile_thread (struct thread_info
*info
,
1686 struct linux_corefile_thread_data
*args
)
1688 struct regcache
*regcache
;
1690 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1692 target_fetch_registers (regcache
, -1);
1693 gdb::byte_vector siginfo_data
= linux_get_siginfo_data (info
, args
->gdbarch
);
1695 args
->note_data
= linux_collect_thread_registers
1696 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1697 args
->note_size
, args
->stop_signal
);
1699 /* Don't return anything if we got no register information above,
1700 such a core file is useless. */
1701 if (args
->note_data
!= NULL
)
1702 if (!siginfo_data
.empty ())
1703 args
->note_data
= elfcore_write_note (args
->obfd
,
1707 siginfo_data
.data (),
1708 siginfo_data
.size ());
1711 /* Fill the PRPSINFO structure with information about the process being
1712 debugged. Returns 1 in case of success, 0 for failures. Please note that
1713 even if the structure cannot be entirely filled (e.g., GDB was unable to
1714 gather information about the process UID/GID), this function will still
1715 return 1 since some information was already recorded. It will only return
1716 0 iff nothing can be gathered. */
1719 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1721 /* The filename which we will use to obtain some info about the process.
1722 We will basically use this to store the `/proc/PID/FILENAME' file. */
1724 /* The basename of the executable. */
1725 const char *basename
;
1727 /* Temporary buffer. */
1729 /* The valid states of a process, according to the Linux kernel. */
1730 const char valid_states
[] = "RSDTZW";
1731 /* The program state. */
1732 const char *prog_state
;
1733 /* The state of the process. */
1735 /* The PID of the program which generated the corefile. */
1737 /* Process flags. */
1738 unsigned int pr_flag
;
1739 /* Process nice value. */
1741 /* The number of fields read by `sscanf'. */
1744 gdb_assert (p
!= NULL
);
1746 /* Obtaining PID and filename. */
1747 pid
= inferior_ptid
.pid ();
1748 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1749 /* The full name of the program which generated the corefile. */
1750 gdb::unique_xmalloc_ptr
<char> fname
1751 = target_fileio_read_stralloc (NULL
, filename
);
1753 if (fname
== NULL
|| fname
.get ()[0] == '\0')
1755 /* No program name was read, so we won't be able to retrieve more
1756 information about the process. */
1760 memset (p
, 0, sizeof (*p
));
1762 /* Defining the PID. */
1765 /* Copying the program name. Only the basename matters. */
1766 basename
= lbasename (fname
.get ());
1767 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1768 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1770 infargs
= get_inferior_args ();
1772 /* The arguments of the program. */
1773 std::string psargs
= fname
.get ();
1774 if (infargs
!= NULL
)
1775 psargs
= psargs
+ " " + infargs
;
1777 strncpy (p
->pr_psargs
, psargs
.c_str (), sizeof (p
->pr_psargs
));
1778 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1780 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1781 /* The contents of `/proc/PID/stat'. */
1782 gdb::unique_xmalloc_ptr
<char> proc_stat_contents
1783 = target_fileio_read_stralloc (NULL
, filename
);
1784 char *proc_stat
= proc_stat_contents
.get ();
1786 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1788 /* Despite being unable to read more information about the
1789 process, we return 1 here because at least we have its
1790 command line, PID and arguments. */
1794 /* Ok, we have the stats. It's time to do a little parsing of the
1795 contents of the buffer, so that we end up reading what we want.
1797 The following parsing mechanism is strongly based on the
1798 information generated by the `fs/proc/array.c' file, present in
1799 the Linux kernel tree. More details about how the information is
1800 displayed can be obtained by seeing the manpage of proc(5),
1801 specifically under the entry of `/proc/[pid]/stat'. */
1803 /* Getting rid of the PID, since we already have it. */
1804 while (isdigit (*proc_stat
))
1807 proc_stat
= skip_spaces (proc_stat
);
1809 /* ps command also relies on no trailing fields ever contain ')'. */
1810 proc_stat
= strrchr (proc_stat
, ')');
1811 if (proc_stat
== NULL
)
1815 proc_stat
= skip_spaces (proc_stat
);
1817 n_fields
= sscanf (proc_stat
,
1818 "%c" /* Process state. */
1819 "%d%d%d" /* Parent PID, group ID, session ID. */
1820 "%*d%*d" /* tty_nr, tpgid (not used). */
1822 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1823 cmajflt (not used). */
1824 "%*s%*s%*s%*s" /* utime, stime, cutime,
1825 cstime (not used). */
1826 "%*s" /* Priority (not used). */
1829 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1835 /* Again, we couldn't read the complementary information about
1836 the process state. However, we already have minimal
1837 information, so we just return 1 here. */
1841 /* Filling the structure fields. */
1842 prog_state
= strchr (valid_states
, pr_sname
);
1843 if (prog_state
!= NULL
)
1844 p
->pr_state
= prog_state
- valid_states
;
1847 /* Zero means "Running". */
1851 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1852 p
->pr_zomb
= p
->pr_sname
== 'Z';
1853 p
->pr_nice
= pr_nice
;
1854 p
->pr_flag
= pr_flag
;
1856 /* Finally, obtaining the UID and GID. For that, we read and parse the
1857 contents of the `/proc/PID/status' file. */
1858 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1859 /* The contents of `/proc/PID/status'. */
1860 gdb::unique_xmalloc_ptr
<char> proc_status_contents
1861 = target_fileio_read_stralloc (NULL
, filename
);
1862 char *proc_status
= proc_status_contents
.get ();
1864 if (proc_status
== NULL
|| *proc_status
== '\0')
1866 /* Returning 1 since we already have a bunch of information. */
1870 /* Extracting the UID. */
1871 tmpstr
= strstr (proc_status
, "Uid:");
1874 /* Advancing the pointer to the beginning of the UID. */
1875 tmpstr
+= sizeof ("Uid:");
1876 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1879 if (isdigit (*tmpstr
))
1880 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1883 /* Extracting the GID. */
1884 tmpstr
= strstr (proc_status
, "Gid:");
1887 /* Advancing the pointer to the beginning of the GID. */
1888 tmpstr
+= sizeof ("Gid:");
1889 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1892 if (isdigit (*tmpstr
))
1893 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1899 /* Build the note section for a corefile, and return it in a malloc
1903 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1905 struct linux_corefile_thread_data thread_args
;
1906 struct elf_internal_linux_prpsinfo prpsinfo
;
1907 char *note_data
= NULL
;
1908 struct thread_info
*curr_thr
, *signalled_thr
, *thr
;
1910 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1913 if (linux_fill_prpsinfo (&prpsinfo
))
1915 if (gdbarch_ptr_bit (gdbarch
) == 64)
1916 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1917 note_data
, note_size
,
1920 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1921 note_data
, note_size
,
1925 /* Thread register information. */
1928 update_thread_list ();
1930 CATCH (e
, RETURN_MASK_ERROR
)
1932 exception_print (gdb_stderr
, e
);
1936 /* Like the kernel, prefer dumping the signalled thread first.
1937 "First thread" is what tools use to infer the signalled thread.
1938 In case there's more than one signalled thread, prefer the
1939 current thread, if it is signalled. */
1940 curr_thr
= inferior_thread ();
1941 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1942 signalled_thr
= curr_thr
;
1945 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
1946 if (signalled_thr
== NULL
)
1947 signalled_thr
= curr_thr
;
1950 thread_args
.gdbarch
= gdbarch
;
1951 thread_args
.obfd
= obfd
;
1952 thread_args
.note_data
= note_data
;
1953 thread_args
.note_size
= note_size
;
1954 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1956 linux_corefile_thread (signalled_thr
, &thread_args
);
1957 ALL_NON_EXITED_THREADS (thr
)
1959 if (thr
== signalled_thr
)
1961 if (thr
->ptid
.pid () != inferior_ptid
.pid ())
1964 linux_corefile_thread (thr
, &thread_args
);
1967 note_data
= thread_args
.note_data
;
1971 /* Auxillary vector. */
1972 gdb::optional
<gdb::byte_vector
> auxv
=
1973 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
1974 if (auxv
&& !auxv
->empty ())
1976 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1977 "CORE", NT_AUXV
, auxv
->data (),
1984 /* SPU information. */
1985 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
1989 /* File mappings. */
1990 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1991 note_data
, note_size
);
1996 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1997 gdbarch.h. This function is not static because it is exported to
1998 other -tdep files. */
2001 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2006 return GDB_SIGNAL_0
;
2009 return GDB_SIGNAL_HUP
;
2012 return GDB_SIGNAL_INT
;
2015 return GDB_SIGNAL_QUIT
;
2018 return GDB_SIGNAL_ILL
;
2021 return GDB_SIGNAL_TRAP
;
2024 return GDB_SIGNAL_ABRT
;
2027 return GDB_SIGNAL_BUS
;
2030 return GDB_SIGNAL_FPE
;
2033 return GDB_SIGNAL_KILL
;
2036 return GDB_SIGNAL_USR1
;
2039 return GDB_SIGNAL_SEGV
;
2042 return GDB_SIGNAL_USR2
;
2045 return GDB_SIGNAL_PIPE
;
2048 return GDB_SIGNAL_ALRM
;
2051 return GDB_SIGNAL_TERM
;
2054 return GDB_SIGNAL_CHLD
;
2057 return GDB_SIGNAL_CONT
;
2060 return GDB_SIGNAL_STOP
;
2063 return GDB_SIGNAL_TSTP
;
2066 return GDB_SIGNAL_TTIN
;
2069 return GDB_SIGNAL_TTOU
;
2072 return GDB_SIGNAL_URG
;
2075 return GDB_SIGNAL_XCPU
;
2078 return GDB_SIGNAL_XFSZ
;
2080 case LINUX_SIGVTALRM
:
2081 return GDB_SIGNAL_VTALRM
;
2084 return GDB_SIGNAL_PROF
;
2086 case LINUX_SIGWINCH
:
2087 return GDB_SIGNAL_WINCH
;
2089 /* No way to differentiate between SIGIO and SIGPOLL.
2090 Therefore, we just handle the first one. */
2092 return GDB_SIGNAL_IO
;
2095 return GDB_SIGNAL_PWR
;
2098 return GDB_SIGNAL_SYS
;
2100 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2101 therefore we have to handle them here. */
2102 case LINUX_SIGRTMIN
:
2103 return GDB_SIGNAL_REALTIME_32
;
2105 case LINUX_SIGRTMAX
:
2106 return GDB_SIGNAL_REALTIME_64
;
2109 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2111 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2113 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2116 return GDB_SIGNAL_UNKNOWN
;
2119 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2120 gdbarch.h. This function is not static because it is exported to
2121 other -tdep files. */
2124 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2125 enum gdb_signal signal
)
2132 case GDB_SIGNAL_HUP
:
2133 return LINUX_SIGHUP
;
2135 case GDB_SIGNAL_INT
:
2136 return LINUX_SIGINT
;
2138 case GDB_SIGNAL_QUIT
:
2139 return LINUX_SIGQUIT
;
2141 case GDB_SIGNAL_ILL
:
2142 return LINUX_SIGILL
;
2144 case GDB_SIGNAL_TRAP
:
2145 return LINUX_SIGTRAP
;
2147 case GDB_SIGNAL_ABRT
:
2148 return LINUX_SIGABRT
;
2150 case GDB_SIGNAL_FPE
:
2151 return LINUX_SIGFPE
;
2153 case GDB_SIGNAL_KILL
:
2154 return LINUX_SIGKILL
;
2156 case GDB_SIGNAL_BUS
:
2157 return LINUX_SIGBUS
;
2159 case GDB_SIGNAL_SEGV
:
2160 return LINUX_SIGSEGV
;
2162 case GDB_SIGNAL_SYS
:
2163 return LINUX_SIGSYS
;
2165 case GDB_SIGNAL_PIPE
:
2166 return LINUX_SIGPIPE
;
2168 case GDB_SIGNAL_ALRM
:
2169 return LINUX_SIGALRM
;
2171 case GDB_SIGNAL_TERM
:
2172 return LINUX_SIGTERM
;
2174 case GDB_SIGNAL_URG
:
2175 return LINUX_SIGURG
;
2177 case GDB_SIGNAL_STOP
:
2178 return LINUX_SIGSTOP
;
2180 case GDB_SIGNAL_TSTP
:
2181 return LINUX_SIGTSTP
;
2183 case GDB_SIGNAL_CONT
:
2184 return LINUX_SIGCONT
;
2186 case GDB_SIGNAL_CHLD
:
2187 return LINUX_SIGCHLD
;
2189 case GDB_SIGNAL_TTIN
:
2190 return LINUX_SIGTTIN
;
2192 case GDB_SIGNAL_TTOU
:
2193 return LINUX_SIGTTOU
;
2198 case GDB_SIGNAL_XCPU
:
2199 return LINUX_SIGXCPU
;
2201 case GDB_SIGNAL_XFSZ
:
2202 return LINUX_SIGXFSZ
;
2204 case GDB_SIGNAL_VTALRM
:
2205 return LINUX_SIGVTALRM
;
2207 case GDB_SIGNAL_PROF
:
2208 return LINUX_SIGPROF
;
2210 case GDB_SIGNAL_WINCH
:
2211 return LINUX_SIGWINCH
;
2213 case GDB_SIGNAL_USR1
:
2214 return LINUX_SIGUSR1
;
2216 case GDB_SIGNAL_USR2
:
2217 return LINUX_SIGUSR2
;
2219 case GDB_SIGNAL_PWR
:
2220 return LINUX_SIGPWR
;
2222 case GDB_SIGNAL_POLL
:
2223 return LINUX_SIGPOLL
;
2225 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2226 therefore we have to handle it here. */
2227 case GDB_SIGNAL_REALTIME_32
:
2228 return LINUX_SIGRTMIN
;
2230 /* Same comment applies to _64. */
2231 case GDB_SIGNAL_REALTIME_64
:
2232 return LINUX_SIGRTMAX
;
2235 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2236 if (signal
>= GDB_SIGNAL_REALTIME_33
2237 && signal
<= GDB_SIGNAL_REALTIME_63
)
2239 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2241 return LINUX_SIGRTMIN
+ 1 + offset
;
2247 /* Helper for linux_vsyscall_range that does the real work of finding
2248 the vsyscall's address range. */
2251 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2256 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2259 /* It doesn't make sense to access the host's /proc when debugging a
2260 core file. Instead, look for the PT_LOAD segment that matches
2262 if (!target_has_execution
)
2264 Elf_Internal_Phdr
*phdrs
;
2268 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2269 if (phdrs_size
== -1)
2272 phdrs
= (Elf_Internal_Phdr
*) alloca (phdrs_size
);
2273 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
);
2274 if (num_phdrs
== -1)
2277 for (i
= 0; i
< num_phdrs
; i
++)
2278 if (phdrs
[i
].p_type
== PT_LOAD
2279 && phdrs
[i
].p_vaddr
== range
->start
)
2281 range
->length
= phdrs
[i
].p_memsz
;
2288 /* We need to know the real target PID to access /proc. */
2289 if (current_inferior ()->fake_pid_p
)
2292 pid
= current_inferior ()->pid
;
2294 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2295 reading /proc/PID/maps (2). The later identifies thread stacks
2296 in the output, which requires scanning every thread in the thread
2297 group to check whether a VMA is actually a thread's stack. With
2298 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2299 a few thousand threads, (1) takes a few miliseconds, while (2)
2300 takes several seconds. Also note that "smaps", what we read for
2301 determining core dump mappings, is even slower than "maps". */
2302 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2303 gdb::unique_xmalloc_ptr
<char> data
2304 = target_fileio_read_stralloc (NULL
, filename
);
2308 char *saveptr
= NULL
;
2310 for (line
= strtok_r (data
.get (), "\n", &saveptr
);
2312 line
= strtok_r (NULL
, "\n", &saveptr
))
2314 ULONGEST addr
, endaddr
;
2315 const char *p
= line
;
2317 addr
= strtoulst (p
, &p
, 16);
2318 if (addr
== range
->start
)
2322 endaddr
= strtoulst (p
, &p
, 16);
2323 range
->length
= endaddr
- addr
;
2329 warning (_("unable to open /proc file '%s'"), filename
);
2334 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2335 caching, and defers the real work to linux_vsyscall_range_raw. */
2338 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2340 struct linux_info
*info
= get_linux_inferior_data ();
2342 if (info
->vsyscall_range_p
== 0)
2344 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2345 info
->vsyscall_range_p
= 1;
2347 info
->vsyscall_range_p
= -1;
2350 if (info
->vsyscall_range_p
< 0)
2353 *range
= info
->vsyscall_range
;
2357 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2358 definitions would be dependent on compilation host. */
2359 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2360 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2362 /* See gdbarch.sh 'infcall_mmap'. */
2365 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2367 struct objfile
*objf
;
2368 /* Do there still exist any Linux systems without "mmap64"?
2369 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2370 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2371 struct value
*addr_val
;
2372 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2376 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2378 struct value
*arg
[ARG_LAST
];
2380 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2382 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2383 arg
[ARG_LENGTH
] = value_from_ulongest
2384 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2385 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2386 | GDB_MMAP_PROT_EXEC
))
2388 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2389 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2390 GDB_MMAP_MAP_PRIVATE
2391 | GDB_MMAP_MAP_ANONYMOUS
);
2392 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2393 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2395 addr_val
= call_function_by_hand (mmap_val
, NULL
, ARG_LAST
, arg
);
2396 retval
= value_as_address (addr_val
);
2397 if (retval
== (CORE_ADDR
) -1)
2398 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2403 /* See gdbarch.sh 'infcall_munmap'. */
2406 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2408 struct objfile
*objf
;
2409 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2410 struct value
*retval_val
;
2411 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2415 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2417 struct value
*arg
[ARG_LAST
];
2419 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2421 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2422 arg
[ARG_LENGTH
] = value_from_ulongest
2423 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2424 retval_val
= call_function_by_hand (munmap_val
, NULL
, ARG_LAST
, arg
);
2425 retval
= value_as_long (retval_val
);
2427 warning (_("Failed inferior munmap call at %s for %s bytes, "
2428 "errno is changed."),
2429 hex_string (addr
), pulongest (size
));
2432 /* See linux-tdep.h. */
2435 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2440 /* Determine entry point from target auxiliary vector. This avoids
2441 the need for symbols. Also, when debugging a stand-alone SPU
2442 executable, entry_point_address () will point to an SPU
2443 local-store address and is thus not usable as displaced stepping
2444 location. The auxiliary vector gets us the PowerPC-side entry
2445 point address instead. */
2446 if (target_auxv_search (current_top_target (), AT_ENTRY
, &addr
) <= 0)
2447 throw_error (NOT_SUPPORTED_ERROR
,
2448 _("Cannot find AT_ENTRY auxiliary vector entry."));
2450 /* Make certain that the address points at real code, and not a
2451 function descriptor. */
2452 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2453 current_top_target ());
2455 /* Inferior calls also use the entry point as a breakpoint location.
2456 We don't want displaced stepping to interfere with those
2457 breakpoints, so leave space. */
2458 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2464 /* Display whether the gcore command is using the
2465 /proc/PID/coredump_filter file. */
2468 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2469 struct cmd_list_element
*c
, const char *value
)
2471 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2472 " corefiles is %s.\n"), value
);
2475 /* Display whether the gcore command is dumping mappings marked with
2476 the VM_DONTDUMP flag. */
2479 show_dump_excluded_mappings (struct ui_file
*file
, int from_tty
,
2480 struct cmd_list_element
*c
, const char *value
)
2482 fprintf_filtered (file
, _("Dumping of mappings marked with the VM_DONTDUMP"
2483 " flag is %s.\n"), value
);
2486 /* To be called from the various GDB_OSABI_LINUX handlers for the
2487 various GNU/Linux architectures and machine types. */
2490 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2492 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2493 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2494 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2495 set_gdbarch_core_xfer_siginfo (gdbarch
, linux_core_xfer_siginfo
);
2496 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2497 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2498 set_gdbarch_has_shared_address_space (gdbarch
,
2499 linux_has_shared_address_space
);
2500 set_gdbarch_gdb_signal_from_target (gdbarch
,
2501 linux_gdb_signal_from_target
);
2502 set_gdbarch_gdb_signal_to_target (gdbarch
,
2503 linux_gdb_signal_to_target
);
2504 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2505 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2506 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2507 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2511 _initialize_linux_tdep (void)
2513 linux_gdbarch_data_handle
=
2514 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2516 /* Set a cache per-inferior. */
2518 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2519 /* Observers used to invalidate the cache when needed. */
2520 gdb::observers::inferior_exit
.attach (invalidate_linux_cache_inf
);
2521 gdb::observers::inferior_appeared
.attach (invalidate_linux_cache_inf
);
2523 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2524 &use_coredump_filter
, _("\
2525 Set whether gcore should consider /proc/PID/coredump_filter."),
2527 Show whether gcore should consider /proc/PID/coredump_filter."),
2529 Use this command to set whether gcore should consider the contents\n\
2530 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2531 about this file, refer to the manpage of core(5)."),
2532 NULL
, show_use_coredump_filter
,
2533 &setlist
, &showlist
);
2535 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files
,
2536 &dump_excluded_mappings
, _("\
2537 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2539 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2541 Use this command to set whether gcore should dump mappings marked with the\n\
2542 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2543 more information about this file, refer to the manpage of proc(5) and core(5)."),
2544 NULL
, show_dump_excluded_mappings
,
2545 &setlist
, &showlist
);