1 /* Target-dependent code for FreeBSD, architecture-independent.
3 Copyright (C) 2002-2022 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 /* Constants for values of si_code as defined in FreeBSD's
81 #define FBSD_SI_USER 0x10001
82 #define FBSD_SI_QUEUE 0x10002
83 #define FBSD_SI_TIMER 0x10003
84 #define FBSD_SI_ASYNCIO 0x10004
85 #define FBSD_SI_MESGQ 0x10005
86 #define FBSD_SI_KERNEL 0x10006
87 #define FBSD_SI_LWP 0x10007
89 #define FBSD_ILL_ILLOPC 1
90 #define FBSD_ILL_ILLOPN 2
91 #define FBSD_ILL_ILLADR 3
92 #define FBSD_ILL_ILLTRP 4
93 #define FBSD_ILL_PRVOPC 5
94 #define FBSD_ILL_PRVREG 6
95 #define FBSD_ILL_COPROC 7
96 #define FBSD_ILL_BADSTK 8
98 #define FBSD_BUS_ADRALN 1
99 #define FBSD_BUS_ADRERR 2
100 #define FBSD_BUS_OBJERR 3
101 #define FBSD_BUS_OOMERR 100
103 #define FBSD_SEGV_MAPERR 1
104 #define FBSD_SEGV_ACCERR 2
105 #define FBSD_SEGV_PKUERR 100
107 #define FBSD_FPE_INTOVF 1
108 #define FBSD_FPE_INTDIV 2
109 #define FBSD_FPE_FLTDIV 3
110 #define FBSD_FPE_FLTOVF 4
111 #define FBSD_FPE_FLTUND 5
112 #define FBSD_FPE_FLTRES 6
113 #define FBSD_FPE_FLTINV 7
114 #define FBSD_FPE_FLTSUB 8
116 #define FBSD_TRAP_BRKPT 1
117 #define FBSD_TRAP_TRACE 2
118 #define FBSD_TRAP_DTRACE 3
119 #define FBSD_TRAP_CAP 4
121 #define FBSD_CLD_EXITED 1
122 #define FBSD_CLD_KILLED 2
123 #define FBSD_CLD_DUMPED 3
124 #define FBSD_CLD_TRAPPED 4
125 #define FBSD_CLD_STOPPED 5
126 #define FBSD_CLD_CONTINUED 6
128 #define FBSD_POLL_IN 1
129 #define FBSD_POLL_OUT 2
130 #define FBSD_POLL_MSG 3
131 #define FBSD_POLL_ERR 4
132 #define FBSD_POLL_PRI 5
133 #define FBSD_POLL_HUP 6
135 /* FreeBSD kernels 12.0 and later include a copy of the
136 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
137 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
138 The constants below define the offset of field members and flags in
139 this structure used by methods in this file. Note that the
140 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
141 containing the size of the structure. */
143 #define LWPINFO_OFFSET 0x4
145 /* Offsets in ptrace_lwpinfo. */
146 #define LWPINFO_PL_FLAGS 0x8
147 #define LWPINFO64_PL_SIGINFO 0x30
148 #define LWPINFO32_PL_SIGINFO 0x2c
150 /* Flags in pl_flags. */
151 #define PL_FLAG_SI 0x20 /* siginfo is valid */
153 /* Sizes of siginfo_t. */
154 #define SIZE64_SIGINFO_T 80
155 #define SIZE32_SIGINFO_T 64
157 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
158 dump notes. See <sys/user.h> for the definition of struct
159 kinfo_vmentry. This data structure should have the same layout on
162 Note that FreeBSD 7.0 used an older version of this structure
163 (struct kinfo_vmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core
164 dump note wasn't introduced until FreeBSD 9.2. As a result, the
165 core dump note has always used the 7.1 and later structure
168 #define KVE_STRUCTSIZE 0x0
169 #define KVE_START 0x8
171 #define KVE_OFFSET 0x18
172 #define KVE_FLAGS 0x2c
173 #define KVE_PROTECTION 0x38
174 #define KVE_PATH 0x88
176 /* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
177 match the KVME_PROT_* constants in <sys/user.h>. */
179 #define KINFO_VME_PROT_READ 0x00000001
180 #define KINFO_VME_PROT_WRITE 0x00000002
181 #define KINFO_VME_PROT_EXEC 0x00000004
183 /* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
184 match the KVME_FLAG_* constants in <sys/user.h>. */
186 #define KINFO_VME_FLAG_COW 0x00000001
187 #define KINFO_VME_FLAG_NEEDS_COPY 0x00000002
188 #define KINFO_VME_FLAG_NOCOREDUMP 0x00000004
189 #define KINFO_VME_FLAG_SUPER 0x00000008
190 #define KINFO_VME_FLAG_GROWS_UP 0x00000010
191 #define KINFO_VME_FLAG_GROWS_DOWN 0x00000020
193 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
194 dump notes. See <sys/user.h> for the definition of struct
195 kinfo_file. This data structure should have the same layout on all
198 Note that FreeBSD 7.0 used an older version of this structure
199 (struct kinfo_ofile), but the NT_FREEBSD_PROCSTAT_FILES core dump
200 note wasn't introduced until FreeBSD 9.2. As a result, the core
201 dump note has always used the 7.1 and later structure format. */
203 #define KF_STRUCTSIZE 0x0
206 #define KF_FLAGS 0x10
207 #define KF_OFFSET 0x18
208 #define KF_VNODE_TYPE 0x20
209 #define KF_SOCK_DOMAIN 0x24
210 #define KF_SOCK_TYPE 0x28
211 #define KF_SOCK_PROTOCOL 0x2c
212 #define KF_SA_LOCAL 0x30
213 #define KF_SA_PEER 0xb0
214 #define KF_PATH 0x170
216 /* Constants for the 'kf_type' field in struct kinfo_file. These
217 match the KF_TYPE_* constants in <sys/user.h>. */
219 #define KINFO_FILE_TYPE_VNODE 1
220 #define KINFO_FILE_TYPE_SOCKET 2
221 #define KINFO_FILE_TYPE_PIPE 3
222 #define KINFO_FILE_TYPE_FIFO 4
223 #define KINFO_FILE_TYPE_KQUEUE 5
224 #define KINFO_FILE_TYPE_CRYPTO 6
225 #define KINFO_FILE_TYPE_MQUEUE 7
226 #define KINFO_FILE_TYPE_SHM 8
227 #define KINFO_FILE_TYPE_SEM 9
228 #define KINFO_FILE_TYPE_PTS 10
229 #define KINFO_FILE_TYPE_PROCDESC 11
231 /* Special values for the 'kf_fd' field in struct kinfo_file. These
232 match the KF_FD_TYPE_* constants in <sys/user.h>. */
234 #define KINFO_FILE_FD_TYPE_CWD -1
235 #define KINFO_FILE_FD_TYPE_ROOT -2
236 #define KINFO_FILE_FD_TYPE_JAIL -3
237 #define KINFO_FILE_FD_TYPE_TRACE -4
238 #define KINFO_FILE_FD_TYPE_TEXT -5
239 #define KINFO_FILE_FD_TYPE_CTTY -6
241 /* Flags in the 'kf_flags' field in struct kinfo_file. These match
242 the KF_FLAG_* constants in <sys/user.h>. */
244 #define KINFO_FILE_FLAG_READ 0x00000001
245 #define KINFO_FILE_FLAG_WRITE 0x00000002
246 #define KINFO_FILE_FLAG_APPEND 0x00000004
247 #define KINFO_FILE_FLAG_ASYNC 0x00000008
248 #define KINFO_FILE_FLAG_FSYNC 0x00000010
249 #define KINFO_FILE_FLAG_NONBLOCK 0x00000020
250 #define KINFO_FILE_FLAG_DIRECT 0x00000040
251 #define KINFO_FILE_FLAG_HASLOCK 0x00000080
252 #define KINFO_FILE_FLAG_EXEC 0x00004000
254 /* Constants for the 'kf_vnode_type' field in struct kinfo_file.
255 These match the KF_VTYPE_* constants in <sys/user.h>. */
257 #define KINFO_FILE_VTYPE_VREG 1
258 #define KINFO_FILE_VTYPE_VDIR 2
259 #define KINFO_FILE_VTYPE_VCHR 4
260 #define KINFO_FILE_VTYPE_VLNK 5
261 #define KINFO_FILE_VTYPE_VSOCK 6
262 #define KINFO_FILE_VTYPE_VFIFO 7
264 /* Constants for socket address families. These match AF_* constants
265 in <sys/socket.h>. */
267 #define FBSD_AF_UNIX 1
268 #define FBSD_AF_INET 2
269 #define FBSD_AF_INET6 28
271 /* Constants for socket types. These match SOCK_* constants in
274 #define FBSD_SOCK_STREAM 1
275 #define FBSD_SOCK_DGRAM 2
276 #define FBSD_SOCK_SEQPACKET 5
278 /* Constants for IP protocols. These match IPPROTO_* constants in
281 #define FBSD_IPPROTO_ICMP 1
282 #define FBSD_IPPROTO_TCP 6
283 #define FBSD_IPPROTO_UDP 17
284 #define FBSD_IPPROTO_SCTP 132
286 /* Socket address structures. These have the same layout on all
287 FreeBSD architectures. In addition, multibyte fields such as IP
288 addresses are always stored in network byte order. */
290 struct fbsd_sockaddr_in
299 struct fbsd_sockaddr_in6
303 uint8_t sin6_port
[2];
304 uint32_t sin6_flowinfo
;
305 uint8_t sin6_addr
[16];
306 uint32_t sin6_scope_id
;
309 struct fbsd_sockaddr_un
316 /* Number of 32-bit words in a signal set. This matches _SIG_WORDS in
317 <sys/_sigset.h> and is the same value on all architectures. */
321 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
322 dump notes. See <sys/user.h> for the definition of struct
323 kinfo_proc. This data structure has different layouts on different
324 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386
325 uses a 32-bit time_t while all other architectures use a 64-bit
328 The core dump note actually contains one kinfo_proc structure for
329 each thread, but all of the process-wide data can be obtained from
330 the first structure. One result of this note's format is that some
331 of the process-wide status available in the native target method
332 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
333 is not available from a core dump. Instead, the per-thread data
334 structures contain the value of these fields for individual
337 struct kinfo_proc_layout
339 /* Offsets of struct kinfo_proc members. */
346 int ki_tdev_freebsd11
;
368 /* Offsets of struct rusage members. */
376 const struct kinfo_proc_layout kinfo_proc_layout_32
=
384 .ki_tdev_freebsd11
= 0x44,
385 .ki_sigignore
= 0x68,
404 .ki_rusage_ch
= 0x278,
413 const struct kinfo_proc_layout kinfo_proc_layout_i386
=
421 .ki_tdev_freebsd11
= 0x44,
422 .ki_sigignore
= 0x68,
441 .ki_rusage_ch
= 0x258,
450 const struct kinfo_proc_layout kinfo_proc_layout_64
=
458 .ki_tdev_freebsd11
= 0x64,
459 .ki_sigignore
= 0x88,
478 .ki_rusage_ch
= 0x2f0,
487 struct fbsd_gdbarch_data
489 struct type
*siginfo_type
= nullptr;
492 static const registry
<gdbarch
>::key
<fbsd_gdbarch_data
>
493 fbsd_gdbarch_data_handle
;
495 static struct fbsd_gdbarch_data
*
496 get_fbsd_gdbarch_data (struct gdbarch
*gdbarch
)
498 struct fbsd_gdbarch_data
*result
= fbsd_gdbarch_data_handle
.get (gdbarch
);
499 if (result
== nullptr)
500 result
= fbsd_gdbarch_data_handle
.emplace (gdbarch
);
504 struct fbsd_pspace_data
506 /* Offsets in the runtime linker's 'Obj_Entry' structure. */
507 LONGEST off_linkmap
= 0;
508 LONGEST off_tlsindex
= 0;
509 bool rtld_offsets_valid
= false;
511 /* vDSO mapping range. */
512 struct mem_range vdso_range
{};
514 /* Zero if the range hasn't been searched for, > 0 if a range was
515 found, or < 0 if a range was not found. */
516 int vdso_range_p
= 0;
519 /* Per-program-space data for FreeBSD architectures. */
520 static const registry
<program_space
>::key
<fbsd_pspace_data
>
521 fbsd_pspace_data_handle
;
523 static struct fbsd_pspace_data
*
524 get_fbsd_pspace_data (struct program_space
*pspace
)
526 struct fbsd_pspace_data
*data
;
528 data
= fbsd_pspace_data_handle
.get (pspace
);
530 data
= fbsd_pspace_data_handle
.emplace (pspace
);
535 /* This is how we want PTIDs from core files to be printed. */
538 fbsd_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
540 if (ptid
.lwp () != 0)
541 return string_printf ("LWP %ld", ptid
.lwp ());
543 return normal_pid_to_str (ptid
);
546 /* Extract the name assigned to a thread from a core. Returns the
547 string in a static buffer. */
550 fbsd_core_thread_name (struct gdbarch
*gdbarch
, struct thread_info
*thr
)
553 struct bfd_section
*section
;
556 if (thr
->ptid
.lwp () != 0)
558 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
559 whose contents are defined by a "struct thrmisc" declared in
560 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
561 a null-terminated string as the first member of the
562 structure. Rather than define the full structure here, just
563 extract the null-terminated name from the start of the
565 thread_section_name
section_name (".thrmisc", thr
->ptid
);
567 section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
568 if (section
!= NULL
&& bfd_section_size (section
) > 0)
570 /* Truncate the name if it is longer than "buf". */
571 size
= bfd_section_size (section
);
572 if (size
> sizeof buf
- 1)
573 size
= sizeof buf
- 1;
574 if (bfd_get_section_contents (core_bfd
, section
, buf
, (file_ptr
) 0,
580 /* Note that each thread will report the process command
581 as its thread name instead of an empty name if a name
582 has not been set explicitly. Return a NULL name in
584 if (strcmp (buf
, elf_tdata (core_bfd
)->core
->program
) != 0)
593 /* Implement the "core_xfer_siginfo" gdbarch method. */
596 fbsd_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
597 ULONGEST offset
, ULONGEST len
)
601 if (gdbarch_long_bit (gdbarch
) == 32)
602 siginfo_size
= SIZE32_SIGINFO_T
;
604 siginfo_size
= SIZE64_SIGINFO_T
;
605 if (offset
> siginfo_size
)
608 thread_section_name
section_name (".note.freebsdcore.lwpinfo", inferior_ptid
);
609 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
614 if (!bfd_get_section_contents (core_bfd
, section
, buf
,
615 LWPINFO_OFFSET
+ LWPINFO_PL_FLAGS
, 4))
618 int pl_flags
= extract_signed_integer (buf
, gdbarch_byte_order (gdbarch
));
619 if (!(pl_flags
& PL_FLAG_SI
))
622 if (offset
+ len
> siginfo_size
)
623 len
= siginfo_size
- offset
;
625 ULONGEST siginfo_offset
;
626 if (gdbarch_long_bit (gdbarch
) == 32)
627 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO32_PL_SIGINFO
;
629 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO64_PL_SIGINFO
;
631 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
632 siginfo_offset
+ offset
, len
))
639 find_signalled_thread (struct thread_info
*info
, void *data
)
641 if (info
->stop_signal () != GDB_SIGNAL_0
642 && info
->ptid
.pid () == inferior_ptid
.pid ())
648 /* Return a byte_vector containing the contents of a core dump note
649 for the target object of type OBJECT. If STRUCTSIZE is non-zero,
650 the data is prefixed with a 32-bit integer size to match the format
651 used in FreeBSD NT_PROCSTAT_* notes. */
653 static gdb::optional
<gdb::byte_vector
>
654 fbsd_make_note_desc (enum target_object object
, uint32_t structsize
)
656 gdb::optional
<gdb::byte_vector
> buf
=
657 target_read_alloc (current_inferior ()->top_target (), object
, NULL
);
658 if (!buf
|| buf
->empty ())
664 gdb::byte_vector
desc (sizeof (structsize
) + buf
->size ());
665 memcpy (desc
.data (), &structsize
, sizeof (structsize
));
666 memcpy (desc
.data () + sizeof (structsize
), buf
->data (), buf
->size ());
670 /* Create appropriate note sections for a corefile, returning them in
673 static gdb::unique_xmalloc_ptr
<char>
674 fbsd_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
676 gdb::unique_xmalloc_ptr
<char> note_data
;
677 Elf_Internal_Ehdr
*i_ehdrp
;
678 struct thread_info
*curr_thr
, *signalled_thr
;
680 /* Put a "FreeBSD" label in the ELF header. */
681 i_ehdrp
= elf_elfheader (obfd
);
682 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
684 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch
));
686 if (get_exec_file (0))
688 const char *fname
= lbasename (get_exec_file (0));
689 std::string psargs
= fname
;
691 const std::string
&infargs
= current_inferior ()->args ();
692 if (!infargs
.empty ())
693 psargs
+= ' ' + infargs
;
695 note_data
.reset (elfcore_write_prpsinfo (obfd
, note_data
.release (),
700 /* Thread register information. */
703 update_thread_list ();
705 catch (const gdb_exception_error
&e
)
707 exception_print (gdb_stderr
, e
);
710 /* Like the kernel, prefer dumping the signalled thread first.
711 "First thread" is what tools use to infer the signalled thread.
712 In case there's more than one signalled thread, prefer the
713 current thread, if it is signalled. */
714 curr_thr
= inferior_thread ();
715 if (curr_thr
->stop_signal () != GDB_SIGNAL_0
)
716 signalled_thr
= curr_thr
;
719 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
720 if (signalled_thr
== NULL
)
721 signalled_thr
= curr_thr
;
724 enum gdb_signal stop_signal
= signalled_thr
->stop_signal ();
725 gcore_elf_build_thread_register_notes (gdbarch
, signalled_thr
, stop_signal
,
726 obfd
, ¬e_data
, note_size
);
727 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
729 if (thr
== signalled_thr
)
732 gcore_elf_build_thread_register_notes (gdbarch
, thr
, stop_signal
,
733 obfd
, ¬e_data
, note_size
);
736 /* Auxiliary vector. */
737 uint32_t structsize
= gdbarch_ptr_bit (gdbarch
) / 4; /* Elf_Auxinfo */
738 gdb::optional
<gdb::byte_vector
> note_desc
=
739 fbsd_make_note_desc (TARGET_OBJECT_AUXV
, structsize
);
740 if (note_desc
&& !note_desc
->empty ())
742 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
743 note_size
, "FreeBSD",
744 NT_FREEBSD_PROCSTAT_AUXV
,
746 note_desc
->size ()));
751 /* Virtual memory mappings. */
752 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP
, 0);
753 if (note_desc
&& !note_desc
->empty ())
755 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
756 note_size
, "FreeBSD",
757 NT_FREEBSD_PROCSTAT_VMMAP
,
759 note_desc
->size ()));
764 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS
, 0);
765 if (note_desc
&& !note_desc
->empty ())
767 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (),
768 note_size
, "FreeBSD",
769 NT_FREEBSD_PROCSTAT_PSSTRINGS
,
771 note_desc
->size ()));
776 /* Include the target description when possible. */
777 gcore_elf_make_tdesc_note (obfd
, ¬e_data
, note_size
);
782 /* Helper function to generate the file descriptor description for a
783 single open file in 'info proc files'. */
786 fbsd_file_fd (int kf_fd
)
790 case KINFO_FILE_FD_TYPE_CWD
:
792 case KINFO_FILE_FD_TYPE_ROOT
:
794 case KINFO_FILE_FD_TYPE_JAIL
:
796 case KINFO_FILE_FD_TYPE_TRACE
:
798 case KINFO_FILE_FD_TYPE_TEXT
:
800 case KINFO_FILE_FD_TYPE_CTTY
:
803 return int_string (kf_fd
, 10, 1, 0, 0);
807 /* Helper function to generate the file type for a single open file in
808 'info proc files'. */
811 fbsd_file_type (int kf_type
, int kf_vnode_type
)
815 case KINFO_FILE_TYPE_VNODE
:
816 switch (kf_vnode_type
)
818 case KINFO_FILE_VTYPE_VREG
:
820 case KINFO_FILE_VTYPE_VDIR
:
822 case KINFO_FILE_VTYPE_VCHR
:
824 case KINFO_FILE_VTYPE_VLNK
:
826 case KINFO_FILE_VTYPE_VSOCK
:
828 case KINFO_FILE_VTYPE_VFIFO
:
832 char *str
= get_print_cell ();
834 xsnprintf (str
, PRINT_CELL_SIZE
, "vn:%d", kf_vnode_type
);
838 case KINFO_FILE_TYPE_SOCKET
:
840 case KINFO_FILE_TYPE_PIPE
:
842 case KINFO_FILE_TYPE_FIFO
:
844 case KINFO_FILE_TYPE_KQUEUE
:
846 case KINFO_FILE_TYPE_CRYPTO
:
848 case KINFO_FILE_TYPE_MQUEUE
:
850 case KINFO_FILE_TYPE_SHM
:
852 case KINFO_FILE_TYPE_SEM
:
854 case KINFO_FILE_TYPE_PTS
:
856 case KINFO_FILE_TYPE_PROCDESC
:
859 return int_string (kf_type
, 10, 1, 0, 0);
863 /* Helper function to generate the file flags for a single open file in
864 'info proc files'. */
867 fbsd_file_flags (int kf_flags
)
869 static char file_flags
[10];
871 file_flags
[0] = (kf_flags
& KINFO_FILE_FLAG_READ
) ? 'r' : '-';
872 file_flags
[1] = (kf_flags
& KINFO_FILE_FLAG_WRITE
) ? 'w' : '-';
873 file_flags
[2] = (kf_flags
& KINFO_FILE_FLAG_EXEC
) ? 'x' : '-';
874 file_flags
[3] = (kf_flags
& KINFO_FILE_FLAG_APPEND
) ? 'a' : '-';
875 file_flags
[4] = (kf_flags
& KINFO_FILE_FLAG_ASYNC
) ? 's' : '-';
876 file_flags
[5] = (kf_flags
& KINFO_FILE_FLAG_FSYNC
) ? 'f' : '-';
877 file_flags
[6] = (kf_flags
& KINFO_FILE_FLAG_NONBLOCK
) ? 'n' : '-';
878 file_flags
[7] = (kf_flags
& KINFO_FILE_FLAG_DIRECT
) ? 'd' : '-';
879 file_flags
[8] = (kf_flags
& KINFO_FILE_FLAG_HASLOCK
) ? 'l' : '-';
880 file_flags
[9] = '\0';
885 /* Helper function to generate the name of an IP protocol. */
888 fbsd_ipproto (int protocol
)
892 case FBSD_IPPROTO_ICMP
:
894 case FBSD_IPPROTO_TCP
:
896 case FBSD_IPPROTO_UDP
:
898 case FBSD_IPPROTO_SCTP
:
902 char *str
= get_print_cell ();
904 xsnprintf (str
, PRINT_CELL_SIZE
, "ip<%d>", protocol
);
910 /* Helper function to print out an IPv4 socket address. */
913 fbsd_print_sockaddr_in (const void *sockaddr
)
915 const struct fbsd_sockaddr_in
*sin
=
916 reinterpret_cast<const struct fbsd_sockaddr_in
*> (sockaddr
);
917 char buf
[INET_ADDRSTRLEN
];
919 if (inet_ntop (AF_INET
, sin
->sin_addr
, buf
, sizeof buf
) == nullptr)
920 error (_("Failed to format IPv4 address"));
921 gdb_printf ("%s:%u", buf
,
922 (sin
->sin_port
[0] << 8) | sin
->sin_port
[1]);
925 /* Helper function to print out an IPv6 socket address. */
928 fbsd_print_sockaddr_in6 (const void *sockaddr
)
930 const struct fbsd_sockaddr_in6
*sin6
=
931 reinterpret_cast<const struct fbsd_sockaddr_in6
*> (sockaddr
);
932 char buf
[INET6_ADDRSTRLEN
];
934 if (inet_ntop (AF_INET6
, sin6
->sin6_addr
, buf
, sizeof buf
) == nullptr)
935 error (_("Failed to format IPv6 address"));
936 gdb_printf ("%s.%u", buf
,
937 (sin6
->sin6_port
[0] << 8) | sin6
->sin6_port
[1]);
940 /* See fbsd-tdep.h. */
943 fbsd_info_proc_files_header ()
945 gdb_printf (_("Open files:\n\n"));
946 gdb_printf (" %6s %6s %10s %9s %s\n",
947 "FD", "Type", "Offset", "Flags ", "Name");
950 /* See fbsd-tdep.h. */
953 fbsd_info_proc_files_entry (int kf_type
, int kf_fd
, int kf_flags
,
954 LONGEST kf_offset
, int kf_vnode_type
,
955 int kf_sock_domain
, int kf_sock_type
,
956 int kf_sock_protocol
, const void *kf_sa_local
,
957 const void *kf_sa_peer
, const void *kf_path
)
959 gdb_printf (" %6s %6s %10s %8s ",
960 fbsd_file_fd (kf_fd
),
961 fbsd_file_type (kf_type
, kf_vnode_type
),
962 kf_offset
> -1 ? hex_string (kf_offset
) : "-",
963 fbsd_file_flags (kf_flags
));
964 if (kf_type
== KINFO_FILE_TYPE_SOCKET
)
966 switch (kf_sock_domain
)
970 switch (kf_sock_type
)
972 case FBSD_SOCK_STREAM
:
973 gdb_printf ("unix stream:");
975 case FBSD_SOCK_DGRAM
:
976 gdb_printf ("unix dgram:");
978 case FBSD_SOCK_SEQPACKET
:
979 gdb_printf ("unix seqpacket:");
982 gdb_printf ("unix <%d>:", kf_sock_type
);
986 /* For local sockets, print out the first non-nul path
987 rather than both paths. */
988 const struct fbsd_sockaddr_un
*saddr_un
989 = reinterpret_cast<const struct fbsd_sockaddr_un
*> (kf_sa_local
);
990 if (saddr_un
->sun_path
[0] == 0)
991 saddr_un
= reinterpret_cast<const struct fbsd_sockaddr_un
*>
993 gdb_printf ("%s", saddr_un
->sun_path
);
997 gdb_printf ("%s4 ", fbsd_ipproto (kf_sock_protocol
));
998 fbsd_print_sockaddr_in (kf_sa_local
);
1000 fbsd_print_sockaddr_in (kf_sa_peer
);
1003 gdb_printf ("%s6 ", fbsd_ipproto (kf_sock_protocol
));
1004 fbsd_print_sockaddr_in6 (kf_sa_local
);
1005 gdb_printf (" -> ");
1006 fbsd_print_sockaddr_in6 (kf_sa_peer
);
1011 gdb_printf ("%s", reinterpret_cast<const char *> (kf_path
));
1015 /* Implement "info proc files" for a corefile. */
1018 fbsd_core_info_proc_files (struct gdbarch
*gdbarch
)
1021 = bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1022 if (section
== NULL
)
1024 warning (_("unable to find open files in core file"));
1028 size_t note_size
= bfd_section_size (section
);
1030 error (_("malformed core note - too short for header"));
1032 gdb::def_vector
<unsigned char> contents (note_size
);
1033 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1035 error (_("could not get core note contents"));
1037 unsigned char *descdata
= contents
.data ();
1038 unsigned char *descend
= descdata
+ note_size
;
1040 /* Skip over the structure size. */
1043 fbsd_info_proc_files_header ();
1045 while (descdata
+ KF_PATH
< descend
)
1047 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1048 if (structsize
< KF_PATH
)
1049 error (_("malformed core note - file structure too small"));
1051 LONGEST type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_TYPE
);
1052 LONGEST fd
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
);
1053 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FLAGS
);
1054 LONGEST offset
= bfd_get_signed_64 (core_bfd
, descdata
+ KF_OFFSET
);
1055 LONGEST vnode_type
= bfd_get_signed_32 (core_bfd
,
1056 descdata
+ KF_VNODE_TYPE
);
1057 LONGEST sock_domain
= bfd_get_signed_32 (core_bfd
,
1058 descdata
+ KF_SOCK_DOMAIN
);
1059 LONGEST sock_type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_SOCK_TYPE
);
1060 LONGEST sock_protocol
= bfd_get_signed_32 (core_bfd
,
1061 descdata
+ KF_SOCK_PROTOCOL
);
1062 fbsd_info_proc_files_entry (type
, fd
, flags
, offset
, vnode_type
,
1063 sock_domain
, sock_type
, sock_protocol
,
1064 descdata
+ KF_SA_LOCAL
, descdata
+ KF_SA_PEER
,
1065 descdata
+ KF_PATH
);
1067 descdata
+= structsize
;
1071 /* Helper function to generate mappings flags for a single VM map
1072 entry in 'info proc mappings'. */
1075 fbsd_vm_map_entry_flags (int kve_flags
, int kve_protection
)
1077 static char vm_flags
[9];
1079 vm_flags
[0] = (kve_protection
& KINFO_VME_PROT_READ
) ? 'r' : '-';
1080 vm_flags
[1] = (kve_protection
& KINFO_VME_PROT_WRITE
) ? 'w' : '-';
1081 vm_flags
[2] = (kve_protection
& KINFO_VME_PROT_EXEC
) ? 'x' : '-';
1083 vm_flags
[4] = (kve_flags
& KINFO_VME_FLAG_COW
) ? 'C' : '-';
1084 vm_flags
[5] = (kve_flags
& KINFO_VME_FLAG_NEEDS_COPY
) ? 'N' : '-';
1085 vm_flags
[6] = (kve_flags
& KINFO_VME_FLAG_SUPER
) ? 'S' : '-';
1086 vm_flags
[7] = (kve_flags
& KINFO_VME_FLAG_GROWS_UP
) ? 'U'
1087 : (kve_flags
& KINFO_VME_FLAG_GROWS_DOWN
) ? 'D' : '-';
1093 /* See fbsd-tdep.h. */
1096 fbsd_info_proc_mappings_header (int addr_bit
)
1098 gdb_printf (_("Mapped address spaces:\n\n"));
1101 gdb_printf (" %18s %18s %10s %10s %9s %s\n",
1104 " Size", " Offset", "Flags ", "File");
1108 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
1111 " Size", " Offset", "Flags ", "File");
1115 /* See fbsd-tdep.h. */
1118 fbsd_info_proc_mappings_entry (int addr_bit
, ULONGEST kve_start
,
1119 ULONGEST kve_end
, ULONGEST kve_offset
,
1120 int kve_flags
, int kve_protection
,
1121 const void *kve_path
)
1125 gdb_printf (" %18s %18s %10s %10s %9s %s\n",
1126 hex_string (kve_start
),
1127 hex_string (kve_end
),
1128 hex_string (kve_end
- kve_start
),
1129 hex_string (kve_offset
),
1130 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1131 reinterpret_cast<const char *> (kve_path
));
1135 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
1136 hex_string (kve_start
),
1137 hex_string (kve_end
),
1138 hex_string (kve_end
- kve_start
),
1139 hex_string (kve_offset
),
1140 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1141 reinterpret_cast<const char *> (kve_path
));
1145 /* Implement "info proc mappings" for a corefile. */
1148 fbsd_core_info_proc_mappings (struct gdbarch
*gdbarch
)
1151 unsigned char *descdata
, *descend
;
1154 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.vmmap");
1155 if (section
== NULL
)
1157 warning (_("unable to find mappings in core file"));
1161 note_size
= bfd_section_size (section
);
1163 error (_("malformed core note - too short for header"));
1165 gdb::def_vector
<unsigned char> contents (note_size
);
1166 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1168 error (_("could not get core note contents"));
1170 descdata
= contents
.data ();
1171 descend
= descdata
+ note_size
;
1173 /* Skip over the structure size. */
1176 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch
));
1177 while (descdata
+ KVE_PATH
< descend
)
1179 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KVE_STRUCTSIZE
);
1180 if (structsize
< KVE_PATH
)
1181 error (_("malformed core note - vmmap entry too small"));
1183 ULONGEST start
= bfd_get_64 (core_bfd
, descdata
+ KVE_START
);
1184 ULONGEST end
= bfd_get_64 (core_bfd
, descdata
+ KVE_END
);
1185 ULONGEST offset
= bfd_get_64 (core_bfd
, descdata
+ KVE_OFFSET
);
1186 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_FLAGS
);
1187 LONGEST prot
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_PROTECTION
);
1188 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch
), start
, end
,
1189 offset
, flags
, prot
, descdata
+ KVE_PATH
);
1191 descdata
+= structsize
;
1195 /* Fetch the pathname of a vnode for a single file descriptor from the
1196 file table core note. */
1198 static gdb::unique_xmalloc_ptr
<char>
1199 fbsd_core_vnode_path (struct gdbarch
*gdbarch
, int fd
)
1202 unsigned char *descdata
, *descend
;
1205 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1206 if (section
== NULL
)
1209 note_size
= bfd_section_size (section
);
1211 error (_("malformed core note - too short for header"));
1213 gdb::def_vector
<unsigned char> contents (note_size
);
1214 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1216 error (_("could not get core note contents"));
1218 descdata
= contents
.data ();
1219 descend
= descdata
+ note_size
;
1221 /* Skip over the structure size. */
1224 while (descdata
+ KF_PATH
< descend
)
1226 ULONGEST structsize
;
1228 structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1229 if (structsize
< KF_PATH
)
1230 error (_("malformed core note - file structure too small"));
1232 if (bfd_get_32 (core_bfd
, descdata
+ KF_TYPE
) == KINFO_FILE_TYPE_VNODE
1233 && bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
) == fd
)
1235 char *path
= (char *) descdata
+ KF_PATH
;
1236 return make_unique_xstrdup (path
);
1239 descdata
+= structsize
;
1244 /* Helper function to read a struct timeval. */
1247 fbsd_core_fetch_timeval (struct gdbarch
*gdbarch
, unsigned char *data
,
1248 LONGEST
&sec
, ULONGEST
&usec
)
1250 if (gdbarch_addr_bit (gdbarch
) == 64)
1252 sec
= bfd_get_signed_64 (core_bfd
, data
);
1253 usec
= bfd_get_64 (core_bfd
, data
+ 8);
1255 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1257 sec
= bfd_get_signed_32 (core_bfd
, data
);
1258 usec
= bfd_get_32 (core_bfd
, data
+ 4);
1262 sec
= bfd_get_signed_64 (core_bfd
, data
);
1263 usec
= bfd_get_32 (core_bfd
, data
+ 8);
1267 /* Print out the contents of a signal set. */
1270 fbsd_print_sigset (const char *descr
, unsigned char *sigset
)
1272 gdb_printf ("%s: ", descr
);
1273 for (int i
= 0; i
< SIG_WORDS
; i
++)
1274 gdb_printf ("%08x ",
1275 (unsigned int) bfd_get_32 (core_bfd
, sigset
+ i
* 4));
1279 /* Implement "info proc status" for a corefile. */
1282 fbsd_core_info_proc_status (struct gdbarch
*gdbarch
)
1284 const struct kinfo_proc_layout
*kp
;
1286 unsigned char *descdata
;
1287 int addr_bit
, long_bit
;
1292 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.proc");
1293 if (section
== NULL
)
1295 warning (_("unable to find process info in core file"));
1299 addr_bit
= gdbarch_addr_bit (gdbarch
);
1301 kp
= &kinfo_proc_layout_64
;
1302 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1303 kp
= &kinfo_proc_layout_i386
;
1305 kp
= &kinfo_proc_layout_32
;
1306 long_bit
= gdbarch_long_bit (gdbarch
);
1309 * Ensure that the note is large enough for all of the fields fetched
1310 * by this function. In particular, the note must contain the 32-bit
1311 * structure size, then it must be long enough to access the last
1312 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1314 note_size
= bfd_section_size (section
);
1315 if (note_size
< (4 + kp
->ki_rusage_ch
+ kp
->ru_majflt
1316 + long_bit
/ TARGET_CHAR_BIT
))
1317 error (_("malformed core note - too short"));
1319 gdb::def_vector
<unsigned char> contents (note_size
);
1320 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1322 error (_("could not get core note contents"));
1324 descdata
= contents
.data ();
1326 /* Skip over the structure size. */
1329 /* Verify 'ki_layout' is 0. */
1330 if (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_layout
) != 0)
1332 warning (_("unsupported process information in core file"));
1336 gdb_printf ("Name: %.19s\n", descdata
+ kp
->ki_comm
);
1337 gdb_printf ("Process ID: %s\n",
1338 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pid
)));
1339 gdb_printf ("Parent process: %s\n",
1340 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ppid
)));
1341 gdb_printf ("Process group: %s\n",
1342 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pgid
)));
1343 gdb_printf ("Session id: %s\n",
1344 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_sid
)));
1346 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1347 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1348 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1349 the structure that is cleared to zero. Assume that a zero value
1350 in ki_tdev indicates a core dump from an older kernel and use the
1351 value in 'ki_tdev_freebsd11' instead. */
1352 value
= bfd_get_64 (core_bfd
, descdata
+ kp
->ki_tdev
);
1354 value
= bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tdev_freebsd11
);
1355 gdb_printf ("TTY: %s\n", pulongest (value
));
1356 gdb_printf ("TTY owner process group: %s\n",
1357 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tpgid
)));
1358 gdb_printf ("User IDs (real, effective, saved): %s %s %s\n",
1359 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ruid
)),
1360 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_uid
)),
1361 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svuid
)));
1362 gdb_printf ("Group IDs (real, effective, saved): %s %s %s\n",
1363 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_rgid
)),
1364 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_groups
)),
1365 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svgid
)));
1366 gdb_printf ("Groups: ");
1367 uint16_t ngroups
= bfd_get_16 (core_bfd
, descdata
+ kp
->ki_ngroups
);
1368 for (int i
= 0; i
< ngroups
; i
++)
1370 pulongest (bfd_get_32 (core_bfd
,
1371 descdata
+ kp
->ki_groups
+ i
* 4)));
1373 value
= bfd_get (long_bit
, core_bfd
,
1374 descdata
+ kp
->ki_rusage
+ kp
->ru_minflt
);
1375 gdb_printf ("Minor faults (no memory page): %s\n", pulongest (value
));
1376 value
= bfd_get (long_bit
, core_bfd
,
1377 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_minflt
);
1378 gdb_printf ("Minor faults, children: %s\n", pulongest (value
));
1379 value
= bfd_get (long_bit
, core_bfd
,
1380 descdata
+ kp
->ki_rusage
+ kp
->ru_majflt
);
1381 gdb_printf ("Major faults (memory page faults): %s\n",
1383 value
= bfd_get (long_bit
, core_bfd
,
1384 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_majflt
);
1385 gdb_printf ("Major faults, children: %s\n", pulongest (value
));
1386 fbsd_core_fetch_timeval (gdbarch
,
1387 descdata
+ kp
->ki_rusage
+ kp
->ru_utime
,
1389 gdb_printf ("utime: %s.%06d\n", plongest (sec
), (int) value
);
1390 fbsd_core_fetch_timeval (gdbarch
,
1391 descdata
+ kp
->ki_rusage
+ kp
->ru_stime
,
1393 gdb_printf ("stime: %s.%06d\n", plongest (sec
), (int) value
);
1394 fbsd_core_fetch_timeval (gdbarch
,
1395 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_utime
,
1397 gdb_printf ("utime, children: %s.%06d\n", plongest (sec
), (int) value
);
1398 fbsd_core_fetch_timeval (gdbarch
,
1399 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_stime
,
1401 gdb_printf ("stime, children: %s.%06d\n", plongest (sec
), (int) value
);
1402 gdb_printf ("'nice' value: %d\n",
1403 (int) bfd_get_signed_8 (core_bfd
, descdata
+ kp
->ki_nice
));
1404 fbsd_core_fetch_timeval (gdbarch
, descdata
+ kp
->ki_start
, sec
, value
);
1405 gdb_printf ("Start time: %s.%06d\n", plongest (sec
), (int) value
);
1406 gdb_printf ("Virtual memory size: %s kB\n",
1407 pulongest (bfd_get (addr_bit
, core_bfd
,
1408 descdata
+ kp
->ki_size
) / 1024));
1409 gdb_printf ("Data size: %s pages\n",
1410 pulongest (bfd_get (addr_bit
, core_bfd
,
1411 descdata
+ kp
->ki_dsize
)));
1412 gdb_printf ("Stack size: %s pages\n",
1413 pulongest (bfd_get (addr_bit
, core_bfd
,
1414 descdata
+ kp
->ki_ssize
)));
1415 gdb_printf ("Text size: %s pages\n",
1416 pulongest (bfd_get (addr_bit
, core_bfd
,
1417 descdata
+ kp
->ki_tsize
)));
1418 gdb_printf ("Resident set size: %s pages\n",
1419 pulongest (bfd_get (addr_bit
, core_bfd
,
1420 descdata
+ kp
->ki_rssize
)));
1421 gdb_printf ("Maximum RSS: %s pages\n",
1422 pulongest (bfd_get (long_bit
, core_bfd
,
1423 descdata
+ kp
->ki_rusage
1425 fbsd_print_sigset ("Ignored Signals", descdata
+ kp
->ki_sigignore
);
1426 fbsd_print_sigset ("Caught Signals", descdata
+ kp
->ki_sigcatch
);
1429 /* Implement the "core_info_proc" gdbarch method. */
1432 fbsd_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1433 enum info_proc_what what
)
1435 bool do_cmdline
= false;
1436 bool do_cwd
= false;
1437 bool do_exe
= false;
1438 bool do_files
= false;
1439 bool do_mappings
= false;
1440 bool do_status
= false;
1481 pid
= bfd_core_file_pid (core_bfd
);
1483 gdb_printf (_("process %d\n"), pid
);
1487 const char *cmdline
;
1489 cmdline
= bfd_core_file_failing_command (core_bfd
);
1491 gdb_printf ("cmdline = '%s'\n", cmdline
);
1493 warning (_("Command line unavailable"));
1497 gdb::unique_xmalloc_ptr
<char> cwd
=
1498 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_CWD
);
1500 gdb_printf ("cwd = '%s'\n", cwd
.get ());
1502 warning (_("unable to read current working directory"));
1506 gdb::unique_xmalloc_ptr
<char> exe
=
1507 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_TEXT
);
1509 gdb_printf ("exe = '%s'\n", exe
.get ());
1511 warning (_("unable to read executable path name"));
1514 fbsd_core_info_proc_files (gdbarch
);
1516 fbsd_core_info_proc_mappings (gdbarch
);
1518 fbsd_core_info_proc_status (gdbarch
);
1521 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1524 fbsd_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1525 CORE_ADDR type
, CORE_ADDR val
)
1527 const char *name
= "???";
1528 const char *description
= "";
1529 enum auxv_format format
= AUXV_FORMAT_HEX
;
1548 default_print_auxv_entry (gdbarch
, file
, type
, val
);
1550 #define _TAGNAME(tag) #tag
1551 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1552 #define TAG(tag, text, kind) \
1553 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1554 TAG (EXECPATH
, _("Executable path"), AUXV_FORMAT_STR
);
1555 TAG (CANARY
, _("Canary for SSP"), AUXV_FORMAT_HEX
);
1556 TAG (CANARYLEN
, ("Length of the SSP canary"), AUXV_FORMAT_DEC
);
1557 TAG (OSRELDATE
, _("OSRELDATE"), AUXV_FORMAT_DEC
);
1558 TAG (NCPUS
, _("Number of CPUs"), AUXV_FORMAT_DEC
);
1559 TAG (PAGESIZES
, _("Pagesizes"), AUXV_FORMAT_HEX
);
1560 TAG (PAGESIZESLEN
, _("Number of pagesizes"), AUXV_FORMAT_DEC
);
1561 TAG (TIMEKEEP
, _("Pointer to timehands"), AUXV_FORMAT_HEX
);
1562 TAG (STACKPROT
, _("Initial stack protection"), AUXV_FORMAT_HEX
);
1563 TAG (EHDRFLAGS
, _("ELF header e_flags"), AUXV_FORMAT_HEX
);
1564 TAG (HWCAP
, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX
);
1565 TAG (HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
1566 TAG (BSDFLAGS
, _("ELF BSD flags"), AUXV_FORMAT_HEX
);
1567 TAG (ARGC
, _("Argument count"), AUXV_FORMAT_DEC
);
1568 TAG (ARGV
, _("Argument vector"), AUXV_FORMAT_HEX
);
1569 TAG (ENVC
, _("Environment count"), AUXV_FORMAT_DEC
);
1570 TAG (ENVV
, _("Environment vector"), AUXV_FORMAT_HEX
);
1571 TAG (PS_STRINGS
, _("Pointer to ps_strings"), AUXV_FORMAT_HEX
);
1572 TAG (FXRNG
, _("Pointer to root RNG seed version"), AUXV_FORMAT_HEX
);
1573 TAG (KPRELOAD
, _("Base address of vDSO"), AUXV_FORMAT_HEX
);
1576 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
1579 /* Implement the "get_siginfo_type" gdbarch method. */
1581 static struct type
*
1582 fbsd_get_siginfo_type (struct gdbarch
*gdbarch
)
1584 struct fbsd_gdbarch_data
*fbsd_gdbarch_data
;
1585 struct type
*int_type
, *int32_type
, *uint32_type
, *long_type
, *void_ptr_type
;
1586 struct type
*uid_type
, *pid_type
;
1587 struct type
*sigval_type
, *reason_type
;
1588 struct type
*siginfo_type
;
1591 fbsd_gdbarch_data
= get_fbsd_gdbarch_data (gdbarch
);
1592 if (fbsd_gdbarch_data
->siginfo_type
!= NULL
)
1593 return fbsd_gdbarch_data
->siginfo_type
;
1595 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
1597 int32_type
= arch_integer_type (gdbarch
, 32, 0, "int32_t");
1598 uint32_type
= arch_integer_type (gdbarch
, 32, 1, "uint32_t");
1599 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
1601 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
1604 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1605 sigval_type
->set_name (xstrdup ("sigval"));
1606 append_composite_type_field (sigval_type
, "sival_int", int_type
);
1607 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
1610 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1611 TYPE_LENGTH (int32_type
) * TARGET_CHAR_BIT
, "__pid_t");
1612 TYPE_TARGET_TYPE (pid_type
) = int32_type
;
1613 pid_type
->set_target_is_stub (true);
1616 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1617 TYPE_LENGTH (uint32_type
) * TARGET_CHAR_BIT
,
1619 TYPE_TARGET_TYPE (uid_type
) = uint32_type
;
1620 pid_type
->set_target_is_stub (true);
1623 reason_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1626 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1627 append_composite_type_field (type
, "si_trapno", int_type
);
1628 append_composite_type_field (reason_type
, "_fault", type
);
1631 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1632 append_composite_type_field (type
, "si_timerid", int_type
);
1633 append_composite_type_field (type
, "si_overrun", int_type
);
1634 append_composite_type_field (reason_type
, "_timer", type
);
1637 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1638 append_composite_type_field (type
, "si_mqd", int_type
);
1639 append_composite_type_field (reason_type
, "_mesgq", type
);
1642 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1643 append_composite_type_field (type
, "si_band", long_type
);
1644 append_composite_type_field (reason_type
, "_poll", type
);
1647 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1648 append_composite_type_field (type
, "__spare1__", long_type
);
1649 append_composite_type_field (type
, "__spare2__",
1650 init_vector_type (int_type
, 7));
1651 append_composite_type_field (reason_type
, "__spare__", type
);
1653 /* struct siginfo */
1654 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1655 siginfo_type
->set_name (xstrdup ("siginfo"));
1656 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
1657 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
1658 append_composite_type_field (siginfo_type
, "si_code", int_type
);
1659 append_composite_type_field (siginfo_type
, "si_pid", pid_type
);
1660 append_composite_type_field (siginfo_type
, "si_uid", uid_type
);
1661 append_composite_type_field (siginfo_type
, "si_status", int_type
);
1662 append_composite_type_field (siginfo_type
, "si_addr", void_ptr_type
);
1663 append_composite_type_field (siginfo_type
, "si_value", sigval_type
);
1664 append_composite_type_field (siginfo_type
, "_reason", reason_type
);
1666 fbsd_gdbarch_data
->siginfo_type
= siginfo_type
;
1668 return siginfo_type
;
1671 /* Implement the "gdb_signal_from_target" gdbarch method. */
1673 static enum gdb_signal
1674 fbsd_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1679 return GDB_SIGNAL_0
;
1681 case FREEBSD_SIGHUP
:
1682 return GDB_SIGNAL_HUP
;
1684 case FREEBSD_SIGINT
:
1685 return GDB_SIGNAL_INT
;
1687 case FREEBSD_SIGQUIT
:
1688 return GDB_SIGNAL_QUIT
;
1690 case FREEBSD_SIGILL
:
1691 return GDB_SIGNAL_ILL
;
1693 case FREEBSD_SIGTRAP
:
1694 return GDB_SIGNAL_TRAP
;
1696 case FREEBSD_SIGABRT
:
1697 return GDB_SIGNAL_ABRT
;
1699 case FREEBSD_SIGEMT
:
1700 return GDB_SIGNAL_EMT
;
1702 case FREEBSD_SIGFPE
:
1703 return GDB_SIGNAL_FPE
;
1705 case FREEBSD_SIGKILL
:
1706 return GDB_SIGNAL_KILL
;
1708 case FREEBSD_SIGBUS
:
1709 return GDB_SIGNAL_BUS
;
1711 case FREEBSD_SIGSEGV
:
1712 return GDB_SIGNAL_SEGV
;
1714 case FREEBSD_SIGSYS
:
1715 return GDB_SIGNAL_SYS
;
1717 case FREEBSD_SIGPIPE
:
1718 return GDB_SIGNAL_PIPE
;
1720 case FREEBSD_SIGALRM
:
1721 return GDB_SIGNAL_ALRM
;
1723 case FREEBSD_SIGTERM
:
1724 return GDB_SIGNAL_TERM
;
1726 case FREEBSD_SIGURG
:
1727 return GDB_SIGNAL_URG
;
1729 case FREEBSD_SIGSTOP
:
1730 return GDB_SIGNAL_STOP
;
1732 case FREEBSD_SIGTSTP
:
1733 return GDB_SIGNAL_TSTP
;
1735 case FREEBSD_SIGCONT
:
1736 return GDB_SIGNAL_CONT
;
1738 case FREEBSD_SIGCHLD
:
1739 return GDB_SIGNAL_CHLD
;
1741 case FREEBSD_SIGTTIN
:
1742 return GDB_SIGNAL_TTIN
;
1744 case FREEBSD_SIGTTOU
:
1745 return GDB_SIGNAL_TTOU
;
1748 return GDB_SIGNAL_IO
;
1750 case FREEBSD_SIGXCPU
:
1751 return GDB_SIGNAL_XCPU
;
1753 case FREEBSD_SIGXFSZ
:
1754 return GDB_SIGNAL_XFSZ
;
1756 case FREEBSD_SIGVTALRM
:
1757 return GDB_SIGNAL_VTALRM
;
1759 case FREEBSD_SIGPROF
:
1760 return GDB_SIGNAL_PROF
;
1762 case FREEBSD_SIGWINCH
:
1763 return GDB_SIGNAL_WINCH
;
1765 case FREEBSD_SIGINFO
:
1766 return GDB_SIGNAL_INFO
;
1768 case FREEBSD_SIGUSR1
:
1769 return GDB_SIGNAL_USR1
;
1771 case FREEBSD_SIGUSR2
:
1772 return GDB_SIGNAL_USR2
;
1774 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1775 case FREEBSD_SIGTHR
:
1776 return GDB_SIGNAL_LWP
;
1778 case FREEBSD_SIGLIBRT
:
1779 return GDB_SIGNAL_LIBRT
;
1782 if (signal
>= FREEBSD_SIGRTMIN
&& signal
<= FREEBSD_SIGRTMAX
)
1784 int offset
= signal
- FREEBSD_SIGRTMIN
;
1786 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_65
+ offset
);
1789 return GDB_SIGNAL_UNKNOWN
;
1792 /* Implement the "gdb_signal_to_target" gdbarch method. */
1795 fbsd_gdb_signal_to_target (struct gdbarch
*gdbarch
,
1796 enum gdb_signal signal
)
1803 case GDB_SIGNAL_HUP
:
1804 return FREEBSD_SIGHUP
;
1806 case GDB_SIGNAL_INT
:
1807 return FREEBSD_SIGINT
;
1809 case GDB_SIGNAL_QUIT
:
1810 return FREEBSD_SIGQUIT
;
1812 case GDB_SIGNAL_ILL
:
1813 return FREEBSD_SIGILL
;
1815 case GDB_SIGNAL_TRAP
:
1816 return FREEBSD_SIGTRAP
;
1818 case GDB_SIGNAL_ABRT
:
1819 return FREEBSD_SIGABRT
;
1821 case GDB_SIGNAL_EMT
:
1822 return FREEBSD_SIGEMT
;
1824 case GDB_SIGNAL_FPE
:
1825 return FREEBSD_SIGFPE
;
1827 case GDB_SIGNAL_KILL
:
1828 return FREEBSD_SIGKILL
;
1830 case GDB_SIGNAL_BUS
:
1831 return FREEBSD_SIGBUS
;
1833 case GDB_SIGNAL_SEGV
:
1834 return FREEBSD_SIGSEGV
;
1836 case GDB_SIGNAL_SYS
:
1837 return FREEBSD_SIGSYS
;
1839 case GDB_SIGNAL_PIPE
:
1840 return FREEBSD_SIGPIPE
;
1842 case GDB_SIGNAL_ALRM
:
1843 return FREEBSD_SIGALRM
;
1845 case GDB_SIGNAL_TERM
:
1846 return FREEBSD_SIGTERM
;
1848 case GDB_SIGNAL_URG
:
1849 return FREEBSD_SIGURG
;
1851 case GDB_SIGNAL_STOP
:
1852 return FREEBSD_SIGSTOP
;
1854 case GDB_SIGNAL_TSTP
:
1855 return FREEBSD_SIGTSTP
;
1857 case GDB_SIGNAL_CONT
:
1858 return FREEBSD_SIGCONT
;
1860 case GDB_SIGNAL_CHLD
:
1861 return FREEBSD_SIGCHLD
;
1863 case GDB_SIGNAL_TTIN
:
1864 return FREEBSD_SIGTTIN
;
1866 case GDB_SIGNAL_TTOU
:
1867 return FREEBSD_SIGTTOU
;
1870 return FREEBSD_SIGIO
;
1872 case GDB_SIGNAL_XCPU
:
1873 return FREEBSD_SIGXCPU
;
1875 case GDB_SIGNAL_XFSZ
:
1876 return FREEBSD_SIGXFSZ
;
1878 case GDB_SIGNAL_VTALRM
:
1879 return FREEBSD_SIGVTALRM
;
1881 case GDB_SIGNAL_PROF
:
1882 return FREEBSD_SIGPROF
;
1884 case GDB_SIGNAL_WINCH
:
1885 return FREEBSD_SIGWINCH
;
1887 case GDB_SIGNAL_INFO
:
1888 return FREEBSD_SIGINFO
;
1890 case GDB_SIGNAL_USR1
:
1891 return FREEBSD_SIGUSR1
;
1893 case GDB_SIGNAL_USR2
:
1894 return FREEBSD_SIGUSR2
;
1896 case GDB_SIGNAL_LWP
:
1897 return FREEBSD_SIGTHR
;
1899 case GDB_SIGNAL_LIBRT
:
1900 return FREEBSD_SIGLIBRT
;
1903 if (signal
>= GDB_SIGNAL_REALTIME_65
1904 && signal
<= GDB_SIGNAL_REALTIME_126
)
1906 int offset
= signal
- GDB_SIGNAL_REALTIME_65
;
1908 return FREEBSD_SIGRTMIN
+ offset
;
1914 /* Implement the "get_syscall_number" gdbarch method. */
1917 fbsd_get_syscall_number (struct gdbarch
*gdbarch
, thread_info
*thread
)
1920 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1921 native targets fetch the system call number from the
1922 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1923 However, system call catching requires this function to be
1926 internal_error (__FILE__
, __LINE__
, _("fbsd_get_sycall_number called"));
1929 /* Read an integer symbol value from the current target. */
1932 fbsd_read_integer_by_name (struct gdbarch
*gdbarch
, const char *name
)
1934 bound_minimal_symbol ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1935 if (ms
.minsym
== NULL
)
1936 error (_("Unable to resolve symbol '%s'"), name
);
1939 if (target_read_memory (ms
.value_address (), buf
, sizeof buf
) != 0)
1940 error (_("Unable to read value of '%s'"), name
);
1942 return extract_signed_integer (buf
, gdbarch_byte_order (gdbarch
));
1945 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1946 structure needed to determine the TLS index of an object file. */
1949 fbsd_fetch_rtld_offsets (struct gdbarch
*gdbarch
, struct fbsd_pspace_data
*data
)
1953 /* Fetch offsets from debug symbols in rtld. */
1954 struct symbol
*obj_entry_sym
1955 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL
, STRUCT_DOMAIN
,
1956 language_c
, NULL
).symbol
;
1957 if (obj_entry_sym
== NULL
)
1958 error (_("Unable to find Struct_Obj_Entry symbol"));
1959 data
->off_linkmap
= lookup_struct_elt (obj_entry_sym
->type (),
1960 "linkmap", 0).offset
/ 8;
1961 data
->off_tlsindex
= lookup_struct_elt (obj_entry_sym
->type (),
1962 "tlsindex", 0).offset
/ 8;
1963 data
->rtld_offsets_valid
= true;
1966 catch (const gdb_exception_error
&e
)
1968 data
->off_linkmap
= -1;
1973 /* Fetch offsets from global variables in libthr. Note that
1974 this does not work for single-threaded processes that are not
1975 linked against libthr. */
1976 data
->off_linkmap
= fbsd_read_integer_by_name (gdbarch
,
1977 "_thread_off_linkmap");
1978 data
->off_tlsindex
= fbsd_read_integer_by_name (gdbarch
,
1979 "_thread_off_tlsindex");
1980 data
->rtld_offsets_valid
= true;
1983 catch (const gdb_exception_error
&e
)
1985 data
->off_linkmap
= -1;
1989 /* Helper function to read the TLS index of an object file associated
1990 with a link map entry at LM_ADDR. */
1993 fbsd_get_tls_index (struct gdbarch
*gdbarch
, CORE_ADDR lm_addr
)
1995 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
1997 if (!data
->rtld_offsets_valid
)
1998 fbsd_fetch_rtld_offsets (gdbarch
, data
);
2000 if (data
->off_linkmap
== -1)
2001 throw_error (TLS_GENERIC_ERROR
,
2002 _("Cannot fetch runtime linker structure offsets"));
2004 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2005 pointer and then compute the offset of the tlsindex member. */
2006 CORE_ADDR tlsindex_addr
= lm_addr
- data
->off_linkmap
+ data
->off_tlsindex
;
2009 if (target_read_memory (tlsindex_addr
, buf
, sizeof buf
) != 0)
2010 throw_error (TLS_GENERIC_ERROR
,
2011 _("Cannot find thread-local variables on this target"));
2013 return extract_signed_integer (buf
, gdbarch_byte_order (gdbarch
));
2016 /* See fbsd-tdep.h. */
2019 fbsd_get_thread_local_address (struct gdbarch
*gdbarch
, CORE_ADDR dtv_addr
,
2020 CORE_ADDR lm_addr
, CORE_ADDR offset
)
2022 LONGEST tls_index
= fbsd_get_tls_index (gdbarch
, lm_addr
);
2024 gdb_byte buf
[gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
];
2025 if (target_read_memory (dtv_addr
, buf
, sizeof buf
) != 0)
2026 throw_error (TLS_GENERIC_ERROR
,
2027 _("Cannot find thread-local variables on this target"));
2029 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
2030 CORE_ADDR addr
= gdbarch_pointer_to_address (gdbarch
,
2031 builtin
->builtin_data_ptr
, buf
);
2033 addr
+= (tls_index
+ 1) * TYPE_LENGTH (builtin
->builtin_data_ptr
);
2034 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
2035 throw_error (TLS_GENERIC_ERROR
,
2036 _("Cannot find thread-local variables on this target"));
2038 addr
= gdbarch_pointer_to_address (gdbarch
, builtin
->builtin_data_ptr
, buf
);
2039 return addr
+ offset
;
2042 /* See fbsd-tdep.h. */
2045 fbsd_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2047 struct bound_minimal_symbol msym
= lookup_bound_minimal_symbol ("_rtld_bind");
2048 if (msym
.minsym
!= nullptr && msym
.value_address () == pc
)
2049 return frame_unwind_caller_pc (get_current_frame ());
2054 /* Return description of signal code or nullptr. */
2057 fbsd_signal_cause (enum gdb_signal siggnal
, int code
)
2059 /* Signal-independent causes. */
2063 return _("Sent by kill()");
2065 return _("Sent by sigqueue()");
2067 return _("Timer expired");
2068 case FBSD_SI_ASYNCIO
:
2069 return _("Asynchronous I/O request completed");
2071 return _("Message arrived on empty message queue");
2072 case FBSD_SI_KERNEL
:
2073 return _("Sent by kernel");
2075 return _("Sent by thr_kill()");
2080 case GDB_SIGNAL_ILL
:
2083 case FBSD_ILL_ILLOPC
:
2084 return _("Illegal opcode");
2085 case FBSD_ILL_ILLOPN
:
2086 return _("Illegal operand");
2087 case FBSD_ILL_ILLADR
:
2088 return _("Illegal addressing mode");
2089 case FBSD_ILL_ILLTRP
:
2090 return _("Illegal trap");
2091 case FBSD_ILL_PRVOPC
:
2092 return _("Privileged opcode");
2093 case FBSD_ILL_PRVREG
:
2094 return _("Privileged register");
2095 case FBSD_ILL_COPROC
:
2096 return _("Coprocessor error");
2097 case FBSD_ILL_BADSTK
:
2098 return _("Internal stack error");
2101 case GDB_SIGNAL_BUS
:
2104 case FBSD_BUS_ADRALN
:
2105 return _("Invalid address alignment");
2106 case FBSD_BUS_ADRERR
:
2107 return _("Address not present");
2108 case FBSD_BUS_OBJERR
:
2109 return _("Object-specific hardware error");
2110 case FBSD_BUS_OOMERR
:
2111 return _("Out of memory");
2114 case GDB_SIGNAL_SEGV
:
2117 case FBSD_SEGV_MAPERR
:
2118 return _("Address not mapped to object");
2119 case FBSD_SEGV_ACCERR
:
2120 return _("Invalid permissions for mapped object");
2121 case FBSD_SEGV_PKUERR
:
2122 return _("PKU violation");
2125 case GDB_SIGNAL_FPE
:
2128 case FBSD_FPE_INTOVF
:
2129 return _("Integer overflow");
2130 case FBSD_FPE_INTDIV
:
2131 return _("Integer divide by zero");
2132 case FBSD_FPE_FLTDIV
:
2133 return _("Floating point divide by zero");
2134 case FBSD_FPE_FLTOVF
:
2135 return _("Floating point overflow");
2136 case FBSD_FPE_FLTUND
:
2137 return _("Floating point underflow");
2138 case FBSD_FPE_FLTRES
:
2139 return _("Floating point inexact result");
2140 case FBSD_FPE_FLTINV
:
2141 return _("Invalid floating point operation");
2142 case FBSD_FPE_FLTSUB
:
2143 return _("Subscript out of range");
2146 case GDB_SIGNAL_TRAP
:
2149 case FBSD_TRAP_BRKPT
:
2150 return _("Breakpoint");
2151 case FBSD_TRAP_TRACE
:
2152 return _("Trace trap");
2153 case FBSD_TRAP_DTRACE
:
2154 return _("DTrace-induced trap");
2156 return _("Capability violation");
2159 case GDB_SIGNAL_CHLD
:
2162 case FBSD_CLD_EXITED
:
2163 return _("Child has exited");
2164 case FBSD_CLD_KILLED
:
2165 return _("Child has terminated abnormally");
2166 case FBSD_CLD_DUMPED
:
2167 return _("Child has dumped core");
2168 case FBSD_CLD_TRAPPED
:
2169 return _("Traced child has trapped");
2170 case FBSD_CLD_STOPPED
:
2171 return _("Child has stopped");
2172 case FBSD_CLD_CONTINUED
:
2173 return _("Stopped child has continued");
2176 case GDB_SIGNAL_POLL
:
2180 return _("Data input available");
2182 return _("Output buffers available");
2184 return _("Input message available");
2186 return _("I/O error");
2188 return _("High priority input available");
2190 return _("Device disconnected");
2198 /* Report additional details for a signal stop. */
2201 fbsd_report_signal_info (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
2202 enum gdb_signal siggnal
)
2204 LONGEST code
, mqd
, pid
, status
, timerid
, uid
;
2208 code
= parse_and_eval_long ("$_siginfo.si_code");
2209 pid
= parse_and_eval_long ("$_siginfo.si_pid");
2210 uid
= parse_and_eval_long ("$_siginfo.si_uid");
2211 status
= parse_and_eval_long ("$_siginfo.si_status");
2212 timerid
= parse_and_eval_long ("$_siginfo._reason._timer.si_timerid");
2213 mqd
= parse_and_eval_long ("$_siginfo._reason._mesgq.si_mqd");
2215 catch (const gdb_exception_error
&e
)
2220 const char *meaning
= fbsd_signal_cause (siggnal
, code
);
2221 if (meaning
== nullptr)
2224 uiout
->text (".\n");
2225 uiout
->field_string ("sigcode-meaning", meaning
);
2232 uiout
->text (" from pid ");
2233 uiout
->field_string ("sending-pid", plongest (pid
));
2234 uiout
->text (" and user ");
2235 uiout
->field_string ("sending-uid", plongest (uid
));
2238 uiout
->text (": timerid ");
2239 uiout
->field_string ("timerid", plongest (timerid
));
2242 uiout
->text (": message queue ");
2243 uiout
->field_string ("message-queue", plongest (mqd
));
2245 case FBSD_SI_ASYNCIO
:
2249 if (siggnal
== GDB_SIGNAL_CHLD
)
2251 uiout
->text (": pid ");
2252 uiout
->field_string ("child-pid", plongest (pid
));
2253 uiout
->text (", uid ");
2254 uiout
->field_string ("child-uid", plongest (uid
));
2255 if (code
== FBSD_CLD_EXITED
)
2257 uiout
->text (", exit status ");
2258 uiout
->field_string ("exit-status", plongest (status
));
2262 uiout
->text (", signal ");
2263 uiout
->field_string ("signal", plongest (status
));
2268 /* Search a list of struct kinfo_vmmap entries in the ENTRIES buffer
2269 of LEN bytes to find the length of the entry starting at ADDR.
2270 Returns the length of the entry or zero if no entry was found. */
2273 fbsd_vmmap_length (struct gdbarch
*gdbarch
, unsigned char *entries
, size_t len
,
2276 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2277 unsigned char *descdata
= entries
;
2278 unsigned char *descend
= descdata
+ len
;
2280 /* Skip over the structure size. */
2283 while (descdata
+ KVE_PATH
< descend
)
2285 ULONGEST structsize
= extract_unsigned_integer (descdata
2286 + KVE_STRUCTSIZE
, 4,
2288 if (structsize
< KVE_PATH
)
2291 ULONGEST start
= extract_unsigned_integer (descdata
+ KVE_START
, 8,
2293 ULONGEST end
= extract_unsigned_integer (descdata
+ KVE_END
, 8,
2298 descdata
+= structsize
;
2303 /* Helper for fbsd_vsyscall_range that does the real work of finding
2304 the vDSO's address range. */
2307 fbsd_vdso_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2309 struct target_ops
*ops
= current_inferior ()->top_target ();
2311 if (target_auxv_search (ops
, AT_FREEBSD_KPRELOAD
, &range
->start
) <= 0)
2314 if (!target_has_execution ())
2316 /* Search for the ending address in the NT_PROCSTAT_VMMAP note. */
2317 asection
*section
= bfd_get_section_by_name (core_bfd
,
2318 ".note.freebsdcore.vmmap");
2319 if (section
== nullptr)
2322 size_t note_size
= bfd_section_size (section
);
2326 gdb::def_vector
<unsigned char> contents (note_size
);
2327 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
2331 range
->length
= fbsd_vmmap_length (gdbarch
, contents
.data (), note_size
,
2336 /* Fetch the list of address space entries from the running target. */
2337 gdb::optional
<gdb::byte_vector
> buf
=
2338 target_read_alloc (ops
, TARGET_OBJECT_FREEBSD_VMMAP
, nullptr);
2339 if (!buf
|| buf
->empty ())
2342 range
->length
= fbsd_vmmap_length (gdbarch
, buf
->data (), buf
->size (),
2345 return range
->length
!= 0;
2348 /* Return the address range of the vDSO for the current inferior. */
2351 fbsd_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2353 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
2355 if (data
->vdso_range_p
== 0)
2357 if (fbsd_vdso_range (gdbarch
, &data
->vdso_range
))
2358 data
->vdso_range_p
= 1;
2360 data
->vdso_range_p
= -1;
2363 if (data
->vdso_range_p
< 0)
2366 *range
= data
->vdso_range
;
2370 /* To be called from GDB_OSABI_FREEBSD handlers. */
2373 fbsd_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2375 set_gdbarch_core_pid_to_str (gdbarch
, fbsd_core_pid_to_str
);
2376 set_gdbarch_core_thread_name (gdbarch
, fbsd_core_thread_name
);
2377 set_gdbarch_core_xfer_siginfo (gdbarch
, fbsd_core_xfer_siginfo
);
2378 set_gdbarch_make_corefile_notes (gdbarch
, fbsd_make_corefile_notes
);
2379 set_gdbarch_core_info_proc (gdbarch
, fbsd_core_info_proc
);
2380 set_gdbarch_print_auxv_entry (gdbarch
, fbsd_print_auxv_entry
);
2381 set_gdbarch_get_siginfo_type (gdbarch
, fbsd_get_siginfo_type
);
2382 set_gdbarch_gdb_signal_from_target (gdbarch
, fbsd_gdb_signal_from_target
);
2383 set_gdbarch_gdb_signal_to_target (gdbarch
, fbsd_gdb_signal_to_target
);
2384 set_gdbarch_report_signal_info (gdbarch
, fbsd_report_signal_info
);
2385 set_gdbarch_skip_solib_resolver (gdbarch
, fbsd_skip_solib_resolver
);
2386 set_gdbarch_vsyscall_range (gdbarch
, fbsd_vsyscall_range
);
2388 /* `catch syscall' */
2389 set_xml_syscall_file_name (gdbarch
, "syscalls/freebsd.xml");
2390 set_gdbarch_get_syscall_number (gdbarch
, fbsd_get_syscall_number
);