1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2022 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 "gdbsupport/byte-vector.h"
28 #include "gdbthread.h"
29 #include "gdbsupport/buildargv.h"
30 #include "gdbsupport/gdb_wait.h"
31 #include "inf-ptrace.h"
32 #include <sys/types.h>
33 #ifdef HAVE_SYS_PROCCTL_H
34 #include <sys/procctl.h>
36 #include <sys/procfs.h>
37 #include <sys/ptrace.h>
38 #include <sys/signal.h>
39 #include <sys/sysctl.h>
45 #include "fbsd-tdep.h"
49 /* Return the name of a file that can be opened to get the symbols for
50 the child process identified by PID. */
53 fbsd_nat_target::pid_to_exec_file (int pid
)
55 static char buf
[PATH_MAX
];
61 mib
[2] = KERN_PROC_PATHNAME
;
64 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
65 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
66 for processes without an associated executable such as kernel
68 return buflen
== 0 ? NULL
: buf
;
73 /* Iterate over all the memory regions in the current inferior,
74 calling FUNC for each memory region. DATA is passed as the last
78 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
81 pid_t pid
= inferior_ptid
.pid ();
82 struct kinfo_vmentry
*kve
;
86 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
87 vmentl (kinfo_getvmmap (pid
, &nitems
));
89 perror_with_name (_("Couldn't fetch VM map entries."));
91 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
93 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
94 if (!(kve
->kve_protection
& KVME_PROT_READ
)
95 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
98 /* Skip segments with an invalid type. */
99 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
100 && kve
->kve_type
!= KVME_TYPE_VNODE
101 && kve
->kve_type
!= KVME_TYPE_SWAP
102 && kve
->kve_type
!= KVME_TYPE_PHYS
)
105 size
= kve
->kve_end
- kve
->kve_start
;
108 fprintf_filtered (gdb_stdout
,
109 "Save segment, %ld bytes at %s (%c%c%c)\n",
111 paddress (target_gdbarch (), kve
->kve_start
),
112 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
113 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
114 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
117 /* Invoke the callback function to create the corefile segment.
118 Pass MODIFIED as true, we do not know the real modification state. */
119 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
120 kve
->kve_protection
& KVME_PROT_WRITE
,
121 kve
->kve_protection
& KVME_PROT_EXEC
, 1, data
);
126 /* Fetch the command line for a running process. */
128 static gdb::unique_xmalloc_ptr
<char>
129 fbsd_fetch_cmdline (pid_t pid
)
137 mib
[2] = KERN_PROC_ARGS
;
139 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
145 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
146 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
149 /* Join the arguments with spaces to form a single string. */
150 char *cp
= cmdline
.get ();
151 for (size_t i
= 0; i
< len
- 1; i
++)
159 /* Fetch the external variant of the kernel's internal process
160 structure for the process PID into KP. */
163 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
171 mib
[2] = KERN_PROC_PID
;
173 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
176 /* Implement the "info_proc" target_ops method. */
179 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
181 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
183 struct kinfo_proc kp
;
185 bool do_cmdline
= false;
188 bool do_files
= false;
189 bool do_mappings
= false;
190 bool do_status
= false;
227 error (_("Not supported on this target."));
230 gdb_argv
built_argv (args
);
231 if (built_argv
.count () == 0)
233 pid
= inferior_ptid
.pid ();
235 error (_("No current process: you must name one."));
237 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
238 pid
= strtol (built_argv
[0], NULL
, 10);
240 error (_("Invalid arguments."));
242 printf_filtered (_("process %d\n"), pid
);
243 if (do_cwd
|| do_exe
|| do_files
)
244 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
248 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
249 if (cmdline
!= nullptr)
250 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
252 warning (_("unable to fetch command line"));
256 const char *cwd
= NULL
;
257 struct kinfo_file
*kf
= fdtbl
.get ();
258 for (int i
= 0; i
< nfd
; i
++, kf
++)
260 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
267 printf_filtered ("cwd = '%s'\n", cwd
);
269 warning (_("unable to fetch current working directory"));
273 const char *exe
= NULL
;
274 struct kinfo_file
*kf
= fdtbl
.get ();
275 for (int i
= 0; i
< nfd
; i
++, kf
++)
277 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
284 exe
= pid_to_exec_file (pid
);
286 printf_filtered ("exe = '%s'\n", exe
);
288 warning (_("unable to fetch executable path name"));
292 struct kinfo_file
*kf
= fdtbl
.get ();
296 fbsd_info_proc_files_header ();
297 for (int i
= 0; i
< nfd
; i
++, kf
++)
298 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
299 kf
->kf_offset
, kf
->kf_vnode_type
,
300 kf
->kf_sock_domain
, kf
->kf_sock_type
,
301 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
302 &kf
->kf_sa_peer
, kf
->kf_path
);
305 warning (_("unable to fetch list of open files"));
310 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
311 vmentl (kinfo_getvmmap (pid
, &nvment
));
313 if (vmentl
!= nullptr)
315 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
316 fbsd_info_proc_mappings_header (addr_bit
);
318 struct kinfo_vmentry
*kve
= vmentl
.get ();
319 for (int i
= 0; i
< nvment
; i
++, kve
++)
320 fbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
321 kve
->kve_end
, kve
->kve_offset
,
322 kve
->kve_flags
, kve
->kve_protection
,
326 warning (_("unable to fetch virtual memory map"));
330 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
331 warning (_("Failed to fetch process information"));
337 printf_filtered ("Name: %s\n", kp
.ki_comm
);
344 state
= "R (running)";
347 state
= "T (stopped)";
350 state
= "Z (zombie)";
353 state
= "S (sleeping)";
356 state
= "W (interrupt wait)";
359 state
= "L (blocked on lock)";
362 state
= "? (unknown)";
365 printf_filtered ("State: %s\n", state
);
366 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
367 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
368 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
369 printf_filtered ("TTY: %s\n", pulongest (kp
.ki_tdev
));
370 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
371 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
372 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
373 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
374 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
375 printf_filtered ("Groups: ");
376 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
377 printf_filtered ("%d ", kp
.ki_groups
[i
]);
378 printf_filtered ("\n");
379 printf_filtered ("Minor faults (no memory page): %ld\n",
380 kp
.ki_rusage
.ru_minflt
);
381 printf_filtered ("Minor faults, children: %ld\n",
382 kp
.ki_rusage_ch
.ru_minflt
);
383 printf_filtered ("Major faults (memory page faults): %ld\n",
384 kp
.ki_rusage
.ru_majflt
);
385 printf_filtered ("Major faults, children: %ld\n",
386 kp
.ki_rusage_ch
.ru_majflt
);
387 printf_filtered ("utime: %s.%06ld\n",
388 plongest (kp
.ki_rusage
.ru_utime
.tv_sec
),
389 kp
.ki_rusage
.ru_utime
.tv_usec
);
390 printf_filtered ("stime: %s.%06ld\n",
391 plongest (kp
.ki_rusage
.ru_stime
.tv_sec
),
392 kp
.ki_rusage
.ru_stime
.tv_usec
);
393 printf_filtered ("utime, children: %s.%06ld\n",
394 plongest (kp
.ki_rusage_ch
.ru_utime
.tv_sec
),
395 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
396 printf_filtered ("stime, children: %s.%06ld\n",
397 plongest (kp
.ki_rusage_ch
.ru_stime
.tv_sec
),
398 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
399 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
400 printf_filtered ("Start time: %s.%06ld\n",
401 plongest (kp
.ki_start
.tv_sec
),
402 kp
.ki_start
.tv_usec
);
403 pgtok
= getpagesize () / 1024;
404 printf_filtered ("Virtual memory size: %s kB\n",
405 pulongest (kp
.ki_size
/ 1024));
406 printf_filtered ("Data size: %s kB\n",
407 pulongest (kp
.ki_dsize
* pgtok
));
408 printf_filtered ("Stack size: %s kB\n",
409 pulongest (kp
.ki_ssize
* pgtok
));
410 printf_filtered ("Text size: %s kB\n",
411 pulongest (kp
.ki_tsize
* pgtok
));
412 printf_filtered ("Resident set size: %s kB\n",
413 pulongest (kp
.ki_rssize
* pgtok
));
414 printf_filtered ("Maximum RSS: %s kB\n",
415 pulongest (kp
.ki_rusage
.ru_maxrss
));
416 printf_filtered ("Pending Signals: ");
417 for (int i
= 0; i
< _SIG_WORDS
; i
++)
418 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
419 printf_filtered ("\n");
420 printf_filtered ("Ignored Signals: ");
421 for (int i
= 0; i
< _SIG_WORDS
; i
++)
422 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
423 printf_filtered ("\n");
424 printf_filtered ("Caught Signals: ");
425 for (int i
= 0; i
< _SIG_WORDS
; i
++)
426 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
427 printf_filtered ("\n");
434 /* Return the size of siginfo for the current inferior. */
442 /* This structure matches the naming and layout of `siginfo_t' in
443 <sys/signal.h>. In particular, the `si_foo' macros defined in that
444 header can be used with both types to copy fields in the `_reason'
456 union sigval32 si_value
;
489 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
491 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
492 if (gdbarch_long_bit (gdbarch
) == 32)
493 return sizeof (struct siginfo32
);
495 return sizeof (siginfo_t
);
498 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
499 that FreeBSD doesn't support writing to $_siginfo, so this only
500 needs to convert one way. */
503 fbsd_convert_siginfo (siginfo_t
*si
)
506 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
508 /* Is the inferior 32-bit? If not, nothing to do. */
509 if (gdbarch_long_bit (gdbarch
) != 32)
512 struct siginfo32 si32
;
514 si32
.si_signo
= si
->si_signo
;
515 si32
.si_errno
= si
->si_errno
;
516 si32
.si_code
= si
->si_code
;
517 si32
.si_pid
= si
->si_pid
;
518 si32
.si_uid
= si
->si_uid
;
519 si32
.si_status
= si
->si_status
;
520 si32
.si_addr
= (uintptr_t) si
->si_addr
;
522 /* If sival_ptr is being used instead of sival_int on a big-endian
523 platform, then sival_int will be zero since it holds the upper
524 32-bits of the pointer value. */
525 #if _BYTE_ORDER == _BIG_ENDIAN
526 if (si
->si_value
.sival_int
== 0)
527 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
529 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
531 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
534 /* Always copy the spare fields and then possibly overwrite them for
535 signal-specific or code-specific fields. */
536 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
537 for (int i
= 0; i
< 7; i
++)
538 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
539 switch (si
->si_signo
) {
544 si32
.si_trapno
= si
->si_trapno
;
547 switch (si
->si_code
) {
549 si32
.si_timerid
= si
->si_timerid
;
550 si32
.si_overrun
= si
->si_overrun
;
553 si32
.si_mqd
= si
->si_mqd
;
557 memcpy(si
, &si32
, sizeof (si32
));
561 /* Implement the "xfer_partial" target_ops method. */
563 enum target_xfer_status
564 fbsd_nat_target::xfer_partial (enum target_object object
,
565 const char *annex
, gdb_byte
*readbuf
,
566 const gdb_byte
*writebuf
,
567 ULONGEST offset
, ULONGEST len
,
568 ULONGEST
*xfered_len
)
570 pid_t pid
= inferior_ptid
.pid ();
574 case TARGET_OBJECT_SIGNAL_INFO
:
576 struct ptrace_lwpinfo pl
;
579 /* FreeBSD doesn't support writing to $_siginfo. */
580 if (writebuf
!= NULL
)
581 return TARGET_XFER_E_IO
;
583 if (inferior_ptid
.lwp_p ())
584 pid
= inferior_ptid
.lwp ();
586 siginfo_size
= fbsd_siginfo_size ();
587 if (offset
> siginfo_size
)
588 return TARGET_XFER_E_IO
;
590 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
591 return TARGET_XFER_E_IO
;
593 if (!(pl
.pl_flags
& PL_FLAG_SI
))
594 return TARGET_XFER_E_IO
;
596 fbsd_convert_siginfo (&pl
.pl_siginfo
);
597 if (offset
+ len
> siginfo_size
)
598 len
= siginfo_size
- offset
;
600 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
602 return TARGET_XFER_OK
;
604 #ifdef KERN_PROC_AUXV
605 case TARGET_OBJECT_AUXV
:
607 gdb::byte_vector buf_storage
;
612 if (writebuf
!= NULL
)
613 return TARGET_XFER_E_IO
;
616 mib
[2] = KERN_PROC_AUXV
;
625 buflen
= offset
+ len
;
626 buf_storage
.resize (buflen
);
627 buf
= buf_storage
.data ();
629 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
636 memcpy (readbuf
, buf
+ offset
, buflen
);
641 *xfered_len
= buflen
;
642 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
644 return TARGET_XFER_E_IO
;
647 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
648 case TARGET_OBJECT_FREEBSD_VMMAP
:
649 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
651 gdb::byte_vector buf_storage
;
657 uint32_t struct_size
;
660 case TARGET_OBJECT_FREEBSD_VMMAP
:
661 proc_target
= KERN_PROC_VMMAP
;
662 struct_size
= sizeof (struct kinfo_vmentry
);
664 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
665 proc_target
= KERN_PROC_PS_STRINGS
;
666 struct_size
= sizeof (void *);
670 if (writebuf
!= NULL
)
671 return TARGET_XFER_E_IO
;
675 mib
[2] = proc_target
;
678 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
679 return TARGET_XFER_E_IO
;
680 buflen
+= sizeof (struct_size
);
682 if (offset
>= buflen
)
685 return TARGET_XFER_EOF
;
688 buf_storage
.resize (buflen
);
689 buf
= buf_storage
.data ();
691 memcpy (buf
, &struct_size
, sizeof (struct_size
));
692 buflen
-= sizeof (struct_size
);
693 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
694 return TARGET_XFER_E_IO
;
695 buflen
+= sizeof (struct_size
);
697 if (buflen
- offset
< len
)
698 len
= buflen
- offset
;
699 memcpy (readbuf
, buf
+ offset
, len
);
701 return TARGET_XFER_OK
;
705 return inf_ptrace_target::xfer_partial (object
, annex
,
706 readbuf
, writebuf
, offset
,
711 static bool debug_fbsd_lwp
;
712 static bool debug_fbsd_nat
;
715 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
716 struct cmd_list_element
*c
, const char *value
)
718 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
722 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
723 struct cmd_list_element
*c
, const char *value
)
725 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
729 #define fbsd_lwp_debug_printf(fmt, ...) \
730 debug_prefixed_printf_cond (debug_fbsd_lwp, "fbsd-lwp", fmt, ##__VA_ARGS__)
732 #define fbsd_nat_debug_printf(fmt, ...) \
733 debug_prefixed_printf_cond (debug_fbsd_nat, "fbsd-nat", fmt, ##__VA_ARGS__)
737 FreeBSD's first thread support was via a "reentrant" version of libc
738 (libc_r) that first shipped in 2.2.7. This library multiplexed all
739 of the threads in a process onto a single kernel thread. This
740 library was supported via the bsd-uthread target.
742 FreeBSD 5.1 introduced two new threading libraries that made use of
743 multiple kernel threads. The first (libkse) scheduled M user
744 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
745 bound each user thread to a dedicated kernel thread. libkse shipped
746 as the default threading library (libpthread).
748 FreeBSD 5.3 added a libthread_db to abstract the interface across
749 the various thread libraries (libc_r, libkse, and libthr).
751 FreeBSD 7.0 switched the default threading library from from libkse
752 to libpthread and removed libc_r.
754 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
755 only threading library supported by 8.0 and later is libthr which
756 ties each user thread directly to an LWP. To simplify the
757 implementation, this target only supports LWP-backed threads using
758 ptrace directly rather than libthread_db.
760 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
763 /* Return true if PTID is still active in the inferior. */
766 fbsd_nat_target::thread_alive (ptid_t ptid
)
770 struct ptrace_lwpinfo pl
;
772 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
775 #ifdef PL_FLAG_EXITED
776 if (pl
.pl_flags
& PL_FLAG_EXITED
)
784 /* Convert PTID to a string. */
787 fbsd_nat_target::pid_to_str (ptid_t ptid
)
794 int pid
= ptid
.pid ();
796 return string_printf ("LWP %d of process %d", lwp
, pid
);
799 return normal_pid_to_str (ptid
);
802 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
803 /* Return the name assigned to a thread by an application. Returns
804 the string in a static buffer. */
807 fbsd_nat_target::thread_name (struct thread_info
*thr
)
809 struct ptrace_lwpinfo pl
;
810 struct kinfo_proc kp
;
811 int pid
= thr
->ptid
.pid ();
812 long lwp
= thr
->ptid
.lwp ();
813 static char buf
[sizeof pl
.pl_tdname
+ 1];
815 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
816 if a name has not been set explicitly. Return a NULL name in
818 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
819 perror_with_name (_("Failed to fetch process information"));
820 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
821 perror_with_name (("ptrace"));
822 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
824 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
829 /* Enable additional event reporting on new processes.
831 To catch fork events, PTRACE_FORK is set on every traced process
832 to enable stops on returns from fork or vfork. Note that both the
833 parent and child will always stop, even if system call stops are
836 To catch LWP events, PTRACE_EVENTS is set on every traced process.
837 This enables stops on the birth for new LWPs (excluding the "main" LWP)
838 and the death of LWPs (excluding the last LWP in a process). Note
839 that unlike fork events, the LWP that creates a new LWP does not
843 fbsd_enable_proc_events (pid_t pid
)
845 #ifdef PT_GET_EVENT_MASK
848 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
849 sizeof (events
)) == -1)
850 perror_with_name (("ptrace"));
851 events
|= PTRACE_FORK
| PTRACE_LWP
;
853 events
|= PTRACE_VFORK
;
855 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
856 sizeof (events
)) == -1)
857 perror_with_name (("ptrace"));
860 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
861 perror_with_name (("ptrace"));
864 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
865 perror_with_name (("ptrace"));
870 /* Add threads for any new LWPs in a process.
872 When LWP events are used, this function is only used to detect existing
873 threads when attaching to a process. On older systems, this function is
874 called to discover new threads each time the thread list is updated. */
877 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
881 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
882 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
884 perror_with_name (("ptrace"));
886 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
888 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
890 perror_with_name (("ptrace"));
892 for (i
= 0; i
< nlwps
; i
++)
894 ptid_t ptid
= ptid_t (pid
, lwps
[i
]);
896 if (!in_thread_list (target
, ptid
))
899 struct ptrace_lwpinfo pl
;
901 /* Don't add exited threads. Note that this is only called
902 when attaching to a multi-threaded process. */
903 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
904 perror_with_name (("ptrace"));
905 if (pl
.pl_flags
& PL_FLAG_EXITED
)
908 fbsd_lwp_debug_printf ("adding thread for LWP %u", lwps
[i
]);
909 add_thread (target
, ptid
);
914 /* Implement the "update_thread_list" target_ops method. */
917 fbsd_nat_target::update_thread_list ()
920 /* With support for thread events, threads are added/deleted from the
921 list as events are reported, so just try deleting exited threads. */
922 delete_exited_threads ();
926 fbsd_add_threads (this, inferior_ptid
.pid ());
932 To catch fork events, PT_FOLLOW_FORK is set on every traced process
933 to enable stops on returns from fork or vfork. Note that both the
934 parent and child will always stop, even if system call stops are not
937 After a fork, both the child and parent process will stop and report
938 an event. However, there is no guarantee of order. If the parent
939 reports its stop first, then fbsd_wait explicitly waits for the new
940 child before returning. If the child reports its stop first, then
941 the event is saved on a list and ignored until the parent's stop is
942 reported. fbsd_wait could have been changed to fetch the parent PID
943 of the new child and used that to wait for the parent explicitly.
944 However, if two threads in the parent fork at the same time, then
945 the wait on the parent might return the "wrong" fork event.
947 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
948 the new child process. This flag could be inferred by treating any
949 events for an unknown pid as a new child.
951 In addition, the initial version of PT_FOLLOW_FORK did not report a
952 stop event for the parent process of a vfork until after the child
953 process executed a new program or exited. The kernel was changed to
954 defer the wait for exit or exec of the child until after posting the
955 stop event shortly after the change to introduce PL_FLAG_CHILD.
956 This could be worked around by reporting a vfork event when the
957 child event posted and ignoring the subsequent event from the
960 This implementation requires both of these fixes for simplicity's
961 sake. FreeBSD versions newer than 9.1 contain both fixes.
964 static std::list
<ptid_t
> fbsd_pending_children
;
966 /* Record a new child process event that is reported before the
967 corresponding fork event in the parent. */
970 fbsd_remember_child (ptid_t pid
)
972 fbsd_pending_children
.push_front (pid
);
975 /* Check for a previously-recorded new child process event for PID.
976 If one is found, remove it from the list and return the PTID. */
979 fbsd_is_child_pending (pid_t pid
)
981 for (auto it
= fbsd_pending_children
.begin ();
982 it
!= fbsd_pending_children
.end (); it
++)
983 if (it
->pid () == pid
)
986 fbsd_pending_children
.erase (it
);
993 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
995 /* Record a pending vfork done event. */
998 fbsd_add_vfork_done (ptid_t pid
)
1000 fbsd_pending_vfork_done
.push_front (pid
);
1003 /* Check for a pending vfork done event for a specific PID. */
1006 fbsd_is_vfork_done_pending (pid_t pid
)
1008 for (auto it
= fbsd_pending_vfork_done
.begin ();
1009 it
!= fbsd_pending_vfork_done
.end (); it
++)
1010 if (it
->pid () == pid
)
1015 /* Check for a pending vfork done event. If one is found, remove it
1016 from the list and return the PTID. */
1019 fbsd_next_vfork_done (void)
1021 if (!fbsd_pending_vfork_done
.empty ())
1023 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1024 fbsd_pending_vfork_done
.pop_front ();
1032 /* Implement the "resume" target_ops method. */
1035 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1037 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1040 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1041 if (minus_one_ptid
== ptid
)
1042 pid
= inferior_ptid
.pid ();
1045 if (fbsd_is_vfork_done_pending (pid
))
1049 fbsd_lwp_debug_printf ("ptid (%d, %ld, %s)", ptid
.pid (), ptid
.lwp (),
1050 pulongest (ptid
.tid ()));
1053 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1054 inferior
*inf
= find_inferior_ptid (this, ptid
);
1056 for (thread_info
*tp
: inf
->non_exited_threads ())
1060 if (tp
->ptid
.lwp () == ptid
.lwp ())
1061 request
= PT_RESUME
;
1063 request
= PT_SUSPEND
;
1065 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1066 perror_with_name (("ptrace"));
1071 /* If ptid is a wildcard, resume all matching threads (they won't run
1072 until the process is continued however). */
1073 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1074 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1075 perror_with_name (("ptrace"));
1076 ptid
= inferior_ptid
;
1079 #if __FreeBSD_version < 1200052
1080 /* When multiple threads within a process wish to report STOPPED
1081 events from wait(), the kernel picks one thread event as the
1082 thread event to report. The chosen thread event is retrieved via
1083 PT_LWPINFO by passing the process ID as the request pid. If
1084 multiple events are pending, then the subsequent wait() after
1085 resuming a process will report another STOPPED event after
1086 resuming the process to handle the next thread event and so on.
1088 A single thread event is cleared as a side effect of resuming the
1089 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1090 however, the request pid was used to select which thread's event
1091 was cleared rather than always clearing the event that was just
1092 reported. To avoid clearing the event of the wrong LWP, always
1093 pass the process ID instead of an LWP ID to PT_CONTINUE or
1096 In the case of stepping, the process ID cannot be used with
1097 PT_STEP since it would step the thread that reported an event
1098 which may not be the thread indicated by PTID. For stepping, use
1099 PT_SETSTEP to enable stepping on the desired thread before
1100 resuming the process via PT_CONTINUE instead of using
1104 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1105 perror_with_name (("ptrace"));
1108 ptid
= ptid_t (ptid
.pid ());
1110 inf_ptrace_target::resume (ptid
, step
, signo
);
1113 #ifdef USE_SIGTRAP_SIGINFO
1114 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1115 trap was a breakpoint or trace trap that should be reported to the
1116 core, return true. */
1119 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1120 const struct ptrace_lwpinfo
&pl
)
1123 /* Ignore traps without valid siginfo or for signals other than
1126 FreeBSD kernels prior to r341800 can return stale siginfo for at
1127 least some events, but those events can be identified by
1128 additional flags set in pl_flags. True breakpoint and
1129 single-step traps should not have other flags set in
1131 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1134 /* Trace traps are either a single step or a hardware watchpoint or
1136 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1138 fbsd_nat_debug_printf ("trace trap for LWP %ld", ptid
.lwp ());
1142 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1144 /* Fixup PC for the software breakpoint. */
1145 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1146 struct gdbarch
*gdbarch
= regcache
->arch ();
1147 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1149 fbsd_nat_debug_printf ("sw breakpoint trap for LWP %ld", ptid
.lwp ());
1154 pc
= regcache_read_pc (regcache
);
1155 regcache_write_pc (regcache
, pc
- decr_pc
);
1164 /* Wait for the child specified by PTID to do something. Return the
1165 process ID of the child, or MINUS_ONE_PTID in case of error; store
1166 the status in *OURSTATUS. */
1169 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1170 target_wait_flags target_options
)
1176 #ifndef PTRACE_VFORK
1177 wptid
= fbsd_next_vfork_done ();
1178 if (wptid
!= null_ptid
)
1180 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1184 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1185 if (ourstatus
->kind () == TARGET_WAITKIND_STOPPED
)
1187 struct ptrace_lwpinfo pl
;
1192 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1193 perror_with_name (("ptrace"));
1195 wptid
= ptid_t (pid
, pl
.pl_lwpid
);
1199 fbsd_nat_debug_printf ("stop for LWP %u event %d flags %#x",
1200 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1201 if (pl
.pl_flags
& PL_FLAG_SI
)
1202 fbsd_nat_debug_printf ("si_signo %u si_code %u",
1203 pl
.pl_siginfo
.si_signo
,
1204 pl
.pl_siginfo
.si_code
);
1207 #ifdef PT_LWP_EVENTS
1208 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1210 /* If GDB attaches to a multi-threaded process, exiting
1211 threads might be skipped during post_attach that
1212 have not yet reported their PL_FLAG_EXITED event.
1213 Ignore EXITED events for an unknown LWP. */
1214 thread_info
*thr
= find_thread_ptid (this, wptid
);
1217 fbsd_lwp_debug_printf ("deleting thread for LWP %u",
1219 if (print_thread_events
)
1220 printf_unfiltered (_("[%s exited]\n"),
1221 target_pid_to_str (wptid
).c_str ());
1222 delete_thread (thr
);
1224 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1225 perror_with_name (("ptrace"));
1230 /* Switch to an LWP PTID on the first stop in a new process.
1231 This is done after handling PL_FLAG_EXITED to avoid
1232 switching to an exited LWP. It is done before checking
1233 PL_FLAG_BORN in case the first stop reported after
1234 attaching to an existing process is a PL_FLAG_BORN
1236 if (in_thread_list (this, ptid_t (pid
)))
1238 fbsd_lwp_debug_printf ("using LWP %u for first thread",
1240 thread_change_ptid (this, ptid_t (pid
), wptid
);
1243 #ifdef PT_LWP_EVENTS
1244 if (pl
.pl_flags
& PL_FLAG_BORN
)
1246 /* If GDB attaches to a multi-threaded process, newborn
1247 threads might be added by fbsd_add_threads that have
1248 not yet reported their PL_FLAG_BORN event. Ignore
1249 BORN events for an already-known LWP. */
1250 if (!in_thread_list (this, wptid
))
1252 fbsd_lwp_debug_printf ("adding thread for LWP %u",
1254 add_thread (this, wptid
);
1256 ourstatus
->set_spurious ();
1262 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1264 #ifndef PTRACE_VFORK
1265 struct kinfo_proc kp
;
1267 bool is_vfork
= false;
1271 child
= pl
.pl_child_pid
;
1273 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1277 /* Make sure the other end of the fork is stopped too. */
1278 child_ptid
= fbsd_is_child_pending (child
);
1279 if (child_ptid
== null_ptid
)
1281 pid
= waitpid (child
, &status
, 0);
1283 perror_with_name (("waitpid"));
1285 gdb_assert (pid
== child
);
1287 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1288 perror_with_name (("ptrace"));
1290 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1291 child_ptid
= ptid_t (child
, pl
.pl_lwpid
);
1294 /* Enable additional events on the child process. */
1295 fbsd_enable_proc_events (child_ptid
.pid ());
1297 #ifndef PTRACE_VFORK
1298 /* For vfork, the child process will have the P_PPWAIT
1300 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1302 if (kp
.ki_flag
& P_PPWAIT
)
1306 warning (_("Failed to fetch process information"));
1310 ourstatus
->set_vforked (child_ptid
);
1312 ourstatus
->set_forked (child_ptid
);
1317 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1319 /* Remember that this child forked, but do not report it
1320 until the parent reports its corresponding fork
1322 fbsd_remember_child (wptid
);
1327 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1329 ourstatus
->set_vfork_done ();
1335 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1337 ourstatus
->set_execd
1338 (make_unique_xstrdup (pid_to_exec_file (pid
)));
1342 #ifdef USE_SIGTRAP_SIGINFO
1343 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1347 /* Note that PL_FLAG_SCE is set for any event reported while
1348 a thread is executing a system call in the kernel. In
1349 particular, signals that interrupt a sleep in a system
1350 call will report this flag as part of their event. Stops
1351 explicitly for system call entry and exit always use
1352 SIGTRAP, so only treat SIGTRAP events as system call
1353 entry/exit events. */
1354 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1355 && ourstatus
->sig () == SIGTRAP
)
1357 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1358 if (catch_syscall_enabled ())
1360 if (catching_syscall_number (pl
.pl_syscall_code
))
1362 if (pl
.pl_flags
& PL_FLAG_SCE
)
1363 ourstatus
->set_syscall_entry (pl
.pl_syscall_code
);
1365 ourstatus
->set_syscall_return (pl
.pl_syscall_code
);
1371 /* If the core isn't interested in this event, just
1372 continue the process explicitly and wait for another
1373 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1374 and once system call stops are enabled on a process
1375 it stops for all system call entries and exits. */
1376 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1377 perror_with_name (("ptrace"));
1385 #ifdef USE_SIGTRAP_SIGINFO
1386 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1389 fbsd_nat_target::stopped_by_sw_breakpoint ()
1391 struct ptrace_lwpinfo pl
;
1393 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1397 return (pl
.pl_flags
== PL_FLAG_SI
1398 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1399 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1402 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1406 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1412 #ifdef PROC_ASLR_CTL
1413 class maybe_disable_address_space_randomization
1416 explicit maybe_disable_address_space_randomization (bool disable_randomization
)
1418 if (disable_randomization
)
1420 if (procctl (P_PID
, getpid (), PROC_ASLR_STATUS
, &m_aslr_ctl
) == -1)
1422 warning (_("Failed to fetch current address space randomization "
1423 "status: %s"), safe_strerror (errno
));
1427 m_aslr_ctl
&= ~PROC_ASLR_ACTIVE
;
1428 if (m_aslr_ctl
== PROC_ASLR_FORCE_DISABLE
)
1431 int ctl
= PROC_ASLR_FORCE_DISABLE
;
1432 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &ctl
) == -1)
1434 warning (_("Error disabling address space randomization: %s"),
1435 safe_strerror (errno
));
1439 m_aslr_ctl_set
= true;
1443 ~maybe_disable_address_space_randomization ()
1447 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &m_aslr_ctl
) == -1)
1448 warning (_("Error restoring address space randomization: %s"),
1449 safe_strerror (errno
));
1453 DISABLE_COPY_AND_ASSIGN (maybe_disable_address_space_randomization
);
1456 bool m_aslr_ctl_set
= false;
1462 fbsd_nat_target::create_inferior (const char *exec_file
,
1463 const std::string
&allargs
,
1464 char **env
, int from_tty
)
1466 #ifdef PROC_ASLR_CTL
1467 maybe_disable_address_space_randomization restore_aslr_ctl
1468 (disable_randomization
);
1471 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1475 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1476 the ptid of the followed inferior. */
1479 fbsd_nat_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
1480 target_waitkind fork_kind
, bool follow_child
,
1483 inf_ptrace_target::follow_fork (child_inf
, child_ptid
, fork_kind
,
1484 follow_child
, detach_fork
);
1486 if (!follow_child
&& detach_fork
)
1488 pid_t child_pid
= child_ptid
.pid ();
1490 /* Breakpoints have already been detached from the child by
1493 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1494 perror_with_name (("ptrace"));
1496 #ifndef PTRACE_VFORK
1497 if (fork_kind () == TARGET_WAITKIND_VFORKED
)
1499 /* We can't insert breakpoints until the child process has
1500 finished with the shared memory region. The parent
1501 process doesn't wait for the child process to exit or
1502 exec until after it has been resumed from the ptrace stop
1503 to report the fork. Once it has been resumed it doesn't
1504 stop again before returning to userland, so there is no
1505 reliable way to wait on the parent.
1507 We can't stay attached to the child to wait for an exec
1508 or exit because it may invoke ptrace(PT_TRACE_ME)
1509 (e.g. if the parent process is a debugger forking a new
1512 In the end, the best we can do is to make sure it runs
1513 for a little while. Hopefully it will be out of range of
1514 any breakpoints we reinsert. Usually this is only the
1515 single-step breakpoint at vfork's return point. */
1519 /* Schedule a fake VFORK_DONE event to report on the next
1521 fbsd_add_vfork_done (inferior_ptid
);
1528 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1534 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1540 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1546 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1552 /* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
1555 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1557 fbsd_enable_proc_events (pid
.pid ());
1560 /* Implement the "post_attach" target_ops method. */
1563 fbsd_nat_target::post_attach (int pid
)
1565 fbsd_enable_proc_events (pid
);
1566 fbsd_add_threads (this, pid
);
1569 /* Traced processes always stop after exec. */
1572 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1578 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1583 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1585 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1587 gdb::array_view
<const int> syscall_counts
)
1590 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1591 will catch all system call entries and exits. The system calls
1592 are filtered by GDB rather than the kernel. */
1598 fbsd_nat_target::supports_multi_process ()
1604 fbsd_nat_target::supports_disable_randomization ()
1606 #ifdef PROC_ASLR_CTL
1613 /* See fbsd-nat.h. */
1616 fbsd_nat_target::fetch_register_set (struct regcache
*regcache
, int regnum
,
1617 int fetch_op
, const struct regset
*regset
,
1618 void *regs
, size_t size
)
1620 const struct regcache_map_entry
*map
1621 = (const struct regcache_map_entry
*) regset
->regmap
;
1622 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1624 if (regnum
== -1 || regcache_map_supplies (map
, regnum
, regcache
->arch(),
1627 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1628 perror_with_name (_("Couldn't get registers"));
1630 regcache
->supply_regset (regset
, regnum
, regs
, size
);
1634 /* See fbsd-nat.h. */
1637 fbsd_nat_target::store_register_set (struct regcache
*regcache
, int regnum
,
1638 int fetch_op
, int store_op
,
1639 const struct regset
*regset
, void *regs
,
1642 const struct regcache_map_entry
*map
1643 = (const struct regcache_map_entry
*) regset
->regmap
;
1644 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1646 if (regnum
== -1 || regcache_map_supplies (map
, regnum
, regcache
->arch(),
1649 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1650 perror_with_name (_("Couldn't get registers"));
1652 regcache
->collect_regset (regset
, regnum
, regs
, size
);
1654 if (ptrace (store_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1655 perror_with_name (_("Couldn't write registers"));
1659 void _initialize_fbsd_nat ();
1661 _initialize_fbsd_nat ()
1663 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1664 &debug_fbsd_lwp
, _("\
1665 Set debugging of FreeBSD lwp module."), _("\
1666 Show debugging of FreeBSD lwp module."), _("\
1667 Enables printf debugging output."),
1669 &show_fbsd_lwp_debug
,
1670 &setdebuglist
, &showdebuglist
);
1671 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1672 &debug_fbsd_nat
, _("\
1673 Set debugging of FreeBSD native target."), _("\
1674 Show debugging of FreeBSD native target."), _("\
1675 Enables printf debugging output."),
1677 &show_fbsd_nat_debug
,
1678 &setdebuglist
, &showdebuglist
);