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       struct thread_info *tp;
1162       int request;
1163
1164       ALL_NON_EXITED_THREADS (tp)
1165         {
1166           if (tp->ptid.pid () != ptid.pid ())
1167             continue;
1168
1169           if (tp->ptid.lwp () == ptid.lwp ())
1170             request = PT_RESUME;
1171           else
1172             request = PT_SUSPEND;
1173
1174           if (ptrace (request, tp->ptid.lwp (), NULL, 0) == -1)
1175             perror_with_name (("ptrace"));
1176         }
1177     }
1178   else
1179     {
1180       /* If ptid is a wildcard, resume all matching threads (they won't run
1181          until the process is continued however).  */
1182       struct thread_info *tp;
1183
1184       ALL_NON_EXITED_THREADS (tp)
1185         {
1186           if (!tp->ptid.matches (ptid))
1187             continue;
1188
1189           if (ptrace (PT_RESUME, tp->ptid.lwp (), NULL, 0) == -1)
1190             perror_with_name (("ptrace"));
1191         }
1192       ptid = inferior_ptid;
1193     }
1194
1195 #if __FreeBSD_version < 1200052
1196   /* When multiple threads within a process wish to report STOPPED
1197      events from wait(), the kernel picks one thread event as the
1198      thread event to report.  The chosen thread event is retrieved via
1199      PT_LWPINFO by passing the process ID as the request pid.  If
1200      multiple events are pending, then the subsequent wait() after
1201      resuming a process will report another STOPPED event after
1202      resuming the process to handle the next thread event and so on.
1203
1204      A single thread event is cleared as a side effect of resuming the
1205      process with PT_CONTINUE, PT_STEP, etc.  In older kernels,
1206      however, the request pid was used to select which thread's event
1207      was cleared rather than always clearing the event that was just
1208      reported.  To avoid clearing the event of the wrong LWP, always
1209      pass the process ID instead of an LWP ID to PT_CONTINUE or
1210      PT_SYSCALL.
1211
1212      In the case of stepping, the process ID cannot be used with
1213      PT_STEP since it would step the thread that reported an event
1214      which may not be the thread indicated by PTID.  For stepping, use
1215      PT_SETSTEP to enable stepping on the desired thread before
1216      resuming the process via PT_CONTINUE instead of using
1217      PT_STEP.  */
1218   if (step)
1219     {
1220       if (ptrace (PT_SETSTEP, get_ptrace_pid (ptid), NULL, 0) == -1)
1221         perror_with_name (("ptrace"));
1222       step = 0;
1223     }
1224   ptid = ptid_t (ptid.pid ());
1225 #endif
1226   inf_ptrace_target::resume (ptid, step, signo);
1227 }
1228
1229 #ifdef USE_SIGTRAP_SIGINFO
1230 /* Handle breakpoint and trace traps reported via SIGTRAP.  If the
1231    trap was a breakpoint or trace trap that should be reported to the
1232    core, return true.  */
1233
1234 static bool
1235 fbsd_handle_debug_trap (ptid_t ptid, const struct ptrace_lwpinfo &pl)
1236 {
1237
1238   /* Ignore traps without valid siginfo or for signals other than
1239      SIGTRAP.  */
1240   if (! (pl.pl_flags & PL_FLAG_SI) || pl.pl_siginfo.si_signo != SIGTRAP)
1241     return false;
1242
1243   /* Trace traps are either a single step or a hardware watchpoint or
1244      breakpoint.  */
1245   if (pl.pl_siginfo.si_code == TRAP_TRACE)
1246     {
1247       if (debug_fbsd_nat)
1248         fprintf_unfiltered (gdb_stdlog,
1249                             "FNAT: trace trap for LWP %ld\n", ptid.lwp ());
1250       return true;
1251     }
1252
1253   if (pl.pl_siginfo.si_code == TRAP_BRKPT)
1254     {
1255       /* Fixup PC for the software breakpoint.  */
1256       struct regcache *regcache = get_thread_regcache (ptid);
1257       struct gdbarch *gdbarch = regcache->arch ();
1258       int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
1259
1260       if (debug_fbsd_nat)
1261         fprintf_unfiltered (gdb_stdlog,
1262                             "FNAT: sw breakpoint trap for LWP %ld\n",
1263                             ptid.lwp ());
1264       if (decr_pc != 0)
1265         {
1266           CORE_ADDR pc;
1267
1268           pc = regcache_read_pc (regcache);
1269           regcache_write_pc (regcache, pc - decr_pc);
1270         }
1271       return true;
1272     }
1273
1274   return false;
1275 }
1276 #endif
1277
1278 /* Wait for the child specified by PTID to do something.  Return the
1279    process ID of the child, or MINUS_ONE_PTID in case of error; store
1280    the status in *OURSTATUS.  */
1281
1282 ptid_t
1283 fbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
1284                        int target_options)
1285 {
1286   ptid_t wptid;
1287
1288   while (1)
1289     {
1290 #ifndef PTRACE_VFORK
1291       wptid = fbsd_next_vfork_done ();
1292       if (wptid != null_ptid)
1293         {
1294           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
1295           return wptid;
1296         }
1297 #endif
1298       wptid = inf_ptrace_target::wait (ptid, ourstatus, target_options);
1299       if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
1300         {
1301           struct ptrace_lwpinfo pl;
1302           pid_t pid;
1303           int status;
1304
1305           pid = wptid.pid ();
1306           if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
1307             perror_with_name (("ptrace"));
1308
1309           wptid = ptid_t (pid, pl.pl_lwpid, 0);
1310
1311           if (debug_fbsd_nat)
1312             {
1313               fprintf_unfiltered (gdb_stdlog,
1314                                   "FNAT: stop for LWP %u event %d flags %#x\n",
1315                                   pl.pl_lwpid, pl.pl_event, pl.pl_flags);
1316               if (pl.pl_flags & PL_FLAG_SI)
1317                 fprintf_unfiltered (gdb_stdlog,
1318                                     "FNAT: si_signo %u si_code %u\n",
1319                                     pl.pl_siginfo.si_signo,
1320                                     pl.pl_siginfo.si_code);
1321             }
1322
1323 #ifdef PT_LWP_EVENTS
1324           if (pl.pl_flags & PL_FLAG_EXITED)
1325             {
1326               /* If GDB attaches to a multi-threaded process, exiting
1327                  threads might be skipped during post_attach that
1328                  have not yet reported their PL_FLAG_EXITED event.
1329                  Ignore EXITED events for an unknown LWP.  */
1330               thread_info *thr = find_thread_ptid (wptid);
1331               if (thr != nullptr)
1332                 {
1333                   if (debug_fbsd_lwp)
1334                     fprintf_unfiltered (gdb_stdlog,
1335                                         "FLWP: deleting thread for LWP %u\n",
1336                                         pl.pl_lwpid);
1337                   if (print_thread_events)
1338                     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
1339                                        (wptid));
1340                   delete_thread (thr);
1341                 }
1342               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
1343                 perror_with_name (("ptrace"));
1344               continue;
1345             }
1346 #endif
1347
1348           /* Switch to an LWP PTID on the first stop in a new process.
1349              This is done after handling PL_FLAG_EXITED to avoid
1350              switching to an exited LWP.  It is done before checking
1351              PL_FLAG_BORN in case the first stop reported after
1352              attaching to an existing process is a PL_FLAG_BORN
1353              event.  */
1354           if (in_thread_list (ptid_t (pid)))
1355             {
1356               if (debug_fbsd_lwp)
1357                 fprintf_unfiltered (gdb_stdlog,
1358                                     "FLWP: using LWP %u for first thread\n",
1359                                     pl.pl_lwpid);
1360               thread_change_ptid (ptid_t (pid), wptid);
1361             }
1362
1363 #ifdef PT_LWP_EVENTS
1364           if (pl.pl_flags & PL_FLAG_BORN)
1365             {
1366               /* If GDB attaches to a multi-threaded process, newborn
1367                  threads might be added by fbsd_add_threads that have
1368                  not yet reported their PL_FLAG_BORN event.  Ignore
1369                  BORN events for an already-known LWP.  */
1370               if (!in_thread_list (wptid))
1371                 {
1372                   if (debug_fbsd_lwp)
1373                     fprintf_unfiltered (gdb_stdlog,
1374                                         "FLWP: adding thread for LWP %u\n",
1375                                         pl.pl_lwpid);
1376                   add_thread (wptid);
1377                 }
1378               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1379               return wptid;
1380             }
1381 #endif
1382
1383 #ifdef TDP_RFPPWAIT
1384           if (pl.pl_flags & PL_FLAG_FORKED)
1385             {
1386 #ifndef PTRACE_VFORK
1387               struct kinfo_proc kp;
1388 #endif
1389               ptid_t child_ptid;
1390               pid_t child;
1391
1392               child = pl.pl_child_pid;
1393               ourstatus->kind = TARGET_WAITKIND_FORKED;
1394 #ifdef PTRACE_VFORK
1395               if (pl.pl_flags & PL_FLAG_VFORKED)
1396                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1397 #endif
1398
1399               /* Make sure the other end of the fork is stopped too.  */
1400               child_ptid = fbsd_is_child_pending (child);
1401               if (child_ptid == null_ptid)
1402                 {
1403                   pid = waitpid (child, &status, 0);
1404                   if (pid == -1)
1405                     perror_with_name (("waitpid"));
1406
1407                   gdb_assert (pid == child);
1408
1409                   if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
1410                     perror_with_name (("ptrace"));
1411
1412                   gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
1413                   child_ptid = ptid_t (child, pl.pl_lwpid, 0);
1414                 }
1415
1416               /* Enable additional events on the child process.  */
1417               fbsd_enable_proc_events (child_ptid.pid ());
1418
1419 #ifndef PTRACE_VFORK
1420               /* For vfork, the child process will have the P_PPWAIT
1421                  flag set.  */
1422               if (fbsd_fetch_kinfo_proc (child, &kp))
1423                 {
1424                   if (kp.ki_flag & P_PPWAIT)
1425                     ourstatus->kind = TARGET_WAITKIND_VFORKED;
1426                 }
1427               else
1428                 warning (_("Failed to fetch process information"));
1429 #endif
1430               ourstatus->value.related_pid = child_ptid;
1431
1432               return wptid;
1433             }
1434
1435           if (pl.pl_flags & PL_FLAG_CHILD)
1436             {
1437               /* Remember that this child forked, but do not report it
1438                  until the parent reports its corresponding fork
1439                  event.  */
1440               fbsd_remember_child (wptid);
1441               continue;
1442             }
1443
1444 #ifdef PTRACE_VFORK
1445           if (pl.pl_flags & PL_FLAG_VFORK_DONE)
1446             {
1447               ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
1448               return wptid;
1449             }
1450 #endif
1451 #endif
1452
1453 #ifdef PL_FLAG_EXEC
1454           if (pl.pl_flags & PL_FLAG_EXEC)
1455             {
1456               ourstatus->kind = TARGET_WAITKIND_EXECD;
1457               ourstatus->value.execd_pathname
1458                 = xstrdup (pid_to_exec_file (pid));
1459               return wptid;
1460             }
1461 #endif
1462
1463 #ifdef USE_SIGTRAP_SIGINFO
1464           if (fbsd_handle_debug_trap (wptid, pl))
1465             return wptid;
1466 #endif
1467
1468           /* Note that PL_FLAG_SCE is set for any event reported while
1469              a thread is executing a system call in the kernel.  In
1470              particular, signals that interrupt a sleep in a system
1471              call will report this flag as part of their event.  Stops
1472              explicitly for system call entry and exit always use
1473              SIGTRAP, so only treat SIGTRAP events as system call
1474              entry/exit events.  */
1475           if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
1476               && ourstatus->value.sig == SIGTRAP)
1477             {
1478 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1479               if (catch_syscall_enabled ())
1480                 {
1481                   if (catching_syscall_number (pl.pl_syscall_code))
1482                     {
1483                       if (pl.pl_flags & PL_FLAG_SCE)
1484                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1485                       else
1486                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1487                       ourstatus->value.syscall_number = pl.pl_syscall_code;
1488                       return wptid;
1489                     }
1490                 }
1491 #endif
1492               /* If the core isn't interested in this event, just
1493                  continue the process explicitly and wait for another
1494                  event.  Note that PT_SYSCALL is "sticky" on FreeBSD
1495                  and once system call stops are enabled on a process
1496                  it stops for all system call entries and exits.  */
1497               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
1498                 perror_with_name (("ptrace"));
1499               continue;
1500             }
1501         }
1502       return wptid;
1503     }
1504 }
1505
1506 #ifdef USE_SIGTRAP_SIGINFO
1507 /* Implement the "stopped_by_sw_breakpoint" target_ops method.  */
1508
1509 bool
1510 fbsd_nat_target::stopped_by_sw_breakpoint ()
1511 {
1512   struct ptrace_lwpinfo pl;
1513
1514   if (ptrace (PT_LWPINFO, get_ptrace_pid (inferior_ptid), (caddr_t) &pl,
1515               sizeof pl) == -1)
1516     return false;
1517
1518   return ((pl.pl_flags & PL_FLAG_SI)
1519           && pl.pl_siginfo.si_signo == SIGTRAP
1520           && pl.pl_siginfo.si_code == TRAP_BRKPT);
1521 }
1522
1523 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1524    method.  */
1525
1526 bool
1527 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1528 {
1529   return true;
1530 }
1531 #endif
1532
1533 #ifdef TDP_RFPPWAIT
1534 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
1535    the ptid of the followed inferior.  */
1536
1537 int
1538 fbsd_nat_target::follow_fork (int follow_child, int detach_fork)
1539 {
1540   if (!follow_child && detach_fork)
1541     {
1542       struct thread_info *tp = inferior_thread ();
1543       pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
1544
1545       /* Breakpoints have already been detached from the child by
1546          infrun.c.  */
1547
1548       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
1549         perror_with_name (("ptrace"));
1550
1551 #ifndef PTRACE_VFORK
1552       if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
1553         {
1554           /* We can't insert breakpoints until the child process has
1555              finished with the shared memory region.  The parent
1556              process doesn't wait for the child process to exit or
1557              exec until after it has been resumed from the ptrace stop
1558              to report the fork.  Once it has been resumed it doesn't
1559              stop again before returning to userland, so there is no
1560              reliable way to wait on the parent.
1561
1562              We can't stay attached to the child to wait for an exec
1563              or exit because it may invoke ptrace(PT_TRACE_ME)
1564              (e.g. if the parent process is a debugger forking a new
1565              child process).
1566
1567              In the end, the best we can do is to make sure it runs
1568              for a little while.  Hopefully it will be out of range of
1569              any breakpoints we reinsert.  Usually this is only the
1570              single-step breakpoint at vfork's return point.  */
1571
1572           usleep (10000);
1573
1574           /* Schedule a fake VFORK_DONE event to report on the next
1575              wait.  */
1576           fbsd_add_vfork_done (inferior_ptid);
1577         }
1578 #endif
1579     }
1580
1581   return 0;
1582 }
1583
1584 int
1585 fbsd_nat_target::insert_fork_catchpoint (int pid)
1586 {
1587   return 0;
1588 }
1589
1590 int
1591 fbsd_nat_target::remove_fork_catchpoint (int pid)
1592 {
1593   return 0;
1594 }
1595
1596 int
1597 fbsd_nat_target::insert_vfork_catchpoint (int pid)
1598 {
1599   return 0;
1600 }
1601
1602 int
1603 fbsd_nat_target::remove_vfork_catchpoint (int pid)
1604 {
1605   return 0;
1606 }
1607 #endif
1608
1609 /* Implement the "post_startup_inferior" target_ops method.  */
1610
1611 void
1612 fbsd_nat_target::post_startup_inferior (ptid_t pid)
1613 {
1614   fbsd_enable_proc_events (pid.pid ());
1615 }
1616
1617 /* Implement the "post_attach" target_ops method.  */
1618
1619 void
1620 fbsd_nat_target::post_attach (int pid)
1621 {
1622   fbsd_enable_proc_events (pid);
1623   fbsd_add_threads (pid);
1624 }
1625
1626 #ifdef PL_FLAG_EXEC
1627 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1628    will always stop after exec.  */
1629
1630 int
1631 fbsd_nat_target::insert_exec_catchpoint (int pid)
1632 {
1633   return 0;
1634 }
1635
1636 int
1637 fbsd_nat_target::remove_exec_catchpoint (int pid)
1638 {
1639   return 0;
1640 }
1641 #endif
1642
1643 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1644 int
1645 fbsd_nat_target::set_syscall_catchpoint (int pid, bool needed,
1646                                          int any_count,
1647                                          gdb::array_view<const int> syscall_counts)
1648 {
1649
1650   /* Ignore the arguments.  inf-ptrace.c will use PT_SYSCALL which
1651      will catch all system call entries and exits.  The system calls
1652      are filtered by GDB rather than the kernel.  */
1653   return 0;
1654 }
1655 #endif
1656 #endif
1657
1658 void
1659 _initialize_fbsd_nat (void)
1660 {
1661 #ifdef PT_LWPINFO
1662   add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
1663                            &debug_fbsd_lwp, _("\
1664 Set debugging of FreeBSD lwp module."), _("\
1665 Show debugging of FreeBSD lwp module."), _("\
1666 Enables printf debugging output."),
1667                            NULL,
1668                            &show_fbsd_lwp_debug,
1669                            &setdebuglist, &showdebuglist);
1670   add_setshow_boolean_cmd ("fbsd-nat", class_maintenance,
1671                            &debug_fbsd_nat, _("\
1672 Set debugging of FreeBSD native target."), _("\
1673 Show debugging of FreeBSD native target."), _("\
1674 Enables printf debugging output."),
1675                            NULL,
1676                            &show_fbsd_nat_debug,
1677                            &setdebuglist, &showdebuglist);
1678 #endif
1679 }