1 /* Target-dependent code for FreeBSD, architecture-independent.
3 Copyright (C) 2002-2019 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/>. */
26 #include "gdbthread.h"
28 #include "xml-syscall.h"
29 #include <sys/socket.h>
30 #include <arpa/inet.h>
33 #include "fbsd-tdep.h"
35 /* This enum is derived from FreeBSD's <sys/signal.h>. */
64 FREEBSD_SIGVTALRM
= 26,
66 FREEBSD_SIGWINCH
= 28,
71 FREEBSD_SIGLIBRT
= 33,
72 FREEBSD_SIGRTMIN
= 65,
73 FREEBSD_SIGRTMAX
= 126,
76 /* FreeBSD kernels 12.0 and later include a copy of the
77 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
78 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
79 The constants below define the offset of field members and flags in
80 this structure used by methods in this file. Note that the
81 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
82 containing the size of the structure. */
84 #define LWPINFO_OFFSET 0x4
86 /* Offsets in ptrace_lwpinfo. */
87 #define LWPINFO_PL_FLAGS 0x8
88 #define LWPINFO64_PL_SIGINFO 0x30
89 #define LWPINFO32_PL_SIGINFO 0x2c
91 /* Flags in pl_flags. */
92 #define PL_FLAG_SI 0x20 /* siginfo is valid */
94 /* Sizes of siginfo_t. */
95 #define SIZE64_SIGINFO_T 80
96 #define SIZE32_SIGINFO_T 64
98 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
99 dump notes. See <sys/user.h> for the definition of struct
100 kinfo_vmentry. This data structure should have the same layout on
103 Note that FreeBSD 7.0 used an older version of this structure
104 (struct kinfo_ovmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core
105 dump note wasn't introduced until FreeBSD 9.2. As a result, the
106 core dump note has always used the 7.1 and later structure
109 #define KVE_STRUCTSIZE 0x0
110 #define KVE_START 0x8
112 #define KVE_OFFSET 0x18
113 #define KVE_FLAGS 0x2c
114 #define KVE_PROTECTION 0x38
115 #define KVE_PATH 0x88
117 /* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
118 match the KVME_PROT_* constants in <sys/user.h>. */
120 #define KINFO_VME_PROT_READ 0x00000001
121 #define KINFO_VME_PROT_WRITE 0x00000002
122 #define KINFO_VME_PROT_EXEC 0x00000004
124 /* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
125 match the KVME_FLAG_* constants in <sys/user.h>. */
127 #define KINFO_VME_FLAG_COW 0x00000001
128 #define KINFO_VME_FLAG_NEEDS_COPY 0x00000002
129 #define KINFO_VME_FLAG_NOCOREDUMP 0x00000004
130 #define KINFO_VME_FLAG_SUPER 0x00000008
131 #define KINFO_VME_FLAG_GROWS_UP 0x00000010
132 #define KINFO_VME_FLAG_GROWS_DOWN 0x00000020
134 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
135 dump notes. See <sys/user.h> for the definition of struct
136 kinfo_file. This data structure should have the same layout on all
139 Note that FreeBSD 7.0 used an older version of this structure
140 (struct kinfo_ofile), but the NT_FREEBSD_PROCSTAT_FILES core dump
141 note wasn't introduced until FreeBSD 9.2. As a result, the core
142 dump note has always used the 7.1 and later structure format. */
144 #define KF_STRUCTSIZE 0x0
147 #define KF_FLAGS 0x10
148 #define KF_OFFSET 0x18
149 #define KF_VNODE_TYPE 0x20
150 #define KF_SOCK_DOMAIN 0x24
151 #define KF_SOCK_TYPE 0x28
152 #define KF_SOCK_PROTOCOL 0x2c
153 #define KF_SA_LOCAL 0x30
154 #define KF_SA_PEER 0xb0
155 #define KF_PATH 0x170
157 /* Constants for the 'kf_type' field in struct kinfo_file. These
158 match the KF_TYPE_* constants in <sys/user.h>. */
160 #define KINFO_FILE_TYPE_VNODE 1
161 #define KINFO_FILE_TYPE_SOCKET 2
162 #define KINFO_FILE_TYPE_PIPE 3
163 #define KINFO_FILE_TYPE_FIFO 4
164 #define KINFO_FILE_TYPE_KQUEUE 5
165 #define KINFO_FILE_TYPE_CRYPTO 6
166 #define KINFO_FILE_TYPE_MQUEUE 7
167 #define KINFO_FILE_TYPE_SHM 8
168 #define KINFO_FILE_TYPE_SEM 9
169 #define KINFO_FILE_TYPE_PTS 10
170 #define KINFO_FILE_TYPE_PROCDESC 11
172 /* Special values for the 'kf_fd' field in struct kinfo_file. These
173 match the KF_FD_TYPE_* constants in <sys/user.h>. */
175 #define KINFO_FILE_FD_TYPE_CWD -1
176 #define KINFO_FILE_FD_TYPE_ROOT -2
177 #define KINFO_FILE_FD_TYPE_JAIL -3
178 #define KINFO_FILE_FD_TYPE_TRACE -4
179 #define KINFO_FILE_FD_TYPE_TEXT -5
180 #define KINFO_FILE_FD_TYPE_CTTY -6
182 /* Flags in the 'kf_flags' field in struct kinfo_file. These match
183 the KF_FLAG_* constants in <sys/user.h>. */
185 #define KINFO_FILE_FLAG_READ 0x00000001
186 #define KINFO_FILE_FLAG_WRITE 0x00000002
187 #define KINFO_FILE_FLAG_APPEND 0x00000004
188 #define KINFO_FILE_FLAG_ASYNC 0x00000008
189 #define KINFO_FILE_FLAG_FSYNC 0x00000010
190 #define KINFO_FILE_FLAG_NONBLOCK 0x00000020
191 #define KINFO_FILE_FLAG_DIRECT 0x00000040
192 #define KINFO_FILE_FLAG_HASLOCK 0x00000080
193 #define KINFO_FILE_FLAG_EXEC 0x00004000
195 /* Constants for the 'kf_vnode_type' field in struct kinfo_file.
196 These match the KF_VTYPE_* constants in <sys/user.h>. */
198 #define KINFO_FILE_VTYPE_VREG 1
199 #define KINFO_FILE_VTYPE_VDIR 2
200 #define KINFO_FILE_VTYPE_VCHR 4
201 #define KINFO_FILE_VTYPE_VLNK 5
202 #define KINFO_FILE_VTYPE_VSOCK 6
203 #define KINFO_FILE_VTYPE_VFIFO 7
205 /* Constants for socket address families. These match AF_* constants
206 in <sys/socket.h>. */
208 #define FBSD_AF_UNIX 1
209 #define FBSD_AF_INET 2
210 #define FBSD_AF_INET6 28
212 /* Constants for socket types. These match SOCK_* constants in
215 #define FBSD_SOCK_STREAM 1
216 #define FBSD_SOCK_DGRAM 2
217 #define FBSD_SOCK_SEQPACKET 5
219 /* Constants for IP protocols. These match IPPROTO_* constants in
222 #define FBSD_IPPROTO_ICMP 1
223 #define FBSD_IPPROTO_TCP 6
224 #define FBSD_IPPROTO_UDP 17
225 #define FBSD_IPPROTO_SCTP 132
227 /* Socket address structures. These have the same layout on all
228 FreeBSD architectures. In addition, multibyte fields such as IP
229 addresses are always stored in network byte order. */
231 struct fbsd_sockaddr_in
240 struct fbsd_sockaddr_in6
244 uint8_t sin6_port
[2];
245 uint32_t sin6_flowinfo
;
246 uint8_t sin6_addr
[16];
247 uint32_t sin6_scope_id
;
250 struct fbsd_sockaddr_un
257 /* Number of 32-bit words in a signal set. This matches _SIG_WORDS in
258 <sys/_sigset.h> and is the same value on all architectures. */
262 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
263 dump notes. See <sys/user.h> for the definition of struct
264 kinfo_proc. This data structure has different layouts on different
265 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386
266 uses a 32-bit time_t while all other architectures use a 64-bit
269 The core dump note actually contains one kinfo_proc structure for
270 each thread, but all of the process-wide data can be obtained from
271 the first structure. One result of this note's format is that some
272 of the process-wide status available in the native target method
273 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
274 is not available from a core dump. Instead, the per-thread data
275 structures contain the value of these fields for individual
278 struct kinfo_proc_layout
280 /* Offsets of struct kinfo_proc members. */
287 int ki_tdev_freebsd11
;
309 /* Offsets of struct rusage members. */
317 const struct kinfo_proc_layout kinfo_proc_layout_32
=
325 .ki_tdev_freebsd11
= 0x44,
326 .ki_sigignore
= 0x68,
345 .ki_rusage_ch
= 0x278,
354 const struct kinfo_proc_layout kinfo_proc_layout_i386
=
362 .ki_tdev_freebsd11
= 0x44,
363 .ki_sigignore
= 0x68,
382 .ki_rusage_ch
= 0x258,
391 const struct kinfo_proc_layout kinfo_proc_layout_64
=
399 .ki_tdev_freebsd11
= 0x64,
400 .ki_sigignore
= 0x88,
419 .ki_rusage_ch
= 0x2f0,
428 static struct gdbarch_data
*fbsd_gdbarch_data_handle
;
430 struct fbsd_gdbarch_data
432 struct type
*siginfo_type
;
436 init_fbsd_gdbarch_data (struct gdbarch
*gdbarch
)
438 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct fbsd_gdbarch_data
);
441 static struct fbsd_gdbarch_data
*
442 get_fbsd_gdbarch_data (struct gdbarch
*gdbarch
)
444 return ((struct fbsd_gdbarch_data
*)
445 gdbarch_data (gdbarch
, fbsd_gdbarch_data_handle
));
448 /* Per-program-space data for FreeBSD architectures. */
449 static const struct program_space_data
*fbsd_pspace_data_handle
;
451 struct fbsd_pspace_data
453 /* Offsets in the runtime linker's 'Obj_Entry' structure. */
455 LONGEST off_tlsindex
;
456 bool rtld_offsets_valid
;
459 static struct fbsd_pspace_data
*
460 get_fbsd_pspace_data (struct program_space
*pspace
)
462 struct fbsd_pspace_data
*data
;
464 data
= ((struct fbsd_pspace_data
*)
465 program_space_data (pspace
, fbsd_pspace_data_handle
));
468 data
= XCNEW (struct fbsd_pspace_data
);
469 set_program_space_data (pspace
, fbsd_pspace_data_handle
, data
);
475 /* The cleanup callback for FreeBSD architecture per-program-space data. */
478 fbsd_pspace_data_cleanup (struct program_space
*pspace
, void *data
)
483 /* This is how we want PTIDs from core files to be printed. */
486 fbsd_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
490 if (ptid
.lwp () != 0)
492 xsnprintf (buf
, sizeof buf
, "LWP %ld", ptid
.lwp ());
496 return normal_pid_to_str (ptid
);
499 /* Extract the name assigned to a thread from a core. Returns the
500 string in a static buffer. */
503 fbsd_core_thread_name (struct gdbarch
*gdbarch
, struct thread_info
*thr
)
506 struct bfd_section
*section
;
509 if (thr
->ptid
.lwp () != 0)
511 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
512 whose contents are defined by a "struct thrmisc" declared in
513 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
514 a null-terminated string as the first member of the
515 structure. Rather than define the full structure here, just
516 extract the null-terminated name from the start of the
518 thread_section_name
section_name (".thrmisc", thr
->ptid
);
520 section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
521 if (section
!= NULL
&& bfd_section_size (core_bfd
, section
) > 0)
523 /* Truncate the name if it is longer than "buf". */
524 size
= bfd_section_size (core_bfd
, section
);
525 if (size
> sizeof buf
- 1)
526 size
= sizeof buf
- 1;
527 if (bfd_get_section_contents (core_bfd
, section
, buf
, (file_ptr
) 0,
533 /* Note that each thread will report the process command
534 as its thread name instead of an empty name if a name
535 has not been set explicitly. Return a NULL name in
537 if (strcmp (buf
, elf_tdata (core_bfd
)->core
->program
) != 0)
546 /* Implement the "core_xfer_siginfo" gdbarch method. */
549 fbsd_core_xfer_siginfo (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
,
550 ULONGEST offset
, ULONGEST len
)
554 if (gdbarch_long_bit (gdbarch
) == 32)
555 siginfo_size
= SIZE32_SIGINFO_T
;
557 siginfo_size
= SIZE64_SIGINFO_T
;
558 if (offset
> siginfo_size
)
561 thread_section_name
section_name (".note.freebsdcore.lwpinfo", inferior_ptid
);
562 asection
*section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
567 if (!bfd_get_section_contents (core_bfd
, section
, buf
,
568 LWPINFO_OFFSET
+ LWPINFO_PL_FLAGS
, 4))
571 int pl_flags
= extract_signed_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
572 if (!(pl_flags
& PL_FLAG_SI
))
575 if (offset
+ len
> siginfo_size
)
576 len
= siginfo_size
- offset
;
578 ULONGEST siginfo_offset
;
579 if (gdbarch_long_bit (gdbarch
) == 32)
580 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO32_PL_SIGINFO
;
582 siginfo_offset
= LWPINFO_OFFSET
+ LWPINFO64_PL_SIGINFO
;
584 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
585 siginfo_offset
+ offset
, len
))
592 find_signalled_thread (struct thread_info
*info
, void *data
)
594 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
595 && info
->ptid
.pid () == inferior_ptid
.pid ())
601 /* Structure for passing information from
602 fbsd_collect_thread_registers via an iterator to
603 fbsd_collect_regset_section_cb. */
605 struct fbsd_collect_regset_section_cb_data
607 const struct regcache
*regcache
;
612 enum gdb_signal stop_signal
;
617 fbsd_collect_regset_section_cb (const char *sect_name
, int supply_size
,
618 int collect_size
, const struct regset
*regset
,
619 const char *human_name
, void *cb_data
)
622 struct fbsd_collect_regset_section_cb_data
*data
623 = (struct fbsd_collect_regset_section_cb_data
*) cb_data
;
625 if (data
->abort_iteration
)
628 gdb_assert (regset
->collect_regset
);
630 buf
= (char *) xmalloc (collect_size
);
631 regset
->collect_regset (regset
, data
->regcache
, -1, buf
, collect_size
);
633 /* PRSTATUS still needs to be treated specially. */
634 if (strcmp (sect_name
, ".reg") == 0)
635 data
->note_data
= (char *) elfcore_write_prstatus
636 (data
->obfd
, data
->note_data
, data
->note_size
, data
->lwp
,
637 gdb_signal_to_host (data
->stop_signal
), buf
);
639 data
->note_data
= (char *) elfcore_write_register_note
640 (data
->obfd
, data
->note_data
, data
->note_size
,
641 sect_name
, buf
, collect_size
);
644 if (data
->note_data
== NULL
)
645 data
->abort_iteration
= 1;
648 /* Records the thread's register state for the corefile note
652 fbsd_collect_thread_registers (const struct regcache
*regcache
,
653 ptid_t ptid
, bfd
*obfd
,
654 char *note_data
, int *note_size
,
655 enum gdb_signal stop_signal
)
657 struct gdbarch
*gdbarch
= regcache
->arch ();
658 struct fbsd_collect_regset_section_cb_data data
;
660 data
.regcache
= regcache
;
662 data
.note_data
= note_data
;
663 data
.note_size
= note_size
;
664 data
.stop_signal
= stop_signal
;
665 data
.abort_iteration
= 0;
666 data
.lwp
= ptid
.lwp ();
668 gdbarch_iterate_over_regset_sections (gdbarch
,
669 fbsd_collect_regset_section_cb
,
671 return data
.note_data
;
674 struct fbsd_corefile_thread_data
676 struct gdbarch
*gdbarch
;
680 enum gdb_signal stop_signal
;
683 /* Records the thread's register state for the corefile note
687 fbsd_corefile_thread (struct thread_info
*info
,
688 struct fbsd_corefile_thread_data
*args
)
690 struct regcache
*regcache
;
692 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
694 target_fetch_registers (regcache
, -1);
696 args
->note_data
= fbsd_collect_thread_registers
697 (regcache
, info
->ptid
, args
->obfd
, args
->note_data
,
698 args
->note_size
, args
->stop_signal
);
701 /* Return a byte_vector containing the contents of a core dump note
702 for the target object of type OBJECT. If STRUCTSIZE is non-zero,
703 the data is prefixed with a 32-bit integer size to match the format
704 used in FreeBSD NT_PROCSTAT_* notes. */
706 static gdb::optional
<gdb::byte_vector
>
707 fbsd_make_note_desc (enum target_object object
, uint32_t structsize
)
709 gdb::optional
<gdb::byte_vector
> buf
=
710 target_read_alloc (current_top_target (), object
, NULL
);
711 if (!buf
|| buf
->empty ())
717 gdb::byte_vector
desc (sizeof (structsize
) + buf
->size ());
718 memcpy (desc
.data (), &structsize
, sizeof (structsize
));
719 memcpy (desc
.data () + sizeof (structsize
), buf
->data (), buf
->size ());
723 /* Create appropriate note sections for a corefile, returning them in
727 fbsd_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
729 struct fbsd_corefile_thread_data thread_args
;
730 char *note_data
= NULL
;
731 Elf_Internal_Ehdr
*i_ehdrp
;
732 struct thread_info
*curr_thr
, *signalled_thr
;
734 /* Put a "FreeBSD" label in the ELF header. */
735 i_ehdrp
= elf_elfheader (obfd
);
736 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
738 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch
));
740 if (get_exec_file (0))
742 const char *fname
= lbasename (get_exec_file (0));
743 char *psargs
= xstrdup (fname
);
745 if (get_inferior_args ())
746 psargs
= reconcat (psargs
, psargs
, " ", get_inferior_args (),
749 note_data
= elfcore_write_prpsinfo (obfd
, note_data
, note_size
,
753 /* Thread register information. */
756 update_thread_list ();
758 CATCH (e
, RETURN_MASK_ERROR
)
760 exception_print (gdb_stderr
, e
);
764 /* Like the kernel, prefer dumping the signalled thread first.
765 "First thread" is what tools use to infer the signalled thread.
766 In case there's more than one signalled thread, prefer the
767 current thread, if it is signalled. */
768 curr_thr
= inferior_thread ();
769 if (curr_thr
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
770 signalled_thr
= curr_thr
;
773 signalled_thr
= iterate_over_threads (find_signalled_thread
, NULL
);
774 if (signalled_thr
== NULL
)
775 signalled_thr
= curr_thr
;
778 thread_args
.gdbarch
= gdbarch
;
779 thread_args
.obfd
= obfd
;
780 thread_args
.note_data
= note_data
;
781 thread_args
.note_size
= note_size
;
782 thread_args
.stop_signal
= signalled_thr
->suspend
.stop_signal
;
784 fbsd_corefile_thread (signalled_thr
, &thread_args
);
785 for (thread_info
*thr
: current_inferior ()->non_exited_threads ())
787 if (thr
== signalled_thr
)
790 fbsd_corefile_thread (thr
, &thread_args
);
793 note_data
= thread_args
.note_data
;
795 /* Auxiliary vector. */
796 uint32_t structsize
= gdbarch_ptr_bit (gdbarch
) / 4; /* Elf_Auxinfo */
797 gdb::optional
<gdb::byte_vector
> note_desc
=
798 fbsd_make_note_desc (TARGET_OBJECT_AUXV
, structsize
);
799 if (note_desc
&& !note_desc
->empty ())
801 note_data
= elfcore_write_note (obfd
, note_data
, note_size
, "FreeBSD",
802 NT_FREEBSD_PROCSTAT_AUXV
,
803 note_desc
->data (), note_desc
->size ());
808 /* Virtual memory mappings. */
809 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP
, 0);
810 if (note_desc
&& !note_desc
->empty ())
812 note_data
= elfcore_write_note (obfd
, note_data
, note_size
, "FreeBSD",
813 NT_FREEBSD_PROCSTAT_VMMAP
,
814 note_desc
->data (), note_desc
->size ());
819 note_desc
= fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS
, 0);
820 if (note_desc
&& !note_desc
->empty ())
822 note_data
= elfcore_write_note (obfd
, note_data
, note_size
, "FreeBSD",
823 NT_FREEBSD_PROCSTAT_PSSTRINGS
,
824 note_desc
->data (), note_desc
->size ());
832 /* Helper function to generate the file descriptor description for a
833 single open file in 'info proc files'. */
836 fbsd_file_fd (int kf_fd
)
840 case KINFO_FILE_FD_TYPE_CWD
:
842 case KINFO_FILE_FD_TYPE_ROOT
:
844 case KINFO_FILE_FD_TYPE_JAIL
:
846 case KINFO_FILE_FD_TYPE_TRACE
:
848 case KINFO_FILE_FD_TYPE_TEXT
:
850 case KINFO_FILE_FD_TYPE_CTTY
:
853 return int_string (kf_fd
, 10, 1, 0, 0);
857 /* Helper function to generate the file type for a single open file in
858 'info proc files'. */
861 fbsd_file_type (int kf_type
, int kf_vnode_type
)
865 case KINFO_FILE_TYPE_VNODE
:
866 switch (kf_vnode_type
)
868 case KINFO_FILE_VTYPE_VREG
:
870 case KINFO_FILE_VTYPE_VDIR
:
872 case KINFO_FILE_VTYPE_VCHR
:
874 case KINFO_FILE_VTYPE_VLNK
:
876 case KINFO_FILE_VTYPE_VSOCK
:
878 case KINFO_FILE_VTYPE_VFIFO
:
882 char *str
= get_print_cell ();
884 xsnprintf (str
, PRINT_CELL_SIZE
, "vn:%d", kf_vnode_type
);
888 case KINFO_FILE_TYPE_SOCKET
:
890 case KINFO_FILE_TYPE_PIPE
:
892 case KINFO_FILE_TYPE_FIFO
:
894 case KINFO_FILE_TYPE_KQUEUE
:
896 case KINFO_FILE_TYPE_CRYPTO
:
898 case KINFO_FILE_TYPE_MQUEUE
:
900 case KINFO_FILE_TYPE_SHM
:
902 case KINFO_FILE_TYPE_SEM
:
904 case KINFO_FILE_TYPE_PTS
:
906 case KINFO_FILE_TYPE_PROCDESC
:
909 return int_string (kf_type
, 10, 1, 0, 0);
913 /* Helper function to generate the file flags for a single open file in
914 'info proc files'. */
917 fbsd_file_flags (int kf_flags
)
919 static char file_flags
[10];
921 file_flags
[0] = (kf_flags
& KINFO_FILE_FLAG_READ
) ? 'r' : '-';
922 file_flags
[1] = (kf_flags
& KINFO_FILE_FLAG_WRITE
) ? 'w' : '-';
923 file_flags
[2] = (kf_flags
& KINFO_FILE_FLAG_EXEC
) ? 'x' : '-';
924 file_flags
[3] = (kf_flags
& KINFO_FILE_FLAG_APPEND
) ? 'a' : '-';
925 file_flags
[4] = (kf_flags
& KINFO_FILE_FLAG_ASYNC
) ? 's' : '-';
926 file_flags
[5] = (kf_flags
& KINFO_FILE_FLAG_FSYNC
) ? 'f' : '-';
927 file_flags
[6] = (kf_flags
& KINFO_FILE_FLAG_NONBLOCK
) ? 'n' : '-';
928 file_flags
[7] = (kf_flags
& KINFO_FILE_FLAG_DIRECT
) ? 'd' : '-';
929 file_flags
[8] = (kf_flags
& KINFO_FILE_FLAG_HASLOCK
) ? 'l' : '-';
930 file_flags
[9] = '\0';
935 /* Helper function to generate the name of an IP protocol. */
938 fbsd_ipproto (int protocol
)
942 case FBSD_IPPROTO_ICMP
:
944 case FBSD_IPPROTO_TCP
:
946 case FBSD_IPPROTO_UDP
:
948 case FBSD_IPPROTO_SCTP
:
952 char *str
= get_print_cell ();
954 xsnprintf (str
, PRINT_CELL_SIZE
, "ip<%d>", protocol
);
960 /* Helper function to print out an IPv4 socket address. */
963 fbsd_print_sockaddr_in (const void *sockaddr
)
965 const struct fbsd_sockaddr_in
*sin
=
966 reinterpret_cast<const struct fbsd_sockaddr_in
*> (sockaddr
);
967 char buf
[INET_ADDRSTRLEN
];
969 if (inet_ntop (AF_INET
, sin
->sin_addr
, buf
, sizeof buf
) == nullptr)
970 error (_("Failed to format IPv4 address"));
971 printf_filtered ("%s:%u", buf
,
972 (sin
->sin_port
[0] << 8) | sin
->sin_port
[1]);
975 /* Helper function to print out an IPv6 socket address. */
978 fbsd_print_sockaddr_in6 (const void *sockaddr
)
980 const struct fbsd_sockaddr_in6
*sin6
=
981 reinterpret_cast<const struct fbsd_sockaddr_in6
*> (sockaddr
);
982 char buf
[INET6_ADDRSTRLEN
];
984 if (inet_ntop (AF_INET6
, sin6
->sin6_addr
, buf
, sizeof buf
) == nullptr)
985 error (_("Failed to format IPv6 address"));
986 printf_filtered ("%s.%u", buf
,
987 (sin6
->sin6_port
[0] << 8) | sin6
->sin6_port
[1]);
990 /* See fbsd-tdep.h. */
993 fbsd_info_proc_files_header ()
995 printf_filtered (_("Open files:\n\n"));
996 printf_filtered (" %6s %6s %10s %9s %s\n",
997 "FD", "Type", "Offset", "Flags ", "Name");
1000 /* See fbsd-tdep.h. */
1003 fbsd_info_proc_files_entry (int kf_type
, int kf_fd
, int kf_flags
,
1004 LONGEST kf_offset
, int kf_vnode_type
,
1005 int kf_sock_domain
, int kf_sock_type
,
1006 int kf_sock_protocol
, const void *kf_sa_local
,
1007 const void *kf_sa_peer
, const void *kf_path
)
1009 printf_filtered (" %6s %6s %10s %8s ",
1010 fbsd_file_fd (kf_fd
),
1011 fbsd_file_type (kf_type
, kf_vnode_type
),
1012 kf_offset
> -1 ? hex_string (kf_offset
) : "-",
1013 fbsd_file_flags (kf_flags
));
1014 if (kf_type
== KINFO_FILE_TYPE_SOCKET
)
1016 switch (kf_sock_domain
)
1020 switch (kf_sock_type
)
1022 case FBSD_SOCK_STREAM
:
1023 printf_filtered ("unix stream:");
1025 case FBSD_SOCK_DGRAM
:
1026 printf_filtered ("unix dgram:");
1028 case FBSD_SOCK_SEQPACKET
:
1029 printf_filtered ("unix seqpacket:");
1032 printf_filtered ("unix <%d>:", kf_sock_type
);
1036 /* For local sockets, print out the first non-nul path
1037 rather than both paths. */
1038 const struct fbsd_sockaddr_un
*sun
1039 = reinterpret_cast<const struct fbsd_sockaddr_un
*> (kf_sa_local
);
1040 if (sun
->sun_path
[0] == 0)
1041 sun
= reinterpret_cast<const struct fbsd_sockaddr_un
*>
1043 printf_filtered ("%s", sun
->sun_path
);
1047 printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol
));
1048 fbsd_print_sockaddr_in (kf_sa_local
);
1049 printf_filtered (" -> ");
1050 fbsd_print_sockaddr_in (kf_sa_peer
);
1053 printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol
));
1054 fbsd_print_sockaddr_in6 (kf_sa_local
);
1055 printf_filtered (" -> ");
1056 fbsd_print_sockaddr_in6 (kf_sa_peer
);
1061 printf_filtered ("%s", reinterpret_cast<const char *> (kf_path
));
1062 printf_filtered ("\n");
1065 /* Implement "info proc files" for a corefile. */
1068 fbsd_core_info_proc_files (struct gdbarch
*gdbarch
)
1071 = bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1072 if (section
== NULL
)
1074 warning (_("unable to find open files in core file"));
1078 size_t note_size
= bfd_get_section_size (section
);
1080 error (_("malformed core note - too short for header"));
1082 gdb::def_vector
<unsigned char> contents (note_size
);
1083 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1085 error (_("could not get core note contents"));
1087 unsigned char *descdata
= contents
.data ();
1088 unsigned char *descend
= descdata
+ note_size
;
1090 /* Skip over the structure size. */
1093 fbsd_info_proc_files_header ();
1095 while (descdata
+ KF_PATH
< descend
)
1097 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1098 if (structsize
< KF_PATH
)
1099 error (_("malformed core note - file structure too small"));
1101 LONGEST type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_TYPE
);
1102 LONGEST fd
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
);
1103 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_FLAGS
);
1104 LONGEST offset
= bfd_get_signed_64 (core_bfd
, descdata
+ KF_OFFSET
);
1105 LONGEST vnode_type
= bfd_get_signed_32 (core_bfd
,
1106 descdata
+ KF_VNODE_TYPE
);
1107 LONGEST sock_domain
= bfd_get_signed_32 (core_bfd
,
1108 descdata
+ KF_SOCK_DOMAIN
);
1109 LONGEST sock_type
= bfd_get_signed_32 (core_bfd
, descdata
+ KF_SOCK_TYPE
);
1110 LONGEST sock_protocol
= bfd_get_signed_32 (core_bfd
,
1111 descdata
+ KF_SOCK_PROTOCOL
);
1112 fbsd_info_proc_files_entry (type
, fd
, flags
, offset
, vnode_type
,
1113 sock_domain
, sock_type
, sock_protocol
,
1114 descdata
+ KF_SA_LOCAL
, descdata
+ KF_SA_PEER
,
1115 descdata
+ KF_PATH
);
1117 descdata
+= structsize
;
1121 /* Helper function to generate mappings flags for a single VM map
1122 entry in 'info proc mappings'. */
1125 fbsd_vm_map_entry_flags (int kve_flags
, int kve_protection
)
1127 static char vm_flags
[9];
1129 vm_flags
[0] = (kve_protection
& KINFO_VME_PROT_READ
) ? 'r' : '-';
1130 vm_flags
[1] = (kve_protection
& KINFO_VME_PROT_WRITE
) ? 'w' : '-';
1131 vm_flags
[2] = (kve_protection
& KINFO_VME_PROT_EXEC
) ? 'x' : '-';
1133 vm_flags
[4] = (kve_flags
& KINFO_VME_FLAG_COW
) ? 'C' : '-';
1134 vm_flags
[5] = (kve_flags
& KINFO_VME_FLAG_NEEDS_COPY
) ? 'N' : '-';
1135 vm_flags
[6] = (kve_flags
& KINFO_VME_FLAG_SUPER
) ? 'S' : '-';
1136 vm_flags
[7] = (kve_flags
& KINFO_VME_FLAG_GROWS_UP
) ? 'U'
1137 : (kve_flags
& KINFO_VME_FLAG_GROWS_DOWN
) ? 'D' : '-';
1143 /* See fbsd-tdep.h. */
1146 fbsd_info_proc_mappings_header (int addr_bit
)
1148 printf_filtered (_("Mapped address spaces:\n\n"));
1151 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1154 " Size", " Offset", "Flags ", "File");
1158 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1161 " Size", " Offset", "Flags ", "File");
1165 /* See fbsd-tdep.h. */
1168 fbsd_info_proc_mappings_entry (int addr_bit
, ULONGEST kve_start
,
1169 ULONGEST kve_end
, ULONGEST kve_offset
,
1170 int kve_flags
, int kve_protection
,
1171 const void *kve_path
)
1175 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1176 hex_string (kve_start
),
1177 hex_string (kve_end
),
1178 hex_string (kve_end
- kve_start
),
1179 hex_string (kve_offset
),
1180 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1181 reinterpret_cast<const char *> (kve_path
));
1185 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1186 hex_string (kve_start
),
1187 hex_string (kve_end
),
1188 hex_string (kve_end
- kve_start
),
1189 hex_string (kve_offset
),
1190 fbsd_vm_map_entry_flags (kve_flags
, kve_protection
),
1191 reinterpret_cast<const char *> (kve_path
));
1195 /* Implement "info proc mappings" for a corefile. */
1198 fbsd_core_info_proc_mappings (struct gdbarch
*gdbarch
)
1201 unsigned char *descdata
, *descend
;
1204 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.vmmap");
1205 if (section
== NULL
)
1207 warning (_("unable to find mappings in core file"));
1211 note_size
= bfd_get_section_size (section
);
1213 error (_("malformed core note - too short for header"));
1215 gdb::def_vector
<unsigned char> contents (note_size
);
1216 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1218 error (_("could not get core note contents"));
1220 descdata
= contents
.data ();
1221 descend
= descdata
+ note_size
;
1223 /* Skip over the structure size. */
1226 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch
));
1227 while (descdata
+ KVE_PATH
< descend
)
1229 ULONGEST structsize
= bfd_get_32 (core_bfd
, descdata
+ KVE_STRUCTSIZE
);
1230 if (structsize
< KVE_PATH
)
1231 error (_("malformed core note - vmmap entry too small"));
1233 ULONGEST start
= bfd_get_64 (core_bfd
, descdata
+ KVE_START
);
1234 ULONGEST end
= bfd_get_64 (core_bfd
, descdata
+ KVE_END
);
1235 ULONGEST offset
= bfd_get_64 (core_bfd
, descdata
+ KVE_OFFSET
);
1236 LONGEST flags
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_FLAGS
);
1237 LONGEST prot
= bfd_get_signed_32 (core_bfd
, descdata
+ KVE_PROTECTION
);
1238 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch
), start
, end
,
1239 offset
, flags
, prot
, descdata
+ KVE_PATH
);
1241 descdata
+= structsize
;
1245 /* Fetch the pathname of a vnode for a single file descriptor from the
1246 file table core note. */
1248 static gdb::unique_xmalloc_ptr
<char>
1249 fbsd_core_vnode_path (struct gdbarch
*gdbarch
, int fd
)
1252 unsigned char *descdata
, *descend
;
1255 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.files");
1256 if (section
== NULL
)
1259 note_size
= bfd_get_section_size (section
);
1261 error (_("malformed core note - too short for header"));
1263 gdb::def_vector
<unsigned char> contents (note_size
);
1264 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1266 error (_("could not get core note contents"));
1268 descdata
= contents
.data ();
1269 descend
= descdata
+ note_size
;
1271 /* Skip over the structure size. */
1274 while (descdata
+ KF_PATH
< descend
)
1276 ULONGEST structsize
;
1278 structsize
= bfd_get_32 (core_bfd
, descdata
+ KF_STRUCTSIZE
);
1279 if (structsize
< KF_PATH
)
1280 error (_("malformed core note - file structure too small"));
1282 if (bfd_get_32 (core_bfd
, descdata
+ KF_TYPE
) == KINFO_FILE_TYPE_VNODE
1283 && bfd_get_signed_32 (core_bfd
, descdata
+ KF_FD
) == fd
)
1285 char *path
= (char *) descdata
+ KF_PATH
;
1286 return gdb::unique_xmalloc_ptr
<char> (xstrdup (path
));
1289 descdata
+= structsize
;
1294 /* Helper function to read a struct timeval. */
1297 fbsd_core_fetch_timeval (struct gdbarch
*gdbarch
, unsigned char *data
,
1298 LONGEST
&sec
, ULONGEST
&usec
)
1300 if (gdbarch_addr_bit (gdbarch
) == 64)
1302 sec
= bfd_get_signed_64 (core_bfd
, data
);
1303 usec
= bfd_get_64 (core_bfd
, data
+ 8);
1305 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1307 sec
= bfd_get_signed_32 (core_bfd
, data
);
1308 usec
= bfd_get_32 (core_bfd
, data
+ 4);
1312 sec
= bfd_get_signed_64 (core_bfd
, data
);
1313 usec
= bfd_get_32 (core_bfd
, data
+ 8);
1317 /* Print out the contents of a signal set. */
1320 fbsd_print_sigset (const char *descr
, unsigned char *sigset
)
1322 printf_filtered ("%s: ", descr
);
1323 for (int i
= 0; i
< SIG_WORDS
; i
++)
1324 printf_filtered ("%08x ",
1325 (unsigned int) bfd_get_32 (core_bfd
, sigset
+ i
* 4));
1326 printf_filtered ("\n");
1329 /* Implement "info proc status" for a corefile. */
1332 fbsd_core_info_proc_status (struct gdbarch
*gdbarch
)
1334 const struct kinfo_proc_layout
*kp
;
1336 unsigned char *descdata
;
1337 int addr_bit
, long_bit
;
1342 section
= bfd_get_section_by_name (core_bfd
, ".note.freebsdcore.proc");
1343 if (section
== NULL
)
1345 warning (_("unable to find process info in core file"));
1349 addr_bit
= gdbarch_addr_bit (gdbarch
);
1351 kp
= &kinfo_proc_layout_64
;
1352 else if (bfd_get_arch (core_bfd
) == bfd_arch_i386
)
1353 kp
= &kinfo_proc_layout_i386
;
1355 kp
= &kinfo_proc_layout_32
;
1356 long_bit
= gdbarch_long_bit (gdbarch
);
1359 * Ensure that the note is large enough for all of the fields fetched
1360 * by this function. In particular, the note must contain the 32-bit
1361 * structure size, then it must be long enough to access the last
1362 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1364 note_size
= bfd_get_section_size (section
);
1365 if (note_size
< (4 + kp
->ki_rusage_ch
+ kp
->ru_majflt
1366 + long_bit
/ TARGET_CHAR_BIT
))
1367 error (_("malformed core note - too short"));
1369 gdb::def_vector
<unsigned char> contents (note_size
);
1370 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
1372 error (_("could not get core note contents"));
1374 descdata
= contents
.data ();
1376 /* Skip over the structure size. */
1379 /* Verify 'ki_layout' is 0. */
1380 if (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_layout
) != 0)
1382 warning (_("unsupported process information in core file"));
1386 printf_filtered ("Name: %.19s\n", descdata
+ kp
->ki_comm
);
1387 printf_filtered ("Process ID: %s\n",
1388 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pid
)));
1389 printf_filtered ("Parent process: %s\n",
1390 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ppid
)));
1391 printf_filtered ("Process group: %s\n",
1392 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_pgid
)));
1393 printf_filtered ("Session id: %s\n",
1394 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_sid
)));
1396 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1397 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1398 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1399 the structure that is cleared to zero. Assume that a zero value
1400 in ki_tdev indicates a core dump from an older kernel and use the
1401 value in 'ki_tdev_freebsd11' instead. */
1402 value
= bfd_get_64 (core_bfd
, descdata
+ kp
->ki_tdev
);
1404 value
= bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tdev_freebsd11
);
1405 printf_filtered ("TTY: %s\n", pulongest (value
));
1406 printf_filtered ("TTY owner process group: %s\n",
1407 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_tpgid
)));
1408 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1409 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_ruid
)),
1410 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_uid
)),
1411 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svuid
)));
1412 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1413 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_rgid
)),
1414 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_groups
)),
1415 pulongest (bfd_get_32 (core_bfd
, descdata
+ kp
->ki_svgid
)));
1416 printf_filtered ("Groups: ");
1417 uint16_t ngroups
= bfd_get_16 (core_bfd
, descdata
+ kp
->ki_ngroups
);
1418 for (int i
= 0; i
< ngroups
; i
++)
1419 printf_filtered ("%s ",
1420 pulongest (bfd_get_32 (core_bfd
,
1421 descdata
+ kp
->ki_groups
+ i
* 4)));
1422 printf_filtered ("\n");
1423 value
= bfd_get (long_bit
, core_bfd
,
1424 descdata
+ kp
->ki_rusage
+ kp
->ru_minflt
);
1425 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value
));
1426 value
= bfd_get (long_bit
, core_bfd
,
1427 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_minflt
);
1428 printf_filtered ("Minor faults, children: %s\n", pulongest (value
));
1429 value
= bfd_get (long_bit
, core_bfd
,
1430 descdata
+ kp
->ki_rusage
+ kp
->ru_majflt
);
1431 printf_filtered ("Major faults (memory page faults): %s\n",
1433 value
= bfd_get (long_bit
, core_bfd
,
1434 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_majflt
);
1435 printf_filtered ("Major faults, children: %s\n", pulongest (value
));
1436 fbsd_core_fetch_timeval (gdbarch
,
1437 descdata
+ kp
->ki_rusage
+ kp
->ru_utime
,
1439 printf_filtered ("utime: %s.%06d\n", plongest (sec
), (int) value
);
1440 fbsd_core_fetch_timeval (gdbarch
,
1441 descdata
+ kp
->ki_rusage
+ kp
->ru_stime
,
1443 printf_filtered ("stime: %s.%06d\n", plongest (sec
), (int) value
);
1444 fbsd_core_fetch_timeval (gdbarch
,
1445 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_utime
,
1447 printf_filtered ("utime, children: %s.%06d\n", plongest (sec
), (int) value
);
1448 fbsd_core_fetch_timeval (gdbarch
,
1449 descdata
+ kp
->ki_rusage_ch
+ kp
->ru_stime
,
1451 printf_filtered ("stime, children: %s.%06d\n", plongest (sec
), (int) value
);
1452 printf_filtered ("'nice' value: %d\n",
1453 bfd_get_signed_8 (core_bfd
, descdata
+ kp
->ki_nice
));
1454 fbsd_core_fetch_timeval (gdbarch
, descdata
+ kp
->ki_start
, sec
, value
);
1455 printf_filtered ("Start time: %s.%06d\n", plongest (sec
), (int) value
);
1456 printf_filtered ("Virtual memory size: %s kB\n",
1457 pulongest (bfd_get (addr_bit
, core_bfd
,
1458 descdata
+ kp
->ki_size
) / 1024));
1459 printf_filtered ("Data size: %s pages\n",
1460 pulongest (bfd_get (addr_bit
, core_bfd
,
1461 descdata
+ kp
->ki_dsize
)));
1462 printf_filtered ("Stack size: %s pages\n",
1463 pulongest (bfd_get (addr_bit
, core_bfd
,
1464 descdata
+ kp
->ki_ssize
)));
1465 printf_filtered ("Text size: %s pages\n",
1466 pulongest (bfd_get (addr_bit
, core_bfd
,
1467 descdata
+ kp
->ki_tsize
)));
1468 printf_filtered ("Resident set size: %s pages\n",
1469 pulongest (bfd_get (addr_bit
, core_bfd
,
1470 descdata
+ kp
->ki_rssize
)));
1471 printf_filtered ("Maximum RSS: %s pages\n",
1472 pulongest (bfd_get (long_bit
, core_bfd
,
1473 descdata
+ kp
->ki_rusage
1475 fbsd_print_sigset ("Ignored Signals", descdata
+ kp
->ki_sigignore
);
1476 fbsd_print_sigset ("Caught Signals", descdata
+ kp
->ki_sigcatch
);
1479 /* Implement the "core_info_proc" gdbarch method. */
1482 fbsd_core_info_proc (struct gdbarch
*gdbarch
, const char *args
,
1483 enum info_proc_what what
)
1485 bool do_cmdline
= false;
1486 bool do_cwd
= false;
1487 bool do_exe
= false;
1488 bool do_files
= false;
1489 bool do_mappings
= false;
1490 bool do_status
= false;
1531 pid
= bfd_core_file_pid (core_bfd
);
1533 printf_filtered (_("process %d\n"), pid
);
1537 const char *cmdline
;
1539 cmdline
= bfd_core_file_failing_command (core_bfd
);
1541 printf_filtered ("cmdline = '%s'\n", cmdline
);
1543 warning (_("Command line unavailable"));
1547 gdb::unique_xmalloc_ptr
<char> cwd
=
1548 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_CWD
);
1550 printf_filtered ("cwd = '%s'\n", cwd
.get ());
1552 warning (_("unable to read current working directory"));
1556 gdb::unique_xmalloc_ptr
<char> exe
=
1557 fbsd_core_vnode_path (gdbarch
, KINFO_FILE_FD_TYPE_TEXT
);
1559 printf_filtered ("exe = '%s'\n", exe
.get ());
1561 warning (_("unable to read executable path name"));
1564 fbsd_core_info_proc_files (gdbarch
);
1566 fbsd_core_info_proc_mappings (gdbarch
);
1568 fbsd_core_info_proc_status (gdbarch
);
1571 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1574 fbsd_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1575 CORE_ADDR type
, CORE_ADDR val
)
1577 const char *name
= "???";
1578 const char *description
= "";
1579 enum auxv_format format
= AUXV_FORMAT_HEX
;
1598 default_print_auxv_entry (gdbarch
, file
, type
, val
);
1600 #define _TAGNAME(tag) #tag
1601 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1602 #define TAG(tag, text, kind) \
1603 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1604 TAG (EXECPATH
, _("Executable path"), AUXV_FORMAT_STR
);
1605 TAG (CANARY
, _("Canary for SSP"), AUXV_FORMAT_HEX
);
1606 TAG (CANARYLEN
, ("Length of the SSP canary"), AUXV_FORMAT_DEC
);
1607 TAG (OSRELDATE
, _("OSRELDATE"), AUXV_FORMAT_DEC
);
1608 TAG (NCPUS
, _("Number of CPUs"), AUXV_FORMAT_DEC
);
1609 TAG (PAGESIZES
, _("Pagesizes"), AUXV_FORMAT_HEX
);
1610 TAG (PAGESIZESLEN
, _("Number of pagesizes"), AUXV_FORMAT_DEC
);
1611 TAG (TIMEKEEP
, _("Pointer to timehands"), AUXV_FORMAT_HEX
);
1612 TAG (STACKPROT
, _("Initial stack protection"), AUXV_FORMAT_HEX
);
1613 TAG (EHDRFLAGS
, _("ELF header e_flags"), AUXV_FORMAT_HEX
);
1614 TAG (HWCAP
, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX
);
1615 TAG (HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
1618 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
1621 /* Implement the "get_siginfo_type" gdbarch method. */
1623 static struct type
*
1624 fbsd_get_siginfo_type (struct gdbarch
*gdbarch
)
1626 struct fbsd_gdbarch_data
*fbsd_gdbarch_data
;
1627 struct type
*int_type
, *int32_type
, *uint32_type
, *long_type
, *void_ptr_type
;
1628 struct type
*uid_type
, *pid_type
;
1629 struct type
*sigval_type
, *reason_type
;
1630 struct type
*siginfo_type
;
1633 fbsd_gdbarch_data
= get_fbsd_gdbarch_data (gdbarch
);
1634 if (fbsd_gdbarch_data
->siginfo_type
!= NULL
)
1635 return fbsd_gdbarch_data
->siginfo_type
;
1637 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
1639 int32_type
= arch_integer_type (gdbarch
, 32, 0, "int32_t");
1640 uint32_type
= arch_integer_type (gdbarch
, 32, 1, "uint32_t");
1641 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
1643 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
1646 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1647 TYPE_NAME (sigval_type
) = xstrdup ("sigval");
1648 append_composite_type_field (sigval_type
, "sival_int", int_type
);
1649 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
1652 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1653 TYPE_LENGTH (int32_type
) * TARGET_CHAR_BIT
, "__pid_t");
1654 TYPE_TARGET_TYPE (pid_type
) = int32_type
;
1655 TYPE_TARGET_STUB (pid_type
) = 1;
1658 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
1659 TYPE_LENGTH (uint32_type
) * TARGET_CHAR_BIT
,
1661 TYPE_TARGET_TYPE (uid_type
) = uint32_type
;
1662 TYPE_TARGET_STUB (uid_type
) = 1;
1665 reason_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1668 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1669 append_composite_type_field (type
, "si_trapno", int_type
);
1670 append_composite_type_field (reason_type
, "_fault", type
);
1673 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1674 append_composite_type_field (type
, "si_timerid", int_type
);
1675 append_composite_type_field (type
, "si_overrun", int_type
);
1676 append_composite_type_field (reason_type
, "_timer", type
);
1679 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1680 append_composite_type_field (type
, "si_mqd", int_type
);
1681 append_composite_type_field (reason_type
, "_mesgq", type
);
1684 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1685 append_composite_type_field (type
, "si_band", long_type
);
1686 append_composite_type_field (reason_type
, "_poll", type
);
1689 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1690 append_composite_type_field (type
, "__spare1__", long_type
);
1691 append_composite_type_field (type
, "__spare2__",
1692 init_vector_type (int_type
, 7));
1693 append_composite_type_field (reason_type
, "__spare__", type
);
1695 /* struct siginfo */
1696 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
1697 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
1698 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
1699 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
1700 append_composite_type_field (siginfo_type
, "si_code", int_type
);
1701 append_composite_type_field (siginfo_type
, "si_pid", pid_type
);
1702 append_composite_type_field (siginfo_type
, "si_uid", uid_type
);
1703 append_composite_type_field (siginfo_type
, "si_status", int_type
);
1704 append_composite_type_field (siginfo_type
, "si_addr", void_ptr_type
);
1705 append_composite_type_field (siginfo_type
, "si_value", sigval_type
);
1706 append_composite_type_field (siginfo_type
, "_reason", reason_type
);
1708 fbsd_gdbarch_data
->siginfo_type
= siginfo_type
;
1710 return siginfo_type
;
1713 /* Implement the "gdb_signal_from_target" gdbarch method. */
1715 static enum gdb_signal
1716 fbsd_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1721 return GDB_SIGNAL_0
;
1723 case FREEBSD_SIGHUP
:
1724 return GDB_SIGNAL_HUP
;
1726 case FREEBSD_SIGINT
:
1727 return GDB_SIGNAL_INT
;
1729 case FREEBSD_SIGQUIT
:
1730 return GDB_SIGNAL_QUIT
;
1732 case FREEBSD_SIGILL
:
1733 return GDB_SIGNAL_ILL
;
1735 case FREEBSD_SIGTRAP
:
1736 return GDB_SIGNAL_TRAP
;
1738 case FREEBSD_SIGABRT
:
1739 return GDB_SIGNAL_ABRT
;
1741 case FREEBSD_SIGEMT
:
1742 return GDB_SIGNAL_EMT
;
1744 case FREEBSD_SIGFPE
:
1745 return GDB_SIGNAL_FPE
;
1747 case FREEBSD_SIGKILL
:
1748 return GDB_SIGNAL_KILL
;
1750 case FREEBSD_SIGBUS
:
1751 return GDB_SIGNAL_BUS
;
1753 case FREEBSD_SIGSEGV
:
1754 return GDB_SIGNAL_SEGV
;
1756 case FREEBSD_SIGSYS
:
1757 return GDB_SIGNAL_SYS
;
1759 case FREEBSD_SIGPIPE
:
1760 return GDB_SIGNAL_PIPE
;
1762 case FREEBSD_SIGALRM
:
1763 return GDB_SIGNAL_ALRM
;
1765 case FREEBSD_SIGTERM
:
1766 return GDB_SIGNAL_TERM
;
1768 case FREEBSD_SIGURG
:
1769 return GDB_SIGNAL_URG
;
1771 case FREEBSD_SIGSTOP
:
1772 return GDB_SIGNAL_STOP
;
1774 case FREEBSD_SIGTSTP
:
1775 return GDB_SIGNAL_TSTP
;
1777 case FREEBSD_SIGCONT
:
1778 return GDB_SIGNAL_CONT
;
1780 case FREEBSD_SIGCHLD
:
1781 return GDB_SIGNAL_CHLD
;
1783 case FREEBSD_SIGTTIN
:
1784 return GDB_SIGNAL_TTIN
;
1786 case FREEBSD_SIGTTOU
:
1787 return GDB_SIGNAL_TTOU
;
1790 return GDB_SIGNAL_IO
;
1792 case FREEBSD_SIGXCPU
:
1793 return GDB_SIGNAL_XCPU
;
1795 case FREEBSD_SIGXFSZ
:
1796 return GDB_SIGNAL_XFSZ
;
1798 case FREEBSD_SIGVTALRM
:
1799 return GDB_SIGNAL_VTALRM
;
1801 case FREEBSD_SIGPROF
:
1802 return GDB_SIGNAL_PROF
;
1804 case FREEBSD_SIGWINCH
:
1805 return GDB_SIGNAL_WINCH
;
1807 case FREEBSD_SIGINFO
:
1808 return GDB_SIGNAL_INFO
;
1810 case FREEBSD_SIGUSR1
:
1811 return GDB_SIGNAL_USR1
;
1813 case FREEBSD_SIGUSR2
:
1814 return GDB_SIGNAL_USR2
;
1816 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1817 case FREEBSD_SIGTHR
:
1818 return GDB_SIGNAL_LWP
;
1820 case FREEBSD_SIGLIBRT
:
1821 return GDB_SIGNAL_LIBRT
;
1824 if (signal
>= FREEBSD_SIGRTMIN
&& signal
<= FREEBSD_SIGRTMAX
)
1826 int offset
= signal
- FREEBSD_SIGRTMIN
;
1828 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_65
+ offset
);
1831 return GDB_SIGNAL_UNKNOWN
;
1834 /* Implement the "gdb_signal_to_target" gdbarch method. */
1837 fbsd_gdb_signal_to_target (struct gdbarch
*gdbarch
,
1838 enum gdb_signal signal
)
1845 case GDB_SIGNAL_HUP
:
1846 return FREEBSD_SIGHUP
;
1848 case GDB_SIGNAL_INT
:
1849 return FREEBSD_SIGINT
;
1851 case GDB_SIGNAL_QUIT
:
1852 return FREEBSD_SIGQUIT
;
1854 case GDB_SIGNAL_ILL
:
1855 return FREEBSD_SIGILL
;
1857 case GDB_SIGNAL_TRAP
:
1858 return FREEBSD_SIGTRAP
;
1860 case GDB_SIGNAL_ABRT
:
1861 return FREEBSD_SIGABRT
;
1863 case GDB_SIGNAL_EMT
:
1864 return FREEBSD_SIGEMT
;
1866 case GDB_SIGNAL_FPE
:
1867 return FREEBSD_SIGFPE
;
1869 case GDB_SIGNAL_KILL
:
1870 return FREEBSD_SIGKILL
;
1872 case GDB_SIGNAL_BUS
:
1873 return FREEBSD_SIGBUS
;
1875 case GDB_SIGNAL_SEGV
:
1876 return FREEBSD_SIGSEGV
;
1878 case GDB_SIGNAL_SYS
:
1879 return FREEBSD_SIGSYS
;
1881 case GDB_SIGNAL_PIPE
:
1882 return FREEBSD_SIGPIPE
;
1884 case GDB_SIGNAL_ALRM
:
1885 return FREEBSD_SIGALRM
;
1887 case GDB_SIGNAL_TERM
:
1888 return FREEBSD_SIGTERM
;
1890 case GDB_SIGNAL_URG
:
1891 return FREEBSD_SIGURG
;
1893 case GDB_SIGNAL_STOP
:
1894 return FREEBSD_SIGSTOP
;
1896 case GDB_SIGNAL_TSTP
:
1897 return FREEBSD_SIGTSTP
;
1899 case GDB_SIGNAL_CONT
:
1900 return FREEBSD_SIGCONT
;
1902 case GDB_SIGNAL_CHLD
:
1903 return FREEBSD_SIGCHLD
;
1905 case GDB_SIGNAL_TTIN
:
1906 return FREEBSD_SIGTTIN
;
1908 case GDB_SIGNAL_TTOU
:
1909 return FREEBSD_SIGTTOU
;
1912 return FREEBSD_SIGIO
;
1914 case GDB_SIGNAL_XCPU
:
1915 return FREEBSD_SIGXCPU
;
1917 case GDB_SIGNAL_XFSZ
:
1918 return FREEBSD_SIGXFSZ
;
1920 case GDB_SIGNAL_VTALRM
:
1921 return FREEBSD_SIGVTALRM
;
1923 case GDB_SIGNAL_PROF
:
1924 return FREEBSD_SIGPROF
;
1926 case GDB_SIGNAL_WINCH
:
1927 return FREEBSD_SIGWINCH
;
1929 case GDB_SIGNAL_INFO
:
1930 return FREEBSD_SIGINFO
;
1932 case GDB_SIGNAL_USR1
:
1933 return FREEBSD_SIGUSR1
;
1935 case GDB_SIGNAL_USR2
:
1936 return FREEBSD_SIGUSR2
;
1938 case GDB_SIGNAL_LWP
:
1939 return FREEBSD_SIGTHR
;
1941 case GDB_SIGNAL_LIBRT
:
1942 return FREEBSD_SIGLIBRT
;
1945 if (signal
>= GDB_SIGNAL_REALTIME_65
1946 && signal
<= GDB_SIGNAL_REALTIME_126
)
1948 int offset
= signal
- GDB_SIGNAL_REALTIME_65
;
1950 return FREEBSD_SIGRTMIN
+ offset
;
1956 /* Implement the "get_syscall_number" gdbarch method. */
1959 fbsd_get_syscall_number (struct gdbarch
*gdbarch
, thread_info
*thread
)
1962 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1963 native targets fetch the system call number from the
1964 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1965 However, system call catching requires this function to be
1968 internal_error (__FILE__
, __LINE__
, _("fbsd_get_sycall_number called"));
1971 /* Read an integer symbol value from the current target. */
1974 fbsd_read_integer_by_name (struct gdbarch
*gdbarch
, const char *name
)
1976 bound_minimal_symbol ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1977 if (ms
.minsym
== NULL
)
1978 error (_("Unable to resolve symbol '%s'"), name
);
1981 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms
), buf
, sizeof buf
) != 0)
1982 error (_("Unable to read value of '%s'"), name
);
1984 return extract_signed_integer (buf
, sizeof buf
, gdbarch_byte_order (gdbarch
));
1987 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1988 structure needed to determine the TLS index of an object file. */
1991 fbsd_fetch_rtld_offsets (struct gdbarch
*gdbarch
, struct fbsd_pspace_data
*data
)
1995 /* Fetch offsets from debug symbols in rtld. */
1996 struct symbol
*obj_entry_sym
1997 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL
, STRUCT_DOMAIN
,
1998 language_c
, NULL
).symbol
;
1999 if (obj_entry_sym
== NULL
)
2000 error (_("Unable to find Struct_Obj_Entry symbol"));
2001 data
->off_linkmap
= lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym
),
2002 "linkmap", 0).offset
/ 8;
2003 data
->off_tlsindex
= lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym
),
2004 "tlsindex", 0).offset
/ 8;
2005 data
->rtld_offsets_valid
= true;
2008 CATCH (e
, RETURN_MASK_ERROR
)
2010 data
->off_linkmap
= -1;
2016 /* Fetch offsets from global variables in libthr. Note that
2017 this does not work for single-threaded processes that are not
2018 linked against libthr. */
2019 data
->off_linkmap
= fbsd_read_integer_by_name (gdbarch
,
2020 "_thread_off_linkmap");
2021 data
->off_tlsindex
= fbsd_read_integer_by_name (gdbarch
,
2022 "_thread_off_tlsindex");
2023 data
->rtld_offsets_valid
= true;
2026 CATCH (e
, RETURN_MASK_ERROR
)
2028 data
->off_linkmap
= -1;
2033 /* Helper function to read the TLS index of an object file associated
2034 with a link map entry at LM_ADDR. */
2037 fbsd_get_tls_index (struct gdbarch
*gdbarch
, CORE_ADDR lm_addr
)
2039 struct fbsd_pspace_data
*data
= get_fbsd_pspace_data (current_program_space
);
2041 if (!data
->rtld_offsets_valid
)
2042 fbsd_fetch_rtld_offsets (gdbarch
, data
);
2044 if (data
->off_linkmap
== -1)
2045 throw_error (TLS_GENERIC_ERROR
,
2046 _("Cannot fetch runtime linker structure offsets"));
2048 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2049 pointer and then compute the offset of the tlsindex member. */
2050 CORE_ADDR tlsindex_addr
= lm_addr
- data
->off_linkmap
+ data
->off_tlsindex
;
2053 if (target_read_memory (tlsindex_addr
, buf
, sizeof buf
) != 0)
2054 throw_error (TLS_GENERIC_ERROR
,
2055 _("Cannot find thread-local variables on this target"));
2057 return extract_signed_integer (buf
, sizeof buf
, gdbarch_byte_order (gdbarch
));
2060 /* See fbsd-tdep.h. */
2063 fbsd_get_thread_local_address (struct gdbarch
*gdbarch
, CORE_ADDR dtv_addr
,
2064 CORE_ADDR lm_addr
, CORE_ADDR offset
)
2066 LONGEST tls_index
= fbsd_get_tls_index (gdbarch
, lm_addr
);
2068 gdb_byte buf
[gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
];
2069 if (target_read_memory (dtv_addr
, buf
, sizeof buf
) != 0)
2070 throw_error (TLS_GENERIC_ERROR
,
2071 _("Cannot find thread-local variables on this target"));
2073 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
2074 CORE_ADDR addr
= gdbarch_pointer_to_address (gdbarch
,
2075 builtin
->builtin_data_ptr
, buf
);
2077 addr
+= (tls_index
+ 1) * TYPE_LENGTH (builtin
->builtin_data_ptr
);
2078 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
2079 throw_error (TLS_GENERIC_ERROR
,
2080 _("Cannot find thread-local variables on this target"));
2082 addr
= gdbarch_pointer_to_address (gdbarch
, builtin
->builtin_data_ptr
, buf
);
2083 return addr
+ offset
;
2086 /* To be called from GDB_OSABI_FREEBSD handlers. */
2089 fbsd_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
2091 set_gdbarch_core_pid_to_str (gdbarch
, fbsd_core_pid_to_str
);
2092 set_gdbarch_core_thread_name (gdbarch
, fbsd_core_thread_name
);
2093 set_gdbarch_core_xfer_siginfo (gdbarch
, fbsd_core_xfer_siginfo
);
2094 set_gdbarch_make_corefile_notes (gdbarch
, fbsd_make_corefile_notes
);
2095 set_gdbarch_core_info_proc (gdbarch
, fbsd_core_info_proc
);
2096 set_gdbarch_print_auxv_entry (gdbarch
, fbsd_print_auxv_entry
);
2097 set_gdbarch_get_siginfo_type (gdbarch
, fbsd_get_siginfo_type
);
2098 set_gdbarch_gdb_signal_from_target (gdbarch
, fbsd_gdb_signal_from_target
);
2099 set_gdbarch_gdb_signal_to_target (gdbarch
, fbsd_gdb_signal_to_target
);
2101 /* `catch syscall' */
2102 set_xml_syscall_file_name (gdbarch
, "syscalls/freebsd.xml");
2103 set_gdbarch_get_syscall_number (gdbarch
, fbsd_get_syscall_number
);
2107 _initialize_fbsd_tdep (void)
2109 fbsd_gdbarch_data_handle
=
2110 gdbarch_data_register_post_init (init_fbsd_gdbarch_data
);
2111 fbsd_pspace_data_handle
2112 = register_program_space_data_with_cleanup (NULL
, fbsd_pspace_data_cleanup
);