1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
26 #include "gdbthread.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
40 /* Return the name of a file that can be opened to get the symbols for
41 the child process identified by PID. */
44 fbsd_pid_to_exec_file (struct target_ops
*self
, int pid
)
47 static char buf
[PATH_MAX
];
50 #ifdef KERN_PROC_PATHNAME
56 mib
[2] = KERN_PROC_PATHNAME
;
59 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
63 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
64 len
= readlink (name
, buf
, PATH_MAX
- 1);
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
80 fbsd_find_memory_regions (struct target_ops
*self
,
81 find_memory_region_ftype func
, void *obfd
)
83 pid_t pid
= ptid_get_pid (inferior_ptid
);
84 struct kinfo_vmentry
*vmentl
, *kve
;
86 struct cleanup
*cleanup
;
89 vmentl
= kinfo_getvmmap (pid
, &nitems
);
91 perror_with_name (_("Couldn't fetch VM map entries."));
92 cleanup
= make_cleanup (free
, vmentl
);
94 for (i
= 0; i
< nitems
; i
++)
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
)
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
)
110 size
= kve
->kve_end
- kve
->kve_start
;
113 fprintf_filtered (gdb_stdout
,
114 "Save segment, %ld bytes at %s (%c%c%c)\n",
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' : '-');
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
);
128 do_cleanups (cleanup
);
133 fbsd_read_mapping (FILE *mapfile
, unsigned long *start
, unsigned long *end
,
136 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
138 int resident
, privateresident
;
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
);
150 return (ret
!= 0 && ret
!= EOF
);
153 /* Iterate over all the memory regions in the current inferior,
154 calling FUNC for each memory region. OBFD is passed as the last
158 fbsd_find_memory_regions (struct target_ops
*self
,
159 find_memory_region_ftype func
, void *obfd
)
161 pid_t pid
= ptid_get_pid (inferior_ptid
);
164 unsigned long start
, end
, size
;
166 int read
, write
, exec
;
167 struct cleanup
*cleanup
;
169 mapfilename
= xstrprintf ("/proc/%ld/map", (long) pid
);
170 cleanup
= make_cleanup (xfree
, mapfilename
);
171 mapfile
= fopen (mapfilename
, "r");
173 error (_("Couldn't open %s."), mapfilename
);
174 make_cleanup_fclose (mapfile
);
177 fprintf_filtered (gdb_stdout
,
178 "Reading memory regions from %s\n", mapfilename
);
180 /* Now iterate until end-of-file. */
181 while (fbsd_read_mapping (mapfile
, &start
, &end
, &protection
[0]))
185 read
= (strchr (protection
, 'r') != 0);
186 write
= (strchr (protection
, 'w') != 0);
187 exec
= (strchr (protection
, 'x') != 0);
191 fprintf_filtered (gdb_stdout
,
192 "Save segment, %ld bytes at %s (%c%c%c)\n",
193 size
, paddress (target_gdbarch (), start
),
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
);
204 do_cleanups (cleanup
);
209 #ifdef KERN_PROC_AUXV
210 static enum target_xfer_status (*super_xfer_partial
) (struct target_ops
*ops
,
211 enum target_object object
,
214 const gdb_byte
*writebuf
,
217 ULONGEST
*xfered_len
);
219 /* Implement the "to_xfer_partial target_ops" method. */
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
)
227 pid_t pid
= ptid_get_pid (inferior_ptid
);
231 case TARGET_OBJECT_AUXV
:
233 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
238 if (writebuf
!= NULL
)
239 return TARGET_XFER_E_IO
;
242 mib
[2] = KERN_PROC_AUXV
;
251 buflen
= offset
+ len
;
252 buf
= XCNEWVEC (unsigned char, buflen
);
253 cleanup
= make_cleanup (xfree
, buf
);
255 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
262 memcpy (readbuf
, buf
+ offset
, buflen
);
267 do_cleanups (cleanup
);
268 *xfered_len
= buflen
;
269 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
271 do_cleanups (cleanup
);
272 return TARGET_XFER_E_IO
;
275 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
, offset
,
282 static int debug_fbsd_lwp
;
284 static void (*super_resume
) (struct target_ops
*,
288 static ptid_t (*super_wait
) (struct target_ops
*,
290 struct target_waitstatus
*,
294 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
295 struct cmd_list_element
*c
, const char *value
)
297 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
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. */
305 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
313 mib
[2] = KERN_PROC_PID
;
315 if (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == -1)
316 perror_with_name (("sysctl"));
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.
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).
332 FreeBSD 5.3 added a libthread_db to abstract the interface across
333 the various thread libraries (libc_r, libkse, and libthr).
335 FreeBSD 7.0 switched the default threading library from from libkse
336 to libpthread and removed libc_r.
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.
344 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
347 /* Return true if PTID is still active in the inferior. */
350 fbsd_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
352 if (ptid_lwp_p (ptid
))
354 struct ptrace_lwpinfo pl
;
356 if (ptrace (PT_LWPINFO
, ptid_get_lwp (ptid
), (caddr_t
) &pl
, sizeof pl
)
359 #ifdef PL_FLAG_EXITED
360 if (pl
.pl_flags
& PL_FLAG_EXITED
)
368 /* Convert PTID to a string. Returns the string in a static
372 fbsd_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
376 lwp
= ptid_get_lwp (ptid
);
380 int pid
= ptid_get_pid (ptid
);
382 xsnprintf (buf
, sizeof buf
, "LWP %d of process %d", lwp
, pid
);
386 return normal_pid_to_str (ptid
);
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. */
394 fbsd_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
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];
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
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)
410 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
415 /* Enable additional event reporting on new processes.
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
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
429 fbsd_enable_proc_events (pid_t pid
)
431 #ifdef PT_GET_EVENT_MASK
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"));
443 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
444 perror_with_name (("ptrace"));
447 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
448 perror_with_name (("ptrace"));
453 /* Add threads for any new LWPs in a process.
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. */
460 fbsd_add_threads (pid_t pid
)
462 struct cleanup
*cleanup
;
466 gdb_assert (!in_thread_list (pid_to_ptid (pid
)));
467 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
469 perror_with_name (("ptrace"));
471 lwps
= XCNEWVEC (lwpid_t
, nlwps
);
472 cleanup
= make_cleanup (xfree
, lwps
);
474 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
, nlwps
);
476 perror_with_name (("ptrace"));
478 for (i
= 0; i
< nlwps
; i
++)
480 ptid_t ptid
= ptid_build (pid
, lwps
[i
], 0);
482 if (!in_thread_list (ptid
))
485 struct ptrace_lwpinfo pl
;
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
)
495 fprintf_unfiltered (gdb_stdlog
,
496 "FLWP: adding thread for LWP %u\n",
501 do_cleanups (cleanup
);
504 /* Implement the "to_update_thread_list" target_ops method. */
507 fbsd_update_thread_list (struct target_ops
*ops
)
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 ();
516 fbsd_add_threads (ptid_get_pid (inferior_ptid
));
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
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.
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.
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
550 This implementation requires both of these fixes for simplicity's
551 sake. FreeBSD versions newer than 9.1 contain both fixes.
554 struct fbsd_fork_info
556 struct fbsd_fork_info
*next
;
560 static struct fbsd_fork_info
*fbsd_pending_children
;
562 /* Record a new child process event that is reported before the
563 corresponding fork event in the parent. */
566 fbsd_remember_child (ptid_t pid
)
568 struct fbsd_fork_info
*info
= XCNEW (struct fbsd_fork_info
);
571 info
->next
= fbsd_pending_children
;
572 fbsd_pending_children
= info
;
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. */
579 fbsd_is_child_pending (pid_t pid
)
581 struct fbsd_fork_info
*info
, *prev
;
585 for (info
= fbsd_pending_children
; info
; prev
= info
, info
= info
->next
)
587 if (ptid_get_pid (info
->ptid
) == pid
)
590 fbsd_pending_children
= info
->next
;
592 prev
->next
= info
->next
;
601 static struct fbsd_fork_info
*fbsd_pending_vfork_done
;
603 /* Record a pending vfork done event. */
606 fbsd_add_vfork_done (ptid_t pid
)
608 struct fbsd_fork_info
*info
= XCNEW (struct fbsd_fork_info
);
611 info
->next
= fbsd_pending_vfork_done
;
612 fbsd_pending_vfork_done
= info
;
615 /* Check for a pending vfork done event for a specific PID. */
618 fbsd_is_vfork_done_pending (pid_t pid
)
620 struct fbsd_fork_info
*info
;
622 for (info
= fbsd_pending_vfork_done
; info
!= NULL
; info
= info
->next
)
624 if (ptid_get_pid (info
->ptid
) == pid
)
630 /* Check for a pending vfork done event. If one is found, remove it
631 from the list and return the PTID. */
634 fbsd_next_vfork_done (void)
636 struct fbsd_fork_info
*info
;
639 if (fbsd_pending_vfork_done
!= NULL
)
641 info
= fbsd_pending_vfork_done
;
642 fbsd_pending_vfork_done
= info
->next
;
652 resume_one_thread_cb (struct thread_info
*tp
, void *data
)
654 ptid_t
*ptid
= (ptid_t
*) data
;
657 if (ptid_get_pid (tp
->ptid
) != ptid_get_pid (*ptid
))
660 if (ptid_get_lwp (tp
->ptid
) == ptid_get_lwp (*ptid
))
663 request
= PT_SUSPEND
;
665 if (ptrace (request
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
666 perror_with_name (("ptrace"));
671 resume_all_threads_cb (struct thread_info
*tp
, void *data
)
673 ptid_t
*filter
= (ptid_t
*) data
;
675 if (!ptid_match (tp
->ptid
, *filter
))
678 if (ptrace (PT_RESUME
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
679 perror_with_name (("ptrace"));
683 /* Implement the "to_resume" target_ops method. */
686 fbsd_resume (struct target_ops
*ops
,
687 ptid_t ptid
, int step
, enum gdb_signal signo
)
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
);
696 pid
= ptid_get_pid (ptid
);
697 if (fbsd_is_vfork_done_pending (pid
))
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
))
708 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
709 iterate_over_threads (resume_one_thread_cb
, &ptid
);
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
;
718 super_resume (ops
, ptid
, step
, signo
);
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. */
726 fbsd_wait (struct target_ops
*ops
,
727 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
734 wptid
= fbsd_next_vfork_done ();
735 if (!ptid_equal (wptid
, null_ptid
))
737 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
740 wptid
= super_wait (ops
, ptid
, ourstatus
, target_options
);
741 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
743 struct ptrace_lwpinfo pl
;
747 pid
= ptid_get_pid (wptid
);
748 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
749 perror_with_name (("ptrace"));
751 wptid
= ptid_build (pid
, pl
.pl_lwpid
, 0);
754 if (pl
.pl_flags
& PL_FLAG_EXITED
)
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
))
763 fprintf_unfiltered (gdb_stdlog
,
764 "FLWP: deleting thread for LWP %u\n",
766 if (print_thread_events
)
767 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
769 delete_thread (wptid
);
771 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
772 perror_with_name (("ptrace"));
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
783 if (in_thread_list (pid_to_ptid (pid
)))
786 fprintf_unfiltered (gdb_stdlog
,
787 "FLWP: using LWP %u for first thread\n",
789 thread_change_ptid (pid_to_ptid (pid
), wptid
);
793 if (pl
.pl_flags
& PL_FLAG_BORN
)
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
))
802 fprintf_unfiltered (gdb_stdlog
,
803 "FLWP: adding thread for LWP %u\n",
807 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
813 if (pl
.pl_flags
& PL_FLAG_FORKED
)
815 struct kinfo_proc kp
;
819 child
= pl
.pl_child_pid
;
820 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
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
))
826 pid
= waitpid (child
, &status
, 0);
828 perror_with_name (("waitpid"));
830 gdb_assert (pid
== child
);
832 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
833 perror_with_name (("ptrace"));
835 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
836 child_ptid
= ptid_build (child
, pl
.pl_lwpid
, 0);
839 /* For vfork, the child process will have the P_PPWAIT
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
;
849 if (pl
.pl_flags
& PL_FLAG_CHILD
)
851 /* Remember that this child forked, but do not report it
852 until the parent reports its corresponding fork
854 fbsd_remember_child (wptid
);
860 if (pl
.pl_flags
& PL_FLAG_EXEC
)
862 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
863 ourstatus
->value
.execd_pathname
864 = xstrdup (fbsd_pid_to_exec_file (NULL
, pid
));
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
)
879 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
880 if (catch_syscall_enabled ())
882 if (catching_syscall_number (pl
.pl_syscall_code
))
884 if (pl
.pl_flags
& PL_FLAG_SCE
)
885 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
887 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
888 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
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"));
908 /* Target hook for follow_fork. On entry and at return inferior_ptid is
909 the ptid of the followed inferior. */
912 fbsd_follow_fork (struct target_ops
*ops
, int follow_child
,
915 if (!follow_child
&& detach_fork
)
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
);
921 /* Breakpoints have already been detached from the child by
924 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
925 perror_with_name (("ptrace"));
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.
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
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. */
949 /* Schedule a fake VFORK_DONE event to report on the next
951 fbsd_add_vfork_done (inferior_ptid
);
959 fbsd_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
965 fbsd_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
971 fbsd_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
977 fbsd_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
983 /* Implement the "to_post_startup_inferior" target_ops method. */
986 fbsd_post_startup_inferior (struct target_ops
*self
, ptid_t pid
)
988 fbsd_enable_proc_events (ptid_get_pid (pid
));
991 /* Implement the "to_post_attach" target_ops method. */
994 fbsd_post_attach (struct target_ops
*self
, int pid
)
996 fbsd_enable_proc_events (pid
);
997 fbsd_add_threads (pid
);
1001 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1002 will always stop after exec. */
1005 fbsd_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
1011 fbsd_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
1017 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1019 fbsd_set_syscall_catchpoint (struct target_ops
*self
, int pid
, int needed
,
1020 int any_count
, int table_size
, int *table
)
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. */
1032 fbsd_nat_add_target (struct target_ops
*t
)
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
;
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
;
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
;
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
;
1062 t
->to_insert_exec_catchpoint
= fbsd_insert_exec_catchpoint
;
1063 t
->to_remove_exec_catchpoint
= fbsd_remove_exec_catchpoint
;
1065 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1066 t
->to_set_syscall_catchpoint
= fbsd_set_syscall_catchpoint
;
1072 /* Provide a prototype to silence -Wmissing-prototypes. */
1073 extern initialize_file_ftype _initialize_fbsd_nat
;
1076 _initialize_fbsd_nat (void)
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."),
1085 &show_fbsd_lwp_debug
,
1086 &setdebuglist
, &showdebuglist
);