1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
35 #include "observable.h"
39 #include "gdb_regex.h"
40 #include "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)
420 if (ptid.lwp () != 0)
421 return string_printf ("LWP %ld", ptid.lwp ());
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, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
590 be dumped, or 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.
630 - Even if, at the end, we decided that we should not dump the
631 mapping, we still have to check if it is something like an ELF
632 header (of a DSO or an executable, for example). If it is, and
633 if the user is interested in dump it, then we should dump it. */
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, ULONGEST addr, ULONGEST offset)
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;
650 /* We always dump vDSO and vsyscall mappings, because it's likely that
651 there'll be no file to read the contents from at core load time.
652 The kernel does the same. */
653 if (strcmp ("[vdso]", filename) == 0
654 || strcmp ("[vsyscall]", filename) == 0)
657 if (v->initialized_p)
659 /* We never dump I/O mappings. */
663 /* Check if we should exclude this mapping. */
664 if (!dump_excluded_mappings && v->exclude_coredump)
667 /* Update our notion of whether this mapping is shared or
668 private based on a trustworthy value. */
669 private_p = !v->shared_mapping;
671 /* HugeTLB checking. */
672 if (v->uses_huge_tlb)
674 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
675 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
684 if (mapping_anon_p && mapping_file_p)
686 /* This is a special situation. It can happen when we see a
687 mapping that is file-backed, but that contains anonymous
689 dump_p = ((filterflags & COREFILTER_ANON_PRIVATE) != 0
690 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
692 else if (mapping_anon_p)
693 dump_p = (filterflags & COREFILTER_ANON_PRIVATE) != 0;
695 dump_p = (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
699 if (mapping_anon_p && mapping_file_p)
701 /* This is a special situation. It can happen when we see a
702 mapping that is file-backed, but that contains anonymous
704 dump_p = ((filterflags & COREFILTER_ANON_SHARED) != 0
705 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
707 else if (mapping_anon_p)
708 dump_p = (filterflags & COREFILTER_ANON_SHARED) != 0;
710 dump_p = (filterflags & COREFILTER_MAPPED_SHARED) != 0;
713 /* Even if we decided that we shouldn't dump this mapping, we still
714 have to check whether (a) the user wants us to dump mappings
715 containing an ELF header, and (b) the mapping in question
716 contains an ELF header. If (a) and (b) are true, then we should
719 A mapping contains an ELF header if it is a private mapping, its
720 offset is zero, and its first word is ELFMAG. */
721 if (!dump_p && private_p && offset == 0
722 && (filterflags & COREFILTER_ELF_HEADERS) != 0)
724 /* Let's check if we have an ELF header. */
725 gdb::unique_xmalloc_ptr<char> header;
728 /* Useful define specifying the size of the ELF magical
734 /* Read the first SELFMAG bytes and check if it is ELFMAG. */
735 if (target_read_string (addr, &header, SELFMAG, &errcode) == SELFMAG
738 const char *h = header.get ();
740 /* The EI_MAG* and ELFMAG* constants come from
742 if (h[EI_MAG0] == ELFMAG0 && h[EI_MAG1] == ELFMAG1
743 && h[EI_MAG2] == ELFMAG2 && h[EI_MAG3] == ELFMAG3)
745 /* This mapping contains an ELF header, so we
755 /* Implement the "info proc" command. */
758 linux_info_proc (struct gdbarch *gdbarch, const char *args,
759 enum info_proc_what what)
761 /* A long is used for pid instead of an int to avoid a loss of precision
762 compiler warning from the output of strtoul. */
764 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
765 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
766 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
767 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
768 int status_f = (what == IP_STATUS || what == IP_ALL);
769 int stat_f = (what == IP_STAT || what == IP_ALL);
773 if (args && isdigit (args[0]))
777 pid = strtoul (args, &tem, 10);
782 if (!target_has_execution)
783 error (_("No current process: you must name one."));
784 if (current_inferior ()->fake_pid_p)
785 error (_("Can't determine the current process's PID: you must name one."));
787 pid = current_inferior ()->pid;
790 args = skip_spaces (args);
792 error (_("Too many parameters: %s"), args);
794 printf_filtered (_("process %ld\n"), pid);
797 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
799 ssize_t len = target_fileio_read_alloc (NULL, filename, &buffer);
803 gdb::unique_xmalloc_ptr<char> cmdline ((char *) buffer);
806 for (pos = 0; pos < len - 1; pos++)
808 if (buffer[pos] == '\0')
811 buffer[len - 1] = '\0';
812 printf_filtered ("cmdline = '%s'\n", buffer);
815 warning (_("unable to open /proc file '%s'"), filename);
819 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
820 gdb::optional<std::string> contents
821 = target_fileio_readlink (NULL, filename, &target_errno);
822 if (contents.has_value ())
823 printf_filtered ("cwd = '%s'\n", contents->c_str ());
825 warning (_("unable to read link '%s'"), filename);
829 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
830 gdb::optional<std::string> contents
831 = target_fileio_readlink (NULL, filename, &target_errno);
832 if (contents.has_value ())
833 printf_filtered ("exe = '%s'\n", contents->c_str ());
835 warning (_("unable to read link '%s'"), filename);
839 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
840 gdb::unique_xmalloc_ptr<char> map
841 = target_fileio_read_stralloc (NULL, filename);
846 printf_filtered (_("Mapped address spaces:\n\n"));
847 if (gdbarch_addr_bit (gdbarch) == 32)
849 printf_filtered ("\t%10s %10s %10s %10s %s\n",
852 " Size", " Offset", "objfile");
856 printf_filtered (" %18s %18s %10s %10s %s\n",
859 " Size", " Offset", "objfile");
862 for (line = strtok (map.get (), "\n");
864 line = strtok (NULL, "\n"))
866 ULONGEST addr, endaddr, offset, inode;
867 const char *permissions, *device, *mapping_filename;
868 size_t permissions_len, device_len;
870 read_mapping (line, &addr, &endaddr,
871 &permissions, &permissions_len,
872 &offset, &device, &device_len,
873 &inode, &mapping_filename);
875 if (gdbarch_addr_bit (gdbarch) == 32)
877 printf_filtered ("\t%10s %10s %10s %10s %s\n",
878 paddress (gdbarch, addr),
879 paddress (gdbarch, endaddr),
880 hex_string (endaddr - addr),
882 *mapping_filename ? mapping_filename : "");
886 printf_filtered (" %18s %18s %10s %10s %s\n",
887 paddress (gdbarch, addr),
888 paddress (gdbarch, endaddr),
889 hex_string (endaddr - addr),
891 *mapping_filename ? mapping_filename : "");
896 warning (_("unable to open /proc file '%s'"), filename);
900 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
901 gdb::unique_xmalloc_ptr<char> status
902 = target_fileio_read_stralloc (NULL, filename);
904 puts_filtered (status.get ());
906 warning (_("unable to open /proc file '%s'"), filename);
910 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
911 gdb::unique_xmalloc_ptr<char> statstr
912 = target_fileio_read_stralloc (NULL, filename);
915 const char *p = statstr.get ();
917 printf_filtered (_("Process: %s\n"),
918 pulongest (strtoulst (p, &p, 10)));
923 /* ps command also relies on no trailing fields
925 const char *ep = strrchr (p, ')');
928 printf_filtered ("Exec file: %.*s\n",
929 (int) (ep - p - 1), p + 1);
936 printf_filtered (_("State: %c\n"), *p++);
939 printf_filtered (_("Parent process: %s\n"),
940 pulongest (strtoulst (p, &p, 10)));
942 printf_filtered (_("Process group: %s\n"),
943 pulongest (strtoulst (p, &p, 10)));
945 printf_filtered (_("Session id: %s\n"),
946 pulongest (strtoulst (p, &p, 10)));
948 printf_filtered (_("TTY: %s\n"),
949 pulongest (strtoulst (p, &p, 10)));
951 printf_filtered (_("TTY owner process group: %s\n"),
952 pulongest (strtoulst (p, &p, 10)));
955 printf_filtered (_("Flags: %s\n"),
956 hex_string (strtoulst (p, &p, 10)));
958 printf_filtered (_("Minor faults (no memory page): %s\n"),
959 pulongest (strtoulst (p, &p, 10)));
961 printf_filtered (_("Minor faults, children: %s\n"),
962 pulongest (strtoulst (p, &p, 10)));
964 printf_filtered (_("Major faults (memory page faults): %s\n"),
965 pulongest (strtoulst (p, &p, 10)));
967 printf_filtered (_("Major faults, children: %s\n"),
968 pulongest (strtoulst (p, &p, 10)));
970 printf_filtered (_("utime: %s\n"),
971 pulongest (strtoulst (p, &p, 10)));
973 printf_filtered (_("stime: %s\n"),
974 pulongest (strtoulst (p, &p, 10)));
976 printf_filtered (_("utime, children: %s\n"),
977 pulongest (strtoulst (p, &p, 10)));
979 printf_filtered (_("stime, children: %s\n"),
980 pulongest (strtoulst (p, &p, 10)));
982 printf_filtered (_("jiffies remaining in current "
984 pulongest (strtoulst (p, &p, 10)));
986 printf_filtered (_("'nice' value: %s\n"),
987 pulongest (strtoulst (p, &p, 10)));
989 printf_filtered (_("jiffies until next timeout: %s\n"),
990 pulongest (strtoulst (p, &p, 10)));
992 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
993 pulongest (strtoulst (p, &p, 10)));
995 printf_filtered (_("start time (jiffies since "
996 "system boot): %s\n"),
997 pulongest (strtoulst (p, &p, 10)));
999 printf_filtered (_("Virtual memory size: %s\n"),
1000 pulongest (strtoulst (p, &p, 10)));
1002 printf_filtered (_("Resident set size: %s\n"),
1003 pulongest (strtoulst (p, &p, 10)));
1005 printf_filtered (_("rlim: %s\n"),
1006 pulongest (strtoulst (p, &p, 10)));
1008 printf_filtered (_("Start of text: %s\n"),
1009 hex_string (strtoulst (p, &p, 10)));
1011 printf_filtered (_("End of text: %s\n"),
1012 hex_string (strtoulst (p, &p, 10)));
1014 printf_filtered (_("Start of stack: %s\n"),
1015 hex_string (strtoulst (p, &p, 10)));
1016 #if 0 /* Don't know how architecture-dependent the rest is...
1017 Anyway the signal bitmap info is available from "status". */
1019 printf_filtered (_("Kernel stack pointer: %s\n"),
1020 hex_string (strtoulst (p, &p, 10)));
1022 printf_filtered (_("Kernel instr pointer: %s\n"),
1023 hex_string (strtoulst (p, &p, 10)));
1025 printf_filtered (_("Pending signals bitmap: %s\n"),
1026 hex_string (strtoulst (p, &p, 10)));
1028 printf_filtered (_("Blocked signals bitmap: %s\n"),
1029 hex_string (strtoulst (p, &p, 10)));
1031 printf_filtered (_("Ignored signals bitmap: %s\n"),
1032 hex_string (strtoulst (p, &p, 10)));
1034 printf_filtered (_("Catched signals bitmap: %s\n"),
1035 hex_string (strtoulst (p, &p, 10)));
1037 printf_filtered (_("wchan (system call): %s\n"),
1038 hex_string (strtoulst (p, &p, 10)));
1042 warning (_("unable to open /proc file '%s'"), filename);
1046 /* Implement "info proc mappings" for a corefile. */
1049 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1052 ULONGEST count, page_size;
1053 unsigned char *descdata, *filenames, *descend;
1055 unsigned int addr_size_bits, addr_size;
1056 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
1057 /* We assume this for reading 64-bit core files. */
1058 gdb_static_assert (sizeof (ULONGEST) >= 8);
1060 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
1061 if (section == NULL)
1063 warning (_("unable to find mappings in core file"));
1067 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
1068 addr_size = addr_size_bits / 8;
1069 note_size = bfd_get_section_size (section);
1071 if (note_size < 2 * addr_size)
1072 error (_("malformed core note - too short for header"));
1074 gdb::def_vector<unsigned char> contents (note_size);
1075 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1077 error (_("could not get core note contents"));
1079 descdata = contents.data ();
1080 descend = descdata + note_size;
1082 if (descdata[note_size - 1] != '\0')
1083 error (_("malformed note - does not end with \\0"));
1085 count = bfd_get (addr_size_bits, core_bfd, descdata);
1086 descdata += addr_size;
1088 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1089 descdata += addr_size;
1091 if (note_size < 2 * addr_size + count * 3 * addr_size)
1092 error (_("malformed note - too short for supplied file count"));
1094 printf_filtered (_("Mapped address spaces:\n\n"));
1095 if (gdbarch_addr_bit (gdbarch) == 32)
1097 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1100 " Size", " Offset", "objfile");
1104 printf_filtered (" %18s %18s %10s %10s %s\n",
1107 " Size", " Offset", "objfile");
1110 filenames = descdata + count * 3 * addr_size;
1113 ULONGEST start, end, file_ofs;
1115 if (filenames == descend)
1116 error (_("malformed note - filenames end too early"));
1118 start = bfd_get (addr_size_bits, core_bfd, descdata);
1119 descdata += addr_size;
1120 end = bfd_get (addr_size_bits, core_bfd, descdata);
1121 descdata += addr_size;
1122 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1123 descdata += addr_size;
1125 file_ofs *= page_size;
1127 if (gdbarch_addr_bit (gdbarch) == 32)
1128 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1129 paddress (gdbarch, start),
1130 paddress (gdbarch, end),
1131 hex_string (end - start),
1132 hex_string (file_ofs),
1135 printf_filtered (" %18s %18s %10s %10s %s\n",
1136 paddress (gdbarch, start),
1137 paddress (gdbarch, end),
1138 hex_string (end - start),
1139 hex_string (file_ofs),
1142 filenames += 1 + strlen ((char *) filenames);
1146 /* Implement "info proc" for a corefile. */
1149 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1150 enum info_proc_what what)
1152 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1153 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1159 exe = bfd_core_file_failing_command (core_bfd);
1161 printf_filtered ("exe = '%s'\n", exe);
1163 warning (_("unable to find command name in core file"));
1167 linux_core_info_proc_mappings (gdbarch, args);
1169 if (!exe_f && !mappings_f)
1170 error (_("unable to handle request"));
1173 /* Read siginfo data from the core, if possible. Returns -1 on
1174 failure. Otherwise, returns the number of bytes read. READBUF,
1175 OFFSET, and LEN are all as specified by the to_xfer_partial
1179 linux_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
1180 ULONGEST offset, ULONGEST len)
1182 thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
1183 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
1184 if (section == NULL)
1187 if (!bfd_get_section_contents (core_bfd, section, readbuf, offset, len))
1193 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1194 ULONGEST offset, ULONGEST inode,
1195 int read, int write,
1196 int exec, int modified,
1197 const char *filename,
1200 /* List memory regions in the inferior for a corefile. */
1203 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1204 linux_find_memory_region_ftype *func,
1207 char mapsfilename[100];
1208 char coredumpfilter_name[100];
1210 /* Default dump behavior of coredump_filter (0x33), according to
1211 Documentation/filesystems/proc.txt from the Linux kernel
1213 filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1214 | COREFILTER_ANON_SHARED
1215 | COREFILTER_ELF_HEADERS
1216 | COREFILTER_HUGETLB_PRIVATE);
1218 /* We need to know the real target PID to access /proc. */
1219 if (current_inferior ()->fake_pid_p)
1222 pid = current_inferior ()->pid;
1224 if (use_coredump_filter)
1226 xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1227 "/proc/%d/coredump_filter", pid);
1228 gdb::unique_xmalloc_ptr<char> coredumpfilterdata
1229 = target_fileio_read_stralloc (NULL, coredumpfilter_name);
1230 if (coredumpfilterdata != NULL)
1234 sscanf (coredumpfilterdata.get (), "%x", &flags);
1235 filterflags = (enum filter_flag) flags;
1239 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1240 gdb::unique_xmalloc_ptr<char> data
1241 = target_fileio_read_stralloc (NULL, mapsfilename);
1244 /* Older Linux kernels did not support /proc/PID/smaps. */
1245 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1246 data = target_fileio_read_stralloc (NULL, mapsfilename);
1253 line = strtok_r (data.get (), "\n", &t);
1254 while (line != NULL)
1256 ULONGEST addr, endaddr, offset, inode;
1257 const char *permissions, *device, *filename;
1258 struct smaps_vmflags v;
1259 size_t permissions_len, device_len;
1260 int read, write, exec, priv;
1261 int has_anonymous = 0;
1262 int should_dump_p = 0;
1266 memset (&v, 0, sizeof (v));
1267 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1268 &offset, &device, &device_len, &inode, &filename);
1269 mapping_anon_p = mapping_is_anonymous_p (filename);
1270 /* If the mapping is not anonymous, then we can consider it
1271 to be file-backed. These two states (anonymous or
1272 file-backed) seem to be exclusive, but they can actually
1273 coexist. For example, if a file-backed mapping has
1274 "Anonymous:" pages (see more below), then the Linux
1275 kernel will dump this mapping when the user specified
1276 that she only wants anonymous mappings in the corefile
1277 (*even* when she explicitly disabled the dumping of
1278 file-backed mappings). */
1279 mapping_file_p = !mapping_anon_p;
1281 /* Decode permissions. */
1282 read = (memchr (permissions, 'r', permissions_len) != 0);
1283 write = (memchr (permissions, 'w', permissions_len) != 0);
1284 exec = (memchr (permissions, 'x', permissions_len) != 0);
1285 /* 'private' here actually means VM_MAYSHARE, and not
1286 VM_SHARED. In order to know if a mapping is really
1287 private or not, we must check the flag "sh" in the
1288 VmFlags field. This is done by decode_vmflags. However,
1289 if we are using a Linux kernel released before the commit
1290 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1291 not have the VmFlags there. In this case, there is
1292 really no way to know if we are dealing with VM_SHARED,
1293 so we just assume that VM_MAYSHARE is enough. */
1294 priv = memchr (permissions, 'p', permissions_len) != 0;
1296 /* Try to detect if region should be dumped by parsing smaps
1298 for (line = strtok_r (NULL, "\n", &t);
1299 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1300 line = strtok_r (NULL, "\n", &t))
1302 char keyword[64 + 1];
1304 if (sscanf (line, "%64s", keyword) != 1)
1306 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1310 if (strcmp (keyword, "Anonymous:") == 0)
1312 /* Older Linux kernels did not support the
1313 "Anonymous:" counter. Check it here. */
1316 else if (strcmp (keyword, "VmFlags:") == 0)
1317 decode_vmflags (line, &v);
1319 if (strcmp (keyword, "AnonHugePages:") == 0
1320 || strcmp (keyword, "Anonymous:") == 0)
1322 unsigned long number;
1324 if (sscanf (line, "%*s%lu", &number) != 1)
1326 warning (_("Error parsing {s,}maps file '%s' number"),
1332 /* Even if we are dealing with a file-backed
1333 mapping, if it contains anonymous pages we
1334 consider it to be *also* an anonymous
1335 mapping, because this is what the Linux
1338 // Dump segments that have been written to.
1339 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1342 Note that if the mapping is already marked as
1343 file-backed (i.e., mapping_file_p is
1344 non-zero), then this is a special case, and
1345 this mapping will be dumped either when the
1346 user wants to dump file-backed *or* anonymous
1354 should_dump_p = dump_mapping_p (filterflags, &v, priv,
1355 mapping_anon_p, mapping_file_p,
1356 filename, addr, offset);
1359 /* Older Linux kernels did not support the "Anonymous:" counter.
1360 If it is missing, we can't be sure - dump all the pages. */
1364 /* Invoke the callback function to create the corefile segment. */
1366 func (addr, endaddr - addr, offset, inode,
1367 read, write, exec, 1, /* MODIFIED is true because we
1368 want to dump the mapping. */
1378 /* A structure for passing information through
1379 linux_find_memory_regions_full. */
1381 struct linux_find_memory_regions_data
1383 /* The original callback. */
1385 find_memory_region_ftype func;
1387 /* The original datum. */
1392 /* A callback for linux_find_memory_regions that converts between the
1393 "full"-style callback and find_memory_region_ftype. */
1396 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1397 ULONGEST offset, ULONGEST inode,
1398 int read, int write, int exec, int modified,
1399 const char *filename, void *arg)
1401 struct linux_find_memory_regions_data *data
1402 = (struct linux_find_memory_regions_data *) arg;
1404 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1407 /* A variant of linux_find_memory_regions_full that is suitable as the
1408 gdbarch find_memory_regions method. */
1411 linux_find_memory_regions (struct gdbarch *gdbarch,
1412 find_memory_region_ftype func, void *obfd)
1414 struct linux_find_memory_regions_data data;
1419 return linux_find_memory_regions_full (gdbarch,
1420 linux_find_memory_regions_thunk,
1424 /* Determine which signal stopped execution. */
1427 find_signalled_thread (struct thread_info *info, void *data)
1429 if (info->suspend.stop_signal != GDB_SIGNAL_0
1430 && info->ptid.pid () == inferior_ptid.pid ())
1436 /* Generate corefile notes for SPU contexts. */
1439 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1441 static const char *spu_files[] =
1463 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1465 /* Determine list of SPU ids. */
1466 gdb::optional<gdb::byte_vector>
1467 spu_ids = target_read_alloc (current_top_target (),
1468 TARGET_OBJECT_SPU, NULL);
1473 /* Generate corefile notes for each SPU file. */
1474 for (size_t i = 0; i < spu_ids->size (); i += 4)
1476 int fd = extract_unsigned_integer (spu_ids->data () + i, 4, byte_order);
1478 for (size_t j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1480 char annex[32], note_name[32];
1482 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1483 gdb::optional<gdb::byte_vector> spu_data
1484 = target_read_alloc (current_top_target (), TARGET_OBJECT_SPU, annex);
1486 if (spu_data && !spu_data->empty ())
1488 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1489 note_data = elfcore_write_note (obfd, note_data, note_size,
1503 /* This is used to pass information from
1504 linux_make_mappings_corefile_notes through
1505 linux_find_memory_regions_full. */
1507 struct linux_make_mappings_data
1509 /* Number of files mapped. */
1510 ULONGEST file_count;
1512 /* The obstack for the main part of the data. */
1513 struct obstack *data_obstack;
1515 /* The filename obstack. */
1516 struct obstack *filename_obstack;
1518 /* The architecture's "long" type. */
1519 struct type *long_type;
1522 static linux_find_memory_region_ftype linux_make_mappings_callback;
1524 /* A callback for linux_find_memory_regions_full that updates the
1525 mappings data for linux_make_mappings_corefile_notes. */
1528 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1529 ULONGEST offset, ULONGEST inode,
1530 int read, int write, int exec, int modified,
1531 const char *filename, void *data)
1533 struct linux_make_mappings_data *map_data
1534 = (struct linux_make_mappings_data *) data;
1535 gdb_byte buf[sizeof (ULONGEST)];
1537 if (*filename == '\0' || inode == 0)
1540 ++map_data->file_count;
1542 pack_long (buf, map_data->long_type, vaddr);
1543 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1544 pack_long (buf, map_data->long_type, vaddr + size);
1545 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1546 pack_long (buf, map_data->long_type, offset);
1547 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1549 obstack_grow_str0 (map_data->filename_obstack, filename);
1554 /* Write the file mapping data to the core file, if possible. OBFD is
1555 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1556 is a pointer to the note size. Returns the new NOTE_DATA and
1557 updates NOTE_SIZE. */
1560 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1561 char *note_data, int *note_size)
1563 struct linux_make_mappings_data mapping_data;
1564 struct type *long_type
1565 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1566 gdb_byte buf[sizeof (ULONGEST)];
1568 auto_obstack data_obstack, filename_obstack;
1570 mapping_data.file_count = 0;
1571 mapping_data.data_obstack = &data_obstack;
1572 mapping_data.filename_obstack = &filename_obstack;
1573 mapping_data.long_type = long_type;
1575 /* Reserve space for the count. */
1576 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1577 /* We always write the page size as 1 since we have no good way to
1578 determine the correct value. */
1579 pack_long (buf, long_type, 1);
1580 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1582 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1585 if (mapping_data.file_count != 0)
1587 /* Write the count to the obstack. */
1588 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1589 long_type, mapping_data.file_count);
1591 /* Copy the filenames to the data obstack. */
1592 int size = obstack_object_size (&filename_obstack);
1593 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1596 note_data = elfcore_write_note (obfd, note_data, note_size,
1598 obstack_base (&data_obstack),
1599 obstack_object_size (&data_obstack));
1605 /* Structure for passing information from
1606 linux_collect_thread_registers via an iterator to
1607 linux_collect_regset_section_cb. */
1609 struct linux_collect_regset_section_cb_data
1611 struct gdbarch *gdbarch;
1612 const struct regcache *regcache;
1617 enum gdb_signal stop_signal;
1618 int abort_iteration;
1621 /* Callback for iterate_over_regset_sections that records a single
1622 regset in the corefile note section. */
1625 linux_collect_regset_section_cb (const char *sect_name, int supply_size,
1626 int collect_size, const struct regset *regset,
1627 const char *human_name, void *cb_data)
1629 struct linux_collect_regset_section_cb_data *data
1630 = (struct linux_collect_regset_section_cb_data *) cb_data;
1631 bool variable_size_section = (regset != NULL
1632 && regset->flags & REGSET_VARIABLE_SIZE);
1634 if (!variable_size_section)
1635 gdb_assert (supply_size == collect_size);
1637 if (data->abort_iteration)
1640 gdb_assert (regset && regset->collect_regset);
1642 /* This is intentionally zero-initialized by using std::vector, so
1643 that any padding bytes in the core file will show as 0. */
1644 std::vector<gdb_byte> buf (collect_size);
1646 regset->collect_regset (regset, data->regcache, -1, buf.data (),
1649 /* PRSTATUS still needs to be treated specially. */
1650 if (strcmp (sect_name, ".reg") == 0)
1651 data->note_data = (char *) elfcore_write_prstatus
1652 (data->obfd, data->note_data, data->note_size, data->lwp,
1653 gdb_signal_to_host (data->stop_signal), buf.data ());
1655 data->note_data = (char *) elfcore_write_register_note
1656 (data->obfd, data->note_data, data->note_size,
1657 sect_name, buf.data (), collect_size);
1659 if (data->note_data == NULL)
1660 data->abort_iteration = 1;
1663 /* Records the thread's register state for the corefile note
1667 linux_collect_thread_registers (const struct regcache *regcache,
1668 ptid_t ptid, bfd *obfd,
1669 char *note_data, int *note_size,
1670 enum gdb_signal stop_signal)
1672 struct gdbarch *gdbarch = regcache->arch ();
1673 struct linux_collect_regset_section_cb_data data;
1675 data.gdbarch = gdbarch;
1676 data.regcache = regcache;
1678 data.note_data = note_data;
1679 data.note_size = note_size;
1680 data.stop_signal = stop_signal;
1681 data.abort_iteration = 0;
1683 /* For remote targets the LWP may not be available, so use the TID. */
1684 data.lwp = ptid.lwp ();
1686 data.lwp = ptid.tid ();
1688 gdbarch_iterate_over_regset_sections (gdbarch,
1689 linux_collect_regset_section_cb,
1691 return data.note_data;
1694 /* Fetch the siginfo data for the specified thread, if it exists. If
1695 there is no data, or we could not read it, return an empty
1698 static gdb::byte_vector
1699 linux_get_siginfo_data (thread_info *thread, struct gdbarch *gdbarch)
1701 struct type *siginfo_type;
1704 if (!gdbarch_get_siginfo_type_p (gdbarch))
1705 return gdb::byte_vector ();
1707 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1708 inferior_ptid = thread->ptid;
1710 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1712 gdb::byte_vector buf (TYPE_LENGTH (siginfo_type));
1714 bytes_read = target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
1715 buf.data (), 0, TYPE_LENGTH (siginfo_type));
1716 if (bytes_read != TYPE_LENGTH (siginfo_type))
1722 struct linux_corefile_thread_data
1724 struct gdbarch *gdbarch;
1728 enum gdb_signal stop_signal;
1731 /* Records the thread's register state for the corefile note
1735 linux_corefile_thread (struct thread_info *info,
1736 struct linux_corefile_thread_data *args)
1738 struct regcache *regcache;
1740 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1742 target_fetch_registers (regcache, -1);
1743 gdb::byte_vector siginfo_data = linux_get_siginfo_data (info, args->gdbarch);
1745 args->note_data = linux_collect_thread_registers
1746 (regcache, info->ptid, args->obfd, args->note_data,
1747 args->note_size, args->stop_signal);
1749 /* Don't return anything if we got no register information above,
1750 such a core file is useless. */
1751 if (args->note_data != NULL)
1752 if (!siginfo_data.empty ())
1753 args->note_data = elfcore_write_note (args->obfd,
1757 siginfo_data.data (),
1758 siginfo_data.size ());
1761 /* Fill the PRPSINFO structure with information about the process being
1762 debugged. Returns 1 in case of success, 0 for failures. Please note that
1763 even if the structure cannot be entirely filled (e.g., GDB was unable to
1764 gather information about the process UID/GID), this function will still
1765 return 1 since some information was already recorded. It will only return
1766 0 iff nothing can be gathered. */
1769 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1771 /* The filename which we will use to obtain some info about the process.
1772 We will basically use this to store the `/proc/PID/FILENAME' file. */
1774 /* The basename of the executable. */
1775 const char *basename;
1776 const char *infargs;
1777 /* Temporary buffer. */
1779 /* The valid states of a process, according to the Linux kernel. */
1780 const char valid_states[] = "RSDTZW";
1781 /* The program state. */
1782 const char *prog_state;
1783 /* The state of the process. */
1785 /* The PID of the program which generated the corefile. */
1787 /* Process flags. */
1788 unsigned int pr_flag;
1789 /* Process nice value. */
1791 /* The number of fields read by `sscanf'. */
1794 gdb_assert (p != NULL);
1796 /* Obtaining PID and filename. */
1797 pid = inferior_ptid.pid ();
1798 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1799 /* The full name of the program which generated the corefile. */
1800 gdb::unique_xmalloc_ptr<char> fname
1801 = target_fileio_read_stralloc (NULL, filename);
1803 if (fname == NULL || fname.get ()[0] == '\0')
1805 /* No program name was read, so we won't be able to retrieve more
1806 information about the process. */
1810 memset (p, 0, sizeof (*p));
1812 /* Defining the PID. */
1815 /* Copying the program name. Only the basename matters. */
1816 basename = lbasename (fname.get ());
1817 strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1818 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1820 infargs = get_inferior_args ();
1822 /* The arguments of the program. */
1823 std::string psargs = fname.get ();
1824 if (infargs != NULL)
1825 psargs = psargs + " " + infargs;
1827 strncpy (p->pr_psargs, psargs.c_str (), sizeof (p->pr_psargs));
1828 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1830 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1831 /* The contents of `/proc/PID/stat'. */
1832 gdb::unique_xmalloc_ptr<char> proc_stat_contents
1833 = target_fileio_read_stralloc (NULL, filename);
1834 char *proc_stat = proc_stat_contents.get ();
1836 if (proc_stat == NULL || *proc_stat == '\0')
1838 /* Despite being unable to read more information about the
1839 process, we return 1 here because at least we have its
1840 command line, PID and arguments. */
1844 /* Ok, we have the stats. It's time to do a little parsing of the
1845 contents of the buffer, so that we end up reading what we want.
1847 The following parsing mechanism is strongly based on the
1848 information generated by the `fs/proc/array.c' file, present in
1849 the Linux kernel tree. More details about how the information is
1850 displayed can be obtained by seeing the manpage of proc(5),
1851 specifically under the entry of `/proc/[pid]/stat'. */
1853 /* Getting rid of the PID, since we already have it. */
1854 while (isdigit (*proc_stat))
1857 proc_stat = skip_spaces (proc_stat);
1859 /* ps command also relies on no trailing fields ever contain ')'. */
1860 proc_stat = strrchr (proc_stat, ')');
1861 if (proc_stat == NULL)
1865 proc_stat = skip_spaces (proc_stat);
1867 n_fields = sscanf (proc_stat,
1868 "%c" /* Process state. */
1869 "%d%d%d" /* Parent PID, group ID, session ID. */
1870 "%*d%*d" /* tty_nr, tpgid (not used). */
1872 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1873 cmajflt (not used). */
1874 "%*s%*s%*s%*s" /* utime, stime, cutime,
1875 cstime (not used). */
1876 "%*s" /* Priority (not used). */
1879 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1885 /* Again, we couldn't read the complementary information about
1886 the process state. However, we already have minimal
1887 information, so we just return 1 here. */
1891 /* Filling the structure fields. */
1892 prog_state = strchr (valid_states, pr_sname);
1893 if (prog_state != NULL)
1894 p->pr_state = prog_state - valid_states;
1897 /* Zero means "Running". */
1901 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1902 p->pr_zomb = p->pr_sname == 'Z';
1903 p->pr_nice = pr_nice;
1904 p->pr_flag = pr_flag;
1906 /* Finally, obtaining the UID and GID. For that, we read and parse the
1907 contents of the `/proc/PID/status' file. */
1908 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1909 /* The contents of `/proc/PID/status'. */
1910 gdb::unique_xmalloc_ptr<char> proc_status_contents
1911 = target_fileio_read_stralloc (NULL, filename);
1912 char *proc_status = proc_status_contents.get ();
1914 if (proc_status == NULL || *proc_status == '\0')
1916 /* Returning 1 since we already have a bunch of information. */
1920 /* Extracting the UID. */
1921 tmpstr = strstr (proc_status, "Uid:");
1924 /* Advancing the pointer to the beginning of the UID. */
1925 tmpstr += sizeof ("Uid:");
1926 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1929 if (isdigit (*tmpstr))
1930 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1933 /* Extracting the GID. */
1934 tmpstr = strstr (proc_status, "Gid:");
1937 /* Advancing the pointer to the beginning of the GID. */
1938 tmpstr += sizeof ("Gid:");
1939 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1942 if (isdigit (*tmpstr))
1943 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1949 /* Build the note section for a corefile, and return it in a malloc
1953 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1955 struct linux_corefile_thread_data thread_args;
1956 struct elf_internal_linux_prpsinfo prpsinfo;
1957 char *note_data = NULL;
1958 struct thread_info *curr_thr, *signalled_thr;
1960 if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1963 if (linux_fill_prpsinfo (&prpsinfo))
1965 if (gdbarch_ptr_bit (gdbarch) == 64)
1966 note_data = elfcore_write_linux_prpsinfo64 (obfd,
1967 note_data, note_size,
1970 note_data = elfcore_write_linux_prpsinfo32 (obfd,
1971 note_data, note_size,
1975 /* Thread register information. */
1978 update_thread_list ();
1980 catch (const gdb_exception_error &e)
1982 exception_print (gdb_stderr, e);
1985 /* Like the kernel, prefer dumping the signalled thread first.
1986 "First thread" is what tools use to infer the signalled thread.
1987 In case there's more than one signalled thread, prefer the
1988 current thread, if it is signalled. */
1989 curr_thr = inferior_thread ();
1990 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
1991 signalled_thr = curr_thr;
1994 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
1995 if (signalled_thr == NULL)
1996 signalled_thr = curr_thr;
1999 thread_args.gdbarch = gdbarch;
2000 thread_args.obfd = obfd;
2001 thread_args.note_data = note_data;
2002 thread_args.note_size = note_size;
2003 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
2005 linux_corefile_thread (signalled_thr, &thread_args);
2006 for (thread_info *thr : current_inferior ()->non_exited_threads ())
2008 if (thr == signalled_thr)
2011 linux_corefile_thread (thr, &thread_args);
2014 note_data = thread_args.note_data;
2018 /* Auxillary vector. */
2019 gdb::optional<gdb::byte_vector> auxv =
2020 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV, NULL);
2021 if (auxv && !auxv->empty ())
2023 note_data = elfcore_write_note (obfd, note_data, note_size,
2024 "CORE", NT_AUXV, auxv->data (),
2031 /* SPU information. */
2032 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
2036 /* File mappings. */
2037 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
2038 note_data, note_size);
2043 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2044 gdbarch.h. This function is not static because it is exported to
2045 other -tdep files. */
2048 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2053 return GDB_SIGNAL_0;
2056 return GDB_SIGNAL_HUP;
2059 return GDB_SIGNAL_INT;
2062 return GDB_SIGNAL_QUIT;
2065 return GDB_SIGNAL_ILL;
2068 return GDB_SIGNAL_TRAP;
2071 return GDB_SIGNAL_ABRT;
2074 return GDB_SIGNAL_BUS;
2077 return GDB_SIGNAL_FPE;
2080 return GDB_SIGNAL_KILL;
2083 return GDB_SIGNAL_USR1;
2086 return GDB_SIGNAL_SEGV;
2089 return GDB_SIGNAL_USR2;
2092 return GDB_SIGNAL_PIPE;
2095 return GDB_SIGNAL_ALRM;
2098 return GDB_SIGNAL_TERM;
2101 return GDB_SIGNAL_CHLD;
2104 return GDB_SIGNAL_CONT;
2107 return GDB_SIGNAL_STOP;
2110 return GDB_SIGNAL_TSTP;
2113 return GDB_SIGNAL_TTIN;
2116 return GDB_SIGNAL_TTOU;
2119 return GDB_SIGNAL_URG;
2122 return GDB_SIGNAL_XCPU;
2125 return GDB_SIGNAL_XFSZ;
2127 case LINUX_SIGVTALRM:
2128 return GDB_SIGNAL_VTALRM;
2131 return GDB_SIGNAL_PROF;
2133 case LINUX_SIGWINCH:
2134 return GDB_SIGNAL_WINCH;
2136 /* No way to differentiate between SIGIO and SIGPOLL.
2137 Therefore, we just handle the first one. */
2139 return GDB_SIGNAL_IO;
2142 return GDB_SIGNAL_PWR;
2145 return GDB_SIGNAL_SYS;
2147 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2148 therefore we have to handle them here. */
2149 case LINUX_SIGRTMIN:
2150 return GDB_SIGNAL_REALTIME_32;
2152 case LINUX_SIGRTMAX:
2153 return GDB_SIGNAL_REALTIME_64;
2156 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2158 int offset = signal - LINUX_SIGRTMIN + 1;
2160 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2163 return GDB_SIGNAL_UNKNOWN;
2166 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2167 gdbarch.h. This function is not static because it is exported to
2168 other -tdep files. */
2171 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2172 enum gdb_signal signal)
2179 case GDB_SIGNAL_HUP:
2180 return LINUX_SIGHUP;
2182 case GDB_SIGNAL_INT:
2183 return LINUX_SIGINT;
2185 case GDB_SIGNAL_QUIT:
2186 return LINUX_SIGQUIT;
2188 case GDB_SIGNAL_ILL:
2189 return LINUX_SIGILL;
2191 case GDB_SIGNAL_TRAP:
2192 return LINUX_SIGTRAP;
2194 case GDB_SIGNAL_ABRT:
2195 return LINUX_SIGABRT;
2197 case GDB_SIGNAL_FPE:
2198 return LINUX_SIGFPE;
2200 case GDB_SIGNAL_KILL:
2201 return LINUX_SIGKILL;
2203 case GDB_SIGNAL_BUS:
2204 return LINUX_SIGBUS;
2206 case GDB_SIGNAL_SEGV:
2207 return LINUX_SIGSEGV;
2209 case GDB_SIGNAL_SYS:
2210 return LINUX_SIGSYS;
2212 case GDB_SIGNAL_PIPE:
2213 return LINUX_SIGPIPE;
2215 case GDB_SIGNAL_ALRM:
2216 return LINUX_SIGALRM;
2218 case GDB_SIGNAL_TERM:
2219 return LINUX_SIGTERM;
2221 case GDB_SIGNAL_URG:
2222 return LINUX_SIGURG;
2224 case GDB_SIGNAL_STOP:
2225 return LINUX_SIGSTOP;
2227 case GDB_SIGNAL_TSTP:
2228 return LINUX_SIGTSTP;
2230 case GDB_SIGNAL_CONT:
2231 return LINUX_SIGCONT;
2233 case GDB_SIGNAL_CHLD:
2234 return LINUX_SIGCHLD;
2236 case GDB_SIGNAL_TTIN:
2237 return LINUX_SIGTTIN;
2239 case GDB_SIGNAL_TTOU:
2240 return LINUX_SIGTTOU;
2245 case GDB_SIGNAL_XCPU:
2246 return LINUX_SIGXCPU;
2248 case GDB_SIGNAL_XFSZ:
2249 return LINUX_SIGXFSZ;
2251 case GDB_SIGNAL_VTALRM:
2252 return LINUX_SIGVTALRM;
2254 case GDB_SIGNAL_PROF:
2255 return LINUX_SIGPROF;
2257 case GDB_SIGNAL_WINCH:
2258 return LINUX_SIGWINCH;
2260 case GDB_SIGNAL_USR1:
2261 return LINUX_SIGUSR1;
2263 case GDB_SIGNAL_USR2:
2264 return LINUX_SIGUSR2;
2266 case GDB_SIGNAL_PWR:
2267 return LINUX_SIGPWR;
2269 case GDB_SIGNAL_POLL:
2270 return LINUX_SIGPOLL;
2272 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2273 therefore we have to handle it here. */
2274 case GDB_SIGNAL_REALTIME_32:
2275 return LINUX_SIGRTMIN;
2277 /* Same comment applies to _64. */
2278 case GDB_SIGNAL_REALTIME_64:
2279 return LINUX_SIGRTMAX;
2282 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2283 if (signal >= GDB_SIGNAL_REALTIME_33
2284 && signal <= GDB_SIGNAL_REALTIME_63)
2286 int offset = signal - GDB_SIGNAL_REALTIME_33;
2288 return LINUX_SIGRTMIN + 1 + offset;
2294 /* Helper for linux_vsyscall_range that does the real work of finding
2295 the vsyscall's address range. */
2298 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2303 if (target_auxv_search (current_top_target (), AT_SYSINFO_EHDR, &range->start) <= 0)
2306 /* It doesn't make sense to access the host's /proc when debugging a
2307 core file. Instead, look for the PT_LOAD segment that matches
2309 if (!target_has_execution)
2314 phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
2315 if (phdrs_size == -1)
2318 gdb::unique_xmalloc_ptr<Elf_Internal_Phdr>
2319 phdrs ((Elf_Internal_Phdr *) xmalloc (phdrs_size));
2320 num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs.get ());
2321 if (num_phdrs == -1)
2324 for (i = 0; i < num_phdrs; i++)
2325 if (phdrs.get ()[i].p_type == PT_LOAD
2326 && phdrs.get ()[i].p_vaddr == range->start)
2328 range->length = phdrs.get ()[i].p_memsz;
2335 /* We need to know the real target PID to access /proc. */
2336 if (current_inferior ()->fake_pid_p)
2339 pid = current_inferior ()->pid;
2341 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2342 reading /proc/PID/maps (2). The later identifies thread stacks
2343 in the output, which requires scanning every thread in the thread
2344 group to check whether a VMA is actually a thread's stack. With
2345 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2346 a few thousand threads, (1) takes a few miliseconds, while (2)
2347 takes several seconds. Also note that "smaps", what we read for
2348 determining core dump mappings, is even slower than "maps". */
2349 xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2350 gdb::unique_xmalloc_ptr<char> data
2351 = target_fileio_read_stralloc (NULL, filename);
2355 char *saveptr = NULL;
2357 for (line = strtok_r (data.get (), "\n", &saveptr);
2359 line = strtok_r (NULL, "\n", &saveptr))
2361 ULONGEST addr, endaddr;
2362 const char *p = line;
2364 addr = strtoulst (p, &p, 16);
2365 if (addr == range->start)
2369 endaddr = strtoulst (p, &p, 16);
2370 range->length = endaddr - addr;
2376 warning (_("unable to open /proc file '%s'"), filename);
2381 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2382 caching, and defers the real work to linux_vsyscall_range_raw. */
2385 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2387 struct linux_info *info = get_linux_inferior_data ();
2389 if (info->vsyscall_range_p == 0)
2391 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2392 info->vsyscall_range_p = 1;
2394 info->vsyscall_range_p = -1;
2397 if (info->vsyscall_range_p < 0)
2400 *range = info->vsyscall_range;
2404 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2405 definitions would be dependent on compilation host. */
2406 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2407 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2409 /* See gdbarch.sh 'infcall_mmap'. */
2412 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2414 struct objfile *objf;
2415 /* Do there still exist any Linux systems without "mmap64"?
2416 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2417 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2418 struct value *addr_val;
2419 struct gdbarch *gdbarch = get_objfile_arch (objf);
2423 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2425 struct value *arg[ARG_LAST];
2427 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2429 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2430 arg[ARG_LENGTH] = value_from_ulongest
2431 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2432 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2433 | GDB_MMAP_PROT_EXEC))
2435 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2436 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2437 GDB_MMAP_MAP_PRIVATE
2438 | GDB_MMAP_MAP_ANONYMOUS);
2439 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2440 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2442 addr_val = call_function_by_hand (mmap_val, NULL, arg);
2443 retval = value_as_address (addr_val);
2444 if (retval == (CORE_ADDR) -1)
2445 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2450 /* See gdbarch.sh 'infcall_munmap'. */
2453 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2455 struct objfile *objf;
2456 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2457 struct value *retval_val;
2458 struct gdbarch *gdbarch = get_objfile_arch (objf);
2462 ARG_ADDR, ARG_LENGTH, ARG_LAST
2464 struct value *arg[ARG_LAST];
2466 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2468 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2469 arg[ARG_LENGTH] = value_from_ulongest
2470 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2471 retval_val = call_function_by_hand (munmap_val, NULL, arg);
2472 retval = value_as_long (retval_val);
2474 warning (_("Failed inferior munmap call at %s for %s bytes, "
2475 "errno is changed."),
2476 hex_string (addr), pulongest (size));
2479 /* See linux-tdep.h. */
2482 linux_displaced_step_location (struct gdbarch *gdbarch)
2487 /* Determine entry point from target auxiliary vector. This avoids
2488 the need for symbols. Also, when debugging a stand-alone SPU
2489 executable, entry_point_address () will point to an SPU
2490 local-store address and is thus not usable as displaced stepping
2491 location. The auxiliary vector gets us the PowerPC-side entry
2492 point address instead. */
2493 if (target_auxv_search (current_top_target (), AT_ENTRY, &addr) <= 0)
2494 throw_error (NOT_SUPPORTED_ERROR,
2495 _("Cannot find AT_ENTRY auxiliary vector entry."));
2497 /* Make certain that the address points at real code, and not a
2498 function descriptor. */
2499 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2500 current_top_target ());
2502 /* Inferior calls also use the entry point as a breakpoint location.
2503 We don't want displaced stepping to interfere with those
2504 breakpoints, so leave space. */
2505 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2511 /* See linux-tdep.h. */
2514 linux_get_hwcap (struct target_ops *target)
2517 if (target_auxv_search (target, AT_HWCAP, &field) != 1)
2522 /* See linux-tdep.h. */
2525 linux_get_hwcap2 (struct target_ops *target)
2528 if (target_auxv_search (target, AT_HWCAP2, &field) != 1)
2533 /* Display whether the gcore command is using the
2534 /proc/PID/coredump_filter file. */
2537 show_use_coredump_filter (struct ui_file *file, int from_tty,
2538 struct cmd_list_element *c, const char *value)
2540 fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2541 " corefiles is %s.\n"), value);
2544 /* Display whether the gcore command is dumping mappings marked with
2545 the VM_DONTDUMP flag. */
2548 show_dump_excluded_mappings (struct ui_file *file, int from_tty,
2549 struct cmd_list_element *c, const char *value)
2551 fprintf_filtered (file, _("Dumping of mappings marked with the VM_DONTDUMP"
2552 " flag is %s.\n"), value);
2555 /* To be called from the various GDB_OSABI_LINUX handlers for the
2556 various GNU/Linux architectures and machine types. */
2559 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2561 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2562 set_gdbarch_info_proc (gdbarch, linux_info_proc);
2563 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2564 set_gdbarch_core_xfer_siginfo (gdbarch, linux_core_xfer_siginfo);
2565 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2566 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2567 set_gdbarch_has_shared_address_space (gdbarch,
2568 linux_has_shared_address_space);
2569 set_gdbarch_gdb_signal_from_target (gdbarch,
2570 linux_gdb_signal_from_target);
2571 set_gdbarch_gdb_signal_to_target (gdbarch,
2572 linux_gdb_signal_to_target);
2573 set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2574 set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2575 set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2576 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2580 _initialize_linux_tdep (void)
2582 linux_gdbarch_data_handle =
2583 gdbarch_data_register_post_init (init_linux_gdbarch_data);
2585 /* Set a cache per-inferior. */
2587 = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2588 /* Observers used to invalidate the cache when needed. */
2589 gdb::observers::inferior_exit.attach (invalidate_linux_cache_inf);
2590 gdb::observers::inferior_appeared.attach (invalidate_linux_cache_inf);
2592 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2593 &use_coredump_filter, _("\
2594 Set whether gcore should consider /proc/PID/coredump_filter."),
2596 Show whether gcore should consider /proc/PID/coredump_filter."),
2598 Use this command to set whether gcore should consider the contents\n\
2599 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2600 about this file, refer to the manpage of core(5)."),
2601 NULL, show_use_coredump_filter,
2602 &setlist, &showlist);
2604 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files,
2605 &dump_excluded_mappings, _("\
2606 Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2608 Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2610 Use this command to set whether gcore should dump mappings marked with the\n\
2611 VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2612 more information about this file, refer to the manpage of proc(5) and core(5)."),
2613 NULL, show_dump_excluded_mappings,
2614 &setlist, &showlist);