1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
39 #include "gdb_regex.h"
40 #include "common/enum-flags.h"
41 #include "common/gdb_optional.h"
45 /* This enum represents the values that the user can choose when
46 informing the Linux kernel about which memory mappings will be
47 dumped in a corefile. They are described in the file
48 Documentation/filesystems/proc.txt, inside the Linux kernel
53 COREFILTER_ANON_PRIVATE = 1 << 0,
54 COREFILTER_ANON_SHARED = 1 << 1,
55 COREFILTER_MAPPED_PRIVATE = 1 << 2,
56 COREFILTER_MAPPED_SHARED = 1 << 3,
57 COREFILTER_ELF_HEADERS = 1 << 4,
58 COREFILTER_HUGETLB_PRIVATE = 1 << 5,
59 COREFILTER_HUGETLB_SHARED = 1 << 6,
61 DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
63 /* This struct is used to map flags found in the "VmFlags:" field (in
64 the /proc/<PID>/smaps file). */
68 /* Zero if this structure has not been initialized yet. It
69 probably means that the Linux kernel being used does not emit
70 the "VmFlags:" field on "/proc/PID/smaps". */
72 unsigned int initialized_p : 1;
74 /* Memory mapped I/O area (VM_IO, "io"). */
76 unsigned int io_page : 1;
78 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
80 unsigned int uses_huge_tlb : 1;
82 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
84 unsigned int exclude_coredump : 1;
86 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
88 unsigned int shared_mapping : 1;
91 /* Whether to take the /proc/PID/coredump_filter into account when
92 generating a corefile. */
94 static int use_coredump_filter = 1;
96 /* This enum represents the signals' numbers on a generic architecture
97 running the Linux kernel. The definition of "generic" comes from
98 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
99 tree, which is the "de facto" implementation of signal numbers to
100 be used by new architecture ports.
102 For those architectures which have differences between the generic
103 standard (e.g., Alpha), we define the different signals (and *only*
104 those) in the specific target-dependent file (e.g.,
105 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
106 tdep file for more information.
108 ARM deserves a special mention here. On the file
109 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
110 (and ARM-only) signal, which is SIGSWI, with the same number as
111 SIGRTMIN. This signal is used only for a very specific target,
112 called ArthurOS (from RISCOS). Therefore, we do not handle it on
113 the ARM-tdep file, and we can safely use the generic signal handler
114 here for ARM targets.
116 As stated above, this enum is derived from
117 <include/uapi/asm-generic/signal.h>, from the Linux kernel
138 LINUX_SIGSTKFLT = 16,
148 LINUX_SIGVTALRM = 26,
152 LINUX_SIGPOLL = LINUX_SIGIO,
155 LINUX_SIGUNUSED = 31,
161 static struct gdbarch_data *linux_gdbarch_data_handle;
163 struct linux_gdbarch_data
165 struct type *siginfo_type;
169 init_linux_gdbarch_data (struct gdbarch *gdbarch)
171 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
174 static struct linux_gdbarch_data *
175 get_linux_gdbarch_data (struct gdbarch *gdbarch)
177 return ((struct linux_gdbarch_data *)
178 gdbarch_data (gdbarch, linux_gdbarch_data_handle));
181 /* Per-inferior data key. */
182 static const struct inferior_data *linux_inferior_data;
184 /* Linux-specific cached data. This is used by GDB for caching
185 purposes for each inferior. This helps reduce the overhead of
186 transfering data from a remote target to the local host. */
189 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
190 if VSYSCALL_RANGE_P is positive. This is cached because getting
191 at this info requires an auxv lookup (which is itself cached),
192 and looking through the inferior's mappings (which change
193 throughout execution and therefore cannot be cached). */
194 struct mem_range vsyscall_range;
196 /* Zero if we haven't tried looking up the vsyscall's range before
197 yet. Positive if we tried looking it up, and found it. Negative
198 if we tried looking it up but failed. */
199 int vsyscall_range_p;
202 /* Frees whatever allocated space there is to be freed and sets INF's
203 linux cache data pointer to NULL. */
206 invalidate_linux_cache_inf (struct inferior *inf)
208 struct linux_info *info;
210 info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
214 set_inferior_data (inf, linux_inferior_data, NULL);
218 /* Handles the cleanup of the linux cache for inferior INF. ARG is
219 ignored. Callback for the inferior_appeared and inferior_exit
223 linux_inferior_data_cleanup (struct inferior *inf, void *arg)
225 invalidate_linux_cache_inf (inf);
228 /* Fetch the linux cache info for INF. This function always returns a
229 valid INFO pointer. */
231 static struct linux_info *
232 get_linux_inferior_data (void)
234 struct linux_info *info;
235 struct inferior *inf = current_inferior ();
237 info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
240 info = XCNEW (struct linux_info);
241 set_inferior_data (inf, linux_inferior_data, info);
247 /* See linux-tdep.h. */
250 linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
251 linux_siginfo_extra_fields extra_fields)
253 struct linux_gdbarch_data *linux_gdbarch_data;
254 struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
255 struct type *uid_type, *pid_type;
256 struct type *sigval_type, *clock_type;
257 struct type *siginfo_type, *sifields_type;
260 linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
261 if (linux_gdbarch_data->siginfo_type != NULL)
262 return linux_gdbarch_data->siginfo_type;
264 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
266 uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
268 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
270 short_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
272 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
275 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
276 TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
277 append_composite_type_field (sigval_type, "sival_int", int_type);
278 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
281 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
282 TYPE_LENGTH (int_type), "__pid_t");
283 TYPE_TARGET_TYPE (pid_type) = int_type;
284 TYPE_TARGET_STUB (pid_type) = 1;
287 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
288 TYPE_LENGTH (uint_type), "__uid_t");
289 TYPE_TARGET_TYPE (uid_type) = uint_type;
290 TYPE_TARGET_STUB (uid_type) = 1;
293 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
294 TYPE_LENGTH (long_type), "__clock_t");
295 TYPE_TARGET_TYPE (clock_type) = long_type;
296 TYPE_TARGET_STUB (clock_type) = 1;
299 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
302 const int si_max_size = 128;
304 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
307 if (gdbarch_ptr_bit (gdbarch) == 64)
308 si_pad_size = (si_max_size / size_of_int) - 4;
310 si_pad_size = (si_max_size / size_of_int) - 3;
311 append_composite_type_field (sifields_type, "_pad",
312 init_vector_type (int_type, si_pad_size));
316 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
317 append_composite_type_field (type, "si_pid", pid_type);
318 append_composite_type_field (type, "si_uid", uid_type);
319 append_composite_type_field (sifields_type, "_kill", type);
322 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
323 append_composite_type_field (type, "si_tid", int_type);
324 append_composite_type_field (type, "si_overrun", int_type);
325 append_composite_type_field (type, "si_sigval", sigval_type);
326 append_composite_type_field (sifields_type, "_timer", type);
329 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
330 append_composite_type_field (type, "si_pid", pid_type);
331 append_composite_type_field (type, "si_uid", uid_type);
332 append_composite_type_field (type, "si_sigval", sigval_type);
333 append_composite_type_field (sifields_type, "_rt", type);
336 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
337 append_composite_type_field (type, "si_pid", pid_type);
338 append_composite_type_field (type, "si_uid", uid_type);
339 append_composite_type_field (type, "si_status", int_type);
340 append_composite_type_field (type, "si_utime", clock_type);
341 append_composite_type_field (type, "si_stime", clock_type);
342 append_composite_type_field (sifields_type, "_sigchld", type);
345 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
346 append_composite_type_field (type, "si_addr", void_ptr_type);
348 /* Additional bound fields for _sigfault in case they were requested. */
349 if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
351 struct type *sigfault_bnd_fields;
353 append_composite_type_field (type, "_addr_lsb", short_type);
354 sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
355 append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
356 append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
357 append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
359 append_composite_type_field (sifields_type, "_sigfault", type);
362 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
363 append_composite_type_field (type, "si_band", long_type);
364 append_composite_type_field (type, "si_fd", int_type);
365 append_composite_type_field (sifields_type, "_sigpoll", type);
368 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
369 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
370 append_composite_type_field (siginfo_type, "si_signo", int_type);
371 append_composite_type_field (siginfo_type, "si_errno", int_type);
372 append_composite_type_field (siginfo_type, "si_code", int_type);
373 append_composite_type_field_aligned (siginfo_type,
374 "_sifields", sifields_type,
375 TYPE_LENGTH (long_type));
377 linux_gdbarch_data->siginfo_type = siginfo_type;
382 /* This function is suitable for architectures that don't
383 extend/override the standard siginfo structure. */
386 linux_get_siginfo_type (struct gdbarch *gdbarch)
388 return linux_get_siginfo_type_with_fields (gdbarch, 0);
391 /* Return true if the target is running on uClinux instead of normal
395 linux_is_uclinux (void)
399 return (target_auxv_search (¤t_target, AT_NULL, &dummy) > 0
400 && target_auxv_search (¤t_target, AT_PAGESZ, &dummy) == 0);
404 linux_has_shared_address_space (struct gdbarch *gdbarch)
406 return linux_is_uclinux ();
409 /* This is how we want PTIDs from core files to be printed. */
412 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
416 if (ptid_get_lwp (ptid) != 0)
418 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
422 return normal_pid_to_str (ptid);
425 /* Service function for corefiles and info proc. */
428 read_mapping (const char *line,
429 ULONGEST *addr, ULONGEST *endaddr,
430 const char **permissions, size_t *permissions_len,
432 const char **device, size_t *device_len,
434 const char **filename)
436 const char *p = line;
438 *addr = strtoulst (p, &p, 16);
441 *endaddr = strtoulst (p, &p, 16);
443 p = skip_spaces_const (p);
445 while (*p && !isspace (*p))
447 *permissions_len = p - *permissions;
449 *offset = strtoulst (p, &p, 16);
451 p = skip_spaces_const (p);
453 while (*p && !isspace (*p))
455 *device_len = p - *device;
457 *inode = strtoulst (p, &p, 10);
459 p = skip_spaces_const (p);
463 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
465 This function was based on the documentation found on
466 <Documentation/filesystems/proc.txt>, on the Linux kernel.
468 Linux kernels before commit
469 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
473 decode_vmflags (char *p, struct smaps_vmflags *v)
475 char *saveptr = NULL;
478 v->initialized_p = 1;
479 p = skip_to_space (p);
482 for (s = strtok_r (p, " ", &saveptr);
484 s = strtok_r (NULL, " ", &saveptr))
486 if (strcmp (s, "io") == 0)
488 else if (strcmp (s, "ht") == 0)
489 v->uses_huge_tlb = 1;
490 else if (strcmp (s, "dd") == 0)
491 v->exclude_coredump = 1;
492 else if (strcmp (s, "sh") == 0)
493 v->shared_mapping = 1;
497 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
498 they're initialized lazily. */
500 struct mapping_regexes
502 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
503 string in the end). We know for sure, based on the Linux kernel
504 code, that memory mappings whose associated filename is
505 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
506 compiled_regex dev_zero
507 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB,
508 _("Could not compile regex to match /dev/zero filename")};
510 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
511 string in the end). These filenames refer to shared memory
512 (shmem), and memory mappings associated with them are
513 MAP_ANONYMOUS as well. */
514 compiled_regex shmem_file
515 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB,
516 _("Could not compile regex to match shmem filenames")};
518 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
519 0' code, which is responsible to decide if it is dealing with a
520 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
521 FILE_DELETED matches, it does not necessarily mean that we are
522 dealing with an anonymous shared mapping. However, there is no
523 easy way to detect this currently, so this is the best
524 approximation we have.
526 As a result, GDB will dump readonly pages of deleted executables
527 when using the default value of coredump_filter (0x33), while the
528 Linux kernel will not dump those pages. But we can live with
530 compiled_regex file_deleted
531 {" (deleted)$", REG_NOSUB,
532 _("Could not compile regex to match '<file> (deleted)'")};
535 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
537 FILENAME is the name of the file present in the first line of the
538 memory mapping, in the "/proc/PID/smaps" output. For example, if
541 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
543 Then FILENAME will be "/path/to/file". */
546 mapping_is_anonymous_p (const char *filename)
548 static gdb::optional<mapping_regexes> regexes;
549 static int init_regex_p = 0;
553 /* Let's be pessimistic and assume there will be an error while
554 compiling the regex'es. */
559 /* If we reached this point, then everything succeeded. */
563 if (init_regex_p == -1)
565 const char deleted[] = " (deleted)";
566 size_t del_len = sizeof (deleted) - 1;
567 size_t filename_len = strlen (filename);
569 /* There was an error while compiling the regex'es above. In
570 order to try to give some reliable information to the caller,
571 we just try to find the string " (deleted)" in the filename.
572 If we managed to find it, then we assume the mapping is
574 return (filename_len >= del_len
575 && strcmp (filename + filename_len - del_len, deleted) == 0);
578 if (*filename == '\0'
579 || regexes->dev_zero.exec (filename, 0, NULL, 0) == 0
580 || regexes->shmem_file.exec (filename, 0, NULL, 0) == 0
581 || regexes->file_deleted.exec (filename, 0, NULL, 0) == 0)
587 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
588 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
589 greater than 0 if it should.
591 In a nutshell, this is the logic that we follow in order to decide
592 if a mapping should be dumped or not.
594 - If the mapping is associated to a file whose name ends with
595 " (deleted)", or if the file is "/dev/zero", or if it is
596 "/SYSV%08x" (shared memory), or if there is no file associated
597 with it, or if the AnonHugePages: or the Anonymous: fields in the
598 /proc/PID/smaps have contents, then GDB considers this mapping to
599 be anonymous. Otherwise, GDB considers this mapping to be a
600 file-backed mapping (because there will be a file associated with
603 It is worth mentioning that, from all those checks described
604 above, the most fragile is the one to see if the file name ends
605 with " (deleted)". This does not necessarily mean that the
606 mapping is anonymous, because the deleted file associated with
607 the mapping may have been a hard link to another file, for
608 example. The Linux kernel checks to see if "i_nlink == 0", but
609 GDB cannot easily (and normally) do this check (iff running as
610 root, it could find the mapping in /proc/PID/map_files/ and
611 determine whether there still are other hard links to the
612 inode/file). Therefore, we made a compromise here, and we assume
613 that if the file name ends with " (deleted)", then the mapping is
614 indeed anonymous. FWIW, this is something the Linux kernel could
615 do better: expose this information in a more direct way.
617 - If we see the flag "sh" in the "VmFlags:" field (in
618 /proc/PID/smaps), then certainly the memory mapping is shared
619 (VM_SHARED). If we have access to the VmFlags, and we don't see
620 the "sh" there, then certainly the mapping is private. However,
621 Linux kernels before commit
622 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
623 "VmFlags:" field; in that case, we use another heuristic: if we
624 see 'p' in the permission flags, then we assume that the mapping
625 is private, even though the presence of the 's' flag there would
626 mean VM_MAYSHARE, which means the mapping could still be private.
627 This should work OK enough, however. */
630 dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
631 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
632 const char *filename)
634 /* Initially, we trust in what we received from our caller. This
635 value may not be very precise (i.e., it was probably gathered
636 from the permission line in the /proc/PID/smaps list, which
637 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
638 what we have until we take a look at the "VmFlags:" field
639 (assuming that the version of the Linux kernel being used
640 supports it, of course). */
641 int private_p = maybe_private_p;
643 /* We always dump vDSO and vsyscall mappings, because it's likely that
644 there'll be no file to read the contents from at core load time.
645 The kernel does the same. */
646 if (strcmp ("[vdso]", filename) == 0
647 || strcmp ("[vsyscall]", filename) == 0)
650 if (v->initialized_p)
652 /* We never dump I/O mappings. */
656 /* Check if we should exclude this mapping. */
657 if (v->exclude_coredump)
660 /* Update our notion of whether this mapping is shared or
661 private based on a trustworthy value. */
662 private_p = !v->shared_mapping;
664 /* HugeTLB checking. */
665 if (v->uses_huge_tlb)
667 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
668 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
677 if (mapping_anon_p && mapping_file_p)
679 /* This is a special situation. It can happen when we see a
680 mapping that is file-backed, but that contains anonymous
682 return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
683 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
685 else if (mapping_anon_p)
686 return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
688 return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
692 if (mapping_anon_p && mapping_file_p)
694 /* This is a special situation. It can happen when we see a
695 mapping that is file-backed, but that contains anonymous
697 return ((filterflags & COREFILTER_ANON_SHARED) != 0
698 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
700 else if (mapping_anon_p)
701 return (filterflags & COREFILTER_ANON_SHARED) != 0;
703 return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
707 /* Implement the "info proc" command. */
710 linux_info_proc (struct gdbarch *gdbarch, const char *args,
711 enum info_proc_what what)
713 /* A long is used for pid instead of an int to avoid a loss of precision
714 compiler warning from the output of strtoul. */
716 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
717 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
718 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
719 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
720 int status_f = (what == IP_STATUS || what == IP_ALL);
721 int stat_f = (what == IP_STAT || what == IP_ALL);
726 if (args && isdigit (args[0]))
730 pid = strtoul (args, &tem, 10);
735 if (!target_has_execution)
736 error (_("No current process: you must name one."));
737 if (current_inferior ()->fake_pid_p)
738 error (_("Can't determine the current process's PID: you must name one."));
740 pid = current_inferior ()->pid;
743 args = skip_spaces_const (args);
745 error (_("Too many parameters: %s"), args);
747 printf_filtered (_("process %ld\n"), pid);
750 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
751 data = target_fileio_read_stralloc (NULL, filename);
754 struct cleanup *cleanup = make_cleanup (xfree, data);
755 printf_filtered ("cmdline = '%s'\n", data);
756 do_cleanups (cleanup);
759 warning (_("unable to open /proc file '%s'"), filename);
763 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
764 data = target_fileio_readlink (NULL, filename, &target_errno);
767 struct cleanup *cleanup = make_cleanup (xfree, data);
768 printf_filtered ("cwd = '%s'\n", data);
769 do_cleanups (cleanup);
772 warning (_("unable to read link '%s'"), filename);
776 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
777 data = target_fileio_readlink (NULL, filename, &target_errno);
780 struct cleanup *cleanup = make_cleanup (xfree, data);
781 printf_filtered ("exe = '%s'\n", data);
782 do_cleanups (cleanup);
785 warning (_("unable to read link '%s'"), filename);
789 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
790 data = target_fileio_read_stralloc (NULL, filename);
793 struct cleanup *cleanup = make_cleanup (xfree, data);
796 printf_filtered (_("Mapped address spaces:\n\n"));
797 if (gdbarch_addr_bit (gdbarch) == 32)
799 printf_filtered ("\t%10s %10s %10s %10s %s\n",
802 " Size", " Offset", "objfile");
806 printf_filtered (" %18s %18s %10s %10s %s\n",
809 " Size", " Offset", "objfile");
812 for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
814 ULONGEST addr, endaddr, offset, inode;
815 const char *permissions, *device, *filename;
816 size_t permissions_len, device_len;
818 read_mapping (line, &addr, &endaddr,
819 &permissions, &permissions_len,
820 &offset, &device, &device_len,
823 if (gdbarch_addr_bit (gdbarch) == 32)
825 printf_filtered ("\t%10s %10s %10s %10s %s\n",
826 paddress (gdbarch, addr),
827 paddress (gdbarch, endaddr),
828 hex_string (endaddr - addr),
830 *filename? filename : "");
834 printf_filtered (" %18s %18s %10s %10s %s\n",
835 paddress (gdbarch, addr),
836 paddress (gdbarch, endaddr),
837 hex_string (endaddr - addr),
839 *filename? filename : "");
843 do_cleanups (cleanup);
846 warning (_("unable to open /proc file '%s'"), filename);
850 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
851 data = target_fileio_read_stralloc (NULL, filename);
854 struct cleanup *cleanup = make_cleanup (xfree, data);
855 puts_filtered (data);
856 do_cleanups (cleanup);
859 warning (_("unable to open /proc file '%s'"), filename);
863 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
864 data = target_fileio_read_stralloc (NULL, filename);
867 struct cleanup *cleanup = make_cleanup (xfree, data);
868 const char *p = data;
870 printf_filtered (_("Process: %s\n"),
871 pulongest (strtoulst (p, &p, 10)));
873 p = skip_spaces_const (p);
876 /* ps command also relies on no trailing fields
878 const char *ep = strrchr (p, ')');
881 printf_filtered ("Exec file: %.*s\n",
882 (int) (ep - p - 1), p + 1);
887 p = skip_spaces_const (p);
889 printf_filtered (_("State: %c\n"), *p++);
892 printf_filtered (_("Parent process: %s\n"),
893 pulongest (strtoulst (p, &p, 10)));
895 printf_filtered (_("Process group: %s\n"),
896 pulongest (strtoulst (p, &p, 10)));
898 printf_filtered (_("Session id: %s\n"),
899 pulongest (strtoulst (p, &p, 10)));
901 printf_filtered (_("TTY: %s\n"),
902 pulongest (strtoulst (p, &p, 10)));
904 printf_filtered (_("TTY owner process group: %s\n"),
905 pulongest (strtoulst (p, &p, 10)));
908 printf_filtered (_("Flags: %s\n"),
909 hex_string (strtoulst (p, &p, 10)));
911 printf_filtered (_("Minor faults (no memory page): %s\n"),
912 pulongest (strtoulst (p, &p, 10)));
914 printf_filtered (_("Minor faults, children: %s\n"),
915 pulongest (strtoulst (p, &p, 10)));
917 printf_filtered (_("Major faults (memory page faults): %s\n"),
918 pulongest (strtoulst (p, &p, 10)));
920 printf_filtered (_("Major faults, children: %s\n"),
921 pulongest (strtoulst (p, &p, 10)));
923 printf_filtered (_("utime: %s\n"),
924 pulongest (strtoulst (p, &p, 10)));
926 printf_filtered (_("stime: %s\n"),
927 pulongest (strtoulst (p, &p, 10)));
929 printf_filtered (_("utime, children: %s\n"),
930 pulongest (strtoulst (p, &p, 10)));
932 printf_filtered (_("stime, children: %s\n"),
933 pulongest (strtoulst (p, &p, 10)));
935 printf_filtered (_("jiffies remaining in current "
937 pulongest (strtoulst (p, &p, 10)));
939 printf_filtered (_("'nice' value: %s\n"),
940 pulongest (strtoulst (p, &p, 10)));
942 printf_filtered (_("jiffies until next timeout: %s\n"),
943 pulongest (strtoulst (p, &p, 10)));
945 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
946 pulongest (strtoulst (p, &p, 10)));
948 printf_filtered (_("start time (jiffies since "
949 "system boot): %s\n"),
950 pulongest (strtoulst (p, &p, 10)));
952 printf_filtered (_("Virtual memory size: %s\n"),
953 pulongest (strtoulst (p, &p, 10)));
955 printf_filtered (_("Resident set size: %s\n"),
956 pulongest (strtoulst (p, &p, 10)));
958 printf_filtered (_("rlim: %s\n"),
959 pulongest (strtoulst (p, &p, 10)));
961 printf_filtered (_("Start of text: %s\n"),
962 hex_string (strtoulst (p, &p, 10)));
964 printf_filtered (_("End of text: %s\n"),
965 hex_string (strtoulst (p, &p, 10)));
967 printf_filtered (_("Start of stack: %s\n"),
968 hex_string (strtoulst (p, &p, 10)));
969 #if 0 /* Don't know how architecture-dependent the rest is...
970 Anyway the signal bitmap info is available from "status". */
972 printf_filtered (_("Kernel stack pointer: %s\n"),
973 hex_string (strtoulst (p, &p, 10)));
975 printf_filtered (_("Kernel instr pointer: %s\n"),
976 hex_string (strtoulst (p, &p, 10)));
978 printf_filtered (_("Pending signals bitmap: %s\n"),
979 hex_string (strtoulst (p, &p, 10)));
981 printf_filtered (_("Blocked signals bitmap: %s\n"),
982 hex_string (strtoulst (p, &p, 10)));
984 printf_filtered (_("Ignored signals bitmap: %s\n"),
985 hex_string (strtoulst (p, &p, 10)));
987 printf_filtered (_("Catched signals bitmap: %s\n"),
988 hex_string (strtoulst (p, &p, 10)));
990 printf_filtered (_("wchan (system call): %s\n"),
991 hex_string (strtoulst (p, &p, 10)));
993 do_cleanups (cleanup);
996 warning (_("unable to open /proc file '%s'"), filename);
1000 /* Implement "info proc mappings" for a corefile. */
1003 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1006 ULONGEST count, page_size;
1007 unsigned char *descdata, *filenames, *descend, *contents;
1009 unsigned int addr_size_bits, addr_size;
1010 struct cleanup *cleanup;
1011 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
1012 /* We assume this for reading 64-bit core files. */
1013 gdb_static_assert (sizeof (ULONGEST) >= 8);
1015 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
1016 if (section == NULL)
1018 warning (_("unable to find mappings in core file"));
1022 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
1023 addr_size = addr_size_bits / 8;
1024 note_size = bfd_get_section_size (section);
1026 if (note_size < 2 * addr_size)
1027 error (_("malformed core note - too short for header"));
1029 contents = (unsigned char *) xmalloc (note_size);
1030 cleanup = make_cleanup (xfree, contents);
1031 if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
1032 error (_("could not get core note contents"));
1034 descdata = contents;
1035 descend = descdata + note_size;
1037 if (descdata[note_size - 1] != '\0')
1038 error (_("malformed note - does not end with \\0"));
1040 count = bfd_get (addr_size_bits, core_bfd, descdata);
1041 descdata += addr_size;
1043 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1044 descdata += addr_size;
1046 if (note_size < 2 * addr_size + count * 3 * addr_size)
1047 error (_("malformed note - too short for supplied file count"));
1049 printf_filtered (_("Mapped address spaces:\n\n"));
1050 if (gdbarch_addr_bit (gdbarch) == 32)
1052 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1055 " Size", " Offset", "objfile");
1059 printf_filtered (" %18s %18s %10s %10s %s\n",
1062 " Size", " Offset", "objfile");
1065 filenames = descdata + count * 3 * addr_size;
1068 ULONGEST start, end, file_ofs;
1070 if (filenames == descend)
1071 error (_("malformed note - filenames end too early"));
1073 start = bfd_get (addr_size_bits, core_bfd, descdata);
1074 descdata += addr_size;
1075 end = bfd_get (addr_size_bits, core_bfd, descdata);
1076 descdata += addr_size;
1077 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1078 descdata += addr_size;
1080 file_ofs *= page_size;
1082 if (gdbarch_addr_bit (gdbarch) == 32)
1083 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1084 paddress (gdbarch, start),
1085 paddress (gdbarch, end),
1086 hex_string (end - start),
1087 hex_string (file_ofs),
1090 printf_filtered (" %18s %18s %10s %10s %s\n",
1091 paddress (gdbarch, start),
1092 paddress (gdbarch, end),
1093 hex_string (end - start),
1094 hex_string (file_ofs),
1097 filenames += 1 + strlen ((char *) filenames);
1100 do_cleanups (cleanup);
1103 /* Implement "info proc" for a corefile. */
1106 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1107 enum info_proc_what what)
1109 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1110 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1116 exe = bfd_core_file_failing_command (core_bfd);
1118 printf_filtered ("exe = '%s'\n", exe);
1120 warning (_("unable to find command name in core file"));
1124 linux_core_info_proc_mappings (gdbarch, args);
1126 if (!exe_f && !mappings_f)
1127 error (_("unable to handle request"));
1130 /* Read siginfo data from the core, if possible. Returns -1 on
1131 failure. Otherwise, returns the number of bytes read. READBUF,
1132 OFFSET, and LEN are all as specified by the to_xfer_partial
1136 linux_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
1137 ULONGEST offset, ULONGEST len)
1139 thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
1140 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
1141 if (section == NULL)
1144 if (!bfd_get_section_contents (core_bfd, section, readbuf, offset, len))
1150 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1151 ULONGEST offset, ULONGEST inode,
1152 int read, int write,
1153 int exec, int modified,
1154 const char *filename,
1157 /* List memory regions in the inferior for a corefile. */
1160 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1161 linux_find_memory_region_ftype *func,
1164 char mapsfilename[100];
1165 char coredumpfilter_name[100];
1166 char *data, *coredumpfilterdata;
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 coredumpfilterdata = target_fileio_read_stralloc (NULL,
1187 coredumpfilter_name);
1188 if (coredumpfilterdata != NULL)
1192 sscanf (coredumpfilterdata, "%x", &flags);
1193 filterflags = (enum filter_flag) flags;
1194 xfree (coredumpfilterdata);
1198 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1199 data = 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);
1209 struct cleanup *cleanup = make_cleanup (xfree, data);
1212 line = strtok_r (data, "\n", &t);
1213 while (line != NULL)
1215 ULONGEST addr, endaddr, offset, inode;
1216 const char *permissions, *device, *filename;
1217 struct smaps_vmflags v;
1218 size_t permissions_len, device_len;
1219 int read, write, exec, priv;
1220 int has_anonymous = 0;
1221 int should_dump_p = 0;
1225 memset (&v, 0, sizeof (v));
1226 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1227 &offset, &device, &device_len, &inode, &filename);
1228 mapping_anon_p = mapping_is_anonymous_p (filename);
1229 /* If the mapping is not anonymous, then we can consider it
1230 to be file-backed. These two states (anonymous or
1231 file-backed) seem to be exclusive, but they can actually
1232 coexist. For example, if a file-backed mapping has
1233 "Anonymous:" pages (see more below), then the Linux
1234 kernel will dump this mapping when the user specified
1235 that she only wants anonymous mappings in the corefile
1236 (*even* when she explicitly disabled the dumping of
1237 file-backed mappings). */
1238 mapping_file_p = !mapping_anon_p;
1240 /* Decode permissions. */
1241 read = (memchr (permissions, 'r', permissions_len) != 0);
1242 write = (memchr (permissions, 'w', permissions_len) != 0);
1243 exec = (memchr (permissions, 'x', permissions_len) != 0);
1244 /* 'private' here actually means VM_MAYSHARE, and not
1245 VM_SHARED. In order to know if a mapping is really
1246 private or not, we must check the flag "sh" in the
1247 VmFlags field. This is done by decode_vmflags. However,
1248 if we are using a Linux kernel released before the commit
1249 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1250 not have the VmFlags there. In this case, there is
1251 really no way to know if we are dealing with VM_SHARED,
1252 so we just assume that VM_MAYSHARE is enough. */
1253 priv = memchr (permissions, 'p', permissions_len) != 0;
1255 /* Try to detect if region should be dumped by parsing smaps
1257 for (line = strtok_r (NULL, "\n", &t);
1258 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1259 line = strtok_r (NULL, "\n", &t))
1261 char keyword[64 + 1];
1263 if (sscanf (line, "%64s", keyword) != 1)
1265 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1269 if (strcmp (keyword, "Anonymous:") == 0)
1271 /* Older Linux kernels did not support the
1272 "Anonymous:" counter. Check it here. */
1275 else if (strcmp (keyword, "VmFlags:") == 0)
1276 decode_vmflags (line, &v);
1278 if (strcmp (keyword, "AnonHugePages:") == 0
1279 || strcmp (keyword, "Anonymous:") == 0)
1281 unsigned long number;
1283 if (sscanf (line, "%*s%lu", &number) != 1)
1285 warning (_("Error parsing {s,}maps file '%s' number"),
1291 /* Even if we are dealing with a file-backed
1292 mapping, if it contains anonymous pages we
1293 consider it to be *also* an anonymous
1294 mapping, because this is what the Linux
1297 // Dump segments that have been written to.
1298 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1301 Note that if the mapping is already marked as
1302 file-backed (i.e., mapping_file_p is
1303 non-zero), then this is a special case, and
1304 this mapping will be dumped either when the
1305 user wants to dump file-backed *or* anonymous
1313 should_dump_p = dump_mapping_p (filterflags, &v, priv,
1314 mapping_anon_p, mapping_file_p,
1318 /* Older Linux kernels did not support the "Anonymous:" counter.
1319 If it is missing, we can't be sure - dump all the pages. */
1323 /* Invoke the callback function to create the corefile segment. */
1325 func (addr, endaddr - addr, offset, inode,
1326 read, write, exec, 1, /* MODIFIED is true because we
1327 want to dump the mapping. */
1331 do_cleanups (cleanup);
1338 /* A structure for passing information through
1339 linux_find_memory_regions_full. */
1341 struct linux_find_memory_regions_data
1343 /* The original callback. */
1345 find_memory_region_ftype func;
1347 /* The original datum. */
1352 /* A callback for linux_find_memory_regions that converts between the
1353 "full"-style callback and find_memory_region_ftype. */
1356 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1357 ULONGEST offset, ULONGEST inode,
1358 int read, int write, int exec, int modified,
1359 const char *filename, void *arg)
1361 struct linux_find_memory_regions_data *data
1362 = (struct linux_find_memory_regions_data *) arg;
1364 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1367 /* A variant of linux_find_memory_regions_full that is suitable as the
1368 gdbarch find_memory_regions method. */
1371 linux_find_memory_regions (struct gdbarch *gdbarch,
1372 find_memory_region_ftype func, void *obfd)
1374 struct linux_find_memory_regions_data data;
1379 return linux_find_memory_regions_full (gdbarch,
1380 linux_find_memory_regions_thunk,
1384 /* Determine which signal stopped execution. */
1387 find_signalled_thread (struct thread_info *info, void *data)
1389 if (info->suspend.stop_signal != GDB_SIGNAL_0
1390 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1396 /* Generate corefile notes for SPU contexts. */
1399 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1401 static const char *spu_files[] =
1423 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1427 /* Determine list of SPU ids. */
1428 size = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1431 /* Generate corefile notes for each SPU file. */
1432 for (i = 0; i < size; i += 4)
1434 int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1436 for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1438 char annex[32], note_name[32];
1442 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1443 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1447 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1448 note_data = elfcore_write_note (obfd, note_data, note_size,
1468 /* This is used to pass information from
1469 linux_make_mappings_corefile_notes through
1470 linux_find_memory_regions_full. */
1472 struct linux_make_mappings_data
1474 /* Number of files mapped. */
1475 ULONGEST file_count;
1477 /* The obstack for the main part of the data. */
1478 struct obstack *data_obstack;
1480 /* The filename obstack. */
1481 struct obstack *filename_obstack;
1483 /* The architecture's "long" type. */
1484 struct type *long_type;
1487 static linux_find_memory_region_ftype linux_make_mappings_callback;
1489 /* A callback for linux_find_memory_regions_full that updates the
1490 mappings data for linux_make_mappings_corefile_notes. */
1493 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1494 ULONGEST offset, ULONGEST inode,
1495 int read, int write, int exec, int modified,
1496 const char *filename, void *data)
1498 struct linux_make_mappings_data *map_data
1499 = (struct linux_make_mappings_data *) data;
1500 gdb_byte buf[sizeof (ULONGEST)];
1502 if (*filename == '\0' || inode == 0)
1505 ++map_data->file_count;
1507 pack_long (buf, map_data->long_type, vaddr);
1508 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1509 pack_long (buf, map_data->long_type, vaddr + size);
1510 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1511 pack_long (buf, map_data->long_type, offset);
1512 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1514 obstack_grow_str0 (map_data->filename_obstack, filename);
1519 /* Write the file mapping data to the core file, if possible. OBFD is
1520 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1521 is a pointer to the note size. Returns the new NOTE_DATA and
1522 updates NOTE_SIZE. */
1525 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1526 char *note_data, int *note_size)
1528 struct cleanup *cleanup;
1529 struct linux_make_mappings_data mapping_data;
1530 struct type *long_type
1531 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1532 gdb_byte buf[sizeof (ULONGEST)];
1534 auto_obstack data_obstack, filename_obstack;
1536 mapping_data.file_count = 0;
1537 mapping_data.data_obstack = &data_obstack;
1538 mapping_data.filename_obstack = &filename_obstack;
1539 mapping_data.long_type = long_type;
1541 /* Reserve space for the count. */
1542 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1543 /* We always write the page size as 1 since we have no good way to
1544 determine the correct value. */
1545 pack_long (buf, long_type, 1);
1546 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1548 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1551 if (mapping_data.file_count != 0)
1553 /* Write the count to the obstack. */
1554 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1555 long_type, mapping_data.file_count);
1557 /* Copy the filenames to the data obstack. */
1558 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1559 obstack_object_size (&filename_obstack));
1561 note_data = elfcore_write_note (obfd, note_data, note_size,
1563 obstack_base (&data_obstack),
1564 obstack_object_size (&data_obstack));
1570 /* Structure for passing information from
1571 linux_collect_thread_registers via an iterator to
1572 linux_collect_regset_section_cb. */
1574 struct linux_collect_regset_section_cb_data
1576 struct gdbarch *gdbarch;
1577 const struct regcache *regcache;
1582 enum gdb_signal stop_signal;
1583 int abort_iteration;
1586 /* Callback for iterate_over_regset_sections that records a single
1587 regset in the corefile note section. */
1590 linux_collect_regset_section_cb (const char *sect_name, int size,
1591 const struct regset *regset,
1592 const char *human_name, void *cb_data)
1595 struct linux_collect_regset_section_cb_data *data
1596 = (struct linux_collect_regset_section_cb_data *) cb_data;
1598 if (data->abort_iteration)
1601 gdb_assert (regset && regset->collect_regset);
1603 buf = (char *) xmalloc (size);
1604 regset->collect_regset (regset, data->regcache, -1, buf, size);
1606 /* PRSTATUS still needs to be treated specially. */
1607 if (strcmp (sect_name, ".reg") == 0)
1608 data->note_data = (char *) elfcore_write_prstatus
1609 (data->obfd, data->note_data, data->note_size, data->lwp,
1610 gdb_signal_to_host (data->stop_signal), buf);
1612 data->note_data = (char *) elfcore_write_register_note
1613 (data->obfd, data->note_data, data->note_size,
1614 sect_name, buf, size);
1617 if (data->note_data == NULL)
1618 data->abort_iteration = 1;
1621 /* Records the thread's register state for the corefile note
1625 linux_collect_thread_registers (const struct regcache *regcache,
1626 ptid_t ptid, bfd *obfd,
1627 char *note_data, int *note_size,
1628 enum gdb_signal stop_signal)
1630 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1631 struct linux_collect_regset_section_cb_data data;
1633 data.gdbarch = gdbarch;
1634 data.regcache = regcache;
1636 data.note_data = note_data;
1637 data.note_size = note_size;
1638 data.stop_signal = stop_signal;
1639 data.abort_iteration = 0;
1641 /* For remote targets the LWP may not be available, so use the TID. */
1642 data.lwp = ptid_get_lwp (ptid);
1644 data.lwp = ptid_get_tid (ptid);
1646 gdbarch_iterate_over_regset_sections (gdbarch,
1647 linux_collect_regset_section_cb,
1649 return data.note_data;
1652 /* Fetch the siginfo data for the specified thread, if it exists. If
1653 there is no data, or we could not read it, return NULL. Otherwise,
1654 return a newly malloc'd buffer holding the data and fill in *SIZE
1655 with the size of the data. The caller is responsible for freeing
1659 linux_get_siginfo_data (thread_info *thread, struct gdbarch *gdbarch,
1662 struct type *siginfo_type;
1665 struct cleanup *cleanups;
1667 if (!gdbarch_get_siginfo_type_p (gdbarch))
1670 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1671 inferior_ptid = thread->ptid;
1673 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1675 buf = (gdb_byte *) xmalloc (TYPE_LENGTH (siginfo_type));
1676 cleanups = make_cleanup (xfree, buf);
1678 bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1679 buf, 0, TYPE_LENGTH (siginfo_type));
1680 if (bytes_read == TYPE_LENGTH (siginfo_type))
1682 discard_cleanups (cleanups);
1687 do_cleanups (cleanups);
1694 struct linux_corefile_thread_data
1696 struct gdbarch *gdbarch;
1700 enum gdb_signal stop_signal;
1703 /* Records the thread's register state for the corefile note
1707 linux_corefile_thread (struct thread_info *info,
1708 struct linux_corefile_thread_data *args)
1710 struct cleanup *old_chain;
1711 struct regcache *regcache;
1712 gdb_byte *siginfo_data;
1713 LONGEST siginfo_size = 0;
1715 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1717 target_fetch_registers (regcache, -1);
1718 siginfo_data = linux_get_siginfo_data (info, args->gdbarch, &siginfo_size);
1720 old_chain = make_cleanup (xfree, siginfo_data);
1722 args->note_data = linux_collect_thread_registers
1723 (regcache, info->ptid, args->obfd, args->note_data,
1724 args->note_size, args->stop_signal);
1726 /* Don't return anything if we got no register information above,
1727 such a core file is useless. */
1728 if (args->note_data != NULL)
1729 if (siginfo_data != NULL)
1730 args->note_data = elfcore_write_note (args->obfd,
1734 siginfo_data, siginfo_size);
1736 do_cleanups (old_chain);
1739 /* Fill the PRPSINFO structure with information about the process being
1740 debugged. Returns 1 in case of success, 0 for failures. Please note that
1741 even if the structure cannot be entirely filled (e.g., GDB was unable to
1742 gather information about the process UID/GID), this function will still
1743 return 1 since some information was already recorded. It will only return
1744 0 iff nothing can be gathered. */
1747 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1749 /* The filename which we will use to obtain some info about the process.
1750 We will basically use this to store the `/proc/PID/FILENAME' file. */
1752 /* The full name of the program which generated the corefile. */
1754 /* The basename of the executable. */
1755 const char *basename;
1756 /* The arguments of the program. */
1759 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1760 char *proc_stat, *proc_status;
1761 /* Temporary buffer. */
1763 /* The valid states of a process, according to the Linux kernel. */
1764 const char valid_states[] = "RSDTZW";
1765 /* The program state. */
1766 const char *prog_state;
1767 /* The state of the process. */
1769 /* The PID of the program which generated the corefile. */
1771 /* Process flags. */
1772 unsigned int pr_flag;
1773 /* Process nice value. */
1775 /* The number of fields read by `sscanf'. */
1780 gdb_assert (p != NULL);
1782 /* Obtaining PID and filename. */
1783 pid = ptid_get_pid (inferior_ptid);
1784 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1785 fname = target_fileio_read_stralloc (NULL, filename);
1787 if (fname == NULL || *fname == '\0')
1789 /* No program name was read, so we won't be able to retrieve more
1790 information about the process. */
1795 c = make_cleanup (xfree, fname);
1796 memset (p, 0, sizeof (*p));
1798 /* Defining the PID. */
1801 /* Copying the program name. Only the basename matters. */
1802 basename = lbasename (fname);
1803 strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1804 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1806 infargs = get_inferior_args ();
1808 psargs = xstrdup (fname);
1809 if (infargs != NULL)
1810 psargs = reconcat (psargs, psargs, " ", infargs, (char *) NULL);
1812 make_cleanup (xfree, psargs);
1814 strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1815 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1817 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1818 proc_stat = target_fileio_read_stralloc (NULL, filename);
1819 make_cleanup (xfree, proc_stat);
1821 if (proc_stat == NULL || *proc_stat == '\0')
1823 /* Despite being unable to read more information about the
1824 process, we return 1 here because at least we have its
1825 command line, PID and arguments. */
1830 /* Ok, we have the stats. It's time to do a little parsing of the
1831 contents of the buffer, so that we end up reading what we want.
1833 The following parsing mechanism is strongly based on the
1834 information generated by the `fs/proc/array.c' file, present in
1835 the Linux kernel tree. More details about how the information is
1836 displayed can be obtained by seeing the manpage of proc(5),
1837 specifically under the entry of `/proc/[pid]/stat'. */
1839 /* Getting rid of the PID, since we already have it. */
1840 while (isdigit (*proc_stat))
1843 proc_stat = skip_spaces (proc_stat);
1845 /* ps command also relies on no trailing fields ever contain ')'. */
1846 proc_stat = strrchr (proc_stat, ')');
1847 if (proc_stat == NULL)
1854 proc_stat = skip_spaces (proc_stat);
1856 n_fields = sscanf (proc_stat,
1857 "%c" /* Process state. */
1858 "%d%d%d" /* Parent PID, group ID, session ID. */
1859 "%*d%*d" /* tty_nr, tpgid (not used). */
1861 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1862 cmajflt (not used). */
1863 "%*s%*s%*s%*s" /* utime, stime, cutime,
1864 cstime (not used). */
1865 "%*s" /* Priority (not used). */
1868 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1874 /* Again, we couldn't read the complementary information about
1875 the process state. However, we already have minimal
1876 information, so we just return 1 here. */
1881 /* Filling the structure fields. */
1882 prog_state = strchr (valid_states, pr_sname);
1883 if (prog_state != NULL)
1884 p->pr_state = prog_state - valid_states;
1887 /* Zero means "Running". */
1891 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1892 p->pr_zomb = p->pr_sname == 'Z';
1893 p->pr_nice = pr_nice;
1894 p->pr_flag = pr_flag;
1896 /* Finally, obtaining the UID and GID. For that, we read and parse the
1897 contents of the `/proc/PID/status' file. */
1898 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1899 proc_status = target_fileio_read_stralloc (NULL, filename);
1900 make_cleanup (xfree, proc_status);
1902 if (proc_status == NULL || *proc_status == '\0')
1904 /* Returning 1 since we already have a bunch of information. */
1909 /* Extracting the UID. */
1910 tmpstr = strstr (proc_status, "Uid:");
1913 /* Advancing the pointer to the beginning of the UID. */
1914 tmpstr += sizeof ("Uid:");
1915 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1918 if (isdigit (*tmpstr))
1919 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1922 /* Extracting the GID. */
1923 tmpstr = strstr (proc_status, "Gid:");
1926 /* Advancing the pointer to the beginning of the GID. */
1927 tmpstr += sizeof ("Gid:");
1928 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1931 if (isdigit (*tmpstr))
1932 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1940 /* Build the note section for a corefile, and return it in a malloc
1944 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1946 struct linux_corefile_thread_data thread_args;
1947 struct elf_internal_linux_prpsinfo prpsinfo;
1948 char *note_data = NULL;
1951 struct thread_info *curr_thr, *signalled_thr, *thr;
1953 if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1956 if (linux_fill_prpsinfo (&prpsinfo))
1958 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1960 note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1961 note_data, note_size,
1966 if (gdbarch_ptr_bit (gdbarch) == 64)
1967 note_data = elfcore_write_linux_prpsinfo64 (obfd,
1968 note_data, note_size,
1971 note_data = elfcore_write_linux_prpsinfo32 (obfd,
1972 note_data, note_size,
1977 /* Thread register information. */
1980 update_thread_list ();
1982 CATCH (e, RETURN_MASK_ERROR)
1984 exception_print (gdb_stderr, e);
1988 /* Like the kernel, prefer dumping the signalled thread first.
1989 "First thread" is what tools use to infer the signalled thread.
1990 In case there's more than one signalled thread, prefer the
1991 current thread, if it is signalled. */
1992 curr_thr = inferior_thread ();
1993 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
1994 signalled_thr = curr_thr;
1997 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
1998 if (signalled_thr == NULL)
1999 signalled_thr = curr_thr;
2002 thread_args.gdbarch = gdbarch;
2003 thread_args.obfd = obfd;
2004 thread_args.note_data = note_data;
2005 thread_args.note_size = note_size;
2006 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
2008 linux_corefile_thread (signalled_thr, &thread_args);
2009 ALL_NON_EXITED_THREADS (thr)
2011 if (thr == signalled_thr)
2013 if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
2016 linux_corefile_thread (thr, &thread_args);
2019 note_data = thread_args.note_data;
2023 /* Auxillary vector. */
2024 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
2028 note_data = elfcore_write_note (obfd, note_data, note_size,
2029 "CORE", NT_AUXV, auxv, auxv_len);
2036 /* SPU information. */
2037 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
2041 /* File mappings. */
2042 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
2043 note_data, note_size);
2048 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2049 gdbarch.h. This function is not static because it is exported to
2050 other -tdep files. */
2053 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2058 return GDB_SIGNAL_0;
2061 return GDB_SIGNAL_HUP;
2064 return GDB_SIGNAL_INT;
2067 return GDB_SIGNAL_QUIT;
2070 return GDB_SIGNAL_ILL;
2073 return GDB_SIGNAL_TRAP;
2076 return GDB_SIGNAL_ABRT;
2079 return GDB_SIGNAL_BUS;
2082 return GDB_SIGNAL_FPE;
2085 return GDB_SIGNAL_KILL;
2088 return GDB_SIGNAL_USR1;
2091 return GDB_SIGNAL_SEGV;
2094 return GDB_SIGNAL_USR2;
2097 return GDB_SIGNAL_PIPE;
2100 return GDB_SIGNAL_ALRM;
2103 return GDB_SIGNAL_TERM;
2106 return GDB_SIGNAL_CHLD;
2109 return GDB_SIGNAL_CONT;
2112 return GDB_SIGNAL_STOP;
2115 return GDB_SIGNAL_TSTP;
2118 return GDB_SIGNAL_TTIN;
2121 return GDB_SIGNAL_TTOU;
2124 return GDB_SIGNAL_URG;
2127 return GDB_SIGNAL_XCPU;
2130 return GDB_SIGNAL_XFSZ;
2132 case LINUX_SIGVTALRM:
2133 return GDB_SIGNAL_VTALRM;
2136 return GDB_SIGNAL_PROF;
2138 case LINUX_SIGWINCH:
2139 return GDB_SIGNAL_WINCH;
2141 /* No way to differentiate between SIGIO and SIGPOLL.
2142 Therefore, we just handle the first one. */
2144 return GDB_SIGNAL_IO;
2147 return GDB_SIGNAL_PWR;
2150 return GDB_SIGNAL_SYS;
2152 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2153 therefore we have to handle them here. */
2154 case LINUX_SIGRTMIN:
2155 return GDB_SIGNAL_REALTIME_32;
2157 case LINUX_SIGRTMAX:
2158 return GDB_SIGNAL_REALTIME_64;
2161 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2163 int offset = signal - LINUX_SIGRTMIN + 1;
2165 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2168 return GDB_SIGNAL_UNKNOWN;
2171 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2172 gdbarch.h. This function is not static because it is exported to
2173 other -tdep files. */
2176 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2177 enum gdb_signal signal)
2184 case GDB_SIGNAL_HUP:
2185 return LINUX_SIGHUP;
2187 case GDB_SIGNAL_INT:
2188 return LINUX_SIGINT;
2190 case GDB_SIGNAL_QUIT:
2191 return LINUX_SIGQUIT;
2193 case GDB_SIGNAL_ILL:
2194 return LINUX_SIGILL;
2196 case GDB_SIGNAL_TRAP:
2197 return LINUX_SIGTRAP;
2199 case GDB_SIGNAL_ABRT:
2200 return LINUX_SIGABRT;
2202 case GDB_SIGNAL_FPE:
2203 return LINUX_SIGFPE;
2205 case GDB_SIGNAL_KILL:
2206 return LINUX_SIGKILL;
2208 case GDB_SIGNAL_BUS:
2209 return LINUX_SIGBUS;
2211 case GDB_SIGNAL_SEGV:
2212 return LINUX_SIGSEGV;
2214 case GDB_SIGNAL_SYS:
2215 return LINUX_SIGSYS;
2217 case GDB_SIGNAL_PIPE:
2218 return LINUX_SIGPIPE;
2220 case GDB_SIGNAL_ALRM:
2221 return LINUX_SIGALRM;
2223 case GDB_SIGNAL_TERM:
2224 return LINUX_SIGTERM;
2226 case GDB_SIGNAL_URG:
2227 return LINUX_SIGURG;
2229 case GDB_SIGNAL_STOP:
2230 return LINUX_SIGSTOP;
2232 case GDB_SIGNAL_TSTP:
2233 return LINUX_SIGTSTP;
2235 case GDB_SIGNAL_CONT:
2236 return LINUX_SIGCONT;
2238 case GDB_SIGNAL_CHLD:
2239 return LINUX_SIGCHLD;
2241 case GDB_SIGNAL_TTIN:
2242 return LINUX_SIGTTIN;
2244 case GDB_SIGNAL_TTOU:
2245 return LINUX_SIGTTOU;
2250 case GDB_SIGNAL_XCPU:
2251 return LINUX_SIGXCPU;
2253 case GDB_SIGNAL_XFSZ:
2254 return LINUX_SIGXFSZ;
2256 case GDB_SIGNAL_VTALRM:
2257 return LINUX_SIGVTALRM;
2259 case GDB_SIGNAL_PROF:
2260 return LINUX_SIGPROF;
2262 case GDB_SIGNAL_WINCH:
2263 return LINUX_SIGWINCH;
2265 case GDB_SIGNAL_USR1:
2266 return LINUX_SIGUSR1;
2268 case GDB_SIGNAL_USR2:
2269 return LINUX_SIGUSR2;
2271 case GDB_SIGNAL_PWR:
2272 return LINUX_SIGPWR;
2274 case GDB_SIGNAL_POLL:
2275 return LINUX_SIGPOLL;
2277 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2278 therefore we have to handle it here. */
2279 case GDB_SIGNAL_REALTIME_32:
2280 return LINUX_SIGRTMIN;
2282 /* Same comment applies to _64. */
2283 case GDB_SIGNAL_REALTIME_64:
2284 return LINUX_SIGRTMAX;
2287 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2288 if (signal >= GDB_SIGNAL_REALTIME_33
2289 && signal <= GDB_SIGNAL_REALTIME_63)
2291 int offset = signal - GDB_SIGNAL_REALTIME_33;
2293 return LINUX_SIGRTMIN + 1 + offset;
2299 /* Helper for linux_vsyscall_range that does the real work of finding
2300 the vsyscall's address range. */
2303 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2309 if (target_auxv_search (¤t_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2312 /* It doesn't make sense to access the host's /proc when debugging a
2313 core file. Instead, look for the PT_LOAD segment that matches
2315 if (!target_has_execution)
2317 Elf_Internal_Phdr *phdrs;
2321 phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
2322 if (phdrs_size == -1)
2325 phdrs = (Elf_Internal_Phdr *) alloca (phdrs_size);
2326 num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs);
2327 if (num_phdrs == -1)
2330 for (i = 0; i < num_phdrs; i++)
2331 if (phdrs[i].p_type == PT_LOAD
2332 && phdrs[i].p_vaddr == range->start)
2334 range->length = phdrs[i].p_memsz;
2341 /* We need to know the real target PID to access /proc. */
2342 if (current_inferior ()->fake_pid_p)
2345 pid = current_inferior ()->pid;
2347 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2348 reading /proc/PID/maps (2). The later identifies thread stacks
2349 in the output, which requires scanning every thread in the thread
2350 group to check whether a VMA is actually a thread's stack. With
2351 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2352 a few thousand threads, (1) takes a few miliseconds, while (2)
2353 takes several seconds. Also note that "smaps", what we read for
2354 determining core dump mappings, is even slower than "maps". */
2355 xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2356 data = target_fileio_read_stralloc (NULL, filename);
2359 struct cleanup *cleanup = make_cleanup (xfree, data);
2361 char *saveptr = NULL;
2363 for (line = strtok_r (data, "\n", &saveptr);
2365 line = strtok_r (NULL, "\n", &saveptr))
2367 ULONGEST addr, endaddr;
2368 const char *p = line;
2370 addr = strtoulst (p, &p, 16);
2371 if (addr == range->start)
2375 endaddr = strtoulst (p, &p, 16);
2376 range->length = endaddr - addr;
2377 do_cleanups (cleanup);
2382 do_cleanups (cleanup);
2385 warning (_("unable to open /proc file '%s'"), filename);
2390 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2391 caching, and defers the real work to linux_vsyscall_range_raw. */
2394 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2396 struct linux_info *info = get_linux_inferior_data ();
2398 if (info->vsyscall_range_p == 0)
2400 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2401 info->vsyscall_range_p = 1;
2403 info->vsyscall_range_p = -1;
2406 if (info->vsyscall_range_p < 0)
2409 *range = info->vsyscall_range;
2413 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2414 definitions would be dependent on compilation host. */
2415 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2416 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2418 /* See gdbarch.sh 'infcall_mmap'. */
2421 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2423 struct objfile *objf;
2424 /* Do there still exist any Linux systems without "mmap64"?
2425 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2426 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2427 struct value *addr_val;
2428 struct gdbarch *gdbarch = get_objfile_arch (objf);
2432 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2434 struct value *arg[ARG_LAST];
2436 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2438 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2439 arg[ARG_LENGTH] = value_from_ulongest
2440 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2441 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2442 | GDB_MMAP_PROT_EXEC))
2444 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2445 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2446 GDB_MMAP_MAP_PRIVATE
2447 | GDB_MMAP_MAP_ANONYMOUS);
2448 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2449 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2451 addr_val = call_function_by_hand (mmap_val, NULL, ARG_LAST, arg);
2452 retval = value_as_address (addr_val);
2453 if (retval == (CORE_ADDR) -1)
2454 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2459 /* See gdbarch.sh 'infcall_munmap'. */
2462 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2464 struct objfile *objf;
2465 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2466 struct value *retval_val;
2467 struct gdbarch *gdbarch = get_objfile_arch (objf);
2471 ARG_ADDR, ARG_LENGTH, ARG_LAST
2473 struct value *arg[ARG_LAST];
2475 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2477 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2478 arg[ARG_LENGTH] = value_from_ulongest
2479 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2480 retval_val = call_function_by_hand (munmap_val, NULL, ARG_LAST, arg);
2481 retval = value_as_long (retval_val);
2483 warning (_("Failed inferior munmap call at %s for %s bytes, "
2484 "errno is changed."),
2485 hex_string (addr), pulongest (size));
2488 /* See linux-tdep.h. */
2491 linux_displaced_step_location (struct gdbarch *gdbarch)
2496 /* Determine entry point from target auxiliary vector. This avoids
2497 the need for symbols. Also, when debugging a stand-alone SPU
2498 executable, entry_point_address () will point to an SPU
2499 local-store address and is thus not usable as displaced stepping
2500 location. The auxiliary vector gets us the PowerPC-side entry
2501 point address instead. */
2502 if (target_auxv_search (¤t_target, AT_ENTRY, &addr) <= 0)
2503 throw_error (NOT_SUPPORTED_ERROR,
2504 _("Cannot find AT_ENTRY auxiliary vector entry."));
2506 /* Make certain that the address points at real code, and not a
2507 function descriptor. */
2508 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2511 /* Inferior calls also use the entry point as a breakpoint location.
2512 We don't want displaced stepping to interfere with those
2513 breakpoints, so leave space. */
2514 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2520 /* Display whether the gcore command is using the
2521 /proc/PID/coredump_filter file. */
2524 show_use_coredump_filter (struct ui_file *file, int from_tty,
2525 struct cmd_list_element *c, const char *value)
2527 fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2528 " corefiles is %s.\n"), value);
2531 /* To be called from the various GDB_OSABI_LINUX handlers for the
2532 various GNU/Linux architectures and machine types. */
2535 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2537 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2538 set_gdbarch_info_proc (gdbarch, linux_info_proc);
2539 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2540 set_gdbarch_core_xfer_siginfo (gdbarch, linux_core_xfer_siginfo);
2541 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2542 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2543 set_gdbarch_has_shared_address_space (gdbarch,
2544 linux_has_shared_address_space);
2545 set_gdbarch_gdb_signal_from_target (gdbarch,
2546 linux_gdb_signal_from_target);
2547 set_gdbarch_gdb_signal_to_target (gdbarch,
2548 linux_gdb_signal_to_target);
2549 set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2550 set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2551 set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2552 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2555 /* Provide a prototype to silence -Wmissing-prototypes. */
2556 extern initialize_file_ftype _initialize_linux_tdep;
2559 _initialize_linux_tdep (void)
2561 linux_gdbarch_data_handle =
2562 gdbarch_data_register_post_init (init_linux_gdbarch_data);
2564 /* Set a cache per-inferior. */
2566 = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2567 /* Observers used to invalidate the cache when needed. */
2568 observer_attach_inferior_exit (invalidate_linux_cache_inf);
2569 observer_attach_inferior_appeared (invalidate_linux_cache_inf);
2571 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2572 &use_coredump_filter, _("\
2573 Set whether gcore should consider /proc/PID/coredump_filter."),
2575 Show whether gcore should consider /proc/PID/coredump_filter."),
2577 Use this command to set whether gcore should consider the contents\n\
2578 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2579 about this file, refer to the manpage of core(5)."),
2580 NULL, show_use_coredump_filter,
2581 &setlist, &showlist);