1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
39 #include "gdb_regex.h"
40 #include "common/enum-flags.h"
41 #include "common/gdb_optional.h"
45 /* This enum represents the values that the user can choose when
46 informing the Linux kernel about which memory mappings will be
47 dumped in a corefile. They are described in the file
48 Documentation/filesystems/proc.txt, inside the Linux kernel
53 COREFILTER_ANON_PRIVATE
= 1 << 0,
54 COREFILTER_ANON_SHARED
= 1 << 1,
55 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
56 COREFILTER_MAPPED_SHARED
= 1 << 3,
57 COREFILTER_ELF_HEADERS
= 1 << 4,
58 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
59 COREFILTER_HUGETLB_SHARED
= 1 << 6,
61 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
63 /* This struct is used to map flags found in the "VmFlags:" field (in
64 the /proc/<PID>/smaps file). */
68 /* Zero if this structure has not been initialized yet. It
69 probably means that the Linux kernel being used does not emit
70 the "VmFlags:" field on "/proc/PID/smaps". */
72 unsigned int initialized_p
: 1;
74 /* Memory mapped I/O area (VM_IO, "io"). */
76 unsigned int io_page
: 1;
78 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
80 unsigned int uses_huge_tlb
: 1;
82 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
84 unsigned int exclude_coredump
: 1;
86 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
88 unsigned int shared_mapping
: 1;
91 /* Whether to take the /proc/PID/coredump_filter into account when
92 generating a corefile. */
94 static int use_coredump_filter
= 1;
96 /* This enum represents the signals' numbers on a generic architecture
97 running the Linux kernel. The definition of "generic" comes from
98 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
99 tree, which is the "de facto" implementation of signal numbers to
100 be used by new architecture ports.
102 For those architectures which have differences between the generic
103 standard (e.g., Alpha), we define the different signals (and *only*
104 those) in the specific target-dependent file (e.g.,
105 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
106 tdep file for more information.
108 ARM deserves a special mention here. On the file
109 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
110 (and ARM-only) signal, which is SIGSWI, with the same number as
111 SIGRTMIN. This signal is used only for a very specific target,
112 called ArthurOS (from RISCOS). Therefore, we do not handle it on
113 the ARM-tdep file, and we can safely use the generic signal handler
114 here for ARM targets.
116 As stated above, this enum is derived from
117 <include/uapi/asm-generic/signal.h>, from the Linux kernel
138 LINUX_SIGSTKFLT
= 16,
148 LINUX_SIGVTALRM
= 26,
152 LINUX_SIGPOLL
= LINUX_SIGIO
,
155 LINUX_SIGUNUSED
= 31,
161 static struct gdbarch_data
*linux_gdbarch_data_handle
;
163 struct linux_gdbarch_data
165 struct type
*siginfo_type
;
169 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
171 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
174 static struct linux_gdbarch_data
*
175 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
177 return ((struct linux_gdbarch_data
*)
178 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
181 /* Per-inferior data key. */
182 static const struct inferior_data
*linux_inferior_data
;
184 /* Linux-specific cached data. This is used by GDB for caching
185 purposes for each inferior. This helps reduce the overhead of
186 transfering data from a remote target to the local host. */
189 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
190 if VSYSCALL_RANGE_P is positive. This is cached because getting
191 at this info requires an auxv lookup (which is itself cached),
192 and looking through the inferior's mappings (which change
193 throughout execution and therefore cannot be cached). */
194 struct mem_range vsyscall_range
;
196 /* Zero if we haven't tried looking up the vsyscall's range before
197 yet. Positive if we tried looking it up, and found it. Negative
198 if we tried looking it up but failed. */
199 int vsyscall_range_p
;
202 /* Frees whatever allocated space there is to be freed and sets INF's
203 linux cache data pointer to NULL. */
206 invalidate_linux_cache_inf (struct inferior
*inf
)
208 struct linux_info
*info
;
210 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
214 set_inferior_data (inf
, linux_inferior_data
, NULL
);
218 /* Handles the cleanup of the linux cache for inferior INF. ARG is
219 ignored. Callback for the inferior_appeared and inferior_exit
223 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
225 invalidate_linux_cache_inf (inf
);
228 /* Fetch the linux cache info for INF. This function always returns a
229 valid INFO pointer. */
231 static struct linux_info
*
232 get_linux_inferior_data (void)
234 struct linux_info
*info
;
235 struct inferior
*inf
= current_inferior ();
237 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
240 info
= XCNEW (struct linux_info
);
241 set_inferior_data (inf
, linux_inferior_data
, info
);
247 /* See linux-tdep.h. */
250 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
251 linux_siginfo_extra_fields extra_fields
)
253 struct linux_gdbarch_data
*linux_gdbarch_data
;
254 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
, *short_type
;
255 struct type
*uid_type
, *pid_type
;
256 struct type
*sigval_type
, *clock_type
;
257 struct type
*siginfo_type
, *sifields_type
;
260 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
261 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
262 return linux_gdbarch_data
->siginfo_type
;
264 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
266 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
268 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
270 short_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
272 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
275 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
276 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
277 append_composite_type_field (sigval_type
, "sival_int", int_type
);
278 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
281 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
282 TYPE_LENGTH (int_type
), "__pid_t");
283 TYPE_TARGET_TYPE (pid_type
) = int_type
;
284 TYPE_TARGET_STUB (pid_type
) = 1;
287 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
288 TYPE_LENGTH (uint_type
), "__uid_t");
289 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
290 TYPE_TARGET_STUB (uid_type
) = 1;
293 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
294 TYPE_LENGTH (long_type
), "__clock_t");
295 TYPE_TARGET_TYPE (clock_type
) = long_type
;
296 TYPE_TARGET_STUB (clock_type
) = 1;
299 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
302 const int si_max_size
= 128;
304 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
307 if (gdbarch_ptr_bit (gdbarch
) == 64)
308 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
310 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
311 append_composite_type_field (sifields_type
, "_pad",
312 init_vector_type (int_type
, si_pad_size
));
316 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
317 append_composite_type_field (type
, "si_pid", pid_type
);
318 append_composite_type_field (type
, "si_uid", uid_type
);
319 append_composite_type_field (sifields_type
, "_kill", type
);
322 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
323 append_composite_type_field (type
, "si_tid", int_type
);
324 append_composite_type_field (type
, "si_overrun", int_type
);
325 append_composite_type_field (type
, "si_sigval", sigval_type
);
326 append_composite_type_field (sifields_type
, "_timer", type
);
329 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
330 append_composite_type_field (type
, "si_pid", pid_type
);
331 append_composite_type_field (type
, "si_uid", uid_type
);
332 append_composite_type_field (type
, "si_sigval", sigval_type
);
333 append_composite_type_field (sifields_type
, "_rt", type
);
336 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
337 append_composite_type_field (type
, "si_pid", pid_type
);
338 append_composite_type_field (type
, "si_uid", uid_type
);
339 append_composite_type_field (type
, "si_status", int_type
);
340 append_composite_type_field (type
, "si_utime", clock_type
);
341 append_composite_type_field (type
, "si_stime", clock_type
);
342 append_composite_type_field (sifields_type
, "_sigchld", type
);
345 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
346 append_composite_type_field (type
, "si_addr", void_ptr_type
);
348 /* Additional bound fields for _sigfault in case they were requested. */
349 if ((extra_fields
& LINUX_SIGINFO_FIELD_ADDR_BND
) != 0)
351 struct type
*sigfault_bnd_fields
;
353 append_composite_type_field (type
, "_addr_lsb", short_type
);
354 sigfault_bnd_fields
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
355 append_composite_type_field (sigfault_bnd_fields
, "_lower", void_ptr_type
);
356 append_composite_type_field (sigfault_bnd_fields
, "_upper", void_ptr_type
);
357 append_composite_type_field (type
, "_addr_bnd", sigfault_bnd_fields
);
359 append_composite_type_field (sifields_type
, "_sigfault", type
);
362 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
363 append_composite_type_field (type
, "si_band", long_type
);
364 append_composite_type_field (type
, "si_fd", int_type
);
365 append_composite_type_field (sifields_type
, "_sigpoll", type
);
368 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
369 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
370 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
371 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
372 append_composite_type_field (siginfo_type
, "si_code", int_type
);
373 append_composite_type_field_aligned (siginfo_type
,
374 "_sifields", sifields_type
,
375 TYPE_LENGTH (long_type
));
377 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
382 /* This function is suitable for architectures that don't
383 extend/override the standard siginfo structure. */
386 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
388 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
391 /* Return true if the target is running on uClinux instead of normal
395 linux_is_uclinux (void)
399 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
400 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
404 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
406 return linux_is_uclinux ();
409 /* This is how we want PTIDs from core files to be printed. */
412 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
416 if (ptid_get_lwp (ptid
) != 0)
418 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
422 return normal_pid_to_str (ptid
);
425 /* Service function for corefiles and info proc. */
428 read_mapping (const char *line
,
429 ULONGEST
*addr
, ULONGEST
*endaddr
,
430 const char **permissions
, size_t *permissions_len
,
432 const char **device
, size_t *device_len
,
434 const char **filename
)
436 const char *p
= line
;
438 *addr
= strtoulst (p
, &p
, 16);
441 *endaddr
= strtoulst (p
, &p
, 16);
443 p
= skip_spaces_const (p
);
445 while (*p
&& !isspace (*p
))
447 *permissions_len
= p
- *permissions
;
449 *offset
= strtoulst (p
, &p
, 16);
451 p
= skip_spaces_const (p
);
453 while (*p
&& !isspace (*p
))
455 *device_len
= p
- *device
;
457 *inode
= strtoulst (p
, &p
, 10);
459 p
= skip_spaces_const (p
);
463 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
465 This function was based on the documentation found on
466 <Documentation/filesystems/proc.txt>, on the Linux kernel.
468 Linux kernels before commit
469 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
473 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
475 char *saveptr
= NULL
;
478 v
->initialized_p
= 1;
479 p
= skip_to_space (p
);
482 for (s
= strtok_r (p
, " ", &saveptr
);
484 s
= strtok_r (NULL
, " ", &saveptr
))
486 if (strcmp (s
, "io") == 0)
488 else if (strcmp (s
, "ht") == 0)
489 v
->uses_huge_tlb
= 1;
490 else if (strcmp (s
, "dd") == 0)
491 v
->exclude_coredump
= 1;
492 else if (strcmp (s
, "sh") == 0)
493 v
->shared_mapping
= 1;
497 /* Regexes used by mapping_is_anonymous_p. Put in a structure because
498 they're initialized lazily. */
500 struct mapping_regexes
502 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
503 string in the end). We know for sure, based on the Linux kernel
504 code, that memory mappings whose associated filename is
505 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
506 compiled_regex dev_zero
507 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB
,
508 _("Could not compile regex to match /dev/zero filename")};
510 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
511 string in the end). These filenames refer to shared memory
512 (shmem), and memory mappings associated with them are
513 MAP_ANONYMOUS as well. */
514 compiled_regex shmem_file
515 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB
,
516 _("Could not compile regex to match shmem filenames")};
518 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
519 0' code, which is responsible to decide if it is dealing with a
520 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
521 FILE_DELETED matches, it does not necessarily mean that we are
522 dealing with an anonymous shared mapping. However, there is no
523 easy way to detect this currently, so this is the best
524 approximation we have.
526 As a result, GDB will dump readonly pages of deleted executables
527 when using the default value of coredump_filter (0x33), while the
528 Linux kernel will not dump those pages. But we can live with
530 compiled_regex file_deleted
531 {" (deleted)$", REG_NOSUB
,
532 _("Could not compile regex to match '<file> (deleted)'")};
535 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
537 FILENAME is the name of the file present in the first line of the
538 memory mapping, in the "/proc/PID/smaps" output. For example, if
541 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
543 Then FILENAME will be "/path/to/file". */
546 mapping_is_anonymous_p (const char *filename
)
548 static gdb::optional
<mapping_regexes
> regexes
;
549 static int init_regex_p
= 0;
553 /* Let's be pessimistic and assume there will be an error while
554 compiling the regex'es. */
559 /* If we reached this point, then everything succeeded. */
563 if (init_regex_p
== -1)
565 const char deleted
[] = " (deleted)";
566 size_t del_len
= sizeof (deleted
) - 1;
567 size_t filename_len
= strlen (filename
);
569 /* There was an error while compiling the regex'es above. In
570 order to try to give some reliable information to the caller,
571 we just try to find the string " (deleted)" in the filename.
572 If we managed to find it, then we assume the mapping is
574 return (filename_len
>= del_len
575 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
578 if (*filename
== '\0'
579 || regexes
->dev_zero
.exec (filename
, 0, NULL
, 0) == 0
580 || regexes
->shmem_file
.exec (filename
, 0, NULL
, 0) == 0
581 || regexes
->file_deleted
.exec (filename
, 0, NULL
, 0) == 0)
587 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
588 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
589 greater than 0 if it should.
591 In a nutshell, this is the logic that we follow in order to decide
592 if a mapping should be dumped or not.
594 - If the mapping is associated to a file whose name ends with
595 " (deleted)", or if the file is "/dev/zero", or if it is
596 "/SYSV%08x" (shared memory), or if there is no file associated
597 with it, or if the AnonHugePages: or the Anonymous: fields in the
598 /proc/PID/smaps have contents, then GDB considers this mapping to
599 be anonymous. Otherwise, GDB considers this mapping to be a
600 file-backed mapping (because there will be a file associated with
603 It is worth mentioning that, from all those checks described
604 above, the most fragile is the one to see if the file name ends
605 with " (deleted)". This does not necessarily mean that the
606 mapping is anonymous, because the deleted file associated with
607 the mapping may have been a hard link to another file, for
608 example. The Linux kernel checks to see if "i_nlink == 0", but
609 GDB cannot easily (and normally) do this check (iff running as
610 root, it could find the mapping in /proc/PID/map_files/ and
611 determine whether there still are other hard links to the
612 inode/file). Therefore, we made a compromise here, and we assume
613 that if the file name ends with " (deleted)", then the mapping is
614 indeed anonymous. FWIW, this is something the Linux kernel could
615 do better: expose this information in a more direct way.
617 - If we see the flag "sh" in the "VmFlags:" field (in
618 /proc/PID/smaps), then certainly the memory mapping is shared
619 (VM_SHARED). If we have access to the VmFlags, and we don't see
620 the "sh" there, then certainly the mapping is private. However,
621 Linux kernels before commit
622 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
623 "VmFlags:" field; in that case, we use another heuristic: if we
624 see 'p' in the permission flags, then we assume that the mapping
625 is private, even though the presence of the 's' flag there would
626 mean VM_MAYSHARE, which means the mapping could still be private.
627 This should work OK enough, however. */
630 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
631 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
632 const char *filename
)
634 /* Initially, we trust in what we received from our caller. This
635 value may not be very precise (i.e., it was probably gathered
636 from the permission line in the /proc/PID/smaps list, which
637 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
638 what we have until we take a look at the "VmFlags:" field
639 (assuming that the version of the Linux kernel being used
640 supports it, of course). */
641 int private_p
= maybe_private_p
;
643 /* We always dump vDSO and vsyscall mappings, because it's likely that
644 there'll be no file to read the contents from at core load time.
645 The kernel does the same. */
646 if (strcmp ("[vdso]", filename
) == 0
647 || strcmp ("[vsyscall]", filename
) == 0)
650 if (v
->initialized_p
)
652 /* We never dump I/O mappings. */
656 /* Check if we should exclude this mapping. */
657 if (v
->exclude_coredump
)
660 /* Update our notion of whether this mapping is shared or
661 private based on a trustworthy value. */
662 private_p
= !v
->shared_mapping
;
664 /* HugeTLB checking. */
665 if (v
->uses_huge_tlb
)
667 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
668 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
677 if (mapping_anon_p
&& mapping_file_p
)
679 /* This is a special situation. It can happen when we see a
680 mapping that is file-backed, but that contains anonymous
682 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
683 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
685 else if (mapping_anon_p
)
686 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
688 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
692 if (mapping_anon_p
&& mapping_file_p
)
694 /* This is a special situation. It can happen when we see a
695 mapping that is file-backed, but that contains anonymous
697 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
698 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
700 else if (mapping_anon_p
)
701 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
703 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
707 /* Implement the "info proc" command. */
710 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
711 enum info_proc_what what
)
713 /* A long is used for pid instead of an int to avoid a loss of precision
714 compiler warning from the output of strtoul. */
716 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
717 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
718 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
719 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
720 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
721 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
726 if (args
&& isdigit (args
[0]))
730 pid
= strtoul (args
, &tem
, 10);
735 if (!target_has_execution
)
736 error (_("No current process: you must name one."));
737 if (current_inferior ()->fake_pid_p
)
738 error (_("Can't determine the current process's PID: you must name one."));
740 pid
= current_inferior ()->pid
;
743 args
= skip_spaces_const (args
);
745 error (_("Too many parameters: %s"), args
);
747 printf_filtered (_("process %ld\n"), pid
);
750 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
751 data
= target_fileio_read_stralloc (NULL
, filename
);
754 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
755 printf_filtered ("cmdline = '%s'\n", data
);
756 do_cleanups (cleanup
);
759 warning (_("unable to open /proc file '%s'"), filename
);
763 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
764 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
767 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
768 printf_filtered ("cwd = '%s'\n", data
);
769 do_cleanups (cleanup
);
772 warning (_("unable to read link '%s'"), filename
);
776 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
777 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
780 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
781 printf_filtered ("exe = '%s'\n", data
);
782 do_cleanups (cleanup
);
785 warning (_("unable to read link '%s'"), filename
);
789 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
790 data
= target_fileio_read_stralloc (NULL
, filename
);
793 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
796 printf_filtered (_("Mapped address spaces:\n\n"));
797 if (gdbarch_addr_bit (gdbarch
) == 32)
799 printf_filtered ("\t%10s %10s %10s %10s %s\n",
802 " Size", " Offset", "objfile");
806 printf_filtered (" %18s %18s %10s %10s %s\n",
809 " Size", " Offset", "objfile");
812 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
814 ULONGEST addr
, endaddr
, offset
, inode
;
815 const char *permissions
, *device
, *filename
;
816 size_t permissions_len
, device_len
;
818 read_mapping (line
, &addr
, &endaddr
,
819 &permissions
, &permissions_len
,
820 &offset
, &device
, &device_len
,
823 if (gdbarch_addr_bit (gdbarch
) == 32)
825 printf_filtered ("\t%10s %10s %10s %10s %s\n",
826 paddress (gdbarch
, addr
),
827 paddress (gdbarch
, endaddr
),
828 hex_string (endaddr
- addr
),
830 *filename
? filename
: "");
834 printf_filtered (" %18s %18s %10s %10s %s\n",
835 paddress (gdbarch
, addr
),
836 paddress (gdbarch
, endaddr
),
837 hex_string (endaddr
- addr
),
839 *filename
? filename
: "");
843 do_cleanups (cleanup
);
846 warning (_("unable to open /proc file '%s'"), filename
);
850 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
851 data
= target_fileio_read_stralloc (NULL
, filename
);
854 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
855 puts_filtered (data
);
856 do_cleanups (cleanup
);
859 warning (_("unable to open /proc file '%s'"), filename
);
863 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
864 data
= target_fileio_read_stralloc (NULL
, filename
);
867 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
868 const char *p
= data
;
870 printf_filtered (_("Process: %s\n"),
871 pulongest (strtoulst (p
, &p
, 10)));
873 p
= skip_spaces_const (p
);
876 /* ps command also relies on no trailing fields
878 const char *ep
= strrchr (p
, ')');
881 printf_filtered ("Exec file: %.*s\n",
882 (int) (ep
- p
- 1), p
+ 1);
887 p
= skip_spaces_const (p
);
889 printf_filtered (_("State: %c\n"), *p
++);
892 printf_filtered (_("Parent process: %s\n"),
893 pulongest (strtoulst (p
, &p
, 10)));
895 printf_filtered (_("Process group: %s\n"),
896 pulongest (strtoulst (p
, &p
, 10)));
898 printf_filtered (_("Session id: %s\n"),
899 pulongest (strtoulst (p
, &p
, 10)));
901 printf_filtered (_("TTY: %s\n"),
902 pulongest (strtoulst (p
, &p
, 10)));
904 printf_filtered (_("TTY owner process group: %s\n"),
905 pulongest (strtoulst (p
, &p
, 10)));
908 printf_filtered (_("Flags: %s\n"),
909 hex_string (strtoulst (p
, &p
, 10)));
911 printf_filtered (_("Minor faults (no memory page): %s\n"),
912 pulongest (strtoulst (p
, &p
, 10)));
914 printf_filtered (_("Minor faults, children: %s\n"),
915 pulongest (strtoulst (p
, &p
, 10)));
917 printf_filtered (_("Major faults (memory page faults): %s\n"),
918 pulongest (strtoulst (p
, &p
, 10)));
920 printf_filtered (_("Major faults, children: %s\n"),
921 pulongest (strtoulst (p
, &p
, 10)));
923 printf_filtered (_("utime: %s\n"),
924 pulongest (strtoulst (p
, &p
, 10)));
926 printf_filtered (_("stime: %s\n"),
927 pulongest (strtoulst (p
, &p
, 10)));
929 printf_filtered (_("utime, children: %s\n"),
930 pulongest (strtoulst (p
, &p
, 10)));
932 printf_filtered (_("stime, children: %s\n"),
933 pulongest (strtoulst (p
, &p
, 10)));
935 printf_filtered (_("jiffies remaining in current "
937 pulongest (strtoulst (p
, &p
, 10)));
939 printf_filtered (_("'nice' value: %s\n"),
940 pulongest (strtoulst (p
, &p
, 10)));
942 printf_filtered (_("jiffies until next timeout: %s\n"),
943 pulongest (strtoulst (p
, &p
, 10)));
945 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
946 pulongest (strtoulst (p
, &p
, 10)));
948 printf_filtered (_("start time (jiffies since "
949 "system boot): %s\n"),
950 pulongest (strtoulst (p
, &p
, 10)));
952 printf_filtered (_("Virtual memory size: %s\n"),
953 pulongest (strtoulst (p
, &p
, 10)));
955 printf_filtered (_("Resident set size: %s\n"),
956 pulongest (strtoulst (p
, &p
, 10)));
958 printf_filtered (_("rlim: %s\n"),
959 pulongest (strtoulst (p
, &p
, 10)));
961 printf_filtered (_("Start of text: %s\n"),
962 hex_string (strtoulst (p
, &p
, 10)));
964 printf_filtered (_("End of text: %s\n"),
965 hex_string (strtoulst (p
, &p
, 10)));
967 printf_filtered (_("Start of stack: %s\n"),
968 hex_string (strtoulst (p
, &p
, 10)));
969 #if 0 /* Don't know how architecture-dependent the rest is...
970 Anyway the signal bitmap info is available from "status". */
972 printf_filtered (_("Kernel stack pointer: %s\n"),
973 hex_string (strtoulst (p
, &p
, 10)));
975 printf_filtered (_("Kernel instr pointer: %s\n"),
976 hex_string (strtoulst (p
, &p
, 10)));
978 printf_filtered (_("Pending signals bitmap: %s\n"),
979 hex_string (strtoulst (p
, &p
, 10)));
981 printf_filtered (_("Blocked signals bitmap: %s\n"),
982 hex_string (strtoulst (p
, &p
, 10)));
984 printf_filtered (_("Ignored signals bitmap: %s\n"),
985 hex_string (strtoulst (p
, &p
, 10)));
987 printf_filtered (_("Catched signals bitmap: %s\n"),
988 hex_string (strtoulst (p
, &p
, 10)));
990 printf_filtered (_("wchan (system call): %s\n"),
991 hex_string (strtoulst (p
, &p
, 10)));
993 do_cleanups (cleanup
);
996 warning (_("unable to open /proc file '%s'"), filename
);
1000 /* Implement "info proc mappings" for a corefile. */
1003 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
1006 ULONGEST count
, page_size
;
1007 unsigned char *descdata
, *filenames
, *descend
, *contents
;
1009 unsigned int addr_size_bits
, addr_size
;
1010 struct cleanup
*cleanup
;
1011 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
1012 /* We assume this for reading 64-bit core files. */
1013 gdb_static_assert (sizeof (ULONGEST
) >= 8);
1015 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1016 if (section
== NULL
)
1018 warning (_("unable to find mappings in core file"));
1022 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1023 addr_size
= addr_size_bits
/ 8;
1024 note_size
= bfd_get_section_size (section
);
1026 if (note_size
< 2 * addr_size
)
1027 error (_("malformed core note - too short for header"));
1029 contents
= (unsigned char *) xmalloc (note_size
);
1030 cleanup
= make_cleanup (xfree
, contents
);
1031 if (!bfd_get_section_contents (core_bfd
, section
, contents
, 0, note_size
))
1032 error (_("could not get core note contents"));
1034 descdata
= contents
;
1035 descend
= descdata
+ note_size
;
1037 if (descdata
[note_size
- 1] != '\0')
1038 error (_("malformed note - does not end with \\0"));
1040 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1041 descdata
+= addr_size
;
1043 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1044 descdata
+= addr_size
;
1046 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1047 error (_("malformed note - too short for supplied file count"));
1049 printf_filtered (_("Mapped address spaces:\n\n"));
1050 if (gdbarch_addr_bit (gdbarch
) == 32)
1052 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1055 " Size", " Offset", "objfile");
1059 printf_filtered (" %18s %18s %10s %10s %s\n",
1062 " Size", " Offset", "objfile");
1065 filenames
= descdata
+ count
* 3 * addr_size
;
1068 ULONGEST start
, end
, file_ofs
;
1070 if (filenames
== descend
)
1071 error (_("malformed note - filenames end too early"));
1073 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1074 descdata
+= addr_size
;
1075 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1076 descdata
+= addr_size
;
1077 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1078 descdata
+= addr_size
;
1080 file_ofs
*= page_size
;
1082 if (gdbarch_addr_bit (gdbarch
) == 32)
1083 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1084 paddress (gdbarch
, start
),
1085 paddress (gdbarch
, end
),
1086 hex_string (end
- start
),
1087 hex_string (file_ofs
),
1090 printf_filtered (" %18s %18s %10s %10s %s\n",
1091 paddress (gdbarch
, start
),
1092 paddress (gdbarch
, end
),
1093 hex_string (end
- start
),
1094 hex_string (file_ofs
),
1097 filenames
+= 1 + strlen ((char *) filenames
);
1100 do_cleanups (cleanup
);
1103 /* Implement "info proc" for a corefile. */
1106 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1107 enum info_proc_what what
)
1109 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1110 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1116 exe
= bfd_core_file_failing_command (core_bfd
);
1118 printf_filtered ("exe = '%s'\n", exe
);
1120 warning (_("unable to find command name in core file"));
1124 linux_core_info_proc_mappings (gdbarch
, args
);
1126 if (!exe_f
&& !mappings_f
)
1127 error (_("unable to handle request"));
1130 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1131 ULONGEST offset
, ULONGEST inode
,
1132 int read
, int write
,
1133 int exec
, int modified
,
1134 const char *filename
,
1137 /* List memory regions in the inferior for a corefile. */
1140 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1141 linux_find_memory_region_ftype
*func
,
1144 char mapsfilename
[100];
1145 char coredumpfilter_name
[100];
1146 char *data
, *coredumpfilterdata
;
1148 /* Default dump behavior of coredump_filter (0x33), according to
1149 Documentation/filesystems/proc.txt from the Linux kernel
1151 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1152 | COREFILTER_ANON_SHARED
1153 | COREFILTER_ELF_HEADERS
1154 | COREFILTER_HUGETLB_PRIVATE
);
1156 /* We need to know the real target PID to access /proc. */
1157 if (current_inferior ()->fake_pid_p
)
1160 pid
= current_inferior ()->pid
;
1162 if (use_coredump_filter
)
1164 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1165 "/proc/%d/coredump_filter", pid
);
1166 coredumpfilterdata
= target_fileio_read_stralloc (NULL
,
1167 coredumpfilter_name
);
1168 if (coredumpfilterdata
!= NULL
)
1172 sscanf (coredumpfilterdata
, "%x", &flags
);
1173 filterflags
= (enum filter_flag
) flags
;
1174 xfree (coredumpfilterdata
);
1178 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1179 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1182 /* Older Linux kernels did not support /proc/PID/smaps. */
1183 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1184 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1189 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
1192 line
= strtok_r (data
, "\n", &t
);
1193 while (line
!= NULL
)
1195 ULONGEST addr
, endaddr
, offset
, inode
;
1196 const char *permissions
, *device
, *filename
;
1197 struct smaps_vmflags v
;
1198 size_t permissions_len
, device_len
;
1199 int read
, write
, exec
, priv
;
1200 int has_anonymous
= 0;
1201 int should_dump_p
= 0;
1205 memset (&v
, 0, sizeof (v
));
1206 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1207 &offset
, &device
, &device_len
, &inode
, &filename
);
1208 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1209 /* If the mapping is not anonymous, then we can consider it
1210 to be file-backed. These two states (anonymous or
1211 file-backed) seem to be exclusive, but they can actually
1212 coexist. For example, if a file-backed mapping has
1213 "Anonymous:" pages (see more below), then the Linux
1214 kernel will dump this mapping when the user specified
1215 that she only wants anonymous mappings in the corefile
1216 (*even* when she explicitly disabled the dumping of
1217 file-backed mappings). */
1218 mapping_file_p
= !mapping_anon_p
;
1220 /* Decode permissions. */
1221 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1222 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1223 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1224 /* 'private' here actually means VM_MAYSHARE, and not
1225 VM_SHARED. In order to know if a mapping is really
1226 private or not, we must check the flag "sh" in the
1227 VmFlags field. This is done by decode_vmflags. However,
1228 if we are using a Linux kernel released before the commit
1229 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1230 not have the VmFlags there. In this case, there is
1231 really no way to know if we are dealing with VM_SHARED,
1232 so we just assume that VM_MAYSHARE is enough. */
1233 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1235 /* Try to detect if region should be dumped by parsing smaps
1237 for (line
= strtok_r (NULL
, "\n", &t
);
1238 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1239 line
= strtok_r (NULL
, "\n", &t
))
1241 char keyword
[64 + 1];
1243 if (sscanf (line
, "%64s", keyword
) != 1)
1245 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1249 if (strcmp (keyword
, "Anonymous:") == 0)
1251 /* Older Linux kernels did not support the
1252 "Anonymous:" counter. Check it here. */
1255 else if (strcmp (keyword
, "VmFlags:") == 0)
1256 decode_vmflags (line
, &v
);
1258 if (strcmp (keyword
, "AnonHugePages:") == 0
1259 || strcmp (keyword
, "Anonymous:") == 0)
1261 unsigned long number
;
1263 if (sscanf (line
, "%*s%lu", &number
) != 1)
1265 warning (_("Error parsing {s,}maps file '%s' number"),
1271 /* Even if we are dealing with a file-backed
1272 mapping, if it contains anonymous pages we
1273 consider it to be *also* an anonymous
1274 mapping, because this is what the Linux
1277 // Dump segments that have been written to.
1278 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1281 Note that if the mapping is already marked as
1282 file-backed (i.e., mapping_file_p is
1283 non-zero), then this is a special case, and
1284 this mapping will be dumped either when the
1285 user wants to dump file-backed *or* anonymous
1293 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1294 mapping_anon_p
, mapping_file_p
,
1298 /* Older Linux kernels did not support the "Anonymous:" counter.
1299 If it is missing, we can't be sure - dump all the pages. */
1303 /* Invoke the callback function to create the corefile segment. */
1305 func (addr
, endaddr
- addr
, offset
, inode
,
1306 read
, write
, exec
, 1, /* MODIFIED is true because we
1307 want to dump the mapping. */
1311 do_cleanups (cleanup
);
1318 /* A structure for passing information through
1319 linux_find_memory_regions_full. */
1321 struct linux_find_memory_regions_data
1323 /* The original callback. */
1325 find_memory_region_ftype func
;
1327 /* The original datum. */
1332 /* A callback for linux_find_memory_regions that converts between the
1333 "full"-style callback and find_memory_region_ftype. */
1336 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1337 ULONGEST offset
, ULONGEST inode
,
1338 int read
, int write
, int exec
, int modified
,
1339 const char *filename
, void *arg
)
1341 struct linux_find_memory_regions_data
*data
1342 = (struct linux_find_memory_regions_data
*) arg
;
1344 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1347 /* A variant of linux_find_memory_regions_full that is suitable as the
1348 gdbarch find_memory_regions method. */
1351 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1352 find_memory_region_ftype func
, void *obfd
)
1354 struct linux_find_memory_regions_data data
;
1359 return linux_find_memory_regions_full (gdbarch
,
1360 linux_find_memory_regions_thunk
,
1364 /* Determine which signal stopped execution. */
1367 find_signalled_thread (struct thread_info
*info
, void *data
)
1369 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1370 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
1376 /* Generate corefile notes for SPU contexts. */
1379 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1381 static const char *spu_files
[] =
1403 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1407 /* Determine list of SPU ids. */
1408 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1411 /* Generate corefile notes for each SPU file. */
1412 for (i
= 0; i
< size
; i
+= 4)
1414 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
1416 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1418 char annex
[32], note_name
[32];
1422 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1423 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1427 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1428 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1448 /* This is used to pass information from
1449 linux_make_mappings_corefile_notes through
1450 linux_find_memory_regions_full. */
1452 struct linux_make_mappings_data
1454 /* Number of files mapped. */
1455 ULONGEST file_count
;
1457 /* The obstack for the main part of the data. */
1458 struct obstack
*data_obstack
;
1460 /* The filename obstack. */
1461 struct obstack
*filename_obstack
;
1463 /* The architecture's "long" type. */
1464 struct type
*long_type
;
1467 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1469 /* A callback for linux_find_memory_regions_full that updates the
1470 mappings data for linux_make_mappings_corefile_notes. */
1473 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1474 ULONGEST offset
, ULONGEST inode
,
1475 int read
, int write
, int exec
, int modified
,
1476 const char *filename
, void *data
)
1478 struct linux_make_mappings_data
*map_data
1479 = (struct linux_make_mappings_data
*) data
;
1480 gdb_byte buf
[sizeof (ULONGEST
)];
1482 if (*filename
== '\0' || inode
== 0)
1485 ++map_data
->file_count
;
1487 pack_long (buf
, map_data
->long_type
, vaddr
);
1488 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1489 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1490 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1491 pack_long (buf
, map_data
->long_type
, offset
);
1492 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1494 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1499 /* Write the file mapping data to the core file, if possible. OBFD is
1500 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1501 is a pointer to the note size. Returns the new NOTE_DATA and
1502 updates NOTE_SIZE. */
1505 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1506 char *note_data
, int *note_size
)
1508 struct cleanup
*cleanup
;
1509 struct obstack data_obstack
, filename_obstack
;
1510 struct linux_make_mappings_data mapping_data
;
1511 struct type
*long_type
1512 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1513 gdb_byte buf
[sizeof (ULONGEST
)];
1515 obstack_init (&data_obstack
);
1516 cleanup
= make_cleanup_obstack_free (&data_obstack
);
1517 obstack_init (&filename_obstack
);
1518 make_cleanup_obstack_free (&filename_obstack
);
1520 mapping_data
.file_count
= 0;
1521 mapping_data
.data_obstack
= &data_obstack
;
1522 mapping_data
.filename_obstack
= &filename_obstack
;
1523 mapping_data
.long_type
= long_type
;
1525 /* Reserve space for the count. */
1526 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1527 /* We always write the page size as 1 since we have no good way to
1528 determine the correct value. */
1529 pack_long (buf
, long_type
, 1);
1530 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1532 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1535 if (mapping_data
.file_count
!= 0)
1537 /* Write the count to the obstack. */
1538 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1539 long_type
, mapping_data
.file_count
);
1541 /* Copy the filenames to the data obstack. */
1542 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1543 obstack_object_size (&filename_obstack
));
1545 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1547 obstack_base (&data_obstack
),
1548 obstack_object_size (&data_obstack
));
1551 do_cleanups (cleanup
);
1555 /* Structure for passing information from
1556 linux_collect_thread_registers via an iterator to
1557 linux_collect_regset_section_cb. */
1559 struct linux_collect_regset_section_cb_data
1561 struct gdbarch
*gdbarch
;
1562 const struct regcache
*regcache
;
1567 enum gdb_signal stop_signal
;
1568 int abort_iteration
;
1571 /* Callback for iterate_over_regset_sections that records a single
1572 regset in the corefile note section. */
1575 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1576 const struct regset
*regset
,
1577 const char *human_name
, void *cb_data
)
1580 struct linux_collect_regset_section_cb_data
*data
1581 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1583 if (data
->abort_iteration
)
1586 gdb_assert (regset
&& regset
->collect_regset
);
1588 buf
= (char *) xmalloc (size
);
1589 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1591 /* PRSTATUS still needs to be treated specially. */
1592 if (strcmp (sect_name
, ".reg") == 0)
1593 data
->note_data
= (char *) elfcore_write_prstatus
1594 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1595 gdb_signal_to_host (data
->stop_signal
), buf
);
1597 data
->note_data
= (char *) elfcore_write_register_note
1598 (data
->obfd
, data
->note_data
, data
->note_size
,
1599 sect_name
, buf
, size
);
1602 if (data
->note_data
== NULL
)
1603 data
->abort_iteration
= 1;
1606 /* Records the thread's register state for the corefile note
1610 linux_collect_thread_registers (const struct regcache
*regcache
,
1611 ptid_t ptid
, bfd
*obfd
,
1612 char *note_data
, int *note_size
,
1613 enum gdb_signal stop_signal
)
1615 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1616 struct linux_collect_regset_section_cb_data data
;
1618 data
.gdbarch
= gdbarch
;
1619 data
.regcache
= regcache
;
1621 data
.note_data
= note_data
;
1622 data
.note_size
= note_size
;
1623 data
.stop_signal
= stop_signal
;
1624 data
.abort_iteration
= 0;
1626 /* For remote targets the LWP may not be available, so use the TID. */
1627 data
.lwp
= ptid_get_lwp (ptid
);
1629 data
.lwp
= ptid_get_tid (ptid
);
1631 gdbarch_iterate_over_regset_sections (gdbarch
,
1632 linux_collect_regset_section_cb
,
1634 return data
.note_data
;
1637 /* Fetch the siginfo data for the current thread, if it exists. If
1638 there is no data, or we could not read it, return NULL. Otherwise,
1639 return a newly malloc'd buffer holding the data and fill in *SIZE
1640 with the size of the data. The caller is responsible for freeing
1644 linux_get_siginfo_data (struct gdbarch
*gdbarch
, LONGEST
*size
)
1646 struct type
*siginfo_type
;
1649 struct cleanup
*cleanups
;
1651 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1654 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1656 buf
= (gdb_byte
*) xmalloc (TYPE_LENGTH (siginfo_type
));
1657 cleanups
= make_cleanup (xfree
, buf
);
1659 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1660 buf
, 0, TYPE_LENGTH (siginfo_type
));
1661 if (bytes_read
== TYPE_LENGTH (siginfo_type
))
1663 discard_cleanups (cleanups
);
1668 do_cleanups (cleanups
);
1675 struct linux_corefile_thread_data
1677 struct gdbarch
*gdbarch
;
1681 enum gdb_signal stop_signal
;
1684 /* Records the thread's register state for the corefile note
1688 linux_corefile_thread (struct thread_info
*info
,
1689 struct linux_corefile_thread_data
*args
)
1691 struct cleanup
*old_chain
;
1692 struct regcache
*regcache
;
1693 gdb_byte
*siginfo_data
;
1694 LONGEST siginfo_size
= 0;
1696 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1698 old_chain
= save_inferior_ptid ();
1699 inferior_ptid
= info
->ptid
;
1700 target_fetch_registers (regcache
, -1);
1701 siginfo_data
= linux_get_siginfo_data (args
->gdbarch
, &siginfo_size
);
1702 do_cleanups (old_chain
);
1704 old_chain
= make_cleanup (xfree
, siginfo_data
);
1706 args
->note_data
= linux_collect_thread_registers
1707 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1708 args
->note_size
, args
->stop_signal
);
1710 /* Don't return anything if we got no register information above,
1711 such a core file is useless. */
1712 if (args
->note_data
!= NULL
)
1713 if (siginfo_data
!= NULL
)
1714 args
->note_data
= elfcore_write_note (args
->obfd
,
1718 siginfo_data
, siginfo_size
);
1720 do_cleanups (old_chain
);
1723 /* Fill the PRPSINFO structure with information about the process being
1724 debugged. Returns 1 in case of success, 0 for failures. Please note that
1725 even if the structure cannot be entirely filled (e.g., GDB was unable to
1726 gather information about the process UID/GID), this function will still
1727 return 1 since some information was already recorded. It will only return
1728 0 iff nothing can be gathered. */
1731 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1733 /* The filename which we will use to obtain some info about the process.
1734 We will basically use this to store the `/proc/PID/FILENAME' file. */
1736 /* The full name of the program which generated the corefile. */
1738 /* The basename of the executable. */
1739 const char *basename
;
1740 /* The arguments of the program. */
1743 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1744 char *proc_stat
, *proc_status
;
1745 /* Temporary buffer. */
1747 /* The valid states of a process, according to the Linux kernel. */
1748 const char valid_states
[] = "RSDTZW";
1749 /* The program state. */
1750 const char *prog_state
;
1751 /* The state of the process. */
1753 /* The PID of the program which generated the corefile. */
1755 /* Process flags. */
1756 unsigned int pr_flag
;
1757 /* Process nice value. */
1759 /* The number of fields read by `sscanf'. */
1764 gdb_assert (p
!= NULL
);
1766 /* Obtaining PID and filename. */
1767 pid
= ptid_get_pid (inferior_ptid
);
1768 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1769 fname
= target_fileio_read_stralloc (NULL
, filename
);
1771 if (fname
== NULL
|| *fname
== '\0')
1773 /* No program name was read, so we won't be able to retrieve more
1774 information about the process. */
1779 c
= make_cleanup (xfree
, fname
);
1780 memset (p
, 0, sizeof (*p
));
1782 /* Defining the PID. */
1785 /* Copying the program name. Only the basename matters. */
1786 basename
= lbasename (fname
);
1787 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1788 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1790 infargs
= get_inferior_args ();
1792 psargs
= xstrdup (fname
);
1793 if (infargs
!= NULL
)
1794 psargs
= reconcat (psargs
, psargs
, " ", infargs
, (char *) NULL
);
1796 make_cleanup (xfree
, psargs
);
1798 strncpy (p
->pr_psargs
, psargs
, sizeof (p
->pr_psargs
));
1799 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1801 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1802 proc_stat
= target_fileio_read_stralloc (NULL
, filename
);
1803 make_cleanup (xfree
, proc_stat
);
1805 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1807 /* Despite being unable to read more information about the
1808 process, we return 1 here because at least we have its
1809 command line, PID and arguments. */
1814 /* Ok, we have the stats. It's time to do a little parsing of the
1815 contents of the buffer, so that we end up reading what we want.
1817 The following parsing mechanism is strongly based on the
1818 information generated by the `fs/proc/array.c' file, present in
1819 the Linux kernel tree. More details about how the information is
1820 displayed can be obtained by seeing the manpage of proc(5),
1821 specifically under the entry of `/proc/[pid]/stat'. */
1823 /* Getting rid of the PID, since we already have it. */
1824 while (isdigit (*proc_stat
))
1827 proc_stat
= skip_spaces (proc_stat
);
1829 /* ps command also relies on no trailing fields ever contain ')'. */
1830 proc_stat
= strrchr (proc_stat
, ')');
1831 if (proc_stat
== NULL
)
1838 proc_stat
= skip_spaces (proc_stat
);
1840 n_fields
= sscanf (proc_stat
,
1841 "%c" /* Process state. */
1842 "%d%d%d" /* Parent PID, group ID, session ID. */
1843 "%*d%*d" /* tty_nr, tpgid (not used). */
1845 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1846 cmajflt (not used). */
1847 "%*s%*s%*s%*s" /* utime, stime, cutime,
1848 cstime (not used). */
1849 "%*s" /* Priority (not used). */
1852 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1858 /* Again, we couldn't read the complementary information about
1859 the process state. However, we already have minimal
1860 information, so we just return 1 here. */
1865 /* Filling the structure fields. */
1866 prog_state
= strchr (valid_states
, pr_sname
);
1867 if (prog_state
!= NULL
)
1868 p
->pr_state
= prog_state
- valid_states
;
1871 /* Zero means "Running". */
1875 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1876 p
->pr_zomb
= p
->pr_sname
== 'Z';
1877 p
->pr_nice
= pr_nice
;
1878 p
->pr_flag
= pr_flag
;
1880 /* Finally, obtaining the UID and GID. For that, we read and parse the
1881 contents of the `/proc/PID/status' file. */
1882 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1883 proc_status
= target_fileio_read_stralloc (NULL
, filename
);
1884 make_cleanup (xfree
, proc_status
);
1886 if (proc_status
== NULL
|| *proc_status
== '\0')
1888 /* Returning 1 since we already have a bunch of information. */
1893 /* Extracting the UID. */
1894 tmpstr
= strstr (proc_status
, "Uid:");
1897 /* Advancing the pointer to the beginning of the UID. */
1898 tmpstr
+= sizeof ("Uid:");
1899 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1902 if (isdigit (*tmpstr
))
1903 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1906 /* Extracting the GID. */
1907 tmpstr
= strstr (proc_status
, "Gid:");
1910 /* Advancing the pointer to the beginning of the GID. */
1911 tmpstr
+= sizeof ("Gid:");
1912 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1915 if (isdigit (*tmpstr
))
1916 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1924 /* Build the note section for a corefile, and return it in a malloc
1928 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1930 struct linux_corefile_thread_data thread_args
;
1931 struct elf_internal_linux_prpsinfo prpsinfo
;
1932 char *note_data
= NULL
;
1935 struct thread_info
*curr_thr
, *signalled_thr
, *thr
;
1937 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1940 if (linux_fill_prpsinfo (&prpsinfo
))
1942 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch
))
1944 note_data
= gdbarch_elfcore_write_linux_prpsinfo (gdbarch
, obfd
,
1945 note_data
, note_size
,
1950 if (gdbarch_ptr_bit (gdbarch
) == 64)
1951 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1952 note_data
, note_size
,
1955 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1956 note_data
, note_size
,
1961 /* Thread register information. */
1964 update_thread_list ();
1966 CATCH (e
, RETURN_MASK_ERROR
)
1968 exception_print (gdb_stderr
, e
);
1972 /* Like the kernel, prefer dumping the signalled thread first.
1973 "First thread" is what tools use to infer the signalled thread.
1974 In case there's more than one signalled thread, prefer the
1975 current thread, if it is signalled. */
1976 curr_thr
= inferior_thread ();
1977 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1978 signalled_thr
= curr_thr
;
1981 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
1982 if (signalled_thr
== NULL
)
1983 signalled_thr
= curr_thr
;
1986 thread_args
.gdbarch
= gdbarch
;
1987 thread_args
.obfd
= obfd
;
1988 thread_args
.note_data
= note_data
;
1989 thread_args
.note_size
= note_size
;
1990 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1992 linux_corefile_thread (signalled_thr
, &thread_args
);
1993 ALL_NON_EXITED_THREADS (thr
)
1995 if (thr
== signalled_thr
)
1997 if (ptid_get_pid (thr
->ptid
) != ptid_get_pid (inferior_ptid
))
2000 linux_corefile_thread (thr
, &thread_args
);
2003 note_data
= thread_args
.note_data
;
2007 /* Auxillary vector. */
2008 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
2012 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
2013 "CORE", NT_AUXV
, auxv
, auxv_len
);
2020 /* SPU information. */
2021 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
2025 /* File mappings. */
2026 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
2027 note_data
, note_size
);
2032 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2033 gdbarch.h. This function is not static because it is exported to
2034 other -tdep files. */
2037 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2042 return GDB_SIGNAL_0
;
2045 return GDB_SIGNAL_HUP
;
2048 return GDB_SIGNAL_INT
;
2051 return GDB_SIGNAL_QUIT
;
2054 return GDB_SIGNAL_ILL
;
2057 return GDB_SIGNAL_TRAP
;
2060 return GDB_SIGNAL_ABRT
;
2063 return GDB_SIGNAL_BUS
;
2066 return GDB_SIGNAL_FPE
;
2069 return GDB_SIGNAL_KILL
;
2072 return GDB_SIGNAL_USR1
;
2075 return GDB_SIGNAL_SEGV
;
2078 return GDB_SIGNAL_USR2
;
2081 return GDB_SIGNAL_PIPE
;
2084 return GDB_SIGNAL_ALRM
;
2087 return GDB_SIGNAL_TERM
;
2090 return GDB_SIGNAL_CHLD
;
2093 return GDB_SIGNAL_CONT
;
2096 return GDB_SIGNAL_STOP
;
2099 return GDB_SIGNAL_TSTP
;
2102 return GDB_SIGNAL_TTIN
;
2105 return GDB_SIGNAL_TTOU
;
2108 return GDB_SIGNAL_URG
;
2111 return GDB_SIGNAL_XCPU
;
2114 return GDB_SIGNAL_XFSZ
;
2116 case LINUX_SIGVTALRM
:
2117 return GDB_SIGNAL_VTALRM
;
2120 return GDB_SIGNAL_PROF
;
2122 case LINUX_SIGWINCH
:
2123 return GDB_SIGNAL_WINCH
;
2125 /* No way to differentiate between SIGIO and SIGPOLL.
2126 Therefore, we just handle the first one. */
2128 return GDB_SIGNAL_IO
;
2131 return GDB_SIGNAL_PWR
;
2134 return GDB_SIGNAL_SYS
;
2136 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2137 therefore we have to handle them here. */
2138 case LINUX_SIGRTMIN
:
2139 return GDB_SIGNAL_REALTIME_32
;
2141 case LINUX_SIGRTMAX
:
2142 return GDB_SIGNAL_REALTIME_64
;
2145 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2147 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2149 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2152 return GDB_SIGNAL_UNKNOWN
;
2155 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2156 gdbarch.h. This function is not static because it is exported to
2157 other -tdep files. */
2160 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2161 enum gdb_signal signal
)
2168 case GDB_SIGNAL_HUP
:
2169 return LINUX_SIGHUP
;
2171 case GDB_SIGNAL_INT
:
2172 return LINUX_SIGINT
;
2174 case GDB_SIGNAL_QUIT
:
2175 return LINUX_SIGQUIT
;
2177 case GDB_SIGNAL_ILL
:
2178 return LINUX_SIGILL
;
2180 case GDB_SIGNAL_TRAP
:
2181 return LINUX_SIGTRAP
;
2183 case GDB_SIGNAL_ABRT
:
2184 return LINUX_SIGABRT
;
2186 case GDB_SIGNAL_FPE
:
2187 return LINUX_SIGFPE
;
2189 case GDB_SIGNAL_KILL
:
2190 return LINUX_SIGKILL
;
2192 case GDB_SIGNAL_BUS
:
2193 return LINUX_SIGBUS
;
2195 case GDB_SIGNAL_SEGV
:
2196 return LINUX_SIGSEGV
;
2198 case GDB_SIGNAL_SYS
:
2199 return LINUX_SIGSYS
;
2201 case GDB_SIGNAL_PIPE
:
2202 return LINUX_SIGPIPE
;
2204 case GDB_SIGNAL_ALRM
:
2205 return LINUX_SIGALRM
;
2207 case GDB_SIGNAL_TERM
:
2208 return LINUX_SIGTERM
;
2210 case GDB_SIGNAL_URG
:
2211 return LINUX_SIGURG
;
2213 case GDB_SIGNAL_STOP
:
2214 return LINUX_SIGSTOP
;
2216 case GDB_SIGNAL_TSTP
:
2217 return LINUX_SIGTSTP
;
2219 case GDB_SIGNAL_CONT
:
2220 return LINUX_SIGCONT
;
2222 case GDB_SIGNAL_CHLD
:
2223 return LINUX_SIGCHLD
;
2225 case GDB_SIGNAL_TTIN
:
2226 return LINUX_SIGTTIN
;
2228 case GDB_SIGNAL_TTOU
:
2229 return LINUX_SIGTTOU
;
2234 case GDB_SIGNAL_XCPU
:
2235 return LINUX_SIGXCPU
;
2237 case GDB_SIGNAL_XFSZ
:
2238 return LINUX_SIGXFSZ
;
2240 case GDB_SIGNAL_VTALRM
:
2241 return LINUX_SIGVTALRM
;
2243 case GDB_SIGNAL_PROF
:
2244 return LINUX_SIGPROF
;
2246 case GDB_SIGNAL_WINCH
:
2247 return LINUX_SIGWINCH
;
2249 case GDB_SIGNAL_USR1
:
2250 return LINUX_SIGUSR1
;
2252 case GDB_SIGNAL_USR2
:
2253 return LINUX_SIGUSR2
;
2255 case GDB_SIGNAL_PWR
:
2256 return LINUX_SIGPWR
;
2258 case GDB_SIGNAL_POLL
:
2259 return LINUX_SIGPOLL
;
2261 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2262 therefore we have to handle it here. */
2263 case GDB_SIGNAL_REALTIME_32
:
2264 return LINUX_SIGRTMIN
;
2266 /* Same comment applies to _64. */
2267 case GDB_SIGNAL_REALTIME_64
:
2268 return LINUX_SIGRTMAX
;
2271 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2272 if (signal
>= GDB_SIGNAL_REALTIME_33
2273 && signal
<= GDB_SIGNAL_REALTIME_63
)
2275 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2277 return LINUX_SIGRTMIN
+ 1 + offset
;
2283 /* Helper for linux_vsyscall_range that does the real work of finding
2284 the vsyscall's address range. */
2287 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2293 if (target_auxv_search (¤t_target
, AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2296 /* It doesn't make sense to access the host's /proc when debugging a
2297 core file. Instead, look for the PT_LOAD segment that matches
2299 if (!target_has_execution
)
2301 Elf_Internal_Phdr
*phdrs
;
2305 phdrs_size
= bfd_get_elf_phdr_upper_bound (core_bfd
);
2306 if (phdrs_size
== -1)
2309 phdrs
= (Elf_Internal_Phdr
*) alloca (phdrs_size
);
2310 num_phdrs
= bfd_get_elf_phdrs (core_bfd
, phdrs
);
2311 if (num_phdrs
== -1)
2314 for (i
= 0; i
< num_phdrs
; i
++)
2315 if (phdrs
[i
].p_type
== PT_LOAD
2316 && phdrs
[i
].p_vaddr
== range
->start
)
2318 range
->length
= phdrs
[i
].p_memsz
;
2325 /* We need to know the real target PID to access /proc. */
2326 if (current_inferior ()->fake_pid_p
)
2329 pid
= current_inferior ()->pid
;
2331 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2332 reading /proc/PID/maps (2). The later identifies thread stacks
2333 in the output, which requires scanning every thread in the thread
2334 group to check whether a VMA is actually a thread's stack. With
2335 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2336 a few thousand threads, (1) takes a few miliseconds, while (2)
2337 takes several seconds. Also note that "smaps", what we read for
2338 determining core dump mappings, is even slower than "maps". */
2339 xsnprintf (filename
, sizeof filename
, "/proc/%ld/task/%ld/maps", pid
, pid
);
2340 data
= target_fileio_read_stralloc (NULL
, filename
);
2343 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
2345 char *saveptr
= NULL
;
2347 for (line
= strtok_r (data
, "\n", &saveptr
);
2349 line
= strtok_r (NULL
, "\n", &saveptr
))
2351 ULONGEST addr
, endaddr
;
2352 const char *p
= line
;
2354 addr
= strtoulst (p
, &p
, 16);
2355 if (addr
== range
->start
)
2359 endaddr
= strtoulst (p
, &p
, 16);
2360 range
->length
= endaddr
- addr
;
2361 do_cleanups (cleanup
);
2366 do_cleanups (cleanup
);
2369 warning (_("unable to open /proc file '%s'"), filename
);
2374 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2375 caching, and defers the real work to linux_vsyscall_range_raw. */
2378 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2380 struct linux_info
*info
= get_linux_inferior_data ();
2382 if (info
->vsyscall_range_p
== 0)
2384 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2385 info
->vsyscall_range_p
= 1;
2387 info
->vsyscall_range_p
= -1;
2390 if (info
->vsyscall_range_p
< 0)
2393 *range
= info
->vsyscall_range
;
2397 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2398 definitions would be dependent on compilation host. */
2399 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2400 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2402 /* See gdbarch.sh 'infcall_mmap'. */
2405 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2407 struct objfile
*objf
;
2408 /* Do there still exist any Linux systems without "mmap64"?
2409 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2410 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2411 struct value
*addr_val
;
2412 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2416 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2418 struct value
*arg
[ARG_LAST
];
2420 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2422 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2423 arg
[ARG_LENGTH
] = value_from_ulongest
2424 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2425 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2426 | GDB_MMAP_PROT_EXEC
))
2428 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2429 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2430 GDB_MMAP_MAP_PRIVATE
2431 | GDB_MMAP_MAP_ANONYMOUS
);
2432 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2433 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2435 addr_val
= call_function_by_hand (mmap_val
, ARG_LAST
, arg
);
2436 retval
= value_as_address (addr_val
);
2437 if (retval
== (CORE_ADDR
) -1)
2438 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2443 /* See gdbarch.sh 'infcall_munmap'. */
2446 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2448 struct objfile
*objf
;
2449 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2450 struct value
*retval_val
;
2451 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2455 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2457 struct value
*arg
[ARG_LAST
];
2459 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2461 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2462 arg
[ARG_LENGTH
] = value_from_ulongest
2463 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2464 retval_val
= call_function_by_hand (munmap_val
, ARG_LAST
, arg
);
2465 retval
= value_as_long (retval_val
);
2467 warning (_("Failed inferior munmap call at %s for %s bytes, "
2468 "errno is changed."),
2469 hex_string (addr
), pulongest (size
));
2472 /* See linux-tdep.h. */
2475 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2480 /* Determine entry point from target auxiliary vector. This avoids
2481 the need for symbols. Also, when debugging a stand-alone SPU
2482 executable, entry_point_address () will point to an SPU
2483 local-store address and is thus not usable as displaced stepping
2484 location. The auxiliary vector gets us the PowerPC-side entry
2485 point address instead. */
2486 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
2487 throw_error (NOT_SUPPORTED_ERROR
,
2488 _("Cannot find AT_ENTRY auxiliary vector entry."));
2490 /* Make certain that the address points at real code, and not a
2491 function descriptor. */
2492 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2495 /* Inferior calls also use the entry point as a breakpoint location.
2496 We don't want displaced stepping to interfere with those
2497 breakpoints, so leave space. */
2498 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2504 /* Display whether the gcore command is using the
2505 /proc/PID/coredump_filter file. */
2508 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2509 struct cmd_list_element
*c
, const char *value
)
2511 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2512 " corefiles is %s.\n"), value
);
2515 /* To be called from the various GDB_OSABI_LINUX handlers for the
2516 various GNU/Linux architectures and machine types. */
2519 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2521 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2522 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2523 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2524 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2525 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2526 set_gdbarch_has_shared_address_space (gdbarch
,
2527 linux_has_shared_address_space
);
2528 set_gdbarch_gdb_signal_from_target (gdbarch
,
2529 linux_gdb_signal_from_target
);
2530 set_gdbarch_gdb_signal_to_target (gdbarch
,
2531 linux_gdb_signal_to_target
);
2532 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2533 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2534 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2535 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2538 /* Provide a prototype to silence -Wmissing-prototypes. */
2539 extern initialize_file_ftype _initialize_linux_tdep
;
2542 _initialize_linux_tdep (void)
2544 linux_gdbarch_data_handle
=
2545 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2547 /* Set a cache per-inferior. */
2549 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2550 /* Observers used to invalidate the cache when needed. */
2551 observer_attach_inferior_exit (invalidate_linux_cache_inf
);
2552 observer_attach_inferior_appeared (invalidate_linux_cache_inf
);
2554 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2555 &use_coredump_filter
, _("\
2556 Set whether gcore should consider /proc/PID/coredump_filter."),
2558 Show whether gcore should consider /proc/PID/coredump_filter."),
2560 Use this command to set whether gcore should consider the contents\n\
2561 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2562 about this file, refer to the manpage of core(5)."),
2563 NULL
, show_use_coredump_filter
,
2564 &setlist
, &showlist
);