1 /* Target-dependent code for FreeBSD, architecture-independent.
3 Copyright (C) 2002-2021 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/>. */
27 #include "gdbthread.h"
29 #include "xml-syscall.h"
30 #include <sys/socket.h>
31 #include <arpa/inet.h>
34 #include "fbsd-tdep.h"
35 #include "gcore-elf.h"
37 /* This enum is derived from FreeBSD's <sys/signal.h>. */
66 FREEBSD_SIGVTALRM
= 26,
68 FREEBSD_SIGWINCH
= 28,
73 FREEBSD_SIGLIBRT
= 33,
74 FREEBSD_SIGRTMIN
= 65,
75 FREEBSD_SIGRTMAX
= 126,
78 /* FreeBSD kernels 12.0 and later include a copy of the
79 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
80 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
81 The constants below define the offset of field members and flags in
82 this structure used by methods in this file. Note that the
83 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
84 containing the size of the structure. */
86 #define LWPINFO_OFFSET 0x4
88 /* Offsets in ptrace_lwpinfo. */
89 #define LWPINFO_PL_FLAGS 0x8
90 #define LWPINFO64_PL_SIGINFO 0x30
91 #define LWPINFO32_PL_SIGINFO 0x2c
93 /* Flags in pl_flags. */
94 #define PL_FLAG_SI 0x20 /* siginfo is valid */
96 /* Sizes of siginfo_t. */
97 #define SIZE64_SIGINFO_T 80
98 #define SIZE32_SIGINFO_T 64
100 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
101 dump notes. See <sys/user.h> for the definition of struct
102 kinfo_vmentry. This data structure should have the same layout on
105 Note that FreeBSD 7.0 used an older version of this structure
106 (struct kinfo_vmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core
107 dump note wasn't introduced until FreeBSD 9.2. As a result, the
108 core dump note has always used the 7.1 and later structure
111 #define KVE_STRUCTSIZE 0x0
112 #define KVE_START 0x8
114 #define KVE_OFFSET 0x18
115 #define KVE_FLAGS 0x2c
116 #define KVE_PROTECTION 0x38
117 #define KVE_PATH 0x88
119 /* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
120 match the KVME_PROT_* constants in <sys/user.h>. */
122 #define KINFO_VME_PROT_READ 0x00000001
123 #define KINFO_VME_PROT_WRITE 0x00000002
124 #define KINFO_VME_PROT_EXEC 0x00000004
126 /* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
127 match the KVME_FLAG_* constants in <sys/user.h>. */
129 #define KINFO_VME_FLAG_COW 0x00000001
130 #define KINFO_VME_FLAG_NEEDS_COPY 0x00000002
131 #define KINFO_VME_FLAG_NOCOREDUMP 0x00000004
132 #define KINFO_VME_FLAG_SUPER 0x00000008
133 #define KINFO_VME_FLAG_GROWS_UP 0x00000010
134 #define KINFO_VME_FLAG_GROWS_DOWN 0x00000020
136 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
137 dump notes. See <sys/user.h> for the definition of struct
138 kinfo_file. This data structure should have the same layout on all
141 Note that FreeBSD 7.0 used an older version of this structure
142 (struct kinfo_ofile), but the NT_FREEBSD_PROCSTAT_FILES core dump
143 note wasn't introduced until FreeBSD 9.2. As a result, the core
144 dump note has always used the 7.1 and later structure format. */
146 #define KF_STRUCTSIZE 0x0
149 #define KF_FLAGS 0x10
150 #define KF_OFFSET 0x18
151 #define KF_VNODE_TYPE 0x20
152 #define KF_SOCK_DOMAIN 0x24
153 #define KF_SOCK_TYPE 0x28
154 #define KF_SOCK_PROTOCOL 0x2c
155 #define KF_SA_LOCAL 0x30
156 #define KF_SA_PEER 0xb0
157 #define KF_PATH 0x170
159 /* Constants for the 'kf_type' field in struct kinfo_file. These
160 match the KF_TYPE_* constants in <sys/user.h>. */
162 #define KINFO_FILE_TYPE_VNODE 1
163 #define KINFO_FILE_TYPE_SOCKET 2
164 #define KINFO_FILE_TYPE_PIPE 3
165 #define KINFO_FILE_TYPE_FIFO 4
166 #define KINFO_FILE_TYPE_KQUEUE 5
167 #define KINFO_FILE_TYPE_CRYPTO 6
168 #define KINFO_FILE_TYPE_MQUEUE 7
169 #define KINFO_FILE_TYPE_SHM 8
170 #define KINFO_FILE_TYPE_SEM 9
171 #define KINFO_FILE_TYPE_PTS 10
172 #define KINFO_FILE_TYPE_PROCDESC 11
174 /* Special values for the 'kf_fd' field in struct kinfo_file. These
175 match the KF_FD_TYPE_* constants in <sys/user.h>. */
177 #define KINFO_FILE_FD_TYPE_CWD -1
178 #define KINFO_FILE_FD_TYPE_ROOT -2
179 #define KINFO_FILE_FD_TYPE_JAIL -3
180 #define KINFO_FILE_FD_TYPE_TRACE -4
181 #define KINFO_FILE_FD_TYPE_TEXT -5
182 #define KINFO_FILE_FD_TYPE_CTTY -6
184 /* Flags in the 'kf_flags' field in struct kinfo_file. These match
185 the KF_FLAG_* constants in <sys/user.h>. */
187 #define KINFO_FILE_FLAG_READ 0x00000001
188 #define KINFO_FILE_FLAG_WRITE 0x00000002
189 #define KINFO_FILE_FLAG_APPEND 0x00000004
190 #define KINFO_FILE_FLAG_ASYNC 0x00000008
191 #define KINFO_FILE_FLAG_FSYNC 0x00000010
192 #define KINFO_FILE_FLAG_NONBLOCK 0x00000020
193 #define KINFO_FILE_FLAG_DIRECT 0x00000040
194 #define KINFO_FILE_FLAG_HASLOCK 0x00000080
195 #define KINFO_FILE_FLAG_EXEC 0x00004000
197 /* Constants for the 'kf_vnode_type' field in struct kinfo_file.
198 These match the KF_VTYPE_* constants in <sys/user.h>. */
200 #define KINFO_FILE_VTYPE_VREG 1
201 #define KINFO_FILE_VTYPE_VDIR 2
202 #define KINFO_FILE_VTYPE_VCHR 4
203 #define KINFO_FILE_VTYPE_VLNK 5
204 #define KINFO_FILE_VTYPE_VSOCK 6
205 #define KINFO_FILE_VTYPE_VFIFO 7
207 /* Constants for socket address families. These match AF_* constants
208 in <sys/socket.h>. */
210 #define FBSD_AF_UNIX 1
211 #define FBSD_AF_INET 2
212 #define FBSD_AF_INET6 28
214 /* Constants for socket types. These match SOCK_* constants in
217 #define FBSD_SOCK_STREAM 1
218 #define FBSD_SOCK_DGRAM 2
219 #define FBSD_SOCK_SEQPACKET 5
221 /* Constants for IP protocols. These match IPPROTO_* constants in
224 #define FBSD_IPPROTO_ICMP 1
225 #define FBSD_IPPROTO_TCP 6
226 #define FBSD_IPPROTO_UDP 17
227 #define FBSD_IPPROTO_SCTP 132
229 /* Socket address structures. These have the same layout on all
230 FreeBSD architectures. In addition, multibyte fields such as IP
231 addresses are always stored in network byte order. */
233 struct fbsd_sockaddr_in
242 struct fbsd_sockaddr_in6
246 uint8_t sin6_port
[2];
247 uint32_t sin6_flowinfo
;
248 uint8_t sin6_addr
[16];
249 uint32_t sin6_scope_id
;
252 struct fbsd_sockaddr_un
259 /* Number of 32-bit words in a signal set. This matches _SIG_WORDS in
260 <sys/_sigset.h> and is the same value on all architectures. */
264 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
265 dump notes. See <sys/user.h> for the definition of struct
266 kinfo_proc. This data structure has different layouts on different
267 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386
268 uses a 32-bit time_t while all other architectures use a 64-bit
271 The core dump note actually contains one kinfo_proc structure for
272 each thread, but all of the process-wide data can be obtained from
273 the first structure. One result of this note's format is that some
274 of the process-wide status available in the native target method
275 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
276 is not available from a core dump. Instead, the per-thread data
277 structures contain the value of these fields for individual
280 struct kinfo_proc_layout
282 /* Offsets of struct kinfo_proc members. */
289 int ki_tdev_freebsd11
;
311 /* Offsets of struct rusage members. */
319 const struct kinfo_proc_layout kinfo_proc_layout_32
=
327 .ki_tdev_freebsd11
= 0x44,
328 .ki_sigignore
= 0x68,
347 .ki_rusage_ch
= 0x278,
356 const struct kinfo_proc_layout kinfo_proc_layout_i386
=
364 .ki_tdev_freebsd11
= 0x44,
365 .ki_sigignore
= 0x68,
384 .ki_rusage_ch
= 0x258,
393 const struct kinfo_proc_layout kinfo_proc_layout_64
=
401 .ki_tdev_freebsd11
= 0x64,
402 .ki_sigignore
= 0x88,
421 .ki_rusage_ch
= 0x2f0,
430 static struct gdbarch_data
*fbsd_gdbarch_data_handle
;
432 struct fbsd_gdbarch_data
434 struct type
*siginfo_type
;
438 init_fbsd_gdbarch_data (struct gdbarch
*gdbarch
)
440 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct fbsd_gdbarch_data
);
443 static struct fbsd_gdbarch_data
*
444 get_fbsd_gdbarch_data (struct gdbarch
*gdbarch
)
446 return ((struct fbsd_gdbarch_data
*)
447 gdbarch_data (gdbarch
, fbsd_gdbarch_data_handle
));
450 struct fbsd_pspace_data
452 /* Offsets in the runtime linker's 'Obj_Entry' structure. */
453 LONGEST off_linkmap
= 0;
454 LONGEST off_tlsindex
= 0;
455 bool rtld_offsets_valid
= false;
458 /* Per-program-space data for FreeBSD architectures. */
459 static const struct program_space_key
<fbsd_pspace_data
>
460 fbsd_pspace_data_handle
;
462 static struct fbsd_pspace_data
*
463 get_fbsd_pspace_data (struct program_space
*pspace
)
465 struct fbsd_pspace_data
*data
;
467 data
= fbsd_pspace_data_handle
.get (pspace
);
469 data
= fbsd_pspace_data_handle
.emplace (pspace
);
474 /* This is how we want PTIDs from core files to be printed. */
477 fbsd_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
479 if (ptid
.lwp () != 0)
480 return string_printf ("LWP %ld", ptid
.lwp ());
482 return normal_pid_to_str (ptid
);
485 /* Extract the name assigned to a thread from a core. Returns the
486 string in a static buffer. */
489 fbsd_core_thread_name (struct gdbarch
*gdbarch
, struct thread_info
*thr
)
492 struct bfd_section
*section
;
495 if (thr
->ptid
.lwp () != 0)
497 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
498 whose contents are defined by a "struct thrmisc" declared in
499 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
500 a null-terminated string as the first member of the
501 structure. Rather than define the full structure here, just
502 extract the null-terminated name from the start of the
504 thread_section_name
section_name (".thrmisc", thr
->ptid
);
506 section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
507 if (section
!= NULL
&& bfd_section_size (section
) > 0)
509 /* Truncate the name if it is longer than "buf". */
510 size
= bfd_section_size (section
);
511 if (size
> sizeof buf
- 1)
512 size
= sizeof buf
- 1;
513 if (bfd_get_section_contents (core_bfd
, section
, buf
, (file_ptr
) 0,
519 /* Note that each thread will report the process command
520 as its thread name instead of an empty name if a name
521 has not been set explicitly. Return a NULL name in
523 if (strcmp (buf
, elf_tdata (core_bfd
)->core
->program
) != 0)
532 /* Implement the "core_xfer_siginfo" gdbarch method. */
535 fbsd_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
536 ULONGEST offset
, ULONGEST len
)
540 if (gdbarch_long_bit (gdbarch
) == 32)
541 siginfo_size
= SIZE32_SIGINFO_T
;
543 siginfo_size
= SIZE64_SIGINFO_T
;
544 if (offset
> siginfo_size
)
547 thread_section_name
section_name (".note.freebsdcore.lwpinfo", inferior_ptid
);
548 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
553 if (!bfd_get_section_contents (core_bfd
, section
, buf
,
554 LWPINFO_OFFSET
+ LWPINFO_PL_FLAGS
, 4))
557 int pl_flags
= extract_signed_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
558 if (!(pl_flags
& PL_FLAG_SI
))
561 if (offset
+ len
> siginfo_size
)
562 len
= siginfo_size
- offset
;
564 ULONGEST siginfo_offset
;
565 if (gdbarch_long_bit (gdbarch
) == 32)
566 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO32_PL_SIGINFO
;
568 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO64_PL_SIGINFO
;
570 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
571 siginfo_offset
+ offset
, len
))
578 find_signalled_thread (struct thread_info
*info
, void *data
)
580 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
581 && info
->ptid
.pid () == inferior_ptid
.pid ())
587 /* Return a byte_vector containing the contents of a core dump note
588 for the target object of type OBJECT. If STRUCTSIZE is non-zero,
589 the data is prefixed with a 32-bit integer size to match the format
590 used in FreeBSD NT_PROCSTAT_* notes. */
592 static gdb::optional
<gdb::byte_vector
>
593 fbsd_make_note_desc (enum target_object object
, uint32_t structsize
)
595 gdb::optional
<gdb::byte_vector
> buf
=
596 target_read_alloc (current_top_target (), object
, NULL
);
597 if (!buf
|| buf
->empty ())
603 gdb::byte_vector
desc (sizeof (structsize
) + buf
->size ());
604 memcpy (desc
.data (), &structsize
, sizeof (structsize
));
605 memcpy (desc
.data () + sizeof (structsize
), buf
->data (), buf
->size ());
609 /* Create appropriate note sections for a corefile, returning them in
612 static gdb::unique_xmalloc_ptr
<char>
613 fbsd_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
615 gdb::unique_xmalloc_ptr
<char> note_data
;
616 Elf_Internal_Ehdr
*i_ehdrp
;
617 struct thread_info
*curr_thr
, *signalled_thr
;
619 /* Put a "FreeBSD" label in the ELF header. */
620 i_ehdrp
= elf_elfheader (obfd
);
621 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
623 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch
));
625 if (get_exec_file (0))
627 const char *fname
= lbasename (get_exec_file (0));
628 std::string psargs
= fname
;
630 const char *infargs
= get_inferior_args ();
632 psargs
= psargs
+ " " + infargs
;
634 note_data
.reset (elfcore_write_prpsinfo (obfd
, note_data
.release (),
639 /* Thread register information. */
642 update_thread_list ();
644 catch (const gdb_exception_error
&e
)
646 exception_print (gdb_stderr
, e
);
649 /* Like the kernel, prefer dumping the signalled thread first.
650 "First thread" is what tools use to infer the signalled thread.
651 In case there's more than one signalled thread, prefer the
652 current thread, if it is signalled. */
653 curr_thr
= inferior_thread ();
654 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
655 signalled_thr
= curr_thr
;
658 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
659 if (signalled_thr
== NULL
)
660 signalled_thr
= curr_thr
;
663 enum gdb_signal stop_signal
= signalled_thr
->suspend
.stop_signal
;
664 gcore_elf_build_thread_register_notes (gdbarch
, signalled_thr
, stop_signal
,
665 obfd
, ¬e_data
, note_size
);
666 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
668 if (thr
== signalled_thr
)
671 gcore_elf_build_thread_register_notes (gdbarch
, thr
, stop_signal
,
672 obfd
, ¬e_data
, note_size
);
675 /* Auxiliary vector. */
676 uint32_t structsize
= gdbarch_ptr_bit (gdbarch
) / 4; /* Elf_Auxinfo */
677 gdb::optional
<gdb::byte_vector
> note_desc
=
678 fbsd_make_note_desc (TARGET_OBJECT_AUXV
, structsize
);
679 if (note_desc
&& !note_desc
->empty ())
681 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
682 note_size
, "FreeBSD",
683 NT_FREEBSD_PROCSTAT_AUXV
,
685 note_desc
->size ()));
690 /* Virtual memory mappings. */
691 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP
, 0);
692 if (note_desc
&& !note_desc
->empty ())
694 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
695 note_size
, "FreeBSD",
696 NT_FREEBSD_PROCSTAT_VMMAP
,
698 note_desc
->size ()));
703 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS
, 0);
704 if (note_desc
&& !note_desc
->empty ())
706 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
707 note_size
, "FreeBSD",
708 NT_FREEBSD_PROCSTAT_PSSTRINGS
,
710 note_desc
->size ()));
718 /* Helper function to generate the file descriptor description for a
719 single open file in 'info proc files'. */
722 fbsd_file_fd (int kf_fd
)
726 case KINFO_FILE_FD_TYPE_CWD
:
728 case KINFO_FILE_FD_TYPE_ROOT
:
730 case KINFO_FILE_FD_TYPE_JAIL
:
732 case KINFO_FILE_FD_TYPE_TRACE
:
734 case KINFO_FILE_FD_TYPE_TEXT
:
736 case KINFO_FILE_FD_TYPE_CTTY
:
739 return int_string (kf_fd
, 10, 1, 0, 0);
743 /* Helper function to generate the file type for a single open file in
744 'info proc files'. */
747 fbsd_file_type (int kf_type
, int kf_vnode_type
)
751 case KINFO_FILE_TYPE_VNODE
:
752 switch (kf_vnode_type
)
754 case KINFO_FILE_VTYPE_VREG
:
756 case KINFO_FILE_VTYPE_VDIR
:
758 case KINFO_FILE_VTYPE_VCHR
:
760 case KINFO_FILE_VTYPE_VLNK
:
762 case KINFO_FILE_VTYPE_VSOCK
:
764 case KINFO_FILE_VTYPE_VFIFO
:
768 char *str
= get_print_cell ();
770 xsnprintf (str
, PRINT_CELL_SIZE
, "vn:%d", kf_vnode_type
);
774 case KINFO_FILE_TYPE_SOCKET
:
776 case KINFO_FILE_TYPE_PIPE
:
778 case KINFO_FILE_TYPE_FIFO
:
780 case KINFO_FILE_TYPE_KQUEUE
:
782 case KINFO_FILE_TYPE_CRYPTO
:
784 case KINFO_FILE_TYPE_MQUEUE
:
786 case KINFO_FILE_TYPE_SHM
:
788 case KINFO_FILE_TYPE_SEM
:
790 case KINFO_FILE_TYPE_PTS
:
792 case KINFO_FILE_TYPE_PROCDESC
:
795 return int_string (kf_type
, 10, 1, 0, 0);
799 /* Helper function to generate the file flags for a single open file in
800 'info proc files'. */
803 fbsd_file_flags (int kf_flags
)
805 static char file_flags
[10];
807 file_flags
[0] = (kf_flags
& KINFO_FILE_FLAG_READ
) ? 'r' : '-';
808 file_flags
[1] = (kf_flags
& KINFO_FILE_FLAG_WRITE
) ? 'w' : '-';
809 file_flags
[2] = (kf_flags
& KINFO_FILE_FLAG_EXEC
) ? 'x' : '-';
810 file_flags
[3] = (kf_flags
& KINFO_FILE_FLAG_APPEND
) ? 'a' : '-';
811 file_flags
[4] = (kf_flags
& KINFO_FILE_FLAG_ASYNC
) ? 's' : '-';
812 file_flags
[5] = (kf_flags
& KINFO_FILE_FLAG_FSYNC
) ? 'f' : '-';
813 file_flags
[6] = (kf_flags
& KINFO_FILE_FLAG_NONBLOCK
) ? 'n' : '-';
814 file_flags
[7] = (kf_flags
& KINFO_FILE_FLAG_DIRECT
) ? 'd' : '-';
815 file_flags
[8] = (kf_flags
& KINFO_FILE_FLAG_HASLOCK
) ? 'l' : '-';
816 file_flags
[9] = '\0';
821 /* Helper function to generate the name of an IP protocol. */
824 fbsd_ipproto (int protocol
)
828 case FBSD_IPPROTO_ICMP
:
830 case FBSD_IPPROTO_TCP
:
832 case FBSD_IPPROTO_UDP
:
834 case FBSD_IPPROTO_SCTP
:
838 char *str
= get_print_cell ();
840 xsnprintf (str
, PRINT_CELL_SIZE
, "ip<%d>", protocol
);
846 /* Helper function to print out an IPv4 socket address. */
849 fbsd_print_sockaddr_in (const void *sockaddr
)
851 const struct fbsd_sockaddr_in
*sin
=
852 reinterpret_cast<const struct fbsd_sockaddr_in
*> (sockaddr
);
853 char buf
[INET_ADDRSTRLEN
];
855 if (inet_ntop (AF_INET
, sin
->sin_addr
, buf
, sizeof buf
) == nullptr)
856 error (_("Failed to format IPv4 address"));
857 printf_filtered ("%s:%u", buf
,
858 (sin
->sin_port
[0] << 8) | sin
->sin_port
[1]);
861 /* Helper function to print out an IPv6 socket address. */
864 fbsd_print_sockaddr_in6 (const void *sockaddr
)
866 const struct fbsd_sockaddr_in6
*sin6
=
867 reinterpret_cast<const struct fbsd_sockaddr_in6
*> (sockaddr
);
868 char buf
[INET6_ADDRSTRLEN
];
870 if (inet_ntop (AF_INET6
, sin6
->sin6_addr
, buf
, sizeof buf
) == nullptr)
871 error (_("Failed to format IPv6 address"));
872 printf_filtered ("%s.%u", buf
,
873 (sin6
->sin6_port
[0] << 8) | sin6
->sin6_port
[1]);
876 /* See fbsd-tdep.h. */
879 fbsd_info_proc_files_header ()
881 printf_filtered (_("Open files:\n\n"));
882 printf_filtered (" %6s %6s %10s %9s %s\n",
883 "FD", "Type", "Offset", "Flags ", "Name");
886 /* See fbsd-tdep.h. */
889 fbsd_info_proc_files_entry (int kf_type
, int kf_fd
, int kf_flags
,
890 LONGEST kf_offset
, int kf_vnode_type
,
891 int kf_sock_domain
, int kf_sock_type
,
892 int kf_sock_protocol
, const void *kf_sa_local
,
893 const void *kf_sa_peer
, const void *kf_path
)
895 printf_filtered (" %6s %6s %10s %8s ",
896 fbsd_file_fd (kf_fd
),
897 fbsd_file_type (kf_type
, kf_vnode_type
),
898 kf_offset
> -1 ? hex_string (kf_offset
) : "-",
899 fbsd_file_flags (kf_flags
));
900 if (kf_type
== KINFO_FILE_TYPE_SOCKET
)
902 switch (kf_sock_domain
)
906 switch (kf_sock_type
)
908 case FBSD_SOCK_STREAM
:
909 printf_filtered ("unix stream:");
911 case FBSD_SOCK_DGRAM
:
912 printf_filtered ("unix dgram:");
914 case FBSD_SOCK_SEQPACKET
:
915 printf_filtered ("unix seqpacket:");
918 printf_filtered ("unix <%d>:", kf_sock_type
);
922 /* For local sockets, print out the first non-nul path
923 rather than both paths. */
924 const struct fbsd_sockaddr_un
*saddr_un
925 = reinterpret_cast<const struct fbsd_sockaddr_un
*> (kf_sa_local
);
926 if (saddr_un
->sun_path
[0] == 0)
927 saddr_un
= reinterpret_cast<const struct fbsd_sockaddr_un
*>
929 printf_filtered ("%s", saddr_un
->sun_path
);
933 printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol
));
934 fbsd_print_sockaddr_in (kf_sa_local
);
935 printf_filtered (" -> ");
936 fbsd_print_sockaddr_in (kf_sa_peer
);
939 printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol
));
940 fbsd_print_sockaddr_in6 (kf_sa_local
);
941 printf_filtered (" -> ");
942 fbsd_print_sockaddr_in6 (kf_sa_peer
);
947 printf_filtered ("%s", reinterpret_cast<const char *> (kf_path
));
948 printf_filtered ("\n");
951 /* Implement "info proc files" for a corefile. */
954 fbsd_core_info_proc_files (struct gdbarch
*gdbarch
)
957 = bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
960 warning (_("unable to find open files in core file"));
964 size_t note_size
= bfd_section_size (section
);
966 error (_("malformed core note - too short for header"));
968 gdb::def_vector
<unsigned char> contents (note_size
);
969 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
971 error (_("could not get core note contents"));
973 unsigned char *descdata
= contents
.data ();
974 unsigned char *descend
= descdata
+ note_size
;
976 /* Skip over the structure size. */
979 fbsd_info_proc_files_header ();
981 while (descdata
+ KF_PATH
< descend
)
983 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
984 if (structsize
< KF_PATH
)
985 error (_("malformed core note - file structure too small"));
987 LONGEST type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_TYPE
);
988 LONGEST fd
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
);
989 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FLAGS
);
990 LONGEST offset
= bfd_get_signed_64 (core_bfd
, descdata
+ KF_OFFSET
);
991 LONGEST vnode_type
= bfd_get_signed_32 (core_bfd
,
992 descdata
+ KF_VNODE_TYPE
);
993 LONGEST sock_domain
= bfd_get_signed_32 (core_bfd
,
994 descdata
+ KF_SOCK_DOMAIN
);
995 LONGEST sock_type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_SOCK_TYPE
);
996 LONGEST sock_protocol
= bfd_get_signed_32 (core_bfd
,
997 descdata
+ KF_SOCK_PROTOCOL
);
998 fbsd_info_proc_files_entry (type
, fd
, flags
, offset
, vnode_type
,
999 sock_domain
, sock_type
, sock_protocol
,
1000 descdata
+ KF_SA_LOCAL
, descdata
+ KF_SA_PEER
,
1001 descdata
+ KF_PATH
);
1003 descdata
+= structsize
;
1007 /* Helper function to generate mappings flags for a single VM map
1008 entry in 'info proc mappings'. */
1011 fbsd_vm_map_entry_flags (int kve_flags
, int kve_protection
)
1013 static char vm_flags
[9];
1015 vm_flags
[0] = (kve_protection
& KINFO_VME_PROT_READ
) ? 'r' : '-';
1016 vm_flags
[1] = (kve_protection
& KINFO_VME_PROT_WRITE
) ? 'w' : '-';
1017 vm_flags
[2] = (kve_protection
& KINFO_VME_PROT_EXEC
) ? 'x' : '-';
1019 vm_flags
[4] = (kve_flags
& KINFO_VME_FLAG_COW
) ? 'C' : '-';
1020 vm_flags
[5] = (kve_flags
& KINFO_VME_FLAG_NEEDS_COPY
) ? 'N' : '-';
1021 vm_flags
[6] = (kve_flags
& KINFO_VME_FLAG_SUPER
) ? 'S' : '-';
1022 vm_flags
[7] = (kve_flags
& KINFO_VME_FLAG_GROWS_UP
) ? 'U'
1023 : (kve_flags
& KINFO_VME_FLAG_GROWS_DOWN
) ? 'D' : '-';
1029 /* See fbsd-tdep.h. */
1032 fbsd_info_proc_mappings_header (int addr_bit
)
1034 printf_filtered (_("Mapped address spaces:\n\n"));
1037 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1040 " Size", " Offset", "Flags ", "File");
1044 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1047 " Size", " Offset", "Flags ", "File");
1051 /* See fbsd-tdep.h. */
1054 fbsd_info_proc_mappings_entry (int addr_bit
, ULONGEST kve_start
,
1055 ULONGEST kve_end
, ULONGEST kve_offset
,
1056 int kve_flags
, int kve_protection
,
1057 const void *kve_path
)
1061 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1062 hex_string (kve_start
),
1063 hex_string (kve_end
),
1064 hex_string (kve_end
- kve_start
),
1065 hex_string (kve_offset
),
1066 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1067 reinterpret_cast<const char *> (kve_path
));
1071 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1072 hex_string (kve_start
),
1073 hex_string (kve_end
),
1074 hex_string (kve_end
- kve_start
),
1075 hex_string (kve_offset
),
1076 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1077 reinterpret_cast<const char *> (kve_path
));
1081 /* Implement "info proc mappings" for a corefile. */
1084 fbsd_core_info_proc_mappings (struct gdbarch
*gdbarch
)
1087 unsigned char *descdata
, *descend
;
1090 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.vmmap");
1091 if (section
== NULL
)
1093 warning (_("unable to find mappings in core file"));
1097 note_size
= bfd_section_size (section
);
1099 error (_("malformed core note - too short for header"));
1101 gdb::def_vector
<unsigned char> contents (note_size
);
1102 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1104 error (_("could not get core note contents"));
1106 descdata
= contents
.data ();
1107 descend
= descdata
+ note_size
;
1109 /* Skip over the structure size. */
1112 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch
));
1113 while (descdata
+ KVE_PATH
< descend
)
1115 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KVE_STRUCTSIZE
);
1116 if (structsize
< KVE_PATH
)
1117 error (_("malformed core note - vmmap entry too small"));
1119 ULONGEST start
= bfd_get_64 (core_bfd
, descdata
+ KVE_START
);
1120 ULONGEST end
= bfd_get_64 (core_bfd
, descdata
+ KVE_END
);
1121 ULONGEST offset
= bfd_get_64 (core_bfd
, descdata
+ KVE_OFFSET
);
1122 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_FLAGS
);
1123 LONGEST prot
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_PROTECTION
);
1124 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch
), start
, end
,
1125 offset
, flags
, prot
, descdata
+ KVE_PATH
);
1127 descdata
+= structsize
;
1131 /* Fetch the pathname of a vnode for a single file descriptor from the
1132 file table core note. */
1134 static gdb::unique_xmalloc_ptr
<char>
1135 fbsd_core_vnode_path (struct gdbarch
*gdbarch
, int fd
)
1138 unsigned char *descdata
, *descend
;
1141 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1142 if (section
== NULL
)
1145 note_size
= bfd_section_size (section
);
1147 error (_("malformed core note - too short for header"));
1149 gdb::def_vector
<unsigned char> contents (note_size
);
1150 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1152 error (_("could not get core note contents"));
1154 descdata
= contents
.data ();
1155 descend
= descdata
+ note_size
;
1157 /* Skip over the structure size. */
1160 while (descdata
+ KF_PATH
< descend
)
1162 ULONGEST structsize
;
1164 structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1165 if (structsize
< KF_PATH
)
1166 error (_("malformed core note - file structure too small"));
1168 if (bfd_get_32 (core_bfd
, descdata
+ KF_TYPE
) == KINFO_FILE_TYPE_VNODE
1169 && bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
) == fd
)
1171 char *path
= (char *) descdata
+ KF_PATH
;
1172 return make_unique_xstrdup (path
);
1175 descdata
+= structsize
;
1180 /* Helper function to read a struct timeval. */
1183 fbsd_core_fetch_timeval (struct gdbarch
*gdbarch
, unsigned char *data
,
1184 LONGEST
&sec
, ULONGEST
&usec
)
1186 if (gdbarch_addr_bit (gdbarch
) == 64)
1188 sec
= bfd_get_signed_64 (core_bfd
, data
);
1189 usec
= bfd_get_64 (core_bfd
, data
+ 8);
1191 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1193 sec
= bfd_get_signed_32 (core_bfd
, data
);
1194 usec
= bfd_get_32 (core_bfd
, data
+ 4);
1198 sec
= bfd_get_signed_64 (core_bfd
, data
);
1199 usec
= bfd_get_32 (core_bfd
, data
+ 8);
1203 /* Print out the contents of a signal set. */
1206 fbsd_print_sigset (const char *descr
, unsigned char *sigset
)
1208 printf_filtered ("%s: ", descr
);
1209 for (int i
= 0; i
< SIG_WORDS
; i
++)
1210 printf_filtered ("%08x ",
1211 (unsigned int) bfd_get_32 (core_bfd
, sigset
+ i
* 4));
1212 printf_filtered ("\n");
1215 /* Implement "info proc status" for a corefile. */
1218 fbsd_core_info_proc_status (struct gdbarch
*gdbarch
)
1220 const struct kinfo_proc_layout
*kp
;
1222 unsigned char *descdata
;
1223 int addr_bit
, long_bit
;
1228 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.proc");
1229 if (section
== NULL
)
1231 warning (_("unable to find process info in core file"));
1235 addr_bit
= gdbarch_addr_bit (gdbarch
);
1237 kp
= &kinfo_proc_layout_64
;
1238 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1239 kp
= &kinfo_proc_layout_i386
;
1241 kp
= &kinfo_proc_layout_32
;
1242 long_bit
= gdbarch_long_bit (gdbarch
);
1245 * Ensure that the note is large enough for all of the fields fetched
1246 * by this function. In particular, the note must contain the 32-bit
1247 * structure size, then it must be long enough to access the last
1248 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1250 note_size
= bfd_section_size (section
);
1251 if (note_size
< (4 + kp
->ki_rusage_ch
+ kp
->ru_majflt
1252 + long_bit
/ TARGET_CHAR_BIT
))
1253 error (_("malformed core note - too short"));
1255 gdb::def_vector
<unsigned char> contents (note_size
);
1256 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1258 error (_("could not get core note contents"));
1260 descdata
= contents
.data ();
1262 /* Skip over the structure size. */
1265 /* Verify 'ki_layout' is 0. */
1266 if (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_layout
) != 0)
1268 warning (_("unsupported process information in core file"));
1272 printf_filtered ("Name: %.19s\n", descdata
+ kp
->ki_comm
);
1273 printf_filtered ("Process ID: %s\n",
1274 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pid
)));
1275 printf_filtered ("Parent process: %s\n",
1276 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ppid
)));
1277 printf_filtered ("Process group: %s\n",
1278 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pgid
)));
1279 printf_filtered ("Session id: %s\n",
1280 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_sid
)));
1282 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1283 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1284 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1285 the structure that is cleared to zero. Assume that a zero value
1286 in ki_tdev indicates a core dump from an older kernel and use the
1287 value in 'ki_tdev_freebsd11' instead. */
1288 value
= bfd_get_64 (core_bfd
, descdata
+ kp
->ki_tdev
);
1290 value
= bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tdev_freebsd11
);
1291 printf_filtered ("TTY: %s\n", pulongest (value
));
1292 printf_filtered ("TTY owner process group: %s\n",
1293 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tpgid
)));
1294 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1295 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ruid
)),
1296 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_uid
)),
1297 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svuid
)));
1298 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1299 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_rgid
)),
1300 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_groups
)),
1301 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svgid
)));
1302 printf_filtered ("Groups: ");
1303 uint16_t ngroups
= bfd_get_16 (core_bfd
, descdata
+ kp
->ki_ngroups
);
1304 for (int i
= 0; i
< ngroups
; i
++)
1305 printf_filtered ("%s ",
1306 pulongest (bfd_get_32 (core_bfd
,
1307 descdata
+ kp
->ki_groups
+ i
* 4)));
1308 printf_filtered ("\n");
1309 value
= bfd_get (long_bit
, core_bfd
,
1310 descdata
+ kp
->ki_rusage
+ kp
->ru_minflt
);
1311 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value
));
1312 value
= bfd_get (long_bit
, core_bfd
,
1313 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_minflt
);
1314 printf_filtered ("Minor faults, children: %s\n", pulongest (value
));
1315 value
= bfd_get (long_bit
, core_bfd
,
1316 descdata
+ kp
->ki_rusage
+ kp
->ru_majflt
);
1317 printf_filtered ("Major faults (memory page faults): %s\n",
1319 value
= bfd_get (long_bit
, core_bfd
,
1320 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_majflt
);
1321 printf_filtered ("Major faults, children: %s\n", pulongest (value
));
1322 fbsd_core_fetch_timeval (gdbarch
,
1323 descdata
+ kp
->ki_rusage
+ kp
->ru_utime
,
1325 printf_filtered ("utime: %s.%06d\n", plongest (sec
), (int) value
);
1326 fbsd_core_fetch_timeval (gdbarch
,
1327 descdata
+ kp
->ki_rusage
+ kp
->ru_stime
,
1329 printf_filtered ("stime: %s.%06d\n", plongest (sec
), (int) value
);
1330 fbsd_core_fetch_timeval (gdbarch
,
1331 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_utime
,
1333 printf_filtered ("utime, children: %s.%06d\n", plongest (sec
), (int) value
);
1334 fbsd_core_fetch_timeval (gdbarch
,
1335 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_stime
,
1337 printf_filtered ("stime, children: %s.%06d\n", plongest (sec
), (int) value
);
1338 printf_filtered ("'nice' value: %d\n",
1339 (int) bfd_get_signed_8 (core_bfd
, descdata
+ kp
->ki_nice
));
1340 fbsd_core_fetch_timeval (gdbarch
, descdata
+ kp
->ki_start
, sec
, value
);
1341 printf_filtered ("Start time: %s.%06d\n", plongest (sec
), (int) value
);
1342 printf_filtered ("Virtual memory size: %s kB\n",
1343 pulongest (bfd_get (addr_bit
, core_bfd
,
1344 descdata
+ kp
->ki_size
) / 1024));
1345 printf_filtered ("Data size: %s pages\n",
1346 pulongest (bfd_get (addr_bit
, core_bfd
,
1347 descdata
+ kp
->ki_dsize
)));
1348 printf_filtered ("Stack size: %s pages\n",
1349 pulongest (bfd_get (addr_bit
, core_bfd
,
1350 descdata
+ kp
->ki_ssize
)));
1351 printf_filtered ("Text size: %s pages\n",
1352 pulongest (bfd_get (addr_bit
, core_bfd
,
1353 descdata
+ kp
->ki_tsize
)));
1354 printf_filtered ("Resident set size: %s pages\n",
1355 pulongest (bfd_get (addr_bit
, core_bfd
,
1356 descdata
+ kp
->ki_rssize
)));
1357 printf_filtered ("Maximum RSS: %s pages\n",
1358 pulongest (bfd_get (long_bit
, core_bfd
,
1359 descdata
+ kp
->ki_rusage
1361 fbsd_print_sigset ("Ignored Signals", descdata
+ kp
->ki_sigignore
);
1362 fbsd_print_sigset ("Caught Signals", descdata
+ kp
->ki_sigcatch
);
1365 /* Implement the "core_info_proc" gdbarch method. */
1368 fbsd_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1369 enum info_proc_what what
)
1371 bool do_cmdline
= false;
1372 bool do_cwd
= false;
1373 bool do_exe
= false;
1374 bool do_files
= false;
1375 bool do_mappings
= false;
1376 bool do_status
= false;
1417 pid
= bfd_core_file_pid (core_bfd
);
1419 printf_filtered (_("process %d\n"), pid
);
1423 const char *cmdline
;
1425 cmdline
= bfd_core_file_failing_command (core_bfd
);
1427 printf_filtered ("cmdline = '%s'\n", cmdline
);
1429 warning (_("Command line unavailable"));
1433 gdb::unique_xmalloc_ptr
<char> cwd
=
1434 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_CWD
);
1436 printf_filtered ("cwd = '%s'\n", cwd
.get ());
1438 warning (_("unable to read current working directory"));
1442 gdb::unique_xmalloc_ptr
<char> exe
=
1443 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_TEXT
);
1445 printf_filtered ("exe = '%s'\n", exe
.get ());
1447 warning (_("unable to read executable path name"));
1450 fbsd_core_info_proc_files (gdbarch
);
1452 fbsd_core_info_proc_mappings (gdbarch
);
1454 fbsd_core_info_proc_status (gdbarch
);
1457 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1460 fbsd_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1461 CORE_ADDR type
, CORE_ADDR val
)
1463 const char *name
= "???";
1464 const char *description
= "";
1465 enum auxv_format format
= AUXV_FORMAT_HEX
;
1484 default_print_auxv_entry (gdbarch
, file
, type
, val
);
1486 #define _TAGNAME(tag) #tag
1487 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1488 #define TAG(tag, text, kind) \
1489 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1490 TAG (EXECPATH
, _("Executable path"), AUXV_FORMAT_STR
);
1491 TAG (CANARY
, _("Canary for SSP"), AUXV_FORMAT_HEX
);
1492 TAG (CANARYLEN
, ("Length of the SSP canary"), AUXV_FORMAT_DEC
);
1493 TAG (OSRELDATE
, _("OSRELDATE"), AUXV_FORMAT_DEC
);
1494 TAG (NCPUS
, _("Number of CPUs"), AUXV_FORMAT_DEC
);
1495 TAG (PAGESIZES
, _("Pagesizes"), AUXV_FORMAT_HEX
);
1496 TAG (PAGESIZESLEN
, _("Number of pagesizes"), AUXV_FORMAT_DEC
);
1497 TAG (TIMEKEEP
, _("Pointer to timehands"), AUXV_FORMAT_HEX
);
1498 TAG (STACKPROT
, _("Initial stack protection"), AUXV_FORMAT_HEX
);
1499 TAG (EHDRFLAGS
, _("ELF header e_flags"), AUXV_FORMAT_HEX
);
1500 TAG (HWCAP
, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX
);
1501 TAG (HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
1502 TAG (BSDFLAGS
, _("ELF BSD flags"), AUXV_FORMAT_HEX
);
1503 TAG (ARGC
, _("Argument count"), AUXV_FORMAT_DEC
);
1504 TAG (ARGV
, _("Argument vector"), AUXV_FORMAT_HEX
);
1505 TAG (ENVC
, _("Environment count"), AUXV_FORMAT_DEC
);
1506 TAG (ENVV
, _("Environment vector"), AUXV_FORMAT_HEX
);
1507 TAG (PS_STRINGS
, _("Pointer to ps_strings"), AUXV_FORMAT_HEX
);
1510 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
1513 /* Implement the "get_siginfo_type" gdbarch method. */
1515 static struct type
*
1516 fbsd_get_siginfo_type (struct gdbarch
*gdbarch
)
1518 struct fbsd_gdbarch_data
*fbsd_gdbarch_data
;
1519 struct type
*int_type
, *int32_type
, *uint32_type
, *long_type
, *void_ptr_type
;
1520 struct type
*uid_type
, *pid_type
;
1521 struct type
*sigval_type
, *reason_type
;
1522 struct type
*siginfo_type
;
1525 fbsd_gdbarch_data
= get_fbsd_gdbarch_data (gdbarch
);
1526 if (fbsd_gdbarch_data
->siginfo_type
!= NULL
)
1527 return fbsd_gdbarch_data
->siginfo_type
;
1529 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
1531 int32_type
= arch_integer_type (gdbarch
, 32, 0, "int32_t");
1532 uint32_type
= arch_integer_type (gdbarch
, 32, 1, "uint32_t");
1533 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
1535 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
1538 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1539 sigval_type
->set_name (xstrdup ("sigval"));
1540 append_composite_type_field (sigval_type
, "sival_int", int_type
);
1541 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
1544 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1545 TYPE_LENGTH (int32_type
) * TARGET_CHAR_BIT
, "__pid_t");
1546 TYPE_TARGET_TYPE (pid_type
) = int32_type
;
1547 pid_type
->set_target_is_stub (true);
1550 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1551 TYPE_LENGTH (uint32_type
) * TARGET_CHAR_BIT
,
1553 TYPE_TARGET_TYPE (uid_type
) = uint32_type
;
1554 pid_type
->set_target_is_stub (true);
1557 reason_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1560 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1561 append_composite_type_field (type
, "si_trapno", int_type
);
1562 append_composite_type_field (reason_type
, "_fault", type
);
1565 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1566 append_composite_type_field (type
, "si_timerid", int_type
);
1567 append_composite_type_field (type
, "si_overrun", int_type
);
1568 append_composite_type_field (reason_type
, "_timer", type
);
1571 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1572 append_composite_type_field (type
, "si_mqd", int_type
);
1573 append_composite_type_field (reason_type
, "_mesgq", type
);
1576 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1577 append_composite_type_field (type
, "si_band", long_type
);
1578 append_composite_type_field (reason_type
, "_poll", type
);
1581 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1582 append_composite_type_field (type
, "__spare1__", long_type
);
1583 append_composite_type_field (type
, "__spare2__",
1584 init_vector_type (int_type
, 7));
1585 append_composite_type_field (reason_type
, "__spare__", type
);
1587 /* struct siginfo */
1588 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1589 siginfo_type
->set_name (xstrdup ("siginfo"));
1590 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
1591 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
1592 append_composite_type_field (siginfo_type
, "si_code", int_type
);
1593 append_composite_type_field (siginfo_type
, "si_pid", pid_type
);
1594 append_composite_type_field (siginfo_type
, "si_uid", uid_type
);
1595 append_composite_type_field (siginfo_type
, "si_status", int_type
);
1596 append_composite_type_field (siginfo_type
, "si_addr", void_ptr_type
);
1597 append_composite_type_field (siginfo_type
, "si_value", sigval_type
);
1598 append_composite_type_field (siginfo_type
, "_reason", reason_type
);
1600 fbsd_gdbarch_data
->siginfo_type
= siginfo_type
;
1602 return siginfo_type
;
1605 /* Implement the "gdb_signal_from_target" gdbarch method. */
1607 static enum gdb_signal
1608 fbsd_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1613 return GDB_SIGNAL_0
;
1615 case FREEBSD_SIGHUP
:
1616 return GDB_SIGNAL_HUP
;
1618 case FREEBSD_SIGINT
:
1619 return GDB_SIGNAL_INT
;
1621 case FREEBSD_SIGQUIT
:
1622 return GDB_SIGNAL_QUIT
;
1624 case FREEBSD_SIGILL
:
1625 return GDB_SIGNAL_ILL
;
1627 case FREEBSD_SIGTRAP
:
1628 return GDB_SIGNAL_TRAP
;
1630 case FREEBSD_SIGABRT
:
1631 return GDB_SIGNAL_ABRT
;
1633 case FREEBSD_SIGEMT
:
1634 return GDB_SIGNAL_EMT
;
1636 case FREEBSD_SIGFPE
:
1637 return GDB_SIGNAL_FPE
;
1639 case FREEBSD_SIGKILL
:
1640 return GDB_SIGNAL_KILL
;
1642 case FREEBSD_SIGBUS
:
1643 return GDB_SIGNAL_BUS
;
1645 case FREEBSD_SIGSEGV
:
1646 return GDB_SIGNAL_SEGV
;
1648 case FREEBSD_SIGSYS
:
1649 return GDB_SIGNAL_SYS
;
1651 case FREEBSD_SIGPIPE
:
1652 return GDB_SIGNAL_PIPE
;
1654 case FREEBSD_SIGALRM
:
1655 return GDB_SIGNAL_ALRM
;
1657 case FREEBSD_SIGTERM
:
1658 return GDB_SIGNAL_TERM
;
1660 case FREEBSD_SIGURG
:
1661 return GDB_SIGNAL_URG
;
1663 case FREEBSD_SIGSTOP
:
1664 return GDB_SIGNAL_STOP
;
1666 case FREEBSD_SIGTSTP
:
1667 return GDB_SIGNAL_TSTP
;
1669 case FREEBSD_SIGCONT
:
1670 return GDB_SIGNAL_CONT
;
1672 case FREEBSD_SIGCHLD
:
1673 return GDB_SIGNAL_CHLD
;
1675 case FREEBSD_SIGTTIN
:
1676 return GDB_SIGNAL_TTIN
;
1678 case FREEBSD_SIGTTOU
:
1679 return GDB_SIGNAL_TTOU
;
1682 return GDB_SIGNAL_IO
;
1684 case FREEBSD_SIGXCPU
:
1685 return GDB_SIGNAL_XCPU
;
1687 case FREEBSD_SIGXFSZ
:
1688 return GDB_SIGNAL_XFSZ
;
1690 case FREEBSD_SIGVTALRM
:
1691 return GDB_SIGNAL_VTALRM
;
1693 case FREEBSD_SIGPROF
:
1694 return GDB_SIGNAL_PROF
;
1696 case FREEBSD_SIGWINCH
:
1697 return GDB_SIGNAL_WINCH
;
1699 case FREEBSD_SIGINFO
:
1700 return GDB_SIGNAL_INFO
;
1702 case FREEBSD_SIGUSR1
:
1703 return GDB_SIGNAL_USR1
;
1705 case FREEBSD_SIGUSR2
:
1706 return GDB_SIGNAL_USR2
;
1708 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1709 case FREEBSD_SIGTHR
:
1710 return GDB_SIGNAL_LWP
;
1712 case FREEBSD_SIGLIBRT
:
1713 return GDB_SIGNAL_LIBRT
;
1716 if (signal
>= FREEBSD_SIGRTMIN
&& signal
<= FREEBSD_SIGRTMAX
)
1718 int offset
= signal
- FREEBSD_SIGRTMIN
;
1720 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_65
+ offset
);
1723 return GDB_SIGNAL_UNKNOWN
;
1726 /* Implement the "gdb_signal_to_target" gdbarch method. */
1729 fbsd_gdb_signal_to_target (struct gdbarch
*gdbarch
,
1730 enum gdb_signal signal
)
1737 case GDB_SIGNAL_HUP
:
1738 return FREEBSD_SIGHUP
;
1740 case GDB_SIGNAL_INT
:
1741 return FREEBSD_SIGINT
;
1743 case GDB_SIGNAL_QUIT
:
1744 return FREEBSD_SIGQUIT
;
1746 case GDB_SIGNAL_ILL
:
1747 return FREEBSD_SIGILL
;
1749 case GDB_SIGNAL_TRAP
:
1750 return FREEBSD_SIGTRAP
;
1752 case GDB_SIGNAL_ABRT
:
1753 return FREEBSD_SIGABRT
;
1755 case GDB_SIGNAL_EMT
:
1756 return FREEBSD_SIGEMT
;
1758 case GDB_SIGNAL_FPE
:
1759 return FREEBSD_SIGFPE
;
1761 case GDB_SIGNAL_KILL
:
1762 return FREEBSD_SIGKILL
;
1764 case GDB_SIGNAL_BUS
:
1765 return FREEBSD_SIGBUS
;
1767 case GDB_SIGNAL_SEGV
:
1768 return FREEBSD_SIGSEGV
;
1770 case GDB_SIGNAL_SYS
:
1771 return FREEBSD_SIGSYS
;
1773 case GDB_SIGNAL_PIPE
:
1774 return FREEBSD_SIGPIPE
;
1776 case GDB_SIGNAL_ALRM
:
1777 return FREEBSD_SIGALRM
;
1779 case GDB_SIGNAL_TERM
:
1780 return FREEBSD_SIGTERM
;
1782 case GDB_SIGNAL_URG
:
1783 return FREEBSD_SIGURG
;
1785 case GDB_SIGNAL_STOP
:
1786 return FREEBSD_SIGSTOP
;
1788 case GDB_SIGNAL_TSTP
:
1789 return FREEBSD_SIGTSTP
;
1791 case GDB_SIGNAL_CONT
:
1792 return FREEBSD_SIGCONT
;
1794 case GDB_SIGNAL_CHLD
:
1795 return FREEBSD_SIGCHLD
;
1797 case GDB_SIGNAL_TTIN
:
1798 return FREEBSD_SIGTTIN
;
1800 case GDB_SIGNAL_TTOU
:
1801 return FREEBSD_SIGTTOU
;
1804 return FREEBSD_SIGIO
;
1806 case GDB_SIGNAL_XCPU
:
1807 return FREEBSD_SIGXCPU
;
1809 case GDB_SIGNAL_XFSZ
:
1810 return FREEBSD_SIGXFSZ
;
1812 case GDB_SIGNAL_VTALRM
:
1813 return FREEBSD_SIGVTALRM
;
1815 case GDB_SIGNAL_PROF
:
1816 return FREEBSD_SIGPROF
;
1818 case GDB_SIGNAL_WINCH
:
1819 return FREEBSD_SIGWINCH
;
1821 case GDB_SIGNAL_INFO
:
1822 return FREEBSD_SIGINFO
;
1824 case GDB_SIGNAL_USR1
:
1825 return FREEBSD_SIGUSR1
;
1827 case GDB_SIGNAL_USR2
:
1828 return FREEBSD_SIGUSR2
;
1830 case GDB_SIGNAL_LWP
:
1831 return FREEBSD_SIGTHR
;
1833 case GDB_SIGNAL_LIBRT
:
1834 return FREEBSD_SIGLIBRT
;
1837 if (signal
>= GDB_SIGNAL_REALTIME_65
1838 && signal
<= GDB_SIGNAL_REALTIME_126
)
1840 int offset
= signal
- GDB_SIGNAL_REALTIME_65
;
1842 return FREEBSD_SIGRTMIN
+ offset
;
1848 /* Implement the "get_syscall_number" gdbarch method. */
1851 fbsd_get_syscall_number (struct gdbarch
*gdbarch
, thread_info
*thread
)
1854 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1855 native targets fetch the system call number from the
1856 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1857 However, system call catching requires this function to be
1860 internal_error (__FILE__
, __LINE__
, _("fbsd_get_sycall_number called"));
1863 /* Read an integer symbol value from the current target. */
1866 fbsd_read_integer_by_name (struct gdbarch
*gdbarch
, const char *name
)
1868 bound_minimal_symbol ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1869 if (ms
.minsym
== NULL
)
1870 error (_("Unable to resolve symbol '%s'"), name
);
1873 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms
), buf
, sizeof buf
) != 0)
1874 error (_("Unable to read value of '%s'"), name
);
1876 return extract_signed_integer (buf
, sizeof buf
, gdbarch_byte_order (gdbarch
));
1879 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1880 structure needed to determine the TLS index of an object file. */
1883 fbsd_fetch_rtld_offsets (struct gdbarch
*gdbarch
, struct fbsd_pspace_data
*data
)
1887 /* Fetch offsets from debug symbols in rtld. */
1888 struct symbol
*obj_entry_sym
1889 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL
, STRUCT_DOMAIN
,
1890 language_c
, NULL
).symbol
;
1891 if (obj_entry_sym
== NULL
)
1892 error (_("Unable to find Struct_Obj_Entry symbol"));
1893 data
->off_linkmap
= lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym
),
1894 "linkmap", 0).offset
/ 8;
1895 data
->off_tlsindex
= lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym
),
1896 "tlsindex", 0).offset
/ 8;
1897 data
->rtld_offsets_valid
= true;
1900 catch (const gdb_exception_error
&e
)
1902 data
->off_linkmap
= -1;
1907 /* Fetch offsets from global variables in libthr. Note that
1908 this does not work for single-threaded processes that are not
1909 linked against libthr. */
1910 data
->off_linkmap
= fbsd_read_integer_by_name (gdbarch
,
1911 "_thread_off_linkmap");
1912 data
->off_tlsindex
= fbsd_read_integer_by_name (gdbarch
,
1913 "_thread_off_tlsindex");
1914 data
->rtld_offsets_valid
= true;
1917 catch (const gdb_exception_error
&e
)
1919 data
->off_linkmap
= -1;
1923 /* Helper function to read the TLS index of an object file associated
1924 with a link map entry at LM_ADDR. */
1927 fbsd_get_tls_index (struct gdbarch
*gdbarch
, CORE_ADDR lm_addr
)
1929 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
1931 if (!data
->rtld_offsets_valid
)
1932 fbsd_fetch_rtld_offsets (gdbarch
, data
);
1934 if (data
->off_linkmap
== -1)
1935 throw_error (TLS_GENERIC_ERROR
,
1936 _("Cannot fetch runtime linker structure offsets"));
1938 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
1939 pointer and then compute the offset of the tlsindex member. */
1940 CORE_ADDR tlsindex_addr
= lm_addr
- data
->off_linkmap
+ data
->off_tlsindex
;
1943 if (target_read_memory (tlsindex_addr
, buf
, sizeof buf
) != 0)
1944 throw_error (TLS_GENERIC_ERROR
,
1945 _("Cannot find thread-local variables on this target"));
1947 return extract_signed_integer (buf
, sizeof buf
, gdbarch_byte_order (gdbarch
));
1950 /* See fbsd-tdep.h. */
1953 fbsd_get_thread_local_address (struct gdbarch
*gdbarch
, CORE_ADDR dtv_addr
,
1954 CORE_ADDR lm_addr
, CORE_ADDR offset
)
1956 LONGEST tls_index
= fbsd_get_tls_index (gdbarch
, lm_addr
);
1958 gdb_byte buf
[gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
];
1959 if (target_read_memory (dtv_addr
, buf
, sizeof buf
) != 0)
1960 throw_error (TLS_GENERIC_ERROR
,
1961 _("Cannot find thread-local variables on this target"));
1963 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1964 CORE_ADDR addr
= gdbarch_pointer_to_address (gdbarch
,
1965 builtin
->builtin_data_ptr
, buf
);
1967 addr
+= (tls_index
+ 1) * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1968 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
1969 throw_error (TLS_GENERIC_ERROR
,
1970 _("Cannot find thread-local variables on this target"));
1972 addr
= gdbarch_pointer_to_address (gdbarch
, builtin
->builtin_data_ptr
, buf
);
1973 return addr
+ offset
;
1976 /* See fbsd-tdep.h. */
1979 fbsd_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1981 struct bound_minimal_symbol msym
= lookup_bound_minimal_symbol ("_rtld_bind");
1982 if (msym
.minsym
!= nullptr && BMSYMBOL_VALUE_ADDRESS (msym
) == pc
)
1983 return frame_unwind_caller_pc (get_current_frame ());
1988 /* To be called from GDB_OSABI_FREEBSD handlers. */
1991 fbsd_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1993 set_gdbarch_core_pid_to_str (gdbarch
, fbsd_core_pid_to_str
);
1994 set_gdbarch_core_thread_name (gdbarch
, fbsd_core_thread_name
);
1995 set_gdbarch_core_xfer_siginfo (gdbarch
, fbsd_core_xfer_siginfo
);
1996 set_gdbarch_make_corefile_notes (gdbarch
, fbsd_make_corefile_notes
);
1997 set_gdbarch_core_info_proc (gdbarch
, fbsd_core_info_proc
);
1998 set_gdbarch_print_auxv_entry (gdbarch
, fbsd_print_auxv_entry
);
1999 set_gdbarch_get_siginfo_type (gdbarch
, fbsd_get_siginfo_type
);
2000 set_gdbarch_gdb_signal_from_target (gdbarch
, fbsd_gdb_signal_from_target
);
2001 set_gdbarch_gdb_signal_to_target (gdbarch
, fbsd_gdb_signal_to_target
);
2002 set_gdbarch_skip_solib_resolver (gdbarch
, fbsd_skip_solib_resolver
);
2004 /* `catch syscall' */
2005 set_xml_syscall_file_name (gdbarch
, "syscalls/freebsd.xml");
2006 set_gdbarch_get_syscall_number (gdbarch
, fbsd_get_syscall_number
);
2009 void _initialize_fbsd_tdep ();
2011 _initialize_fbsd_tdep ()
2013 fbsd_gdbarch_data_handle
=
2014 gdbarch_data_register_post_init (init_fbsd_gdbarch_data
);