1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2015 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"
43 /* This enum represents the values that the user can choose when
44 informing the Linux kernel about which memory mappings will be
45 dumped in a corefile. They are described in the file
46 Documentation/filesystems/proc.txt, inside the Linux kernel
51 COREFILTER_ANON_PRIVATE = 1 << 0,
52 COREFILTER_ANON_SHARED = 1 << 1,
53 COREFILTER_MAPPED_PRIVATE = 1 << 2,
54 COREFILTER_MAPPED_SHARED = 1 << 3,
55 COREFILTER_ELF_HEADERS = 1 << 4,
56 COREFILTER_HUGETLB_PRIVATE = 1 << 5,
57 COREFILTER_HUGETLB_SHARED = 1 << 6,
60 /* This struct is used to map flags found in the "VmFlags:" field (in
61 the /proc/<PID>/smaps file). */
65 /* Zero if this structure has not been initialized yet. It
66 probably means that the Linux kernel being used does not emit
67 the "VmFlags:" field on "/proc/PID/smaps". */
69 unsigned int initialized_p : 1;
71 /* Memory mapped I/O area (VM_IO, "io"). */
73 unsigned int io_page : 1;
75 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
77 unsigned int uses_huge_tlb : 1;
79 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
81 unsigned int exclude_coredump : 1;
83 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
85 unsigned int shared_mapping : 1;
88 /* Whether to take the /proc/PID/coredump_filter into account when
89 generating a corefile. */
91 static int use_coredump_filter = 1;
93 /* This enum represents the signals' numbers on a generic architecture
94 running the Linux kernel. The definition of "generic" comes from
95 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
96 tree, which is the "de facto" implementation of signal numbers to
97 be used by new architecture ports.
99 For those architectures which have differences between the generic
100 standard (e.g., Alpha), we define the different signals (and *only*
101 those) in the specific target-dependent file (e.g.,
102 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
103 tdep file for more information.
105 ARM deserves a special mention here. On the file
106 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
107 (and ARM-only) signal, which is SIGSWI, with the same number as
108 SIGRTMIN. This signal is used only for a very specific target,
109 called ArthurOS (from RISCOS). Therefore, we do not handle it on
110 the ARM-tdep file, and we can safely use the generic signal handler
111 here for ARM targets.
113 As stated above, this enum is derived from
114 <include/uapi/asm-generic/signal.h>, from the Linux kernel
135 LINUX_SIGSTKFLT = 16,
145 LINUX_SIGVTALRM = 26,
149 LINUX_SIGPOLL = LINUX_SIGIO,
152 LINUX_SIGUNUSED = 31,
158 static struct gdbarch_data *linux_gdbarch_data_handle;
160 struct linux_gdbarch_data
162 struct type *siginfo_type;
166 init_linux_gdbarch_data (struct gdbarch *gdbarch)
168 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
171 static struct linux_gdbarch_data *
172 get_linux_gdbarch_data (struct gdbarch *gdbarch)
174 return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
177 /* Per-inferior data key. */
178 static const struct inferior_data *linux_inferior_data;
180 /* Linux-specific cached data. This is used by GDB for caching
181 purposes for each inferior. This helps reduce the overhead of
182 transfering data from a remote target to the local host. */
185 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
186 if VSYSCALL_RANGE_P is positive. This is cached because getting
187 at this info requires an auxv lookup (which is itself cached),
188 and looking through the inferior's mappings (which change
189 throughout execution and therefore cannot be cached). */
190 struct mem_range vsyscall_range;
192 /* Zero if we haven't tried looking up the vsyscall's range before
193 yet. Positive if we tried looking it up, and found it. Negative
194 if we tried looking it up but failed. */
195 int vsyscall_range_p;
198 /* Frees whatever allocated space there is to be freed and sets INF's
199 linux cache data pointer to NULL. */
202 invalidate_linux_cache_inf (struct inferior *inf)
204 struct linux_info *info;
206 info = inferior_data (inf, linux_inferior_data);
210 set_inferior_data (inf, linux_inferior_data, NULL);
214 /* Handles the cleanup of the linux cache for inferior INF. ARG is
215 ignored. Callback for the inferior_appeared and inferior_exit
219 linux_inferior_data_cleanup (struct inferior *inf, void *arg)
221 invalidate_linux_cache_inf (inf);
224 /* Fetch the linux cache info for INF. This function always returns a
225 valid INFO pointer. */
227 static struct linux_info *
228 get_linux_inferior_data (void)
230 struct linux_info *info;
231 struct inferior *inf = current_inferior ();
233 info = inferior_data (inf, linux_inferior_data);
236 info = XCNEW (struct linux_info);
237 set_inferior_data (inf, linux_inferior_data, info);
243 /* This function is suitable for architectures that don't
244 extend/override the standard siginfo structure. */
247 linux_get_siginfo_type (struct gdbarch *gdbarch)
249 struct linux_gdbarch_data *linux_gdbarch_data;
250 struct type *int_type, *uint_type, *long_type, *void_ptr_type;
251 struct type *uid_type, *pid_type;
252 struct type *sigval_type, *clock_type;
253 struct type *siginfo_type, *sifields_type;
256 linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
257 if (linux_gdbarch_data->siginfo_type != NULL)
258 return linux_gdbarch_data->siginfo_type;
260 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
262 uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
264 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
266 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
269 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
270 TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
271 append_composite_type_field (sigval_type, "sival_int", int_type);
272 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
275 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
276 TYPE_LENGTH (int_type), "__pid_t");
277 TYPE_TARGET_TYPE (pid_type) = int_type;
278 TYPE_TARGET_STUB (pid_type) = 1;
281 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
282 TYPE_LENGTH (uint_type), "__uid_t");
283 TYPE_TARGET_TYPE (uid_type) = uint_type;
284 TYPE_TARGET_STUB (uid_type) = 1;
287 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
288 TYPE_LENGTH (long_type), "__clock_t");
289 TYPE_TARGET_TYPE (clock_type) = long_type;
290 TYPE_TARGET_STUB (clock_type) = 1;
293 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
296 const int si_max_size = 128;
298 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
301 if (gdbarch_ptr_bit (gdbarch) == 64)
302 si_pad_size = (si_max_size / size_of_int) - 4;
304 si_pad_size = (si_max_size / size_of_int) - 3;
305 append_composite_type_field (sifields_type, "_pad",
306 init_vector_type (int_type, si_pad_size));
310 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
311 append_composite_type_field (type, "si_pid", pid_type);
312 append_composite_type_field (type, "si_uid", uid_type);
313 append_composite_type_field (sifields_type, "_kill", type);
316 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
317 append_composite_type_field (type, "si_tid", int_type);
318 append_composite_type_field (type, "si_overrun", int_type);
319 append_composite_type_field (type, "si_sigval", sigval_type);
320 append_composite_type_field (sifields_type, "_timer", type);
323 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
324 append_composite_type_field (type, "si_pid", pid_type);
325 append_composite_type_field (type, "si_uid", uid_type);
326 append_composite_type_field (type, "si_sigval", sigval_type);
327 append_composite_type_field (sifields_type, "_rt", type);
330 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
331 append_composite_type_field (type, "si_pid", pid_type);
332 append_composite_type_field (type, "si_uid", uid_type);
333 append_composite_type_field (type, "si_status", int_type);
334 append_composite_type_field (type, "si_utime", clock_type);
335 append_composite_type_field (type, "si_stime", clock_type);
336 append_composite_type_field (sifields_type, "_sigchld", type);
339 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
340 append_composite_type_field (type, "si_addr", void_ptr_type);
341 append_composite_type_field (sifields_type, "_sigfault", type);
344 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
345 append_composite_type_field (type, "si_band", long_type);
346 append_composite_type_field (type, "si_fd", int_type);
347 append_composite_type_field (sifields_type, "_sigpoll", type);
350 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
351 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
352 append_composite_type_field (siginfo_type, "si_signo", int_type);
353 append_composite_type_field (siginfo_type, "si_errno", int_type);
354 append_composite_type_field (siginfo_type, "si_code", int_type);
355 append_composite_type_field_aligned (siginfo_type,
356 "_sifields", sifields_type,
357 TYPE_LENGTH (long_type));
359 linux_gdbarch_data->siginfo_type = siginfo_type;
364 /* Return true if the target is running on uClinux instead of normal
368 linux_is_uclinux (void)
372 return (target_auxv_search (¤t_target, AT_NULL, &dummy) > 0
373 && target_auxv_search (¤t_target, AT_PAGESZ, &dummy) == 0);
377 linux_has_shared_address_space (struct gdbarch *gdbarch)
379 return linux_is_uclinux ();
382 /* This is how we want PTIDs from core files to be printed. */
385 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
389 if (ptid_get_lwp (ptid) != 0)
391 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
395 return normal_pid_to_str (ptid);
398 /* Service function for corefiles and info proc. */
401 read_mapping (const char *line,
402 ULONGEST *addr, ULONGEST *endaddr,
403 const char **permissions, size_t *permissions_len,
405 const char **device, size_t *device_len,
407 const char **filename)
409 const char *p = line;
411 *addr = strtoulst (p, &p, 16);
414 *endaddr = strtoulst (p, &p, 16);
416 p = skip_spaces_const (p);
418 while (*p && !isspace (*p))
420 *permissions_len = p - *permissions;
422 *offset = strtoulst (p, &p, 16);
424 p = skip_spaces_const (p);
426 while (*p && !isspace (*p))
428 *device_len = p - *device;
430 *inode = strtoulst (p, &p, 10);
432 p = skip_spaces_const (p);
436 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
438 This function was based on the documentation found on
439 <Documentation/filesystems/proc.txt>, on the Linux kernel.
441 Linux kernels before commit
442 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
446 decode_vmflags (char *p, struct smaps_vmflags *v)
448 char *saveptr = NULL;
451 v->initialized_p = 1;
452 p = skip_to_space (p);
455 for (s = strtok_r (p, " ", &saveptr);
457 s = strtok_r (NULL, " ", &saveptr))
459 if (strcmp (s, "io") == 0)
461 else if (strcmp (s, "ht") == 0)
462 v->uses_huge_tlb = 1;
463 else if (strcmp (s, "dd") == 0)
464 v->exclude_coredump = 1;
465 else if (strcmp (s, "sh") == 0)
466 v->shared_mapping = 1;
470 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
472 FILENAME is the name of the file present in the first line of the
473 memory mapping, in the "/proc/PID/smaps" output. For example, if
476 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
478 Then FILENAME will be "/path/to/file". */
481 mapping_is_anonymous_p (const char *filename)
483 static regex_t dev_zero_regex, shmem_file_regex, file_deleted_regex;
484 static int init_regex_p = 0;
488 struct cleanup *c = make_cleanup (null_cleanup, NULL);
490 /* Let's be pessimistic and assume there will be an error while
491 compiling the regex'es. */
494 /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
495 without the "(deleted)" string in the end). We know for
496 sure, based on the Linux kernel code, that memory mappings
497 whose associated filename is "/dev/zero" are guaranteed to be
499 compile_rx_or_error (&dev_zero_regex, "^/dev/zero\\( (deleted)\\)\\?$",
500 _("Could not compile regex to match /dev/zero "
502 /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
503 without the "(deleted)" string in the end). These filenames
504 refer to shared memory (shmem), and memory mappings
505 associated with them are MAP_ANONYMOUS as well. */
506 compile_rx_or_error (&shmem_file_regex,
507 "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
508 _("Could not compile regex to match shmem "
510 /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
511 Linux kernel's 'n_link == 0' code, which is responsible to
512 decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
513 mapping. In other words, if FILE_DELETED_REGEX matches, it
514 does not necessarily mean that we are dealing with an
515 anonymous shared mapping. However, there is no easy way to
516 detect this currently, so this is the best approximation we
519 As a result, GDB will dump readonly pages of deleted
520 executables when using the default value of coredump_filter
521 (0x33), while the Linux kernel will not dump those pages.
522 But we can live with that. */
523 compile_rx_or_error (&file_deleted_regex, " (deleted)$",
524 _("Could not compile regex to match "
525 "'<file> (deleted)'"));
526 /* We will never release these regexes, so just discard the
528 discard_cleanups (c);
530 /* If we reached this point, then everything succeeded. */
534 if (init_regex_p == -1)
536 const char deleted[] = " (deleted)";
537 size_t del_len = sizeof (deleted) - 1;
538 size_t filename_len = strlen (filename);
540 /* There was an error while compiling the regex'es above. In
541 order to try to give some reliable information to the caller,
542 we just try to find the string " (deleted)" in the filename.
543 If we managed to find it, then we assume the mapping is
545 return (filename_len >= del_len
546 && strcmp (filename + filename_len - del_len, deleted) == 0);
549 if (*filename == '\0'
550 || regexec (&dev_zero_regex, filename, 0, NULL, 0) == 0
551 || regexec (&shmem_file_regex, filename, 0, NULL, 0) == 0
552 || regexec (&file_deleted_regex, filename, 0, NULL, 0) == 0)
558 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
559 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
560 greater than 0 if it should.
562 In a nutshell, this is the logic that we follow in order to decide
563 if a mapping should be dumped or not.
565 - If the mapping is associated to a file whose name ends with
566 " (deleted)", or if the file is "/dev/zero", or if it is
567 "/SYSV%08x" (shared memory), or if there is no file associated
568 with it, or if the AnonHugePages: or the Anonymous: fields in the
569 /proc/PID/smaps have contents, then GDB considers this mapping to
570 be anonymous. Otherwise, GDB considers this mapping to be a
571 file-backed mapping (because there will be a file associated with
574 It is worth mentioning that, from all those checks described
575 above, the most fragile is the one to see if the file name ends
576 with " (deleted)". This does not necessarily mean that the
577 mapping is anonymous, because the deleted file associated with
578 the mapping may have been a hard link to another file, for
579 example. The Linux kernel checks to see if "i_nlink == 0", but
580 GDB cannot easily (and normally) do this check (iff running as
581 root, it could find the mapping in /proc/PID/map_files/ and
582 determine whether there still are other hard links to the
583 inode/file). Therefore, we made a compromise here, and we assume
584 that if the file name ends with " (deleted)", then the mapping is
585 indeed anonymous. FWIW, this is something the Linux kernel could
586 do better: expose this information in a more direct way.
588 - If we see the flag "sh" in the "VmFlags:" field (in
589 /proc/PID/smaps), then certainly the memory mapping is shared
590 (VM_SHARED). If we have access to the VmFlags, and we don't see
591 the "sh" there, then certainly the mapping is private. However,
592 Linux kernels before commit
593 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
594 "VmFlags:" field; in that case, we use another heuristic: if we
595 see 'p' in the permission flags, then we assume that the mapping
596 is private, even though the presence of the 's' flag there would
597 mean VM_MAYSHARE, which means the mapping could still be private.
598 This should work OK enough, however. */
601 dump_mapping_p (enum filterflags filterflags, const struct smaps_vmflags *v,
602 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
603 const char *filename)
605 /* Initially, we trust in what we received from our caller. This
606 value may not be very precise (i.e., it was probably gathered
607 from the permission line in the /proc/PID/smaps list, which
608 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
609 what we have until we take a look at the "VmFlags:" field
610 (assuming that the version of the Linux kernel being used
611 supports it, of course). */
612 int private_p = maybe_private_p;
614 /* We always dump vDSO and vsyscall mappings, because it's likely that
615 there'll be no file to read the contents from at core load time.
616 The kernel does the same. */
617 if (strcmp ("[vdso]", filename) == 0
618 || strcmp ("[vsyscall]", filename) == 0)
621 if (v->initialized_p)
623 /* We never dump I/O mappings. */
627 /* Check if we should exclude this mapping. */
628 if (v->exclude_coredump)
631 /* Update our notion of whether this mapping is shared or
632 private based on a trustworthy value. */
633 private_p = !v->shared_mapping;
635 /* HugeTLB checking. */
636 if (v->uses_huge_tlb)
638 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
639 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
648 if (mapping_anon_p && mapping_file_p)
650 /* This is a special situation. It can happen when we see a
651 mapping that is file-backed, but that contains anonymous
653 return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
654 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
656 else if (mapping_anon_p)
657 return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
659 return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
663 if (mapping_anon_p && mapping_file_p)
665 /* This is a special situation. It can happen when we see a
666 mapping that is file-backed, but that contains anonymous
668 return ((filterflags & COREFILTER_ANON_SHARED) != 0
669 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
671 else if (mapping_anon_p)
672 return (filterflags & COREFILTER_ANON_SHARED) != 0;
674 return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
678 /* Implement the "info proc" command. */
681 linux_info_proc (struct gdbarch *gdbarch, const char *args,
682 enum info_proc_what what)
684 /* A long is used for pid instead of an int to avoid a loss of precision
685 compiler warning from the output of strtoul. */
687 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
688 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
689 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
690 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
691 int status_f = (what == IP_STATUS || what == IP_ALL);
692 int stat_f = (what == IP_STAT || what == IP_ALL);
697 if (args && isdigit (args[0]))
701 pid = strtoul (args, &tem, 10);
706 if (!target_has_execution)
707 error (_("No current process: you must name one."));
708 if (current_inferior ()->fake_pid_p)
709 error (_("Can't determine the current process's PID: you must name one."));
711 pid = current_inferior ()->pid;
714 args = skip_spaces_const (args);
716 error (_("Too many parameters: %s"), args);
718 printf_filtered (_("process %ld\n"), pid);
721 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
722 data = target_fileio_read_stralloc (NULL, filename);
725 struct cleanup *cleanup = make_cleanup (xfree, data);
726 printf_filtered ("cmdline = '%s'\n", data);
727 do_cleanups (cleanup);
730 warning (_("unable to open /proc file '%s'"), filename);
734 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
735 data = target_fileio_readlink (NULL, filename, &target_errno);
738 struct cleanup *cleanup = make_cleanup (xfree, data);
739 printf_filtered ("cwd = '%s'\n", data);
740 do_cleanups (cleanup);
743 warning (_("unable to read link '%s'"), filename);
747 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
748 data = target_fileio_readlink (NULL, filename, &target_errno);
751 struct cleanup *cleanup = make_cleanup (xfree, data);
752 printf_filtered ("exe = '%s'\n", data);
753 do_cleanups (cleanup);
756 warning (_("unable to read link '%s'"), filename);
760 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
761 data = target_fileio_read_stralloc (NULL, filename);
764 struct cleanup *cleanup = make_cleanup (xfree, data);
767 printf_filtered (_("Mapped address spaces:\n\n"));
768 if (gdbarch_addr_bit (gdbarch) == 32)
770 printf_filtered ("\t%10s %10s %10s %10s %s\n",
773 " Size", " Offset", "objfile");
777 printf_filtered (" %18s %18s %10s %10s %s\n",
780 " Size", " Offset", "objfile");
783 for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
785 ULONGEST addr, endaddr, offset, inode;
786 const char *permissions, *device, *filename;
787 size_t permissions_len, device_len;
789 read_mapping (line, &addr, &endaddr,
790 &permissions, &permissions_len,
791 &offset, &device, &device_len,
794 if (gdbarch_addr_bit (gdbarch) == 32)
796 printf_filtered ("\t%10s %10s %10s %10s %s\n",
797 paddress (gdbarch, addr),
798 paddress (gdbarch, endaddr),
799 hex_string (endaddr - addr),
801 *filename? filename : "");
805 printf_filtered (" %18s %18s %10s %10s %s\n",
806 paddress (gdbarch, addr),
807 paddress (gdbarch, endaddr),
808 hex_string (endaddr - addr),
810 *filename? filename : "");
814 do_cleanups (cleanup);
817 warning (_("unable to open /proc file '%s'"), filename);
821 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
822 data = target_fileio_read_stralloc (NULL, filename);
825 struct cleanup *cleanup = make_cleanup (xfree, data);
826 puts_filtered (data);
827 do_cleanups (cleanup);
830 warning (_("unable to open /proc file '%s'"), filename);
834 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
835 data = target_fileio_read_stralloc (NULL, filename);
838 struct cleanup *cleanup = make_cleanup (xfree, data);
839 const char *p = data;
841 printf_filtered (_("Process: %s\n"),
842 pulongest (strtoulst (p, &p, 10)));
844 p = skip_spaces_const (p);
847 /* ps command also relies on no trailing fields
849 const char *ep = strrchr (p, ')');
852 printf_filtered ("Exec file: %.*s\n",
853 (int) (ep - p - 1), p + 1);
858 p = skip_spaces_const (p);
860 printf_filtered (_("State: %c\n"), *p++);
863 printf_filtered (_("Parent process: %s\n"),
864 pulongest (strtoulst (p, &p, 10)));
866 printf_filtered (_("Process group: %s\n"),
867 pulongest (strtoulst (p, &p, 10)));
869 printf_filtered (_("Session id: %s\n"),
870 pulongest (strtoulst (p, &p, 10)));
872 printf_filtered (_("TTY: %s\n"),
873 pulongest (strtoulst (p, &p, 10)));
875 printf_filtered (_("TTY owner process group: %s\n"),
876 pulongest (strtoulst (p, &p, 10)));
879 printf_filtered (_("Flags: %s\n"),
880 hex_string (strtoulst (p, &p, 10)));
882 printf_filtered (_("Minor faults (no memory page): %s\n"),
883 pulongest (strtoulst (p, &p, 10)));
885 printf_filtered (_("Minor faults, children: %s\n"),
886 pulongest (strtoulst (p, &p, 10)));
888 printf_filtered (_("Major faults (memory page faults): %s\n"),
889 pulongest (strtoulst (p, &p, 10)));
891 printf_filtered (_("Major faults, children: %s\n"),
892 pulongest (strtoulst (p, &p, 10)));
894 printf_filtered (_("utime: %s\n"),
895 pulongest (strtoulst (p, &p, 10)));
897 printf_filtered (_("stime: %s\n"),
898 pulongest (strtoulst (p, &p, 10)));
900 printf_filtered (_("utime, children: %s\n"),
901 pulongest (strtoulst (p, &p, 10)));
903 printf_filtered (_("stime, children: %s\n"),
904 pulongest (strtoulst (p, &p, 10)));
906 printf_filtered (_("jiffies remaining in current "
908 pulongest (strtoulst (p, &p, 10)));
910 printf_filtered (_("'nice' value: %s\n"),
911 pulongest (strtoulst (p, &p, 10)));
913 printf_filtered (_("jiffies until next timeout: %s\n"),
914 pulongest (strtoulst (p, &p, 10)));
916 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
917 pulongest (strtoulst (p, &p, 10)));
919 printf_filtered (_("start time (jiffies since "
920 "system boot): %s\n"),
921 pulongest (strtoulst (p, &p, 10)));
923 printf_filtered (_("Virtual memory size: %s\n"),
924 pulongest (strtoulst (p, &p, 10)));
926 printf_filtered (_("Resident set size: %s\n"),
927 pulongest (strtoulst (p, &p, 10)));
929 printf_filtered (_("rlim: %s\n"),
930 pulongest (strtoulst (p, &p, 10)));
932 printf_filtered (_("Start of text: %s\n"),
933 hex_string (strtoulst (p, &p, 10)));
935 printf_filtered (_("End of text: %s\n"),
936 hex_string (strtoulst (p, &p, 10)));
938 printf_filtered (_("Start of stack: %s\n"),
939 hex_string (strtoulst (p, &p, 10)));
940 #if 0 /* Don't know how architecture-dependent the rest is...
941 Anyway the signal bitmap info is available from "status". */
943 printf_filtered (_("Kernel stack pointer: %s\n"),
944 hex_string (strtoulst (p, &p, 10)));
946 printf_filtered (_("Kernel instr pointer: %s\n"),
947 hex_string (strtoulst (p, &p, 10)));
949 printf_filtered (_("Pending signals bitmap: %s\n"),
950 hex_string (strtoulst (p, &p, 10)));
952 printf_filtered (_("Blocked signals bitmap: %s\n"),
953 hex_string (strtoulst (p, &p, 10)));
955 printf_filtered (_("Ignored signals bitmap: %s\n"),
956 hex_string (strtoulst (p, &p, 10)));
958 printf_filtered (_("Catched signals bitmap: %s\n"),
959 hex_string (strtoulst (p, &p, 10)));
961 printf_filtered (_("wchan (system call): %s\n"),
962 hex_string (strtoulst (p, &p, 10)));
964 do_cleanups (cleanup);
967 warning (_("unable to open /proc file '%s'"), filename);
971 /* Implement "info proc mappings" for a corefile. */
974 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
977 ULONGEST count, page_size;
978 unsigned char *descdata, *filenames, *descend, *contents;
980 unsigned int addr_size_bits, addr_size;
981 struct cleanup *cleanup;
982 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
983 /* We assume this for reading 64-bit core files. */
984 gdb_static_assert (sizeof (ULONGEST) >= 8);
986 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
989 warning (_("unable to find mappings in core file"));
993 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
994 addr_size = addr_size_bits / 8;
995 note_size = bfd_get_section_size (section);
997 if (note_size < 2 * addr_size)
998 error (_("malformed core note - too short for header"));
1000 contents = xmalloc (note_size);
1001 cleanup = make_cleanup (xfree, contents);
1002 if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
1003 error (_("could not get core note contents"));
1005 descdata = contents;
1006 descend = descdata + note_size;
1008 if (descdata[note_size - 1] != '\0')
1009 error (_("malformed note - does not end with \\0"));
1011 count = bfd_get (addr_size_bits, core_bfd, descdata);
1012 descdata += addr_size;
1014 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1015 descdata += addr_size;
1017 if (note_size < 2 * addr_size + count * 3 * addr_size)
1018 error (_("malformed note - too short for supplied file count"));
1020 printf_filtered (_("Mapped address spaces:\n\n"));
1021 if (gdbarch_addr_bit (gdbarch) == 32)
1023 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1026 " Size", " Offset", "objfile");
1030 printf_filtered (" %18s %18s %10s %10s %s\n",
1033 " Size", " Offset", "objfile");
1036 filenames = descdata + count * 3 * addr_size;
1039 ULONGEST start, end, file_ofs;
1041 if (filenames == descend)
1042 error (_("malformed note - filenames end too early"));
1044 start = bfd_get (addr_size_bits, core_bfd, descdata);
1045 descdata += addr_size;
1046 end = bfd_get (addr_size_bits, core_bfd, descdata);
1047 descdata += addr_size;
1048 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1049 descdata += addr_size;
1051 file_ofs *= page_size;
1053 if (gdbarch_addr_bit (gdbarch) == 32)
1054 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1055 paddress (gdbarch, start),
1056 paddress (gdbarch, end),
1057 hex_string (end - start),
1058 hex_string (file_ofs),
1061 printf_filtered (" %18s %18s %10s %10s %s\n",
1062 paddress (gdbarch, start),
1063 paddress (gdbarch, end),
1064 hex_string (end - start),
1065 hex_string (file_ofs),
1068 filenames += 1 + strlen ((char *) filenames);
1071 do_cleanups (cleanup);
1074 /* Implement "info proc" for a corefile. */
1077 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1078 enum info_proc_what what)
1080 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1081 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1087 exe = bfd_core_file_failing_command (core_bfd);
1089 printf_filtered ("exe = '%s'\n", exe);
1091 warning (_("unable to find command name in core file"));
1095 linux_core_info_proc_mappings (gdbarch, args);
1097 if (!exe_f && !mappings_f)
1098 error (_("unable to handle request"));
1101 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1102 ULONGEST offset, ULONGEST inode,
1103 int read, int write,
1104 int exec, int modified,
1105 const char *filename,
1108 /* List memory regions in the inferior for a corefile. */
1111 linux_find_memory_regions_full (struct gdbarch *gdbarch,
1112 linux_find_memory_region_ftype *func,
1115 char mapsfilename[100];
1116 char coredumpfilter_name[100];
1117 char *data, *coredumpfilterdata;
1119 /* Default dump behavior of coredump_filter (0x33), according to
1120 Documentation/filesystems/proc.txt from the Linux kernel
1122 enum filterflags filterflags = (COREFILTER_ANON_PRIVATE
1123 | COREFILTER_ANON_SHARED
1124 | COREFILTER_ELF_HEADERS
1125 | COREFILTER_HUGETLB_PRIVATE);
1127 /* We need to know the real target PID to access /proc. */
1128 if (current_inferior ()->fake_pid_p)
1131 pid = current_inferior ()->pid;
1133 if (use_coredump_filter)
1135 xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1136 "/proc/%d/coredump_filter", pid);
1137 coredumpfilterdata = target_fileio_read_stralloc (NULL,
1138 coredumpfilter_name);
1139 if (coredumpfilterdata != NULL)
1141 sscanf (coredumpfilterdata, "%x", &filterflags);
1142 xfree (coredumpfilterdata);
1146 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1147 data = target_fileio_read_stralloc (NULL, mapsfilename);
1150 /* Older Linux kernels did not support /proc/PID/smaps. */
1151 xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1152 data = target_fileio_read_stralloc (NULL, mapsfilename);
1157 struct cleanup *cleanup = make_cleanup (xfree, data);
1160 line = strtok_r (data, "\n", &t);
1161 while (line != NULL)
1163 ULONGEST addr, endaddr, offset, inode;
1164 const char *permissions, *device, *filename;
1165 struct smaps_vmflags v;
1166 size_t permissions_len, device_len;
1167 int read, write, exec, priv;
1168 int has_anonymous = 0;
1169 int should_dump_p = 0;
1173 memset (&v, 0, sizeof (v));
1174 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1175 &offset, &device, &device_len, &inode, &filename);
1176 mapping_anon_p = mapping_is_anonymous_p (filename);
1177 /* If the mapping is not anonymous, then we can consider it
1178 to be file-backed. These two states (anonymous or
1179 file-backed) seem to be exclusive, but they can actually
1180 coexist. For example, if a file-backed mapping has
1181 "Anonymous:" pages (see more below), then the Linux
1182 kernel will dump this mapping when the user specified
1183 that she only wants anonymous mappings in the corefile
1184 (*even* when she explicitly disabled the dumping of
1185 file-backed mappings). */
1186 mapping_file_p = !mapping_anon_p;
1188 /* Decode permissions. */
1189 read = (memchr (permissions, 'r', permissions_len) != 0);
1190 write = (memchr (permissions, 'w', permissions_len) != 0);
1191 exec = (memchr (permissions, 'x', permissions_len) != 0);
1192 /* 'private' here actually means VM_MAYSHARE, and not
1193 VM_SHARED. In order to know if a mapping is really
1194 private or not, we must check the flag "sh" in the
1195 VmFlags field. This is done by decode_vmflags. However,
1196 if we are using a Linux kernel released before the commit
1197 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1198 not have the VmFlags there. In this case, there is
1199 really no way to know if we are dealing with VM_SHARED,
1200 so we just assume that VM_MAYSHARE is enough. */
1201 priv = memchr (permissions, 'p', permissions_len) != 0;
1203 /* Try to detect if region should be dumped by parsing smaps
1205 for (line = strtok_r (NULL, "\n", &t);
1206 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1207 line = strtok_r (NULL, "\n", &t))
1209 char keyword[64 + 1];
1211 if (sscanf (line, "%64s", keyword) != 1)
1213 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1217 if (strcmp (keyword, "Anonymous:") == 0)
1219 /* Older Linux kernels did not support the
1220 "Anonymous:" counter. Check it here. */
1223 else if (strcmp (keyword, "VmFlags:") == 0)
1224 decode_vmflags (line, &v);
1226 if (strcmp (keyword, "AnonHugePages:") == 0
1227 || strcmp (keyword, "Anonymous:") == 0)
1229 unsigned long number;
1231 if (sscanf (line, "%*s%lu", &number) != 1)
1233 warning (_("Error parsing {s,}maps file '%s' number"),
1239 /* Even if we are dealing with a file-backed
1240 mapping, if it contains anonymous pages we
1241 consider it to be *also* an anonymous
1242 mapping, because this is what the Linux
1245 // Dump segments that have been written to.
1246 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1249 Note that if the mapping is already marked as
1250 file-backed (i.e., mapping_file_p is
1251 non-zero), then this is a special case, and
1252 this mapping will be dumped either when the
1253 user wants to dump file-backed *or* anonymous
1261 should_dump_p = dump_mapping_p (filterflags, &v, priv,
1262 mapping_anon_p, mapping_file_p,
1266 /* Older Linux kernels did not support the "Anonymous:" counter.
1267 If it is missing, we can't be sure - dump all the pages. */
1271 /* Invoke the callback function to create the corefile segment. */
1273 func (addr, endaddr - addr, offset, inode,
1274 read, write, exec, 1, /* MODIFIED is true because we
1275 want to dump the mapping. */
1279 do_cleanups (cleanup);
1286 /* A structure for passing information through
1287 linux_find_memory_regions_full. */
1289 struct linux_find_memory_regions_data
1291 /* The original callback. */
1293 find_memory_region_ftype func;
1295 /* The original datum. */
1300 /* A callback for linux_find_memory_regions that converts between the
1301 "full"-style callback and find_memory_region_ftype. */
1304 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1305 ULONGEST offset, ULONGEST inode,
1306 int read, int write, int exec, int modified,
1307 const char *filename, void *arg)
1309 struct linux_find_memory_regions_data *data = arg;
1311 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1314 /* A variant of linux_find_memory_regions_full that is suitable as the
1315 gdbarch find_memory_regions method. */
1318 linux_find_memory_regions (struct gdbarch *gdbarch,
1319 find_memory_region_ftype func, void *obfd)
1321 struct linux_find_memory_regions_data data;
1326 return linux_find_memory_regions_full (gdbarch,
1327 linux_find_memory_regions_thunk,
1331 /* Determine which signal stopped execution. */
1334 find_signalled_thread (struct thread_info *info, void *data)
1336 if (info->suspend.stop_signal != GDB_SIGNAL_0
1337 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1343 static enum gdb_signal
1344 find_stop_signal (void)
1346 struct thread_info *info =
1347 iterate_over_threads (find_signalled_thread, NULL);
1350 return info->suspend.stop_signal;
1352 return GDB_SIGNAL_0;
1355 /* Generate corefile notes for SPU contexts. */
1358 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1360 static const char *spu_files[] =
1382 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1386 /* Determine list of SPU ids. */
1387 size = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1390 /* Generate corefile notes for each SPU file. */
1391 for (i = 0; i < size; i += 4)
1393 int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1395 for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1397 char annex[32], note_name[32];
1401 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1402 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
1406 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1407 note_data = elfcore_write_note (obfd, note_data, note_size,
1427 /* This is used to pass information from
1428 linux_make_mappings_corefile_notes through
1429 linux_find_memory_regions_full. */
1431 struct linux_make_mappings_data
1433 /* Number of files mapped. */
1434 ULONGEST file_count;
1436 /* The obstack for the main part of the data. */
1437 struct obstack *data_obstack;
1439 /* The filename obstack. */
1440 struct obstack *filename_obstack;
1442 /* The architecture's "long" type. */
1443 struct type *long_type;
1446 static linux_find_memory_region_ftype linux_make_mappings_callback;
1448 /* A callback for linux_find_memory_regions_full that updates the
1449 mappings data for linux_make_mappings_corefile_notes. */
1452 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1453 ULONGEST offset, ULONGEST inode,
1454 int read, int write, int exec, int modified,
1455 const char *filename, void *data)
1457 struct linux_make_mappings_data *map_data = data;
1458 gdb_byte buf[sizeof (ULONGEST)];
1460 if (*filename == '\0' || inode == 0)
1463 ++map_data->file_count;
1465 pack_long (buf, map_data->long_type, vaddr);
1466 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1467 pack_long (buf, map_data->long_type, vaddr + size);
1468 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1469 pack_long (buf, map_data->long_type, offset);
1470 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1472 obstack_grow_str0 (map_data->filename_obstack, filename);
1477 /* Write the file mapping data to the core file, if possible. OBFD is
1478 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1479 is a pointer to the note size. Returns the new NOTE_DATA and
1480 updates NOTE_SIZE. */
1483 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1484 char *note_data, int *note_size)
1486 struct cleanup *cleanup;
1487 struct obstack data_obstack, filename_obstack;
1488 struct linux_make_mappings_data mapping_data;
1489 struct type *long_type
1490 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1491 gdb_byte buf[sizeof (ULONGEST)];
1493 obstack_init (&data_obstack);
1494 cleanup = make_cleanup_obstack_free (&data_obstack);
1495 obstack_init (&filename_obstack);
1496 make_cleanup_obstack_free (&filename_obstack);
1498 mapping_data.file_count = 0;
1499 mapping_data.data_obstack = &data_obstack;
1500 mapping_data.filename_obstack = &filename_obstack;
1501 mapping_data.long_type = long_type;
1503 /* Reserve space for the count. */
1504 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1505 /* We always write the page size as 1 since we have no good way to
1506 determine the correct value. */
1507 pack_long (buf, long_type, 1);
1508 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1510 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1513 if (mapping_data.file_count != 0)
1515 /* Write the count to the obstack. */
1516 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1517 long_type, mapping_data.file_count);
1519 /* Copy the filenames to the data obstack. */
1520 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1521 obstack_object_size (&filename_obstack));
1523 note_data = elfcore_write_note (obfd, note_data, note_size,
1525 obstack_base (&data_obstack),
1526 obstack_object_size (&data_obstack));
1529 do_cleanups (cleanup);
1533 /* Structure for passing information from
1534 linux_collect_thread_registers via an iterator to
1535 linux_collect_regset_section_cb. */
1537 struct linux_collect_regset_section_cb_data
1539 struct gdbarch *gdbarch;
1540 const struct regcache *regcache;
1545 enum gdb_signal stop_signal;
1546 int abort_iteration;
1549 /* Callback for iterate_over_regset_sections that records a single
1550 regset in the corefile note section. */
1553 linux_collect_regset_section_cb (const char *sect_name, int size,
1554 const struct regset *regset,
1555 const char *human_name, void *cb_data)
1558 struct linux_collect_regset_section_cb_data *data = cb_data;
1560 if (data->abort_iteration)
1563 gdb_assert (regset && regset->collect_regset);
1565 buf = xmalloc (size);
1566 regset->collect_regset (regset, data->regcache, -1, buf, size);
1568 /* PRSTATUS still needs to be treated specially. */
1569 if (strcmp (sect_name, ".reg") == 0)
1570 data->note_data = (char *) elfcore_write_prstatus
1571 (data->obfd, data->note_data, data->note_size, data->lwp,
1572 gdb_signal_to_host (data->stop_signal), buf);
1574 data->note_data = (char *) elfcore_write_register_note
1575 (data->obfd, data->note_data, data->note_size,
1576 sect_name, buf, size);
1579 if (data->note_data == NULL)
1580 data->abort_iteration = 1;
1583 /* Records the thread's register state for the corefile note
1587 linux_collect_thread_registers (const struct regcache *regcache,
1588 ptid_t ptid, bfd *obfd,
1589 char *note_data, int *note_size,
1590 enum gdb_signal stop_signal)
1592 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1593 struct linux_collect_regset_section_cb_data data;
1595 data.gdbarch = gdbarch;
1596 data.regcache = regcache;
1598 data.note_data = note_data;
1599 data.note_size = note_size;
1600 data.stop_signal = stop_signal;
1601 data.abort_iteration = 0;
1603 /* For remote targets the LWP may not be available, so use the TID. */
1604 data.lwp = ptid_get_lwp (ptid);
1606 data.lwp = ptid_get_tid (ptid);
1608 gdbarch_iterate_over_regset_sections (gdbarch,
1609 linux_collect_regset_section_cb,
1611 return data.note_data;
1614 /* Fetch the siginfo data for the current thread, if it exists. If
1615 there is no data, or we could not read it, return NULL. Otherwise,
1616 return a newly malloc'd buffer holding the data and fill in *SIZE
1617 with the size of the data. The caller is responsible for freeing
1621 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1623 struct type *siginfo_type;
1626 struct cleanup *cleanups;
1628 if (!gdbarch_get_siginfo_type_p (gdbarch))
1631 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1633 buf = xmalloc (TYPE_LENGTH (siginfo_type));
1634 cleanups = make_cleanup (xfree, buf);
1636 bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1637 buf, 0, TYPE_LENGTH (siginfo_type));
1638 if (bytes_read == TYPE_LENGTH (siginfo_type))
1640 discard_cleanups (cleanups);
1645 do_cleanups (cleanups);
1652 struct linux_corefile_thread_data
1654 struct gdbarch *gdbarch;
1659 enum gdb_signal stop_signal;
1662 /* Called by gdbthread.c once per thread. Records the thread's
1663 register state for the corefile note section. */
1666 linux_corefile_thread_callback (struct thread_info *info, void *data)
1668 struct linux_corefile_thread_data *args = data;
1670 /* It can be current thread
1671 which cannot be removed by update_thread_list. */
1672 if (info->state == THREAD_EXITED)
1675 if (ptid_get_pid (info->ptid) == args->pid)
1677 struct cleanup *old_chain;
1678 struct regcache *regcache;
1679 gdb_byte *siginfo_data;
1680 LONGEST siginfo_size = 0;
1682 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1684 old_chain = save_inferior_ptid ();
1685 inferior_ptid = info->ptid;
1686 target_fetch_registers (regcache, -1);
1687 siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1688 do_cleanups (old_chain);
1690 old_chain = make_cleanup (xfree, siginfo_data);
1692 args->note_data = linux_collect_thread_registers
1693 (regcache, info->ptid, args->obfd, args->note_data,
1694 args->note_size, args->stop_signal);
1696 /* Don't return anything if we got no register information above,
1697 such a core file is useless. */
1698 if (args->note_data != NULL)
1699 if (siginfo_data != NULL)
1700 args->note_data = elfcore_write_note (args->obfd,
1704 siginfo_data, siginfo_size);
1706 do_cleanups (old_chain);
1709 return !args->note_data;
1712 /* Fill the PRPSINFO structure with information about the process being
1713 debugged. Returns 1 in case of success, 0 for failures. Please note that
1714 even if the structure cannot be entirely filled (e.g., GDB was unable to
1715 gather information about the process UID/GID), this function will still
1716 return 1 since some information was already recorded. It will only return
1717 0 iff nothing can be gathered. */
1720 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1722 /* The filename which we will use to obtain some info about the process.
1723 We will basically use this to store the `/proc/PID/FILENAME' file. */
1725 /* The full name of the program which generated the corefile. */
1727 /* The basename of the executable. */
1728 const char *basename;
1729 /* The arguments of the program. */
1732 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1733 char *proc_stat, *proc_status;
1734 /* Temporary buffer. */
1736 /* The valid states of a process, according to the Linux kernel. */
1737 const char valid_states[] = "RSDTZW";
1738 /* The program state. */
1739 const char *prog_state;
1740 /* The state of the process. */
1742 /* The PID of the program which generated the corefile. */
1744 /* Process flags. */
1745 unsigned int pr_flag;
1746 /* Process nice value. */
1748 /* The number of fields read by `sscanf'. */
1754 gdb_assert (p != NULL);
1756 /* Obtaining PID and filename. */
1757 pid = ptid_get_pid (inferior_ptid);
1758 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1759 fname = target_fileio_read_stralloc (NULL, filename);
1761 if (fname == NULL || *fname == '\0')
1763 /* No program name was read, so we won't be able to retrieve more
1764 information about the process. */
1769 c = make_cleanup (xfree, fname);
1770 memset (p, 0, sizeof (*p));
1772 /* Defining the PID. */
1775 /* Copying the program name. Only the basename matters. */
1776 basename = lbasename (fname);
1777 strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1778 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1780 infargs = get_inferior_args ();
1782 psargs = xstrdup (fname);
1783 if (infargs != NULL)
1784 psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1786 make_cleanup (xfree, psargs);
1788 strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1789 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1791 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1792 proc_stat = target_fileio_read_stralloc (NULL, filename);
1793 make_cleanup (xfree, proc_stat);
1795 if (proc_stat == NULL || *proc_stat == '\0')
1797 /* Despite being unable to read more information about the
1798 process, we return 1 here because at least we have its
1799 command line, PID and arguments. */
1804 /* Ok, we have the stats. It's time to do a little parsing of the
1805 contents of the buffer, so that we end up reading what we want.
1807 The following parsing mechanism is strongly based on the
1808 information generated by the `fs/proc/array.c' file, present in
1809 the Linux kernel tree. More details about how the information is
1810 displayed can be obtained by seeing the manpage of proc(5),
1811 specifically under the entry of `/proc/[pid]/stat'. */
1813 /* Getting rid of the PID, since we already have it. */
1814 while (isdigit (*proc_stat))
1817 proc_stat = skip_spaces (proc_stat);
1819 /* ps command also relies on no trailing fields ever contain ')'. */
1820 proc_stat = strrchr (proc_stat, ')');
1821 if (proc_stat == NULL)
1828 proc_stat = skip_spaces (proc_stat);
1830 n_fields = sscanf (proc_stat,
1831 "%c" /* Process state. */
1832 "%d%d%d" /* Parent PID, group ID, session ID. */
1833 "%*d%*d" /* tty_nr, tpgid (not used). */
1835 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1836 cmajflt (not used). */
1837 "%*s%*s%*s%*s" /* utime, stime, cutime,
1838 cstime (not used). */
1839 "%*s" /* Priority (not used). */
1842 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1848 /* Again, we couldn't read the complementary information about
1849 the process state. However, we already have minimal
1850 information, so we just return 1 here. */
1855 /* Filling the structure fields. */
1856 prog_state = strchr (valid_states, pr_sname);
1857 if (prog_state != NULL)
1858 p->pr_state = prog_state - valid_states;
1861 /* Zero means "Running". */
1865 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1866 p->pr_zomb = p->pr_sname == 'Z';
1867 p->pr_nice = pr_nice;
1868 p->pr_flag = pr_flag;
1870 /* Finally, obtaining the UID and GID. For that, we read and parse the
1871 contents of the `/proc/PID/status' file. */
1872 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1873 proc_status = target_fileio_read_stralloc (NULL, filename);
1874 make_cleanup (xfree, proc_status);
1876 if (proc_status == NULL || *proc_status == '\0')
1878 /* Returning 1 since we already have a bunch of information. */
1883 /* Extracting the UID. */
1884 tmpstr = strstr (proc_status, "Uid:");
1887 /* Advancing the pointer to the beginning of the UID. */
1888 tmpstr += sizeof ("Uid:");
1889 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1892 if (isdigit (*tmpstr))
1893 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1896 /* Extracting the GID. */
1897 tmpstr = strstr (proc_status, "Gid:");
1900 /* Advancing the pointer to the beginning of the GID. */
1901 tmpstr += sizeof ("Gid:");
1902 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1905 if (isdigit (*tmpstr))
1906 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1914 /* Build the note section for a corefile, and return it in a malloc
1918 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1920 struct linux_corefile_thread_data thread_args;
1921 struct elf_internal_linux_prpsinfo prpsinfo;
1922 char *note_data = NULL;
1926 if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1929 if (linux_fill_prpsinfo (&prpsinfo))
1931 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1933 note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1934 note_data, note_size,
1939 if (gdbarch_ptr_bit (gdbarch) == 64)
1940 note_data = elfcore_write_linux_prpsinfo64 (obfd,
1941 note_data, note_size,
1944 note_data = elfcore_write_linux_prpsinfo32 (obfd,
1945 note_data, note_size,
1950 /* Thread register information. */
1953 update_thread_list ();
1955 CATCH (e, RETURN_MASK_ERROR)
1957 exception_print (gdb_stderr, e);
1961 thread_args.gdbarch = gdbarch;
1962 thread_args.pid = ptid_get_pid (inferior_ptid);
1963 thread_args.obfd = obfd;
1964 thread_args.note_data = note_data;
1965 thread_args.note_size = note_size;
1966 thread_args.stop_signal = find_stop_signal ();
1967 iterate_over_threads (linux_corefile_thread_callback, &thread_args);
1968 note_data = thread_args.note_data;
1972 /* Auxillary vector. */
1973 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
1977 note_data = elfcore_write_note (obfd, note_data, note_size,
1978 "CORE", NT_AUXV, auxv, auxv_len);
1985 /* SPU information. */
1986 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1990 /* File mappings. */
1991 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1992 note_data, note_size);
1997 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1998 gdbarch.h. This function is not static because it is exported to
1999 other -tdep files. */
2002 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
2007 return GDB_SIGNAL_0;
2010 return GDB_SIGNAL_HUP;
2013 return GDB_SIGNAL_INT;
2016 return GDB_SIGNAL_QUIT;
2019 return GDB_SIGNAL_ILL;
2022 return GDB_SIGNAL_TRAP;
2025 return GDB_SIGNAL_ABRT;
2028 return GDB_SIGNAL_BUS;
2031 return GDB_SIGNAL_FPE;
2034 return GDB_SIGNAL_KILL;
2037 return GDB_SIGNAL_USR1;
2040 return GDB_SIGNAL_SEGV;
2043 return GDB_SIGNAL_USR2;
2046 return GDB_SIGNAL_PIPE;
2049 return GDB_SIGNAL_ALRM;
2052 return GDB_SIGNAL_TERM;
2055 return GDB_SIGNAL_CHLD;
2058 return GDB_SIGNAL_CONT;
2061 return GDB_SIGNAL_STOP;
2064 return GDB_SIGNAL_TSTP;
2067 return GDB_SIGNAL_TTIN;
2070 return GDB_SIGNAL_TTOU;
2073 return GDB_SIGNAL_URG;
2076 return GDB_SIGNAL_XCPU;
2079 return GDB_SIGNAL_XFSZ;
2081 case LINUX_SIGVTALRM:
2082 return GDB_SIGNAL_VTALRM;
2085 return GDB_SIGNAL_PROF;
2087 case LINUX_SIGWINCH:
2088 return GDB_SIGNAL_WINCH;
2090 /* No way to differentiate between SIGIO and SIGPOLL.
2091 Therefore, we just handle the first one. */
2093 return GDB_SIGNAL_IO;
2096 return GDB_SIGNAL_PWR;
2099 return GDB_SIGNAL_SYS;
2101 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2102 therefore we have to handle them here. */
2103 case LINUX_SIGRTMIN:
2104 return GDB_SIGNAL_REALTIME_32;
2106 case LINUX_SIGRTMAX:
2107 return GDB_SIGNAL_REALTIME_64;
2110 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2112 int offset = signal - LINUX_SIGRTMIN + 1;
2114 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2117 return GDB_SIGNAL_UNKNOWN;
2120 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2121 gdbarch.h. This function is not static because it is exported to
2122 other -tdep files. */
2125 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
2126 enum gdb_signal signal)
2133 case GDB_SIGNAL_HUP:
2134 return LINUX_SIGHUP;
2136 case GDB_SIGNAL_INT:
2137 return LINUX_SIGINT;
2139 case GDB_SIGNAL_QUIT:
2140 return LINUX_SIGQUIT;
2142 case GDB_SIGNAL_ILL:
2143 return LINUX_SIGILL;
2145 case GDB_SIGNAL_TRAP:
2146 return LINUX_SIGTRAP;
2148 case GDB_SIGNAL_ABRT:
2149 return LINUX_SIGABRT;
2151 case GDB_SIGNAL_FPE:
2152 return LINUX_SIGFPE;
2154 case GDB_SIGNAL_KILL:
2155 return LINUX_SIGKILL;
2157 case GDB_SIGNAL_BUS:
2158 return LINUX_SIGBUS;
2160 case GDB_SIGNAL_SEGV:
2161 return LINUX_SIGSEGV;
2163 case GDB_SIGNAL_SYS:
2164 return LINUX_SIGSYS;
2166 case GDB_SIGNAL_PIPE:
2167 return LINUX_SIGPIPE;
2169 case GDB_SIGNAL_ALRM:
2170 return LINUX_SIGALRM;
2172 case GDB_SIGNAL_TERM:
2173 return LINUX_SIGTERM;
2175 case GDB_SIGNAL_URG:
2176 return LINUX_SIGURG;
2178 case GDB_SIGNAL_STOP:
2179 return LINUX_SIGSTOP;
2181 case GDB_SIGNAL_TSTP:
2182 return LINUX_SIGTSTP;
2184 case GDB_SIGNAL_CONT:
2185 return LINUX_SIGCONT;
2187 case GDB_SIGNAL_CHLD:
2188 return LINUX_SIGCHLD;
2190 case GDB_SIGNAL_TTIN:
2191 return LINUX_SIGTTIN;
2193 case GDB_SIGNAL_TTOU:
2194 return LINUX_SIGTTOU;
2199 case GDB_SIGNAL_XCPU:
2200 return LINUX_SIGXCPU;
2202 case GDB_SIGNAL_XFSZ:
2203 return LINUX_SIGXFSZ;
2205 case GDB_SIGNAL_VTALRM:
2206 return LINUX_SIGVTALRM;
2208 case GDB_SIGNAL_PROF:
2209 return LINUX_SIGPROF;
2211 case GDB_SIGNAL_WINCH:
2212 return LINUX_SIGWINCH;
2214 case GDB_SIGNAL_USR1:
2215 return LINUX_SIGUSR1;
2217 case GDB_SIGNAL_USR2:
2218 return LINUX_SIGUSR2;
2220 case GDB_SIGNAL_PWR:
2221 return LINUX_SIGPWR;
2223 case GDB_SIGNAL_POLL:
2224 return LINUX_SIGPOLL;
2226 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2227 therefore we have to handle it here. */
2228 case GDB_SIGNAL_REALTIME_32:
2229 return LINUX_SIGRTMIN;
2231 /* Same comment applies to _64. */
2232 case GDB_SIGNAL_REALTIME_64:
2233 return LINUX_SIGRTMAX;
2236 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2237 if (signal >= GDB_SIGNAL_REALTIME_33
2238 && signal <= GDB_SIGNAL_REALTIME_63)
2240 int offset = signal - GDB_SIGNAL_REALTIME_33;
2242 return LINUX_SIGRTMIN + 1 + offset;
2248 /* Rummage through mappings to find a mapping's size. */
2251 find_mapping_size (CORE_ADDR vaddr, unsigned long size,
2252 int read, int write, int exec, int modified,
2255 struct mem_range *range = data;
2257 if (vaddr == range->start)
2259 range->length = size;
2265 /* Helper for linux_vsyscall_range that does the real work of finding
2266 the vsyscall's address range. */
2269 linux_vsyscall_range_raw (struct gdbarch *gdbarch, struct mem_range *range)
2271 if (target_auxv_search (¤t_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2274 /* This is installed by linux_init_abi below, so should always be
2276 gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2279 gdbarch_find_memory_regions (gdbarch, find_mapping_size, range);
2283 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2284 caching, and defers the real work to linux_vsyscall_range_raw. */
2287 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
2289 struct linux_info *info = get_linux_inferior_data ();
2291 if (info->vsyscall_range_p == 0)
2293 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2294 info->vsyscall_range_p = 1;
2296 info->vsyscall_range_p = -1;
2299 if (info->vsyscall_range_p < 0)
2302 *range = info->vsyscall_range;
2306 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2307 definitions would be dependent on compilation host. */
2308 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2309 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2311 /* See gdbarch.sh 'infcall_mmap'. */
2314 linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2316 struct objfile *objf;
2317 /* Do there still exist any Linux systems without "mmap64"?
2318 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2319 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2320 struct value *addr_val;
2321 struct gdbarch *gdbarch = get_objfile_arch (objf);
2325 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2327 struct value *arg[ARG_LAST];
2329 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2331 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2332 arg[ARG_LENGTH] = value_from_ulongest
2333 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2334 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2335 | GDB_MMAP_PROT_EXEC))
2337 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2338 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2339 GDB_MMAP_MAP_PRIVATE
2340 | GDB_MMAP_MAP_ANONYMOUS);
2341 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2342 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2344 addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
2345 retval = value_as_address (addr_val);
2346 if (retval == (CORE_ADDR) -1)
2347 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2352 /* See gdbarch.sh 'infcall_munmap'. */
2355 linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2357 struct objfile *objf;
2358 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2359 struct value *retval_val;
2360 struct gdbarch *gdbarch = get_objfile_arch (objf);
2364 ARG_ADDR, ARG_LENGTH, ARG_LAST
2366 struct value *arg[ARG_LAST];
2368 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2370 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2371 arg[ARG_LENGTH] = value_from_ulongest
2372 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2373 retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
2374 retval = value_as_long (retval_val);
2376 warning (_("Failed inferior munmap call at %s for %s bytes, "
2377 "errno is changed."),
2378 hex_string (addr), pulongest (size));
2381 /* See linux-tdep.h. */
2384 linux_displaced_step_location (struct gdbarch *gdbarch)
2389 /* Determine entry point from target auxiliary vector. This avoids
2390 the need for symbols. Also, when debugging a stand-alone SPU
2391 executable, entry_point_address () will point to an SPU
2392 local-store address and is thus not usable as displaced stepping
2393 location. The auxiliary vector gets us the PowerPC-side entry
2394 point address instead. */
2395 if (target_auxv_search (¤t_target, AT_ENTRY, &addr) <= 0)
2396 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2398 /* Make certain that the address points at real code, and not a
2399 function descriptor. */
2400 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2403 /* Inferior calls also use the entry point as a breakpoint location.
2404 We don't want displaced stepping to interfere with those
2405 breakpoints, so leave space. */
2406 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2412 /* Display whether the gcore command is using the
2413 /proc/PID/coredump_filter file. */
2416 show_use_coredump_filter (struct ui_file *file, int from_tty,
2417 struct cmd_list_element *c, const char *value)
2419 fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2420 " corefiles is %s.\n"), value);
2423 /* To be called from the various GDB_OSABI_LINUX handlers for the
2424 various GNU/Linux architectures and machine types. */
2427 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2429 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
2430 set_gdbarch_info_proc (gdbarch, linux_info_proc);
2431 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
2432 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
2433 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
2434 set_gdbarch_has_shared_address_space (gdbarch,
2435 linux_has_shared_address_space);
2436 set_gdbarch_gdb_signal_from_target (gdbarch,
2437 linux_gdb_signal_from_target);
2438 set_gdbarch_gdb_signal_to_target (gdbarch,
2439 linux_gdb_signal_to_target);
2440 set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
2441 set_gdbarch_infcall_mmap (gdbarch, linux_infcall_mmap);
2442 set_gdbarch_infcall_munmap (gdbarch, linux_infcall_munmap);
2445 /* Provide a prototype to silence -Wmissing-prototypes. */
2446 extern initialize_file_ftype _initialize_linux_tdep;
2449 _initialize_linux_tdep (void)
2451 linux_gdbarch_data_handle =
2452 gdbarch_data_register_post_init (init_linux_gdbarch_data);
2454 /* Set a cache per-inferior. */
2456 = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2457 /* Observers used to invalidate the cache when needed. */
2458 observer_attach_inferior_exit (invalidate_linux_cache_inf);
2459 observer_attach_inferior_appeared (invalidate_linux_cache_inf);
2461 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2462 &use_coredump_filter, _("\
2463 Set whether gcore should consider /proc/PID/coredump_filter."),
2465 Show whether gcore should consider /proc/PID/coredump_filter."),
2467 Use this command to set whether gcore should consider the contents\n\
2468 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2469 about this file, refer to the manpage of core(5)."),
2470 NULL, show_use_coredump_filter,
2471 &setlist, &showlist);