]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/fbsd-tdep.c
Remove ptid_get_pid
[thirdparty/binutils-gdb.git] / gdb / fbsd-tdep.c
1 /* Target-dependent code for FreeBSD, architecture-independent.
2
3 Copyright (C) 2002-2018 Free Software Foundation, Inc.
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"
21 #include "auxv.h"
22 #include "gdbcore.h"
23 #include "inferior.h"
24 #include "regcache.h"
25 #include "regset.h"
26 #include "gdbthread.h"
27 #include "xml-syscall.h"
28
29 #include "elf-bfd.h"
30 #include "fbsd-tdep.h"
31
32
33 /* FreeBSD kernels 12.0 and later include a copy of the
34 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
35 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
36 The constants below define the offset of field members and flags in
37 this structure used by methods in this file. Note that the
38 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
39 containing the size of the structure. */
40
41 #define LWPINFO_OFFSET 0x4
42
43 /* Offsets in ptrace_lwpinfo. */
44 #define LWPINFO_PL_FLAGS 0x8
45 #define LWPINFO64_PL_SIGINFO 0x30
46 #define LWPINFO32_PL_SIGINFO 0x2c
47
48 /* Flags in pl_flags. */
49 #define PL_FLAG_SI 0x20 /* siginfo is valid */
50
51 /* Sizes of siginfo_t. */
52 #define SIZE64_SIGINFO_T 80
53 #define SIZE32_SIGINFO_T 64
54
55 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core
56 dump notes. See <sys/user.h> for the definition of struct
57 kinfo_vmentry. This data structure should have the same layout on
58 all architectures. */
59
60 #define KVE_STRUCTSIZE 0x0
61 #define KVE_START 0x8
62 #define KVE_END 0x10
63 #define KVE_OFFSET 0x18
64 #define KVE_FLAGS 0x2c
65 #define KVE_PROTECTION 0x38
66 #define KVE_PATH 0x88
67
68 /* Flags in the 'kve_protection' field in struct kinfo_vmentry. These
69 match the KVME_PROT_* constants in <sys/user.h>. */
70
71 #define KINFO_VME_PROT_READ 0x00000001
72 #define KINFO_VME_PROT_WRITE 0x00000002
73 #define KINFO_VME_PROT_EXEC 0x00000004
74
75 /* Flags in the 'kve_flags' field in struct kinfo_vmentry. These
76 match the KVME_FLAG_* constants in <sys/user.h>. */
77
78 #define KINFO_VME_FLAG_COW 0x00000001
79 #define KINFO_VME_FLAG_NEEDS_COPY 0x00000002
80 #define KINFO_VME_FLAG_NOCOREDUMP 0x00000004
81 #define KINFO_VME_FLAG_SUPER 0x00000008
82 #define KINFO_VME_FLAG_GROWS_UP 0x00000010
83 #define KINFO_VME_FLAG_GROWS_DOWN 0x00000020
84
85 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core
86 dump notes. See <sys/user.h> for the definition of struct
87 kinfo_file. This data structure should have the same layout on all
88 architectures. */
89
90 #define KF_STRUCTSIZE 0x0
91 #define KF_TYPE 0x4
92 #define KF_FD 0x8
93 #define KF_PATH 0x170
94
95 /* Constants for the 'kf_type' field in struct kinfo_file. These
96 match the KF_TYPE_* constants in <sys/user.h>. */
97
98 #define KINFO_FILE_TYPE_VNODE 1
99
100 /* Special values for the 'kf_fd' field in struct kinfo_file. These
101 match the KF_FD_TYPE_* constants in <sys/user.h>. */
102
103 #define KINFO_FILE_FD_TYPE_CWD -1
104 #define KINFO_FILE_FD_TYPE_TEXT -5
105
106 /* Number of 32-bit words in a signal set. This matches _SIG_WORDS in
107 <sys/_sigset.h> and is the same value on all architectures. */
108
109 #define SIG_WORDS 4
110
111 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core
112 dump notes. See <sys/user.h> for the definition of struct
113 kinfo_proc. This data structure has different layouts on different
114 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386
115 uses a 32-bit time_t while all other architectures use a 64-bit
116 time_t.
117
118 The core dump note actually contains one kinfo_proc structure for
119 each thread, but all of the process-wide data can be obtained from
120 the first structure. One result of this note's format is that some
121 of the process-wide status available in the native target method
122 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist
123 is not available from a core dump. Instead, the per-thread data
124 structures contain the value of these fields for individual
125 threads. */
126
127 struct kinfo_proc_layout
128 {
129 /* Offsets of struct kinfo_proc members. */
130 int ki_layout;
131 int ki_pid;
132 int ki_ppid;
133 int ki_pgid;
134 int ki_tpgid;
135 int ki_sid;
136 int ki_tdev_freebsd11;
137 int ki_sigignore;
138 int ki_sigcatch;
139 int ki_uid;
140 int ki_ruid;
141 int ki_svuid;
142 int ki_rgid;
143 int ki_svgid;
144 int ki_ngroups;
145 int ki_groups;
146 int ki_size;
147 int ki_rssize;
148 int ki_tsize;
149 int ki_dsize;
150 int ki_ssize;
151 int ki_start;
152 int ki_nice;
153 int ki_comm;
154 int ki_tdev;
155 int ki_rusage;
156 int ki_rusage_ch;
157
158 /* Offsets of struct rusage members. */
159 int ru_utime;
160 int ru_stime;
161 int ru_maxrss;
162 int ru_minflt;
163 int ru_majflt;
164 };
165
166 const struct kinfo_proc_layout kinfo_proc_layout_32 =
167 {
168 .ki_layout = 0x4,
169 .ki_pid = 0x28,
170 .ki_ppid = 0x2c,
171 .ki_pgid = 0x30,
172 .ki_tpgid = 0x34,
173 .ki_sid = 0x38,
174 .ki_tdev_freebsd11 = 0x44,
175 .ki_sigignore = 0x68,
176 .ki_sigcatch = 0x78,
177 .ki_uid = 0x88,
178 .ki_ruid = 0x8c,
179 .ki_svuid = 0x90,
180 .ki_rgid = 0x94,
181 .ki_svgid = 0x98,
182 .ki_ngroups = 0x9c,
183 .ki_groups = 0xa0,
184 .ki_size = 0xe0,
185 .ki_rssize = 0xe4,
186 .ki_tsize = 0xec,
187 .ki_dsize = 0xf0,
188 .ki_ssize = 0xf4,
189 .ki_start = 0x118,
190 .ki_nice = 0x145,
191 .ki_comm = 0x17f,
192 .ki_tdev = 0x1f0,
193 .ki_rusage = 0x220,
194 .ki_rusage_ch = 0x278,
195
196 .ru_utime = 0x0,
197 .ru_stime = 0x10,
198 .ru_maxrss = 0x20,
199 .ru_minflt = 0x30,
200 .ru_majflt = 0x34,
201 };
202
203 const struct kinfo_proc_layout kinfo_proc_layout_i386 =
204 {
205 .ki_layout = 0x4,
206 .ki_pid = 0x28,
207 .ki_ppid = 0x2c,
208 .ki_pgid = 0x30,
209 .ki_tpgid = 0x34,
210 .ki_sid = 0x38,
211 .ki_tdev_freebsd11 = 0x44,
212 .ki_sigignore = 0x68,
213 .ki_sigcatch = 0x78,
214 .ki_uid = 0x88,
215 .ki_ruid = 0x8c,
216 .ki_svuid = 0x90,
217 .ki_rgid = 0x94,
218 .ki_svgid = 0x98,
219 .ki_ngroups = 0x9c,
220 .ki_groups = 0xa0,
221 .ki_size = 0xe0,
222 .ki_rssize = 0xe4,
223 .ki_tsize = 0xec,
224 .ki_dsize = 0xf0,
225 .ki_ssize = 0xf4,
226 .ki_start = 0x118,
227 .ki_nice = 0x135,
228 .ki_comm = 0x16f,
229 .ki_tdev = 0x1e0,
230 .ki_rusage = 0x210,
231 .ki_rusage_ch = 0x258,
232
233 .ru_utime = 0x0,
234 .ru_stime = 0x8,
235 .ru_maxrss = 0x10,
236 .ru_minflt = 0x20,
237 .ru_majflt = 0x24,
238 };
239
240 const struct kinfo_proc_layout kinfo_proc_layout_64 =
241 {
242 .ki_layout = 0x4,
243 .ki_pid = 0x48,
244 .ki_ppid = 0x4c,
245 .ki_pgid = 0x50,
246 .ki_tpgid = 0x54,
247 .ki_sid = 0x58,
248 .ki_tdev_freebsd11 = 0x64,
249 .ki_sigignore = 0x88,
250 .ki_sigcatch = 0x98,
251 .ki_uid = 0xa8,
252 .ki_ruid = 0xac,
253 .ki_svuid = 0xb0,
254 .ki_rgid = 0xb4,
255 .ki_svgid = 0xb8,
256 .ki_ngroups = 0xbc,
257 .ki_groups = 0xc0,
258 .ki_size = 0x100,
259 .ki_rssize = 0x108,
260 .ki_tsize = 0x118,
261 .ki_dsize = 0x120,
262 .ki_ssize = 0x128,
263 .ki_start = 0x150,
264 .ki_nice = 0x185,
265 .ki_comm = 0x1bf,
266 .ki_tdev = 0x230,
267 .ki_rusage = 0x260,
268 .ki_rusage_ch = 0x2f0,
269
270 .ru_utime = 0x0,
271 .ru_stime = 0x10,
272 .ru_maxrss = 0x20,
273 .ru_minflt = 0x40,
274 .ru_majflt = 0x48,
275 };
276
277 static struct gdbarch_data *fbsd_gdbarch_data_handle;
278
279 struct fbsd_gdbarch_data
280 {
281 struct type *siginfo_type;
282 };
283
284 static void *
285 init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
286 {
287 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
288 }
289
290 static struct fbsd_gdbarch_data *
291 get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
292 {
293 return ((struct fbsd_gdbarch_data *)
294 gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
295 }
296
297 /* This is how we want PTIDs from core files to be printed. */
298
299 static const char *
300 fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
301 {
302 static char buf[80];
303
304 if (ptid_get_lwp (ptid) != 0)
305 {
306 xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
307 return buf;
308 }
309
310 return normal_pid_to_str (ptid);
311 }
312
313 /* Extract the name assigned to a thread from a core. Returns the
314 string in a static buffer. */
315
316 static const char *
317 fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
318 {
319 static char buf[80];
320 struct bfd_section *section;
321 bfd_size_type size;
322
323 if (ptid_get_lwp (thr->ptid) != 0)
324 {
325 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
326 whose contents are defined by a "struct thrmisc" declared in
327 <sys/procfs.h> on FreeBSD. The per-thread name is stored as
328 a null-terminated string as the first member of the
329 structure. Rather than define the full structure here, just
330 extract the null-terminated name from the start of the
331 note. */
332 thread_section_name section_name (".thrmisc", thr->ptid);
333
334 section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
335 if (section != NULL && bfd_section_size (core_bfd, section) > 0)
336 {
337 /* Truncate the name if it is longer than "buf". */
338 size = bfd_section_size (core_bfd, section);
339 if (size > sizeof buf - 1)
340 size = sizeof buf - 1;
341 if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
342 size)
343 && buf[0] != '\0')
344 {
345 buf[size] = '\0';
346
347 /* Note that each thread will report the process command
348 as its thread name instead of an empty name if a name
349 has not been set explicitly. Return a NULL name in
350 that case. */
351 if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
352 return buf;
353 }
354 }
355 }
356
357 return NULL;
358 }
359
360 /* Implement the "core_xfer_siginfo" gdbarch method. */
361
362 static LONGEST
363 fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
364 ULONGEST offset, ULONGEST len)
365 {
366 size_t siginfo_size;
367
368 if (gdbarch_long_bit (gdbarch) == 32)
369 siginfo_size = SIZE32_SIGINFO_T;
370 else
371 siginfo_size = SIZE64_SIGINFO_T;
372 if (offset > siginfo_size)
373 return -1;
374
375 thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
376 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
377 if (section == NULL)
378 return -1;
379
380 gdb_byte buf[4];
381 if (!bfd_get_section_contents (core_bfd, section, buf,
382 LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
383 return -1;
384
385 int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
386 if (!(pl_flags & PL_FLAG_SI))
387 return -1;
388
389 if (offset + len > siginfo_size)
390 len = siginfo_size - offset;
391
392 ULONGEST siginfo_offset;
393 if (gdbarch_long_bit (gdbarch) == 32)
394 siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
395 else
396 siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
397
398 if (!bfd_get_section_contents (core_bfd, section, readbuf,
399 siginfo_offset + offset, len))
400 return -1;
401
402 return len;
403 }
404
405 static int
406 find_signalled_thread (struct thread_info *info, void *data)
407 {
408 if (info->suspend.stop_signal != GDB_SIGNAL_0
409 && info->ptid.pid () == inferior_ptid.pid ())
410 return 1;
411
412 return 0;
413 }
414
415 /* Structure for passing information from
416 fbsd_collect_thread_registers via an iterator to
417 fbsd_collect_regset_section_cb. */
418
419 struct fbsd_collect_regset_section_cb_data
420 {
421 const struct regcache *regcache;
422 bfd *obfd;
423 char *note_data;
424 int *note_size;
425 unsigned long lwp;
426 enum gdb_signal stop_signal;
427 int abort_iteration;
428 };
429
430 static void
431 fbsd_collect_regset_section_cb (const char *sect_name, int size,
432 const struct regset *regset,
433 const char *human_name, void *cb_data)
434 {
435 char *buf;
436 struct fbsd_collect_regset_section_cb_data *data
437 = (struct fbsd_collect_regset_section_cb_data *) cb_data;
438
439 if (data->abort_iteration)
440 return;
441
442 gdb_assert (regset->collect_regset);
443
444 buf = (char *) xmalloc (size);
445 regset->collect_regset (regset, data->regcache, -1, buf, size);
446
447 /* PRSTATUS still needs to be treated specially. */
448 if (strcmp (sect_name, ".reg") == 0)
449 data->note_data = (char *) elfcore_write_prstatus
450 (data->obfd, data->note_data, data->note_size, data->lwp,
451 gdb_signal_to_host (data->stop_signal), buf);
452 else
453 data->note_data = (char *) elfcore_write_register_note
454 (data->obfd, data->note_data, data->note_size,
455 sect_name, buf, size);
456 xfree (buf);
457
458 if (data->note_data == NULL)
459 data->abort_iteration = 1;
460 }
461
462 /* Records the thread's register state for the corefile note
463 section. */
464
465 static char *
466 fbsd_collect_thread_registers (const struct regcache *regcache,
467 ptid_t ptid, bfd *obfd,
468 char *note_data, int *note_size,
469 enum gdb_signal stop_signal)
470 {
471 struct gdbarch *gdbarch = regcache->arch ();
472 struct fbsd_collect_regset_section_cb_data data;
473
474 data.regcache = regcache;
475 data.obfd = obfd;
476 data.note_data = note_data;
477 data.note_size = note_size;
478 data.stop_signal = stop_signal;
479 data.abort_iteration = 0;
480 data.lwp = ptid_get_lwp (ptid);
481
482 gdbarch_iterate_over_regset_sections (gdbarch,
483 fbsd_collect_regset_section_cb,
484 &data, regcache);
485 return data.note_data;
486 }
487
488 struct fbsd_corefile_thread_data
489 {
490 struct gdbarch *gdbarch;
491 bfd *obfd;
492 char *note_data;
493 int *note_size;
494 enum gdb_signal stop_signal;
495 };
496
497 /* Records the thread's register state for the corefile note
498 section. */
499
500 static void
501 fbsd_corefile_thread (struct thread_info *info,
502 struct fbsd_corefile_thread_data *args)
503 {
504 struct regcache *regcache;
505
506 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
507
508 target_fetch_registers (regcache, -1);
509
510 args->note_data = fbsd_collect_thread_registers
511 (regcache, info->ptid, args->obfd, args->note_data,
512 args->note_size, args->stop_signal);
513 }
514
515 /* Create appropriate note sections for a corefile, returning them in
516 allocated memory. */
517
518 static char *
519 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
520 {
521 struct fbsd_corefile_thread_data thread_args;
522 char *note_data = NULL;
523 Elf_Internal_Ehdr *i_ehdrp;
524 struct thread_info *curr_thr, *signalled_thr, *thr;
525
526 /* Put a "FreeBSD" label in the ELF header. */
527 i_ehdrp = elf_elfheader (obfd);
528 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
529
530 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
531
532 if (get_exec_file (0))
533 {
534 const char *fname = lbasename (get_exec_file (0));
535 char *psargs = xstrdup (fname);
536
537 if (get_inferior_args ())
538 psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
539 (char *) NULL);
540
541 note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
542 fname, psargs);
543 }
544
545 /* Thread register information. */
546 TRY
547 {
548 update_thread_list ();
549 }
550 CATCH (e, RETURN_MASK_ERROR)
551 {
552 exception_print (gdb_stderr, e);
553 }
554 END_CATCH
555
556 /* Like the kernel, prefer dumping the signalled thread first.
557 "First thread" is what tools use to infer the signalled thread.
558 In case there's more than one signalled thread, prefer the
559 current thread, if it is signalled. */
560 curr_thr = inferior_thread ();
561 if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
562 signalled_thr = curr_thr;
563 else
564 {
565 signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
566 if (signalled_thr == NULL)
567 signalled_thr = curr_thr;
568 }
569
570 thread_args.gdbarch = gdbarch;
571 thread_args.obfd = obfd;
572 thread_args.note_data = note_data;
573 thread_args.note_size = note_size;
574 thread_args.stop_signal = signalled_thr->suspend.stop_signal;
575
576 fbsd_corefile_thread (signalled_thr, &thread_args);
577 ALL_NON_EXITED_THREADS (thr)
578 {
579 if (thr == signalled_thr)
580 continue;
581 if (thr->ptid.pid () != inferior_ptid.pid ())
582 continue;
583
584 fbsd_corefile_thread (thr, &thread_args);
585 }
586
587 note_data = thread_args.note_data;
588
589 return note_data;
590 }
591
592 /* Helper function to generate mappings flags for a single VM map
593 entry in 'info proc mappings'. */
594
595 const char *
596 fbsd_vm_map_entry_flags (int kve_flags, int kve_protection)
597 {
598 static char vm_flags[9];
599
600 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-';
601 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-';
602 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-';
603 vm_flags[3] = ' ';
604 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-';
605 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-';
606 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-';
607 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U'
608 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-';
609 vm_flags[8] = '\0';
610
611 return vm_flags;
612 }
613
614 /* Implement "info proc mappings" for a corefile. */
615
616 static void
617 fbsd_core_info_proc_mappings (struct gdbarch *gdbarch)
618 {
619 asection *section;
620 unsigned char *descdata, *descend;
621 size_t note_size;
622
623 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap");
624 if (section == NULL)
625 {
626 warning (_("unable to find mappings in core file"));
627 return;
628 }
629
630 note_size = bfd_get_section_size (section);
631 if (note_size < 4)
632 error (_("malformed core note - too short for header"));
633
634 gdb::def_vector<unsigned char> contents (note_size);
635 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
636 0, note_size))
637 error (_("could not get core note contents"));
638
639 descdata = contents.data ();
640 descend = descdata + note_size;
641
642 /* Skip over the structure size. */
643 descdata += 4;
644
645 printf_filtered (_("Mapped address spaces:\n\n"));
646 if (gdbarch_addr_bit (gdbarch) == 64)
647 {
648 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
649 "Start Addr",
650 " End Addr",
651 " Size", " Offset", "Flags ", "File");
652 }
653 else
654 {
655 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
656 "Start Addr",
657 " End Addr",
658 " Size", " Offset", "Flags ", "File");
659 }
660
661 while (descdata + KVE_PATH < descend)
662 {
663 ULONGEST start, end, offset, flags, prot, structsize;
664
665 structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE);
666 if (structsize < KVE_PATH)
667 error (_("malformed core note - vmmap entry too small"));
668
669 start = bfd_get_64 (core_bfd, descdata + KVE_START);
670 end = bfd_get_64 (core_bfd, descdata + KVE_END);
671 offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET);
672 flags = bfd_get_32 (core_bfd, descdata + KVE_FLAGS);
673 prot = bfd_get_32 (core_bfd, descdata + KVE_PROTECTION);
674 if (gdbarch_addr_bit (gdbarch) == 64)
675 {
676 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
677 paddress (gdbarch, start),
678 paddress (gdbarch, end),
679 hex_string (end - start),
680 hex_string (offset),
681 fbsd_vm_map_entry_flags (flags, prot),
682 descdata + KVE_PATH);
683 }
684 else
685 {
686 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
687 paddress (gdbarch, start),
688 paddress (gdbarch, end),
689 hex_string (end - start),
690 hex_string (offset),
691 fbsd_vm_map_entry_flags (flags, prot),
692 descdata + KVE_PATH);
693 }
694
695 descdata += structsize;
696 }
697 }
698
699 /* Fetch the pathname of a vnode for a single file descriptor from the
700 file table core note. */
701
702 static gdb::unique_xmalloc_ptr<char>
703 fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd)
704 {
705 asection *section;
706 unsigned char *descdata, *descend;
707 size_t note_size;
708
709 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files");
710 if (section == NULL)
711 return nullptr;
712
713 note_size = bfd_get_section_size (section);
714 if (note_size < 4)
715 error (_("malformed core note - too short for header"));
716
717 gdb::def_vector<unsigned char> contents (note_size);
718 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
719 0, note_size))
720 error (_("could not get core note contents"));
721
722 descdata = contents.data ();
723 descend = descdata + note_size;
724
725 /* Skip over the structure size. */
726 descdata += 4;
727
728 while (descdata + KVE_PATH < descend)
729 {
730 ULONGEST structsize;
731
732 structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE);
733 if (structsize < KVE_PATH)
734 error (_("malformed core note - vmmap entry too small"));
735
736 if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE
737 && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd)
738 {
739 char *path = (char *) descdata + KF_PATH;
740 return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
741 }
742
743 descdata += structsize;
744 }
745 return nullptr;
746 }
747
748 /* Helper function to read a struct timeval. */
749
750 static void
751 fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data,
752 LONGEST &sec, ULONGEST &usec)
753 {
754 if (gdbarch_addr_bit (gdbarch) == 64)
755 {
756 sec = bfd_get_signed_64 (core_bfd, data);
757 usec = bfd_get_64 (core_bfd, data + 8);
758 }
759 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
760 {
761 sec = bfd_get_signed_32 (core_bfd, data);
762 usec = bfd_get_32 (core_bfd, data + 4);
763 }
764 else
765 {
766 sec = bfd_get_signed_64 (core_bfd, data);
767 usec = bfd_get_32 (core_bfd, data + 8);
768 }
769 }
770
771 /* Print out the contents of a signal set. */
772
773 static void
774 fbsd_print_sigset (const char *descr, unsigned char *sigset)
775 {
776 printf_filtered ("%s: ", descr);
777 for (int i = 0; i < SIG_WORDS; i++)
778 printf_filtered ("%08x ",
779 (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4));
780 printf_filtered ("\n");
781 }
782
783 /* Implement "info proc status" for a corefile. */
784
785 static void
786 fbsd_core_info_proc_status (struct gdbarch *gdbarch)
787 {
788 const struct kinfo_proc_layout *kp;
789 asection *section;
790 const char *state;
791 unsigned char *descdata;
792 int addr_bit, long_bit;
793 size_t note_size;
794 ULONGEST value;
795 LONGEST sec;
796
797 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc");
798 if (section == NULL)
799 {
800 warning (_("unable to find process info in core file"));
801 return;
802 }
803
804 addr_bit = gdbarch_addr_bit (gdbarch);
805 if (addr_bit == 64)
806 kp = &kinfo_proc_layout_64;
807 else if (bfd_get_arch (core_bfd) == bfd_arch_i386)
808 kp = &kinfo_proc_layout_i386;
809 else
810 kp = &kinfo_proc_layout_32;
811 long_bit = gdbarch_long_bit (gdbarch);
812
813 /*
814 * Ensure that the note is large enough for all of the fields fetched
815 * by this function. In particular, the note must contain the 32-bit
816 * structure size, then it must be long enough to access the last
817 * field used (ki_rusage_ch.ru_majflt) which is the size of a long.
818 */
819 note_size = bfd_get_section_size (section);
820 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt
821 + long_bit / TARGET_CHAR_BIT))
822 error (_("malformed core note - too short"));
823
824 gdb::def_vector<unsigned char> contents (note_size);
825 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
826 0, note_size))
827 error (_("could not get core note contents"));
828
829 descdata = contents.data ();
830
831 /* Skip over the structure size. */
832 descdata += 4;
833
834 /* Verify 'ki_layout' is 0. */
835 if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0)
836 {
837 warning (_("unsupported process information in core file"));
838 return;
839 }
840
841 printf_filtered ("Name: %.19s\n", descdata + kp->ki_comm);
842 printf_filtered ("Process ID: %s\n",
843 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid)));
844 printf_filtered ("Parent process: %s\n",
845 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid)));
846 printf_filtered ("Process group: %s\n",
847 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid)));
848 printf_filtered ("Session id: %s\n",
849 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid)));
850
851 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older
852 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older
853 kernels the 64-bit 'ki_tdev' field is in a reserved section of
854 the structure that is cleared to zero. Assume that a zero value
855 in ki_tdev indicates a core dump from an older kernel and use the
856 value in 'ki_tdev_freebsd11' instead. */
857 value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev);
858 if (value == 0)
859 value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11);
860 printf_filtered ("TTY: %s\n", pulongest (value));
861 printf_filtered ("TTY owner process group: %s\n",
862 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid)));
863 printf_filtered ("User IDs (real, effective, saved): %s %s %s\n",
864 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)),
865 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)),
866 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid)));
867 printf_filtered ("Group IDs (real, effective, saved): %s %s %s\n",
868 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)),
869 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)),
870 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid)));
871 printf_filtered ("Groups: ");
872 uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups);
873 for (int i = 0; i < ngroups; i++)
874 printf_filtered ("%s ",
875 pulongest (bfd_get_32 (core_bfd,
876 descdata + kp->ki_groups + i * 4)));
877 printf_filtered ("\n");
878 value = bfd_get (long_bit, core_bfd,
879 descdata + kp->ki_rusage + kp->ru_minflt);
880 printf_filtered ("Minor faults (no memory page): %s\n", pulongest (value));
881 value = bfd_get (long_bit, core_bfd,
882 descdata + kp->ki_rusage_ch + kp->ru_minflt);
883 printf_filtered ("Minor faults, children: %s\n", pulongest (value));
884 value = bfd_get (long_bit, core_bfd,
885 descdata + kp->ki_rusage + kp->ru_majflt);
886 printf_filtered ("Major faults (memory page faults): %s\n",
887 pulongest (value));
888 value = bfd_get (long_bit, core_bfd,
889 descdata + kp->ki_rusage_ch + kp->ru_majflt);
890 printf_filtered ("Major faults, children: %s\n", pulongest (value));
891 fbsd_core_fetch_timeval (gdbarch,
892 descdata + kp->ki_rusage + kp->ru_utime,
893 sec, value);
894 printf_filtered ("utime: %s.%06d\n", plongest (sec), (int) value);
895 fbsd_core_fetch_timeval (gdbarch,
896 descdata + kp->ki_rusage + kp->ru_stime,
897 sec, value);
898 printf_filtered ("stime: %s.%06d\n", plongest (sec), (int) value);
899 fbsd_core_fetch_timeval (gdbarch,
900 descdata + kp->ki_rusage_ch + kp->ru_utime,
901 sec, value);
902 printf_filtered ("utime, children: %s.%06d\n", plongest (sec), (int) value);
903 fbsd_core_fetch_timeval (gdbarch,
904 descdata + kp->ki_rusage_ch + kp->ru_stime,
905 sec, value);
906 printf_filtered ("stime, children: %s.%06d\n", plongest (sec), (int) value);
907 printf_filtered ("'nice' value: %d\n",
908 bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice));
909 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value);
910 printf_filtered ("Start time: %s.%06d\n", plongest (sec), (int) value);
911 printf_filtered ("Virtual memory size: %s kB\n",
912 pulongest (bfd_get (addr_bit, core_bfd,
913 descdata + kp->ki_size) / 1024));
914 printf_filtered ("Data size: %s pages\n",
915 pulongest (bfd_get (addr_bit, core_bfd,
916 descdata + kp->ki_dsize)));
917 printf_filtered ("Stack size: %s pages\n",
918 pulongest (bfd_get (addr_bit, core_bfd,
919 descdata + kp->ki_ssize)));
920 printf_filtered ("Text size: %s pages\n",
921 pulongest (bfd_get (addr_bit, core_bfd,
922 descdata + kp->ki_tsize)));
923 printf_filtered ("Resident set size: %s pages\n",
924 pulongest (bfd_get (addr_bit, core_bfd,
925 descdata + kp->ki_rssize)));
926 printf_filtered ("Maximum RSS: %s pages\n",
927 pulongest (bfd_get (long_bit, core_bfd,
928 descdata + kp->ki_rusage
929 + kp->ru_maxrss)));
930 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore);
931 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch);
932 }
933
934 /* Implement the "core_info_proc" gdbarch method. */
935
936 static void
937 fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args,
938 enum info_proc_what what)
939 {
940 bool do_cmdline = false;
941 bool do_cwd = false;
942 bool do_exe = false;
943 bool do_mappings = false;
944 bool do_status = false;
945 int pid;
946
947 switch (what)
948 {
949 case IP_MINIMAL:
950 do_cmdline = true;
951 do_cwd = true;
952 do_exe = true;
953 break;
954 case IP_MAPPINGS:
955 do_mappings = true;
956 break;
957 case IP_STATUS:
958 case IP_STAT:
959 do_status = true;
960 break;
961 case IP_CMDLINE:
962 do_cmdline = true;
963 break;
964 case IP_EXE:
965 do_exe = true;
966 break;
967 case IP_CWD:
968 do_cwd = true;
969 break;
970 case IP_ALL:
971 do_cmdline = true;
972 do_cwd = true;
973 do_exe = true;
974 do_mappings = true;
975 do_status = true;
976 break;
977 default:
978 return;
979 }
980
981 pid = bfd_core_file_pid (core_bfd);
982 if (pid != 0)
983 printf_filtered (_("process %d\n"), pid);
984
985 if (do_cmdline)
986 {
987 const char *cmdline;
988
989 cmdline = bfd_core_file_failing_command (core_bfd);
990 if (cmdline)
991 printf_filtered ("cmdline = '%s'\n", cmdline);
992 else
993 warning (_("Command line unavailable"));
994 }
995 if (do_cwd)
996 {
997 gdb::unique_xmalloc_ptr<char> cwd =
998 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD);
999 if (cwd)
1000 printf_filtered ("cwd = '%s'\n", cwd.get ());
1001 else
1002 warning (_("unable to read current working directory"));
1003 }
1004 if (do_exe)
1005 {
1006 gdb::unique_xmalloc_ptr<char> exe =
1007 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT);
1008 if (exe)
1009 printf_filtered ("exe = '%s'\n", exe.get ());
1010 else
1011 warning (_("unable to read executable path name"));
1012 }
1013 if (do_mappings)
1014 fbsd_core_info_proc_mappings (gdbarch);
1015 if (do_status)
1016 fbsd_core_info_proc_status (gdbarch);
1017 }
1018
1019 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
1020
1021 static void
1022 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
1023 CORE_ADDR type, CORE_ADDR val)
1024 {
1025 const char *name;
1026 const char *description;
1027 enum auxv_format format;
1028
1029 switch (type)
1030 {
1031 #define _TAGNAME(tag) #tag
1032 #define TAGNAME(tag) _TAGNAME(AT_##tag)
1033 #define TAG(tag, text, kind) \
1034 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
1035 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
1036 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
1037 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
1038 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
1039 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
1040 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
1041 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
1042 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
1043 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
1044 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX);
1045 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX);
1046 default:
1047 default_print_auxv_entry (gdbarch, file, type, val);
1048 return;
1049 }
1050
1051 fprint_auxv_entry (file, name, description, format, type, val);
1052 }
1053
1054 /* Implement the "get_siginfo_type" gdbarch method. */
1055
1056 static struct type *
1057 fbsd_get_siginfo_type (struct gdbarch *gdbarch)
1058 {
1059 struct fbsd_gdbarch_data *fbsd_gdbarch_data;
1060 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
1061 struct type *uid_type, *pid_type;
1062 struct type *sigval_type, *reason_type;
1063 struct type *siginfo_type;
1064 struct type *type;
1065
1066 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
1067 if (fbsd_gdbarch_data->siginfo_type != NULL)
1068 return fbsd_gdbarch_data->siginfo_type;
1069
1070 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
1071 0, "int");
1072 int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
1073 uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1074 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
1075 0, "long");
1076 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
1077
1078 /* union sigval */
1079 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1080 TYPE_NAME (sigval_type) = xstrdup ("sigval");
1081 append_composite_type_field (sigval_type, "sival_int", int_type);
1082 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
1083
1084 /* __pid_t */
1085 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1086 TYPE_LENGTH (int32_type) * TARGET_CHAR_BIT, "__pid_t");
1087 TYPE_TARGET_TYPE (pid_type) = int32_type;
1088 TYPE_TARGET_STUB (pid_type) = 1;
1089
1090 /* __uid_t */
1091 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
1092 TYPE_LENGTH (uint32_type) * TARGET_CHAR_BIT,
1093 "__uid_t");
1094 TYPE_TARGET_TYPE (uid_type) = uint32_type;
1095 TYPE_TARGET_STUB (uid_type) = 1;
1096
1097 /* _reason */
1098 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
1099
1100 /* _fault */
1101 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1102 append_composite_type_field (type, "si_trapno", int_type);
1103 append_composite_type_field (reason_type, "_fault", type);
1104
1105 /* _timer */
1106 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1107 append_composite_type_field (type, "si_timerid", int_type);
1108 append_composite_type_field (type, "si_overrun", int_type);
1109 append_composite_type_field (reason_type, "_timer", type);
1110
1111 /* _mesgq */
1112 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1113 append_composite_type_field (type, "si_mqd", int_type);
1114 append_composite_type_field (reason_type, "_mesgq", type);
1115
1116 /* _poll */
1117 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1118 append_composite_type_field (type, "si_band", long_type);
1119 append_composite_type_field (reason_type, "_poll", type);
1120
1121 /* __spare__ */
1122 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1123 append_composite_type_field (type, "__spare1__", long_type);
1124 append_composite_type_field (type, "__spare2__",
1125 init_vector_type (int_type, 7));
1126 append_composite_type_field (reason_type, "__spare__", type);
1127
1128 /* struct siginfo */
1129 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
1130 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
1131 append_composite_type_field (siginfo_type, "si_signo", int_type);
1132 append_composite_type_field (siginfo_type, "si_errno", int_type);
1133 append_composite_type_field (siginfo_type, "si_code", int_type);
1134 append_composite_type_field (siginfo_type, "si_pid", pid_type);
1135 append_composite_type_field (siginfo_type, "si_uid", uid_type);
1136 append_composite_type_field (siginfo_type, "si_status", int_type);
1137 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
1138 append_composite_type_field (siginfo_type, "si_value", sigval_type);
1139 append_composite_type_field (siginfo_type, "_reason", reason_type);
1140
1141 fbsd_gdbarch_data->siginfo_type = siginfo_type;
1142
1143 return siginfo_type;
1144 }
1145
1146 /* Implement the "get_syscall_number" gdbarch method. */
1147
1148 static LONGEST
1149 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
1150 {
1151
1152 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
1153 native targets fetch the system call number from the
1154 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
1155 However, system call catching requires this function to be
1156 set. */
1157
1158 internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
1159 }
1160
1161 /* To be called from GDB_OSABI_FREEBSD handlers. */
1162
1163 void
1164 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1165 {
1166 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
1167 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
1168 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
1169 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
1170 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc);
1171 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
1172 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
1173
1174 /* `catch syscall' */
1175 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
1176 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
1177 }
1178
1179 void
1180 _initialize_fbsd_tdep (void)
1181 {
1182 fbsd_gdbarch_data_handle =
1183 gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
1184 }