gdb/fbsd-nat.c

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