1 /* Native-dependent code for FreeBSD. 2 3 Copyright (C) 2002-2019 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "common/byte-vector.h" 22 #include "gdbcore.h" 23 #include "inferior.h" 24 #include "regcache.h" 25 #include "regset.h" 26 #include "gdbcmd.h" 27 #include "gdbthread.h" 28 #include "common/gdb_wait.h" 29 #include "inf-ptrace.h" 30 #include <sys/types.h> 31 #include <sys/procfs.h> 32 #include <sys/ptrace.h> 33 #include <sys/signal.h> 34 #include <sys/sysctl.h> 35 #include <sys/user.h> 36 #if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP) 37 #include <libutil.h> 38 #endif 39 #if !defined(HAVE_KINFO_GETVMMAP) 40 #include "common/filestuff.h" 41 #endif 42 43 #include "elf-bfd.h" 44 #include "fbsd-nat.h" 45 #include "fbsd-tdep.h" 46 47 #include <list> 48 49 /* Return the name of a file that can be opened to get the symbols for 50 the child process identified by PID. */ 51 52 char * 53 fbsd_nat_target::pid_to_exec_file (int pid) 54 { 55 ssize_t len; 56 static char buf[PATH_MAX]; 57 char name[PATH_MAX]; 58 59 #ifdef KERN_PROC_PATHNAME 60 size_t buflen; 61 int mib[4]; 62 63 mib[0] = CTL_KERN; 64 mib[1] = KERN_PROC; 65 mib[2] = KERN_PROC_PATHNAME; 66 mib[3] = pid; 67 buflen = sizeof buf; 68 if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0) 69 /* The kern.proc.pathname.<pid> sysctl returns a length of zero 70 for processes without an associated executable such as kernel 71 processes. */ 72 return buflen == 0 ? NULL : buf; 73 #endif 74 75 xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid); 76 len = readlink (name, buf, PATH_MAX - 1); 77 if (len != -1) 78 { 79 buf[len] = '\0'; 80 return buf; 81 } 82 83 return NULL; 84 } 85 86 #ifdef HAVE_KINFO_GETVMMAP 87 /* Iterate over all the memory regions in the current inferior, 88 calling FUNC for each memory region. OBFD is passed as the last 89 argument to FUNC. */ 90 91 int 92 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func, 93 void *obfd) 94 { 95 pid_t pid = inferior_ptid.pid (); 96 struct kinfo_vmentry *kve; 97 uint64_t size; 98 int i, nitems; 99 100 gdb::unique_xmalloc_ptr<struct kinfo_vmentry> 101 vmentl (kinfo_getvmmap (pid, &nitems)); 102 if (vmentl == NULL) 103 perror_with_name (_("Couldn't fetch VM map entries.")); 104 105 for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++) 106 { 107 /* Skip unreadable segments and those where MAP_NOCORE has been set. */ 108 if (!(kve->kve_protection & KVME_PROT_READ) 109 || kve->kve_flags & KVME_FLAG_NOCOREDUMP) 110 continue; 111 112 /* Skip segments with an invalid type. */ 113 if (kve->kve_type != KVME_TYPE_DEFAULT 114 && kve->kve_type != KVME_TYPE_VNODE 115 && kve->kve_type != KVME_TYPE_SWAP 116 && kve->kve_type != KVME_TYPE_PHYS) 117 continue; 118 119 size = kve->kve_end - kve->kve_start; 120 if (info_verbose) 121 { 122 fprintf_filtered (gdb_stdout, 123 "Save segment, %ld bytes at %s (%c%c%c)\n", 124 (long) size, 125 paddress (target_gdbarch (), kve->kve_start), 126 kve->kve_protection & KVME_PROT_READ ? 'r' : '-', 127 kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-', 128 kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-'); 129 } 130 131 /* Invoke the callback function to create the corefile segment. 132 Pass MODIFIED as true, we do not know the real modification state. */ 133 func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ, 134 kve->kve_protection & KVME_PROT_WRITE, 135 kve->kve_protection & KVME_PROT_EXEC, 1, obfd); 136 } 137 return 0; 138 } 139 #else 140 static int 141 fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end, 142 char *protection) 143 { 144 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */ 145 char buf[256]; 146 int resident, privateresident; 147 unsigned long obj; 148 int ret = EOF; 149 150 /* As of FreeBSD 5.0-RELEASE, the layout is described in 151 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a 152 new column was added to the procfs map. Therefore we can't use 153 fscanf since we need to support older releases too. */ 154 if (fgets (buf, sizeof buf, mapfile) != NULL) 155 ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end, 156 &resident, &privateresident, &obj, protection); 157 158 return (ret != 0 && ret != EOF); 159 } 160 161 /* Iterate over all the memory regions in the current inferior, 162 calling FUNC for each memory region. OBFD is passed as the last 163 argument to FUNC. */ 164 165 int 166 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func, 167 void *obfd) 168 { 169 pid_t pid = inferior_ptid.pid (); 170 unsigned long start, end, size; 171 char protection[4]; 172 int read, write, exec; 173 174 std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid); 175 gdb_file_up mapfile (fopen (mapfilename.c_str (), "r")); 176 if (mapfile == NULL) 177 error (_("Couldn't open %s."), mapfilename.c_str ()); 178 179 if (info_verbose) 180 fprintf_filtered (gdb_stdout, 181 "Reading memory regions from %s\n", mapfilename.c_str ()); 182 183 /* Now iterate until end-of-file. */ 184 while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0])) 185 { 186 size = end - start; 187 188 read = (strchr (protection, 'r') != 0); 189 write = (strchr (protection, 'w') != 0); 190 exec = (strchr (protection, 'x') != 0); 191 192 if (info_verbose) 193 { 194 fprintf_filtered (gdb_stdout, 195 "Save segment, %ld bytes at %s (%c%c%c)\n", 196 size, paddress (target_gdbarch (), start), 197 read ? 'r' : '-', 198 write ? 'w' : '-', 199 exec ? 'x' : '-'); 200 } 201 202 /* Invoke the callback function to create the corefile segment. 203 Pass MODIFIED as true, we do not know the real modification state. */ 204 func (start, size, read, write, exec, 1, obfd); 205 } 206 207 return 0; 208 } 209 #endif 210 211 /* Fetch the command line for a running process. */ 212 213 static gdb::unique_xmalloc_ptr<char> 214 fbsd_fetch_cmdline (pid_t pid) 215 { 216 size_t len; 217 int mib[4]; 218 219 len = 0; 220 mib[0] = CTL_KERN; 221 mib[1] = KERN_PROC; 222 mib[2] = KERN_PROC_ARGS; 223 mib[3] = pid; 224 if (sysctl (mib, 4, NULL, &len, NULL, 0) == -1) 225 return nullptr; 226 227 if (len == 0) 228 return nullptr; 229 230 gdb::unique_xmalloc_ptr<char> cmdline ((char *) xmalloc (len)); 231 if (sysctl (mib, 4, cmdline.get (), &len, NULL, 0) == -1) 232 return nullptr; 233 234 /* Join the arguments with spaces to form a single string. */ 235 char *cp = cmdline.get (); 236 for (size_t i = 0; i < len - 1; i++) 237 if (cp[i] == '\0') 238 cp[i] = ' '; 239 cp[len - 1] = '\0'; 240 241 return cmdline; 242 } 243 244 /* Fetch the external variant of the kernel's internal process 245 structure for the process PID into KP. */ 246 247 static bool 248 fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp) 249 { 250 size_t len; 251 int mib[4]; 252 253 len = sizeof *kp; 254 mib[0] = CTL_KERN; 255 mib[1] = KERN_PROC; 256 mib[2] = KERN_PROC_PID; 257 mib[3] = pid; 258 return (sysctl (mib, 4, kp, &len, NULL, 0) == 0); 259 } 260 261 /* Implement the "info_proc" target_ops method. */ 262 263 bool 264 fbsd_nat_target::info_proc (const char *args, enum info_proc_what what) 265 { 266 #ifdef HAVE_KINFO_GETFILE 267 gdb::unique_xmalloc_ptr<struct kinfo_file> fdtbl; 268 int nfd = 0; 269 #endif 270 struct kinfo_proc kp; 271 pid_t pid; 272 bool do_cmdline = false; 273 bool do_cwd = false; 274 bool do_exe = false; 275 #ifdef HAVE_KINFO_GETFILE 276 bool do_files = false; 277 #endif 278 #ifdef HAVE_KINFO_GETVMMAP 279 bool do_mappings = false; 280 #endif 281 bool do_status = false; 282 283 switch (what) 284 { 285 case IP_MINIMAL: 286 do_cmdline = true; 287 do_cwd = true; 288 do_exe = true; 289 break; 290 #ifdef HAVE_KINFO_GETVMMAP 291 case IP_MAPPINGS: 292 do_mappings = true; 293 break; 294 #endif 295 case IP_STATUS: 296 case IP_STAT: 297 do_status = true; 298 break; 299 case IP_CMDLINE: 300 do_cmdline = true; 301 break; 302 case IP_EXE: 303 do_exe = true; 304 break; 305 case IP_CWD: 306 do_cwd = true; 307 break; 308 #ifdef HAVE_KINFO_GETFILE 309 case IP_FILES: 310 do_files = true; 311 break; 312 #endif 313 case IP_ALL: 314 do_cmdline = true; 315 do_cwd = true; 316 do_exe = true; 317 #ifdef HAVE_KINFO_GETFILE 318 do_files = true; 319 #endif 320 #ifdef HAVE_KINFO_GETVMMAP 321 do_mappings = true; 322 #endif 323 do_status = true; 324 break; 325 default: 326 error (_("Not supported on this target.")); 327 } 328 329 gdb_argv built_argv (args); 330 if (built_argv.count () == 0) 331 { 332 pid = inferior_ptid.pid (); 333 if (pid == 0) 334 error (_("No current process: you must name one.")); 335 } 336 else if (built_argv.count () == 1 && isdigit (built_argv[0][0])) 337 pid = strtol (built_argv[0], NULL, 10); 338 else 339 error (_("Invalid arguments.")); 340 341 printf_filtered (_("process %d\n"), pid); 342 #ifdef HAVE_KINFO_GETFILE 343 if (do_cwd || do_exe || do_files) 344 fdtbl.reset (kinfo_getfile (pid, &nfd)); 345 #endif 346 347 if (do_cmdline) 348 { 349 gdb::unique_xmalloc_ptr<char> cmdline = fbsd_fetch_cmdline (pid); 350 if (cmdline != nullptr) 351 printf_filtered ("cmdline = '%s'\n", cmdline.get ()); 352 else 353 warning (_("unable to fetch command line")); 354 } 355 if (do_cwd) 356 { 357 const char *cwd = NULL; 358 #ifdef HAVE_KINFO_GETFILE 359 struct kinfo_file *kf = fdtbl.get (); 360 for (int i = 0; i < nfd; i++, kf++) 361 { 362 if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_CWD) 363 { 364 cwd = kf->kf_path; 365 break; 366 } 367 } 368 #endif 369 if (cwd != NULL) 370 printf_filtered ("cwd = '%s'\n", cwd); 371 else 372 warning (_("unable to fetch current working directory")); 373 } 374 if (do_exe) 375 { 376 const char *exe = NULL; 377 #ifdef HAVE_KINFO_GETFILE 378 struct kinfo_file *kf = fdtbl.get (); 379 for (int i = 0; i < nfd; i++, kf++) 380 { 381 if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_TEXT) 382 { 383 exe = kf->kf_path; 384 break; 385 } 386 } 387 #endif 388 if (exe == NULL) 389 exe = pid_to_exec_file (pid); 390 if (exe != NULL) 391 printf_filtered ("exe = '%s'\n", exe); 392 else 393 warning (_("unable to fetch executable path name")); 394 } 395 #ifdef HAVE_KINFO_GETFILE 396 if (do_files) 397 { 398 struct kinfo_file *kf = fdtbl.get (); 399 400 if (nfd > 0) 401 { 402 fbsd_info_proc_files_header (); 403 for (int i = 0; i < nfd; i++, kf++) 404 fbsd_info_proc_files_entry (kf->kf_type, kf->kf_fd, kf->kf_flags, 405 kf->kf_offset, kf->kf_vnode_type, 406 kf->kf_sock_domain, kf->kf_sock_type, 407 kf->kf_sock_protocol, &kf->kf_sa_local, 408 &kf->kf_sa_peer, kf->kf_path); 409 } 410 else 411 warning (_("unable to fetch list of open files")); 412 } 413 #endif 414 #ifdef HAVE_KINFO_GETVMMAP 415 if (do_mappings) 416 { 417 int nvment; 418 gdb::unique_xmalloc_ptr<struct kinfo_vmentry> 419 vmentl (kinfo_getvmmap (pid, &nvment)); 420 421 if (vmentl != nullptr) 422 { 423 int addr_bit = TARGET_CHAR_BIT * sizeof (void *); 424 fbsd_info_proc_mappings_header (addr_bit); 425 426 struct kinfo_vmentry *kve = vmentl.get (); 427 for (int i = 0; i < nvment; i++, kve++) 428 fbsd_info_proc_mappings_entry (addr_bit, kve->kve_start, 429 kve->kve_end, kve->kve_offset, 430 kve->kve_flags, kve->kve_protection, 431 kve->kve_path); 432 } 433 else 434 warning (_("unable to fetch virtual memory map")); 435 } 436 #endif 437 if (do_status) 438 { 439 if (!fbsd_fetch_kinfo_proc (pid, &kp)) 440 warning (_("Failed to fetch process information")); 441 else 442 { 443 const char *state; 444 int pgtok; 445 446 printf_filtered ("Name: %s\n", kp.ki_comm); 447 switch (kp.ki_stat) 448 { 449 case SIDL: 450 state = "I (idle)"; 451 break; 452 case SRUN: 453 state = "R (running)"; 454 break; 455 case SSTOP: 456 state = "T (stopped)"; 457 break; 458 case SZOMB: 459 state = "Z (zombie)"; 460 break; 461 case SSLEEP: 462 state = "S (sleeping)"; 463 break; 464 case SWAIT: 465 state = "W (interrupt wait)"; 466 break; 467 case SLOCK: 468 state = "L (blocked on lock)"; 469 break; 470 default: 471 state = "? (unknown)"; 472 break; 473 } 474 printf_filtered ("State: %s\n", state); 475 printf_filtered ("Parent process: %d\n", kp.ki_ppid); 476 printf_filtered ("Process group: %d\n", kp.ki_pgid); 477 printf_filtered ("Session id: %d\n", kp.ki_sid); 478 printf_filtered ("TTY: %ju\n", (uintmax_t) kp.ki_tdev); 479 printf_filtered ("TTY owner process group: %d\n", kp.ki_tpgid); 480 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n", 481 kp.ki_ruid, kp.ki_uid, kp.ki_svuid); 482 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n", 483 kp.ki_rgid, kp.ki_groups[0], kp.ki_svgid); 484 printf_filtered ("Groups: "); 485 for (int i = 0; i < kp.ki_ngroups; i++) 486 printf_filtered ("%d ", kp.ki_groups[i]); 487 printf_filtered ("\n"); 488 printf_filtered ("Minor faults (no memory page): %ld\n", 489 kp.ki_rusage.ru_minflt); 490 printf_filtered ("Minor faults, children: %ld\n", 491 kp.ki_rusage_ch.ru_minflt); 492 printf_filtered ("Major faults (memory page faults): %ld\n", 493 kp.ki_rusage.ru_majflt); 494 printf_filtered ("Major faults, children: %ld\n", 495 kp.ki_rusage_ch.ru_majflt); 496 printf_filtered ("utime: %jd.%06ld\n", 497 (intmax_t) kp.ki_rusage.ru_utime.tv_sec, 498 kp.ki_rusage.ru_utime.tv_usec); 499 printf_filtered ("stime: %jd.%06ld\n", 500 (intmax_t) kp.ki_rusage.ru_stime.tv_sec, 501 kp.ki_rusage.ru_stime.tv_usec); 502 printf_filtered ("utime, children: %jd.%06ld\n", 503 (intmax_t) kp.ki_rusage_ch.ru_utime.tv_sec, 504 kp.ki_rusage_ch.ru_utime.tv_usec); 505 printf_filtered ("stime, children: %jd.%06ld\n", 506 (intmax_t) kp.ki_rusage_ch.ru_stime.tv_sec, 507 kp.ki_rusage_ch.ru_stime.tv_usec); 508 printf_filtered ("'nice' value: %d\n", kp.ki_nice); 509 printf_filtered ("Start time: %jd.%06ld\n", kp.ki_start.tv_sec, 510 kp.ki_start.tv_usec); 511 pgtok = getpagesize () / 1024; 512 printf_filtered ("Virtual memory size: %ju kB\n", 513 (uintmax_t) kp.ki_size / 1024); 514 printf_filtered ("Data size: %ju kB\n", 515 (uintmax_t) kp.ki_dsize * pgtok); 516 printf_filtered ("Stack size: %ju kB\n", 517 (uintmax_t) kp.ki_ssize * pgtok); 518 printf_filtered ("Text size: %ju kB\n", 519 (uintmax_t) kp.ki_tsize * pgtok); 520 printf_filtered ("Resident set size: %ju kB\n", 521 (uintmax_t) kp.ki_rssize * pgtok); 522 printf_filtered ("Maximum RSS: %ju kB\n", 523 (uintmax_t) kp.ki_rusage.ru_maxrss); 524 printf_filtered ("Pending Signals: "); 525 for (int i = 0; i < _SIG_WORDS; i++) 526 printf_filtered ("%08x ", kp.ki_siglist.__bits[i]); 527 printf_filtered ("\n"); 528 printf_filtered ("Ignored Signals: "); 529 for (int i = 0; i < _SIG_WORDS; i++) 530 printf_filtered ("%08x ", kp.ki_sigignore.__bits[i]); 531 printf_filtered ("\n"); 532 printf_filtered ("Caught Signals: "); 533 for (int i = 0; i < _SIG_WORDS; i++) 534 printf_filtered ("%08x ", kp.ki_sigcatch.__bits[i]); 535 printf_filtered ("\n"); 536 } 537 } 538 539 return true; 540 } 541 542 /* 543 * The current layout of siginfo_t on FreeBSD was adopted in SVN 544 * revision 153154 which shipped in FreeBSD versions 7.0 and later. 545 * Don't bother supporting the older layout on older kernels. The 546 * older format was also never used in core dump notes. 547 */ 548 #if __FreeBSD_version >= 700009 549 #define USE_SIGINFO 550 #endif 551 552 #ifdef USE_SIGINFO 553 /* Return the size of siginfo for the current inferior. */ 554 555 #ifdef __LP64__ 556 union sigval32 { 557 int sival_int; 558 uint32_t sival_ptr; 559 }; 560 561 /* This structure matches the naming and layout of `siginfo_t' in 562 <sys/signal.h>. In particular, the `si_foo' macros defined in that 563 header can be used with both types to copy fields in the `_reason' 564 union. */ 565 566 struct siginfo32 567 { 568 int si_signo; 569 int si_errno; 570 int si_code; 571 __pid_t si_pid; 572 __uid_t si_uid; 573 int si_status; 574 uint32_t si_addr; 575 union sigval32 si_value; 576 union 577 { 578 struct 579 { 580 int _trapno; 581 } _fault; 582 struct 583 { 584 int _timerid; 585 int _overrun; 586 } _timer; 587 struct 588 { 589 int _mqd; 590 } _mesgq; 591 struct 592 { 593 int32_t _band; 594 } _poll; 595 struct 596 { 597 int32_t __spare1__; 598 int __spare2__[7]; 599 } __spare__; 600 } _reason; 601 }; 602 #endif 603 604 static size_t 605 fbsd_siginfo_size () 606 { 607 #ifdef __LP64__ 608 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); 609 610 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */ 611 if (gdbarch_long_bit (gdbarch) == 32) 612 return sizeof (struct siginfo32); 613 #endif 614 return sizeof (siginfo_t); 615 } 616 617 /* Convert a native 64-bit siginfo object to a 32-bit object. Note 618 that FreeBSD doesn't support writing to $_siginfo, so this only 619 needs to convert one way. */ 620 621 static void 622 fbsd_convert_siginfo (siginfo_t *si) 623 { 624 #ifdef __LP64__ 625 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); 626 627 /* Is the inferior 32-bit? If not, nothing to do. */ 628 if (gdbarch_long_bit (gdbarch) != 32) 629 return; 630 631 struct siginfo32 si32; 632 633 si32.si_signo = si->si_signo; 634 si32.si_errno = si->si_errno; 635 si32.si_code = si->si_code; 636 si32.si_pid = si->si_pid; 637 si32.si_uid = si->si_uid; 638 si32.si_status = si->si_status; 639 si32.si_addr = (uintptr_t) si->si_addr; 640 641 /* If sival_ptr is being used instead of sival_int on a big-endian 642 platform, then sival_int will be zero since it holds the upper 643 32-bits of the pointer value. */ 644 #if _BYTE_ORDER == _BIG_ENDIAN 645 if (si->si_value.sival_int == 0) 646 si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr; 647 else 648 si32.si_value.sival_int = si->si_value.sival_int; 649 #else 650 si32.si_value.sival_int = si->si_value.sival_int; 651 #endif 652 653 /* Always copy the spare fields and then possibly overwrite them for 654 signal-specific or code-specific fields. */ 655 si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__; 656 for (int i = 0; i < 7; i++) 657 si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i]; 658 switch (si->si_signo) { 659 case SIGILL: 660 case SIGFPE: 661 case SIGSEGV: 662 case SIGBUS: 663 si32.si_trapno = si->si_trapno; 664 break; 665 } 666 switch (si->si_code) { 667 case SI_TIMER: 668 si32.si_timerid = si->si_timerid; 669 si32.si_overrun = si->si_overrun; 670 break; 671 case SI_MESGQ: 672 si32.si_mqd = si->si_mqd; 673 break; 674 } 675 676 memcpy(si, &si32, sizeof (si32)); 677 #endif 678 } 679 #endif 680 681 /* Implement the "xfer_partial" target_ops method. */ 682 683 enum target_xfer_status 684 fbsd_nat_target::xfer_partial (enum target_object object, 685 const char *annex, gdb_byte *readbuf, 686 const gdb_byte *writebuf, 687 ULONGEST offset, ULONGEST len, 688 ULONGEST *xfered_len) 689 { 690 pid_t pid = inferior_ptid.pid (); 691 692 switch (object) 693 { 694 #ifdef USE_SIGINFO 695 case TARGET_OBJECT_SIGNAL_INFO: 696 { 697 struct ptrace_lwpinfo pl; 698 size_t siginfo_size; 699 700 /* FreeBSD doesn't support writing to $_siginfo. */ 701 if (writebuf != NULL) 702 return TARGET_XFER_E_IO; 703 704 if (inferior_ptid.lwp_p ()) 705 pid = inferior_ptid.lwp (); 706 707 siginfo_size = fbsd_siginfo_size (); 708 if (offset > siginfo_size) 709 return TARGET_XFER_E_IO; 710 711 if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1) 712 return TARGET_XFER_E_IO; 713 714 if (!(pl.pl_flags & PL_FLAG_SI)) 715 return TARGET_XFER_E_IO; 716 717 fbsd_convert_siginfo (&pl.pl_siginfo); 718 if (offset + len > siginfo_size) 719 len = siginfo_size - offset; 720 721 memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len); 722 *xfered_len = len; 723 return TARGET_XFER_OK; 724 } 725 #endif 726 #ifdef KERN_PROC_AUXV 727 case TARGET_OBJECT_AUXV: 728 { 729 gdb::byte_vector buf_storage; 730 gdb_byte *buf; 731 size_t buflen; 732 int mib[4]; 733 734 if (writebuf != NULL) 735 return TARGET_XFER_E_IO; 736 mib[0] = CTL_KERN; 737 mib[1] = KERN_PROC; 738 mib[2] = KERN_PROC_AUXV; 739 mib[3] = pid; 740 if (offset == 0) 741 { 742 buf = readbuf; 743 buflen = len; 744 } 745 else 746 { 747 buflen = offset + len; 748 buf_storage.resize (buflen); 749 buf = buf_storage.data (); 750 } 751 if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0) 752 { 753 if (offset != 0) 754 { 755 if (buflen > offset) 756 { 757 buflen -= offset; 758 memcpy (readbuf, buf + offset, buflen); 759 } 760 else 761 buflen = 0; 762 } 763 *xfered_len = buflen; 764 return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK; 765 } 766 return TARGET_XFER_E_IO; 767 } 768 #endif 769 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS) 770 case TARGET_OBJECT_FREEBSD_VMMAP: 771 case TARGET_OBJECT_FREEBSD_PS_STRINGS: 772 { 773 gdb::byte_vector buf_storage; 774 gdb_byte *buf; 775 size_t buflen; 776 int mib[4]; 777 778 int proc_target; 779 uint32_t struct_size; 780 switch (object) 781 { 782 case TARGET_OBJECT_FREEBSD_VMMAP: 783 proc_target = KERN_PROC_VMMAP; 784 struct_size = sizeof (struct kinfo_vmentry); 785 break; 786 case TARGET_OBJECT_FREEBSD_PS_STRINGS: 787 proc_target = KERN_PROC_PS_STRINGS; 788 struct_size = sizeof (void *); 789 break; 790 } 791 792 if (writebuf != NULL) 793 return TARGET_XFER_E_IO; 794 795 mib[0] = CTL_KERN; 796 mib[1] = KERN_PROC; 797 mib[2] = proc_target; 798 mib[3] = pid; 799 800 if (sysctl (mib, 4, NULL, &buflen, NULL, 0) != 0) 801 return TARGET_XFER_E_IO; 802 buflen += sizeof (struct_size); 803 804 if (offset >= buflen) 805 { 806 *xfered_len = 0; 807 return TARGET_XFER_EOF; 808 } 809 810 buf_storage.resize (buflen); 811 buf = buf_storage.data (); 812 813 memcpy (buf, &struct_size, sizeof (struct_size)); 814 buflen -= sizeof (struct_size); 815 if (sysctl (mib, 4, buf + sizeof (struct_size), &buflen, NULL, 0) != 0) 816 return TARGET_XFER_E_IO; 817 buflen += sizeof (struct_size); 818 819 if (buflen - offset < len) 820 len = buflen - offset; 821 memcpy (readbuf, buf + offset, len); 822 *xfered_len = len; 823 return TARGET_XFER_OK; 824 } 825 #endif 826 default: 827 return inf_ptrace_target::xfer_partial (object, annex, 828 readbuf, writebuf, offset, 829 len, xfered_len); 830 } 831 } 832 833 #ifdef PT_LWPINFO 834 static int debug_fbsd_lwp; 835 static int debug_fbsd_nat; 836 837 static void 838 show_fbsd_lwp_debug (struct ui_file *file, int from_tty, 839 struct cmd_list_element *c, const char *value) 840 { 841 fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value); 842 } 843 844 static void 845 show_fbsd_nat_debug (struct ui_file *file, int from_tty, 846 struct cmd_list_element *c, const char *value) 847 { 848 fprintf_filtered (file, _("Debugging of FreeBSD native target is %s.\n"), 849 value); 850 } 851 852 /* 853 FreeBSD's first thread support was via a "reentrant" version of libc 854 (libc_r) that first shipped in 2.2.7. This library multiplexed all 855 of the threads in a process onto a single kernel thread. This 856 library was supported via the bsd-uthread target. 857 858 FreeBSD 5.1 introduced two new threading libraries that made use of 859 multiple kernel threads. The first (libkse) scheduled M user 860 threads onto N (<= M) kernel threads (LWPs). The second (libthr) 861 bound each user thread to a dedicated kernel thread. libkse shipped 862 as the default threading library (libpthread). 863 864 FreeBSD 5.3 added a libthread_db to abstract the interface across 865 the various thread libraries (libc_r, libkse, and libthr). 866 867 FreeBSD 7.0 switched the default threading library from from libkse 868 to libpthread and removed libc_r. 869 870 FreeBSD 8.0 removed libkse and the in-kernel support for it. The 871 only threading library supported by 8.0 and later is libthr which 872 ties each user thread directly to an LWP. To simplify the 873 implementation, this target only supports LWP-backed threads using 874 ptrace directly rather than libthread_db. 875 876 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS. 877 */ 878 879 /* Return true if PTID is still active in the inferior. */ 880 881 bool 882 fbsd_nat_target::thread_alive (ptid_t ptid) 883 { 884 if (ptid.lwp_p ()) 885 { 886 struct ptrace_lwpinfo pl; 887 888 if (ptrace (PT_LWPINFO, ptid.lwp (), (caddr_t) &pl, sizeof pl) 889 == -1) 890 return false; 891 #ifdef PL_FLAG_EXITED 892 if (pl.pl_flags & PL_FLAG_EXITED) 893 return false; 894 #endif 895 } 896 897 return true; 898 } 899 900 /* Convert PTID to a string. Returns the string in a static 901 buffer. */ 902 903 const char * 904 fbsd_nat_target::pid_to_str (ptid_t ptid) 905 { 906 lwpid_t lwp; 907 908 lwp = ptid.lwp (); 909 if (lwp != 0) 910 { 911 static char buf[64]; 912 int pid = ptid.pid (); 913 914 xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid); 915 return buf; 916 } 917 918 return normal_pid_to_str (ptid); 919 } 920 921 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME 922 /* Return the name assigned to a thread by an application. Returns 923 the string in a static buffer. */ 924 925 const char * 926 fbsd_nat_target::thread_name (struct thread_info *thr) 927 { 928 struct ptrace_lwpinfo pl; 929 struct kinfo_proc kp; 930 int pid = thr->ptid.pid (); 931 long lwp = thr->ptid.lwp (); 932 static char buf[sizeof pl.pl_tdname + 1]; 933 934 /* Note that ptrace_lwpinfo returns the process command in pl_tdname 935 if a name has not been set explicitly. Return a NULL name in 936 that case. */ 937 if (!fbsd_fetch_kinfo_proc (pid, &kp)) 938 perror_with_name (_("Failed to fetch process information")); 939 if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1) 940 perror_with_name (("ptrace")); 941 if (strcmp (kp.ki_comm, pl.pl_tdname) == 0) 942 return NULL; 943 xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname); 944 return buf; 945 } 946 #endif 947 948 /* Enable additional event reporting on new processes. 949 950 To catch fork events, PTRACE_FORK is set on every traced process 951 to enable stops on returns from fork or vfork. Note that both the 952 parent and child will always stop, even if system call stops are 953 not enabled. 954 955 To catch LWP events, PTRACE_EVENTS is set on every traced process. 956 This enables stops on the birth for new LWPs (excluding the "main" LWP) 957 and the death of LWPs (excluding the last LWP in a process). Note 958 that unlike fork events, the LWP that creates a new LWP does not 959 report an event. */ 960 961 static void 962 fbsd_enable_proc_events (pid_t pid) 963 { 964 #ifdef PT_GET_EVENT_MASK 965 int events; 966 967 if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events, 968 sizeof (events)) == -1) 969 perror_with_name (("ptrace")); 970 events |= PTRACE_FORK | PTRACE_LWP; 971 #ifdef PTRACE_VFORK 972 events |= PTRACE_VFORK; 973 #endif 974 if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events, 975 sizeof (events)) == -1) 976 perror_with_name (("ptrace")); 977 #else 978 #ifdef TDP_RFPPWAIT 979 if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) 980 perror_with_name (("ptrace")); 981 #endif 982 #ifdef PT_LWP_EVENTS 983 if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) 984 perror_with_name (("ptrace")); 985 #endif 986 #endif 987 } 988 989 /* Add threads for any new LWPs in a process. 990 991 When LWP events are used, this function is only used to detect existing 992 threads when attaching to a process. On older systems, this function is 993 called to discover new threads each time the thread list is updated. */ 994 995 static void 996 fbsd_add_threads (pid_t pid) 997 { 998 int i, nlwps; 999 1000 gdb_assert (!in_thread_list (ptid_t (pid))); 1001 nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0); 1002 if (nlwps == -1) 1003 perror_with_name (("ptrace")); 1004 1005 gdb::unique_xmalloc_ptr<lwpid_t[]> lwps (XCNEWVEC (lwpid_t, nlwps)); 1006 1007 nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps); 1008 if (nlwps == -1) 1009 perror_with_name (("ptrace")); 1010 1011 for (i = 0; i < nlwps; i++) 1012 { 1013 ptid_t ptid = ptid_t (pid, lwps[i], 0); 1014 1015 if (!in_thread_list (ptid)) 1016 { 1017 #ifdef PT_LWP_EVENTS 1018 struct ptrace_lwpinfo pl; 1019 1020 /* Don't add exited threads. Note that this is only called 1021 when attaching to a multi-threaded process. */ 1022 if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1) 1023 perror_with_name (("ptrace")); 1024 if (pl.pl_flags & PL_FLAG_EXITED) 1025 continue; 1026 #endif 1027 if (debug_fbsd_lwp) 1028 fprintf_unfiltered (gdb_stdlog, 1029 "FLWP: adding thread for LWP %u\n", 1030 lwps[i]); 1031 add_thread (ptid); 1032 } 1033 } 1034 } 1035 1036 /* Implement the "update_thread_list" target_ops method. */ 1037 1038 void 1039 fbsd_nat_target::update_thread_list () 1040 { 1041 #ifdef PT_LWP_EVENTS 1042 /* With support for thread events, threads are added/deleted from the 1043 list as events are reported, so just try deleting exited threads. */ 1044 delete_exited_threads (); 1045 #else 1046 prune_threads (); 1047 1048 fbsd_add_threads (inferior_ptid.pid ()); 1049 #endif 1050 } 1051 1052 #ifdef TDP_RFPPWAIT 1053 /* 1054 To catch fork events, PT_FOLLOW_FORK is set on every traced process 1055 to enable stops on returns from fork or vfork. Note that both the 1056 parent and child will always stop, even if system call stops are not 1057 enabled. 1058 1059 After a fork, both the child and parent process will stop and report 1060 an event. However, there is no guarantee of order. If the parent 1061 reports its stop first, then fbsd_wait explicitly waits for the new 1062 child before returning. If the child reports its stop first, then 1063 the event is saved on a list and ignored until the parent's stop is 1064 reported. fbsd_wait could have been changed to fetch the parent PID 1065 of the new child and used that to wait for the parent explicitly. 1066 However, if two threads in the parent fork at the same time, then 1067 the wait on the parent might return the "wrong" fork event. 1068 1069 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for 1070 the new child process. This flag could be inferred by treating any 1071 events for an unknown pid as a new child. 1072 1073 In addition, the initial version of PT_FOLLOW_FORK did not report a 1074 stop event for the parent process of a vfork until after the child 1075 process executed a new program or exited. The kernel was changed to 1076 defer the wait for exit or exec of the child until after posting the 1077 stop event shortly after the change to introduce PL_FLAG_CHILD. 1078 This could be worked around by reporting a vfork event when the 1079 child event posted and ignoring the subsequent event from the 1080 parent. 1081 1082 This implementation requires both of these fixes for simplicity's 1083 sake. FreeBSD versions newer than 9.1 contain both fixes. 1084 */ 1085 1086 static std::list<ptid_t> fbsd_pending_children; 1087 1088 /* Record a new child process event that is reported before the 1089 corresponding fork event in the parent. */ 1090 1091 static void 1092 fbsd_remember_child (ptid_t pid) 1093 { 1094 fbsd_pending_children.push_front (pid); 1095 } 1096 1097 /* Check for a previously-recorded new child process event for PID. 1098 If one is found, remove it from the list and return the PTID. */ 1099 1100 static ptid_t 1101 fbsd_is_child_pending (pid_t pid) 1102 { 1103 for (auto it = fbsd_pending_children.begin (); 1104 it != fbsd_pending_children.end (); it++) 1105 if (it->pid () == pid) 1106 { 1107 ptid_t ptid = *it; 1108 fbsd_pending_children.erase (it); 1109 return ptid; 1110 } 1111 return null_ptid; 1112 } 1113 1114 #ifndef PTRACE_VFORK 1115 static std::forward_list<ptid_t> fbsd_pending_vfork_done; 1116 1117 /* Record a pending vfork done event. */ 1118 1119 static void 1120 fbsd_add_vfork_done (ptid_t pid) 1121 { 1122 fbsd_pending_vfork_done.push_front (pid); 1123 } 1124 1125 /* Check for a pending vfork done event for a specific PID. */ 1126 1127 static int 1128 fbsd_is_vfork_done_pending (pid_t pid) 1129 { 1130 for (auto it = fbsd_pending_vfork_done.begin (); 1131 it != fbsd_pending_vfork_done.end (); it++) 1132 if (it->pid () == pid) 1133 return 1; 1134 return 0; 1135 } 1136 1137 /* Check for a pending vfork done event. If one is found, remove it 1138 from the list and return the PTID. */ 1139 1140 static ptid_t 1141 fbsd_next_vfork_done (void) 1142 { 1143 if (!fbsd_pending_vfork_done.empty ()) 1144 { 1145 ptid_t ptid = fbsd_pending_vfork_done.front (); 1146 fbsd_pending_vfork_done.pop_front (); 1147 return ptid; 1148 } 1149 return null_ptid; 1150 } 1151 #endif 1152 #endif 1153 1154 /* Implement the "resume" target_ops method. */ 1155 1156 void 1157 fbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) 1158 { 1159 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK) 1160 pid_t pid; 1161 1162 /* Don't PT_CONTINUE a process which has a pending vfork done event. */ 1163 if (minus_one_ptid == ptid) 1164 pid = inferior_ptid.pid (); 1165 else 1166 pid = ptid.pid (); 1167 if (fbsd_is_vfork_done_pending (pid)) 1168 return; 1169 #endif 1170 1171 if (debug_fbsd_lwp) 1172 fprintf_unfiltered (gdb_stdlog, 1173 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n", 1174 ptid.pid (), ptid.lwp (), 1175 ptid.tid ()); 1176 if (ptid.lwp_p ()) 1177 { 1178 /* If ptid is a specific LWP, suspend all other LWPs in the process. */ 1179 inferior *inf = find_inferior_ptid (ptid); 1180 1181 for (thread_info *tp : inf->non_exited_threads ()) 1182 { 1183 int request; 1184 1185 if (tp->ptid.lwp () == ptid.lwp ()) 1186 request = PT_RESUME; 1187 else 1188 request = PT_SUSPEND; 1189 1190 if (ptrace (request, tp->ptid.lwp (), NULL, 0) == -1) 1191 perror_with_name (("ptrace")); 1192 } 1193 } 1194 else 1195 { 1196 /* If ptid is a wildcard, resume all matching threads (they won't run 1197 until the process is continued however). */ 1198 for (thread_info *tp : all_non_exited_threads (ptid)) 1199 if (ptrace (PT_RESUME, tp->ptid.lwp (), NULL, 0) == -1) 1200 perror_with_name (("ptrace")); 1201 ptid = inferior_ptid; 1202 } 1203 1204 #if __FreeBSD_version < 1200052 1205 /* When multiple threads within a process wish to report STOPPED 1206 events from wait(), the kernel picks one thread event as the 1207 thread event to report. The chosen thread event is retrieved via 1208 PT_LWPINFO by passing the process ID as the request pid. If 1209 multiple events are pending, then the subsequent wait() after 1210 resuming a process will report another STOPPED event after 1211 resuming the process to handle the next thread event and so on. 1212 1213 A single thread event is cleared as a side effect of resuming the 1214 process with PT_CONTINUE, PT_STEP, etc. In older kernels, 1215 however, the request pid was used to select which thread's event 1216 was cleared rather than always clearing the event that was just 1217 reported. To avoid clearing the event of the wrong LWP, always 1218 pass the process ID instead of an LWP ID to PT_CONTINUE or 1219 PT_SYSCALL. 1220 1221 In the case of stepping, the process ID cannot be used with 1222 PT_STEP since it would step the thread that reported an event 1223 which may not be the thread indicated by PTID. For stepping, use 1224 PT_SETSTEP to enable stepping on the desired thread before 1225 resuming the process via PT_CONTINUE instead of using 1226 PT_STEP. */ 1227 if (step) 1228 { 1229 if (ptrace (PT_SETSTEP, get_ptrace_pid (ptid), NULL, 0) == -1) 1230 perror_with_name (("ptrace")); 1231 step = 0; 1232 } 1233 ptid = ptid_t (ptid.pid ()); 1234 #endif 1235 inf_ptrace_target::resume (ptid, step, signo); 1236 } 1237 1238 #ifdef USE_SIGTRAP_SIGINFO 1239 /* Handle breakpoint and trace traps reported via SIGTRAP. If the 1240 trap was a breakpoint or trace trap that should be reported to the 1241 core, return true. */ 1242 1243 static bool 1244 fbsd_handle_debug_trap (ptid_t ptid, const struct ptrace_lwpinfo &pl) 1245 { 1246 1247 /* Ignore traps without valid siginfo or for signals other than 1248 SIGTRAP. 1249 1250 FreeBSD kernels prior to r341800 can return stale siginfo for at 1251 least some events, but those events can be identified by 1252 additional flags set in pl_flags. True breakpoint and 1253 single-step traps should not have other flags set in 1254 pl_flags. */ 1255 if (pl.pl_flags != PL_FLAG_SI || pl.pl_siginfo.si_signo != SIGTRAP) 1256 return false; 1257 1258 /* Trace traps are either a single step or a hardware watchpoint or 1259 breakpoint. */ 1260 if (pl.pl_siginfo.si_code == TRAP_TRACE) 1261 { 1262 if (debug_fbsd_nat) 1263 fprintf_unfiltered (gdb_stdlog, 1264 "FNAT: trace trap for LWP %ld\n", ptid.lwp ()); 1265 return true; 1266 } 1267 1268 if (pl.pl_siginfo.si_code == TRAP_BRKPT) 1269 { 1270 /* Fixup PC for the software breakpoint. */ 1271 struct regcache *regcache = get_thread_regcache (ptid); 1272 struct gdbarch *gdbarch = regcache->arch (); 1273 int decr_pc = gdbarch_decr_pc_after_break (gdbarch); 1274 1275 if (debug_fbsd_nat) 1276 fprintf_unfiltered (gdb_stdlog, 1277 "FNAT: sw breakpoint trap for LWP %ld\n", 1278 ptid.lwp ()); 1279 if (decr_pc != 0) 1280 { 1281 CORE_ADDR pc; 1282 1283 pc = regcache_read_pc (regcache); 1284 regcache_write_pc (regcache, pc - decr_pc); 1285 } 1286 return true; 1287 } 1288 1289 return false; 1290 } 1291 #endif 1292 1293 /* Wait for the child specified by PTID to do something. Return the 1294 process ID of the child, or MINUS_ONE_PTID in case of error; store 1295 the status in *OURSTATUS. */ 1296 1297 ptid_t 1298 fbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 1299 int target_options) 1300 { 1301 ptid_t wptid; 1302 1303 while (1) 1304 { 1305 #ifndef PTRACE_VFORK 1306 wptid = fbsd_next_vfork_done (); 1307 if (wptid != null_ptid) 1308 { 1309 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE; 1310 return wptid; 1311 } 1312 #endif 1313 wptid = inf_ptrace_target::wait (ptid, ourstatus, target_options); 1314 if (ourstatus->kind == TARGET_WAITKIND_STOPPED) 1315 { 1316 struct ptrace_lwpinfo pl; 1317 pid_t pid; 1318 int status; 1319 1320 pid = wptid.pid (); 1321 if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1) 1322 perror_with_name (("ptrace")); 1323 1324 wptid = ptid_t (pid, pl.pl_lwpid, 0); 1325 1326 if (debug_fbsd_nat) 1327 { 1328 fprintf_unfiltered (gdb_stdlog, 1329 "FNAT: stop for LWP %u event %d flags %#x\n", 1330 pl.pl_lwpid, pl.pl_event, pl.pl_flags); 1331 if (pl.pl_flags & PL_FLAG_SI) 1332 fprintf_unfiltered (gdb_stdlog, 1333 "FNAT: si_signo %u si_code %u\n", 1334 pl.pl_siginfo.si_signo, 1335 pl.pl_siginfo.si_code); 1336 } 1337 1338 #ifdef PT_LWP_EVENTS 1339 if (pl.pl_flags & PL_FLAG_EXITED) 1340 { 1341 /* If GDB attaches to a multi-threaded process, exiting 1342 threads might be skipped during post_attach that 1343 have not yet reported their PL_FLAG_EXITED event. 1344 Ignore EXITED events for an unknown LWP. */ 1345 thread_info *thr = find_thread_ptid (wptid); 1346 if (thr != nullptr) 1347 { 1348 if (debug_fbsd_lwp) 1349 fprintf_unfiltered (gdb_stdlog, 1350 "FLWP: deleting thread for LWP %u\n", 1351 pl.pl_lwpid); 1352 if (print_thread_events) 1353 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str 1354 (wptid)); 1355 delete_thread (thr); 1356 } 1357 if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1) 1358 perror_with_name (("ptrace")); 1359 continue; 1360 } 1361 #endif 1362 1363 /* Switch to an LWP PTID on the first stop in a new process. 1364 This is done after handling PL_FLAG_EXITED to avoid 1365 switching to an exited LWP. It is done before checking 1366 PL_FLAG_BORN in case the first stop reported after 1367 attaching to an existing process is a PL_FLAG_BORN 1368 event. */ 1369 if (in_thread_list (ptid_t (pid))) 1370 { 1371 if (debug_fbsd_lwp) 1372 fprintf_unfiltered (gdb_stdlog, 1373 "FLWP: using LWP %u for first thread\n", 1374 pl.pl_lwpid); 1375 thread_change_ptid (ptid_t (pid), wptid); 1376 } 1377 1378 #ifdef PT_LWP_EVENTS 1379 if (pl.pl_flags & PL_FLAG_BORN) 1380 { 1381 /* If GDB attaches to a multi-threaded process, newborn 1382 threads might be added by fbsd_add_threads that have 1383 not yet reported their PL_FLAG_BORN event. Ignore 1384 BORN events for an already-known LWP. */ 1385 if (!in_thread_list (wptid)) 1386 { 1387 if (debug_fbsd_lwp) 1388 fprintf_unfiltered (gdb_stdlog, 1389 "FLWP: adding thread for LWP %u\n", 1390 pl.pl_lwpid); 1391 add_thread (wptid); 1392 } 1393 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 1394 return wptid; 1395 } 1396 #endif 1397 1398 #ifdef TDP_RFPPWAIT 1399 if (pl.pl_flags & PL_FLAG_FORKED) 1400 { 1401 #ifndef PTRACE_VFORK 1402 struct kinfo_proc kp; 1403 #endif 1404 ptid_t child_ptid; 1405 pid_t child; 1406 1407 child = pl.pl_child_pid; 1408 ourstatus->kind = TARGET_WAITKIND_FORKED; 1409 #ifdef PTRACE_VFORK 1410 if (pl.pl_flags & PL_FLAG_VFORKED) 1411 ourstatus->kind = TARGET_WAITKIND_VFORKED; 1412 #endif 1413 1414 /* Make sure the other end of the fork is stopped too. */ 1415 child_ptid = fbsd_is_child_pending (child); 1416 if (child_ptid == null_ptid) 1417 { 1418 pid = waitpid (child, &status, 0); 1419 if (pid == -1) 1420 perror_with_name (("waitpid")); 1421 1422 gdb_assert (pid == child); 1423 1424 if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1) 1425 perror_with_name (("ptrace")); 1426 1427 gdb_assert (pl.pl_flags & PL_FLAG_CHILD); 1428 child_ptid = ptid_t (child, pl.pl_lwpid, 0); 1429 } 1430 1431 /* Enable additional events on the child process. */ 1432 fbsd_enable_proc_events (child_ptid.pid ()); 1433 1434 #ifndef PTRACE_VFORK 1435 /* For vfork, the child process will have the P_PPWAIT 1436 flag set. */ 1437 if (fbsd_fetch_kinfo_proc (child, &kp)) 1438 { 1439 if (kp.ki_flag & P_PPWAIT) 1440 ourstatus->kind = TARGET_WAITKIND_VFORKED; 1441 } 1442 else 1443 warning (_("Failed to fetch process information")); 1444 #endif 1445 ourstatus->value.related_pid = child_ptid; 1446 1447 return wptid; 1448 } 1449 1450 if (pl.pl_flags & PL_FLAG_CHILD) 1451 { 1452 /* Remember that this child forked, but do not report it 1453 until the parent reports its corresponding fork 1454 event. */ 1455 fbsd_remember_child (wptid); 1456 continue; 1457 } 1458 1459 #ifdef PTRACE_VFORK 1460 if (pl.pl_flags & PL_FLAG_VFORK_DONE) 1461 { 1462 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE; 1463 return wptid; 1464 } 1465 #endif 1466 #endif 1467 1468 #ifdef PL_FLAG_EXEC 1469 if (pl.pl_flags & PL_FLAG_EXEC) 1470 { 1471 ourstatus->kind = TARGET_WAITKIND_EXECD; 1472 ourstatus->value.execd_pathname 1473 = xstrdup (pid_to_exec_file (pid)); 1474 return wptid; 1475 } 1476 #endif 1477 1478 #ifdef USE_SIGTRAP_SIGINFO 1479 if (fbsd_handle_debug_trap (wptid, pl)) 1480 return wptid; 1481 #endif 1482 1483 /* Note that PL_FLAG_SCE is set for any event reported while 1484 a thread is executing a system call in the kernel. In 1485 particular, signals that interrupt a sleep in a system 1486 call will report this flag as part of their event. Stops 1487 explicitly for system call entry and exit always use 1488 SIGTRAP, so only treat SIGTRAP events as system call 1489 entry/exit events. */ 1490 if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX) 1491 && ourstatus->value.sig == SIGTRAP) 1492 { 1493 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE 1494 if (catch_syscall_enabled ()) 1495 { 1496 if (catching_syscall_number (pl.pl_syscall_code)) 1497 { 1498 if (pl.pl_flags & PL_FLAG_SCE) 1499 ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY; 1500 else 1501 ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN; 1502 ourstatus->value.syscall_number = pl.pl_syscall_code; 1503 return wptid; 1504 } 1505 } 1506 #endif 1507 /* If the core isn't interested in this event, just 1508 continue the process explicitly and wait for another 1509 event. Note that PT_SYSCALL is "sticky" on FreeBSD 1510 and once system call stops are enabled on a process 1511 it stops for all system call entries and exits. */ 1512 if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1) 1513 perror_with_name (("ptrace")); 1514 continue; 1515 } 1516 } 1517 return wptid; 1518 } 1519 } 1520 1521 #ifdef USE_SIGTRAP_SIGINFO 1522 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */ 1523 1524 bool 1525 fbsd_nat_target::stopped_by_sw_breakpoint () 1526 { 1527 struct ptrace_lwpinfo pl; 1528 1529 if (ptrace (PT_LWPINFO, get_ptrace_pid (inferior_ptid), (caddr_t) &pl, 1530 sizeof pl) == -1) 1531 return false; 1532 1533 return (pl.pl_flags == PL_FLAG_SI 1534 && pl.pl_siginfo.si_signo == SIGTRAP 1535 && pl.pl_siginfo.si_code == TRAP_BRKPT); 1536 } 1537 1538 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops 1539 method. */ 1540 1541 bool 1542 fbsd_nat_target::supports_stopped_by_sw_breakpoint () 1543 { 1544 return true; 1545 } 1546 #endif 1547 1548 #ifdef TDP_RFPPWAIT 1549 /* Target hook for follow_fork. On entry and at return inferior_ptid is 1550 the ptid of the followed inferior. */ 1551 1552 int 1553 fbsd_nat_target::follow_fork (int follow_child, int detach_fork) 1554 { 1555 if (!follow_child && detach_fork) 1556 { 1557 struct thread_info *tp = inferior_thread (); 1558 pid_t child_pid = tp->pending_follow.value.related_pid.pid (); 1559 1560 /* Breakpoints have already been detached from the child by 1561 infrun.c. */ 1562 1563 if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1) 1564 perror_with_name (("ptrace")); 1565 1566 #ifndef PTRACE_VFORK 1567 if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED) 1568 { 1569 /* We can't insert breakpoints until the child process has 1570 finished with the shared memory region. The parent 1571 process doesn't wait for the child process to exit or 1572 exec until after it has been resumed from the ptrace stop 1573 to report the fork. Once it has been resumed it doesn't 1574 stop again before returning to userland, so there is no 1575 reliable way to wait on the parent. 1576 1577 We can't stay attached to the child to wait for an exec 1578 or exit because it may invoke ptrace(PT_TRACE_ME) 1579 (e.g. if the parent process is a debugger forking a new 1580 child process). 1581 1582 In the end, the best we can do is to make sure it runs 1583 for a little while. Hopefully it will be out of range of 1584 any breakpoints we reinsert. Usually this is only the 1585 single-step breakpoint at vfork's return point. */ 1586 1587 usleep (10000); 1588 1589 /* Schedule a fake VFORK_DONE event to report on the next 1590 wait. */ 1591 fbsd_add_vfork_done (inferior_ptid); 1592 } 1593 #endif 1594 } 1595 1596 return 0; 1597 } 1598 1599 int 1600 fbsd_nat_target::insert_fork_catchpoint (int pid) 1601 { 1602 return 0; 1603 } 1604 1605 int 1606 fbsd_nat_target::remove_fork_catchpoint (int pid) 1607 { 1608 return 0; 1609 } 1610 1611 int 1612 fbsd_nat_target::insert_vfork_catchpoint (int pid) 1613 { 1614 return 0; 1615 } 1616 1617 int 1618 fbsd_nat_target::remove_vfork_catchpoint (int pid) 1619 { 1620 return 0; 1621 } 1622 #endif 1623 1624 /* Implement the "post_startup_inferior" target_ops method. */ 1625 1626 void 1627 fbsd_nat_target::post_startup_inferior (ptid_t pid) 1628 { 1629 fbsd_enable_proc_events (pid.pid ()); 1630 } 1631 1632 /* Implement the "post_attach" target_ops method. */ 1633 1634 void 1635 fbsd_nat_target::post_attach (int pid) 1636 { 1637 fbsd_enable_proc_events (pid); 1638 fbsd_add_threads (pid); 1639 } 1640 1641 #ifdef PL_FLAG_EXEC 1642 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes 1643 will always stop after exec. */ 1644 1645 int 1646 fbsd_nat_target::insert_exec_catchpoint (int pid) 1647 { 1648 return 0; 1649 } 1650 1651 int 1652 fbsd_nat_target::remove_exec_catchpoint (int pid) 1653 { 1654 return 0; 1655 } 1656 #endif 1657 1658 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE 1659 int 1660 fbsd_nat_target::set_syscall_catchpoint (int pid, bool needed, 1661 int any_count, 1662 gdb::array_view<const int> syscall_counts) 1663 { 1664 1665 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which 1666 will catch all system call entries and exits. The system calls 1667 are filtered by GDB rather than the kernel. */ 1668 return 0; 1669 } 1670 #endif 1671 #endif 1672 1673 void 1674 _initialize_fbsd_nat (void) 1675 { 1676 #ifdef PT_LWPINFO 1677 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance, 1678 &debug_fbsd_lwp, _("\ 1679 Set debugging of FreeBSD lwp module."), _("\ 1680 Show debugging of FreeBSD lwp module."), _("\ 1681 Enables printf debugging output."), 1682 NULL, 1683 &show_fbsd_lwp_debug, 1684 &setdebuglist, &showdebuglist); 1685 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance, 1686 &debug_fbsd_nat, _("\ 1687 Set debugging of FreeBSD native target."), _("\ 1688 Show debugging of FreeBSD native target."), _("\ 1689 Enables printf debugging output."), 1690 NULL, 1691 &show_fbsd_nat_debug, 1692 &setdebuglist, &showdebuglist); 1693 #endif 1694 } 1695