1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2021 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"),
724 #define fbsd_lwp_debug_printf(fmt, ...) \
725 debug_prefixed_printf_cond (debug_fbsd_lwp, "fbsd-lwp", fmt, ##__VA_ARGS__)
727 #define fbsd_nat_debug_printf(fmt, ...) \
728 debug_prefixed_printf_cond (debug_fbsd_nat, "fbsd-nat", fmt, ##__VA_ARGS__)
732 FreeBSD's first thread support was via a "reentrant" version of libc
733 (libc_r) that first shipped in 2.2.7. This library multiplexed all
734 of the threads in a process onto a single kernel thread. This
735 library was supported via the bsd-uthread target.
737 FreeBSD 5.1 introduced two new threading libraries that made use of
738 multiple kernel threads. The first (libkse) scheduled M user
739 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
740 bound each user thread to a dedicated kernel thread. libkse shipped
741 as the default threading library (libpthread).
743 FreeBSD 5.3 added a libthread_db to abstract the interface across
744 the various thread libraries (libc_r, libkse, and libthr).
746 FreeBSD 7.0 switched the default threading library from from libkse
747 to libpthread and removed libc_r.
749 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
750 only threading library supported by 8.0 and later is libthr which
751 ties each user thread directly to an LWP. To simplify the
752 implementation, this target only supports LWP-backed threads using
753 ptrace directly rather than libthread_db.
755 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
758 /* Return true if PTID is still active in the inferior. */
761 fbsd_nat_target::thread_alive (ptid_t ptid
)
765 struct ptrace_lwpinfo pl
;
767 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
770 #ifdef PL_FLAG_EXITED
771 if (pl
.pl_flags
& PL_FLAG_EXITED
)
779 /* Convert PTID to a string. */
782 fbsd_nat_target::pid_to_str (ptid_t ptid
)
789 int pid
= ptid
.pid ();
791 return string_printf ("LWP %d of process %d", lwp
, pid
);
794 return normal_pid_to_str (ptid
);
797 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
798 /* Return the name assigned to a thread by an application. Returns
799 the string in a static buffer. */
802 fbsd_nat_target::thread_name (struct thread_info
*thr
)
804 struct ptrace_lwpinfo pl
;
805 struct kinfo_proc kp
;
806 int pid
= thr
->ptid
.pid ();
807 long lwp
= thr
->ptid
.lwp ();
808 static char buf
[sizeof pl
.pl_tdname
+ 1];
810 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
811 if a name has not been set explicitly. Return a NULL name in
813 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
814 perror_with_name (_("Failed to fetch process information"));
815 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
816 perror_with_name (("ptrace"));
817 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
819 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
824 /* Enable additional event reporting on new processes.
826 To catch fork events, PTRACE_FORK is set on every traced process
827 to enable stops on returns from fork or vfork. Note that both the
828 parent and child will always stop, even if system call stops are
831 To catch LWP events, PTRACE_EVENTS is set on every traced process.
832 This enables stops on the birth for new LWPs (excluding the "main" LWP)
833 and the death of LWPs (excluding the last LWP in a process). Note
834 that unlike fork events, the LWP that creates a new LWP does not
838 fbsd_enable_proc_events (pid_t pid
)
840 #ifdef PT_GET_EVENT_MASK
843 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
844 sizeof (events
)) == -1)
845 perror_with_name (("ptrace"));
846 events
|= PTRACE_FORK
| PTRACE_LWP
;
848 events
|= PTRACE_VFORK
;
850 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
851 sizeof (events
)) == -1)
852 perror_with_name (("ptrace"));
855 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
856 perror_with_name (("ptrace"));
859 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
860 perror_with_name (("ptrace"));
865 /* Add threads for any new LWPs in a process.
867 When LWP events are used, this function is only used to detect existing
868 threads when attaching to a process. On older systems, this function is
869 called to discover new threads each time the thread list is updated. */
872 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
876 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
877 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
879 perror_with_name (("ptrace"));
881 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
883 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
885 perror_with_name (("ptrace"));
887 for (i
= 0; i
< nlwps
; i
++)
889 ptid_t ptid
= ptid_t (pid
, lwps
[i
], 0);
891 if (!in_thread_list (target
, ptid
))
894 struct ptrace_lwpinfo pl
;
896 /* Don't add exited threads. Note that this is only called
897 when attaching to a multi-threaded process. */
898 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
899 perror_with_name (("ptrace"));
900 if (pl
.pl_flags
& PL_FLAG_EXITED
)
903 fbsd_lwp_debug_printf ("adding thread for LWP %u", lwps
[i
]);
904 add_thread (target
, ptid
);
909 /* Implement the "update_thread_list" target_ops method. */
912 fbsd_nat_target::update_thread_list ()
915 /* With support for thread events, threads are added/deleted from the
916 list as events are reported, so just try deleting exited threads. */
917 delete_exited_threads ();
921 fbsd_add_threads (this, inferior_ptid
.pid ());
927 To catch fork events, PT_FOLLOW_FORK is set on every traced process
928 to enable stops on returns from fork or vfork. Note that both the
929 parent and child will always stop, even if system call stops are not
932 After a fork, both the child and parent process will stop and report
933 an event. However, there is no guarantee of order. If the parent
934 reports its stop first, then fbsd_wait explicitly waits for the new
935 child before returning. If the child reports its stop first, then
936 the event is saved on a list and ignored until the parent's stop is
937 reported. fbsd_wait could have been changed to fetch the parent PID
938 of the new child and used that to wait for the parent explicitly.
939 However, if two threads in the parent fork at the same time, then
940 the wait on the parent might return the "wrong" fork event.
942 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
943 the new child process. This flag could be inferred by treating any
944 events for an unknown pid as a new child.
946 In addition, the initial version of PT_FOLLOW_FORK did not report a
947 stop event for the parent process of a vfork until after the child
948 process executed a new program or exited. The kernel was changed to
949 defer the wait for exit or exec of the child until after posting the
950 stop event shortly after the change to introduce PL_FLAG_CHILD.
951 This could be worked around by reporting a vfork event when the
952 child event posted and ignoring the subsequent event from the
955 This implementation requires both of these fixes for simplicity's
956 sake. FreeBSD versions newer than 9.1 contain both fixes.
959 static std::list
<ptid_t
> fbsd_pending_children
;
961 /* Record a new child process event that is reported before the
962 corresponding fork event in the parent. */
965 fbsd_remember_child (ptid_t pid
)
967 fbsd_pending_children
.push_front (pid
);
970 /* Check for a previously-recorded new child process event for PID.
971 If one is found, remove it from the list and return the PTID. */
974 fbsd_is_child_pending (pid_t pid
)
976 for (auto it
= fbsd_pending_children
.begin ();
977 it
!= fbsd_pending_children
.end (); it
++)
978 if (it
->pid () == pid
)
981 fbsd_pending_children
.erase (it
);
988 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
990 /* Record a pending vfork done event. */
993 fbsd_add_vfork_done (ptid_t pid
)
995 fbsd_pending_vfork_done
.push_front (pid
);
998 /* Check for a pending vfork done event for a specific PID. */
1001 fbsd_is_vfork_done_pending (pid_t pid
)
1003 for (auto it
= fbsd_pending_vfork_done
.begin ();
1004 it
!= fbsd_pending_vfork_done
.end (); it
++)
1005 if (it
->pid () == pid
)
1010 /* Check for a pending vfork done event. If one is found, remove it
1011 from the list and return the PTID. */
1014 fbsd_next_vfork_done (void)
1016 if (!fbsd_pending_vfork_done
.empty ())
1018 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1019 fbsd_pending_vfork_done
.pop_front ();
1027 /* Implement the "resume" target_ops method. */
1030 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1032 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1035 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1036 if (minus_one_ptid
== ptid
)
1037 pid
= inferior_ptid
.pid ();
1040 if (fbsd_is_vfork_done_pending (pid
))
1044 fbsd_lwp_debug_printf ("ptid (%d, %ld, %ld)", ptid
.pid (), ptid
.lwp (),
1048 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1049 inferior
*inf
= find_inferior_ptid (this, ptid
);
1051 for (thread_info
*tp
: inf
->non_exited_threads ())
1055 if (tp
->ptid
.lwp () == ptid
.lwp ())
1056 request
= PT_RESUME
;
1058 request
= PT_SUSPEND
;
1060 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1061 perror_with_name (("ptrace"));
1066 /* If ptid is a wildcard, resume all matching threads (they won't run
1067 until the process is continued however). */
1068 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1069 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1070 perror_with_name (("ptrace"));
1071 ptid
= inferior_ptid
;
1074 #if __FreeBSD_version < 1200052
1075 /* When multiple threads within a process wish to report STOPPED
1076 events from wait(), the kernel picks one thread event as the
1077 thread event to report. The chosen thread event is retrieved via
1078 PT_LWPINFO by passing the process ID as the request pid. If
1079 multiple events are pending, then the subsequent wait() after
1080 resuming a process will report another STOPPED event after
1081 resuming the process to handle the next thread event and so on.
1083 A single thread event is cleared as a side effect of resuming the
1084 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1085 however, the request pid was used to select which thread's event
1086 was cleared rather than always clearing the event that was just
1087 reported. To avoid clearing the event of the wrong LWP, always
1088 pass the process ID instead of an LWP ID to PT_CONTINUE or
1091 In the case of stepping, the process ID cannot be used with
1092 PT_STEP since it would step the thread that reported an event
1093 which may not be the thread indicated by PTID. For stepping, use
1094 PT_SETSTEP to enable stepping on the desired thread before
1095 resuming the process via PT_CONTINUE instead of using
1099 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1100 perror_with_name (("ptrace"));
1103 ptid
= ptid_t (ptid
.pid ());
1105 inf_ptrace_target::resume (ptid
, step
, signo
);
1108 #ifdef USE_SIGTRAP_SIGINFO
1109 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1110 trap was a breakpoint or trace trap that should be reported to the
1111 core, return true. */
1114 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1115 const struct ptrace_lwpinfo
&pl
)
1118 /* Ignore traps without valid siginfo or for signals other than
1121 FreeBSD kernels prior to r341800 can return stale siginfo for at
1122 least some events, but those events can be identified by
1123 additional flags set in pl_flags. True breakpoint and
1124 single-step traps should not have other flags set in
1126 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1129 /* Trace traps are either a single step or a hardware watchpoint or
1131 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1133 fbsd_nat_debug_printf ("trace trap for LWP %ld", ptid
.lwp ());
1137 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1139 /* Fixup PC for the software breakpoint. */
1140 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1141 struct gdbarch
*gdbarch
= regcache
->arch ();
1142 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1144 fbsd_nat_debug_printf ("sw breakpoint trap for LWP %ld", ptid
.lwp ());
1149 pc
= regcache_read_pc (regcache
);
1150 regcache_write_pc (regcache
, pc
- decr_pc
);
1159 /* Wait for the child specified by PTID to do something. Return the
1160 process ID of the child, or MINUS_ONE_PTID in case of error; store
1161 the status in *OURSTATUS. */
1164 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1165 target_wait_flags target_options
)
1171 #ifndef PTRACE_VFORK
1172 wptid
= fbsd_next_vfork_done ();
1173 if (wptid
!= null_ptid
)
1175 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1179 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1180 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1182 struct ptrace_lwpinfo pl
;
1187 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1188 perror_with_name (("ptrace"));
1190 wptid
= ptid_t (pid
, pl
.pl_lwpid
, 0);
1194 fbsd_nat_debug_printf ("stop for LWP %u event %d flags %#x",
1195 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1196 if (pl
.pl_flags
& PL_FLAG_SI
)
1197 fbsd_nat_debug_printf ("si_signo %u si_code %u",
1198 pl
.pl_siginfo
.si_signo
,
1199 pl
.pl_siginfo
.si_code
);
1202 #ifdef PT_LWP_EVENTS
1203 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1205 /* If GDB attaches to a multi-threaded process, exiting
1206 threads might be skipped during post_attach that
1207 have not yet reported their PL_FLAG_EXITED event.
1208 Ignore EXITED events for an unknown LWP. */
1209 thread_info
*thr
= find_thread_ptid (this, wptid
);
1212 fbsd_lwp_debug_printf ("deleting thread for LWP %u",
1214 if (print_thread_events
)
1215 printf_unfiltered (_("[%s exited]\n"),
1216 target_pid_to_str (wptid
).c_str ());
1217 delete_thread (thr
);
1219 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1220 perror_with_name (("ptrace"));
1225 /* Switch to an LWP PTID on the first stop in a new process.
1226 This is done after handling PL_FLAG_EXITED to avoid
1227 switching to an exited LWP. It is done before checking
1228 PL_FLAG_BORN in case the first stop reported after
1229 attaching to an existing process is a PL_FLAG_BORN
1231 if (in_thread_list (this, ptid_t (pid
)))
1233 fbsd_lwp_debug_printf ("using LWP %u for first thread",
1235 thread_change_ptid (this, ptid_t (pid
), wptid
);
1238 #ifdef PT_LWP_EVENTS
1239 if (pl
.pl_flags
& PL_FLAG_BORN
)
1241 /* If GDB attaches to a multi-threaded process, newborn
1242 threads might be added by fbsd_add_threads that have
1243 not yet reported their PL_FLAG_BORN event. Ignore
1244 BORN events for an already-known LWP. */
1245 if (!in_thread_list (this, wptid
))
1247 fbsd_lwp_debug_printf ("adding thread for LWP %u",
1249 add_thread (this, wptid
);
1251 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1257 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1259 #ifndef PTRACE_VFORK
1260 struct kinfo_proc kp
;
1265 child
= pl
.pl_child_pid
;
1266 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1268 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1269 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1272 /* Make sure the other end of the fork is stopped too. */
1273 child_ptid
= fbsd_is_child_pending (child
);
1274 if (child_ptid
== null_ptid
)
1276 pid
= waitpid (child
, &status
, 0);
1278 perror_with_name (("waitpid"));
1280 gdb_assert (pid
== child
);
1282 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1283 perror_with_name (("ptrace"));
1285 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1286 child_ptid
= ptid_t (child
, pl
.pl_lwpid
, 0);
1289 /* Enable additional events on the child process. */
1290 fbsd_enable_proc_events (child_ptid
.pid ());
1292 #ifndef PTRACE_VFORK
1293 /* For vfork, the child process will have the P_PPWAIT
1295 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1297 if (kp
.ki_flag
& P_PPWAIT
)
1298 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1301 warning (_("Failed to fetch process information"));
1303 ourstatus
->value
.related_pid
= child_ptid
;
1308 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1310 /* Remember that this child forked, but do not report it
1311 until the parent reports its corresponding fork
1313 fbsd_remember_child (wptid
);
1318 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1320 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1326 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1328 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1329 ourstatus
->value
.execd_pathname
1330 = xstrdup (pid_to_exec_file (pid
));
1334 #ifdef USE_SIGTRAP_SIGINFO
1335 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1339 /* Note that PL_FLAG_SCE is set for any event reported while
1340 a thread is executing a system call in the kernel. In
1341 particular, signals that interrupt a sleep in a system
1342 call will report this flag as part of their event. Stops
1343 explicitly for system call entry and exit always use
1344 SIGTRAP, so only treat SIGTRAP events as system call
1345 entry/exit events. */
1346 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1347 && ourstatus
->value
.sig
== SIGTRAP
)
1349 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1350 if (catch_syscall_enabled ())
1352 if (catching_syscall_number (pl
.pl_syscall_code
))
1354 if (pl
.pl_flags
& PL_FLAG_SCE
)
1355 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1357 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1358 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1363 /* If the core isn't interested in this event, just
1364 continue the process explicitly and wait for another
1365 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1366 and once system call stops are enabled on a process
1367 it stops for all system call entries and exits. */
1368 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1369 perror_with_name (("ptrace"));
1377 #ifdef USE_SIGTRAP_SIGINFO
1378 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1381 fbsd_nat_target::stopped_by_sw_breakpoint ()
1383 struct ptrace_lwpinfo pl
;
1385 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1389 return (pl
.pl_flags
== PL_FLAG_SI
1390 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1391 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1394 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1398 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1405 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1406 the ptid of the followed inferior. */
1409 fbsd_nat_target::follow_fork (bool follow_child
, bool detach_fork
)
1411 if (!follow_child
&& detach_fork
)
1413 struct thread_info
*tp
= inferior_thread ();
1414 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
1416 /* Breakpoints have already been detached from the child by
1419 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1420 perror_with_name (("ptrace"));
1422 #ifndef PTRACE_VFORK
1423 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1425 /* We can't insert breakpoints until the child process has
1426 finished with the shared memory region. The parent
1427 process doesn't wait for the child process to exit or
1428 exec until after it has been resumed from the ptrace stop
1429 to report the fork. Once it has been resumed it doesn't
1430 stop again before returning to userland, so there is no
1431 reliable way to wait on the parent.
1433 We can't stay attached to the child to wait for an exec
1434 or exit because it may invoke ptrace(PT_TRACE_ME)
1435 (e.g. if the parent process is a debugger forking a new
1438 In the end, the best we can do is to make sure it runs
1439 for a little while. Hopefully it will be out of range of
1440 any breakpoints we reinsert. Usually this is only the
1441 single-step breakpoint at vfork's return point. */
1445 /* Schedule a fake VFORK_DONE event to report on the next
1447 fbsd_add_vfork_done (inferior_ptid
);
1454 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1460 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1466 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1472 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1478 /* Implement the "post_startup_inferior" target_ops method. */
1481 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1483 fbsd_enable_proc_events (pid
.pid ());
1486 /* Implement the "post_attach" target_ops method. */
1489 fbsd_nat_target::post_attach (int pid
)
1491 fbsd_enable_proc_events (pid
);
1492 fbsd_add_threads (this, pid
);
1495 /* Traced processes always stop after exec. */
1498 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1504 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1509 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1511 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1513 gdb::array_view
<const int> syscall_counts
)
1516 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1517 will catch all system call entries and exits. The system calls
1518 are filtered by GDB rather than the kernel. */
1524 fbsd_nat_target::supports_multi_process ()
1529 void _initialize_fbsd_nat ();
1531 _initialize_fbsd_nat ()
1533 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1534 &debug_fbsd_lwp
, _("\
1535 Set debugging of FreeBSD lwp module."), _("\
1536 Show debugging of FreeBSD lwp module."), _("\
1537 Enables printf debugging output."),
1539 &show_fbsd_lwp_debug
,
1540 &setdebuglist
, &showdebuglist
);
1541 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1542 &debug_fbsd_nat
, _("\
1543 Set debugging of FreeBSD native target."), _("\
1544 Show debugging of FreeBSD native target."), _("\
1545 Enables printf debugging output."),
1547 &show_fbsd_nat_debug
,
1548 &setdebuglist
, &showdebuglist
);