]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/fbsd-tdep.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR24435, buffer overflow reading dynamic entries
[thirdparty/binutils-gdb.git] / gdb / fbsd-tdep.c
CommitLineData
a904c024
AA		 1/* Target-dependent code for FreeBSD, architecture-independent.
2
42a4f53d 3 Copyright (C) 2002-2019 Free Software Foundation, Inc.
a904c024
AA		 4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
82372b2f 21#include "auxv.h"
a904c024
AA		 22#include "gdbcore.h"
23#include "inferior.h"
24#include "regcache.h"
25#include "regset.h"
4de283e4
TT		 26#include "gdbthread.h"
27#include "objfiles.h"
e6cdd38e 28#include "xml-syscall.h"
4de283e4
TT		 29#include <sys/socket.h>
30#include <arpa/inet.h>
31
32#include "elf-bfd.h"
33#include "fbsd-tdep.h"
a904c024 34
e61667ef
RS		 35/* This enum is derived from FreeBSD's <sys/signal.h>. */
36
37enum
38 {
39 FREEBSD_SIGHUP = 1,
40 FREEBSD_SIGINT = 2,
41 FREEBSD_SIGQUIT = 3,
42 FREEBSD_SIGILL = 4,
43 FREEBSD_SIGTRAP = 5,
44 FREEBSD_SIGABRT = 6,
45 FREEBSD_SIGEMT = 7,
46 FREEBSD_SIGFPE = 8,
47 FREEBSD_SIGKILL = 9,
48 FREEBSD_SIGBUS = 10,
49 FREEBSD_SIGSEGV = 11,
50 FREEBSD_SIGSYS = 12,
51 FREEBSD_SIGPIPE = 13,
52 FREEBSD_SIGALRM = 14,
53 FREEBSD_SIGTERM = 15,
54 FREEBSD_SIGURG = 16,
55 FREEBSD_SIGSTOP = 17,
56 FREEBSD_SIGTSTP = 18,
57 FREEBSD_SIGCONT = 19,
58 FREEBSD_SIGCHLD = 20,
59 FREEBSD_SIGTTIN = 21,
60 FREEBSD_SIGTTOU = 22,
61 FREEBSD_SIGIO = 23,
62 FREEBSD_SIGXCPU = 24,
63 FREEBSD_SIGXFSZ = 25,
64 FREEBSD_SIGVTALRM = 26,
65 FREEBSD_SIGPROF = 27,
66 FREEBSD_SIGWINCH = 28,
67 FREEBSD_SIGINFO = 29,
68 FREEBSD_SIGUSR1 = 30,
69 FREEBSD_SIGUSR2 = 31,
70 FREEBSD_SIGTHR = 32,
71 FREEBSD_SIGLIBRT = 33,
72 FREEBSD_SIGRTMIN = 65,
73 FREEBSD_SIGRTMAX = 126,
74 };
a904c024 75
4b654465
JB		 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. */
83
84#define LWPINFO_OFFSET 0x4
85
86/* Offsets in ptrace_lwpinfo. */
87#define LWPINFO_PL_FLAGS 0x8
88#define LWPINFO64_PL_SIGINFO 0x30
89#define LWPINFO32_PL_SIGINFO 0x2c
90
91/* Flags in pl_flags. */
92#define PL_FLAG_SI 0x20 /* siginfo is valid */
93
94/* Sizes of siginfo_t. */
95#define SIZE64_SIGINFO_T 80
96#define SIZE32_SIGINFO_T 64
97
d2176225
JB		 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
57c2a98a
JB		 101 all architectures.
102
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
107 format. */
d2176225
JB		 108
109#define KVE_STRUCTSIZE 0x0
110#define KVE_START 0x8
111#define KVE_END 0x10
112#define KVE_OFFSET 0x18
113#define KVE_FLAGS 0x2c
906b4aac 114#define KVE_PROTECTION 0x38
d2176225
JB		 115#define KVE_PATH 0x88
116
117/* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
118 match the KVME_PROT_* constants in <sys/user.h>. */
119
120#define KINFO_VME_PROT_READ 0x00000001
121#define KINFO_VME_PROT_WRITE 0x00000002
122#define KINFO_VME_PROT_EXEC 0x00000004
123
124/* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
125 match the KVME_FLAG_* constants in <sys/user.h>. */
126
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
133
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
57c2a98a
JB		 137 architectures.
138
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. */
d2176225
JB		 143
144#define KF_STRUCTSIZE 0x0
145#define KF_TYPE 0x4
146#define KF_FD 0x8
57c2a98a
JB		 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
d2176225
JB		 155#define KF_PATH 0x170
156
157/* Constants for the 'kf_type' field in struct kinfo_file. These
158 match the KF_TYPE_* constants in <sys/user.h>. */
159
160#define KINFO_FILE_TYPE_VNODE 1
57c2a98a
JB		 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
d2176225
JB		 171
172/* Special values for the 'kf_fd' field in struct kinfo_file. These
173 match the KF_FD_TYPE_* constants in <sys/user.h>. */
174
175#define KINFO_FILE_FD_TYPE_CWD -1
57c2a98a
JB		 176#define KINFO_FILE_FD_TYPE_ROOT -2
177#define KINFO_FILE_FD_TYPE_JAIL -3
178#define KINFO_FILE_FD_TYPE_TRACE -4
d2176225 179#define KINFO_FILE_FD_TYPE_TEXT -5
57c2a98a
JB		 180#define KINFO_FILE_FD_TYPE_CTTY -6
181
182/* Flags in the 'kf_flags' field in struct kinfo_file. These match
183 the KF_FLAG_* constants in <sys/user.h>. */
184
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
194
195/* Constants for the 'kf_vnode_type' field in struct kinfo_file.
196 These match the KF_VTYPE_* constants in <sys/user.h>. */
197
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
204
205/* Constants for socket address families. These match AF_* constants
206 in <sys/socket.h>. */
207
208#define FBSD_AF_UNIX 1
209#define FBSD_AF_INET 2
210#define FBSD_AF_INET6 28
211
212/* Constants for socket types. These match SOCK_* constants in
213 <sys/socket.h>. */
214
215#define FBSD_SOCK_STREAM 1
216#define FBSD_SOCK_DGRAM 2
217#define FBSD_SOCK_SEQPACKET 5
218
219/* Constants for IP protocols. These match IPPROTO_* constants in
220 <netinet/in.h>. */
221
222#define FBSD_IPPROTO_ICMP 1
223#define FBSD_IPPROTO_TCP 6
224#define FBSD_IPPROTO_UDP 17
225#define FBSD_IPPROTO_SCTP 132
226
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. */
230
231struct fbsd_sockaddr_in
232{
233 uint8_t sin_len;
234 uint8_t sin_family;
235 uint8_t sin_port[2];
236 uint8_t sin_addr[4];
237 char sin_zero[8];
238};
239
240struct fbsd_sockaddr_in6
241{
242 uint8_t sin6_len;
243 uint8_t sin6_family;
244 uint8_t sin6_port[2];
245 uint32_t sin6_flowinfo;
246 uint8_t sin6_addr[16];
247 uint32_t sin6_scope_id;
248};
249
250struct fbsd_sockaddr_un
251{
252 uint8_t sun_len;
253 uint8_t sun_family;
254 char sun_path[104];
255};
d2176225
JB		 256
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. */
259
260#define SIG_WORDS 4
261
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
267 time_t.
268
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
276 threads. */
277
278struct kinfo_proc_layout
279{
280 /* Offsets of struct kinfo_proc members. */
281 int ki_layout;
282 int ki_pid;
283 int ki_ppid;
284 int ki_pgid;
285 int ki_tpgid;
286 int ki_sid;
287 int ki_tdev_freebsd11;
288 int ki_sigignore;
289 int ki_sigcatch;
290 int ki_uid;
291 int ki_ruid;
292 int ki_svuid;
293 int ki_rgid;
294 int ki_svgid;
295 int ki_ngroups;
296 int ki_groups;
297 int ki_size;
298 int ki_rssize;
299 int ki_tsize;
300 int ki_dsize;
301 int ki_ssize;
302 int ki_start;
303 int ki_nice;
304 int ki_comm;
305 int ki_tdev;
306 int ki_rusage;
307 int ki_rusage_ch;
308
309 /* Offsets of struct rusage members. */
310 int ru_utime;
311 int ru_stime;
312 int ru_maxrss;
313 int ru_minflt;
314 int ru_majflt;
315};
316
317const struct kinfo_proc_layout kinfo_proc_layout_32 =
318 {
319 .ki_layout = 0x4,
320 .ki_pid = 0x28,
321 .ki_ppid = 0x2c,
322 .ki_pgid = 0x30,
323 .ki_tpgid = 0x34,
324 .ki_sid = 0x38,
325 .ki_tdev_freebsd11 = 0x44,
326 .ki_sigignore = 0x68,
327 .ki_sigcatch = 0x78,
328 .ki_uid = 0x88,
329 .ki_ruid = 0x8c,
330 .ki_svuid = 0x90,
331 .ki_rgid = 0x94,
332 .ki_svgid = 0x98,
333 .ki_ngroups = 0x9c,
334 .ki_groups = 0xa0,
335 .ki_size = 0xe0,
336 .ki_rssize = 0xe4,
337 .ki_tsize = 0xec,
338 .ki_dsize = 0xf0,
339 .ki_ssize = 0xf4,
340 .ki_start = 0x118,
341 .ki_nice = 0x145,
342 .ki_comm = 0x17f,
343 .ki_tdev = 0x1f0,
344 .ki_rusage = 0x220,
345 .ki_rusage_ch = 0x278,
346
347 .ru_utime = 0x0,
348 .ru_stime = 0x10,
349 .ru_maxrss = 0x20,
350 .ru_minflt = 0x30,
351 .ru_majflt = 0x34,
352 };
353
354const struct kinfo_proc_layout kinfo_proc_layout_i386 =
355 {
356 .ki_layout = 0x4,
357 .ki_pid = 0x28,
358 .ki_ppid = 0x2c,
359 .ki_pgid = 0x30,
360 .ki_tpgid = 0x34,
361 .ki_sid = 0x38,
362 .ki_tdev_freebsd11 = 0x44,
363 .ki_sigignore = 0x68,
364 .ki_sigcatch = 0x78,
365 .ki_uid = 0x88,
366 .ki_ruid = 0x8c,
367 .ki_svuid = 0x90,
368 .ki_rgid = 0x94,
369 .ki_svgid = 0x98,
370 .ki_ngroups = 0x9c,
371 .ki_groups = 0xa0,
372 .ki_size = 0xe0,
373 .ki_rssize = 0xe4,
374 .ki_tsize = 0xec,
375 .ki_dsize = 0xf0,
376 .ki_ssize = 0xf4,
377 .ki_start = 0x118,
378 .ki_nice = 0x135,
379 .ki_comm = 0x16f,
380 .ki_tdev = 0x1e0,
381 .ki_rusage = 0x210,
382 .ki_rusage_ch = 0x258,
383
384 .ru_utime = 0x0,
385 .ru_stime = 0x8,
386 .ru_maxrss = 0x10,
387 .ru_minflt = 0x20,
388 .ru_majflt = 0x24,
389 };
390
391const struct kinfo_proc_layout kinfo_proc_layout_64 =
392 {
393 .ki_layout = 0x4,
394 .ki_pid = 0x48,
395 .ki_ppid = 0x4c,
396 .ki_pgid = 0x50,
397 .ki_tpgid = 0x54,
398 .ki_sid = 0x58,
399 .ki_tdev_freebsd11 = 0x64,
400 .ki_sigignore = 0x88,
401 .ki_sigcatch = 0x98,
402 .ki_uid = 0xa8,
403 .ki_ruid = 0xac,
404 .ki_svuid = 0xb0,
405 .ki_rgid = 0xb4,
406 .ki_svgid = 0xb8,
407 .ki_ngroups = 0xbc,
408 .ki_groups = 0xc0,
409 .ki_size = 0x100,
410 .ki_rssize = 0x108,
411 .ki_tsize = 0x118,
412 .ki_dsize = 0x120,
413 .ki_ssize = 0x128,
414 .ki_start = 0x150,
415 .ki_nice = 0x185,
416 .ki_comm = 0x1bf,
417 .ki_tdev = 0x230,
418 .ki_rusage = 0x260,
419 .ki_rusage_ch = 0x2f0,
420
421 .ru_utime = 0x0,
422 .ru_stime = 0x10,
423 .ru_maxrss = 0x20,
424 .ru_minflt = 0x40,
425 .ru_majflt = 0x48,
426 };
427
762c974a
JB		 428static struct gdbarch_data *fbsd_gdbarch_data_handle;
429
430struct fbsd_gdbarch_data
431 {
432 struct type *siginfo_type;
433 };
434
435static void *
436init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
437{
438 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
439}
440
441static struct fbsd_gdbarch_data *
442get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
443{
444 return ((struct fbsd_gdbarch_data *)
445 gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
446}
447
945f3901
JB		 448/* Per-program-space data for FreeBSD architectures. */
449static const struct program_space_data *fbsd_pspace_data_handle;
450
451struct fbsd_pspace_data
452{
453 /* Offsets in the runtime linker's 'Obj_Entry' structure. */
454 LONGEST off_linkmap;
455 LONGEST off_tlsindex;
456 bool rtld_offsets_valid;
457};
458
459static struct fbsd_pspace_data *
460get_fbsd_pspace_data (struct program_space *pspace)
461{
462 struct fbsd_pspace_data *data;
463
464 data = ((struct fbsd_pspace_data *)
465 program_space_data (pspace, fbsd_pspace_data_handle));
466 if (data == NULL)
467 {
468 data = XCNEW (struct fbsd_pspace_data);
469 set_program_space_data (pspace, fbsd_pspace_data_handle, data);
470 }
471
472 return data;
473}
474
475/* The cleanup callback for FreeBSD architecture per-program-space data. */
476
477static void
478fbsd_pspace_data_cleanup (struct program_space *pspace, void *data)
479{
480 xfree (data);
481}
482
79117428
JB		 483/* This is how we want PTIDs from core files to be printed. */
484
a068643d 485static std::string
79117428
JB		 486fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
487{
e38504b3 488 if (ptid.lwp () != 0)
a068643d 489 return string_printf ("LWP %ld", ptid.lwp ());
79117428
JB		 490
491 return normal_pid_to_str (ptid);
492}
493
494/* Extract the name assigned to a thread from a core. Returns the
495 string in a static buffer. */
496
497static const char *
498fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
499{
500 static char buf[80];
501 struct bfd_section *section;
502 bfd_size_type size;
79117428 503
e38504b3 504 if (thr->ptid.lwp () != 0)
79117428
JB		 505 {
506 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
507 whose contents are defined by a "struct thrmisc" declared in
508 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
509 a null-terminated string as the first member of the
510 structure. Rather than define the full structure here, just
511 extract the null-terminated name from the start of the
512 note. */
2af9fc44
JB		 513 thread_section_name section_name (".thrmisc", thr->ptid);
514
515 section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
79117428
JB		 516 if (section != NULL && bfd_section_size (core_bfd, section) > 0)
517 {
518 /* Truncate the name if it is longer than "buf". */
519 size = bfd_section_size (core_bfd, section);
520 if (size > sizeof buf - 1)
521 size = sizeof buf - 1;
522 if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
523 size)
524 && buf[0] != '\0')
525 {
526 buf[size] = '\0';
527
528 /* Note that each thread will report the process command
529 as its thread name instead of an empty name if a name
530 has not been set explicitly. Return a NULL name in
531 that case. */
532 if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
533 return buf;
534 }
535 }
536 }
537
538 return NULL;
539}
540
4b654465
JB		 541/* Implement the "core_xfer_siginfo" gdbarch method. */
542
543static LONGEST
544fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
545 ULONGEST offset, ULONGEST len)
546{
547 size_t siginfo_size;
548
a181c0bf 549 if (gdbarch_long_bit (gdbarch) == 32)
4b654465
JB		 550 siginfo_size = SIZE32_SIGINFO_T;
551 else
552 siginfo_size = SIZE64_SIGINFO_T;
553 if (offset > siginfo_size)
554 return -1;
555
556 thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
557 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
558 if (section == NULL)
559 return -1;
560
561 gdb_byte buf[4];
562 if (!bfd_get_section_contents (core_bfd, section, buf,
563 LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
564 return -1;
565
566 int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
567 if (!(pl_flags & PL_FLAG_SI))
568 return -1;
569
570 if (offset + len > siginfo_size)
571 len = siginfo_size - offset;
572
573 ULONGEST siginfo_offset;
a181c0bf 574 if (gdbarch_long_bit (gdbarch) == 32)
4b654465
JB		 575 siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
576 else
577 siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
578
579 if (!bfd_get_section_contents (core_bfd, section, readbuf,
580 siginfo_offset + offset, len))
581 return -1;
582
583 return len;
584}
585
a904c024
AA		 586static int
587find_signalled_thread (struct thread_info *info, void *data)
588{
589 if (info->suspend.stop_signal != GDB_SIGNAL_0
e99b03dc 590 && info->ptid.pid () == inferior_ptid.pid ())
a904c024
AA		 591 return 1;
592
593 return 0;
594}
595
20a0aab3
JB		 596/* Structure for passing information from
597 fbsd_collect_thread_registers via an iterator to
598 fbsd_collect_regset_section_cb. */
a904c024
AA		 599
600struct fbsd_collect_regset_section_cb_data
601{
602 const struct regcache *regcache;
603 bfd *obfd;
604 char *note_data;
605 int *note_size;
20a0aab3
JB		 606 unsigned long lwp;
607 enum gdb_signal stop_signal;
608 int abort_iteration;
a904c024
AA		 609};
610
611static void
a616bb94
AH		 612fbsd_collect_regset_section_cb (const char *sect_name, int supply_size,
613 int collect_size, const struct regset *regset,
a904c024
AA		 614 const char *human_name, void *cb_data)
615{
616 char *buf;
7567e115
SM		 617 struct fbsd_collect_regset_section_cb_data *data
618 = (struct fbsd_collect_regset_section_cb_data *) cb_data;
a904c024 619
20a0aab3
JB		 620 if (data->abort_iteration)
621 return;
622
a904c024
AA		 623 gdb_assert (regset->collect_regset);
624
a616bb94
AH		 625 buf = (char *) xmalloc (collect_size);
626 regset->collect_regset (regset, data->regcache, -1, buf, collect_size);
a904c024
AA		 627
628 /* PRSTATUS still needs to be treated specially. */
629 if (strcmp (sect_name, ".reg") == 0)
630 data->note_data = (char *) elfcore_write_prstatus
20a0aab3
JB		 631 (data->obfd, data->note_data, data->note_size, data->lwp,
632 gdb_signal_to_host (data->stop_signal), buf);
a904c024
AA		 633 else
634 data->note_data = (char *) elfcore_write_register_note
635 (data->obfd, data->note_data, data->note_size,
a616bb94 636 sect_name, buf, collect_size);
a904c024 637 xfree (buf);
20a0aab3
JB		 638
639 if (data->note_data == NULL)
640 data->abort_iteration = 1;
641}
642
643/* Records the thread's register state for the corefile note
644 section. */
645
646static char *
647fbsd_collect_thread_registers (const struct regcache *regcache,
648 ptid_t ptid, bfd *obfd,
649 char *note_data, int *note_size,
650 enum gdb_signal stop_signal)
651{
ac7936df 652 struct gdbarch *gdbarch = regcache->arch ();
20a0aab3
JB		 653 struct fbsd_collect_regset_section_cb_data data;
654
655 data.regcache = regcache;
656 data.obfd = obfd;
657 data.note_data = note_data;
658 data.note_size = note_size;
659 data.stop_signal = stop_signal;
660 data.abort_iteration = 0;
e38504b3 661 data.lwp = ptid.lwp ();
20a0aab3
JB		 662
663 gdbarch_iterate_over_regset_sections (gdbarch,
664 fbsd_collect_regset_section_cb,
665 &data, regcache);
666 return data.note_data;
667}
668
669struct fbsd_corefile_thread_data
670{
671 struct gdbarch *gdbarch;
672 bfd *obfd;
673 char *note_data;
674 int *note_size;
675 enum gdb_signal stop_signal;
676};
677
678/* Records the thread's register state for the corefile note
679 section. */
680
681static void
682fbsd_corefile_thread (struct thread_info *info,
683 struct fbsd_corefile_thread_data *args)
684{
20a0aab3
JB		 685 struct regcache *regcache;
686
687 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
688
20a0aab3 689 target_fetch_registers (regcache, -1);
20a0aab3
JB		 690
691 args->note_data = fbsd_collect_thread_registers
692 (regcache, info->ptid, args->obfd, args->note_data,
693 args->note_size, args->stop_signal);
a904c024
AA		 694}
695
739ab2e9
SS		 696/* Return a byte_vector containing the contents of a core dump note
697 for the target object of type OBJECT. If STRUCTSIZE is non-zero,
698 the data is prefixed with a 32-bit integer size to match the format
699 used in FreeBSD NT_PROCSTAT_* notes. */
700
701static gdb::optional<gdb::byte_vector>
702fbsd_make_note_desc (enum target_object object, uint32_t structsize)
703{
704 gdb::optional<gdb::byte_vector> buf =
705 target_read_alloc (current_top_target (), object, NULL);
706 if (!buf || buf->empty ())
707 return {};
708
709 if (structsize == 0)
710 return buf;
711
712 gdb::byte_vector desc (sizeof (structsize) + buf->size ());
713 memcpy (desc.data (), &structsize, sizeof (structsize));
714 memcpy (desc.data () + sizeof (structsize), buf->data (), buf->size ());
715 return desc;
716}
717
a904c024
AA		 718/* Create appropriate note sections for a corefile, returning them in
719 allocated memory. */
720
721static char *
722fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
723{
20a0aab3
JB		 724 struct fbsd_corefile_thread_data thread_args;
725 char *note_data = NULL;
a904c024 726 Elf_Internal_Ehdr *i_ehdrp;
08036331 727 struct thread_info *curr_thr, *signalled_thr;
a904c024
AA		 728
729 /* Put a "FreeBSD" label in the ELF header. */
730 i_ehdrp = elf_elfheader (obfd);
731 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
732
733 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
734
a904c024
AA		 735 if (get_exec_file (0))
736 {
737 const char *fname = lbasename (get_exec_file (0));
738 char *psargs = xstrdup (fname);
739
740 if (get_inferior_args ())
741 psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
742 (char *) NULL);
743
744 note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
745 fname, psargs);
746 }
747
20a0aab3 748 /* Thread register information. */
a70b8144 749 try
20a0aab3
JB		 750 {
751 update_thread_list ();
752 }
230d2906 753 catch (const gdb_exception_error &e)
20a0aab3
JB		 754 {
755 exception_print (gdb_stderr, e);
756 }
20a0aab3
JB		 757
758 /* Like the kernel, prefer dumping the signalled thread first.
759 "First thread" is what tools use to infer the signalled thread.
760 In case there's more than one signalled thread, prefer the
761 current thread, if it is signalled. */
762 curr_thr = inferior_thread ();
763 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
764 signalled_thr = curr_thr;
765 else
766 {
767 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
768 if (signalled_thr == NULL)
769 signalled_thr = curr_thr;
770 }
771
772 thread_args.gdbarch = gdbarch;
773 thread_args.obfd = obfd;
774 thread_args.note_data = note_data;
775 thread_args.note_size = note_size;
776 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
777
778 fbsd_corefile_thread (signalled_thr, &thread_args);
08036331 779 for (thread_info *thr : current_inferior ()->non_exited_threads ())
20a0aab3
JB		 780 {
781 if (thr == signalled_thr)
782 continue;
20a0aab3
JB		 783
784 fbsd_corefile_thread (thr, &thread_args);
785 }
786
787 note_data = thread_args.note_data;
788
739ab2e9
SS		 789 /* Auxiliary vector. */
790 uint32_t structsize = gdbarch_ptr_bit (gdbarch) / 4; /* Elf_Auxinfo */
791 gdb::optional<gdb::byte_vector> note_desc =
792 fbsd_make_note_desc (TARGET_OBJECT_AUXV, structsize);
793 if (note_desc && !note_desc->empty ())
794 {
795 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
796 NT_FREEBSD_PROCSTAT_AUXV,
797 note_desc->data (), note_desc->size ());
798 if (!note_data)
799 return NULL;
800 }
801
802 /* Virtual memory mappings. */
803 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP, 0);
804 if (note_desc && !note_desc->empty ())
805 {
806 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
807 NT_FREEBSD_PROCSTAT_VMMAP,
808 note_desc->data (), note_desc->size ());
809 if (!note_data)
810 return NULL;
811 }
812
813 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS, 0);
814 if (note_desc && !note_desc->empty ())
815 {
816 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
817 NT_FREEBSD_PROCSTAT_PSSTRINGS,
818 note_desc->data (), note_desc->size ());
819 if (!note_data)
820 return NULL;
821 }
822
a904c024
AA		 823 return note_data;
824}
825
57c2a98a
JB		 826/* Helper function to generate the file descriptor description for a
827 single open file in 'info proc files'. */
828
829static const char *
830fbsd_file_fd (int kf_fd)
831{
832 switch (kf_fd)
833 {
834 case KINFO_FILE_FD_TYPE_CWD:
835 return "cwd";
836 case KINFO_FILE_FD_TYPE_ROOT:
837 return "root";
838 case KINFO_FILE_FD_TYPE_JAIL:
839 return "jail";
840 case KINFO_FILE_FD_TYPE_TRACE:
841 return "trace";
842 case KINFO_FILE_FD_TYPE_TEXT:
843 return "text";
844 case KINFO_FILE_FD_TYPE_CTTY:
845 return "ctty";
846 default:
847 return int_string (kf_fd, 10, 1, 0, 0);
848 }
849}
850
851/* Helper function to generate the file type for a single open file in
852 'info proc files'. */
853
854static const char *
855fbsd_file_type (int kf_type, int kf_vnode_type)
856{
857 switch (kf_type)
858 {
859 case KINFO_FILE_TYPE_VNODE:
860 switch (kf_vnode_type)
861 {
862 case KINFO_FILE_VTYPE_VREG:
863 return "file";
864 case KINFO_FILE_VTYPE_VDIR:
865 return "dir";
866 case KINFO_FILE_VTYPE_VCHR:
867 return "chr";
868 case KINFO_FILE_VTYPE_VLNK:
869 return "link";
870 case KINFO_FILE_VTYPE_VSOCK:
871 return "socket";
872 case KINFO_FILE_VTYPE_VFIFO:
873 return "fifo";
874 default:
875 {
876 char *str = get_print_cell ();
877
878 xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type);
879 return str;
880 }
881 }
882 case KINFO_FILE_TYPE_SOCKET:
883 return "socket";
884 case KINFO_FILE_TYPE_PIPE:
885 return "pipe";
886 case KINFO_FILE_TYPE_FIFO:
887 return "fifo";
888 case KINFO_FILE_TYPE_KQUEUE:
889 return "kqueue";
890 case KINFO_FILE_TYPE_CRYPTO:
891 return "crypto";
892 case KINFO_FILE_TYPE_MQUEUE:
893 return "mqueue";
894 case KINFO_FILE_TYPE_SHM:
895 return "shm";
896 case KINFO_FILE_TYPE_SEM:
897 return "sem";
898 case KINFO_FILE_TYPE_PTS:
899 return "pts";
900 case KINFO_FILE_TYPE_PROCDESC:
901 return "proc";
902 default:
903 return int_string (kf_type, 10, 1, 0, 0);
904 }
905}
906
907/* Helper function to generate the file flags for a single open file in
908 'info proc files'. */
909
910static const char *
911fbsd_file_flags (int kf_flags)
912{
913 static char file_flags[10];
914
915 file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-';
916 file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-';
917 file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-';
918 file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-';
919 file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-';
920 file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-';
921 file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-';
922 file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-';
923 file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-';
924 file_flags[9] = '\0';
925
926 return file_flags;
927}
928
929/* Helper function to generate the name of an IP protocol. */
930
931static const char *
932fbsd_ipproto (int protocol)
933{
934 switch (protocol)
935 {
936 case FBSD_IPPROTO_ICMP:
937 return "icmp";
938 case FBSD_IPPROTO_TCP:
939 return "tcp";
940 case FBSD_IPPROTO_UDP:
941 return "udp";
942 case FBSD_IPPROTO_SCTP:
943 return "sctp";
944 default:
945 {
946 char *str = get_print_cell ();
947
948 xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol);
949 return str;
950 }
951 }
952}
953
954/* Helper function to print out an IPv4 socket address. */
955
956static void
957fbsd_print_sockaddr_in (const void *sockaddr)
958{
959 const struct fbsd_sockaddr_in *sin =
960 reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr);
961 char buf[INET_ADDRSTRLEN];
962
07147793 963 if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 964 error (_("Failed to format IPv4 address"));
965 printf_filtered ("%s:%u", buf,
966 (sin->sin_port[0] << 8) | sin->sin_port[1]);
967}
968
969/* Helper function to print out an IPv6 socket address. */
970
971static void
972fbsd_print_sockaddr_in6 (const void *sockaddr)
973{
974 const struct fbsd_sockaddr_in6 *sin6 =
975 reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr);
976 char buf[INET6_ADDRSTRLEN];
977
07147793 978 if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 979 error (_("Failed to format IPv6 address"));
980 printf_filtered ("%s.%u", buf,
981 (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]);
982}
983
984/* See fbsd-tdep.h. */
985
986void
987fbsd_info_proc_files_header ()
988{
989 printf_filtered (_("Open files:\n\n"));
990 printf_filtered (" %6s %6s %10s %9s %s\n",
991 "FD", "Type", "Offset", "Flags ", "Name");
992}
993
994/* See fbsd-tdep.h. */
995
996void
997fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags,
998 LONGEST kf_offset, int kf_vnode_type,
999 int kf_sock_domain, int kf_sock_type,
1000 int kf_sock_protocol, const void *kf_sa_local,
1001 const void *kf_sa_peer, const void *kf_path)
1002{
1003 printf_filtered (" %6s %6s %10s %8s ",
1004 fbsd_file_fd (kf_fd),
1005 fbsd_file_type (kf_type, kf_vnode_type),
1006 kf_offset > -1 ? hex_string (kf_offset) : "-",
1007 fbsd_file_flags (kf_flags));
1008 if (kf_type == KINFO_FILE_TYPE_SOCKET)
1009 {
1010 switch (kf_sock_domain)
1011 {
1012 case FBSD_AF_UNIX:
1013 {
1014 switch (kf_sock_type)
1015 {
1016 case FBSD_SOCK_STREAM:
1017 printf_filtered ("unix stream:");
1018 break;
1019 case FBSD_SOCK_DGRAM:
1020 printf_filtered ("unix dgram:");
1021 break;
1022 case FBSD_SOCK_SEQPACKET:
1023 printf_filtered ("unix seqpacket:");
1024 break;
1025 default:
1026 printf_filtered ("unix <%d>:", kf_sock_type);
1027 break;
1028 }
1029
1030 /* For local sockets, print out the first non-nul path
1031 rather than both paths. */
1032 const struct fbsd_sockaddr_un *sun
1033 = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local);
1034 if (sun->sun_path[0] == 0)
1035 sun = reinterpret_cast<const struct fbsd_sockaddr_un *>
1036 (kf_sa_peer);
1037 printf_filtered ("%s", sun->sun_path);
1038 break;
1039 }
1040 case FBSD_AF_INET:
1041 printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol));
1042 fbsd_print_sockaddr_in (kf_sa_local);
1043 printf_filtered (" -> ");
1044 fbsd_print_sockaddr_in (kf_sa_peer);
1045 break;
1046 case FBSD_AF_INET6:
1047 printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol));
1048 fbsd_print_sockaddr_in6 (kf_sa_local);
1049 printf_filtered (" -> ");
1050 fbsd_print_sockaddr_in6 (kf_sa_peer);
1051 break;
1052 }
1053 }
1054 else
1055 printf_filtered ("%s", reinterpret_cast<const char *> (kf_path));
1056 printf_filtered ("\n");
1057}
1058
1059/* Implement "info proc files" for a corefile. */
1060
1061static void
1062fbsd_core_info_proc_files (struct gdbarch *gdbarch)
1063{
1064 asection *section
1065 = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1066 if (section == NULL)
1067 {
1068 warning (_("unable to find open files in core file"));
1069 return;
1070 }
1071
1072 size_t note_size = bfd_get_section_size (section);
1073 if (note_size < 4)
1074 error (_("malformed core note - too short for header"));
1075
1076 gdb::def_vector<unsigned char> contents (note_size);
1077 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1078 0, note_size))
1079 error (_("could not get core note contents"));
1080
1081 unsigned char *descdata = contents.data ();
1082 unsigned char *descend = descdata + note_size;
1083
1084 /* Skip over the structure size. */
1085 descdata += 4;
1086
1087 fbsd_info_proc_files_header ();
1088
1089 while (descdata + KF_PATH < descend)
1090 {
1091 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
1092 if (structsize < KF_PATH)
1093 error (_("malformed core note - file structure too small"));
1094
1095 LONGEST type = bfd_get_signed_32 (core_bfd, descdata + KF_TYPE);
1096 LONGEST fd = bfd_get_signed_32 (core_bfd, descdata + KF_FD);
1097 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KF_FLAGS);
1098 LONGEST offset = bfd_get_signed_64 (core_bfd, descdata + KF_OFFSET);
1099 LONGEST vnode_type = bfd_get_signed_32 (core_bfd,
1100 descdata + KF_VNODE_TYPE);
1101 LONGEST sock_domain = bfd_get_signed_32 (core_bfd,
1102 descdata + KF_SOCK_DOMAIN);
1103 LONGEST sock_type = bfd_get_signed_32 (core_bfd, descdata + KF_SOCK_TYPE);
1104 LONGEST sock_protocol = bfd_get_signed_32 (core_bfd,
1105 descdata + KF_SOCK_PROTOCOL);
1106 fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type,
1107 sock_domain, sock_type, sock_protocol,
1108 descdata + KF_SA_LOCAL, descdata + KF_SA_PEER,
1109 descdata + KF_PATH);
1110
1111 descdata += structsize;
1112 }
1113}
1114
d2176225
JB		 1115/* Helper function to generate mappings flags for a single VM map
1116 entry in 'info proc mappings'. */
1117
6f3b1098 1118static const char *
d2176225
JB		 1119fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
1120{
1121 static char vm_flags[9];
1122
1123 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
1124 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
1125 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
1126 vm_flags[3] = ' ';
1127 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
1128 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
1129 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
1130 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
1131 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
1132 vm_flags[8] = '\0';
1133
1134 return vm_flags;
1135}
1136
6f3b1098
JB		 1137/* See fbsd-tdep.h. */
1138
1139void
1140fbsd_info_proc_mappings_header (int addr_bit)
1141{
1142 printf_filtered (_("Mapped address spaces:\n\n"));
1143 if (addr_bit == 64)
1144 {
1145 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1146 "Start Addr",
1147 " End Addr",
1148 " Size", " Offset", "Flags ", "File");
1149 }
1150 else
1151 {
1152 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1153 "Start Addr",
1154 " End Addr",
1155 " Size", " Offset", "Flags ", "File");
1156 }
1157}
1158
1159/* See fbsd-tdep.h. */
1160
1161void
1162fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
1163 ULONGEST kve_end, ULONGEST kve_offset,
1164 int kve_flags, int kve_protection,
1165 const void *kve_path)
1166{
1167 if (addr_bit == 64)
1168 {
1169 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1170 hex_string (kve_start),
1171 hex_string (kve_end),
1172 hex_string (kve_end - kve_start),
1173 hex_string (kve_offset),
1174 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1175 reinterpret_cast<const char *> (kve_path));
1176 }
1177 else
1178 {
1179 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1180 hex_string (kve_start),
1181 hex_string (kve_end),
1182 hex_string (kve_end - kve_start),
1183 hex_string (kve_offset),
1184 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1185 reinterpret_cast<const char *> (kve_path));
1186 }
1187}
1188
d2176225
JB		 1189/* Implement "info proc mappings" for a corefile. */
1190
1191static void
1192fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
1193{
1194 asection *section;
1195 unsigned char *descdata, *descend;
1196 size_t note_size;
1197
1198 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
1199 if (section == NULL)
1200 {
1201 warning (_("unable to find mappings in core file"));
1202 return;
1203 }
1204
1205 note_size = bfd_get_section_size (section);
1206 if (note_size < 4)
1207 error (_("malformed core note - too short for header"));
1208
1209 gdb::def_vector<unsigned char> contents (note_size);
1210 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1211 0, note_size))
1212 error (_("could not get core note contents"));
1213
1214 descdata = contents.data ();
1215 descend = descdata + note_size;
1216
1217 /* Skip over the structure size. */
1218 descdata += 4;
1219
6f3b1098 1220 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch));
d2176225
JB		 1221 while (descdata + KVE_PATH < descend)
1222 {
6f3b1098 1223 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
d2176225
JB		 1224 if (structsize < KVE_PATH)
1225 error (_("malformed core note - vmmap entry too small"));
1226
6f3b1098
JB		 1227 ULONGEST start = bfd_get_64 (core_bfd, descdata + KVE_START);
1228 ULONGEST end = bfd_get_64 (core_bfd, descdata + KVE_END);
1229 ULONGEST offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
1230 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KVE_FLAGS);
1231 LONGEST prot = bfd_get_signed_32 (core_bfd, descdata + KVE_PROTECTION);
1232 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end,
1233 offset, flags, prot, descdata + KVE_PATH);
d2176225
JB		 1234
1235 descdata += structsize;
1236 }
1237}
1238
1239/* Fetch the pathname of a vnode for a single file descriptor from the
1240 file table core note. */
1241
1242static gdb::unique_xmalloc_ptr<char>
1243fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
1244{
1245 asection *section;
1246 unsigned char *descdata, *descend;
1247 size_t note_size;
1248
1249 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1250 if (section == NULL)
1251 return nullptr;
1252
1253 note_size = bfd_get_section_size (section);
1254 if (note_size < 4)
1255 error (_("malformed core note - too short for header"));
1256
1257 gdb::def_vector<unsigned char> contents (note_size);
1258 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1259 0, note_size))
1260 error (_("could not get core note contents"));
1261
1262 descdata = contents.data ();
1263 descend = descdata + note_size;
1264
1265 /* Skip over the structure size. */
1266 descdata += 4;
1267
9f235e09 1268 while (descdata + KF_PATH < descend)
d2176225
JB		 1269 {
1270 ULONGEST structsize;
1271
1272 structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
9f235e09
JB		 1273 if (structsize < KF_PATH)
1274 error (_("malformed core note - file structure too small"));
d2176225
JB		 1275
1276 if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
1277 && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
1278 {
1279 char *path = (char *) descdata + KF_PATH;
1280 return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
1281 }
1282
1283 descdata += structsize;
1284 }
1285 return nullptr;
1286}
1287
1288/* Helper function to read a struct timeval. */
1289
1290static void
1291fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
1292 LONGEST &sec, ULONGEST &usec)
1293{
1294 if (gdbarch_addr_bit (gdbarch) == 64)
1295 {
1296 sec = bfd_get_signed_64 (core_bfd, data);
1297 usec = bfd_get_64 (core_bfd, data + 8);
1298 }
1299 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1300 {
1301 sec = bfd_get_signed_32 (core_bfd, data);
1302 usec = bfd_get_32 (core_bfd, data + 4);
1303 }
1304 else
1305 {
1306 sec = bfd_get_signed_64 (core_bfd, data);
1307 usec = bfd_get_32 (core_bfd, data + 8);
1308 }
1309}
1310
1311/* Print out the contents of a signal set. */
1312
1313static void
1314fbsd_print_sigset (const char *descr, unsigned char *sigset)
1315{
1316 printf_filtered ("%s: ", descr);
1317 for (int i = 0; i < SIG_WORDS; i++)
1318 printf_filtered ("%08x ",
1319 (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
1320 printf_filtered ("\n");
1321}
1322
1323/* Implement "info proc status" for a corefile. */
1324
1325static void
1326fbsd_core_info_proc_status (struct gdbarch *gdbarch)
1327{
1328 const struct kinfo_proc_layout *kp;
1329 asection *section;
d2176225
JB		 1330 unsigned char *descdata;
1331 int addr_bit, long_bit;
1332 size_t note_size;
1333 ULONGEST value;
1334 LONGEST sec;
1335
1336 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
1337 if (section == NULL)
1338 {
1339 warning (_("unable to find process info in core file"));
1340 return;
1341 }
1342
1343 addr_bit = gdbarch_addr_bit (gdbarch);
1344 if (addr_bit == 64)
1345 kp = &kinfo_proc_layout_64;
1346 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1347 kp = &kinfo_proc_layout_i386;
1348 else
1349 kp = &kinfo_proc_layout_32;
1350 long_bit = gdbarch_long_bit (gdbarch);
1351
1352 /*
1353 * Ensure that the note is large enough for all of the fields fetched
1354 * by this function. In particular, the note must contain the 32-bit
1355 * structure size, then it must be long enough to access the last
1356 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1357 */
1358 note_size = bfd_get_section_size (section);
1359 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
1360 + long_bit / TARGET_CHAR_BIT))
1361 error (_("malformed core note - too short"));
1362
1363 gdb::def_vector<unsigned char> contents (note_size);
1364 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1365 0, note_size))
1366 error (_("could not get core note contents"));
1367
1368 descdata = contents.data ();
1369
1370 /* Skip over the structure size. */
1371 descdata += 4;
1372
1373 /* Verify 'ki_layout' is 0. */
1374 if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
1375 {
1376 warning (_("unsupported process information in core file"));
1377 return;
1378 }
1379
1380 printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
1381 printf_filtered ("Process ID: %s\n",
1382 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
1383 printf_filtered ("Parent process: %s\n",
1384 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
1385 printf_filtered ("Process group: %s\n",
1386 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
1387 printf_filtered ("Session id: %s\n",
1388 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
1389
1390 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1391 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1392 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1393 the structure that is cleared to zero. Assume that a zero value
1394 in ki_tdev indicates a core dump from an older kernel and use the
1395 value in 'ki_tdev_freebsd11' instead. */
1396 value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
1397 if (value == 0)
1398 value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
1399 printf_filtered ("TTY: %s\n", pulongest (value));
1400 printf_filtered ("TTY owner process group: %s\n",
1401 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
1402 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1403 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
1404 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
1405 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
1406 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1407 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
1408 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
1409 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
1410 printf_filtered ("Groups: ");
1411 uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
1412 for (int i = 0; i < ngroups; i++)
1413 printf_filtered ("%s ",
1414 pulongest (bfd_get_32 (core_bfd,
1415 descdata + kp->ki_groups + i * 4)));
1416 printf_filtered ("\n");
1417 value = bfd_get (long_bit, core_bfd,
1418 descdata + kp->ki_rusage + kp->ru_minflt);
1419 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
1420 value = bfd_get (long_bit, core_bfd,
1421 descdata + kp->ki_rusage_ch + kp->ru_minflt);
1422 printf_filtered ("Minor faults, children: %s\n", pulongest (value));
1423 value = bfd_get (long_bit, core_bfd,
1424 descdata + kp->ki_rusage + kp->ru_majflt);
1425 printf_filtered ("Major faults (memory page faults): %s\n",
1426 pulongest (value));
1427 value = bfd_get (long_bit, core_bfd,
1428 descdata + kp->ki_rusage_ch + kp->ru_majflt);
1429 printf_filtered ("Major faults, children: %s\n", pulongest (value));
1430 fbsd_core_fetch_timeval (gdbarch,
1431 descdata + kp->ki_rusage + kp->ru_utime,
1432 sec, value);
1433 printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
1434 fbsd_core_fetch_timeval (gdbarch,
1435 descdata + kp->ki_rusage + kp->ru_stime,
1436 sec, value);
1437 printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
1438 fbsd_core_fetch_timeval (gdbarch,
1439 descdata + kp->ki_rusage_ch + kp->ru_utime,
1440 sec, value);
1441 printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
1442 fbsd_core_fetch_timeval (gdbarch,
1443 descdata + kp->ki_rusage_ch + kp->ru_stime,
1444 sec, value);
1445 printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
1446 printf_filtered ("'nice' value: %d\n",
1447 bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
1448 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
1449 printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
1450 printf_filtered ("Virtual memory size: %s kB\n",
1451 pulongest (bfd_get (addr_bit, core_bfd,
1452 descdata + kp->ki_size) / 1024));
1453 printf_filtered ("Data size: %s pages\n",
1454 pulongest (bfd_get (addr_bit, core_bfd,
1455 descdata + kp->ki_dsize)));
1456 printf_filtered ("Stack size: %s pages\n",
1457 pulongest (bfd_get (addr_bit, core_bfd,
1458 descdata + kp->ki_ssize)));
1459 printf_filtered ("Text size: %s pages\n",
1460 pulongest (bfd_get (addr_bit, core_bfd,
1461 descdata + kp->ki_tsize)));
1462 printf_filtered ("Resident set size: %s pages\n",
1463 pulongest (bfd_get (addr_bit, core_bfd,
1464 descdata + kp->ki_rssize)));
1465 printf_filtered ("Maximum RSS: %s pages\n",
1466 pulongest (bfd_get (long_bit, core_bfd,
1467 descdata + kp->ki_rusage
1468 + kp->ru_maxrss)));
1469 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
1470 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
1471}
1472
1473/* Implement the "core_info_proc" gdbarch method. */
1474
1475static void
1476fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
1477 enum info_proc_what what)
1478{
1479 bool do_cmdline = false;
1480 bool do_cwd = false;
1481 bool do_exe = false;
57c2a98a 1482 bool do_files = false;
d2176225
JB		 1483 bool do_mappings = false;
1484 bool do_status = false;
1485 int pid;
1486
1487 switch (what)
1488 {
1489 case IP_MINIMAL:
1490 do_cmdline = true;
1491 do_cwd = true;
1492 do_exe = true;
1493 break;
1494 case IP_MAPPINGS:
1495 do_mappings = true;
1496 break;
1497 case IP_STATUS:
1498 case IP_STAT:
1499 do_status = true;
1500 break;
1501 case IP_CMDLINE:
1502 do_cmdline = true;
1503 break;
1504 case IP_EXE:
1505 do_exe = true;
1506 break;
1507 case IP_CWD:
1508 do_cwd = true;
1509 break;
57c2a98a
JB		 1510 case IP_FILES:
1511 do_files = true;
1512 break;
d2176225
JB		 1513 case IP_ALL:
1514 do_cmdline = true;
1515 do_cwd = true;
1516 do_exe = true;
57c2a98a 1517 do_files = true;
d2176225
JB		 1518 do_mappings = true;
1519 do_status = true;
1520 break;
1521 default:
1522 return;
1523 }
1524
1525 pid = bfd_core_file_pid (core_bfd);
1526 if (pid != 0)
1527 printf_filtered (_("process %d\n"), pid);
1528
1529 if (do_cmdline)
1530 {
1531 const char *cmdline;
1532
1533 cmdline = bfd_core_file_failing_command (core_bfd);
1534 if (cmdline)
1535 printf_filtered ("cmdline = '%s'\n", cmdline);
1536 else
1537 warning (_("Command line unavailable"));
1538 }
1539 if (do_cwd)
1540 {
1541 gdb::unique_xmalloc_ptr<char> cwd =
1542 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
1543 if (cwd)
1544 printf_filtered ("cwd = '%s'\n", cwd.get ());
1545 else
1546 warning (_("unable to read current working directory"));
1547 }
1548 if (do_exe)
1549 {
1550 gdb::unique_xmalloc_ptr<char> exe =
1551 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1552 if (exe)
1553 printf_filtered ("exe = '%s'\n", exe.get ());
1554 else
1555 warning (_("unable to read executable path name"));
1556 }
57c2a98a
JB		 1557 if (do_files)
1558 fbsd_core_info_proc_files (gdbarch);
d2176225
JB		 1559 if (do_mappings)
1560 fbsd_core_info_proc_mappings (gdbarch);
1561 if (do_status)
1562 fbsd_core_info_proc_status (gdbarch);
1563}
1564
82372b2f
JB		 1565/* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1566
1567static void
1568fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1569 CORE_ADDR type, CORE_ADDR val)
1570{
fd2b4de5
JB		 1571 const char *name = "???";
1572 const char *description = "";
1573 enum auxv_format format = AUXV_FORMAT_HEX;
82372b2f
JB		 1574
1575 switch (type)
1576 {
fd2b4de5
JB		 1577 case AT_NULL:
1578 case AT_IGNORE:
1579 case AT_EXECFD:
1580 case AT_PHDR:
1581 case AT_PHENT:
1582 case AT_PHNUM:
1583 case AT_PAGESZ:
1584 case AT_BASE:
1585 case AT_FLAGS:
1586 case AT_ENTRY:
1587 case AT_NOTELF:
1588 case AT_UID:
1589 case AT_EUID:
1590 case AT_GID:
1591 case AT_EGID:
1592 default_print_auxv_entry (gdbarch, file, type, val);
1593 return;
82372b2f
JB		 1594#define _TAGNAME(tag) #tag
1595#define TAGNAME(tag) _TAGNAME(AT_##tag)
1596#define TAG(tag, text, kind) \
1597 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1598 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1599 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1600 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1601 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1602 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1603 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1604 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1605 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1606 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
12c4bd7f
JB		 1607 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1608 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
d7ded98f 1609 TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
82372b2f
JB		 1610 }
1611
1612 fprint_auxv_entry (file, name, description, format, type, val);
1613}
1614
762c974a
JB		 1615/* Implement the "get_siginfo_type" gdbarch method. */
1616
1617static struct type *
1618fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1619{
1620 struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1621 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1622 struct type *uid_type, *pid_type;
1623 struct type *sigval_type, *reason_type;
1624 struct type *siginfo_type;
1625 struct type *type;
1626
1627 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1628 if (fbsd_gdbarch_data->siginfo_type != NULL)
1629 return fbsd_gdbarch_data->siginfo_type;
1630
1631 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1632 0, "int");
1633 int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1634 uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1635 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1636 0, "long");
1637 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1638
1639 /* union sigval */
1640 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1641 TYPE_NAME (sigval_type) = xstrdup ("sigval");
1642 append_composite_type_field (sigval_type, "sival_int", int_type);
1643 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1644
1645 /* __pid_t */
1646 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781 1647 TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
762c974a
JB		 1648 TYPE_TARGET_TYPE (pid_type) = int32_type;
1649 TYPE_TARGET_STUB (pid_type) = 1;
1650
1651 /* __uid_t */
1652 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781
UW		 1653 TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1654 "__uid_t");
762c974a
JB		 1655 TYPE_TARGET_TYPE (uid_type) = uint32_type;
1656 TYPE_TARGET_STUB (uid_type) = 1;
1657
1658 /* _reason */
1659 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1660
1661 /* _fault */
1662 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1663 append_composite_type_field (type, "si_trapno", int_type);
1664 append_composite_type_field (reason_type, "_fault", type);
1665
1666 /* _timer */
1667 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1668 append_composite_type_field (type, "si_timerid", int_type);
1669 append_composite_type_field (type, "si_overrun", int_type);
1670 append_composite_type_field (reason_type, "_timer", type);
1671
1672 /* _mesgq */
1673 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1674 append_composite_type_field (type, "si_mqd", int_type);
1675 append_composite_type_field (reason_type, "_mesgq", type);
1676
1677 /* _poll */
1678 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1679 append_composite_type_field (type, "si_band", long_type);
1680 append_composite_type_field (reason_type, "_poll", type);
1681
1682 /* __spare__ */
1683 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1684 append_composite_type_field (type, "__spare1__", long_type);
1685 append_composite_type_field (type, "__spare2__",
1686 init_vector_type (int_type, 7));
1687 append_composite_type_field (reason_type, "__spare__", type);
1688
1689 /* struct siginfo */
1690 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1691 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
1692 append_composite_type_field (siginfo_type, "si_signo", int_type);
1693 append_composite_type_field (siginfo_type, "si_errno", int_type);
1694 append_composite_type_field (siginfo_type, "si_code", int_type);
1695 append_composite_type_field (siginfo_type, "si_pid", pid_type);
1696 append_composite_type_field (siginfo_type, "si_uid", uid_type);
1697 append_composite_type_field (siginfo_type, "si_status", int_type);
1698 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1699 append_composite_type_field (siginfo_type, "si_value", sigval_type);
1700 append_composite_type_field (siginfo_type, "_reason", reason_type);
1701
1702 fbsd_gdbarch_data->siginfo_type = siginfo_type;
1703
1704 return siginfo_type;
1705}
1706
e61667ef
RS		 1707/* Implement the "gdb_signal_from_target" gdbarch method. */
1708
1709static enum gdb_signal
1710fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1711{
1712 switch (signal)
1713 {
1714 case 0:
1715 return GDB_SIGNAL_0;
1716
1717 case FREEBSD_SIGHUP:
1718 return GDB_SIGNAL_HUP;
1719
1720 case FREEBSD_SIGINT:
1721 return GDB_SIGNAL_INT;
1722
1723 case FREEBSD_SIGQUIT:
1724 return GDB_SIGNAL_QUIT;
1725
1726 case FREEBSD_SIGILL:
1727 return GDB_SIGNAL_ILL;
1728
1729 case FREEBSD_SIGTRAP:
1730 return GDB_SIGNAL_TRAP;
1731
1732 case FREEBSD_SIGABRT:
1733 return GDB_SIGNAL_ABRT;
1734
1735 case FREEBSD_SIGEMT:
1736 return GDB_SIGNAL_EMT;
1737
1738 case FREEBSD_SIGFPE:
1739 return GDB_SIGNAL_FPE;
1740
1741 case FREEBSD_SIGKILL:
1742 return GDB_SIGNAL_KILL;
1743
1744 case FREEBSD_SIGBUS:
1745 return GDB_SIGNAL_BUS;
1746
1747 case FREEBSD_SIGSEGV:
1748 return GDB_SIGNAL_SEGV;
1749
1750 case FREEBSD_SIGSYS:
1751 return GDB_SIGNAL_SYS;
1752
1753 case FREEBSD_SIGPIPE:
1754 return GDB_SIGNAL_PIPE;
1755
1756 case FREEBSD_SIGALRM:
1757 return GDB_SIGNAL_ALRM;
1758
1759 case FREEBSD_SIGTERM:
1760 return GDB_SIGNAL_TERM;
1761
1762 case FREEBSD_SIGURG:
1763 return GDB_SIGNAL_URG;
1764
1765 case FREEBSD_SIGSTOP:
1766 return GDB_SIGNAL_STOP;
1767
1768 case FREEBSD_SIGTSTP:
1769 return GDB_SIGNAL_TSTP;
1770
1771 case FREEBSD_SIGCONT:
1772 return GDB_SIGNAL_CONT;
1773
1774 case FREEBSD_SIGCHLD:
1775 return GDB_SIGNAL_CHLD;
1776
1777 case FREEBSD_SIGTTIN:
1778 return GDB_SIGNAL_TTIN;
1779
1780 case FREEBSD_SIGTTOU:
1781 return GDB_SIGNAL_TTOU;
1782
1783 case FREEBSD_SIGIO:
1784 return GDB_SIGNAL_IO;
1785
1786 case FREEBSD_SIGXCPU:
1787 return GDB_SIGNAL_XCPU;
1788
1789 case FREEBSD_SIGXFSZ:
1790 return GDB_SIGNAL_XFSZ;
1791
1792 case FREEBSD_SIGVTALRM:
1793 return GDB_SIGNAL_VTALRM;
1794
1795 case FREEBSD_SIGPROF:
1796 return GDB_SIGNAL_PROF;
1797
1798 case FREEBSD_SIGWINCH:
1799 return GDB_SIGNAL_WINCH;
1800
1801 case FREEBSD_SIGINFO:
1802 return GDB_SIGNAL_INFO;
1803
1804 case FREEBSD_SIGUSR1:
1805 return GDB_SIGNAL_USR1;
1806
1807 case FREEBSD_SIGUSR2:
1808 return GDB_SIGNAL_USR2;
1809
1810 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1811 case FREEBSD_SIGTHR:
1812 return GDB_SIGNAL_LWP;
1813
1814 case FREEBSD_SIGLIBRT:
1815 return GDB_SIGNAL_LIBRT;
1816 }
1817
1818 if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX)
1819 {
1820 int offset = signal - FREEBSD_SIGRTMIN;
1821
1822 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset);
1823 }
1824
1825 return GDB_SIGNAL_UNKNOWN;
1826}
1827
1828/* Implement the "gdb_signal_to_target" gdbarch method. */
1829
1830static int
1831fbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
1832 enum gdb_signal signal)
1833{
1834 switch (signal)
1835 {
1836 case GDB_SIGNAL_0:
1837 return 0;
1838
1839 case GDB_SIGNAL_HUP:
1840 return FREEBSD_SIGHUP;
1841
1842 case GDB_SIGNAL_INT:
1843 return FREEBSD_SIGINT;
1844
1845 case GDB_SIGNAL_QUIT:
1846 return FREEBSD_SIGQUIT;
1847
1848 case GDB_SIGNAL_ILL:
1849 return FREEBSD_SIGILL;
1850
1851 case GDB_SIGNAL_TRAP:
1852 return FREEBSD_SIGTRAP;
1853
1854 case GDB_SIGNAL_ABRT:
1855 return FREEBSD_SIGABRT;
1856
1857 case GDB_SIGNAL_EMT:
1858 return FREEBSD_SIGEMT;
1859
1860 case GDB_SIGNAL_FPE:
1861 return FREEBSD_SIGFPE;
1862
1863 case GDB_SIGNAL_KILL:
1864 return FREEBSD_SIGKILL;
1865
1866 case GDB_SIGNAL_BUS:
1867 return FREEBSD_SIGBUS;
1868
1869 case GDB_SIGNAL_SEGV:
1870 return FREEBSD_SIGSEGV;
1871
1872 case GDB_SIGNAL_SYS:
1873 return FREEBSD_SIGSYS;
1874
1875 case GDB_SIGNAL_PIPE:
1876 return FREEBSD_SIGPIPE;
1877
1878 case GDB_SIGNAL_ALRM:
1879 return FREEBSD_SIGALRM;
1880
1881 case GDB_SIGNAL_TERM:
1882 return FREEBSD_SIGTERM;
1883
1884 case GDB_SIGNAL_URG:
1885 return FREEBSD_SIGURG;
1886
1887 case GDB_SIGNAL_STOP:
1888 return FREEBSD_SIGSTOP;
1889
1890 case GDB_SIGNAL_TSTP:
1891 return FREEBSD_SIGTSTP;
1892
1893 case GDB_SIGNAL_CONT:
1894 return FREEBSD_SIGCONT;
1895
1896 case GDB_SIGNAL_CHLD:
1897 return FREEBSD_SIGCHLD;
1898
1899 case GDB_SIGNAL_TTIN:
1900 return FREEBSD_SIGTTIN;
1901
1902 case GDB_SIGNAL_TTOU:
1903 return FREEBSD_SIGTTOU;
1904
1905 case GDB_SIGNAL_IO:
1906 return FREEBSD_SIGIO;
1907
1908 case GDB_SIGNAL_XCPU:
1909 return FREEBSD_SIGXCPU;
1910
1911 case GDB_SIGNAL_XFSZ:
1912 return FREEBSD_SIGXFSZ;
1913
1914 case GDB_SIGNAL_VTALRM:
1915 return FREEBSD_SIGVTALRM;
1916
1917 case GDB_SIGNAL_PROF:
1918 return FREEBSD_SIGPROF;
1919
1920 case GDB_SIGNAL_WINCH:
1921 return FREEBSD_SIGWINCH;
1922
1923 case GDB_SIGNAL_INFO:
1924 return FREEBSD_SIGINFO;
1925
1926 case GDB_SIGNAL_USR1:
1927 return FREEBSD_SIGUSR1;
1928
1929 case GDB_SIGNAL_USR2:
1930 return FREEBSD_SIGUSR2;
1931
1932 case GDB_SIGNAL_LWP:
1933 return FREEBSD_SIGTHR;
1934
1935 case GDB_SIGNAL_LIBRT:
1936 return FREEBSD_SIGLIBRT;
1937 }
1938
1939 if (signal >= GDB_SIGNAL_REALTIME_65
1940 && signal <= GDB_SIGNAL_REALTIME_126)
1941 {
1942 int offset = signal - GDB_SIGNAL_REALTIME_65;
1943
1944 return FREEBSD_SIGRTMIN + offset;
1945 }
1946
1947 return -1;
1948}
1949
e6cdd38e
JB		 1950/* Implement the "get_syscall_number" gdbarch method. */
1951
1952static LONGEST
00431a78 1953fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
e6cdd38e
JB		 1954{
1955
1956 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1957 native targets fetch the system call number from the
1958 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1959 However, system call catching requires this function to be
1960 set. */
1961
1962 internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1963}
1964
945f3901
JB		 1965/* Read an integer symbol value from the current target. */
1966
1967static LONGEST
1968fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name)
1969{
1970 bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL);
1971 if (ms.minsym == NULL)
1972 error (_("Unable to resolve symbol '%s'"), name);
1973
1974 gdb_byte buf[4];
1975 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), buf, sizeof buf) != 0)
1976 error (_("Unable to read value of '%s'"), name);
1977
1978 return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
1979}
1980
1981/* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1982 structure needed to determine the TLS index of an object file. */
1983
1984static void
1985fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
1986{
a70b8144 1987 try
945f3901
JB		 1988 {
1989 /* Fetch offsets from debug symbols in rtld. */
1990 struct symbol *obj_entry_sym
1991 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
1992 language_c, NULL).symbol;
1993 if (obj_entry_sym == NULL)
1994 error (_("Unable to find Struct_Obj_Entry symbol"));
1995 data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
1996 "linkmap", 0).offset / 8;
1997 data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
1998 "tlsindex", 0).offset / 8;
1999 data->rtld_offsets_valid = true;
2000 return;
2001 }
230d2906 2002 catch (const gdb_exception_error &e)
945f3901
JB		 2003 {
2004 data->off_linkmap = -1;
2005 }
945f3901 2006
a70b8144 2007 try
945f3901
JB		 2008 {
2009 /* Fetch offsets from global variables in libthr. Note that
2010 this does not work for single-threaded processes that are not
2011 linked against libthr. */
2012 data->off_linkmap = fbsd_read_integer_by_name (gdbarch,
2013 "_thread_off_linkmap");
2014 data->off_tlsindex = fbsd_read_integer_by_name (gdbarch,
2015 "_thread_off_tlsindex");
2016 data->rtld_offsets_valid = true;
2017 return;
2018 }
230d2906 2019 catch (const gdb_exception_error &e)
945f3901
JB		 2020 {
2021 data->off_linkmap = -1;
2022 }
945f3901
JB		 2023}
2024
2025/* Helper function to read the TLS index of an object file associated
2026 with a link map entry at LM_ADDR. */
2027
2028static LONGEST
2029fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr)
2030{
2031 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space);
2032
2033 if (!data->rtld_offsets_valid)
2034 fbsd_fetch_rtld_offsets (gdbarch, data);
2035
2036 if (data->off_linkmap == -1)
2037 throw_error (TLS_GENERIC_ERROR,
2038 _("Cannot fetch runtime linker structure offsets"));
2039
2040 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2041 pointer and then compute the offset of the tlsindex member. */
2042 CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex;
2043
2044 gdb_byte buf[4];
2045 if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0)
2046 throw_error (TLS_GENERIC_ERROR,
2047 _("Cannot find thread-local variables on this target"));
2048
2049 return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
2050}
2051
2052/* See fbsd-tdep.h. */
2053
2054CORE_ADDR
2055fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr,
2056 CORE_ADDR lm_addr, CORE_ADDR offset)
2057{
2058 LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr);
2059
2060 gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
2061 if (target_read_memory (dtv_addr, buf, sizeof buf) != 0)
2062 throw_error (TLS_GENERIC_ERROR,
2063 _("Cannot find thread-local variables on this target"));
2064
2065 const struct builtin_type *builtin = builtin_type (gdbarch);
2066 CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch,
2067 builtin->builtin_data_ptr, buf);
2068
2069 addr += (tls_index + 1) * TYPE_LENGTH (builtin->builtin_data_ptr);
2070 if (target_read_memory (addr, buf, sizeof buf) != 0)
2071 throw_error (TLS_GENERIC_ERROR,
2072 _("Cannot find thread-local variables on this target"));
2073
2074 addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf);
2075 return addr + offset;
2076}
2077
1736a7bd 2078/* To be called from GDB_OSABI_FREEBSD handlers. */
a904c024
AA		 2079
2080void
2081fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2082{
79117428
JB		 2083 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
2084 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
4b654465 2085 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
a904c024 2086 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
d2176225 2087 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
82372b2f 2088 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
762c974a 2089 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
e61667ef
RS		 2090 set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target);
2091 set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target);
e6cdd38e
JB		 2092
2093 /* `catch syscall' */
2094 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
2095 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
a904c024 2096}
762c974a 2097
762c974a
JB		 2098void
2099_initialize_fbsd_tdep (void)
2100{
2101 fbsd_gdbarch_data_handle =
2102 gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
945f3901
JB		 2103 fbsd_pspace_data_handle
2104 = register_program_space_data_with_cleanup (NULL, fbsd_pspace_data_cleanup);
762c974a 2105}
A mirror of the official binutils-gdb repository