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