1 /* Target-dependent code for FreeBSD, architecture-independent.
3 Copyright (C) 2002-2024 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 std::optional
<gdb::byte_vector
>
654 fbsd_make_note_desc (enum target_object object
, uint32_t structsize
)
656 std::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 std::copy (buf
->begin (), buf
->end (), desc
.data () + sizeof (structsize
));
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 std::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. Some architectures
777 allow for per-thread gdbarch so we should really be emitting a tdesc
778 per-thread, however, we don't currently support reading in a
779 per-thread tdesc, so just emit the tdesc for the signalled thread. */
780 gdbarch
= target_thread_architecture (signalled_thr
->ptid
);
781 gcore_elf_make_tdesc_note (gdbarch
, obfd
, ¬e_data
, note_size
);
786 /* Helper function to generate the file descriptor description for a
787 single open file in 'info proc files'. */
790 fbsd_file_fd (int kf_fd
)
794 case KINFO_FILE_FD_TYPE_CWD
:
796 case KINFO_FILE_FD_TYPE_ROOT
:
798 case KINFO_FILE_FD_TYPE_JAIL
:
800 case KINFO_FILE_FD_TYPE_TRACE
:
802 case KINFO_FILE_FD_TYPE_TEXT
:
804 case KINFO_FILE_FD_TYPE_CTTY
:
807 return int_string (kf_fd
, 10, 1, 0, 0);
811 /* Helper function to generate the file type for a single open file in
812 'info proc files'. */
815 fbsd_file_type (int kf_type
, int kf_vnode_type
)
819 case KINFO_FILE_TYPE_VNODE
:
820 switch (kf_vnode_type
)
822 case KINFO_FILE_VTYPE_VREG
:
824 case KINFO_FILE_VTYPE_VDIR
:
826 case KINFO_FILE_VTYPE_VCHR
:
828 case KINFO_FILE_VTYPE_VLNK
:
830 case KINFO_FILE_VTYPE_VSOCK
:
832 case KINFO_FILE_VTYPE_VFIFO
:
836 char *str
= get_print_cell ();
838 xsnprintf (str
, PRINT_CELL_SIZE
, "vn:%d", kf_vnode_type
);
842 case KINFO_FILE_TYPE_SOCKET
:
844 case KINFO_FILE_TYPE_PIPE
:
846 case KINFO_FILE_TYPE_FIFO
:
848 case KINFO_FILE_TYPE_KQUEUE
:
850 case KINFO_FILE_TYPE_CRYPTO
:
852 case KINFO_FILE_TYPE_MQUEUE
:
854 case KINFO_FILE_TYPE_SHM
:
856 case KINFO_FILE_TYPE_SEM
:
858 case KINFO_FILE_TYPE_PTS
:
860 case KINFO_FILE_TYPE_PROCDESC
:
863 return int_string (kf_type
, 10, 1, 0, 0);
867 /* Helper function to generate the file flags for a single open file in
868 'info proc files'. */
871 fbsd_file_flags (int kf_flags
)
873 static char file_flags
[10];
875 file_flags
[0] = (kf_flags
& KINFO_FILE_FLAG_READ
) ? 'r' : '-';
876 file_flags
[1] = (kf_flags
& KINFO_FILE_FLAG_WRITE
) ? 'w' : '-';
877 file_flags
[2] = (kf_flags
& KINFO_FILE_FLAG_EXEC
) ? 'x' : '-';
878 file_flags
[3] = (kf_flags
& KINFO_FILE_FLAG_APPEND
) ? 'a' : '-';
879 file_flags
[4] = (kf_flags
& KINFO_FILE_FLAG_ASYNC
) ? 's' : '-';
880 file_flags
[5] = (kf_flags
& KINFO_FILE_FLAG_FSYNC
) ? 'f' : '-';
881 file_flags
[6] = (kf_flags
& KINFO_FILE_FLAG_NONBLOCK
) ? 'n' : '-';
882 file_flags
[7] = (kf_flags
& KINFO_FILE_FLAG_DIRECT
) ? 'd' : '-';
883 file_flags
[8] = (kf_flags
& KINFO_FILE_FLAG_HASLOCK
) ? 'l' : '-';
884 file_flags
[9] = '\0';
889 /* Helper function to generate the name of an IP protocol. */
892 fbsd_ipproto (int protocol
)
896 case FBSD_IPPROTO_ICMP
:
898 case FBSD_IPPROTO_TCP
:
900 case FBSD_IPPROTO_UDP
:
902 case FBSD_IPPROTO_SCTP
:
906 char *str
= get_print_cell ();
908 xsnprintf (str
, PRINT_CELL_SIZE
, "ip<%d>", protocol
);
914 /* Helper function to print out an IPv4 socket address. */
917 fbsd_print_sockaddr_in (const void *sockaddr
)
919 const struct fbsd_sockaddr_in
*sin
=
920 reinterpret_cast<const struct fbsd_sockaddr_in
*> (sockaddr
);
921 char buf
[INET_ADDRSTRLEN
];
923 if (inet_ntop (AF_INET
, sin
->sin_addr
, buf
, sizeof buf
) == nullptr)
924 error (_("Failed to format IPv4 address"));
925 gdb_printf ("%s:%u", buf
,
926 (sin
->sin_port
[0] << 8) | sin
->sin_port
[1]);
929 /* Helper function to print out an IPv6 socket address. */
932 fbsd_print_sockaddr_in6 (const void *sockaddr
)
934 const struct fbsd_sockaddr_in6
*sin6
=
935 reinterpret_cast<const struct fbsd_sockaddr_in6
*> (sockaddr
);
936 char buf
[INET6_ADDRSTRLEN
];
938 if (inet_ntop (AF_INET6
, sin6
->sin6_addr
, buf
, sizeof buf
) == nullptr)
939 error (_("Failed to format IPv6 address"));
940 gdb_printf ("%s.%u", buf
,
941 (sin6
->sin6_port
[0] << 8) | sin6
->sin6_port
[1]);
944 /* See fbsd-tdep.h. */
947 fbsd_info_proc_files_header ()
949 gdb_printf (_("Open files:\n\n"));
950 gdb_printf (" %6s %6s %10s %9s %s\n",
951 "FD", "Type", "Offset", "Flags ", "Name");
954 /* See fbsd-tdep.h. */
957 fbsd_info_proc_files_entry (int kf_type
, int kf_fd
, int kf_flags
,
958 LONGEST kf_offset
, int kf_vnode_type
,
959 int kf_sock_domain
, int kf_sock_type
,
960 int kf_sock_protocol
, const void *kf_sa_local
,
961 const void *kf_sa_peer
, const void *kf_path
)
963 gdb_printf (" %6s %6s %10s %8s ",
964 fbsd_file_fd (kf_fd
),
965 fbsd_file_type (kf_type
, kf_vnode_type
),
966 kf_offset
> -1 ? hex_string (kf_offset
) : "-",
967 fbsd_file_flags (kf_flags
));
968 if (kf_type
== KINFO_FILE_TYPE_SOCKET
)
970 switch (kf_sock_domain
)
974 switch (kf_sock_type
)
976 case FBSD_SOCK_STREAM
:
977 gdb_printf ("unix stream:");
979 case FBSD_SOCK_DGRAM
:
980 gdb_printf ("unix dgram:");
982 case FBSD_SOCK_SEQPACKET
:
983 gdb_printf ("unix seqpacket:");
986 gdb_printf ("unix <%d>:", kf_sock_type
);
990 /* For local sockets, print out the first non-nul path
991 rather than both paths. */
992 const struct fbsd_sockaddr_un
*saddr_un
993 = reinterpret_cast<const struct fbsd_sockaddr_un
*> (kf_sa_local
);
994 if (saddr_un
->sun_path
[0] == 0)
995 saddr_un
= reinterpret_cast<const struct fbsd_sockaddr_un
*>
997 gdb_printf ("%s", saddr_un
->sun_path
);
1001 gdb_printf ("%s4 ", fbsd_ipproto (kf_sock_protocol
));
1002 fbsd_print_sockaddr_in (kf_sa_local
);
1003 gdb_printf (" -> ");
1004 fbsd_print_sockaddr_in (kf_sa_peer
);
1007 gdb_printf ("%s6 ", fbsd_ipproto (kf_sock_protocol
));
1008 fbsd_print_sockaddr_in6 (kf_sa_local
);
1009 gdb_printf (" -> ");
1010 fbsd_print_sockaddr_in6 (kf_sa_peer
);
1015 gdb_printf ("%s", reinterpret_cast<const char *> (kf_path
));
1019 /* Implement "info proc files" for a corefile. */
1022 fbsd_core_info_proc_files (struct gdbarch
*gdbarch
)
1025 = bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1026 if (section
== NULL
)
1028 warning (_("unable to find open files in core file"));
1032 size_t note_size
= bfd_section_size (section
);
1034 error (_("malformed core note - too short for header"));
1036 gdb::def_vector
<unsigned char> contents (note_size
);
1037 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1039 error (_("could not get core note contents"));
1041 unsigned char *descdata
= contents
.data ();
1042 unsigned char *descend
= descdata
+ note_size
;
1044 /* Skip over the structure size. */
1047 fbsd_info_proc_files_header ();
1049 while (descdata
+ KF_PATH
< descend
)
1051 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1052 if (structsize
< KF_PATH
)
1053 error (_("malformed core note - file structure too small"));
1055 LONGEST type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_TYPE
);
1056 LONGEST fd
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
);
1057 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FLAGS
);
1058 LONGEST offset
= bfd_get_signed_64 (core_bfd
, descdata
+ KF_OFFSET
);
1059 LONGEST vnode_type
= bfd_get_signed_32 (core_bfd
,
1060 descdata
+ KF_VNODE_TYPE
);
1061 LONGEST sock_domain
= bfd_get_signed_32 (core_bfd
,
1062 descdata
+ KF_SOCK_DOMAIN
);
1063 LONGEST sock_type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_SOCK_TYPE
);
1064 LONGEST sock_protocol
= bfd_get_signed_32 (core_bfd
,
1065 descdata
+ KF_SOCK_PROTOCOL
);
1066 fbsd_info_proc_files_entry (type
, fd
, flags
, offset
, vnode_type
,
1067 sock_domain
, sock_type
, sock_protocol
,
1068 descdata
+ KF_SA_LOCAL
, descdata
+ KF_SA_PEER
,
1069 descdata
+ KF_PATH
);
1071 descdata
+= structsize
;
1075 /* Helper function to generate mappings flags for a single VM map
1076 entry in 'info proc mappings'. */
1079 fbsd_vm_map_entry_flags (int kve_flags
, int kve_protection
)
1081 static char vm_flags
[9];
1083 vm_flags
[0] = (kve_protection
& KINFO_VME_PROT_READ
) ? 'r' : '-';
1084 vm_flags
[1] = (kve_protection
& KINFO_VME_PROT_WRITE
) ? 'w' : '-';
1085 vm_flags
[2] = (kve_protection
& KINFO_VME_PROT_EXEC
) ? 'x' : '-';
1087 vm_flags
[4] = (kve_flags
& KINFO_VME_FLAG_COW
) ? 'C' : '-';
1088 vm_flags
[5] = (kve_flags
& KINFO_VME_FLAG_NEEDS_COPY
) ? 'N' : '-';
1089 vm_flags
[6] = (kve_flags
& KINFO_VME_FLAG_SUPER
) ? 'S' : '-';
1090 vm_flags
[7] = (kve_flags
& KINFO_VME_FLAG_GROWS_UP
) ? 'U'
1091 : (kve_flags
& KINFO_VME_FLAG_GROWS_DOWN
) ? 'D' : '-';
1097 /* See fbsd-tdep.h. */
1100 fbsd_info_proc_mappings_header (int addr_bit
)
1102 gdb_printf (_("Mapped address spaces:\n\n"));
1105 gdb_printf (" %18s %18s %10s %10s %9s %s\n",
1108 " Size", " Offset", "Flags ", "File");
1112 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
1115 " Size", " Offset", "Flags ", "File");
1119 /* See fbsd-tdep.h. */
1122 fbsd_info_proc_mappings_entry (int addr_bit
, ULONGEST kve_start
,
1123 ULONGEST kve_end
, ULONGEST kve_offset
,
1124 int kve_flags
, int kve_protection
,
1125 const void *kve_path
)
1129 gdb_printf (" %18s %18s %10s %10s %9s %s\n",
1130 hex_string (kve_start
),
1131 hex_string (kve_end
),
1132 hex_string (kve_end
- kve_start
),
1133 hex_string (kve_offset
),
1134 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1135 reinterpret_cast<const char *> (kve_path
));
1139 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n",
1140 hex_string (kve_start
),
1141 hex_string (kve_end
),
1142 hex_string (kve_end
- kve_start
),
1143 hex_string (kve_offset
),
1144 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1145 reinterpret_cast<const char *> (kve_path
));
1149 /* Implement "info proc mappings" for a corefile. */
1152 fbsd_core_info_proc_mappings (struct gdbarch
*gdbarch
)
1155 unsigned char *descdata
, *descend
;
1158 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.vmmap");
1159 if (section
== NULL
)
1161 warning (_("unable to find mappings in core file"));
1165 note_size
= bfd_section_size (section
);
1167 error (_("malformed core note - too short for header"));
1169 gdb::def_vector
<unsigned char> contents (note_size
);
1170 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1172 error (_("could not get core note contents"));
1174 descdata
= contents
.data ();
1175 descend
= descdata
+ note_size
;
1177 /* Skip over the structure size. */
1180 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch
));
1181 while (descdata
+ KVE_PATH
< descend
)
1183 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KVE_STRUCTSIZE
);
1184 if (structsize
< KVE_PATH
)
1185 error (_("malformed core note - vmmap entry too small"));
1187 ULONGEST start
= bfd_get_64 (core_bfd
, descdata
+ KVE_START
);
1188 ULONGEST end
= bfd_get_64 (core_bfd
, descdata
+ KVE_END
);
1189 ULONGEST offset
= bfd_get_64 (core_bfd
, descdata
+ KVE_OFFSET
);
1190 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_FLAGS
);
1191 LONGEST prot
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_PROTECTION
);
1192 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch
), start
, end
,
1193 offset
, flags
, prot
, descdata
+ KVE_PATH
);
1195 descdata
+= structsize
;
1199 /* Fetch the pathname of a vnode for a single file descriptor from the
1200 file table core note. */
1202 static gdb::unique_xmalloc_ptr
<char>
1203 fbsd_core_vnode_path (struct gdbarch
*gdbarch
, int fd
)
1206 unsigned char *descdata
, *descend
;
1209 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1210 if (section
== NULL
)
1213 note_size
= bfd_section_size (section
);
1215 error (_("malformed core note - too short for header"));
1217 gdb::def_vector
<unsigned char> contents (note_size
);
1218 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1220 error (_("could not get core note contents"));
1222 descdata
= contents
.data ();
1223 descend
= descdata
+ note_size
;
1225 /* Skip over the structure size. */
1228 while (descdata
+ KF_PATH
< descend
)
1230 ULONGEST structsize
;
1232 structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1233 if (structsize
< KF_PATH
)
1234 error (_("malformed core note - file structure too small"));
1236 if (bfd_get_32 (core_bfd
, descdata
+ KF_TYPE
) == KINFO_FILE_TYPE_VNODE
1237 && bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
) == fd
)
1239 char *path
= (char *) descdata
+ KF_PATH
;
1240 return make_unique_xstrdup (path
);
1243 descdata
+= structsize
;
1248 /* Helper function to read a struct timeval. */
1251 fbsd_core_fetch_timeval (struct gdbarch
*gdbarch
, unsigned char *data
,
1252 LONGEST
&sec
, ULONGEST
&usec
)
1254 if (gdbarch_addr_bit (gdbarch
) == 64)
1256 sec
= bfd_get_signed_64 (core_bfd
, data
);
1257 usec
= bfd_get_64 (core_bfd
, data
+ 8);
1259 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1261 sec
= bfd_get_signed_32 (core_bfd
, data
);
1262 usec
= bfd_get_32 (core_bfd
, data
+ 4);
1266 sec
= bfd_get_signed_64 (core_bfd
, data
);
1267 usec
= bfd_get_32 (core_bfd
, data
+ 8);
1271 /* Print out the contents of a signal set. */
1274 fbsd_print_sigset (const char *descr
, unsigned char *sigset
)
1276 gdb_printf ("%s: ", descr
);
1277 for (int i
= 0; i
< SIG_WORDS
; i
++)
1278 gdb_printf ("%08x ",
1279 (unsigned int) bfd_get_32 (core_bfd
, sigset
+ i
* 4));
1283 /* Implement "info proc status" for a corefile. */
1286 fbsd_core_info_proc_status (struct gdbarch
*gdbarch
)
1288 const struct kinfo_proc_layout
*kp
;
1290 unsigned char *descdata
;
1291 int addr_bit
, long_bit
;
1296 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.proc");
1297 if (section
== NULL
)
1299 warning (_("unable to find process info in core file"));
1303 addr_bit
= gdbarch_addr_bit (gdbarch
);
1305 kp
= &kinfo_proc_layout_64
;
1306 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1307 kp
= &kinfo_proc_layout_i386
;
1309 kp
= &kinfo_proc_layout_32
;
1310 long_bit
= gdbarch_long_bit (gdbarch
);
1313 * Ensure that the note is large enough for all of the fields fetched
1314 * by this function. In particular, the note must contain the 32-bit
1315 * structure size, then it must be long enough to access the last
1316 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1318 note_size
= bfd_section_size (section
);
1319 if (note_size
< (4 + kp
->ki_rusage_ch
+ kp
->ru_majflt
1320 + long_bit
/ TARGET_CHAR_BIT
))
1321 error (_("malformed core note - too short"));
1323 gdb::def_vector
<unsigned char> contents (note_size
);
1324 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1326 error (_("could not get core note contents"));
1328 descdata
= contents
.data ();
1330 /* Skip over the structure size. */
1333 /* Verify 'ki_layout' is 0. */
1334 if (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_layout
) != 0)
1336 warning (_("unsupported process information in core file"));
1340 gdb_printf ("Name: %.19s\n", descdata
+ kp
->ki_comm
);
1341 gdb_printf ("Process ID: %s\n",
1342 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pid
)));
1343 gdb_printf ("Parent process: %s\n",
1344 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ppid
)));
1345 gdb_printf ("Process group: %s\n",
1346 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pgid
)));
1347 gdb_printf ("Session id: %s\n",
1348 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_sid
)));
1350 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1351 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1352 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1353 the structure that is cleared to zero. Assume that a zero value
1354 in ki_tdev indicates a core dump from an older kernel and use the
1355 value in 'ki_tdev_freebsd11' instead. */
1356 value
= bfd_get_64 (core_bfd
, descdata
+ kp
->ki_tdev
);
1358 value
= bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tdev_freebsd11
);
1359 gdb_printf ("TTY: %s\n", pulongest (value
));
1360 gdb_printf ("TTY owner process group: %s\n",
1361 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tpgid
)));
1362 gdb_printf ("User IDs (real, effective, saved): %s %s %s\n",
1363 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ruid
)),
1364 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_uid
)),
1365 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svuid
)));
1366 gdb_printf ("Group IDs (real, effective, saved): %s %s %s\n",
1367 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_rgid
)),
1368 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_groups
)),
1369 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svgid
)));
1370 gdb_printf ("Groups: ");
1371 uint16_t ngroups
= bfd_get_16 (core_bfd
, descdata
+ kp
->ki_ngroups
);
1372 for (int i
= 0; i
< ngroups
; i
++)
1374 pulongest (bfd_get_32 (core_bfd
,
1375 descdata
+ kp
->ki_groups
+ i
* 4)));
1377 value
= bfd_get (long_bit
, core_bfd
,
1378 descdata
+ kp
->ki_rusage
+ kp
->ru_minflt
);
1379 gdb_printf ("Minor faults (no memory page): %s\n", pulongest (value
));
1380 value
= bfd_get (long_bit
, core_bfd
,
1381 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_minflt
);
1382 gdb_printf ("Minor faults, children: %s\n", pulongest (value
));
1383 value
= bfd_get (long_bit
, core_bfd
,
1384 descdata
+ kp
->ki_rusage
+ kp
->ru_majflt
);
1385 gdb_printf ("Major faults (memory page faults): %s\n",
1387 value
= bfd_get (long_bit
, core_bfd
,
1388 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_majflt
);
1389 gdb_printf ("Major faults, children: %s\n", pulongest (value
));
1390 fbsd_core_fetch_timeval (gdbarch
,
1391 descdata
+ kp
->ki_rusage
+ kp
->ru_utime
,
1393 gdb_printf ("utime: %s.%06d\n", plongest (sec
), (int) value
);
1394 fbsd_core_fetch_timeval (gdbarch
,
1395 descdata
+ kp
->ki_rusage
+ kp
->ru_stime
,
1397 gdb_printf ("stime: %s.%06d\n", plongest (sec
), (int) value
);
1398 fbsd_core_fetch_timeval (gdbarch
,
1399 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_utime
,
1401 gdb_printf ("utime, children: %s.%06d\n", plongest (sec
), (int) value
);
1402 fbsd_core_fetch_timeval (gdbarch
,
1403 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_stime
,
1405 gdb_printf ("stime, children: %s.%06d\n", plongest (sec
), (int) value
);
1406 gdb_printf ("'nice' value: %d\n",
1407 (int) bfd_get_signed_8 (core_bfd
, descdata
+ kp
->ki_nice
));
1408 fbsd_core_fetch_timeval (gdbarch
, descdata
+ kp
->ki_start
, sec
, value
);
1409 gdb_printf ("Start time: %s.%06d\n", plongest (sec
), (int) value
);
1410 gdb_printf ("Virtual memory size: %s kB\n",
1411 pulongest (bfd_get (addr_bit
, core_bfd
,
1412 descdata
+ kp
->ki_size
) / 1024));
1413 gdb_printf ("Data size: %s pages\n",
1414 pulongest (bfd_get (addr_bit
, core_bfd
,
1415 descdata
+ kp
->ki_dsize
)));
1416 gdb_printf ("Stack size: %s pages\n",
1417 pulongest (bfd_get (addr_bit
, core_bfd
,
1418 descdata
+ kp
->ki_ssize
)));
1419 gdb_printf ("Text size: %s pages\n",
1420 pulongest (bfd_get (addr_bit
, core_bfd
,
1421 descdata
+ kp
->ki_tsize
)));
1422 gdb_printf ("Resident set size: %s pages\n",
1423 pulongest (bfd_get (addr_bit
, core_bfd
,
1424 descdata
+ kp
->ki_rssize
)));
1425 gdb_printf ("Maximum RSS: %s pages\n",
1426 pulongest (bfd_get (long_bit
, core_bfd
,
1427 descdata
+ kp
->ki_rusage
1429 fbsd_print_sigset ("Ignored Signals", descdata
+ kp
->ki_sigignore
);
1430 fbsd_print_sigset ("Caught Signals", descdata
+ kp
->ki_sigcatch
);
1433 /* Implement the "core_info_proc" gdbarch method. */
1436 fbsd_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1437 enum info_proc_what what
)
1439 bool do_cmdline
= false;
1440 bool do_cwd
= false;
1441 bool do_exe
= false;
1442 bool do_files
= false;
1443 bool do_mappings
= false;
1444 bool do_status
= false;
1485 pid
= bfd_core_file_pid (core_bfd
);
1487 gdb_printf (_("process %d\n"), pid
);
1491 const char *cmdline
;
1493 cmdline
= bfd_core_file_failing_command (core_bfd
);
1495 gdb_printf ("cmdline = '%s'\n", cmdline
);
1497 warning (_("Command line unavailable"));
1501 gdb::unique_xmalloc_ptr
<char> cwd
=
1502 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_CWD
);
1504 gdb_printf ("cwd = '%s'\n", cwd
.get ());
1506 warning (_("unable to read current working directory"));
1510 gdb::unique_xmalloc_ptr
<char> exe
=
1511 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_TEXT
);
1513 gdb_printf ("exe = '%s'\n", exe
.get ());
1515 warning (_("unable to read executable path name"));
1518 fbsd_core_info_proc_files (gdbarch
);
1520 fbsd_core_info_proc_mappings (gdbarch
);
1522 fbsd_core_info_proc_status (gdbarch
);
1525 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1528 fbsd_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1529 CORE_ADDR type
, CORE_ADDR val
)
1531 const char *name
= "???";
1532 const char *description
= "";
1533 enum auxv_format format
= AUXV_FORMAT_HEX
;
1552 default_print_auxv_entry (gdbarch
, file
, type
, val
);
1554 #define _TAGNAME(tag) #tag
1555 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1556 #define TAG(tag, text, kind) \
1557 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1558 TAG (EXECPATH
, _("Executable path"), AUXV_FORMAT_STR
);
1559 TAG (CANARY
, _("Canary for SSP"), AUXV_FORMAT_HEX
);
1560 TAG (CANARYLEN
, ("Length of the SSP canary"), AUXV_FORMAT_DEC
);
1561 TAG (OSRELDATE
, _("OSRELDATE"), AUXV_FORMAT_DEC
);
1562 TAG (NCPUS
, _("Number of CPUs"), AUXV_FORMAT_DEC
);
1563 TAG (PAGESIZES
, _("Pagesizes"), AUXV_FORMAT_HEX
);
1564 TAG (PAGESIZESLEN
, _("Number of pagesizes"), AUXV_FORMAT_DEC
);
1565 TAG (TIMEKEEP
, _("Pointer to timehands"), AUXV_FORMAT_HEX
);
1566 TAG (STACKPROT
, _("Initial stack protection"), AUXV_FORMAT_HEX
);
1567 TAG (EHDRFLAGS
, _("ELF header e_flags"), AUXV_FORMAT_HEX
);
1568 TAG (HWCAP
, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX
);
1569 TAG (HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
1570 TAG (BSDFLAGS
, _("ELF BSD flags"), AUXV_FORMAT_HEX
);
1571 TAG (ARGC
, _("Argument count"), AUXV_FORMAT_DEC
);
1572 TAG (ARGV
, _("Argument vector"), AUXV_FORMAT_HEX
);
1573 TAG (ENVC
, _("Environment count"), AUXV_FORMAT_DEC
);
1574 TAG (ENVV
, _("Environment vector"), AUXV_FORMAT_HEX
);
1575 TAG (PS_STRINGS
, _("Pointer to ps_strings"), AUXV_FORMAT_HEX
);
1576 TAG (FXRNG
, _("Pointer to root RNG seed version"), AUXV_FORMAT_HEX
);
1577 TAG (KPRELOAD
, _("Base address of vDSO"), AUXV_FORMAT_HEX
);
1578 TAG (USRSTACKBASE
, _("Top of user stack"), AUXV_FORMAT_HEX
);
1579 TAG (USRSTACKLIM
, _("Grow limit of user stack"), AUXV_FORMAT_HEX
);
1582 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
1585 /* Implement the "get_siginfo_type" gdbarch method. */
1587 static struct type
*
1588 fbsd_get_siginfo_type (struct gdbarch
*gdbarch
)
1590 struct fbsd_gdbarch_data
*fbsd_gdbarch_data
;
1591 struct type
*int_type
, *int32_type
, *uint32_type
, *long_type
, *void_ptr_type
;
1592 struct type
*uid_type
, *pid_type
;
1593 struct type
*sigval_type
, *reason_type
;
1594 struct type
*siginfo_type
;
1597 fbsd_gdbarch_data
= get_fbsd_gdbarch_data (gdbarch
);
1598 if (fbsd_gdbarch_data
->siginfo_type
!= NULL
)
1599 return fbsd_gdbarch_data
->siginfo_type
;
1601 type_allocator
alloc (gdbarch
);
1602 int_type
= init_integer_type (alloc
, gdbarch_int_bit (gdbarch
),
1604 int32_type
= init_integer_type (alloc
, 32, 0, "int32_t");
1605 uint32_type
= init_integer_type (alloc
, 32, 1, "uint32_t");
1606 long_type
= init_integer_type (alloc
, gdbarch_long_bit (gdbarch
),
1608 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
1611 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1612 sigval_type
->set_name (xstrdup ("sigval"));
1613 append_composite_type_field (sigval_type
, "sival_int", int_type
);
1614 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
1617 pid_type
= alloc
.new_type (TYPE_CODE_TYPEDEF
,
1618 int32_type
->length () * TARGET_CHAR_BIT
,
1620 pid_type
->set_target_type (int32_type
);
1621 pid_type
->set_target_is_stub (true);
1624 uid_type
= alloc
.new_type (TYPE_CODE_TYPEDEF
,
1625 uint32_type
->length () * TARGET_CHAR_BIT
,
1627 uid_type
->set_target_type (uint32_type
);
1628 pid_type
->set_target_is_stub (true);
1631 reason_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1634 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1635 append_composite_type_field (type
, "si_trapno", int_type
);
1636 append_composite_type_field (reason_type
, "_fault", type
);
1639 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1640 append_composite_type_field (type
, "si_timerid", int_type
);
1641 append_composite_type_field (type
, "si_overrun", int_type
);
1642 append_composite_type_field (reason_type
, "_timer", type
);
1645 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1646 append_composite_type_field (type
, "si_mqd", int_type
);
1647 append_composite_type_field (reason_type
, "_mesgq", type
);
1650 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1651 append_composite_type_field (type
, "si_band", long_type
);
1652 append_composite_type_field (reason_type
, "_poll", type
);
1655 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1656 append_composite_type_field (type
, "__spare1__", long_type
);
1657 append_composite_type_field (type
, "__spare2__",
1658 init_vector_type (int_type
, 7));
1659 append_composite_type_field (reason_type
, "__spare__", type
);
1661 /* struct siginfo */
1662 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1663 siginfo_type
->set_name (xstrdup ("siginfo"));
1664 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
1665 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
1666 append_composite_type_field (siginfo_type
, "si_code", int_type
);
1667 append_composite_type_field (siginfo_type
, "si_pid", pid_type
);
1668 append_composite_type_field (siginfo_type
, "si_uid", uid_type
);
1669 append_composite_type_field (siginfo_type
, "si_status", int_type
);
1670 append_composite_type_field (siginfo_type
, "si_addr", void_ptr_type
);
1671 append_composite_type_field (siginfo_type
, "si_value", sigval_type
);
1672 append_composite_type_field (siginfo_type
, "_reason", reason_type
);
1674 fbsd_gdbarch_data
->siginfo_type
= siginfo_type
;
1676 return siginfo_type
;
1679 /* Implement the "gdb_signal_from_target" gdbarch method. */
1681 static enum gdb_signal
1682 fbsd_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1687 return GDB_SIGNAL_0
;
1689 case FREEBSD_SIGHUP
:
1690 return GDB_SIGNAL_HUP
;
1692 case FREEBSD_SIGINT
:
1693 return GDB_SIGNAL_INT
;
1695 case FREEBSD_SIGQUIT
:
1696 return GDB_SIGNAL_QUIT
;
1698 case FREEBSD_SIGILL
:
1699 return GDB_SIGNAL_ILL
;
1701 case FREEBSD_SIGTRAP
:
1702 return GDB_SIGNAL_TRAP
;
1704 case FREEBSD_SIGABRT
:
1705 return GDB_SIGNAL_ABRT
;
1707 case FREEBSD_SIGEMT
:
1708 return GDB_SIGNAL_EMT
;
1710 case FREEBSD_SIGFPE
:
1711 return GDB_SIGNAL_FPE
;
1713 case FREEBSD_SIGKILL
:
1714 return GDB_SIGNAL_KILL
;
1716 case FREEBSD_SIGBUS
:
1717 return GDB_SIGNAL_BUS
;
1719 case FREEBSD_SIGSEGV
:
1720 return GDB_SIGNAL_SEGV
;
1722 case FREEBSD_SIGSYS
:
1723 return GDB_SIGNAL_SYS
;
1725 case FREEBSD_SIGPIPE
:
1726 return GDB_SIGNAL_PIPE
;
1728 case FREEBSD_SIGALRM
:
1729 return GDB_SIGNAL_ALRM
;
1731 case FREEBSD_SIGTERM
:
1732 return GDB_SIGNAL_TERM
;
1734 case FREEBSD_SIGURG
:
1735 return GDB_SIGNAL_URG
;
1737 case FREEBSD_SIGSTOP
:
1738 return GDB_SIGNAL_STOP
;
1740 case FREEBSD_SIGTSTP
:
1741 return GDB_SIGNAL_TSTP
;
1743 case FREEBSD_SIGCONT
:
1744 return GDB_SIGNAL_CONT
;
1746 case FREEBSD_SIGCHLD
:
1747 return GDB_SIGNAL_CHLD
;
1749 case FREEBSD_SIGTTIN
:
1750 return GDB_SIGNAL_TTIN
;
1752 case FREEBSD_SIGTTOU
:
1753 return GDB_SIGNAL_TTOU
;
1756 return GDB_SIGNAL_IO
;
1758 case FREEBSD_SIGXCPU
:
1759 return GDB_SIGNAL_XCPU
;
1761 case FREEBSD_SIGXFSZ
:
1762 return GDB_SIGNAL_XFSZ
;
1764 case FREEBSD_SIGVTALRM
:
1765 return GDB_SIGNAL_VTALRM
;
1767 case FREEBSD_SIGPROF
:
1768 return GDB_SIGNAL_PROF
;
1770 case FREEBSD_SIGWINCH
:
1771 return GDB_SIGNAL_WINCH
;
1773 case FREEBSD_SIGINFO
:
1774 return GDB_SIGNAL_INFO
;
1776 case FREEBSD_SIGUSR1
:
1777 return GDB_SIGNAL_USR1
;
1779 case FREEBSD_SIGUSR2
:
1780 return GDB_SIGNAL_USR2
;
1782 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1783 case FREEBSD_SIGTHR
:
1784 return GDB_SIGNAL_LWP
;
1786 case FREEBSD_SIGLIBRT
:
1787 return GDB_SIGNAL_LIBRT
;
1790 if (signal
>= FREEBSD_SIGRTMIN
&& signal
<= FREEBSD_SIGRTMAX
)
1792 int offset
= signal
- FREEBSD_SIGRTMIN
;
1794 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_65
+ offset
);
1797 return GDB_SIGNAL_UNKNOWN
;
1800 /* Implement the "gdb_signal_to_target" gdbarch method. */
1803 fbsd_gdb_signal_to_target (struct gdbarch
*gdbarch
,
1804 enum gdb_signal signal
)
1811 case GDB_SIGNAL_HUP
:
1812 return FREEBSD_SIGHUP
;
1814 case GDB_SIGNAL_INT
:
1815 return FREEBSD_SIGINT
;
1817 case GDB_SIGNAL_QUIT
:
1818 return FREEBSD_SIGQUIT
;
1820 case GDB_SIGNAL_ILL
:
1821 return FREEBSD_SIGILL
;
1823 case GDB_SIGNAL_TRAP
:
1824 return FREEBSD_SIGTRAP
;
1826 case GDB_SIGNAL_ABRT
:
1827 return FREEBSD_SIGABRT
;
1829 case GDB_SIGNAL_EMT
:
1830 return FREEBSD_SIGEMT
;
1832 case GDB_SIGNAL_FPE
:
1833 return FREEBSD_SIGFPE
;
1835 case GDB_SIGNAL_KILL
:
1836 return FREEBSD_SIGKILL
;
1838 case GDB_SIGNAL_BUS
:
1839 return FREEBSD_SIGBUS
;
1841 case GDB_SIGNAL_SEGV
:
1842 return FREEBSD_SIGSEGV
;
1844 case GDB_SIGNAL_SYS
:
1845 return FREEBSD_SIGSYS
;
1847 case GDB_SIGNAL_PIPE
:
1848 return FREEBSD_SIGPIPE
;
1850 case GDB_SIGNAL_ALRM
:
1851 return FREEBSD_SIGALRM
;
1853 case GDB_SIGNAL_TERM
:
1854 return FREEBSD_SIGTERM
;
1856 case GDB_SIGNAL_URG
:
1857 return FREEBSD_SIGURG
;
1859 case GDB_SIGNAL_STOP
:
1860 return FREEBSD_SIGSTOP
;
1862 case GDB_SIGNAL_TSTP
:
1863 return FREEBSD_SIGTSTP
;
1865 case GDB_SIGNAL_CONT
:
1866 return FREEBSD_SIGCONT
;
1868 case GDB_SIGNAL_CHLD
:
1869 return FREEBSD_SIGCHLD
;
1871 case GDB_SIGNAL_TTIN
:
1872 return FREEBSD_SIGTTIN
;
1874 case GDB_SIGNAL_TTOU
:
1875 return FREEBSD_SIGTTOU
;
1878 return FREEBSD_SIGIO
;
1880 case GDB_SIGNAL_XCPU
:
1881 return FREEBSD_SIGXCPU
;
1883 case GDB_SIGNAL_XFSZ
:
1884 return FREEBSD_SIGXFSZ
;
1886 case GDB_SIGNAL_VTALRM
:
1887 return FREEBSD_SIGVTALRM
;
1889 case GDB_SIGNAL_PROF
:
1890 return FREEBSD_SIGPROF
;
1892 case GDB_SIGNAL_WINCH
:
1893 return FREEBSD_SIGWINCH
;
1895 case GDB_SIGNAL_INFO
:
1896 return FREEBSD_SIGINFO
;
1898 case GDB_SIGNAL_USR1
:
1899 return FREEBSD_SIGUSR1
;
1901 case GDB_SIGNAL_USR2
:
1902 return FREEBSD_SIGUSR2
;
1904 case GDB_SIGNAL_LWP
:
1905 return FREEBSD_SIGTHR
;
1907 case GDB_SIGNAL_LIBRT
:
1908 return FREEBSD_SIGLIBRT
;
1911 if (signal
>= GDB_SIGNAL_REALTIME_65
1912 && signal
<= GDB_SIGNAL_REALTIME_126
)
1914 int offset
= signal
- GDB_SIGNAL_REALTIME_65
;
1916 return FREEBSD_SIGRTMIN
+ offset
;
1922 /* Implement the "get_syscall_number" gdbarch method. */
1925 fbsd_get_syscall_number (struct gdbarch
*gdbarch
, thread_info
*thread
)
1928 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1929 native targets fetch the system call number from the
1930 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1931 However, system call catching requires this function to be
1934 internal_error (_("fbsd_get_sycall_number called"));
1937 /* Read an integer symbol value from the current target. */
1940 fbsd_read_integer_by_name (struct gdbarch
*gdbarch
, const char *name
)
1942 bound_minimal_symbol ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1943 if (ms
.minsym
== NULL
)
1944 error (_("Unable to resolve symbol '%s'"), name
);
1947 if (target_read_memory (ms
.value_address (), buf
, sizeof buf
) != 0)
1948 error (_("Unable to read value of '%s'"), name
);
1950 return extract_signed_integer (buf
, gdbarch_byte_order (gdbarch
));
1953 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1954 structure needed to determine the TLS index of an object file. */
1957 fbsd_fetch_rtld_offsets (struct gdbarch
*gdbarch
, struct fbsd_pspace_data
*data
)
1961 /* Fetch offsets from debug symbols in rtld. */
1962 struct symbol
*obj_entry_sym
1963 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL
, STRUCT_DOMAIN
,
1964 language_c
, NULL
).symbol
;
1965 if (obj_entry_sym
== NULL
)
1966 error (_("Unable to find Struct_Obj_Entry symbol"));
1967 data
->off_linkmap
= lookup_struct_elt (obj_entry_sym
->type (),
1968 "linkmap", 0).offset
/ 8;
1969 data
->off_tlsindex
= lookup_struct_elt (obj_entry_sym
->type (),
1970 "tlsindex", 0).offset
/ 8;
1971 data
->rtld_offsets_valid
= true;
1974 catch (const gdb_exception_error
&e
)
1976 data
->off_linkmap
= -1;
1981 /* Fetch offsets from global variables in libthr. Note that
1982 this does not work for single-threaded processes that are not
1983 linked against libthr. */
1984 data
->off_linkmap
= fbsd_read_integer_by_name (gdbarch
,
1985 "_thread_off_linkmap");
1986 data
->off_tlsindex
= fbsd_read_integer_by_name (gdbarch
,
1987 "_thread_off_tlsindex");
1988 data
->rtld_offsets_valid
= true;
1991 catch (const gdb_exception_error
&e
)
1993 data
->off_linkmap
= -1;
1997 /* Helper function to read the TLS index of an object file associated
1998 with a link map entry at LM_ADDR. */
2001 fbsd_get_tls_index (struct gdbarch
*gdbarch
, CORE_ADDR lm_addr
)
2003 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
2005 if (!data
->rtld_offsets_valid
)
2006 fbsd_fetch_rtld_offsets (gdbarch
, data
);
2008 if (data
->off_linkmap
== -1)
2009 throw_error (TLS_GENERIC_ERROR
,
2010 _("Cannot fetch runtime linker structure offsets"));
2012 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2013 pointer and then compute the offset of the tlsindex member. */
2014 CORE_ADDR tlsindex_addr
= lm_addr
- data
->off_linkmap
+ data
->off_tlsindex
;
2017 if (target_read_memory (tlsindex_addr
, buf
, sizeof buf
) != 0)
2018 throw_error (TLS_GENERIC_ERROR
,
2019 _("Cannot find thread-local variables on this target"));
2021 return extract_signed_integer (buf
, gdbarch_byte_order (gdbarch
));
2024 /* See fbsd-tdep.h. */
2027 fbsd_get_thread_local_address (struct gdbarch
*gdbarch
, CORE_ADDR dtv_addr
,
2028 CORE_ADDR lm_addr
, CORE_ADDR offset
)
2030 LONGEST tls_index
= fbsd_get_tls_index (gdbarch
, lm_addr
);
2032 gdb_byte buf
[gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
];
2033 if (target_read_memory (dtv_addr
, buf
, sizeof buf
) != 0)
2034 throw_error (TLS_GENERIC_ERROR
,
2035 _("Cannot find thread-local variables on this target"));
2037 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
2038 CORE_ADDR addr
= gdbarch_pointer_to_address (gdbarch
,
2039 builtin
->builtin_data_ptr
, buf
);
2041 addr
+= (tls_index
+ 1) * builtin
->builtin_data_ptr
->length ();
2042 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
2043 throw_error (TLS_GENERIC_ERROR
,
2044 _("Cannot find thread-local variables on this target"));
2046 addr
= gdbarch_pointer_to_address (gdbarch
, builtin
->builtin_data_ptr
, buf
);
2047 return addr
+ offset
;
2050 /* See fbsd-tdep.h. */
2053 fbsd_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2055 struct bound_minimal_symbol msym
= lookup_bound_minimal_symbol ("_rtld_bind");
2056 if (msym
.minsym
!= nullptr && msym
.value_address () == pc
)
2057 return frame_unwind_caller_pc (get_current_frame ());
2062 /* Return description of signal code or nullptr. */
2065 fbsd_signal_cause (enum gdb_signal siggnal
, int code
)
2067 /* Signal-independent causes. */
2071 return _("Sent by kill()");
2073 return _("Sent by sigqueue()");
2075 return _("Timer expired");
2076 case FBSD_SI_ASYNCIO
:
2077 return _("Asynchronous I/O request completed");
2079 return _("Message arrived on empty message queue");
2080 case FBSD_SI_KERNEL
:
2081 return _("Sent by kernel");
2083 return _("Sent by thr_kill()");
2088 case GDB_SIGNAL_ILL
:
2091 case FBSD_ILL_ILLOPC
:
2092 return _("Illegal opcode");
2093 case FBSD_ILL_ILLOPN
:
2094 return _("Illegal operand");
2095 case FBSD_ILL_ILLADR
:
2096 return _("Illegal addressing mode");
2097 case FBSD_ILL_ILLTRP
:
2098 return _("Illegal trap");
2099 case FBSD_ILL_PRVOPC
:
2100 return _("Privileged opcode");
2101 case FBSD_ILL_PRVREG
:
2102 return _("Privileged register");
2103 case FBSD_ILL_COPROC
:
2104 return _("Coprocessor error");
2105 case FBSD_ILL_BADSTK
:
2106 return _("Internal stack error");
2109 case GDB_SIGNAL_BUS
:
2112 case FBSD_BUS_ADRALN
:
2113 return _("Invalid address alignment");
2114 case FBSD_BUS_ADRERR
:
2115 return _("Address not present");
2116 case FBSD_BUS_OBJERR
:
2117 return _("Object-specific hardware error");
2118 case FBSD_BUS_OOMERR
:
2119 return _("Out of memory");
2122 case GDB_SIGNAL_SEGV
:
2125 case FBSD_SEGV_MAPERR
:
2126 return _("Address not mapped to object");
2127 case FBSD_SEGV_ACCERR
:
2128 return _("Invalid permissions for mapped object");
2129 case FBSD_SEGV_PKUERR
:
2130 return _("PKU violation");
2133 case GDB_SIGNAL_FPE
:
2136 case FBSD_FPE_INTOVF
:
2137 return _("Integer overflow");
2138 case FBSD_FPE_INTDIV
:
2139 return _("Integer divide by zero");
2140 case FBSD_FPE_FLTDIV
:
2141 return _("Floating point divide by zero");
2142 case FBSD_FPE_FLTOVF
:
2143 return _("Floating point overflow");
2144 case FBSD_FPE_FLTUND
:
2145 return _("Floating point underflow");
2146 case FBSD_FPE_FLTRES
:
2147 return _("Floating point inexact result");
2148 case FBSD_FPE_FLTINV
:
2149 return _("Invalid floating point operation");
2150 case FBSD_FPE_FLTSUB
:
2151 return _("Subscript out of range");
2154 case GDB_SIGNAL_TRAP
:
2157 case FBSD_TRAP_BRKPT
:
2158 return _("Breakpoint");
2159 case FBSD_TRAP_TRACE
:
2160 return _("Trace trap");
2161 case FBSD_TRAP_DTRACE
:
2162 return _("DTrace-induced trap");
2164 return _("Capability violation");
2167 case GDB_SIGNAL_CHLD
:
2170 case FBSD_CLD_EXITED
:
2171 return _("Child has exited");
2172 case FBSD_CLD_KILLED
:
2173 return _("Child has terminated abnormally");
2174 case FBSD_CLD_DUMPED
:
2175 return _("Child has dumped core");
2176 case FBSD_CLD_TRAPPED
:
2177 return _("Traced child has trapped");
2178 case FBSD_CLD_STOPPED
:
2179 return _("Child has stopped");
2180 case FBSD_CLD_CONTINUED
:
2181 return _("Stopped child has continued");
2184 case GDB_SIGNAL_POLL
:
2188 return _("Data input available");
2190 return _("Output buffers available");
2192 return _("Input message available");
2194 return _("I/O error");
2196 return _("High priority input available");
2198 return _("Device disconnected");
2206 /* Report additional details for a signal stop. */
2209 fbsd_report_signal_info (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
2210 enum gdb_signal siggnal
)
2212 LONGEST code
, mqd
, pid
, status
, timerid
, uid
;
2216 code
= parse_and_eval_long ("$_siginfo.si_code");
2217 pid
= parse_and_eval_long ("$_siginfo.si_pid");
2218 uid
= parse_and_eval_long ("$_siginfo.si_uid");
2219 status
= parse_and_eval_long ("$_siginfo.si_status");
2220 timerid
= parse_and_eval_long ("$_siginfo._reason._timer.si_timerid");
2221 mqd
= parse_and_eval_long ("$_siginfo._reason._mesgq.si_mqd");
2223 catch (const gdb_exception_error
&e
)
2228 const char *meaning
= fbsd_signal_cause (siggnal
, code
);
2229 if (meaning
== nullptr)
2232 uiout
->text (".\n");
2233 uiout
->field_string ("sigcode-meaning", meaning
);
2240 uiout
->text (" from pid ");
2241 uiout
->field_string ("sending-pid", plongest (pid
));
2242 uiout
->text (" and user ");
2243 uiout
->field_string ("sending-uid", plongest (uid
));
2246 uiout
->text (": timerid ");
2247 uiout
->field_string ("timerid", plongest (timerid
));
2250 uiout
->text (": message queue ");
2251 uiout
->field_string ("message-queue", plongest (mqd
));
2253 case FBSD_SI_ASYNCIO
:
2257 if (siggnal
== GDB_SIGNAL_CHLD
)
2259 uiout
->text (": pid ");
2260 uiout
->field_string ("child-pid", plongest (pid
));
2261 uiout
->text (", uid ");
2262 uiout
->field_string ("child-uid", plongest (uid
));
2263 if (code
== FBSD_CLD_EXITED
)
2265 uiout
->text (", exit status ");
2266 uiout
->field_string ("exit-status", plongest (status
));
2270 uiout
->text (", signal ");
2271 uiout
->field_string ("signal", plongest (status
));
2276 /* Search a list of struct kinfo_vmmap entries in the ENTRIES buffer
2277 of LEN bytes to find the length of the entry starting at ADDR.
2278 Returns the length of the entry or zero if no entry was found. */
2281 fbsd_vmmap_length (struct gdbarch
*gdbarch
, unsigned char *entries
, size_t len
,
2284 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2285 unsigned char *descdata
= entries
;
2286 unsigned char *descend
= descdata
+ len
;
2288 /* Skip over the structure size. */
2291 while (descdata
+ KVE_PATH
< descend
)
2293 ULONGEST structsize
= extract_unsigned_integer (descdata
2294 + KVE_STRUCTSIZE
, 4,
2296 if (structsize
< KVE_PATH
)
2299 ULONGEST start
= extract_unsigned_integer (descdata
+ KVE_START
, 8,
2301 ULONGEST end
= extract_unsigned_integer (descdata
+ KVE_END
, 8,
2306 descdata
+= structsize
;
2311 /* Helper for fbsd_vsyscall_range that does the real work of finding
2312 the vDSO's address range. */
2315 fbsd_vdso_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2317 if (target_auxv_search (AT_FREEBSD_KPRELOAD
, &range
->start
) <= 0)
2320 if (!target_has_execution ())
2322 /* Search for the ending address in the NT_PROCSTAT_VMMAP note. */
2323 asection
*section
= bfd_get_section_by_name (core_bfd
,
2324 ".note.freebsdcore.vmmap");
2325 if (section
== nullptr)
2328 size_t note_size
= bfd_section_size (section
);
2332 gdb::def_vector
<unsigned char> contents (note_size
);
2333 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
2337 range
->length
= fbsd_vmmap_length (gdbarch
, contents
.data (), note_size
,
2342 /* Fetch the list of address space entries from the running target. */
2343 std::optional
<gdb::byte_vector
> buf
=
2344 target_read_alloc (current_inferior ()->top_target (),
2345 TARGET_OBJECT_FREEBSD_VMMAP
, nullptr);
2346 if (!buf
|| buf
->empty ())
2349 range
->length
= fbsd_vmmap_length (gdbarch
, buf
->data (), buf
->size (),
2352 return range
->length
!= 0;
2355 /* Return the address range of the vDSO for the current inferior. */
2358 fbsd_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
2360 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
2362 if (data
->vdso_range_p
== 0)
2364 if (fbsd_vdso_range (gdbarch
, &data
->vdso_range
))
2365 data
->vdso_range_p
= 1;
2367 data
->vdso_range_p
= -1;
2370 if (data
->vdso_range_p
< 0)
2373 *range
= data
->vdso_range
;
2377 /* To be called from GDB_OSABI_FREEBSD handlers. */
2380 fbsd_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2382 set_gdbarch_core_pid_to_str (gdbarch
, fbsd_core_pid_to_str
);
2383 set_gdbarch_core_thread_name (gdbarch
, fbsd_core_thread_name
);
2384 set_gdbarch_core_xfer_siginfo (gdbarch
, fbsd_core_xfer_siginfo
);
2385 set_gdbarch_make_corefile_notes (gdbarch
, fbsd_make_corefile_notes
);
2386 set_gdbarch_core_info_proc (gdbarch
, fbsd_core_info_proc
);
2387 set_gdbarch_print_auxv_entry (gdbarch
, fbsd_print_auxv_entry
);
2388 set_gdbarch_get_siginfo_type (gdbarch
, fbsd_get_siginfo_type
);
2389 set_gdbarch_gdb_signal_from_target (gdbarch
, fbsd_gdb_signal_from_target
);
2390 set_gdbarch_gdb_signal_to_target (gdbarch
, fbsd_gdb_signal_to_target
);
2391 set_gdbarch_report_signal_info (gdbarch
, fbsd_report_signal_info
);
2392 set_gdbarch_skip_solib_resolver (gdbarch
, fbsd_skip_solib_resolver
);
2393 set_gdbarch_vsyscall_range (gdbarch
, fbsd_vsyscall_range
);
2395 /* `catch syscall' */
2396 set_xml_syscall_file_name (gdbarch
, "syscalls/freebsd.xml");
2397 set_gdbarch_get_syscall_number (gdbarch
, fbsd_get_syscall_number
);