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 "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 was 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 const 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 /* Enable additional event reporting on new processes.
 416
 417    To catch fork events, PTRACE_FORK is set on every traced process
 418    to enable stops on returns from fork or vfork.  Note that both the
 419    parent and child will always stop, even if system call stops are
 420    not enabled.
 421
 422    To catch LWP events, PTRACE_EVENTS is set on every traced process.
 423    This enables stops on the birth for new LWPs (excluding the "main" LWP)
 424    and the death of LWPs (excluding the last LWP in a process).  Note
 425    that unlike fork events, the LWP that creates a new LWP does not
 426    report an event.  */
 427
 428 static void
 429 fbsd_enable_proc_events (pid_t pid)
 430 {
 431 #ifdef PT_GET_EVENT_MASK
 432   int events;
 433
 434   if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
 435               sizeof (events)) == -1)
 436     perror_with_name (("ptrace"));
 437   events |= PTRACE_FORK | PTRACE_LWP;
 438 #ifdef PTRACE_VFORK
 439   events |= PTRACE_VFORK;
 440 #endif
 441   if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
 442               sizeof (events)) == -1)
 443     perror_with_name (("ptrace"));
 444 #else
 445 #ifdef TDP_RFPPWAIT
 446   if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 447     perror_with_name (("ptrace"));
 448 #endif
 449 #ifdef PT_LWP_EVENTS
 450   if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
 451     perror_with_name (("ptrace"));
 452 #endif
 453 #endif
 454 }
 455
 456 /* Add threads for any new LWPs in a process.
 457
 458    When LWP events are used, this function is only used to detect existing
 459    threads when attaching to a process.  On older systems, this function is
 460    called to discover new threads each time the thread list is updated.  */
 461
 462 static void
 463 fbsd_add_threads (pid_t pid)
 464 {
 465   struct cleanup *cleanup;
 466   lwpid_t *lwps;
 467   int i, nlwps;
 468
 469   gdb_assert (!in_thread_list (pid_to_ptid (pid)));
 470   nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
 471   if (nlwps == -1)
 472     perror_with_name (("ptrace"));
 473
 474   lwps = XCNEWVEC (lwpid_t, nlwps);
 475   cleanup = make_cleanup (xfree, lwps);
 476
 477   nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);
 478   if (nlwps == -1)
 479     perror_with_name (("ptrace"));
 480
 481   for (i = 0; i < nlwps; i++)
 482     {
 483       ptid_t ptid = ptid_build (pid, lwps[i], 0);
 484
 485       if (!in_thread_list (ptid))
 486         {
 487 #ifdef PT_LWP_EVENTS
 488           struct ptrace_lwpinfo pl;
 489
 490           /* Don't add exited threads.  Note that this is only called
 491              when attaching to a multi-threaded process.  */
 492           if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1)
 493             perror_with_name (("ptrace"));
 494           if (pl.pl_flags & PL_FLAG_EXITED)
 495             continue;
 496 #endif
 497           if (debug_fbsd_lwp)
 498             fprintf_unfiltered (gdb_stdlog,
 499                                 "FLWP: adding thread for LWP %u\n",
 500                                 lwps[i]);
 501           add_thread (ptid);
 502         }
 503     }
 504   do_cleanups (cleanup);
 505 }
 506
 507 /* Implement the "to_update_thread_list" target_ops method.  */
 508
 509 static void
 510 fbsd_update_thread_list (struct target_ops *ops)
 511 {
 512 #ifdef PT_LWP_EVENTS
 513   /* With support for thread events, threads are added/deleted from the
 514      list as events are reported, so just try deleting exited threads.  */
 515   delete_exited_threads ();
 516 #else
 517   prune_threads ();
 518
 519   fbsd_add_threads (ptid_get_pid (inferior_ptid));
 520 #endif
 521 }
 522
 523 #ifdef TDP_RFPPWAIT
 524 /*
 525   To catch fork events, PT_FOLLOW_FORK is set on every traced process
 526   to enable stops on returns from fork or vfork.  Note that both the
 527   parent and child will always stop, even if system call stops are not
 528   enabled.
 529
 530   After a fork, both the child and parent process will stop and report
 531   an event.  However, there is no guarantee of order.  If the parent
 532   reports its stop first, then fbsd_wait explicitly waits for the new
 533   child before returning.  If the child reports its stop first, then
 534   the event is saved on a list and ignored until the parent's stop is
 535   reported.  fbsd_wait could have been changed to fetch the parent PID
 536   of the new child and used that to wait for the parent explicitly.
 537   However, if two threads in the parent fork at the same time, then
 538   the wait on the parent might return the "wrong" fork event.
 539
 540   The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
 541   the new child process.  This flag could be inferred by treating any
 542   events for an unknown pid as a new child.
 543
 544   In addition, the initial version of PT_FOLLOW_FORK did not report a
 545   stop event for the parent process of a vfork until after the child
 546   process executed a new program or exited.  The kernel was changed to
 547   defer the wait for exit or exec of the child until after posting the
 548   stop event shortly after the change to introduce PL_FLAG_CHILD.
 549   This could be worked around by reporting a vfork event when the
 550   child event posted and ignoring the subsequent event from the
 551   parent.
 552
 553   This implementation requires both of these fixes for simplicity's
 554   sake.  FreeBSD versions newer than 9.1 contain both fixes.
 555 */
 556
 557 struct fbsd_fork_info
 558 {
 559   struct fbsd_fork_info *next;
 560   ptid_t ptid;
 561 };
 562
 563 static struct fbsd_fork_info *fbsd_pending_children;
 564
 565 /* Record a new child process event that is reported before the
 566    corresponding fork event in the parent.  */
 567
 568 static void
 569 fbsd_remember_child (ptid_t pid)
 570 {
 571   struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
 572
 573   info->ptid = pid;
 574   info->next = fbsd_pending_children;
 575   fbsd_pending_children = info;
 576 }
 577
 578 /* Check for a previously-recorded new child process event for PID.
 579    If one is found, remove it from the list and return the PTID.  */
 580
 581 static ptid_t
 582 fbsd_is_child_pending (pid_t pid)
 583 {
 584   struct fbsd_fork_info *info, *prev;
 585   ptid_t ptid;
 586
 587   prev = NULL;
 588   for (info = fbsd_pending_children; info; prev = info, info = info->next)
 589     {
 590       if (ptid_get_pid (info->ptid) == pid)
 591         {
 592           if (prev == NULL)
 593             fbsd_pending_children = info->next;
 594           else
 595             prev->next = info->next;
 596           ptid = info->ptid;
 597           xfree (info);
 598           return ptid;
 599         }
 600     }
 601   return null_ptid;
 602 }
 603
 604 #ifndef PTRACE_VFORK
 605 static struct fbsd_fork_info *fbsd_pending_vfork_done;
 606
 607 /* Record a pending vfork done event.  */
 608
 609 static void
 610 fbsd_add_vfork_done (ptid_t pid)
 611 {
 612   struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
 613
 614   info->ptid = pid;
 615   info->next = fbsd_pending_vfork_done;
 616   fbsd_pending_vfork_done = info;
 617 }
 618
 619 /* Check for a pending vfork done event for a specific PID.  */
 620
 621 static int
 622 fbsd_is_vfork_done_pending (pid_t pid)
 623 {
 624   struct fbsd_fork_info *info;
 625
 626   for (info = fbsd_pending_vfork_done; info != NULL; info = info->next)
 627     {
 628       if (ptid_get_pid (info->ptid) == pid)
 629         return 1;
 630     }
 631   return 0;
 632 }
 633
 634 /* Check for a pending vfork done event.  If one is found, remove it
 635    from the list and return the PTID.  */
 636
 637 static ptid_t
 638 fbsd_next_vfork_done (void)
 639 {
 640   struct fbsd_fork_info *info;
 641   ptid_t ptid;
 642
 643   if (fbsd_pending_vfork_done != NULL)
 644     {
 645       info = fbsd_pending_vfork_done;
 646       fbsd_pending_vfork_done = info->next;
 647       ptid = info->ptid;
 648       xfree (info);
 649       return ptid;
 650     }
 651   return null_ptid;
 652 }
 653 #endif
 654 #endif
 655
 656 /* Implement the "to_resume" target_ops method.  */
 657
 658 static void
 659 fbsd_resume (struct target_ops *ops,
 660              ptid_t ptid, int step, enum gdb_signal signo)
 661 {
 662 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
 663   pid_t pid;
 664
 665   /* Don't PT_CONTINUE a process which has a pending vfork done event.  */
 666   if (ptid_equal (minus_one_ptid, ptid))
 667     pid = ptid_get_pid (inferior_ptid);
 668   else
 669     pid = ptid_get_pid (ptid);
 670   if (fbsd_is_vfork_done_pending (pid))
 671     return;
 672 #endif
 673
 674   if (debug_fbsd_lwp)
 675     fprintf_unfiltered (gdb_stdlog,
 676                         "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
 677                         ptid_get_pid (ptid), ptid_get_lwp (ptid),
 678                         ptid_get_tid (ptid));
 679   if (ptid_lwp_p (ptid))
 680     {
 681       /* If ptid is a specific LWP, suspend all other LWPs in the process.  */
 682       struct thread_info *tp;
 683       int request;
 684
 685       ALL_NON_EXITED_THREADS (tp)
 686         {
 687           if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid))
 688             continue;
 689
 690           if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid))
 691             request = PT_RESUME;
 692           else
 693             request = PT_SUSPEND;
 694
 695           if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 696             perror_with_name (("ptrace"));
 697         }
 698     }
 699   else
 700     {
 701       /* If ptid is a wildcard, resume all matching threads (they won't run
 702          until the process is continued however).  */
 703       struct thread_info *tp;
 704
 705       ALL_NON_EXITED_THREADS (tp)
 706         {
 707           if (!ptid_match (tp->ptid, ptid))
 708             continue;
 709
 710           if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
 711             perror_with_name (("ptrace"));
 712         }
 713       ptid = inferior_ptid;
 714     }
 715   super_resume (ops, ptid, step, signo);
 716 }
 717
 718 /* Wait for the child specified by PTID to do something.  Return the
 719    process ID of the child, or MINUS_ONE_PTID in case of error; store
 720    the status in *OURSTATUS.  */
 721
 722 static ptid_t
 723 fbsd_wait (struct target_ops *ops,
 724            ptid_t ptid, struct target_waitstatus *ourstatus,
 725            int target_options)
 726 {
 727   ptid_t wptid;
 728
 729   while (1)
 730     {
 731 #ifndef PTRACE_VFORK
 732       wptid = fbsd_next_vfork_done ();
 733       if (!ptid_equal (wptid, null_ptid))
 734         {
 735           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
 736           return wptid;
 737         }
 738 #endif
 739       wptid = super_wait (ops, ptid, ourstatus, target_options);
 740       if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
 741         {
 742           struct ptrace_lwpinfo pl;
 743           pid_t pid;
 744           int status;
 745
 746           pid = ptid_get_pid (wptid);
 747           if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
 748             perror_with_name (("ptrace"));
 749
 750           wptid = ptid_build (pid, pl.pl_lwpid, 0);
 751
 752 #ifdef PT_LWP_EVENTS
 753           if (pl.pl_flags & PL_FLAG_EXITED)
 754             {
 755               /* If GDB attaches to a multi-threaded process, exiting
 756                  threads might be skipped during fbsd_post_attach that
 757                  have not yet reported their PL_FLAG_EXITED event.
 758                  Ignore EXITED events for an unknown LWP.  */
 759               if (in_thread_list (wptid))
 760                 {
 761                   if (debug_fbsd_lwp)
 762                     fprintf_unfiltered (gdb_stdlog,
 763                                         "FLWP: deleting thread for LWP %u\n",
 764                                         pl.pl_lwpid);
 765                   if (print_thread_events)
 766                     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
 767                                        (wptid));
 768                   delete_thread (wptid);
 769                 }
 770               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
 771                 perror_with_name (("ptrace"));
 772               continue;
 773             }
 774 #endif
 775
 776           /* Switch to an LWP PTID on the first stop in a new process.
 777              This is done after handling PL_FLAG_EXITED to avoid
 778              switching to an exited LWP.  It is done before checking
 779              PL_FLAG_BORN in case the first stop reported after
 780              attaching to an existing process is a PL_FLAG_BORN
 781              event.  */
 782           if (in_thread_list (pid_to_ptid (pid)))
 783             {
 784               if (debug_fbsd_lwp)
 785                 fprintf_unfiltered (gdb_stdlog,
 786                                     "FLWP: using LWP %u for first thread\n",
 787                                     pl.pl_lwpid);
 788               thread_change_ptid (pid_to_ptid (pid), wptid);
 789             }
 790
 791 #ifdef PT_LWP_EVENTS
 792           if (pl.pl_flags & PL_FLAG_BORN)
 793             {
 794               /* If GDB attaches to a multi-threaded process, newborn
 795                  threads might be added by fbsd_add_threads that have
 796                  not yet reported their PL_FLAG_BORN event.  Ignore
 797                  BORN events for an already-known LWP.  */
 798               if (!in_thread_list (wptid))
 799                 {
 800                   if (debug_fbsd_lwp)
 801                     fprintf_unfiltered (gdb_stdlog,
 802                                         "FLWP: adding thread for LWP %u\n",
 803                                         pl.pl_lwpid);
 804                   add_thread (wptid);
 805                 }
 806               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 807               return wptid;
 808             }
 809 #endif
 810
 811 #ifdef TDP_RFPPWAIT
 812           if (pl.pl_flags & PL_FLAG_FORKED)
 813             {
 814 #ifndef PTRACE_VFORK
 815               struct kinfo_proc kp;
 816 #endif
 817               ptid_t child_ptid;
 818               pid_t child;
 819
 820               child = pl.pl_child_pid;
 821               ourstatus->kind = TARGET_WAITKIND_FORKED;
 822 #ifdef PTRACE_VFORK
 823               if (pl.pl_flags & PL_FLAG_VFORKED)
 824                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
 825 #endif
 826
 827               /* Make sure the other end of the fork is stopped too.  */
 828               child_ptid = fbsd_is_child_pending (child);
 829               if (ptid_equal (child_ptid, null_ptid))
 830                 {
 831                   pid = waitpid (child, &status, 0);
 832                   if (pid == -1)
 833                     perror_with_name (("waitpid"));
 834
 835                   gdb_assert (pid == child);
 836
 837                   if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
 838                     perror_with_name (("ptrace"));
 839
 840                   gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
 841                   child_ptid = ptid_build (child, pl.pl_lwpid, 0);
 842                 }
 843
 844               /* Enable additional events on the child process.  */
 845               fbsd_enable_proc_events (ptid_get_pid (child_ptid));
 846
 847 #ifndef PTRACE_VFORK
 848               /* For vfork, the child process will have the P_PPWAIT
 849                  flag set.  */
 850               fbsd_fetch_kinfo_proc (child, &kp);
 851               if (kp.ki_flag & P_PPWAIT)
 852                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
 853 #endif
 854               ourstatus->value.related_pid = child_ptid;
 855
 856               return wptid;
 857             }
 858
 859           if (pl.pl_flags & PL_FLAG_CHILD)
 860             {
 861               /* Remember that this child forked, but do not report it
 862                  until the parent reports its corresponding fork
 863                  event.  */
 864               fbsd_remember_child (wptid);
 865               continue;
 866             }
 867
 868 #ifdef PTRACE_VFORK
 869           if (pl.pl_flags & PL_FLAG_VFORK_DONE)
 870             {
 871               ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
 872               return wptid;
 873             }
 874 #endif
 875 #endif
 876
 877 #ifdef PL_FLAG_EXEC
 878           if (pl.pl_flags & PL_FLAG_EXEC)
 879             {
 880               ourstatus->kind = TARGET_WAITKIND_EXECD;
 881               ourstatus->value.execd_pathname
 882                 = xstrdup (fbsd_pid_to_exec_file (NULL, pid));
 883               return wptid;
 884             }
 885 #endif
 886
 887           /* Note that PL_FLAG_SCE is set for any event reported while
 888              a thread is executing a system call in the kernel.  In
 889              particular, signals that interrupt a sleep in a system
 890              call will report this flag as part of their event.  Stops
 891              explicitly for system call entry and exit always use
 892              SIGTRAP, so only treat SIGTRAP events as system call
 893              entry/exit events.  */
 894           if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
 895               && ourstatus->value.sig == SIGTRAP)
 896             {
 897 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
 898               if (catch_syscall_enabled ())
 899                 {
 900                   if (catching_syscall_number (pl.pl_syscall_code))
 901                     {
 902                       if (pl.pl_flags & PL_FLAG_SCE)
 903                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
 904                       else
 905                         ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
 906                       ourstatus->value.syscall_number = pl.pl_syscall_code;
 907                       return wptid;
 908                     }
 909                 }
 910 #endif
 911               /* If the core isn't interested in this event, just
 912                  continue the process explicitly and wait for another
 913                  event.  Note that PT_SYSCALL is "sticky" on FreeBSD
 914                  and once system call stops are enabled on a process
 915                  it stops for all system call entries and exits.  */
 916               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
 917                 perror_with_name (("ptrace"));
 918               continue;
 919             }
 920         }
 921       return wptid;
 922     }
 923 }
 924
 925 #ifdef TDP_RFPPWAIT
 926 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
 927    the ptid of the followed inferior.  */
 928
 929 static int
 930 fbsd_follow_fork (struct target_ops *ops, int follow_child,
 931                         int detach_fork)
 932 {
 933   if (!follow_child && detach_fork)
 934     {
 935       struct thread_info *tp = inferior_thread ();
 936       pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
 937
 938       /* Breakpoints have already been detached from the child by
 939          infrun.c.  */
 940
 941       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
 942         perror_with_name (("ptrace"));
 943
 944 #ifndef PTRACE_VFORK
 945       if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
 946         {
 947           /* We can't insert breakpoints until the child process has
 948              finished with the shared memory region.  The parent
 949              process doesn't wait for the child process to exit or
 950              exec until after it has been resumed from the ptrace stop
 951              to report the fork.  Once it has been resumed it doesn't
 952              stop again before returning to userland, so there is no
 953              reliable way to wait on the parent.
 954
 955              We can't stay attached to the child to wait for an exec
 956              or exit because it may invoke ptrace(PT_TRACE_ME)
 957              (e.g. if the parent process is a debugger forking a new
 958              child process).
 959
 960              In the end, the best we can do is to make sure it runs
 961              for a little while.  Hopefully it will be out of range of
 962              any breakpoints we reinsert.  Usually this is only the
 963              single-step breakpoint at vfork's return point.  */
 964
 965           usleep (10000);
 966
 967           /* Schedule a fake VFORK_DONE event to report on the next
 968              wait.  */
 969           fbsd_add_vfork_done (inferior_ptid);
 970         }
 971 #endif
 972     }
 973
 974   return 0;
 975 }
 976
 977 static int
 978 fbsd_insert_fork_catchpoint (struct target_ops *self, int pid)
 979 {
 980   return 0;
 981 }
 982
 983 static int
 984 fbsd_remove_fork_catchpoint (struct target_ops *self, int pid)
 985 {
 986   return 0;
 987 }
 988
 989 static int
 990 fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid)
 991 {
 992   return 0;
 993 }
 994
 995 static int
 996 fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid)
 997 {
 998   return 0;
 999 }
1000 #endif
1001
1002 /* Implement the "to_post_startup_inferior" target_ops method.  */
1003
1004 static void
1005 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
1006 {
1007   fbsd_enable_proc_events (ptid_get_pid (pid));
1008 }
1009
1010 /* Implement the "to_post_attach" target_ops method.  */
1011
1012 static void
1013 fbsd_post_attach (struct target_ops *self, int pid)
1014 {
1015   fbsd_enable_proc_events (pid);
1016   fbsd_add_threads (pid);
1017 }
1018
1019 #ifdef PL_FLAG_EXEC
1020 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1021    will always stop after exec.  */
1022
1023 static int
1024 fbsd_insert_exec_catchpoint (struct target_ops *self, int pid)
1025 {
1026   return 0;
1027 }
1028
1029 static int
1030 fbsd_remove_exec_catchpoint (struct target_ops *self, int pid)
1031 {
1032   return 0;
1033 }
1034 #endif
1035
1036 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1037 static int
1038 fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
1039                              int any_count, int table_size, int *table)
1040 {
1041
1042   /* Ignore the arguments.  inf-ptrace.c will use PT_SYSCALL which
1043      will catch all system call entries and exits.  The system calls
1044      are filtered by GDB rather than the kernel.  */
1045   return 0;
1046 }
1047 #endif
1048 #endif
1049
1050 void
1051 fbsd_nat_add_target (struct target_ops *t)
1052 {
1053   t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
1054   t->to_find_memory_regions = fbsd_find_memory_regions;
1055 #ifdef KERN_PROC_AUXV
1056   super_xfer_partial = t->to_xfer_partial;
1057   t->to_xfer_partial = fbsd_xfer_partial;
1058 #endif
1059 #ifdef PT_LWPINFO
1060   t->to_thread_alive = fbsd_thread_alive;
1061   t->to_pid_to_str = fbsd_pid_to_str;
1062 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
1063   t->to_thread_name = fbsd_thread_name;
1064 #endif
1065   t->to_update_thread_list = fbsd_update_thread_list;
1066   t->to_has_thread_control = tc_schedlock;
1067   super_resume = t->to_resume;
1068   t->to_resume = fbsd_resume;
1069   super_wait = t->to_wait;
1070   t->to_wait = fbsd_wait;
1071   t->to_post_startup_inferior = fbsd_post_startup_inferior;
1072   t->to_post_attach = fbsd_post_attach;
1073 #ifdef TDP_RFPPWAIT
1074   t->to_follow_fork = fbsd_follow_fork;
1075   t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;
1076   t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;
1077   t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;
1078   t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;
1079 #endif
1080 #ifdef PL_FLAG_EXEC
1081   t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
1082   t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
1083 #endif
1084 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1085   t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint;
1086 #endif
1087 #endif
1088   add_target (t);
1089 }
1090
1091 /* Provide a prototype to silence -Wmissing-prototypes.  */
1092 extern initialize_file_ftype _initialize_fbsd_nat;
1093
1094 void
1095 _initialize_fbsd_nat (void)
1096 {
1097 #ifdef PT_LWPINFO
1098   add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
1099                            &debug_fbsd_lwp, _("\
1100 Set debugging of FreeBSD lwp module."), _("\
1101 Show debugging of FreeBSD lwp module."), _("\
1102 Enables printf debugging output."),
1103                            NULL,
1104                            &show_fbsd_lwp_debug,
1105                            &setdebuglist, &showdebuglist);
1106 #endif
1107 }