1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdbsupport/block-signals.h"
22 #include "gdbsupport/byte-vector.h"
23 #include "gdbsupport/event-loop.h"
30 #include "gdbthread.h"
31 #include "gdbsupport/buildargv.h"
32 #include "gdbsupport/gdb_wait.h"
34 #include "inf-ptrace.h"
35 #include <sys/types.h>
36 #ifdef HAVE_SYS_PROCCTL_H
37 #include <sys/procctl.h>
39 #include <sys/procfs.h>
40 #include <sys/ptrace.h>
41 #include <sys/signal.h>
42 #include <sys/sysctl.h>
48 #include "fbsd-tdep.h"
53 #define PT_GETREGSET 42 /* Get a target register set */
54 #define PT_SETREGSET 43 /* Set a target register set */
57 /* Return the name of a file that can be opened to get the symbols for
58 the child process identified by PID. */
61 fbsd_nat_target::pid_to_exec_file (int pid
)
63 static char buf
[PATH_MAX
];
69 mib
[2] = KERN_PROC_PATHNAME
;
72 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
73 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
74 for processes without an associated executable such as kernel
76 return buflen
== 0 ? NULL
: buf
;
81 /* Iterate over all the memory regions in the current inferior,
82 calling FUNC for each memory region. DATA is passed as the last
86 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
89 pid_t pid
= inferior_ptid
.pid ();
90 struct kinfo_vmentry
*kve
;
94 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
95 vmentl (kinfo_getvmmap (pid
, &nitems
));
97 perror_with_name (_("Couldn't fetch VM map entries"));
99 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
101 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
102 if (!(kve
->kve_protection
& KVME_PROT_READ
)
103 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
106 /* Skip segments with an invalid type. */
107 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
108 && kve
->kve_type
!= KVME_TYPE_VNODE
109 && kve
->kve_type
!= KVME_TYPE_SWAP
110 && kve
->kve_type
!= KVME_TYPE_PHYS
)
113 size
= kve
->kve_end
- kve
->kve_start
;
116 gdb_printf ("Save segment, %ld bytes at %s (%c%c%c)\n",
118 paddress (target_gdbarch (), kve
->kve_start
),
119 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
120 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
121 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
124 /* Invoke the callback function to create the corefile segment.
125 Pass MODIFIED as true, we do not know the real modification state. */
126 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
127 kve
->kve_protection
& KVME_PROT_WRITE
,
128 kve
->kve_protection
& KVME_PROT_EXEC
, 1, false, data
);
133 /* Fetch the command line for a running process. */
135 static gdb::unique_xmalloc_ptr
<char>
136 fbsd_fetch_cmdline (pid_t pid
)
144 mib
[2] = KERN_PROC_ARGS
;
146 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
152 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
153 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
156 /* Join the arguments with spaces to form a single string. */
157 char *cp
= cmdline
.get ();
158 for (size_t i
= 0; i
< len
- 1; i
++)
166 /* Fetch the external variant of the kernel's internal process
167 structure for the process PID into KP. */
170 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
178 mib
[2] = KERN_PROC_PID
;
180 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
183 /* Implement the "info_proc" target_ops method. */
186 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
188 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
190 struct kinfo_proc kp
;
192 bool do_cmdline
= false;
195 bool do_files
= false;
196 bool do_mappings
= false;
197 bool do_status
= false;
234 error (_("Not supported on this target."));
237 gdb_argv
built_argv (args
);
238 if (built_argv
.count () == 0)
240 pid
= inferior_ptid
.pid ();
242 error (_("No current process: you must name one."));
244 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
245 pid
= strtol (built_argv
[0], NULL
, 10);
247 error (_("Invalid arguments."));
249 gdb_printf (_("process %d\n"), pid
);
250 if (do_cwd
|| do_exe
|| do_files
)
251 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
255 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
256 if (cmdline
!= nullptr)
257 gdb_printf ("cmdline = '%s'\n", cmdline
.get ());
259 warning (_("unable to fetch command line"));
263 const char *cwd
= NULL
;
264 struct kinfo_file
*kf
= fdtbl
.get ();
265 for (int i
= 0; i
< nfd
; i
++, kf
++)
267 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
274 gdb_printf ("cwd = '%s'\n", cwd
);
276 warning (_("unable to fetch current working directory"));
280 const char *exe
= NULL
;
281 struct kinfo_file
*kf
= fdtbl
.get ();
282 for (int i
= 0; i
< nfd
; i
++, kf
++)
284 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
291 exe
= pid_to_exec_file (pid
);
293 gdb_printf ("exe = '%s'\n", exe
);
295 warning (_("unable to fetch executable path name"));
299 struct kinfo_file
*kf
= fdtbl
.get ();
303 fbsd_info_proc_files_header ();
304 for (int i
= 0; i
< nfd
; i
++, kf
++)
305 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
306 kf
->kf_offset
, kf
->kf_vnode_type
,
307 kf
->kf_sock_domain
, kf
->kf_sock_type
,
308 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
309 &kf
->kf_sa_peer
, kf
->kf_path
);
312 warning (_("unable to fetch list of open files"));
317 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
318 vmentl (kinfo_getvmmap (pid
, &nvment
));
320 if (vmentl
!= nullptr)
322 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
323 fbsd_info_proc_mappings_header (addr_bit
);
325 struct kinfo_vmentry
*kve
= vmentl
.get ();
326 for (int i
= 0; i
< nvment
; i
++, kve
++)
327 fbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
328 kve
->kve_end
, kve
->kve_offset
,
329 kve
->kve_flags
, kve
->kve_protection
,
333 warning (_("unable to fetch virtual memory map"));
337 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
338 warning (_("Failed to fetch process information"));
344 gdb_printf ("Name: %s\n", kp
.ki_comm
);
351 state
= "R (running)";
354 state
= "T (stopped)";
357 state
= "Z (zombie)";
360 state
= "S (sleeping)";
363 state
= "W (interrupt wait)";
366 state
= "L (blocked on lock)";
369 state
= "? (unknown)";
372 gdb_printf ("State: %s\n", state
);
373 gdb_printf ("Parent process: %d\n", kp
.ki_ppid
);
374 gdb_printf ("Process group: %d\n", kp
.ki_pgid
);
375 gdb_printf ("Session id: %d\n", kp
.ki_sid
);
376 gdb_printf ("TTY: %s\n", pulongest (kp
.ki_tdev
));
377 gdb_printf ("TTY owner process group: %d\n", kp
.ki_tpgid
);
378 gdb_printf ("User IDs (real, effective, saved): %d %d %d\n",
379 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
380 gdb_printf ("Group IDs (real, effective, saved): %d %d %d\n",
381 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
382 gdb_printf ("Groups: ");
383 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
384 gdb_printf ("%d ", kp
.ki_groups
[i
]);
386 gdb_printf ("Minor faults (no memory page): %ld\n",
387 kp
.ki_rusage
.ru_minflt
);
388 gdb_printf ("Minor faults, children: %ld\n",
389 kp
.ki_rusage_ch
.ru_minflt
);
390 gdb_printf ("Major faults (memory page faults): %ld\n",
391 kp
.ki_rusage
.ru_majflt
);
392 gdb_printf ("Major faults, children: %ld\n",
393 kp
.ki_rusage_ch
.ru_majflt
);
394 gdb_printf ("utime: %s.%06ld\n",
395 plongest (kp
.ki_rusage
.ru_utime
.tv_sec
),
396 kp
.ki_rusage
.ru_utime
.tv_usec
);
397 gdb_printf ("stime: %s.%06ld\n",
398 plongest (kp
.ki_rusage
.ru_stime
.tv_sec
),
399 kp
.ki_rusage
.ru_stime
.tv_usec
);
400 gdb_printf ("utime, children: %s.%06ld\n",
401 plongest (kp
.ki_rusage_ch
.ru_utime
.tv_sec
),
402 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
403 gdb_printf ("stime, children: %s.%06ld\n",
404 plongest (kp
.ki_rusage_ch
.ru_stime
.tv_sec
),
405 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
406 gdb_printf ("'nice' value: %d\n", kp
.ki_nice
);
407 gdb_printf ("Start time: %s.%06ld\n",
408 plongest (kp
.ki_start
.tv_sec
),
409 kp
.ki_start
.tv_usec
);
410 pgtok
= getpagesize () / 1024;
411 gdb_printf ("Virtual memory size: %s kB\n",
412 pulongest (kp
.ki_size
/ 1024));
413 gdb_printf ("Data size: %s kB\n",
414 pulongest (kp
.ki_dsize
* pgtok
));
415 gdb_printf ("Stack size: %s kB\n",
416 pulongest (kp
.ki_ssize
* pgtok
));
417 gdb_printf ("Text size: %s kB\n",
418 pulongest (kp
.ki_tsize
* pgtok
));
419 gdb_printf ("Resident set size: %s kB\n",
420 pulongest (kp
.ki_rssize
* pgtok
));
421 gdb_printf ("Maximum RSS: %s kB\n",
422 pulongest (kp
.ki_rusage
.ru_maxrss
));
423 gdb_printf ("Pending Signals: ");
424 for (int i
= 0; i
< _SIG_WORDS
; i
++)
425 gdb_printf ("%08x ", kp
.ki_siglist
.__bits
[i
]);
427 gdb_printf ("Ignored Signals: ");
428 for (int i
= 0; i
< _SIG_WORDS
; i
++)
429 gdb_printf ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
431 gdb_printf ("Caught Signals: ");
432 for (int i
= 0; i
< _SIG_WORDS
; i
++)
433 gdb_printf ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
441 /* Return the size of siginfo for the current inferior. */
449 /* This structure matches the naming and layout of `siginfo_t' in
450 <sys/signal.h>. In particular, the `si_foo' macros defined in that
451 header can be used with both types to copy fields in the `_reason'
463 union sigval32 si_value
;
496 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
498 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
499 if (gdbarch_long_bit (gdbarch
) == 32)
500 return sizeof (struct siginfo32
);
502 return sizeof (siginfo_t
);
505 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
506 that FreeBSD doesn't support writing to $_siginfo, so this only
507 needs to convert one way. */
510 fbsd_convert_siginfo (siginfo_t
*si
)
513 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
515 /* Is the inferior 32-bit? If not, nothing to do. */
516 if (gdbarch_long_bit (gdbarch
) != 32)
519 struct siginfo32 si32
;
521 si32
.si_signo
= si
->si_signo
;
522 si32
.si_errno
= si
->si_errno
;
523 si32
.si_code
= si
->si_code
;
524 si32
.si_pid
= si
->si_pid
;
525 si32
.si_uid
= si
->si_uid
;
526 si32
.si_status
= si
->si_status
;
527 si32
.si_addr
= (uintptr_t) si
->si_addr
;
529 /* If sival_ptr is being used instead of sival_int on a big-endian
530 platform, then sival_int will be zero since it holds the upper
531 32-bits of the pointer value. */
532 #if _BYTE_ORDER == _BIG_ENDIAN
533 if (si
->si_value
.sival_int
== 0)
534 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
536 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
538 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
541 /* Always copy the spare fields and then possibly overwrite them for
542 signal-specific or code-specific fields. */
543 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
544 for (int i
= 0; i
< 7; i
++)
545 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
546 switch (si
->si_signo
) {
551 si32
.si_trapno
= si
->si_trapno
;
554 switch (si
->si_code
) {
556 si32
.si_timerid
= si
->si_timerid
;
557 si32
.si_overrun
= si
->si_overrun
;
560 si32
.si_mqd
= si
->si_mqd
;
564 memcpy(si
, &si32
, sizeof (si32
));
568 /* Implement the "xfer_partial" target_ops method. */
570 enum target_xfer_status
571 fbsd_nat_target::xfer_partial (enum target_object object
,
572 const char *annex
, gdb_byte
*readbuf
,
573 const gdb_byte
*writebuf
,
574 ULONGEST offset
, ULONGEST len
,
575 ULONGEST
*xfered_len
)
577 pid_t pid
= inferior_ptid
.pid ();
581 case TARGET_OBJECT_SIGNAL_INFO
:
583 struct ptrace_lwpinfo pl
;
586 /* FreeBSD doesn't support writing to $_siginfo. */
587 if (writebuf
!= NULL
)
588 return TARGET_XFER_E_IO
;
590 if (inferior_ptid
.lwp_p ())
591 pid
= inferior_ptid
.lwp ();
593 siginfo_size
= fbsd_siginfo_size ();
594 if (offset
> siginfo_size
)
595 return TARGET_XFER_E_IO
;
597 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
598 return TARGET_XFER_E_IO
;
600 if (!(pl
.pl_flags
& PL_FLAG_SI
))
601 return TARGET_XFER_E_IO
;
603 fbsd_convert_siginfo (&pl
.pl_siginfo
);
604 if (offset
+ len
> siginfo_size
)
605 len
= siginfo_size
- offset
;
607 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
609 return TARGET_XFER_OK
;
611 #ifdef KERN_PROC_AUXV
612 case TARGET_OBJECT_AUXV
:
614 gdb::byte_vector buf_storage
;
619 if (writebuf
!= NULL
)
620 return TARGET_XFER_E_IO
;
623 mib
[2] = KERN_PROC_AUXV
;
632 buflen
= offset
+ len
;
633 buf_storage
.resize (buflen
);
634 buf
= buf_storage
.data ();
636 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
643 memcpy (readbuf
, buf
+ offset
, buflen
);
648 *xfered_len
= buflen
;
649 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
651 return TARGET_XFER_E_IO
;
654 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
655 case TARGET_OBJECT_FREEBSD_VMMAP
:
656 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
658 gdb::byte_vector buf_storage
;
664 uint32_t struct_size
;
667 case TARGET_OBJECT_FREEBSD_VMMAP
:
668 proc_target
= KERN_PROC_VMMAP
;
669 struct_size
= sizeof (struct kinfo_vmentry
);
671 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
672 proc_target
= KERN_PROC_PS_STRINGS
;
673 struct_size
= sizeof (void *);
677 if (writebuf
!= NULL
)
678 return TARGET_XFER_E_IO
;
682 mib
[2] = proc_target
;
685 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
686 return TARGET_XFER_E_IO
;
687 buflen
+= sizeof (struct_size
);
689 if (offset
>= buflen
)
692 return TARGET_XFER_EOF
;
695 buf_storage
.resize (buflen
);
696 buf
= buf_storage
.data ();
698 memcpy (buf
, &struct_size
, sizeof (struct_size
));
699 buflen
-= sizeof (struct_size
);
700 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
701 return TARGET_XFER_E_IO
;
702 buflen
+= sizeof (struct_size
);
704 if (buflen
- offset
< len
)
705 len
= buflen
- offset
;
706 memcpy (readbuf
, buf
+ offset
, len
);
708 return TARGET_XFER_OK
;
712 return inf_ptrace_target::xfer_partial (object
, annex
,
713 readbuf
, writebuf
, offset
,
718 static bool debug_fbsd_lwp
;
719 static bool debug_fbsd_nat
;
722 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
723 struct cmd_list_element
*c
, const char *value
)
725 gdb_printf (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
729 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
730 struct cmd_list_element
*c
, const char *value
)
732 gdb_printf (file
, _("Debugging of FreeBSD native target is %s.\n"),
736 #define fbsd_lwp_debug_printf(fmt, ...) \
737 debug_prefixed_printf_cond (debug_fbsd_lwp, "fbsd-lwp", fmt, ##__VA_ARGS__)
739 #define fbsd_nat_debug_printf(fmt, ...) \
740 debug_prefixed_printf_cond (debug_fbsd_nat, "fbsd-nat", fmt, ##__VA_ARGS__)
744 FreeBSD's first thread support was via a "reentrant" version of libc
745 (libc_r) that first shipped in 2.2.7. This library multiplexed all
746 of the threads in a process onto a single kernel thread. This
747 library was supported via the bsd-uthread target.
749 FreeBSD 5.1 introduced two new threading libraries that made use of
750 multiple kernel threads. The first (libkse) scheduled M user
751 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
752 bound each user thread to a dedicated kernel thread. libkse shipped
753 as the default threading library (libpthread).
755 FreeBSD 5.3 added a libthread_db to abstract the interface across
756 the various thread libraries (libc_r, libkse, and libthr).
758 FreeBSD 7.0 switched the default threading library from from libkse
759 to libpthread and removed libc_r.
761 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
762 only threading library supported by 8.0 and later is libthr which
763 ties each user thread directly to an LWP. To simplify the
764 implementation, this target only supports LWP-backed threads using
765 ptrace directly rather than libthread_db.
767 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
770 /* Return true if PTID is still active in the inferior. */
773 fbsd_nat_target::thread_alive (ptid_t ptid
)
777 struct ptrace_lwpinfo pl
;
779 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
782 #ifdef PL_FLAG_EXITED
783 if (pl
.pl_flags
& PL_FLAG_EXITED
)
791 /* Convert PTID to a string. */
794 fbsd_nat_target::pid_to_str (ptid_t ptid
)
801 int pid
= ptid
.pid ();
803 return string_printf ("LWP %d of process %d", lwp
, pid
);
806 return normal_pid_to_str (ptid
);
809 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
810 /* Return the name assigned to a thread by an application. Returns
811 the string in a static buffer. */
814 fbsd_nat_target::thread_name (struct thread_info
*thr
)
816 struct ptrace_lwpinfo pl
;
817 struct kinfo_proc kp
;
818 int pid
= thr
->ptid
.pid ();
819 long lwp
= thr
->ptid
.lwp ();
820 static char buf
[sizeof pl
.pl_tdname
+ 1];
822 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
823 if a name has not been set explicitly. Return a NULL name in
825 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
827 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
829 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
831 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
836 /* Enable additional event reporting on new processes.
838 To catch fork events, PTRACE_FORK is set on every traced process
839 to enable stops on returns from fork or vfork. Note that both the
840 parent and child will always stop, even if system call stops are
843 To catch LWP events, PTRACE_EVENTS is set on every traced process.
844 This enables stops on the birth for new LWPs (excluding the "main" LWP)
845 and the death of LWPs (excluding the last LWP in a process). Note
846 that unlike fork events, the LWP that creates a new LWP does not
850 fbsd_enable_proc_events (pid_t pid
)
852 #ifdef PT_GET_EVENT_MASK
855 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
856 sizeof (events
)) == -1)
857 perror_with_name (("ptrace (PT_GET_EVENT_MASK)"));
858 events
|= PTRACE_FORK
| PTRACE_LWP
;
860 events
|= PTRACE_VFORK
;
862 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
863 sizeof (events
)) == -1)
864 perror_with_name (("ptrace (PT_SET_EVENT_MASK)"));
867 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
868 perror_with_name (("ptrace (PT_FOLLOW_FORK)"));
871 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
872 perror_with_name (("ptrace (PT_LWP_EVENTS)"));
877 /* Add threads for any new LWPs in a process.
879 When LWP events are used, this function is only used to detect existing
880 threads when attaching to a process. On older systems, this function is
881 called to discover new threads each time the thread list is updated. */
884 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
888 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
889 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
891 perror_with_name (("ptrace (PT_GETNUMLWPS)"));
893 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
895 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
897 perror_with_name (("ptrace (PT_GETLWPLIST)"));
899 for (i
= 0; i
< nlwps
; i
++)
901 ptid_t ptid
= ptid_t (pid
, lwps
[i
]);
903 if (!in_thread_list (target
, ptid
))
906 struct ptrace_lwpinfo pl
;
908 /* Don't add exited threads. Note that this is only called
909 when attaching to a multi-threaded process. */
910 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
911 perror_with_name (("ptrace (PT_LWPINFO)"));
912 if (pl
.pl_flags
& PL_FLAG_EXITED
)
915 fbsd_lwp_debug_printf ("adding thread for LWP %u", lwps
[i
]);
916 add_thread (target
, ptid
);
921 /* Implement the "update_thread_list" target_ops method. */
924 fbsd_nat_target::update_thread_list ()
927 /* With support for thread events, threads are added/deleted from the
928 list as events are reported, so just try deleting exited threads. */
929 delete_exited_threads ();
933 fbsd_add_threads (this, inferior_ptid
.pid ());
937 /* Async mode support. */
939 /* Implement the "can_async_p" target method. */
942 fbsd_nat_target::can_async_p ()
944 /* This flag should be checked in the common target.c code. */
945 gdb_assert (target_async_permitted
);
947 /* Otherwise, this targets is always able to support async mode. */
951 /* SIGCHLD handler notifies the event-loop in async mode. */
954 sigchld_handler (int signo
)
956 int old_errno
= errno
;
958 fbsd_nat_target::async_file_mark_if_open ();
963 /* Callback registered with the target events file descriptor. */
966 handle_target_event (int error
, gdb_client_data client_data
)
968 inferior_event_handler (INF_REG_EVENT
);
971 /* Implement the "async" target method. */
974 fbsd_nat_target::async (bool enable
)
976 if (enable
== is_async_p ())
979 /* Block SIGCHILD while we create/destroy the pipe, as the handler
981 gdb::block_signals blocker
;
985 if (!async_file_open ())
986 internal_error ("failed to create event pipe.");
988 add_file_handler (async_wait_fd (), handle_target_event
, NULL
, "fbsd-nat");
990 /* Trigger a poll in case there are pending events to
996 delete_file_handler (async_wait_fd ());
1003 To catch fork events, PT_FOLLOW_FORK is set on every traced process
1004 to enable stops on returns from fork or vfork. Note that both the
1005 parent and child will always stop, even if system call stops are not
1008 After a fork, both the child and parent process will stop and report
1009 an event. However, there is no guarantee of order. If the parent
1010 reports its stop first, then fbsd_wait explicitly waits for the new
1011 child before returning. If the child reports its stop first, then
1012 the event is saved on a list and ignored until the parent's stop is
1013 reported. fbsd_wait could have been changed to fetch the parent PID
1014 of the new child and used that to wait for the parent explicitly.
1015 However, if two threads in the parent fork at the same time, then
1016 the wait on the parent might return the "wrong" fork event.
1018 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
1019 the new child process. This flag could be inferred by treating any
1020 events for an unknown pid as a new child.
1022 In addition, the initial version of PT_FOLLOW_FORK did not report a
1023 stop event for the parent process of a vfork until after the child
1024 process executed a new program or exited. The kernel was changed to
1025 defer the wait for exit or exec of the child until after posting the
1026 stop event shortly after the change to introduce PL_FLAG_CHILD.
1027 This could be worked around by reporting a vfork event when the
1028 child event posted and ignoring the subsequent event from the
1031 This implementation requires both of these fixes for simplicity's
1032 sake. FreeBSD versions newer than 9.1 contain both fixes.
1035 static std::list
<ptid_t
> fbsd_pending_children
;
1037 /* Record a new child process event that is reported before the
1038 corresponding fork event in the parent. */
1041 fbsd_remember_child (ptid_t pid
)
1043 fbsd_pending_children
.push_front (pid
);
1046 /* Check for a previously-recorded new child process event for PID.
1047 If one is found, remove it from the list and return the PTID. */
1050 fbsd_is_child_pending (pid_t pid
)
1052 for (auto it
= fbsd_pending_children
.begin ();
1053 it
!= fbsd_pending_children
.end (); it
++)
1054 if (it
->pid () == pid
)
1057 fbsd_pending_children
.erase (it
);
1063 #ifndef PTRACE_VFORK
1064 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
1066 /* Record a pending vfork done event. */
1069 fbsd_add_vfork_done (ptid_t pid
)
1071 fbsd_pending_vfork_done
.push_front (pid
);
1073 /* If we're in async mode, need to tell the event loop there's
1074 something here to process. */
1075 if (target_is_async_p ())
1079 /* Check for a pending vfork done event for a specific PID. */
1082 fbsd_is_vfork_done_pending (pid_t pid
)
1084 for (auto it
= fbsd_pending_vfork_done
.begin ();
1085 it
!= fbsd_pending_vfork_done
.end (); it
++)
1086 if (it
->pid () == pid
)
1091 /* Check for a pending vfork done event. If one is found, remove it
1092 from the list and return the PTID. */
1095 fbsd_next_vfork_done (void)
1097 if (!fbsd_pending_vfork_done
.empty ())
1099 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1100 fbsd_pending_vfork_done
.pop_front ();
1108 /* Implement the "resume" target_ops method. */
1111 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1113 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1116 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1117 if (minus_one_ptid
== ptid
)
1118 pid
= inferior_ptid
.pid ();
1121 if (fbsd_is_vfork_done_pending (pid
))
1125 fbsd_nat_debug_printf ("[%s], step %d, signo %d (%s)",
1126 target_pid_to_str (ptid
).c_str (), step
, signo
,
1127 gdb_signal_to_name (signo
));
1130 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1131 inferior
*inf
= find_inferior_ptid (this, ptid
);
1133 for (thread_info
*tp
: inf
->non_exited_threads ())
1137 if (tp
->ptid
.lwp () == ptid
.lwp ())
1138 request
= PT_RESUME
;
1140 request
= PT_SUSPEND
;
1142 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1143 perror_with_name (request
== PT_RESUME
?
1144 ("ptrace (PT_RESUME)") :
1145 ("ptrace (PT_SUSPEND)"));
1146 if (request
== PT_RESUME
)
1147 low_prepare_to_resume (tp
);
1152 /* If ptid is a wildcard, resume all matching threads (they won't run
1153 until the process is continued however). */
1154 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1156 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1157 perror_with_name (("ptrace (PT_RESUME)"));
1158 low_prepare_to_resume (tp
);
1160 ptid
= inferior_ptid
;
1163 #if __FreeBSD_version < 1200052
1164 /* When multiple threads within a process wish to report STOPPED
1165 events from wait(), the kernel picks one thread event as the
1166 thread event to report. The chosen thread event is retrieved via
1167 PT_LWPINFO by passing the process ID as the request pid. If
1168 multiple events are pending, then the subsequent wait() after
1169 resuming a process will report another STOPPED event after
1170 resuming the process to handle the next thread event and so on.
1172 A single thread event is cleared as a side effect of resuming the
1173 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1174 however, the request pid was used to select which thread's event
1175 was cleared rather than always clearing the event that was just
1176 reported. To avoid clearing the event of the wrong LWP, always
1177 pass the process ID instead of an LWP ID to PT_CONTINUE or
1180 In the case of stepping, the process ID cannot be used with
1181 PT_STEP since it would step the thread that reported an event
1182 which may not be the thread indicated by PTID. For stepping, use
1183 PT_SETSTEP to enable stepping on the desired thread before
1184 resuming the process via PT_CONTINUE instead of using
1188 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1189 perror_with_name (("ptrace (PT_SETSTEP)"));
1192 ptid
= ptid_t (ptid
.pid ());
1194 inf_ptrace_target::resume (ptid
, step
, signo
);
1197 #ifdef USE_SIGTRAP_SIGINFO
1198 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1199 trap was a breakpoint or trace trap that should be reported to the
1200 core, return true. */
1203 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1204 const struct ptrace_lwpinfo
&pl
)
1207 /* Ignore traps without valid siginfo or for signals other than
1210 FreeBSD kernels prior to r341800 can return stale siginfo for at
1211 least some events, but those events can be identified by
1212 additional flags set in pl_flags. True breakpoint and
1213 single-step traps should not have other flags set in
1215 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1218 /* Trace traps are either a single step or a hardware watchpoint or
1220 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1222 fbsd_nat_debug_printf ("trace trap for LWP %ld", ptid
.lwp ());
1226 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1228 /* Fixup PC for the software breakpoint. */
1229 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1230 struct gdbarch
*gdbarch
= regcache
->arch ();
1231 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1233 fbsd_nat_debug_printf ("sw breakpoint trap for LWP %ld", ptid
.lwp ());
1238 pc
= regcache_read_pc (regcache
);
1239 regcache_write_pc (regcache
, pc
- decr_pc
);
1248 /* Wait for the child specified by PTID to do something. Return the
1249 process ID of the child, or MINUS_ONE_PTID in case of error; store
1250 the status in *OURSTATUS. */
1253 fbsd_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1254 target_wait_flags target_options
)
1260 #ifndef PTRACE_VFORK
1261 wptid
= fbsd_next_vfork_done ();
1262 if (wptid
!= null_ptid
)
1264 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1268 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1269 if (ourstatus
->kind () == TARGET_WAITKIND_STOPPED
)
1271 struct ptrace_lwpinfo pl
;
1276 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1277 perror_with_name (("ptrace (PT_LWPINFO)"));
1279 wptid
= ptid_t (pid
, pl
.pl_lwpid
);
1283 fbsd_nat_debug_printf ("stop for LWP %u event %d flags %#x",
1284 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1285 if (pl
.pl_flags
& PL_FLAG_SI
)
1286 fbsd_nat_debug_printf ("si_signo %u si_code %u",
1287 pl
.pl_siginfo
.si_signo
,
1288 pl
.pl_siginfo
.si_code
);
1291 #ifdef PT_LWP_EVENTS
1292 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1294 /* If GDB attaches to a multi-threaded process, exiting
1295 threads might be skipped during post_attach that
1296 have not yet reported their PL_FLAG_EXITED event.
1297 Ignore EXITED events for an unknown LWP. */
1298 thread_info
*thr
= find_thread_ptid (this, wptid
);
1301 fbsd_lwp_debug_printf ("deleting thread for LWP %u",
1303 if (print_thread_events
)
1304 gdb_printf (_("[%s exited]\n"),
1305 target_pid_to_str (wptid
).c_str ());
1306 low_delete_thread (thr
);
1307 delete_thread (thr
);
1309 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1310 perror_with_name (("ptrace (PT_CONTINUE)"));
1315 /* Switch to an LWP PTID on the first stop in a new process.
1316 This is done after handling PL_FLAG_EXITED to avoid
1317 switching to an exited LWP. It is done before checking
1318 PL_FLAG_BORN in case the first stop reported after
1319 attaching to an existing process is a PL_FLAG_BORN
1321 if (in_thread_list (this, ptid_t (pid
)))
1323 fbsd_lwp_debug_printf ("using LWP %u for first thread",
1325 thread_change_ptid (this, ptid_t (pid
), wptid
);
1328 #ifdef PT_LWP_EVENTS
1329 if (pl
.pl_flags
& PL_FLAG_BORN
)
1331 /* If GDB attaches to a multi-threaded process, newborn
1332 threads might be added by fbsd_add_threads that have
1333 not yet reported their PL_FLAG_BORN event. Ignore
1334 BORN events for an already-known LWP. */
1335 if (!in_thread_list (this, wptid
))
1337 fbsd_lwp_debug_printf ("adding thread for LWP %u",
1339 add_thread (this, wptid
);
1341 ourstatus
->set_spurious ();
1347 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1349 #ifndef PTRACE_VFORK
1350 struct kinfo_proc kp
;
1352 bool is_vfork
= false;
1356 child
= pl
.pl_child_pid
;
1358 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1362 /* Make sure the other end of the fork is stopped too. */
1363 child_ptid
= fbsd_is_child_pending (child
);
1364 if (child_ptid
== null_ptid
)
1366 pid
= waitpid (child
, &status
, 0);
1368 perror_with_name (("waitpid"));
1370 gdb_assert (pid
== child
);
1372 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1373 perror_with_name (("ptrace (PT_LWPINFO)"));
1375 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1376 child_ptid
= ptid_t (child
, pl
.pl_lwpid
);
1379 /* Enable additional events on the child process. */
1380 fbsd_enable_proc_events (child_ptid
.pid ());
1382 #ifndef PTRACE_VFORK
1383 /* For vfork, the child process will have the P_PPWAIT
1385 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1387 if (kp
.ki_flag
& P_PPWAIT
)
1391 warning (_("Failed to fetch process information"));
1394 low_new_fork (wptid
, child
);
1397 ourstatus
->set_vforked (child_ptid
);
1399 ourstatus
->set_forked (child_ptid
);
1404 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1406 /* Remember that this child forked, but do not report it
1407 until the parent reports its corresponding fork
1409 fbsd_remember_child (wptid
);
1414 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1416 ourstatus
->set_vfork_done ();
1422 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1424 ourstatus
->set_execd
1425 (make_unique_xstrdup (pid_to_exec_file (pid
)));
1429 #ifdef USE_SIGTRAP_SIGINFO
1430 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1434 /* Note that PL_FLAG_SCE is set for any event reported while
1435 a thread is executing a system call in the kernel. In
1436 particular, signals that interrupt a sleep in a system
1437 call will report this flag as part of their event. Stops
1438 explicitly for system call entry and exit always use
1439 SIGTRAP, so only treat SIGTRAP events as system call
1440 entry/exit events. */
1441 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1442 && ourstatus
->sig () == SIGTRAP
)
1444 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1445 if (catch_syscall_enabled ())
1447 if (catching_syscall_number (pl
.pl_syscall_code
))
1449 if (pl
.pl_flags
& PL_FLAG_SCE
)
1450 ourstatus
->set_syscall_entry (pl
.pl_syscall_code
);
1452 ourstatus
->set_syscall_return (pl
.pl_syscall_code
);
1458 /* If the core isn't interested in this event, just
1459 continue the process explicitly and wait for another
1460 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1461 and once system call stops are enabled on a process
1462 it stops for all system call entries and exits. */
1463 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1464 perror_with_name (("ptrace (PT_CONTINUE)"));
1473 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1474 target_wait_flags target_options
)
1478 fbsd_nat_debug_printf ("[%s], [%s]", target_pid_to_str (ptid
).c_str (),
1479 target_options_to_string (target_options
).c_str ());
1481 /* Ensure any subsequent events trigger a new event in the loop. */
1483 async_file_flush ();
1485 wptid
= wait_1 (ptid
, ourstatus
, target_options
);
1487 /* If we are in async mode and found an event, there may still be
1488 another event pending. Trigger the event pipe so that that the
1489 event loop keeps polling until no event is returned. */
1491 && ((ourstatus
->kind () != TARGET_WAITKIND_IGNORE
1492 && ourstatus
->kind() != TARGET_WAITKIND_NO_RESUMED
)
1493 || ptid
!= minus_one_ptid
))
1496 fbsd_nat_debug_printf ("returning [%s], [%s]",
1497 target_pid_to_str (wptid
).c_str (),
1498 ourstatus
->to_string ().c_str ());
1502 #ifdef USE_SIGTRAP_SIGINFO
1503 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1506 fbsd_nat_target::stopped_by_sw_breakpoint ()
1508 struct ptrace_lwpinfo pl
;
1510 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1514 return (pl
.pl_flags
== PL_FLAG_SI
1515 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1516 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1519 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1523 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1529 #ifdef PROC_ASLR_CTL
1530 class maybe_disable_address_space_randomization
1533 explicit maybe_disable_address_space_randomization (bool disable_randomization
)
1535 if (disable_randomization
)
1537 if (procctl (P_PID
, getpid (), PROC_ASLR_STATUS
, &m_aslr_ctl
) == -1)
1539 warning (_("Failed to fetch current address space randomization "
1540 "status: %s"), safe_strerror (errno
));
1544 m_aslr_ctl
&= ~PROC_ASLR_ACTIVE
;
1545 if (m_aslr_ctl
== PROC_ASLR_FORCE_DISABLE
)
1548 int ctl
= PROC_ASLR_FORCE_DISABLE
;
1549 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &ctl
) == -1)
1551 warning (_("Error disabling address space randomization: %s"),
1552 safe_strerror (errno
));
1556 m_aslr_ctl_set
= true;
1560 ~maybe_disable_address_space_randomization ()
1564 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &m_aslr_ctl
) == -1)
1565 warning (_("Error restoring address space randomization: %s"),
1566 safe_strerror (errno
));
1570 DISABLE_COPY_AND_ASSIGN (maybe_disable_address_space_randomization
);
1573 bool m_aslr_ctl_set
= false;
1579 fbsd_nat_target::create_inferior (const char *exec_file
,
1580 const std::string
&allargs
,
1581 char **env
, int from_tty
)
1583 #ifdef PROC_ASLR_CTL
1584 maybe_disable_address_space_randomization restore_aslr_ctl
1585 (disable_randomization
);
1588 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1592 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1593 the ptid of the followed inferior. */
1596 fbsd_nat_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
1597 target_waitkind fork_kind
, bool follow_child
,
1600 inf_ptrace_target::follow_fork (child_inf
, child_ptid
, fork_kind
,
1601 follow_child
, detach_fork
);
1603 if (!follow_child
&& detach_fork
)
1605 pid_t child_pid
= child_ptid
.pid ();
1607 /* Breakpoints have already been detached from the child by
1610 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1611 perror_with_name (("ptrace (PT_DETACH)"));
1613 #ifndef PTRACE_VFORK
1614 if (fork_kind () == TARGET_WAITKIND_VFORKED
)
1616 /* We can't insert breakpoints until the child process has
1617 finished with the shared memory region. The parent
1618 process doesn't wait for the child process to exit or
1619 exec until after it has been resumed from the ptrace stop
1620 to report the fork. Once it has been resumed it doesn't
1621 stop again before returning to userland, so there is no
1622 reliable way to wait on the parent.
1624 We can't stay attached to the child to wait for an exec
1625 or exit because it may invoke ptrace(PT_TRACE_ME)
1626 (e.g. if the parent process is a debugger forking a new
1629 In the end, the best we can do is to make sure it runs
1630 for a little while. Hopefully it will be out of range of
1631 any breakpoints we reinsert. Usually this is only the
1632 single-step breakpoint at vfork's return point. */
1636 /* Schedule a fake VFORK_DONE event to report on the next
1638 fbsd_add_vfork_done (inferior_ptid
);
1645 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1651 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1657 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1663 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1669 /* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
1672 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1674 fbsd_enable_proc_events (pid
.pid ());
1677 /* Implement the "post_attach" target_ops method. */
1680 fbsd_nat_target::post_attach (int pid
)
1682 fbsd_enable_proc_events (pid
);
1683 fbsd_add_threads (this, pid
);
1686 /* Traced processes always stop after exec. */
1689 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1695 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1700 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1702 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1704 gdb::array_view
<const int> syscall_counts
)
1707 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1708 will catch all system call entries and exits. The system calls
1709 are filtered by GDB rather than the kernel. */
1715 fbsd_nat_target::supports_multi_process ()
1721 fbsd_nat_target::supports_disable_randomization ()
1723 #ifdef PROC_ASLR_CTL
1730 /* See fbsd-nat.h. */
1733 fbsd_nat_target::fetch_register_set (struct regcache
*regcache
, int regnum
,
1734 int fetch_op
, const struct regset
*regset
,
1735 int regbase
, void *regs
, size_t size
)
1737 const struct regcache_map_entry
*map
1738 = (const struct regcache_map_entry
*) regset
->regmap
;
1739 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1742 || (regnum
>= regbase
&& regcache_map_supplies (map
, regnum
- regbase
,
1743 regcache
->arch(), size
)))
1745 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1746 perror_with_name (_("Couldn't get registers"));
1748 regset
->supply_regset (regset
, regcache
, regnum
, regs
, size
);
1754 /* See fbsd-nat.h. */
1757 fbsd_nat_target::store_register_set (struct regcache
*regcache
, int regnum
,
1758 int fetch_op
, int store_op
,
1759 const struct regset
*regset
, int regbase
,
1760 void *regs
, size_t size
)
1762 const struct regcache_map_entry
*map
1763 = (const struct regcache_map_entry
*) regset
->regmap
;
1764 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1767 || (regnum
>= regbase
&& regcache_map_supplies (map
, regnum
- regbase
,
1768 regcache
->arch(), size
)))
1770 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1771 perror_with_name (_("Couldn't get registers"));
1773 regset
->collect_regset (regset
, regcache
, regnum
, regs
, size
);
1775 if (ptrace (store_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1776 perror_with_name (_("Couldn't write registers"));
1782 /* See fbsd-nat.h. */
1785 fbsd_nat_target::have_regset (ptid_t ptid
, int note
)
1787 pid_t pid
= get_ptrace_pid (ptid
);
1790 iov
.iov_base
= nullptr;
1792 if (ptrace (PT_GETREGSET
, pid
, (PTRACE_TYPE_ARG3
) &iov
, note
) == -1)
1797 /* See fbsd-nat.h. */
1800 fbsd_nat_target::fetch_regset (struct regcache
*regcache
, int regnum
, int note
,
1801 const struct regset
*regset
, int regbase
,
1802 void *regs
, size_t size
)
1804 const struct regcache_map_entry
*map
1805 = (const struct regcache_map_entry
*) regset
->regmap
;
1806 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1809 || (regnum
>= regbase
&& regcache_map_supplies (map
, regnum
- regbase
,
1810 regcache
->arch(), size
)))
1814 iov
.iov_base
= regs
;
1816 if (ptrace (PT_GETREGSET
, pid
, (PTRACE_TYPE_ARG3
) &iov
, note
) == -1)
1817 perror_with_name (_("Couldn't get registers"));
1819 regset
->supply_regset (regset
, regcache
, regnum
, regs
, size
);
1826 fbsd_nat_target::store_regset (struct regcache
*regcache
, int regnum
, int note
,
1827 const struct regset
*regset
, int regbase
,
1828 void *regs
, size_t size
)
1830 const struct regcache_map_entry
*map
1831 = (const struct regcache_map_entry
*) regset
->regmap
;
1832 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1835 || (regnum
>= regbase
&& regcache_map_supplies (map
, regnum
- regbase
,
1836 regcache
->arch(), size
)))
1840 iov
.iov_base
= regs
;
1842 if (ptrace (PT_GETREGSET
, pid
, (PTRACE_TYPE_ARG3
) &iov
, note
) == -1)
1843 perror_with_name (_("Couldn't get registers"));
1845 regset
->collect_regset (regset
, regcache
, regnum
, regs
, size
);
1847 if (ptrace (PT_SETREGSET
, pid
, (PTRACE_TYPE_ARG3
) &iov
, note
) == -1)
1848 perror_with_name (_("Couldn't write registers"));
1854 /* See fbsd-nat.h. */
1857 fbsd_nat_get_siginfo (ptid_t ptid
, siginfo_t
*siginfo
)
1859 struct ptrace_lwpinfo pl
;
1860 pid_t pid
= get_ptrace_pid (ptid
);
1862 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1864 if (!(pl
.pl_flags
& PL_FLAG_SI
))
1866 *siginfo
= pl
.pl_siginfo
;
1870 void _initialize_fbsd_nat ();
1872 _initialize_fbsd_nat ()
1874 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1875 &debug_fbsd_lwp
, _("\
1876 Set debugging of FreeBSD lwp module."), _("\
1877 Show debugging of FreeBSD lwp module."), _("\
1878 Enables printf debugging output."),
1880 &show_fbsd_lwp_debug
,
1881 &setdebuglist
, &showdebuglist
);
1882 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1883 &debug_fbsd_nat
, _("\
1884 Set debugging of FreeBSD native target."), _("\
1885 Show debugging of FreeBSD native target."), _("\
1886 Enables printf debugging output."),
1888 &show_fbsd_nat_debug
,
1889 &setdebuglist
, &showdebuglist
);
1891 /* Install a SIGCHLD handler. */
1892 signal (SIGCHLD
, sigchld_handler
);