fbsd-tdep.c revision 1.8
1 /* Target-dependent code for FreeBSD, architecture-independent. 2 3 Copyright (C) 2002-2023 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 "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 567 section = bfd_get_section_by_name (core_bfd, section_name.c_str ()); 568 if (section != NULL && bfd_section_size (section) > 0) 569 { 570 /* Truncate the name if it is longer than "buf". */ 571 size = bfd_section_size (section); 572 if (size > sizeof buf - 1) 573 size = sizeof buf - 1; 574 if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0, 575 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 (core_bfd)->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 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ()); 610 if (section == NULL) 611 return -1; 612 613 gdb_byte buf[4]; 614 if (!bfd_get_section_contents (core_bfd, section, buf, 615 LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4)) 616 return -1; 617 618 int pl_flags = extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 619 if (!(pl_flags & PL_FLAG_SI)) 620 return -1; 621 622 if (offset + len > siginfo_size) 623 len = siginfo_size - offset; 624 625 ULONGEST siginfo_offset; 626 if (gdbarch_long_bit (gdbarch) == 32) 627 siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO; 628 else 629 siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO; 630 631 if (!bfd_get_section_contents (core_bfd, section, readbuf, 632 siginfo_offset + offset, len)) 633 return -1; 634 635 return len; 636 } 637 638 static int 639 find_signalled_thread (struct thread_info *info, void *data) 640 { 641 if (info->stop_signal () != GDB_SIGNAL_0 642 && info->ptid.pid () == inferior_ptid.pid ()) 643 return 1; 644 645 return 0; 646 } 647 648 /* Return a byte_vector containing the contents of a core dump note 649 for the target object of type OBJECT. If STRUCTSIZE is non-zero, 650 the data is prefixed with a 32-bit integer size to match the format 651 used in FreeBSD NT_PROCSTAT_* notes. */ 652 653 static gdb::optional<gdb::byte_vector> 654 fbsd_make_note_desc (enum target_object object, uint32_t structsize) 655 { 656 gdb::optional<gdb::byte_vector> buf = 657 target_read_alloc (current_inferior ()->top_target (), object, NULL); 658 if (!buf || buf->empty ()) 659 return {}; 660 661 if (structsize == 0) 662 return buf; 663 664 gdb::byte_vector desc (sizeof (structsize) + buf->size ()); 665 memcpy (desc.data (), &structsize, sizeof (structsize)); 666 memcpy (desc.data () + sizeof (structsize), buf->data (), buf->size ()); 667 return desc; 668 } 669 670 /* Create appropriate note sections for a corefile, returning them in 671 allocated memory. */ 672 673 static gdb::unique_xmalloc_ptr<char> 674 fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size) 675 { 676 gdb::unique_xmalloc_ptr<char> note_data; 677 Elf_Internal_Ehdr *i_ehdrp; 678 struct thread_info *curr_thr, *signalled_thr; 679 680 /* Put a "FreeBSD" label in the ELF header. */ 681 i_ehdrp = elf_elfheader (obfd); 682 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; 683 684 gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch)); 685 686 if (get_exec_file (0)) 687 { 688 const char *fname = lbasename (get_exec_file (0)); 689 std::string psargs = fname; 690 691 const std::string &infargs = current_inferior ()->args (); 692 if (!infargs.empty ()) 693 psargs += ' ' + infargs; 694 695 note_data.reset (elfcore_write_prpsinfo (obfd, note_data.release (), 696 note_size, fname, 697 psargs.c_str ())); 698 } 699 700 /* Thread register information. */ 701 try 702 { 703 update_thread_list (); 704 } 705 catch (const gdb_exception_error &e) 706 { 707 exception_print (gdb_stderr, e); 708 } 709 710 /* Like the kernel, prefer dumping the signalled thread first. 711 "First thread" is what tools use to infer the signalled thread. 712 In case there's more than one signalled thread, prefer the 713 current thread, if it is signalled. */ 714 curr_thr = inferior_thread (); 715 if (curr_thr->stop_signal () != GDB_SIGNAL_0) 716 signalled_thr = curr_thr; 717 else 718 { 719 signalled_thr = iterate_over_threads (find_signalled_thread, NULL); 720 if (signalled_thr == NULL) 721 signalled_thr = curr_thr; 722 } 723 724 enum gdb_signal stop_signal = signalled_thr->stop_signal (); 725 gcore_elf_build_thread_register_notes (gdbarch, signalled_thr, stop_signal, 726 obfd, ¬e_data, note_size); 727 for (thread_info *thr : current_inferior ()->non_exited_threads ()) 728 { 729 if (thr == signalled_thr) 730 continue; 731 732 gcore_elf_build_thread_register_notes (gdbarch, thr, stop_signal, 733 obfd, ¬e_data, note_size); 734 } 735 736 /* Auxiliary vector. */ 737 uint32_t structsize = gdbarch_ptr_bit (gdbarch) / 4; /* Elf_Auxinfo */ 738 gdb::optional<gdb::byte_vector> note_desc = 739 fbsd_make_note_desc (TARGET_OBJECT_AUXV, structsize); 740 if (note_desc && !note_desc->empty ()) 741 { 742 note_data.reset (elfcore_write_note (obfd, note_data.release (), 743 note_size, "FreeBSD", 744 NT_FREEBSD_PROCSTAT_AUXV, 745 note_desc->data (), 746 note_desc->size ())); 747 if (!note_data) 748 return NULL; 749 } 750 751 /* Virtual memory mappings. */ 752 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_VMMAP, 0); 753 if (note_desc && !note_desc->empty ()) 754 { 755 note_data.reset (elfcore_write_note (obfd, note_data.release (), 756 note_size, "FreeBSD", 757 NT_FREEBSD_PROCSTAT_VMMAP, 758 note_desc->data (), 759 note_desc->size ())); 760 if (!note_data) 761 return NULL; 762 } 763 764 note_desc = fbsd_make_note_desc (TARGET_OBJECT_FREEBSD_PS_STRINGS, 0); 765 if (note_desc && !note_desc->empty ()) 766 { 767 note_data.reset (elfcore_write_note (obfd, note_data.release (), 768 note_size, "FreeBSD", 769 NT_FREEBSD_PROCSTAT_PSSTRINGS, 770 note_desc->data (), 771 note_desc->size ())); 772 if (!note_data) 773 return NULL; 774 } 775 776 /* Include the target description when possible. */ 777 gcore_elf_make_tdesc_note (obfd, ¬e_data, note_size); 778 779 return note_data; 780 } 781 782 /* Helper function to generate the file descriptor description for a 783 single open file in 'info proc files'. */ 784 785 static const char * 786 fbsd_file_fd (int kf_fd) 787 { 788 switch (kf_fd) 789 { 790 case KINFO_FILE_FD_TYPE_CWD: 791 return "cwd"; 792 case KINFO_FILE_FD_TYPE_ROOT: 793 return "root"; 794 case KINFO_FILE_FD_TYPE_JAIL: 795 return "jail"; 796 case KINFO_FILE_FD_TYPE_TRACE: 797 return "trace"; 798 case KINFO_FILE_FD_TYPE_TEXT: 799 return "text"; 800 case KINFO_FILE_FD_TYPE_CTTY: 801 return "ctty"; 802 default: 803 return int_string (kf_fd, 10, 1, 0, 0); 804 } 805 } 806 807 /* Helper function to generate the file type for a single open file in 808 'info proc files'. */ 809 810 static const char * 811 fbsd_file_type (int kf_type, int kf_vnode_type) 812 { 813 switch (kf_type) 814 { 815 case KINFO_FILE_TYPE_VNODE: 816 switch (kf_vnode_type) 817 { 818 case KINFO_FILE_VTYPE_VREG: 819 return "file"; 820 case KINFO_FILE_VTYPE_VDIR: 821 return "dir"; 822 case KINFO_FILE_VTYPE_VCHR: 823 return "chr"; 824 case KINFO_FILE_VTYPE_VLNK: 825 return "link"; 826 case KINFO_FILE_VTYPE_VSOCK: 827 return "socket"; 828 case KINFO_FILE_VTYPE_VFIFO: 829 return "fifo"; 830 default: 831 { 832 char *str = get_print_cell (); 833 834 xsnprintf (str, PRINT_CELL_SIZE, "vn:%d", kf_vnode_type); 835 return str; 836 } 837 } 838 case KINFO_FILE_TYPE_SOCKET: 839 return "socket"; 840 case KINFO_FILE_TYPE_PIPE: 841 return "pipe"; 842 case KINFO_FILE_TYPE_FIFO: 843 return "fifo"; 844 case KINFO_FILE_TYPE_KQUEUE: 845 return "kqueue"; 846 case KINFO_FILE_TYPE_CRYPTO: 847 return "crypto"; 848 case KINFO_FILE_TYPE_MQUEUE: 849 return "mqueue"; 850 case KINFO_FILE_TYPE_SHM: 851 return "shm"; 852 case KINFO_FILE_TYPE_SEM: 853 return "sem"; 854 case KINFO_FILE_TYPE_PTS: 855 return "pts"; 856 case KINFO_FILE_TYPE_PROCDESC: 857 return "proc"; 858 default: 859 return int_string (kf_type, 10, 1, 0, 0); 860 } 861 } 862 863 /* Helper function to generate the file flags for a single open file in 864 'info proc files'. */ 865 866 static const char * 867 fbsd_file_flags (int kf_flags) 868 { 869 static char file_flags[10]; 870 871 file_flags[0] = (kf_flags & KINFO_FILE_FLAG_READ) ? 'r' : '-'; 872 file_flags[1] = (kf_flags & KINFO_FILE_FLAG_WRITE) ? 'w' : '-'; 873 file_flags[2] = (kf_flags & KINFO_FILE_FLAG_EXEC) ? 'x' : '-'; 874 file_flags[3] = (kf_flags & KINFO_FILE_FLAG_APPEND) ? 'a' : '-'; 875 file_flags[4] = (kf_flags & KINFO_FILE_FLAG_ASYNC) ? 's' : '-'; 876 file_flags[5] = (kf_flags & KINFO_FILE_FLAG_FSYNC) ? 'f' : '-'; 877 file_flags[6] = (kf_flags & KINFO_FILE_FLAG_NONBLOCK) ? 'n' : '-'; 878 file_flags[7] = (kf_flags & KINFO_FILE_FLAG_DIRECT) ? 'd' : '-'; 879 file_flags[8] = (kf_flags & KINFO_FILE_FLAG_HASLOCK) ? 'l' : '-'; 880 file_flags[9] = '\0'; 881 882 return file_flags; 883 } 884 885 /* Helper function to generate the name of an IP protocol. */ 886 887 static const char * 888 fbsd_ipproto (int protocol) 889 { 890 switch (protocol) 891 { 892 case FBSD_IPPROTO_ICMP: 893 return "icmp"; 894 case FBSD_IPPROTO_TCP: 895 return "tcp"; 896 case FBSD_IPPROTO_UDP: 897 return "udp"; 898 case FBSD_IPPROTO_SCTP: 899 return "sctp"; 900 default: 901 { 902 char *str = get_print_cell (); 903 904 xsnprintf (str, PRINT_CELL_SIZE, "ip<%d>", protocol); 905 return str; 906 } 907 } 908 } 909 910 /* Helper function to print out an IPv4 socket address. */ 911 912 static void 913 fbsd_print_sockaddr_in (const void *sockaddr) 914 { 915 const struct fbsd_sockaddr_in *sin = 916 reinterpret_cast<const struct fbsd_sockaddr_in *> (sockaddr); 917 char buf[INET_ADDRSTRLEN]; 918 919 if (inet_ntop (AF_INET, sin->sin_addr, buf, sizeof buf) == nullptr) 920 error (_("Failed to format IPv4 address")); 921 gdb_printf ("%s:%u", buf, 922 (sin->sin_port[0] << 8) | sin->sin_port[1]); 923 } 924 925 /* Helper function to print out an IPv6 socket address. */ 926 927 static void 928 fbsd_print_sockaddr_in6 (const void *sockaddr) 929 { 930 const struct fbsd_sockaddr_in6 *sin6 = 931 reinterpret_cast<const struct fbsd_sockaddr_in6 *> (sockaddr); 932 char buf[INET6_ADDRSTRLEN]; 933 934 if (inet_ntop (AF_INET6, sin6->sin6_addr, buf, sizeof buf) == nullptr) 935 error (_("Failed to format IPv6 address")); 936 gdb_printf ("%s.%u", buf, 937 (sin6->sin6_port[0] << 8) | sin6->sin6_port[1]); 938 } 939 940 /* See fbsd-tdep.h. */ 941 942 void 943 fbsd_info_proc_files_header () 944 { 945 gdb_printf (_("Open files:\n\n")); 946 gdb_printf (" %6s %6s %10s %9s %s\n", 947 "FD", "Type", "Offset", "Flags ", "Name"); 948 } 949 950 /* See fbsd-tdep.h. */ 951 952 void 953 fbsd_info_proc_files_entry (int kf_type, int kf_fd, int kf_flags, 954 LONGEST kf_offset, int kf_vnode_type, 955 int kf_sock_domain, int kf_sock_type, 956 int kf_sock_protocol, const void *kf_sa_local, 957 const void *kf_sa_peer, const void *kf_path) 958 { 959 gdb_printf (" %6s %6s %10s %8s ", 960 fbsd_file_fd (kf_fd), 961 fbsd_file_type (kf_type, kf_vnode_type), 962 kf_offset > -1 ? hex_string (kf_offset) : "-", 963 fbsd_file_flags (kf_flags)); 964 if (kf_type == KINFO_FILE_TYPE_SOCKET) 965 { 966 switch (kf_sock_domain) 967 { 968 case FBSD_AF_UNIX: 969 { 970 switch (kf_sock_type) 971 { 972 case FBSD_SOCK_STREAM: 973 gdb_printf ("unix stream:"); 974 break; 975 case FBSD_SOCK_DGRAM: 976 gdb_printf ("unix dgram:"); 977 break; 978 case FBSD_SOCK_SEQPACKET: 979 gdb_printf ("unix seqpacket:"); 980 break; 981 default: 982 gdb_printf ("unix <%d>:", kf_sock_type); 983 break; 984 } 985 986 /* For local sockets, print out the first non-nul path 987 rather than both paths. */ 988 const struct fbsd_sockaddr_un *saddr_un 989 = reinterpret_cast<const struct fbsd_sockaddr_un *> (kf_sa_local); 990 if (saddr_un->sun_path[0] == 0) 991 saddr_un = reinterpret_cast<const struct fbsd_sockaddr_un *> 992 (kf_sa_peer); 993 gdb_printf ("%s", saddr_un->sun_path); 994 break; 995 } 996 case FBSD_AF_INET: 997 gdb_printf ("%s4 ", fbsd_ipproto (kf_sock_protocol)); 998 fbsd_print_sockaddr_in (kf_sa_local); 999 gdb_printf (" -> "); 1000 fbsd_print_sockaddr_in (kf_sa_peer); 1001 break; 1002 case FBSD_AF_INET6: 1003 gdb_printf ("%s6 ", fbsd_ipproto (kf_sock_protocol)); 1004 fbsd_print_sockaddr_in6 (kf_sa_local); 1005 gdb_printf (" -> "); 1006 fbsd_print_sockaddr_in6 (kf_sa_peer); 1007 break; 1008 } 1009 } 1010 else 1011 gdb_printf ("%s", reinterpret_cast<const char *> (kf_path)); 1012 gdb_printf ("\n"); 1013 } 1014 1015 /* Implement "info proc files" for a corefile. */ 1016 1017 static void 1018 fbsd_core_info_proc_files (struct gdbarch *gdbarch) 1019 { 1020 asection *section 1021 = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files"); 1022 if (section == NULL) 1023 { 1024 warning (_("unable to find open files in core file")); 1025 return; 1026 } 1027 1028 size_t note_size = bfd_section_size (section); 1029 if (note_size < 4) 1030 error (_("malformed core note - too short for header")); 1031 1032 gdb::def_vector<unsigned char> contents (note_size); 1033 if (!bfd_get_section_contents (core_bfd, section, contents.data (), 1034 0, note_size)) 1035 error (_("could not get core note contents")); 1036 1037 unsigned char *descdata = contents.data (); 1038 unsigned char *descend = descdata + note_size; 1039 1040 /* Skip over the structure size. */ 1041 descdata += 4; 1042 1043 fbsd_info_proc_files_header (); 1044 1045 while (descdata + KF_PATH < descend) 1046 { 1047 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE); 1048 if (structsize < KF_PATH) 1049 error (_("malformed core note - file structure too small")); 1050 1051 LONGEST type = bfd_get_signed_32 (core_bfd, descdata + KF_TYPE); 1052 LONGEST fd = bfd_get_signed_32 (core_bfd, descdata + KF_FD); 1053 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KF_FLAGS); 1054 LONGEST offset = bfd_get_signed_64 (core_bfd, descdata + KF_OFFSET); 1055 LONGEST vnode_type = bfd_get_signed_32 (core_bfd, 1056 descdata + KF_VNODE_TYPE); 1057 LONGEST sock_domain = bfd_get_signed_32 (core_bfd, 1058 descdata + KF_SOCK_DOMAIN); 1059 LONGEST sock_type = bfd_get_signed_32 (core_bfd, descdata + KF_SOCK_TYPE); 1060 LONGEST sock_protocol = bfd_get_signed_32 (core_bfd, 1061 descdata + KF_SOCK_PROTOCOL); 1062 fbsd_info_proc_files_entry (type, fd, flags, offset, vnode_type, 1063 sock_domain, sock_type, sock_protocol, 1064 descdata + KF_SA_LOCAL, descdata + KF_SA_PEER, 1065 descdata + KF_PATH); 1066 1067 descdata += structsize; 1068 } 1069 } 1070 1071 /* Helper function to generate mappings flags for a single VM map 1072 entry in 'info proc mappings'. */ 1073 1074 static const char * 1075 fbsd_vm_map_entry_flags (int kve_flags, int kve_protection) 1076 { 1077 static char vm_flags[9]; 1078 1079 vm_flags[0] = (kve_protection & KINFO_VME_PROT_READ) ? 'r' : '-'; 1080 vm_flags[1] = (kve_protection & KINFO_VME_PROT_WRITE) ? 'w' : '-'; 1081 vm_flags[2] = (kve_protection & KINFO_VME_PROT_EXEC) ? 'x' : '-'; 1082 vm_flags[3] = ' '; 1083 vm_flags[4] = (kve_flags & KINFO_VME_FLAG_COW) ? 'C' : '-'; 1084 vm_flags[5] = (kve_flags & KINFO_VME_FLAG_NEEDS_COPY) ? 'N' : '-'; 1085 vm_flags[6] = (kve_flags & KINFO_VME_FLAG_SUPER) ? 'S' : '-'; 1086 vm_flags[7] = (kve_flags & KINFO_VME_FLAG_GROWS_UP) ? 'U' 1087 : (kve_flags & KINFO_VME_FLAG_GROWS_DOWN) ? 'D' : '-'; 1088 vm_flags[8] = '\0'; 1089 1090 return vm_flags; 1091 } 1092 1093 /* See fbsd-tdep.h. */ 1094 1095 void 1096 fbsd_info_proc_mappings_header (int addr_bit) 1097 { 1098 gdb_printf (_("Mapped address spaces:\n\n")); 1099 if (addr_bit == 64) 1100 { 1101 gdb_printf (" %18s %18s %10s %10s %9s %s\n", 1102 "Start Addr", 1103 " End Addr", 1104 " Size", " Offset", "Flags ", "File"); 1105 } 1106 else 1107 { 1108 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n", 1109 "Start Addr", 1110 " End Addr", 1111 " Size", " Offset", "Flags ", "File"); 1112 } 1113 } 1114 1115 /* See fbsd-tdep.h. */ 1116 1117 void 1118 fbsd_info_proc_mappings_entry (int addr_bit, ULONGEST kve_start, 1119 ULONGEST kve_end, ULONGEST kve_offset, 1120 int kve_flags, int kve_protection, 1121 const void *kve_path) 1122 { 1123 if (addr_bit == 64) 1124 { 1125 gdb_printf (" %18s %18s %10s %10s %9s %s\n", 1126 hex_string (kve_start), 1127 hex_string (kve_end), 1128 hex_string (kve_end - kve_start), 1129 hex_string (kve_offset), 1130 fbsd_vm_map_entry_flags (kve_flags, kve_protection), 1131 reinterpret_cast<const char *> (kve_path)); 1132 } 1133 else 1134 { 1135 gdb_printf ("\t%10s %10s %10s %10s %9s %s\n", 1136 hex_string (kve_start), 1137 hex_string (kve_end), 1138 hex_string (kve_end - kve_start), 1139 hex_string (kve_offset), 1140 fbsd_vm_map_entry_flags (kve_flags, kve_protection), 1141 reinterpret_cast<const char *> (kve_path)); 1142 } 1143 } 1144 1145 /* Implement "info proc mappings" for a corefile. */ 1146 1147 static void 1148 fbsd_core_info_proc_mappings (struct gdbarch *gdbarch) 1149 { 1150 asection *section; 1151 unsigned char *descdata, *descend; 1152 size_t note_size; 1153 1154 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.vmmap"); 1155 if (section == NULL) 1156 { 1157 warning (_("unable to find mappings in core file")); 1158 return; 1159 } 1160 1161 note_size = bfd_section_size (section); 1162 if (note_size < 4) 1163 error (_("malformed core note - too short for header")); 1164 1165 gdb::def_vector<unsigned char> contents (note_size); 1166 if (!bfd_get_section_contents (core_bfd, section, contents.data (), 1167 0, note_size)) 1168 error (_("could not get core note contents")); 1169 1170 descdata = contents.data (); 1171 descend = descdata + note_size; 1172 1173 /* Skip over the structure size. */ 1174 descdata += 4; 1175 1176 fbsd_info_proc_mappings_header (gdbarch_addr_bit (gdbarch)); 1177 while (descdata + KVE_PATH < descend) 1178 { 1179 ULONGEST structsize = bfd_get_32 (core_bfd, descdata + KVE_STRUCTSIZE); 1180 if (structsize < KVE_PATH) 1181 error (_("malformed core note - vmmap entry too small")); 1182 1183 ULONGEST start = bfd_get_64 (core_bfd, descdata + KVE_START); 1184 ULONGEST end = bfd_get_64 (core_bfd, descdata + KVE_END); 1185 ULONGEST offset = bfd_get_64 (core_bfd, descdata + KVE_OFFSET); 1186 LONGEST flags = bfd_get_signed_32 (core_bfd, descdata + KVE_FLAGS); 1187 LONGEST prot = bfd_get_signed_32 (core_bfd, descdata + KVE_PROTECTION); 1188 fbsd_info_proc_mappings_entry (gdbarch_addr_bit (gdbarch), start, end, 1189 offset, flags, prot, descdata + KVE_PATH); 1190 1191 descdata += structsize; 1192 } 1193 } 1194 1195 /* Fetch the pathname of a vnode for a single file descriptor from the 1196 file table core note. */ 1197 1198 static gdb::unique_xmalloc_ptr<char> 1199 fbsd_core_vnode_path (struct gdbarch *gdbarch, int fd) 1200 { 1201 asection *section; 1202 unsigned char *descdata, *descend; 1203 size_t note_size; 1204 1205 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.files"); 1206 if (section == NULL) 1207 return nullptr; 1208 1209 note_size = bfd_section_size (section); 1210 if (note_size < 4) 1211 error (_("malformed core note - too short for header")); 1212 1213 gdb::def_vector<unsigned char> contents (note_size); 1214 if (!bfd_get_section_contents (core_bfd, section, contents.data (), 1215 0, note_size)) 1216 error (_("could not get core note contents")); 1217 1218 descdata = contents.data (); 1219 descend = descdata + note_size; 1220 1221 /* Skip over the structure size. */ 1222 descdata += 4; 1223 1224 while (descdata + KF_PATH < descend) 1225 { 1226 ULONGEST structsize; 1227 1228 structsize = bfd_get_32 (core_bfd, descdata + KF_STRUCTSIZE); 1229 if (structsize < KF_PATH) 1230 error (_("malformed core note - file structure too small")); 1231 1232 if (bfd_get_32 (core_bfd, descdata + KF_TYPE) == KINFO_FILE_TYPE_VNODE 1233 && bfd_get_signed_32 (core_bfd, descdata + KF_FD) == fd) 1234 { 1235 char *path = (char *) descdata + KF_PATH; 1236 return make_unique_xstrdup (path); 1237 } 1238 1239 descdata += structsize; 1240 } 1241 return nullptr; 1242 } 1243 1244 /* Helper function to read a struct timeval. */ 1245 1246 static void 1247 fbsd_core_fetch_timeval (struct gdbarch *gdbarch, unsigned char *data, 1248 LONGEST &sec, ULONGEST &usec) 1249 { 1250 if (gdbarch_addr_bit (gdbarch) == 64) 1251 { 1252 sec = bfd_get_signed_64 (core_bfd, data); 1253 usec = bfd_get_64 (core_bfd, data + 8); 1254 } 1255 else if (bfd_get_arch (core_bfd) == bfd_arch_i386) 1256 { 1257 sec = bfd_get_signed_32 (core_bfd, data); 1258 usec = bfd_get_32 (core_bfd, data + 4); 1259 } 1260 else 1261 { 1262 sec = bfd_get_signed_64 (core_bfd, data); 1263 usec = bfd_get_32 (core_bfd, data + 8); 1264 } 1265 } 1266 1267 /* Print out the contents of a signal set. */ 1268 1269 static void 1270 fbsd_print_sigset (const char *descr, unsigned char *sigset) 1271 { 1272 gdb_printf ("%s: ", descr); 1273 for (int i = 0; i < SIG_WORDS; i++) 1274 gdb_printf ("%08x ", 1275 (unsigned int) bfd_get_32 (core_bfd, sigset + i * 4)); 1276 gdb_printf ("\n"); 1277 } 1278 1279 /* Implement "info proc status" for a corefile. */ 1280 1281 static void 1282 fbsd_core_info_proc_status (struct gdbarch *gdbarch) 1283 { 1284 const struct kinfo_proc_layout *kp; 1285 asection *section; 1286 unsigned char *descdata; 1287 int addr_bit, long_bit; 1288 size_t note_size; 1289 ULONGEST value; 1290 LONGEST sec; 1291 1292 section = bfd_get_section_by_name (core_bfd, ".note.freebsdcore.proc"); 1293 if (section == NULL) 1294 { 1295 warning (_("unable to find process info in core file")); 1296 return; 1297 } 1298 1299 addr_bit = gdbarch_addr_bit (gdbarch); 1300 if (addr_bit == 64) 1301 kp = &kinfo_proc_layout_64; 1302 else if (bfd_get_arch (core_bfd) == bfd_arch_i386) 1303 kp = &kinfo_proc_layout_i386; 1304 else 1305 kp = &kinfo_proc_layout_32; 1306 long_bit = gdbarch_long_bit (gdbarch); 1307 1308 /* 1309 * Ensure that the note is large enough for all of the fields fetched 1310 * by this function. In particular, the note must contain the 32-bit 1311 * structure size, then it must be long enough to access the last 1312 * field used (ki_rusage_ch.ru_majflt) which is the size of a long. 1313 */ 1314 note_size = bfd_section_size (section); 1315 if (note_size < (4 + kp->ki_rusage_ch + kp->ru_majflt 1316 + long_bit / TARGET_CHAR_BIT)) 1317 error (_("malformed core note - too short")); 1318 1319 gdb::def_vector<unsigned char> contents (note_size); 1320 if (!bfd_get_section_contents (core_bfd, section, contents.data (), 1321 0, note_size)) 1322 error (_("could not get core note contents")); 1323 1324 descdata = contents.data (); 1325 1326 /* Skip over the structure size. */ 1327 descdata += 4; 1328 1329 /* Verify 'ki_layout' is 0. */ 1330 if (bfd_get_32 (core_bfd, descdata + kp->ki_layout) != 0) 1331 { 1332 warning (_("unsupported process information in core file")); 1333 return; 1334 } 1335 1336 gdb_printf ("Name: %.19s\n", descdata + kp->ki_comm); 1337 gdb_printf ("Process ID: %s\n", 1338 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pid))); 1339 gdb_printf ("Parent process: %s\n", 1340 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ppid))); 1341 gdb_printf ("Process group: %s\n", 1342 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_pgid))); 1343 gdb_printf ("Session id: %s\n", 1344 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_sid))); 1345 1346 /* FreeBSD 12.0 and later store a 64-bit dev_t at 'ki_tdev'. Older 1347 kernels store a 32-bit dev_t at 'ki_tdev_freebsd11'. In older 1348 kernels the 64-bit 'ki_tdev' field is in a reserved section of 1349 the structure that is cleared to zero. Assume that a zero value 1350 in ki_tdev indicates a core dump from an older kernel and use the 1351 value in 'ki_tdev_freebsd11' instead. */ 1352 value = bfd_get_64 (core_bfd, descdata + kp->ki_tdev); 1353 if (value == 0) 1354 value = bfd_get_32 (core_bfd, descdata + kp->ki_tdev_freebsd11); 1355 gdb_printf ("TTY: %s\n", pulongest (value)); 1356 gdb_printf ("TTY owner process group: %s\n", 1357 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_tpgid))); 1358 gdb_printf ("User IDs (real, effective, saved): %s %s %s\n", 1359 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_ruid)), 1360 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_uid)), 1361 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svuid))); 1362 gdb_printf ("Group IDs (real, effective, saved): %s %s %s\n", 1363 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_rgid)), 1364 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_groups)), 1365 pulongest (bfd_get_32 (core_bfd, descdata + kp->ki_svgid))); 1366 gdb_printf ("Groups: "); 1367 uint16_t ngroups = bfd_get_16 (core_bfd, descdata + kp->ki_ngroups); 1368 for (int i = 0; i < ngroups; i++) 1369 gdb_printf ("%s ", 1370 pulongest (bfd_get_32 (core_bfd, 1371 descdata + kp->ki_groups + i * 4))); 1372 gdb_printf ("\n"); 1373 value = bfd_get (long_bit, core_bfd, 1374 descdata + kp->ki_rusage + kp->ru_minflt); 1375 gdb_printf ("Minor faults (no memory page): %s\n", pulongest (value)); 1376 value = bfd_get (long_bit, core_bfd, 1377 descdata + kp->ki_rusage_ch + kp->ru_minflt); 1378 gdb_printf ("Minor faults, children: %s\n", pulongest (value)); 1379 value = bfd_get (long_bit, core_bfd, 1380 descdata + kp->ki_rusage + kp->ru_majflt); 1381 gdb_printf ("Major faults (memory page faults): %s\n", 1382 pulongest (value)); 1383 value = bfd_get (long_bit, core_bfd, 1384 descdata + kp->ki_rusage_ch + kp->ru_majflt); 1385 gdb_printf ("Major faults, children: %s\n", pulongest (value)); 1386 fbsd_core_fetch_timeval (gdbarch, 1387 descdata + kp->ki_rusage + kp->ru_utime, 1388 sec, value); 1389 gdb_printf ("utime: %s.%06d\n", plongest (sec), (int) value); 1390 fbsd_core_fetch_timeval (gdbarch, 1391 descdata + kp->ki_rusage + kp->ru_stime, 1392 sec, value); 1393 gdb_printf ("stime: %s.%06d\n", plongest (sec), (int) value); 1394 fbsd_core_fetch_timeval (gdbarch, 1395 descdata + kp->ki_rusage_ch + kp->ru_utime, 1396 sec, value); 1397 gdb_printf ("utime, children: %s.%06d\n", plongest (sec), (int) value); 1398 fbsd_core_fetch_timeval (gdbarch, 1399 descdata + kp->ki_rusage_ch + kp->ru_stime, 1400 sec, value); 1401 gdb_printf ("stime, children: %s.%06d\n", plongest (sec), (int) value); 1402 gdb_printf ("'nice' value: %d\n", 1403 (int) bfd_get_signed_8 (core_bfd, descdata + kp->ki_nice)); 1404 fbsd_core_fetch_timeval (gdbarch, descdata + kp->ki_start, sec, value); 1405 gdb_printf ("Start time: %s.%06d\n", plongest (sec), (int) value); 1406 gdb_printf ("Virtual memory size: %s kB\n", 1407 pulongest (bfd_get (addr_bit, core_bfd, 1408 descdata + kp->ki_size) / 1024)); 1409 gdb_printf ("Data size: %s pages\n", 1410 pulongest (bfd_get (addr_bit, core_bfd, 1411 descdata + kp->ki_dsize))); 1412 gdb_printf ("Stack size: %s pages\n", 1413 pulongest (bfd_get (addr_bit, core_bfd, 1414 descdata + kp->ki_ssize))); 1415 gdb_printf ("Text size: %s pages\n", 1416 pulongest (bfd_get (addr_bit, core_bfd, 1417 descdata + kp->ki_tsize))); 1418 gdb_printf ("Resident set size: %s pages\n", 1419 pulongest (bfd_get (addr_bit, core_bfd, 1420 descdata + kp->ki_rssize))); 1421 gdb_printf ("Maximum RSS: %s pages\n", 1422 pulongest (bfd_get (long_bit, core_bfd, 1423 descdata + kp->ki_rusage 1424 + kp->ru_maxrss))); 1425 fbsd_print_sigset ("Ignored Signals", descdata + kp->ki_sigignore); 1426 fbsd_print_sigset ("Caught Signals", descdata + kp->ki_sigcatch); 1427 } 1428 1429 /* Implement the "core_info_proc" gdbarch method. */ 1430 1431 static void 1432 fbsd_core_info_proc (struct gdbarch *gdbarch, const char *args, 1433 enum info_proc_what what) 1434 { 1435 bool do_cmdline = false; 1436 bool do_cwd = false; 1437 bool do_exe = false; 1438 bool do_files = false; 1439 bool do_mappings = false; 1440 bool do_status = false; 1441 int pid; 1442 1443 switch (what) 1444 { 1445 case IP_MINIMAL: 1446 do_cmdline = true; 1447 do_cwd = true; 1448 do_exe = true; 1449 break; 1450 case IP_MAPPINGS: 1451 do_mappings = true; 1452 break; 1453 case IP_STATUS: 1454 case IP_STAT: 1455 do_status = true; 1456 break; 1457 case IP_CMDLINE: 1458 do_cmdline = true; 1459 break; 1460 case IP_EXE: 1461 do_exe = true; 1462 break; 1463 case IP_CWD: 1464 do_cwd = true; 1465 break; 1466 case IP_FILES: 1467 do_files = true; 1468 break; 1469 case IP_ALL: 1470 do_cmdline = true; 1471 do_cwd = true; 1472 do_exe = true; 1473 do_files = true; 1474 do_mappings = true; 1475 do_status = true; 1476 break; 1477 default: 1478 return; 1479 } 1480 1481 pid = bfd_core_file_pid (core_bfd); 1482 if (pid != 0) 1483 gdb_printf (_("process %d\n"), pid); 1484 1485 if (do_cmdline) 1486 { 1487 const char *cmdline; 1488 1489 cmdline = bfd_core_file_failing_command (core_bfd); 1490 if (cmdline) 1491 gdb_printf ("cmdline = '%s'\n", cmdline); 1492 else 1493 warning (_("Command line unavailable")); 1494 } 1495 if (do_cwd) 1496 { 1497 gdb::unique_xmalloc_ptr<char> cwd = 1498 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_CWD); 1499 if (cwd) 1500 gdb_printf ("cwd = '%s'\n", cwd.get ()); 1501 else 1502 warning (_("unable to read current working directory")); 1503 } 1504 if (do_exe) 1505 { 1506 gdb::unique_xmalloc_ptr<char> exe = 1507 fbsd_core_vnode_path (gdbarch, KINFO_FILE_FD_TYPE_TEXT); 1508 if (exe) 1509 gdb_printf ("exe = '%s'\n", exe.get ()); 1510 else 1511 warning (_("unable to read executable path name")); 1512 } 1513 if (do_files) 1514 fbsd_core_info_proc_files (gdbarch); 1515 if (do_mappings) 1516 fbsd_core_info_proc_mappings (gdbarch); 1517 if (do_status) 1518 fbsd_core_info_proc_status (gdbarch); 1519 } 1520 1521 /* Print descriptions of FreeBSD-specific AUXV entries to FILE. */ 1522 1523 static void 1524 fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, 1525 CORE_ADDR type, CORE_ADDR val) 1526 { 1527 const char *name = "???"; 1528 const char *description = ""; 1529 enum auxv_format format = AUXV_FORMAT_HEX; 1530 1531 switch (type) 1532 { 1533 case AT_NULL: 1534 case AT_IGNORE: 1535 case AT_EXECFD: 1536 case AT_PHDR: 1537 case AT_PHENT: 1538 case AT_PHNUM: 1539 case AT_PAGESZ: 1540 case AT_BASE: 1541 case AT_FLAGS: 1542 case AT_ENTRY: 1543 case AT_NOTELF: 1544 case AT_UID: 1545 case AT_EUID: 1546 case AT_GID: 1547 case AT_EGID: 1548 default_print_auxv_entry (gdbarch, file, type, val); 1549 return; 1550 #define _TAGNAME(tag) #tag 1551 #define TAGNAME(tag) _TAGNAME(AT_##tag) 1552 #define TAG(tag, text, kind) \ 1553 case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break 1554 TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR); 1555 TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX); 1556 TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC); 1557 TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC); 1558 TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC); 1559 TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX); 1560 TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC); 1561 TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX); 1562 TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX); 1563 TAG (EHDRFLAGS, _("ELF header e_flags"), AUXV_FORMAT_HEX); 1564 TAG (HWCAP, _("Machine-dependent CPU capability hints"), AUXV_FORMAT_HEX); 1565 TAG (HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX); 1566 TAG (BSDFLAGS, _("ELF BSD flags"), AUXV_FORMAT_HEX); 1567 TAG (ARGC, _("Argument count"), AUXV_FORMAT_DEC); 1568 TAG (ARGV, _("Argument vector"), AUXV_FORMAT_HEX); 1569 TAG (ENVC, _("Environment count"), AUXV_FORMAT_DEC); 1570 TAG (ENVV, _("Environment vector"), AUXV_FORMAT_HEX); 1571 TAG (PS_STRINGS, _("Pointer to ps_strings"), AUXV_FORMAT_HEX); 1572 TAG (FXRNG, _("Pointer to root RNG seed version"), AUXV_FORMAT_HEX); 1573 TAG (KPRELOAD, _("Base address of vDSO"), AUXV_FORMAT_HEX); 1574 TAG (USRSTACKBASE, _("Top of user stack"), AUXV_FORMAT_HEX); 1575 TAG (USRSTACKLIM, _("Grow limit of user stack"), AUXV_FORMAT_HEX); 1576 } 1577 1578 fprint_auxv_entry (file, name, description, format, type, val); 1579 } 1580 1581 /* Implement the "get_siginfo_type" gdbarch method. */ 1582 1583 static struct type * 1584 fbsd_get_siginfo_type (struct gdbarch *gdbarch) 1585 { 1586 struct fbsd_gdbarch_data *fbsd_gdbarch_data; 1587 struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type; 1588 struct type *uid_type, *pid_type; 1589 struct type *sigval_type, *reason_type; 1590 struct type *siginfo_type; 1591 struct type *type; 1592 1593 fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch); 1594 if (fbsd_gdbarch_data->siginfo_type != NULL) 1595 return fbsd_gdbarch_data->siginfo_type; 1596 1597 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1598 0, "int"); 1599 int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t"); 1600 uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t"); 1601 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 1602 0, "long"); 1603 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void); 1604 1605 /* union sigval */ 1606 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); 1607 sigval_type->set_name (xstrdup ("sigval")); 1608 append_composite_type_field (sigval_type, "sival_int", int_type); 1609 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type); 1610 1611 /* __pid_t */ 1612 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, 1613 int32_type->length () * TARGET_CHAR_BIT, "__pid_t"); 1614 pid_type->set_target_type (int32_type); 1615 pid_type->set_target_is_stub (true); 1616 1617 /* __uid_t */ 1618 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, 1619 uint32_type->length () * TARGET_CHAR_BIT, 1620 "__uid_t"); 1621 uid_type->set_target_type (uint32_type); 1622 pid_type->set_target_is_stub (true); 1623 1624 /* _reason */ 1625 reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); 1626 1627 /* _fault */ 1628 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1629 append_composite_type_field (type, "si_trapno", int_type); 1630 append_composite_type_field (reason_type, "_fault", type); 1631 1632 /* _timer */ 1633 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1634 append_composite_type_field (type, "si_timerid", int_type); 1635 append_composite_type_field (type, "si_overrun", int_type); 1636 append_composite_type_field (reason_type, "_timer", type); 1637 1638 /* _mesgq */ 1639 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1640 append_composite_type_field (type, "si_mqd", int_type); 1641 append_composite_type_field (reason_type, "_mesgq", type); 1642 1643 /* _poll */ 1644 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1645 append_composite_type_field (type, "si_band", long_type); 1646 append_composite_type_field (reason_type, "_poll", type); 1647 1648 /* __spare__ */ 1649 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1650 append_composite_type_field (type, "__spare1__", long_type); 1651 append_composite_type_field (type, "__spare2__", 1652 init_vector_type (int_type, 7)); 1653 append_composite_type_field (reason_type, "__spare__", type); 1654 1655 /* struct siginfo */ 1656 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 1657 siginfo_type->set_name (xstrdup ("siginfo")); 1658 append_composite_type_field (siginfo_type, "si_signo", int_type); 1659 append_composite_type_field (siginfo_type, "si_errno", int_type); 1660 append_composite_type_field (siginfo_type, "si_code", int_type); 1661 append_composite_type_field (siginfo_type, "si_pid", pid_type); 1662 append_composite_type_field (siginfo_type, "si_uid", uid_type); 1663 append_composite_type_field (siginfo_type, "si_status", int_type); 1664 append_composite_type_field (siginfo_type, "si_addr", void_ptr_type); 1665 append_composite_type_field (siginfo_type, "si_value", sigval_type); 1666 append_composite_type_field (siginfo_type, "_reason", reason_type); 1667 1668 fbsd_gdbarch_data->siginfo_type = siginfo_type; 1669 1670 return siginfo_type; 1671 } 1672 1673 /* Implement the "gdb_signal_from_target" gdbarch method. */ 1674 1675 static enum gdb_signal 1676 fbsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal) 1677 { 1678 switch (signal) 1679 { 1680 case 0: 1681 return GDB_SIGNAL_0; 1682 1683 case FREEBSD_SIGHUP: 1684 return GDB_SIGNAL_HUP; 1685 1686 case FREEBSD_SIGINT: 1687 return GDB_SIGNAL_INT; 1688 1689 case FREEBSD_SIGQUIT: 1690 return GDB_SIGNAL_QUIT; 1691 1692 case FREEBSD_SIGILL: 1693 return GDB_SIGNAL_ILL; 1694 1695 case FREEBSD_SIGTRAP: 1696 return GDB_SIGNAL_TRAP; 1697 1698 case FREEBSD_SIGABRT: 1699 return GDB_SIGNAL_ABRT; 1700 1701 case FREEBSD_SIGEMT: 1702 return GDB_SIGNAL_EMT; 1703 1704 case FREEBSD_SIGFPE: 1705 return GDB_SIGNAL_FPE; 1706 1707 case FREEBSD_SIGKILL: 1708 return GDB_SIGNAL_KILL; 1709 1710 case FREEBSD_SIGBUS: 1711 return GDB_SIGNAL_BUS; 1712 1713 case FREEBSD_SIGSEGV: 1714 return GDB_SIGNAL_SEGV; 1715 1716 case FREEBSD_SIGSYS: 1717 return GDB_SIGNAL_SYS; 1718 1719 case FREEBSD_SIGPIPE: 1720 return GDB_SIGNAL_PIPE; 1721 1722 case FREEBSD_SIGALRM: 1723 return GDB_SIGNAL_ALRM; 1724 1725 case FREEBSD_SIGTERM: 1726 return GDB_SIGNAL_TERM; 1727 1728 case FREEBSD_SIGURG: 1729 return GDB_SIGNAL_URG; 1730 1731 case FREEBSD_SIGSTOP: 1732 return GDB_SIGNAL_STOP; 1733 1734 case FREEBSD_SIGTSTP: 1735 return GDB_SIGNAL_TSTP; 1736 1737 case FREEBSD_SIGCONT: 1738 return GDB_SIGNAL_CONT; 1739 1740 case FREEBSD_SIGCHLD: 1741 return GDB_SIGNAL_CHLD; 1742 1743 case FREEBSD_SIGTTIN: 1744 return GDB_SIGNAL_TTIN; 1745 1746 case FREEBSD_SIGTTOU: 1747 return GDB_SIGNAL_TTOU; 1748 1749 case FREEBSD_SIGIO: 1750 return GDB_SIGNAL_IO; 1751 1752 case FREEBSD_SIGXCPU: 1753 return GDB_SIGNAL_XCPU; 1754 1755 case FREEBSD_SIGXFSZ: 1756 return GDB_SIGNAL_XFSZ; 1757 1758 case FREEBSD_SIGVTALRM: 1759 return GDB_SIGNAL_VTALRM; 1760 1761 case FREEBSD_SIGPROF: 1762 return GDB_SIGNAL_PROF; 1763 1764 case FREEBSD_SIGWINCH: 1765 return GDB_SIGNAL_WINCH; 1766 1767 case FREEBSD_SIGINFO: 1768 return GDB_SIGNAL_INFO; 1769 1770 case FREEBSD_SIGUSR1: 1771 return GDB_SIGNAL_USR1; 1772 1773 case FREEBSD_SIGUSR2: 1774 return GDB_SIGNAL_USR2; 1775 1776 /* SIGTHR is the same as SIGLWP on FreeBSD. */ 1777 case FREEBSD_SIGTHR: 1778 return GDB_SIGNAL_LWP; 1779 1780 case FREEBSD_SIGLIBRT: 1781 return GDB_SIGNAL_LIBRT; 1782 } 1783 1784 if (signal >= FREEBSD_SIGRTMIN && signal <= FREEBSD_SIGRTMAX) 1785 { 1786 int offset = signal - FREEBSD_SIGRTMIN; 1787 1788 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_65 + offset); 1789 } 1790 1791 return GDB_SIGNAL_UNKNOWN; 1792 } 1793 1794 /* Implement the "gdb_signal_to_target" gdbarch method. */ 1795 1796 static int 1797 fbsd_gdb_signal_to_target (struct gdbarch *gdbarch, 1798 enum gdb_signal signal) 1799 { 1800 switch (signal) 1801 { 1802 case GDB_SIGNAL_0: 1803 return 0; 1804 1805 case GDB_SIGNAL_HUP: 1806 return FREEBSD_SIGHUP; 1807 1808 case GDB_SIGNAL_INT: 1809 return FREEBSD_SIGINT; 1810 1811 case GDB_SIGNAL_QUIT: 1812 return FREEBSD_SIGQUIT; 1813 1814 case GDB_SIGNAL_ILL: 1815 return FREEBSD_SIGILL; 1816 1817 case GDB_SIGNAL_TRAP: 1818 return FREEBSD_SIGTRAP; 1819 1820 case GDB_SIGNAL_ABRT: 1821 return FREEBSD_SIGABRT; 1822 1823 case GDB_SIGNAL_EMT: 1824 return FREEBSD_SIGEMT; 1825 1826 case GDB_SIGNAL_FPE: 1827 return FREEBSD_SIGFPE; 1828 1829 case GDB_SIGNAL_KILL: 1830 return FREEBSD_SIGKILL; 1831 1832 case GDB_SIGNAL_BUS: 1833 return FREEBSD_SIGBUS; 1834 1835 case GDB_SIGNAL_SEGV: 1836 return FREEBSD_SIGSEGV; 1837 1838 case GDB_SIGNAL_SYS: 1839 return FREEBSD_SIGSYS; 1840 1841 case GDB_SIGNAL_PIPE: 1842 return FREEBSD_SIGPIPE; 1843 1844 case GDB_SIGNAL_ALRM: 1845 return FREEBSD_SIGALRM; 1846 1847 case GDB_SIGNAL_TERM: 1848 return FREEBSD_SIGTERM; 1849 1850 case GDB_SIGNAL_URG: 1851 return FREEBSD_SIGURG; 1852 1853 case GDB_SIGNAL_STOP: 1854 return FREEBSD_SIGSTOP; 1855 1856 case GDB_SIGNAL_TSTP: 1857 return FREEBSD_SIGTSTP; 1858 1859 case GDB_SIGNAL_CONT: 1860 return FREEBSD_SIGCONT; 1861 1862 case GDB_SIGNAL_CHLD: 1863 return FREEBSD_SIGCHLD; 1864 1865 case GDB_SIGNAL_TTIN: 1866 return FREEBSD_SIGTTIN; 1867 1868 case GDB_SIGNAL_TTOU: 1869 return FREEBSD_SIGTTOU; 1870 1871 case GDB_SIGNAL_IO: 1872 return FREEBSD_SIGIO; 1873 1874 case GDB_SIGNAL_XCPU: 1875 return FREEBSD_SIGXCPU; 1876 1877 case GDB_SIGNAL_XFSZ: 1878 return FREEBSD_SIGXFSZ; 1879 1880 case GDB_SIGNAL_VTALRM: 1881 return FREEBSD_SIGVTALRM; 1882 1883 case GDB_SIGNAL_PROF: 1884 return FREEBSD_SIGPROF; 1885 1886 case GDB_SIGNAL_WINCH: 1887 return FREEBSD_SIGWINCH; 1888 1889 case GDB_SIGNAL_INFO: 1890 return FREEBSD_SIGINFO; 1891 1892 case GDB_SIGNAL_USR1: 1893 return FREEBSD_SIGUSR1; 1894 1895 case GDB_SIGNAL_USR2: 1896 return FREEBSD_SIGUSR2; 1897 1898 case GDB_SIGNAL_LWP: 1899 return FREEBSD_SIGTHR; 1900 1901 case GDB_SIGNAL_LIBRT: 1902 return FREEBSD_SIGLIBRT; 1903 } 1904 1905 if (signal >= GDB_SIGNAL_REALTIME_65 1906 && signal <= GDB_SIGNAL_REALTIME_126) 1907 { 1908 int offset = signal - GDB_SIGNAL_REALTIME_65; 1909 1910 return FREEBSD_SIGRTMIN + offset; 1911 } 1912 1913 return -1; 1914 } 1915 1916 /* Implement the "get_syscall_number" gdbarch method. */ 1917 1918 static LONGEST 1919 fbsd_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread) 1920 { 1921 1922 /* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD 1923 native targets fetch the system call number from the 1924 'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait. 1925 However, system call catching requires this function to be 1926 set. */ 1927 1928 internal_error (_("fbsd_get_sycall_number called")); 1929 } 1930 1931 /* Read an integer symbol value from the current target. */ 1932 1933 static LONGEST 1934 fbsd_read_integer_by_name (struct gdbarch *gdbarch, const char *name) 1935 { 1936 bound_minimal_symbol ms = lookup_minimal_symbol (name, NULL, NULL); 1937 if (ms.minsym == NULL) 1938 error (_("Unable to resolve symbol '%s'"), name); 1939 1940 gdb_byte buf[4]; 1941 if (target_read_memory (ms.value_address (), buf, sizeof buf) != 0) 1942 error (_("Unable to read value of '%s'"), name); 1943 1944 return extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 1945 } 1946 1947 /* Lookup offsets of fields in the runtime linker's 'Obj_Entry' 1948 structure needed to determine the TLS index of an object file. */ 1949 1950 static void 1951 fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data) 1952 { 1953 try 1954 { 1955 /* Fetch offsets from debug symbols in rtld. */ 1956 struct symbol *obj_entry_sym 1957 = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN, 1958 language_c, NULL).symbol; 1959 if (obj_entry_sym == NULL) 1960 error (_("Unable to find Struct_Obj_Entry symbol")); 1961 data->off_linkmap = lookup_struct_elt (obj_entry_sym->type (), 1962 "linkmap", 0).offset / 8; 1963 data->off_tlsindex = lookup_struct_elt (obj_entry_sym->type (), 1964 "tlsindex", 0).offset / 8; 1965 data->rtld_offsets_valid = true; 1966 return; 1967 } 1968 catch (const gdb_exception_error &e) 1969 { 1970 data->off_linkmap = -1; 1971 } 1972 1973 try 1974 { 1975 /* Fetch offsets from global variables in libthr. Note that 1976 this does not work for single-threaded processes that are not 1977 linked against libthr. */ 1978 data->off_linkmap = fbsd_read_integer_by_name (gdbarch, 1979 "_thread_off_linkmap"); 1980 data->off_tlsindex = fbsd_read_integer_by_name (gdbarch, 1981 "_thread_off_tlsindex"); 1982 data->rtld_offsets_valid = true; 1983 return; 1984 } 1985 catch (const gdb_exception_error &e) 1986 { 1987 data->off_linkmap = -1; 1988 } 1989 } 1990 1991 /* Helper function to read the TLS index of an object file associated 1992 with a link map entry at LM_ADDR. */ 1993 1994 static LONGEST 1995 fbsd_get_tls_index (struct gdbarch *gdbarch, CORE_ADDR lm_addr) 1996 { 1997 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space); 1998 1999 if (!data->rtld_offsets_valid) 2000 fbsd_fetch_rtld_offsets (gdbarch, data); 2001 2002 if (data->off_linkmap == -1) 2003 throw_error (TLS_GENERIC_ERROR, 2004 _("Cannot fetch runtime linker structure offsets")); 2005 2006 /* Simulate container_of to convert from LM_ADDR to the Obj_Entry 2007 pointer and then compute the offset of the tlsindex member. */ 2008 CORE_ADDR tlsindex_addr = lm_addr - data->off_linkmap + data->off_tlsindex; 2009 2010 gdb_byte buf[4]; 2011 if (target_read_memory (tlsindex_addr, buf, sizeof buf) != 0) 2012 throw_error (TLS_GENERIC_ERROR, 2013 _("Cannot find thread-local variables on this target")); 2014 2015 return extract_signed_integer (buf, gdbarch_byte_order (gdbarch)); 2016 } 2017 2018 /* See fbsd-tdep.h. */ 2019 2020 CORE_ADDR 2021 fbsd_get_thread_local_address (struct gdbarch *gdbarch, CORE_ADDR dtv_addr, 2022 CORE_ADDR lm_addr, CORE_ADDR offset) 2023 { 2024 LONGEST tls_index = fbsd_get_tls_index (gdbarch, lm_addr); 2025 2026 gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT]; 2027 if (target_read_memory (dtv_addr, buf, sizeof buf) != 0) 2028 throw_error (TLS_GENERIC_ERROR, 2029 _("Cannot find thread-local variables on this target")); 2030 2031 const struct builtin_type *builtin = builtin_type (gdbarch); 2032 CORE_ADDR addr = gdbarch_pointer_to_address (gdbarch, 2033 builtin->builtin_data_ptr, buf); 2034 2035 addr += (tls_index + 1) * builtin->builtin_data_ptr->length (); 2036 if (target_read_memory (addr, buf, sizeof buf) != 0) 2037 throw_error (TLS_GENERIC_ERROR, 2038 _("Cannot find thread-local variables on this target")); 2039 2040 addr = gdbarch_pointer_to_address (gdbarch, builtin->builtin_data_ptr, buf); 2041 return addr + offset; 2042 } 2043 2044 /* See fbsd-tdep.h. */ 2045 2046 CORE_ADDR 2047 fbsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 2048 { 2049 struct bound_minimal_symbol msym = lookup_bound_minimal_symbol ("_rtld_bind"); 2050 if (msym.minsym != nullptr && msym.value_address () == pc) 2051 return frame_unwind_caller_pc (get_current_frame ()); 2052 2053 return 0; 2054 } 2055 2056 /* Return description of signal code or nullptr. */ 2057 2058 static const char * 2059 fbsd_signal_cause (enum gdb_signal siggnal, int code) 2060 { 2061 /* Signal-independent causes. */ 2062 switch (code) 2063 { 2064 case FBSD_SI_USER: 2065 return _("Sent by kill()"); 2066 case FBSD_SI_QUEUE: 2067 return _("Sent by sigqueue()"); 2068 case FBSD_SI_TIMER: 2069 return _("Timer expired"); 2070 case FBSD_SI_ASYNCIO: 2071 return _("Asynchronous I/O request completed"); 2072 case FBSD_SI_MESGQ: 2073 return _("Message arrived on empty message queue"); 2074 case FBSD_SI_KERNEL: 2075 return _("Sent by kernel"); 2076 case FBSD_SI_LWP: 2077 return _("Sent by thr_kill()"); 2078 } 2079 2080 switch (siggnal) 2081 { 2082 case GDB_SIGNAL_ILL: 2083 switch (code) 2084 { 2085 case FBSD_ILL_ILLOPC: 2086 return _("Illegal opcode"); 2087 case FBSD_ILL_ILLOPN: 2088 return _("Illegal operand"); 2089 case FBSD_ILL_ILLADR: 2090 return _("Illegal addressing mode"); 2091 case FBSD_ILL_ILLTRP: 2092 return _("Illegal trap"); 2093 case FBSD_ILL_PRVOPC: 2094 return _("Privileged opcode"); 2095 case FBSD_ILL_PRVREG: 2096 return _("Privileged register"); 2097 case FBSD_ILL_COPROC: 2098 return _("Coprocessor error"); 2099 case FBSD_ILL_BADSTK: 2100 return _("Internal stack error"); 2101 } 2102 break; 2103 case GDB_SIGNAL_BUS: 2104 switch (code) 2105 { 2106 case FBSD_BUS_ADRALN: 2107 return _("Invalid address alignment"); 2108 case FBSD_BUS_ADRERR: 2109 return _("Address not present"); 2110 case FBSD_BUS_OBJERR: 2111 return _("Object-specific hardware error"); 2112 case FBSD_BUS_OOMERR: 2113 return _("Out of memory"); 2114 } 2115 break; 2116 case GDB_SIGNAL_SEGV: 2117 switch (code) 2118 { 2119 case FBSD_SEGV_MAPERR: 2120 return _("Address not mapped to object"); 2121 case FBSD_SEGV_ACCERR: 2122 return _("Invalid permissions for mapped object"); 2123 case FBSD_SEGV_PKUERR: 2124 return _("PKU violation"); 2125 } 2126 break; 2127 case GDB_SIGNAL_FPE: 2128 switch (code) 2129 { 2130 case FBSD_FPE_INTOVF: 2131 return _("Integer overflow"); 2132 case FBSD_FPE_INTDIV: 2133 return _("Integer divide by zero"); 2134 case FBSD_FPE_FLTDIV: 2135 return _("Floating point divide by zero"); 2136 case FBSD_FPE_FLTOVF: 2137 return _("Floating point overflow"); 2138 case FBSD_FPE_FLTUND: 2139 return _("Floating point underflow"); 2140 case FBSD_FPE_FLTRES: 2141 return _("Floating point inexact result"); 2142 case FBSD_FPE_FLTINV: 2143 return _("Invalid floating point operation"); 2144 case FBSD_FPE_FLTSUB: 2145 return _("Subscript out of range"); 2146 } 2147 break; 2148 case GDB_SIGNAL_TRAP: 2149 switch (code) 2150 { 2151 case FBSD_TRAP_BRKPT: 2152 return _("Breakpoint"); 2153 case FBSD_TRAP_TRACE: 2154 return _("Trace trap"); 2155 case FBSD_TRAP_DTRACE: 2156 return _("DTrace-induced trap"); 2157 case FBSD_TRAP_CAP: 2158 return _("Capability violation"); 2159 } 2160 break; 2161 case GDB_SIGNAL_CHLD: 2162 switch (code) 2163 { 2164 case FBSD_CLD_EXITED: 2165 return _("Child has exited"); 2166 case FBSD_CLD_KILLED: 2167 return _("Child has terminated abnormally"); 2168 case FBSD_CLD_DUMPED: 2169 return _("Child has dumped core"); 2170 case FBSD_CLD_TRAPPED: 2171 return _("Traced child has trapped"); 2172 case FBSD_CLD_STOPPED: 2173 return _("Child has stopped"); 2174 case FBSD_CLD_CONTINUED: 2175 return _("Stopped child has continued"); 2176 } 2177 break; 2178 case GDB_SIGNAL_POLL: 2179 switch (code) 2180 { 2181 case FBSD_POLL_IN: 2182 return _("Data input available"); 2183 case FBSD_POLL_OUT: 2184 return _("Output buffers available"); 2185 case FBSD_POLL_MSG: 2186 return _("Input message available"); 2187 case FBSD_POLL_ERR: 2188 return _("I/O error"); 2189 case FBSD_POLL_PRI: 2190 return _("High priority input available"); 2191 case FBSD_POLL_HUP: 2192 return _("Device disconnected"); 2193 } 2194 break; 2195 } 2196 2197 return nullptr; 2198 } 2199 2200 /* Report additional details for a signal stop. */ 2201 2202 static void 2203 fbsd_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout, 2204 enum gdb_signal siggnal) 2205 { 2206 LONGEST code, mqd, pid, status, timerid, uid; 2207 2208 try 2209 { 2210 code = parse_and_eval_long ("$_siginfo.si_code"); 2211 pid = parse_and_eval_long ("$_siginfo.si_pid"); 2212 uid = parse_and_eval_long ("$_siginfo.si_uid"); 2213 status = parse_and_eval_long ("$_siginfo.si_status"); 2214 timerid = parse_and_eval_long ("$_siginfo._reason._timer.si_timerid"); 2215 mqd = parse_and_eval_long ("$_siginfo._reason._mesgq.si_mqd"); 2216 } 2217 catch (const gdb_exception_error &e) 2218 { 2219 return; 2220 } 2221 2222 const char *meaning = fbsd_signal_cause (siggnal, code); 2223 if (meaning == nullptr) 2224 return; 2225 2226 uiout->text (".\n"); 2227 uiout->field_string ("sigcode-meaning", meaning); 2228 2229 switch (code) 2230 { 2231 case FBSD_SI_USER: 2232 case FBSD_SI_QUEUE: 2233 case FBSD_SI_LWP: 2234 uiout->text (" from pid "); 2235 uiout->field_string ("sending-pid", plongest (pid)); 2236 uiout->text (" and user "); 2237 uiout->field_string ("sending-uid", plongest (uid)); 2238 return; 2239 case FBSD_SI_TIMER: 2240 uiout->text (": timerid "); 2241 uiout->field_string ("timerid", plongest (timerid)); 2242 return; 2243 case FBSD_SI_MESGQ: 2244 uiout->text (": message queue "); 2245 uiout->field_string ("message-queue", plongest (mqd)); 2246 return; 2247 case FBSD_SI_ASYNCIO: 2248 return; 2249 } 2250 2251 if (siggnal == GDB_SIGNAL_CHLD) 2252 { 2253 uiout->text (": pid "); 2254 uiout->field_string ("child-pid", plongest (pid)); 2255 uiout->text (", uid "); 2256 uiout->field_string ("child-uid", plongest (uid)); 2257 if (code == FBSD_CLD_EXITED) 2258 { 2259 uiout->text (", exit status "); 2260 uiout->field_string ("exit-status", plongest (status)); 2261 } 2262 else 2263 { 2264 uiout->text (", signal "); 2265 uiout->field_string ("signal", plongest (status)); 2266 } 2267 } 2268 } 2269 2270 /* Search a list of struct kinfo_vmmap entries in the ENTRIES buffer 2271 of LEN bytes to find the length of the entry starting at ADDR. 2272 Returns the length of the entry or zero if no entry was found. */ 2273 2274 static ULONGEST 2275 fbsd_vmmap_length (struct gdbarch *gdbarch, unsigned char *entries, size_t len, 2276 CORE_ADDR addr) 2277 { 2278 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2279 unsigned char *descdata = entries; 2280 unsigned char *descend = descdata + len; 2281 2282 /* Skip over the structure size. */ 2283 descdata += 4; 2284 2285 while (descdata + KVE_PATH < descend) 2286 { 2287 ULONGEST structsize = extract_unsigned_integer (descdata 2288 + KVE_STRUCTSIZE, 4, 2289 byte_order); 2290 if (structsize < KVE_PATH) 2291 return false; 2292 2293 ULONGEST start = extract_unsigned_integer (descdata + KVE_START, 8, 2294 byte_order); 2295 ULONGEST end = extract_unsigned_integer (descdata + KVE_END, 8, 2296 byte_order); 2297 if (start == addr) 2298 return end - start; 2299 2300 descdata += structsize; 2301 } 2302 return 0; 2303 } 2304 2305 /* Helper for fbsd_vsyscall_range that does the real work of finding 2306 the vDSO's address range. */ 2307 2308 static bool 2309 fbsd_vdso_range (struct gdbarch *gdbarch, struct mem_range *range) 2310 { 2311 if (target_auxv_search (AT_FREEBSD_KPRELOAD, &range->start) <= 0) 2312 return false; 2313 2314 if (!target_has_execution ()) 2315 { 2316 /* Search for the ending address in the NT_PROCSTAT_VMMAP note. */ 2317 asection *section = bfd_get_section_by_name (core_bfd, 2318 ".note.freebsdcore.vmmap"); 2319 if (section == nullptr) 2320 return false; 2321 2322 size_t note_size = bfd_section_size (section); 2323 if (note_size < 4) 2324 return false; 2325 2326 gdb::def_vector<unsigned char> contents (note_size); 2327 if (!bfd_get_section_contents (core_bfd, section, contents.data (), 2328 0, note_size)) 2329 return false; 2330 2331 range->length = fbsd_vmmap_length (gdbarch, contents.data (), note_size, 2332 range->start); 2333 } 2334 else 2335 { 2336 /* Fetch the list of address space entries from the running target. */ 2337 gdb::optional<gdb::byte_vector> buf = 2338 target_read_alloc (current_inferior ()->top_target (), 2339 TARGET_OBJECT_FREEBSD_VMMAP, nullptr); 2340 if (!buf || buf->empty ()) 2341 return false; 2342 2343 range->length = fbsd_vmmap_length (gdbarch, buf->data (), buf->size (), 2344 range->start); 2345 } 2346 return range->length != 0; 2347 } 2348 2349 /* Return the address range of the vDSO for the current inferior. */ 2350 2351 static int 2352 fbsd_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range) 2353 { 2354 struct fbsd_pspace_data *data = get_fbsd_pspace_data (current_program_space); 2355 2356 if (data->vdso_range_p == 0) 2357 { 2358 if (fbsd_vdso_range (gdbarch, &data->vdso_range)) 2359 data->vdso_range_p = 1; 2360 else 2361 data->vdso_range_p = -1; 2362 } 2363 2364 if (data->vdso_range_p < 0) 2365 return 0; 2366 2367 *range = data->vdso_range; 2368 return 1; 2369 } 2370 2371 /* To be called from GDB_OSABI_FREEBSD handlers. */ 2372 2373 void 2374 fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 2375 { 2376 set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str); 2377 set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name); 2378 set_gdbarch_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo); 2379 set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes); 2380 set_gdbarch_core_info_proc (gdbarch, fbsd_core_info_proc); 2381 set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry); 2382 set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type); 2383 set_gdbarch_gdb_signal_from_target (gdbarch, fbsd_gdb_signal_from_target); 2384 set_gdbarch_gdb_signal_to_target (gdbarch, fbsd_gdb_signal_to_target); 2385 set_gdbarch_report_signal_info (gdbarch, fbsd_report_signal_info); 2386 set_gdbarch_skip_solib_resolver (gdbarch, fbsd_skip_solib_resolver); 2387 set_gdbarch_vsyscall_range (gdbarch, fbsd_vsyscall_range); 2388 2389 /* `catch syscall' */ 2390 set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml"); 2391 set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number); 2392 } 2393
Indexes created Sun Apr 12 00:22:20 UTC 2026