1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2017 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/>. */
21 #include "byte-vector.h"
27 #include "gdbthread.h"
29 #include <sys/types.h>
30 #include <sys/procfs.h>
31 #include <sys/ptrace.h>
32 #include <sys/signal.h>
33 #include <sys/sysctl.h>
35 #ifdef HAVE_KINFO_GETVMMAP
38 #include "filestuff.h"
44 /* Return the name of a file that can be opened to get the symbols for
45 the child process identified by PID. */
48 fbsd_pid_to_exec_file (struct target_ops
*self
, int pid
)
51 static char buf
[PATH_MAX
];
54 #ifdef KERN_PROC_PATHNAME
60 mib
[2] = KERN_PROC_PATHNAME
;
63 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
67 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
68 len
= readlink (name
, buf
, PATH_MAX
- 1);
78 #ifdef HAVE_KINFO_GETVMMAP
79 /* Deleter for std::unique_ptr that invokes free. */
84 void operator() (T
*ptr
) const { free (ptr
); }
87 /* Iterate over all the memory regions in the current inferior,
88 calling FUNC for each memory region. OBFD is passed as the last
92 fbsd_find_memory_regions (struct target_ops
*self
,
93 find_memory_region_ftype func
, void *obfd
)
95 pid_t pid
= ptid_get_pid (inferior_ptid
);
96 struct kinfo_vmentry
*kve
;
100 std::unique_ptr
<struct kinfo_vmentry
, free_deleter
<struct kinfo_vmentry
>>
101 vmentl (kinfo_getvmmap (pid
, &nitems
));
103 perror_with_name (_("Couldn't fetch VM map entries."));
105 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
107 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
108 if (!(kve
->kve_protection
& KVME_PROT_READ
)
109 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
112 /* Skip segments with an invalid type. */
113 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
114 && kve
->kve_type
!= KVME_TYPE_VNODE
115 && kve
->kve_type
!= KVME_TYPE_SWAP
116 && kve
->kve_type
!= KVME_TYPE_PHYS
)
119 size
= kve
->kve_end
- kve
->kve_start
;
122 fprintf_filtered (gdb_stdout
,
123 "Save segment, %ld bytes at %s (%c%c%c)\n",
125 paddress (target_gdbarch (), kve
->kve_start
),
126 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
127 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
128 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
131 /* Invoke the callback function to create the corefile segment.
132 Pass MODIFIED as true, we do not know the real modification state. */
133 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
134 kve
->kve_protection
& KVME_PROT_WRITE
,
135 kve
->kve_protection
& KVME_PROT_EXEC
, 1, obfd
);
141 fbsd_read_mapping (FILE *mapfile
, unsigned long *start
, unsigned long *end
,
144 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
146 int resident
, privateresident
;
150 /* As of FreeBSD 5.0-RELEASE, the layout is described in
151 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
152 new column was added to the procfs map. Therefore we can't use
153 fscanf since we need to support older releases too. */
154 if (fgets (buf
, sizeof buf
, mapfile
) != NULL
)
155 ret
= sscanf (buf
, "%lx %lx %d %d %lx %s", start
, end
,
156 &resident
, &privateresident
, &obj
, protection
);
158 return (ret
!= 0 && ret
!= EOF
);
161 /* Iterate over all the memory regions in the current inferior,
162 calling FUNC for each memory region. OBFD is passed as the last
166 fbsd_find_memory_regions (struct target_ops
*self
,
167 find_memory_region_ftype func
, void *obfd
)
169 pid_t pid
= ptid_get_pid (inferior_ptid
);
170 unsigned long start
, end
, size
;
172 int read
, write
, exec
;
174 std::string mapfilename
= string_printf ("/proc/%ld/map", (long) pid
);
175 gdb_file_up
mapfile (fopen (mapfilename
.c_str (), "r"));
177 error (_("Couldn't open %s."), mapfilename
.c_str ());
180 fprintf_filtered (gdb_stdout
,
181 "Reading memory regions from %s\n", mapfilename
.c_str ());
183 /* Now iterate until end-of-file. */
184 while (fbsd_read_mapping (mapfile
.get (), &start
, &end
, &protection
[0]))
188 read
= (strchr (protection
, 'r') != 0);
189 write
= (strchr (protection
, 'w') != 0);
190 exec
= (strchr (protection
, 'x') != 0);
194 fprintf_filtered (gdb_stdout
,
195 "Save segment, %ld bytes at %s (%c%c%c)\n",
196 size
, paddress (target_gdbarch (), start
),
202 /* Invoke the callback function to create the corefile segment.
203 Pass MODIFIED as true, we do not know the real modification state. */
204 func (start
, size
, read
, write
, exec
, 1, obfd
);
211 #ifdef KERN_PROC_AUXV
212 static enum target_xfer_status (*super_xfer_partial
) (struct target_ops
*ops
,
213 enum target_object object
,
216 const gdb_byte
*writebuf
,
219 ULONGEST
*xfered_len
);
222 /* Return the size of siginfo for the current inferior. */
230 /* This structure matches the naming and layout of `siginfo_t' in
231 <sys/signal.h>. In particular, the `si_foo' macros defined in that
232 header can be used with both types to copy fields in the `_reason'
244 union sigval32 si_value
;
277 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
279 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
280 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
281 return sizeof (struct siginfo32
);
283 return sizeof (siginfo_t
);
286 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
287 that FreeBSD doesn't support writing to $_siginfo, so this only
288 needs to convert one way. */
291 fbsd_convert_siginfo (siginfo_t
*si
)
294 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
296 /* Is the inferior 32-bit? If not, nothing to do. */
297 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
!= 32)
300 struct siginfo32 si32
;
302 si32
.si_signo
= si
->si_signo
;
303 si32
.si_errno
= si
->si_errno
;
304 si32
.si_code
= si
->si_code
;
305 si32
.si_pid
= si
->si_pid
;
306 si32
.si_uid
= si
->si_uid
;
307 si32
.si_status
= si
->si_status
;
308 si32
.si_addr
= (uintptr_t) si
->si_addr
;
310 /* If sival_ptr is being used instead of sival_int on a big-endian
311 platform, then sival_int will be zero since it holds the upper
312 32-bits of the pointer value. */
313 #if _BYTE_ORDER == _BIG_ENDIAN
314 if (si
->si_value
.sival_int
== 0)
315 si32
->si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
317 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
319 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
322 /* Always copy the spare fields and then possibly overwrite them for
323 signal-specific or code-specific fields. */
324 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
325 for (int i
= 0; i
< 7; i
++)
326 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
327 switch (si
->si_signo
) {
332 si32
.si_trapno
= si
->si_trapno
;
335 switch (si
->si_code
) {
337 si32
.si_timerid
= si
->si_timerid
;
338 si32
.si_overrun
= si
->si_overrun
;
341 si32
.si_mqd
= si
->si_mqd
;
345 memcpy(si
, &si32
, sizeof (si32
));
350 /* Implement the "to_xfer_partial target_ops" method. */
352 static enum target_xfer_status
353 fbsd_xfer_partial (struct target_ops
*ops
, enum target_object object
,
354 const char *annex
, gdb_byte
*readbuf
,
355 const gdb_byte
*writebuf
,
356 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
358 pid_t pid
= ptid_get_pid (inferior_ptid
);
363 case TARGET_OBJECT_SIGNAL_INFO
:
365 struct ptrace_lwpinfo pl
;
368 /* FreeBSD doesn't support writing to $_siginfo. */
369 if (writebuf
!= NULL
)
370 return TARGET_XFER_E_IO
;
372 if (inferior_ptid
.lwp_p ())
373 pid
= inferior_ptid
.lwp ();
375 siginfo_size
= fbsd_siginfo_size ();
376 if (offset
> siginfo_size
)
377 return TARGET_XFER_E_IO
;
379 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
380 return TARGET_XFER_E_IO
;
382 if (!(pl
.pl_flags
& PL_FLAG_SI
))
383 return TARGET_XFER_E_IO
;
385 fbsd_convert_siginfo (&pl
.pl_siginfo
);
386 if (offset
+ len
> siginfo_size
)
387 len
= siginfo_size
- offset
;
389 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
391 return TARGET_XFER_OK
;
394 case TARGET_OBJECT_AUXV
:
396 gdb::byte_vector buf_storage
;
401 if (writebuf
!= NULL
)
402 return TARGET_XFER_E_IO
;
405 mib
[2] = KERN_PROC_AUXV
;
414 buflen
= offset
+ len
;
415 buf_storage
.resize (buflen
);
416 buf
= buf_storage
.data ();
418 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
425 memcpy (readbuf
, buf
+ offset
, buflen
);
430 *xfered_len
= buflen
;
431 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
433 return TARGET_XFER_E_IO
;
436 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
, offset
,
443 static int debug_fbsd_lwp
;
445 static void (*super_resume
) (struct target_ops
*,
449 static ptid_t (*super_wait
) (struct target_ops
*,
451 struct target_waitstatus
*,
455 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
456 struct cmd_list_element
*c
, const char *value
)
458 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
461 #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
462 /* Fetch the external variant of the kernel's internal process
463 structure for the process PID into KP. */
466 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
474 mib
[2] = KERN_PROC_PID
;
476 if (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == -1)
477 perror_with_name (("sysctl"));
482 FreeBSD's first thread support was via a "reentrant" version of libc
483 (libc_r) that first shipped in 2.2.7. This library multiplexed all
484 of the threads in a process onto a single kernel thread. This
485 library was supported via the bsd-uthread target.
487 FreeBSD 5.1 introduced two new threading libraries that made use of
488 multiple kernel threads. The first (libkse) scheduled M user
489 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
490 bound each user thread to a dedicated kernel thread. libkse shipped
491 as the default threading library (libpthread).
493 FreeBSD 5.3 added a libthread_db to abstract the interface across
494 the various thread libraries (libc_r, libkse, and libthr).
496 FreeBSD 7.0 switched the default threading library from from libkse
497 to libpthread and removed libc_r.
499 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
500 only threading library supported by 8.0 and later is libthr which
501 ties each user thread directly to an LWP. To simplify the
502 implementation, this target only supports LWP-backed threads using
503 ptrace directly rather than libthread_db.
505 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
508 /* Return true if PTID is still active in the inferior. */
511 fbsd_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
513 if (ptid_lwp_p (ptid
))
515 struct ptrace_lwpinfo pl
;
517 if (ptrace (PT_LWPINFO
, ptid_get_lwp (ptid
), (caddr_t
) &pl
, sizeof pl
)
520 #ifdef PL_FLAG_EXITED
521 if (pl
.pl_flags
& PL_FLAG_EXITED
)
529 /* Convert PTID to a string. Returns the string in a static
533 fbsd_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
537 lwp
= ptid_get_lwp (ptid
);
541 int pid
= ptid_get_pid (ptid
);
543 xsnprintf (buf
, sizeof buf
, "LWP %d of process %d", lwp
, pid
);
547 return normal_pid_to_str (ptid
);
550 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
551 /* Return the name assigned to a thread by an application. Returns
552 the string in a static buffer. */
555 fbsd_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
557 struct ptrace_lwpinfo pl
;
558 struct kinfo_proc kp
;
559 int pid
= ptid_get_pid (thr
->ptid
);
560 long lwp
= ptid_get_lwp (thr
->ptid
);
561 static char buf
[sizeof pl
.pl_tdname
+ 1];
563 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
564 if a name has not been set explicitly. Return a NULL name in
566 fbsd_fetch_kinfo_proc (pid
, &kp
);
567 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
568 perror_with_name (("ptrace"));
569 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
571 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
576 /* Enable additional event reporting on new processes.
578 To catch fork events, PTRACE_FORK is set on every traced process
579 to enable stops on returns from fork or vfork. Note that both the
580 parent and child will always stop, even if system call stops are
583 To catch LWP events, PTRACE_EVENTS is set on every traced process.
584 This enables stops on the birth for new LWPs (excluding the "main" LWP)
585 and the death of LWPs (excluding the last LWP in a process). Note
586 that unlike fork events, the LWP that creates a new LWP does not
590 fbsd_enable_proc_events (pid_t pid
)
592 #ifdef PT_GET_EVENT_MASK
595 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
596 sizeof (events
)) == -1)
597 perror_with_name (("ptrace"));
598 events
|= PTRACE_FORK
| PTRACE_LWP
;
600 events
|= PTRACE_VFORK
;
602 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
603 sizeof (events
)) == -1)
604 perror_with_name (("ptrace"));
607 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
608 perror_with_name (("ptrace"));
611 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
612 perror_with_name (("ptrace"));
617 /* Add threads for any new LWPs in a process.
619 When LWP events are used, this function is only used to detect existing
620 threads when attaching to a process. On older systems, this function is
621 called to discover new threads each time the thread list is updated. */
624 fbsd_add_threads (pid_t pid
)
628 gdb_assert (!in_thread_list (pid_to_ptid (pid
)));
629 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
631 perror_with_name (("ptrace"));
633 gdb::unique_xmalloc_ptr
<lwpid_t
> lwps (XCNEWVEC (lwpid_t
, nlwps
));
635 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
637 perror_with_name (("ptrace"));
639 for (i
= 0; i
< nlwps
; i
++)
641 lwpid_t lwp
= lwps
.get ()[i
];
642 ptid_t ptid
= ptid_build (pid
, lwp
, 0);
644 if (!in_thread_list (ptid
))
647 struct ptrace_lwpinfo pl
;
649 /* Don't add exited threads. Note that this is only called
650 when attaching to a multi-threaded process. */
651 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
652 perror_with_name (("ptrace"));
653 if (pl
.pl_flags
& PL_FLAG_EXITED
)
657 fprintf_unfiltered (gdb_stdlog
,
658 "FLWP: adding thread for LWP %u\n",
665 /* Implement the "to_update_thread_list" target_ops method. */
668 fbsd_update_thread_list (struct target_ops
*ops
)
671 /* With support for thread events, threads are added/deleted from the
672 list as events are reported, so just try deleting exited threads. */
673 delete_exited_threads ();
677 fbsd_add_threads (ptid_get_pid (inferior_ptid
));
683 To catch fork events, PT_FOLLOW_FORK is set on every traced process
684 to enable stops on returns from fork or vfork. Note that both the
685 parent and child will always stop, even if system call stops are not
688 After a fork, both the child and parent process will stop and report
689 an event. However, there is no guarantee of order. If the parent
690 reports its stop first, then fbsd_wait explicitly waits for the new
691 child before returning. If the child reports its stop first, then
692 the event is saved on a list and ignored until the parent's stop is
693 reported. fbsd_wait could have been changed to fetch the parent PID
694 of the new child and used that to wait for the parent explicitly.
695 However, if two threads in the parent fork at the same time, then
696 the wait on the parent might return the "wrong" fork event.
698 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
699 the new child process. This flag could be inferred by treating any
700 events for an unknown pid as a new child.
702 In addition, the initial version of PT_FOLLOW_FORK did not report a
703 stop event for the parent process of a vfork until after the child
704 process executed a new program or exited. The kernel was changed to
705 defer the wait for exit or exec of the child until after posting the
706 stop event shortly after the change to introduce PL_FLAG_CHILD.
707 This could be worked around by reporting a vfork event when the
708 child event posted and ignoring the subsequent event from the
711 This implementation requires both of these fixes for simplicity's
712 sake. FreeBSD versions newer than 9.1 contain both fixes.
715 struct fbsd_fork_info
717 struct fbsd_fork_info
*next
;
721 static struct fbsd_fork_info
*fbsd_pending_children
;
723 /* Record a new child process event that is reported before the
724 corresponding fork event in the parent. */
727 fbsd_remember_child (ptid_t pid
)
729 struct fbsd_fork_info
*info
= XCNEW (struct fbsd_fork_info
);
732 info
->next
= fbsd_pending_children
;
733 fbsd_pending_children
= info
;
736 /* Check for a previously-recorded new child process event for PID.
737 If one is found, remove it from the list and return the PTID. */
740 fbsd_is_child_pending (pid_t pid
)
742 struct fbsd_fork_info
*info
, *prev
;
746 for (info
= fbsd_pending_children
; info
; prev
= info
, info
= info
->next
)
748 if (ptid_get_pid (info
->ptid
) == pid
)
751 fbsd_pending_children
= info
->next
;
753 prev
->next
= info
->next
;
763 static struct fbsd_fork_info
*fbsd_pending_vfork_done
;
765 /* Record a pending vfork done event. */
768 fbsd_add_vfork_done (ptid_t pid
)
770 struct fbsd_fork_info
*info
= XCNEW (struct fbsd_fork_info
);
773 info
->next
= fbsd_pending_vfork_done
;
774 fbsd_pending_vfork_done
= info
;
777 /* Check for a pending vfork done event for a specific PID. */
780 fbsd_is_vfork_done_pending (pid_t pid
)
782 struct fbsd_fork_info
*info
;
784 for (info
= fbsd_pending_vfork_done
; info
!= NULL
; info
= info
->next
)
786 if (ptid_get_pid (info
->ptid
) == pid
)
792 /* Check for a pending vfork done event. If one is found, remove it
793 from the list and return the PTID. */
796 fbsd_next_vfork_done (void)
798 struct fbsd_fork_info
*info
;
801 if (fbsd_pending_vfork_done
!= NULL
)
803 info
= fbsd_pending_vfork_done
;
804 fbsd_pending_vfork_done
= info
->next
;
814 /* Implement the "to_resume" target_ops method. */
817 fbsd_resume (struct target_ops
*ops
,
818 ptid_t ptid
, int step
, enum gdb_signal signo
)
820 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
823 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
824 if (ptid_equal (minus_one_ptid
, ptid
))
825 pid
= ptid_get_pid (inferior_ptid
);
827 pid
= ptid_get_pid (ptid
);
828 if (fbsd_is_vfork_done_pending (pid
))
833 fprintf_unfiltered (gdb_stdlog
,
834 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
835 ptid_get_pid (ptid
), ptid_get_lwp (ptid
),
836 ptid_get_tid (ptid
));
837 if (ptid_lwp_p (ptid
))
839 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
840 struct thread_info
*tp
;
843 ALL_NON_EXITED_THREADS (tp
)
845 if (ptid_get_pid (tp
->ptid
) != ptid_get_pid (ptid
))
848 if (ptid_get_lwp (tp
->ptid
) == ptid_get_lwp (ptid
))
851 request
= PT_SUSPEND
;
853 if (ptrace (request
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
854 perror_with_name (("ptrace"));
859 /* If ptid is a wildcard, resume all matching threads (they won't run
860 until the process is continued however). */
861 struct thread_info
*tp
;
863 ALL_NON_EXITED_THREADS (tp
)
865 if (!ptid_match (tp
->ptid
, ptid
))
868 if (ptrace (PT_RESUME
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
869 perror_with_name (("ptrace"));
871 ptid
= inferior_ptid
;
873 super_resume (ops
, ptid
, step
, signo
);
876 /* Wait for the child specified by PTID to do something. Return the
877 process ID of the child, or MINUS_ONE_PTID in case of error; store
878 the status in *OURSTATUS. */
881 fbsd_wait (struct target_ops
*ops
,
882 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
890 wptid
= fbsd_next_vfork_done ();
891 if (!ptid_equal (wptid
, null_ptid
))
893 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
897 wptid
= super_wait (ops
, ptid
, ourstatus
, target_options
);
898 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
900 struct ptrace_lwpinfo pl
;
904 pid
= ptid_get_pid (wptid
);
905 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
906 perror_with_name (("ptrace"));
908 wptid
= ptid_build (pid
, pl
.pl_lwpid
, 0);
911 if (pl
.pl_flags
& PL_FLAG_EXITED
)
913 /* If GDB attaches to a multi-threaded process, exiting
914 threads might be skipped during fbsd_post_attach that
915 have not yet reported their PL_FLAG_EXITED event.
916 Ignore EXITED events for an unknown LWP. */
917 if (in_thread_list (wptid
))
920 fprintf_unfiltered (gdb_stdlog
,
921 "FLWP: deleting thread for LWP %u\n",
923 if (print_thread_events
)
924 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
926 delete_thread (wptid
);
928 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
929 perror_with_name (("ptrace"));
934 /* Switch to an LWP PTID on the first stop in a new process.
935 This is done after handling PL_FLAG_EXITED to avoid
936 switching to an exited LWP. It is done before checking
937 PL_FLAG_BORN in case the first stop reported after
938 attaching to an existing process is a PL_FLAG_BORN
940 if (in_thread_list (pid_to_ptid (pid
)))
943 fprintf_unfiltered (gdb_stdlog
,
944 "FLWP: using LWP %u for first thread\n",
946 thread_change_ptid (pid_to_ptid (pid
), wptid
);
950 if (pl
.pl_flags
& PL_FLAG_BORN
)
952 /* If GDB attaches to a multi-threaded process, newborn
953 threads might be added by fbsd_add_threads that have
954 not yet reported their PL_FLAG_BORN event. Ignore
955 BORN events for an already-known LWP. */
956 if (!in_thread_list (wptid
))
959 fprintf_unfiltered (gdb_stdlog
,
960 "FLWP: adding thread for LWP %u\n",
964 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
970 if (pl
.pl_flags
& PL_FLAG_FORKED
)
973 struct kinfo_proc kp
;
978 child
= pl
.pl_child_pid
;
979 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
981 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
982 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
985 /* Make sure the other end of the fork is stopped too. */
986 child_ptid
= fbsd_is_child_pending (child
);
987 if (ptid_equal (child_ptid
, null_ptid
))
989 pid
= waitpid (child
, &status
, 0);
991 perror_with_name (("waitpid"));
993 gdb_assert (pid
== child
);
995 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
996 perror_with_name (("ptrace"));
998 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
999 child_ptid
= ptid_build (child
, pl
.pl_lwpid
, 0);
1002 /* Enable additional events on the child process. */
1003 fbsd_enable_proc_events (ptid_get_pid (child_ptid
));
1005 #ifndef PTRACE_VFORK
1006 /* For vfork, the child process will have the P_PPWAIT
1008 fbsd_fetch_kinfo_proc (child
, &kp
);
1009 if (kp
.ki_flag
& P_PPWAIT
)
1010 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1012 ourstatus
->value
.related_pid
= child_ptid
;
1017 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1019 /* Remember that this child forked, but do not report it
1020 until the parent reports its corresponding fork
1022 fbsd_remember_child (wptid
);
1027 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1029 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1036 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1038 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1039 ourstatus
->value
.execd_pathname
1040 = xstrdup (fbsd_pid_to_exec_file (NULL
, pid
));
1045 /* Note that PL_FLAG_SCE is set for any event reported while
1046 a thread is executing a system call in the kernel. In
1047 particular, signals that interrupt a sleep in a system
1048 call will report this flag as part of their event. Stops
1049 explicitly for system call entry and exit always use
1050 SIGTRAP, so only treat SIGTRAP events as system call
1051 entry/exit events. */
1052 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1053 && ourstatus
->value
.sig
== SIGTRAP
)
1055 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1056 if (catch_syscall_enabled ())
1058 if (catching_syscall_number (pl
.pl_syscall_code
))
1060 if (pl
.pl_flags
& PL_FLAG_SCE
)
1061 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1063 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1064 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1069 /* If the core isn't interested in this event, just
1070 continue the process explicitly and wait for another
1071 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1072 and once system call stops are enabled on a process
1073 it stops for all system call entries and exits. */
1074 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1075 perror_with_name (("ptrace"));
1084 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1085 the ptid of the followed inferior. */
1088 fbsd_follow_fork (struct target_ops
*ops
, int follow_child
,
1091 if (!follow_child
&& detach_fork
)
1093 struct thread_info
*tp
= inferior_thread ();
1094 pid_t child_pid
= ptid_get_pid (tp
->pending_follow
.value
.related_pid
);
1096 /* Breakpoints have already been detached from the child by
1099 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1100 perror_with_name (("ptrace"));
1102 #ifndef PTRACE_VFORK
1103 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1105 /* We can't insert breakpoints until the child process has
1106 finished with the shared memory region. The parent
1107 process doesn't wait for the child process to exit or
1108 exec until after it has been resumed from the ptrace stop
1109 to report the fork. Once it has been resumed it doesn't
1110 stop again before returning to userland, so there is no
1111 reliable way to wait on the parent.
1113 We can't stay attached to the child to wait for an exec
1114 or exit because it may invoke ptrace(PT_TRACE_ME)
1115 (e.g. if the parent process is a debugger forking a new
1118 In the end, the best we can do is to make sure it runs
1119 for a little while. Hopefully it will be out of range of
1120 any breakpoints we reinsert. Usually this is only the
1121 single-step breakpoint at vfork's return point. */
1125 /* Schedule a fake VFORK_DONE event to report on the next
1127 fbsd_add_vfork_done (inferior_ptid
);
1136 fbsd_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
1142 fbsd_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
1148 fbsd_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
1154 fbsd_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
1160 /* Implement the "to_post_startup_inferior" target_ops method. */
1163 fbsd_post_startup_inferior (struct target_ops
*self
, ptid_t pid
)
1165 fbsd_enable_proc_events (ptid_get_pid (pid
));
1168 /* Implement the "to_post_attach" target_ops method. */
1171 fbsd_post_attach (struct target_ops
*self
, int pid
)
1173 fbsd_enable_proc_events (pid
);
1174 fbsd_add_threads (pid
);
1178 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1179 will always stop after exec. */
1182 fbsd_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
1188 fbsd_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
1194 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1196 fbsd_set_syscall_catchpoint (struct target_ops
*self
, int pid
, int needed
,
1197 int any_count
, int table_size
, int *table
)
1200 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1201 will catch all system call entries and exits. The system calls
1202 are filtered by GDB rather than the kernel. */
1209 fbsd_nat_add_target (struct target_ops
*t
)
1211 t
->to_pid_to_exec_file
= fbsd_pid_to_exec_file
;
1212 t
->to_find_memory_regions
= fbsd_find_memory_regions
;
1213 #ifdef KERN_PROC_AUXV
1214 super_xfer_partial
= t
->to_xfer_partial
;
1215 t
->to_xfer_partial
= fbsd_xfer_partial
;
1218 t
->to_thread_alive
= fbsd_thread_alive
;
1219 t
->to_pid_to_str
= fbsd_pid_to_str
;
1220 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
1221 t
->to_thread_name
= fbsd_thread_name
;
1223 t
->to_update_thread_list
= fbsd_update_thread_list
;
1224 t
->to_has_thread_control
= tc_schedlock
;
1225 super_resume
= t
->to_resume
;
1226 t
->to_resume
= fbsd_resume
;
1227 super_wait
= t
->to_wait
;
1228 t
->to_wait
= fbsd_wait
;
1229 t
->to_post_startup_inferior
= fbsd_post_startup_inferior
;
1230 t
->to_post_attach
= fbsd_post_attach
;
1232 t
->to_follow_fork
= fbsd_follow_fork
;
1233 t
->to_insert_fork_catchpoint
= fbsd_insert_fork_catchpoint
;
1234 t
->to_remove_fork_catchpoint
= fbsd_remove_fork_catchpoint
;
1235 t
->to_insert_vfork_catchpoint
= fbsd_insert_vfork_catchpoint
;
1236 t
->to_remove_vfork_catchpoint
= fbsd_remove_vfork_catchpoint
;
1239 t
->to_insert_exec_catchpoint
= fbsd_insert_exec_catchpoint
;
1240 t
->to_remove_exec_catchpoint
= fbsd_remove_exec_catchpoint
;
1242 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1243 t
->to_set_syscall_catchpoint
= fbsd_set_syscall_catchpoint
;
1249 /* Provide a prototype to silence -Wmissing-prototypes. */
1250 extern initialize_file_ftype _initialize_fbsd_nat
;
1253 _initialize_fbsd_nat (void)
1256 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1257 &debug_fbsd_lwp
, _("\
1258 Set debugging of FreeBSD lwp module."), _("\
1259 Show debugging of FreeBSD lwp module."), _("\
1260 Enables printf debugging output."),
1262 &show_fbsd_lwp_debug
,
1263 &setdebuglist
, &showdebuglist
);