gdb/fbsd-nat.c

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