1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2018 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 "inf-ptrace.h"
30 #include <sys/types.h>
31 #include <sys/procfs.h>
32 #include <sys/ptrace.h>
33 #include <sys/signal.h>
34 #include <sys/sysctl.h>
36 #if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP)
39 #if !defined(HAVE_KINFO_GETVMMAP)
40 #include "filestuff.h"
45 #include "fbsd-tdep.h"
50 /* MIPS does not set si_code for SIGTRAP. sparc64 reports
51 non-standard values in si_code for SIGTRAP. */
52 # if !defined(__mips__) && !defined(__sparc64__)
53 # define USE_SIGTRAP_SIGINFO
57 /* Return the name of a file that can be opened to get the symbols for
58 the child process identified by PID. */
61 fbsd_pid_to_exec_file (struct target_ops
*self
, int pid
)
64 static char buf
[PATH_MAX
];
67 #ifdef KERN_PROC_PATHNAME
73 mib
[2] = KERN_PROC_PATHNAME
;
76 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
77 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
78 for processes without an associated executable such as kernel
80 return buflen
== 0 ? NULL
: buf
;
83 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
84 len
= readlink (name
, buf
, PATH_MAX
- 1);
94 #ifdef HAVE_KINFO_GETVMMAP
95 /* Iterate over all the memory regions in the current inferior,
96 calling FUNC for each memory region. OBFD is passed as the last
100 fbsd_find_memory_regions (struct target_ops
*self
,
101 find_memory_region_ftype func
, void *obfd
)
103 pid_t pid
= ptid_get_pid (inferior_ptid
);
104 struct kinfo_vmentry
*kve
;
108 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
109 vmentl (kinfo_getvmmap (pid
, &nitems
));
111 perror_with_name (_("Couldn't fetch VM map entries."));
113 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
115 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
116 if (!(kve
->kve_protection
& KVME_PROT_READ
)
117 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
120 /* Skip segments with an invalid type. */
121 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
122 && kve
->kve_type
!= KVME_TYPE_VNODE
123 && kve
->kve_type
!= KVME_TYPE_SWAP
124 && kve
->kve_type
!= KVME_TYPE_PHYS
)
127 size
= kve
->kve_end
- kve
->kve_start
;
130 fprintf_filtered (gdb_stdout
,
131 "Save segment, %ld bytes at %s (%c%c%c)\n",
133 paddress (target_gdbarch (), kve
->kve_start
),
134 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
135 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
136 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
139 /* Invoke the callback function to create the corefile segment.
140 Pass MODIFIED as true, we do not know the real modification state. */
141 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
142 kve
->kve_protection
& KVME_PROT_WRITE
,
143 kve
->kve_protection
& KVME_PROT_EXEC
, 1, obfd
);
149 fbsd_read_mapping (FILE *mapfile
, unsigned long *start
, unsigned long *end
,
152 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
154 int resident
, privateresident
;
158 /* As of FreeBSD 5.0-RELEASE, the layout is described in
159 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
160 new column was added to the procfs map. Therefore we can't use
161 fscanf since we need to support older releases too. */
162 if (fgets (buf
, sizeof buf
, mapfile
) != NULL
)
163 ret
= sscanf (buf
, "%lx %lx %d %d %lx %s", start
, end
,
164 &resident
, &privateresident
, &obj
, protection
);
166 return (ret
!= 0 && ret
!= EOF
);
169 /* Iterate over all the memory regions in the current inferior,
170 calling FUNC for each memory region. OBFD is passed as the last
174 fbsd_find_memory_regions (struct target_ops
*self
,
175 find_memory_region_ftype func
, void *obfd
)
177 pid_t pid
= ptid_get_pid (inferior_ptid
);
178 unsigned long start
, end
, size
;
180 int read
, write
, exec
;
182 std::string mapfilename
= string_printf ("/proc/%ld/map", (long) pid
);
183 gdb_file_up
mapfile (fopen (mapfilename
.c_str (), "r"));
185 error (_("Couldn't open %s."), mapfilename
.c_str ());
188 fprintf_filtered (gdb_stdout
,
189 "Reading memory regions from %s\n", mapfilename
.c_str ());
191 /* Now iterate until end-of-file. */
192 while (fbsd_read_mapping (mapfile
.get (), &start
, &end
, &protection
[0]))
196 read
= (strchr (protection
, 'r') != 0);
197 write
= (strchr (protection
, 'w') != 0);
198 exec
= (strchr (protection
, 'x') != 0);
202 fprintf_filtered (gdb_stdout
,
203 "Save segment, %ld bytes at %s (%c%c%c)\n",
204 size
, paddress (target_gdbarch (), start
),
210 /* Invoke the callback function to create the corefile segment.
211 Pass MODIFIED as true, we do not know the real modification state. */
212 func (start
, size
, read
, write
, exec
, 1, obfd
);
219 /* Fetch the command line for a running process. */
221 static gdb::unique_xmalloc_ptr
<char>
222 fbsd_fetch_cmdline (pid_t pid
)
230 mib
[2] = KERN_PROC_ARGS
;
232 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
238 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
239 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
245 /* Fetch the external variant of the kernel's internal process
246 structure for the process PID into KP. */
249 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
257 mib
[2] = KERN_PROC_PID
;
259 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
262 /* Implement the "to_info_proc target_ops" method. */
265 fbsd_info_proc (struct target_ops
*ops
, const char *args
,
266 enum info_proc_what what
)
268 #ifdef HAVE_KINFO_GETFILE
269 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
272 struct kinfo_proc kp
;
275 bool do_cmdline
= false;
278 #ifdef HAVE_KINFO_GETVMMAP
279 bool do_mappings
= false;
281 bool do_status
= false;
290 #ifdef HAVE_KINFO_GETVMMAP
312 #ifdef HAVE_KINFO_GETVMMAP
318 error (_("Not supported on this target."));
321 gdb_argv
built_argv (args
);
322 if (built_argv
.count () == 0)
324 pid
= ptid_get_pid (inferior_ptid
);
326 error (_("No current process: you must name one."));
328 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
329 pid
= strtol (built_argv
[0], NULL
, 10);
331 error (_("Invalid arguments."));
333 printf_filtered (_("process %d\n"), pid
);
334 #ifdef HAVE_KINFO_GETFILE
335 if (do_cwd
|| do_exe
)
336 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
341 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
342 if (cmdline
!= nullptr)
343 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
345 warning (_("unable to fetch command line"));
349 const char *cwd
= NULL
;
350 #ifdef HAVE_KINFO_GETFILE
351 struct kinfo_file
*kf
= fdtbl
.get ();
352 for (int i
= 0; i
< nfd
; i
++, kf
++)
354 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
362 printf_filtered ("cwd = '%s'\n", cwd
);
364 warning (_("unable to fetch current working directory"));
368 const char *exe
= NULL
;
369 #ifdef HAVE_KINFO_GETFILE
370 struct kinfo_file
*kf
= fdtbl
.get ();
371 for (int i
= 0; i
< nfd
; i
++, kf
++)
373 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
381 exe
= fbsd_pid_to_exec_file (ops
, pid
);
383 printf_filtered ("exe = '%s'\n", exe
);
385 warning (_("unable to fetch executable path name"));
387 #ifdef HAVE_KINFO_GETVMMAP
391 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
392 vmentl (kinfo_getvmmap (pid
, &nvment
));
394 if (vmentl
!= nullptr)
396 printf_filtered (_("Mapped address spaces:\n\n"));
398 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
401 " Size", " Offset", "Flags ", "File");
403 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
406 " Size", " Offset", "Flags ", "File");
409 struct kinfo_vmentry
*kve
= vmentl
.get ();
410 for (int i
= 0; i
< nvment
; i
++, kve
++)
414 start
= kve
->kve_start
;
417 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
420 hex_string (end
- start
),
421 hex_string (kve
->kve_offset
),
422 fbsd_vm_map_entry_flags (kve
->kve_flags
,
423 kve
->kve_protection
),
426 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
429 hex_string (end
- start
),
430 hex_string (kve
->kve_offset
),
431 fbsd_vm_map_entry_flags (kve
->kve_flags
,
432 kve
->kve_protection
),
438 warning (_("unable to fetch virtual memory map"));
443 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
444 warning (_("Failed to fetch process information"));
450 printf_filtered ("Name: %s\n", kp
.ki_comm
);
457 state
= "R (running)";
460 state
= "T (stopped)";
463 state
= "Z (zombie)";
466 state
= "S (sleeping)";
469 state
= "W (interrupt wait)";
472 state
= "L (blocked on lock)";
475 state
= "? (unknown)";
478 printf_filtered ("State: %s\n", state
);
479 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
480 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
481 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
482 printf_filtered ("TTY: %ju\n", (uintmax_t) kp
.ki_tdev
);
483 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
484 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
485 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
486 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
487 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
488 printf_filtered ("Groups: ");
489 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
490 printf_filtered ("%d ", kp
.ki_groups
[i
]);
491 printf_filtered ("\n");
492 printf_filtered ("Minor faults (no memory page): %ld\n",
493 kp
.ki_rusage
.ru_minflt
);
494 printf_filtered ("Minor faults, children: %ld\n",
495 kp
.ki_rusage_ch
.ru_minflt
);
496 printf_filtered ("Major faults (memory page faults): %ld\n",
497 kp
.ki_rusage
.ru_majflt
);
498 printf_filtered ("Major faults, children: %ld\n",
499 kp
.ki_rusage_ch
.ru_majflt
);
500 printf_filtered ("utime: %jd.%06ld\n",
501 (intmax_t) kp
.ki_rusage
.ru_utime
.tv_sec
,
502 kp
.ki_rusage
.ru_utime
.tv_usec
);
503 printf_filtered ("stime: %jd.%06ld\n",
504 (intmax_t) kp
.ki_rusage
.ru_stime
.tv_sec
,
505 kp
.ki_rusage
.ru_stime
.tv_usec
);
506 printf_filtered ("utime, children: %jd.%06ld\n",
507 (intmax_t) kp
.ki_rusage_ch
.ru_utime
.tv_sec
,
508 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
509 printf_filtered ("stime, children: %jd.%06ld\n",
510 (intmax_t) kp
.ki_rusage_ch
.ru_stime
.tv_sec
,
511 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
512 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
513 printf_filtered ("Start time: %jd.%06ld\n", kp
.ki_start
.tv_sec
,
514 kp
.ki_start
.tv_usec
);
515 pgtok
= getpagesize () / 1024;
516 printf_filtered ("Virtual memory size: %ju kB\n",
517 (uintmax_t) kp
.ki_size
/ 1024);
518 printf_filtered ("Data size: %ju kB\n",
519 (uintmax_t) kp
.ki_dsize
* pgtok
);
520 printf_filtered ("Stack size: %ju kB\n",
521 (uintmax_t) kp
.ki_ssize
* pgtok
);
522 printf_filtered ("Text size: %ju kB\n",
523 (uintmax_t) kp
.ki_tsize
* pgtok
);
524 printf_filtered ("Resident set size: %ju kB\n",
525 (uintmax_t) kp
.ki_rssize
* pgtok
);
526 printf_filtered ("Maximum RSS: %ju kB\n",
527 (uintmax_t) kp
.ki_rusage
.ru_maxrss
);
528 printf_filtered ("Pending Signals: ");
529 for (int i
= 0; i
< _SIG_WORDS
; i
++)
530 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
531 printf_filtered ("\n");
532 printf_filtered ("Ignored Signals: ");
533 for (int i
= 0; i
< _SIG_WORDS
; i
++)
534 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
535 printf_filtered ("\n");
536 printf_filtered ("Caught Signals: ");
537 for (int i
= 0; i
< _SIG_WORDS
; i
++)
538 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
539 printf_filtered ("\n");
544 #ifdef KERN_PROC_AUXV
545 static enum target_xfer_status (*super_xfer_partial
) (struct target_ops
*ops
,
546 enum target_object object
,
549 const gdb_byte
*writebuf
,
552 ULONGEST
*xfered_len
);
555 /* Return the size of siginfo for the current inferior. */
563 /* This structure matches the naming and layout of `siginfo_t' in
564 <sys/signal.h>. In particular, the `si_foo' macros defined in that
565 header can be used with both types to copy fields in the `_reason'
577 union sigval32 si_value
;
610 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
612 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
613 if (gdbarch_long_bit (gdbarch
) == 32)
614 return sizeof (struct siginfo32
);
616 return sizeof (siginfo_t
);
619 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
620 that FreeBSD doesn't support writing to $_siginfo, so this only
621 needs to convert one way. */
624 fbsd_convert_siginfo (siginfo_t
*si
)
627 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
629 /* Is the inferior 32-bit? If not, nothing to do. */
630 if (gdbarch_long_bit (gdbarch
) != 32)
633 struct siginfo32 si32
;
635 si32
.si_signo
= si
->si_signo
;
636 si32
.si_errno
= si
->si_errno
;
637 si32
.si_code
= si
->si_code
;
638 si32
.si_pid
= si
->si_pid
;
639 si32
.si_uid
= si
->si_uid
;
640 si32
.si_status
= si
->si_status
;
641 si32
.si_addr
= (uintptr_t) si
->si_addr
;
643 /* If sival_ptr is being used instead of sival_int on a big-endian
644 platform, then sival_int will be zero since it holds the upper
645 32-bits of the pointer value. */
646 #if _BYTE_ORDER == _BIG_ENDIAN
647 if (si
->si_value
.sival_int
== 0)
648 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
650 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
652 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
655 /* Always copy the spare fields and then possibly overwrite them for
656 signal-specific or code-specific fields. */
657 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
658 for (int i
= 0; i
< 7; i
++)
659 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
660 switch (si
->si_signo
) {
665 si32
.si_trapno
= si
->si_trapno
;
668 switch (si
->si_code
) {
670 si32
.si_timerid
= si
->si_timerid
;
671 si32
.si_overrun
= si
->si_overrun
;
674 si32
.si_mqd
= si
->si_mqd
;
678 memcpy(si
, &si32
, sizeof (si32
));
683 /* Implement the "to_xfer_partial target_ops" method. */
685 static enum target_xfer_status
686 fbsd_xfer_partial (struct target_ops
*ops
, enum target_object object
,
687 const char *annex
, gdb_byte
*readbuf
,
688 const gdb_byte
*writebuf
,
689 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
691 pid_t pid
= ptid_get_pid (inferior_ptid
);
696 case TARGET_OBJECT_SIGNAL_INFO
:
698 struct ptrace_lwpinfo pl
;
701 /* FreeBSD doesn't support writing to $_siginfo. */
702 if (writebuf
!= NULL
)
703 return TARGET_XFER_E_IO
;
705 if (inferior_ptid
.lwp_p ())
706 pid
= inferior_ptid
.lwp ();
708 siginfo_size
= fbsd_siginfo_size ();
709 if (offset
> siginfo_size
)
710 return TARGET_XFER_E_IO
;
712 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
713 return TARGET_XFER_E_IO
;
715 if (!(pl
.pl_flags
& PL_FLAG_SI
))
716 return TARGET_XFER_E_IO
;
718 fbsd_convert_siginfo (&pl
.pl_siginfo
);
719 if (offset
+ len
> siginfo_size
)
720 len
= siginfo_size
- offset
;
722 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
724 return TARGET_XFER_OK
;
727 case TARGET_OBJECT_AUXV
:
729 gdb::byte_vector buf_storage
;
734 if (writebuf
!= NULL
)
735 return TARGET_XFER_E_IO
;
738 mib
[2] = KERN_PROC_AUXV
;
747 buflen
= offset
+ len
;
748 buf_storage
.resize (buflen
);
749 buf
= buf_storage
.data ();
751 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
758 memcpy (readbuf
, buf
+ offset
, buflen
);
763 *xfered_len
= buflen
;
764 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
766 return TARGET_XFER_E_IO
;
769 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
, offset
,
776 static int debug_fbsd_lwp
;
777 static int debug_fbsd_nat
;
779 static void (*super_resume
) (struct target_ops
*,
783 static ptid_t (*super_wait
) (struct target_ops
*,
785 struct target_waitstatus
*,
789 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
790 struct cmd_list_element
*c
, const char *value
)
792 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
796 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
797 struct cmd_list_element
*c
, const char *value
)
799 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
804 FreeBSD's first thread support was via a "reentrant" version of libc
805 (libc_r) that first shipped in 2.2.7. This library multiplexed all
806 of the threads in a process onto a single kernel thread. This
807 library was supported via the bsd-uthread target.
809 FreeBSD 5.1 introduced two new threading libraries that made use of
810 multiple kernel threads. The first (libkse) scheduled M user
811 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
812 bound each user thread to a dedicated kernel thread. libkse shipped
813 as the default threading library (libpthread).
815 FreeBSD 5.3 added a libthread_db to abstract the interface across
816 the various thread libraries (libc_r, libkse, and libthr).
818 FreeBSD 7.0 switched the default threading library from from libkse
819 to libpthread and removed libc_r.
821 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
822 only threading library supported by 8.0 and later is libthr which
823 ties each user thread directly to an LWP. To simplify the
824 implementation, this target only supports LWP-backed threads using
825 ptrace directly rather than libthread_db.
827 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
830 /* Return true if PTID is still active in the inferior. */
833 fbsd_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
835 if (ptid_lwp_p (ptid
))
837 struct ptrace_lwpinfo pl
;
839 if (ptrace (PT_LWPINFO
, ptid_get_lwp (ptid
), (caddr_t
) &pl
, sizeof pl
)
842 #ifdef PL_FLAG_EXITED
843 if (pl
.pl_flags
& PL_FLAG_EXITED
)
851 /* Convert PTID to a string. Returns the string in a static
855 fbsd_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
859 lwp
= ptid_get_lwp (ptid
);
863 int pid
= ptid_get_pid (ptid
);
865 xsnprintf (buf
, sizeof buf
, "LWP %d of process %d", lwp
, pid
);
869 return normal_pid_to_str (ptid
);
872 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
873 /* Return the name assigned to a thread by an application. Returns
874 the string in a static buffer. */
877 fbsd_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
879 struct ptrace_lwpinfo pl
;
880 struct kinfo_proc kp
;
881 int pid
= ptid_get_pid (thr
->ptid
);
882 long lwp
= ptid_get_lwp (thr
->ptid
);
883 static char buf
[sizeof pl
.pl_tdname
+ 1];
885 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
886 if a name has not been set explicitly. Return a NULL name in
888 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
889 perror_with_name (_("Failed to fetch process information"));
890 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
891 perror_with_name (("ptrace"));
892 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
894 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
899 /* Enable additional event reporting on new processes.
901 To catch fork events, PTRACE_FORK is set on every traced process
902 to enable stops on returns from fork or vfork. Note that both the
903 parent and child will always stop, even if system call stops are
906 To catch LWP events, PTRACE_EVENTS is set on every traced process.
907 This enables stops on the birth for new LWPs (excluding the "main" LWP)
908 and the death of LWPs (excluding the last LWP in a process). Note
909 that unlike fork events, the LWP that creates a new LWP does not
913 fbsd_enable_proc_events (pid_t pid
)
915 #ifdef PT_GET_EVENT_MASK
918 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
919 sizeof (events
)) == -1)
920 perror_with_name (("ptrace"));
921 events
|= PTRACE_FORK
| PTRACE_LWP
;
923 events
|= PTRACE_VFORK
;
925 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
926 sizeof (events
)) == -1)
927 perror_with_name (("ptrace"));
930 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
931 perror_with_name (("ptrace"));
934 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
935 perror_with_name (("ptrace"));
940 /* Add threads for any new LWPs in a process.
942 When LWP events are used, this function is only used to detect existing
943 threads when attaching to a process. On older systems, this function is
944 called to discover new threads each time the thread list is updated. */
947 fbsd_add_threads (pid_t pid
)
951 gdb_assert (!in_thread_list (pid_to_ptid (pid
)));
952 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
954 perror_with_name (("ptrace"));
956 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
958 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
960 perror_with_name (("ptrace"));
962 for (i
= 0; i
< nlwps
; i
++)
964 ptid_t ptid
= ptid_build (pid
, lwps
[i
], 0);
966 if (!in_thread_list (ptid
))
969 struct ptrace_lwpinfo pl
;
971 /* Don't add exited threads. Note that this is only called
972 when attaching to a multi-threaded process. */
973 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
974 perror_with_name (("ptrace"));
975 if (pl
.pl_flags
& PL_FLAG_EXITED
)
979 fprintf_unfiltered (gdb_stdlog
,
980 "FLWP: adding thread for LWP %u\n",
987 /* Implement the "to_update_thread_list" target_ops method. */
990 fbsd_update_thread_list (struct target_ops
*ops
)
993 /* With support for thread events, threads are added/deleted from the
994 list as events are reported, so just try deleting exited threads. */
995 delete_exited_threads ();
999 fbsd_add_threads (ptid_get_pid (inferior_ptid
));
1005 To catch fork events, PT_FOLLOW_FORK is set on every traced process
1006 to enable stops on returns from fork or vfork. Note that both the
1007 parent and child will always stop, even if system call stops are not
1010 After a fork, both the child and parent process will stop and report
1011 an event. However, there is no guarantee of order. If the parent
1012 reports its stop first, then fbsd_wait explicitly waits for the new
1013 child before returning. If the child reports its stop first, then
1014 the event is saved on a list and ignored until the parent's stop is
1015 reported. fbsd_wait could have been changed to fetch the parent PID
1016 of the new child and used that to wait for the parent explicitly.
1017 However, if two threads in the parent fork at the same time, then
1018 the wait on the parent might return the "wrong" fork event.
1020 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
1021 the new child process. This flag could be inferred by treating any
1022 events for an unknown pid as a new child.
1024 In addition, the initial version of PT_FOLLOW_FORK did not report a
1025 stop event for the parent process of a vfork until after the child
1026 process executed a new program or exited. The kernel was changed to
1027 defer the wait for exit or exec of the child until after posting the
1028 stop event shortly after the change to introduce PL_FLAG_CHILD.
1029 This could be worked around by reporting a vfork event when the
1030 child event posted and ignoring the subsequent event from the
1033 This implementation requires both of these fixes for simplicity's
1034 sake. FreeBSD versions newer than 9.1 contain both fixes.
1037 static std::list
<ptid_t
> fbsd_pending_children
;
1039 /* Record a new child process event that is reported before the
1040 corresponding fork event in the parent. */
1043 fbsd_remember_child (ptid_t pid
)
1045 fbsd_pending_children
.push_front (pid
);
1048 /* Check for a previously-recorded new child process event for PID.
1049 If one is found, remove it from the list and return the PTID. */
1052 fbsd_is_child_pending (pid_t pid
)
1054 for (auto it
= fbsd_pending_children
.begin ();
1055 it
!= fbsd_pending_children
.end (); it
++)
1056 if (it
->pid () == pid
)
1059 fbsd_pending_children
.erase (it
);
1065 #ifndef PTRACE_VFORK
1066 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
1068 /* Record a pending vfork done event. */
1071 fbsd_add_vfork_done (ptid_t pid
)
1073 fbsd_pending_vfork_done
.push_front (pid
);
1076 /* Check for a pending vfork done event for a specific PID. */
1079 fbsd_is_vfork_done_pending (pid_t pid
)
1081 for (auto it
= fbsd_pending_vfork_done
.begin ();
1082 it
!= fbsd_pending_vfork_done
.end (); it
++)
1083 if (it
->pid () == pid
)
1088 /* Check for a pending vfork done event. If one is found, remove it
1089 from the list and return the PTID. */
1092 fbsd_next_vfork_done (void)
1094 if (!fbsd_pending_vfork_done
.empty ())
1096 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1097 fbsd_pending_vfork_done
.pop_front ();
1105 /* Implement the "to_resume" target_ops method. */
1108 fbsd_resume (struct target_ops
*ops
,
1109 ptid_t ptid
, int step
, enum gdb_signal signo
)
1111 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1114 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1115 if (ptid_equal (minus_one_ptid
, ptid
))
1116 pid
= ptid_get_pid (inferior_ptid
);
1118 pid
= ptid_get_pid (ptid
);
1119 if (fbsd_is_vfork_done_pending (pid
))
1124 fprintf_unfiltered (gdb_stdlog
,
1125 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
1126 ptid_get_pid (ptid
), ptid_get_lwp (ptid
),
1127 ptid_get_tid (ptid
));
1128 if (ptid_lwp_p (ptid
))
1130 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1131 struct thread_info
*tp
;
1134 ALL_NON_EXITED_THREADS (tp
)
1136 if (ptid_get_pid (tp
->ptid
) != ptid_get_pid (ptid
))
1139 if (ptid_get_lwp (tp
->ptid
) == ptid_get_lwp (ptid
))
1140 request
= PT_RESUME
;
1142 request
= PT_SUSPEND
;
1144 if (ptrace (request
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
1145 perror_with_name (("ptrace"));
1150 /* If ptid is a wildcard, resume all matching threads (they won't run
1151 until the process is continued however). */
1152 struct thread_info
*tp
;
1154 ALL_NON_EXITED_THREADS (tp
)
1156 if (!ptid_match (tp
->ptid
, ptid
))
1159 if (ptrace (PT_RESUME
, ptid_get_lwp (tp
->ptid
), NULL
, 0) == -1)
1160 perror_with_name (("ptrace"));
1162 ptid
= inferior_ptid
;
1165 #if __FreeBSD_version < 1200052
1166 /* When multiple threads within a process wish to report STOPPED
1167 events from wait(), the kernel picks one thread event as the
1168 thread event to report. The chosen thread event is retrieved via
1169 PT_LWPINFO by passing the process ID as the request pid. If
1170 multiple events are pending, then the subsequent wait() after
1171 resuming a process will report another STOPPED event after
1172 resuming the process to handle the next thread event and so on.
1174 A single thread event is cleared as a side effect of resuming the
1175 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1176 however, the request pid was used to select which thread's event
1177 was cleared rather than always clearing the event that was just
1178 reported. To avoid clearing the event of the wrong LWP, always
1179 pass the process ID instead of an LWP ID to PT_CONTINUE or
1182 In the case of stepping, the process ID cannot be used with
1183 PT_STEP since it would step the thread that reported an event
1184 which may not be the thread indicated by PTID. For stepping, use
1185 PT_SETSTEP to enable stepping on the desired thread before
1186 resuming the process via PT_CONTINUE instead of using
1190 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1191 perror_with_name (("ptrace"));
1194 ptid
= ptid_t (ptid
.pid ());
1196 super_resume (ops
, ptid
, step
, signo
);
1199 #ifdef USE_SIGTRAP_SIGINFO
1200 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1201 trap was a breakpoint or trace trap that should be reported to the
1202 core, return true. */
1205 fbsd_handle_debug_trap (struct target_ops
*ops
, ptid_t ptid
,
1206 const struct ptrace_lwpinfo
&pl
)
1209 /* Ignore traps without valid siginfo or for signals other than
1211 if (! (pl
.pl_flags
& PL_FLAG_SI
) || pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1214 /* Trace traps are either a single step or a hardware watchpoint or
1216 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1219 fprintf_unfiltered (gdb_stdlog
,
1220 "FNAT: trace trap for LWP %ld\n", ptid
.lwp ());
1224 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1226 /* Fixup PC for the software breakpoint. */
1227 struct regcache
*regcache
= get_thread_regcache (ptid
);
1228 struct gdbarch
*gdbarch
= regcache
->arch ();
1229 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1232 fprintf_unfiltered (gdb_stdlog
,
1233 "FNAT: sw breakpoint trap for LWP %ld\n",
1239 pc
= regcache_read_pc (regcache
);
1240 regcache_write_pc (regcache
, pc
- decr_pc
);
1249 /* Wait for the child specified by PTID to do something. Return the
1250 process ID of the child, or MINUS_ONE_PTID in case of error; store
1251 the status in *OURSTATUS. */
1254 fbsd_wait (struct target_ops
*ops
,
1255 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1262 #ifndef PTRACE_VFORK
1263 wptid
= fbsd_next_vfork_done ();
1264 if (!ptid_equal (wptid
, null_ptid
))
1266 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1270 wptid
= super_wait (ops
, ptid
, ourstatus
, target_options
);
1271 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1273 struct ptrace_lwpinfo pl
;
1277 pid
= ptid_get_pid (wptid
);
1278 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1279 perror_with_name (("ptrace"));
1281 wptid
= ptid_build (pid
, pl
.pl_lwpid
, 0);
1285 fprintf_unfiltered (gdb_stdlog
,
1286 "FNAT: stop for LWP %u event %d flags %#x\n",
1287 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1288 if (pl
.pl_flags
& PL_FLAG_SI
)
1289 fprintf_unfiltered (gdb_stdlog
,
1290 "FNAT: si_signo %u si_code %u\n",
1291 pl
.pl_siginfo
.si_signo
,
1292 pl
.pl_siginfo
.si_code
);
1295 #ifdef PT_LWP_EVENTS
1296 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1298 /* If GDB attaches to a multi-threaded process, exiting
1299 threads might be skipped during fbsd_post_attach that
1300 have not yet reported their PL_FLAG_EXITED event.
1301 Ignore EXITED events for an unknown LWP. */
1302 if (in_thread_list (wptid
))
1305 fprintf_unfiltered (gdb_stdlog
,
1306 "FLWP: deleting thread for LWP %u\n",
1308 if (print_thread_events
)
1309 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
1311 delete_thread (wptid
);
1313 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1314 perror_with_name (("ptrace"));
1319 /* Switch to an LWP PTID on the first stop in a new process.
1320 This is done after handling PL_FLAG_EXITED to avoid
1321 switching to an exited LWP. It is done before checking
1322 PL_FLAG_BORN in case the first stop reported after
1323 attaching to an existing process is a PL_FLAG_BORN
1325 if (in_thread_list (pid_to_ptid (pid
)))
1328 fprintf_unfiltered (gdb_stdlog
,
1329 "FLWP: using LWP %u for first thread\n",
1331 thread_change_ptid (pid_to_ptid (pid
), wptid
);
1334 #ifdef PT_LWP_EVENTS
1335 if (pl
.pl_flags
& PL_FLAG_BORN
)
1337 /* If GDB attaches to a multi-threaded process, newborn
1338 threads might be added by fbsd_add_threads that have
1339 not yet reported their PL_FLAG_BORN event. Ignore
1340 BORN events for an already-known LWP. */
1341 if (!in_thread_list (wptid
))
1344 fprintf_unfiltered (gdb_stdlog
,
1345 "FLWP: adding thread for LWP %u\n",
1349 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1355 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1357 #ifndef PTRACE_VFORK
1358 struct kinfo_proc kp
;
1363 child
= pl
.pl_child_pid
;
1364 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1366 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1367 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1370 /* Make sure the other end of the fork is stopped too. */
1371 child_ptid
= fbsd_is_child_pending (child
);
1372 if (ptid_equal (child_ptid
, null_ptid
))
1374 pid
= waitpid (child
, &status
, 0);
1376 perror_with_name (("waitpid"));
1378 gdb_assert (pid
== child
);
1380 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1381 perror_with_name (("ptrace"));
1383 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1384 child_ptid
= ptid_build (child
, pl
.pl_lwpid
, 0);
1387 /* Enable additional events on the child process. */
1388 fbsd_enable_proc_events (ptid_get_pid (child_ptid
));
1390 #ifndef PTRACE_VFORK
1391 /* For vfork, the child process will have the P_PPWAIT
1393 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1395 if (kp
.ki_flag
& P_PPWAIT
)
1396 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1399 warning (_("Failed to fetch process information"));
1401 ourstatus
->value
.related_pid
= child_ptid
;
1406 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1408 /* Remember that this child forked, but do not report it
1409 until the parent reports its corresponding fork
1411 fbsd_remember_child (wptid
);
1416 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1418 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1425 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1427 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1428 ourstatus
->value
.execd_pathname
1429 = xstrdup (fbsd_pid_to_exec_file (NULL
, pid
));
1434 #ifdef USE_SIGTRAP_SIGINFO
1435 if (fbsd_handle_debug_trap (ops
, wptid
, pl
))
1439 /* Note that PL_FLAG_SCE is set for any event reported while
1440 a thread is executing a system call in the kernel. In
1441 particular, signals that interrupt a sleep in a system
1442 call will report this flag as part of their event. Stops
1443 explicitly for system call entry and exit always use
1444 SIGTRAP, so only treat SIGTRAP events as system call
1445 entry/exit events. */
1446 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1447 && ourstatus
->value
.sig
== SIGTRAP
)
1449 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1450 if (catch_syscall_enabled ())
1452 if (catching_syscall_number (pl
.pl_syscall_code
))
1454 if (pl
.pl_flags
& PL_FLAG_SCE
)
1455 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1457 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1458 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1463 /* If the core isn't interested in this event, just
1464 continue the process explicitly and wait for another
1465 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1466 and once system call stops are enabled on a process
1467 it stops for all system call entries and exits. */
1468 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1469 perror_with_name (("ptrace"));
1477 #ifdef USE_SIGTRAP_SIGINFO
1478 /* Implement the "to_stopped_by_sw_breakpoint" target_ops method. */
1481 fbsd_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1483 struct ptrace_lwpinfo pl
;
1485 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1489 return ((pl
.pl_flags
& PL_FLAG_SI
)
1490 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1491 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1494 /* Implement the "to_supports_stopped_by_sw_breakpoint" target_ops
1498 fbsd_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1503 /* Implement the "to_supports_stopped_by_hw_breakpoint" target_ops
1507 fbsd_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1509 return ops
->to_stopped_by_hw_breakpoint
!= NULL
;
1514 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1515 the ptid of the followed inferior. */
1518 fbsd_follow_fork (struct target_ops
*ops
, int follow_child
,
1521 if (!follow_child
&& detach_fork
)
1523 struct thread_info
*tp
= inferior_thread ();
1524 pid_t child_pid
= ptid_get_pid (tp
->pending_follow
.value
.related_pid
);
1526 /* Breakpoints have already been detached from the child by
1529 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1530 perror_with_name (("ptrace"));
1532 #ifndef PTRACE_VFORK
1533 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1535 /* We can't insert breakpoints until the child process has
1536 finished with the shared memory region. The parent
1537 process doesn't wait for the child process to exit or
1538 exec until after it has been resumed from the ptrace stop
1539 to report the fork. Once it has been resumed it doesn't
1540 stop again before returning to userland, so there is no
1541 reliable way to wait on the parent.
1543 We can't stay attached to the child to wait for an exec
1544 or exit because it may invoke ptrace(PT_TRACE_ME)
1545 (e.g. if the parent process is a debugger forking a new
1548 In the end, the best we can do is to make sure it runs
1549 for a little while. Hopefully it will be out of range of
1550 any breakpoints we reinsert. Usually this is only the
1551 single-step breakpoint at vfork's return point. */
1555 /* Schedule a fake VFORK_DONE event to report on the next
1557 fbsd_add_vfork_done (inferior_ptid
);
1566 fbsd_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
1572 fbsd_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
1578 fbsd_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
1584 fbsd_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
1590 /* Implement the "to_post_startup_inferior" target_ops method. */
1593 fbsd_post_startup_inferior (struct target_ops
*self
, ptid_t pid
)
1595 fbsd_enable_proc_events (ptid_get_pid (pid
));
1598 /* Implement the "to_post_attach" target_ops method. */
1601 fbsd_post_attach (struct target_ops
*self
, int pid
)
1603 fbsd_enable_proc_events (pid
);
1604 fbsd_add_threads (pid
);
1608 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1609 will always stop after exec. */
1612 fbsd_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
1618 fbsd_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
1624 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1626 fbsd_set_syscall_catchpoint (struct target_ops
*self
, int pid
, bool needed
,
1628 gdb::array_view
<const int> syscall_counts
)
1631 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1632 will catch all system call entries and exits. The system calls
1633 are filtered by GDB rather than the kernel. */
1640 fbsd_nat_add_target (struct target_ops
*t
)
1642 t
->to_pid_to_exec_file
= fbsd_pid_to_exec_file
;
1643 t
->to_find_memory_regions
= fbsd_find_memory_regions
;
1644 t
->to_info_proc
= fbsd_info_proc
;
1645 #ifdef KERN_PROC_AUXV
1646 super_xfer_partial
= t
->to_xfer_partial
;
1647 t
->to_xfer_partial
= fbsd_xfer_partial
;
1650 t
->to_thread_alive
= fbsd_thread_alive
;
1651 t
->to_pid_to_str
= fbsd_pid_to_str
;
1652 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
1653 t
->to_thread_name
= fbsd_thread_name
;
1655 t
->to_update_thread_list
= fbsd_update_thread_list
;
1656 t
->to_has_thread_control
= tc_schedlock
;
1657 super_resume
= t
->to_resume
;
1658 t
->to_resume
= fbsd_resume
;
1659 super_wait
= t
->to_wait
;
1660 t
->to_wait
= fbsd_wait
;
1661 t
->to_post_startup_inferior
= fbsd_post_startup_inferior
;
1662 t
->to_post_attach
= fbsd_post_attach
;
1663 #ifdef USE_SIGTRAP_SIGINFO
1664 t
->to_stopped_by_sw_breakpoint
= fbsd_stopped_by_sw_breakpoint
;
1665 t
->to_supports_stopped_by_sw_breakpoint
1666 = fbsd_supports_stopped_by_sw_breakpoint
;
1667 t
->to_supports_stopped_by_hw_breakpoint
1668 = fbsd_supports_stopped_by_hw_breakpoint
;
1671 t
->to_follow_fork
= fbsd_follow_fork
;
1672 t
->to_insert_fork_catchpoint
= fbsd_insert_fork_catchpoint
;
1673 t
->to_remove_fork_catchpoint
= fbsd_remove_fork_catchpoint
;
1674 t
->to_insert_vfork_catchpoint
= fbsd_insert_vfork_catchpoint
;
1675 t
->to_remove_vfork_catchpoint
= fbsd_remove_vfork_catchpoint
;
1678 t
->to_insert_exec_catchpoint
= fbsd_insert_exec_catchpoint
;
1679 t
->to_remove_exec_catchpoint
= fbsd_remove_exec_catchpoint
;
1681 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1682 t
->to_set_syscall_catchpoint
= fbsd_set_syscall_catchpoint
;
1689 _initialize_fbsd_nat (void)
1692 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1693 &debug_fbsd_lwp
, _("\
1694 Set debugging of FreeBSD lwp module."), _("\
1695 Show debugging of FreeBSD lwp module."), _("\
1696 Enables printf debugging output."),
1698 &show_fbsd_lwp_debug
,
1699 &setdebuglist
, &showdebuglist
);
1700 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1701 &debug_fbsd_nat
, _("\
1702 Set debugging of FreeBSD native target."), _("\
1703 Show debugging of FreeBSD native target."), _("\
1704 Enables printf debugging output."),
1706 &show_fbsd_nat_debug
,
1707 &setdebuglist
, &showdebuglist
);