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