1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
39 #include "gdb_regex.h"
43 /* This enum represents the values that the user can choose when
44 informing the Linux kernel about which memory mappings will be
45 dumped in a corefile. They are described in the file
46 Documentation/filesystems/proc.txt, inside the Linux kernel
51 COREFILTER_ANON_PRIVATE
= 1 << 0,
52 COREFILTER_ANON_SHARED
= 1 << 1,
53 COREFILTER_MAPPED_PRIVATE
= 1 << 2,
54 COREFILTER_MAPPED_SHARED
= 1 << 3,
55 COREFILTER_ELF_HEADERS
= 1 << 4,
56 COREFILTER_HUGETLB_PRIVATE
= 1 << 5,
57 COREFILTER_HUGETLB_SHARED
= 1 << 6,
60 /* This struct is used to map flags found in the "VmFlags:" field (in
61 the /proc/<PID>/smaps file). */
65 /* Zero if this structure has not been initialized yet. It
66 probably means that the Linux kernel being used does not emit
67 the "VmFlags:" field on "/proc/PID/smaps". */
69 unsigned int initialized_p
: 1;
71 /* Memory mapped I/O area (VM_IO, "io"). */
73 unsigned int io_page
: 1;
75 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
77 unsigned int uses_huge_tlb
: 1;
79 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
81 unsigned int exclude_coredump
: 1;
83 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
85 unsigned int shared_mapping
: 1;
88 /* Whether to take the /proc/PID/coredump_filter into account when
89 generating a corefile. */
91 static int use_coredump_filter
= 1;
93 /* This enum represents the signals' numbers on a generic architecture
94 running the Linux kernel. The definition of "generic" comes from
95 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
96 tree, which is the "de facto" implementation of signal numbers to
97 be used by new architecture ports.
99 For those architectures which have differences between the generic
100 standard (e.g., Alpha), we define the different signals (and *only*
101 those) in the specific target-dependent file (e.g.,
102 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
103 tdep file for more information.
105 ARM deserves a special mention here. On the file
106 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
107 (and ARM-only) signal, which is SIGSWI, with the same number as
108 SIGRTMIN. This signal is used only for a very specific target,
109 called ArthurOS (from RISCOS). Therefore, we do not handle it on
110 the ARM-tdep file, and we can safely use the generic signal handler
111 here for ARM targets.
113 As stated above, this enum is derived from
114 <include/uapi/asm-generic/signal.h>, from the Linux kernel
135 LINUX_SIGSTKFLT
= 16,
145 LINUX_SIGVTALRM
= 26,
149 LINUX_SIGPOLL
= LINUX_SIGIO
,
152 LINUX_SIGUNUSED
= 31,
158 static struct gdbarch_data
*linux_gdbarch_data_handle
;
160 struct linux_gdbarch_data
162 struct type
*siginfo_type
;
166 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
168 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
171 static struct linux_gdbarch_data
*
172 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
174 return gdbarch_data (gdbarch
, linux_gdbarch_data_handle
);
177 /* Per-inferior data key. */
178 static const struct inferior_data
*linux_inferior_data
;
180 /* Linux-specific cached data. This is used by GDB for caching
181 purposes for each inferior. This helps reduce the overhead of
182 transfering data from a remote target to the local host. */
185 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
186 if VSYSCALL_RANGE_P is positive. This is cached because getting
187 at this info requires an auxv lookup (which is itself cached),
188 and looking through the inferior's mappings (which change
189 throughout execution and therefore cannot be cached). */
190 struct mem_range vsyscall_range
;
192 /* Zero if we haven't tried looking up the vsyscall's range before
193 yet. Positive if we tried looking it up, and found it. Negative
194 if we tried looking it up but failed. */
195 int vsyscall_range_p
;
198 /* Frees whatever allocated space there is to be freed and sets INF's
199 linux cache data pointer to NULL. */
202 invalidate_linux_cache_inf (struct inferior
*inf
)
204 struct linux_info
*info
;
206 info
= inferior_data (inf
, linux_inferior_data
);
210 set_inferior_data (inf
, linux_inferior_data
, NULL
);
214 /* Handles the cleanup of the linux cache for inferior INF. ARG is
215 ignored. Callback for the inferior_appeared and inferior_exit
219 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
221 invalidate_linux_cache_inf (inf
);
224 /* Fetch the linux cache info for INF. This function always returns a
225 valid INFO pointer. */
227 static struct linux_info
*
228 get_linux_inferior_data (void)
230 struct linux_info
*info
;
231 struct inferior
*inf
= current_inferior ();
233 info
= inferior_data (inf
, linux_inferior_data
);
236 info
= XCNEW (struct linux_info
);
237 set_inferior_data (inf
, linux_inferior_data
, info
);
243 /* This function is suitable for architectures that don't
244 extend/override the standard siginfo structure. */
247 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
249 struct linux_gdbarch_data
*linux_gdbarch_data
;
250 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
;
251 struct type
*uid_type
, *pid_type
;
252 struct type
*sigval_type
, *clock_type
;
253 struct type
*siginfo_type
, *sifields_type
;
256 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
257 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
258 return linux_gdbarch_data
->siginfo_type
;
260 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
262 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
264 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
266 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
269 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
270 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
271 append_composite_type_field (sigval_type
, "sival_int", int_type
);
272 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
275 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
276 TYPE_LENGTH (int_type
), "__pid_t");
277 TYPE_TARGET_TYPE (pid_type
) = int_type
;
278 TYPE_TARGET_STUB (pid_type
) = 1;
281 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
282 TYPE_LENGTH (uint_type
), "__uid_t");
283 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
284 TYPE_TARGET_STUB (uid_type
) = 1;
287 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
288 TYPE_LENGTH (long_type
), "__clock_t");
289 TYPE_TARGET_TYPE (clock_type
) = long_type
;
290 TYPE_TARGET_STUB (clock_type
) = 1;
293 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
296 const int si_max_size
= 128;
298 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
301 if (gdbarch_ptr_bit (gdbarch
) == 64)
302 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
304 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
305 append_composite_type_field (sifields_type
, "_pad",
306 init_vector_type (int_type
, si_pad_size
));
310 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
311 append_composite_type_field (type
, "si_pid", pid_type
);
312 append_composite_type_field (type
, "si_uid", uid_type
);
313 append_composite_type_field (sifields_type
, "_kill", type
);
316 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
317 append_composite_type_field (type
, "si_tid", int_type
);
318 append_composite_type_field (type
, "si_overrun", int_type
);
319 append_composite_type_field (type
, "si_sigval", sigval_type
);
320 append_composite_type_field (sifields_type
, "_timer", type
);
323 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
324 append_composite_type_field (type
, "si_pid", pid_type
);
325 append_composite_type_field (type
, "si_uid", uid_type
);
326 append_composite_type_field (type
, "si_sigval", sigval_type
);
327 append_composite_type_field (sifields_type
, "_rt", type
);
330 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
331 append_composite_type_field (type
, "si_pid", pid_type
);
332 append_composite_type_field (type
, "si_uid", uid_type
);
333 append_composite_type_field (type
, "si_status", int_type
);
334 append_composite_type_field (type
, "si_utime", clock_type
);
335 append_composite_type_field (type
, "si_stime", clock_type
);
336 append_composite_type_field (sifields_type
, "_sigchld", type
);
339 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
340 append_composite_type_field (type
, "si_addr", void_ptr_type
);
341 append_composite_type_field (sifields_type
, "_sigfault", type
);
344 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
345 append_composite_type_field (type
, "si_band", long_type
);
346 append_composite_type_field (type
, "si_fd", int_type
);
347 append_composite_type_field (sifields_type
, "_sigpoll", type
);
350 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
351 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
352 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
353 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
354 append_composite_type_field (siginfo_type
, "si_code", int_type
);
355 append_composite_type_field_aligned (siginfo_type
,
356 "_sifields", sifields_type
,
357 TYPE_LENGTH (long_type
));
359 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
364 /* Return true if the target is running on uClinux instead of normal
368 linux_is_uclinux (void)
372 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
373 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
377 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
379 return linux_is_uclinux ();
382 /* This is how we want PTIDs from core files to be printed. */
385 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
389 if (ptid_get_lwp (ptid
) != 0)
391 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
395 return normal_pid_to_str (ptid
);
398 /* Service function for corefiles and info proc. */
401 read_mapping (const char *line
,
402 ULONGEST
*addr
, ULONGEST
*endaddr
,
403 const char **permissions
, size_t *permissions_len
,
405 const char **device
, size_t *device_len
,
407 const char **filename
)
409 const char *p
= line
;
411 *addr
= strtoulst (p
, &p
, 16);
414 *endaddr
= strtoulst (p
, &p
, 16);
416 p
= skip_spaces_const (p
);
418 while (*p
&& !isspace (*p
))
420 *permissions_len
= p
- *permissions
;
422 *offset
= strtoulst (p
, &p
, 16);
424 p
= skip_spaces_const (p
);
426 while (*p
&& !isspace (*p
))
428 *device_len
= p
- *device
;
430 *inode
= strtoulst (p
, &p
, 10);
432 p
= skip_spaces_const (p
);
436 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
438 This function was based on the documentation found on
439 <Documentation/filesystems/proc.txt>, on the Linux kernel.
441 Linux kernels before commit
442 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
446 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
448 char *saveptr
= NULL
;
451 v
->initialized_p
= 1;
452 p
= skip_to_space (p
);
455 for (s
= strtok_r (p
, " ", &saveptr
);
457 s
= strtok_r (NULL
, " ", &saveptr
))
459 if (strcmp (s
, "io") == 0)
461 else if (strcmp (s
, "ht") == 0)
462 v
->uses_huge_tlb
= 1;
463 else if (strcmp (s
, "dd") == 0)
464 v
->exclude_coredump
= 1;
465 else if (strcmp (s
, "sh") == 0)
466 v
->shared_mapping
= 1;
470 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
472 FILENAME is the name of the file present in the first line of the
473 memory mapping, in the "/proc/PID/smaps" output. For example, if
476 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
478 Then FILENAME will be "/path/to/file". */
481 mapping_is_anonymous_p (const char *filename
)
483 static regex_t dev_zero_regex
, shmem_file_regex
, file_deleted_regex
;
484 static int init_regex_p
= 0;
488 struct cleanup
*c
= make_cleanup (null_cleanup
, NULL
);
490 /* Let's be pessimistic and assume there will be an error while
491 compiling the regex'es. */
494 /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
495 without the "(deleted)" string in the end). We know for
496 sure, based on the Linux kernel code, that memory mappings
497 whose associated filename is "/dev/zero" are guaranteed to be
499 compile_rx_or_error (&dev_zero_regex
, "^/dev/zero\\( (deleted)\\)\\?$",
500 _("Could not compile regex to match /dev/zero "
502 /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
503 without the "(deleted)" string in the end). These filenames
504 refer to shared memory (shmem), and memory mappings
505 associated with them are MAP_ANONYMOUS as well. */
506 compile_rx_or_error (&shmem_file_regex
,
507 "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
508 _("Could not compile regex to match shmem "
510 /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
511 Linux kernel's 'n_link == 0' code, which is responsible to
512 decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
513 mapping. In other words, if FILE_DELETED_REGEX matches, it
514 does not necessarily mean that we are dealing with an
515 anonymous shared mapping. However, there is no easy way to
516 detect this currently, so this is the best approximation we
519 As a result, GDB will dump readonly pages of deleted
520 executables when using the default value of coredump_filter
521 (0x33), while the Linux kernel will not dump those pages.
522 But we can live with that. */
523 compile_rx_or_error (&file_deleted_regex
, " (deleted)$",
524 _("Could not compile regex to match "
525 "'<file> (deleted)'"));
526 /* We will never release these regexes, so just discard the
528 discard_cleanups (c
);
530 /* If we reached this point, then everything succeeded. */
534 if (init_regex_p
== -1)
536 const char deleted
[] = " (deleted)";
537 size_t del_len
= sizeof (deleted
) - 1;
538 size_t filename_len
= strlen (filename
);
540 /* There was an error while compiling the regex'es above. In
541 order to try to give some reliable information to the caller,
542 we just try to find the string " (deleted)" in the filename.
543 If we managed to find it, then we assume the mapping is
545 return (filename_len
>= del_len
546 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
549 if (*filename
== '\0'
550 || regexec (&dev_zero_regex
, filename
, 0, NULL
, 0) == 0
551 || regexec (&shmem_file_regex
, filename
, 0, NULL
, 0) == 0
552 || regexec (&file_deleted_regex
, filename
, 0, NULL
, 0) == 0)
558 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
559 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
560 greater than 0 if it should.
562 In a nutshell, this is the logic that we follow in order to decide
563 if a mapping should be dumped or not.
565 - If the mapping is associated to a file whose name ends with
566 " (deleted)", or if the file is "/dev/zero", or if it is
567 "/SYSV%08x" (shared memory), or if there is no file associated
568 with it, or if the AnonHugePages: or the Anonymous: fields in the
569 /proc/PID/smaps have contents, then GDB considers this mapping to
570 be anonymous. Otherwise, GDB considers this mapping to be a
571 file-backed mapping (because there will be a file associated with
574 It is worth mentioning that, from all those checks described
575 above, the most fragile is the one to see if the file name ends
576 with " (deleted)". This does not necessarily mean that the
577 mapping is anonymous, because the deleted file associated with
578 the mapping may have been a hard link to another file, for
579 example. The Linux kernel checks to see if "i_nlink == 0", but
580 GDB cannot easily (and normally) do this check (iff running as
581 root, it could find the mapping in /proc/PID/map_files/ and
582 determine whether there still are other hard links to the
583 inode/file). Therefore, we made a compromise here, and we assume
584 that if the file name ends with " (deleted)", then the mapping is
585 indeed anonymous. FWIW, this is something the Linux kernel could
586 do better: expose this information in a more direct way.
588 - If we see the flag "sh" in the "VmFlags:" field (in
589 /proc/PID/smaps), then certainly the memory mapping is shared
590 (VM_SHARED). If we have access to the VmFlags, and we don't see
591 the "sh" there, then certainly the mapping is private. However,
592 Linux kernels before commit
593 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
594 "VmFlags:" field; in that case, we use another heuristic: if we
595 see 'p' in the permission flags, then we assume that the mapping
596 is private, even though the presence of the 's' flag there would
597 mean VM_MAYSHARE, which means the mapping could still be private.
598 This should work OK enough, however. */
601 dump_mapping_p (enum filterflags filterflags
, const struct smaps_vmflags
*v
,
602 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
603 const char *filename
)
605 /* Initially, we trust in what we received from our caller. This
606 value may not be very precise (i.e., it was probably gathered
607 from the permission line in the /proc/PID/smaps list, which
608 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
609 what we have until we take a look at the "VmFlags:" field
610 (assuming that the version of the Linux kernel being used
611 supports it, of course). */
612 int private_p
= maybe_private_p
;
614 /* We always dump vDSO and vsyscall mappings, because it's likely that
615 there'll be no file to read the contents from at core load time.
616 The kernel does the same. */
617 if (strcmp ("[vdso]", filename
) == 0
618 || strcmp ("[vsyscall]", filename
) == 0)
621 if (v
->initialized_p
)
623 /* We never dump I/O mappings. */
627 /* Check if we should exclude this mapping. */
628 if (v
->exclude_coredump
)
631 /* Update our notion of whether this mapping is shared or
632 private based on a trustworthy value. */
633 private_p
= !v
->shared_mapping
;
635 /* HugeTLB checking. */
636 if (v
->uses_huge_tlb
)
638 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
639 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
648 if (mapping_anon_p
&& mapping_file_p
)
650 /* This is a special situation. It can happen when we see a
651 mapping that is file-backed, but that contains anonymous
653 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
654 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
656 else if (mapping_anon_p
)
657 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
659 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
663 if (mapping_anon_p
&& mapping_file_p
)
665 /* This is a special situation. It can happen when we see a
666 mapping that is file-backed, but that contains anonymous
668 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
669 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
671 else if (mapping_anon_p
)
672 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
674 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
678 /* Implement the "info proc" command. */
681 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
682 enum info_proc_what what
)
684 /* A long is used for pid instead of an int to avoid a loss of precision
685 compiler warning from the output of strtoul. */
687 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
688 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
689 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
690 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
691 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
692 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
697 if (args
&& isdigit (args
[0]))
701 pid
= strtoul (args
, &tem
, 10);
706 if (!target_has_execution
)
707 error (_("No current process: you must name one."));
708 if (current_inferior ()->fake_pid_p
)
709 error (_("Can't determine the current process's PID: you must name one."));
711 pid
= current_inferior ()->pid
;
714 args
= skip_spaces_const (args
);
716 error (_("Too many parameters: %s"), args
);
718 printf_filtered (_("process %ld\n"), pid
);
721 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
722 data
= target_fileio_read_stralloc (NULL
, filename
);
725 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
726 printf_filtered ("cmdline = '%s'\n", data
);
727 do_cleanups (cleanup
);
730 warning (_("unable to open /proc file '%s'"), filename
);
734 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
735 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
738 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
739 printf_filtered ("cwd = '%s'\n", data
);
740 do_cleanups (cleanup
);
743 warning (_("unable to read link '%s'"), filename
);
747 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
748 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
751 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
752 printf_filtered ("exe = '%s'\n", data
);
753 do_cleanups (cleanup
);
756 warning (_("unable to read link '%s'"), filename
);
760 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
761 data
= target_fileio_read_stralloc (NULL
, filename
);
764 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
767 printf_filtered (_("Mapped address spaces:\n\n"));
768 if (gdbarch_addr_bit (gdbarch
) == 32)
770 printf_filtered ("\t%10s %10s %10s %10s %s\n",
773 " Size", " Offset", "objfile");
777 printf_filtered (" %18s %18s %10s %10s %s\n",
780 " Size", " Offset", "objfile");
783 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
785 ULONGEST addr
, endaddr
, offset
, inode
;
786 const char *permissions
, *device
, *filename
;
787 size_t permissions_len
, device_len
;
789 read_mapping (line
, &addr
, &endaddr
,
790 &permissions
, &permissions_len
,
791 &offset
, &device
, &device_len
,
794 if (gdbarch_addr_bit (gdbarch
) == 32)
796 printf_filtered ("\t%10s %10s %10s %10s %s\n",
797 paddress (gdbarch
, addr
),
798 paddress (gdbarch
, endaddr
),
799 hex_string (endaddr
- addr
),
801 *filename
? filename
: "");
805 printf_filtered (" %18s %18s %10s %10s %s\n",
806 paddress (gdbarch
, addr
),
807 paddress (gdbarch
, endaddr
),
808 hex_string (endaddr
- addr
),
810 *filename
? filename
: "");
814 do_cleanups (cleanup
);
817 warning (_("unable to open /proc file '%s'"), filename
);
821 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
822 data
= target_fileio_read_stralloc (NULL
, filename
);
825 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
826 puts_filtered (data
);
827 do_cleanups (cleanup
);
830 warning (_("unable to open /proc file '%s'"), filename
);
834 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
835 data
= target_fileio_read_stralloc (NULL
, filename
);
838 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
839 const char *p
= data
;
841 printf_filtered (_("Process: %s\n"),
842 pulongest (strtoulst (p
, &p
, 10)));
844 p
= skip_spaces_const (p
);
847 /* ps command also relies on no trailing fields
849 const char *ep
= strrchr (p
, ')');
852 printf_filtered ("Exec file: %.*s\n",
853 (int) (ep
- p
- 1), p
+ 1);
858 p
= skip_spaces_const (p
);
860 printf_filtered (_("State: %c\n"), *p
++);
863 printf_filtered (_("Parent process: %s\n"),
864 pulongest (strtoulst (p
, &p
, 10)));
866 printf_filtered (_("Process group: %s\n"),
867 pulongest (strtoulst (p
, &p
, 10)));
869 printf_filtered (_("Session id: %s\n"),
870 pulongest (strtoulst (p
, &p
, 10)));
872 printf_filtered (_("TTY: %s\n"),
873 pulongest (strtoulst (p
, &p
, 10)));
875 printf_filtered (_("TTY owner process group: %s\n"),
876 pulongest (strtoulst (p
, &p
, 10)));
879 printf_filtered (_("Flags: %s\n"),
880 hex_string (strtoulst (p
, &p
, 10)));
882 printf_filtered (_("Minor faults (no memory page): %s\n"),
883 pulongest (strtoulst (p
, &p
, 10)));
885 printf_filtered (_("Minor faults, children: %s\n"),
886 pulongest (strtoulst (p
, &p
, 10)));
888 printf_filtered (_("Major faults (memory page faults): %s\n"),
889 pulongest (strtoulst (p
, &p
, 10)));
891 printf_filtered (_("Major faults, children: %s\n"),
892 pulongest (strtoulst (p
, &p
, 10)));
894 printf_filtered (_("utime: %s\n"),
895 pulongest (strtoulst (p
, &p
, 10)));
897 printf_filtered (_("stime: %s\n"),
898 pulongest (strtoulst (p
, &p
, 10)));
900 printf_filtered (_("utime, children: %s\n"),
901 pulongest (strtoulst (p
, &p
, 10)));
903 printf_filtered (_("stime, children: %s\n"),
904 pulongest (strtoulst (p
, &p
, 10)));
906 printf_filtered (_("jiffies remaining in current "
908 pulongest (strtoulst (p
, &p
, 10)));
910 printf_filtered (_("'nice' value: %s\n"),
911 pulongest (strtoulst (p
, &p
, 10)));
913 printf_filtered (_("jiffies until next timeout: %s\n"),
914 pulongest (strtoulst (p
, &p
, 10)));
916 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
917 pulongest (strtoulst (p
, &p
, 10)));
919 printf_filtered (_("start time (jiffies since "
920 "system boot): %s\n"),
921 pulongest (strtoulst (p
, &p
, 10)));
923 printf_filtered (_("Virtual memory size: %s\n"),
924 pulongest (strtoulst (p
, &p
, 10)));
926 printf_filtered (_("Resident set size: %s\n"),
927 pulongest (strtoulst (p
, &p
, 10)));
929 printf_filtered (_("rlim: %s\n"),
930 pulongest (strtoulst (p
, &p
, 10)));
932 printf_filtered (_("Start of text: %s\n"),
933 hex_string (strtoulst (p
, &p
, 10)));
935 printf_filtered (_("End of text: %s\n"),
936 hex_string (strtoulst (p
, &p
, 10)));
938 printf_filtered (_("Start of stack: %s\n"),
939 hex_string (strtoulst (p
, &p
, 10)));
940 #if 0 /* Don't know how architecture-dependent the rest is...
941 Anyway the signal bitmap info is available from "status". */
943 printf_filtered (_("Kernel stack pointer: %s\n"),
944 hex_string (strtoulst (p
, &p
, 10)));
946 printf_filtered (_("Kernel instr pointer: %s\n"),
947 hex_string (strtoulst (p
, &p
, 10)));
949 printf_filtered (_("Pending signals bitmap: %s\n"),
950 hex_string (strtoulst (p
, &p
, 10)));
952 printf_filtered (_("Blocked signals bitmap: %s\n"),
953 hex_string (strtoulst (p
, &p
, 10)));
955 printf_filtered (_("Ignored signals bitmap: %s\n"),
956 hex_string (strtoulst (p
, &p
, 10)));
958 printf_filtered (_("Catched signals bitmap: %s\n"),
959 hex_string (strtoulst (p
, &p
, 10)));
961 printf_filtered (_("wchan (system call): %s\n"),
962 hex_string (strtoulst (p
, &p
, 10)));
964 do_cleanups (cleanup
);
967 warning (_("unable to open /proc file '%s'"), filename
);
971 /* Implement "info proc mappings" for a corefile. */
974 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
977 ULONGEST count
, page_size
;
978 unsigned char *descdata
, *filenames
, *descend
, *contents
;
980 unsigned int addr_size_bits
, addr_size
;
981 struct cleanup
*cleanup
;
982 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
983 /* We assume this for reading 64-bit core files. */
984 gdb_static_assert (sizeof (ULONGEST
) >= 8);
986 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
989 warning (_("unable to find mappings in core file"));
993 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
994 addr_size
= addr_size_bits
/ 8;
995 note_size
= bfd_get_section_size (section
);
997 if (note_size
< 2 * addr_size
)
998 error (_("malformed core note - too short for header"));
1000 contents
= xmalloc (note_size
);
1001 cleanup
= make_cleanup (xfree
, contents
);
1002 if (!bfd_get_section_contents (core_bfd
, section
, contents
, 0, note_size
))
1003 error (_("could not get core note contents"));
1005 descdata
= contents
;
1006 descend
= descdata
+ note_size
;
1008 if (descdata
[note_size
- 1] != '\0')
1009 error (_("malformed note - does not end with \\0"));
1011 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1012 descdata
+= addr_size
;
1014 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1015 descdata
+= addr_size
;
1017 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1018 error (_("malformed note - too short for supplied file count"));
1020 printf_filtered (_("Mapped address spaces:\n\n"));
1021 if (gdbarch_addr_bit (gdbarch
) == 32)
1023 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1026 " Size", " Offset", "objfile");
1030 printf_filtered (" %18s %18s %10s %10s %s\n",
1033 " Size", " Offset", "objfile");
1036 filenames
= descdata
+ count
* 3 * addr_size
;
1039 ULONGEST start
, end
, file_ofs
;
1041 if (filenames
== descend
)
1042 error (_("malformed note - filenames end too early"));
1044 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1045 descdata
+= addr_size
;
1046 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1047 descdata
+= addr_size
;
1048 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1049 descdata
+= addr_size
;
1051 file_ofs
*= page_size
;
1053 if (gdbarch_addr_bit (gdbarch
) == 32)
1054 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1055 paddress (gdbarch
, start
),
1056 paddress (gdbarch
, end
),
1057 hex_string (end
- start
),
1058 hex_string (file_ofs
),
1061 printf_filtered (" %18s %18s %10s %10s %s\n",
1062 paddress (gdbarch
, start
),
1063 paddress (gdbarch
, end
),
1064 hex_string (end
- start
),
1065 hex_string (file_ofs
),
1068 filenames
+= 1 + strlen ((char *) filenames
);
1071 do_cleanups (cleanup
);
1074 /* Implement "info proc" for a corefile. */
1077 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1078 enum info_proc_what what
)
1080 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1081 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1087 exe
= bfd_core_file_failing_command (core_bfd
);
1089 printf_filtered ("exe = '%s'\n", exe
);
1091 warning (_("unable to find command name in core file"));
1095 linux_core_info_proc_mappings (gdbarch
, args
);
1097 if (!exe_f
&& !mappings_f
)
1098 error (_("unable to handle request"));
1101 /* Callback function for linux_find_memory_regions_full. If it returns
1102 non-zero linux_find_memory_regions_full returns immediately with that
1105 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1106 ULONGEST offset
, ULONGEST inode
,
1107 int read
, int write
,
1108 int exec
, int modified
,
1109 const char *filename
,
1112 /* List memory regions in the inferior PID matched to FILTERFLAGS for
1113 a corefile. Call FUNC with FUNC_DATA for each such region. Return
1114 immediately with the value returned by FUNC if it is non-zero.
1115 *MEMORY_TO_FREE_PTR should be registered to be freed automatically if
1116 called FUNC throws an exception. MEMORY_TO_FREE_PTR can be also
1117 passed as NULL if it is not used. Return -1 if error occurs, 0 if
1118 all memory regions have been processed or return the value from FUNC
1119 if FUNC returns non-zero. */
1122 linux_find_memory_regions_full (pid_t pid
, enum filterflags filterflags
,
1123 linux_find_memory_region_ftype
*func
,
1126 char mapsfilename
[100];
1129 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1130 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1133 /* Older Linux kernels did not support /proc/PID/smaps. */
1134 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1135 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1140 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
1144 line
= strtok_r (data
, "\n", &t
);
1145 while (line
!= NULL
)
1147 ULONGEST addr
, endaddr
, offset
, inode
;
1148 const char *permissions
, *device
, *filename
;
1149 struct smaps_vmflags v
;
1150 size_t permissions_len
, device_len
;
1151 int read
, write
, exec
, priv
;
1152 int has_anonymous
= 0;
1153 int should_dump_p
= 0;
1157 memset (&v
, 0, sizeof (v
));
1158 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1159 &offset
, &device
, &device_len
, &inode
, &filename
);
1160 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1161 /* If the mapping is not anonymous, then we can consider it
1162 to be file-backed. These two states (anonymous or
1163 file-backed) seem to be exclusive, but they can actually
1164 coexist. For example, if a file-backed mapping has
1165 "Anonymous:" pages (see more below), then the Linux
1166 kernel will dump this mapping when the user specified
1167 that she only wants anonymous mappings in the corefile
1168 (*even* when she explicitly disabled the dumping of
1169 file-backed mappings). */
1170 mapping_file_p
= !mapping_anon_p
;
1172 /* Decode permissions. */
1173 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1174 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1175 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1176 /* 'private' here actually means VM_MAYSHARE, and not
1177 VM_SHARED. In order to know if a mapping is really
1178 private or not, we must check the flag "sh" in the
1179 VmFlags field. This is done by decode_vmflags. However,
1180 if we are using a Linux kernel released before the commit
1181 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1182 not have the VmFlags there. In this case, there is
1183 really no way to know if we are dealing with VM_SHARED,
1184 so we just assume that VM_MAYSHARE is enough. */
1185 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1187 /* Try to detect if region should be dumped by parsing smaps
1189 for (line
= strtok_r (NULL
, "\n", &t
);
1190 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1191 line
= strtok_r (NULL
, "\n", &t
))
1193 char keyword
[64 + 1];
1195 if (sscanf (line
, "%64s", keyword
) != 1)
1197 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1201 if (strcmp (keyword
, "Anonymous:") == 0)
1203 /* Older Linux kernels did not support the
1204 "Anonymous:" counter. Check it here. */
1207 else if (strcmp (keyword
, "VmFlags:") == 0)
1208 decode_vmflags (line
, &v
);
1210 if (strcmp (keyword
, "AnonHugePages:") == 0
1211 || strcmp (keyword
, "Anonymous:") == 0)
1213 unsigned long number
;
1215 if (sscanf (line
, "%*s%lu", &number
) != 1)
1217 warning (_("Error parsing {s,}maps file '%s' number"),
1223 /* Even if we are dealing with a file-backed
1224 mapping, if it contains anonymous pages we
1225 consider it to be *also* an anonymous
1226 mapping, because this is what the Linux
1229 // Dump segments that have been written to.
1230 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1233 Note that if the mapping is already marked as
1234 file-backed (i.e., mapping_file_p is
1235 non-zero), then this is a special case, and
1236 this mapping will be dumped either when the
1237 user wants to dump file-backed *or* anonymous
1245 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1246 mapping_anon_p
, mapping_file_p
,
1250 /* Older Linux kernels did not support the "Anonymous:" counter.
1251 If it is missing, we can't be sure - dump all the pages. */
1255 /* Invoke the callback function to create the corefile segment. */
1257 retval
= func (addr
, endaddr
- addr
, offset
, inode
,
1259 1, /* MODIFIED is true because we want to dump the
1261 filename
, func_data
);
1266 do_cleanups (cleanup
);
1273 /* A structure for passing information through
1274 linux_find_memory_regions_full. */
1276 struct linux_find_memory_regions_data
1278 /* The original callback. */
1280 find_memory_region_ftype func
;
1282 /* The original datum. */
1287 /* A callback for linux_find_memory_regions that converts between the
1288 "full"-style callback and find_memory_region_ftype. */
1291 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1292 ULONGEST offset
, ULONGEST inode
,
1293 int read
, int write
, int exec
, int modified
,
1294 const char *filename
, void *arg
)
1296 struct linux_find_memory_regions_data
*data
= arg
;
1298 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->data
);
1301 /* Wrapper of linux_find_memory_regions_full handling FAKE_PID_P in GDB. */
1304 linux_find_memory_regions_gdb (struct gdbarch
*gdbarch
,
1305 linux_find_memory_region_ftype
*func
,
1309 /* Default dump behavior of coredump_filter (0x33), according to
1310 Documentation/filesystems/proc.txt from the Linux kernel
1312 enum filterflags filterflags
= (COREFILTER_ANON_PRIVATE
1313 | COREFILTER_ANON_SHARED
1314 | COREFILTER_ELF_HEADERS
1315 | COREFILTER_HUGETLB_PRIVATE
);
1317 /* We need to know the real target PID so
1318 linux_find_memory_regions_full can access /proc. */
1319 if (current_inferior ()->fake_pid_p
)
1322 pid
= current_inferior ()->pid
;
1324 if (use_coredump_filter
)
1326 char coredumpfilter_name
[100], *coredumpfilterdata
;
1328 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1329 "/proc/%d/coredump_filter", pid
);
1330 coredumpfilterdata
= target_fileio_read_stralloc (NULL
,
1331 coredumpfilter_name
);
1332 if (coredumpfilterdata
!= NULL
)
1334 sscanf (coredumpfilterdata
, "%x", &filterflags
);
1335 xfree (coredumpfilterdata
);
1339 return linux_find_memory_regions_full (pid
, filterflags
, func
, func_data
);
1342 /* A variant of linux_find_memory_regions_full that is suitable as the
1343 gdbarch find_memory_regions method. */
1346 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1347 find_memory_region_ftype func
, void *func_data
)
1349 struct linux_find_memory_regions_data data
;
1352 data
.data
= func_data
;
1354 return linux_find_memory_regions_gdb (gdbarch
,
1355 linux_find_memory_regions_thunk
, &data
);
1358 /* Determine which signal stopped execution. */
1361 find_signalled_thread (struct thread_info
*info
, void *data
)
1363 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1364 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
1370 static enum gdb_signal
1371 find_stop_signal (void)
1373 struct thread_info
*info
=
1374 iterate_over_threads (find_signalled_thread
, NULL
);
1377 return info
->suspend
.stop_signal
;
1379 return GDB_SIGNAL_0
;
1382 /* Generate corefile notes for SPU contexts. */
1385 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1387 static const char *spu_files
[] =
1409 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1413 /* Determine list of SPU ids. */
1414 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1417 /* Generate corefile notes for each SPU file. */
1418 for (i
= 0; i
< size
; i
+= 4)
1420 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
1422 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1424 char annex
[32], note_name
[32];
1428 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1429 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1433 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1434 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1454 /* This is used to pass information from
1455 linux_make_mappings_corefile_notes through
1456 linux_find_memory_regions_full. */
1458 struct linux_make_mappings_data
1460 /* Number of files mapped. */
1461 ULONGEST file_count
;
1463 /* The obstack for the main part of the data. */
1464 struct obstack
*data_obstack
;
1466 /* The filename obstack. */
1467 struct obstack
*filename_obstack
;
1469 /* The architecture's "long" type. */
1470 struct type
*long_type
;
1473 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1475 /* A callback for linux_find_memory_regions_full that updates the
1476 mappings data for linux_make_mappings_corefile_notes. */
1479 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1480 ULONGEST offset
, ULONGEST inode
,
1481 int read
, int write
, int exec
, int modified
,
1482 const char *filename
, void *data
)
1484 struct linux_make_mappings_data
*map_data
= data
;
1485 gdb_byte buf
[sizeof (ULONGEST
)];
1487 if (*filename
== '\0' || inode
== 0)
1490 ++map_data
->file_count
;
1492 pack_long (buf
, map_data
->long_type
, vaddr
);
1493 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1494 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1495 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1496 pack_long (buf
, map_data
->long_type
, offset
);
1497 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1499 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1504 /* Write the file mapping data to the core file, if possible. OBFD is
1505 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1506 is a pointer to the note size. Returns the new NOTE_DATA and
1507 updates NOTE_SIZE. */
1510 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1511 char *note_data
, int *note_size
)
1513 struct cleanup
*cleanup
;
1514 struct obstack data_obstack
, filename_obstack
;
1515 struct linux_make_mappings_data mapping_data
;
1516 struct type
*long_type
1517 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1518 gdb_byte buf
[sizeof (ULONGEST
)];
1520 obstack_init (&data_obstack
);
1521 cleanup
= make_cleanup_obstack_free (&data_obstack
);
1522 obstack_init (&filename_obstack
);
1523 make_cleanup_obstack_free (&filename_obstack
);
1525 mapping_data
.file_count
= 0;
1526 mapping_data
.data_obstack
= &data_obstack
;
1527 mapping_data
.filename_obstack
= &filename_obstack
;
1528 mapping_data
.long_type
= long_type
;
1530 /* Reserve space for the count. */
1531 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1532 /* We always write the page size as 1 since we have no good way to
1533 determine the correct value. */
1534 pack_long (buf
, long_type
, 1);
1535 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1537 linux_find_memory_regions_gdb (gdbarch
, linux_make_mappings_callback
,
1540 if (mapping_data
.file_count
!= 0)
1542 /* Write the count to the obstack. */
1543 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1544 long_type
, mapping_data
.file_count
);
1546 /* Copy the filenames to the data obstack. */
1547 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1548 obstack_object_size (&filename_obstack
));
1550 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1552 obstack_base (&data_obstack
),
1553 obstack_object_size (&data_obstack
));
1556 do_cleanups (cleanup
);
1560 /* Structure for passing information from
1561 linux_collect_thread_registers via an iterator to
1562 linux_collect_regset_section_cb. */
1564 struct linux_collect_regset_section_cb_data
1566 struct gdbarch
*gdbarch
;
1567 const struct regcache
*regcache
;
1572 enum gdb_signal stop_signal
;
1573 int abort_iteration
;
1576 /* Callback for iterate_over_regset_sections that records a single
1577 regset in the corefile note section. */
1580 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1581 const struct regset
*regset
,
1582 const char *human_name
, void *cb_data
)
1585 struct linux_collect_regset_section_cb_data
*data
= cb_data
;
1587 if (data
->abort_iteration
)
1590 gdb_assert (regset
&& regset
->collect_regset
);
1592 buf
= xmalloc (size
);
1593 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1595 /* PRSTATUS still needs to be treated specially. */
1596 if (strcmp (sect_name
, ".reg") == 0)
1597 data
->note_data
= (char *) elfcore_write_prstatus
1598 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1599 gdb_signal_to_host (data
->stop_signal
), buf
);
1601 data
->note_data
= (char *) elfcore_write_register_note
1602 (data
->obfd
, data
->note_data
, data
->note_size
,
1603 sect_name
, buf
, size
);
1606 if (data
->note_data
== NULL
)
1607 data
->abort_iteration
= 1;
1610 /* Records the thread's register state for the corefile note
1614 linux_collect_thread_registers (const struct regcache
*regcache
,
1615 ptid_t ptid
, bfd
*obfd
,
1616 char *note_data
, int *note_size
,
1617 enum gdb_signal stop_signal
)
1619 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1620 struct linux_collect_regset_section_cb_data data
;
1622 data
.gdbarch
= gdbarch
;
1623 data
.regcache
= regcache
;
1625 data
.note_data
= note_data
;
1626 data
.note_size
= note_size
;
1627 data
.stop_signal
= stop_signal
;
1628 data
.abort_iteration
= 0;
1630 /* For remote targets the LWP may not be available, so use the TID. */
1631 data
.lwp
= ptid_get_lwp (ptid
);
1633 data
.lwp
= ptid_get_tid (ptid
);
1635 gdbarch_iterate_over_regset_sections (gdbarch
,
1636 linux_collect_regset_section_cb
,
1638 return data
.note_data
;
1641 /* Fetch the siginfo data for the current thread, if it exists. If
1642 there is no data, or we could not read it, return NULL. Otherwise,
1643 return a newly malloc'd buffer holding the data and fill in *SIZE
1644 with the size of the data. The caller is responsible for freeing
1648 linux_get_siginfo_data (struct gdbarch
*gdbarch
, LONGEST
*size
)
1650 struct type
*siginfo_type
;
1653 struct cleanup
*cleanups
;
1655 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1658 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1660 buf
= xmalloc (TYPE_LENGTH (siginfo_type
));
1661 cleanups
= make_cleanup (xfree
, buf
);
1663 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1664 buf
, 0, TYPE_LENGTH (siginfo_type
));
1665 if (bytes_read
== TYPE_LENGTH (siginfo_type
))
1667 discard_cleanups (cleanups
);
1672 do_cleanups (cleanups
);
1679 struct linux_corefile_thread_data
1681 struct gdbarch
*gdbarch
;
1686 enum gdb_signal stop_signal
;
1689 /* Called by gdbthread.c once per thread. Records the thread's
1690 register state for the corefile note section. */
1693 linux_corefile_thread_callback (struct thread_info
*info
, void *data
)
1695 struct linux_corefile_thread_data
*args
= data
;
1697 /* It can be current thread
1698 which cannot be removed by update_thread_list. */
1699 if (info
->state
== THREAD_EXITED
)
1702 if (ptid_get_pid (info
->ptid
) == args
->pid
)
1704 struct cleanup
*old_chain
;
1705 struct regcache
*regcache
;
1706 gdb_byte
*siginfo_data
;
1707 LONGEST siginfo_size
= 0;
1709 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1711 old_chain
= save_inferior_ptid ();
1712 inferior_ptid
= info
->ptid
;
1713 target_fetch_registers (regcache
, -1);
1714 siginfo_data
= linux_get_siginfo_data (args
->gdbarch
, &siginfo_size
);
1715 do_cleanups (old_chain
);
1717 old_chain
= make_cleanup (xfree
, siginfo_data
);
1719 args
->note_data
= linux_collect_thread_registers
1720 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1721 args
->note_size
, args
->stop_signal
);
1723 /* Don't return anything if we got no register information above,
1724 such a core file is useless. */
1725 if (args
->note_data
!= NULL
)
1726 if (siginfo_data
!= NULL
)
1727 args
->note_data
= elfcore_write_note (args
->obfd
,
1731 siginfo_data
, siginfo_size
);
1733 do_cleanups (old_chain
);
1736 return !args
->note_data
;
1739 /* Fill the PRPSINFO structure with information about the process being
1740 debugged. Returns 1 in case of success, 0 for failures. Please note that
1741 even if the structure cannot be entirely filled (e.g., GDB was unable to
1742 gather information about the process UID/GID), this function will still
1743 return 1 since some information was already recorded. It will only return
1744 0 iff nothing can be gathered. */
1747 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1749 /* The filename which we will use to obtain some info about the process.
1750 We will basically use this to store the `/proc/PID/FILENAME' file. */
1752 /* The full name of the program which generated the corefile. */
1754 /* The basename of the executable. */
1755 const char *basename
;
1756 /* The arguments of the program. */
1759 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1760 char *proc_stat
, *proc_status
;
1761 /* Temporary buffer. */
1763 /* The valid states of a process, according to the Linux kernel. */
1764 const char valid_states
[] = "RSDTZW";
1765 /* The program state. */
1766 const char *prog_state
;
1767 /* The state of the process. */
1769 /* The PID of the program which generated the corefile. */
1771 /* Process flags. */
1772 unsigned int pr_flag
;
1773 /* Process nice value. */
1775 /* The number of fields read by `sscanf'. */
1781 gdb_assert (p
!= NULL
);
1783 /* Obtaining PID and filename. */
1784 pid
= ptid_get_pid (inferior_ptid
);
1785 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1786 fname
= target_fileio_read_stralloc (NULL
, filename
);
1788 if (fname
== NULL
|| *fname
== '\0')
1790 /* No program name was read, so we won't be able to retrieve more
1791 information about the process. */
1796 c
= make_cleanup (xfree
, fname
);
1797 memset (p
, 0, sizeof (*p
));
1799 /* Defining the PID. */
1802 /* Copying the program name. Only the basename matters. */
1803 basename
= lbasename (fname
);
1804 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1805 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1807 infargs
= get_inferior_args ();
1809 psargs
= xstrdup (fname
);
1810 if (infargs
!= NULL
)
1811 psargs
= reconcat (psargs
, psargs
, " ", infargs
, NULL
);
1813 make_cleanup (xfree
, psargs
);
1815 strncpy (p
->pr_psargs
, psargs
, sizeof (p
->pr_psargs
));
1816 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1818 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1819 proc_stat
= target_fileio_read_stralloc (NULL
, filename
);
1820 make_cleanup (xfree
, proc_stat
);
1822 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1824 /* Despite being unable to read more information about the
1825 process, we return 1 here because at least we have its
1826 command line, PID and arguments. */
1831 /* Ok, we have the stats. It's time to do a little parsing of the
1832 contents of the buffer, so that we end up reading what we want.
1834 The following parsing mechanism is strongly based on the
1835 information generated by the `fs/proc/array.c' file, present in
1836 the Linux kernel tree. More details about how the information is
1837 displayed can be obtained by seeing the manpage of proc(5),
1838 specifically under the entry of `/proc/[pid]/stat'. */
1840 /* Getting rid of the PID, since we already have it. */
1841 while (isdigit (*proc_stat
))
1844 proc_stat
= skip_spaces (proc_stat
);
1846 /* ps command also relies on no trailing fields ever contain ')'. */
1847 proc_stat
= strrchr (proc_stat
, ')');
1848 if (proc_stat
== NULL
)
1855 proc_stat
= skip_spaces (proc_stat
);
1857 n_fields
= sscanf (proc_stat
,
1858 "%c" /* Process state. */
1859 "%d%d%d" /* Parent PID, group ID, session ID. */
1860 "%*d%*d" /* tty_nr, tpgid (not used). */
1862 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1863 cmajflt (not used). */
1864 "%*s%*s%*s%*s" /* utime, stime, cutime,
1865 cstime (not used). */
1866 "%*s" /* Priority (not used). */
1869 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1875 /* Again, we couldn't read the complementary information about
1876 the process state. However, we already have minimal
1877 information, so we just return 1 here. */
1882 /* Filling the structure fields. */
1883 prog_state
= strchr (valid_states
, pr_sname
);
1884 if (prog_state
!= NULL
)
1885 p
->pr_state
= prog_state
- valid_states
;
1888 /* Zero means "Running". */
1892 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1893 p
->pr_zomb
= p
->pr_sname
== 'Z';
1894 p
->pr_nice
= pr_nice
;
1895 p
->pr_flag
= pr_flag
;
1897 /* Finally, obtaining the UID and GID. For that, we read and parse the
1898 contents of the `/proc/PID/status' file. */
1899 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1900 proc_status
= target_fileio_read_stralloc (NULL
, filename
);
1901 make_cleanup (xfree
, proc_status
);
1903 if (proc_status
== NULL
|| *proc_status
== '\0')
1905 /* Returning 1 since we already have a bunch of information. */
1910 /* Extracting the UID. */
1911 tmpstr
= strstr (proc_status
, "Uid:");
1914 /* Advancing the pointer to the beginning of the UID. */
1915 tmpstr
+= sizeof ("Uid:");
1916 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1919 if (isdigit (*tmpstr
))
1920 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1923 /* Extracting the GID. */
1924 tmpstr
= strstr (proc_status
, "Gid:");
1927 /* Advancing the pointer to the beginning of the GID. */
1928 tmpstr
+= sizeof ("Gid:");
1929 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1932 if (isdigit (*tmpstr
))
1933 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1941 /* Build the note section for a corefile, and return it in a malloc
1945 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1947 struct linux_corefile_thread_data thread_args
;
1948 struct elf_internal_linux_prpsinfo prpsinfo
;
1949 char *note_data
= NULL
;
1953 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1956 if (linux_fill_prpsinfo (&prpsinfo
))
1958 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch
))
1960 note_data
= gdbarch_elfcore_write_linux_prpsinfo (gdbarch
, obfd
,
1961 note_data
, note_size
,
1966 if (gdbarch_ptr_bit (gdbarch
) == 64)
1967 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1968 note_data
, note_size
,
1971 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1972 note_data
, note_size
,
1977 /* Thread register information. */
1980 update_thread_list ();
1982 CATCH (e
, RETURN_MASK_ERROR
)
1984 exception_print (gdb_stderr
, e
);
1988 thread_args
.gdbarch
= gdbarch
;
1989 thread_args
.pid
= ptid_get_pid (inferior_ptid
);
1990 thread_args
.obfd
= obfd
;
1991 thread_args
.note_data
= note_data
;
1992 thread_args
.note_size
= note_size
;
1993 thread_args
.stop_signal
= find_stop_signal ();
1994 iterate_over_threads (linux_corefile_thread_callback
, &thread_args
);
1995 note_data
= thread_args
.note_data
;
1999 /* Auxillary vector. */
2000 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
2004 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
2005 "CORE", NT_AUXV
, auxv
, auxv_len
);
2012 /* SPU information. */
2013 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
2017 /* File mappings. */
2018 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
2019 note_data
, note_size
);
2024 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2025 gdbarch.h. This function is not static because it is exported to
2026 other -tdep files. */
2029 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2034 return GDB_SIGNAL_0
;
2037 return GDB_SIGNAL_HUP
;
2040 return GDB_SIGNAL_INT
;
2043 return GDB_SIGNAL_QUIT
;
2046 return GDB_SIGNAL_ILL
;
2049 return GDB_SIGNAL_TRAP
;
2052 return GDB_SIGNAL_ABRT
;
2055 return GDB_SIGNAL_BUS
;
2058 return GDB_SIGNAL_FPE
;
2061 return GDB_SIGNAL_KILL
;
2064 return GDB_SIGNAL_USR1
;
2067 return GDB_SIGNAL_SEGV
;
2070 return GDB_SIGNAL_USR2
;
2073 return GDB_SIGNAL_PIPE
;
2076 return GDB_SIGNAL_ALRM
;
2079 return GDB_SIGNAL_TERM
;
2082 return GDB_SIGNAL_CHLD
;
2085 return GDB_SIGNAL_CONT
;
2088 return GDB_SIGNAL_STOP
;
2091 return GDB_SIGNAL_TSTP
;
2094 return GDB_SIGNAL_TTIN
;
2097 return GDB_SIGNAL_TTOU
;
2100 return GDB_SIGNAL_URG
;
2103 return GDB_SIGNAL_XCPU
;
2106 return GDB_SIGNAL_XFSZ
;
2108 case LINUX_SIGVTALRM
:
2109 return GDB_SIGNAL_VTALRM
;
2112 return GDB_SIGNAL_PROF
;
2114 case LINUX_SIGWINCH
:
2115 return GDB_SIGNAL_WINCH
;
2117 /* No way to differentiate between SIGIO and SIGPOLL.
2118 Therefore, we just handle the first one. */
2120 return GDB_SIGNAL_IO
;
2123 return GDB_SIGNAL_PWR
;
2126 return GDB_SIGNAL_SYS
;
2128 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2129 therefore we have to handle them here. */
2130 case LINUX_SIGRTMIN
:
2131 return GDB_SIGNAL_REALTIME_32
;
2133 case LINUX_SIGRTMAX
:
2134 return GDB_SIGNAL_REALTIME_64
;
2137 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2139 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2141 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2144 return GDB_SIGNAL_UNKNOWN
;
2147 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2148 gdbarch.h. This function is not static because it is exported to
2149 other -tdep files. */
2152 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2153 enum gdb_signal signal
)
2160 case GDB_SIGNAL_HUP
:
2161 return LINUX_SIGHUP
;
2163 case GDB_SIGNAL_INT
:
2164 return LINUX_SIGINT
;
2166 case GDB_SIGNAL_QUIT
:
2167 return LINUX_SIGQUIT
;
2169 case GDB_SIGNAL_ILL
:
2170 return LINUX_SIGILL
;
2172 case GDB_SIGNAL_TRAP
:
2173 return LINUX_SIGTRAP
;
2175 case GDB_SIGNAL_ABRT
:
2176 return LINUX_SIGABRT
;
2178 case GDB_SIGNAL_FPE
:
2179 return LINUX_SIGFPE
;
2181 case GDB_SIGNAL_KILL
:
2182 return LINUX_SIGKILL
;
2184 case GDB_SIGNAL_BUS
:
2185 return LINUX_SIGBUS
;
2187 case GDB_SIGNAL_SEGV
:
2188 return LINUX_SIGSEGV
;
2190 case GDB_SIGNAL_SYS
:
2191 return LINUX_SIGSYS
;
2193 case GDB_SIGNAL_PIPE
:
2194 return LINUX_SIGPIPE
;
2196 case GDB_SIGNAL_ALRM
:
2197 return LINUX_SIGALRM
;
2199 case GDB_SIGNAL_TERM
:
2200 return LINUX_SIGTERM
;
2202 case GDB_SIGNAL_URG
:
2203 return LINUX_SIGURG
;
2205 case GDB_SIGNAL_STOP
:
2206 return LINUX_SIGSTOP
;
2208 case GDB_SIGNAL_TSTP
:
2209 return LINUX_SIGTSTP
;
2211 case GDB_SIGNAL_CONT
:
2212 return LINUX_SIGCONT
;
2214 case GDB_SIGNAL_CHLD
:
2215 return LINUX_SIGCHLD
;
2217 case GDB_SIGNAL_TTIN
:
2218 return LINUX_SIGTTIN
;
2220 case GDB_SIGNAL_TTOU
:
2221 return LINUX_SIGTTOU
;
2226 case GDB_SIGNAL_XCPU
:
2227 return LINUX_SIGXCPU
;
2229 case GDB_SIGNAL_XFSZ
:
2230 return LINUX_SIGXFSZ
;
2232 case GDB_SIGNAL_VTALRM
:
2233 return LINUX_SIGVTALRM
;
2235 case GDB_SIGNAL_PROF
:
2236 return LINUX_SIGPROF
;
2238 case GDB_SIGNAL_WINCH
:
2239 return LINUX_SIGWINCH
;
2241 case GDB_SIGNAL_USR1
:
2242 return LINUX_SIGUSR1
;
2244 case GDB_SIGNAL_USR2
:
2245 return LINUX_SIGUSR2
;
2247 case GDB_SIGNAL_PWR
:
2248 return LINUX_SIGPWR
;
2250 case GDB_SIGNAL_POLL
:
2251 return LINUX_SIGPOLL
;
2253 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2254 therefore we have to handle it here. */
2255 case GDB_SIGNAL_REALTIME_32
:
2256 return LINUX_SIGRTMIN
;
2258 /* Same comment applies to _64. */
2259 case GDB_SIGNAL_REALTIME_64
:
2260 return LINUX_SIGRTMAX
;
2263 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2264 if (signal
>= GDB_SIGNAL_REALTIME_33
2265 && signal
<= GDB_SIGNAL_REALTIME_63
)
2267 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2269 return LINUX_SIGRTMIN
+ 1 + offset
;
2275 /* Rummage through mappings to find a mapping's size. */
2278 find_mapping_size (CORE_ADDR vaddr
, unsigned long size
,
2279 int read
, int write
, int exec
, int modified
,
2282 struct mem_range
*range
= data
;
2284 if (vaddr
== range
->start
)
2286 range
->length
= size
;
2292 /* Helper for linux_vsyscall_range that does the real work of finding
2293 the vsyscall's address range. */
2296 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2298 if (target_auxv_search (¤t_target
, AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2301 /* This is installed by linux_init_abi below, so should always be
2303 gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2306 gdbarch_find_memory_regions (gdbarch
, find_mapping_size
, range
);
2310 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2311 caching, and defers the real work to linux_vsyscall_range_raw. */
2314 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2316 struct linux_info
*info
= get_linux_inferior_data ();
2318 if (info
->vsyscall_range_p
== 0)
2320 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2321 info
->vsyscall_range_p
= 1;
2323 info
->vsyscall_range_p
= -1;
2326 if (info
->vsyscall_range_p
< 0)
2329 *range
= info
->vsyscall_range
;
2333 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2334 definitions would be dependent on compilation host. */
2335 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2336 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2338 /* See gdbarch.sh 'infcall_mmap'. */
2341 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2343 struct objfile
*objf
;
2344 /* Do there still exist any Linux systems without "mmap64"?
2345 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2346 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2347 struct value
*addr_val
;
2348 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2352 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2354 struct value
*arg
[ARG_LAST
];
2356 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2358 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2359 arg
[ARG_LENGTH
] = value_from_ulongest
2360 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2361 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2362 | GDB_MMAP_PROT_EXEC
))
2364 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2365 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2366 GDB_MMAP_MAP_PRIVATE
2367 | GDB_MMAP_MAP_ANONYMOUS
);
2368 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2369 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2371 addr_val
= call_function_by_hand (mmap_val
, ARG_LAST
, arg
);
2372 retval
= value_as_address (addr_val
);
2373 if (retval
== (CORE_ADDR
) -1)
2374 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2379 /* See gdbarch.sh 'infcall_munmap'. */
2382 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2384 struct objfile
*objf
;
2385 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2386 struct value
*retval_val
;
2387 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2391 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2393 struct value
*arg
[ARG_LAST
];
2395 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2397 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2398 arg
[ARG_LENGTH
] = value_from_ulongest
2399 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2400 retval_val
= call_function_by_hand (munmap_val
, ARG_LAST
, arg
);
2401 retval
= value_as_long (retval_val
);
2403 warning (_("Failed inferior munmap call at %s for %s bytes, "
2404 "errno is changed."),
2405 hex_string (addr
), pulongest (size
));
2408 /* See linux-tdep.h. */
2411 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2416 /* Determine entry point from target auxiliary vector. This avoids
2417 the need for symbols. Also, when debugging a stand-alone SPU
2418 executable, entry_point_address () will point to an SPU
2419 local-store address and is thus not usable as displaced stepping
2420 location. The auxiliary vector gets us the PowerPC-side entry
2421 point address instead. */
2422 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
2423 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2425 /* Make certain that the address points at real code, and not a
2426 function descriptor. */
2427 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2430 /* Inferior calls also use the entry point as a breakpoint location.
2431 We don't want displaced stepping to interfere with those
2432 breakpoints, so leave space. */
2433 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2439 /* Display whether the gcore command is using the
2440 /proc/PID/coredump_filter file. */
2443 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2444 struct cmd_list_element
*c
, const char *value
)
2446 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2447 " corefiles is %s.\n"), value
);
2450 /* To be called from the various GDB_OSABI_LINUX handlers for the
2451 various GNU/Linux architectures and machine types. */
2454 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2456 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2457 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2458 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2459 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2460 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2461 set_gdbarch_has_shared_address_space (gdbarch
,
2462 linux_has_shared_address_space
);
2463 set_gdbarch_gdb_signal_from_target (gdbarch
,
2464 linux_gdb_signal_from_target
);
2465 set_gdbarch_gdb_signal_to_target (gdbarch
,
2466 linux_gdb_signal_to_target
);
2467 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2468 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2469 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2470 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2473 /* Provide a prototype to silence -Wmissing-prototypes. */
2474 extern initialize_file_ftype _initialize_linux_tdep
;
2477 _initialize_linux_tdep (void)
2479 linux_gdbarch_data_handle
=
2480 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2482 /* Set a cache per-inferior. */
2484 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2485 /* Observers used to invalidate the cache when needed. */
2486 observer_attach_inferior_exit (invalidate_linux_cache_inf
);
2487 observer_attach_inferior_appeared (invalidate_linux_cache_inf
);
2489 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2490 &use_coredump_filter
, _("\
2491 Set whether gcore should consider /proc/PID/coredump_filter."),
2493 Show whether gcore should consider /proc/PID/coredump_filter."),
2495 Use this command to set whether gcore should consider the contents\n\
2496 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2497 about this file, refer to the manpage of core(5)."),
2498 NULL
, show_use_coredump_filter
,
2499 &setlist
, &showlist
);