fbsd-tdep.c revision 1.9
1 /* Target-dependent code for FreeBSD, architecture-independent. 2 3 Copyright (C) 2002-2024 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 "auxv.h" 21 #include "extract-store-integer.h" 22 #include "gdbcore.h" 23 #include "inferior.h" 24 #include "objfiles.h" 25 #include "regcache.h" 26 #include "regset.h" 27 #include "gdbthread.h" 28 #include "objfiles.h" 29 #include "xml-syscall.h" 30 #include <sys/socket.h> 31 #include <arpa/inet.h> 32 33 #include "elf-bfd.h" 34 #include "fbsd-tdep.h" 35 #include "gcore-elf.h" 36 37 /* This enum is derived from FreeBSD's <sys/signal.h>. */ 38 39 enum 40 { 41 FREEBSD_SIGHUP = 1, 42 FREEBSD_SIGINT = 2, 43 FREEBSD_SIGQUIT = 3, 44 FREEBSD_SIGILL = 4, 45 FREEBSD_SIGTRAP = 5, 46 FREEBSD_SIGABRT = 6, 47 FREEBSD_SIGEMT = 7, 48 FREEBSD_SIGFPE = 8, 49 FREEBSD_SIGKILL = 9, 50 FREEBSD_SIGBUS = 10, 51 FREEBSD_SIGSEGV = 11, 52 FREEBSD_SIGSYS = 12, 53 FREEBSD_SIGPIPE = 13, 54 FREEBSD_SIGALRM = 14, 55 FREEBSD_SIGTERM = 15, 56 FREEBSD_SIGURG = 16, 57 FREEBSD_SIGSTOP = 17, 58 FREEBSD_SIGTSTP = 18, 59 FREEBSD_SIGCONT = 19, 60 FREEBSD_SIGCHLD = 20, 61 FREEBSD_SIGTTIN = 21, 62 FREEBSD_SIGTTOU = 22, 63 FREEBSD_SIGIO = 23, 64 FREEBSD_SIGXCPU = 24, 65 FREEBSD_SIGXFSZ = 25, 66 FREEBSD_SIGVTALRM = 26, 67 FREEBSD_SIGPROF = 27, 68 FREEBSD_SIGWINCH = 28, 69 FREEBSD_SIGINFO = 29, 70 FREEBSD_SIGUSR1 = 30, 71 FREEBSD_SIGUSR2 = 31, 72 FREEBSD_SIGTHR = 32, 73 FREEBSD_SIGLIBRT = 33, 74 FREEBSD_SIGRTMIN = 65, 75 FREEBSD_SIGRTMAX = 126, 76 }; 77 78 /* Constants for values of si_code as defined in FreeBSD's 79 <sys/signal.h>. */ 80 81 #define FBSD_SI_USER 0x10001 82 #define FBSD_SI_QUEUE 0x10002 83 #define FBSD_SI_TIMER 0x10003 84 #define FBSD_SI_ASYNCIO 0x10004 85 #define FBSD_SI_MESGQ 0x10005 86 #define FBSD_SI_KERNEL 0x10006 87 #define FBSD_SI_LWP 0x10007 88 89 #define FBSD_ILL_ILLOPC 1 90 #define FBSD_ILL_ILLOPN 2 91 #define FBSD_ILL_ILLADR 3 92 #define FBSD_ILL_ILLTRP 4 93 #define FBSD_ILL_PRVOPC 5 94 #define FBSD_ILL_PRVREG 6 95 #define FBSD_ILL_COPROC 7 96 #define FBSD_ILL_BADSTK 8 97 98 #define FBSD_BUS_ADRALN 1 99 #define FBSD_BUS_ADRERR 2 100 #define FBSD_BUS_OBJERR 3 101 #define FBSD_BUS_OOMERR 100 102 103 #define FBSD_SEGV_MAPERR 1 104 #define FBSD_SEGV_ACCERR 2 105 #define FBSD_SEGV_PKUERR 100 106 107 #define FBSD_FPE_INTOVF 1 108 #define FBSD_FPE_INTDIV 2 109 #define FBSD_FPE_FLTDIV 3 110 #define FBSD_FPE_FLTOVF 4 111 #define FBSD_FPE_FLTUND 5 112 #define FBSD_FPE_FLTRES 6 113 #define FBSD_FPE_FLTINV 7 114 #define FBSD_FPE_FLTSUB 8 115 116 #define FBSD_TRAP_BRKPT 1 117 #define FBSD_TRAP_TRACE 2 118 #define FBSD_TRAP_DTRACE 3 119 #define FBSD_TRAP_CAP 4 120 121 #define FBSD_CLD_EXITED 1 122 #define FBSD_CLD_KILLED 2 123 #define FBSD_CLD_DUMPED 3 124 #define FBSD_CLD_TRAPPED 4 125 #define FBSD_CLD_STOPPED 5 126 #define FBSD_CLD_CONTINUED 6 127 128 #define FBSD_POLL_IN 1 129 #define FBSD_POLL_OUT 2 130 #define FBSD_POLL_MSG 3 131 #define FBSD_POLL_ERR 4 132 #define FBSD_POLL_PRI 5 133 #define FBSD_POLL_HUP 6 134 135 /* FreeBSD kernels 12.0 and later include a copy of the 136 'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace 137 operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP. 138 The constants below define the offset of field members and flags in 139 this structure used by methods in this file. Note that the 140 'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer 141 containing the size of the structure. */ 142 143 #define LWPINFO_OFFSET 0x4 144 145 /* Offsets in ptrace_lwpinfo. */ 146 #define LWPINFO_PL_FLAGS 0x8 147 #define LWPINFO64_PL_SIGINFO 0x30 148 #define LWPINFO32_PL_SIGINFO 0x2c 149 150 /* Flags in pl_flags. */ 151 #define PL_FLAG_SI 0x20 /* siginfo is valid */ 152 153 /* Sizes of siginfo_t. */ 154 #define SIZE64_SIGINFO_T 80 155 #define SIZE32_SIGINFO_T 64 156 157 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_VMMAP core 158 dump notes. See <sys/user.h> for the definition of struct 159 kinfo_vmentry. This data structure should have the same layout on 160 all architectures. 161 162 Note that FreeBSD 7.0 used an older version of this structure 163 (struct kinfo_vmentry), but the NT_FREEBSD_PROCSTAT_VMMAP core 164 dump note wasn't introduced until FreeBSD 9.2. As a result, the 165 core dump note has always used the 7.1 and later structure 166 format. */ 167 168 #define KVE_STRUCTSIZE 0x0 169 #define KVE_START 0x8 170 #define KVE_END 0x10 171 #define KVE_OFFSET 0x18 172 #define KVE_FLAGS 0x2c 173 #define KVE_PROTECTION 0x38 174 #define KVE_PATH 0x88 175 176 /* Flags in the 'kve_protection' field in struct kinfo_vmentry. These 177 match the KVME_PROT_* constants in <sys/user.h>. */ 178 179 #define KINFO_VME_PROT_READ 0x00000001 180 #define KINFO_VME_PROT_WRITE 0x00000002 181 #define KINFO_VME_PROT_EXEC 0x00000004 182 183 /* Flags in the 'kve_flags' field in struct kinfo_vmentry. These 184 match the KVME_FLAG_* constants in <sys/user.h>. */ 185 186 #define KINFO_VME_FLAG_COW 0x00000001 187 #define KINFO_VME_FLAG_NEEDS_COPY 0x00000002 188 #define KINFO_VME_FLAG_NOCOREDUMP 0x00000004 189 #define KINFO_VME_FLAG_SUPER 0x00000008 190 #define KINFO_VME_FLAG_GROWS_UP 0x00000010 191 #define KINFO_VME_FLAG_GROWS_DOWN 0x00000020 192 193 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_FILES core 194 dump notes. See <sys/user.h> for the definition of struct 195 kinfo_file. This data structure should have the same layout on all 196 architectures. 197 198 Note that FreeBSD 7.0 used an older version of this structure 199 (struct kinfo_ofile), but the NT_FREEBSD_PROCSTAT_FILES core dump 200 note wasn't introduced until FreeBSD 9.2. As a result, the core 201 dump note has always used the 7.1 and later structure format. */ 202 203 #define KF_STRUCTSIZE 0x0 204 #define KF_TYPE 0x4 205 #define KF_FD 0x8 206 #define KF_FLAGS 0x10 207 #define KF_OFFSET 0x18 208 #define KF_VNODE_TYPE 0x20 209 #define KF_SOCK_DOMAIN 0x24 210 #define KF_SOCK_TYPE 0x28 211 #define KF_SOCK_PROTOCOL 0x2c 212 #define KF_SA_LOCAL 0x30 213 #define KF_SA_PEER 0xb0 214 #define KF_PATH 0x170 215 216 /* Constants for the 'kf_type' field in struct kinfo_file. These 217 match the KF_TYPE_* constants in <sys/user.h>. */ 218 219 #define KINFO_FILE_TYPE_VNODE 1 220 #define KINFO_FILE_TYPE_SOCKET 2 221 #define KINFO_FILE_TYPE_PIPE 3 222 #define KINFO_FILE_TYPE_FIFO 4 223 #define KINFO_FILE_TYPE_KQUEUE 5 224 #define KINFO_FILE_TYPE_CRYPTO 6 225 #define KINFO_FILE_TYPE_MQUEUE 7 226 #define KINFO_FILE_TYPE_SHM 8 227 #define KINFO_FILE_TYPE_SEM 9 228 #define KINFO_FILE_TYPE_PTS 10 229 #define KINFO_FILE_TYPE_PROCDESC 11 230 231 /* Special values for the 'kf_fd' field in struct kinfo_file. These 232 match the KF_FD_TYPE_* constants in <sys/user.h>. */ 233 234 #define KINFO_FILE_FD_TYPE_CWD -1 235 #define KINFO_FILE_FD_TYPE_ROOT -2 236 #define KINFO_FILE_FD_TYPE_JAIL -3 237 #define KINFO_FILE_FD_TYPE_TRACE -4 238 #define KINFO_FILE_FD_TYPE_TEXT -5 239 #define KINFO_FILE_FD_TYPE_CTTY -6 240 241 /* Flags in the 'kf_flags' field in struct kinfo_file. These match 242 the KF_FLAG_* constants in <sys/user.h>. */ 243 244 #define KINFO_FILE_FLAG_READ 0x00000001 245 #define KINFO_FILE_FLAG_WRITE 0x00000002 246 #define KINFO_FILE_FLAG_APPEND 0x00000004 247 #define KINFO_FILE_FLAG_ASYNC 0x00000008 248 #define KINFO_FILE_FLAG_FSYNC 0x00000010 249 #define KINFO_FILE_FLAG_NONBLOCK 0x00000020 250 #define KINFO_FILE_FLAG_DIRECT 0x00000040 251 #define KINFO_FILE_FLAG_HASLOCK 0x00000080 252 #define KINFO_FILE_FLAG_EXEC 0x00004000 253 254 /* Constants for the 'kf_vnode_type' field in struct kinfo_file. 255 These match the KF_VTYPE_* constants in <sys/user.h>. */ 256 257 #define KINFO_FILE_VTYPE_VREG 1 258 #define KINFO_FILE_VTYPE_VDIR 2 259 #define KINFO_FILE_VTYPE_VCHR 4 260 #define KINFO_FILE_VTYPE_VLNK 5 261 #define KINFO_FILE_VTYPE_VSOCK 6 262 #define KINFO_FILE_VTYPE_VFIFO 7 263 264 /* Constants for socket address families. These match AF_* constants 265 in <sys/socket.h>. */ 266 267 #define FBSD_AF_UNIX 1 268 #define FBSD_AF_INET 2 269 #define FBSD_AF_INET6 28 270 271 /* Constants for socket types. These match SOCK_* constants in 272 <sys/socket.h>. */ 273 274 #define FBSD_SOCK_STREAM 1 275 #define FBSD_SOCK_DGRAM 2 276 #define FBSD_SOCK_SEQPACKET 5 277 278 /* Constants for IP protocols. These match IPPROTO_* constants in 279 <netinet/in.h>. */ 280 281 #define FBSD_IPPROTO_ICMP 1 282 #define FBSD_IPPROTO_TCP 6 283 #define FBSD_IPPROTO_UDP 17 284 #define FBSD_IPPROTO_SCTP 132 285 286 /* Socket address structures. These have the same layout on all 287 FreeBSD architectures. In addition, multibyte fields such as IP 288 addresses are always stored in network byte order. */ 289 290 struct fbsd_sockaddr_in 291 { 292 uint8_t sin_len; 293 uint8_t sin_family; 294 uint8_t sin_port[2]; 295 uint8_t sin_addr[4]; 296 char sin_zero[8]; 297 }; 298 299 struct fbsd_sockaddr_in6 300 { 301 uint8_t sin6_len; 302 uint8_t sin6_family; 303 uint8_t sin6_port[2]; 304 uint32_t sin6_flowinfo; 305 uint8_t sin6_addr[16]; 306 uint32_t sin6_scope_id; 307 }; 308 309 struct fbsd_sockaddr_un 310 { 311 uint8_t sun_len; 312 uint8_t sun_family; 313 char sun_path[104]; 314 }; 315 316 /* Number of 32-bit words in a signal set. This matches _SIG_WORDS in 317 <sys/_sigset.h> and is the same value on all architectures. */ 318 319 #define SIG_WORDS 4 320 321 /* Offsets in data structure used in NT_FREEBSD_PROCSTAT_PROC core 322 dump notes. See <sys/user.h> for the definition of struct 323 kinfo_proc. This data structure has different layouts on different 324 architectures mostly due to ILP32 vs LP64. However, FreeBSD/i386 325 uses a 32-bit time_t while all other architectures use a 64-bit 326 time_t. 327 328 The core dump note actually contains one kinfo_proc structure for 329 each thread, but all of the process-wide data can be obtained from 330 the first structure. One result of this note's format is that some 331 of the process-wide status available in the native target method 332 from the kern.proc.pid.<pid> sysctl such as ki_stat and ki_siglist 333 is not available from a core dump. Instead, the per-thread data 334 structures contain the value of these fields for individual 335 threads. */ 336 337 struct kinfo_proc_layout 338 { 339 /* Offsets of struct kinfo_proc members. */ 340 int ki_layout; 341 int ki_pid; 342 int ki_ppid; 343 int ki_pgid; 344 int ki_tpgid; 345 int ki_sid; 346 int ki_tdev_freebsd11; 347 int ki_sigignore; 348 int ki_sigcatch; 349 int ki_uid; 350 int ki_ruid; 351 int ki_svuid; 352 int ki_rgid; 353 int ki_svgid; 354 int ki_ngroups; 355 int ki_groups; 356 int ki_size; 357 int ki_rssize; 358 int ki_tsize; 359 int ki_dsize; 360 int ki_ssize; 361 int ki_start; 362 int ki_nice; 363 int ki_comm; 364 int ki_tdev; 365 int ki_rusage; 366 int ki_rusage_ch; 367 368 /* Offsets of struct rusage members. */ 369 int ru_utime; 370 int ru_stime; 371 int ru_maxrss; 372 int ru_minflt; 373 int ru_majflt; 374 }; 375 376 const struct kinfo_proc_layout kinfo_proc_layout_32 = 377 { 378 .ki_layout = 0x4, 379 .ki_pid = 0x28, 380 .ki_ppid = 0x2c, 381 .ki_pgid = 0x30, 382 .ki_tpgid = 0x34, 383 .ki_sid = 0x38, 384 .ki_tdev_freebsd11 = 0x44, 385 .ki_sigignore = 0x68, 386 .ki_sigcatch = 0x78, 387 .ki_uid = 0x88, 388 .ki_ruid = 0x8c, 389 .ki_svuid = 0x90, 390 .ki_rgid = 0x94, 391 .ki_svgid = 0x98, 392 .ki_ngroups = 0x9c, 393 .ki_groups = 0xa0, 394 .ki_size = 0xe0, 395 .ki_rssize = 0xe4, 396 .ki_tsize = 0xec, 397 .ki_dsize = 0xf0, 398 .ki_ssize = 0xf4, 399 .ki_start = 0x118, 400 .ki_nice = 0x145, 401 .ki_comm = 0x17f, 402 .ki_tdev = 0x1f0, 403 .ki_rusage = 0x220, 404 .ki_rusage_ch = 0x278, 405 406 .ru_utime = 0x0, 407 .ru_stime = 0x10, 408 .ru_maxrss = 0x20, 409 .ru_minflt = 0x30, 410 .ru_majflt = 0x34, 411 }; 412 413 const struct kinfo_proc_layout kinfo_proc_layout_i386 = 414 { 415 .ki_layout = 0x4, 416 .ki_pid = 0x28, 417 .ki_ppid = 0x2c, 418 .ki_pgid = 0x30, 419 .ki_tpgid = 0x34, 420 .ki_sid = 0x38, 421 .ki_tdev_freebsd11 = 0x44, 422 .ki_sigignore = 0x68, 423 .ki_sigcatch = 0x78, 424 .ki_uid = 0x88, 425 .ki_ruid = 0x8c, 426 .ki_svuid = 0x90, 427 .ki_rgid = 0x94, 428 .ki_svgid = 0x98, 429 .ki_ngroups = 0x9c, 430 .ki_groups = 0xa0, 431 .ki_size = 0xe0, 432 .ki_rssize = 0xe4, 433 .ki_tsize = 0xec, 434 .ki_dsize = 0xf0, 435 .ki_ssize = 0xf4, 436 .ki_start = 0x118, 437 .ki_nice = 0x135, 438 .ki_comm = 0x16f, 439 .ki_tdev = 0x1e0, 440 .ki_rusage = 0x210, 441 .ki_rusage_ch = 0x258, 442 443 .ru_utime = 0x0, 444 .ru_stime = 0x8, 445 .ru_maxrss = 0x10, 446 .ru_minflt = 0x20, 447 .ru_majflt = 0x24, 448 }; 449 450 const struct kinfo_proc_layout kinfo_proc_layout_64 = 451 { 452 .ki_layout = 0x4, 453 .ki_pid = 0x48, 454 .ki_ppid = 0x4c, 455 .ki_pgid = 0x50, 456 .ki_tpgid = 0x54, 457 .ki_sid = 0x58, 458 .ki_tdev_freebsd11 = 0x64, 459 .ki_sigignore = 0x88, 460 .ki_sigcatch = 0x98, 461 .ki_uid = 0xa8, 462 .ki_ruid = 0xac, 463 .ki_svuid = 0xb0, 464 .ki_rgid = 0xb4, 465 .ki_svgid = 0xb8, 466 .ki_ngroups = 0xbc, 467 .ki_groups = 0xc0, 468 .ki_size = 0x100, 469 .ki_rssize = 0x108, 470 .ki_tsize = 0x118, 471 .ki_dsize = 0x120, 472 .ki_ssize = 0x128, 473 .ki_start = 0x150, 474 .ki_nice = 0x185, 475 .ki_comm = 0x1bf, 476 .ki_tdev = 0x230, 477 .ki_rusage = 0x260, 478 .ki_rusage_ch = 0x2f0, 479 480 .ru_utime = 0x0, 481 .ru_stime = 0x10, 482 .ru_maxrss = 0x20, 483 .ru_minflt = 0x40, 484 .ru_majflt = 0x48, 485 }; 486 487 struct fbsd_gdbarch_data 488 { 489 struct type *siginfo_type = nullptr; 490 }; 491 492 static const registry<gdbarch>::key<fbsd_gdbarch_data> 493 fbsd_gdbarch_data_handle; 494 495 static struct fbsd_gdbarch_data * 496 get_fbsd_gdbarch_data (struct gdbarch *gdbarch) 497 { 498 struct fbsd_gdbarch_data *result = fbsd_gdbarch_data_handle.get (gdbarch); 499 if (result == nullptr) 500 result = fbsd_gdbarch_data_handle.emplace (gdbarch); 501 return result; 502 } 503 504 struct fbsd_pspace_data 505 { 506 /* Offsets in the runtime linker's 'Obj_Entry' structure. */ 507 LONGEST off_linkmap = 0; 508 LONGEST off_tlsindex = 0; 509 bool rtld_offsets_valid = false; 510 511 /* vDSO mapping range. */ 512 struct mem_range vdso_range {}; 513 514 /* Zero if the range hasn't been searched for, > 0 if a range was 515 found, or < 0 if a range was not found. */ 516 int vdso_range_p = 0; 517 }; 518 519 /* Per-program-space data for FreeBSD architectures. */ 520 static const registry<program_space>::key<fbsd_pspace_data> 521 fbsd_pspace_data_handle; 522 523 static struct fbsd_pspace_data * 524 get_fbsd_pspace_data (struct program_space *pspace) 525 { 526 struct fbsd_pspace_data *data; 527 528 data = fbsd_pspace_data_handle.get (pspace); 529 if (data == NULL) 530 data = fbsd_pspace_data_handle.emplace (pspace); 531 532 return data; 533 } 534 535 /* This is how we want PTIDs from core files to be printed. */ 536 537 static std::string 538 fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid) 539 { 540 if (ptid.lwp () != 0) 541 return string_printf ("LWP %ld", ptid.lwp ()); 542 543 return normal_pid_to_str (ptid); 544 } 545 546 /* Extract the name assigned to a thread from a core. Returns the 547 string in a static buffer. */ 548 549 static const char * 550 fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr) 551 { 552 static char buf[80]; 553 struct bfd_section *section; 554 bfd_size_type size; 555 556 if (thr->ptid.lwp () != 0) 557 { 558 /* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread 559 whose contents are defined by a "struct thrmisc" declared in 560 <sys/procfs.h> on FreeBSD. The per-thread name is stored as 561 a null-terminated string as the first member of the 562 structure. Rather than define the full structure here, just 563 extract the null-terminated name from the start of the 564 note. */ 565 thread_section_name section_name (".thrmisc", thr->ptid); 566 bfd *cbfd = current_program_space->core_bfd (); 567 568 section = bfd_get_section_by_name (cbfd, section_name.c_str ()); 569 if (section != NULL && bfd_section_size (section) > 0) 570 { 571 /* Truncate the name if it is longer than "buf". */ 572 size = bfd_section_size (section); 573 if (size > sizeof buf - 1) 574 size = sizeof buf - 1; 575 if (bfd_get_section_contents (cbfd, section, buf, (file_ptr) 0, size) 576 && buf[0] != '\0') 577 { 578 buf[size] = '\0'; 579 580 /* Note that each thread will report the process command 581 as its thread name instead of an empty name if a name 582 has not been set explicitly. Return a NULL name in 583 that case. */ 584 if (strcmp (buf, elf_tdata (cbfd)->core->program) != 0) 585 return buf; 586 } 587 } 588 } 589 590 return NULL; 591 } 592 593 /* Implement the "core_xfer_siginfo" gdbarch method. */ 594 595 static LONGEST 596 fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf, 597 ULONGEST offset, ULONGEST len) 598 { 599 size_t siginfo_size; 600 601 if (gdbarch_long_bit (gdbarch) == 32) 602 siginfo_size = SIZE32_SIGINFO_T; 603 else 604 siginfo_size = SIZE64_SIGINFO_T; 605 if (offset > siginfo_size) 606 return -1; 607 608 thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid); 609 bfd *cbfd = current_program_space->core_bfd (); 610 asection *section = bfd_get_section_by_name (cbfd, section_name.c_str ()); 611 if (section == NULL) 612 return -1; 613 614 gdb_byte buf[4]; 615 if (!bfd_get_section_contents (cbfd, section, buf, 616 LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4)) 617 return -1; 618 619 int pl_flags = extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 620 if (!(pl_flags & PL_FLAG_SI)) 621 return -1; 622 623 if (offset + len > siginfo_size) 624 len = siginfo_size - offset; 625 626 ULONGEST siginfo_offset; 627 if (gdbarch_long_bit (gdbarch) == 32) 628 siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO; 629 else 630 siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO; 631 632 if (!bfd_get_section_contents (cbfd, section, readbuf, 633 siginfo_offset + offset, len)) 634 return -1; 635 636 return len; 637 } 638 639 static int 640 find_signalled_thread (struct thread_info *info, void *data) 641 { 642 if (info->stop_signal () != GDB_SIGNAL_0 643 && info->ptid.pid () == inferior_ptid.pid ()) 644 return 1; 645 646 return 0; 647 } 648 649 /* Return a byte_vector containing the contents of a core dump note 650 for the target object of type OBJECT. If STRUCTSIZE is non-zero, 651 the data is prefixed with a 32-bit integer size to match the format 652 used in FreeBSD NT_PROCSTAT_* notes. */ 653 654 static std::optional<gdb::byte_vector> 655 fbsd_make_note_desc (enum target_object object, uint32_t structsize) 656 { 657 std::optional<gdb::byte_vector> buf = 658 target_read_alloc (current_inferior ()->top_target (), object, NULL); 659 if (!buf || buf->empty ()) 660 return {}; 661 662 if (structsize == 0) 663 return buf; 664 665 gdb::byte_vector desc (sizeof (structsize) + buf->size ()); 666 memcpy (desc.data (), &structsize, sizeof (structsize)); 667 std::copy (buf->begin (), buf->end (), desc.data () + sizeof (structsize)); 668 return desc; 669 } 670 671 /* Create appropriate note sections for a corefile, returning them in 672 allocated memory. */ 673 674 static gdb::unique_xmalloc_ptr<char> 675 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size) 676 { 677 gdb::unique_xmalloc_ptr<char> note_data; 678 Elf_Internal_Ehdr *i_ehdrp; 679 struct thread_info *curr_thr, *signalled_thr; 680 681 /* Put a "FreeBSD" label in the ELF header. */ 682 i_ehdrp = elf_elfheader (obfd); 683 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; 684 685 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch)); 686 687 if (get_exec_file (0)) 688 { 689 const char *fname = lbasename (get_exec_file (0)); 690 std::string psargs = fname; 691 692 const std::string &infargs = current_inferior ()->args (); 693 if (!infargs.empty ()) 694 psargs += ' ' + infargs; 695 696 note_data.reset (elfcore_write_prpsinfo (obfd, note_data.release (), 697 note_size, fname, 698 psargs.c_str ())); 699 } 700 701 /* Thread register information. */ 702 try 703 { 704 update_thread_list (); 705 } 706 catch (const gdb_exception_error &e) 707 { 708 exception_print (gdb_stderr, e); 709 } 710 711 /* Like the kernel, prefer dumping the signalled thread first. 712 "First thread" is what tools use to infer the signalled thread. 713 In case there's more than one signalled thread, prefer the 714 current thread, if it is signalled. */ 715 curr_thr = inferior_thread (); 716 if (curr_thr->stop_signal () != GDB_SIGNAL_0) 717 signalled_thr = curr_thr; 718 else 719 { 720 signalled_thr = iterate_over_threads (find_signalled_thread, NULL); 721 if (signalled_thr == NULL) 722 signalled_thr = curr_thr; 723 } 724 725 enum gdb_signal stop_signal = signalled_thr->stop_signal (); 726 gcore_elf_build_thread_register_notes (gdbarch, signalled_thr, stop_signal, 727 obfd, ¬e_data, note_size); 728 for (thread_info *thr : current_inferior ()->non_exited_threads ()) 729 { 730 if (thr == signalled_thr) 731 continue; 732 733 gcore_elf_build_thread_register_notes (gdbarch, thr, stop_signal, 734 obfd, ¬e_data, note_size); 735 } 736 737 /* Auxiliary vector. */ 738 uint32_t structsize = gdbarch_ptr_bit (gdbarch) / 4; /* Elf_Auxinfo */ 739 std::optional<gdb::byte_vector> note_desc = 740 fbsd_make_note_desc (TARGET_OBJECT_AUXV, structsize); 741 if (note_desc && !note_desc->empty ()) 742 { 743 note_data.reset (elfcore_write_note (obfd, note_data.release (), 744 note_size, "FreeBSD", 745 NT_FREEBSD_PROCSTAT_AUXV, 746 note_desc->data (), 747 note_desc->size ())); 748 if (!note_data) 749 return NULL; 750 } 751 752 /* Virtual memory mappings. */ 753 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP, 0); 754 if (note_desc && !note_desc->empty ()) 755 { 756 note_data.reset (elfcore_write_note (obfd, note_data.release (), 757 note_size, "FreeBSD", 758 NT_FREEBSD_PROCSTAT_VMMAP, 759 note_desc->data (), 760 note_desc->size ())); 761 if (!note_data) 762 return NULL; 763 } 764 765 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS, 0); 766 if (note_desc && !note_desc->empty ()) 767 { 768 note_data.reset (elfcore_write_note (obfd, note_data.release (), 769 note_size, "FreeBSD", 770 NT_FREEBSD_PROCSTAT_PSSTRINGS, 771 note_desc->data (), 772 note_desc->size ())); 773 if (!note_data) 774 return NULL; 775 } 776 777 /* Include the target description when possible. Some architectures 778 allow for per-thread gdbarch so we should really be emitting a tdesc 779 per-thread, however, we don't currently support reading in a 780 per-thread tdesc, so just emit the tdesc for the signalled thread. */ 781 gdbarch = target_thread_architecture (signalled_thr->ptid); 782 gcore_elf_make_tdesc_note (gdbarch, obfd, ¬e_data, note_size); 783 784 return note_data; 785 } 786 787 /* Helper function to generate the file descriptor description for a 788 single open file in 'info proc files'. */ 789 790 static const char * 791 fbsd_file_fd (int kf_fd) 792 { 793 switch (kf_fd) 794 { 795 case KINFO_FILE_FD_TYPE_CWD: 796 return "cwd"; 797 case KINFO_FILE_FD_TYPE_ROOT: 798 return "root"; 799 case KINFO_FILE_FD_TYPE_JAIL: 800 return "jail"; 801 case KINFO_FILE_FD_TYPE_TRACE: 802 return "trace"; 803 case KINFO_FILE_FD_TYPE_TEXT: 804 return "text"; 805 case KINFO_FILE_FD_TYPE_CTTY: 806 return "ctty"; 807 default: 808 return int_string (kf_fd, 10, 1, 0, 0); 809 } 810 } 811 812 /* Helper function to generate the file type for a single open file in 813 'info proc files'. */ 814 815 static const char * 816 fbsd_file_type (int kf_type, int kf_vnode_type) 817 { 818 switch (kf_type) 819 { 820 case KINFO_FILE_TYPE_VNODE: 821 switch (kf_vnode_type) 822 { 823 case KINFO_FILE_VTYPE_VREG: 824 return "file"; 825 case KINFO_FILE_VTYPE_VDIR: 826 return "dir"; 827 case KINFO_FILE_VTYPE_VCHR: 828 return "chr"; 829 case KINFO_FILE_VTYPE_VLNK: 830 return "link"; 831 case KINFO_FILE_VTYPE_VSOCK: 832 return "socket"; 833 case KINFO_FILE_VTYPE_VFIFO: 834 return "fifo"; 835 default: 836 { 837 char *str = get_print_cell (); 838 839 xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type); 840 return str; 841 } 842 } 843 case KINFO_FILE_TYPE_SOCKET: 844 return "socket"; 845 case KINFO_FILE_TYPE_PIPE: 846 return "pipe"; 847 case KINFO_FILE_TYPE_FIFO: 848 return "fifo"; 849 case KINFO_FILE_TYPE_KQUEUE: 850 return "kqueue"; 851 case KINFO_FILE_TYPE_CRYPTO: 852 return "crypto"; 853 case KINFO_FILE_TYPE_MQUEUE: 854 return "mqueue"; 855 case KINFO_FILE_TYPE_SHM: 856 return "shm"; 857 case KINFO_FILE_TYPE_SEM: 858 return "sem"; 859 case KINFO_FILE_TYPE_PTS: 860 return "pts"; 861 case KINFO_FILE_TYPE_PROCDESC: 862 return "proc"; 863 default: 864 return int_string (kf_type, 10, 1, 0, 0); 865 } 866 } 867 868 /* Helper function to generate the file flags for a single open file in 869 'info proc files'. */ 870 871 static const char * 872 fbsd_file_flags (int kf_flags) 873 { 874 static char file_flags[10]; 875 876 file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-'; 877 file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-'; 878 file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-'; 879 file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-'; 880 file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-'; 881 file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-'; 882 file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-'; 883 file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-'; 884 file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-'; 885 file_flags[9] = '\0'; 886 887 return file_flags; 888 } 889 890 /* Helper function to generate the name of an IP protocol. */ 891 892 static const char * 893 fbsd_ipproto (int protocol) 894 { 895 switch (protocol) 896 { 897 case FBSD_IPPROTO_ICMP: 898 return "icmp"; 899 case FBSD_IPPROTO_TCP: 900 return "tcp"; 901 case FBSD_IPPROTO_UDP: 902 return "udp"; 903 case FBSD_IPPROTO_SCTP: 904 return "sctp"; 905 default: 906 { 907 char *str = get_print_cell (); 908 909 xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol); 910 return str; 911 } 912 } 913 } 914 915 /* Helper function to print out an IPv4 socket address. */ 916 917 static void 918 fbsd_print_sockaddr_in (const void *sockaddr) 919 { 920 const struct fbsd_sockaddr_in *sin = 921 reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr); 922 char buf[INET_ADDRSTRLEN]; 923 924 if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr) 925 error (_("Failed to format IPv4 address")); 926 gdb_printf ("%s:%u", buf, 927 (sin->sin_port[0] << 8) | sin->sin_port[1]); 928 } 929 930 /* Helper function to print out an IPv6 socket address. */ 931 932 static void 933 fbsd_print_sockaddr_in6 (const void *sockaddr) 934 { 935 const struct fbsd_sockaddr_in6 *sin6 = 936 reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr); 937 char buf[INET6_ADDRSTRLEN]; 938 939 if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr) 940 error (_("Failed to format IPv6 address")); 941 gdb_printf ("%s.%u", buf, 942 (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]); 943 } 944 945 /* See fbsd-tdep.h. */ 946 947 void 948 fbsd_info_proc_files_header () 949 { 950 gdb_printf (_("Open files:\n\n")); 951 gdb_printf (" %6s %6s %10s %9s %s\n", 952 "FD", "Type", "Offset", "Flags ", "Name"); 953 } 954 955 /* See fbsd-tdep.h. */ 956 957 void 958 fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags, 959 LONGEST kf_offset, int kf_vnode_type, 960 int kf_sock_domain, int kf_sock_type, 961 int kf_sock_protocol, const void *kf_sa_local, 962 const void *kf_sa_peer, const void *kf_path) 963 { 964 gdb_printf (" %6s %6s %10s %8s ", 965 fbsd_file_fd (kf_fd), 966 fbsd_file_type (kf_type, kf_vnode_type), 967 kf_offset > -1 ? hex_string (kf_offset) : "-", 968 fbsd_file_flags (kf_flags)); 969 if (kf_type == KINFO_FILE_TYPE_SOCKET) 970 { 971 switch (kf_sock_domain) 972 { 973 case FBSD_AF_UNIX: 974 { 975 switch (kf_sock_type) 976 { 977 case FBSD_SOCK_STREAM: 978 gdb_printf ("unix stream:"); 979 break; 980 case FBSD_SOCK_DGRAM: 981 gdb_printf ("unix dgram:"); 982 break; 983 case FBSD_SOCK_SEQPACKET: 984 gdb_printf ("unix seqpacket:"); 985 break; 986 default: 987 gdb_printf ("unix <%d>:", kf_sock_type); 988 break; 989 } 990 991 /* For local sockets, print out the first non-nul path 992 rather than both paths. */ 993 const struct fbsd_sockaddr_un *saddr_un 994 = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local); 995 if (saddr_un->sun_path[0] == 0) 996 saddr_un = reinterpret_cast<const struct fbsd_sockaddr_un *> 997 (kf_sa_peer); 998 gdb_printf ("%s", saddr_un->sun_path); 999 break; 1000 } 1001 case FBSD_AF_INET: 1002 gdb_printf ("%s4 ", fbsd_ipproto (kf_sock_protocol)); 1003 fbsd_print_sockaddr_in (kf_sa_local); 1004 gdb_printf (" -> "); 1005 fbsd_print_sockaddr_in (kf_sa_peer); 1006 break; 1007 case FBSD_AF_INET6: 1008 gdb_printf ("%s6 ", fbsd_ipproto (kf_sock_protocol)); 1009 fbsd_print_sockaddr_in6 (kf_sa_local); 1010 gdb_printf (" -> "); 1011 fbsd_print_sockaddr_in6 (kf_sa_peer); 1012 break; 1013 } 1014 } 1015 else 1016 gdb_printf ("%s", reinterpret_cast<const char *> (kf_path)); 1017 gdb_printf ("\n"); 1018 } 1019 1020 /* Implement "info proc files" for a corefile. */ 1021 1022 static void 1023 fbsd_core_info_proc_files (struct gdbarch *gdbarch) 1024 { 1025 bfd *cbfd = current_program_space->core_bfd (); 1026 asection *section = bfd_get_section_by_name (cbfd, ".note.freebsdcore.files"); 1027 if (section == NULL) 1028 { 1029 warning (_("unable to find open files in core file")); 1030 return; 1031 } 1032 1033 size_t note_size = bfd_section_size (section); 1034 if (note_size < 4) 1035 error (_("malformed core note - too short for header")); 1036 1037 gdb::def_vector<unsigned char> contents (note_size); 1038 if (!bfd_get_section_contents (cbfd, section, contents.data (), 1039 0, note_size)) 1040 error (_("could not get core note contents")); 1041 1042 unsigned char *descdata = contents.data (); 1043 unsigned char *descend = descdata + note_size; 1044 1045 /* Skip over the structure size. */ 1046 descdata += 4; 1047 1048 fbsd_info_proc_files_header (); 1049 1050 while (descdata + KF_PATH < descend) 1051 { 1052 ULONGEST structsize = bfd_get_32 (cbfd, descdata + KF_STRUCTSIZE); 1053 if (structsize < KF_PATH) 1054 error (_("malformed core note - file structure too small")); 1055 1056 LONGEST type = bfd_get_signed_32 (cbfd, descdata + KF_TYPE); 1057 LONGEST fd = bfd_get_signed_32 (cbfd, descdata + KF_FD); 1058 LONGEST flags = bfd_get_signed_32 (cbfd, descdata + KF_FLAGS); 1059 LONGEST offset = bfd_get_signed_64 (cbfd, descdata + KF_OFFSET); 1060 LONGEST vnode_type = bfd_get_signed_32 (cbfd, descdata + KF_VNODE_TYPE); 1061 LONGEST sock_domain = bfd_get_signed_32 (cbfd, descdata + KF_SOCK_DOMAIN); 1062 LONGEST sock_type = bfd_get_signed_32 (cbfd, descdata + KF_SOCK_TYPE); 1063 LONGEST sock_protocol = bfd_get_signed_32 (cbfd, 1064 descdata + KF_SOCK_PROTOCOL); 1065 fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type, 1066 sock_domain, sock_type, sock_protocol, 1067 descdata + KF_SA_LOCAL, descdata + KF_SA_PEER, 1068 descdata + KF_PATH); 1069 1070 descdata += structsize; 1071 } 1072 } 1073 1074 /* Helper function to generate mappings flags for a single VM map 1075 entry in 'info proc mappings'. */ 1076 1077 static const char * 1078 fbsd_vm_map_entry_flags (int kve_flags, int kve_protection) 1079 { 1080 static char vm_flags[9]; 1081 1082 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-'; 1083 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-'; 1084 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-'; 1085 vm_flags[3] = ' '; 1086 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-'; 1087 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-'; 1088 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-'; 1089 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U' 1090 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-'; 1091 vm_flags[8] = '\0'; 1092 1093 return vm_flags; 1094 } 1095 1096 /* See fbsd-tdep.h. */ 1097 1098 void 1099 fbsd_info_proc_mappings_header (int addr_bit) 1100 { 1101 gdb_printf (_("Mapped address spaces:\n\n")); 1102 if (addr_bit == 64) 1103 { 1104 gdb_printf (" %18s %18s %10s %10s %9s %s\n", 1105 "Start Addr", 1106 " End Addr", 1107 " Size", " Offset", "Flags ", "File"); 1108 } 1109 else 1110 { 1111 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n", 1112 "Start Addr", 1113 " End Addr", 1114 " Size", " Offset", "Flags ", "File"); 1115 } 1116 } 1117 1118 /* See fbsd-tdep.h. */ 1119 1120 void 1121 fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start, 1122 ULONGEST kve_end, ULONGEST kve_offset, 1123 int kve_flags, int kve_protection, 1124 const void *kve_path) 1125 { 1126 if (addr_bit == 64) 1127 { 1128 gdb_printf (" %18s %18s %10s %10s %9s %s\n", 1129 hex_string (kve_start), 1130 hex_string (kve_end), 1131 hex_string (kve_end - kve_start), 1132 hex_string (kve_offset), 1133 fbsd_vm_map_entry_flags (kve_flags, kve_protection), 1134 reinterpret_cast<const char *> (kve_path)); 1135 } 1136 else 1137 { 1138 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n", 1139 hex_string (kve_start), 1140 hex_string (kve_end), 1141 hex_string (kve_end - kve_start), 1142 hex_string (kve_offset), 1143 fbsd_vm_map_entry_flags (kve_flags, kve_protection), 1144 reinterpret_cast<const char *> (kve_path)); 1145 } 1146 } 1147 1148 /* Implement "info proc mappings" for a corefile. */ 1149 1150 static void 1151 fbsd_core_info_proc_mappings (struct gdbarch *gdbarch) 1152 { 1153 asection *section; 1154 unsigned char *descdata, *descend; 1155 size_t note_size; 1156 bfd *cbfd = current_program_space->core_bfd (); 1157 1158 section = bfd_get_section_by_name (cbfd, ".note.freebsdcore.vmmap"); 1159 if (section == NULL) 1160 { 1161 warning (_("unable to find mappings in core file")); 1162 return; 1163 } 1164 1165 note_size = bfd_section_size (section); 1166 if (note_size < 4) 1167 error (_("malformed core note - too short for header")); 1168 1169 gdb::def_vector<unsigned char> contents (note_size); 1170 if (!bfd_get_section_contents (cbfd, section, contents.data (), 0, note_size)) 1171 error (_("could not get core note contents")); 1172 1173 descdata = contents.data (); 1174 descend = descdata + note_size; 1175 1176 /* Skip over the structure size. */ 1177 descdata += 4; 1178 1179 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch)); 1180 while (descdata + KVE_PATH < descend) 1181 { 1182 ULONGEST structsize = bfd_get_32 (cbfd, descdata + KVE_STRUCTSIZE); 1183 if (structsize < KVE_PATH) 1184 error (_("malformed core note - vmmap entry too small")); 1185 1186 ULONGEST start = bfd_get_64 (cbfd, descdata + KVE_START); 1187 ULONGEST end = bfd_get_64 (cbfd, descdata + KVE_END); 1188 ULONGEST offset = bfd_get_64 (cbfd, descdata + KVE_OFFSET); 1189 LONGEST flags = bfd_get_signed_32 (cbfd, descdata + KVE_FLAGS); 1190 LONGEST prot = bfd_get_signed_32 (cbfd, descdata + KVE_PROTECTION); 1191 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end, 1192 offset, flags, prot, descdata + KVE_PATH); 1193 1194 descdata += structsize; 1195 } 1196 } 1197 1198 /* Fetch the pathname of a vnode for a single file descriptor from the 1199 file table core note. */ 1200 1201 static gdb::unique_xmalloc_ptr<char> 1202 fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd) 1203 { 1204 asection *section; 1205 unsigned char *descdata, *descend; 1206 size_t note_size; 1207 bfd *cbfd = current_program_space->core_bfd (); 1208 1209 section = bfd_get_section_by_name (cbfd, ".note.freebsdcore.files"); 1210 if (section == NULL) 1211 return nullptr; 1212 1213 note_size = bfd_section_size (section); 1214 if (note_size < 4) 1215 error (_("malformed core note - too short for header")); 1216 1217 gdb::def_vector<unsigned char> contents (note_size); 1218 if (!bfd_get_section_contents (cbfd, section, contents.data (), 0, note_size)) 1219 error (_("could not get core note contents")); 1220 1221 descdata = contents.data (); 1222 descend = descdata + note_size; 1223 1224 /* Skip over the structure size. */ 1225 descdata += 4; 1226 1227 while (descdata + KF_PATH < descend) 1228 { 1229 ULONGEST structsize; 1230 1231 structsize = bfd_get_32 (cbfd, descdata + KF_STRUCTSIZE); 1232 if (structsize < KF_PATH) 1233 error (_("malformed core note - file structure too small")); 1234 1235 if (bfd_get_32 (cbfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE 1236 && bfd_get_signed_32 (cbfd, descdata + KF_FD) == fd) 1237 { 1238 char *path = (char *) descdata + KF_PATH; 1239 return make_unique_xstrdup (path); 1240 } 1241 1242 descdata += structsize; 1243 } 1244 return nullptr; 1245 } 1246 1247 /* Helper function to read a struct timeval. */ 1248 1249 static void 1250 fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data, 1251 LONGEST &sec, ULONGEST &usec) 1252 { 1253 bfd *cbfd = current_program_space->core_bfd (); 1254 1255 if (gdbarch_addr_bit (gdbarch) == 64) 1256 { 1257 sec = bfd_get_signed_64 (cbfd, data); 1258 usec = bfd_get_64 (cbfd, data + 8); 1259 } 1260 else if (bfd_get_arch (cbfd) == bfd_arch_i386) 1261 { 1262 sec = bfd_get_signed_32 (cbfd, data); 1263 usec = bfd_get_32 (cbfd, data + 4); 1264 } 1265 else 1266 { 1267 sec = bfd_get_signed_64 (cbfd, data); 1268 usec = bfd_get_32 (cbfd, data + 8); 1269 } 1270 } 1271 1272 /* Print out the contents of a signal set. */ 1273 1274 static void 1275 fbsd_print_sigset (const char *descr, unsigned char *sigset) 1276 { 1277 bfd *cbfd = current_program_space->core_bfd (); 1278 gdb_printf ("%s: ", descr); 1279 for (int i = 0; i < SIG_WORDS; i++) 1280 gdb_printf ("%08x ", 1281 (unsigned int) bfd_get_32 (cbfd, sigset + i * 4)); 1282 gdb_printf ("\n"); 1283 } 1284 1285 /* Implement "info proc status" for a corefile. */ 1286 1287 static void 1288 fbsd_core_info_proc_status (struct gdbarch *gdbarch) 1289 { 1290 const struct kinfo_proc_layout *kp; 1291 asection *section; 1292 unsigned char *descdata; 1293 int addr_bit, long_bit; 1294 size_t note_size; 1295 ULONGEST value; 1296 LONGEST sec; 1297 bfd *cbfd = current_program_space->core_bfd (); 1298 1299 section = bfd_get_section_by_name (cbfd, ".note.freebsdcore.proc"); 1300 if (section == NULL) 1301 { 1302 warning (_("unable to find process info in core file")); 1303 return; 1304 } 1305 1306 addr_bit = gdbarch_addr_bit (gdbarch); 1307 if (addr_bit == 64) 1308 kp = &kinfo_proc_layout_64; 1309 else if (bfd_get_arch (cbfd) == bfd_arch_i386) 1310 kp = &kinfo_proc_layout_i386; 1311 else 1312 kp = &kinfo_proc_layout_32; 1313 long_bit = gdbarch_long_bit (gdbarch); 1314 1315 /* 1316 * Ensure that the note is large enough for all of the fields fetched 1317 * by this function. In particular, the note must contain the 32-bit 1318 * structure size, then it must be long enough to access the last 1319 * field used (ki_rusage_ch.ru_majflt) which is the size of a long. 1320 */ 1321 note_size = bfd_section_size (section); 1322 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt 1323 + long_bit / TARGET_CHAR_BIT)) 1324 error (_("malformed core note - too short")); 1325 1326 gdb::def_vector<unsigned char> contents (note_size); 1327 if (!bfd_get_section_contents (cbfd, section, contents.data (), 0, note_size)) 1328 error (_("could not get core note contents")); 1329 1330 descdata = contents.data (); 1331 1332 /* Skip over the structure size. */ 1333 descdata += 4; 1334 1335 /* Verify 'ki_layout' is 0. */ 1336 if (bfd_get_32 (cbfd, descdata + kp->ki_layout) != 0) 1337 { 1338 warning (_("unsupported process information in core file")); 1339 return; 1340 } 1341 1342 gdb_printf ("Name: %.19s\n", descdata + kp->ki_comm); 1343 gdb_printf ("Process ID: %s\n", 1344 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_pid))); 1345 gdb_printf ("Parent process: %s\n", 1346 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_ppid))); 1347 gdb_printf ("Process group: %s\n", 1348 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_pgid))); 1349 gdb_printf ("Session id: %s\n", 1350 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_sid))); 1351 1352 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older 1353 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older 1354 kernels the 64-bit 'ki_tdev' field is in a reserved section of 1355 the structure that is cleared to zero. Assume that a zero value 1356 in ki_tdev indicates a core dump from an older kernel and use the 1357 value in 'ki_tdev_freebsd11' instead. */ 1358 value = bfd_get_64 (cbfd, descdata + kp->ki_tdev); 1359 if (value == 0) 1360 value = bfd_get_32 (cbfd, descdata + kp->ki_tdev_freebsd11); 1361 gdb_printf ("TTY: %s\n", pulongest (value)); 1362 gdb_printf ("TTY owner process group: %s\n", 1363 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_tpgid))); 1364 gdb_printf ("User IDs (real, effective, saved): %s %s %s\n", 1365 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_ruid)), 1366 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_uid)), 1367 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_svuid))); 1368 gdb_printf ("Group IDs (real, effective, saved): %s %s %s\n", 1369 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_rgid)), 1370 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_groups)), 1371 pulongest (bfd_get_32 (cbfd, descdata + kp->ki_svgid))); 1372 gdb_printf ("Groups: "); 1373 uint16_t ngroups = bfd_get_16 (cbfd, descdata + kp->ki_ngroups); 1374 for (int i = 0; i < ngroups; i++) 1375 gdb_printf ("%s ", 1376 pulongest (bfd_get_32 (cbfd, 1377 descdata + kp->ki_groups + i * 4))); 1378 gdb_printf ("\n"); 1379 value = bfd_get (long_bit, cbfd, 1380 descdata + kp->ki_rusage + kp->ru_minflt); 1381 gdb_printf ("Minor faults (no memory page): %s\n", pulongest (value)); 1382 value = bfd_get (long_bit, cbfd, 1383 descdata + kp->ki_rusage_ch + kp->ru_minflt); 1384 gdb_printf ("Minor faults, children: %s\n", pulongest (value)); 1385 value = bfd_get (long_bit, cbfd, 1386 descdata + kp->ki_rusage + kp->ru_majflt); 1387 gdb_printf ("Major faults (memory page faults): %s\n", 1388 pulongest (value)); 1389 value = bfd_get (long_bit, cbfd, 1390 descdata + kp->ki_rusage_ch + kp->ru_majflt); 1391 gdb_printf ("Major faults, children: %s\n", pulongest (value)); 1392 fbsd_core_fetch_timeval (gdbarch, 1393 descdata + kp->ki_rusage + kp->ru_utime, 1394 sec, value); 1395 gdb_printf ("utime: %s.%06d\n", plongest (sec), (int) value); 1396 fbsd_core_fetch_timeval (gdbarch, 1397 descdata + kp->ki_rusage + kp->ru_stime, 1398 sec, value); 1399 gdb_printf ("stime: %s.%06d\n", plongest (sec), (int) value); 1400 fbsd_core_fetch_timeval (gdbarch, 1401 descdata + kp->ki_rusage_ch + kp->ru_utime, 1402 sec, value); 1403 gdb_printf ("utime, children: %s.%06d\n", plongest (sec), (int) value); 1404 fbsd_core_fetch_timeval (gdbarch, 1405 descdata + kp->ki_rusage_ch + kp->ru_stime, 1406 sec, value); 1407 gdb_printf ("stime, children: %s.%06d\n", plongest (sec), (int) value); 1408 gdb_printf ("'nice' value: %d\n", 1409 (int) bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice)); 1410 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value); 1411 gdb_printf ("Start time: %s.%06d\n", plongest (sec), (int) value); 1412 gdb_printf ("Virtual memory size: %s kB\n", 1413 pulongest (bfd_get (addr_bit, cbfd, 1414 descdata + kp->ki_size) / 1024)); 1415 gdb_printf ("Data size: %s pages\n", 1416 pulongest (bfd_get (addr_bit, cbfd, 1417 descdata + kp->ki_dsize))); 1418 gdb_printf ("Stack size: %s pages\n", 1419 pulongest (bfd_get (addr_bit, cbfd, 1420 descdata + kp->ki_ssize))); 1421 gdb_printf ("Text size: %s pages\n", 1422 pulongest (bfd_get (addr_bit, cbfd, 1423 descdata + kp->ki_tsize))); 1424 gdb_printf ("Resident set size: %s pages\n", 1425 pulongest (bfd_get (addr_bit, cbfd, 1426 descdata + kp->ki_rssize))); 1427 gdb_printf ("Maximum RSS: %s pages\n", 1428 pulongest (bfd_get (long_bit, cbfd, 1429 descdata + kp->ki_rusage 1430 + kp->ru_maxrss))); 1431 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore); 1432 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch); 1433 } 1434 1435 /* Implement the "core_info_proc" gdbarch method. */ 1436 1437 static void 1438 fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args, 1439 enum info_proc_what what) 1440 { 1441 bool do_cmdline = false; 1442 bool do_cwd = false; 1443 bool do_exe = false; 1444 bool do_files = false; 1445 bool do_mappings = false; 1446 bool do_status = false; 1447 int pid; 1448 1449 switch (what) 1450 { 1451 case IP_MINIMAL: 1452 do_cmdline = true; 1453 do_cwd = true; 1454 do_exe = true; 1455 break; 1456 case IP_MAPPINGS: 1457 do_mappings = true; 1458 break; 1459 case IP_STATUS: 1460 case IP_STAT: 1461 do_status = true; 1462 break; 1463 case IP_CMDLINE: 1464 do_cmdline = true; 1465 break; 1466 case IP_EXE: 1467 do_exe = true; 1468 break; 1469 case IP_CWD: 1470 do_cwd = true; 1471 break; 1472 case IP_FILES: 1473 do_files = true; 1474 break; 1475 case IP_ALL: 1476 do_cmdline = true; 1477 do_cwd = true; 1478 do_exe = true; 1479 do_files = true; 1480 do_mappings = true; 1481 do_status = true; 1482 break; 1483 default: 1484 return; 1485 } 1486 1487 bfd *cbfd = current_program_space->core_bfd (); 1488 pid = bfd_core_file_pid (cbfd); 1489 if (pid != 0) 1490 gdb_printf (_("process %d\n"), pid); 1491 1492 if (do_cmdline) 1493 { 1494 const char *cmdline; 1495 1496 cmdline = bfd_core_file_failing_command (cbfd); 1497 if (cmdline) 1498 gdb_printf ("cmdline = '%s'\n", cmdline); 1499 else 1500 warning (_("Command line unavailable")); 1501 } 1502 if (do_cwd) 1503 { 1504 gdb::unique_xmalloc_ptr<char> cwd = 1505 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD); 1506 if (cwd) 1507 gdb_printf ("cwd = '%s'\n", cwd.get ()); 1508 else 1509 warning (_("unable to read current working directory")); 1510 } 1511 if (do_exe) 1512 { 1513 gdb::unique_xmalloc_ptr<char> exe = 1514 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT); 1515 if (exe) 1516 gdb_printf ("exe = '%s'\n", exe.get ()); 1517 else 1518 warning (_("unable to read executable path name")); 1519 } 1520 if (do_files) 1521 fbsd_core_info_proc_files (gdbarch); 1522 if (do_mappings) 1523 fbsd_core_info_proc_mappings (gdbarch); 1524 if (do_status) 1525 fbsd_core_info_proc_status (gdbarch); 1526 } 1527 1528 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */ 1529 1530 static void 1531 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, 1532 CORE_ADDR type, CORE_ADDR val) 1533 { 1534 const char *name = "???"; 1535 const char *description = ""; 1536 enum auxv_format format = AUXV_FORMAT_HEX; 1537 1538 switch (type) 1539 { 1540 case AT_NULL: 1541 case AT_IGNORE: 1542 case AT_EXECFD: 1543 case AT_PHDR: 1544 case AT_PHENT: 1545 case AT_PHNUM: 1546 case AT_PAGESZ: 1547 case AT_BASE: 1548 case AT_FLAGS: 1549 case AT_ENTRY: 1550 case AT_NOTELF: 1551 case AT_UID: 1552 case AT_EUID: 1553 case AT_GID: 1554 case AT_EGID: 1555 default_print_auxv_entry (gdbarch, file, type, val); 1556 return; 1557 #define _TAGNAME(tag) #tag 1558 #define TAGNAME(tag) _TAGNAME(AT_##tag) 1559 #define TAG(tag, text, kind) \ 1560 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break 1561 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR); 1562 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX); 1563 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC); 1564 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC); 1565 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC); 1566 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX); 1567 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC); 1568 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX); 1569 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX); 1570 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX); 1571 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX); 1572 TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX); 1573 TAG (BSDFLAGS, _("ELF BSD flags"), AUXV_FORMAT_HEX); 1574 TAG (ARGC, _("Argument count"), AUXV_FORMAT_DEC); 1575 TAG (ARGV, _("Argument vector"), AUXV_FORMAT_HEX); 1576 TAG (ENVC, _("Environment count"), AUXV_FORMAT_DEC); 1577 TAG (ENVV, _("Environment vector"), AUXV_FORMAT_HEX); 1578 TAG (PS_STRINGS, _("Pointer to ps_strings"), AUXV_FORMAT_HEX); 1579 TAG (FXRNG, _("Pointer to root RNG seed version"), AUXV_FORMAT_HEX); 1580 TAG (KPRELOAD, _("Base address of vDSO"), AUXV_FORMAT_HEX); 1581 TAG (USRSTACKBASE, _("Top of user stack"), AUXV_FORMAT_HEX); 1582 TAG (USRSTACKLIM, _("Grow limit of user stack"), AUXV_FORMAT_HEX); 1583 } 1584 1585 fprint_auxv_entry (file, name, description, format, type, val); 1586 } 1587 1588 /* Implement the "get_siginfo_type" gdbarch method. */ 1589 1590 static struct type * 1591 fbsd_get_siginfo_type (struct gdbarch *gdbarch) 1592 { 1593 struct fbsd_gdbarch_data *fbsd_gdbarch_data; 1594 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type; 1595 struct type *uid_type, *pid_type; 1596 struct type *sigval_type, *reason_type; 1597 struct type *siginfo_type; 1598 struct type *type; 1599 1600 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch); 1601 if (fbsd_gdbarch_data->siginfo_type != NULL) 1602 return fbsd_gdbarch_data->siginfo_type; 1603 1604 type_allocator alloc (gdbarch); 1605 int_type = init_integer_type (alloc, gdbarch_int_bit (gdbarch), 1606 0, "int"); 1607 int32_type = init_integer_type (alloc, 32, 0, "int32_t"); 1608 uint32_type = init_integer_type (alloc, 32, 1, "uint32_t"); 1609 long_type = init_integer_type (alloc, gdbarch_long_bit (gdbarch), 1610 0, "long"); 1611 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void); 1612 1613 /* union sigval */ 1614 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); 1615 sigval_type->set_name (xstrdup ("sigval")); 1616 append_composite_type_field (sigval_type, "sival_int", int_type); 1617 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type); 1618 1619 /* __pid_t */ 1620 pid_type = alloc.new_type (TYPE_CODE_TYPEDEF, 1621 int32_type->length () * TARGET_CHAR_BIT, 1622 "__pid_t"); 1623 pid_type->set_target_type (int32_type); 1624 pid_type->set_target_is_stub (true); 1625 1626 /* __uid_t */ 1627 uid_type = alloc.new_type (TYPE_CODE_TYPEDEF, 1628 uint32_type->length () * TARGET_CHAR_BIT, 1629 "__uid_t"); 1630 uid_type->set_target_type (uint32_type); 1631 pid_type->set_target_is_stub (true); 1632 1633 /* _reason */ 1634 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); 1635 1636 /* _fault */ 1637 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1638 append_composite_type_field (type, "si_trapno", int_type); 1639 append_composite_type_field (reason_type, "_fault", type); 1640 1641 /* _timer */ 1642 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1643 append_composite_type_field (type, "si_timerid", int_type); 1644 append_composite_type_field (type, "si_overrun", int_type); 1645 append_composite_type_field (reason_type, "_timer", type); 1646 1647 /* _mesgq */ 1648 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1649 append_composite_type_field (type, "si_mqd", int_type); 1650 append_composite_type_field (reason_type, "_mesgq", type); 1651 1652 /* _poll */ 1653 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1654 append_composite_type_field (type, "si_band", long_type); 1655 append_composite_type_field (reason_type, "_poll", type); 1656 1657 /* __spare__ */ 1658 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1659 append_composite_type_field (type, "__spare1__", long_type); 1660 append_composite_type_field (type, "__spare2__", 1661 init_vector_type (int_type, 7)); 1662 append_composite_type_field (reason_type, "__spare__", type); 1663 1664 /* struct siginfo */ 1665 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1666 siginfo_type->set_name (xstrdup ("siginfo")); 1667 append_composite_type_field (siginfo_type, "si_signo", int_type); 1668 append_composite_type_field (siginfo_type, "si_errno", int_type); 1669 append_composite_type_field (siginfo_type, "si_code", int_type); 1670 append_composite_type_field (siginfo_type, "si_pid", pid_type); 1671 append_composite_type_field (siginfo_type, "si_uid", uid_type); 1672 append_composite_type_field (siginfo_type, "si_status", int_type); 1673 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type); 1674 append_composite_type_field (siginfo_type, "si_value", sigval_type); 1675 append_composite_type_field (siginfo_type, "_reason", reason_type); 1676 1677 fbsd_gdbarch_data->siginfo_type = siginfo_type; 1678 1679 return siginfo_type; 1680 } 1681 1682 /* Implement the "gdb_signal_from_target" gdbarch method. */ 1683 1684 static enum gdb_signal 1685 fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal) 1686 { 1687 switch (signal) 1688 { 1689 case 0: 1690 return GDB_SIGNAL_0; 1691 1692 case FREEBSD_SIGHUP: 1693 return GDB_SIGNAL_HUP; 1694 1695 case FREEBSD_SIGINT: 1696 return GDB_SIGNAL_INT; 1697 1698 case FREEBSD_SIGQUIT: 1699 return GDB_SIGNAL_QUIT; 1700 1701 case FREEBSD_SIGILL: 1702 return GDB_SIGNAL_ILL; 1703 1704 case FREEBSD_SIGTRAP: 1705 return GDB_SIGNAL_TRAP; 1706 1707 case FREEBSD_SIGABRT: 1708 return GDB_SIGNAL_ABRT; 1709 1710 case FREEBSD_SIGEMT: 1711 return GDB_SIGNAL_EMT; 1712 1713 case FREEBSD_SIGFPE: 1714 return GDB_SIGNAL_FPE; 1715 1716 case FREEBSD_SIGKILL: 1717 return GDB_SIGNAL_KILL; 1718 1719 case FREEBSD_SIGBUS: 1720 return GDB_SIGNAL_BUS; 1721 1722 case FREEBSD_SIGSEGV: 1723 return GDB_SIGNAL_SEGV; 1724 1725 case FREEBSD_SIGSYS: 1726 return GDB_SIGNAL_SYS; 1727 1728 case FREEBSD_SIGPIPE: 1729 return GDB_SIGNAL_PIPE; 1730 1731 case FREEBSD_SIGALRM: 1732 return GDB_SIGNAL_ALRM; 1733 1734 case FREEBSD_SIGTERM: 1735 return GDB_SIGNAL_TERM; 1736 1737 case FREEBSD_SIGURG: 1738 return GDB_SIGNAL_URG; 1739 1740 case FREEBSD_SIGSTOP: 1741 return GDB_SIGNAL_STOP; 1742 1743 case FREEBSD_SIGTSTP: 1744 return GDB_SIGNAL_TSTP; 1745 1746 case FREEBSD_SIGCONT: 1747 return GDB_SIGNAL_CONT; 1748 1749 case FREEBSD_SIGCHLD: 1750 return GDB_SIGNAL_CHLD; 1751 1752 case FREEBSD_SIGTTIN: 1753 return GDB_SIGNAL_TTIN; 1754 1755 case FREEBSD_SIGTTOU: 1756 return GDB_SIGNAL_TTOU; 1757 1758 case FREEBSD_SIGIO: 1759 return GDB_SIGNAL_IO; 1760 1761 case FREEBSD_SIGXCPU: 1762 return GDB_SIGNAL_XCPU; 1763 1764 case FREEBSD_SIGXFSZ: 1765 return GDB_SIGNAL_XFSZ; 1766 1767 case FREEBSD_SIGVTALRM: 1768 return GDB_SIGNAL_VTALRM; 1769 1770 case FREEBSD_SIGPROF: 1771 return GDB_SIGNAL_PROF; 1772 1773 case FREEBSD_SIGWINCH: 1774 return GDB_SIGNAL_WINCH; 1775 1776 case FREEBSD_SIGINFO: 1777 return GDB_SIGNAL_INFO; 1778 1779 case FREEBSD_SIGUSR1: 1780 return GDB_SIGNAL_USR1; 1781 1782 case FREEBSD_SIGUSR2: 1783 return GDB_SIGNAL_USR2; 1784 1785 /* SIGTHR is the same as SIGLWP on FreeBSD. */ 1786 case FREEBSD_SIGTHR: 1787 return GDB_SIGNAL_LWP; 1788 1789 case FREEBSD_SIGLIBRT: 1790 return GDB_SIGNAL_LIBRT; 1791 } 1792 1793 if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX) 1794 { 1795 int offset = signal - FREEBSD_SIGRTMIN; 1796 1797 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset); 1798 } 1799 1800 return GDB_SIGNAL_UNKNOWN; 1801 } 1802 1803 /* Implement the "gdb_signal_to_target" gdbarch method. */ 1804 1805 static int 1806 fbsd_gdb_signal_to_target (struct gdbarch *gdbarch, 1807 enum gdb_signal signal) 1808 { 1809 switch (signal) 1810 { 1811 case GDB_SIGNAL_0: 1812 return 0; 1813 1814 case GDB_SIGNAL_HUP: 1815 return FREEBSD_SIGHUP; 1816 1817 case GDB_SIGNAL_INT: 1818 return FREEBSD_SIGINT; 1819 1820 case GDB_SIGNAL_QUIT: 1821 return FREEBSD_SIGQUIT; 1822 1823 case GDB_SIGNAL_ILL: 1824 return FREEBSD_SIGILL; 1825 1826 case GDB_SIGNAL_TRAP: 1827 return FREEBSD_SIGTRAP; 1828 1829 case GDB_SIGNAL_ABRT: 1830 return FREEBSD_SIGABRT; 1831 1832 case GDB_SIGNAL_EMT: 1833 return FREEBSD_SIGEMT; 1834 1835 case GDB_SIGNAL_FPE: 1836 return FREEBSD_SIGFPE; 1837 1838 case GDB_SIGNAL_KILL: 1839 return FREEBSD_SIGKILL; 1840 1841 case GDB_SIGNAL_BUS: 1842 return FREEBSD_SIGBUS; 1843 1844 case GDB_SIGNAL_SEGV: 1845 return FREEBSD_SIGSEGV; 1846 1847 case GDB_SIGNAL_SYS: 1848 return FREEBSD_SIGSYS; 1849 1850 case GDB_SIGNAL_PIPE: 1851 return FREEBSD_SIGPIPE; 1852 1853 case GDB_SIGNAL_ALRM: 1854 return FREEBSD_SIGALRM; 1855 1856 case GDB_SIGNAL_TERM: 1857 return FREEBSD_SIGTERM; 1858 1859 case GDB_SIGNAL_URG: 1860 return FREEBSD_SIGURG; 1861 1862 case GDB_SIGNAL_STOP: 1863 return FREEBSD_SIGSTOP; 1864 1865 case GDB_SIGNAL_TSTP: 1866 return FREEBSD_SIGTSTP; 1867 1868 case GDB_SIGNAL_CONT: 1869 return FREEBSD_SIGCONT; 1870 1871 case GDB_SIGNAL_CHLD: 1872 return FREEBSD_SIGCHLD; 1873 1874 case GDB_SIGNAL_TTIN: 1875 return FREEBSD_SIGTTIN; 1876 1877 case GDB_SIGNAL_TTOU: 1878 return FREEBSD_SIGTTOU; 1879 1880 case GDB_SIGNAL_IO: 1881 return FREEBSD_SIGIO; 1882 1883 case GDB_SIGNAL_XCPU: 1884 return FREEBSD_SIGXCPU; 1885 1886 case GDB_SIGNAL_XFSZ: 1887 return FREEBSD_SIGXFSZ; 1888 1889 case GDB_SIGNAL_VTALRM: 1890 return FREEBSD_SIGVTALRM; 1891 1892 case GDB_SIGNAL_PROF: 1893 return FREEBSD_SIGPROF; 1894 1895 case GDB_SIGNAL_WINCH: 1896 return FREEBSD_SIGWINCH; 1897 1898 case GDB_SIGNAL_INFO: 1899 return FREEBSD_SIGINFO; 1900 1901 case GDB_SIGNAL_USR1: 1902 return FREEBSD_SIGUSR1; 1903 1904 case GDB_SIGNAL_USR2: 1905 return FREEBSD_SIGUSR2; 1906 1907 case GDB_SIGNAL_LWP: 1908 return FREEBSD_SIGTHR; 1909 1910 case GDB_SIGNAL_LIBRT: 1911 return FREEBSD_SIGLIBRT; 1912 } 1913 1914 if (signal >= GDB_SIGNAL_REALTIME_65 1915 && signal <= GDB_SIGNAL_REALTIME_126) 1916 { 1917 int offset = signal - GDB_SIGNAL_REALTIME_65; 1918 1919 return FREEBSD_SIGRTMIN + offset; 1920 } 1921 1922 return -1; 1923 } 1924 1925 /* Implement the "get_syscall_number" gdbarch method. */ 1926 1927 static LONGEST 1928 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread) 1929 { 1930 1931 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD 1932 native targets fetch the system call number from the 1933 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait. 1934 However, system call catching requires this function to be 1935 set. */ 1936 1937 internal_error (_("fbsd_get_sycall_number called")); 1938 } 1939 1940 /* Read an integer symbol value from the current target. */ 1941 1942 static LONGEST 1943 fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name) 1944 { 1945 bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL); 1946 if (ms.minsym == NULL) 1947 error (_("Unable to resolve symbol '%s'"), name); 1948 1949 gdb_byte buf[4]; 1950 if (target_read_memory (ms.value_address (), buf, sizeof buf) != 0) 1951 error (_("Unable to read value of '%s'"), name); 1952 1953 return extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 1954 } 1955 1956 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry' 1957 structure needed to determine the TLS index of an object file. */ 1958 1959 static void 1960 fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data) 1961 { 1962 try 1963 { 1964 /* Fetch offsets from debug symbols in rtld. */ 1965 struct symbol *obj_entry_sym 1966 = lookup_symbol_in_language ("Struct_Obj_Entry", nullptr, 1967 SEARCH_STRUCT_DOMAIN, 1968 language_c, nullptr).symbol; 1969 if (obj_entry_sym == NULL) 1970 error (_("Unable to find Struct_Obj_Entry symbol")); 1971 data->off_linkmap = lookup_struct_elt (obj_entry_sym->type (), 1972 "linkmap", 0).offset / 8; 1973 data->off_tlsindex = lookup_struct_elt (obj_entry_sym->type (), 1974 "tlsindex", 0).offset / 8; 1975 data->rtld_offsets_valid = true; 1976 return; 1977 } 1978 catch (const gdb_exception_error &e) 1979 { 1980 data->off_linkmap = -1; 1981 } 1982 1983 try 1984 { 1985 /* Fetch offsets from global variables in libthr. Note that 1986 this does not work for single-threaded processes that are not 1987 linked against libthr. */ 1988 data->off_linkmap = fbsd_read_integer_by_name (gdbarch, 1989 "_thread_off_linkmap"); 1990 data->off_tlsindex = fbsd_read_integer_by_name (gdbarch, 1991 "_thread_off_tlsindex"); 1992 data->rtld_offsets_valid = true; 1993 return; 1994 } 1995 catch (const gdb_exception_error &e) 1996 { 1997 data->off_linkmap = -1; 1998 } 1999 } 2000 2001 /* Helper function to read the TLS index of an object file associated 2002 with a link map entry at LM_ADDR. */ 2003 2004 static LONGEST 2005 fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr) 2006 { 2007 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space); 2008 2009 if (!data->rtld_offsets_valid) 2010 fbsd_fetch_rtld_offsets (gdbarch, data); 2011 2012 if (data->off_linkmap == -1) 2013 throw_error (TLS_GENERIC_ERROR, 2014 _("Cannot fetch runtime linker structure offsets")); 2015 2016 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry 2017 pointer and then compute the offset of the tlsindex member. */ 2018 CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex; 2019 2020 gdb_byte buf[4]; 2021 if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0) 2022 throw_error (TLS_GENERIC_ERROR, 2023 _("Cannot find thread-local variables on this target")); 2024 2025 return extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 2026 } 2027 2028 /* See fbsd-tdep.h. */ 2029 2030 CORE_ADDR 2031 fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr, 2032 CORE_ADDR lm_addr, CORE_ADDR offset) 2033 { 2034 LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr); 2035 2036 gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT]; 2037 if (target_read_memory (dtv_addr, buf, sizeof buf) != 0) 2038 throw_error (TLS_GENERIC_ERROR, 2039 _("Cannot find thread-local variables on this target")); 2040 2041 const struct builtin_type *builtin = builtin_type (gdbarch); 2042 CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch, 2043 builtin->builtin_data_ptr, buf); 2044 2045 addr += (tls_index + 1) * builtin->builtin_data_ptr->length (); 2046 if (target_read_memory (addr, buf, sizeof buf) != 0) 2047 throw_error (TLS_GENERIC_ERROR, 2048 _("Cannot find thread-local variables on this target")); 2049 2050 addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf); 2051 return addr + offset; 2052 } 2053 2054 /* See fbsd-tdep.h. */ 2055 2056 CORE_ADDR 2057 fbsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 2058 { 2059 struct bound_minimal_symbol msym = lookup_bound_minimal_symbol ("_rtld_bind"); 2060 if (msym.minsym != nullptr && msym.value_address () == pc) 2061 return frame_unwind_caller_pc (get_current_frame ()); 2062 2063 return 0; 2064 } 2065 2066 /* Return description of signal code or nullptr. */ 2067 2068 static const char * 2069 fbsd_signal_cause (enum gdb_signal siggnal, int code) 2070 { 2071 /* Signal-independent causes. */ 2072 switch (code) 2073 { 2074 case FBSD_SI_USER: 2075 return _("Sent by kill()"); 2076 case FBSD_SI_QUEUE: 2077 return _("Sent by sigqueue()"); 2078 case FBSD_SI_TIMER: 2079 return _("Timer expired"); 2080 case FBSD_SI_ASYNCIO: 2081 return _("Asynchronous I/O request completed"); 2082 case FBSD_SI_MESGQ: 2083 return _("Message arrived on empty message queue"); 2084 case FBSD_SI_KERNEL: 2085 return _("Sent by kernel"); 2086 case FBSD_SI_LWP: 2087 return _("Sent by thr_kill()"); 2088 } 2089 2090 switch (siggnal) 2091 { 2092 case GDB_SIGNAL_ILL: 2093 switch (code) 2094 { 2095 case FBSD_ILL_ILLOPC: 2096 return _("Illegal opcode"); 2097 case FBSD_ILL_ILLOPN: 2098 return _("Illegal operand"); 2099 case FBSD_ILL_ILLADR: 2100 return _("Illegal addressing mode"); 2101 case FBSD_ILL_ILLTRP: 2102 return _("Illegal trap"); 2103 case FBSD_ILL_PRVOPC: 2104 return _("Privileged opcode"); 2105 case FBSD_ILL_PRVREG: 2106 return _("Privileged register"); 2107 case FBSD_ILL_COPROC: 2108 return _("Coprocessor error"); 2109 case FBSD_ILL_BADSTK: 2110 return _("Internal stack error"); 2111 } 2112 break; 2113 case GDB_SIGNAL_BUS: 2114 switch (code) 2115 { 2116 case FBSD_BUS_ADRALN: 2117 return _("Invalid address alignment"); 2118 case FBSD_BUS_ADRERR: 2119 return _("Address not present"); 2120 case FBSD_BUS_OBJERR: 2121 return _("Object-specific hardware error"); 2122 case FBSD_BUS_OOMERR: 2123 return _("Out of memory"); 2124 } 2125 break; 2126 case GDB_SIGNAL_SEGV: 2127 switch (code) 2128 { 2129 case FBSD_SEGV_MAPERR: 2130 return _("Address not mapped to object"); 2131 case FBSD_SEGV_ACCERR: 2132 return _("Invalid permissions for mapped object"); 2133 case FBSD_SEGV_PKUERR: 2134 return _("PKU violation"); 2135 } 2136 break; 2137 case GDB_SIGNAL_FPE: 2138 switch (code) 2139 { 2140 case FBSD_FPE_INTOVF: 2141 return _("Integer overflow"); 2142 case FBSD_FPE_INTDIV: 2143 return _("Integer divide by zero"); 2144 case FBSD_FPE_FLTDIV: 2145 return _("Floating point divide by zero"); 2146 case FBSD_FPE_FLTOVF: 2147 return _("Floating point overflow"); 2148 case FBSD_FPE_FLTUND: 2149 return _("Floating point underflow"); 2150 case FBSD_FPE_FLTRES: 2151 return _("Floating point inexact result"); 2152 case FBSD_FPE_FLTINV: 2153 return _("Invalid floating point operation"); 2154 case FBSD_FPE_FLTSUB: 2155 return _("Subscript out of range"); 2156 } 2157 break; 2158 case GDB_SIGNAL_TRAP: 2159 switch (code) 2160 { 2161 case FBSD_TRAP_BRKPT: 2162 return _("Breakpoint"); 2163 case FBSD_TRAP_TRACE: 2164 return _("Trace trap"); 2165 case FBSD_TRAP_DTRACE: 2166 return _("DTrace-induced trap"); 2167 case FBSD_TRAP_CAP: 2168 return _("Capability violation"); 2169 } 2170 break; 2171 case GDB_SIGNAL_CHLD: 2172 switch (code) 2173 { 2174 case FBSD_CLD_EXITED: 2175 return _("Child has exited"); 2176 case FBSD_CLD_KILLED: 2177 return _("Child has terminated abnormally"); 2178 case FBSD_CLD_DUMPED: 2179 return _("Child has dumped core"); 2180 case FBSD_CLD_TRAPPED: 2181 return _("Traced child has trapped"); 2182 case FBSD_CLD_STOPPED: 2183 return _("Child has stopped"); 2184 case FBSD_CLD_CONTINUED: 2185 return _("Stopped child has continued"); 2186 } 2187 break; 2188 case GDB_SIGNAL_POLL: 2189 switch (code) 2190 { 2191 case FBSD_POLL_IN: 2192 return _("Data input available"); 2193 case FBSD_POLL_OUT: 2194 return _("Output buffers available"); 2195 case FBSD_POLL_MSG: 2196 return _("Input message available"); 2197 case FBSD_POLL_ERR: 2198 return _("I/O error"); 2199 case FBSD_POLL_PRI: 2200 return _("High priority input available"); 2201 case FBSD_POLL_HUP: 2202 return _("Device disconnected"); 2203 } 2204 break; 2205 } 2206 2207 return nullptr; 2208 } 2209 2210 /* Report additional details for a signal stop. */ 2211 2212 static void 2213 fbsd_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout, 2214 enum gdb_signal siggnal) 2215 { 2216 LONGEST code, mqd, pid, status, timerid, uid; 2217 2218 try 2219 { 2220 code = parse_and_eval_long ("$_siginfo.si_code"); 2221 pid = parse_and_eval_long ("$_siginfo.si_pid"); 2222 uid = parse_and_eval_long ("$_siginfo.si_uid"); 2223 status = parse_and_eval_long ("$_siginfo.si_status"); 2224 timerid = parse_and_eval_long ("$_siginfo._reason._timer.si_timerid"); 2225 mqd = parse_and_eval_long ("$_siginfo._reason._mesgq.si_mqd"); 2226 } 2227 catch (const gdb_exception_error &e) 2228 { 2229 return; 2230 } 2231 2232 const char *meaning = fbsd_signal_cause (siggnal, code); 2233 if (meaning == nullptr) 2234 return; 2235 2236 uiout->text (".\n"); 2237 uiout->field_string ("sigcode-meaning", meaning); 2238 2239 switch (code) 2240 { 2241 case FBSD_SI_USER: 2242 case FBSD_SI_QUEUE: 2243 case FBSD_SI_LWP: 2244 uiout->text (" from pid "); 2245 uiout->field_string ("sending-pid", plongest (pid)); 2246 uiout->text (" and user "); 2247 uiout->field_string ("sending-uid", plongest (uid)); 2248 return; 2249 case FBSD_SI_TIMER: 2250 uiout->text (": timerid "); 2251 uiout->field_string ("timerid", plongest (timerid)); 2252 return; 2253 case FBSD_SI_MESGQ: 2254 uiout->text (": message queue "); 2255 uiout->field_string ("message-queue", plongest (mqd)); 2256 return; 2257 case FBSD_SI_ASYNCIO: 2258 return; 2259 } 2260 2261 if (siggnal == GDB_SIGNAL_CHLD) 2262 { 2263 uiout->text (": pid "); 2264 uiout->field_string ("child-pid", plongest (pid)); 2265 uiout->text (", uid "); 2266 uiout->field_string ("child-uid", plongest (uid)); 2267 if (code == FBSD_CLD_EXITED) 2268 { 2269 uiout->text (", exit status "); 2270 uiout->field_string ("exit-status", plongest (status)); 2271 } 2272 else 2273 { 2274 uiout->text (", signal "); 2275 uiout->field_string ("signal", plongest (status)); 2276 } 2277 } 2278 } 2279 2280 /* Search a list of struct kinfo_vmmap entries in the ENTRIES buffer 2281 of LEN bytes to find the length of the entry starting at ADDR. 2282 Returns the length of the entry or zero if no entry was found. */ 2283 2284 static ULONGEST 2285 fbsd_vmmap_length (struct gdbarch *gdbarch, unsigned char *entries, size_t len, 2286 CORE_ADDR addr) 2287 { 2288 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2289 unsigned char *descdata = entries; 2290 unsigned char *descend = descdata + len; 2291 2292 /* Skip over the structure size. */ 2293 descdata += 4; 2294 2295 while (descdata + KVE_PATH < descend) 2296 { 2297 ULONGEST structsize = extract_unsigned_integer (descdata 2298 + KVE_STRUCTSIZE, 4, 2299 byte_order); 2300 if (structsize < KVE_PATH) 2301 return false; 2302 2303 ULONGEST start = extract_unsigned_integer (descdata + KVE_START, 8, 2304 byte_order); 2305 ULONGEST end = extract_unsigned_integer (descdata + KVE_END, 8, 2306 byte_order); 2307 if (start == addr) 2308 return end - start; 2309 2310 descdata += structsize; 2311 } 2312 return 0; 2313 } 2314 2315 /* Helper for fbsd_vsyscall_range that does the real work of finding 2316 the vDSO's address range. */ 2317 2318 static bool 2319 fbsd_vdso_range (struct gdbarch *gdbarch, struct mem_range *range) 2320 { 2321 if (target_auxv_search (AT_FREEBSD_KPRELOAD, &range->start) <= 0) 2322 return false; 2323 2324 if (!target_has_execution ()) 2325 { 2326 /* Search for the ending address in the NT_PROCSTAT_VMMAP note. */ 2327 bfd *cbfd = current_program_space->core_bfd (); 2328 asection *section = bfd_get_section_by_name (cbfd, 2329 ".note.freebsdcore.vmmap"); 2330 if (section == nullptr) 2331 return false; 2332 2333 size_t note_size = bfd_section_size (section); 2334 if (note_size < 4) 2335 return false; 2336 2337 gdb::def_vector<unsigned char> contents (note_size); 2338 if (!bfd_get_section_contents (cbfd, section, contents.data (), 2339 0, note_size)) 2340 return false; 2341 2342 range->length = fbsd_vmmap_length (gdbarch, contents.data (), note_size, 2343 range->start); 2344 } 2345 else 2346 { 2347 /* Fetch the list of address space entries from the running target. */ 2348 std::optional<gdb::byte_vector> buf = 2349 target_read_alloc (current_inferior ()->top_target (), 2350 TARGET_OBJECT_FREEBSD_VMMAP, nullptr); 2351 if (!buf || buf->empty ()) 2352 return false; 2353 2354 range->length = fbsd_vmmap_length (gdbarch, buf->data (), buf->size (), 2355 range->start); 2356 } 2357 return range->length != 0; 2358 } 2359 2360 /* Return the address range of the vDSO for the current inferior. */ 2361 2362 static int 2363 fbsd_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range) 2364 { 2365 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space); 2366 2367 if (data->vdso_range_p == 0) 2368 { 2369 if (fbsd_vdso_range (gdbarch, &data->vdso_range)) 2370 data->vdso_range_p = 1; 2371 else 2372 data->vdso_range_p = -1; 2373 } 2374 2375 if (data->vdso_range_p < 0) 2376 return 0; 2377 2378 *range = data->vdso_range; 2379 return 1; 2380 } 2381 2382 /* To be called from GDB_OSABI_FREEBSD handlers. */ 2383 2384 void 2385 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 2386 { 2387 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str); 2388 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name); 2389 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo); 2390 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes); 2391 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc); 2392 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry); 2393 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type); 2394 set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target); 2395 set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target); 2396 set_gdbarch_report_signal_info (gdbarch, fbsd_report_signal_info); 2397 set_gdbarch_skip_solib_resolver (gdbarch, fbsd_skip_solib_resolver); 2398 set_gdbarch_vsyscall_range (gdbarch, fbsd_vsyscall_range); 2399 2400 /* `catch syscall' */ 2401 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml"); 2402 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number); 2403 } 2404
Indexes created Sun Apr 12 00:22:20 UTC 2026