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 #ifdef HAVE_SYS_PROCCTL_H
33 #include <sys/procctl.h>
35 #include <sys/procfs.h>
36 #include <sys/ptrace.h>
37 #include <sys/signal.h>
38 #include <sys/sysctl.h>
44 #include "fbsd-tdep.h"
48 /* Return the name of a file that can be opened to get the symbols for
49 the child process identified by PID. */
52 fbsd_nat_target::pid_to_exec_file (int pid
)
54 static char buf
[PATH_MAX
];
60 mib
[2] = KERN_PROC_PATHNAME
;
63 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
64 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
65 for processes without an associated executable such as kernel
67 return buflen
== 0 ? NULL
: buf
;
72 /* Iterate over all the memory regions in the current inferior,
73 calling FUNC for each memory region. DATA is passed as the last
77 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
80 pid_t pid
= inferior_ptid
.pid ();
81 struct kinfo_vmentry
*kve
;
85 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
86 vmentl (kinfo_getvmmap (pid
, &nitems
));
88 perror_with_name (_("Couldn't fetch VM map entries."));
90 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
92 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
93 if (!(kve
->kve_protection
& KVME_PROT_READ
)
94 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
97 /* Skip segments with an invalid type. */
98 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
99 && kve
->kve_type
!= KVME_TYPE_VNODE
100 && kve
->kve_type
!= KVME_TYPE_SWAP
101 && kve
->kve_type
!= KVME_TYPE_PHYS
)
104 size
= kve
->kve_end
- kve
->kve_start
;
107 fprintf_filtered (gdb_stdout
,
108 "Save segment, %ld bytes at %s (%c%c%c)\n",
110 paddress (target_gdbarch (), kve
->kve_start
),
111 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
112 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
113 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
116 /* Invoke the callback function to create the corefile segment.
117 Pass MODIFIED as true, we do not know the real modification state. */
118 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
119 kve
->kve_protection
& KVME_PROT_WRITE
,
120 kve
->kve_protection
& KVME_PROT_EXEC
, 1, data
);
125 /* Fetch the command line for a running process. */
127 static gdb::unique_xmalloc_ptr
<char>
128 fbsd_fetch_cmdline (pid_t pid
)
136 mib
[2] = KERN_PROC_ARGS
;
138 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
144 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
145 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
148 /* Join the arguments with spaces to form a single string. */
149 char *cp
= cmdline
.get ();
150 for (size_t i
= 0; i
< len
- 1; i
++)
158 /* Fetch the external variant of the kernel's internal process
159 structure for the process PID into KP. */
162 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
170 mib
[2] = KERN_PROC_PID
;
172 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
175 /* Implement the "info_proc" target_ops method. */
178 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
180 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
182 struct kinfo_proc kp
;
184 bool do_cmdline
= false;
187 bool do_files
= false;
188 bool do_mappings
= false;
189 bool do_status
= false;
226 error (_("Not supported on this target."));
229 gdb_argv
built_argv (args
);
230 if (built_argv
.count () == 0)
232 pid
= inferior_ptid
.pid ();
234 error (_("No current process: you must name one."));
236 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
237 pid
= strtol (built_argv
[0], NULL
, 10);
239 error (_("Invalid arguments."));
241 printf_filtered (_("process %d\n"), pid
);
242 if (do_cwd
|| do_exe
|| do_files
)
243 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
247 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
248 if (cmdline
!= nullptr)
249 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
251 warning (_("unable to fetch command line"));
255 const char *cwd
= NULL
;
256 struct kinfo_file
*kf
= fdtbl
.get ();
257 for (int i
= 0; i
< nfd
; i
++, kf
++)
259 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
266 printf_filtered ("cwd = '%s'\n", cwd
);
268 warning (_("unable to fetch current working directory"));
272 const char *exe
= NULL
;
273 struct kinfo_file
*kf
= fdtbl
.get ();
274 for (int i
= 0; i
< nfd
; i
++, kf
++)
276 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
283 exe
= pid_to_exec_file (pid
);
285 printf_filtered ("exe = '%s'\n", exe
);
287 warning (_("unable to fetch executable path name"));
291 struct kinfo_file
*kf
= fdtbl
.get ();
295 fbsd_info_proc_files_header ();
296 for (int i
= 0; i
< nfd
; i
++, kf
++)
297 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
298 kf
->kf_offset
, kf
->kf_vnode_type
,
299 kf
->kf_sock_domain
, kf
->kf_sock_type
,
300 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
301 &kf
->kf_sa_peer
, kf
->kf_path
);
304 warning (_("unable to fetch list of open files"));
309 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
310 vmentl (kinfo_getvmmap (pid
, &nvment
));
312 if (vmentl
!= nullptr)
314 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
315 fbsd_info_proc_mappings_header (addr_bit
);
317 struct kinfo_vmentry
*kve
= vmentl
.get ();
318 for (int i
= 0; i
< nvment
; i
++, kve
++)
319 fbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
320 kve
->kve_end
, kve
->kve_offset
,
321 kve
->kve_flags
, kve
->kve_protection
,
325 warning (_("unable to fetch virtual memory map"));
329 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
330 warning (_("Failed to fetch process information"));
336 printf_filtered ("Name: %s\n", kp
.ki_comm
);
343 state
= "R (running)";
346 state
= "T (stopped)";
349 state
= "Z (zombie)";
352 state
= "S (sleeping)";
355 state
= "W (interrupt wait)";
358 state
= "L (blocked on lock)";
361 state
= "? (unknown)";
364 printf_filtered ("State: %s\n", state
);
365 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
366 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
367 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
368 printf_filtered ("TTY: %ju\n", (uintmax_t) kp
.ki_tdev
);
369 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
370 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
371 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
372 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
373 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
374 printf_filtered ("Groups: ");
375 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
376 printf_filtered ("%d ", kp
.ki_groups
[i
]);
377 printf_filtered ("\n");
378 printf_filtered ("Minor faults (no memory page): %ld\n",
379 kp
.ki_rusage
.ru_minflt
);
380 printf_filtered ("Minor faults, children: %ld\n",
381 kp
.ki_rusage_ch
.ru_minflt
);
382 printf_filtered ("Major faults (memory page faults): %ld\n",
383 kp
.ki_rusage
.ru_majflt
);
384 printf_filtered ("Major faults, children: %ld\n",
385 kp
.ki_rusage_ch
.ru_majflt
);
386 printf_filtered ("utime: %jd.%06ld\n",
387 (intmax_t) kp
.ki_rusage
.ru_utime
.tv_sec
,
388 kp
.ki_rusage
.ru_utime
.tv_usec
);
389 printf_filtered ("stime: %jd.%06ld\n",
390 (intmax_t) kp
.ki_rusage
.ru_stime
.tv_sec
,
391 kp
.ki_rusage
.ru_stime
.tv_usec
);
392 printf_filtered ("utime, children: %jd.%06ld\n",
393 (intmax_t) kp
.ki_rusage_ch
.ru_utime
.tv_sec
,
394 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
395 printf_filtered ("stime, children: %jd.%06ld\n",
396 (intmax_t) kp
.ki_rusage_ch
.ru_stime
.tv_sec
,
397 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
398 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
399 printf_filtered ("Start time: %jd.%06ld\n", kp
.ki_start
.tv_sec
,
400 kp
.ki_start
.tv_usec
);
401 pgtok
= getpagesize () / 1024;
402 printf_filtered ("Virtual memory size: %ju kB\n",
403 (uintmax_t) kp
.ki_size
/ 1024);
404 printf_filtered ("Data size: %ju kB\n",
405 (uintmax_t) kp
.ki_dsize
* pgtok
);
406 printf_filtered ("Stack size: %ju kB\n",
407 (uintmax_t) kp
.ki_ssize
* pgtok
);
408 printf_filtered ("Text size: %ju kB\n",
409 (uintmax_t) kp
.ki_tsize
* pgtok
);
410 printf_filtered ("Resident set size: %ju kB\n",
411 (uintmax_t) kp
.ki_rssize
* pgtok
);
412 printf_filtered ("Maximum RSS: %ju kB\n",
413 (uintmax_t) kp
.ki_rusage
.ru_maxrss
);
414 printf_filtered ("Pending Signals: ");
415 for (int i
= 0; i
< _SIG_WORDS
; i
++)
416 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
417 printf_filtered ("\n");
418 printf_filtered ("Ignored Signals: ");
419 for (int i
= 0; i
< _SIG_WORDS
; i
++)
420 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
421 printf_filtered ("\n");
422 printf_filtered ("Caught Signals: ");
423 for (int i
= 0; i
< _SIG_WORDS
; i
++)
424 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
425 printf_filtered ("\n");
432 /* Return the size of siginfo for the current inferior. */
440 /* This structure matches the naming and layout of `siginfo_t' in
441 <sys/signal.h>. In particular, the `si_foo' macros defined in that
442 header can be used with both types to copy fields in the `_reason'
454 union sigval32 si_value
;
487 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
489 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
490 if (gdbarch_long_bit (gdbarch
) == 32)
491 return sizeof (struct siginfo32
);
493 return sizeof (siginfo_t
);
496 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
497 that FreeBSD doesn't support writing to $_siginfo, so this only
498 needs to convert one way. */
501 fbsd_convert_siginfo (siginfo_t
*si
)
504 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
506 /* Is the inferior 32-bit? If not, nothing to do. */
507 if (gdbarch_long_bit (gdbarch
) != 32)
510 struct siginfo32 si32
;
512 si32
.si_signo
= si
->si_signo
;
513 si32
.si_errno
= si
->si_errno
;
514 si32
.si_code
= si
->si_code
;
515 si32
.si_pid
= si
->si_pid
;
516 si32
.si_uid
= si
->si_uid
;
517 si32
.si_status
= si
->si_status
;
518 si32
.si_addr
= (uintptr_t) si
->si_addr
;
520 /* If sival_ptr is being used instead of sival_int on a big-endian
521 platform, then sival_int will be zero since it holds the upper
522 32-bits of the pointer value. */
523 #if _BYTE_ORDER == _BIG_ENDIAN
524 if (si
->si_value
.sival_int
== 0)
525 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
527 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
529 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
532 /* Always copy the spare fields and then possibly overwrite them for
533 signal-specific or code-specific fields. */
534 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
535 for (int i
= 0; i
< 7; i
++)
536 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
537 switch (si
->si_signo
) {
542 si32
.si_trapno
= si
->si_trapno
;
545 switch (si
->si_code
) {
547 si32
.si_timerid
= si
->si_timerid
;
548 si32
.si_overrun
= si
->si_overrun
;
551 si32
.si_mqd
= si
->si_mqd
;
555 memcpy(si
, &si32
, sizeof (si32
));
559 /* Implement the "xfer_partial" target_ops method. */
561 enum target_xfer_status
562 fbsd_nat_target::xfer_partial (enum target_object object
,
563 const char *annex
, gdb_byte
*readbuf
,
564 const gdb_byte
*writebuf
,
565 ULONGEST offset
, ULONGEST len
,
566 ULONGEST
*xfered_len
)
568 pid_t pid
= inferior_ptid
.pid ();
572 case TARGET_OBJECT_SIGNAL_INFO
:
574 struct ptrace_lwpinfo pl
;
577 /* FreeBSD doesn't support writing to $_siginfo. */
578 if (writebuf
!= NULL
)
579 return TARGET_XFER_E_IO
;
581 if (inferior_ptid
.lwp_p ())
582 pid
= inferior_ptid
.lwp ();
584 siginfo_size
= fbsd_siginfo_size ();
585 if (offset
> siginfo_size
)
586 return TARGET_XFER_E_IO
;
588 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
589 return TARGET_XFER_E_IO
;
591 if (!(pl
.pl_flags
& PL_FLAG_SI
))
592 return TARGET_XFER_E_IO
;
594 fbsd_convert_siginfo (&pl
.pl_siginfo
);
595 if (offset
+ len
> siginfo_size
)
596 len
= siginfo_size
- offset
;
598 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
600 return TARGET_XFER_OK
;
602 #ifdef KERN_PROC_AUXV
603 case TARGET_OBJECT_AUXV
:
605 gdb::byte_vector buf_storage
;
610 if (writebuf
!= NULL
)
611 return TARGET_XFER_E_IO
;
614 mib
[2] = KERN_PROC_AUXV
;
623 buflen
= offset
+ len
;
624 buf_storage
.resize (buflen
);
625 buf
= buf_storage
.data ();
627 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
634 memcpy (readbuf
, buf
+ offset
, buflen
);
639 *xfered_len
= buflen
;
640 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
642 return TARGET_XFER_E_IO
;
645 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
646 case TARGET_OBJECT_FREEBSD_VMMAP
:
647 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
649 gdb::byte_vector buf_storage
;
655 uint32_t struct_size
;
658 case TARGET_OBJECT_FREEBSD_VMMAP
:
659 proc_target
= KERN_PROC_VMMAP
;
660 struct_size
= sizeof (struct kinfo_vmentry
);
662 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
663 proc_target
= KERN_PROC_PS_STRINGS
;
664 struct_size
= sizeof (void *);
668 if (writebuf
!= NULL
)
669 return TARGET_XFER_E_IO
;
673 mib
[2] = proc_target
;
676 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
677 return TARGET_XFER_E_IO
;
678 buflen
+= sizeof (struct_size
);
680 if (offset
>= buflen
)
683 return TARGET_XFER_EOF
;
686 buf_storage
.resize (buflen
);
687 buf
= buf_storage
.data ();
689 memcpy (buf
, &struct_size
, sizeof (struct_size
));
690 buflen
-= sizeof (struct_size
);
691 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
692 return TARGET_XFER_E_IO
;
693 buflen
+= sizeof (struct_size
);
695 if (buflen
- offset
< len
)
696 len
= buflen
- offset
;
697 memcpy (readbuf
, buf
+ offset
, len
);
699 return TARGET_XFER_OK
;
703 return inf_ptrace_target::xfer_partial (object
, annex
,
704 readbuf
, writebuf
, offset
,
709 static bool debug_fbsd_lwp
;
710 static bool debug_fbsd_nat
;
713 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
714 struct cmd_list_element
*c
, const char *value
)
716 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
720 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
721 struct cmd_list_element
*c
, const char *value
)
723 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
727 #define fbsd_lwp_debug_printf(fmt, ...) \
728 debug_prefixed_printf_cond (debug_fbsd_lwp, "fbsd-lwp", fmt, ##__VA_ARGS__)
730 #define fbsd_nat_debug_printf(fmt, ...) \
731 debug_prefixed_printf_cond (debug_fbsd_nat, "fbsd-nat", fmt, ##__VA_ARGS__)
735 FreeBSD's first thread support was via a "reentrant" version of libc
736 (libc_r) that first shipped in 2.2.7. This library multiplexed all
737 of the threads in a process onto a single kernel thread. This
738 library was supported via the bsd-uthread target.
740 FreeBSD 5.1 introduced two new threading libraries that made use of
741 multiple kernel threads. The first (libkse) scheduled M user
742 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
743 bound each user thread to a dedicated kernel thread. libkse shipped
744 as the default threading library (libpthread).
746 FreeBSD 5.3 added a libthread_db to abstract the interface across
747 the various thread libraries (libc_r, libkse, and libthr).
749 FreeBSD 7.0 switched the default threading library from from libkse
750 to libpthread and removed libc_r.
752 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
753 only threading library supported by 8.0 and later is libthr which
754 ties each user thread directly to an LWP. To simplify the
755 implementation, this target only supports LWP-backed threads using
756 ptrace directly rather than libthread_db.
758 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
761 /* Return true if PTID is still active in the inferior. */
764 fbsd_nat_target::thread_alive (ptid_t ptid
)
768 struct ptrace_lwpinfo pl
;
770 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
773 #ifdef PL_FLAG_EXITED
774 if (pl
.pl_flags
& PL_FLAG_EXITED
)
782 /* Convert PTID to a string. */
785 fbsd_nat_target::pid_to_str (ptid_t ptid
)
792 int pid
= ptid
.pid ();
794 return string_printf ("LWP %d of process %d", lwp
, pid
);
797 return normal_pid_to_str (ptid
);
800 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
801 /* Return the name assigned to a thread by an application. Returns
802 the string in a static buffer. */
805 fbsd_nat_target::thread_name (struct thread_info
*thr
)
807 struct ptrace_lwpinfo pl
;
808 struct kinfo_proc kp
;
809 int pid
= thr
->ptid
.pid ();
810 long lwp
= thr
->ptid
.lwp ();
811 static char buf
[sizeof pl
.pl_tdname
+ 1];
813 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
814 if a name has not been set explicitly. Return a NULL name in
816 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
817 perror_with_name (_("Failed to fetch process information"));
818 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
819 perror_with_name (("ptrace"));
820 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
822 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
827 /* Enable additional event reporting on new processes.
829 To catch fork events, PTRACE_FORK is set on every traced process
830 to enable stops on returns from fork or vfork. Note that both the
831 parent and child will always stop, even if system call stops are
834 To catch LWP events, PTRACE_EVENTS is set on every traced process.
835 This enables stops on the birth for new LWPs (excluding the "main" LWP)
836 and the death of LWPs (excluding the last LWP in a process). Note
837 that unlike fork events, the LWP that creates a new LWP does not
841 fbsd_enable_proc_events (pid_t pid
)
843 #ifdef PT_GET_EVENT_MASK
846 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
847 sizeof (events
)) == -1)
848 perror_with_name (("ptrace"));
849 events
|= PTRACE_FORK
| PTRACE_LWP
;
851 events
|= PTRACE_VFORK
;
853 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
854 sizeof (events
)) == -1)
855 perror_with_name (("ptrace"));
858 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
859 perror_with_name (("ptrace"));
862 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
863 perror_with_name (("ptrace"));
868 /* Add threads for any new LWPs in a process.
870 When LWP events are used, this function is only used to detect existing
871 threads when attaching to a process. On older systems, this function is
872 called to discover new threads each time the thread list is updated. */
875 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
879 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
880 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
882 perror_with_name (("ptrace"));
884 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
886 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
888 perror_with_name (("ptrace"));
890 for (i
= 0; i
< nlwps
; i
++)
892 ptid_t ptid
= ptid_t (pid
, lwps
[i
], 0);
894 if (!in_thread_list (target
, ptid
))
897 struct ptrace_lwpinfo pl
;
899 /* Don't add exited threads. Note that this is only called
900 when attaching to a multi-threaded process. */
901 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
902 perror_with_name (("ptrace"));
903 if (pl
.pl_flags
& PL_FLAG_EXITED
)
906 fbsd_lwp_debug_printf ("adding thread for LWP %u", lwps
[i
]);
907 add_thread (target
, ptid
);
912 /* Implement the "update_thread_list" target_ops method. */
915 fbsd_nat_target::update_thread_list ()
918 /* With support for thread events, threads are added/deleted from the
919 list as events are reported, so just try deleting exited threads. */
920 delete_exited_threads ();
924 fbsd_add_threads (this, inferior_ptid
.pid ());
930 To catch fork events, PT_FOLLOW_FORK is set on every traced process
931 to enable stops on returns from fork or vfork. Note that both the
932 parent and child will always stop, even if system call stops are not
935 After a fork, both the child and parent process will stop and report
936 an event. However, there is no guarantee of order. If the parent
937 reports its stop first, then fbsd_wait explicitly waits for the new
938 child before returning. If the child reports its stop first, then
939 the event is saved on a list and ignored until the parent's stop is
940 reported. fbsd_wait could have been changed to fetch the parent PID
941 of the new child and used that to wait for the parent explicitly.
942 However, if two threads in the parent fork at the same time, then
943 the wait on the parent might return the "wrong" fork event.
945 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
946 the new child process. This flag could be inferred by treating any
947 events for an unknown pid as a new child.
949 In addition, the initial version of PT_FOLLOW_FORK did not report a
950 stop event for the parent process of a vfork until after the child
951 process executed a new program or exited. The kernel was changed to
952 defer the wait for exit or exec of the child until after posting the
953 stop event shortly after the change to introduce PL_FLAG_CHILD.
954 This could be worked around by reporting a vfork event when the
955 child event posted and ignoring the subsequent event from the
958 This implementation requires both of these fixes for simplicity's
959 sake. FreeBSD versions newer than 9.1 contain both fixes.
962 static std::list
<ptid_t
> fbsd_pending_children
;
964 /* Record a new child process event that is reported before the
965 corresponding fork event in the parent. */
968 fbsd_remember_child (ptid_t pid
)
970 fbsd_pending_children
.push_front (pid
);
973 /* Check for a previously-recorded new child process event for PID.
974 If one is found, remove it from the list and return the PTID. */
977 fbsd_is_child_pending (pid_t pid
)
979 for (auto it
= fbsd_pending_children
.begin ();
980 it
!= fbsd_pending_children
.end (); it
++)
981 if (it
->pid () == pid
)
984 fbsd_pending_children
.erase (it
);
991 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
993 /* Record a pending vfork done event. */
996 fbsd_add_vfork_done (ptid_t pid
)
998 fbsd_pending_vfork_done
.push_front (pid
);
1001 /* Check for a pending vfork done event for a specific PID. */
1004 fbsd_is_vfork_done_pending (pid_t pid
)
1006 for (auto it
= fbsd_pending_vfork_done
.begin ();
1007 it
!= fbsd_pending_vfork_done
.end (); it
++)
1008 if (it
->pid () == pid
)
1013 /* Check for a pending vfork done event. If one is found, remove it
1014 from the list and return the PTID. */
1017 fbsd_next_vfork_done (void)
1019 if (!fbsd_pending_vfork_done
.empty ())
1021 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1022 fbsd_pending_vfork_done
.pop_front ();
1030 /* Implement the "resume" target_ops method. */
1033 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1035 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1038 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1039 if (minus_one_ptid
== ptid
)
1040 pid
= inferior_ptid
.pid ();
1043 if (fbsd_is_vfork_done_pending (pid
))
1047 fbsd_lwp_debug_printf ("ptid (%d, %ld, %ld)", ptid
.pid (), ptid
.lwp (),
1051 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1052 inferior
*inf
= find_inferior_ptid (this, ptid
);
1054 for (thread_info
*tp
: inf
->non_exited_threads ())
1058 if (tp
->ptid
.lwp () == ptid
.lwp ())
1059 request
= PT_RESUME
;
1061 request
= PT_SUSPEND
;
1063 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1064 perror_with_name (("ptrace"));
1069 /* If ptid is a wildcard, resume all matching threads (they won't run
1070 until the process is continued however). */
1071 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1072 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1073 perror_with_name (("ptrace"));
1074 ptid
= inferior_ptid
;
1077 #if __FreeBSD_version < 1200052
1078 /* When multiple threads within a process wish to report STOPPED
1079 events from wait(), the kernel picks one thread event as the
1080 thread event to report. The chosen thread event is retrieved via
1081 PT_LWPINFO by passing the process ID as the request pid. If
1082 multiple events are pending, then the subsequent wait() after
1083 resuming a process will report another STOPPED event after
1084 resuming the process to handle the next thread event and so on.
1086 A single thread event is cleared as a side effect of resuming the
1087 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1088 however, the request pid was used to select which thread's event
1089 was cleared rather than always clearing the event that was just
1090 reported. To avoid clearing the event of the wrong LWP, always
1091 pass the process ID instead of an LWP ID to PT_CONTINUE or
1094 In the case of stepping, the process ID cannot be used with
1095 PT_STEP since it would step the thread that reported an event
1096 which may not be the thread indicated by PTID. For stepping, use
1097 PT_SETSTEP to enable stepping on the desired thread before
1098 resuming the process via PT_CONTINUE instead of using
1102 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1103 perror_with_name (("ptrace"));
1106 ptid
= ptid_t (ptid
.pid ());
1108 inf_ptrace_target::resume (ptid
, step
, signo
);
1111 #ifdef USE_SIGTRAP_SIGINFO
1112 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1113 trap was a breakpoint or trace trap that should be reported to the
1114 core, return true. */
1117 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1118 const struct ptrace_lwpinfo
&pl
)
1121 /* Ignore traps without valid siginfo or for signals other than
1124 FreeBSD kernels prior to r341800 can return stale siginfo for at
1125 least some events, but those events can be identified by
1126 additional flags set in pl_flags. True breakpoint and
1127 single-step traps should not have other flags set in
1129 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1132 /* Trace traps are either a single step or a hardware watchpoint or
1134 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1136 fbsd_nat_debug_printf ("trace trap for LWP %ld", ptid
.lwp ());
1140 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1142 /* Fixup PC for the software breakpoint. */
1143 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1144 struct gdbarch
*gdbarch
= regcache
->arch ();
1145 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1147 fbsd_nat_debug_printf ("sw breakpoint trap for LWP %ld", ptid
.lwp ());
1152 pc
= regcache_read_pc (regcache
);
1153 regcache_write_pc (regcache
, pc
- decr_pc
);
1162 /* Wait for the child specified by PTID to do something. Return the
1163 process ID of the child, or MINUS_ONE_PTID in case of error; store
1164 the status in *OURSTATUS. */
1167 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1168 target_wait_flags target_options
)
1174 #ifndef PTRACE_VFORK
1175 wptid
= fbsd_next_vfork_done ();
1176 if (wptid
!= null_ptid
)
1178 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1182 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1183 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1185 struct ptrace_lwpinfo pl
;
1190 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1191 perror_with_name (("ptrace"));
1193 wptid
= ptid_t (pid
, pl
.pl_lwpid
, 0);
1197 fbsd_nat_debug_printf ("stop for LWP %u event %d flags %#x",
1198 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1199 if (pl
.pl_flags
& PL_FLAG_SI
)
1200 fbsd_nat_debug_printf ("si_signo %u si_code %u",
1201 pl
.pl_siginfo
.si_signo
,
1202 pl
.pl_siginfo
.si_code
);
1205 #ifdef PT_LWP_EVENTS
1206 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1208 /* If GDB attaches to a multi-threaded process, exiting
1209 threads might be skipped during post_attach that
1210 have not yet reported their PL_FLAG_EXITED event.
1211 Ignore EXITED events for an unknown LWP. */
1212 thread_info
*thr
= find_thread_ptid (this, wptid
);
1215 fbsd_lwp_debug_printf ("deleting thread for LWP %u",
1217 if (print_thread_events
)
1218 printf_unfiltered (_("[%s exited]\n"),
1219 target_pid_to_str (wptid
).c_str ());
1220 delete_thread (thr
);
1222 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1223 perror_with_name (("ptrace"));
1228 /* Switch to an LWP PTID on the first stop in a new process.
1229 This is done after handling PL_FLAG_EXITED to avoid
1230 switching to an exited LWP. It is done before checking
1231 PL_FLAG_BORN in case the first stop reported after
1232 attaching to an existing process is a PL_FLAG_BORN
1234 if (in_thread_list (this, ptid_t (pid
)))
1236 fbsd_lwp_debug_printf ("using LWP %u for first thread",
1238 thread_change_ptid (this, ptid_t (pid
), wptid
);
1241 #ifdef PT_LWP_EVENTS
1242 if (pl
.pl_flags
& PL_FLAG_BORN
)
1244 /* If GDB attaches to a multi-threaded process, newborn
1245 threads might be added by fbsd_add_threads that have
1246 not yet reported their PL_FLAG_BORN event. Ignore
1247 BORN events for an already-known LWP. */
1248 if (!in_thread_list (this, wptid
))
1250 fbsd_lwp_debug_printf ("adding thread for LWP %u",
1252 add_thread (this, wptid
);
1254 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1260 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1262 #ifndef PTRACE_VFORK
1263 struct kinfo_proc kp
;
1268 child
= pl
.pl_child_pid
;
1269 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1271 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1272 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1275 /* Make sure the other end of the fork is stopped too. */
1276 child_ptid
= fbsd_is_child_pending (child
);
1277 if (child_ptid
== null_ptid
)
1279 pid
= waitpid (child
, &status
, 0);
1281 perror_with_name (("waitpid"));
1283 gdb_assert (pid
== child
);
1285 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1286 perror_with_name (("ptrace"));
1288 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1289 child_ptid
= ptid_t (child
, pl
.pl_lwpid
, 0);
1292 /* Enable additional events on the child process. */
1293 fbsd_enable_proc_events (child_ptid
.pid ());
1295 #ifndef PTRACE_VFORK
1296 /* For vfork, the child process will have the P_PPWAIT
1298 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1300 if (kp
.ki_flag
& P_PPWAIT
)
1301 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1304 warning (_("Failed to fetch process information"));
1306 ourstatus
->value
.related_pid
= child_ptid
;
1311 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1313 /* Remember that this child forked, but do not report it
1314 until the parent reports its corresponding fork
1316 fbsd_remember_child (wptid
);
1321 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1323 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1329 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1331 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1332 ourstatus
->value
.execd_pathname
1333 = xstrdup (pid_to_exec_file (pid
));
1337 #ifdef USE_SIGTRAP_SIGINFO
1338 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1342 /* Note that PL_FLAG_SCE is set for any event reported while
1343 a thread is executing a system call in the kernel. In
1344 particular, signals that interrupt a sleep in a system
1345 call will report this flag as part of their event. Stops
1346 explicitly for system call entry and exit always use
1347 SIGTRAP, so only treat SIGTRAP events as system call
1348 entry/exit events. */
1349 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1350 && ourstatus
->value
.sig
== SIGTRAP
)
1352 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1353 if (catch_syscall_enabled ())
1355 if (catching_syscall_number (pl
.pl_syscall_code
))
1357 if (pl
.pl_flags
& PL_FLAG_SCE
)
1358 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1360 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1361 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1366 /* If the core isn't interested in this event, just
1367 continue the process explicitly and wait for another
1368 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1369 and once system call stops are enabled on a process
1370 it stops for all system call entries and exits. */
1371 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1372 perror_with_name (("ptrace"));
1380 #ifdef USE_SIGTRAP_SIGINFO
1381 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1384 fbsd_nat_target::stopped_by_sw_breakpoint ()
1386 struct ptrace_lwpinfo pl
;
1388 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1392 return (pl
.pl_flags
== PL_FLAG_SI
1393 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1394 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1397 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1401 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1407 #ifdef PROC_ASLR_CTL
1408 class maybe_disable_address_space_randomization
1411 explicit maybe_disable_address_space_randomization (bool disable_randomization
)
1413 if (disable_randomization
)
1415 if (procctl (P_PID
, getpid (), PROC_ASLR_STATUS
, &m_aslr_ctl
) == -1)
1417 warning (_("Failed to fetch current address space randomization "
1418 "status: %s"), safe_strerror (errno
));
1422 m_aslr_ctl
&= ~PROC_ASLR_ACTIVE
;
1423 if (m_aslr_ctl
== PROC_ASLR_FORCE_DISABLE
)
1426 int ctl
= PROC_ASLR_FORCE_DISABLE
;
1427 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &ctl
) == -1)
1429 warning (_("Error disabling address space randomization: %s"),
1430 safe_strerror (errno
));
1434 m_aslr_ctl_set
= true;
1438 ~maybe_disable_address_space_randomization ()
1442 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &m_aslr_ctl
) == -1)
1443 warning (_("Error restoring address space randomization: %s"),
1444 safe_strerror (errno
));
1448 DISABLE_COPY_AND_ASSIGN (maybe_disable_address_space_randomization
);
1451 bool m_aslr_ctl_set
= false;
1457 fbsd_nat_target::create_inferior (const char *exec_file
,
1458 const std::string
&allargs
,
1459 char **env
, int from_tty
)
1461 #ifdef PROC_ASLR_CTL
1462 maybe_disable_address_space_randomization restore_aslr_ctl
1463 (disable_randomization
);
1466 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1470 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1471 the ptid of the followed inferior. */
1474 fbsd_nat_target::follow_fork (bool follow_child
, bool detach_fork
)
1476 if (!follow_child
&& detach_fork
)
1478 struct thread_info
*tp
= inferior_thread ();
1479 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
1481 /* Breakpoints have already been detached from the child by
1484 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1485 perror_with_name (("ptrace"));
1487 #ifndef PTRACE_VFORK
1488 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1490 /* We can't insert breakpoints until the child process has
1491 finished with the shared memory region. The parent
1492 process doesn't wait for the child process to exit or
1493 exec until after it has been resumed from the ptrace stop
1494 to report the fork. Once it has been resumed it doesn't
1495 stop again before returning to userland, so there is no
1496 reliable way to wait on the parent.
1498 We can't stay attached to the child to wait for an exec
1499 or exit because it may invoke ptrace(PT_TRACE_ME)
1500 (e.g. if the parent process is a debugger forking a new
1503 In the end, the best we can do is to make sure it runs
1504 for a little while. Hopefully it will be out of range of
1505 any breakpoints we reinsert. Usually this is only the
1506 single-step breakpoint at vfork's return point. */
1510 /* Schedule a fake VFORK_DONE event to report on the next
1512 fbsd_add_vfork_done (inferior_ptid
);
1519 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1525 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1531 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1537 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1543 /* Implement the "post_startup_inferior" target_ops method. */
1546 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1548 fbsd_enable_proc_events (pid
.pid ());
1551 /* Implement the "post_attach" target_ops method. */
1554 fbsd_nat_target::post_attach (int pid
)
1556 fbsd_enable_proc_events (pid
);
1557 fbsd_add_threads (this, pid
);
1560 /* Traced processes always stop after exec. */
1563 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1569 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1574 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1576 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1578 gdb::array_view
<const int> syscall_counts
)
1581 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1582 will catch all system call entries and exits. The system calls
1583 are filtered by GDB rather than the kernel. */
1589 fbsd_nat_target::supports_multi_process ()
1595 fbsd_nat_target::supports_disable_randomization ()
1597 #ifdef PROC_ASLR_CTL
1604 void _initialize_fbsd_nat ();
1606 _initialize_fbsd_nat ()
1608 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1609 &debug_fbsd_lwp
, _("\
1610 Set debugging of FreeBSD lwp module."), _("\
1611 Show debugging of FreeBSD lwp module."), _("\
1612 Enables printf debugging output."),
1614 &show_fbsd_lwp_debug
,
1615 &setdebuglist
, &showdebuglist
);
1616 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1617 &debug_fbsd_nat
, _("\
1618 Set debugging of FreeBSD native target."), _("\
1619 Show debugging of FreeBSD native target."), _("\
1620 Enables printf debugging output."),
1622 &show_fbsd_nat_debug
,
1623 &setdebuglist
, &showdebuglist
);