projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Change pid_to_str to return std::string
[deliverable/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"
26#include "gdbthread.h"
945f3901 27#include "objfiles.h"
e6cdd38e 28#include "xml-syscall.h"
57c2a98a
JB		 29#include <sys/socket.h>
30#include <arpa/inet.h>
a904c024 31
a904c024
AA		 32#include "elf-bfd.h"
33#include "fbsd-tdep.h"
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
JB		 748 /* Thread register information. */
749 TRY
750 {
751 update_thread_list ();
752 }
753 CATCH (e, RETURN_MASK_ERROR)
754 {
755 exception_print (gdb_stderr, e);
756 }
757 END_CATCH
758
759 /* Like the kernel, prefer dumping the signalled thread first.
760 "First thread" is what tools use to infer the signalled thread.
761 In case there's more than one signalled thread, prefer the
762 current thread, if it is signalled. */
763 curr_thr = inferior_thread ();
764 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
765 signalled_thr = curr_thr;
766 else
767 {
768 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
769 if (signalled_thr == NULL)
770 signalled_thr = curr_thr;
771 }
772
773 thread_args.gdbarch = gdbarch;
774 thread_args.obfd = obfd;
775 thread_args.note_data = note_data;
776 thread_args.note_size = note_size;
777 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
778
779 fbsd_corefile_thread (signalled_thr, &thread_args);
08036331 780 for (thread_info *thr : current_inferior ()->non_exited_threads ())
20a0aab3
JB		 781 {
782 if (thr == signalled_thr)
783 continue;
20a0aab3
JB		 784
785 fbsd_corefile_thread (thr, &thread_args);
786 }
787
788 note_data = thread_args.note_data;
789
739ab2e9
SS		 790 /* Auxiliary vector. */
791 uint32_t structsize = gdbarch_ptr_bit (gdbarch) / 4; /* Elf_Auxinfo */
792 gdb::optional<gdb::byte_vector> note_desc =
793 fbsd_make_note_desc (TARGET_OBJECT_AUXV, structsize);
794 if (note_desc && !note_desc->empty ())
795 {
796 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
797 NT_FREEBSD_PROCSTAT_AUXV,
798 note_desc->data (), note_desc->size ());
799 if (!note_data)
800 return NULL;
801 }
802
803 /* Virtual memory mappings. */
804 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP, 0);
805 if (note_desc && !note_desc->empty ())
806 {
807 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
808 NT_FREEBSD_PROCSTAT_VMMAP,
809 note_desc->data (), note_desc->size ());
810 if (!note_data)
811 return NULL;
812 }
813
814 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS, 0);
815 if (note_desc && !note_desc->empty ())
816 {
817 note_data = elfcore_write_note (obfd, note_data, note_size, "FreeBSD",
818 NT_FREEBSD_PROCSTAT_PSSTRINGS,
819 note_desc->data (), note_desc->size ());
820 if (!note_data)
821 return NULL;
822 }
823
a904c024
AA		 824 return note_data;
825}
826
57c2a98a
JB		 827/* Helper function to generate the file descriptor description for a
828 single open file in 'info proc files'. */
829
830static const char *
831fbsd_file_fd (int kf_fd)
832{
833 switch (kf_fd)
834 {
835 case KINFO_FILE_FD_TYPE_CWD:
836 return "cwd";
837 case KINFO_FILE_FD_TYPE_ROOT:
838 return "root";
839 case KINFO_FILE_FD_TYPE_JAIL:
840 return "jail";
841 case KINFO_FILE_FD_TYPE_TRACE:
842 return "trace";
843 case KINFO_FILE_FD_TYPE_TEXT:
844 return "text";
845 case KINFO_FILE_FD_TYPE_CTTY:
846 return "ctty";
847 default:
848 return int_string (kf_fd, 10, 1, 0, 0);
849 }
850}
851
852/* Helper function to generate the file type for a single open file in
853 'info proc files'. */
854
855static const char *
856fbsd_file_type (int kf_type, int kf_vnode_type)
857{
858 switch (kf_type)
859 {
860 case KINFO_FILE_TYPE_VNODE:
861 switch (kf_vnode_type)
862 {
863 case KINFO_FILE_VTYPE_VREG:
864 return "file";
865 case KINFO_FILE_VTYPE_VDIR:
866 return "dir";
867 case KINFO_FILE_VTYPE_VCHR:
868 return "chr";
869 case KINFO_FILE_VTYPE_VLNK:
870 return "link";
871 case KINFO_FILE_VTYPE_VSOCK:
872 return "socket";
873 case KINFO_FILE_VTYPE_VFIFO:
874 return "fifo";
875 default:
876 {
877 char *str = get_print_cell ();
878
879 xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type);
880 return str;
881 }
882 }
883 case KINFO_FILE_TYPE_SOCKET:
884 return "socket";
885 case KINFO_FILE_TYPE_PIPE:
886 return "pipe";
887 case KINFO_FILE_TYPE_FIFO:
888 return "fifo";
889 case KINFO_FILE_TYPE_KQUEUE:
890 return "kqueue";
891 case KINFO_FILE_TYPE_CRYPTO:
892 return "crypto";
893 case KINFO_FILE_TYPE_MQUEUE:
894 return "mqueue";
895 case KINFO_FILE_TYPE_SHM:
896 return "shm";
897 case KINFO_FILE_TYPE_SEM:
898 return "sem";
899 case KINFO_FILE_TYPE_PTS:
900 return "pts";
901 case KINFO_FILE_TYPE_PROCDESC:
902 return "proc";
903 default:
904 return int_string (kf_type, 10, 1, 0, 0);
905 }
906}
907
908/* Helper function to generate the file flags for a single open file in
909 'info proc files'. */
910
911static const char *
912fbsd_file_flags (int kf_flags)
913{
914 static char file_flags[10];
915
916 file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-';
917 file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-';
918 file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-';
919 file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-';
920 file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-';
921 file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-';
922 file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-';
923 file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-';
924 file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-';
925 file_flags[9] = '\0';
926
927 return file_flags;
928}
929
930/* Helper function to generate the name of an IP protocol. */
931
932static const char *
933fbsd_ipproto (int protocol)
934{
935 switch (protocol)
936 {
937 case FBSD_IPPROTO_ICMP:
938 return "icmp";
939 case FBSD_IPPROTO_TCP:
940 return "tcp";
941 case FBSD_IPPROTO_UDP:
942 return "udp";
943 case FBSD_IPPROTO_SCTP:
944 return "sctp";
945 default:
946 {
947 char *str = get_print_cell ();
948
949 xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol);
950 return str;
951 }
952 }
953}
954
955/* Helper function to print out an IPv4 socket address. */
956
957static void
958fbsd_print_sockaddr_in (const void *sockaddr)
959{
960 const struct fbsd_sockaddr_in *sin =
961 reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr);
962 char buf[INET_ADDRSTRLEN];
963
07147793 964 if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 965 error (_("Failed to format IPv4 address"));
966 printf_filtered ("%s:%u", buf,
967 (sin->sin_port[0] << 8) | sin->sin_port[1]);
968}
969
970/* Helper function to print out an IPv6 socket address. */
971
972static void
973fbsd_print_sockaddr_in6 (const void *sockaddr)
974{
975 const struct fbsd_sockaddr_in6 *sin6 =
976 reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr);
977 char buf[INET6_ADDRSTRLEN];
978
07147793 979 if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr)
57c2a98a
JB		 980 error (_("Failed to format IPv6 address"));
981 printf_filtered ("%s.%u", buf,
982 (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]);
983}
984
985/* See fbsd-tdep.h. */
986
987void
988fbsd_info_proc_files_header ()
989{
990 printf_filtered (_("Open files:\n\n"));
991 printf_filtered (" %6s %6s %10s %9s %s\n",
992 "FD", "Type", "Offset", "Flags ", "Name");
993}
994
995/* See fbsd-tdep.h. */
996
997void
998fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags,
999 LONGEST kf_offset, int kf_vnode_type,
1000 int kf_sock_domain, int kf_sock_type,
1001 int kf_sock_protocol, const void *kf_sa_local,
1002 const void *kf_sa_peer, const void *kf_path)
1003{
1004 printf_filtered (" %6s %6s %10s %8s ",
1005 fbsd_file_fd (kf_fd),
1006 fbsd_file_type (kf_type, kf_vnode_type),
1007 kf_offset > -1 ? hex_string (kf_offset) : "-",
1008 fbsd_file_flags (kf_flags));
1009 if (kf_type == KINFO_FILE_TYPE_SOCKET)
1010 {
1011 switch (kf_sock_domain)
1012 {
1013 case FBSD_AF_UNIX:
1014 {
1015 switch (kf_sock_type)
1016 {
1017 case FBSD_SOCK_STREAM:
1018 printf_filtered ("unix stream:");
1019 break;
1020 case FBSD_SOCK_DGRAM:
1021 printf_filtered ("unix dgram:");
1022 break;
1023 case FBSD_SOCK_SEQPACKET:
1024 printf_filtered ("unix seqpacket:");
1025 break;
1026 default:
1027 printf_filtered ("unix <%d>:", kf_sock_type);
1028 break;
1029 }
1030
1031 /* For local sockets, print out the first non-nul path
1032 rather than both paths. */
1033 const struct fbsd_sockaddr_un *sun
1034 = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local);
1035 if (sun->sun_path[0] == 0)
1036 sun = reinterpret_cast<const struct fbsd_sockaddr_un *>
1037 (kf_sa_peer);
1038 printf_filtered ("%s", sun->sun_path);
1039 break;
1040 }
1041 case FBSD_AF_INET:
1042 printf_filtered ("%s4 ", fbsd_ipproto (kf_sock_protocol));
1043 fbsd_print_sockaddr_in (kf_sa_local);
1044 printf_filtered (" -> ");
1045 fbsd_print_sockaddr_in (kf_sa_peer);
1046 break;
1047 case FBSD_AF_INET6:
1048 printf_filtered ("%s6 ", fbsd_ipproto (kf_sock_protocol));
1049 fbsd_print_sockaddr_in6 (kf_sa_local);
1050 printf_filtered (" -> ");
1051 fbsd_print_sockaddr_in6 (kf_sa_peer);
1052 break;
1053 }
1054 }
1055 else
1056 printf_filtered ("%s", reinterpret_cast<const char *> (kf_path));
1057 printf_filtered ("\n");
1058}
1059
1060/* Implement "info proc files" for a corefile. */
1061
1062static void
1063fbsd_core_info_proc_files (struct gdbarch *gdbarch)
1064{
1065 asection *section
1066 = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1067 if (section == NULL)
1068 {
1069 warning (_("unable to find open files in core file"));
1070 return;
1071 }
1072
1073 size_t note_size = bfd_get_section_size (section);
1074 if (note_size < 4)
1075 error (_("malformed core note - too short for header"));
1076
1077 gdb::def_vector<unsigned char> contents (note_size);
1078 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1079 0, note_size))
1080 error (_("could not get core note contents"));
1081
1082 unsigned char *descdata = contents.data ();
1083 unsigned char *descend = descdata + note_size;
1084
1085 /* Skip over the structure size. */
1086 descdata += 4;
1087
1088 fbsd_info_proc_files_header ();
1089
1090 while (descdata + KF_PATH < descend)
1091 {
1092 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
1093 if (structsize < KF_PATH)
1094 error (_("malformed core note - file structure too small"));
1095
1096 LONGEST type = bfd_get_signed_32 (core_bfd, descdata + KF_TYPE);
1097 LONGEST fd = bfd_get_signed_32 (core_bfd, descdata + KF_FD);
1098 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KF_FLAGS);
1099 LONGEST offset = bfd_get_signed_64 (core_bfd, descdata + KF_OFFSET);
1100 LONGEST vnode_type = bfd_get_signed_32 (core_bfd,
1101 descdata + KF_VNODE_TYPE);
1102 LONGEST sock_domain = bfd_get_signed_32 (core_bfd,
1103 descdata + KF_SOCK_DOMAIN);
1104 LONGEST sock_type = bfd_get_signed_32 (core_bfd, descdata + KF_SOCK_TYPE);
1105 LONGEST sock_protocol = bfd_get_signed_32 (core_bfd,
1106 descdata + KF_SOCK_PROTOCOL);
1107 fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type,
1108 sock_domain, sock_type, sock_protocol,
1109 descdata + KF_SA_LOCAL, descdata + KF_SA_PEER,
1110 descdata + KF_PATH);
1111
1112 descdata += structsize;
1113 }
1114}
1115
d2176225
JB		 1116/* Helper function to generate mappings flags for a single VM map
1117 entry in 'info proc mappings'. */
1118
6f3b1098 1119static const char *
d2176225
JB		 1120fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
1121{
1122 static char vm_flags[9];
1123
1124 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
1125 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
1126 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
1127 vm_flags[3] = ' ';
1128 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
1129 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
1130 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
1131 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
1132 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
1133 vm_flags[8] = '\0';
1134
1135 return vm_flags;
1136}
1137
6f3b1098
JB		 1138/* See fbsd-tdep.h. */
1139
1140void
1141fbsd_info_proc_mappings_header (int addr_bit)
1142{
1143 printf_filtered (_("Mapped address spaces:\n\n"));
1144 if (addr_bit == 64)
1145 {
1146 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1147 "Start Addr",
1148 " End Addr",
1149 " Size", " Offset", "Flags ", "File");
1150 }
1151 else
1152 {
1153 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1154 "Start Addr",
1155 " End Addr",
1156 " Size", " Offset", "Flags ", "File");
1157 }
1158}
1159
1160/* See fbsd-tdep.h. */
1161
1162void
1163fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start,
1164 ULONGEST kve_end, ULONGEST kve_offset,
1165 int kve_flags, int kve_protection,
1166 const void *kve_path)
1167{
1168 if (addr_bit == 64)
1169 {
1170 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
1171 hex_string (kve_start),
1172 hex_string (kve_end),
1173 hex_string (kve_end - kve_start),
1174 hex_string (kve_offset),
1175 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1176 reinterpret_cast<const char *> (kve_path));
1177 }
1178 else
1179 {
1180 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
1181 hex_string (kve_start),
1182 hex_string (kve_end),
1183 hex_string (kve_end - kve_start),
1184 hex_string (kve_offset),
1185 fbsd_vm_map_entry_flags (kve_flags, kve_protection),
1186 reinterpret_cast<const char *> (kve_path));
1187 }
1188}
1189
d2176225
JB		 1190/* Implement "info proc mappings" for a corefile. */
1191
1192static void
1193fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
1194{
1195 asection *section;
1196 unsigned char *descdata, *descend;
1197 size_t note_size;
1198
1199 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
1200 if (section == NULL)
1201 {
1202 warning (_("unable to find mappings in core file"));
1203 return;
1204 }
1205
1206 note_size = bfd_get_section_size (section);
1207 if (note_size < 4)
1208 error (_("malformed core note - too short for header"));
1209
1210 gdb::def_vector<unsigned char> contents (note_size);
1211 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1212 0, note_size))
1213 error (_("could not get core note contents"));
1214
1215 descdata = contents.data ();
1216 descend = descdata + note_size;
1217
1218 /* Skip over the structure size. */
1219 descdata += 4;
1220
6f3b1098 1221 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch));
d2176225
JB		 1222 while (descdata + KVE_PATH < descend)
1223 {
6f3b1098 1224 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
d2176225
JB		 1225 if (structsize < KVE_PATH)
1226 error (_("malformed core note - vmmap entry too small"));
1227
6f3b1098
JB		 1228 ULONGEST start = bfd_get_64 (core_bfd, descdata + KVE_START);
1229 ULONGEST end = bfd_get_64 (core_bfd, descdata + KVE_END);
1230 ULONGEST offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
1231 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KVE_FLAGS);
1232 LONGEST prot = bfd_get_signed_32 (core_bfd, descdata + KVE_PROTECTION);
1233 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end,
1234 offset, flags, prot, descdata + KVE_PATH);
d2176225
JB		 1235
1236 descdata += structsize;
1237 }
1238}
1239
1240/* Fetch the pathname of a vnode for a single file descriptor from the
1241 file table core note. */
1242
1243static gdb::unique_xmalloc_ptr<char>
1244fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
1245{
1246 asection *section;
1247 unsigned char *descdata, *descend;
1248 size_t note_size;
1249
1250 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
1251 if (section == NULL)
1252 return nullptr;
1253
1254 note_size = bfd_get_section_size (section);
1255 if (note_size < 4)
1256 error (_("malformed core note - too short for header"));
1257
1258 gdb::def_vector<unsigned char> contents (note_size);
1259 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1260 0, note_size))
1261 error (_("could not get core note contents"));
1262
1263 descdata = contents.data ();
1264 descend = descdata + note_size;
1265
1266 /* Skip over the structure size. */
1267 descdata += 4;
1268
9f235e09 1269 while (descdata + KF_PATH < descend)
d2176225
JB		 1270 {
1271 ULONGEST structsize;
1272
1273 structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
9f235e09
JB		 1274 if (structsize < KF_PATH)
1275 error (_("malformed core note - file structure too small"));
d2176225
JB		 1276
1277 if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
1278 && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
1279 {
1280 char *path = (char *) descdata + KF_PATH;
1281 return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
1282 }
1283
1284 descdata += structsize;
1285 }
1286 return nullptr;
1287}
1288
1289/* Helper function to read a struct timeval. */
1290
1291static void
1292fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
1293 LONGEST &sec, ULONGEST &usec)
1294{
1295 if (gdbarch_addr_bit (gdbarch) == 64)
1296 {
1297 sec = bfd_get_signed_64 (core_bfd, data);
1298 usec = bfd_get_64 (core_bfd, data + 8);
1299 }
1300 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1301 {
1302 sec = bfd_get_signed_32 (core_bfd, data);
1303 usec = bfd_get_32 (core_bfd, data + 4);
1304 }
1305 else
1306 {
1307 sec = bfd_get_signed_64 (core_bfd, data);
1308 usec = bfd_get_32 (core_bfd, data + 8);
1309 }
1310}
1311
1312/* Print out the contents of a signal set. */
1313
1314static void
1315fbsd_print_sigset (const char *descr, unsigned char *sigset)
1316{
1317 printf_filtered ("%s: ", descr);
1318 for (int i = 0; i < SIG_WORDS; i++)
1319 printf_filtered ("%08x ",
1320 (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
1321 printf_filtered ("\n");
1322}
1323
1324/* Implement "info proc status" for a corefile. */
1325
1326static void
1327fbsd_core_info_proc_status (struct gdbarch *gdbarch)
1328{
1329 const struct kinfo_proc_layout *kp;
1330 asection *section;
d2176225
JB		 1331 unsigned char *descdata;
1332 int addr_bit, long_bit;
1333 size_t note_size;
1334 ULONGEST value;
1335 LONGEST sec;
1336
1337 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
1338 if (section == NULL)
1339 {
1340 warning (_("unable to find process info in core file"));
1341 return;
1342 }
1343
1344 addr_bit = gdbarch_addr_bit (gdbarch);
1345 if (addr_bit == 64)
1346 kp = &kinfo_proc_layout_64;
1347 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
1348 kp = &kinfo_proc_layout_i386;
1349 else
1350 kp = &kinfo_proc_layout_32;
1351 long_bit = gdbarch_long_bit (gdbarch);
1352
1353 /*
1354 * Ensure that the note is large enough for all of the fields fetched
1355 * by this function. In particular, the note must contain the 32-bit
1356 * structure size, then it must be long enough to access the last
1357 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
1358 */
1359 note_size = bfd_get_section_size (section);
1360 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
1361 + long_bit / TARGET_CHAR_BIT))
1362 error (_("malformed core note - too short"));
1363
1364 gdb::def_vector<unsigned char> contents (note_size);
1365 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1366 0, note_size))
1367 error (_("could not get core note contents"));
1368
1369 descdata = contents.data ();
1370
1371 /* Skip over the structure size. */
1372 descdata += 4;
1373
1374 /* Verify 'ki_layout' is 0. */
1375 if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
1376 {
1377 warning (_("unsupported process information in core file"));
1378 return;
1379 }
1380
1381 printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
1382 printf_filtered ("Process ID: %s\n",
1383 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
1384 printf_filtered ("Parent process: %s\n",
1385 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
1386 printf_filtered ("Process group: %s\n",
1387 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
1388 printf_filtered ("Session id: %s\n",
1389 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
1390
1391 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
1392 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
1393 kernels the 64-bit 'ki_tdev' field is in a reserved section of
1394 the structure that is cleared to zero. Assume that a zero value
1395 in ki_tdev indicates a core dump from an older kernel and use the
1396 value in 'ki_tdev_freebsd11' instead. */
1397 value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
1398 if (value == 0)
1399 value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
1400 printf_filtered ("TTY: %s\n", pulongest (value));
1401 printf_filtered ("TTY owner process group: %s\n",
1402 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
1403 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
1404 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
1405 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
1406 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
1407 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
1408 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
1409 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
1410 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
1411 printf_filtered ("Groups: ");
1412 uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
1413 for (int i = 0; i < ngroups; i++)
1414 printf_filtered ("%s ",
1415 pulongest (bfd_get_32 (core_bfd,
1416 descdata + kp->ki_groups + i * 4)));
1417 printf_filtered ("\n");
1418 value = bfd_get (long_bit, core_bfd,
1419 descdata + kp->ki_rusage + kp->ru_minflt);
1420 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
1421 value = bfd_get (long_bit, core_bfd,
1422 descdata + kp->ki_rusage_ch + kp->ru_minflt);
1423 printf_filtered ("Minor faults, children: %s\n", pulongest (value));
1424 value = bfd_get (long_bit, core_bfd,
1425 descdata + kp->ki_rusage + kp->ru_majflt);
1426 printf_filtered ("Major faults (memory page faults): %s\n",
1427 pulongest (value));
1428 value = bfd_get (long_bit, core_bfd,
1429 descdata + kp->ki_rusage_ch + kp->ru_majflt);
1430 printf_filtered ("Major faults, children: %s\n", pulongest (value));
1431 fbsd_core_fetch_timeval (gdbarch,
1432 descdata + kp->ki_rusage + kp->ru_utime,
1433 sec, value);
1434 printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
1435 fbsd_core_fetch_timeval (gdbarch,
1436 descdata + kp->ki_rusage + kp->ru_stime,
1437 sec, value);
1438 printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
1439 fbsd_core_fetch_timeval (gdbarch,
1440 descdata + kp->ki_rusage_ch + kp->ru_utime,
1441 sec, value);
1442 printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
1443 fbsd_core_fetch_timeval (gdbarch,
1444 descdata + kp->ki_rusage_ch + kp->ru_stime,
1445 sec, value);
1446 printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
1447 printf_filtered ("'nice' value: %d\n",
1448 bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
1449 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
1450 printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
1451 printf_filtered ("Virtual memory size: %s kB\n",
1452 pulongest (bfd_get (addr_bit, core_bfd,
1453 descdata + kp->ki_size) / 1024));
1454 printf_filtered ("Data size: %s pages\n",
1455 pulongest (bfd_get (addr_bit, core_bfd,
1456 descdata + kp->ki_dsize)));
1457 printf_filtered ("Stack size: %s pages\n",
1458 pulongest (bfd_get (addr_bit, core_bfd,
1459 descdata + kp->ki_ssize)));
1460 printf_filtered ("Text size: %s pages\n",
1461 pulongest (bfd_get (addr_bit, core_bfd,
1462 descdata + kp->ki_tsize)));
1463 printf_filtered ("Resident set size: %s pages\n",
1464 pulongest (bfd_get (addr_bit, core_bfd,
1465 descdata + kp->ki_rssize)));
1466 printf_filtered ("Maximum RSS: %s pages\n",
1467 pulongest (bfd_get (long_bit, core_bfd,
1468 descdata + kp->ki_rusage
1469 + kp->ru_maxrss)));
1470 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
1471 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
1472}
1473
1474/* Implement the "core_info_proc" gdbarch method. */
1475
1476static void
1477fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
1478 enum info_proc_what what)
1479{
1480 bool do_cmdline = false;
1481 bool do_cwd = false;
1482 bool do_exe = false;
57c2a98a 1483 bool do_files = false;
d2176225
JB		 1484 bool do_mappings = false;
1485 bool do_status = false;
1486 int pid;
1487
1488 switch (what)
1489 {
1490 case IP_MINIMAL:
1491 do_cmdline = true;
1492 do_cwd = true;
1493 do_exe = true;
1494 break;
1495 case IP_MAPPINGS:
1496 do_mappings = true;
1497 break;
1498 case IP_STATUS:
1499 case IP_STAT:
1500 do_status = true;
1501 break;
1502 case IP_CMDLINE:
1503 do_cmdline = true;
1504 break;
1505 case IP_EXE:
1506 do_exe = true;
1507 break;
1508 case IP_CWD:
1509 do_cwd = true;
1510 break;
57c2a98a
JB		 1511 case IP_FILES:
1512 do_files = true;
1513 break;
d2176225
JB		 1514 case IP_ALL:
1515 do_cmdline = true;
1516 do_cwd = true;
1517 do_exe = true;
57c2a98a 1518 do_files = true;
d2176225
JB		 1519 do_mappings = true;
1520 do_status = true;
1521 break;
1522 default:
1523 return;
1524 }
1525
1526 pid = bfd_core_file_pid (core_bfd);
1527 if (pid != 0)
1528 printf_filtered (_("process %d\n"), pid);
1529
1530 if (do_cmdline)
1531 {
1532 const char *cmdline;
1533
1534 cmdline = bfd_core_file_failing_command (core_bfd);
1535 if (cmdline)
1536 printf_filtered ("cmdline = '%s'\n", cmdline);
1537 else
1538 warning (_("Command line unavailable"));
1539 }
1540 if (do_cwd)
1541 {
1542 gdb::unique_xmalloc_ptr<char> cwd =
1543 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
1544 if (cwd)
1545 printf_filtered ("cwd = '%s'\n", cwd.get ());
1546 else
1547 warning (_("unable to read current working directory"));
1548 }
1549 if (do_exe)
1550 {
1551 gdb::unique_xmalloc_ptr<char> exe =
1552 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1553 if (exe)
1554 printf_filtered ("exe = '%s'\n", exe.get ());
1555 else
1556 warning (_("unable to read executable path name"));
1557 }
57c2a98a
JB		 1558 if (do_files)
1559 fbsd_core_info_proc_files (gdbarch);
d2176225
JB		 1560 if (do_mappings)
1561 fbsd_core_info_proc_mappings (gdbarch);
1562 if (do_status)
1563 fbsd_core_info_proc_status (gdbarch);
1564}
1565
82372b2f
JB		 1566/* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1567
1568static void
1569fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1570 CORE_ADDR type, CORE_ADDR val)
1571{
fd2b4de5
JB		 1572 const char *name = "???";
1573 const char *description = "";
1574 enum auxv_format format = AUXV_FORMAT_HEX;
82372b2f
JB		 1575
1576 switch (type)
1577 {
fd2b4de5
JB		 1578 case AT_NULL:
1579 case AT_IGNORE:
1580 case AT_EXECFD:
1581 case AT_PHDR:
1582 case AT_PHENT:
1583 case AT_PHNUM:
1584 case AT_PAGESZ:
1585 case AT_BASE:
1586 case AT_FLAGS:
1587 case AT_ENTRY:
1588 case AT_NOTELF:
1589 case AT_UID:
1590 case AT_EUID:
1591 case AT_GID:
1592 case AT_EGID:
1593 default_print_auxv_entry (gdbarch, file, type, val);
1594 return;
82372b2f
JB		 1595#define _TAGNAME(tag) #tag
1596#define TAGNAME(tag) _TAGNAME(AT_##tag)
1597#define TAG(tag, text, kind) \
1598 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1599 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1600 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1601 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1602 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1603 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1604 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1605 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1606 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1607 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
12c4bd7f
JB		 1608 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1609 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
d7ded98f 1610 TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
82372b2f
JB		 1611 }
1612
1613 fprint_auxv_entry (file, name, description, format, type, val);
1614}
1615
762c974a
JB		 1616/* Implement the "get_siginfo_type" gdbarch method. */
1617
1618static struct type *
1619fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1620{
1621 struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1622 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1623 struct type *uid_type, *pid_type;
1624 struct type *sigval_type, *reason_type;
1625 struct type *siginfo_type;
1626 struct type *type;
1627
1628 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1629 if (fbsd_gdbarch_data->siginfo_type != NULL)
1630 return fbsd_gdbarch_data->siginfo_type;
1631
1632 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1633 0, "int");
1634 int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1635 uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1636 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1637 0, "long");
1638 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1639
1640 /* union sigval */
1641 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1642 TYPE_NAME (sigval_type) = xstrdup ("sigval");
1643 append_composite_type_field (sigval_type, "sival_int", int_type);
1644 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1645
1646 /* __pid_t */
1647 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781 1648 TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
762c974a
JB		 1649 TYPE_TARGET_TYPE (pid_type) = int32_type;
1650 TYPE_TARGET_STUB (pid_type) = 1;
1651
1652 /* __uid_t */
1653 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
77b7c781
UW		 1654 TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1655 "__uid_t");
762c974a
JB		 1656 TYPE_TARGET_TYPE (uid_type) = uint32_type;
1657 TYPE_TARGET_STUB (uid_type) = 1;
1658
1659 /* _reason */
1660 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1661
1662 /* _fault */
1663 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1664 append_composite_type_field (type, "si_trapno", int_type);
1665 append_composite_type_field (reason_type, "_fault", type);
1666
1667 /* _timer */
1668 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1669 append_composite_type_field (type, "si_timerid", int_type);
1670 append_composite_type_field (type, "si_overrun", int_type);
1671 append_composite_type_field (reason_type, "_timer", type);
1672
1673 /* _mesgq */
1674 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1675 append_composite_type_field (type, "si_mqd", int_type);
1676 append_composite_type_field (reason_type, "_mesgq", type);
1677
1678 /* _poll */
1679 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1680 append_composite_type_field (type, "si_band", long_type);
1681 append_composite_type_field (reason_type, "_poll", type);
1682
1683 /* __spare__ */
1684 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1685 append_composite_type_field (type, "__spare1__", long_type);
1686 append_composite_type_field (type, "__spare2__",
1687 init_vector_type (int_type, 7));
1688 append_composite_type_field (reason_type, "__spare__", type);
1689
1690 /* struct siginfo */
1691 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1692 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
1693 append_composite_type_field (siginfo_type, "si_signo", int_type);
1694 append_composite_type_field (siginfo_type, "si_errno", int_type);
1695 append_composite_type_field (siginfo_type, "si_code", int_type);
1696 append_composite_type_field (siginfo_type, "si_pid", pid_type);
1697 append_composite_type_field (siginfo_type, "si_uid", uid_type);
1698 append_composite_type_field (siginfo_type, "si_status", int_type);
1699 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1700 append_composite_type_field (siginfo_type, "si_value", sigval_type);
1701 append_composite_type_field (siginfo_type, "_reason", reason_type);
1702
1703 fbsd_gdbarch_data->siginfo_type = siginfo_type;
1704
1705 return siginfo_type;
1706}
1707
e61667ef
RS		 1708/* Implement the "gdb_signal_from_target" gdbarch method. */
1709
1710static enum gdb_signal
1711fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1712{
1713 switch (signal)
1714 {
1715 case 0:
1716 return GDB_SIGNAL_0;
1717
1718 case FREEBSD_SIGHUP:
1719 return GDB_SIGNAL_HUP;
1720
1721 case FREEBSD_SIGINT:
1722 return GDB_SIGNAL_INT;
1723
1724 case FREEBSD_SIGQUIT:
1725 return GDB_SIGNAL_QUIT;
1726
1727 case FREEBSD_SIGILL:
1728 return GDB_SIGNAL_ILL;
1729
1730 case FREEBSD_SIGTRAP:
1731 return GDB_SIGNAL_TRAP;
1732
1733 case FREEBSD_SIGABRT:
1734 return GDB_SIGNAL_ABRT;
1735
1736 case FREEBSD_SIGEMT:
1737 return GDB_SIGNAL_EMT;
1738
1739 case FREEBSD_SIGFPE:
1740 return GDB_SIGNAL_FPE;
1741
1742 case FREEBSD_SIGKILL:
1743 return GDB_SIGNAL_KILL;
1744
1745 case FREEBSD_SIGBUS:
1746 return GDB_SIGNAL_BUS;
1747
1748 case FREEBSD_SIGSEGV:
1749 return GDB_SIGNAL_SEGV;
1750
1751 case FREEBSD_SIGSYS:
1752 return GDB_SIGNAL_SYS;
1753
1754 case FREEBSD_SIGPIPE:
1755 return GDB_SIGNAL_PIPE;
1756
1757 case FREEBSD_SIGALRM:
1758 return GDB_SIGNAL_ALRM;
1759
1760 case FREEBSD_SIGTERM:
1761 return GDB_SIGNAL_TERM;
1762
1763 case FREEBSD_SIGURG:
1764 return GDB_SIGNAL_URG;
1765
1766 case FREEBSD_SIGSTOP:
1767 return GDB_SIGNAL_STOP;
1768
1769 case FREEBSD_SIGTSTP:
1770 return GDB_SIGNAL_TSTP;
1771
1772 case FREEBSD_SIGCONT:
1773 return GDB_SIGNAL_CONT;
1774
1775 case FREEBSD_SIGCHLD:
1776 return GDB_SIGNAL_CHLD;
1777
1778 case FREEBSD_SIGTTIN:
1779 return GDB_SIGNAL_TTIN;
1780
1781 case FREEBSD_SIGTTOU:
1782 return GDB_SIGNAL_TTOU;
1783
1784 case FREEBSD_SIGIO:
1785 return GDB_SIGNAL_IO;
1786
1787 case FREEBSD_SIGXCPU:
1788 return GDB_SIGNAL_XCPU;
1789
1790 case FREEBSD_SIGXFSZ:
1791 return GDB_SIGNAL_XFSZ;
1792
1793 case FREEBSD_SIGVTALRM:
1794 return GDB_SIGNAL_VTALRM;
1795
1796 case FREEBSD_SIGPROF:
1797 return GDB_SIGNAL_PROF;
1798
1799 case FREEBSD_SIGWINCH:
1800 return GDB_SIGNAL_WINCH;
1801
1802 case FREEBSD_SIGINFO:
1803 return GDB_SIGNAL_INFO;
1804
1805 case FREEBSD_SIGUSR1:
1806 return GDB_SIGNAL_USR1;
1807
1808 case FREEBSD_SIGUSR2:
1809 return GDB_SIGNAL_USR2;
1810
1811 /* SIGTHR is the same as SIGLWP on FreeBSD. */
1812 case FREEBSD_SIGTHR:
1813 return GDB_SIGNAL_LWP;
1814
1815 case FREEBSD_SIGLIBRT:
1816 return GDB_SIGNAL_LIBRT;
1817 }
1818
1819 if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX)
1820 {
1821 int offset = signal - FREEBSD_SIGRTMIN;
1822
1823 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset);
1824 }
1825
1826 return GDB_SIGNAL_UNKNOWN;
1827}
1828
1829/* Implement the "gdb_signal_to_target" gdbarch method. */
1830
1831static int
1832fbsd_gdb_signal_to_target (struct gdbarch *gdbarch,
1833 enum gdb_signal signal)
1834{
1835 switch (signal)
1836 {
1837 case GDB_SIGNAL_0:
1838 return 0;
1839
1840 case GDB_SIGNAL_HUP:
1841 return FREEBSD_SIGHUP;
1842
1843 case GDB_SIGNAL_INT:
1844 return FREEBSD_SIGINT;
1845
1846 case GDB_SIGNAL_QUIT:
1847 return FREEBSD_SIGQUIT;
1848
1849 case GDB_SIGNAL_ILL:
1850 return FREEBSD_SIGILL;
1851
1852 case GDB_SIGNAL_TRAP:
1853 return FREEBSD_SIGTRAP;
1854
1855 case GDB_SIGNAL_ABRT:
1856 return FREEBSD_SIGABRT;
1857
1858 case GDB_SIGNAL_EMT:
1859 return FREEBSD_SIGEMT;
1860
1861 case GDB_SIGNAL_FPE:
1862 return FREEBSD_SIGFPE;
1863
1864 case GDB_SIGNAL_KILL:
1865 return FREEBSD_SIGKILL;
1866
1867 case GDB_SIGNAL_BUS:
1868 return FREEBSD_SIGBUS;
1869
1870 case GDB_SIGNAL_SEGV:
1871 return FREEBSD_SIGSEGV;
1872
1873 case GDB_SIGNAL_SYS:
1874 return FREEBSD_SIGSYS;
1875
1876 case GDB_SIGNAL_PIPE:
1877 return FREEBSD_SIGPIPE;
1878
1879 case GDB_SIGNAL_ALRM:
1880 return FREEBSD_SIGALRM;
1881
1882 case GDB_SIGNAL_TERM:
1883 return FREEBSD_SIGTERM;
1884
1885 case GDB_SIGNAL_URG:
1886 return FREEBSD_SIGURG;
1887
1888 case GDB_SIGNAL_STOP:
1889 return FREEBSD_SIGSTOP;
1890
1891 case GDB_SIGNAL_TSTP:
1892 return FREEBSD_SIGTSTP;
1893
1894 case GDB_SIGNAL_CONT:
1895 return FREEBSD_SIGCONT;
1896
1897 case GDB_SIGNAL_CHLD:
1898 return FREEBSD_SIGCHLD;
1899
1900 case GDB_SIGNAL_TTIN:
1901 return FREEBSD_SIGTTIN;
1902
1903 case GDB_SIGNAL_TTOU:
1904 return FREEBSD_SIGTTOU;
1905
1906 case GDB_SIGNAL_IO:
1907 return FREEBSD_SIGIO;
1908
1909 case GDB_SIGNAL_XCPU:
1910 return FREEBSD_SIGXCPU;
1911
1912 case GDB_SIGNAL_XFSZ:
1913 return FREEBSD_SIGXFSZ;
1914
1915 case GDB_SIGNAL_VTALRM:
1916 return FREEBSD_SIGVTALRM;
1917
1918 case GDB_SIGNAL_PROF:
1919 return FREEBSD_SIGPROF;
1920
1921 case GDB_SIGNAL_WINCH:
1922 return FREEBSD_SIGWINCH;
1923
1924 case GDB_SIGNAL_INFO:
1925 return FREEBSD_SIGINFO;
1926
1927 case GDB_SIGNAL_USR1:
1928 return FREEBSD_SIGUSR1;
1929
1930 case GDB_SIGNAL_USR2:
1931 return FREEBSD_SIGUSR2;
1932
1933 case GDB_SIGNAL_LWP:
1934 return FREEBSD_SIGTHR;
1935
1936 case GDB_SIGNAL_LIBRT:
1937 return FREEBSD_SIGLIBRT;
1938 }
1939
1940 if (signal >= GDB_SIGNAL_REALTIME_65
1941 && signal <= GDB_SIGNAL_REALTIME_126)
1942 {
1943 int offset = signal - GDB_SIGNAL_REALTIME_65;
1944
1945 return FREEBSD_SIGRTMIN + offset;
1946 }
1947
1948 return -1;
1949}
1950
e6cdd38e
JB		 1951/* Implement the "get_syscall_number" gdbarch method. */
1952
1953static LONGEST
00431a78 1954fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
e6cdd38e
JB		 1955{
1956
1957 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1958 native targets fetch the system call number from the
1959 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1960 However, system call catching requires this function to be
1961 set. */
1962
1963 internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1964}
1965
945f3901
JB		 1966/* Read an integer symbol value from the current target. */
1967
1968static LONGEST
1969fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name)
1970{
1971 bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL);
1972 if (ms.minsym == NULL)
1973 error (_("Unable to resolve symbol '%s'"), name);
1974
1975 gdb_byte buf[4];
1976 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), buf, sizeof buf) != 0)
1977 error (_("Unable to read value of '%s'"), name);
1978
1979 return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
1980}
1981
1982/* Lookup offsets of fields in the runtime linker's 'Obj_Entry'
1983 structure needed to determine the TLS index of an object file. */
1984
1985static void
1986fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
1987{
1988 TRY
1989 {
1990 /* Fetch offsets from debug symbols in rtld. */
1991 struct symbol *obj_entry_sym
1992 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
1993 language_c, NULL).symbol;
1994 if (obj_entry_sym == NULL)
1995 error (_("Unable to find Struct_Obj_Entry symbol"));
1996 data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
1997 "linkmap", 0).offset / 8;
1998 data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE(obj_entry_sym),
1999 "tlsindex", 0).offset / 8;
2000 data->rtld_offsets_valid = true;
2001 return;
2002 }
2003 CATCH (e, RETURN_MASK_ERROR)
2004 {
2005 data->off_linkmap = -1;
2006 }
2007 END_CATCH
2008
2009 TRY
2010 {
2011 /* Fetch offsets from global variables in libthr. Note that
2012 this does not work for single-threaded processes that are not
2013 linked against libthr. */
2014 data->off_linkmap = fbsd_read_integer_by_name (gdbarch,
2015 "_thread_off_linkmap");
2016 data->off_tlsindex = fbsd_read_integer_by_name (gdbarch,
2017 "_thread_off_tlsindex");
2018 data->rtld_offsets_valid = true;
2019 return;
2020 }
2021 CATCH (e, RETURN_MASK_ERROR)
2022 {
2023 data->off_linkmap = -1;
2024 }
2025 END_CATCH
2026}
2027
2028/* Helper function to read the TLS index of an object file associated
2029 with a link map entry at LM_ADDR. */
2030
2031static LONGEST
2032fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr)
2033{
2034 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space);
2035
2036 if (!data->rtld_offsets_valid)
2037 fbsd_fetch_rtld_offsets (gdbarch, data);
2038
2039 if (data->off_linkmap == -1)
2040 throw_error (TLS_GENERIC_ERROR,
2041 _("Cannot fetch runtime linker structure offsets"));
2042
2043 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry
2044 pointer and then compute the offset of the tlsindex member. */
2045 CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex;
2046
2047 gdb_byte buf[4];
2048 if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0)
2049 throw_error (TLS_GENERIC_ERROR,
2050 _("Cannot find thread-local variables on this target"));
2051
2052 return extract_signed_integer (buf, sizeof buf, gdbarch_byte_order (gdbarch));
2053}
2054
2055/* See fbsd-tdep.h. */
2056
2057CORE_ADDR
2058fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr,
2059 CORE_ADDR lm_addr, CORE_ADDR offset)
2060{
2061 LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr);
2062
2063 gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
2064 if (target_read_memory (dtv_addr, buf, sizeof buf) != 0)
2065 throw_error (TLS_GENERIC_ERROR,
2066 _("Cannot find thread-local variables on this target"));
2067
2068 const struct builtin_type *builtin = builtin_type (gdbarch);
2069 CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch,
2070 builtin->builtin_data_ptr, buf);
2071
2072 addr += (tls_index + 1) * TYPE_LENGTH (builtin->builtin_data_ptr);
2073 if (target_read_memory (addr, buf, sizeof buf) != 0)
2074 throw_error (TLS_GENERIC_ERROR,
2075 _("Cannot find thread-local variables on this target"));
2076
2077 addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf);
2078 return addr + offset;
2079}
2080
1736a7bd 2081/* To be called from GDB_OSABI_FREEBSD handlers. */
a904c024
AA		 2082
2083void
2084fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2085{
79117428
JB		 2086 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
2087 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
4b654465 2088 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
a904c024 2089 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
d2176225 2090 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
82372b2f 2091 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
762c974a 2092 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
e61667ef
RS		 2093 set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target);
2094 set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target);
e6cdd38e
JB		 2095
2096 /* `catch syscall' */
2097 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
2098 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
a904c024 2099}
762c974a 2100
762c974a
JB		 2101void
2102_initialize_fbsd_tdep (void)
2103{
2104 fbsd_gdbarch_data_handle =
2105 gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
945f3901
JB		 2106 fbsd_pspace_data_handle
2107 = register_program_space_data_with_cleanup (NULL, fbsd_pspace_data_cleanup);
762c974a 2108}
GDB Binutils - Deliverables
This page took 0.426152 seconds and 4 git commands to generate.