1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
39 #include "gdb_regex.h"
40 #include "common/enum-flags.h"
44 /* This enum represents the values that the user can choose when
45 informing the Linux kernel about which memory mappings will be
46 dumped in a corefile. They are described in the file
47 Documentation/filesystems/proc.txt, inside the Linux kernel
52 COREFILTER_ANON_PRIVATE
= 1 << 0,
53 COREFILTER_ANON_SHARED
= 1 << 1,
54 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
55 COREFILTER_MAPPED_SHARED
= 1 << 3,
56 COREFILTER_ELF_HEADERS
= 1 << 4,
57 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
58 COREFILTER_HUGETLB_SHARED
= 1 << 6,
60 DEF_ENUM_FLAGS_TYPE (enum filter_flag
, filter_flags
);
62 /* This struct is used to map flags found in the "VmFlags:" field (in
63 the /proc/<PID>/smaps file). */
67 /* Zero if this structure has not been initialized yet. It
68 probably means that the Linux kernel being used does not emit
69 the "VmFlags:" field on "/proc/PID/smaps". */
71 unsigned int initialized_p
: 1;
73 /* Memory mapped I/O area (VM_IO, "io"). */
75 unsigned int io_page
: 1;
77 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
79 unsigned int uses_huge_tlb
: 1;
81 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
83 unsigned int exclude_coredump
: 1;
85 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
87 unsigned int shared_mapping
: 1;
90 /* Whether to take the /proc/PID/coredump_filter into account when
91 generating a corefile. */
93 static int use_coredump_filter
= 1;
95 /* This enum represents the signals' numbers on a generic architecture
96 running the Linux kernel. The definition of "generic" comes from
97 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
98 tree, which is the "de facto" implementation of signal numbers to
99 be used by new architecture ports.
101 For those architectures which have differences between the generic
102 standard (e.g., Alpha), we define the different signals (and *only*
103 those) in the specific target-dependent file (e.g.,
104 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
105 tdep file for more information.
107 ARM deserves a special mention here. On the file
108 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
109 (and ARM-only) signal, which is SIGSWI, with the same number as
110 SIGRTMIN. This signal is used only for a very specific target,
111 called ArthurOS (from RISCOS). Therefore, we do not handle it on
112 the ARM-tdep file, and we can safely use the generic signal handler
113 here for ARM targets.
115 As stated above, this enum is derived from
116 <include/uapi/asm-generic/signal.h>, from the Linux kernel
137 LINUX_SIGSTKFLT
= 16,
147 LINUX_SIGVTALRM
= 26,
151 LINUX_SIGPOLL
= LINUX_SIGIO
,
154 LINUX_SIGUNUSED
= 31,
160 static struct gdbarch_data
*linux_gdbarch_data_handle
;
162 struct linux_gdbarch_data
164 struct type
*siginfo_type
;
168 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
170 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
173 static struct linux_gdbarch_data
*
174 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
176 return ((struct linux_gdbarch_data
*)
177 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
180 /* Per-inferior data key. */
181 static const struct inferior_data
*linux_inferior_data
;
183 /* Linux-specific cached data. This is used by GDB for caching
184 purposes for each inferior. This helps reduce the overhead of
185 transfering data from a remote target to the local host. */
188 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
189 if VSYSCALL_RANGE_P is positive. This is cached because getting
190 at this info requires an auxv lookup (which is itself cached),
191 and looking through the inferior's mappings (which change
192 throughout execution and therefore cannot be cached). */
193 struct mem_range vsyscall_range
;
195 /* Zero if we haven't tried looking up the vsyscall's range before
196 yet. Positive if we tried looking it up, and found it. Negative
197 if we tried looking it up but failed. */
198 int vsyscall_range_p
;
201 /* Frees whatever allocated space there is to be freed and sets INF's
202 linux cache data pointer to NULL. */
205 invalidate_linux_cache_inf (struct inferior
*inf
)
207 struct linux_info
*info
;
209 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
213 set_inferior_data (inf
, linux_inferior_data
, NULL
);
217 /* Handles the cleanup of the linux cache for inferior INF. ARG is
218 ignored. Callback for the inferior_appeared and inferior_exit
222 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
224 invalidate_linux_cache_inf (inf
);
227 /* Fetch the linux cache info for INF. This function always returns a
228 valid INFO pointer. */
230 static struct linux_info
*
231 get_linux_inferior_data (void)
233 struct linux_info
*info
;
234 struct inferior
*inf
= current_inferior ();
236 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
239 info
= XCNEW (struct linux_info
);
240 set_inferior_data (inf
, linux_inferior_data
, info
);
246 /* See linux-tdep.h. */
249 linux_get_siginfo_type_with_fields (struct gdbarch
*gdbarch
,
250 linux_siginfo_extra_fields extra_fields
)
252 struct linux_gdbarch_data
*linux_gdbarch_data
;
253 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
;
254 struct type
*uid_type
, *pid_type
;
255 struct type
*sigval_type
, *clock_type
;
256 struct type
*siginfo_type
, *sifields_type
;
259 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
260 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
261 return linux_gdbarch_data
->siginfo_type
;
263 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
265 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
267 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
269 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
272 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
273 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
274 append_composite_type_field (sigval_type
, "sival_int", int_type
);
275 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
278 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
279 TYPE_LENGTH (int_type
), "__pid_t");
280 TYPE_TARGET_TYPE (pid_type
) = int_type
;
281 TYPE_TARGET_STUB (pid_type
) = 1;
284 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
285 TYPE_LENGTH (uint_type
), "__uid_t");
286 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
287 TYPE_TARGET_STUB (uid_type
) = 1;
290 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
291 TYPE_LENGTH (long_type
), "__clock_t");
292 TYPE_TARGET_TYPE (clock_type
) = long_type
;
293 TYPE_TARGET_STUB (clock_type
) = 1;
296 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
299 const int si_max_size
= 128;
301 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
304 if (gdbarch_ptr_bit (gdbarch
) == 64)
305 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
307 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
308 append_composite_type_field (sifields_type
, "_pad",
309 init_vector_type (int_type
, si_pad_size
));
313 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
314 append_composite_type_field (type
, "si_pid", pid_type
);
315 append_composite_type_field (type
, "si_uid", uid_type
);
316 append_composite_type_field (sifields_type
, "_kill", type
);
319 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
320 append_composite_type_field (type
, "si_tid", int_type
);
321 append_composite_type_field (type
, "si_overrun", int_type
);
322 append_composite_type_field (type
, "si_sigval", sigval_type
);
323 append_composite_type_field (sifields_type
, "_timer", type
);
326 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
327 append_composite_type_field (type
, "si_pid", pid_type
);
328 append_composite_type_field (type
, "si_uid", uid_type
);
329 append_composite_type_field (type
, "si_sigval", sigval_type
);
330 append_composite_type_field (sifields_type
, "_rt", type
);
333 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
334 append_composite_type_field (type
, "si_pid", pid_type
);
335 append_composite_type_field (type
, "si_uid", uid_type
);
336 append_composite_type_field (type
, "si_status", int_type
);
337 append_composite_type_field (type
, "si_utime", clock_type
);
338 append_composite_type_field (type
, "si_stime", clock_type
);
339 append_composite_type_field (sifields_type
, "_sigchld", type
);
342 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
343 append_composite_type_field (type
, "si_addr", void_ptr_type
);
344 append_composite_type_field (sifields_type
, "_sigfault", type
);
347 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
348 append_composite_type_field (type
, "si_band", long_type
);
349 append_composite_type_field (type
, "si_fd", int_type
);
350 append_composite_type_field (sifields_type
, "_sigpoll", type
);
353 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
354 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
355 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
356 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
357 append_composite_type_field (siginfo_type
, "si_code", int_type
);
358 append_composite_type_field_aligned (siginfo_type
,
359 "_sifields", sifields_type
,
360 TYPE_LENGTH (long_type
));
362 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
367 /* This function is suitable for architectures that don't
368 extend/override the standard siginfo structure. */
371 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
373 return linux_get_siginfo_type_with_fields (gdbarch
, 0);
376 /* Return true if the target is running on uClinux instead of normal
380 linux_is_uclinux (void)
384 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
385 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
389 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
391 return linux_is_uclinux ();
394 /* This is how we want PTIDs from core files to be printed. */
397 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
401 if (ptid_get_lwp (ptid
) != 0)
403 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
407 return normal_pid_to_str (ptid
);
410 /* Service function for corefiles and info proc. */
413 read_mapping (const char *line
,
414 ULONGEST
*addr
, ULONGEST
*endaddr
,
415 const char **permissions
, size_t *permissions_len
,
417 const char **device
, size_t *device_len
,
419 const char **filename
)
421 const char *p
= line
;
423 *addr
= strtoulst (p
, &p
, 16);
426 *endaddr
= strtoulst (p
, &p
, 16);
428 p
= skip_spaces_const (p
);
430 while (*p
&& !isspace (*p
))
432 *permissions_len
= p
- *permissions
;
434 *offset
= strtoulst (p
, &p
, 16);
436 p
= skip_spaces_const (p
);
438 while (*p
&& !isspace (*p
))
440 *device_len
= p
- *device
;
442 *inode
= strtoulst (p
, &p
, 10);
444 p
= skip_spaces_const (p
);
448 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
450 This function was based on the documentation found on
451 <Documentation/filesystems/proc.txt>, on the Linux kernel.
453 Linux kernels before commit
454 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
458 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
460 char *saveptr
= NULL
;
463 v
->initialized_p
= 1;
464 p
= skip_to_space (p
);
467 for (s
= strtok_r (p
, " ", &saveptr
);
469 s
= strtok_r (NULL
, " ", &saveptr
))
471 if (strcmp (s
, "io") == 0)
473 else if (strcmp (s
, "ht") == 0)
474 v
->uses_huge_tlb
= 1;
475 else if (strcmp (s
, "dd") == 0)
476 v
->exclude_coredump
= 1;
477 else if (strcmp (s
, "sh") == 0)
478 v
->shared_mapping
= 1;
482 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
484 FILENAME is the name of the file present in the first line of the
485 memory mapping, in the "/proc/PID/smaps" output. For example, if
488 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
490 Then FILENAME will be "/path/to/file". */
493 mapping_is_anonymous_p (const char *filename
)
495 static regex_t dev_zero_regex
, shmem_file_regex
, file_deleted_regex
;
496 static int init_regex_p
= 0;
500 struct cleanup
*c
= make_cleanup (null_cleanup
, NULL
);
502 /* Let's be pessimistic and assume there will be an error while
503 compiling the regex'es. */
506 /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
507 without the "(deleted)" string in the end). We know for
508 sure, based on the Linux kernel code, that memory mappings
509 whose associated filename is "/dev/zero" are guaranteed to be
511 compile_rx_or_error (&dev_zero_regex
, "^/dev/zero\\( (deleted)\\)\\?$",
512 _("Could not compile regex to match /dev/zero "
514 /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
515 without the "(deleted)" string in the end). These filenames
516 refer to shared memory (shmem), and memory mappings
517 associated with them are MAP_ANONYMOUS as well. */
518 compile_rx_or_error (&shmem_file_regex
,
519 "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
520 _("Could not compile regex to match shmem "
522 /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
523 Linux kernel's 'n_link == 0' code, which is responsible to
524 decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
525 mapping. In other words, if FILE_DELETED_REGEX matches, it
526 does not necessarily mean that we are dealing with an
527 anonymous shared mapping. However, there is no easy way to
528 detect this currently, so this is the best approximation we
531 As a result, GDB will dump readonly pages of deleted
532 executables when using the default value of coredump_filter
533 (0x33), while the Linux kernel will not dump those pages.
534 But we can live with that. */
535 compile_rx_or_error (&file_deleted_regex
, " (deleted)$",
536 _("Could not compile regex to match "
537 "'<file> (deleted)'"));
538 /* We will never release these regexes, so just discard the
540 discard_cleanups (c
);
542 /* If we reached this point, then everything succeeded. */
546 if (init_regex_p
== -1)
548 const char deleted
[] = " (deleted)";
549 size_t del_len
= sizeof (deleted
) - 1;
550 size_t filename_len
= strlen (filename
);
552 /* There was an error while compiling the regex'es above. In
553 order to try to give some reliable information to the caller,
554 we just try to find the string " (deleted)" in the filename.
555 If we managed to find it, then we assume the mapping is
557 return (filename_len
>= del_len
558 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
561 if (*filename
== '\0'
562 || regexec (&dev_zero_regex
, filename
, 0, NULL
, 0) == 0
563 || regexec (&shmem_file_regex
, filename
, 0, NULL
, 0) == 0
564 || regexec (&file_deleted_regex
, filename
, 0, NULL
, 0) == 0)
570 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
571 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
572 greater than 0 if it should.
574 In a nutshell, this is the logic that we follow in order to decide
575 if a mapping should be dumped or not.
577 - If the mapping is associated to a file whose name ends with
578 " (deleted)", or if the file is "/dev/zero", or if it is
579 "/SYSV%08x" (shared memory), or if there is no file associated
580 with it, or if the AnonHugePages: or the Anonymous: fields in the
581 /proc/PID/smaps have contents, then GDB considers this mapping to
582 be anonymous. Otherwise, GDB considers this mapping to be a
583 file-backed mapping (because there will be a file associated with
586 It is worth mentioning that, from all those checks described
587 above, the most fragile is the one to see if the file name ends
588 with " (deleted)". This does not necessarily mean that the
589 mapping is anonymous, because the deleted file associated with
590 the mapping may have been a hard link to another file, for
591 example. The Linux kernel checks to see if "i_nlink == 0", but
592 GDB cannot easily (and normally) do this check (iff running as
593 root, it could find the mapping in /proc/PID/map_files/ and
594 determine whether there still are other hard links to the
595 inode/file). Therefore, we made a compromise here, and we assume
596 that if the file name ends with " (deleted)", then the mapping is
597 indeed anonymous. FWIW, this is something the Linux kernel could
598 do better: expose this information in a more direct way.
600 - If we see the flag "sh" in the "VmFlags:" field (in
601 /proc/PID/smaps), then certainly the memory mapping is shared
602 (VM_SHARED). If we have access to the VmFlags, and we don't see
603 the "sh" there, then certainly the mapping is private. However,
604 Linux kernels before commit
605 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
606 "VmFlags:" field; in that case, we use another heuristic: if we
607 see 'p' in the permission flags, then we assume that the mapping
608 is private, even though the presence of the 's' flag there would
609 mean VM_MAYSHARE, which means the mapping could still be private.
610 This should work OK enough, however. */
613 dump_mapping_p (filter_flags filterflags
, const struct smaps_vmflags
*v
,
614 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
615 const char *filename
)
617 /* Initially, we trust in what we received from our caller. This
618 value may not be very precise (i.e., it was probably gathered
619 from the permission line in the /proc/PID/smaps list, which
620 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
621 what we have until we take a look at the "VmFlags:" field
622 (assuming that the version of the Linux kernel being used
623 supports it, of course). */
624 int private_p
= maybe_private_p
;
626 /* We always dump vDSO and vsyscall mappings, because it's likely that
627 there'll be no file to read the contents from at core load time.
628 The kernel does the same. */
629 if (strcmp ("[vdso]", filename
) == 0
630 || strcmp ("[vsyscall]", filename
) == 0)
633 if (v
->initialized_p
)
635 /* We never dump I/O mappings. */
639 /* Check if we should exclude this mapping. */
640 if (v
->exclude_coredump
)
643 /* Update our notion of whether this mapping is shared or
644 private based on a trustworthy value. */
645 private_p
= !v
->shared_mapping
;
647 /* HugeTLB checking. */
648 if (v
->uses_huge_tlb
)
650 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
651 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
660 if (mapping_anon_p
&& mapping_file_p
)
662 /* This is a special situation. It can happen when we see a
663 mapping that is file-backed, but that contains anonymous
665 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
666 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
668 else if (mapping_anon_p
)
669 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
671 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
675 if (mapping_anon_p
&& mapping_file_p
)
677 /* This is a special situation. It can happen when we see a
678 mapping that is file-backed, but that contains anonymous
680 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
681 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
683 else if (mapping_anon_p
)
684 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
686 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
690 /* Implement the "info proc" command. */
693 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
694 enum info_proc_what what
)
696 /* A long is used for pid instead of an int to avoid a loss of precision
697 compiler warning from the output of strtoul. */
699 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
700 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
701 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
702 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
703 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
704 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
709 if (args
&& isdigit (args
[0]))
713 pid
= strtoul (args
, &tem
, 10);
718 if (!target_has_execution
)
719 error (_("No current process: you must name one."));
720 if (current_inferior ()->fake_pid_p
)
721 error (_("Can't determine the current process's PID: you must name one."));
723 pid
= current_inferior ()->pid
;
726 args
= skip_spaces_const (args
);
728 error (_("Too many parameters: %s"), args
);
730 printf_filtered (_("process %ld\n"), pid
);
733 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
734 data
= target_fileio_read_stralloc (NULL
, filename
);
737 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
738 printf_filtered ("cmdline = '%s'\n", data
);
739 do_cleanups (cleanup
);
742 warning (_("unable to open /proc file '%s'"), filename
);
746 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
747 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
750 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
751 printf_filtered ("cwd = '%s'\n", data
);
752 do_cleanups (cleanup
);
755 warning (_("unable to read link '%s'"), filename
);
759 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
760 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
763 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
764 printf_filtered ("exe = '%s'\n", data
);
765 do_cleanups (cleanup
);
768 warning (_("unable to read link '%s'"), filename
);
772 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
773 data
= target_fileio_read_stralloc (NULL
, filename
);
776 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
779 printf_filtered (_("Mapped address spaces:\n\n"));
780 if (gdbarch_addr_bit (gdbarch
) == 32)
782 printf_filtered ("\t%10s %10s %10s %10s %s\n",
785 " Size", " Offset", "objfile");
789 printf_filtered (" %18s %18s %10s %10s %s\n",
792 " Size", " Offset", "objfile");
795 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
797 ULONGEST addr
, endaddr
, offset
, inode
;
798 const char *permissions
, *device
, *filename
;
799 size_t permissions_len
, device_len
;
801 read_mapping (line
, &addr
, &endaddr
,
802 &permissions
, &permissions_len
,
803 &offset
, &device
, &device_len
,
806 if (gdbarch_addr_bit (gdbarch
) == 32)
808 printf_filtered ("\t%10s %10s %10s %10s %s\n",
809 paddress (gdbarch
, addr
),
810 paddress (gdbarch
, endaddr
),
811 hex_string (endaddr
- addr
),
813 *filename
? filename
: "");
817 printf_filtered (" %18s %18s %10s %10s %s\n",
818 paddress (gdbarch
, addr
),
819 paddress (gdbarch
, endaddr
),
820 hex_string (endaddr
- addr
),
822 *filename
? filename
: "");
826 do_cleanups (cleanup
);
829 warning (_("unable to open /proc file '%s'"), filename
);
833 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
834 data
= target_fileio_read_stralloc (NULL
, filename
);
837 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
838 puts_filtered (data
);
839 do_cleanups (cleanup
);
842 warning (_("unable to open /proc file '%s'"), filename
);
846 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
847 data
= target_fileio_read_stralloc (NULL
, filename
);
850 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
851 const char *p
= data
;
853 printf_filtered (_("Process: %s\n"),
854 pulongest (strtoulst (p
, &p
, 10)));
856 p
= skip_spaces_const (p
);
859 /* ps command also relies on no trailing fields
861 const char *ep
= strrchr (p
, ')');
864 printf_filtered ("Exec file: %.*s\n",
865 (int) (ep
- p
- 1), p
+ 1);
870 p
= skip_spaces_const (p
);
872 printf_filtered (_("State: %c\n"), *p
++);
875 printf_filtered (_("Parent process: %s\n"),
876 pulongest (strtoulst (p
, &p
, 10)));
878 printf_filtered (_("Process group: %s\n"),
879 pulongest (strtoulst (p
, &p
, 10)));
881 printf_filtered (_("Session id: %s\n"),
882 pulongest (strtoulst (p
, &p
, 10)));
884 printf_filtered (_("TTY: %s\n"),
885 pulongest (strtoulst (p
, &p
, 10)));
887 printf_filtered (_("TTY owner process group: %s\n"),
888 pulongest (strtoulst (p
, &p
, 10)));
891 printf_filtered (_("Flags: %s\n"),
892 hex_string (strtoulst (p
, &p
, 10)));
894 printf_filtered (_("Minor faults (no memory page): %s\n"),
895 pulongest (strtoulst (p
, &p
, 10)));
897 printf_filtered (_("Minor faults, children: %s\n"),
898 pulongest (strtoulst (p
, &p
, 10)));
900 printf_filtered (_("Major faults (memory page faults): %s\n"),
901 pulongest (strtoulst (p
, &p
, 10)));
903 printf_filtered (_("Major faults, children: %s\n"),
904 pulongest (strtoulst (p
, &p
, 10)));
906 printf_filtered (_("utime: %s\n"),
907 pulongest (strtoulst (p
, &p
, 10)));
909 printf_filtered (_("stime: %s\n"),
910 pulongest (strtoulst (p
, &p
, 10)));
912 printf_filtered (_("utime, children: %s\n"),
913 pulongest (strtoulst (p
, &p
, 10)));
915 printf_filtered (_("stime, children: %s\n"),
916 pulongest (strtoulst (p
, &p
, 10)));
918 printf_filtered (_("jiffies remaining in current "
920 pulongest (strtoulst (p
, &p
, 10)));
922 printf_filtered (_("'nice' value: %s\n"),
923 pulongest (strtoulst (p
, &p
, 10)));
925 printf_filtered (_("jiffies until next timeout: %s\n"),
926 pulongest (strtoulst (p
, &p
, 10)));
928 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
929 pulongest (strtoulst (p
, &p
, 10)));
931 printf_filtered (_("start time (jiffies since "
932 "system boot): %s\n"),
933 pulongest (strtoulst (p
, &p
, 10)));
935 printf_filtered (_("Virtual memory size: %s\n"),
936 pulongest (strtoulst (p
, &p
, 10)));
938 printf_filtered (_("Resident set size: %s\n"),
939 pulongest (strtoulst (p
, &p
, 10)));
941 printf_filtered (_("rlim: %s\n"),
942 pulongest (strtoulst (p
, &p
, 10)));
944 printf_filtered (_("Start of text: %s\n"),
945 hex_string (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("End of text: %s\n"),
948 hex_string (strtoulst (p
, &p
, 10)));
950 printf_filtered (_("Start of stack: %s\n"),
951 hex_string (strtoulst (p
, &p
, 10)));
952 #if 0 /* Don't know how architecture-dependent the rest is...
953 Anyway the signal bitmap info is available from "status". */
955 printf_filtered (_("Kernel stack pointer: %s\n"),
956 hex_string (strtoulst (p
, &p
, 10)));
958 printf_filtered (_("Kernel instr pointer: %s\n"),
959 hex_string (strtoulst (p
, &p
, 10)));
961 printf_filtered (_("Pending signals bitmap: %s\n"),
962 hex_string (strtoulst (p
, &p
, 10)));
964 printf_filtered (_("Blocked signals bitmap: %s\n"),
965 hex_string (strtoulst (p
, &p
, 10)));
967 printf_filtered (_("Ignored signals bitmap: %s\n"),
968 hex_string (strtoulst (p
, &p
, 10)));
970 printf_filtered (_("Catched signals bitmap: %s\n"),
971 hex_string (strtoulst (p
, &p
, 10)));
973 printf_filtered (_("wchan (system call): %s\n"),
974 hex_string (strtoulst (p
, &p
, 10)));
976 do_cleanups (cleanup
);
979 warning (_("unable to open /proc file '%s'"), filename
);
983 /* Implement "info proc mappings" for a corefile. */
986 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
989 ULONGEST count
, page_size
;
990 unsigned char *descdata
, *filenames
, *descend
, *contents
;
992 unsigned int addr_size_bits
, addr_size
;
993 struct cleanup
*cleanup
;
994 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
995 /* We assume this for reading 64-bit core files. */
996 gdb_static_assert (sizeof (ULONGEST
) >= 8);
998 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
1001 warning (_("unable to find mappings in core file"));
1005 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
1006 addr_size
= addr_size_bits
/ 8;
1007 note_size
= bfd_get_section_size (section
);
1009 if (note_size
< 2 * addr_size
)
1010 error (_("malformed core note - too short for header"));
1012 contents
= (unsigned char *) xmalloc (note_size
);
1013 cleanup
= make_cleanup (xfree
, contents
);
1014 if (!bfd_get_section_contents (core_bfd
, section
, contents
, 0, note_size
))
1015 error (_("could not get core note contents"));
1017 descdata
= contents
;
1018 descend
= descdata
+ note_size
;
1020 if (descdata
[note_size
- 1] != '\0')
1021 error (_("malformed note - does not end with \\0"));
1023 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1024 descdata
+= addr_size
;
1026 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1027 descdata
+= addr_size
;
1029 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1030 error (_("malformed note - too short for supplied file count"));
1032 printf_filtered (_("Mapped address spaces:\n\n"));
1033 if (gdbarch_addr_bit (gdbarch
) == 32)
1035 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1038 " Size", " Offset", "objfile");
1042 printf_filtered (" %18s %18s %10s %10s %s\n",
1045 " Size", " Offset", "objfile");
1048 filenames
= descdata
+ count
* 3 * addr_size
;
1051 ULONGEST start
, end
, file_ofs
;
1053 if (filenames
== descend
)
1054 error (_("malformed note - filenames end too early"));
1056 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1057 descdata
+= addr_size
;
1058 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1059 descdata
+= addr_size
;
1060 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1061 descdata
+= addr_size
;
1063 file_ofs
*= page_size
;
1065 if (gdbarch_addr_bit (gdbarch
) == 32)
1066 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1067 paddress (gdbarch
, start
),
1068 paddress (gdbarch
, end
),
1069 hex_string (end
- start
),
1070 hex_string (file_ofs
),
1073 printf_filtered (" %18s %18s %10s %10s %s\n",
1074 paddress (gdbarch
, start
),
1075 paddress (gdbarch
, end
),
1076 hex_string (end
- start
),
1077 hex_string (file_ofs
),
1080 filenames
+= 1 + strlen ((char *) filenames
);
1083 do_cleanups (cleanup
);
1086 /* Implement "info proc" for a corefile. */
1089 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1090 enum info_proc_what what
)
1092 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1093 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1099 exe
= bfd_core_file_failing_command (core_bfd
);
1101 printf_filtered ("exe = '%s'\n", exe
);
1103 warning (_("unable to find command name in core file"));
1107 linux_core_info_proc_mappings (gdbarch
, args
);
1109 if (!exe_f
&& !mappings_f
)
1110 error (_("unable to handle request"));
1113 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1114 ULONGEST offset
, ULONGEST inode
,
1115 int read
, int write
,
1116 int exec
, int modified
,
1117 const char *filename
,
1120 /* List memory regions in the inferior for a corefile. */
1123 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1124 linux_find_memory_region_ftype
*func
,
1127 char mapsfilename
[100];
1128 char coredumpfilter_name
[100];
1129 char *data
, *coredumpfilterdata
;
1131 /* Default dump behavior of coredump_filter (0x33), according to
1132 Documentation/filesystems/proc.txt from the Linux kernel
1134 filter_flags filterflags
= (COREFILTER_ANON_PRIVATE
1135 | COREFILTER_ANON_SHARED
1136 | COREFILTER_ELF_HEADERS
1137 | COREFILTER_HUGETLB_PRIVATE
);
1139 /* We need to know the real target PID to access /proc. */
1140 if (current_inferior ()->fake_pid_p
)
1143 pid
= current_inferior ()->pid
;
1145 if (use_coredump_filter
)
1147 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1148 "/proc/%d/coredump_filter", pid
);
1149 coredumpfilterdata
= target_fileio_read_stralloc (NULL
,
1150 coredumpfilter_name
);
1151 if (coredumpfilterdata
!= NULL
)
1155 sscanf (coredumpfilterdata
, "%x", &flags
);
1156 filterflags
= (enum filter_flag
) flags
;
1157 xfree (coredumpfilterdata
);
1161 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1162 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1165 /* Older Linux kernels did not support /proc/PID/smaps. */
1166 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1167 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1172 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
1175 line
= strtok_r (data
, "\n", &t
);
1176 while (line
!= NULL
)
1178 ULONGEST addr
, endaddr
, offset
, inode
;
1179 const char *permissions
, *device
, *filename
;
1180 struct smaps_vmflags v
;
1181 size_t permissions_len
, device_len
;
1182 int read
, write
, exec
, priv
;
1183 int has_anonymous
= 0;
1184 int should_dump_p
= 0;
1188 memset (&v
, 0, sizeof (v
));
1189 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1190 &offset
, &device
, &device_len
, &inode
, &filename
);
1191 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1192 /* If the mapping is not anonymous, then we can consider it
1193 to be file-backed. These two states (anonymous or
1194 file-backed) seem to be exclusive, but they can actually
1195 coexist. For example, if a file-backed mapping has
1196 "Anonymous:" pages (see more below), then the Linux
1197 kernel will dump this mapping when the user specified
1198 that she only wants anonymous mappings in the corefile
1199 (*even* when she explicitly disabled the dumping of
1200 file-backed mappings). */
1201 mapping_file_p
= !mapping_anon_p
;
1203 /* Decode permissions. */
1204 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1205 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1206 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1207 /* 'private' here actually means VM_MAYSHARE, and not
1208 VM_SHARED. In order to know if a mapping is really
1209 private or not, we must check the flag "sh" in the
1210 VmFlags field. This is done by decode_vmflags. However,
1211 if we are using a Linux kernel released before the commit
1212 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1213 not have the VmFlags there. In this case, there is
1214 really no way to know if we are dealing with VM_SHARED,
1215 so we just assume that VM_MAYSHARE is enough. */
1216 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1218 /* Try to detect if region should be dumped by parsing smaps
1220 for (line
= strtok_r (NULL
, "\n", &t
);
1221 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1222 line
= strtok_r (NULL
, "\n", &t
))
1224 char keyword
[64 + 1];
1226 if (sscanf (line
, "%64s", keyword
) != 1)
1228 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1232 if (strcmp (keyword
, "Anonymous:") == 0)
1234 /* Older Linux kernels did not support the
1235 "Anonymous:" counter. Check it here. */
1238 else if (strcmp (keyword
, "VmFlags:") == 0)
1239 decode_vmflags (line
, &v
);
1241 if (strcmp (keyword
, "AnonHugePages:") == 0
1242 || strcmp (keyword
, "Anonymous:") == 0)
1244 unsigned long number
;
1246 if (sscanf (line
, "%*s%lu", &number
) != 1)
1248 warning (_("Error parsing {s,}maps file '%s' number"),
1254 /* Even if we are dealing with a file-backed
1255 mapping, if it contains anonymous pages we
1256 consider it to be *also* an anonymous
1257 mapping, because this is what the Linux
1260 // Dump segments that have been written to.
1261 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1264 Note that if the mapping is already marked as
1265 file-backed (i.e., mapping_file_p is
1266 non-zero), then this is a special case, and
1267 this mapping will be dumped either when the
1268 user wants to dump file-backed *or* anonymous
1276 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1277 mapping_anon_p
, mapping_file_p
,
1281 /* Older Linux kernels did not support the "Anonymous:" counter.
1282 If it is missing, we can't be sure - dump all the pages. */
1286 /* Invoke the callback function to create the corefile segment. */
1288 func (addr
, endaddr
- addr
, offset
, inode
,
1289 read
, write
, exec
, 1, /* MODIFIED is true because we
1290 want to dump the mapping. */
1294 do_cleanups (cleanup
);
1301 /* A structure for passing information through
1302 linux_find_memory_regions_full. */
1304 struct linux_find_memory_regions_data
1306 /* The original callback. */
1308 find_memory_region_ftype func
;
1310 /* The original datum. */
1315 /* A callback for linux_find_memory_regions that converts between the
1316 "full"-style callback and find_memory_region_ftype. */
1319 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1320 ULONGEST offset
, ULONGEST inode
,
1321 int read
, int write
, int exec
, int modified
,
1322 const char *filename
, void *arg
)
1324 struct linux_find_memory_regions_data
*data
1325 = (struct linux_find_memory_regions_data
*) arg
;
1327 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1330 /* A variant of linux_find_memory_regions_full that is suitable as the
1331 gdbarch find_memory_regions method. */
1334 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1335 find_memory_region_ftype func
, void *obfd
)
1337 struct linux_find_memory_regions_data data
;
1342 return linux_find_memory_regions_full (gdbarch
,
1343 linux_find_memory_regions_thunk
,
1347 /* Determine which signal stopped execution. */
1350 find_signalled_thread (struct thread_info
*info
, void *data
)
1352 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1353 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
1359 /* Generate corefile notes for SPU contexts. */
1362 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1364 static const char *spu_files
[] =
1386 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1390 /* Determine list of SPU ids. */
1391 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1394 /* Generate corefile notes for each SPU file. */
1395 for (i
= 0; i
< size
; i
+= 4)
1397 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
1399 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1401 char annex
[32], note_name
[32];
1405 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1406 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1410 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1411 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1431 /* This is used to pass information from
1432 linux_make_mappings_corefile_notes through
1433 linux_find_memory_regions_full. */
1435 struct linux_make_mappings_data
1437 /* Number of files mapped. */
1438 ULONGEST file_count
;
1440 /* The obstack for the main part of the data. */
1441 struct obstack
*data_obstack
;
1443 /* The filename obstack. */
1444 struct obstack
*filename_obstack
;
1446 /* The architecture's "long" type. */
1447 struct type
*long_type
;
1450 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1452 /* A callback for linux_find_memory_regions_full that updates the
1453 mappings data for linux_make_mappings_corefile_notes. */
1456 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1457 ULONGEST offset
, ULONGEST inode
,
1458 int read
, int write
, int exec
, int modified
,
1459 const char *filename
, void *data
)
1461 struct linux_make_mappings_data
*map_data
1462 = (struct linux_make_mappings_data
*) data
;
1463 gdb_byte buf
[sizeof (ULONGEST
)];
1465 if (*filename
== '\0' || inode
== 0)
1468 ++map_data
->file_count
;
1470 pack_long (buf
, map_data
->long_type
, vaddr
);
1471 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1472 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1473 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1474 pack_long (buf
, map_data
->long_type
, offset
);
1475 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1477 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1482 /* Write the file mapping data to the core file, if possible. OBFD is
1483 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1484 is a pointer to the note size. Returns the new NOTE_DATA and
1485 updates NOTE_SIZE. */
1488 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1489 char *note_data
, int *note_size
)
1491 struct cleanup
*cleanup
;
1492 struct obstack data_obstack
, filename_obstack
;
1493 struct linux_make_mappings_data mapping_data
;
1494 struct type
*long_type
1495 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1496 gdb_byte buf
[sizeof (ULONGEST
)];
1498 obstack_init (&data_obstack
);
1499 cleanup
= make_cleanup_obstack_free (&data_obstack
);
1500 obstack_init (&filename_obstack
);
1501 make_cleanup_obstack_free (&filename_obstack
);
1503 mapping_data
.file_count
= 0;
1504 mapping_data
.data_obstack
= &data_obstack
;
1505 mapping_data
.filename_obstack
= &filename_obstack
;
1506 mapping_data
.long_type
= long_type
;
1508 /* Reserve space for the count. */
1509 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1510 /* We always write the page size as 1 since we have no good way to
1511 determine the correct value. */
1512 pack_long (buf
, long_type
, 1);
1513 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1515 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1518 if (mapping_data
.file_count
!= 0)
1520 /* Write the count to the obstack. */
1521 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1522 long_type
, mapping_data
.file_count
);
1524 /* Copy the filenames to the data obstack. */
1525 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1526 obstack_object_size (&filename_obstack
));
1528 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1530 obstack_base (&data_obstack
),
1531 obstack_object_size (&data_obstack
));
1534 do_cleanups (cleanup
);
1538 /* Structure for passing information from
1539 linux_collect_thread_registers via an iterator to
1540 linux_collect_regset_section_cb. */
1542 struct linux_collect_regset_section_cb_data
1544 struct gdbarch
*gdbarch
;
1545 const struct regcache
*regcache
;
1550 enum gdb_signal stop_signal
;
1551 int abort_iteration
;
1554 /* Callback for iterate_over_regset_sections that records a single
1555 regset in the corefile note section. */
1558 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1559 const struct regset
*regset
,
1560 const char *human_name
, void *cb_data
)
1563 struct linux_collect_regset_section_cb_data
*data
1564 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1566 if (data
->abort_iteration
)
1569 gdb_assert (regset
&& regset
->collect_regset
);
1571 buf
= (char *) xmalloc (size
);
1572 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1574 /* PRSTATUS still needs to be treated specially. */
1575 if (strcmp (sect_name
, ".reg") == 0)
1576 data
->note_data
= (char *) elfcore_write_prstatus
1577 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1578 gdb_signal_to_host (data
->stop_signal
), buf
);
1580 data
->note_data
= (char *) elfcore_write_register_note
1581 (data
->obfd
, data
->note_data
, data
->note_size
,
1582 sect_name
, buf
, size
);
1585 if (data
->note_data
== NULL
)
1586 data
->abort_iteration
= 1;
1589 /* Records the thread's register state for the corefile note
1593 linux_collect_thread_registers (const struct regcache
*regcache
,
1594 ptid_t ptid
, bfd
*obfd
,
1595 char *note_data
, int *note_size
,
1596 enum gdb_signal stop_signal
)
1598 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1599 struct linux_collect_regset_section_cb_data data
;
1601 data
.gdbarch
= gdbarch
;
1602 data
.regcache
= regcache
;
1604 data
.note_data
= note_data
;
1605 data
.note_size
= note_size
;
1606 data
.stop_signal
= stop_signal
;
1607 data
.abort_iteration
= 0;
1609 /* For remote targets the LWP may not be available, so use the TID. */
1610 data
.lwp
= ptid_get_lwp (ptid
);
1612 data
.lwp
= ptid_get_tid (ptid
);
1614 gdbarch_iterate_over_regset_sections (gdbarch
,
1615 linux_collect_regset_section_cb
,
1617 return data
.note_data
;
1620 /* Fetch the siginfo data for the current thread, if it exists. If
1621 there is no data, or we could not read it, return NULL. Otherwise,
1622 return a newly malloc'd buffer holding the data and fill in *SIZE
1623 with the size of the data. The caller is responsible for freeing
1627 linux_get_siginfo_data (struct gdbarch
*gdbarch
, LONGEST
*size
)
1629 struct type
*siginfo_type
;
1632 struct cleanup
*cleanups
;
1634 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1637 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1639 buf
= (gdb_byte
*) xmalloc (TYPE_LENGTH (siginfo_type
));
1640 cleanups
= make_cleanup (xfree
, buf
);
1642 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1643 buf
, 0, TYPE_LENGTH (siginfo_type
));
1644 if (bytes_read
== TYPE_LENGTH (siginfo_type
))
1646 discard_cleanups (cleanups
);
1651 do_cleanups (cleanups
);
1658 struct linux_corefile_thread_data
1660 struct gdbarch
*gdbarch
;
1664 enum gdb_signal stop_signal
;
1667 /* Records the thread's register state for the corefile note
1671 linux_corefile_thread (struct thread_info
*info
,
1672 struct linux_corefile_thread_data
*args
)
1674 struct cleanup
*old_chain
;
1675 struct regcache
*regcache
;
1676 gdb_byte
*siginfo_data
;
1677 LONGEST siginfo_size
= 0;
1679 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1681 old_chain
= save_inferior_ptid ();
1682 inferior_ptid
= info
->ptid
;
1683 target_fetch_registers (regcache
, -1);
1684 siginfo_data
= linux_get_siginfo_data (args
->gdbarch
, &siginfo_size
);
1685 do_cleanups (old_chain
);
1687 old_chain
= make_cleanup (xfree
, siginfo_data
);
1689 args
->note_data
= linux_collect_thread_registers
1690 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1691 args
->note_size
, args
->stop_signal
);
1693 /* Don't return anything if we got no register information above,
1694 such a core file is useless. */
1695 if (args
->note_data
!= NULL
)
1696 if (siginfo_data
!= NULL
)
1697 args
->note_data
= elfcore_write_note (args
->obfd
,
1701 siginfo_data
, siginfo_size
);
1703 do_cleanups (old_chain
);
1706 /* Fill the PRPSINFO structure with information about the process being
1707 debugged. Returns 1 in case of success, 0 for failures. Please note that
1708 even if the structure cannot be entirely filled (e.g., GDB was unable to
1709 gather information about the process UID/GID), this function will still
1710 return 1 since some information was already recorded. It will only return
1711 0 iff nothing can be gathered. */
1714 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1716 /* The filename which we will use to obtain some info about the process.
1717 We will basically use this to store the `/proc/PID/FILENAME' file. */
1719 /* The full name of the program which generated the corefile. */
1721 /* The basename of the executable. */
1722 const char *basename
;
1723 /* The arguments of the program. */
1726 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1727 char *proc_stat
, *proc_status
;
1728 /* Temporary buffer. */
1730 /* The valid states of a process, according to the Linux kernel. */
1731 const char valid_states
[] = "RSDTZW";
1732 /* The program state. */
1733 const char *prog_state
;
1734 /* The state of the process. */
1736 /* The PID of the program which generated the corefile. */
1738 /* Process flags. */
1739 unsigned int pr_flag
;
1740 /* Process nice value. */
1742 /* The number of fields read by `sscanf'. */
1748 gdb_assert (p
!= NULL
);
1750 /* Obtaining PID and filename. */
1751 pid
= ptid_get_pid (inferior_ptid
);
1752 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1753 fname
= target_fileio_read_stralloc (NULL
, filename
);
1755 if (fname
== NULL
|| *fname
== '\0')
1757 /* No program name was read, so we won't be able to retrieve more
1758 information about the process. */
1763 c
= make_cleanup (xfree
, fname
);
1764 memset (p
, 0, sizeof (*p
));
1766 /* Defining the PID. */
1769 /* Copying the program name. Only the basename matters. */
1770 basename
= lbasename (fname
);
1771 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1772 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1774 infargs
= get_inferior_args ();
1776 psargs
= xstrdup (fname
);
1777 if (infargs
!= NULL
)
1778 psargs
= reconcat (psargs
, psargs
, " ", infargs
, NULL
);
1780 make_cleanup (xfree
, psargs
);
1782 strncpy (p
->pr_psargs
, psargs
, sizeof (p
->pr_psargs
));
1783 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1785 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1786 proc_stat
= target_fileio_read_stralloc (NULL
, filename
);
1787 make_cleanup (xfree
, proc_stat
);
1789 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1791 /* Despite being unable to read more information about the
1792 process, we return 1 here because at least we have its
1793 command line, PID and arguments. */
1798 /* Ok, we have the stats. It's time to do a little parsing of the
1799 contents of the buffer, so that we end up reading what we want.
1801 The following parsing mechanism is strongly based on the
1802 information generated by the `fs/proc/array.c' file, present in
1803 the Linux kernel tree. More details about how the information is
1804 displayed can be obtained by seeing the manpage of proc(5),
1805 specifically under the entry of `/proc/[pid]/stat'. */
1807 /* Getting rid of the PID, since we already have it. */
1808 while (isdigit (*proc_stat
))
1811 proc_stat
= skip_spaces (proc_stat
);
1813 /* ps command also relies on no trailing fields ever contain ')'. */
1814 proc_stat
= strrchr (proc_stat
, ')');
1815 if (proc_stat
== NULL
)
1822 proc_stat
= skip_spaces (proc_stat
);
1824 n_fields
= sscanf (proc_stat
,
1825 "%c" /* Process state. */
1826 "%d%d%d" /* Parent PID, group ID, session ID. */
1827 "%*d%*d" /* tty_nr, tpgid (not used). */
1829 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1830 cmajflt (not used). */
1831 "%*s%*s%*s%*s" /* utime, stime, cutime,
1832 cstime (not used). */
1833 "%*s" /* Priority (not used). */
1836 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1842 /* Again, we couldn't read the complementary information about
1843 the process state. However, we already have minimal
1844 information, so we just return 1 here. */
1849 /* Filling the structure fields. */
1850 prog_state
= strchr (valid_states
, pr_sname
);
1851 if (prog_state
!= NULL
)
1852 p
->pr_state
= prog_state
- valid_states
;
1855 /* Zero means "Running". */
1859 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1860 p
->pr_zomb
= p
->pr_sname
== 'Z';
1861 p
->pr_nice
= pr_nice
;
1862 p
->pr_flag
= pr_flag
;
1864 /* Finally, obtaining the UID and GID. For that, we read and parse the
1865 contents of the `/proc/PID/status' file. */
1866 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1867 proc_status
= target_fileio_read_stralloc (NULL
, filename
);
1868 make_cleanup (xfree
, proc_status
);
1870 if (proc_status
== NULL
|| *proc_status
== '\0')
1872 /* Returning 1 since we already have a bunch of information. */
1877 /* Extracting the UID. */
1878 tmpstr
= strstr (proc_status
, "Uid:");
1881 /* Advancing the pointer to the beginning of the UID. */
1882 tmpstr
+= sizeof ("Uid:");
1883 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1886 if (isdigit (*tmpstr
))
1887 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1890 /* Extracting the GID. */
1891 tmpstr
= strstr (proc_status
, "Gid:");
1894 /* Advancing the pointer to the beginning of the GID. */
1895 tmpstr
+= sizeof ("Gid:");
1896 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1899 if (isdigit (*tmpstr
))
1900 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1908 /* Build the note section for a corefile, and return it in a malloc
1912 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1914 struct linux_corefile_thread_data thread_args
;
1915 struct elf_internal_linux_prpsinfo prpsinfo
;
1916 char *note_data
= NULL
;
1919 struct thread_info
*curr_thr
, *signalled_thr
, *thr
;
1921 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1924 if (linux_fill_prpsinfo (&prpsinfo
))
1926 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch
))
1928 note_data
= gdbarch_elfcore_write_linux_prpsinfo (gdbarch
, obfd
,
1929 note_data
, note_size
,
1934 if (gdbarch_ptr_bit (gdbarch
) == 64)
1935 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1936 note_data
, note_size
,
1939 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1940 note_data
, note_size
,
1945 /* Thread register information. */
1948 update_thread_list ();
1950 CATCH (e
, RETURN_MASK_ERROR
)
1952 exception_print (gdb_stderr
, e
);
1956 /* Like the kernel, prefer dumping the signalled thread first.
1957 "First thread" is what tools use to infer the signalled thread.
1958 In case there's more than one signalled thread, prefer the
1959 current thread, if it is signalled. */
1960 curr_thr
= inferior_thread ();
1961 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1962 signalled_thr
= curr_thr
;
1965 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
1966 if (signalled_thr
== NULL
)
1967 signalled_thr
= curr_thr
;
1970 thread_args
.gdbarch
= gdbarch
;
1971 thread_args
.obfd
= obfd
;
1972 thread_args
.note_data
= note_data
;
1973 thread_args
.note_size
= note_size
;
1974 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
1976 linux_corefile_thread (signalled_thr
, &thread_args
);
1977 ALL_NON_EXITED_THREADS (thr
)
1979 if (thr
== signalled_thr
)
1981 if (ptid_get_pid (thr
->ptid
) != ptid_get_pid (inferior_ptid
))
1984 linux_corefile_thread (thr
, &thread_args
);
1987 note_data
= thread_args
.note_data
;
1991 /* Auxillary vector. */
1992 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
1996 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1997 "CORE", NT_AUXV
, auxv
, auxv_len
);
2004 /* SPU information. */
2005 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
2009 /* File mappings. */
2010 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
2011 note_data
, note_size
);
2016 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2017 gdbarch.h. This function is not static because it is exported to
2018 other -tdep files. */
2021 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2026 return GDB_SIGNAL_0
;
2029 return GDB_SIGNAL_HUP
;
2032 return GDB_SIGNAL_INT
;
2035 return GDB_SIGNAL_QUIT
;
2038 return GDB_SIGNAL_ILL
;
2041 return GDB_SIGNAL_TRAP
;
2044 return GDB_SIGNAL_ABRT
;
2047 return GDB_SIGNAL_BUS
;
2050 return GDB_SIGNAL_FPE
;
2053 return GDB_SIGNAL_KILL
;
2056 return GDB_SIGNAL_USR1
;
2059 return GDB_SIGNAL_SEGV
;
2062 return GDB_SIGNAL_USR2
;
2065 return GDB_SIGNAL_PIPE
;
2068 return GDB_SIGNAL_ALRM
;
2071 return GDB_SIGNAL_TERM
;
2074 return GDB_SIGNAL_CHLD
;
2077 return GDB_SIGNAL_CONT
;
2080 return GDB_SIGNAL_STOP
;
2083 return GDB_SIGNAL_TSTP
;
2086 return GDB_SIGNAL_TTIN
;
2089 return GDB_SIGNAL_TTOU
;
2092 return GDB_SIGNAL_URG
;
2095 return GDB_SIGNAL_XCPU
;
2098 return GDB_SIGNAL_XFSZ
;
2100 case LINUX_SIGVTALRM
:
2101 return GDB_SIGNAL_VTALRM
;
2104 return GDB_SIGNAL_PROF
;
2106 case LINUX_SIGWINCH
:
2107 return GDB_SIGNAL_WINCH
;
2109 /* No way to differentiate between SIGIO and SIGPOLL.
2110 Therefore, we just handle the first one. */
2112 return GDB_SIGNAL_IO
;
2115 return GDB_SIGNAL_PWR
;
2118 return GDB_SIGNAL_SYS
;
2120 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2121 therefore we have to handle them here. */
2122 case LINUX_SIGRTMIN
:
2123 return GDB_SIGNAL_REALTIME_32
;
2125 case LINUX_SIGRTMAX
:
2126 return GDB_SIGNAL_REALTIME_64
;
2129 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2131 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2133 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2136 return GDB_SIGNAL_UNKNOWN
;
2139 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2140 gdbarch.h. This function is not static because it is exported to
2141 other -tdep files. */
2144 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2145 enum gdb_signal signal
)
2152 case GDB_SIGNAL_HUP
:
2153 return LINUX_SIGHUP
;
2155 case GDB_SIGNAL_INT
:
2156 return LINUX_SIGINT
;
2158 case GDB_SIGNAL_QUIT
:
2159 return LINUX_SIGQUIT
;
2161 case GDB_SIGNAL_ILL
:
2162 return LINUX_SIGILL
;
2164 case GDB_SIGNAL_TRAP
:
2165 return LINUX_SIGTRAP
;
2167 case GDB_SIGNAL_ABRT
:
2168 return LINUX_SIGABRT
;
2170 case GDB_SIGNAL_FPE
:
2171 return LINUX_SIGFPE
;
2173 case GDB_SIGNAL_KILL
:
2174 return LINUX_SIGKILL
;
2176 case GDB_SIGNAL_BUS
:
2177 return LINUX_SIGBUS
;
2179 case GDB_SIGNAL_SEGV
:
2180 return LINUX_SIGSEGV
;
2182 case GDB_SIGNAL_SYS
:
2183 return LINUX_SIGSYS
;
2185 case GDB_SIGNAL_PIPE
:
2186 return LINUX_SIGPIPE
;
2188 case GDB_SIGNAL_ALRM
:
2189 return LINUX_SIGALRM
;
2191 case GDB_SIGNAL_TERM
:
2192 return LINUX_SIGTERM
;
2194 case GDB_SIGNAL_URG
:
2195 return LINUX_SIGURG
;
2197 case GDB_SIGNAL_STOP
:
2198 return LINUX_SIGSTOP
;
2200 case GDB_SIGNAL_TSTP
:
2201 return LINUX_SIGTSTP
;
2203 case GDB_SIGNAL_CONT
:
2204 return LINUX_SIGCONT
;
2206 case GDB_SIGNAL_CHLD
:
2207 return LINUX_SIGCHLD
;
2209 case GDB_SIGNAL_TTIN
:
2210 return LINUX_SIGTTIN
;
2212 case GDB_SIGNAL_TTOU
:
2213 return LINUX_SIGTTOU
;
2218 case GDB_SIGNAL_XCPU
:
2219 return LINUX_SIGXCPU
;
2221 case GDB_SIGNAL_XFSZ
:
2222 return LINUX_SIGXFSZ
;
2224 case GDB_SIGNAL_VTALRM
:
2225 return LINUX_SIGVTALRM
;
2227 case GDB_SIGNAL_PROF
:
2228 return LINUX_SIGPROF
;
2230 case GDB_SIGNAL_WINCH
:
2231 return LINUX_SIGWINCH
;
2233 case GDB_SIGNAL_USR1
:
2234 return LINUX_SIGUSR1
;
2236 case GDB_SIGNAL_USR2
:
2237 return LINUX_SIGUSR2
;
2239 case GDB_SIGNAL_PWR
:
2240 return LINUX_SIGPWR
;
2242 case GDB_SIGNAL_POLL
:
2243 return LINUX_SIGPOLL
;
2245 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2246 therefore we have to handle it here. */
2247 case GDB_SIGNAL_REALTIME_32
:
2248 return LINUX_SIGRTMIN
;
2250 /* Same comment applies to _64. */
2251 case GDB_SIGNAL_REALTIME_64
:
2252 return LINUX_SIGRTMAX
;
2255 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2256 if (signal
>= GDB_SIGNAL_REALTIME_33
2257 && signal
<= GDB_SIGNAL_REALTIME_63
)
2259 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2261 return LINUX_SIGRTMIN
+ 1 + offset
;
2267 /* Rummage through mappings to find a mapping's size. */
2270 find_mapping_size (CORE_ADDR vaddr
, unsigned long size
,
2271 int read
, int write
, int exec
, int modified
,
2274 struct mem_range
*range
= (struct mem_range
*) data
;
2276 if (vaddr
== range
->start
)
2278 range
->length
= size
;
2284 /* Helper for linux_vsyscall_range that does the real work of finding
2285 the vsyscall's address range. */
2288 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2290 if (target_auxv_search (¤t_target
, AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2293 /* This is installed by linux_init_abi below, so should always be
2295 gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2298 gdbarch_find_memory_regions (gdbarch
, find_mapping_size
, range
);
2302 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2303 caching, and defers the real work to linux_vsyscall_range_raw. */
2306 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2308 struct linux_info
*info
= get_linux_inferior_data ();
2310 if (info
->vsyscall_range_p
== 0)
2312 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2313 info
->vsyscall_range_p
= 1;
2315 info
->vsyscall_range_p
= -1;
2318 if (info
->vsyscall_range_p
< 0)
2321 *range
= info
->vsyscall_range
;
2325 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2326 definitions would be dependent on compilation host. */
2327 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2328 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2330 /* See gdbarch.sh 'infcall_mmap'. */
2333 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2335 struct objfile
*objf
;
2336 /* Do there still exist any Linux systems without "mmap64"?
2337 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2338 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2339 struct value
*addr_val
;
2340 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2344 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2346 struct value
*arg
[ARG_LAST
];
2348 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2350 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2351 arg
[ARG_LENGTH
] = value_from_ulongest
2352 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2353 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2354 | GDB_MMAP_PROT_EXEC
))
2356 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2357 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2358 GDB_MMAP_MAP_PRIVATE
2359 | GDB_MMAP_MAP_ANONYMOUS
);
2360 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2361 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2363 addr_val
= call_function_by_hand (mmap_val
, ARG_LAST
, arg
);
2364 retval
= value_as_address (addr_val
);
2365 if (retval
== (CORE_ADDR
) -1)
2366 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2371 /* See gdbarch.sh 'infcall_munmap'. */
2374 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2376 struct objfile
*objf
;
2377 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2378 struct value
*retval_val
;
2379 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2383 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2385 struct value
*arg
[ARG_LAST
];
2387 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2389 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2390 arg
[ARG_LENGTH
] = value_from_ulongest
2391 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2392 retval_val
= call_function_by_hand (munmap_val
, ARG_LAST
, arg
);
2393 retval
= value_as_long (retval_val
);
2395 warning (_("Failed inferior munmap call at %s for %s bytes, "
2396 "errno is changed."),
2397 hex_string (addr
), pulongest (size
));
2400 /* See linux-tdep.h. */
2403 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2408 /* Determine entry point from target auxiliary vector. This avoids
2409 the need for symbols. Also, when debugging a stand-alone SPU
2410 executable, entry_point_address () will point to an SPU
2411 local-store address and is thus not usable as displaced stepping
2412 location. The auxiliary vector gets us the PowerPC-side entry
2413 point address instead. */
2414 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
2415 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2417 /* Make certain that the address points at real code, and not a
2418 function descriptor. */
2419 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2422 /* Inferior calls also use the entry point as a breakpoint location.
2423 We don't want displaced stepping to interfere with those
2424 breakpoints, so leave space. */
2425 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2431 /* Display whether the gcore command is using the
2432 /proc/PID/coredump_filter file. */
2435 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2436 struct cmd_list_element
*c
, const char *value
)
2438 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2439 " corefiles is %s.\n"), value
);
2442 /* To be called from the various GDB_OSABI_LINUX handlers for the
2443 various GNU/Linux architectures and machine types. */
2446 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2448 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2449 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2450 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2451 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2452 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2453 set_gdbarch_has_shared_address_space (gdbarch
,
2454 linux_has_shared_address_space
);
2455 set_gdbarch_gdb_signal_from_target (gdbarch
,
2456 linux_gdb_signal_from_target
);
2457 set_gdbarch_gdb_signal_to_target (gdbarch
,
2458 linux_gdb_signal_to_target
);
2459 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2460 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2461 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2462 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2465 /* Provide a prototype to silence -Wmissing-prototypes. */
2466 extern initialize_file_ftype _initialize_linux_tdep
;
2469 _initialize_linux_tdep (void)
2471 linux_gdbarch_data_handle
=
2472 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2474 /* Set a cache per-inferior. */
2476 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2477 /* Observers used to invalidate the cache when needed. */
2478 observer_attach_inferior_exit (invalidate_linux_cache_inf
);
2479 observer_attach_inferior_appeared (invalidate_linux_cache_inf
);
2481 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2482 &use_coredump_filter
, _("\
2483 Set whether gcore should consider /proc/PID/coredump_filter."),
2485 Show whether gcore should consider /proc/PID/coredump_filter."),
2487 Use this command to set whether gcore should consider the contents\n\
2488 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2489 about this file, refer to the manpage of core(5)."),
2490 NULL
, show_use_coredump_filter
,
2491 &setlist
, &showlist
);