gdb/fbsd-nat.c

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