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