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 ((struct linux_gdbarch_data
*)
175 gdbarch_data (gdbarch
, linux_gdbarch_data_handle
));
178 /* Per-inferior data key. */
179 static const struct inferior_data
*linux_inferior_data
;
181 /* Linux-specific cached data. This is used by GDB for caching
182 purposes for each inferior. This helps reduce the overhead of
183 transfering data from a remote target to the local host. */
186 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
187 if VSYSCALL_RANGE_P is positive. This is cached because getting
188 at this info requires an auxv lookup (which is itself cached),
189 and looking through the inferior's mappings (which change
190 throughout execution and therefore cannot be cached). */
191 struct mem_range vsyscall_range
;
193 /* Zero if we haven't tried looking up the vsyscall's range before
194 yet. Positive if we tried looking it up, and found it. Negative
195 if we tried looking it up but failed. */
196 int vsyscall_range_p
;
199 /* Frees whatever allocated space there is to be freed and sets INF's
200 linux cache data pointer to NULL. */
203 invalidate_linux_cache_inf (struct inferior
*inf
)
205 struct linux_info
*info
;
207 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
211 set_inferior_data (inf
, linux_inferior_data
, NULL
);
215 /* Handles the cleanup of the linux cache for inferior INF. ARG is
216 ignored. Callback for the inferior_appeared and inferior_exit
220 linux_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
222 invalidate_linux_cache_inf (inf
);
225 /* Fetch the linux cache info for INF. This function always returns a
226 valid INFO pointer. */
228 static struct linux_info
*
229 get_linux_inferior_data (void)
231 struct linux_info
*info
;
232 struct inferior
*inf
= current_inferior ();
234 info
= (struct linux_info
*) inferior_data (inf
, linux_inferior_data
);
237 info
= XCNEW (struct linux_info
);
238 set_inferior_data (inf
, linux_inferior_data
, info
);
244 /* This function is suitable for architectures that don't
245 extend/override the standard siginfo structure. */
248 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
250 struct linux_gdbarch_data
*linux_gdbarch_data
;
251 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
;
252 struct type
*uid_type
, *pid_type
;
253 struct type
*sigval_type
, *clock_type
;
254 struct type
*siginfo_type
, *sifields_type
;
257 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
258 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
259 return linux_gdbarch_data
->siginfo_type
;
261 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
263 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
265 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
267 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
270 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
271 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
272 append_composite_type_field (sigval_type
, "sival_int", int_type
);
273 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
276 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
277 TYPE_LENGTH (int_type
), "__pid_t");
278 TYPE_TARGET_TYPE (pid_type
) = int_type
;
279 TYPE_TARGET_STUB (pid_type
) = 1;
282 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
283 TYPE_LENGTH (uint_type
), "__uid_t");
284 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
285 TYPE_TARGET_STUB (uid_type
) = 1;
288 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
289 TYPE_LENGTH (long_type
), "__clock_t");
290 TYPE_TARGET_TYPE (clock_type
) = long_type
;
291 TYPE_TARGET_STUB (clock_type
) = 1;
294 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
297 const int si_max_size
= 128;
299 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
302 if (gdbarch_ptr_bit (gdbarch
) == 64)
303 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
305 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
306 append_composite_type_field (sifields_type
, "_pad",
307 init_vector_type (int_type
, si_pad_size
));
311 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
312 append_composite_type_field (type
, "si_pid", pid_type
);
313 append_composite_type_field (type
, "si_uid", uid_type
);
314 append_composite_type_field (sifields_type
, "_kill", type
);
317 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
318 append_composite_type_field (type
, "si_tid", int_type
);
319 append_composite_type_field (type
, "si_overrun", int_type
);
320 append_composite_type_field (type
, "si_sigval", sigval_type
);
321 append_composite_type_field (sifields_type
, "_timer", type
);
324 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
325 append_composite_type_field (type
, "si_pid", pid_type
);
326 append_composite_type_field (type
, "si_uid", uid_type
);
327 append_composite_type_field (type
, "si_sigval", sigval_type
);
328 append_composite_type_field (sifields_type
, "_rt", type
);
331 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
332 append_composite_type_field (type
, "si_pid", pid_type
);
333 append_composite_type_field (type
, "si_uid", uid_type
);
334 append_composite_type_field (type
, "si_status", int_type
);
335 append_composite_type_field (type
, "si_utime", clock_type
);
336 append_composite_type_field (type
, "si_stime", clock_type
);
337 append_composite_type_field (sifields_type
, "_sigchld", type
);
340 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
341 append_composite_type_field (type
, "si_addr", void_ptr_type
);
342 append_composite_type_field (sifields_type
, "_sigfault", type
);
345 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
346 append_composite_type_field (type
, "si_band", long_type
);
347 append_composite_type_field (type
, "si_fd", int_type
);
348 append_composite_type_field (sifields_type
, "_sigpoll", type
);
351 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
352 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
353 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
354 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
355 append_composite_type_field (siginfo_type
, "si_code", int_type
);
356 append_composite_type_field_aligned (siginfo_type
,
357 "_sifields", sifields_type
,
358 TYPE_LENGTH (long_type
));
360 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
365 /* Return true if the target is running on uClinux instead of normal
369 linux_is_uclinux (void)
373 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
374 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
378 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
380 return linux_is_uclinux ();
383 /* This is how we want PTIDs from core files to be printed. */
386 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
390 if (ptid_get_lwp (ptid
) != 0)
392 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
396 return normal_pid_to_str (ptid
);
399 /* Service function for corefiles and info proc. */
402 read_mapping (const char *line
,
403 ULONGEST
*addr
, ULONGEST
*endaddr
,
404 const char **permissions
, size_t *permissions_len
,
406 const char **device
, size_t *device_len
,
408 const char **filename
)
410 const char *p
= line
;
412 *addr
= strtoulst (p
, &p
, 16);
415 *endaddr
= strtoulst (p
, &p
, 16);
417 p
= skip_spaces_const (p
);
419 while (*p
&& !isspace (*p
))
421 *permissions_len
= p
- *permissions
;
423 *offset
= strtoulst (p
, &p
, 16);
425 p
= skip_spaces_const (p
);
427 while (*p
&& !isspace (*p
))
429 *device_len
= p
- *device
;
431 *inode
= strtoulst (p
, &p
, 10);
433 p
= skip_spaces_const (p
);
437 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
439 This function was based on the documentation found on
440 <Documentation/filesystems/proc.txt>, on the Linux kernel.
442 Linux kernels before commit
443 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
447 decode_vmflags (char *p
, struct smaps_vmflags
*v
)
449 char *saveptr
= NULL
;
452 v
->initialized_p
= 1;
453 p
= skip_to_space (p
);
456 for (s
= strtok_r (p
, " ", &saveptr
);
458 s
= strtok_r (NULL
, " ", &saveptr
))
460 if (strcmp (s
, "io") == 0)
462 else if (strcmp (s
, "ht") == 0)
463 v
->uses_huge_tlb
= 1;
464 else if (strcmp (s
, "dd") == 0)
465 v
->exclude_coredump
= 1;
466 else if (strcmp (s
, "sh") == 0)
467 v
->shared_mapping
= 1;
471 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
473 FILENAME is the name of the file present in the first line of the
474 memory mapping, in the "/proc/PID/smaps" output. For example, if
477 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
479 Then FILENAME will be "/path/to/file". */
482 mapping_is_anonymous_p (const char *filename
)
484 static regex_t dev_zero_regex
, shmem_file_regex
, file_deleted_regex
;
485 static int init_regex_p
= 0;
489 struct cleanup
*c
= make_cleanup (null_cleanup
, NULL
);
491 /* Let's be pessimistic and assume there will be an error while
492 compiling the regex'es. */
495 /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
496 without the "(deleted)" string in the end). We know for
497 sure, based on the Linux kernel code, that memory mappings
498 whose associated filename is "/dev/zero" are guaranteed to be
500 compile_rx_or_error (&dev_zero_regex
, "^/dev/zero\\( (deleted)\\)\\?$",
501 _("Could not compile regex to match /dev/zero "
503 /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
504 without the "(deleted)" string in the end). These filenames
505 refer to shared memory (shmem), and memory mappings
506 associated with them are MAP_ANONYMOUS as well. */
507 compile_rx_or_error (&shmem_file_regex
,
508 "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
509 _("Could not compile regex to match shmem "
511 /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
512 Linux kernel's 'n_link == 0' code, which is responsible to
513 decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
514 mapping. In other words, if FILE_DELETED_REGEX matches, it
515 does not necessarily mean that we are dealing with an
516 anonymous shared mapping. However, there is no easy way to
517 detect this currently, so this is the best approximation we
520 As a result, GDB will dump readonly pages of deleted
521 executables when using the default value of coredump_filter
522 (0x33), while the Linux kernel will not dump those pages.
523 But we can live with that. */
524 compile_rx_or_error (&file_deleted_regex
, " (deleted)$",
525 _("Could not compile regex to match "
526 "'<file> (deleted)'"));
527 /* We will never release these regexes, so just discard the
529 discard_cleanups (c
);
531 /* If we reached this point, then everything succeeded. */
535 if (init_regex_p
== -1)
537 const char deleted
[] = " (deleted)";
538 size_t del_len
= sizeof (deleted
) - 1;
539 size_t filename_len
= strlen (filename
);
541 /* There was an error while compiling the regex'es above. In
542 order to try to give some reliable information to the caller,
543 we just try to find the string " (deleted)" in the filename.
544 If we managed to find it, then we assume the mapping is
546 return (filename_len
>= del_len
547 && strcmp (filename
+ filename_len
- del_len
, deleted
) == 0);
550 if (*filename
== '\0'
551 || regexec (&dev_zero_regex
, filename
, 0, NULL
, 0) == 0
552 || regexec (&shmem_file_regex
, filename
, 0, NULL
, 0) == 0
553 || regexec (&file_deleted_regex
, filename
, 0, NULL
, 0) == 0)
559 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
560 MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
561 greater than 0 if it should.
563 In a nutshell, this is the logic that we follow in order to decide
564 if a mapping should be dumped or not.
566 - If the mapping is associated to a file whose name ends with
567 " (deleted)", or if the file is "/dev/zero", or if it is
568 "/SYSV%08x" (shared memory), or if there is no file associated
569 with it, or if the AnonHugePages: or the Anonymous: fields in the
570 /proc/PID/smaps have contents, then GDB considers this mapping to
571 be anonymous. Otherwise, GDB considers this mapping to be a
572 file-backed mapping (because there will be a file associated with
575 It is worth mentioning that, from all those checks described
576 above, the most fragile is the one to see if the file name ends
577 with " (deleted)". This does not necessarily mean that the
578 mapping is anonymous, because the deleted file associated with
579 the mapping may have been a hard link to another file, for
580 example. The Linux kernel checks to see if "i_nlink == 0", but
581 GDB cannot easily (and normally) do this check (iff running as
582 root, it could find the mapping in /proc/PID/map_files/ and
583 determine whether there still are other hard links to the
584 inode/file). Therefore, we made a compromise here, and we assume
585 that if the file name ends with " (deleted)", then the mapping is
586 indeed anonymous. FWIW, this is something the Linux kernel could
587 do better: expose this information in a more direct way.
589 - If we see the flag "sh" in the "VmFlags:" field (in
590 /proc/PID/smaps), then certainly the memory mapping is shared
591 (VM_SHARED). If we have access to the VmFlags, and we don't see
592 the "sh" there, then certainly the mapping is private. However,
593 Linux kernels before commit
594 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
595 "VmFlags:" field; in that case, we use another heuristic: if we
596 see 'p' in the permission flags, then we assume that the mapping
597 is private, even though the presence of the 's' flag there would
598 mean VM_MAYSHARE, which means the mapping could still be private.
599 This should work OK enough, however. */
602 dump_mapping_p (enum filterflags filterflags
, const struct smaps_vmflags
*v
,
603 int maybe_private_p
, int mapping_anon_p
, int mapping_file_p
,
604 const char *filename
)
606 /* Initially, we trust in what we received from our caller. This
607 value may not be very precise (i.e., it was probably gathered
608 from the permission line in the /proc/PID/smaps list, which
609 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
610 what we have until we take a look at the "VmFlags:" field
611 (assuming that the version of the Linux kernel being used
612 supports it, of course). */
613 int private_p
= maybe_private_p
;
615 /* We always dump vDSO and vsyscall mappings, because it's likely that
616 there'll be no file to read the contents from at core load time.
617 The kernel does the same. */
618 if (strcmp ("[vdso]", filename
) == 0
619 || strcmp ("[vsyscall]", filename
) == 0)
622 if (v
->initialized_p
)
624 /* We never dump I/O mappings. */
628 /* Check if we should exclude this mapping. */
629 if (v
->exclude_coredump
)
632 /* Update our notion of whether this mapping is shared or
633 private based on a trustworthy value. */
634 private_p
= !v
->shared_mapping
;
636 /* HugeTLB checking. */
637 if (v
->uses_huge_tlb
)
639 if ((private_p
&& (filterflags
& COREFILTER_HUGETLB_PRIVATE
))
640 || (!private_p
&& (filterflags
& COREFILTER_HUGETLB_SHARED
)))
649 if (mapping_anon_p
&& mapping_file_p
)
651 /* This is a special situation. It can happen when we see a
652 mapping that is file-backed, but that contains anonymous
654 return ((filterflags
& COREFILTER_ANON_PRIVATE
) != 0
655 || (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0);
657 else if (mapping_anon_p
)
658 return (filterflags
& COREFILTER_ANON_PRIVATE
) != 0;
660 return (filterflags
& COREFILTER_MAPPED_PRIVATE
) != 0;
664 if (mapping_anon_p
&& mapping_file_p
)
666 /* This is a special situation. It can happen when we see a
667 mapping that is file-backed, but that contains anonymous
669 return ((filterflags
& COREFILTER_ANON_SHARED
) != 0
670 || (filterflags
& COREFILTER_MAPPED_SHARED
) != 0);
672 else if (mapping_anon_p
)
673 return (filterflags
& COREFILTER_ANON_SHARED
) != 0;
675 return (filterflags
& COREFILTER_MAPPED_SHARED
) != 0;
679 /* Implement the "info proc" command. */
682 linux_info_proc (struct gdbarch
*gdbarch
, const char *args
,
683 enum info_proc_what what
)
685 /* A long is used for pid instead of an int to avoid a loss of precision
686 compiler warning from the output of strtoul. */
688 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
689 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
690 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
691 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
692 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
693 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
698 if (args
&& isdigit (args
[0]))
702 pid
= strtoul (args
, &tem
, 10);
707 if (!target_has_execution
)
708 error (_("No current process: you must name one."));
709 if (current_inferior ()->fake_pid_p
)
710 error (_("Can't determine the current process's PID: you must name one."));
712 pid
= current_inferior ()->pid
;
715 args
= skip_spaces_const (args
);
717 error (_("Too many parameters: %s"), args
);
719 printf_filtered (_("process %ld\n"), pid
);
722 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
723 data
= target_fileio_read_stralloc (NULL
, filename
);
726 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
727 printf_filtered ("cmdline = '%s'\n", data
);
728 do_cleanups (cleanup
);
731 warning (_("unable to open /proc file '%s'"), filename
);
735 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
736 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
739 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
740 printf_filtered ("cwd = '%s'\n", data
);
741 do_cleanups (cleanup
);
744 warning (_("unable to read link '%s'"), filename
);
748 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
749 data
= target_fileio_readlink (NULL
, filename
, &target_errno
);
752 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
753 printf_filtered ("exe = '%s'\n", data
);
754 do_cleanups (cleanup
);
757 warning (_("unable to read link '%s'"), filename
);
761 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
762 data
= target_fileio_read_stralloc (NULL
, filename
);
765 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
768 printf_filtered (_("Mapped address spaces:\n\n"));
769 if (gdbarch_addr_bit (gdbarch
) == 32)
771 printf_filtered ("\t%10s %10s %10s %10s %s\n",
774 " Size", " Offset", "objfile");
778 printf_filtered (" %18s %18s %10s %10s %s\n",
781 " Size", " Offset", "objfile");
784 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
786 ULONGEST addr
, endaddr
, offset
, inode
;
787 const char *permissions
, *device
, *filename
;
788 size_t permissions_len
, device_len
;
790 read_mapping (line
, &addr
, &endaddr
,
791 &permissions
, &permissions_len
,
792 &offset
, &device
, &device_len
,
795 if (gdbarch_addr_bit (gdbarch
) == 32)
797 printf_filtered ("\t%10s %10s %10s %10s %s\n",
798 paddress (gdbarch
, addr
),
799 paddress (gdbarch
, endaddr
),
800 hex_string (endaddr
- addr
),
802 *filename
? filename
: "");
806 printf_filtered (" %18s %18s %10s %10s %s\n",
807 paddress (gdbarch
, addr
),
808 paddress (gdbarch
, endaddr
),
809 hex_string (endaddr
- addr
),
811 *filename
? filename
: "");
815 do_cleanups (cleanup
);
818 warning (_("unable to open /proc file '%s'"), filename
);
822 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
823 data
= target_fileio_read_stralloc (NULL
, filename
);
826 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
827 puts_filtered (data
);
828 do_cleanups (cleanup
);
831 warning (_("unable to open /proc file '%s'"), filename
);
835 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
836 data
= target_fileio_read_stralloc (NULL
, filename
);
839 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
840 const char *p
= data
;
842 printf_filtered (_("Process: %s\n"),
843 pulongest (strtoulst (p
, &p
, 10)));
845 p
= skip_spaces_const (p
);
848 /* ps command also relies on no trailing fields
850 const char *ep
= strrchr (p
, ')');
853 printf_filtered ("Exec file: %.*s\n",
854 (int) (ep
- p
- 1), p
+ 1);
859 p
= skip_spaces_const (p
);
861 printf_filtered (_("State: %c\n"), *p
++);
864 printf_filtered (_("Parent process: %s\n"),
865 pulongest (strtoulst (p
, &p
, 10)));
867 printf_filtered (_("Process group: %s\n"),
868 pulongest (strtoulst (p
, &p
, 10)));
870 printf_filtered (_("Session id: %s\n"),
871 pulongest (strtoulst (p
, &p
, 10)));
873 printf_filtered (_("TTY: %s\n"),
874 pulongest (strtoulst (p
, &p
, 10)));
876 printf_filtered (_("TTY owner process group: %s\n"),
877 pulongest (strtoulst (p
, &p
, 10)));
880 printf_filtered (_("Flags: %s\n"),
881 hex_string (strtoulst (p
, &p
, 10)));
883 printf_filtered (_("Minor faults (no memory page): %s\n"),
884 pulongest (strtoulst (p
, &p
, 10)));
886 printf_filtered (_("Minor faults, children: %s\n"),
887 pulongest (strtoulst (p
, &p
, 10)));
889 printf_filtered (_("Major faults (memory page faults): %s\n"),
890 pulongest (strtoulst (p
, &p
, 10)));
892 printf_filtered (_("Major faults, children: %s\n"),
893 pulongest (strtoulst (p
, &p
, 10)));
895 printf_filtered (_("utime: %s\n"),
896 pulongest (strtoulst (p
, &p
, 10)));
898 printf_filtered (_("stime: %s\n"),
899 pulongest (strtoulst (p
, &p
, 10)));
901 printf_filtered (_("utime, children: %s\n"),
902 pulongest (strtoulst (p
, &p
, 10)));
904 printf_filtered (_("stime, children: %s\n"),
905 pulongest (strtoulst (p
, &p
, 10)));
907 printf_filtered (_("jiffies remaining in current "
909 pulongest (strtoulst (p
, &p
, 10)));
911 printf_filtered (_("'nice' value: %s\n"),
912 pulongest (strtoulst (p
, &p
, 10)));
914 printf_filtered (_("jiffies until next timeout: %s\n"),
915 pulongest (strtoulst (p
, &p
, 10)));
917 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
918 pulongest (strtoulst (p
, &p
, 10)));
920 printf_filtered (_("start time (jiffies since "
921 "system boot): %s\n"),
922 pulongest (strtoulst (p
, &p
, 10)));
924 printf_filtered (_("Virtual memory size: %s\n"),
925 pulongest (strtoulst (p
, &p
, 10)));
927 printf_filtered (_("Resident set size: %s\n"),
928 pulongest (strtoulst (p
, &p
, 10)));
930 printf_filtered (_("rlim: %s\n"),
931 pulongest (strtoulst (p
, &p
, 10)));
933 printf_filtered (_("Start of text: %s\n"),
934 hex_string (strtoulst (p
, &p
, 10)));
936 printf_filtered (_("End of text: %s\n"),
937 hex_string (strtoulst (p
, &p
, 10)));
939 printf_filtered (_("Start of stack: %s\n"),
940 hex_string (strtoulst (p
, &p
, 10)));
941 #if 0 /* Don't know how architecture-dependent the rest is...
942 Anyway the signal bitmap info is available from "status". */
944 printf_filtered (_("Kernel stack pointer: %s\n"),
945 hex_string (strtoulst (p
, &p
, 10)));
947 printf_filtered (_("Kernel instr pointer: %s\n"),
948 hex_string (strtoulst (p
, &p
, 10)));
950 printf_filtered (_("Pending signals bitmap: %s\n"),
951 hex_string (strtoulst (p
, &p
, 10)));
953 printf_filtered (_("Blocked signals bitmap: %s\n"),
954 hex_string (strtoulst (p
, &p
, 10)));
956 printf_filtered (_("Ignored signals bitmap: %s\n"),
957 hex_string (strtoulst (p
, &p
, 10)));
959 printf_filtered (_("Catched signals bitmap: %s\n"),
960 hex_string (strtoulst (p
, &p
, 10)));
962 printf_filtered (_("wchan (system call): %s\n"),
963 hex_string (strtoulst (p
, &p
, 10)));
965 do_cleanups (cleanup
);
968 warning (_("unable to open /proc file '%s'"), filename
);
972 /* Implement "info proc mappings" for a corefile. */
975 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, const char *args
)
978 ULONGEST count
, page_size
;
979 unsigned char *descdata
, *filenames
, *descend
, *contents
;
981 unsigned int addr_size_bits
, addr_size
;
982 struct cleanup
*cleanup
;
983 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
984 /* We assume this for reading 64-bit core files. */
985 gdb_static_assert (sizeof (ULONGEST
) >= 8);
987 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
990 warning (_("unable to find mappings in core file"));
994 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
995 addr_size
= addr_size_bits
/ 8;
996 note_size
= bfd_get_section_size (section
);
998 if (note_size
< 2 * addr_size
)
999 error (_("malformed core note - too short for header"));
1001 contents
= (unsigned char *) xmalloc (note_size
);
1002 cleanup
= make_cleanup (xfree
, contents
);
1003 if (!bfd_get_section_contents (core_bfd
, section
, contents
, 0, note_size
))
1004 error (_("could not get core note contents"));
1006 descdata
= contents
;
1007 descend
= descdata
+ note_size
;
1009 if (descdata
[note_size
- 1] != '\0')
1010 error (_("malformed note - does not end with \\0"));
1012 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1013 descdata
+= addr_size
;
1015 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1016 descdata
+= addr_size
;
1018 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
1019 error (_("malformed note - too short for supplied file count"));
1021 printf_filtered (_("Mapped address spaces:\n\n"));
1022 if (gdbarch_addr_bit (gdbarch
) == 32)
1024 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1027 " Size", " Offset", "objfile");
1031 printf_filtered (" %18s %18s %10s %10s %s\n",
1034 " Size", " Offset", "objfile");
1037 filenames
= descdata
+ count
* 3 * addr_size
;
1040 ULONGEST start
, end
, file_ofs
;
1042 if (filenames
== descend
)
1043 error (_("malformed note - filenames end too early"));
1045 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1046 descdata
+= addr_size
;
1047 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1048 descdata
+= addr_size
;
1049 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
1050 descdata
+= addr_size
;
1052 file_ofs
*= page_size
;
1054 if (gdbarch_addr_bit (gdbarch
) == 32)
1055 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1056 paddress (gdbarch
, start
),
1057 paddress (gdbarch
, end
),
1058 hex_string (end
- start
),
1059 hex_string (file_ofs
),
1062 printf_filtered (" %18s %18s %10s %10s %s\n",
1063 paddress (gdbarch
, start
),
1064 paddress (gdbarch
, end
),
1065 hex_string (end
- start
),
1066 hex_string (file_ofs
),
1069 filenames
+= 1 + strlen ((char *) filenames
);
1072 do_cleanups (cleanup
);
1075 /* Implement "info proc" for a corefile. */
1078 linux_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1079 enum info_proc_what what
)
1081 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
1082 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
1088 exe
= bfd_core_file_failing_command (core_bfd
);
1090 printf_filtered ("exe = '%s'\n", exe
);
1092 warning (_("unable to find command name in core file"));
1096 linux_core_info_proc_mappings (gdbarch
, args
);
1098 if (!exe_f
&& !mappings_f
)
1099 error (_("unable to handle request"));
1102 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
1103 ULONGEST offset
, ULONGEST inode
,
1104 int read
, int write
,
1105 int exec
, int modified
,
1106 const char *filename
,
1109 /* List memory regions in the inferior for a corefile. */
1112 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
1113 linux_find_memory_region_ftype
*func
,
1116 char mapsfilename
[100];
1117 char coredumpfilter_name
[100];
1118 char *data
, *coredumpfilterdata
;
1120 /* Default dump behavior of coredump_filter (0x33), according to
1121 Documentation/filesystems/proc.txt from the Linux kernel
1123 enum filterflags filterflags
= (COREFILTER_ANON_PRIVATE
1124 | COREFILTER_ANON_SHARED
1125 | COREFILTER_ELF_HEADERS
1126 | COREFILTER_HUGETLB_PRIVATE
);
1128 /* We need to know the real target PID to access /proc. */
1129 if (current_inferior ()->fake_pid_p
)
1132 pid
= current_inferior ()->pid
;
1134 if (use_coredump_filter
)
1136 xsnprintf (coredumpfilter_name
, sizeof (coredumpfilter_name
),
1137 "/proc/%d/coredump_filter", pid
);
1138 coredumpfilterdata
= target_fileio_read_stralloc (NULL
,
1139 coredumpfilter_name
);
1140 if (coredumpfilterdata
!= NULL
)
1142 sscanf (coredumpfilterdata
, "%x", &filterflags
);
1143 xfree (coredumpfilterdata
);
1147 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/smaps", pid
);
1148 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1151 /* Older Linux kernels did not support /proc/PID/smaps. */
1152 xsnprintf (mapsfilename
, sizeof mapsfilename
, "/proc/%d/maps", pid
);
1153 data
= target_fileio_read_stralloc (NULL
, mapsfilename
);
1158 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
1161 line
= strtok_r (data
, "\n", &t
);
1162 while (line
!= NULL
)
1164 ULONGEST addr
, endaddr
, offset
, inode
;
1165 const char *permissions
, *device
, *filename
;
1166 struct smaps_vmflags v
;
1167 size_t permissions_len
, device_len
;
1168 int read
, write
, exec
, priv
;
1169 int has_anonymous
= 0;
1170 int should_dump_p
= 0;
1174 memset (&v
, 0, sizeof (v
));
1175 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
1176 &offset
, &device
, &device_len
, &inode
, &filename
);
1177 mapping_anon_p
= mapping_is_anonymous_p (filename
);
1178 /* If the mapping is not anonymous, then we can consider it
1179 to be file-backed. These two states (anonymous or
1180 file-backed) seem to be exclusive, but they can actually
1181 coexist. For example, if a file-backed mapping has
1182 "Anonymous:" pages (see more below), then the Linux
1183 kernel will dump this mapping when the user specified
1184 that she only wants anonymous mappings in the corefile
1185 (*even* when she explicitly disabled the dumping of
1186 file-backed mappings). */
1187 mapping_file_p
= !mapping_anon_p
;
1189 /* Decode permissions. */
1190 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
1191 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
1192 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
1193 /* 'private' here actually means VM_MAYSHARE, and not
1194 VM_SHARED. In order to know if a mapping is really
1195 private or not, we must check the flag "sh" in the
1196 VmFlags field. This is done by decode_vmflags. However,
1197 if we are using a Linux kernel released before the commit
1198 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1199 not have the VmFlags there. In this case, there is
1200 really no way to know if we are dealing with VM_SHARED,
1201 so we just assume that VM_MAYSHARE is enough. */
1202 priv
= memchr (permissions
, 'p', permissions_len
) != 0;
1204 /* Try to detect if region should be dumped by parsing smaps
1206 for (line
= strtok_r (NULL
, "\n", &t
);
1207 line
!= NULL
&& line
[0] >= 'A' && line
[0] <= 'Z';
1208 line
= strtok_r (NULL
, "\n", &t
))
1210 char keyword
[64 + 1];
1212 if (sscanf (line
, "%64s", keyword
) != 1)
1214 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
1218 if (strcmp (keyword
, "Anonymous:") == 0)
1220 /* Older Linux kernels did not support the
1221 "Anonymous:" counter. Check it here. */
1224 else if (strcmp (keyword
, "VmFlags:") == 0)
1225 decode_vmflags (line
, &v
);
1227 if (strcmp (keyword
, "AnonHugePages:") == 0
1228 || strcmp (keyword
, "Anonymous:") == 0)
1230 unsigned long number
;
1232 if (sscanf (line
, "%*s%lu", &number
) != 1)
1234 warning (_("Error parsing {s,}maps file '%s' number"),
1240 /* Even if we are dealing with a file-backed
1241 mapping, if it contains anonymous pages we
1242 consider it to be *also* an anonymous
1243 mapping, because this is what the Linux
1246 // Dump segments that have been written to.
1247 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1250 Note that if the mapping is already marked as
1251 file-backed (i.e., mapping_file_p is
1252 non-zero), then this is a special case, and
1253 this mapping will be dumped either when the
1254 user wants to dump file-backed *or* anonymous
1262 should_dump_p
= dump_mapping_p (filterflags
, &v
, priv
,
1263 mapping_anon_p
, mapping_file_p
,
1267 /* Older Linux kernels did not support the "Anonymous:" counter.
1268 If it is missing, we can't be sure - dump all the pages. */
1272 /* Invoke the callback function to create the corefile segment. */
1274 func (addr
, endaddr
- addr
, offset
, inode
,
1275 read
, write
, exec
, 1, /* MODIFIED is true because we
1276 want to dump the mapping. */
1280 do_cleanups (cleanup
);
1287 /* A structure for passing information through
1288 linux_find_memory_regions_full. */
1290 struct linux_find_memory_regions_data
1292 /* The original callback. */
1294 find_memory_region_ftype func
;
1296 /* The original datum. */
1301 /* A callback for linux_find_memory_regions that converts between the
1302 "full"-style callback and find_memory_region_ftype. */
1305 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
1306 ULONGEST offset
, ULONGEST inode
,
1307 int read
, int write
, int exec
, int modified
,
1308 const char *filename
, void *arg
)
1310 struct linux_find_memory_regions_data
*data
1311 = (struct linux_find_memory_regions_data
*) arg
;
1313 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
1316 /* A variant of linux_find_memory_regions_full that is suitable as the
1317 gdbarch find_memory_regions method. */
1320 linux_find_memory_regions (struct gdbarch
*gdbarch
,
1321 find_memory_region_ftype func
, void *obfd
)
1323 struct linux_find_memory_regions_data data
;
1328 return linux_find_memory_regions_full (gdbarch
,
1329 linux_find_memory_regions_thunk
,
1333 /* Determine which signal stopped execution. */
1336 find_signalled_thread (struct thread_info
*info
, void *data
)
1338 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
1339 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
1345 static enum gdb_signal
1346 find_stop_signal (void)
1348 struct thread_info
*info
=
1349 iterate_over_threads (find_signalled_thread
, NULL
);
1352 return info
->suspend
.stop_signal
;
1354 return GDB_SIGNAL_0
;
1357 /* Generate corefile notes for SPU contexts. */
1360 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
1362 static const char *spu_files
[] =
1384 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
1388 /* Determine list of SPU ids. */
1389 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1392 /* Generate corefile notes for each SPU file. */
1393 for (i
= 0; i
< size
; i
+= 4)
1395 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
1397 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
1399 char annex
[32], note_name
[32];
1403 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
1404 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
1408 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
1409 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1429 /* This is used to pass information from
1430 linux_make_mappings_corefile_notes through
1431 linux_find_memory_regions_full. */
1433 struct linux_make_mappings_data
1435 /* Number of files mapped. */
1436 ULONGEST file_count
;
1438 /* The obstack for the main part of the data. */
1439 struct obstack
*data_obstack
;
1441 /* The filename obstack. */
1442 struct obstack
*filename_obstack
;
1444 /* The architecture's "long" type. */
1445 struct type
*long_type
;
1448 static linux_find_memory_region_ftype linux_make_mappings_callback
;
1450 /* A callback for linux_find_memory_regions_full that updates the
1451 mappings data for linux_make_mappings_corefile_notes. */
1454 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1455 ULONGEST offset
, ULONGEST inode
,
1456 int read
, int write
, int exec
, int modified
,
1457 const char *filename
, void *data
)
1459 struct linux_make_mappings_data
*map_data
1460 = (struct linux_make_mappings_data
*) data
;
1461 gdb_byte buf
[sizeof (ULONGEST
)];
1463 if (*filename
== '\0' || inode
== 0)
1466 ++map_data
->file_count
;
1468 pack_long (buf
, map_data
->long_type
, vaddr
);
1469 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1470 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1471 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1472 pack_long (buf
, map_data
->long_type
, offset
);
1473 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1475 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1480 /* Write the file mapping data to the core file, if possible. OBFD is
1481 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1482 is a pointer to the note size. Returns the new NOTE_DATA and
1483 updates NOTE_SIZE. */
1486 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1487 char *note_data
, int *note_size
)
1489 struct cleanup
*cleanup
;
1490 struct obstack data_obstack
, filename_obstack
;
1491 struct linux_make_mappings_data mapping_data
;
1492 struct type
*long_type
1493 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1494 gdb_byte buf
[sizeof (ULONGEST
)];
1496 obstack_init (&data_obstack
);
1497 cleanup
= make_cleanup_obstack_free (&data_obstack
);
1498 obstack_init (&filename_obstack
);
1499 make_cleanup_obstack_free (&filename_obstack
);
1501 mapping_data
.file_count
= 0;
1502 mapping_data
.data_obstack
= &data_obstack
;
1503 mapping_data
.filename_obstack
= &filename_obstack
;
1504 mapping_data
.long_type
= long_type
;
1506 /* Reserve space for the count. */
1507 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1508 /* We always write the page size as 1 since we have no good way to
1509 determine the correct value. */
1510 pack_long (buf
, long_type
, 1);
1511 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1513 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1516 if (mapping_data
.file_count
!= 0)
1518 /* Write the count to the obstack. */
1519 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1520 long_type
, mapping_data
.file_count
);
1522 /* Copy the filenames to the data obstack. */
1523 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1524 obstack_object_size (&filename_obstack
));
1526 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1528 obstack_base (&data_obstack
),
1529 obstack_object_size (&data_obstack
));
1532 do_cleanups (cleanup
);
1536 /* Structure for passing information from
1537 linux_collect_thread_registers via an iterator to
1538 linux_collect_regset_section_cb. */
1540 struct linux_collect_regset_section_cb_data
1542 struct gdbarch
*gdbarch
;
1543 const struct regcache
*regcache
;
1548 enum gdb_signal stop_signal
;
1549 int abort_iteration
;
1552 /* Callback for iterate_over_regset_sections that records a single
1553 regset in the corefile note section. */
1556 linux_collect_regset_section_cb (const char *sect_name
, int size
,
1557 const struct regset
*regset
,
1558 const char *human_name
, void *cb_data
)
1561 struct linux_collect_regset_section_cb_data
*data
1562 = (struct linux_collect_regset_section_cb_data
*) cb_data
;
1564 if (data
->abort_iteration
)
1567 gdb_assert (regset
&& regset
->collect_regset
);
1569 buf
= (char *) xmalloc (size
);
1570 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, size
);
1572 /* PRSTATUS still needs to be treated specially. */
1573 if (strcmp (sect_name
, ".reg") == 0)
1574 data
->note_data
= (char *) elfcore_write_prstatus
1575 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
1576 gdb_signal_to_host (data
->stop_signal
), buf
);
1578 data
->note_data
= (char *) elfcore_write_register_note
1579 (data
->obfd
, data
->note_data
, data
->note_size
,
1580 sect_name
, buf
, size
);
1583 if (data
->note_data
== NULL
)
1584 data
->abort_iteration
= 1;
1587 /* Records the thread's register state for the corefile note
1591 linux_collect_thread_registers (const struct regcache
*regcache
,
1592 ptid_t ptid
, bfd
*obfd
,
1593 char *note_data
, int *note_size
,
1594 enum gdb_signal stop_signal
)
1596 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1597 struct linux_collect_regset_section_cb_data data
;
1599 data
.gdbarch
= gdbarch
;
1600 data
.regcache
= regcache
;
1602 data
.note_data
= note_data
;
1603 data
.note_size
= note_size
;
1604 data
.stop_signal
= stop_signal
;
1605 data
.abort_iteration
= 0;
1607 /* For remote targets the LWP may not be available, so use the TID. */
1608 data
.lwp
= ptid_get_lwp (ptid
);
1610 data
.lwp
= ptid_get_tid (ptid
);
1612 gdbarch_iterate_over_regset_sections (gdbarch
,
1613 linux_collect_regset_section_cb
,
1615 return data
.note_data
;
1618 /* Fetch the siginfo data for the current thread, if it exists. If
1619 there is no data, or we could not read it, return NULL. Otherwise,
1620 return a newly malloc'd buffer holding the data and fill in *SIZE
1621 with the size of the data. The caller is responsible for freeing
1625 linux_get_siginfo_data (struct gdbarch
*gdbarch
, LONGEST
*size
)
1627 struct type
*siginfo_type
;
1630 struct cleanup
*cleanups
;
1632 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1635 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1637 buf
= (gdb_byte
*) xmalloc (TYPE_LENGTH (siginfo_type
));
1638 cleanups
= make_cleanup (xfree
, buf
);
1640 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1641 buf
, 0, TYPE_LENGTH (siginfo_type
));
1642 if (bytes_read
== TYPE_LENGTH (siginfo_type
))
1644 discard_cleanups (cleanups
);
1649 do_cleanups (cleanups
);
1656 struct linux_corefile_thread_data
1658 struct gdbarch
*gdbarch
;
1663 enum gdb_signal stop_signal
;
1666 /* Called by gdbthread.c once per thread. Records the thread's
1667 register state for the corefile note section. */
1670 linux_corefile_thread_callback (struct thread_info
*info
, void *data
)
1672 struct linux_corefile_thread_data
*args
1673 = (struct linux_corefile_thread_data
*) data
;
1675 /* It can be current thread
1676 which cannot be removed by update_thread_list. */
1677 if (info
->state
== THREAD_EXITED
)
1680 if (ptid_get_pid (info
->ptid
) == args
->pid
)
1682 struct cleanup
*old_chain
;
1683 struct regcache
*regcache
;
1684 gdb_byte
*siginfo_data
;
1685 LONGEST siginfo_size
= 0;
1687 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1689 old_chain
= save_inferior_ptid ();
1690 inferior_ptid
= info
->ptid
;
1691 target_fetch_registers (regcache
, -1);
1692 siginfo_data
= linux_get_siginfo_data (args
->gdbarch
, &siginfo_size
);
1693 do_cleanups (old_chain
);
1695 old_chain
= make_cleanup (xfree
, siginfo_data
);
1697 args
->note_data
= linux_collect_thread_registers
1698 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
1699 args
->note_size
, args
->stop_signal
);
1701 /* Don't return anything if we got no register information above,
1702 such a core file is useless. */
1703 if (args
->note_data
!= NULL
)
1704 if (siginfo_data
!= NULL
)
1705 args
->note_data
= elfcore_write_note (args
->obfd
,
1709 siginfo_data
, siginfo_size
);
1711 do_cleanups (old_chain
);
1714 return !args
->note_data
;
1717 /* Fill the PRPSINFO structure with information about the process being
1718 debugged. Returns 1 in case of success, 0 for failures. Please note that
1719 even if the structure cannot be entirely filled (e.g., GDB was unable to
1720 gather information about the process UID/GID), this function will still
1721 return 1 since some information was already recorded. It will only return
1722 0 iff nothing can be gathered. */
1725 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1727 /* The filename which we will use to obtain some info about the process.
1728 We will basically use this to store the `/proc/PID/FILENAME' file. */
1730 /* The full name of the program which generated the corefile. */
1732 /* The basename of the executable. */
1733 const char *basename
;
1734 /* The arguments of the program. */
1737 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1738 char *proc_stat
, *proc_status
;
1739 /* Temporary buffer. */
1741 /* The valid states of a process, according to the Linux kernel. */
1742 const char valid_states
[] = "RSDTZW";
1743 /* The program state. */
1744 const char *prog_state
;
1745 /* The state of the process. */
1747 /* The PID of the program which generated the corefile. */
1749 /* Process flags. */
1750 unsigned int pr_flag
;
1751 /* Process nice value. */
1753 /* The number of fields read by `sscanf'. */
1759 gdb_assert (p
!= NULL
);
1761 /* Obtaining PID and filename. */
1762 pid
= ptid_get_pid (inferior_ptid
);
1763 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1764 fname
= target_fileio_read_stralloc (NULL
, filename
);
1766 if (fname
== NULL
|| *fname
== '\0')
1768 /* No program name was read, so we won't be able to retrieve more
1769 information about the process. */
1774 c
= make_cleanup (xfree
, fname
);
1775 memset (p
, 0, sizeof (*p
));
1777 /* Defining the PID. */
1780 /* Copying the program name. Only the basename matters. */
1781 basename
= lbasename (fname
);
1782 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1783 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1785 infargs
= get_inferior_args ();
1787 psargs
= xstrdup (fname
);
1788 if (infargs
!= NULL
)
1789 psargs
= reconcat (psargs
, psargs
, " ", infargs
, NULL
);
1791 make_cleanup (xfree
, psargs
);
1793 strncpy (p
->pr_psargs
, psargs
, sizeof (p
->pr_psargs
));
1794 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1796 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1797 proc_stat
= target_fileio_read_stralloc (NULL
, filename
);
1798 make_cleanup (xfree
, proc_stat
);
1800 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1802 /* Despite being unable to read more information about the
1803 process, we return 1 here because at least we have its
1804 command line, PID and arguments. */
1809 /* Ok, we have the stats. It's time to do a little parsing of the
1810 contents of the buffer, so that we end up reading what we want.
1812 The following parsing mechanism is strongly based on the
1813 information generated by the `fs/proc/array.c' file, present in
1814 the Linux kernel tree. More details about how the information is
1815 displayed can be obtained by seeing the manpage of proc(5),
1816 specifically under the entry of `/proc/[pid]/stat'. */
1818 /* Getting rid of the PID, since we already have it. */
1819 while (isdigit (*proc_stat
))
1822 proc_stat
= skip_spaces (proc_stat
);
1824 /* ps command also relies on no trailing fields ever contain ')'. */
1825 proc_stat
= strrchr (proc_stat
, ')');
1826 if (proc_stat
== NULL
)
1833 proc_stat
= skip_spaces (proc_stat
);
1835 n_fields
= sscanf (proc_stat
,
1836 "%c" /* Process state. */
1837 "%d%d%d" /* Parent PID, group ID, session ID. */
1838 "%*d%*d" /* tty_nr, tpgid (not used). */
1840 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1841 cmajflt (not used). */
1842 "%*s%*s%*s%*s" /* utime, stime, cutime,
1843 cstime (not used). */
1844 "%*s" /* Priority (not used). */
1847 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1853 /* Again, we couldn't read the complementary information about
1854 the process state. However, we already have minimal
1855 information, so we just return 1 here. */
1860 /* Filling the structure fields. */
1861 prog_state
= strchr (valid_states
, pr_sname
);
1862 if (prog_state
!= NULL
)
1863 p
->pr_state
= prog_state
- valid_states
;
1866 /* Zero means "Running". */
1870 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1871 p
->pr_zomb
= p
->pr_sname
== 'Z';
1872 p
->pr_nice
= pr_nice
;
1873 p
->pr_flag
= pr_flag
;
1875 /* Finally, obtaining the UID and GID. For that, we read and parse the
1876 contents of the `/proc/PID/status' file. */
1877 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1878 proc_status
= target_fileio_read_stralloc (NULL
, filename
);
1879 make_cleanup (xfree
, proc_status
);
1881 if (proc_status
== NULL
|| *proc_status
== '\0')
1883 /* Returning 1 since we already have a bunch of information. */
1888 /* Extracting the UID. */
1889 tmpstr
= strstr (proc_status
, "Uid:");
1892 /* Advancing the pointer to the beginning of the UID. */
1893 tmpstr
+= sizeof ("Uid:");
1894 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1897 if (isdigit (*tmpstr
))
1898 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1901 /* Extracting the GID. */
1902 tmpstr
= strstr (proc_status
, "Gid:");
1905 /* Advancing the pointer to the beginning of the GID. */
1906 tmpstr
+= sizeof ("Gid:");
1907 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1910 if (isdigit (*tmpstr
))
1911 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1919 /* Build the note section for a corefile, and return it in a malloc
1923 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1925 struct linux_corefile_thread_data thread_args
;
1926 struct elf_internal_linux_prpsinfo prpsinfo
;
1927 char *note_data
= NULL
;
1931 if (! gdbarch_iterate_over_regset_sections_p (gdbarch
))
1934 if (linux_fill_prpsinfo (&prpsinfo
))
1936 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch
))
1938 note_data
= gdbarch_elfcore_write_linux_prpsinfo (gdbarch
, obfd
,
1939 note_data
, note_size
,
1944 if (gdbarch_ptr_bit (gdbarch
) == 64)
1945 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1946 note_data
, note_size
,
1949 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1950 note_data
, note_size
,
1955 /* Thread register information. */
1958 update_thread_list ();
1960 CATCH (e
, RETURN_MASK_ERROR
)
1962 exception_print (gdb_stderr
, e
);
1966 thread_args
.gdbarch
= gdbarch
;
1967 thread_args
.pid
= ptid_get_pid (inferior_ptid
);
1968 thread_args
.obfd
= obfd
;
1969 thread_args
.note_data
= note_data
;
1970 thread_args
.note_size
= note_size
;
1971 thread_args
.stop_signal
= find_stop_signal ();
1972 iterate_over_threads (linux_corefile_thread_callback
, &thread_args
);
1973 note_data
= thread_args
.note_data
;
1977 /* Auxillary vector. */
1978 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
1982 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1983 "CORE", NT_AUXV
, auxv
, auxv_len
);
1990 /* SPU information. */
1991 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
1995 /* File mappings. */
1996 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1997 note_data
, note_size
);
2002 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2003 gdbarch.h. This function is not static because it is exported to
2004 other -tdep files. */
2007 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
2012 return GDB_SIGNAL_0
;
2015 return GDB_SIGNAL_HUP
;
2018 return GDB_SIGNAL_INT
;
2021 return GDB_SIGNAL_QUIT
;
2024 return GDB_SIGNAL_ILL
;
2027 return GDB_SIGNAL_TRAP
;
2030 return GDB_SIGNAL_ABRT
;
2033 return GDB_SIGNAL_BUS
;
2036 return GDB_SIGNAL_FPE
;
2039 return GDB_SIGNAL_KILL
;
2042 return GDB_SIGNAL_USR1
;
2045 return GDB_SIGNAL_SEGV
;
2048 return GDB_SIGNAL_USR2
;
2051 return GDB_SIGNAL_PIPE
;
2054 return GDB_SIGNAL_ALRM
;
2057 return GDB_SIGNAL_TERM
;
2060 return GDB_SIGNAL_CHLD
;
2063 return GDB_SIGNAL_CONT
;
2066 return GDB_SIGNAL_STOP
;
2069 return GDB_SIGNAL_TSTP
;
2072 return GDB_SIGNAL_TTIN
;
2075 return GDB_SIGNAL_TTOU
;
2078 return GDB_SIGNAL_URG
;
2081 return GDB_SIGNAL_XCPU
;
2084 return GDB_SIGNAL_XFSZ
;
2086 case LINUX_SIGVTALRM
:
2087 return GDB_SIGNAL_VTALRM
;
2090 return GDB_SIGNAL_PROF
;
2092 case LINUX_SIGWINCH
:
2093 return GDB_SIGNAL_WINCH
;
2095 /* No way to differentiate between SIGIO and SIGPOLL.
2096 Therefore, we just handle the first one. */
2098 return GDB_SIGNAL_IO
;
2101 return GDB_SIGNAL_PWR
;
2104 return GDB_SIGNAL_SYS
;
2106 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2107 therefore we have to handle them here. */
2108 case LINUX_SIGRTMIN
:
2109 return GDB_SIGNAL_REALTIME_32
;
2111 case LINUX_SIGRTMAX
:
2112 return GDB_SIGNAL_REALTIME_64
;
2115 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
2117 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
2119 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
2122 return GDB_SIGNAL_UNKNOWN
;
2125 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2126 gdbarch.h. This function is not static because it is exported to
2127 other -tdep files. */
2130 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
2131 enum gdb_signal signal
)
2138 case GDB_SIGNAL_HUP
:
2139 return LINUX_SIGHUP
;
2141 case GDB_SIGNAL_INT
:
2142 return LINUX_SIGINT
;
2144 case GDB_SIGNAL_QUIT
:
2145 return LINUX_SIGQUIT
;
2147 case GDB_SIGNAL_ILL
:
2148 return LINUX_SIGILL
;
2150 case GDB_SIGNAL_TRAP
:
2151 return LINUX_SIGTRAP
;
2153 case GDB_SIGNAL_ABRT
:
2154 return LINUX_SIGABRT
;
2156 case GDB_SIGNAL_FPE
:
2157 return LINUX_SIGFPE
;
2159 case GDB_SIGNAL_KILL
:
2160 return LINUX_SIGKILL
;
2162 case GDB_SIGNAL_BUS
:
2163 return LINUX_SIGBUS
;
2165 case GDB_SIGNAL_SEGV
:
2166 return LINUX_SIGSEGV
;
2168 case GDB_SIGNAL_SYS
:
2169 return LINUX_SIGSYS
;
2171 case GDB_SIGNAL_PIPE
:
2172 return LINUX_SIGPIPE
;
2174 case GDB_SIGNAL_ALRM
:
2175 return LINUX_SIGALRM
;
2177 case GDB_SIGNAL_TERM
:
2178 return LINUX_SIGTERM
;
2180 case GDB_SIGNAL_URG
:
2181 return LINUX_SIGURG
;
2183 case GDB_SIGNAL_STOP
:
2184 return LINUX_SIGSTOP
;
2186 case GDB_SIGNAL_TSTP
:
2187 return LINUX_SIGTSTP
;
2189 case GDB_SIGNAL_CONT
:
2190 return LINUX_SIGCONT
;
2192 case GDB_SIGNAL_CHLD
:
2193 return LINUX_SIGCHLD
;
2195 case GDB_SIGNAL_TTIN
:
2196 return LINUX_SIGTTIN
;
2198 case GDB_SIGNAL_TTOU
:
2199 return LINUX_SIGTTOU
;
2204 case GDB_SIGNAL_XCPU
:
2205 return LINUX_SIGXCPU
;
2207 case GDB_SIGNAL_XFSZ
:
2208 return LINUX_SIGXFSZ
;
2210 case GDB_SIGNAL_VTALRM
:
2211 return LINUX_SIGVTALRM
;
2213 case GDB_SIGNAL_PROF
:
2214 return LINUX_SIGPROF
;
2216 case GDB_SIGNAL_WINCH
:
2217 return LINUX_SIGWINCH
;
2219 case GDB_SIGNAL_USR1
:
2220 return LINUX_SIGUSR1
;
2222 case GDB_SIGNAL_USR2
:
2223 return LINUX_SIGUSR2
;
2225 case GDB_SIGNAL_PWR
:
2226 return LINUX_SIGPWR
;
2228 case GDB_SIGNAL_POLL
:
2229 return LINUX_SIGPOLL
;
2231 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2232 therefore we have to handle it here. */
2233 case GDB_SIGNAL_REALTIME_32
:
2234 return LINUX_SIGRTMIN
;
2236 /* Same comment applies to _64. */
2237 case GDB_SIGNAL_REALTIME_64
:
2238 return LINUX_SIGRTMAX
;
2241 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2242 if (signal
>= GDB_SIGNAL_REALTIME_33
2243 && signal
<= GDB_SIGNAL_REALTIME_63
)
2245 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
2247 return LINUX_SIGRTMIN
+ 1 + offset
;
2253 /* Rummage through mappings to find a mapping's size. */
2256 find_mapping_size (CORE_ADDR vaddr
, unsigned long size
,
2257 int read
, int write
, int exec
, int modified
,
2260 struct mem_range
*range
= (struct mem_range
*) data
;
2262 if (vaddr
== range
->start
)
2264 range
->length
= size
;
2270 /* Helper for linux_vsyscall_range that does the real work of finding
2271 the vsyscall's address range. */
2274 linux_vsyscall_range_raw (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2276 if (target_auxv_search (¤t_target
, AT_SYSINFO_EHDR
, &range
->start
) <= 0)
2279 /* This is installed by linux_init_abi below, so should always be
2281 gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
2284 gdbarch_find_memory_regions (gdbarch
, find_mapping_size
, range
);
2288 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2289 caching, and defers the real work to linux_vsyscall_range_raw. */
2292 linux_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2294 struct linux_info
*info
= get_linux_inferior_data ();
2296 if (info
->vsyscall_range_p
== 0)
2298 if (linux_vsyscall_range_raw (gdbarch
, &info
->vsyscall_range
))
2299 info
->vsyscall_range_p
= 1;
2301 info
->vsyscall_range_p
= -1;
2304 if (info
->vsyscall_range_p
< 0)
2307 *range
= info
->vsyscall_range
;
2311 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2312 definitions would be dependent on compilation host. */
2313 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2314 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2316 /* See gdbarch.sh 'infcall_mmap'. */
2319 linux_infcall_mmap (CORE_ADDR size
, unsigned prot
)
2321 struct objfile
*objf
;
2322 /* Do there still exist any Linux systems without "mmap64"?
2323 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2324 struct value
*mmap_val
= find_function_in_inferior ("mmap64", &objf
);
2325 struct value
*addr_val
;
2326 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2330 ARG_ADDR
, ARG_LENGTH
, ARG_PROT
, ARG_FLAGS
, ARG_FD
, ARG_OFFSET
, ARG_LAST
2332 struct value
*arg
[ARG_LAST
];
2334 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2336 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2337 arg
[ARG_LENGTH
] = value_from_ulongest
2338 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2339 gdb_assert ((prot
& ~(GDB_MMAP_PROT_READ
| GDB_MMAP_PROT_WRITE
2340 | GDB_MMAP_PROT_EXEC
))
2342 arg
[ARG_PROT
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, prot
);
2343 arg
[ARG_FLAGS
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2344 GDB_MMAP_MAP_PRIVATE
2345 | GDB_MMAP_MAP_ANONYMOUS
);
2346 arg
[ARG_FD
] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, -1);
2347 arg
[ARG_OFFSET
] = value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2349 addr_val
= call_function_by_hand (mmap_val
, ARG_LAST
, arg
);
2350 retval
= value_as_address (addr_val
);
2351 if (retval
== (CORE_ADDR
) -1)
2352 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2357 /* See gdbarch.sh 'infcall_munmap'. */
2360 linux_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
2362 struct objfile
*objf
;
2363 struct value
*munmap_val
= find_function_in_inferior ("munmap", &objf
);
2364 struct value
*retval_val
;
2365 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
2369 ARG_ADDR
, ARG_LENGTH
, ARG_LAST
2371 struct value
*arg
[ARG_LAST
];
2373 arg
[ARG_ADDR
] = value_from_pointer (builtin_type (gdbarch
)->builtin_data_ptr
,
2375 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2376 arg
[ARG_LENGTH
] = value_from_ulongest
2377 (builtin_type (gdbarch
)->builtin_unsigned_long
, size
);
2378 retval_val
= call_function_by_hand (munmap_val
, ARG_LAST
, arg
);
2379 retval
= value_as_long (retval_val
);
2381 warning (_("Failed inferior munmap call at %s for %s bytes, "
2382 "errno is changed."),
2383 hex_string (addr
), pulongest (size
));
2386 /* See linux-tdep.h. */
2389 linux_displaced_step_location (struct gdbarch
*gdbarch
)
2394 /* Determine entry point from target auxiliary vector. This avoids
2395 the need for symbols. Also, when debugging a stand-alone SPU
2396 executable, entry_point_address () will point to an SPU
2397 local-store address and is thus not usable as displaced stepping
2398 location. The auxiliary vector gets us the PowerPC-side entry
2399 point address instead. */
2400 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
2401 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2403 /* Make certain that the address points at real code, and not a
2404 function descriptor. */
2405 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2408 /* Inferior calls also use the entry point as a breakpoint location.
2409 We don't want displaced stepping to interfere with those
2410 breakpoints, so leave space. */
2411 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
2417 /* Display whether the gcore command is using the
2418 /proc/PID/coredump_filter file. */
2421 show_use_coredump_filter (struct ui_file
*file
, int from_tty
,
2422 struct cmd_list_element
*c
, const char *value
)
2424 fprintf_filtered (file
, _("Use of /proc/PID/coredump_filter file to generate"
2425 " corefiles is %s.\n"), value
);
2428 /* To be called from the various GDB_OSABI_LINUX handlers for the
2429 various GNU/Linux architectures and machine types. */
2432 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2434 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
2435 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
2436 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
2437 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
2438 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes
);
2439 set_gdbarch_has_shared_address_space (gdbarch
,
2440 linux_has_shared_address_space
);
2441 set_gdbarch_gdb_signal_from_target (gdbarch
,
2442 linux_gdb_signal_from_target
);
2443 set_gdbarch_gdb_signal_to_target (gdbarch
,
2444 linux_gdb_signal_to_target
);
2445 set_gdbarch_vsyscall_range (gdbarch
, linux_vsyscall_range
);
2446 set_gdbarch_infcall_mmap (gdbarch
, linux_infcall_mmap
);
2447 set_gdbarch_infcall_munmap (gdbarch
, linux_infcall_munmap
);
2448 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
2451 /* Provide a prototype to silence -Wmissing-prototypes. */
2452 extern initialize_file_ftype _initialize_linux_tdep
;
2455 _initialize_linux_tdep (void)
2457 linux_gdbarch_data_handle
=
2458 gdbarch_data_register_post_init (init_linux_gdbarch_data
);
2460 /* Set a cache per-inferior. */
2462 = register_inferior_data_with_cleanup (NULL
, linux_inferior_data_cleanup
);
2463 /* Observers used to invalidate the cache when needed. */
2464 observer_attach_inferior_exit (invalidate_linux_cache_inf
);
2465 observer_attach_inferior_appeared (invalidate_linux_cache_inf
);
2467 add_setshow_boolean_cmd ("use-coredump-filter", class_files
,
2468 &use_coredump_filter
, _("\
2469 Set whether gcore should consider /proc/PID/coredump_filter."),
2471 Show whether gcore should consider /proc/PID/coredump_filter."),
2473 Use this command to set whether gcore should consider the contents\n\
2474 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2475 about this file, refer to the manpage of core(5)."),
2476 NULL
, show_use_coredump_filter
,
2477 &setlist
, &showlist
);