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"
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
)
56 static char buf
[PATH_MAX
];
59 #ifdef KERN_PROC_PATHNAME
65 mib
[2] = KERN_PROC_PATHNAME
;
68 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
69 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
70 for processes without an associated executable such as kernel
72 return buflen
== 0 ? NULL
: buf
;
75 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
76 len
= readlink (name
, buf
, PATH_MAX
- 1);
86 #ifdef HAVE_KINFO_GETVMMAP
87 /* Iterate over all the memory regions in the current inferior,
88 calling FUNC for each memory region. OBFD is passed as the last
92 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
95 pid_t pid
= inferior_ptid
.pid ();
96 struct kinfo_vmentry
*kve
;
100 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
101 vmentl (kinfo_getvmmap (pid
, &nitems
));
103 perror_with_name (_("Couldn't fetch VM map entries."));
105 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
107 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
108 if (!(kve
->kve_protection
& KVME_PROT_READ
)
109 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
112 /* Skip segments with an invalid type. */
113 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
114 && kve
->kve_type
!= KVME_TYPE_VNODE
115 && kve
->kve_type
!= KVME_TYPE_SWAP
116 && kve
->kve_type
!= KVME_TYPE_PHYS
)
119 size
= kve
->kve_end
- kve
->kve_start
;
122 fprintf_filtered (gdb_stdout
,
123 "Save segment, %ld bytes at %s (%c%c%c)\n",
125 paddress (target_gdbarch (), kve
->kve_start
),
126 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
127 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
128 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
131 /* Invoke the callback function to create the corefile segment.
132 Pass MODIFIED as true, we do not know the real modification state. */
133 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
134 kve
->kve_protection
& KVME_PROT_WRITE
,
135 kve
->kve_protection
& KVME_PROT_EXEC
, 1, obfd
);
141 fbsd_read_mapping (FILE *mapfile
, unsigned long *start
, unsigned long *end
,
144 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
146 int resident
, privateresident
;
150 /* As of FreeBSD 5.0-RELEASE, the layout is described in
151 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
152 new column was added to the procfs map. Therefore we can't use
153 fscanf since we need to support older releases too. */
154 if (fgets (buf
, sizeof buf
, mapfile
) != NULL
)
155 ret
= sscanf (buf
, "%lx %lx %d %d %lx %s", start
, end
,
156 &resident
, &privateresident
, &obj
, protection
);
158 return (ret
!= 0 && ret
!= EOF
);
161 /* Iterate over all the memory regions in the current inferior,
162 calling FUNC for each memory region. OBFD is passed as the last
166 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
169 pid_t pid
= inferior_ptid
.pid ();
170 unsigned long start
, end
, size
;
172 int read
, write
, exec
;
174 std::string mapfilename
= string_printf ("/proc/%ld/map", (long) pid
);
175 gdb_file_up
mapfile (fopen (mapfilename
.c_str (), "r"));
177 error (_("Couldn't open %s."), mapfilename
.c_str ());
180 fprintf_filtered (gdb_stdout
,
181 "Reading memory regions from %s\n", mapfilename
.c_str ());
183 /* Now iterate until end-of-file. */
184 while (fbsd_read_mapping (mapfile
.get (), &start
, &end
, &protection
[0]))
188 read
= (strchr (protection
, 'r') != 0);
189 write
= (strchr (protection
, 'w') != 0);
190 exec
= (strchr (protection
, 'x') != 0);
194 fprintf_filtered (gdb_stdout
,
195 "Save segment, %ld bytes at %s (%c%c%c)\n",
196 size
, paddress (target_gdbarch (), start
),
202 /* Invoke the callback function to create the corefile segment.
203 Pass MODIFIED as true, we do not know the real modification state. */
204 func (start
, size
, read
, write
, exec
, 1, obfd
);
211 /* Fetch the command line for a running process. */
213 static gdb::unique_xmalloc_ptr
<char>
214 fbsd_fetch_cmdline (pid_t pid
)
222 mib
[2] = KERN_PROC_ARGS
;
224 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
230 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
231 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
237 /* Fetch the external variant of the kernel's internal process
238 structure for the process PID into KP. */
241 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
249 mib
[2] = KERN_PROC_PID
;
251 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
254 /* Implement the "info_proc" target_ops method. */
257 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
259 #ifdef HAVE_KINFO_GETFILE
260 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
263 struct kinfo_proc kp
;
265 bool do_cmdline
= false;
268 #ifdef HAVE_KINFO_GETFILE
269 bool do_files
= false;
271 #ifdef HAVE_KINFO_GETVMMAP
272 bool do_mappings
= false;
274 bool do_status
= false;
283 #ifdef HAVE_KINFO_GETVMMAP
301 #ifdef HAVE_KINFO_GETFILE
310 #ifdef HAVE_KINFO_GETFILE
313 #ifdef HAVE_KINFO_GETVMMAP
319 error (_("Not supported on this target."));
322 gdb_argv
built_argv (args
);
323 if (built_argv
.count () == 0)
325 pid
= inferior_ptid
.pid ();
327 error (_("No current process: you must name one."));
329 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
330 pid
= strtol (built_argv
[0], NULL
, 10);
332 error (_("Invalid arguments."));
334 printf_filtered (_("process %d\n"), pid
);
335 #ifdef HAVE_KINFO_GETFILE
336 if (do_cwd
|| do_exe
|| do_files
)
337 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
342 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
343 if (cmdline
!= nullptr)
344 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
346 warning (_("unable to fetch command line"));
350 const char *cwd
= NULL
;
351 #ifdef HAVE_KINFO_GETFILE
352 struct kinfo_file
*kf
= fdtbl
.get ();
353 for (int i
= 0; i
< nfd
; i
++, kf
++)
355 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
363 printf_filtered ("cwd = '%s'\n", cwd
);
365 warning (_("unable to fetch current working directory"));
369 const char *exe
= NULL
;
370 #ifdef HAVE_KINFO_GETFILE
371 struct kinfo_file
*kf
= fdtbl
.get ();
372 for (int i
= 0; i
< nfd
; i
++, kf
++)
374 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
382 exe
= pid_to_exec_file (pid
);
384 printf_filtered ("exe = '%s'\n", exe
);
386 warning (_("unable to fetch executable path name"));
388 #ifdef HAVE_KINFO_GETFILE
391 struct kinfo_file
*kf
= fdtbl
.get ();
395 fbsd_info_proc_files_header ();
396 for (int i
= 0; i
< nfd
; i
++, kf
++)
397 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
398 kf
->kf_offset
, kf
->kf_vnode_type
,
399 kf
->kf_sock_domain
, kf
->kf_sock_type
,
400 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
401 &kf
->kf_sa_peer
, kf
->kf_path
);
404 warning (_("unable to fetch list of open files"));
407 #ifdef HAVE_KINFO_GETVMMAP
411 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
412 vmentl (kinfo_getvmmap (pid
, &nvment
));
414 if (vmentl
!= nullptr)
416 printf_filtered (_("Mapped address spaces:\n\n"));
418 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
421 " Size", " Offset", "Flags ", "File");
423 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
426 " Size", " Offset", "Flags ", "File");
429 struct kinfo_vmentry
*kve
= vmentl
.get ();
430 for (int i
= 0; i
< nvment
; i
++, kve
++)
434 start
= kve
->kve_start
;
437 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
440 hex_string (end
- start
),
441 hex_string (kve
->kve_offset
),
442 fbsd_vm_map_entry_flags (kve
->kve_flags
,
443 kve
->kve_protection
),
446 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
449 hex_string (end
- start
),
450 hex_string (kve
->kve_offset
),
451 fbsd_vm_map_entry_flags (kve
->kve_flags
,
452 kve
->kve_protection
),
458 warning (_("unable to fetch virtual memory map"));
463 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
464 warning (_("Failed to fetch process information"));
470 printf_filtered ("Name: %s\n", kp
.ki_comm
);
477 state
= "R (running)";
480 state
= "T (stopped)";
483 state
= "Z (zombie)";
486 state
= "S (sleeping)";
489 state
= "W (interrupt wait)";
492 state
= "L (blocked on lock)";
495 state
= "? (unknown)";
498 printf_filtered ("State: %s\n", state
);
499 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
500 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
501 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
502 printf_filtered ("TTY: %ju\n", (uintmax_t) kp
.ki_tdev
);
503 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
504 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
505 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
506 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
507 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
508 printf_filtered ("Groups: ");
509 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
510 printf_filtered ("%d ", kp
.ki_groups
[i
]);
511 printf_filtered ("\n");
512 printf_filtered ("Minor faults (no memory page): %ld\n",
513 kp
.ki_rusage
.ru_minflt
);
514 printf_filtered ("Minor faults, children: %ld\n",
515 kp
.ki_rusage_ch
.ru_minflt
);
516 printf_filtered ("Major faults (memory page faults): %ld\n",
517 kp
.ki_rusage
.ru_majflt
);
518 printf_filtered ("Major faults, children: %ld\n",
519 kp
.ki_rusage_ch
.ru_majflt
);
520 printf_filtered ("utime: %jd.%06ld\n",
521 (intmax_t) kp
.ki_rusage
.ru_utime
.tv_sec
,
522 kp
.ki_rusage
.ru_utime
.tv_usec
);
523 printf_filtered ("stime: %jd.%06ld\n",
524 (intmax_t) kp
.ki_rusage
.ru_stime
.tv_sec
,
525 kp
.ki_rusage
.ru_stime
.tv_usec
);
526 printf_filtered ("utime, children: %jd.%06ld\n",
527 (intmax_t) kp
.ki_rusage_ch
.ru_utime
.tv_sec
,
528 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
529 printf_filtered ("stime, children: %jd.%06ld\n",
530 (intmax_t) kp
.ki_rusage_ch
.ru_stime
.tv_sec
,
531 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
532 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
533 printf_filtered ("Start time: %jd.%06ld\n", kp
.ki_start
.tv_sec
,
534 kp
.ki_start
.tv_usec
);
535 pgtok
= getpagesize () / 1024;
536 printf_filtered ("Virtual memory size: %ju kB\n",
537 (uintmax_t) kp
.ki_size
/ 1024);
538 printf_filtered ("Data size: %ju kB\n",
539 (uintmax_t) kp
.ki_dsize
* pgtok
);
540 printf_filtered ("Stack size: %ju kB\n",
541 (uintmax_t) kp
.ki_ssize
* pgtok
);
542 printf_filtered ("Text size: %ju kB\n",
543 (uintmax_t) kp
.ki_tsize
* pgtok
);
544 printf_filtered ("Resident set size: %ju kB\n",
545 (uintmax_t) kp
.ki_rssize
* pgtok
);
546 printf_filtered ("Maximum RSS: %ju kB\n",
547 (uintmax_t) kp
.ki_rusage
.ru_maxrss
);
548 printf_filtered ("Pending Signals: ");
549 for (int i
= 0; i
< _SIG_WORDS
; i
++)
550 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
551 printf_filtered ("\n");
552 printf_filtered ("Ignored Signals: ");
553 for (int i
= 0; i
< _SIG_WORDS
; i
++)
554 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
555 printf_filtered ("\n");
556 printf_filtered ("Caught Signals: ");
557 for (int i
= 0; i
< _SIG_WORDS
; i
++)
558 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
559 printf_filtered ("\n");
566 #ifdef KERN_PROC_AUXV
569 /* Return the size of siginfo for the current inferior. */
577 /* This structure matches the naming and layout of `siginfo_t' in
578 <sys/signal.h>. In particular, the `si_foo' macros defined in that
579 header can be used with both types to copy fields in the `_reason'
591 union sigval32 si_value
;
624 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
626 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
627 if (gdbarch_long_bit (gdbarch
) == 32)
628 return sizeof (struct siginfo32
);
630 return sizeof (siginfo_t
);
633 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
634 that FreeBSD doesn't support writing to $_siginfo, so this only
635 needs to convert one way. */
638 fbsd_convert_siginfo (siginfo_t
*si
)
641 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
643 /* Is the inferior 32-bit? If not, nothing to do. */
644 if (gdbarch_long_bit (gdbarch
) != 32)
647 struct siginfo32 si32
;
649 si32
.si_signo
= si
->si_signo
;
650 si32
.si_errno
= si
->si_errno
;
651 si32
.si_code
= si
->si_code
;
652 si32
.si_pid
= si
->si_pid
;
653 si32
.si_uid
= si
->si_uid
;
654 si32
.si_status
= si
->si_status
;
655 si32
.si_addr
= (uintptr_t) si
->si_addr
;
657 /* If sival_ptr is being used instead of sival_int on a big-endian
658 platform, then sival_int will be zero since it holds the upper
659 32-bits of the pointer value. */
660 #if _BYTE_ORDER == _BIG_ENDIAN
661 if (si
->si_value
.sival_int
== 0)
662 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
664 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
666 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
669 /* Always copy the spare fields and then possibly overwrite them for
670 signal-specific or code-specific fields. */
671 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
672 for (int i
= 0; i
< 7; i
++)
673 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
674 switch (si
->si_signo
) {
679 si32
.si_trapno
= si
->si_trapno
;
682 switch (si
->si_code
) {
684 si32
.si_timerid
= si
->si_timerid
;
685 si32
.si_overrun
= si
->si_overrun
;
688 si32
.si_mqd
= si
->si_mqd
;
692 memcpy(si
, &si32
, sizeof (si32
));
697 /* Implement the "xfer_partial" target_ops method. */
699 enum target_xfer_status
700 fbsd_nat_target::xfer_partial (enum target_object object
,
701 const char *annex
, gdb_byte
*readbuf
,
702 const gdb_byte
*writebuf
,
703 ULONGEST offset
, ULONGEST len
,
704 ULONGEST
*xfered_len
)
706 pid_t pid
= inferior_ptid
.pid ();
711 case TARGET_OBJECT_SIGNAL_INFO
:
713 struct ptrace_lwpinfo pl
;
716 /* FreeBSD doesn't support writing to $_siginfo. */
717 if (writebuf
!= NULL
)
718 return TARGET_XFER_E_IO
;
720 if (inferior_ptid
.lwp_p ())
721 pid
= inferior_ptid
.lwp ();
723 siginfo_size
= fbsd_siginfo_size ();
724 if (offset
> siginfo_size
)
725 return TARGET_XFER_E_IO
;
727 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
728 return TARGET_XFER_E_IO
;
730 if (!(pl
.pl_flags
& PL_FLAG_SI
))
731 return TARGET_XFER_E_IO
;
733 fbsd_convert_siginfo (&pl
.pl_siginfo
);
734 if (offset
+ len
> siginfo_size
)
735 len
= siginfo_size
- offset
;
737 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
739 return TARGET_XFER_OK
;
742 case TARGET_OBJECT_AUXV
:
744 gdb::byte_vector buf_storage
;
749 if (writebuf
!= NULL
)
750 return TARGET_XFER_E_IO
;
753 mib
[2] = KERN_PROC_AUXV
;
762 buflen
= offset
+ len
;
763 buf_storage
.resize (buflen
);
764 buf
= buf_storage
.data ();
766 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
773 memcpy (readbuf
, buf
+ offset
, buflen
);
778 *xfered_len
= buflen
;
779 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
781 return TARGET_XFER_E_IO
;
783 case TARGET_OBJECT_FREEBSD_VMMAP
:
784 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
786 gdb::byte_vector buf_storage
;
792 uint32_t struct_size
;
795 case TARGET_OBJECT_FREEBSD_VMMAP
:
796 proc_target
= KERN_PROC_VMMAP
;
797 struct_size
= sizeof (struct kinfo_vmentry
);
799 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
800 proc_target
= KERN_PROC_PS_STRINGS
;
801 struct_size
= sizeof (void *);
805 if (writebuf
!= NULL
)
806 return TARGET_XFER_E_IO
;
810 mib
[2] = proc_target
;
813 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
814 return TARGET_XFER_E_IO
;
815 buflen
+= sizeof (struct_size
);
817 if (offset
>= buflen
)
820 return TARGET_XFER_EOF
;
823 buf_storage
.resize (buflen
);
824 buf
= buf_storage
.data ();
826 memcpy (buf
, &struct_size
, sizeof (struct_size
));
827 buflen
-= sizeof (struct_size
);
828 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
829 return TARGET_XFER_E_IO
;
830 buflen
+= sizeof (struct_size
);
832 if (buflen
- offset
< len
)
833 len
= buflen
- offset
;
834 memcpy (readbuf
, buf
+ offset
, len
);
836 return TARGET_XFER_OK
;
839 return inf_ptrace_target::xfer_partial (object
, annex
,
840 readbuf
, writebuf
, offset
,
847 static int debug_fbsd_lwp
;
848 static int debug_fbsd_nat
;
851 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
852 struct cmd_list_element
*c
, const char *value
)
854 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
858 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
859 struct cmd_list_element
*c
, const char *value
)
861 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
866 FreeBSD's first thread support was via a "reentrant" version of libc
867 (libc_r) that first shipped in 2.2.7. This library multiplexed all
868 of the threads in a process onto a single kernel thread. This
869 library was supported via the bsd-uthread target.
871 FreeBSD 5.1 introduced two new threading libraries that made use of
872 multiple kernel threads. The first (libkse) scheduled M user
873 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
874 bound each user thread to a dedicated kernel thread. libkse shipped
875 as the default threading library (libpthread).
877 FreeBSD 5.3 added a libthread_db to abstract the interface across
878 the various thread libraries (libc_r, libkse, and libthr).
880 FreeBSD 7.0 switched the default threading library from from libkse
881 to libpthread and removed libc_r.
883 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
884 only threading library supported by 8.0 and later is libthr which
885 ties each user thread directly to an LWP. To simplify the
886 implementation, this target only supports LWP-backed threads using
887 ptrace directly rather than libthread_db.
889 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
892 /* Return true if PTID is still active in the inferior. */
895 fbsd_nat_target::thread_alive (ptid_t ptid
)
899 struct ptrace_lwpinfo pl
;
901 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
904 #ifdef PL_FLAG_EXITED
905 if (pl
.pl_flags
& PL_FLAG_EXITED
)
913 /* Convert PTID to a string. Returns the string in a static
917 fbsd_nat_target::pid_to_str (ptid_t ptid
)
925 int pid
= ptid
.pid ();
927 xsnprintf (buf
, sizeof buf
, "LWP %d of process %d", lwp
, pid
);
931 return normal_pid_to_str (ptid
);
934 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
935 /* Return the name assigned to a thread by an application. Returns
936 the string in a static buffer. */
939 fbsd_nat_target::thread_name (struct thread_info
*thr
)
941 struct ptrace_lwpinfo pl
;
942 struct kinfo_proc kp
;
943 int pid
= thr
->ptid
.pid ();
944 long lwp
= thr
->ptid
.lwp ();
945 static char buf
[sizeof pl
.pl_tdname
+ 1];
947 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
948 if a name has not been set explicitly. Return a NULL name in
950 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
951 perror_with_name (_("Failed to fetch process information"));
952 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
953 perror_with_name (("ptrace"));
954 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
956 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
961 /* Enable additional event reporting on new processes.
963 To catch fork events, PTRACE_FORK is set on every traced process
964 to enable stops on returns from fork or vfork. Note that both the
965 parent and child will always stop, even if system call stops are
968 To catch LWP events, PTRACE_EVENTS is set on every traced process.
969 This enables stops on the birth for new LWPs (excluding the "main" LWP)
970 and the death of LWPs (excluding the last LWP in a process). Note
971 that unlike fork events, the LWP that creates a new LWP does not
975 fbsd_enable_proc_events (pid_t pid
)
977 #ifdef PT_GET_EVENT_MASK
980 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
981 sizeof (events
)) == -1)
982 perror_with_name (("ptrace"));
983 events
|= PTRACE_FORK
| PTRACE_LWP
;
985 events
|= PTRACE_VFORK
;
987 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
988 sizeof (events
)) == -1)
989 perror_with_name (("ptrace"));
992 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
993 perror_with_name (("ptrace"));
996 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
997 perror_with_name (("ptrace"));
1002 /* Add threads for any new LWPs in a process.
1004 When LWP events are used, this function is only used to detect existing
1005 threads when attaching to a process. On older systems, this function is
1006 called to discover new threads each time the thread list is updated. */
1009 fbsd_add_threads (pid_t pid
)
1013 gdb_assert (!in_thread_list (ptid_t (pid
)));
1014 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
1016 perror_with_name (("ptrace"));
1018 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
1020 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
1022 perror_with_name (("ptrace"));
1024 for (i
= 0; i
< nlwps
; i
++)
1026 ptid_t ptid
= ptid_t (pid
, lwps
[i
], 0);
1028 if (!in_thread_list (ptid
))
1030 #ifdef PT_LWP_EVENTS
1031 struct ptrace_lwpinfo pl
;
1033 /* Don't add exited threads. Note that this is only called
1034 when attaching to a multi-threaded process. */
1035 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
1036 perror_with_name (("ptrace"));
1037 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1041 fprintf_unfiltered (gdb_stdlog
,
1042 "FLWP: adding thread for LWP %u\n",
1049 /* Implement the "update_thread_list" target_ops method. */
1052 fbsd_nat_target::update_thread_list ()
1054 #ifdef PT_LWP_EVENTS
1055 /* With support for thread events, threads are added/deleted from the
1056 list as events are reported, so just try deleting exited threads. */
1057 delete_exited_threads ();
1061 fbsd_add_threads (inferior_ptid
.pid ());
1067 To catch fork events, PT_FOLLOW_FORK is set on every traced process
1068 to enable stops on returns from fork or vfork. Note that both the
1069 parent and child will always stop, even if system call stops are not
1072 After a fork, both the child and parent process will stop and report
1073 an event. However, there is no guarantee of order. If the parent
1074 reports its stop first, then fbsd_wait explicitly waits for the new
1075 child before returning. If the child reports its stop first, then
1076 the event is saved on a list and ignored until the parent's stop is
1077 reported. fbsd_wait could have been changed to fetch the parent PID
1078 of the new child and used that to wait for the parent explicitly.
1079 However, if two threads in the parent fork at the same time, then
1080 the wait on the parent might return the "wrong" fork event.
1082 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
1083 the new child process. This flag could be inferred by treating any
1084 events for an unknown pid as a new child.
1086 In addition, the initial version of PT_FOLLOW_FORK did not report a
1087 stop event for the parent process of a vfork until after the child
1088 process executed a new program or exited. The kernel was changed to
1089 defer the wait for exit or exec of the child until after posting the
1090 stop event shortly after the change to introduce PL_FLAG_CHILD.
1091 This could be worked around by reporting a vfork event when the
1092 child event posted and ignoring the subsequent event from the
1095 This implementation requires both of these fixes for simplicity's
1096 sake. FreeBSD versions newer than 9.1 contain both fixes.
1099 static std::list
<ptid_t
> fbsd_pending_children
;
1101 /* Record a new child process event that is reported before the
1102 corresponding fork event in the parent. */
1105 fbsd_remember_child (ptid_t pid
)
1107 fbsd_pending_children
.push_front (pid
);
1110 /* Check for a previously-recorded new child process event for PID.
1111 If one is found, remove it from the list and return the PTID. */
1114 fbsd_is_child_pending (pid_t pid
)
1116 for (auto it
= fbsd_pending_children
.begin ();
1117 it
!= fbsd_pending_children
.end (); it
++)
1118 if (it
->pid () == pid
)
1121 fbsd_pending_children
.erase (it
);
1127 #ifndef PTRACE_VFORK
1128 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
1130 /* Record a pending vfork done event. */
1133 fbsd_add_vfork_done (ptid_t pid
)
1135 fbsd_pending_vfork_done
.push_front (pid
);
1138 /* Check for a pending vfork done event for a specific PID. */
1141 fbsd_is_vfork_done_pending (pid_t pid
)
1143 for (auto it
= fbsd_pending_vfork_done
.begin ();
1144 it
!= fbsd_pending_vfork_done
.end (); it
++)
1145 if (it
->pid () == pid
)
1150 /* Check for a pending vfork done event. If one is found, remove it
1151 from the list and return the PTID. */
1154 fbsd_next_vfork_done (void)
1156 if (!fbsd_pending_vfork_done
.empty ())
1158 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1159 fbsd_pending_vfork_done
.pop_front ();
1167 /* Implement the "resume" target_ops method. */
1170 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1172 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1175 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1176 if (minus_one_ptid
== ptid
)
1177 pid
= inferior_ptid
.pid ();
1180 if (fbsd_is_vfork_done_pending (pid
))
1185 fprintf_unfiltered (gdb_stdlog
,
1186 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
1187 ptid
.pid (), ptid
.lwp (),
1191 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1192 struct thread_info
*tp
;
1195 ALL_NON_EXITED_THREADS (tp
)
1197 if (tp
->ptid
.pid () != ptid
.pid ())
1200 if (tp
->ptid
.lwp () == ptid
.lwp ())
1201 request
= PT_RESUME
;
1203 request
= PT_SUSPEND
;
1205 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1206 perror_with_name (("ptrace"));
1211 /* If ptid is a wildcard, resume all matching threads (they won't run
1212 until the process is continued however). */
1213 struct thread_info
*tp
;
1215 ALL_NON_EXITED_THREADS (tp
)
1217 if (!tp
->ptid
.matches (ptid
))
1220 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1221 perror_with_name (("ptrace"));
1223 ptid
= inferior_ptid
;
1226 #if __FreeBSD_version < 1200052
1227 /* When multiple threads within a process wish to report STOPPED
1228 events from wait(), the kernel picks one thread event as the
1229 thread event to report. The chosen thread event is retrieved via
1230 PT_LWPINFO by passing the process ID as the request pid. If
1231 multiple events are pending, then the subsequent wait() after
1232 resuming a process will report another STOPPED event after
1233 resuming the process to handle the next thread event and so on.
1235 A single thread event is cleared as a side effect of resuming the
1236 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1237 however, the request pid was used to select which thread's event
1238 was cleared rather than always clearing the event that was just
1239 reported. To avoid clearing the event of the wrong LWP, always
1240 pass the process ID instead of an LWP ID to PT_CONTINUE or
1243 In the case of stepping, the process ID cannot be used with
1244 PT_STEP since it would step the thread that reported an event
1245 which may not be the thread indicated by PTID. For stepping, use
1246 PT_SETSTEP to enable stepping on the desired thread before
1247 resuming the process via PT_CONTINUE instead of using
1251 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1252 perror_with_name (("ptrace"));
1255 ptid
= ptid_t (ptid
.pid ());
1257 inf_ptrace_target::resume (ptid
, step
, signo
);
1260 #ifdef USE_SIGTRAP_SIGINFO
1261 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1262 trap was a breakpoint or trace trap that should be reported to the
1263 core, return true. */
1266 fbsd_handle_debug_trap (ptid_t ptid
, const struct ptrace_lwpinfo
&pl
)
1269 /* Ignore traps without valid siginfo or for signals other than
1271 if (! (pl
.pl_flags
& PL_FLAG_SI
) || pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1274 /* Trace traps are either a single step or a hardware watchpoint or
1276 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1279 fprintf_unfiltered (gdb_stdlog
,
1280 "FNAT: trace trap for LWP %ld\n", ptid
.lwp ());
1284 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1286 /* Fixup PC for the software breakpoint. */
1287 struct regcache
*regcache
= get_thread_regcache (ptid
);
1288 struct gdbarch
*gdbarch
= regcache
->arch ();
1289 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1292 fprintf_unfiltered (gdb_stdlog
,
1293 "FNAT: sw breakpoint trap for LWP %ld\n",
1299 pc
= regcache_read_pc (regcache
);
1300 regcache_write_pc (regcache
, pc
- decr_pc
);
1309 /* Wait for the child specified by PTID to do something. Return the
1310 process ID of the child, or MINUS_ONE_PTID in case of error; store
1311 the status in *OURSTATUS. */
1314 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1321 #ifndef PTRACE_VFORK
1322 wptid
= fbsd_next_vfork_done ();
1323 if (wptid
!= null_ptid
)
1325 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1329 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1330 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1332 struct ptrace_lwpinfo pl
;
1337 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1338 perror_with_name (("ptrace"));
1340 wptid
= ptid_t (pid
, pl
.pl_lwpid
, 0);
1344 fprintf_unfiltered (gdb_stdlog
,
1345 "FNAT: stop for LWP %u event %d flags %#x\n",
1346 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1347 if (pl
.pl_flags
& PL_FLAG_SI
)
1348 fprintf_unfiltered (gdb_stdlog
,
1349 "FNAT: si_signo %u si_code %u\n",
1350 pl
.pl_siginfo
.si_signo
,
1351 pl
.pl_siginfo
.si_code
);
1354 #ifdef PT_LWP_EVENTS
1355 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1357 /* If GDB attaches to a multi-threaded process, exiting
1358 threads might be skipped during post_attach that
1359 have not yet reported their PL_FLAG_EXITED event.
1360 Ignore EXITED events for an unknown LWP. */
1361 thread_info
*thr
= find_thread_ptid (wptid
);
1365 fprintf_unfiltered (gdb_stdlog
,
1366 "FLWP: deleting thread for LWP %u\n",
1368 if (print_thread_events
)
1369 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
1371 delete_thread (thr
);
1373 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1374 perror_with_name (("ptrace"));
1379 /* Switch to an LWP PTID on the first stop in a new process.
1380 This is done after handling PL_FLAG_EXITED to avoid
1381 switching to an exited LWP. It is done before checking
1382 PL_FLAG_BORN in case the first stop reported after
1383 attaching to an existing process is a PL_FLAG_BORN
1385 if (in_thread_list (ptid_t (pid
)))
1388 fprintf_unfiltered (gdb_stdlog
,
1389 "FLWP: using LWP %u for first thread\n",
1391 thread_change_ptid (ptid_t (pid
), wptid
);
1394 #ifdef PT_LWP_EVENTS
1395 if (pl
.pl_flags
& PL_FLAG_BORN
)
1397 /* If GDB attaches to a multi-threaded process, newborn
1398 threads might be added by fbsd_add_threads that have
1399 not yet reported their PL_FLAG_BORN event. Ignore
1400 BORN events for an already-known LWP. */
1401 if (!in_thread_list (wptid
))
1404 fprintf_unfiltered (gdb_stdlog
,
1405 "FLWP: adding thread for LWP %u\n",
1409 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1415 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1417 #ifndef PTRACE_VFORK
1418 struct kinfo_proc kp
;
1423 child
= pl
.pl_child_pid
;
1424 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1426 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1427 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1430 /* Make sure the other end of the fork is stopped too. */
1431 child_ptid
= fbsd_is_child_pending (child
);
1432 if (child_ptid
== null_ptid
)
1434 pid
= waitpid (child
, &status
, 0);
1436 perror_with_name (("waitpid"));
1438 gdb_assert (pid
== child
);
1440 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1441 perror_with_name (("ptrace"));
1443 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1444 child_ptid
= ptid_t (child
, pl
.pl_lwpid
, 0);
1447 /* Enable additional events on the child process. */
1448 fbsd_enable_proc_events (child_ptid
.pid ());
1450 #ifndef PTRACE_VFORK
1451 /* For vfork, the child process will have the P_PPWAIT
1453 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1455 if (kp
.ki_flag
& P_PPWAIT
)
1456 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1459 warning (_("Failed to fetch process information"));
1461 ourstatus
->value
.related_pid
= child_ptid
;
1466 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1468 /* Remember that this child forked, but do not report it
1469 until the parent reports its corresponding fork
1471 fbsd_remember_child (wptid
);
1476 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1478 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1485 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1487 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1488 ourstatus
->value
.execd_pathname
1489 = xstrdup (pid_to_exec_file (pid
));
1494 #ifdef USE_SIGTRAP_SIGINFO
1495 if (fbsd_handle_debug_trap (wptid
, pl
))
1499 /* Note that PL_FLAG_SCE is set for any event reported while
1500 a thread is executing a system call in the kernel. In
1501 particular, signals that interrupt a sleep in a system
1502 call will report this flag as part of their event. Stops
1503 explicitly for system call entry and exit always use
1504 SIGTRAP, so only treat SIGTRAP events as system call
1505 entry/exit events. */
1506 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1507 && ourstatus
->value
.sig
== SIGTRAP
)
1509 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1510 if (catch_syscall_enabled ())
1512 if (catching_syscall_number (pl
.pl_syscall_code
))
1514 if (pl
.pl_flags
& PL_FLAG_SCE
)
1515 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1517 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1518 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1523 /* If the core isn't interested in this event, just
1524 continue the process explicitly and wait for another
1525 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1526 and once system call stops are enabled on a process
1527 it stops for all system call entries and exits. */
1528 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1529 perror_with_name (("ptrace"));
1537 #ifdef USE_SIGTRAP_SIGINFO
1538 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1541 fbsd_nat_target::stopped_by_sw_breakpoint ()
1543 struct ptrace_lwpinfo pl
;
1545 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1549 return ((pl
.pl_flags
& PL_FLAG_SI
)
1550 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1551 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1554 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1558 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1565 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1566 the ptid of the followed inferior. */
1569 fbsd_nat_target::follow_fork (int follow_child
, int detach_fork
)
1571 if (!follow_child
&& detach_fork
)
1573 struct thread_info
*tp
= inferior_thread ();
1574 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
1576 /* Breakpoints have already been detached from the child by
1579 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1580 perror_with_name (("ptrace"));
1582 #ifndef PTRACE_VFORK
1583 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1585 /* We can't insert breakpoints until the child process has
1586 finished with the shared memory region. The parent
1587 process doesn't wait for the child process to exit or
1588 exec until after it has been resumed from the ptrace stop
1589 to report the fork. Once it has been resumed it doesn't
1590 stop again before returning to userland, so there is no
1591 reliable way to wait on the parent.
1593 We can't stay attached to the child to wait for an exec
1594 or exit because it may invoke ptrace(PT_TRACE_ME)
1595 (e.g. if the parent process is a debugger forking a new
1598 In the end, the best we can do is to make sure it runs
1599 for a little while. Hopefully it will be out of range of
1600 any breakpoints we reinsert. Usually this is only the
1601 single-step breakpoint at vfork's return point. */
1605 /* Schedule a fake VFORK_DONE event to report on the next
1607 fbsd_add_vfork_done (inferior_ptid
);
1616 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1622 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1628 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1634 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1640 /* Implement the "post_startup_inferior" target_ops method. */
1643 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1645 fbsd_enable_proc_events (pid
.pid ());
1648 /* Implement the "post_attach" target_ops method. */
1651 fbsd_nat_target::post_attach (int pid
)
1653 fbsd_enable_proc_events (pid
);
1654 fbsd_add_threads (pid
);
1658 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1659 will always stop after exec. */
1662 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1668 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1674 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1676 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1678 gdb::array_view
<const int> syscall_counts
)
1681 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1682 will catch all system call entries and exits. The system calls
1683 are filtered by GDB rather than the kernel. */
1690 _initialize_fbsd_nat (void)
1693 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1694 &debug_fbsd_lwp
, _("\
1695 Set debugging of FreeBSD lwp module."), _("\
1696 Show debugging of FreeBSD lwp module."), _("\
1697 Enables printf debugging output."),
1699 &show_fbsd_lwp_debug
,
1700 &setdebuglist
, &showdebuglist
);
1701 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1702 &debug_fbsd_nat
, _("\
1703 Set debugging of FreeBSD native target."), _("\
1704 Show debugging of FreeBSD native target."), _("\
1705 Enables printf debugging output."),
1707 &show_fbsd_nat_debug
,
1708 &setdebuglist
, &showdebuglist
);