1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2020 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/gdb_wait.h"
30 #include "inf-ptrace.h"
31 #include <sys/types.h>
32 #include <sys/procfs.h>
33 #include <sys/ptrace.h>
34 #include <sys/signal.h>
35 #include <sys/sysctl.h>
41 #include "fbsd-tdep.h"
45 /* Return the name of a file that can be opened to get the symbols for
46 the child process identified by PID. */
49 fbsd_nat_target::pid_to_exec_file (int pid
)
51 static char buf
[PATH_MAX
];
57 mib
[2] = KERN_PROC_PATHNAME
;
60 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
61 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
62 for processes without an associated executable such as kernel
64 return buflen
== 0 ? NULL
: buf
;
69 /* Iterate over all the memory regions in the current inferior,
70 calling FUNC for each memory region. DATA is passed as the last
74 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
77 pid_t pid
= inferior_ptid
.pid ();
78 struct kinfo_vmentry
*kve
;
82 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
83 vmentl (kinfo_getvmmap (pid
, &nitems
));
85 perror_with_name (_("Couldn't fetch VM map entries."));
87 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
89 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
90 if (!(kve
->kve_protection
& KVME_PROT_READ
)
91 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
94 /* Skip segments with an invalid type. */
95 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
96 && kve
->kve_type
!= KVME_TYPE_VNODE
97 && kve
->kve_type
!= KVME_TYPE_SWAP
98 && kve
->kve_type
!= KVME_TYPE_PHYS
)
101 size
= kve
->kve_end
- kve
->kve_start
;
104 fprintf_filtered (gdb_stdout
,
105 "Save segment, %ld bytes at %s (%c%c%c)\n",
107 paddress (target_gdbarch (), kve
->kve_start
),
108 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
109 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
110 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
113 /* Invoke the callback function to create the corefile segment.
114 Pass MODIFIED as true, we do not know the real modification state. */
115 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
116 kve
->kve_protection
& KVME_PROT_WRITE
,
117 kve
->kve_protection
& KVME_PROT_EXEC
, 1, data
);
122 /* Fetch the command line for a running process. */
124 static gdb::unique_xmalloc_ptr
<char>
125 fbsd_fetch_cmdline (pid_t pid
)
133 mib
[2] = KERN_PROC_ARGS
;
135 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
141 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
142 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
145 /* Join the arguments with spaces to form a single string. */
146 char *cp
= cmdline
.get ();
147 for (size_t i
= 0; i
< len
- 1; i
++)
155 /* Fetch the external variant of the kernel's internal process
156 structure for the process PID into KP. */
159 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
167 mib
[2] = KERN_PROC_PID
;
169 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
172 /* Implement the "info_proc" target_ops method. */
175 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
177 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
179 struct kinfo_proc kp
;
181 bool do_cmdline
= false;
184 bool do_files
= false;
185 bool do_mappings
= false;
186 bool do_status
= false;
223 error (_("Not supported on this target."));
226 gdb_argv
built_argv (args
);
227 if (built_argv
.count () == 0)
229 pid
= inferior_ptid
.pid ();
231 error (_("No current process: you must name one."));
233 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
234 pid
= strtol (built_argv
[0], NULL
, 10);
236 error (_("Invalid arguments."));
238 printf_filtered (_("process %d\n"), pid
);
239 if (do_cwd
|| do_exe
|| do_files
)
240 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
244 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
245 if (cmdline
!= nullptr)
246 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
248 warning (_("unable to fetch command line"));
252 const char *cwd
= NULL
;
253 struct kinfo_file
*kf
= fdtbl
.get ();
254 for (int i
= 0; i
< nfd
; i
++, kf
++)
256 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
263 printf_filtered ("cwd = '%s'\n", cwd
);
265 warning (_("unable to fetch current working directory"));
269 const char *exe
= NULL
;
270 struct kinfo_file
*kf
= fdtbl
.get ();
271 for (int i
= 0; i
< nfd
; i
++, kf
++)
273 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
280 exe
= pid_to_exec_file (pid
);
282 printf_filtered ("exe = '%s'\n", exe
);
284 warning (_("unable to fetch executable path name"));
288 struct kinfo_file
*kf
= fdtbl
.get ();
292 fbsd_info_proc_files_header ();
293 for (int i
= 0; i
< nfd
; i
++, kf
++)
294 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
295 kf
->kf_offset
, kf
->kf_vnode_type
,
296 kf
->kf_sock_domain
, kf
->kf_sock_type
,
297 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
298 &kf
->kf_sa_peer
, kf
->kf_path
);
301 warning (_("unable to fetch list of open files"));
306 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
307 vmentl (kinfo_getvmmap (pid
, &nvment
));
309 if (vmentl
!= nullptr)
311 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
312 fbsd_info_proc_mappings_header (addr_bit
);
314 struct kinfo_vmentry
*kve
= vmentl
.get ();
315 for (int i
= 0; i
< nvment
; i
++, kve
++)
316 fbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
317 kve
->kve_end
, kve
->kve_offset
,
318 kve
->kve_flags
, kve
->kve_protection
,
322 warning (_("unable to fetch virtual memory map"));
326 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
327 warning (_("Failed to fetch process information"));
333 printf_filtered ("Name: %s\n", kp
.ki_comm
);
340 state
= "R (running)";
343 state
= "T (stopped)";
346 state
= "Z (zombie)";
349 state
= "S (sleeping)";
352 state
= "W (interrupt wait)";
355 state
= "L (blocked on lock)";
358 state
= "? (unknown)";
361 printf_filtered ("State: %s\n", state
);
362 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
363 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
364 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
365 printf_filtered ("TTY: %ju\n", (uintmax_t) kp
.ki_tdev
);
366 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
367 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
368 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
369 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
370 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
371 printf_filtered ("Groups: ");
372 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
373 printf_filtered ("%d ", kp
.ki_groups
[i
]);
374 printf_filtered ("\n");
375 printf_filtered ("Minor faults (no memory page): %ld\n",
376 kp
.ki_rusage
.ru_minflt
);
377 printf_filtered ("Minor faults, children: %ld\n",
378 kp
.ki_rusage_ch
.ru_minflt
);
379 printf_filtered ("Major faults (memory page faults): %ld\n",
380 kp
.ki_rusage
.ru_majflt
);
381 printf_filtered ("Major faults, children: %ld\n",
382 kp
.ki_rusage_ch
.ru_majflt
);
383 printf_filtered ("utime: %jd.%06ld\n",
384 (intmax_t) kp
.ki_rusage
.ru_utime
.tv_sec
,
385 kp
.ki_rusage
.ru_utime
.tv_usec
);
386 printf_filtered ("stime: %jd.%06ld\n",
387 (intmax_t) kp
.ki_rusage
.ru_stime
.tv_sec
,
388 kp
.ki_rusage
.ru_stime
.tv_usec
);
389 printf_filtered ("utime, children: %jd.%06ld\n",
390 (intmax_t) kp
.ki_rusage_ch
.ru_utime
.tv_sec
,
391 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
392 printf_filtered ("stime, children: %jd.%06ld\n",
393 (intmax_t) kp
.ki_rusage_ch
.ru_stime
.tv_sec
,
394 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
395 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
396 printf_filtered ("Start time: %jd.%06ld\n", kp
.ki_start
.tv_sec
,
397 kp
.ki_start
.tv_usec
);
398 pgtok
= getpagesize () / 1024;
399 printf_filtered ("Virtual memory size: %ju kB\n",
400 (uintmax_t) kp
.ki_size
/ 1024);
401 printf_filtered ("Data size: %ju kB\n",
402 (uintmax_t) kp
.ki_dsize
* pgtok
);
403 printf_filtered ("Stack size: %ju kB\n",
404 (uintmax_t) kp
.ki_ssize
* pgtok
);
405 printf_filtered ("Text size: %ju kB\n",
406 (uintmax_t) kp
.ki_tsize
* pgtok
);
407 printf_filtered ("Resident set size: %ju kB\n",
408 (uintmax_t) kp
.ki_rssize
* pgtok
);
409 printf_filtered ("Maximum RSS: %ju kB\n",
410 (uintmax_t) kp
.ki_rusage
.ru_maxrss
);
411 printf_filtered ("Pending Signals: ");
412 for (int i
= 0; i
< _SIG_WORDS
; i
++)
413 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
414 printf_filtered ("\n");
415 printf_filtered ("Ignored Signals: ");
416 for (int i
= 0; i
< _SIG_WORDS
; i
++)
417 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
418 printf_filtered ("\n");
419 printf_filtered ("Caught Signals: ");
420 for (int i
= 0; i
< _SIG_WORDS
; i
++)
421 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
422 printf_filtered ("\n");
429 /* Return the size of siginfo for the current inferior. */
437 /* This structure matches the naming and layout of `siginfo_t' in
438 <sys/signal.h>. In particular, the `si_foo' macros defined in that
439 header can be used with both types to copy fields in the `_reason'
451 union sigval32 si_value
;
484 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
486 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
487 if (gdbarch_long_bit (gdbarch
) == 32)
488 return sizeof (struct siginfo32
);
490 return sizeof (siginfo_t
);
493 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
494 that FreeBSD doesn't support writing to $_siginfo, so this only
495 needs to convert one way. */
498 fbsd_convert_siginfo (siginfo_t
*si
)
501 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
503 /* Is the inferior 32-bit? If not, nothing to do. */
504 if (gdbarch_long_bit (gdbarch
) != 32)
507 struct siginfo32 si32
;
509 si32
.si_signo
= si
->si_signo
;
510 si32
.si_errno
= si
->si_errno
;
511 si32
.si_code
= si
->si_code
;
512 si32
.si_pid
= si
->si_pid
;
513 si32
.si_uid
= si
->si_uid
;
514 si32
.si_status
= si
->si_status
;
515 si32
.si_addr
= (uintptr_t) si
->si_addr
;
517 /* If sival_ptr is being used instead of sival_int on a big-endian
518 platform, then sival_int will be zero since it holds the upper
519 32-bits of the pointer value. */
520 #if _BYTE_ORDER == _BIG_ENDIAN
521 if (si
->si_value
.sival_int
== 0)
522 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
524 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
526 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
529 /* Always copy the spare fields and then possibly overwrite them for
530 signal-specific or code-specific fields. */
531 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
532 for (int i
= 0; i
< 7; i
++)
533 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
534 switch (si
->si_signo
) {
539 si32
.si_trapno
= si
->si_trapno
;
542 switch (si
->si_code
) {
544 si32
.si_timerid
= si
->si_timerid
;
545 si32
.si_overrun
= si
->si_overrun
;
548 si32
.si_mqd
= si
->si_mqd
;
552 memcpy(si
, &si32
, sizeof (si32
));
556 /* Implement the "xfer_partial" target_ops method. */
558 enum target_xfer_status
559 fbsd_nat_target::xfer_partial (enum target_object object
,
560 const char *annex
, gdb_byte
*readbuf
,
561 const gdb_byte
*writebuf
,
562 ULONGEST offset
, ULONGEST len
,
563 ULONGEST
*xfered_len
)
565 pid_t pid
= inferior_ptid
.pid ();
569 case TARGET_OBJECT_SIGNAL_INFO
:
571 struct ptrace_lwpinfo pl
;
574 /* FreeBSD doesn't support writing to $_siginfo. */
575 if (writebuf
!= NULL
)
576 return TARGET_XFER_E_IO
;
578 if (inferior_ptid
.lwp_p ())
579 pid
= inferior_ptid
.lwp ();
581 siginfo_size
= fbsd_siginfo_size ();
582 if (offset
> siginfo_size
)
583 return TARGET_XFER_E_IO
;
585 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
586 return TARGET_XFER_E_IO
;
588 if (!(pl
.pl_flags
& PL_FLAG_SI
))
589 return TARGET_XFER_E_IO
;
591 fbsd_convert_siginfo (&pl
.pl_siginfo
);
592 if (offset
+ len
> siginfo_size
)
593 len
= siginfo_size
- offset
;
595 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
597 return TARGET_XFER_OK
;
599 #ifdef KERN_PROC_AUXV
600 case TARGET_OBJECT_AUXV
:
602 gdb::byte_vector buf_storage
;
607 if (writebuf
!= NULL
)
608 return TARGET_XFER_E_IO
;
611 mib
[2] = KERN_PROC_AUXV
;
620 buflen
= offset
+ len
;
621 buf_storage
.resize (buflen
);
622 buf
= buf_storage
.data ();
624 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
631 memcpy (readbuf
, buf
+ offset
, buflen
);
636 *xfered_len
= buflen
;
637 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
639 return TARGET_XFER_E_IO
;
642 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
643 case TARGET_OBJECT_FREEBSD_VMMAP
:
644 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
646 gdb::byte_vector buf_storage
;
652 uint32_t struct_size
;
655 case TARGET_OBJECT_FREEBSD_VMMAP
:
656 proc_target
= KERN_PROC_VMMAP
;
657 struct_size
= sizeof (struct kinfo_vmentry
);
659 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
660 proc_target
= KERN_PROC_PS_STRINGS
;
661 struct_size
= sizeof (void *);
665 if (writebuf
!= NULL
)
666 return TARGET_XFER_E_IO
;
670 mib
[2] = proc_target
;
673 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
674 return TARGET_XFER_E_IO
;
675 buflen
+= sizeof (struct_size
);
677 if (offset
>= buflen
)
680 return TARGET_XFER_EOF
;
683 buf_storage
.resize (buflen
);
684 buf
= buf_storage
.data ();
686 memcpy (buf
, &struct_size
, sizeof (struct_size
));
687 buflen
-= sizeof (struct_size
);
688 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
689 return TARGET_XFER_E_IO
;
690 buflen
+= sizeof (struct_size
);
692 if (buflen
- offset
< len
)
693 len
= buflen
- offset
;
694 memcpy (readbuf
, buf
+ offset
, len
);
696 return TARGET_XFER_OK
;
700 return inf_ptrace_target::xfer_partial (object
, annex
,
701 readbuf
, writebuf
, offset
,
706 static bool debug_fbsd_lwp
;
707 static bool debug_fbsd_nat
;
710 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
711 struct cmd_list_element
*c
, const char *value
)
713 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
717 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
718 struct cmd_list_element
*c
, const char *value
)
720 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
725 FreeBSD's first thread support was via a "reentrant" version of libc
726 (libc_r) that first shipped in 2.2.7. This library multiplexed all
727 of the threads in a process onto a single kernel thread. This
728 library was supported via the bsd-uthread target.
730 FreeBSD 5.1 introduced two new threading libraries that made use of
731 multiple kernel threads. The first (libkse) scheduled M user
732 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
733 bound each user thread to a dedicated kernel thread. libkse shipped
734 as the default threading library (libpthread).
736 FreeBSD 5.3 added a libthread_db to abstract the interface across
737 the various thread libraries (libc_r, libkse, and libthr).
739 FreeBSD 7.0 switched the default threading library from from libkse
740 to libpthread and removed libc_r.
742 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
743 only threading library supported by 8.0 and later is libthr which
744 ties each user thread directly to an LWP. To simplify the
745 implementation, this target only supports LWP-backed threads using
746 ptrace directly rather than libthread_db.
748 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
751 /* Return true if PTID is still active in the inferior. */
754 fbsd_nat_target::thread_alive (ptid_t ptid
)
758 struct ptrace_lwpinfo pl
;
760 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
763 #ifdef PL_FLAG_EXITED
764 if (pl
.pl_flags
& PL_FLAG_EXITED
)
772 /* Convert PTID to a string. */
775 fbsd_nat_target::pid_to_str (ptid_t ptid
)
782 int pid
= ptid
.pid ();
784 return string_printf ("LWP %d of process %d", lwp
, pid
);
787 return normal_pid_to_str (ptid
);
790 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
791 /* Return the name assigned to a thread by an application. Returns
792 the string in a static buffer. */
795 fbsd_nat_target::thread_name (struct thread_info
*thr
)
797 struct ptrace_lwpinfo pl
;
798 struct kinfo_proc kp
;
799 int pid
= thr
->ptid
.pid ();
800 long lwp
= thr
->ptid
.lwp ();
801 static char buf
[sizeof pl
.pl_tdname
+ 1];
803 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
804 if a name has not been set explicitly. Return a NULL name in
806 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
807 perror_with_name (_("Failed to fetch process information"));
808 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
809 perror_with_name (("ptrace"));
810 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
812 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
817 /* Enable additional event reporting on new processes.
819 To catch fork events, PTRACE_FORK is set on every traced process
820 to enable stops on returns from fork or vfork. Note that both the
821 parent and child will always stop, even if system call stops are
824 To catch LWP events, PTRACE_EVENTS is set on every traced process.
825 This enables stops on the birth for new LWPs (excluding the "main" LWP)
826 and the death of LWPs (excluding the last LWP in a process). Note
827 that unlike fork events, the LWP that creates a new LWP does not
831 fbsd_enable_proc_events (pid_t pid
)
833 #ifdef PT_GET_EVENT_MASK
836 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
837 sizeof (events
)) == -1)
838 perror_with_name (("ptrace"));
839 events
|= PTRACE_FORK
| PTRACE_LWP
;
841 events
|= PTRACE_VFORK
;
843 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
844 sizeof (events
)) == -1)
845 perror_with_name (("ptrace"));
848 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
849 perror_with_name (("ptrace"));
852 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
853 perror_with_name (("ptrace"));
858 /* Add threads for any new LWPs in a process.
860 When LWP events are used, this function is only used to detect existing
861 threads when attaching to a process. On older systems, this function is
862 called to discover new threads each time the thread list is updated. */
865 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
869 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
870 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
872 perror_with_name (("ptrace"));
874 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
876 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
878 perror_with_name (("ptrace"));
880 for (i
= 0; i
< nlwps
; i
++)
882 ptid_t ptid
= ptid_t (pid
, lwps
[i
], 0);
884 if (!in_thread_list (target
, ptid
))
887 struct ptrace_lwpinfo pl
;
889 /* Don't add exited threads. Note that this is only called
890 when attaching to a multi-threaded process. */
891 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
892 perror_with_name (("ptrace"));
893 if (pl
.pl_flags
& PL_FLAG_EXITED
)
897 fprintf_unfiltered (gdb_stdlog
,
898 "FLWP: adding thread for LWP %u\n",
900 add_thread (target
, ptid
);
905 /* Implement the "update_thread_list" target_ops method. */
908 fbsd_nat_target::update_thread_list ()
911 /* With support for thread events, threads are added/deleted from the
912 list as events are reported, so just try deleting exited threads. */
913 delete_exited_threads ();
917 fbsd_add_threads (this, inferior_ptid
.pid ());
923 To catch fork events, PT_FOLLOW_FORK is set on every traced process
924 to enable stops on returns from fork or vfork. Note that both the
925 parent and child will always stop, even if system call stops are not
928 After a fork, both the child and parent process will stop and report
929 an event. However, there is no guarantee of order. If the parent
930 reports its stop first, then fbsd_wait explicitly waits for the new
931 child before returning. If the child reports its stop first, then
932 the event is saved on a list and ignored until the parent's stop is
933 reported. fbsd_wait could have been changed to fetch the parent PID
934 of the new child and used that to wait for the parent explicitly.
935 However, if two threads in the parent fork at the same time, then
936 the wait on the parent might return the "wrong" fork event.
938 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
939 the new child process. This flag could be inferred by treating any
940 events for an unknown pid as a new child.
942 In addition, the initial version of PT_FOLLOW_FORK did not report a
943 stop event for the parent process of a vfork until after the child
944 process executed a new program or exited. The kernel was changed to
945 defer the wait for exit or exec of the child until after posting the
946 stop event shortly after the change to introduce PL_FLAG_CHILD.
947 This could be worked around by reporting a vfork event when the
948 child event posted and ignoring the subsequent event from the
951 This implementation requires both of these fixes for simplicity's
952 sake. FreeBSD versions newer than 9.1 contain both fixes.
955 static std::list
<ptid_t
> fbsd_pending_children
;
957 /* Record a new child process event that is reported before the
958 corresponding fork event in the parent. */
961 fbsd_remember_child (ptid_t pid
)
963 fbsd_pending_children
.push_front (pid
);
966 /* Check for a previously-recorded new child process event for PID.
967 If one is found, remove it from the list and return the PTID. */
970 fbsd_is_child_pending (pid_t pid
)
972 for (auto it
= fbsd_pending_children
.begin ();
973 it
!= fbsd_pending_children
.end (); it
++)
974 if (it
->pid () == pid
)
977 fbsd_pending_children
.erase (it
);
984 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
986 /* Record a pending vfork done event. */
989 fbsd_add_vfork_done (ptid_t pid
)
991 fbsd_pending_vfork_done
.push_front (pid
);
994 /* Check for a pending vfork done event for a specific PID. */
997 fbsd_is_vfork_done_pending (pid_t pid
)
999 for (auto it
= fbsd_pending_vfork_done
.begin ();
1000 it
!= fbsd_pending_vfork_done
.end (); it
++)
1001 if (it
->pid () == pid
)
1006 /* Check for a pending vfork done event. If one is found, remove it
1007 from the list and return the PTID. */
1010 fbsd_next_vfork_done (void)
1012 if (!fbsd_pending_vfork_done
.empty ())
1014 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1015 fbsd_pending_vfork_done
.pop_front ();
1023 /* Implement the "resume" target_ops method. */
1026 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1028 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1031 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1032 if (minus_one_ptid
== ptid
)
1033 pid
= inferior_ptid
.pid ();
1036 if (fbsd_is_vfork_done_pending (pid
))
1041 fprintf_unfiltered (gdb_stdlog
,
1042 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
1043 ptid
.pid (), ptid
.lwp (),
1047 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1048 inferior
*inf
= find_inferior_ptid (this, ptid
);
1050 for (thread_info
*tp
: inf
->non_exited_threads ())
1054 if (tp
->ptid
.lwp () == ptid
.lwp ())
1055 request
= PT_RESUME
;
1057 request
= PT_SUSPEND
;
1059 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1060 perror_with_name (("ptrace"));
1065 /* If ptid is a wildcard, resume all matching threads (they won't run
1066 until the process is continued however). */
1067 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1068 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1069 perror_with_name (("ptrace"));
1070 ptid
= inferior_ptid
;
1073 #if __FreeBSD_version < 1200052
1074 /* When multiple threads within a process wish to report STOPPED
1075 events from wait(), the kernel picks one thread event as the
1076 thread event to report. The chosen thread event is retrieved via
1077 PT_LWPINFO by passing the process ID as the request pid. If
1078 multiple events are pending, then the subsequent wait() after
1079 resuming a process will report another STOPPED event after
1080 resuming the process to handle the next thread event and so on.
1082 A single thread event is cleared as a side effect of resuming the
1083 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1084 however, the request pid was used to select which thread's event
1085 was cleared rather than always clearing the event that was just
1086 reported. To avoid clearing the event of the wrong LWP, always
1087 pass the process ID instead of an LWP ID to PT_CONTINUE or
1090 In the case of stepping, the process ID cannot be used with
1091 PT_STEP since it would step the thread that reported an event
1092 which may not be the thread indicated by PTID. For stepping, use
1093 PT_SETSTEP to enable stepping on the desired thread before
1094 resuming the process via PT_CONTINUE instead of using
1098 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1099 perror_with_name (("ptrace"));
1102 ptid
= ptid_t (ptid
.pid ());
1104 inf_ptrace_target::resume (ptid
, step
, signo
);
1107 #ifdef USE_SIGTRAP_SIGINFO
1108 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1109 trap was a breakpoint or trace trap that should be reported to the
1110 core, return true. */
1113 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1114 const struct ptrace_lwpinfo
&pl
)
1117 /* Ignore traps without valid siginfo or for signals other than
1120 FreeBSD kernels prior to r341800 can return stale siginfo for at
1121 least some events, but those events can be identified by
1122 additional flags set in pl_flags. True breakpoint and
1123 single-step traps should not have other flags set in
1125 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1128 /* Trace traps are either a single step or a hardware watchpoint or
1130 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1133 fprintf_unfiltered (gdb_stdlog
,
1134 "FNAT: trace trap for LWP %ld\n", ptid
.lwp ());
1138 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1140 /* Fixup PC for the software breakpoint. */
1141 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1142 struct gdbarch
*gdbarch
= regcache
->arch ();
1143 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1146 fprintf_unfiltered (gdb_stdlog
,
1147 "FNAT: sw breakpoint trap for LWP %ld\n",
1153 pc
= regcache_read_pc (regcache
);
1154 regcache_write_pc (regcache
, pc
- decr_pc
);
1163 /* Wait for the child specified by PTID to do something. Return the
1164 process ID of the child, or MINUS_ONE_PTID in case of error; store
1165 the status in *OURSTATUS. */
1168 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1169 target_wait_flags target_options
)
1175 #ifndef PTRACE_VFORK
1176 wptid
= fbsd_next_vfork_done ();
1177 if (wptid
!= null_ptid
)
1179 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1183 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1184 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1186 struct ptrace_lwpinfo pl
;
1191 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1192 perror_with_name (("ptrace"));
1194 wptid
= ptid_t (pid
, pl
.pl_lwpid
, 0);
1198 fprintf_unfiltered (gdb_stdlog
,
1199 "FNAT: stop for LWP %u event %d flags %#x\n",
1200 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1201 if (pl
.pl_flags
& PL_FLAG_SI
)
1202 fprintf_unfiltered (gdb_stdlog
,
1203 "FNAT: si_signo %u si_code %u\n",
1204 pl
.pl_siginfo
.si_signo
,
1205 pl
.pl_siginfo
.si_code
);
1208 #ifdef PT_LWP_EVENTS
1209 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1211 /* If GDB attaches to a multi-threaded process, exiting
1212 threads might be skipped during post_attach that
1213 have not yet reported their PL_FLAG_EXITED event.
1214 Ignore EXITED events for an unknown LWP. */
1215 thread_info
*thr
= find_thread_ptid (this, wptid
);
1219 fprintf_unfiltered (gdb_stdlog
,
1220 "FLWP: deleting thread for LWP %u\n",
1222 if (print_thread_events
)
1223 printf_unfiltered (_("[%s exited]\n"),
1224 target_pid_to_str (wptid
).c_str ());
1225 delete_thread (thr
);
1227 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1228 perror_with_name (("ptrace"));
1233 /* Switch to an LWP PTID on the first stop in a new process.
1234 This is done after handling PL_FLAG_EXITED to avoid
1235 switching to an exited LWP. It is done before checking
1236 PL_FLAG_BORN in case the first stop reported after
1237 attaching to an existing process is a PL_FLAG_BORN
1239 if (in_thread_list (this, ptid_t (pid
)))
1242 fprintf_unfiltered (gdb_stdlog
,
1243 "FLWP: using LWP %u for first thread\n",
1245 thread_change_ptid (this, ptid_t (pid
), wptid
);
1248 #ifdef PT_LWP_EVENTS
1249 if (pl
.pl_flags
& PL_FLAG_BORN
)
1251 /* If GDB attaches to a multi-threaded process, newborn
1252 threads might be added by fbsd_add_threads that have
1253 not yet reported their PL_FLAG_BORN event. Ignore
1254 BORN events for an already-known LWP. */
1255 if (!in_thread_list (this, wptid
))
1258 fprintf_unfiltered (gdb_stdlog
,
1259 "FLWP: adding thread for LWP %u\n",
1261 add_thread (this, wptid
);
1263 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1269 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1271 #ifndef PTRACE_VFORK
1272 struct kinfo_proc kp
;
1277 child
= pl
.pl_child_pid
;
1278 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1280 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1281 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1284 /* Make sure the other end of the fork is stopped too. */
1285 child_ptid
= fbsd_is_child_pending (child
);
1286 if (child_ptid
== null_ptid
)
1288 pid
= waitpid (child
, &status
, 0);
1290 perror_with_name (("waitpid"));
1292 gdb_assert (pid
== child
);
1294 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1295 perror_with_name (("ptrace"));
1297 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1298 child_ptid
= ptid_t (child
, pl
.pl_lwpid
, 0);
1301 /* Enable additional events on the child process. */
1302 fbsd_enable_proc_events (child_ptid
.pid ());
1304 #ifndef PTRACE_VFORK
1305 /* For vfork, the child process will have the P_PPWAIT
1307 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1309 if (kp
.ki_flag
& P_PPWAIT
)
1310 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1313 warning (_("Failed to fetch process information"));
1315 ourstatus
->value
.related_pid
= child_ptid
;
1320 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1322 /* Remember that this child forked, but do not report it
1323 until the parent reports its corresponding fork
1325 fbsd_remember_child (wptid
);
1330 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1332 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1338 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1340 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1341 ourstatus
->value
.execd_pathname
1342 = xstrdup (pid_to_exec_file (pid
));
1346 #ifdef USE_SIGTRAP_SIGINFO
1347 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1351 /* Note that PL_FLAG_SCE is set for any event reported while
1352 a thread is executing a system call in the kernel. In
1353 particular, signals that interrupt a sleep in a system
1354 call will report this flag as part of their event. Stops
1355 explicitly for system call entry and exit always use
1356 SIGTRAP, so only treat SIGTRAP events as system call
1357 entry/exit events. */
1358 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1359 && ourstatus
->value
.sig
== SIGTRAP
)
1361 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1362 if (catch_syscall_enabled ())
1364 if (catching_syscall_number (pl
.pl_syscall_code
))
1366 if (pl
.pl_flags
& PL_FLAG_SCE
)
1367 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1369 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1370 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1375 /* If the core isn't interested in this event, just
1376 continue the process explicitly and wait for another
1377 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1378 and once system call stops are enabled on a process
1379 it stops for all system call entries and exits. */
1380 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1381 perror_with_name (("ptrace"));
1389 #ifdef USE_SIGTRAP_SIGINFO
1390 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1393 fbsd_nat_target::stopped_by_sw_breakpoint ()
1395 struct ptrace_lwpinfo pl
;
1397 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1401 return (pl
.pl_flags
== PL_FLAG_SI
1402 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1403 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1406 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1410 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1417 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1418 the ptid of the followed inferior. */
1421 fbsd_nat_target::follow_fork (bool follow_child
, bool detach_fork
)
1423 if (!follow_child
&& detach_fork
)
1425 struct thread_info
*tp
= inferior_thread ();
1426 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
1428 /* Breakpoints have already been detached from the child by
1431 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1432 perror_with_name (("ptrace"));
1434 #ifndef PTRACE_VFORK
1435 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1437 /* We can't insert breakpoints until the child process has
1438 finished with the shared memory region. The parent
1439 process doesn't wait for the child process to exit or
1440 exec until after it has been resumed from the ptrace stop
1441 to report the fork. Once it has been resumed it doesn't
1442 stop again before returning to userland, so there is no
1443 reliable way to wait on the parent.
1445 We can't stay attached to the child to wait for an exec
1446 or exit because it may invoke ptrace(PT_TRACE_ME)
1447 (e.g. if the parent process is a debugger forking a new
1450 In the end, the best we can do is to make sure it runs
1451 for a little while. Hopefully it will be out of range of
1452 any breakpoints we reinsert. Usually this is only the
1453 single-step breakpoint at vfork's return point. */
1457 /* Schedule a fake VFORK_DONE event to report on the next
1459 fbsd_add_vfork_done (inferior_ptid
);
1468 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1474 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1480 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1486 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1492 /* Implement the "post_startup_inferior" target_ops method. */
1495 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1497 fbsd_enable_proc_events (pid
.pid ());
1500 /* Implement the "post_attach" target_ops method. */
1503 fbsd_nat_target::post_attach (int pid
)
1505 fbsd_enable_proc_events (pid
);
1506 fbsd_add_threads (this, pid
);
1509 /* Traced processes always stop after exec. */
1512 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1518 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1523 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1525 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1527 gdb::array_view
<const int> syscall_counts
)
1530 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1531 will catch all system call entries and exits. The system calls
1532 are filtered by GDB rather than the kernel. */
1538 fbsd_nat_target::supports_multi_process ()
1543 void _initialize_fbsd_nat ();
1545 _initialize_fbsd_nat ()
1547 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1548 &debug_fbsd_lwp
, _("\
1549 Set debugging of FreeBSD lwp module."), _("\
1550 Show debugging of FreeBSD lwp module."), _("\
1551 Enables printf debugging output."),
1553 &show_fbsd_lwp_debug
,
1554 &setdebuglist
, &showdebuglist
);
1555 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1556 &debug_fbsd_nat
, _("\
1557 Set debugging of FreeBSD native target."), _("\
1558 Show debugging of FreeBSD native target."), _("\
1559 Enables printf debugging output."),
1561 &show_fbsd_nat_debug
,
1562 &setdebuglist
, &showdebuglist
);