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"
46 /* Return the name of a file that can be opened to get the symbols for
47 the child process identified by PID. */
50 fbsd_pid_to_exec_file (struct target_ops *self, int pid)
53 static char buf[PATH_MAX];
56 #ifdef KERN_PROC_PATHNAME
62 mib[2] = KERN_PROC_PATHNAME;
65 if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
69 xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
70 len = readlink (name, buf, PATH_MAX - 1);
80 #ifdef HAVE_KINFO_GETVMMAP
81 /* Deleter for std::unique_ptr that invokes free. */
86 void operator() (T *ptr) const { free (ptr); }
89 /* Iterate over all the memory regions in the current inferior,
90 calling FUNC for each memory region. OBFD is passed as the last
94 fbsd_find_memory_regions (struct target_ops *self,
95 find_memory_region_ftype func, void *obfd)
97 pid_t pid = ptid_get_pid (inferior_ptid);
98 struct kinfo_vmentry *kve;
102 std::unique_ptr<struct kinfo_vmentry, free_deleter<struct kinfo_vmentry>>
103 vmentl (kinfo_getvmmap (pid, &nitems));
105 perror_with_name (_("Couldn't fetch VM map entries."));
107 for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++)
109 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
110 if (!(kve->kve_protection & KVME_PROT_READ)
111 || kve->kve_flags & KVME_FLAG_NOCOREDUMP)
114 /* Skip segments with an invalid type. */
115 if (kve->kve_type != KVME_TYPE_DEFAULT
116 && kve->kve_type != KVME_TYPE_VNODE
117 && kve->kve_type != KVME_TYPE_SWAP
118 && kve->kve_type != KVME_TYPE_PHYS)
121 size = kve->kve_end - kve->kve_start;
124 fprintf_filtered (gdb_stdout,
125 "Save segment, %ld bytes at %s (%c%c%c)\n",
127 paddress (target_gdbarch (), kve->kve_start),
128 kve->kve_protection & KVME_PROT_READ ? 'r' : '-',
129 kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-',
130 kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-');
133 /* Invoke the callback function to create the corefile segment.
134 Pass MODIFIED as true, we do not know the real modification state. */
135 func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ,
136 kve->kve_protection & KVME_PROT_WRITE,
137 kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
143 fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end,
146 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
148 int resident, privateresident;
152 /* As of FreeBSD 5.0-RELEASE, the layout is described in
153 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
154 new column was added to the procfs map. Therefore we can't use
155 fscanf since we need to support older releases too. */
156 if (fgets (buf, sizeof buf, mapfile) != NULL)
157 ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end,
158 &resident, &privateresident, &obj, protection);
160 return (ret != 0 && ret != EOF);
163 /* Iterate over all the memory regions in the current inferior,
164 calling FUNC for each memory region. OBFD is passed as the last
168 fbsd_find_memory_regions (struct target_ops *self,
169 find_memory_region_ftype func, void *obfd)
171 pid_t pid = ptid_get_pid (inferior_ptid);
172 unsigned long start, end, size;
174 int read, write, exec;
176 std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid);
177 gdb_file_up mapfile (fopen (mapfilename.c_str (), "r"));
179 error (_("Couldn't open %s."), mapfilename.c_str ());
182 fprintf_filtered (gdb_stdout,
183 "Reading memory regions from %s\n", mapfilename.c_str ());
185 /* Now iterate until end-of-file. */
186 while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0]))
190 read = (strchr (protection, 'r') != 0);
191 write = (strchr (protection, 'w') != 0);
192 exec = (strchr (protection, 'x') != 0);
196 fprintf_filtered (gdb_stdout,
197 "Save segment, %ld bytes at %s (%c%c%c)\n",
198 size, paddress (target_gdbarch (), start),
204 /* Invoke the callback function to create the corefile segment.
205 Pass MODIFIED as true, we do not know the real modification state. */
206 func (start, size, read, write, exec, 1, obfd);
213 #ifdef KERN_PROC_AUXV
214 static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
215 enum target_object object,
218 const gdb_byte *writebuf,
221 ULONGEST *xfered_len);
224 /* Return the size of siginfo for the current inferior. */
232 /* This structure matches the naming and layout of `siginfo_t' in
233 <sys/signal.h>. In particular, the `si_foo' macros defined in that
234 header can be used with both types to copy fields in the `_reason'
246 union sigval32 si_value;
279 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
281 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
282 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
283 return sizeof (struct siginfo32);
285 return sizeof (siginfo_t);
288 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
289 that FreeBSD doesn't support writing to $_siginfo, so this only
290 needs to convert one way. */
293 fbsd_convert_siginfo (siginfo_t *si)
296 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
298 /* Is the inferior 32-bit? If not, nothing to do. */
299 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 32)
302 struct siginfo32 si32;
304 si32.si_signo = si->si_signo;
305 si32.si_errno = si->si_errno;
306 si32.si_code = si->si_code;
307 si32.si_pid = si->si_pid;
308 si32.si_uid = si->si_uid;
309 si32.si_status = si->si_status;
310 si32.si_addr = (uintptr_t) si->si_addr;
312 /* If sival_ptr is being used instead of sival_int on a big-endian
313 platform, then sival_int will be zero since it holds the upper
314 32-bits of the pointer value. */
315 #if _BYTE_ORDER == _BIG_ENDIAN
316 if (si->si_value.sival_int == 0)
317 si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
319 si32.si_value.sival_int = si->si_value.sival_int;
321 si32.si_value.sival_int = si->si_value.sival_int;
324 /* Always copy the spare fields and then possibly overwrite them for
325 signal-specific or code-specific fields. */
326 si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
327 for (int i = 0; i < 7; i++)
328 si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
329 switch (si->si_signo) {
334 si32.si_trapno = si->si_trapno;
337 switch (si->si_code) {
339 si32.si_timerid = si->si_timerid;
340 si32.si_overrun = si->si_overrun;
343 si32.si_mqd = si->si_mqd;
347 memcpy(si, &si32, sizeof (si32));
352 /* Implement the "to_xfer_partial target_ops" method. */
354 static enum target_xfer_status
355 fbsd_xfer_partial (struct target_ops *ops, enum target_object object,
356 const char *annex, gdb_byte *readbuf,
357 const gdb_byte *writebuf,
358 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
360 pid_t pid = ptid_get_pid (inferior_ptid);
365 case TARGET_OBJECT_SIGNAL_INFO:
367 struct ptrace_lwpinfo pl;
370 /* FreeBSD doesn't support writing to $_siginfo. */
371 if (writebuf != NULL)
372 return TARGET_XFER_E_IO;
374 if (inferior_ptid.lwp_p ())
375 pid = inferior_ptid.lwp ();
377 siginfo_size = fbsd_siginfo_size ();
378 if (offset > siginfo_size)
379 return TARGET_XFER_E_IO;
381 if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
382 return TARGET_XFER_E_IO;
384 if (!(pl.pl_flags & PL_FLAG_SI))
385 return TARGET_XFER_E_IO;
387 fbsd_convert_siginfo (&pl.pl_siginfo);
388 if (offset + len > siginfo_size)
389 len = siginfo_size - offset;
391 memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
393 return TARGET_XFER_OK;
396 case TARGET_OBJECT_AUXV:
398 gdb::byte_vector buf_storage;
403 if (writebuf != NULL)
404 return TARGET_XFER_E_IO;
407 mib[2] = KERN_PROC_AUXV;
416 buflen = offset + len;
417 buf_storage.resize (buflen);
418 buf = buf_storage.data ();
420 if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
427 memcpy (readbuf, buf + offset, buflen);
432 *xfered_len = buflen;
433 return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
435 return TARGET_XFER_E_IO;
438 return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
445 static int debug_fbsd_lwp;
447 static void (*super_resume) (struct target_ops *,
451 static ptid_t (*super_wait) (struct target_ops *,
453 struct target_waitstatus *,
457 show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
458 struct cmd_list_element *c, const char *value)
460 fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
463 #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
464 /* Fetch the external variant of the kernel's internal process
465 structure for the process PID into KP. */
468 fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
476 mib[2] = KERN_PROC_PID;
478 if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)
479 perror_with_name (("sysctl"));
484 FreeBSD's first thread support was via a "reentrant" version of libc
485 (libc_r) that first shipped in 2.2.7. This library multiplexed all
486 of the threads in a process onto a single kernel thread. This
487 library was supported via the bsd-uthread target.
489 FreeBSD 5.1 introduced two new threading libraries that made use of
490 multiple kernel threads. The first (libkse) scheduled M user
491 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
492 bound each user thread to a dedicated kernel thread. libkse shipped
493 as the default threading library (libpthread).
495 FreeBSD 5.3 added a libthread_db to abstract the interface across
496 the various thread libraries (libc_r, libkse, and libthr).
498 FreeBSD 7.0 switched the default threading library from from libkse
499 to libpthread and removed libc_r.
501 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
502 only threading library supported by 8.0 and later is libthr which
503 ties each user thread directly to an LWP. To simplify the
504 implementation, this target only supports LWP-backed threads using
505 ptrace directly rather than libthread_db.
507 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
510 /* Return true if PTID is still active in the inferior. */
513 fbsd_thread_alive (struct target_ops *ops, ptid_t ptid)
515 if (ptid_lwp_p (ptid))
517 struct ptrace_lwpinfo pl;
519 if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl)
522 #ifdef PL_FLAG_EXITED
523 if (pl.pl_flags & PL_FLAG_EXITED)
531 /* Convert PTID to a string. Returns the string in a static
535 fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
539 lwp = ptid_get_lwp (ptid);
543 int pid = ptid_get_pid (ptid);
545 xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid);
549 return normal_pid_to_str (ptid);
552 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
553 /* Return the name assigned to a thread by an application. Returns
554 the string in a static buffer. */
557 fbsd_thread_name (struct target_ops *self, struct thread_info *thr)
559 struct ptrace_lwpinfo pl;
560 struct kinfo_proc kp;
561 int pid = ptid_get_pid (thr->ptid);
562 long lwp = ptid_get_lwp (thr->ptid);
563 static char buf[sizeof pl.pl_tdname + 1];
565 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
566 if a name has not been set explicitly. Return a NULL name in
568 fbsd_fetch_kinfo_proc (pid, &kp);
569 if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
570 perror_with_name (("ptrace"));
571 if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
573 xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname);
578 /* Enable additional event reporting on new processes.
580 To catch fork events, PTRACE_FORK is set on every traced process
581 to enable stops on returns from fork or vfork. Note that both the
582 parent and child will always stop, even if system call stops are
585 To catch LWP events, PTRACE_EVENTS is set on every traced process.
586 This enables stops on the birth for new LWPs (excluding the "main" LWP)
587 and the death of LWPs (excluding the last LWP in a process). Note
588 that unlike fork events, the LWP that creates a new LWP does not
592 fbsd_enable_proc_events (pid_t pid)
594 #ifdef PT_GET_EVENT_MASK
597 if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
598 sizeof (events)) == -1)
599 perror_with_name (("ptrace"));
600 events |= PTRACE_FORK | PTRACE_LWP;
602 events |= PTRACE_VFORK;
604 if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
605 sizeof (events)) == -1)
606 perror_with_name (("ptrace"));
609 if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
610 perror_with_name (("ptrace"));
613 if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
614 perror_with_name (("ptrace"));
619 /* Add threads for any new LWPs in a process.
621 When LWP events are used, this function is only used to detect existing
622 threads when attaching to a process. On older systems, this function is
623 called to discover new threads each time the thread list is updated. */
626 fbsd_add_threads (pid_t pid)
630 gdb_assert (!in_thread_list (pid_to_ptid (pid)));
631 nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0);
633 perror_with_name (("ptrace"));
635 gdb::unique_xmalloc_ptr<lwpid_t> lwps (XCNEWVEC (lwpid_t, nlwps));
637 nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps);
639 perror_with_name (("ptrace"));
641 for (i = 0; i < nlwps; i++)
643 lwpid_t lwp = lwps.get ()[i];
644 ptid_t ptid = ptid_build (pid, lwp, 0);
646 if (!in_thread_list (ptid))
649 struct ptrace_lwpinfo pl;
651 /* Don't add exited threads. Note that this is only called
652 when attaching to a multi-threaded process. */
653 if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
654 perror_with_name (("ptrace"));
655 if (pl.pl_flags & PL_FLAG_EXITED)
659 fprintf_unfiltered (gdb_stdlog,
660 "FLWP: adding thread for LWP %u\n",
667 /* Implement the "to_update_thread_list" target_ops method. */
670 fbsd_update_thread_list (struct target_ops *ops)
673 /* With support for thread events, threads are added/deleted from the
674 list as events are reported, so just try deleting exited threads. */
675 delete_exited_threads ();
679 fbsd_add_threads (ptid_get_pid (inferior_ptid));
685 To catch fork events, PT_FOLLOW_FORK is set on every traced process
686 to enable stops on returns from fork or vfork. Note that both the
687 parent and child will always stop, even if system call stops are not
690 After a fork, both the child and parent process will stop and report
691 an event. However, there is no guarantee of order. If the parent
692 reports its stop first, then fbsd_wait explicitly waits for the new
693 child before returning. If the child reports its stop first, then
694 the event is saved on a list and ignored until the parent's stop is
695 reported. fbsd_wait could have been changed to fetch the parent PID
696 of the new child and used that to wait for the parent explicitly.
697 However, if two threads in the parent fork at the same time, then
698 the wait on the parent might return the "wrong" fork event.
700 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
701 the new child process. This flag could be inferred by treating any
702 events for an unknown pid as a new child.
704 In addition, the initial version of PT_FOLLOW_FORK did not report a
705 stop event for the parent process of a vfork until after the child
706 process executed a new program or exited. The kernel was changed to
707 defer the wait for exit or exec of the child until after posting the
708 stop event shortly after the change to introduce PL_FLAG_CHILD.
709 This could be worked around by reporting a vfork event when the
710 child event posted and ignoring the subsequent event from the
713 This implementation requires both of these fixes for simplicity's
714 sake. FreeBSD versions newer than 9.1 contain both fixes.
717 static std::list<ptid_t> fbsd_pending_children;
719 /* Record a new child process event that is reported before the
720 corresponding fork event in the parent. */
723 fbsd_remember_child (ptid_t pid)
725 fbsd_pending_children.push_front (pid);
728 /* Check for a previously-recorded new child process event for PID.
729 If one is found, remove it from the list and return the PTID. */
732 fbsd_is_child_pending (pid_t pid)
734 for (auto it = fbsd_pending_children.begin ();
735 it != fbsd_pending_children.end (); it++)
736 if (it->pid () == pid)
739 fbsd_pending_children.erase (it);
746 static std::forward_list<ptid_t> fbsd_pending_vfork_done;
748 /* Record a pending vfork done event. */
751 fbsd_add_vfork_done (ptid_t pid)
753 fbsd_pending_vfork_done.push_front (pid);
756 /* Check for a pending vfork done event for a specific PID. */
759 fbsd_is_vfork_done_pending (pid_t pid)
761 for (auto it = fbsd_pending_vfork_done.begin ();
762 it != fbsd_pending_vfork_done.end (); it++)
763 if (it->pid () == pid)
768 /* Check for a pending vfork done event. If one is found, remove it
769 from the list and return the PTID. */
772 fbsd_next_vfork_done (void)
774 if (!fbsd_pending_vfork_done.empty ())
776 ptid_t ptid = fbsd_pending_vfork_done.front ();
777 fbsd_pending_vfork_done.pop_front ();
785 /* Implement the "to_resume" target_ops method. */
788 fbsd_resume (struct target_ops *ops,
789 ptid_t ptid, int step, enum gdb_signal signo)
791 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
794 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
795 if (ptid_equal (minus_one_ptid, ptid))
796 pid = ptid_get_pid (inferior_ptid);
798 pid = ptid_get_pid (ptid);
799 if (fbsd_is_vfork_done_pending (pid))
804 fprintf_unfiltered (gdb_stdlog,
805 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
806 ptid_get_pid (ptid), ptid_get_lwp (ptid),
807 ptid_get_tid (ptid));
808 if (ptid_lwp_p (ptid))
810 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
811 struct thread_info *tp;
814 ALL_NON_EXITED_THREADS (tp)
816 if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid))
819 if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid))
822 request = PT_SUSPEND;
824 if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
825 perror_with_name (("ptrace"));
830 /* If ptid is a wildcard, resume all matching threads (they won't run
831 until the process is continued however). */
832 struct thread_info *tp;
834 ALL_NON_EXITED_THREADS (tp)
836 if (!ptid_match (tp->ptid, ptid))
839 if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
840 perror_with_name (("ptrace"));
842 ptid = inferior_ptid;
844 super_resume (ops, ptid, step, signo);
847 /* Wait for the child specified by PTID to do something. Return the
848 process ID of the child, or MINUS_ONE_PTID in case of error; store
849 the status in *OURSTATUS. */
852 fbsd_wait (struct target_ops *ops,
853 ptid_t ptid, struct target_waitstatus *ourstatus,
861 wptid = fbsd_next_vfork_done ();
862 if (!ptid_equal (wptid, null_ptid))
864 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
868 wptid = super_wait (ops, ptid, ourstatus, target_options);
869 if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
871 struct ptrace_lwpinfo pl;
875 pid = ptid_get_pid (wptid);
876 if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1)
877 perror_with_name (("ptrace"));
879 wptid = ptid_build (pid, pl.pl_lwpid, 0);
882 if (pl.pl_flags & PL_FLAG_EXITED)
884 /* If GDB attaches to a multi-threaded process, exiting
885 threads might be skipped during fbsd_post_attach that
886 have not yet reported their PL_FLAG_EXITED event.
887 Ignore EXITED events for an unknown LWP. */
888 if (in_thread_list (wptid))
891 fprintf_unfiltered (gdb_stdlog,
892 "FLWP: deleting thread for LWP %u\n",
894 if (print_thread_events)
895 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
897 delete_thread (wptid);
899 if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
900 perror_with_name (("ptrace"));
905 /* Switch to an LWP PTID on the first stop in a new process.
906 This is done after handling PL_FLAG_EXITED to avoid
907 switching to an exited LWP. It is done before checking
908 PL_FLAG_BORN in case the first stop reported after
909 attaching to an existing process is a PL_FLAG_BORN
911 if (in_thread_list (pid_to_ptid (pid)))
914 fprintf_unfiltered (gdb_stdlog,
915 "FLWP: using LWP %u for first thread\n",
917 thread_change_ptid (pid_to_ptid (pid), wptid);
921 if (pl.pl_flags & PL_FLAG_BORN)
923 /* If GDB attaches to a multi-threaded process, newborn
924 threads might be added by fbsd_add_threads that have
925 not yet reported their PL_FLAG_BORN event. Ignore
926 BORN events for an already-known LWP. */
927 if (!in_thread_list (wptid))
930 fprintf_unfiltered (gdb_stdlog,
931 "FLWP: adding thread for LWP %u\n",
935 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
941 if (pl.pl_flags & PL_FLAG_FORKED)
944 struct kinfo_proc kp;
949 child = pl.pl_child_pid;
950 ourstatus->kind = TARGET_WAITKIND_FORKED;
952 if (pl.pl_flags & PL_FLAG_VFORKED)
953 ourstatus->kind = TARGET_WAITKIND_VFORKED;
956 /* Make sure the other end of the fork is stopped too. */
957 child_ptid = fbsd_is_child_pending (child);
958 if (ptid_equal (child_ptid, null_ptid))
960 pid = waitpid (child, &status, 0);
962 perror_with_name (("waitpid"));
964 gdb_assert (pid == child);
966 if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1)
967 perror_with_name (("ptrace"));
969 gdb_assert (pl.pl_flags & PL_FLAG_CHILD);
970 child_ptid = ptid_build (child, pl.pl_lwpid, 0);
973 /* Enable additional events on the child process. */
974 fbsd_enable_proc_events (ptid_get_pid (child_ptid));
977 /* For vfork, the child process will have the P_PPWAIT
979 fbsd_fetch_kinfo_proc (child, &kp);
980 if (kp.ki_flag & P_PPWAIT)
981 ourstatus->kind = TARGET_WAITKIND_VFORKED;
983 ourstatus->value.related_pid = child_ptid;
988 if (pl.pl_flags & PL_FLAG_CHILD)
990 /* Remember that this child forked, but do not report it
991 until the parent reports its corresponding fork
993 fbsd_remember_child (wptid);
998 if (pl.pl_flags & PL_FLAG_VFORK_DONE)
1000 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
1007 if (pl.pl_flags & PL_FLAG_EXEC)
1009 ourstatus->kind = TARGET_WAITKIND_EXECD;
1010 ourstatus->value.execd_pathname
1011 = xstrdup (fbsd_pid_to_exec_file (NULL, pid));
1016 /* Note that PL_FLAG_SCE is set for any event reported while
1017 a thread is executing a system call in the kernel. In
1018 particular, signals that interrupt a sleep in a system
1019 call will report this flag as part of their event. Stops
1020 explicitly for system call entry and exit always use
1021 SIGTRAP, so only treat SIGTRAP events as system call
1022 entry/exit events. */
1023 if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
1024 && ourstatus->value.sig == SIGTRAP)
1026 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1027 if (catch_syscall_enabled ())
1029 if (catching_syscall_number (pl.pl_syscall_code))
1031 if (pl.pl_flags & PL_FLAG_SCE)
1032 ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
1034 ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
1035 ourstatus->value.syscall_number = pl.pl_syscall_code;
1040 /* If the core isn't interested in this event, just
1041 continue the process explicitly and wait for another
1042 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1043 and once system call stops are enabled on a process
1044 it stops for all system call entries and exits. */
1045 if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
1046 perror_with_name (("ptrace"));
1055 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1056 the ptid of the followed inferior. */
1059 fbsd_follow_fork (struct target_ops *ops, int follow_child,
1062 if (!follow_child && detach_fork)
1064 struct thread_info *tp = inferior_thread ();
1065 pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
1067 /* Breakpoints have already been detached from the child by
1070 if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
1071 perror_with_name (("ptrace"));
1073 #ifndef PTRACE_VFORK
1074 if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
1076 /* We can't insert breakpoints until the child process has
1077 finished with the shared memory region. The parent
1078 process doesn't wait for the child process to exit or
1079 exec until after it has been resumed from the ptrace stop
1080 to report the fork. Once it has been resumed it doesn't
1081 stop again before returning to userland, so there is no
1082 reliable way to wait on the parent.
1084 We can't stay attached to the child to wait for an exec
1085 or exit because it may invoke ptrace(PT_TRACE_ME)
1086 (e.g. if the parent process is a debugger forking a new
1089 In the end, the best we can do is to make sure it runs
1090 for a little while. Hopefully it will be out of range of
1091 any breakpoints we reinsert. Usually this is only the
1092 single-step breakpoint at vfork's return point. */
1096 /* Schedule a fake VFORK_DONE event to report on the next
1098 fbsd_add_vfork_done (inferior_ptid);
1107 fbsd_insert_fork_catchpoint (struct target_ops *self, int pid)
1113 fbsd_remove_fork_catchpoint (struct target_ops *self, int pid)
1119 fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid)
1125 fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid)
1131 /* Implement the "to_post_startup_inferior" target_ops method. */
1134 fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
1136 fbsd_enable_proc_events (ptid_get_pid (pid));
1139 /* Implement the "to_post_attach" target_ops method. */
1142 fbsd_post_attach (struct target_ops *self, int pid)
1144 fbsd_enable_proc_events (pid);
1145 fbsd_add_threads (pid);
1149 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1150 will always stop after exec. */
1153 fbsd_insert_exec_catchpoint (struct target_ops *self, int pid)
1159 fbsd_remove_exec_catchpoint (struct target_ops *self, int pid)
1165 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1167 fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
1168 int any_count, int table_size, int *table)
1171 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1172 will catch all system call entries and exits. The system calls
1173 are filtered by GDB rather than the kernel. */
1180 fbsd_nat_add_target (struct target_ops *t)
1182 t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
1183 t->to_find_memory_regions = fbsd_find_memory_regions;
1184 #ifdef KERN_PROC_AUXV
1185 super_xfer_partial = t->to_xfer_partial;
1186 t->to_xfer_partial = fbsd_xfer_partial;
1189 t->to_thread_alive = fbsd_thread_alive;
1190 t->to_pid_to_str = fbsd_pid_to_str;
1191 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
1192 t->to_thread_name = fbsd_thread_name;
1194 t->to_update_thread_list = fbsd_update_thread_list;
1195 t->to_has_thread_control = tc_schedlock;
1196 super_resume = t->to_resume;
1197 t->to_resume = fbsd_resume;
1198 super_wait = t->to_wait;
1199 t->to_wait = fbsd_wait;
1200 t->to_post_startup_inferior = fbsd_post_startup_inferior;
1201 t->to_post_attach = fbsd_post_attach;
1203 t->to_follow_fork = fbsd_follow_fork;
1204 t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint;
1205 t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint;
1206 t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint;
1207 t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint;
1210 t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
1211 t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
1213 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1214 t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint;
1220 /* Provide a prototype to silence -Wmissing-prototypes. */
1221 extern initialize_file_ftype _initialize_fbsd_nat;
1224 _initialize_fbsd_nat (void)
1227 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
1228 &debug_fbsd_lwp, _("\
1229 Set debugging of FreeBSD lwp module."), _("\
1230 Show debugging of FreeBSD lwp module."), _("\
1231 Enables printf debugging output."),
1233 &show_fbsd_lwp_debug,
1234 &setdebuglist, &showdebuglist);