gdb/fbsd-nat.c

   1 /* Native-dependent code for FreeBSD.
   2
   3    Copyright (C) 2002-2016 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 "gdbcore.h"
  22 #include "inferior.h"
  23 #include "regcache.h"
  24 #include "regset.h"
  25 #include "gdbcmd.h"
  26 #include "gdbthread.h"
  27 #include "gdb_wait.h"
  28 #include <sys/types.h>
  29 #include <sys/procfs.h>
  30 #include <sys/ptrace.h>
  31 #include <sys/sysctl.h>
  32 #ifdef HAVE_KINFO_GETVMMAP
  33 #include <sys/user.h>
  34 #include <libutil.h>
  35 #endif
  36
  37 #include "elf-bfd.h"
  38 #include "fbsd-nat.h"
  39
  40 /* Return the name of a file that can be opened to get the symbols for
  41    the child process identified by PID.  */
  42
  43 static char *
  44 fbsd_pid_to_exec_file (struct target_ops *self, int pid)
  45 {
  46   ssize_t len;
  47   static char buf[PATH_MAX];
  48   char name[PATH_MAX];
  49
  50 #ifdef KERN_PROC_PATHNAME
  51   size_t buflen;
  52   int mib[4];
  53
  54   mib[0] = CTL_KERN;
  55   mib[1] = KERN_PROC;
  56   mib[2] = KERN_PROC_PATHNAME;
  57   mib[3] = pid;
  58   buflen = sizeof buf;
  59   if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
  60     return buf;
  61 #endif
  62
  63   xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
  64   len = readlink (name, buf, PATH_MAX - 1);
  65   if (len != -1)
  66     {
  67       buf[len] = '\0';
  68       return buf;
  69     }
  70
  71   return NULL;
  72 }
  73
  74 #ifdef HAVE_KINFO_GETVMMAP
  75 /* Iterate over all the memory regions in the current inferior,
  76    calling FUNC for each memory region.  OBFD is passed as the last
  77    argument to FUNC.  */
  78
  79 static int
  80 fbsd_find_memory_regions (struct target_ops *self,
  81                           find_memory_region_ftype func, void *obfd)
  82 {
  83   pid_t pid = ptid_get_pid (inferior_ptid);
  84   struct kinfo_vmentry *vmentl, *kve;
  85   uint64_t size;
  86   struct cleanup *cleanup;
  87   int i, nitems;
  88
  89   vmentl = kinfo_getvmmap (pid, &nitems);
  90   if (vmentl == NULL)
  91     perror_with_name (_("Couldn't fetch VM map entries."));
  92   cleanup = make_cleanup (free, vmentl);
  93
  94   for (i = 0; i < nitems; i++)
  95     {
  96       kve = &vmentl[i];
  97
  98       /* Skip unreadable segments and those where MAP_NOCORE has been set.  */
  99       if (!(kve->kve_protection & KVME_PROT_READ)
 100           || kve->kve_flags & KVME_FLAG_NOCOREDUMP)
 101         continue;
 102
 103       /* Skip segments with an invalid type.  */
 104       if (kve->kve_type != KVME_TYPE_DEFAULT
 105           && kve->kve_type != KVME_TYPE_VNODE
 106           && kve->kve_type != KVME_TYPE_SWAP
 107           && kve->kve_type != KVME_TYPE_PHYS)
 108         continue;
 109
 110       size = kve->kve_end - kve->kve_start;
 111       if (info_verbose)
 112         {
 113           fprintf_filtered (gdb_stdout,
 114                             "Save segment, %ld bytes at %s (%c%c%c)\n",
 115                             (long) size,
 116                             paddress (target_gdbarch (), kve->kve_start),
 117                             kve->kve_protection & KVME_PROT_READ ? 'r' : '-',
 118                             kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-',
 119                             kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-');
 120         }
 121
 122       /* Invoke the callback function to create the corefile segment.
 123          Pass MODIFIED as true, we do not know the real modification state.  */
 124       func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ,
 125             kve->kve_protection & KVME_PROT_WRITE,
 126             kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
 127     }
 128   do_cleanups (cleanup);
 129   return 0;
 130 }
 131 #else
 132 static int
 133 fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end,
 134                    char *protection)
 135 {
 136   /* FreeBSD 5.1-RELEASE uses a 256-byte buffer.  */
 137   char buf[256];
 138   int resident, privateresident;
 139   unsigned long obj;
 140   int ret = EOF;
 141
 142   /* As of FreeBSD 5.0-RELEASE, the layout is described in
 143      /usr/src/sys/fs/procfs/procfs_map.c.  Somewhere in 5.1-CURRENT a
 144      new column was added to the procfs map.  Therefore we can't use
 145      fscanf since we need to support older releases too.  */
 146   if (fgets (buf, sizeof buf, mapfile) != NULL)
 147     ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end,
 148                   &resident, &privateresident, &obj, protection);
 149
 150   return (ret != 0 && ret != EOF);
 151 }
 152
 153 /* Iterate over all the memory regions in the current inferior,
 154    calling FUNC for each memory region.  OBFD is passed as the last
 155    argument to FUNC.  */
 156
 157 static int
 158 fbsd_find_memory_regions (struct target_ops *self,
 159                           find_memory_region_ftype func, void *obfd)
 160 {
 161   pid_t pid = ptid_get_pid (inferior_ptid);
 162   char *mapfilename;
 163   FILE *mapfile;
 164   unsigned long start, end, size;
 165   char protection[4];
 166   int read, write, exec;
 167   struct cleanup *cleanup;
 168
 169   mapfilename = xstrprintf ("/proc/%ld/map", (long) pid);
 170   cleanup = make_cleanup (xfree, mapfilename);
 171   mapfile = fopen (mapfilename, "r");
 172   if (mapfile == NULL)
 173     error (_("Couldn't open %s."), mapfilename);
 174   make_cleanup_fclose (mapfile);
 175
 176   if (info_verbose)
 177     fprintf_filtered (gdb_stdout,
 178                       "Reading memory regions from %s\n", mapfilename);
 179
 180   /* Now iterate until end-of-file.  */
 181   while (fbsd_read_mapping (mapfile, &start, &end, &protection[0]))
 182     {
 183       size = end - start;
 184
 185       read = (strchr (protection, 'r') != 0);
 186       write = (strchr (protection, 'w') != 0);
 187       exec = (strchr (protection, 'x') != 0);
 188
 189       if (info_verbose)
 190         {
 191           fprintf_filtered (gdb_stdout,
 192                             "Save segment, %ld bytes at %s (%c%c%c)\n",
 193                             size, paddress (target_gdbarch (), start),
 194                             read ? 'r' : '-',
 195                             write ? 'w' : '-',
 196                             exec ? 'x' : '-');
 197         }
 198
 199       /* Invoke the callback function to create the corefile segment.
 200          Pass MODIFIED as true, we do not know the real modification state.  */
 201       func (start, size, read, write, exec, 1, obfd);
 202     }
 203
 204   do_cleanups (cleanup);
 205   return 0;
 206 }
 207 #endif
 208
 209 #ifdef KERN_PROC_AUXV
 210 static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
 211                                                       enum target_object object,
 212                                                       const char *annex,
 213                                                       gdb_byte *readbuf,
 214                                                       const gdb_byte *writebuf,
 215                                                       ULONGEST offset,
 216                                                       ULONGEST len,
 217                                                       ULONGEST *xfered_len);
 218
 219 /* Implement the "to_xfer_partial target_ops" method.  */
 220
 221 static enum target_xfer_status
 222 fbsd_xfer_partial (struct target_ops *ops, enum target_object object,
 223                    const char *annex, gdb_byte *readbuf,
 224                    const gdb_byte *writebuf,
 225                    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 226 {
 227   pid_t pid = ptid_get_pid (inferior_ptid);
 228
 229   switch (object)
 230     {
 231     case TARGET_OBJECT_AUXV:
 232       {
 233         struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 234         unsigned char *buf;
 235         size_t buflen;
 236         int mib[4];
 237
 238         if (writebuf != NULL)
 239           return TARGET_XFER_E_IO;
 240         mib[0] = CTL_KERN;
 241         mib[1] = KERN_PROC;
 242         mib[2] = KERN_PROC_AUXV;
 243         mib[3] = pid;
 244         if (offset == 0)
 245           {
 246             buf = readbuf;
 247             buflen = len;
 248           }
 249         else
 250           {
 251             buflen = offset + len;
 252             buf = XCNEWVEC (unsigned char, buflen);
 253             cleanup = make_cleanup (xfree, buf);
 254           }
 255         if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
 256           {
 257             if (offset != 0)
 258               {
 259                 if (buflen > offset)
 260                   {
 261                     buflen -= offset;
 262                     memcpy (readbuf, buf + offset, buflen);
 263                   }
 264                 else
 265                   buflen = 0;
 266               }
 267             do_cleanups (cleanup);
 268             *xfered_len = buflen;
 269             return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 270           }
 271         do_cleanups (cleanup);
 272         return TARGET_XFER_E_IO;
 273       }
 274     default:
 275       return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
 276                                  len, xfered_len);
 277     }
 278 }
 279 #endif
 280
 281 #ifdef PT_LWPINFO
 282 static int debug_fbsd_lwp;
 283
 284 static void (*super_resume) (struct target_ops *,
 285                              ptid_t,
 286                              int,
 287                              enum gdb_signal);
 288 static ptid_t (*super_wait) (struct target_ops *,
 289                              ptid_t,
 290                              struct target_waitstatus *,
 291                              int);
 292
 293 static void
 294 show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
 295                      struct cmd_list_element *c, const char *value)
 296 {
 297   fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
 298 }
 299
 300 #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
 301 /* Fetch the external variant of the kernel's internal process
 302    structure for the process PID into KP.  */
 303
 304 static void
 305 fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
 306 {
 307   size_t len;
 308   int mib[4];
 309
 310   len = sizeof *kp;
 311   mib[0] = CTL_KERN;
 312   mib[1] = KERN_PROC;
 313   mib[2] = KERN_PROC_PID;
 314   mib[3] = pid;
 315   if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)
 316     perror_with_name (("sysctl"));
 317 }
 318 #endif
 319
 320 /*
 321   FreeBSD's first thread support was via a "reentrant" version of libc
 322   (libc_r) that first shipped in 2.2.7.  This library multiplexed all
 323   of the threads in a process onto a single kernel thread.  This
 324   library is supported via the bsd-uthread target.
 325
 326   FreeBSD 5.1 introduced two new threading libraries that made use of
 327   multiple kernel threads.  The first (libkse) scheduled M user
 328   threads onto N (<= M) kernel threads (LWPs).  The second (libthr)
 329   bound each user thread to a dedicated kernel thread.  libkse shipped
 330   as the default threading library (libpthread).
 331
 332   FreeBSD 5.3 added a libthread_db to abstract the interface across
 333   the various thread libraries (libc_r, libkse, and libthr).
 334
 335   FreeBSD 7.0 switched the default threading library from from libkse
 336   to libpthread and removed libc_r.
 337
 338   FreeBSD 8.0 removed libkse and the in-kernel support for it.  The
 339   only threading library supported by 8.0 and later is libthr which
 340   ties each user thread directly to an LWP.  To simplify the
 341   implementation, this target only supports LWP-backed threads using
 342   ptrace directly rather than libthread_db.
 343
 344   FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
 345 */
 346
 347 /* Return true if PTID is still active in the inferior.  */
 348
 349 static int
 350 fbsd_thread_alive (struct target_ops *ops, ptid_t ptid)
 351 {
 352   if (ptid_lwp_p (ptid))
 353     {
 354       struct ptrace_lwpinfo pl;
 355
 356       if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)
 357           == -1)
 358         return 0;
 359 #ifdef PL_FLAG_EXITED
 360       if (pl.pl_flags & PL_FLAG_EXITED)
 361         return 0;
 362 #endif
 363     }
 364
 365   return 1;
 366 }
 367
 368 /* Convert PTID to a string.  Returns the string in a static
 369    buffer.  */
 370
 371 static char *
 372 fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
 373 {
 374   lwpid_t lwp;
 375
 376   lwp = ptid_get_lwp (ptid);
 377   if (lwp != 0)
 378     {
 379       static char buf[64];
 380       int pid = ptid_get_pid (ptid);
 381
 382       xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid);
 383       return buf;
 384     }
 385
 386   return normal_pid_to_str (ptid);
 387 }
 388
 389 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
 390 /* Return the name assigned to a thread by an application.  Returns
 391    the string in a static buffer.  */
 392
 393 static const char *
 394 fbsd_thread_name (struct target_ops *self, struct thread_info *thr)
 395 {
 396   struct ptrace_lwpinfo pl;
 397   struct kinfo_proc kp;
 398   int pid = ptid_get_pid (thr->ptid);
 399   long lwp = ptid_get_lwp (thr->ptid);
 400   static char buf[sizeof pl.pl_tdname + 1];
 401
 402   /* Note that ptrace_lwpinfo returns the process command in pl_tdname
 403      if a name has not been set explicitly.  Return a NULL name in
 404      that case.  */
 405   fbsd_fetch_kinfo_proc (pid, &kp);
 406   if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
 407     perror_with_name (("ptrace"));
 408   if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
 409     return NULL;
 410   xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);
 411   return buf;
 412 }
 413 #endif
 414
 415 #ifdef PT_LWP_EVENTS
 416 /* Enable LWP events for a specific process.
 417
 418    To catch LWP events, PT_LWP_EVENTS is set on every traced process.
 419    This enables stops on the birth for new LWPs (excluding the "main" LWP)
 420    and the death of LWPs (excluding the last LWP in a process).  Note
 421    that unlike fork events, the LWP that creates a new LWP does not
 422    report an event.  */
 423
 424 static void
 425 fbsd_enable_lwp_events (pid_t pid)
 426 {
 427   if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 428     perror_with_name (("ptrace"));
 429 }
 430 #endif
 431
 432 /* Add threads for any new LWPs in a process.
 433
 434    When LWP events are used, this function is only used to detect existing
 435    threads when attaching to a process.  On older systems, this function is
 436    called to discover new threads each time the thread list is updated.  */
 437
 438 static void
 439 fbsd_add_threads (pid_t pid)
 440 {
 441   struct cleanup *cleanup;
 442   lwpid_t *lwps;
 443   int i, nlwps;
 444
 445   gdb_assert (!in_thread_list (pid_to_ptid (pid)));
 446   nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
 447   if (nlwps == -1)
 448     perror_with_name (("ptrace"));
 449
 450   lwps = XCNEWVEC (lwpid_t, nlwps);
 451   cleanup = make_cleanup (xfree, lwps);
 452
 453   nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);
 454   if (nlwps == -1)
 455     perror_with_name (("ptrace"));
 456
 457   for (i = 0; i < nlwps; i++)
 458     {
 459       ptid_t ptid = ptid_build (pid, lwps[i], 0);
 460
 461       if (!in_thread_list (ptid))
 462         {
 463 #ifdef PT_LWP_EVENTS
 464           struct ptrace_lwpinfo pl;
 465
 466           /* Don't add exited threads.  Note that this is only called
 467              when attaching to a multi-threaded process.  */
 468           if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1)
 469             perror_with_name (("ptrace"));
 470           if (pl.pl_flags & PL_FLAG_EXITED)
 471             continue;
 472 #endif
 473           if (debug_fbsd_lwp)
 474             fprintf_unfiltered (gdb_stdlog,
 475                                 "FLWP: adding thread for LWP %u\n",
 476                                 lwps[i]);
 477           add_thread (ptid);
 478         }
 479     }
 480   do_cleanups (cleanup);
 481 }
 482
 483 /* Implement the "to_update_thread_list" target_ops method.  */
 484
 485 static void
 486 fbsd_update_thread_list (struct target_ops *ops)
 487 {
 488 #ifdef PT_LWP_EVENTS
 489   /* With support for thread events, threads are added/deleted from the
 490      list as events are reported, so just try deleting exited threads.  */
 491   delete_exited_threads ();
 492 #else
 493   prune_threads ();
 494
 495   fbsd_add_threads (ptid_get_pid (inferior_ptid));
 496 #endif
 497 }
 498
 499 #ifdef TDP_RFPPWAIT
 500 /*
 501   To catch fork events, PT_FOLLOW_FORK is set on every traced process
 502   to enable stops on returns from fork or vfork.  Note that both the
 503   parent and child will always stop, even if system call stops are not
 504   enabled.
 505
 506   After a fork, both the child and parent process will stop and report
 507   an event.  However, there is no guarantee of order.  If the parent
 508   reports its stop first, then fbsd_wait explicitly waits for the new
 509   child before returning.  If the child reports its stop first, then
 510   the event is saved on a list and ignored until the parent's stop is
 511   reported.  fbsd_wait could have been changed to fetch the parent PID
 512   of the new child and used that to wait for the parent explicitly.
 513   However, if two threads in the parent fork at the same time, then
 514   the wait on the parent might return the "wrong" fork event.
 515
 516   The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
 517   the new child process.  This flag could be inferred by treating any
 518   events for an unknown pid as a new child.
 519
 520   In addition, the initial version of PT_FOLLOW_FORK did not report a
 521   stop event for the parent process of a vfork until after the child
 522   process executed a new program or exited.  The kernel was changed to
 523   defer the wait for exit or exec of the child until after posting the
 524   stop event shortly after the change to introduce PL_FLAG_CHILD.
 525   This could be worked around by reporting a vfork event when the
 526   child event posted and ignoring the subsequent event from the
 527   parent.
 528
 529   This implementation requires both of these fixes for simplicity's
 530   sake.  FreeBSD versions newer than 9.1 contain both fixes.
 531 */
 532
 533 struct fbsd_fork_child_info
 534 {
 535   struct fbsd_fork_child_info *next;
 536   ptid_t child;                 /* Pid of new child.  */
 537 };
 538
 539 static struct fbsd_fork_child_info *fbsd_pending_children;
 540
 541 /* Record a new child process event that is reported before the
 542    corresponding fork event in the parent.  */
 543
 544 static void
 545 fbsd_remember_child (ptid_t pid)
 546 {
 547   struct fbsd_fork_child_info *info = XCNEW (struct fbsd_fork_child_info);
 548
 549   info->child = pid;
 550   info->next = fbsd_pending_children;
 551   fbsd_pending_children = info;
 552 }
 553
 554 /* Check for a previously-recorded new child process event for PID.
 555    If one is found, remove it from the list and return the PTID.  */
 556
 557 static ptid_t
 558 fbsd_is_child_pending (pid_t pid)
 559 {
 560   struct fbsd_fork_child_info *info, *prev;
 561   ptid_t ptid;
 562
 563   prev = NULL;
 564   for (info = fbsd_pending_children; info; prev = info, info = info->next)
 565     {
 566       if (ptid_get_pid (info->child) == pid)
 567         {
 568           if (prev == NULL)
 569             fbsd_pending_children = info->next;
 570           else
 571             prev->next = info->next;
 572           ptid = info->child;
 573           xfree (info);
 574           return ptid;
 575         }
 576     }
 577   return null_ptid;
 578 }
 579 #endif
 580
 581 static int
 582 resume_one_thread_cb (struct thread_info *tp, void *data)
 583 {
 584   ptid_t *ptid = (ptid_t *) data;
 585   int request;
 586
 587   if (ptid_get_pid (tp->ptid) != ptid_get_pid (*ptid))
 588     return 0;
 589
 590   if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (*ptid))
 591     request = PT_RESUME;
 592   else
 593     request = PT_SUSPEND;
 594
 595   if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 596     perror_with_name (("ptrace"));
 597   return 0;
 598 }
 599
 600 static int
 601 resume_all_threads_cb (struct thread_info *tp, void *data)
 602 {
 603   ptid_t *filter = (ptid_t *) data;
 604
 605   if (!ptid_match (tp->ptid, *filter))
 606     return 0;
 607
 608   if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 609     perror_with_name (("ptrace"));
 610   return 0;
 611 }
 612
 613 /* Implement the "to_resume" target_ops method.  */
 614
 615 static void
 616 fbsd_resume (struct target_ops *ops,
 617              ptid_t ptid, int step, enum gdb_signal signo)
 618 {
 619
 620   if (debug_fbsd_lwp)
 621     fprintf_unfiltered (gdb_stdlog,
 622                         "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
 623                         ptid_get_pid (ptid), ptid_get_lwp (ptid),
 624                         ptid_get_tid (ptid));
 625   if (ptid_lwp_p (ptid))
 626     {
 627       /* If ptid is a specific LWP, suspend all other LWPs in the process.  */
 628       iterate_over_threads (resume_one_thread_cb, &ptid);
 629     }
 630   else
 631     {
 632       /* If ptid is a wildcard, resume all matching threads (they won't run
 633          until the process is continued however).  */
 634       iterate_over_threads (resume_all_threads_cb, &ptid);
 635       ptid = inferior_ptid;
 636     }
 637   super_resume (ops, ptid, step, signo);
 638 }
 639
 640 /* Wait for the child specified by PTID to do something.  Return the
 641    process ID of the child, or MINUS_ONE_PTID in case of error; store
 642    the status in *OURSTATUS.  */
 643
 644 static ptid_t
 645 fbsd_wait (struct target_ops *ops,
 646            ptid_t ptid, struct target_waitstatus *ourstatus,
 647            int target_options)
 648 {
 649   ptid_t wptid;
 650
 651   while (1)
 652     {
 653       wptid = super_wait (ops, ptid, ourstatus, target_options);
 654       if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
 655         {
 656           struct ptrace_lwpinfo pl;
 657           pid_t pid;
 658           int status;
 659
 660           pid = ptid_get_pid (wptid);
 661           if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
 662             perror_with_name (("ptrace"));
 663
 664           wptid = ptid_build (pid, pl.pl_lwpid, 0);
 665
 666 #ifdef PT_LWP_EVENTS
 667           if (pl.pl_flags & PL_FLAG_EXITED)
 668             {
 669               /* If GDB attaches to a multi-threaded process, exiting
 670                  threads might be skipped during fbsd_post_attach that
 671                  have not yet reported their PL_FLAG_EXITED event.
 672                  Ignore EXITED events for an unknown LWP.  */
 673               if (in_thread_list (wptid))
 674                 {
 675                   if (debug_fbsd_lwp)
 676                     fprintf_unfiltered (gdb_stdlog,
 677                                         "FLWP: deleting thread for LWP %u\n",
 678                                         pl.pl_lwpid);
 679                   if (print_thread_events)
 680                     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
 681                                        (wptid));
 682                   delete_thread (wptid);
 683                 }
 684               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
 685                 perror_with_name (("ptrace"));
 686               continue;
 687             }
 688 #endif
 689
 690           /* Switch to an LWP PTID on the first stop in a new process.
 691              This is done after handling PL_FLAG_EXITED to avoid
 692              switching to an exited LWP.  It is done before checking
 693              PL_FLAG_BORN in case the first stop reported after
 694              attaching to an existing process is a PL_FLAG_BORN
 695              event.  */
 696           if (in_thread_list (pid_to_ptid (pid)))
 697             {
 698               if (debug_fbsd_lwp)
 699                 fprintf_unfiltered (gdb_stdlog,
 700                                     "FLWP: using LWP %u for first thread\n",
 701                                     pl.pl_lwpid);
 702               thread_change_ptid (pid_to_ptid (pid), wptid);
 703             }
 704
 705 #ifdef PT_LWP_EVENTS
 706           if (pl.pl_flags & PL_FLAG_BORN)
 707             {
 708               /* If GDB attaches to a multi-threaded process, newborn
 709                  threads might be added by fbsd_add_threads that have
 710                  not yet reported their PL_FLAG_BORN event.  Ignore
 711                  BORN events for an already-known LWP.  */
 712               if (!in_thread_list (wptid))
 713                 {
 714                   if (debug_fbsd_lwp)
 715                     fprintf_unfiltered (gdb_stdlog,
 716                                         "FLWP: adding thread for LWP %u\n",
 717                                         pl.pl_lwpid);
 718                   add_thread (wptid);
 719                 }
 720               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 721               return wptid;
 722             }
 723 #endif
 724
 725 #ifdef TDP_RFPPWAIT
 726           if (pl.pl_flags & PL_FLAG_FORKED)
 727             {
 728               struct kinfo_proc kp;
 729               ptid_t child_ptid;
 730               pid_t child;
 731
 732               child = pl.pl_child_pid;
 733               ourstatus->kind = TARGET_WAITKIND_FORKED;
 734
 735               /* Make sure the other end of the fork is stopped too.  */
 736               child_ptid = fbsd_is_child_pending (child);
 737               if (ptid_equal (child_ptid, null_ptid))
 738                 {
 739                   pid = waitpid (child, &status, 0);
 740                   if (pid == -1)
 741                     perror_with_name (("waitpid"));
 742
 743                   gdb_assert (pid == child);
 744
 745                   if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
 746                     perror_with_name (("ptrace"));
 747
 748                   gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
 749                   child_ptid = ptid_build (child, pl.pl_lwpid, 0);
 750                 }
 751
 752               /* For vfork, the child process will have the P_PPWAIT
 753                  flag set.  */
 754               fbsd_fetch_kinfo_proc (child, &kp);
 755               if (kp.ki_flag & P_PPWAIT)
 756                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
 757               ourstatus->value.related_pid = child_ptid;
 758
 759               return wptid;
 760             }
 761
 762           if (pl.pl_flags & PL_FLAG_CHILD)
 763             {
 764               /* Remember that this child forked, but do not report it
 765                  until the parent reports its corresponding fork
 766                  event.  */
 767               fbsd_remember_child (wptid);
 768               continue;
 769             }
 770 #endif
 771
 772 #ifdef PL_FLAG_EXEC
 773           if (pl.pl_flags & PL_FLAG_EXEC)
 774             {
 775               ourstatus->kind = TARGET_WAITKIND_EXECD;
 776               ourstatus->value.execd_pathname
 777                 = xstrdup (fbsd_pid_to_exec_file (NULL, pid));
 778               return wptid;
 779             }
 780 #endif
 781
 782           /* Note that PL_FLAG_SCE is set for any event reported while
 783              a thread is executing a system call in the kernel.  In
 784              particular, signals that interrupt a sleep in a system
 785              call will report this flag as part of their event.  Stops
 786              explicitly for system call entry and exit always use
 787              SIGTRAP, so only treat SIGTRAP events as system call
 788              entry/exit events.  */
 789           if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
 790               && ourstatus->value.sig == SIGTRAP)
 791             {
 792 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
 793               if (catch_syscall_enabled ())
 794                 {
 795                   if (catching_syscall_number (pl.pl_syscall_code))
 796                     {
 797                       if (pl.pl_flags & PL_FLAG_SCE)
 798                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
 799                       else
 800                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
 801                       ourstatus->value.syscall_number = pl.pl_syscall_code;
 802                       return wptid;
 803                     }
 804                 }
 805 #endif
 806               /* If the core isn't interested in this event, just
 807                  continue the process explicitly and wait for another
 808                  event.  Note that PT_SYSCALL is "sticky" on FreeBSD
 809                  and once system call stops are enabled on a process
 810                  it stops for all system call entries and exits.  */
 811               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
 812                 perror_with_name (("ptrace"));
 813               continue;
 814             }
 815         }
 816       return wptid;
 817     }
 818 }
 819
 820 #ifdef TDP_RFPPWAIT
 821 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
 822    the ptid of the followed inferior.  */
 823
 824 static int
 825 fbsd_follow_fork (struct target_ops *ops, int follow_child,
 826                         int detach_fork)
 827 {
 828   if (!follow_child && detach_fork)
 829     {
 830       struct thread_info *tp = inferior_thread ();
 831       pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
 832
 833       /* Breakpoints have already been detached from the child by
 834          infrun.c.  */
 835
 836       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
 837         perror_with_name (("ptrace"));
 838     }
 839
 840   return 0;
 841 }
 842
 843 static int
 844 fbsd_insert_fork_catchpoint (struct target_ops *self, int pid)
 845 {
 846   return 0;
 847 }
 848
 849 static int
 850 fbsd_remove_fork_catchpoint (struct target_ops *self, int pid)
 851 {
 852   return 0;
 853 }
 854
 855 static int
 856 fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid)
 857 {
 858   return 0;
 859 }
 860
 861 static int
 862 fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid)
 863 {
 864   return 0;
 865 }
 866
 867 /* Enable fork tracing for a specific process.
 868
 869    To catch fork events, PT_FOLLOW_FORK is set on every traced process
 870    to enable stops on returns from fork or vfork.  Note that both the
 871    parent and child will always stop, even if system call stops are
 872    not enabled.  */
 873
 874 static void
 875 fbsd_enable_follow_fork (pid_t pid)
 876 {
 877   if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 878     perror_with_name (("ptrace"));
 879 }
 880 #endif
 881
 882 /* Implement the "to_post_startup_inferior" target_ops method.  */
 883
 884 static void
 885 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
 886 {
 887 #ifdef TDP_RFPPWAIT
 888   fbsd_enable_follow_fork (ptid_get_pid (pid));
 889 #endif
 890 #ifdef PT_LWP_EVENTS
 891   fbsd_enable_lwp_events (ptid_get_pid (pid));
 892 #endif
 893 }
 894
 895 /* Implement the "to_post_attach" target_ops method.  */
 896
 897 static void
 898 fbsd_post_attach (struct target_ops *self, int pid)
 899 {
 900 #ifdef TDP_RFPPWAIT
 901   fbsd_enable_follow_fork (pid);
 902 #endif
 903 #ifdef PT_LWP_EVENTS
 904   fbsd_enable_lwp_events (pid);
 905 #endif
 906   fbsd_add_threads (pid);
 907 }
 908
 909 #ifdef PL_FLAG_EXEC
 910 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
 911    will always stop after exec.  */
 912
 913 static int
 914 fbsd_insert_exec_catchpoint (struct target_ops *self, int pid)
 915 {
 916   return 0;
 917 }
 918
 919 static int
 920 fbsd_remove_exec_catchpoint (struct target_ops *self, int pid)
 921 {
 922   return 0;
 923 }
 924 #endif
 925
 926 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
 927 static int
 928 fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
 929                              int any_count, int table_size, int *table)
 930 {
 931
 932   /* Ignore the arguments.  inf-ptrace.c will use PT_SYSCALL which
 933      will catch all system call entries and exits.  The system calls
 934      are filtered by GDB rather than the kernel.  */
 935   return 0;
 936 }
 937 #endif
 938 #endif
 939
 940 void
 941 fbsd_nat_add_target (struct target_ops *t)
 942 {
 943   t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
 944   t->to_find_memory_regions = fbsd_find_memory_regions;
 945 #ifdef KERN_PROC_AUXV
 946   super_xfer_partial = t->to_xfer_partial;
 947   t->to_xfer_partial = fbsd_xfer_partial;
 948 #endif
 949 #ifdef PT_LWPINFO
 950   t->to_thread_alive = fbsd_thread_alive;
 951   t->to_pid_to_str = fbsd_pid_to_str;
 952 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
 953   t->to_thread_name = fbsd_thread_name;
 954 #endif
 955   t->to_update_thread_list = fbsd_update_thread_list;
 956   t->to_has_thread_control = tc_schedlock;
 957   super_resume = t->to_resume;
 958   t->to_resume = fbsd_resume;
 959   super_wait = t->to_wait;
 960   t->to_wait = fbsd_wait;
 961   t->to_post_startup_inferior = fbsd_post_startup_inferior;
 962   t->to_post_attach = fbsd_post_attach;
 963 #ifdef TDP_RFPPWAIT
 964   t->to_follow_fork = fbsd_follow_fork;
 965   t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;
 966   t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;
 967   t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;
 968   t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;
 969 #endif
 970 #ifdef PL_FLAG_EXEC
 971   t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
 972   t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
 973 #endif
 974 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
 975   t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint;
 976 #endif
 977 #endif
 978   add_target (t);
 979 }
 980
 981 /* Provide a prototype to silence -Wmissing-prototypes.  */
 982 extern initialize_file_ftype _initialize_fbsd_nat;
 983
 984 void
 985 _initialize_fbsd_nat (void)
 986 {
 987 #ifdef PT_LWPINFO
 988   add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
 989                            &debug_fbsd_lwp, _("\
 990 Set debugging of FreeBSD lwp module."), _("\
 991 Show debugging of FreeBSD lwp module."), _("\
 992 Enables printf debugging output."),
 993                            NULL,
 994                            &show_fbsd_lwp_debug,
 995                            &setdebuglist, &showdebuglist);
 996 #endif
 997 }