Handle void * conversions in FreeBSD/x86 native code to fix C++ build.
[external/binutils.git] / 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 PT_LWPINFO
210 static int debug_fbsd_lwp;
211
212 static ptid_t (*super_wait) (struct target_ops *,
213                              ptid_t,
214                              struct target_waitstatus *,
215                              int);
216
217 static void
218 show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
219                      struct cmd_list_element *c, const char *value)
220 {
221   fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
222 }
223
224 #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
225 /* Fetch the external variant of the kernel's internal process
226    structure for the process PID into KP.  */
227
228 static void
229 fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
230 {
231   size_t len;
232   int mib[4];
233
234   len = sizeof *kp;
235   mib[0] = CTL_KERN;
236   mib[1] = KERN_PROC;
237   mib[2] = KERN_PROC_PID;
238   mib[3] = pid;
239   if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)
240     perror_with_name (("sysctl"));
241 }
242 #endif
243
244 /*
245   FreeBSD's first thread support was via a "reentrant" version of libc
246   (libc_r) that first shipped in 2.2.7.  This library multiplexed all
247   of the threads in a process onto a single kernel thread.  This
248   library is supported via the bsd-uthread target.
249
250   FreeBSD 5.1 introduced two new threading libraries that made use of
251   multiple kernel threads.  The first (libkse) scheduled M user
252   threads onto N (<= M) kernel threads (LWPs).  The second (libthr)
253   bound each user thread to a dedicated kernel thread.  libkse shipped
254   as the default threading library (libpthread).
255
256   FreeBSD 5.3 added a libthread_db to abstract the interface across
257   the various thread libraries (libc_r, libkse, and libthr).
258
259   FreeBSD 7.0 switched the default threading library from from libkse
260   to libpthread and removed libc_r.
261
262   FreeBSD 8.0 removed libkse and the in-kernel support for it.  The
263   only threading library supported by 8.0 and later is libthr which
264   ties each user thread directly to an LWP.  To simplify the
265   implementation, this target only supports LWP-backed threads using
266   ptrace directly rather than libthread_db.
267
268   FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
269 */
270
271 /* Return true if PTID is still active in the inferior.  */
272
273 static int
274 fbsd_thread_alive (struct target_ops *ops, ptid_t ptid)
275 {
276   if (ptid_lwp_p (ptid))
277     {
278       struct ptrace_lwpinfo pl;
279
280       if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)
281           == -1)
282         return 0;
283 #ifdef PL_FLAG_EXITED
284       if (pl.pl_flags & PL_FLAG_EXITED)
285         return 0;
286 #endif
287     }
288
289   return 1;
290 }
291
292 /* Convert PTID to a string.  Returns the string in a static
293    buffer.  */
294
295 static char *
296 fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
297 {
298   lwpid_t lwp;
299
300   lwp = ptid_get_lwp (ptid);
301   if (lwp != 0)
302     {
303       static char buf[64];
304       int pid = ptid_get_pid (ptid);
305
306       xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid);
307       return buf;
308     }
309
310   return normal_pid_to_str (ptid);
311 }
312
313 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
314 /* Return the name assigned to a thread by an application.  Returns
315    the string in a static buffer.  */
316
317 static const char *
318 fbsd_thread_name (struct target_ops *self, struct thread_info *thr)
319 {
320   struct ptrace_lwpinfo pl;
321   struct kinfo_proc kp;
322   int pid = ptid_get_pid (thr->ptid);
323   long lwp = ptid_get_lwp (thr->ptid);
324   static char buf[sizeof pl.pl_tdname + 1];
325
326   /* Note that ptrace_lwpinfo returns the process command in pl_tdname
327      if a name has not been set explicitly.  Return a NULL name in
328      that case.  */
329   fbsd_fetch_kinfo_proc (pid, &kp);
330   if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
331     perror_with_name (("ptrace"));
332   if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
333     return NULL;
334   xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);
335   return buf;
336 }
337 #endif
338
339 #ifdef PT_LWP_EVENTS
340 /* Enable LWP events for a specific process.
341
342    To catch LWP events, PT_LWP_EVENTS is set on every traced process.
343    This enables stops on the birth for new LWPs (excluding the "main" LWP)
344    and the death of LWPs (excluding the last LWP in a process).  Note
345    that unlike fork events, the LWP that creates a new LWP does not
346    report an event.  */
347
348 static void
349 fbsd_enable_lwp_events (pid_t pid)
350 {
351   if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
352     perror_with_name (("ptrace"));
353 }
354 #endif
355
356 /* Add threads for any new LWPs in a process.
357
358    When LWP events are used, this function is only used to detect existing
359    threads when attaching to a process.  On older systems, this function is
360    called to discover new threads each time the thread list is updated.  */
361
362 static void
363 fbsd_add_threads (pid_t pid)
364 {
365   struct cleanup *cleanup;
366   lwpid_t *lwps;
367   int i, nlwps;
368
369   gdb_assert (!in_thread_list (pid_to_ptid (pid)));
370   nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
371   if (nlwps == -1)
372     perror_with_name (("ptrace"));
373
374   lwps = XCNEWVEC (lwpid_t, nlwps);
375   cleanup = make_cleanup (xfree, lwps);
376
377   nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);
378   if (nlwps == -1)
379     perror_with_name (("ptrace"));
380
381   for (i = 0; i < nlwps; i++)
382     {
383       ptid_t ptid = ptid_build (pid, lwps[i], 0);
384
385       if (!in_thread_list (ptid))
386         {
387 #ifdef PT_LWP_EVENTS
388           struct ptrace_lwpinfo pl;
389
390           /* Don't add exited threads.  Note that this is only called
391              when attaching to a multi-threaded process.  */
392           if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1)
393             perror_with_name (("ptrace"));
394           if (pl.pl_flags & PL_FLAG_EXITED)
395             continue;
396 #endif
397           if (debug_fbsd_lwp)
398             fprintf_unfiltered (gdb_stdlog,
399                                 "FLWP: adding thread for LWP %u\n",
400                                 lwps[i]);
401           add_thread (ptid);
402         }
403     }
404   do_cleanups (cleanup);
405 }
406
407 /* Implement the "to_update_thread_list" target_ops method.  */
408
409 static void
410 fbsd_update_thread_list (struct target_ops *ops)
411 {
412 #ifdef PT_LWP_EVENTS
413   /* With support for thread events, threads are added/deleted from the
414      list as events are reported, so just try deleting exited threads.  */
415   delete_exited_threads ();
416 #else
417   prune_threads ();
418
419   fbsd_add_threads (ptid_get_pid (inferior_ptid));
420 #endif
421 }
422
423 static void (*super_resume) (struct target_ops *,
424                              ptid_t,
425                              int,
426                              enum gdb_signal);
427
428 static int
429 resume_one_thread_cb (struct thread_info *tp, void *data)
430 {
431   ptid_t *ptid = (ptid_t *) data;
432   int request;
433
434   if (ptid_get_pid (tp->ptid) != ptid_get_pid (*ptid))
435     return 0;
436
437   if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (*ptid))
438     request = PT_RESUME;
439   else
440     request = PT_SUSPEND;
441
442   if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
443     perror_with_name (("ptrace"));
444   return 0;
445 }
446
447 static int
448 resume_all_threads_cb (struct thread_info *tp, void *data)
449 {
450   ptid_t *filter = (ptid_t *) data;
451
452   if (!ptid_match (tp->ptid, *filter))
453     return 0;
454
455   if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
456     perror_with_name (("ptrace"));
457   return 0;
458 }
459
460 /* Implement the "to_resume" target_ops method.  */
461
462 static void
463 fbsd_resume (struct target_ops *ops,
464              ptid_t ptid, int step, enum gdb_signal signo)
465 {
466
467   if (debug_fbsd_lwp)
468     fprintf_unfiltered (gdb_stdlog,
469                         "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
470                         ptid_get_pid (ptid), ptid_get_lwp (ptid),
471                         ptid_get_tid (ptid));
472   if (ptid_lwp_p (ptid))
473     {
474       /* If ptid is a specific LWP, suspend all other LWPs in the process.  */
475       iterate_over_threads (resume_one_thread_cb, &ptid);
476     }
477   else
478     {
479       /* If ptid is a wildcard, resume all matching threads (they won't run
480          until the process is continued however).  */
481       iterate_over_threads (resume_all_threads_cb, &ptid);
482       ptid = inferior_ptid;
483     }
484   super_resume (ops, ptid, step, signo);
485 }
486
487 #ifdef TDP_RFPPWAIT
488 /*
489   To catch fork events, PT_FOLLOW_FORK is set on every traced process
490   to enable stops on returns from fork or vfork.  Note that both the
491   parent and child will always stop, even if system call stops are not
492   enabled.
493
494   After a fork, both the child and parent process will stop and report
495   an event.  However, there is no guarantee of order.  If the parent
496   reports its stop first, then fbsd_wait explicitly waits for the new
497   child before returning.  If the child reports its stop first, then
498   the event is saved on a list and ignored until the parent's stop is
499   reported.  fbsd_wait could have been changed to fetch the parent PID
500   of the new child and used that to wait for the parent explicitly.
501   However, if two threads in the parent fork at the same time, then
502   the wait on the parent might return the "wrong" fork event.
503
504   The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
505   the new child process.  This flag could be inferred by treating any
506   events for an unknown pid as a new child.
507
508   In addition, the initial version of PT_FOLLOW_FORK did not report a
509   stop event for the parent process of a vfork until after the child
510   process executed a new program or exited.  The kernel was changed to
511   defer the wait for exit or exec of the child until after posting the
512   stop event shortly after the change to introduce PL_FLAG_CHILD.
513   This could be worked around by reporting a vfork event when the
514   child event posted and ignoring the subsequent event from the
515   parent.
516
517   This implementation requires both of these fixes for simplicity's
518   sake.  FreeBSD versions newer than 9.1 contain both fixes.
519 */
520
521 struct fbsd_fork_child_info
522 {
523   struct fbsd_fork_child_info *next;
524   ptid_t child;                 /* Pid of new child.  */
525 };
526
527 static struct fbsd_fork_child_info *fbsd_pending_children;
528
529 /* Record a new child process event that is reported before the
530    corresponding fork event in the parent.  */
531
532 static void
533 fbsd_remember_child (ptid_t pid)
534 {
535   struct fbsd_fork_child_info *info = XCNEW (struct fbsd_fork_child_info);
536
537   info->child = pid;
538   info->next = fbsd_pending_children;
539   fbsd_pending_children = info;
540 }
541
542 /* Check for a previously-recorded new child process event for PID.
543    If one is found, remove it from the list and return the PTID.  */
544
545 static ptid_t
546 fbsd_is_child_pending (pid_t pid)
547 {
548   struct fbsd_fork_child_info *info, *prev;
549   ptid_t ptid;
550
551   prev = NULL;
552   for (info = fbsd_pending_children; info; prev = info, info = info->next)
553     {
554       if (ptid_get_pid (info->child) == pid)
555         {
556           if (prev == NULL)
557             fbsd_pending_children = info->next;
558           else
559             prev->next = info->next;
560           ptid = info->child;
561           xfree (info);
562           return ptid;
563         }
564     }
565   return null_ptid;
566 }
567 #endif
568
569 /* Wait for the child specified by PTID to do something.  Return the
570    process ID of the child, or MINUS_ONE_PTID in case of error; store
571    the status in *OURSTATUS.  */
572
573 static ptid_t
574 fbsd_wait (struct target_ops *ops,
575            ptid_t ptid, struct target_waitstatus *ourstatus,
576            int target_options)
577 {
578   ptid_t wptid;
579
580   while (1)
581     {
582       wptid = super_wait (ops, ptid, ourstatus, target_options);
583       if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
584         {
585           struct ptrace_lwpinfo pl;
586           pid_t pid;
587           int status;
588
589           pid = ptid_get_pid (wptid);
590           if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
591             perror_with_name (("ptrace"));
592
593           wptid = ptid_build (pid, pl.pl_lwpid, 0);
594
595 #ifdef PT_LWP_EVENTS
596           if (pl.pl_flags & PL_FLAG_EXITED)
597             {
598               /* If GDB attaches to a multi-threaded process, exiting
599                  threads might be skipped during fbsd_post_attach that
600                  have not yet reported their PL_FLAG_EXITED event.
601                  Ignore EXITED events for an unknown LWP.  */
602               if (in_thread_list (wptid))
603                 {
604                   if (debug_fbsd_lwp)
605                     fprintf_unfiltered (gdb_stdlog,
606                                         "FLWP: deleting thread for LWP %u\n",
607                                         pl.pl_lwpid);
608                   if (print_thread_events)
609                     printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
610                                        (wptid));
611                   delete_thread (wptid);
612                 }
613               if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
614                 perror_with_name (("ptrace"));
615               continue;
616             }
617 #endif
618
619           /* Switch to an LWP PTID on the first stop in a new process.
620              This is done after handling PL_FLAG_EXITED to avoid
621              switching to an exited LWP.  It is done before checking
622              PL_FLAG_BORN in case the first stop reported after
623              attaching to an existing process is a PL_FLAG_BORN
624              event.  */
625           if (in_thread_list (pid_to_ptid (pid)))
626             {
627               if (debug_fbsd_lwp)
628                 fprintf_unfiltered (gdb_stdlog,
629                                     "FLWP: using LWP %u for first thread\n",
630                                     pl.pl_lwpid);
631               thread_change_ptid (pid_to_ptid (pid), wptid);
632             }
633
634 #ifdef PT_LWP_EVENTS
635           if (pl.pl_flags & PL_FLAG_BORN)
636             {
637               /* If GDB attaches to a multi-threaded process, newborn
638                  threads might be added by fbsd_add_threads that have
639                  not yet reported their PL_FLAG_BORN event.  Ignore
640                  BORN events for an already-known LWP.  */
641               if (!in_thread_list (wptid))
642                 {
643                   if (debug_fbsd_lwp)
644                     fprintf_unfiltered (gdb_stdlog,
645                                         "FLWP: adding thread for LWP %u\n",
646                                         pl.pl_lwpid);
647                   add_thread (wptid);
648                 }
649               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
650               return wptid;
651             }
652 #endif
653
654 #ifdef TDP_RFPPWAIT
655           if (pl.pl_flags & PL_FLAG_FORKED)
656             {
657               struct kinfo_proc kp;
658               ptid_t child_ptid;
659               pid_t child;
660
661               child = pl.pl_child_pid;
662               ourstatus->kind = TARGET_WAITKIND_FORKED;
663
664               /* Make sure the other end of the fork is stopped too.  */
665               child_ptid = fbsd_is_child_pending (child);
666               if (ptid_equal (child_ptid, null_ptid))
667                 {
668                   pid = waitpid (child, &status, 0);
669                   if (pid == -1)
670                     perror_with_name (("waitpid"));
671
672                   gdb_assert (pid == child);
673
674                   if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
675                     perror_with_name (("ptrace"));
676
677                   gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
678                   child_ptid = ptid_build (child, pl.pl_lwpid, 0);
679                 }
680
681               /* For vfork, the child process will have the P_PPWAIT
682                  flag set.  */
683               fbsd_fetch_kinfo_proc (child, &kp);
684               if (kp.ki_flag & P_PPWAIT)
685                 ourstatus->kind = TARGET_WAITKIND_VFORKED;
686               ourstatus->value.related_pid = child_ptid;
687
688               return wptid;
689             }
690
691           if (pl.pl_flags & PL_FLAG_CHILD)
692             {
693               /* Remember that this child forked, but do not report it
694                  until the parent reports its corresponding fork
695                  event.  */
696               fbsd_remember_child (wptid);
697               continue;
698             }
699 #endif
700
701 #ifdef PL_FLAG_EXEC
702           if (pl.pl_flags & PL_FLAG_EXEC)
703             {
704               ourstatus->kind = TARGET_WAITKIND_EXECD;
705               ourstatus->value.execd_pathname
706                 = xstrdup (fbsd_pid_to_exec_file (NULL, pid));
707               return wptid;
708             }
709 #endif
710         }
711       return wptid;
712     }
713 }
714
715 #ifdef TDP_RFPPWAIT
716 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
717    the ptid of the followed inferior.  */
718
719 static int
720 fbsd_follow_fork (struct target_ops *ops, int follow_child,
721                         int detach_fork)
722 {
723   if (!follow_child)
724     {
725       struct thread_info *tp = inferior_thread ();
726       pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
727
728       /* Breakpoints have already been detached from the child by
729          infrun.c.  */
730
731       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
732         perror_with_name (("ptrace"));
733     }
734
735   return 0;
736 }
737
738 static int
739 fbsd_insert_fork_catchpoint (struct target_ops *self, int pid)
740 {
741   return 0;
742 }
743
744 static int
745 fbsd_remove_fork_catchpoint (struct target_ops *self, int pid)
746 {
747   return 0;
748 }
749
750 static int
751 fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid)
752 {
753   return 0;
754 }
755
756 static int
757 fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid)
758 {
759   return 0;
760 }
761
762 /* Enable fork tracing for a specific process.
763    
764    To catch fork events, PT_FOLLOW_FORK is set on every traced process
765    to enable stops on returns from fork or vfork.  Note that both the
766    parent and child will always stop, even if system call stops are
767    not enabled.  */
768
769 static void
770 fbsd_enable_follow_fork (pid_t pid)
771 {
772   if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
773     perror_with_name (("ptrace"));
774 }
775 #endif
776
777 /* Implement the "to_post_startup_inferior" target_ops method.  */
778
779 static void
780 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
781 {
782 #ifdef TDP_RFPPWAIT
783   fbsd_enable_follow_fork (ptid_get_pid (pid));
784 #endif
785 #ifdef PT_LWP_EVENTS
786   fbsd_enable_lwp_events (ptid_get_pid (pid));
787 #endif
788 }
789
790 /* Implement the "to_post_attach" target_ops method.  */
791
792 static void
793 fbsd_post_attach (struct target_ops *self, int pid)
794 {
795 #ifdef TDP_RFPPWAIT
796   fbsd_enable_follow_fork (pid);
797 #endif
798 #ifdef PT_LWP_EVENTS
799   fbsd_enable_lwp_events (pid);
800 #endif
801   fbsd_add_threads (pid);
802 }
803
804 #ifdef PL_FLAG_EXEC
805 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
806    will always stop after exec.  */
807
808 static int
809 fbsd_insert_exec_catchpoint (struct target_ops *self, int pid)
810 {
811   return 0;
812 }
813
814 static int
815 fbsd_remove_exec_catchpoint (struct target_ops *self, int pid)
816 {
817   return 0;
818 }
819 #endif
820 #endif
821
822 void
823 fbsd_nat_add_target (struct target_ops *t)
824 {
825   t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
826   t->to_find_memory_regions = fbsd_find_memory_regions;
827 #ifdef PT_LWPINFO
828   t->to_thread_alive = fbsd_thread_alive;
829   t->to_pid_to_str = fbsd_pid_to_str;
830 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
831   t->to_thread_name = fbsd_thread_name;
832 #endif
833   t->to_update_thread_list = fbsd_update_thread_list;
834   t->to_has_thread_control = tc_schedlock;
835   super_resume = t->to_resume;
836   t->to_resume = fbsd_resume;
837   super_wait = t->to_wait;
838   t->to_wait = fbsd_wait;
839   t->to_post_startup_inferior = fbsd_post_startup_inferior;
840   t->to_post_attach = fbsd_post_attach;
841 #ifdef TDP_RFPPWAIT
842   t->to_follow_fork = fbsd_follow_fork;
843   t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;
844   t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;
845   t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;
846   t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;
847 #endif
848 #ifdef PL_FLAG_EXEC
849   t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
850   t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
851 #endif
852 #endif
853   add_target (t);
854 }
855
856 /* Provide a prototype to silence -Wmissing-prototypes.  */
857 extern initialize_file_ftype _initialize_fbsd_nat;
858
859 void
860 _initialize_fbsd_nat (void)
861 {
862 #ifdef PT_LWPINFO
863   add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
864                            &debug_fbsd_lwp, _("\
865 Set debugging of FreeBSD lwp module."), _("\
866 Show debugging of FreeBSD lwp module."), _("\
867 Enables printf debugging output."),
868                            NULL,
869                            &show_fbsd_lwp_debug,
870                            &setdebuglist, &showdebuglist);
871 #endif
872 }