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"
52 /* Return the name of a file that can be opened to get the symbols for
53 the child process identified by PID. */
56 fbsd_nat_target::pid_to_exec_file (int pid
)
58 static char buf
[PATH_MAX
];
64 mib
[2] = KERN_PROC_PATHNAME
;
67 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
68 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
69 for processes without an associated executable such as kernel
71 return buflen
== 0 ? NULL
: buf
;
76 /* Iterate over all the memory regions in the current inferior,
77 calling FUNC for each memory region. DATA is passed as the last
81 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
84 pid_t pid
= inferior_ptid
.pid ();
85 struct kinfo_vmentry
*kve
;
89 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
90 vmentl (kinfo_getvmmap (pid
, &nitems
));
92 perror_with_name (_("Couldn't fetch VM map entries."));
94 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
96 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
97 if (!(kve
->kve_protection
& KVME_PROT_READ
)
98 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
101 /* Skip segments with an invalid type. */
102 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
103 && kve
->kve_type
!= KVME_TYPE_VNODE
104 && kve
->kve_type
!= KVME_TYPE_SWAP
105 && kve
->kve_type
!= KVME_TYPE_PHYS
)
108 size
= kve
->kve_end
- kve
->kve_start
;
111 printf_filtered ("Save segment, %ld bytes at %s (%c%c%c)\n",
113 paddress (target_gdbarch (), kve
->kve_start
),
114 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
115 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
116 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
119 /* Invoke the callback function to create the corefile segment.
120 Pass MODIFIED as true, we do not know the real modification state. */
121 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
122 kve
->kve_protection
& KVME_PROT_WRITE
,
123 kve
->kve_protection
& KVME_PROT_EXEC
, 1, data
);
128 /* Fetch the command line for a running process. */
130 static gdb::unique_xmalloc_ptr
<char>
131 fbsd_fetch_cmdline (pid_t pid
)
139 mib
[2] = KERN_PROC_ARGS
;
141 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
147 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
148 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
151 /* Join the arguments with spaces to form a single string. */
152 char *cp
= cmdline
.get ();
153 for (size_t i
= 0; i
< len
- 1; i
++)
161 /* Fetch the external variant of the kernel's internal process
162 structure for the process PID into KP. */
165 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
173 mib
[2] = KERN_PROC_PID
;
175 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
178 /* Implement the "info_proc" target_ops method. */
181 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
183 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
185 struct kinfo_proc kp
;
187 bool do_cmdline
= false;
190 bool do_files
= false;
191 bool do_mappings
= false;
192 bool do_status
= false;
229 error (_("Not supported on this target."));
232 gdb_argv
built_argv (args
);
233 if (built_argv
.count () == 0)
235 pid
= inferior_ptid
.pid ();
237 error (_("No current process: you must name one."));
239 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
240 pid
= strtol (built_argv
[0], NULL
, 10);
242 error (_("Invalid arguments."));
244 printf_filtered (_("process %d\n"), pid
);
245 if (do_cwd
|| do_exe
|| do_files
)
246 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
250 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
251 if (cmdline
!= nullptr)
252 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
254 warning (_("unable to fetch command line"));
258 const char *cwd
= NULL
;
259 struct kinfo_file
*kf
= fdtbl
.get ();
260 for (int i
= 0; i
< nfd
; i
++, kf
++)
262 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
269 printf_filtered ("cwd = '%s'\n", cwd
);
271 warning (_("unable to fetch current working directory"));
275 const char *exe
= NULL
;
276 struct kinfo_file
*kf
= fdtbl
.get ();
277 for (int i
= 0; i
< nfd
; i
++, kf
++)
279 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
286 exe
= pid_to_exec_file (pid
);
288 printf_filtered ("exe = '%s'\n", exe
);
290 warning (_("unable to fetch executable path name"));
294 struct kinfo_file
*kf
= fdtbl
.get ();
298 fbsd_info_proc_files_header ();
299 for (int i
= 0; i
< nfd
; i
++, kf
++)
300 fbsd_info_proc_files_entry (kf
->kf_type
, kf
->kf_fd
, kf
->kf_flags
,
301 kf
->kf_offset
, kf
->kf_vnode_type
,
302 kf
->kf_sock_domain
, kf
->kf_sock_type
,
303 kf
->kf_sock_protocol
, &kf
->kf_sa_local
,
304 &kf
->kf_sa_peer
, kf
->kf_path
);
307 warning (_("unable to fetch list of open files"));
312 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
313 vmentl (kinfo_getvmmap (pid
, &nvment
));
315 if (vmentl
!= nullptr)
317 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
318 fbsd_info_proc_mappings_header (addr_bit
);
320 struct kinfo_vmentry
*kve
= vmentl
.get ();
321 for (int i
= 0; i
< nvment
; i
++, kve
++)
322 fbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
323 kve
->kve_end
, kve
->kve_offset
,
324 kve
->kve_flags
, kve
->kve_protection
,
328 warning (_("unable to fetch virtual memory map"));
332 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
333 warning (_("Failed to fetch process information"));
339 printf_filtered ("Name: %s\n", kp
.ki_comm
);
346 state
= "R (running)";
349 state
= "T (stopped)";
352 state
= "Z (zombie)";
355 state
= "S (sleeping)";
358 state
= "W (interrupt wait)";
361 state
= "L (blocked on lock)";
364 state
= "? (unknown)";
367 printf_filtered ("State: %s\n", state
);
368 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
369 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
370 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
371 printf_filtered ("TTY: %s\n", pulongest (kp
.ki_tdev
));
372 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
373 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
374 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
375 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
376 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
377 printf_filtered ("Groups: ");
378 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
379 printf_filtered ("%d ", kp
.ki_groups
[i
]);
380 printf_filtered ("\n");
381 printf_filtered ("Minor faults (no memory page): %ld\n",
382 kp
.ki_rusage
.ru_minflt
);
383 printf_filtered ("Minor faults, children: %ld\n",
384 kp
.ki_rusage_ch
.ru_minflt
);
385 printf_filtered ("Major faults (memory page faults): %ld\n",
386 kp
.ki_rusage
.ru_majflt
);
387 printf_filtered ("Major faults, children: %ld\n",
388 kp
.ki_rusage_ch
.ru_majflt
);
389 printf_filtered ("utime: %s.%06ld\n",
390 plongest (kp
.ki_rusage
.ru_utime
.tv_sec
),
391 kp
.ki_rusage
.ru_utime
.tv_usec
);
392 printf_filtered ("stime: %s.%06ld\n",
393 plongest (kp
.ki_rusage
.ru_stime
.tv_sec
),
394 kp
.ki_rusage
.ru_stime
.tv_usec
);
395 printf_filtered ("utime, children: %s.%06ld\n",
396 plongest (kp
.ki_rusage_ch
.ru_utime
.tv_sec
),
397 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
398 printf_filtered ("stime, children: %s.%06ld\n",
399 plongest (kp
.ki_rusage_ch
.ru_stime
.tv_sec
),
400 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
401 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
402 printf_filtered ("Start time: %s.%06ld\n",
403 plongest (kp
.ki_start
.tv_sec
),
404 kp
.ki_start
.tv_usec
);
405 pgtok
= getpagesize () / 1024;
406 printf_filtered ("Virtual memory size: %s kB\n",
407 pulongest (kp
.ki_size
/ 1024));
408 printf_filtered ("Data size: %s kB\n",
409 pulongest (kp
.ki_dsize
* pgtok
));
410 printf_filtered ("Stack size: %s kB\n",
411 pulongest (kp
.ki_ssize
* pgtok
));
412 printf_filtered ("Text size: %s kB\n",
413 pulongest (kp
.ki_tsize
* pgtok
));
414 printf_filtered ("Resident set size: %s kB\n",
415 pulongest (kp
.ki_rssize
* pgtok
));
416 printf_filtered ("Maximum RSS: %s kB\n",
417 pulongest (kp
.ki_rusage
.ru_maxrss
));
418 printf_filtered ("Pending Signals: ");
419 for (int i
= 0; i
< _SIG_WORDS
; i
++)
420 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
421 printf_filtered ("\n");
422 printf_filtered ("Ignored Signals: ");
423 for (int i
= 0; i
< _SIG_WORDS
; i
++)
424 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
425 printf_filtered ("\n");
426 printf_filtered ("Caught Signals: ");
427 for (int i
= 0; i
< _SIG_WORDS
; i
++)
428 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
429 printf_filtered ("\n");
436 /* Return the size of siginfo for the current inferior. */
444 /* This structure matches the naming and layout of `siginfo_t' in
445 <sys/signal.h>. In particular, the `si_foo' macros defined in that
446 header can be used with both types to copy fields in the `_reason'
458 union sigval32 si_value
;
491 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
493 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
494 if (gdbarch_long_bit (gdbarch
) == 32)
495 return sizeof (struct siginfo32
);
497 return sizeof (siginfo_t
);
500 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
501 that FreeBSD doesn't support writing to $_siginfo, so this only
502 needs to convert one way. */
505 fbsd_convert_siginfo (siginfo_t
*si
)
508 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
510 /* Is the inferior 32-bit? If not, nothing to do. */
511 if (gdbarch_long_bit (gdbarch
) != 32)
514 struct siginfo32 si32
;
516 si32
.si_signo
= si
->si_signo
;
517 si32
.si_errno
= si
->si_errno
;
518 si32
.si_code
= si
->si_code
;
519 si32
.si_pid
= si
->si_pid
;
520 si32
.si_uid
= si
->si_uid
;
521 si32
.si_status
= si
->si_status
;
522 si32
.si_addr
= (uintptr_t) si
->si_addr
;
524 /* If sival_ptr is being used instead of sival_int on a big-endian
525 platform, then sival_int will be zero since it holds the upper
526 32-bits of the pointer value. */
527 #if _BYTE_ORDER == _BIG_ENDIAN
528 if (si
->si_value
.sival_int
== 0)
529 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
531 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
533 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
536 /* Always copy the spare fields and then possibly overwrite them for
537 signal-specific or code-specific fields. */
538 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
539 for (int i
= 0; i
< 7; i
++)
540 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
541 switch (si
->si_signo
) {
546 si32
.si_trapno
= si
->si_trapno
;
549 switch (si
->si_code
) {
551 si32
.si_timerid
= si
->si_timerid
;
552 si32
.si_overrun
= si
->si_overrun
;
555 si32
.si_mqd
= si
->si_mqd
;
559 memcpy(si
, &si32
, sizeof (si32
));
563 /* Implement the "xfer_partial" target_ops method. */
565 enum target_xfer_status
566 fbsd_nat_target::xfer_partial (enum target_object object
,
567 const char *annex
, gdb_byte
*readbuf
,
568 const gdb_byte
*writebuf
,
569 ULONGEST offset
, ULONGEST len
,
570 ULONGEST
*xfered_len
)
572 pid_t pid
= inferior_ptid
.pid ();
576 case TARGET_OBJECT_SIGNAL_INFO
:
578 struct ptrace_lwpinfo pl
;
581 /* FreeBSD doesn't support writing to $_siginfo. */
582 if (writebuf
!= NULL
)
583 return TARGET_XFER_E_IO
;
585 if (inferior_ptid
.lwp_p ())
586 pid
= inferior_ptid
.lwp ();
588 siginfo_size
= fbsd_siginfo_size ();
589 if (offset
> siginfo_size
)
590 return TARGET_XFER_E_IO
;
592 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
593 return TARGET_XFER_E_IO
;
595 if (!(pl
.pl_flags
& PL_FLAG_SI
))
596 return TARGET_XFER_E_IO
;
598 fbsd_convert_siginfo (&pl
.pl_siginfo
);
599 if (offset
+ len
> siginfo_size
)
600 len
= siginfo_size
- offset
;
602 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
604 return TARGET_XFER_OK
;
606 #ifdef KERN_PROC_AUXV
607 case TARGET_OBJECT_AUXV
:
609 gdb::byte_vector buf_storage
;
614 if (writebuf
!= NULL
)
615 return TARGET_XFER_E_IO
;
618 mib
[2] = KERN_PROC_AUXV
;
627 buflen
= offset
+ len
;
628 buf_storage
.resize (buflen
);
629 buf
= buf_storage
.data ();
631 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
638 memcpy (readbuf
, buf
+ offset
, buflen
);
643 *xfered_len
= buflen
;
644 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
646 return TARGET_XFER_E_IO
;
649 #if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
650 case TARGET_OBJECT_FREEBSD_VMMAP
:
651 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
653 gdb::byte_vector buf_storage
;
659 uint32_t struct_size
;
662 case TARGET_OBJECT_FREEBSD_VMMAP
:
663 proc_target
= KERN_PROC_VMMAP
;
664 struct_size
= sizeof (struct kinfo_vmentry
);
666 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
667 proc_target
= KERN_PROC_PS_STRINGS
;
668 struct_size
= sizeof (void *);
672 if (writebuf
!= NULL
)
673 return TARGET_XFER_E_IO
;
677 mib
[2] = proc_target
;
680 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
681 return TARGET_XFER_E_IO
;
682 buflen
+= sizeof (struct_size
);
684 if (offset
>= buflen
)
687 return TARGET_XFER_EOF
;
690 buf_storage
.resize (buflen
);
691 buf
= buf_storage
.data ();
693 memcpy (buf
, &struct_size
, sizeof (struct_size
));
694 buflen
-= sizeof (struct_size
);
695 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
696 return TARGET_XFER_E_IO
;
697 buflen
+= sizeof (struct_size
);
699 if (buflen
- offset
< len
)
700 len
= buflen
- offset
;
701 memcpy (readbuf
, buf
+ offset
, len
);
703 return TARGET_XFER_OK
;
707 return inf_ptrace_target::xfer_partial (object
, annex
,
708 readbuf
, writebuf
, offset
,
713 static bool debug_fbsd_lwp
;
714 static bool debug_fbsd_nat
;
717 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
718 struct cmd_list_element
*c
, const char *value
)
720 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
724 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
725 struct cmd_list_element
*c
, const char *value
)
727 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
731 #define fbsd_lwp_debug_printf(fmt, ...) \
732 debug_prefixed_printf_cond (debug_fbsd_lwp, "fbsd-lwp", fmt, ##__VA_ARGS__)
734 #define fbsd_nat_debug_printf(fmt, ...) \
735 debug_prefixed_printf_cond (debug_fbsd_nat, "fbsd-nat", fmt, ##__VA_ARGS__)
739 FreeBSD's first thread support was via a "reentrant" version of libc
740 (libc_r) that first shipped in 2.2.7. This library multiplexed all
741 of the threads in a process onto a single kernel thread. This
742 library was supported via the bsd-uthread target.
744 FreeBSD 5.1 introduced two new threading libraries that made use of
745 multiple kernel threads. The first (libkse) scheduled M user
746 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
747 bound each user thread to a dedicated kernel thread. libkse shipped
748 as the default threading library (libpthread).
750 FreeBSD 5.3 added a libthread_db to abstract the interface across
751 the various thread libraries (libc_r, libkse, and libthr).
753 FreeBSD 7.0 switched the default threading library from from libkse
754 to libpthread and removed libc_r.
756 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
757 only threading library supported by 8.0 and later is libthr which
758 ties each user thread directly to an LWP. To simplify the
759 implementation, this target only supports LWP-backed threads using
760 ptrace directly rather than libthread_db.
762 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
765 /* Return true if PTID is still active in the inferior. */
768 fbsd_nat_target::thread_alive (ptid_t ptid
)
772 struct ptrace_lwpinfo pl
;
774 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
777 #ifdef PL_FLAG_EXITED
778 if (pl
.pl_flags
& PL_FLAG_EXITED
)
786 /* Convert PTID to a string. */
789 fbsd_nat_target::pid_to_str (ptid_t ptid
)
796 int pid
= ptid
.pid ();
798 return string_printf ("LWP %d of process %d", lwp
, pid
);
801 return normal_pid_to_str (ptid
);
804 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
805 /* Return the name assigned to a thread by an application. Returns
806 the string in a static buffer. */
809 fbsd_nat_target::thread_name (struct thread_info
*thr
)
811 struct ptrace_lwpinfo pl
;
812 struct kinfo_proc kp
;
813 int pid
= thr
->ptid
.pid ();
814 long lwp
= thr
->ptid
.lwp ();
815 static char buf
[sizeof pl
.pl_tdname
+ 1];
817 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
818 if a name has not been set explicitly. Return a NULL name in
820 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
822 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
824 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
826 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
831 /* Enable additional event reporting on new processes.
833 To catch fork events, PTRACE_FORK is set on every traced process
834 to enable stops on returns from fork or vfork. Note that both the
835 parent and child will always stop, even if system call stops are
838 To catch LWP events, PTRACE_EVENTS is set on every traced process.
839 This enables stops on the birth for new LWPs (excluding the "main" LWP)
840 and the death of LWPs (excluding the last LWP in a process). Note
841 that unlike fork events, the LWP that creates a new LWP does not
845 fbsd_enable_proc_events (pid_t pid
)
847 #ifdef PT_GET_EVENT_MASK
850 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
851 sizeof (events
)) == -1)
852 perror_with_name (("ptrace (PT_GET_EVENT_MASK)"));
853 events
|= PTRACE_FORK
| PTRACE_LWP
;
855 events
|= PTRACE_VFORK
;
857 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
858 sizeof (events
)) == -1)
859 perror_with_name (("ptrace (PT_SET_EVENT_MASK)"));
862 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
863 perror_with_name (("ptrace (PT_FOLLOW_FORK)"));
866 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
867 perror_with_name (("ptrace (PT_LWP_EVENTS)"));
872 /* Add threads for any new LWPs in a process.
874 When LWP events are used, this function is only used to detect existing
875 threads when attaching to a process. On older systems, this function is
876 called to discover new threads each time the thread list is updated. */
879 fbsd_add_threads (fbsd_nat_target
*target
, pid_t pid
)
883 gdb_assert (!in_thread_list (target
, ptid_t (pid
)));
884 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
886 perror_with_name (("ptrace (PT_GETNUMLWPS)"));
888 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
890 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
892 perror_with_name (("ptrace (PT_GETLWPLIST)"));
894 for (i
= 0; i
< nlwps
; i
++)
896 ptid_t ptid
= ptid_t (pid
, lwps
[i
]);
898 if (!in_thread_list (target
, ptid
))
901 struct ptrace_lwpinfo pl
;
903 /* Don't add exited threads. Note that this is only called
904 when attaching to a multi-threaded process. */
905 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
906 perror_with_name (("ptrace (PT_LWPINFO)"));
907 if (pl
.pl_flags
& PL_FLAG_EXITED
)
910 fbsd_lwp_debug_printf ("adding thread for LWP %u", lwps
[i
]);
911 add_thread (target
, ptid
);
916 /* Implement the "update_thread_list" target_ops method. */
919 fbsd_nat_target::update_thread_list ()
922 /* With support for thread events, threads are added/deleted from the
923 list as events are reported, so just try deleting exited threads. */
924 delete_exited_threads ();
928 fbsd_add_threads (this, inferior_ptid
.pid ());
932 /* Async mode support. */
934 /* Implement the "can_async_p" target method. */
937 fbsd_nat_target::can_async_p ()
939 /* This flag should be checked in the common target.c code. */
940 gdb_assert (target_async_permitted
);
942 /* Otherwise, this targets is always able to support async mode. */
946 /* SIGCHLD handler notifies the event-loop in async mode. */
949 sigchld_handler (int signo
)
951 int old_errno
= errno
;
953 fbsd_nat_target::async_file_mark_if_open ();
958 /* Callback registered with the target events file descriptor. */
961 handle_target_event (int error
, gdb_client_data client_data
)
963 inferior_event_handler (INF_REG_EVENT
);
966 /* Implement the "async" target method. */
969 fbsd_nat_target::async (int enable
)
971 if ((enable
!= 0) == is_async_p ())
974 /* Block SIGCHILD while we create/destroy the pipe, as the handler
976 gdb::block_signals blocker
;
980 if (!async_file_open ())
981 internal_error (__FILE__
, __LINE__
, "failed to create event pipe.");
983 add_file_handler (async_wait_fd (), handle_target_event
, NULL
, "fbsd-nat");
985 /* Trigger a poll in case there are pending events to
991 delete_file_handler (async_wait_fd ());
998 To catch fork events, PT_FOLLOW_FORK is set on every traced process
999 to enable stops on returns from fork or vfork. Note that both the
1000 parent and child will always stop, even if system call stops are not
1003 After a fork, both the child and parent process will stop and report
1004 an event. However, there is no guarantee of order. If the parent
1005 reports its stop first, then fbsd_wait explicitly waits for the new
1006 child before returning. If the child reports its stop first, then
1007 the event is saved on a list and ignored until the parent's stop is
1008 reported. fbsd_wait could have been changed to fetch the parent PID
1009 of the new child and used that to wait for the parent explicitly.
1010 However, if two threads in the parent fork at the same time, then
1011 the wait on the parent might return the "wrong" fork event.
1013 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
1014 the new child process. This flag could be inferred by treating any
1015 events for an unknown pid as a new child.
1017 In addition, the initial version of PT_FOLLOW_FORK did not report a
1018 stop event for the parent process of a vfork until after the child
1019 process executed a new program or exited. The kernel was changed to
1020 defer the wait for exit or exec of the child until after posting the
1021 stop event shortly after the change to introduce PL_FLAG_CHILD.
1022 This could be worked around by reporting a vfork event when the
1023 child event posted and ignoring the subsequent event from the
1026 This implementation requires both of these fixes for simplicity's
1027 sake. FreeBSD versions newer than 9.1 contain both fixes.
1030 static std::list
<ptid_t
> fbsd_pending_children
;
1032 /* Record a new child process event that is reported before the
1033 corresponding fork event in the parent. */
1036 fbsd_remember_child (ptid_t pid
)
1038 fbsd_pending_children
.push_front (pid
);
1041 /* Check for a previously-recorded new child process event for PID.
1042 If one is found, remove it from the list and return the PTID. */
1045 fbsd_is_child_pending (pid_t pid
)
1047 for (auto it
= fbsd_pending_children
.begin ();
1048 it
!= fbsd_pending_children
.end (); it
++)
1049 if (it
->pid () == pid
)
1052 fbsd_pending_children
.erase (it
);
1058 #ifndef PTRACE_VFORK
1059 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
1061 /* Record a pending vfork done event. */
1064 fbsd_add_vfork_done (ptid_t pid
)
1066 fbsd_pending_vfork_done
.push_front (pid
);
1068 /* If we're in async mode, need to tell the event loop there's
1069 something here to process. */
1070 if (target_is_async_p ())
1074 /* Check for a pending vfork done event for a specific PID. */
1077 fbsd_is_vfork_done_pending (pid_t pid
)
1079 for (auto it
= fbsd_pending_vfork_done
.begin ();
1080 it
!= fbsd_pending_vfork_done
.end (); it
++)
1081 if (it
->pid () == pid
)
1086 /* Check for a pending vfork done event. If one is found, remove it
1087 from the list and return the PTID. */
1090 fbsd_next_vfork_done (void)
1092 if (!fbsd_pending_vfork_done
.empty ())
1094 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1095 fbsd_pending_vfork_done
.pop_front ();
1103 /* Implement the "resume" target_ops method. */
1106 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1108 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1111 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1112 if (minus_one_ptid
== ptid
)
1113 pid
= inferior_ptid
.pid ();
1116 if (fbsd_is_vfork_done_pending (pid
))
1120 fbsd_nat_debug_printf ("[%s], step %d, signo %d (%s)",
1121 target_pid_to_str (ptid
).c_str (), step
, signo
,
1122 gdb_signal_to_name (signo
));
1125 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1126 inferior
*inf
= find_inferior_ptid (this, ptid
);
1128 for (thread_info
*tp
: inf
->non_exited_threads ())
1132 if (tp
->ptid
.lwp () == ptid
.lwp ())
1133 request
= PT_RESUME
;
1135 request
= PT_SUSPEND
;
1137 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1138 perror_with_name (request
== PT_RESUME
?
1139 ("ptrace (PT_RESUME)") :
1140 ("ptrace (PT_SUSPEND)"));
1145 /* If ptid is a wildcard, resume all matching threads (they won't run
1146 until the process is continued however). */
1147 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
1148 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1149 perror_with_name (("ptrace (PT_RESUME)"));
1150 ptid
= inferior_ptid
;
1153 #if __FreeBSD_version < 1200052
1154 /* When multiple threads within a process wish to report STOPPED
1155 events from wait(), the kernel picks one thread event as the
1156 thread event to report. The chosen thread event is retrieved via
1157 PT_LWPINFO by passing the process ID as the request pid. If
1158 multiple events are pending, then the subsequent wait() after
1159 resuming a process will report another STOPPED event after
1160 resuming the process to handle the next thread event and so on.
1162 A single thread event is cleared as a side effect of resuming the
1163 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1164 however, the request pid was used to select which thread's event
1165 was cleared rather than always clearing the event that was just
1166 reported. To avoid clearing the event of the wrong LWP, always
1167 pass the process ID instead of an LWP ID to PT_CONTINUE or
1170 In the case of stepping, the process ID cannot be used with
1171 PT_STEP since it would step the thread that reported an event
1172 which may not be the thread indicated by PTID. For stepping, use
1173 PT_SETSTEP to enable stepping on the desired thread before
1174 resuming the process via PT_CONTINUE instead of using
1178 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1179 perror_with_name (("ptrace (PT_SETSTEP)"));
1182 ptid
= ptid_t (ptid
.pid ());
1184 inf_ptrace_target::resume (ptid
, step
, signo
);
1187 #ifdef USE_SIGTRAP_SIGINFO
1188 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1189 trap was a breakpoint or trace trap that should be reported to the
1190 core, return true. */
1193 fbsd_handle_debug_trap (fbsd_nat_target
*target
, ptid_t ptid
,
1194 const struct ptrace_lwpinfo
&pl
)
1197 /* Ignore traps without valid siginfo or for signals other than
1200 FreeBSD kernels prior to r341800 can return stale siginfo for at
1201 least some events, but those events can be identified by
1202 additional flags set in pl_flags. True breakpoint and
1203 single-step traps should not have other flags set in
1205 if (pl
.pl_flags
!= PL_FLAG_SI
|| pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1208 /* Trace traps are either a single step or a hardware watchpoint or
1210 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1212 fbsd_nat_debug_printf ("trace trap for LWP %ld", ptid
.lwp ());
1216 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1218 /* Fixup PC for the software breakpoint. */
1219 struct regcache
*regcache
= get_thread_regcache (target
, ptid
);
1220 struct gdbarch
*gdbarch
= regcache
->arch ();
1221 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1223 fbsd_nat_debug_printf ("sw breakpoint trap for LWP %ld", ptid
.lwp ());
1228 pc
= regcache_read_pc (regcache
);
1229 regcache_write_pc (regcache
, pc
- decr_pc
);
1238 /* Wait for the child specified by PTID to do something. Return the
1239 process ID of the child, or MINUS_ONE_PTID in case of error; store
1240 the status in *OURSTATUS. */
1243 fbsd_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1244 target_wait_flags target_options
)
1250 #ifndef PTRACE_VFORK
1251 wptid
= fbsd_next_vfork_done ();
1252 if (wptid
!= null_ptid
)
1254 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1258 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1259 if (ourstatus
->kind () == TARGET_WAITKIND_STOPPED
)
1261 struct ptrace_lwpinfo pl
;
1266 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1267 perror_with_name (("ptrace (PT_LWPINFO)"));
1269 wptid
= ptid_t (pid
, pl
.pl_lwpid
);
1273 fbsd_nat_debug_printf ("stop for LWP %u event %d flags %#x",
1274 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1275 if (pl
.pl_flags
& PL_FLAG_SI
)
1276 fbsd_nat_debug_printf ("si_signo %u si_code %u",
1277 pl
.pl_siginfo
.si_signo
,
1278 pl
.pl_siginfo
.si_code
);
1281 #ifdef PT_LWP_EVENTS
1282 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1284 /* If GDB attaches to a multi-threaded process, exiting
1285 threads might be skipped during post_attach that
1286 have not yet reported their PL_FLAG_EXITED event.
1287 Ignore EXITED events for an unknown LWP. */
1288 thread_info
*thr
= find_thread_ptid (this, wptid
);
1291 fbsd_lwp_debug_printf ("deleting thread for LWP %u",
1293 if (print_thread_events
)
1294 printf_unfiltered (_("[%s exited]\n"),
1295 target_pid_to_str (wptid
).c_str ());
1296 low_delete_thread (thr
);
1297 delete_thread (thr
);
1299 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1300 perror_with_name (("ptrace (PT_CONTINUE)"));
1305 /* Switch to an LWP PTID on the first stop in a new process.
1306 This is done after handling PL_FLAG_EXITED to avoid
1307 switching to an exited LWP. It is done before checking
1308 PL_FLAG_BORN in case the first stop reported after
1309 attaching to an existing process is a PL_FLAG_BORN
1311 if (in_thread_list (this, ptid_t (pid
)))
1313 fbsd_lwp_debug_printf ("using LWP %u for first thread",
1315 thread_change_ptid (this, ptid_t (pid
), wptid
);
1318 #ifdef PT_LWP_EVENTS
1319 if (pl
.pl_flags
& PL_FLAG_BORN
)
1321 /* If GDB attaches to a multi-threaded process, newborn
1322 threads might be added by fbsd_add_threads that have
1323 not yet reported their PL_FLAG_BORN event. Ignore
1324 BORN events for an already-known LWP. */
1325 if (!in_thread_list (this, wptid
))
1327 fbsd_lwp_debug_printf ("adding thread for LWP %u",
1329 add_thread (this, wptid
);
1331 ourstatus
->set_spurious ();
1337 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1339 #ifndef PTRACE_VFORK
1340 struct kinfo_proc kp
;
1342 bool is_vfork
= false;
1346 child
= pl
.pl_child_pid
;
1348 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1352 /* Make sure the other end of the fork is stopped too. */
1353 child_ptid
= fbsd_is_child_pending (child
);
1354 if (child_ptid
== null_ptid
)
1356 pid
= waitpid (child
, &status
, 0);
1358 perror_with_name (("waitpid"));
1360 gdb_assert (pid
== child
);
1362 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1363 perror_with_name (("ptrace (PT_LWPINFO)"));
1365 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1366 child_ptid
= ptid_t (child
, pl
.pl_lwpid
);
1369 /* Enable additional events on the child process. */
1370 fbsd_enable_proc_events (child_ptid
.pid ());
1372 #ifndef PTRACE_VFORK
1373 /* For vfork, the child process will have the P_PPWAIT
1375 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1377 if (kp
.ki_flag
& P_PPWAIT
)
1381 warning (_("Failed to fetch process information"));
1384 low_new_fork (wptid
, child
);
1387 ourstatus
->set_vforked (child_ptid
);
1389 ourstatus
->set_forked (child_ptid
);
1394 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1396 /* Remember that this child forked, but do not report it
1397 until the parent reports its corresponding fork
1399 fbsd_remember_child (wptid
);
1404 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1406 ourstatus
->set_vfork_done ();
1412 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1414 ourstatus
->set_execd
1415 (make_unique_xstrdup (pid_to_exec_file (pid
)));
1419 #ifdef USE_SIGTRAP_SIGINFO
1420 if (fbsd_handle_debug_trap (this, wptid
, pl
))
1424 /* Note that PL_FLAG_SCE is set for any event reported while
1425 a thread is executing a system call in the kernel. In
1426 particular, signals that interrupt a sleep in a system
1427 call will report this flag as part of their event. Stops
1428 explicitly for system call entry and exit always use
1429 SIGTRAP, so only treat SIGTRAP events as system call
1430 entry/exit events. */
1431 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1432 && ourstatus
->sig () == SIGTRAP
)
1434 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1435 if (catch_syscall_enabled ())
1437 if (catching_syscall_number (pl
.pl_syscall_code
))
1439 if (pl
.pl_flags
& PL_FLAG_SCE
)
1440 ourstatus
->set_syscall_entry (pl
.pl_syscall_code
);
1442 ourstatus
->set_syscall_return (pl
.pl_syscall_code
);
1448 /* If the core isn't interested in this event, just
1449 continue the process explicitly and wait for another
1450 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1451 and once system call stops are enabled on a process
1452 it stops for all system call entries and exits. */
1453 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1454 perror_with_name (("ptrace (PT_CONTINUE)"));
1463 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1464 target_wait_flags target_options
)
1468 fbsd_nat_debug_printf ("[%s], [%s]", target_pid_to_str (ptid
).c_str (),
1469 target_options_to_string (target_options
).c_str ());
1471 /* Ensure any subsequent events trigger a new event in the loop. */
1473 async_file_flush ();
1475 wptid
= wait_1 (ptid
, ourstatus
, target_options
);
1477 /* If we are in async mode and found an event, there may still be
1478 another event pending. Trigger the event pipe so that that the
1479 event loop keeps polling until no event is returned. */
1481 && ((ourstatus
->kind () != TARGET_WAITKIND_IGNORE
1482 && ourstatus
->kind() != TARGET_WAITKIND_NO_RESUMED
)
1483 || ptid
!= minus_one_ptid
))
1486 fbsd_nat_debug_printf ("returning [%s], [%s]",
1487 target_pid_to_str (wptid
).c_str (),
1488 ourstatus
->to_string ().c_str ());
1492 #ifdef USE_SIGTRAP_SIGINFO
1493 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1496 fbsd_nat_target::stopped_by_sw_breakpoint ()
1498 struct ptrace_lwpinfo pl
;
1500 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1504 return (pl
.pl_flags
== PL_FLAG_SI
1505 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1506 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1509 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1513 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1519 #ifdef PROC_ASLR_CTL
1520 class maybe_disable_address_space_randomization
1523 explicit maybe_disable_address_space_randomization (bool disable_randomization
)
1525 if (disable_randomization
)
1527 if (procctl (P_PID
, getpid (), PROC_ASLR_STATUS
, &m_aslr_ctl
) == -1)
1529 warning (_("Failed to fetch current address space randomization "
1530 "status: %s"), safe_strerror (errno
));
1534 m_aslr_ctl
&= ~PROC_ASLR_ACTIVE
;
1535 if (m_aslr_ctl
== PROC_ASLR_FORCE_DISABLE
)
1538 int ctl
= PROC_ASLR_FORCE_DISABLE
;
1539 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &ctl
) == -1)
1541 warning (_("Error disabling address space randomization: %s"),
1542 safe_strerror (errno
));
1546 m_aslr_ctl_set
= true;
1550 ~maybe_disable_address_space_randomization ()
1554 if (procctl (P_PID
, getpid (), PROC_ASLR_CTL
, &m_aslr_ctl
) == -1)
1555 warning (_("Error restoring address space randomization: %s"),
1556 safe_strerror (errno
));
1560 DISABLE_COPY_AND_ASSIGN (maybe_disable_address_space_randomization
);
1563 bool m_aslr_ctl_set
= false;
1569 fbsd_nat_target::create_inferior (const char *exec_file
,
1570 const std::string
&allargs
,
1571 char **env
, int from_tty
)
1573 #ifdef PROC_ASLR_CTL
1574 maybe_disable_address_space_randomization restore_aslr_ctl
1575 (disable_randomization
);
1578 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1582 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1583 the ptid of the followed inferior. */
1586 fbsd_nat_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
1587 target_waitkind fork_kind
, bool follow_child
,
1590 inf_ptrace_target::follow_fork (child_inf
, child_ptid
, fork_kind
,
1591 follow_child
, detach_fork
);
1593 if (!follow_child
&& detach_fork
)
1595 pid_t child_pid
= child_ptid
.pid ();
1597 /* Breakpoints have already been detached from the child by
1600 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1601 perror_with_name (("ptrace (PT_DETACH)"));
1603 #ifndef PTRACE_VFORK
1604 if (fork_kind () == TARGET_WAITKIND_VFORKED
)
1606 /* We can't insert breakpoints until the child process has
1607 finished with the shared memory region. The parent
1608 process doesn't wait for the child process to exit or
1609 exec until after it has been resumed from the ptrace stop
1610 to report the fork. Once it has been resumed it doesn't
1611 stop again before returning to userland, so there is no
1612 reliable way to wait on the parent.
1614 We can't stay attached to the child to wait for an exec
1615 or exit because it may invoke ptrace(PT_TRACE_ME)
1616 (e.g. if the parent process is a debugger forking a new
1619 In the end, the best we can do is to make sure it runs
1620 for a little while. Hopefully it will be out of range of
1621 any breakpoints we reinsert. Usually this is only the
1622 single-step breakpoint at vfork's return point. */
1626 /* Schedule a fake VFORK_DONE event to report on the next
1628 fbsd_add_vfork_done (inferior_ptid
);
1635 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1641 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1647 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1653 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1659 /* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
1662 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1664 fbsd_enable_proc_events (pid
.pid ());
1667 /* Implement the "post_attach" target_ops method. */
1670 fbsd_nat_target::post_attach (int pid
)
1672 fbsd_enable_proc_events (pid
);
1673 fbsd_add_threads (this, pid
);
1676 /* Traced processes always stop after exec. */
1679 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1685 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1690 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1692 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1694 gdb::array_view
<const int> syscall_counts
)
1697 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1698 will catch all system call entries and exits. The system calls
1699 are filtered by GDB rather than the kernel. */
1705 fbsd_nat_target::supports_multi_process ()
1711 fbsd_nat_target::supports_disable_randomization ()
1713 #ifdef PROC_ASLR_CTL
1720 /* See fbsd-nat.h. */
1723 fbsd_nat_target::fetch_register_set (struct regcache
*regcache
, int regnum
,
1724 int fetch_op
, const struct regset
*regset
,
1725 void *regs
, size_t size
)
1727 const struct regcache_map_entry
*map
1728 = (const struct regcache_map_entry
*) regset
->regmap
;
1729 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1731 if (regnum
== -1 || regcache_map_supplies (map
, regnum
, regcache
->arch(),
1734 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1735 perror_with_name (_("Couldn't get registers"));
1737 regcache
->supply_regset (regset
, regnum
, regs
, size
);
1743 /* See fbsd-nat.h. */
1746 fbsd_nat_target::store_register_set (struct regcache
*regcache
, int regnum
,
1747 int fetch_op
, int store_op
,
1748 const struct regset
*regset
, void *regs
,
1751 const struct regcache_map_entry
*map
1752 = (const struct regcache_map_entry
*) regset
->regmap
;
1753 pid_t pid
= get_ptrace_pid (regcache
->ptid ());
1755 if (regnum
== -1 || regcache_map_supplies (map
, regnum
, regcache
->arch(),
1758 if (ptrace (fetch_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1759 perror_with_name (_("Couldn't get registers"));
1761 regcache
->collect_regset (regset
, regnum
, regs
, size
);
1763 if (ptrace (store_op
, pid
, (PTRACE_TYPE_ARG3
) regs
, 0) == -1)
1764 perror_with_name (_("Couldn't write registers"));
1770 /* See fbsd-nat.h. */
1773 fbsd_nat_get_siginfo (ptid_t ptid
, siginfo_t
*siginfo
)
1775 struct ptrace_lwpinfo pl
;
1776 pid_t pid
= get_ptrace_pid (ptid
);
1778 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1780 if (!(pl
.pl_flags
& PL_FLAG_SI
))
1782 *siginfo
= pl
.pl_siginfo
;
1786 void _initialize_fbsd_nat ();
1788 _initialize_fbsd_nat ()
1790 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1791 &debug_fbsd_lwp
, _("\
1792 Set debugging of FreeBSD lwp module."), _("\
1793 Show debugging of FreeBSD lwp module."), _("\
1794 Enables printf debugging output."),
1796 &show_fbsd_lwp_debug
,
1797 &setdebuglist
, &showdebuglist
);
1798 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1799 &debug_fbsd_nat
, _("\
1800 Set debugging of FreeBSD native target."), _("\
1801 Show debugging of FreeBSD native target."), _("\
1802 Enables printf debugging output."),
1804 &show_fbsd_nat_debug
,
1805 &setdebuglist
, &showdebuglist
);
1807 /* Install a SIGCHLD handler. */
1808 signal (SIGCHLD
, sigchld_handler
);