gdb/fbsd-nat.c

   1 /* Native-dependent code for FreeBSD.
   2
   3    Copyright (C) 2002-2017 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 <sys/types.h>
  30 #include <sys/procfs.h>
  31 #include <sys/ptrace.h>
  32 #include <sys/signal.h>
  33 #include <sys/sysctl.h>
  34 #include <sys/user.h>
  35 #ifdef HAVE_KINFO_GETVMMAP
  36 #include <libutil.h>
  37 #else
  38 #include "filestuff.h"
  39 #endif
  40
  41 #include "elf-bfd.h"
  42 #include "fbsd-nat.h"
  43
  44 #include <list>
  45
  46 /* Return the name of a file that can be opened to get the symbols for
  47    the child process identified by PID.  */
  48
  49 static char *
  50 fbsd_pid_to_exec_file (struct target_ops *self, int pid)
  51 {
  52   ssize_t len;
  53   static char buf[PATH_MAX];
  54   char name[PATH_MAX];
  55
  56 #ifdef KERN_PROC_PATHNAME
  57   size_t buflen;
  58   int mib[4];
  59
  60   mib[0] = CTL_KERN;
  61   mib[1] = KERN_PROC;
  62   mib[2] = KERN_PROC_PATHNAME;
  63   mib[3] = pid;
  64   buflen = sizeof buf;
  65   if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
  66     return buf;
  67 #endif
  68
  69   xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
  70   len = readlink (name, buf, PATH_MAX - 1);
  71   if (len != -1)
  72     {
  73       buf[len] = '\0';
  74       return buf;
  75     }
  76
  77   return NULL;
  78 }
  79
  80 #ifdef HAVE_KINFO_GETVMMAP
  81 /* Deleter for std::unique_ptr that invokes free.  */
  82
  83 template <typename T>
  84 struct free_deleter
  85 {
  86   void operator() (T *ptr) const { free (ptr); }
  87 };
  88
  89 /* Iterate over all the memory regions in the current inferior,
  90    calling FUNC for each memory region.  OBFD is passed as the last
  91    argument to FUNC.  */
  92
  93 static int
  94 fbsd_find_memory_regions (struct target_ops *self,
  95                           find_memory_region_ftype func, void *obfd)
  96 {
  97   pid_t pid = ptid_get_pid (inferior_ptid);
  98   struct kinfo_vmentry *kve;
  99   uint64_t size;
 100   int i, nitems;
 101
 102   std::unique_ptr<struct kinfo_vmentry, free_deleter<struct kinfo_vmentry>>
 103     vmentl (kinfo_getvmmap (pid, &nitems));
 104   if (vmentl == NULL)
 105     perror_with_name (_("Couldn't fetch VM map entries."));
 106
 107   for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++)
 108     {
 109       /* Skip unreadable segments and those where MAP_NOCORE has been set.  */
 110       if (!(kve->kve_protection & KVME_PROT_READ)
 111           || kve->kve_flags & KVME_FLAG_NOCOREDUMP)
 112         continue;
 113
 114       /* Skip segments with an invalid type.  */
 115       if (kve->kve_type != KVME_TYPE_DEFAULT
 116           && kve->kve_type != KVME_TYPE_VNODE
 117           && kve->kve_type != KVME_TYPE_SWAP
 118           && kve->kve_type != KVME_TYPE_PHYS)
 119         continue;
 120
 121       size = kve->kve_end - kve->kve_start;
 122       if (info_verbose)
 123         {
 124           fprintf_filtered (gdb_stdout,
 125                             "Save segment, %ld bytes at %s (%c%c%c)\n",
 126                             (long) size,
 127                             paddress (target_gdbarch (), kve->kve_start),
 128                             kve->kve_protection & KVME_PROT_READ ? 'r' : '-',
 129                             kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-',
 130                             kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-');
 131         }
 132
 133       /* Invoke the callback function to create the corefile segment.
 134          Pass MODIFIED as true, we do not know the real modification state.  */
 135       func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ,
 136             kve->kve_protection & KVME_PROT_WRITE,
 137             kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
 138     }
 139   return 0;
 140 }
 141 #else
 142 static int
 143 fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end,
 144                    char *protection)
 145 {
 146   /* FreeBSD 5.1-RELEASE uses a 256-byte buffer.  */
 147   char buf[256];
 148   int resident, privateresident;
 149   unsigned long obj;
 150   int ret = EOF;
 151
 152   /* As of FreeBSD 5.0-RELEASE, the layout is described in
 153      /usr/src/sys/fs/procfs/procfs_map.c.  Somewhere in 5.1-CURRENT a
 154      new column was added to the procfs map.  Therefore we can't use
 155      fscanf since we need to support older releases too.  */
 156   if (fgets (buf, sizeof buf, mapfile) != NULL)
 157     ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end,
 158                   &resident, &privateresident, &obj, protection);
 159
 160   return (ret != 0 && ret != EOF);
 161 }
 162
 163 /* Iterate over all the memory regions in the current inferior,
 164    calling FUNC for each memory region.  OBFD is passed as the last
 165    argument to FUNC.  */
 166
 167 static int
 168 fbsd_find_memory_regions (struct target_ops *self,
 169                           find_memory_region_ftype func, void *obfd)
 170 {
 171   pid_t pid = ptid_get_pid (inferior_ptid);
 172   unsigned long start, end, size;
 173   char protection[4];
 174   int read, write, exec;
 175
 176   std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid);
 177   gdb_file_up mapfile (fopen (mapfilename.c_str (), "r"));
 178   if (mapfile == NULL)
 179     error (_("Couldn't open %s."), mapfilename.c_str ());
 180
 181   if (info_verbose)
 182     fprintf_filtered (gdb_stdout,
 183                       "Reading memory regions from %s\n", mapfilename.c_str ());
 184
 185   /* Now iterate until end-of-file.  */
 186   while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0]))
 187     {
 188       size = end - start;
 189
 190       read = (strchr (protection, 'r') != 0);
 191       write = (strchr (protection, 'w') != 0);
 192       exec = (strchr (protection, 'x') != 0);
 193
 194       if (info_verbose)
 195         {
 196           fprintf_filtered (gdb_stdout,
 197                             "Save segment, %ld bytes at %s (%c%c%c)\n",
 198                             size, paddress (target_gdbarch (), start),
 199                             read ? 'r' : '-',
 200                             write ? 'w' : '-',
 201                             exec ? 'x' : '-');
 202         }
 203
 204       /* Invoke the callback function to create the corefile segment.
 205          Pass MODIFIED as true, we do not know the real modification state.  */
 206       func (start, size, read, write, exec, 1, obfd);
 207     }
 208
 209   return 0;
 210 }
 211 #endif
 212
 213 #ifdef KERN_PROC_AUXV
 214 static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
 215                                                       enum target_object object,
 216                                                       const char *annex,
 217                                                       gdb_byte *readbuf,
 218                                                       const gdb_byte *writebuf,
 219                                                       ULONGEST offset,
 220                                                       ULONGEST len,
 221                                                       ULONGEST *xfered_len);
 222
 223 #ifdef PT_LWPINFO
 224 /* Return the size of siginfo for the current inferior.  */
 225
 226 #ifdef __LP64__
 227 union sigval32 {
 228   int sival_int;
 229   uint32_t sival_ptr;
 230 };
 231
 232 /* This structure matches the naming and layout of `siginfo_t' in
 233    <sys/signal.h>.  In particular, the `si_foo' macros defined in that
 234    header can be used with both types to copy fields in the `_reason'
 235    union.  */
 236
 237 struct siginfo32
 238 {
 239   int si_signo;
 240   int si_errno;
 241   int si_code;
 242   __pid_t si_pid;
 243   __uid_t si_uid;
 244   int si_status;
 245   uint32_t si_addr;
 246   union sigval32 si_value;
 247   union
 248   {
 249     struct
 250     {
 251       int _trapno;
 252     } _fault;
 253     struct
 254     {
 255       int _timerid;
 256       int _overrun;
 257     } _timer;
 258     struct
 259     {
 260       int _mqd;
 261     } _mesgq;
 262     struct
 263     {
 264       int32_t _band;
 265     } _poll;
 266     struct
 267     {
 268       int32_t __spare1__;
 269       int __spare2__[7];
 270     } __spare__;
 271   } _reason;
 272 };
 273 #endif
 274
 275 static size_t
 276 fbsd_siginfo_size ()
 277 {
 278 #ifdef __LP64__
 279   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
 280
 281   /* Is the inferior 32-bit?  If so, use the 32-bit siginfo size.  */
 282   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 283     return sizeof (struct siginfo32);
 284 #endif
 285   return sizeof (siginfo_t);
 286 }
 287
 288 /* Convert a native 64-bit siginfo object to a 32-bit object.  Note
 289    that FreeBSD doesn't support writing to $_siginfo, so this only
 290    needs to convert one way.  */
 291
 292 static void
 293 fbsd_convert_siginfo (siginfo_t *si)
 294 {
 295 #ifdef __LP64__
 296   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
 297
 298   /* Is the inferior 32-bit?  If not, nothing to do.  */
 299   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 32)
 300     return;
 301
 302   struct siginfo32 si32;
 303
 304   si32.si_signo = si->si_signo;
 305   si32.si_errno = si->si_errno;
 306   si32.si_code = si->si_code;
 307   si32.si_pid = si->si_pid;
 308   si32.si_uid = si->si_uid;
 309   si32.si_status = si->si_status;
 310   si32.si_addr = (uintptr_t) si->si_addr;
 311
 312   /* If sival_ptr is being used instead of sival_int on a big-endian
 313      platform, then sival_int will be zero since it holds the upper
 314      32-bits of the pointer value.  */
 315 #if _BYTE_ORDER == _BIG_ENDIAN
 316   if (si->si_value.sival_int == 0)
 317     si32->si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
 318   else
 319     si32.si_value.sival_int = si->si_value.sival_int;
 320 #else
 321   si32.si_value.sival_int = si->si_value.sival_int;
 322 #endif
 323
 324   /* Always copy the spare fields and then possibly overwrite them for
 325      signal-specific or code-specific fields.  */
 326   si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
 327   for (int i = 0; i < 7; i++)
 328     si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
 329   switch (si->si_signo) {
 330   case SIGILL:
 331   case SIGFPE:
 332   case SIGSEGV:
 333   case SIGBUS:
 334     si32.si_trapno = si->si_trapno;
 335     break;
 336   }
 337   switch (si->si_code) {
 338   case SI_TIMER:
 339     si32.si_timerid = si->si_timerid;
 340     si32.si_overrun = si->si_overrun;
 341     break;
 342   case SI_MESGQ:
 343     si32.si_mqd = si->si_mqd;
 344     break;
 345   }
 346
 347   memcpy(si, &si32, sizeof (si32));
 348 #endif
 349 }
 350 #endif
 351
 352 /* Implement the "to_xfer_partial target_ops" method.  */
 353
 354 static enum target_xfer_status
 355 fbsd_xfer_partial (struct target_ops *ops, enum target_object object,
 356                    const char *annex, gdb_byte *readbuf,
 357                    const gdb_byte *writebuf,
 358                    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 359 {
 360   pid_t pid = ptid_get_pid (inferior_ptid);
 361
 362   switch (object)
 363     {
 364 #ifdef PT_LWPINFO
 365     case TARGET_OBJECT_SIGNAL_INFO:
 366       {
 367         struct ptrace_lwpinfo pl;
 368         size_t siginfo_size;
 369
 370         /* FreeBSD doesn't support writing to $_siginfo.  */
 371         if (writebuf != NULL)
 372           return TARGET_XFER_E_IO;
 373
 374         if (inferior_ptid.lwp_p ())
 375           pid = inferior_ptid.lwp ();
 376
 377         siginfo_size = fbsd_siginfo_size ();
 378         if (offset > siginfo_size)
 379           return TARGET_XFER_E_IO;
 380
 381         if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
 382           return TARGET_XFER_E_IO;
 383
 384         if (!(pl.pl_flags & PL_FLAG_SI))
 385           return TARGET_XFER_E_IO;
 386
 387         fbsd_convert_siginfo (&pl.pl_siginfo);
 388         if (offset + len > siginfo_size)
 389           len = siginfo_size - offset;
 390
 391         memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
 392         *xfered_len = len;
 393         return TARGET_XFER_OK;
 394       }
 395 #endif
 396     case TARGET_OBJECT_AUXV:
 397       {
 398         gdb::byte_vector buf_storage;
 399         gdb_byte *buf;
 400         size_t buflen;
 401         int mib[4];
 402
 403         if (writebuf != NULL)
 404           return TARGET_XFER_E_IO;
 405         mib[0] = CTL_KERN;
 406         mib[1] = KERN_PROC;
 407         mib[2] = KERN_PROC_AUXV;
 408         mib[3] = pid;
 409         if (offset == 0)
 410           {
 411             buf = readbuf;
 412             buflen = len;
 413           }
 414         else
 415           {
 416             buflen = offset + len;
 417             buf_storage.resize (buflen);
 418             buf = buf_storage.data ();
 419           }
 420         if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
 421           {
 422             if (offset != 0)
 423               {
 424                 if (buflen > offset)
 425                   {
 426                     buflen -= offset;
 427                     memcpy (readbuf, buf + offset, buflen);
 428                   }
 429                 else
 430                   buflen = 0;
 431               }
 432             *xfered_len = buflen;
 433             return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 434           }
 435         return TARGET_XFER_E_IO;
 436       }
 437     default:
 438       return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
 439                                  len, xfered_len);
 440     }
 441 }
 442 #endif
 443
 444 #ifdef PT_LWPINFO
 445 static int debug_fbsd_lwp;
 446
 447 static void (*super_resume) (struct target_ops *,
 448                              ptid_t,
 449                              int,
 450                              enum gdb_signal);
 451 static ptid_t (*super_wait) (struct target_ops *,
 452                              ptid_t,
 453                              struct target_waitstatus *,
 454                              int);
 455
 456 static void
 457 show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
 458                      struct cmd_list_element *c, const char *value)
 459 {
 460   fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
 461 }
 462
 463 #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
 464 /* Fetch the external variant of the kernel's internal process
 465    structure for the process PID into KP.  */
 466
 467 static void
 468 fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
 469 {
 470   size_t len;
 471   int mib[4];
 472
 473   len = sizeof *kp;
 474   mib[0] = CTL_KERN;
 475   mib[1] = KERN_PROC;
 476   mib[2] = KERN_PROC_PID;
 477   mib[3] = pid;
 478   if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)
 479     perror_with_name (("sysctl"));
 480 }
 481 #endif
 482
 483 /*
 484   FreeBSD's first thread support was via a "reentrant" version of libc
 485   (libc_r) that first shipped in 2.2.7.  This library multiplexed all
 486   of the threads in a process onto a single kernel thread.  This
 487   library was supported via the bsd-uthread target.
 488
 489   FreeBSD 5.1 introduced two new threading libraries that made use of
 490   multiple kernel threads.  The first (libkse) scheduled M user
 491   threads onto N (<= M) kernel threads (LWPs).  The second (libthr)
 492   bound each user thread to a dedicated kernel thread.  libkse shipped
 493   as the default threading library (libpthread).
 494
 495   FreeBSD 5.3 added a libthread_db to abstract the interface across
 496   the various thread libraries (libc_r, libkse, and libthr).
 497
 498   FreeBSD 7.0 switched the default threading library from from libkse
 499   to libpthread and removed libc_r.
 500
 501   FreeBSD 8.0 removed libkse and the in-kernel support for it.  The
 502   only threading library supported by 8.0 and later is libthr which
 503   ties each user thread directly to an LWP.  To simplify the
 504   implementation, this target only supports LWP-backed threads using
 505   ptrace directly rather than libthread_db.
 506
 507   FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
 508 */
 509
 510 /* Return true if PTID is still active in the inferior.  */
 511
 512 static int
 513 fbsd_thread_alive (struct target_ops *ops, ptid_t ptid)
 514 {
 515   if (ptid_lwp_p (ptid))
 516     {
 517       struct ptrace_lwpinfo pl;
 518
 519       if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)
 520           == -1)
 521         return 0;
 522 #ifdef PL_FLAG_EXITED
 523       if (pl.pl_flags & PL_FLAG_EXITED)
 524         return 0;
 525 #endif
 526     }
 527
 528   return 1;
 529 }
 530
 531 /* Convert PTID to a string.  Returns the string in a static
 532    buffer.  */
 533
 534 static const char *
 535 fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
 536 {
 537   lwpid_t lwp;
 538
 539   lwp = ptid_get_lwp (ptid);
 540   if (lwp != 0)
 541     {
 542       static char buf[64];
 543       int pid = ptid_get_pid (ptid);
 544
 545       xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid);
 546       return buf;
 547     }
 548
 549   return normal_pid_to_str (ptid);
 550 }
 551
 552 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
 553 /* Return the name assigned to a thread by an application.  Returns
 554    the string in a static buffer.  */
 555
 556 static const char *
 557 fbsd_thread_name (struct target_ops *self, struct thread_info *thr)
 558 {
 559   struct ptrace_lwpinfo pl;
 560   struct kinfo_proc kp;
 561   int pid = ptid_get_pid (thr->ptid);
 562   long lwp = ptid_get_lwp (thr->ptid);
 563   static char buf[sizeof pl.pl_tdname + 1];
 564
 565   /* Note that ptrace_lwpinfo returns the process command in pl_tdname
 566      if a name has not been set explicitly.  Return a NULL name in
 567      that case.  */
 568   fbsd_fetch_kinfo_proc (pid, &kp);
 569   if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
 570     perror_with_name (("ptrace"));
 571   if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
 572     return NULL;
 573   xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);
 574   return buf;
 575 }
 576 #endif
 577
 578 /* Enable additional event reporting on new processes.
 579
 580    To catch fork events, PTRACE_FORK is set on every traced process
 581    to enable stops on returns from fork or vfork.  Note that both the
 582    parent and child will always stop, even if system call stops are
 583    not enabled.
 584
 585    To catch LWP events, PTRACE_EVENTS is set on every traced process.
 586    This enables stops on the birth for new LWPs (excluding the "main" LWP)
 587    and the death of LWPs (excluding the last LWP in a process).  Note
 588    that unlike fork events, the LWP that creates a new LWP does not
 589    report an event.  */
 590
 591 static void
 592 fbsd_enable_proc_events (pid_t pid)
 593 {
 594 #ifdef PT_GET_EVENT_MASK
 595   int events;
 596
 597   if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
 598               sizeof (events)) == -1)
 599     perror_with_name (("ptrace"));
 600   events |= PTRACE_FORK | PTRACE_LWP;
 601 #ifdef PTRACE_VFORK
 602   events |= PTRACE_VFORK;
 603 #endif
 604   if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
 605               sizeof (events)) == -1)
 606     perror_with_name (("ptrace"));
 607 #else
 608 #ifdef TDP_RFPPWAIT
 609   if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 610     perror_with_name (("ptrace"));
 611 #endif
 612 #ifdef PT_LWP_EVENTS
 613   if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 614     perror_with_name (("ptrace"));
 615 #endif
 616 #endif
 617 }
 618
 619 /* Add threads for any new LWPs in a process.
 620
 621    When LWP events are used, this function is only used to detect existing
 622    threads when attaching to a process.  On older systems, this function is
 623    called to discover new threads each time the thread list is updated.  */
 624
 625 static void
 626 fbsd_add_threads (pid_t pid)
 627 {
 628   int i, nlwps;
 629
 630   gdb_assert (!in_thread_list (pid_to_ptid (pid)));
 631   nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
 632   if (nlwps == -1)
 633     perror_with_name (("ptrace"));
 634
 635   gdb::unique_xmalloc_ptr<lwpid_t> lwps (XCNEWVEC (lwpid_t, nlwps));
 636
 637   nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps);
 638   if (nlwps == -1)
 639     perror_with_name (("ptrace"));
 640
 641   for (i = 0; i < nlwps; i++)
 642     {
 643       lwpid_t lwp = lwps.get ()[i];
 644       ptid_t ptid = ptid_build (pid, lwp, 0);
 645
 646       if (!in_thread_list (ptid))
 647         {
 648 #ifdef PT_LWP_EVENTS
 649           struct ptrace_lwpinfo pl;
 650
 651           /* Don't add exited threads.  Note that this is only called
 652              when attaching to a multi-threaded process.  */
 653           if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
 654             perror_with_name (("ptrace"));
 655           if (pl.pl_flags & PL_FLAG_EXITED)
 656             continue;
 657 #endif
 658           if (debug_fbsd_lwp)
 659             fprintf_unfiltered (gdb_stdlog,
 660                                 "FLWP: adding thread for LWP %u\n",
 661                                 lwp);
 662           add_thread (ptid);
 663         }
 664     }
 665 }
 666
 667 /* Implement the "to_update_thread_list" target_ops method.  */
 668
 669 static void
 670 fbsd_update_thread_list (struct target_ops *ops)
 671 {
 672 #ifdef PT_LWP_EVENTS
 673   /* With support for thread events, threads are added/deleted from the
 674      list as events are reported, so just try deleting exited threads.  */
 675   delete_exited_threads ();
 676 #else
 677   prune_threads ();
 678
 679   fbsd_add_threads (ptid_get_pid (inferior_ptid));
 680 #endif
 681 }
 682
 683 #ifdef TDP_RFPPWAIT
 684 /*
 685   To catch fork events, PT_FOLLOW_FORK is set on every traced process
 686   to enable stops on returns from fork or vfork.  Note that both the
 687   parent and child will always stop, even if system call stops are not
 688   enabled.
 689
 690   After a fork, both the child and parent process will stop and report
 691   an event.  However, there is no guarantee of order.  If the parent
 692   reports its stop first, then fbsd_wait explicitly waits for the new
 693   child before returning.  If the child reports its stop first, then
 694   the event is saved on a list and ignored until the parent's stop is
 695   reported.  fbsd_wait could have been changed to fetch the parent PID
 696   of the new child and used that to wait for the parent explicitly.
 697   However, if two threads in the parent fork at the same time, then
 698   the wait on the parent might return the "wrong" fork event.
 699
 700   The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
 701   the new child process.  This flag could be inferred by treating any
 702   events for an unknown pid as a new child.
 703
 704   In addition, the initial version of PT_FOLLOW_FORK did not report a
 705   stop event for the parent process of a vfork until after the child
 706   process executed a new program or exited.  The kernel was changed to
 707   defer the wait for exit or exec of the child until after posting the
 708   stop event shortly after the change to introduce PL_FLAG_CHILD.
 709   This could be worked around by reporting a vfork event when the
 710   child event posted and ignoring the subsequent event from the
 711   parent.
 712
 713   This implementation requires both of these fixes for simplicity's
 714   sake.  FreeBSD versions newer than 9.1 contain both fixes.
 715 */
 716
 717 static std::list<ptid_t> fbsd_pending_children;
 718
 719 /* Record a new child process event that is reported before the
 720    corresponding fork event in the parent.  */
 721
 722 static void
 723 fbsd_remember_child (ptid_t pid)
 724 {
 725   fbsd_pending_children.push_front (pid);
 726 }
 727
 728 /* Check for a previously-recorded new child process event for PID.
 729    If one is found, remove it from the list and return the PTID.  */
 730
 731 static ptid_t
 732 fbsd_is_child_pending (pid_t pid)
 733 {
 734   for (auto it = fbsd_pending_children.begin ();
 735        it != fbsd_pending_children.end (); it++)
 736     if (it->pid () == pid)
 737       {
 738         ptid_t ptid = *it;
 739         fbsd_pending_children.erase (it);
 740         return ptid;
 741       }
 742   return null_ptid;
 743 }
 744
 745 #ifndef PTRACE_VFORK
 746 static std::forward_list<ptid_t> fbsd_pending_vfork_done;
 747
 748 /* Record a pending vfork done event.  */
 749
 750 static void
 751 fbsd_add_vfork_done (ptid_t pid)
 752 {
 753   fbsd_pending_vfork_done.push_front (pid);
 754 }
 755
 756 /* Check for a pending vfork done event for a specific PID.  */
 757
 758 static int
 759 fbsd_is_vfork_done_pending (pid_t pid)
 760 {
 761   for (auto it = fbsd_pending_vfork_done.begin ();
 762        it != fbsd_pending_vfork_done.end (); it++)
 763     if (it->pid () == pid)
 764       return 1;
 765   return 0;
 766 }
 767
 768 /* Check for a pending vfork done event.  If one is found, remove it
 769    from the list and return the PTID.  */
 770
 771 static ptid_t
 772 fbsd_next_vfork_done (void)
 773 {
 774   if (!fbsd_pending_vfork_done.empty ())
 775     {
 776       ptid_t ptid = fbsd_pending_vfork_done.front ();
 777       fbsd_pending_vfork_done.pop_front ();
 778       return ptid;
 779     }
 780   return null_ptid;
 781 }
 782 #endif
 783 #endif
 784
 785 /* Implement the "to_resume" target_ops method.  */
 786
 787 static void
 788 fbsd_resume (struct target_ops *ops,
 789              ptid_t ptid, int step, enum gdb_signal signo)
 790 {
 791 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
 792   pid_t pid;
 793
 794   /* Don't PT_CONTINUE a process which has a pending vfork done event.  */
 795   if (ptid_equal (minus_one_ptid, ptid))
 796     pid = ptid_get_pid (inferior_ptid);
 797   else
 798     pid = ptid_get_pid (ptid);
 799   if (fbsd_is_vfork_done_pending (pid))
 800     return;
 801 #endif
 802
 803   if (debug_fbsd_lwp)
 804     fprintf_unfiltered (gdb_stdlog,
 805                         "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
 806                         ptid_get_pid (ptid), ptid_get_lwp (ptid),
 807                         ptid_get_tid (ptid));
 808   if (ptid_lwp_p (ptid))
 809     {
 810       /* If ptid is a specific LWP, suspend all other LWPs in the process.  */
 811       struct thread_info *tp;
 812       int request;
 813
 814       ALL_NON_EXITED_THREADS (tp)
 815         {
 816           if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid))
 817             continue;
 818
 819           if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid))
 820             request = PT_RESUME;
 821           else
 822             request = PT_SUSPEND;
 823
 824           if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 825             perror_with_name (("ptrace"));
 826         }
 827     }
 828   else
 829     {
 830       /* If ptid is a wildcard, resume all matching threads (they won't run
 831          until the process is continued however).  */
 832       struct thread_info *tp;
 833
 834       ALL_NON_EXITED_THREADS (tp)
 835         {
 836           if (!ptid_match (tp->ptid, ptid))
 837             continue;
 838
 839           if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 840             perror_with_name (("ptrace"));
 841         }
 842       ptid = inferior_ptid;
 843     }
 844   super_resume (ops, ptid, step, signo);
 845 }
 846
 847 /* Wait for the child specified by PTID to do something.  Return the
 848    process ID of the child, or MINUS_ONE_PTID in case of error; store
 849    the status in *OURSTATUS.  */
 850
 851 static ptid_t
 852 fbsd_wait (struct target_ops *ops,
 853            ptid_t ptid, struct target_waitstatus *ourstatus,
 854            int target_options)
 855 {
 856   ptid_t wptid;
 857
 858   while (1)
 859     {
 860 #ifndef PTRACE_VFORK
 861       wptid = fbsd_next_vfork_done ();
 862       if (!ptid_equal (wptid, null_ptid))
 863         {
 864           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
 865           return wptid;
 866         }
 867 #endif
 868       wptid = super_wait (ops, ptid, ourstatus, target_options);
 869       if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
 870         {
 871           struct ptrace_lwpinfo pl;
 872           pid_t pid;
 873           int status;
 874
 875           pid = ptid_get_pid (wptid);
 876           if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
 877             perror_with_name (("ptrace"));
 878
 879           wptid = ptid_build (pid, pl.pl_lwpid, 0);
 880
 881 #ifdef PT_LWP_EVENTS
 882           if (pl.pl_flags & PL_FLAG_EXITED)
 883             {
 884               /* If GDB attaches to a multi-threaded process, exiting
 885                  threads might be skipped during fbsd_post_attach that
 886                  have not yet reported their PL_FLAG_EXITED event.
 887                  Ignore EXITED events for an unknown LWP.  */
 888               if (in_thread_list (wptid))
 889                 {
 890                   if (debug_fbsd_lwp)
 891                     fprintf_unfiltered (gdb_stdlog,
 892                                         "FLWP: deleting thread for LWP %u\n",
 893                                         pl.pl_lwpid);
 894                   if (print_thread_events)
 895                     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
 896                                        (wptid));
 897                   delete_thread (wptid);
 898                 }
 899               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
 900                 perror_with_name (("ptrace"));
 901               continue;
 902             }
 903 #endif
 904
 905           /* Switch to an LWP PTID on the first stop in a new process.
 906              This is done after handling PL_FLAG_EXITED to avoid
 907              switching to an exited LWP.  It is done before checking
 908              PL_FLAG_BORN in case the first stop reported after
 909              attaching to an existing process is a PL_FLAG_BORN
 910              event.  */
 911           if (in_thread_list (pid_to_ptid (pid)))
 912             {
 913               if (debug_fbsd_lwp)
 914                 fprintf_unfiltered (gdb_stdlog,
 915                                     "FLWP: using LWP %u for first thread\n",
 916                                     pl.pl_lwpid);
 917               thread_change_ptid (pid_to_ptid (pid), wptid);
 918             }
 919
 920 #ifdef PT_LWP_EVENTS
 921           if (pl.pl_flags & PL_FLAG_BORN)
 922             {
 923               /* If GDB attaches to a multi-threaded process, newborn
 924                  threads might be added by fbsd_add_threads that have
 925                  not yet reported their PL_FLAG_BORN event.  Ignore
 926                  BORN events for an already-known LWP.  */
 927               if (!in_thread_list (wptid))
 928                 {
 929                   if (debug_fbsd_lwp)
 930                     fprintf_unfiltered (gdb_stdlog,
 931                                         "FLWP: adding thread for LWP %u\n",
 932                                         pl.pl_lwpid);
 933                   add_thread (wptid);
 934                 }
 935               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 936               return wptid;
 937             }
 938 #endif
 939
 940 #ifdef TDP_RFPPWAIT
 941           if (pl.pl_flags & PL_FLAG_FORKED)
 942             {
 943 #ifndef PTRACE_VFORK
 944               struct kinfo_proc kp;
 945 #endif
 946               ptid_t child_ptid;
 947               pid_t child;
 948
 949               child = pl.pl_child_pid;
 950               ourstatus->kind = TARGET_WAITKIND_FORKED;
 951 #ifdef PTRACE_VFORK
 952               if (pl.pl_flags & PL_FLAG_VFORKED)
 953                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
 954 #endif
 955
 956               /* Make sure the other end of the fork is stopped too.  */
 957               child_ptid = fbsd_is_child_pending (child);
 958               if (ptid_equal (child_ptid, null_ptid))
 959                 {
 960                   pid = waitpid (child, &status, 0);
 961                   if (pid == -1)
 962                     perror_with_name (("waitpid"));
 963
 964                   gdb_assert (pid == child);
 965
 966                   if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
 967                     perror_with_name (("ptrace"));
 968
 969                   gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
 970                   child_ptid = ptid_build (child, pl.pl_lwpid, 0);
 971                 }
 972
 973               /* Enable additional events on the child process.  */
 974               fbsd_enable_proc_events (ptid_get_pid (child_ptid));
 975
 976 #ifndef PTRACE_VFORK
 977               /* For vfork, the child process will have the P_PPWAIT
 978                  flag set.  */
 979               fbsd_fetch_kinfo_proc (child, &kp);
 980               if (kp.ki_flag & P_PPWAIT)
 981                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
 982 #endif
 983               ourstatus->value.related_pid = child_ptid;
 984
 985               return wptid;
 986             }
 987
 988           if (pl.pl_flags & PL_FLAG_CHILD)
 989             {
 990               /* Remember that this child forked, but do not report it
 991                  until the parent reports its corresponding fork
 992                  event.  */
 993               fbsd_remember_child (wptid);
 994               continue;
 995             }
 996
 997 #ifdef PTRACE_VFORK
 998           if (pl.pl_flags & PL_FLAG_VFORK_DONE)
 999             {
1000               ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
1001               return wptid;
1002             }
1003 #endif
1004 #endif
1005
1006 #ifdef PL_FLAG_EXEC
1007           if (pl.pl_flags & PL_FLAG_EXEC)
1008             {
1009               ourstatus->kind = TARGET_WAITKIND_EXECD;
1010               ourstatus->value.execd_pathname
1011                 = xstrdup (fbsd_pid_to_exec_file (NULL, pid));
1012               return wptid;
1013             }
1014 #endif
1015
1016           /* Note that PL_FLAG_SCE is set for any event reported while
1017              a thread is executing a system call in the kernel.  In
1018              particular, signals that interrupt a sleep in a system
1019              call will report this flag as part of their event.  Stops
1020              explicitly for system call entry and exit always use
1021              SIGTRAP, so only treat SIGTRAP events as system call
1022              entry/exit events.  */
1023           if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
1024               && ourstatus->value.sig == SIGTRAP)
1025             {
1026 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1027               if (catch_syscall_enabled ())
1028                 {
1029                   if (catching_syscall_number (pl.pl_syscall_code))
1030                     {
1031                       if (pl.pl_flags & PL_FLAG_SCE)
1032                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1033                       else
1034                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1035                       ourstatus->value.syscall_number = pl.pl_syscall_code;
1036                       return wptid;
1037                     }
1038                 }
1039 #endif
1040               /* If the core isn't interested in this event, just
1041                  continue the process explicitly and wait for another
1042                  event.  Note that PT_SYSCALL is "sticky" on FreeBSD
1043                  and once system call stops are enabled on a process
1044                  it stops for all system call entries and exits.  */
1045               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
1046                 perror_with_name (("ptrace"));
1047               continue;
1048             }
1049         }
1050       return wptid;
1051     }
1052 }
1053
1054 #ifdef TDP_RFPPWAIT
1055 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
1056    the ptid of the followed inferior.  */
1057
1058 static int
1059 fbsd_follow_fork (struct target_ops *ops, int follow_child,
1060                         int detach_fork)
1061 {
1062   if (!follow_child && detach_fork)
1063     {
1064       struct thread_info *tp = inferior_thread ();
1065       pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
1066
1067       /* Breakpoints have already been detached from the child by
1068          infrun.c.  */
1069
1070       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
1071         perror_with_name (("ptrace"));
1072
1073 #ifndef PTRACE_VFORK
1074       if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
1075         {
1076           /* We can't insert breakpoints until the child process has
1077              finished with the shared memory region.  The parent
1078              process doesn't wait for the child process to exit or
1079              exec until after it has been resumed from the ptrace stop
1080              to report the fork.  Once it has been resumed it doesn't
1081              stop again before returning to userland, so there is no
1082              reliable way to wait on the parent.
1083
1084              We can't stay attached to the child to wait for an exec
1085              or exit because it may invoke ptrace(PT_TRACE_ME)
1086              (e.g. if the parent process is a debugger forking a new
1087              child process).
1088
1089              In the end, the best we can do is to make sure it runs
1090              for a little while.  Hopefully it will be out of range of
1091              any breakpoints we reinsert.  Usually this is only the
1092              single-step breakpoint at vfork's return point.  */
1093
1094           usleep (10000);
1095
1096           /* Schedule a fake VFORK_DONE event to report on the next
1097              wait.  */
1098           fbsd_add_vfork_done (inferior_ptid);
1099         }
1100 #endif
1101     }
1102
1103   return 0;
1104 }
1105
1106 static int
1107 fbsd_insert_fork_catchpoint (struct target_ops *self, int pid)
1108 {
1109   return 0;
1110 }
1111
1112 static int
1113 fbsd_remove_fork_catchpoint (struct target_ops *self, int pid)
1114 {
1115   return 0;
1116 }
1117
1118 static int
1119 fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid)
1120 {
1121   return 0;
1122 }
1123
1124 static int
1125 fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid)
1126 {
1127   return 0;
1128 }
1129 #endif
1130
1131 /* Implement the "to_post_startup_inferior" target_ops method.  */
1132
1133 static void
1134 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
1135 {
1136   fbsd_enable_proc_events (ptid_get_pid (pid));
1137 }
1138
1139 /* Implement the "to_post_attach" target_ops method.  */
1140
1141 static void
1142 fbsd_post_attach (struct target_ops *self, int pid)
1143 {
1144   fbsd_enable_proc_events (pid);
1145   fbsd_add_threads (pid);
1146 }
1147
1148 #ifdef PL_FLAG_EXEC
1149 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1150    will always stop after exec.  */
1151
1152 static int
1153 fbsd_insert_exec_catchpoint (struct target_ops *self, int pid)
1154 {
1155   return 0;
1156 }
1157
1158 static int
1159 fbsd_remove_exec_catchpoint (struct target_ops *self, int pid)
1160 {
1161   return 0;
1162 }
1163 #endif
1164
1165 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1166 static int
1167 fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
1168                              int any_count, int table_size, int *table)
1169 {
1170
1171   /* Ignore the arguments.  inf-ptrace.c will use PT_SYSCALL which
1172      will catch all system call entries and exits.  The system calls
1173      are filtered by GDB rather than the kernel.  */
1174   return 0;
1175 }
1176 #endif
1177 #endif
1178
1179 void
1180 fbsd_nat_add_target (struct target_ops *t)
1181 {
1182   t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
1183   t->to_find_memory_regions = fbsd_find_memory_regions;
1184 #ifdef KERN_PROC_AUXV
1185   super_xfer_partial = t->to_xfer_partial;
1186   t->to_xfer_partial = fbsd_xfer_partial;
1187 #endif
1188 #ifdef PT_LWPINFO
1189   t->to_thread_alive = fbsd_thread_alive;
1190   t->to_pid_to_str = fbsd_pid_to_str;
1191 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
1192   t->to_thread_name = fbsd_thread_name;
1193 #endif
1194   t->to_update_thread_list = fbsd_update_thread_list;
1195   t->to_has_thread_control = tc_schedlock;
1196   super_resume = t->to_resume;
1197   t->to_resume = fbsd_resume;
1198   super_wait = t->to_wait;
1199   t->to_wait = fbsd_wait;
1200   t->to_post_startup_inferior = fbsd_post_startup_inferior;
1201   t->to_post_attach = fbsd_post_attach;
1202 #ifdef TDP_RFPPWAIT
1203   t->to_follow_fork = fbsd_follow_fork;
1204   t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;
1205   t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;
1206   t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;
1207   t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;
1208 #endif
1209 #ifdef PL_FLAG_EXEC
1210   t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
1211   t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
1212 #endif
1213 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1214   t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint;
1215 #endif
1216 #endif
1217   add_target (t);
1218 }
1219
1220 /* Provide a prototype to silence -Wmissing-prototypes.  */
1221 extern initialize_file_ftype _initialize_fbsd_nat;
1222
1223 void
1224 _initialize_fbsd_nat (void)
1225 {
1226 #ifdef PT_LWPINFO
1227   add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
1228                            &debug_fbsd_lwp, _("\
1229 Set debugging of FreeBSD lwp module."), _("\
1230 Show debugging of FreeBSD lwp module."), _("\
1231 Enables printf debugging output."),
1232                            NULL,
1233                            &show_fbsd_lwp_debug,
1234                            &setdebuglist, &showdebuglist);
1235 #endif
1236 }