1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2016 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"
44 /* This enum represents the values that the user can choose when
45 informing the Linux kernel about which memory mappings will be
46 dumped in a corefile. They are described in the file
47 Documentation/filesystems/proc.txt, inside the Linux kernel
52 COREFILTER_ANON_PRIVATE = 1 << 0,
53 COREFILTER_ANON_SHARED = 1 << 1,
54 COREFILTER_MAPPED_PRIVATE = 1 << 2,
55 COREFILTER_MAPPED_SHARED = 1 << 3,
56 COREFILTER_ELF_HEADERS = 1 << 4,
57 COREFILTER_HUGETLB_PRIVATE = 1 << 5,
58 COREFILTER_HUGETLB_SHARED = 1 << 6,
60 DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
62 /* This struct is used to map flags found in the "VmFlags:" field (in
63 the /proc/<PID>/smaps file). */
67 /* Zero if this structure has not been initialized yet. It
68 probably means that the Linux kernel being used does not emit
69 the "VmFlags:" field on "/proc/PID/smaps". */
71 unsigned int initialized_p : 1;
73 /* Memory mapped I/O area (VM_IO, "io"). */
75 unsigned int io_page : 1;
77 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
79 unsigned int uses_huge_tlb : 1;
81 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
83 unsigned int exclude_coredump : 1;
85 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
87 unsigned int shared_mapping : 1;
90 /* Whether to take the /proc/PID/coredump_filter into account when
91 generating a corefile. */
93 static int use_coredump_filter = 1;
95 /* This enum represents the signals' numbers on a generic architecture
96 running the Linux kernel. The definition of "generic" comes from
97 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
98 tree, which is the "de facto" implementation of signal numbers to
99 be used by new architecture ports.
101 For those architectures which have differences between the generic
102 standard (e.g., Alpha), we define the different signals (and *only*
103 those) in the specific target-dependent file (e.g.,
104 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
105 tdep file for more information.
107 ARM deserves a special mention here. On the file
108 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
109 (and ARM-only) signal, which is SIGSWI, with the same number as
110 SIGRTMIN. This signal is used only for a very specific target,
111 called ArthurOS (from RISCOS). Therefore, we do not handle it on
112 the ARM-tdep file, and we can safely use the generic signal handler
113 here for ARM targets.
115 As stated above, this enum is derived from
116 <include/uapi/asm-generic/signal.h>, from the Linux kernel
137 LINUX_SIGSTKFLT = 16,
147 LINUX_SIGVTALRM = 26,
151 LINUX_SIGPOLL = LINUX_SIGIO,
154 LINUX_SIGUNUSED = 31,
160 static struct gdbarch_data *linux_gdbarch_data_handle;
162 struct linux_gdbarch_data
164 struct type *siginfo_type;
168 init_linux_gdbarch_data (struct gdbarch *gdbarch)
170 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
173 static struct linux_gdbarch_data *
174 get_linux_gdbarch_data (struct gdbarch *gdbarch)
176 return ((struct linux_gdbarch_data *)
177 gdbarch_data (gdbarch, linux_gdbarch_data_handle));
180 /* Per-inferior data key. */
181 static const struct inferior_data *linux_inferior_data;
183 /* Linux-specific cached data. This is used by GDB for caching
184 purposes for each inferior. This helps reduce the overhead of
185 transfering data from a remote target to the local host. */
188 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
189 if VSYSCALL_RANGE_P is positive. This is cached because getting
190 at this info requires an auxv lookup (which is itself cached),
191 and looking through the inferior's mappings (which change
192 throughout execution and therefore cannot be cached). */
193 struct mem_range vsyscall_range;
195 /* Zero if we haven't tried looking up the vsyscall's range before
196 yet. Positive if we tried looking it up, and found it. Negative
197 if we tried looking it up but failed. */
198 int vsyscall_range_p;
201 /* Frees whatever allocated space there is to be freed and sets INF's
202 linux cache data pointer to NULL. */
205 invalidate_linux_cache_inf (struct inferior *inf)
207 struct linux_info *info;
209 info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
213 set_inferior_data (inf, linux_inferior_data, NULL);
217 /* Handles the cleanup of the linux cache for inferior INF. ARG is
218 ignored. Callback for the inferior_appeared and inferior_exit
222 linux_inferior_data_cleanup (struct inferior *inf, void *arg)
224 invalidate_linux_cache_inf (inf);
227 /* Fetch the linux cache info for INF. This function always returns a
228 valid INFO pointer. */
230 static struct linux_info *
231 get_linux_inferior_data (void)
233 struct linux_info *info;
234 struct inferior *inf = current_inferior ();
236 info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
239 info = XCNEW (struct linux_info);
240 set_inferior_data (inf, linux_inferior_data, info);
246 /* See linux-tdep.h. */
249 linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
250 linux_siginfo_extra_fields extra_fields)
252 struct linux_gdbarch_data *linux_gdbarch_data;
253 struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
254 struct type *uid_type, *pid_type;
255 struct type *sigval_type, *clock_type;
256 struct type *siginfo_type, *sifields_type;
259 linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
260 if (linux_gdbarch_data->siginfo_type != NULL)
261 return linux_gdbarch_data->siginfo_type;
263 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
265 uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
267 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
269 short_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
271 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
274 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
275 TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
276 append_composite_type_field (sigval_type, "sival_int", int_type);
277 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
280 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
281 TYPE_LENGTH (int_type), "__pid_t");
282 TYPE_TARGET_TYPE (pid_type) = int_type;
283 TYPE_TARGET_STUB (pid_type) = 1;
286 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
287 TYPE_LENGTH (uint_type), "__uid_t");
288 TYPE_TARGET_TYPE (uid_type) = uint_type;
289 TYPE_TARGET_STUB (uid_type) = 1;
292 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
293 TYPE_LENGTH (long_type), "__clock_t");
294 TYPE_TARGET_TYPE (clock_type) = long_type;
295 TYPE_TARGET_STUB (clock_type) = 1;
298 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
301 const int si_max_size = 128;
303 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
306 if (gdbarch_ptr_bit (gdbarch) == 64)
307 si_pad_size = (si_max_size / size_of_int) - 4;
309 si_pad_size = (si_max_size / size_of_int) - 3;
310 append_composite_type_field (sifields_type, "_pad",
311 init_vector_type (int_type, si_pad_size));
315 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
316 append_composite_type_field (type, "si_pid", pid_type);
317 append_composite_type_field (type, "si_uid", uid_type);
318 append_composite_type_field (sifields_type, "_kill", type);
321 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
322 append_composite_type_field (type, "si_tid", int_type);
323 append_composite_type_field (type, "si_overrun", int_type);
324 append_composite_type_field (type, "si_sigval", sigval_type);
325 append_composite_type_field (sifields_type, "_timer", type);
328 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
329 append_composite_type_field (type, "si_pid", pid_type);
330 append_composite_type_field (type, "si_uid", uid_type);
331 append_composite_type_field (type, "si_sigval", sigval_type);
332 append_composite_type_field (sifields_type, "_rt", 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_status", int_type);
339 append_composite_type_field (type, "si_utime", clock_type);
340 append_composite_type_field (type, "si_stime", clock_type);
341 append_composite_type_field (sifields_type, "_sigchld", type);
344 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
345 append_composite_type_field (type, "si_addr", void_ptr_type);
347 /* Additional bound fields for _sigfault in case they were requested. */
348 if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
350 struct type *sigfault_bnd_fields;
352 append_composite_type_field (type, "_addr_lsb", short_type);
353 sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
354 append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
355 append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
356 append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
358 append_composite_type_field (sifields_type, "_sigfault", type);
361 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
362 append_composite_type_field (type, "si_band", long_type);
363 append_composite_type_field (type, "si_fd", int_type);
364 append_composite_type_field (sifields_type, "_sigpoll", type);
367 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
368 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
369 append_composite_type_field (siginfo_type, "si_signo", int_type);
370 append_composite_type_field (siginfo_type, "si_errno", int_type);
371 append_composite_type_field (siginfo_type, "si_code", int_type);
372 append_composite_type_field_aligned (siginfo_type,
373 "_sifields", sifields_type,
374 TYPE_LENGTH (long_type));
376 linux_gdbarch_data->siginfo_type = siginfo_type;
381 /* This function is suitable for architectures that don't
382 extend/override the standard siginfo structure. */
385 linux_get_siginfo_type (struct gdbarch *gdbarch)
387 return linux_get_siginfo_type_with_fields (gdbarch, 0);
390 /* Return true if the target is running on uClinux instead of normal
394 linux_is_uclinux (void)
398 return (target_auxv_search (¤t_target, AT_NULL, &dummy) > 0
399 && target_auxv_search (¤t_target, AT_PAGESZ, &dummy) == 0);
403 linux_has_shared_address_space (struct gdbarch *gdbarch)
405 return linux_is_uclinux ();
408 /* This is how we want PTIDs from core files to be printed. */
411 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
415 if (ptid_get_lwp (ptid) != 0)
417 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
421 return normal_pid_to_str (ptid);
424 /* Service function for corefiles and info proc. */
427 read_mapping (const char *line,
428 ULONGEST *addr, ULONGEST *endaddr,
429 const char **permissions, size_t *permissions_len,
431 const char **device, size_t *device_len,
433 const char **filename)
435 const char *p = line;
437 *addr = strtoulst (p, &p, 16);
440 *endaddr = strtoulst (p, &p, 16);
442 p = skip_spaces_const (p);
444 while (*p && !isspace (*p))
446 *permissions_len = p - *permissions;
448 *offset = strtoulst (p, &p, 16);
450 p = skip_spaces_const (p);
452 while (*p && !isspace (*p))
454 *device_len = p - *device;
456 *inode = strtoulst (p, &p, 10);
458 p = skip_spaces_const (p);
462 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
464 This function was based on the documentation found on
465 <Documentation/filesystems/proc.txt>, on the Linux kernel.
467 Linux kernels before commit
468 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
472 decode_vmflags (char *p, struct smaps_vmflags *v)
474 char *saveptr = NULL;
477 v->initialized_p = 1;
478 p = skip_to_space (p);
481 for (s = strtok_r (p, " ", &saveptr);
483 s = strtok_r (NULL, " ", &saveptr))
485 if (strcmp (s, "io") == 0)
487 else if (strcmp (s, "ht") == 0)
488 v->uses_huge_tlb = 1;
489 else if (strcmp (s, "dd") == 0)
490 v->exclude_coredump = 1;
491 else if (strcmp (s, "sh") == 0)
492 v->shared_mapping = 1;
496 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
498 FILENAME is the name of the file present in the first line of the
499 memory mapping, in the "/proc/PID/smaps" output. For example, if
502 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
504 Then FILENAME will be "/path/to/file". */
507 mapping_is_anonymous_p (const char *filename)
509 static regex_t dev_zero_regex, shmem_file_regex, file_deleted_regex;
510 static int init_regex_p = 0;
514 struct cleanup *c = make_cleanup (null_cleanup, NULL);
516 /* Let's be pessimistic and assume there will be an error while
517 compiling the regex'es. */
520 /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
521 without the "(deleted)" string in the end). We know for
522 sure, based on the Linux kernel code, that memory mappings
523 whose associated filename is "/dev/zero" are guaranteed to be
525 compile_rx_or_error (&dev_zero_regex, "^/dev/zero\\( (deleted)\\)\\?$",
526 _("Could not compile regex to match /dev/zero "
528 /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
529 without the "(deleted)" string in the end). These filenames
530 refer to shared memory (shmem), and memory mappings
531 associated with them are MAP_ANONYMOUS as well. */
532 compile_rx_or_error (&shmem_file_regex,
533 "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
534 _("Could not compile regex to match shmem "
536 /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
537 Linux kernel's 'n_link == 0' code, which is responsible to
538 decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
539 mapping. In other words, if FILE_DELETED_REGEX matches, it
540 does not necessarily mean that we are dealing with an
541 anonymous shared mapping. However, there is no easy way to
542 detect this currently, so this is the best approximation we
545 As a result, GDB will dump readonly pages of deleted
546 executables when using the default value of coredump_filter
547 (0x33), while the Linux kernel will not dump those pages.
548 But we can live with that. */
549 compile_rx_or_error (&file_deleted_regex, " (deleted)$",
550 _("Could not compile regex to match "
551 "'<file> (deleted)'"));
552 /* We will never release these regexes, so just discard the
554 discard_cleanups (c);
556 /* If we reached this point, then everything succeeded. */
560 if (init_regex_p == -1)
562 const char deleted[] = " (deleted)";
563 size_t del_len = sizeof (deleted) - 1;
564 size_t filename_len = strlen (filename);
566 /* There was an error while compiling the regex'es above. In
567 order to try to give some reliable information to the caller,
568 we just try to find the string " (deleted)" in the filename.
569 If we managed to find it, then we assume the mapping is
571 return (filename_len >= del_len
572 && strcmp (filename + filename_len - del_len, deleted) == 0);
575 if (*filename == '\0'
576 || regexec (&dev_zero_regex, filename, 0, NULL, 0) == 0
577 || regexec (&shmem_file_regex, filename, 0, NULL, 0) == 0
578 || regexec (&file_deleted_regex, filename, 0, NULL, 0) == 0)
584 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
585 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
586 greater than 0 if it should.
588 In a nutshell, this is the logic that we follow in order to decide
589 if a mapping should be dumped or not.
591 - If the mapping is associated to a file whose name ends with
592 " (deleted)", or if the file is "/dev/zero", or if it is
593 "/SYSV%08x" (shared memory), or if there is no file associated
594 with it, or if the AnonHugePages: or the Anonymous: fields in the
595 /proc/PID/smaps have contents, then GDB considers this mapping to
596 be anonymous. Otherwise, GDB considers this mapping to be a
597 file-backed mapping (because there will be a file associated with
600 It is worth mentioning that, from all those checks described
601 above, the most fragile is the one to see if the file name ends
602 with " (deleted)". This does not necessarily mean that the
603 mapping is anonymous, because the deleted file associated with
604 the mapping may have been a hard link to another file, for
605 example. The Linux kernel checks to see if "i_nlink == 0", but
606 GDB cannot easily (and normally) do this check (iff running as
607 root, it could find the mapping in /proc/PID/map_files/ and
608 determine whether there still are other hard links to the
609 inode/file). Therefore, we made a compromise here, and we assume
610 that if the file name ends with " (deleted)", then the mapping is
611 indeed anonymous. FWIW, this is something the Linux kernel could
612 do better: expose this information in a more direct way.
614 - If we see the flag "sh" in the "VmFlags:" field (in
615 /proc/PID/smaps), then certainly the memory mapping is shared
616 (VM_SHARED). If we have access to the VmFlags, and we don't see
617 the "sh" there, then certainly the mapping is private. However,
618 Linux kernels before commit
619 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
620 "VmFlags:" field; in that case, we use another heuristic: if we
621 see 'p' in the permission flags, then we assume that the mapping
622 is private, even though the presence of the 's' flag there would
623 mean VM_MAYSHARE, which means the mapping could still be private.
624 This should work OK enough, however. */
627 dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
628 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
629 const char *filename)
631 /* Initially, we trust in what we received from our caller. This
632 value may not be very precise (i.e., it was probably gathered
633 from the permission line in the /proc/PID/smaps list, which
634 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
635 what we have until we take a look at the "VmFlags:" field
636 (assuming that the version of the Linux kernel being used
637 supports it, of course). */
638 int private_p = maybe_private_p;
640 /* We always dump vDSO and vsyscall mappings, because it's likely that
641 there'll be no file to read the contents from at core load time.
642 The kernel does the same. */
643 if (strcmp ("[vdso]", filename) == 0
644 || strcmp ("[vsyscall]", filename) == 0)
647 if (v->initialized_p)
649 /* We never dump I/O mappings. */
653 /* Check if we should exclude this mapping. */
654 if (v->exclude_coredump)
657 /* Update our notion of whether this mapping is shared or
658 private based on a trustworthy value. */
659 private_p = !v->shared_mapping;
661 /* HugeTLB checking. */
662 if (v->uses_huge_tlb)
664 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
665 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
674 if (mapping_anon_p && mapping_file_p)
676 /* This is a special situation. It can happen when we see a
677 mapping that is file-backed, but that contains anonymous
679 return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
680 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
682 else if (mapping_anon_p)
683 return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
685 return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
689 if (mapping_anon_p && mapping_file_p)
691 /* This is a special situation. It can happen when we see a
692 mapping that is file-backed, but that contains anonymous
694 return ((filterflags & COREFILTER_ANON_SHARED) != 0
695 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
697 else if (mapping_anon_p)
698 return (filterflags & COREFILTER_ANON_SHARED) != 0;
700 return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
704 /* Implement the "info proc" command. */
707 linux_info_proc (struct gdbarch *gdbarch, const char *args,
708 enum info_proc_what what)
710 /* A long is used for pid instead of an int to avoid a loss of precision
711 compiler warning from the output of strtoul. */
713 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
714 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
715 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
716 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
717 int status_f = (what == IP_STATUS || what == IP_ALL);
718 int stat_f = (what == IP_STAT || what == IP_ALL);
723 if (args && isdigit (args[0]))
727 pid = strtoul (args, &tem, 10);
732 if (!target_has_execution)
733 error (_("No current process: you must name one."));
734 if (current_inferior ()->fake_pid_p)
735 error (_("Can't determine the current process's PID: you must name one."));
737 pid = current_inferior ()->pid;
740 args = skip_spaces_const (args);
742 error (_("Too many parameters: %s"), args);
744 printf_filtered (_("process %ld\n"), pid);
747 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
748 data = target_fileio_read_stralloc (NULL, filename);
751 struct cleanup *cleanup = make_cleanup (xfree, data);
752 printf_filtered ("cmdline = '%s'\n", data);
753 do_cleanups (cleanup);
756 warning (_("unable to open /proc file '%s'"), filename);
760 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
761 data = target_fileio_readlink (NULL, filename, &target_errno);
764 struct cleanup *cleanup = make_cleanup (xfree, data);
765 printf_filtered ("cwd = '%s'\n", data);
766 do_cleanups (cleanup);
769 warning (_("unable to read link '%s'"), filename);
773 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
774 data = target_fileio_readlink (NULL, filename, &target_errno);
777 struct cleanup *cleanup = make_cleanup (xfree, data);
778 printf_filtered ("exe = '%s'\n", data);
779 do_cleanups (cleanup);
782 warning (_("unable to read link '%s'"), filename);
786 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
787 data = target_fileio_read_stralloc (NULL, filename);
790 struct cleanup *cleanup = make_cleanup (xfree, data);
793 printf_filtered (_("Mapped address spaces:\n\n"));
794 if (gdbarch_addr_bit (gdbarch) == 32)
796 printf_filtered ("\t%10s %10s %10s %10s %s\n",
799 " Size", " Offset", "objfile");
803 printf_filtered (" %18s %18s %10s %10s %s\n",
806 " Size", " Offset", "objfile");
809 for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
811 ULONGEST addr, endaddr, offset, inode;
812 const char *permissions, *device, *filename;
813 size_t permissions_len, device_len;
815 read_mapping (line, &addr, &endaddr,
816 &permissions, &permissions_len,
817 &offset, &device, &device_len,
820 if (gdbarch_addr_bit (gdbarch) == 32)
822 printf_filtered ("\t%10s %10s %10s %10s %s\n",
823 paddress (gdbarch, addr),
824 paddress (gdbarch, endaddr),
825 hex_string (endaddr - addr),
827 *filename? filename : "");
831 printf_filtered (" %18s %18s %10s %10s %s\n",
832 paddress (gdbarch, addr),
833 paddress (gdbarch, endaddr),
834 hex_string (endaddr - addr),
836 *filename? filename : "");
840 do_cleanups (cleanup);
843 warning (_("unable to open /proc file '%s'"), filename);
847 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
848 data = target_fileio_read_stralloc (NULL, filename);
851 struct cleanup *cleanup = make_cleanup (xfree, data);
852 puts_filtered (data);
853 do_cleanups (cleanup);
856 warning (_("unable to open /proc file '%s'"), filename);
860 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
861 data = target_fileio_read_stralloc (NULL, filename);
864 struct cleanup *cleanup = make_cleanup (xfree, data);
865 const char *p = data;
867 printf_filtered (_("Process: %s\n"),
868 pulongest (strtoulst (p, &p, 10)));
870 p = skip_spaces_const (p);
873 /* ps command also relies on no trailing fields
875 const char *ep = strrchr (p, ')');
878 printf_filtered ("Exec file: %.*s\n",
879 (int) (ep - p - 1), p + 1);
884 p = skip_spaces_const (p);
886 printf_filtered (_("State: %c\n"), *p++);
889 printf_filtered (_("Parent process: %s\n"),
890 pulongest (strtoulst (p, &p, 10)));
892 printf_filtered (_("Process group: %s\n"),
893 pulongest (strtoulst (p, &p, 10)));
895 printf_filtered (_("Session id: %s\n"),
896 pulongest (strtoulst (p, &p, 10)));
898 printf_filtered (_("TTY: %s\n"),
899 pulongest (strtoulst (p, &p, 10)));
901 printf_filtered (_("TTY owner process group: %s\n"),
902 pulongest (strtoulst (p, &p, 10)));
905 printf_filtered (_("Flags: %s\n"),
906 hex_string (strtoulst (p, &p, 10)));
908 printf_filtered (_("Minor faults (no memory page): %s\n"),
909 pulongest (strtoulst (p, &p, 10)));
911 printf_filtered (_("Minor faults, children: %s\n"),
912 pulongest (strtoulst (p, &p, 10)));
914 printf_filtered (_("Major faults (memory page faults): %s\n"),
915 pulongest (strtoulst (p, &p, 10)));
917 printf_filtered (_("Major faults, children: %s\n"),
918 pulongest (strtoulst (p, &p, 10)));
920 printf_filtered (_("utime: %s\n"),
921 pulongest (strtoulst (p, &p, 10)));
923 printf_filtered (_("stime: %s\n"),
924 pulongest (strtoulst (p, &p, 10)));
926 printf_filtered (_("utime, children: %s\n"),
927 pulongest (strtoulst (p, &p, 10)));
929 printf_filtered (_("stime, children: %s\n"),
930 pulongest (strtoulst (p, &p, 10)));
932 printf_filtered (_("jiffies remaining in current "
934 pulongest (strtoulst (p, &p, 10)));
936 printf_filtered (_("'nice' value: %s\n"),
937 pulongest (strtoulst (p, &p, 10)));
939 printf_filtered (_("jiffies until next timeout: %s\n"),
940 pulongest (strtoulst (p, &p, 10)));
942 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
943 pulongest (strtoulst (p, &p, 10)));
945 printf_filtered (_("start time (jiffies since "
946 "system boot): %s\n"),
947 pulongest (strtoulst (p, &p, 10)));
949 printf_filtered (_("Virtual memory size: %s\n"),
950 pulongest (strtoulst (p, &p, 10)));
952 printf_filtered (_("Resident set size: %s\n"),
953 pulongest (strtoulst (p, &p, 10)));
955 printf_filtered (_("rlim: %s\n"),
956 pulongest (strtoulst (p, &p, 10)));
958 printf_filtered (_("Start of text: %s\n"),
959 hex_string (strtoulst (p, &p, 10)));
961 printf_filtered (_("End of text: %s\n"),
962 hex_string (strtoulst (p, &p, 10)));
964 printf_filtered (_("Start of stack: %s\n"),
965 hex_string (strtoulst (p, &p, 10)));
966 #if 0 /* Don't know how architecture-dependent the rest is...
967 Anyway the signal bitmap info is available from "status". */
969 printf_filtered (_("Kernel stack pointer: %s\n"),
970 hex_string (strtoulst (p, &p, 10)));
972 printf_filtered (_("Kernel instr pointer: %s\n"),
973 hex_string (strtoulst (p, &p, 10)));
975 printf_filtered (_("Pending signals bitmap: %s\n"),
976 hex_string (strtoulst (p, &p, 10)));
978 printf_filtered (_("Blocked signals bitmap: %s\n"),
979 hex_string (strtoulst (p, &p, 10)));
981 printf_filtered (_("Ignored signals bitmap: %s\n"),
982 hex_string (strtoulst (p, &p, 10)));
984 printf_filtered (_("Catched signals bitmap: %s\n"),
985 hex_string (strtoulst (p, &p, 10)));
987 printf_filtered (_("wchan (system call): %s\n"),
988 hex_string (strtoulst (p, &p, 10)));
990 do_cleanups (cleanup);
993 warning (_("unable to open /proc file '%s'"), filename);
997 /* Implement "info proc mappings" for a corefile. */
1000 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
1003 ULONGEST count, page_size;
1004 unsigned char *descdata, *filenames, *descend, *contents;
1006 unsigned int addr_size_bits, addr_size;
1007 struct cleanup *cleanup;
1008 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
1009 /* We assume this for reading 64-bit core files. */
1010 gdb_static_assert (sizeof (ULONGEST) >= 8);
1012 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
1013 if (section == NULL)
1015 warning (_("unable to find mappings in core file"));
1019 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
1020 addr_size = addr_size_bits / 8;
1021 note_size = bfd_get_section_size (section);
1023 if (note_size < 2 * addr_size)
1024 error (_("malformed core note - too short for header"));
1026 contents = (unsigned char *) xmalloc (note_size);
1027 cleanup = make_cleanup (xfree, contents);
1028 if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
1029 error (_("could not get core note contents"));
1031 descdata = contents;
1032 descend = descdata + note_size;
1034 if (descdata[note_size - 1] != '\0')
1035 error (_("malformed note - does not end with \\0"));
1037 count = bfd_get (addr_size_bits, core_bfd, descdata);
1038 descdata += addr_size;
1040 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1041 descdata += addr_size;
1043 if (note_size < 2 * addr_size + count * 3 * addr_size)
1044 error (_("malformed note - too short for supplied file count"));
1046 printf_filtered (_("Mapped address spaces:\n\n"));
1047 if (gdbarch_addr_bit (gdbarch) == 32)
1049 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1052 " Size", " Offset", "objfile");
1056 printf_filtered (" %18s %18s %10s %10s %s\n",
1059 " Size", " Offset", "objfile");
1062 filenames = descdata + count * 3 * addr_size;
1065 ULONGEST start, end, file_ofs;
1067 if (filenames == descend)
1068 error (_("malformed note - filenames end too early"));
1070 start = bfd_get (addr_size_bits, core_bfd, descdata);
1071 descdata += addr_size;
1072 end = bfd_get (addr_size_bits, core_bfd, descdata);
1073 descdata += addr_size;
1074 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1075 descdata += addr_size;
1077 file_ofs *= page_size;
1079 if (gdbarch_addr_bit (gdbarch) == 32)
1080 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1081 paddress (gdbarch, start),
1082 paddress (gdbarch, end),
1083 hex_string (end - start),
1084 hex_string (file_ofs),
1087 printf_filtered (" %18s %18s %10s %10s %s\n",
1088 paddress (gdbarch, start),
1089 paddress (gdbarch, end),
1090 hex_string (end - start),
1091 hex_string (file_ofs),
1094 filenames += 1 + strlen ((char *) filenames);
1097 do_cleanups (cleanup);
1100 /* Implement "info proc" for a corefile. */
1103 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1104 enum info_proc_what what)
1106 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1107 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1113 exe = bfd_core_file_failing_command (core_bfd);
1115 printf_filtered ("exe = '%s'\n", exe);
1117 warning (_("unable to find command name in core file"));
1121 linux_core_info_proc_mappings (gdbarch, args);
1123 if (!exe_f && !mappings_f)
1124 error (_("unable to handle request"));
1127 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1128 ULONGEST offset, ULONGEST inode,
1129 int read, int write,
1130 int exec, int modified,
1131 const char *filename,
1134 /* List memory regions in the inferior for a corefile. */
1137 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1138 linux_find_memory_region_ftype *func,
1141 char mapsfilename[100];
1142 char coredumpfilter_name[100];
1143 char *data, *coredumpfilterdata;
1145 /* Default dump behavior of coredump_filter (0x33), according to
1146 Documentation/filesystems/proc.txt from the Linux kernel
1148 filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1149 | COREFILTER_ANON_SHARED
1150 | COREFILTER_ELF_HEADERS
1151 | COREFILTER_HUGETLB_PRIVATE);
1153 /* We need to know the real target PID to access /proc. */
1154 if (current_inferior ()->fake_pid_p)
1157 pid = current_inferior ()->pid;
1159 if (use_coredump_filter)
1161 xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1162 "/proc/%d/coredump_filter", pid);
1163 coredumpfilterdata = target_fileio_read_stralloc (NULL,
1164 coredumpfilter_name);
1165 if (coredumpfilterdata != NULL)
1169 sscanf (coredumpfilterdata, "%x", &flags);
1170 filterflags = (enum filter_flag) flags;
1171 xfree (coredumpfilterdata);
1175 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1176 data = target_fileio_read_stralloc (NULL, mapsfilename);
1179 /* Older Linux kernels did not support /proc/PID/smaps. */
1180 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1181 data = target_fileio_read_stralloc (NULL, mapsfilename);
1186 struct cleanup *cleanup = make_cleanup (xfree, data);
1189 line = strtok_r (data, "\n", &t);
1190 while (line != NULL)
1192 ULONGEST addr, endaddr, offset, inode;
1193 const char *permissions, *device, *filename;
1194 struct smaps_vmflags v;
1195 size_t permissions_len, device_len;
1196 int read, write, exec, priv;
1197 int has_anonymous = 0;
1198 int should_dump_p = 0;
1202 memset (&v, 0, sizeof (v));
1203 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1204 &offset, &device, &device_len, &inode, &filename);
1205 mapping_anon_p = mapping_is_anonymous_p (filename);
1206 /* If the mapping is not anonymous, then we can consider it
1207 to be file-backed. These two states (anonymous or
1208 file-backed) seem to be exclusive, but they can actually
1209 coexist. For example, if a file-backed mapping has
1210 "Anonymous:" pages (see more below), then the Linux
1211 kernel will dump this mapping when the user specified
1212 that she only wants anonymous mappings in the corefile
1213 (*even* when she explicitly disabled the dumping of
1214 file-backed mappings). */
1215 mapping_file_p = !mapping_anon_p;
1217 /* Decode permissions. */
1218 read = (memchr (permissions, 'r', permissions_len) != 0);
1219 write = (memchr (permissions, 'w', permissions_len) != 0);
1220 exec = (memchr (permissions, 'x', permissions_len) != 0);
1221 /* 'private' here actually means VM_MAYSHARE, and not
1222 VM_SHARED. In order to know if a mapping is really
1223 private or not, we must check the flag "sh" in the
1224 VmFlags field. This is done by decode_vmflags. However,
1225 if we are using a Linux kernel released before the commit
1226 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1227 not have the VmFlags there. In this case, there is
1228 really no way to know if we are dealing with VM_SHARED,
1229 so we just assume that VM_MAYSHARE is enough. */
1230 priv = memchr (permissions, 'p', permissions_len) != 0;
1232 /* Try to detect if region should be dumped by parsing smaps
1234 for (line = strtok_r (NULL, "\n", &t);
1235 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1236 line = strtok_r (NULL, "\n", &t))
1238 char keyword[64 + 1];
1240 if (sscanf (line, "%64s", keyword) != 1)
1242 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1246 if (strcmp (keyword, "Anonymous:") == 0)
1248 /* Older Linux kernels did not support the
1249 "Anonymous:" counter. Check it here. */
1252 else if (strcmp (keyword, "VmFlags:") == 0)
1253 decode_vmflags (line, &v);
1255 if (strcmp (keyword, "AnonHugePages:") == 0
1256 || strcmp (keyword, "Anonymous:") == 0)
1258 unsigned long number;
1260 if (sscanf (line, "%*s%lu", &number) != 1)
1262 warning (_("Error parsing {s,}maps file '%s' number"),
1268 /* Even if we are dealing with a file-backed
1269 mapping, if it contains anonymous pages we
1270 consider it to be *also* an anonymous
1271 mapping, because this is what the Linux
1274 // Dump segments that have been written to.
1275 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1278 Note that if the mapping is already marked as
1279 file-backed (i.e., mapping_file_p is
1280 non-zero), then this is a special case, and
1281 this mapping will be dumped either when the
1282 user wants to dump file-backed *or* anonymous
1290 should_dump_p = dump_mapping_p (filterflags, &v, priv,
1291 mapping_anon_p, mapping_file_p,
1295 /* Older Linux kernels did not support the "Anonymous:" counter.
1296 If it is missing, we can't be sure - dump all the pages. */
1300 /* Invoke the callback function to create the corefile segment. */
1302 func (addr, endaddr - addr, offset, inode,
1303 read, write, exec, 1, /* MODIFIED is true because we
1304 want to dump the mapping. */
1308 do_cleanups (cleanup);
1315 /* A structure for passing information through
1316 linux_find_memory_regions_full. */
1318 struct linux_find_memory_regions_data
1320 /* The original callback. */
1322 find_memory_region_ftype func;
1324 /* The original datum. */
1329 /* A callback for linux_find_memory_regions that converts between the
1330 "full"-style callback and find_memory_region_ftype. */
1333 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1334 ULONGEST offset, ULONGEST inode,
1335 int read, int write, int exec, int modified,
1336 const char *filename, void *arg)
1338 struct linux_find_memory_regions_data *data
1339 = (struct linux_find_memory_regions_data *) arg;
1341 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1344 /* A variant of linux_find_memory_regions_full that is suitable as the
1345 gdbarch find_memory_regions method. */
1348 linux_find_memory_regions (struct gdbarch *gdbarch,
1349 find_memory_region_ftype func, void *obfd)
1351 struct linux_find_memory_regions_data data;
1356 return linux_find_memory_regions_full (gdbarch,
1357 linux_find_memory_regions_thunk,
1361 /* Determine which signal stopped execution. */
1364 find_signalled_thread (struct thread_info *info, void *data)
1366 if (info->suspend.stop_signal != GDB_SIGNAL_0
1367 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1373 /* Generate corefile notes for SPU contexts. */
1376 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1378 static const char *spu_files[] =
1400 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1404 /* Determine list of SPU ids. */
1405 size = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1408 /* Generate corefile notes for each SPU file. */
1409 for (i = 0; i < size; i += 4)
1411 int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1413 for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1415 char annex[32], note_name[32];
1419 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1420 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1424 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1425 note_data = elfcore_write_note (obfd, note_data, note_size,
1445 /* This is used to pass information from
1446 linux_make_mappings_corefile_notes through
1447 linux_find_memory_regions_full. */
1449 struct linux_make_mappings_data
1451 /* Number of files mapped. */
1452 ULONGEST file_count;
1454 /* The obstack for the main part of the data. */
1455 struct obstack *data_obstack;
1457 /* The filename obstack. */
1458 struct obstack *filename_obstack;
1460 /* The architecture's "long" type. */
1461 struct type *long_type;
1464 static linux_find_memory_region_ftype linux_make_mappings_callback;
1466 /* A callback for linux_find_memory_regions_full that updates the
1467 mappings data for linux_make_mappings_corefile_notes. */
1470 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1471 ULONGEST offset, ULONGEST inode,
1472 int read, int write, int exec, int modified,
1473 const char *filename, void *data)
1475 struct linux_make_mappings_data *map_data
1476 = (struct linux_make_mappings_data *) data;
1477 gdb_byte buf[sizeof (ULONGEST)];
1479 if (*filename == '\0' || inode == 0)
1482 ++map_data->file_count;
1484 pack_long (buf, map_data->long_type, vaddr);
1485 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1486 pack_long (buf, map_data->long_type, vaddr + size);
1487 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1488 pack_long (buf, map_data->long_type, offset);
1489 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1491 obstack_grow_str0 (map_data->filename_obstack, filename);
1496 /* Write the file mapping data to the core file, if possible. OBFD is
1497 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1498 is a pointer to the note size. Returns the new NOTE_DATA and
1499 updates NOTE_SIZE. */
1502 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1503 char *note_data, int *note_size)
1505 struct cleanup *cleanup;
1506 struct obstack data_obstack, filename_obstack;
1507 struct linux_make_mappings_data mapping_data;
1508 struct type *long_type
1509 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1510 gdb_byte buf[sizeof (ULONGEST)];
1512 obstack_init (&data_obstack);
1513 cleanup = make_cleanup_obstack_free (&data_obstack);
1514 obstack_init (&filename_obstack);
1515 make_cleanup_obstack_free (&filename_obstack);
1517 mapping_data.file_count = 0;
1518 mapping_data.data_obstack = &data_obstack;
1519 mapping_data.filename_obstack = &filename_obstack;
1520 mapping_data.long_type = long_type;
1522 /* Reserve space for the count. */
1523 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1524 /* We always write the page size as 1 since we have no good way to
1525 determine the correct value. */
1526 pack_long (buf, long_type, 1);
1527 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1529 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1532 if (mapping_data.file_count != 0)
1534 /* Write the count to the obstack. */
1535 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1536 long_type, mapping_data.file_count);
1538 /* Copy the filenames to the data obstack. */
1539 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1540 obstack_object_size (&filename_obstack));
1542 note_data = elfcore_write_note (obfd, note_data, note_size,
1544 obstack_base (&data_obstack),
1545 obstack_object_size (&data_obstack));
1548 do_cleanups (cleanup);
1552 /* Structure for passing information from
1553 linux_collect_thread_registers via an iterator to
1554 linux_collect_regset_section_cb. */
1556 struct linux_collect_regset_section_cb_data
1558 struct gdbarch *gdbarch;
1559 const struct regcache *regcache;
1564 enum gdb_signal stop_signal;
1565 int abort_iteration;
1568 /* Callback for iterate_over_regset_sections that records a single
1569 regset in the corefile note section. */
1572 linux_collect_regset_section_cb (const char *sect_name, int size,
1573 const struct regset *regset,
1574 const char *human_name, void *cb_data)
1577 struct linux_collect_regset_section_cb_data *data
1578 = (struct linux_collect_regset_section_cb_data *) cb_data;
1580 if (data->abort_iteration)
1583 gdb_assert (regset && regset->collect_regset);
1585 buf = (char *) xmalloc (size);
1586 regset->collect_regset (regset, data->regcache, -1, buf, size);
1588 /* PRSTATUS still needs to be treated specially. */
1589 if (strcmp (sect_name, ".reg") == 0)
1590 data->note_data = (char *) elfcore_write_prstatus
1591 (data->obfd, data->note_data, data->note_size, data->lwp,
1592 gdb_signal_to_host (data->stop_signal), buf);
1594 data->note_data = (char *) elfcore_write_register_note
1595 (data->obfd, data->note_data, data->note_size,
1596 sect_name, buf, size);
1599 if (data->note_data == NULL)
1600 data->abort_iteration = 1;
1603 /* Records the thread's register state for the corefile note
1607 linux_collect_thread_registers (const struct regcache *regcache,
1608 ptid_t ptid, bfd *obfd,
1609 char *note_data, int *note_size,
1610 enum gdb_signal stop_signal)
1612 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1613 struct linux_collect_regset_section_cb_data data;
1615 data.gdbarch = gdbarch;
1616 data.regcache = regcache;
1618 data.note_data = note_data;
1619 data.note_size = note_size;
1620 data.stop_signal = stop_signal;
1621 data.abort_iteration = 0;
1623 /* For remote targets the LWP may not be available, so use the TID. */
1624 data.lwp = ptid_get_lwp (ptid);
1626 data.lwp = ptid_get_tid (ptid);
1628 gdbarch_iterate_over_regset_sections (gdbarch,
1629 linux_collect_regset_section_cb,
1631 return data.note_data;
1634 /* Fetch the siginfo data for the current thread, if it exists. If
1635 there is no data, or we could not read it, return NULL. Otherwise,
1636 return a newly malloc'd buffer holding the data and fill in *SIZE
1637 with the size of the data. The caller is responsible for freeing
1641 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1643 struct type *siginfo_type;
1646 struct cleanup *cleanups;
1648 if (!gdbarch_get_siginfo_type_p (gdbarch))
1651 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1653 buf = (gdb_byte *) xmalloc (TYPE_LENGTH (siginfo_type));
1654 cleanups = make_cleanup (xfree, buf);
1656 bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1657 buf, 0, TYPE_LENGTH (siginfo_type));
1658 if (bytes_read == TYPE_LENGTH (siginfo_type))
1660 discard_cleanups (cleanups);
1665 do_cleanups (cleanups);
1672 struct linux_corefile_thread_data
1674 struct gdbarch *gdbarch;
1678 enum gdb_signal stop_signal;
1681 /* Records the thread's register state for the corefile note
1685 linux_corefile_thread (struct thread_info *info,
1686 struct linux_corefile_thread_data *args)
1688 struct cleanup *old_chain;
1689 struct regcache *regcache;
1690 gdb_byte *siginfo_data;
1691 LONGEST siginfo_size = 0;
1693 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1695 old_chain = save_inferior_ptid ();
1696 inferior_ptid = info->ptid;
1697 target_fetch_registers (regcache, -1);
1698 siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1699 do_cleanups (old_chain);
1701 old_chain = make_cleanup (xfree, siginfo_data);
1703 args->note_data = linux_collect_thread_registers
1704 (regcache, info->ptid, args->obfd, args->note_data,
1705 args->note_size, args->stop_signal);
1707 /* Don't return anything if we got no register information above,
1708 such a core file is useless. */
1709 if (args->note_data != NULL)
1710 if (siginfo_data != NULL)
1711 args->note_data = elfcore_write_note (args->obfd,
1715 siginfo_data, siginfo_size);
1717 do_cleanups (old_chain);
1720 /* Fill the PRPSINFO structure with information about the process being
1721 debugged. Returns 1 in case of success, 0 for failures. Please note that
1722 even if the structure cannot be entirely filled (e.g., GDB was unable to
1723 gather information about the process UID/GID), this function will still
1724 return 1 since some information was already recorded. It will only return
1725 0 iff nothing can be gathered. */
1728 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1730 /* The filename which we will use to obtain some info about the process.
1731 We will basically use this to store the `/proc/PID/FILENAME' file. */
1733 /* The full name of the program which generated the corefile. */
1735 /* The basename of the executable. */
1736 const char *basename;
1737 /* The arguments of the program. */
1740 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1741 char *proc_stat, *proc_status;
1742 /* Temporary buffer. */
1744 /* The valid states of a process, according to the Linux kernel. */
1745 const char valid_states[] = "RSDTZW";
1746 /* The program state. */
1747 const char *prog_state;
1748 /* The state of the process. */
1750 /* The PID of the program which generated the corefile. */
1752 /* Process flags. */
1753 unsigned int pr_flag;
1754 /* Process nice value. */
1756 /* The number of fields read by `sscanf'. */
1762 gdb_assert (p != NULL);
1764 /* Obtaining PID and filename. */
1765 pid = ptid_get_pid (inferior_ptid);
1766 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1767 fname = target_fileio_read_stralloc (NULL, filename);
1769 if (fname == NULL || *fname == '\0')
1771 /* No program name was read, so we won't be able to retrieve more
1772 information about the process. */
1777 c = make_cleanup (xfree, fname);
1778 memset (p, 0, sizeof (*p));
1780 /* Defining the PID. */
1783 /* Copying the program name. Only the basename matters. */
1784 basename = lbasename (fname);
1785 strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1786 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1788 infargs = get_inferior_args ();
1790 psargs = xstrdup (fname);
1791 if (infargs != NULL)
1792 psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1794 make_cleanup (xfree, psargs);
1796 strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1797 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1799 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1800 proc_stat = target_fileio_read_stralloc (NULL, filename);
1801 make_cleanup (xfree, proc_stat);
1803 if (proc_stat == NULL || *proc_stat == '\0')
1805 /* Despite being unable to read more information about the
1806 process, we return 1 here because at least we have its
1807 command line, PID and arguments. */
1812 /* Ok, we have the stats. It's time to do a little parsing of the
1813 contents of the buffer, so that we end up reading what we want.
1815 The following parsing mechanism is strongly based on the
1816 information generated by the `fs/proc/array.c' file, present in
1817 the Linux kernel tree. More details about how the information is
1818 displayed can be obtained by seeing the manpage of proc(5),
1819 specifically under the entry of `/proc/[pid]/stat'. */
1821 /* Getting rid of the PID, since we already have it. */
1822 while (isdigit (*proc_stat))
1825 proc_stat = skip_spaces (proc_stat);
1827 /* ps command also relies on no trailing fields ever contain ')'. */
1828 proc_stat = strrchr (proc_stat, ')');
1829 if (proc_stat == NULL)
1836 proc_stat = skip_spaces (proc_stat);
1838 n_fields = sscanf (proc_stat,
1839 "%c" /* Process state. */
1840 "%d%d%d" /* Parent PID, group ID, session ID. */
1841 "%*d%*d" /* tty_nr, tpgid (not used). */
1843 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1844 cmajflt (not used). */
1845 "%*s%*s%*s%*s" /* utime, stime, cutime,
1846 cstime (not used). */
1847 "%*s" /* Priority (not used). */
1850 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1856 /* Again, we couldn't read the complementary information about
1857 the process state. However, we already have minimal
1858 information, so we just return 1 here. */
1863 /* Filling the structure fields. */
1864 prog_state = strchr (valid_states, pr_sname);
1865 if (prog_state != NULL)
1866 p->pr_state = prog_state - valid_states;
1869 /* Zero means "Running". */
1873 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1874 p->pr_zomb = p->pr_sname == 'Z';
1875 p->pr_nice = pr_nice;
1876 p->pr_flag = pr_flag;
1878 /* Finally, obtaining the UID and GID. For that, we read and parse the
1879 contents of the `/proc/PID/status' file. */
1880 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1881 proc_status = target_fileio_read_stralloc (NULL, filename);
1882 make_cleanup (xfree, proc_status);
1884 if (proc_status == NULL || *proc_status == '\0')
1886 /* Returning 1 since we already have a bunch of information. */
1891 /* Extracting the UID. */
1892 tmpstr = strstr (proc_status, "Uid:");
1895 /* Advancing the pointer to the beginning of the UID. */
1896 tmpstr += sizeof ("Uid:");
1897 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1900 if (isdigit (*tmpstr))
1901 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1904 /* Extracting the GID. */
1905 tmpstr = strstr (proc_status, "Gid:");
1908 /* Advancing the pointer to the beginning of the GID. */
1909 tmpstr += sizeof ("Gid:");
1910 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1913 if (isdigit (*tmpstr))
1914 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1922 /* Build the note section for a corefile, and return it in a malloc
1926 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1928 struct linux_corefile_thread_data thread_args;
1929 struct elf_internal_linux_prpsinfo prpsinfo;
1930 char *note_data = NULL;
1933 struct thread_info *curr_thr, *signalled_thr, *thr;
1935 if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1938 if (linux_fill_prpsinfo (&prpsinfo))
1940 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1942 note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1943 note_data, note_size,
1948 if (gdbarch_ptr_bit (gdbarch) == 64)
1949 note_data = elfcore_write_linux_prpsinfo64 (obfd,
1950 note_data, note_size,
1953 note_data = elfcore_write_linux_prpsinfo32 (obfd,
1954 note_data, note_size,
1959 /* Thread register information. */
1962 update_thread_list ();
1964 CATCH (e, RETURN_MASK_ERROR)
1966 exception_print (gdb_stderr, e);
1970 /* Like the kernel, prefer dumping the signalled thread first.
1971 "First thread" is what tools use to infer the signalled thread.
1972 In case there's more than one signalled thread, prefer the
1973 current thread, if it is signalled. */
1974 curr_thr = inferior_thread ();
1975 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
1976 signalled_thr = curr_thr;
1979 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
1980 if (signalled_thr == NULL)
1981 signalled_thr = curr_thr;
1984 thread_args.gdbarch = gdbarch;
1985 thread_args.obfd = obfd;
1986 thread_args.note_data = note_data;
1987 thread_args.note_size = note_size;
1988 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
1990 linux_corefile_thread (signalled_thr, &thread_args);
1991 ALL_NON_EXITED_THREADS (thr)
1993 if (thr == signalled_thr)
1995 if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
1998 linux_corefile_thread (thr, &thread_args);
2001 note_data = thread_args.note_data;
2005 /* Auxillary vector. */
2006 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
2010 note_data = elfcore_write_note (obfd, note_data, note_size,
2011 "CORE", NT_AUXV, auxv, auxv_len);
2018 /* SPU information. */
2019 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
2023 /* File mappings. */
2024 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
2025 note_data, note_size);
2030 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2031 gdbarch.h. This function is not static because it is exported to
2032 other -tdep files. */
2035 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2040 return GDB_SIGNAL_0;
2043 return GDB_SIGNAL_HUP;
2046 return GDB_SIGNAL_INT;
2049 return GDB_SIGNAL_QUIT;
2052 return GDB_SIGNAL_ILL;
2055 return GDB_SIGNAL_TRAP;
2058 return GDB_SIGNAL_ABRT;
2061 return GDB_SIGNAL_BUS;
2064 return GDB_SIGNAL_FPE;
2067 return GDB_SIGNAL_KILL;
2070 return GDB_SIGNAL_USR1;
2073 return GDB_SIGNAL_SEGV;
2076 return GDB_SIGNAL_USR2;
2079 return GDB_SIGNAL_PIPE;
2082 return GDB_SIGNAL_ALRM;
2085 return GDB_SIGNAL_TERM;
2088 return GDB_SIGNAL_CHLD;
2091 return GDB_SIGNAL_CONT;
2094 return GDB_SIGNAL_STOP;
2097 return GDB_SIGNAL_TSTP;
2100 return GDB_SIGNAL_TTIN;
2103 return GDB_SIGNAL_TTOU;
2106 return GDB_SIGNAL_URG;
2109 return GDB_SIGNAL_XCPU;
2112 return GDB_SIGNAL_XFSZ;
2114 case LINUX_SIGVTALRM:
2115 return GDB_SIGNAL_VTALRM;
2118 return GDB_SIGNAL_PROF;
2120 case LINUX_SIGWINCH:
2121 return GDB_SIGNAL_WINCH;
2123 /* No way to differentiate between SIGIO and SIGPOLL.
2124 Therefore, we just handle the first one. */
2126 return GDB_SIGNAL_IO;
2129 return GDB_SIGNAL_PWR;
2132 return GDB_SIGNAL_SYS;
2134 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2135 therefore we have to handle them here. */
2136 case LINUX_SIGRTMIN:
2137 return GDB_SIGNAL_REALTIME_32;
2139 case LINUX_SIGRTMAX:
2140 return GDB_SIGNAL_REALTIME_64;
2143 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2145 int offset = signal - LINUX_SIGRTMIN + 1;
2147 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2150 return GDB_SIGNAL_UNKNOWN;
2153 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2154 gdbarch.h. This function is not static because it is exported to
2155 other -tdep files. */
2158 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2159 enum gdb_signal signal)
2166 case GDB_SIGNAL_HUP:
2167 return LINUX_SIGHUP;
2169 case GDB_SIGNAL_INT:
2170 return LINUX_SIGINT;
2172 case GDB_SIGNAL_QUIT:
2173 return LINUX_SIGQUIT;
2175 case GDB_SIGNAL_ILL:
2176 return LINUX_SIGILL;
2178 case GDB_SIGNAL_TRAP:
2179 return LINUX_SIGTRAP;
2181 case GDB_SIGNAL_ABRT:
2182 return LINUX_SIGABRT;
2184 case GDB_SIGNAL_FPE:
2185 return LINUX_SIGFPE;
2187 case GDB_SIGNAL_KILL:
2188 return LINUX_SIGKILL;
2190 case GDB_SIGNAL_BUS:
2191 return LINUX_SIGBUS;
2193 case GDB_SIGNAL_SEGV:
2194 return LINUX_SIGSEGV;
2196 case GDB_SIGNAL_SYS:
2197 return LINUX_SIGSYS;
2199 case GDB_SIGNAL_PIPE:
2200 return LINUX_SIGPIPE;
2202 case GDB_SIGNAL_ALRM:
2203 return LINUX_SIGALRM;
2205 case GDB_SIGNAL_TERM:
2206 return LINUX_SIGTERM;
2208 case GDB_SIGNAL_URG:
2209 return LINUX_SIGURG;
2211 case GDB_SIGNAL_STOP:
2212 return LINUX_SIGSTOP;
2214 case GDB_SIGNAL_TSTP:
2215 return LINUX_SIGTSTP;
2217 case GDB_SIGNAL_CONT:
2218 return LINUX_SIGCONT;
2220 case GDB_SIGNAL_CHLD:
2221 return LINUX_SIGCHLD;
2223 case GDB_SIGNAL_TTIN:
2224 return LINUX_SIGTTIN;
2226 case GDB_SIGNAL_TTOU:
2227 return LINUX_SIGTTOU;
2232 case GDB_SIGNAL_XCPU:
2233 return LINUX_SIGXCPU;
2235 case GDB_SIGNAL_XFSZ:
2236 return LINUX_SIGXFSZ;
2238 case GDB_SIGNAL_VTALRM:
2239 return LINUX_SIGVTALRM;
2241 case GDB_SIGNAL_PROF:
2242 return LINUX_SIGPROF;
2244 case GDB_SIGNAL_WINCH:
2245 return LINUX_SIGWINCH;
2247 case GDB_SIGNAL_USR1:
2248 return LINUX_SIGUSR1;
2250 case GDB_SIGNAL_USR2:
2251 return LINUX_SIGUSR2;
2253 case GDB_SIGNAL_PWR:
2254 return LINUX_SIGPWR;
2256 case GDB_SIGNAL_POLL:
2257 return LINUX_SIGPOLL;
2259 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2260 therefore we have to handle it here. */
2261 case GDB_SIGNAL_REALTIME_32:
2262 return LINUX_SIGRTMIN;
2264 /* Same comment applies to _64. */
2265 case GDB_SIGNAL_REALTIME_64:
2266 return LINUX_SIGRTMAX;
2269 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2270 if (signal >= GDB_SIGNAL_REALTIME_33
2271 && signal <= GDB_SIGNAL_REALTIME_63)
2273 int offset = signal - GDB_SIGNAL_REALTIME_33;
2275 return LINUX_SIGRTMIN + 1 + offset;
2281 /* Rummage through mappings to find a mapping's size. */
2284 find_mapping_size (CORE_ADDR vaddr, unsigned long size,
2285 int read, int write, int exec, int modified,
2288 struct mem_range *range = (struct mem_range *) data;
2290 if (vaddr == range->start)
2292 range->length = size;
2298 /* Helper for linux_vsyscall_range that does the real work of finding
2299 the vsyscall's address range. */
2302 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2304 if (target_auxv_search (¤t_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2307 /* This is installed by linux_init_abi below, so should always be
2309 gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2312 gdbarch_find_memory_regions (gdbarch, find_mapping_size, range);
2316 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2317 caching, and defers the real work to linux_vsyscall_range_raw. */
2320 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2322 struct linux_info *info = get_linux_inferior_data ();
2324 if (info->vsyscall_range_p == 0)
2326 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2327 info->vsyscall_range_p = 1;
2329 info->vsyscall_range_p = -1;
2332 if (info->vsyscall_range_p < 0)
2335 *range = info->vsyscall_range;
2339 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2340 definitions would be dependent on compilation host. */
2341 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2342 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2344 /* See gdbarch.sh 'infcall_mmap'. */
2347 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2349 struct objfile *objf;
2350 /* Do there still exist any Linux systems without "mmap64"?
2351 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2352 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2353 struct value *addr_val;
2354 struct gdbarch *gdbarch = get_objfile_arch (objf);
2358 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2360 struct value *arg[ARG_LAST];
2362 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2364 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2365 arg[ARG_LENGTH] = value_from_ulongest
2366 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2367 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2368 | GDB_MMAP_PROT_EXEC))
2370 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2371 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2372 GDB_MMAP_MAP_PRIVATE
2373 | GDB_MMAP_MAP_ANONYMOUS);
2374 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2375 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2377 addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
2378 retval = value_as_address (addr_val);
2379 if (retval == (CORE_ADDR) -1)
2380 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2385 /* See gdbarch.sh 'infcall_munmap'. */
2388 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2390 struct objfile *objf;
2391 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2392 struct value *retval_val;
2393 struct gdbarch *gdbarch = get_objfile_arch (objf);
2397 ARG_ADDR, ARG_LENGTH, ARG_LAST
2399 struct value *arg[ARG_LAST];
2401 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2403 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2404 arg[ARG_LENGTH] = value_from_ulongest
2405 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2406 retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
2407 retval = value_as_long (retval_val);
2409 warning (_("Failed inferior munmap call at %s for %s bytes, "
2410 "errno is changed."),
2411 hex_string (addr), pulongest (size));
2414 /* See linux-tdep.h. */
2417 linux_displaced_step_location (struct gdbarch *gdbarch)
2422 /* Determine entry point from target auxiliary vector. This avoids
2423 the need for symbols. Also, when debugging a stand-alone SPU
2424 executable, entry_point_address () will point to an SPU
2425 local-store address and is thus not usable as displaced stepping
2426 location. The auxiliary vector gets us the PowerPC-side entry
2427 point address instead. */
2428 if (target_auxv_search (¤t_target, AT_ENTRY, &addr) <= 0)
2429 throw_error (NOT_SUPPORTED_ERROR,
2430 _("Cannot find AT_ENTRY auxiliary vector entry."));
2432 /* Make certain that the address points at real code, and not a
2433 function descriptor. */
2434 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2437 /* Inferior calls also use the entry point as a breakpoint location.
2438 We don't want displaced stepping to interfere with those
2439 breakpoints, so leave space. */
2440 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2446 /* Display whether the gcore command is using the
2447 /proc/PID/coredump_filter file. */
2450 show_use_coredump_filter (struct ui_file *file, int from_tty,
2451 struct cmd_list_element *c, const char *value)
2453 fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2454 " corefiles is %s.\n"), value);
2457 /* To be called from the various GDB_OSABI_LINUX handlers for the
2458 various GNU/Linux architectures and machine types. */
2461 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2463 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2464 set_gdbarch_info_proc (gdbarch, linux_info_proc);
2465 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2466 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2467 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2468 set_gdbarch_has_shared_address_space (gdbarch,
2469 linux_has_shared_address_space);
2470 set_gdbarch_gdb_signal_from_target (gdbarch,
2471 linux_gdb_signal_from_target);
2472 set_gdbarch_gdb_signal_to_target (gdbarch,
2473 linux_gdb_signal_to_target);
2474 set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2475 set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2476 set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2477 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
2480 /* Provide a prototype to silence -Wmissing-prototypes. */
2481 extern initialize_file_ftype _initialize_linux_tdep;
2484 _initialize_linux_tdep (void)
2486 linux_gdbarch_data_handle =
2487 gdbarch_data_register_post_init (init_linux_gdbarch_data);
2489 /* Set a cache per-inferior. */
2491 = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2492 /* Observers used to invalidate the cache when needed. */
2493 observer_attach_inferior_exit (invalidate_linux_cache_inf);
2494 observer_attach_inferior_appeared (invalidate_linux_cache_inf);
2496 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2497 &use_coredump_filter, _("\
2498 Set whether gcore should consider /proc/PID/coredump_filter."),
2500 Show whether gcore should consider /proc/PID/coredump_filter."),
2502 Use this command to set whether gcore should consider the contents\n\
2503 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2504 about this file, refer to the manpage of core(5)."),
2505 NULL, show_use_coredump_filter,
2506 &setlist, &showlist);