1 /* Native-dependent code for FreeBSD.
3 Copyright (C) 2002-2018 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 "byte-vector.h"
27 #include "gdbthread.h"
29 #include "inf-ptrace.h"
30 #include <sys/types.h>
31 #include <sys/procfs.h>
32 #include <sys/ptrace.h>
33 #include <sys/signal.h>
34 #include <sys/sysctl.h>
36 #if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP)
39 #if !defined(HAVE_KINFO_GETVMMAP)
40 #include "filestuff.h"
45 #include "fbsd-tdep.h"
49 /* Return the name of a file that can be opened to get the symbols for
50 the child process identified by PID. */
53 fbsd_nat_target::pid_to_exec_file (int pid
)
56 static char buf
[PATH_MAX
];
59 #ifdef KERN_PROC_PATHNAME
65 mib
[2] = KERN_PROC_PATHNAME
;
68 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
69 /* The kern.proc.pathname.<pid> sysctl returns a length of zero
70 for processes without an associated executable such as kernel
72 return buflen
== 0 ? NULL
: buf
;
75 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
76 len
= readlink (name
, buf
, PATH_MAX
- 1);
86 #ifdef HAVE_KINFO_GETVMMAP
87 /* Iterate over all the memory regions in the current inferior,
88 calling FUNC for each memory region. OBFD is passed as the last
92 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
95 pid_t pid
= inferior_ptid
.pid ();
96 struct kinfo_vmentry
*kve
;
100 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
101 vmentl (kinfo_getvmmap (pid
, &nitems
));
103 perror_with_name (_("Couldn't fetch VM map entries."));
105 for (i
= 0, kve
= vmentl
.get (); i
< nitems
; i
++, kve
++)
107 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
108 if (!(kve
->kve_protection
& KVME_PROT_READ
)
109 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
112 /* Skip segments with an invalid type. */
113 if (kve
->kve_type
!= KVME_TYPE_DEFAULT
114 && kve
->kve_type
!= KVME_TYPE_VNODE
115 && kve
->kve_type
!= KVME_TYPE_SWAP
116 && kve
->kve_type
!= KVME_TYPE_PHYS
)
119 size
= kve
->kve_end
- kve
->kve_start
;
122 fprintf_filtered (gdb_stdout
,
123 "Save segment, %ld bytes at %s (%c%c%c)\n",
125 paddress (target_gdbarch (), kve
->kve_start
),
126 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
127 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
128 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
131 /* Invoke the callback function to create the corefile segment.
132 Pass MODIFIED as true, we do not know the real modification state. */
133 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
134 kve
->kve_protection
& KVME_PROT_WRITE
,
135 kve
->kve_protection
& KVME_PROT_EXEC
, 1, obfd
);
141 fbsd_read_mapping (FILE *mapfile
, unsigned long *start
, unsigned long *end
,
144 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */
146 int resident
, privateresident
;
150 /* As of FreeBSD 5.0-RELEASE, the layout is described in
151 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a
152 new column was added to the procfs map. Therefore we can't use
153 fscanf since we need to support older releases too. */
154 if (fgets (buf
, sizeof buf
, mapfile
) != NULL
)
155 ret
= sscanf (buf
, "%lx %lx %d %d %lx %s", start
, end
,
156 &resident
, &privateresident
, &obj
, protection
);
158 return (ret
!= 0 && ret
!= EOF
);
161 /* Iterate over all the memory regions in the current inferior,
162 calling FUNC for each memory region. OBFD is passed as the last
166 fbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
169 pid_t pid
= inferior_ptid
.pid ();
170 unsigned long start
, end
, size
;
172 int read
, write
, exec
;
174 std::string mapfilename
= string_printf ("/proc/%ld/map", (long) pid
);
175 gdb_file_up
mapfile (fopen (mapfilename
.c_str (), "r"));
177 error (_("Couldn't open %s."), mapfilename
.c_str ());
180 fprintf_filtered (gdb_stdout
,
181 "Reading memory regions from %s\n", mapfilename
.c_str ());
183 /* Now iterate until end-of-file. */
184 while (fbsd_read_mapping (mapfile
.get (), &start
, &end
, &protection
[0]))
188 read
= (strchr (protection
, 'r') != 0);
189 write
= (strchr (protection
, 'w') != 0);
190 exec
= (strchr (protection
, 'x') != 0);
194 fprintf_filtered (gdb_stdout
,
195 "Save segment, %ld bytes at %s (%c%c%c)\n",
196 size
, paddress (target_gdbarch (), start
),
202 /* Invoke the callback function to create the corefile segment.
203 Pass MODIFIED as true, we do not know the real modification state. */
204 func (start
, size
, read
, write
, exec
, 1, obfd
);
211 /* Fetch the command line for a running process. */
213 static gdb::unique_xmalloc_ptr
<char>
214 fbsd_fetch_cmdline (pid_t pid
)
222 mib
[2] = KERN_PROC_ARGS
;
224 if (sysctl (mib
, 4, NULL
, &len
, NULL
, 0) == -1)
230 gdb::unique_xmalloc_ptr
<char> cmdline ((char *) xmalloc (len
));
231 if (sysctl (mib
, 4, cmdline
.get (), &len
, NULL
, 0) == -1)
237 /* Fetch the external variant of the kernel's internal process
238 structure for the process PID into KP. */
241 fbsd_fetch_kinfo_proc (pid_t pid
, struct kinfo_proc
*kp
)
249 mib
[2] = KERN_PROC_PID
;
251 return (sysctl (mib
, 4, kp
, &len
, NULL
, 0) == 0);
254 /* Implement the "info_proc" target_ops method. */
257 fbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
259 #ifdef HAVE_KINFO_GETFILE
260 gdb::unique_xmalloc_ptr
<struct kinfo_file
> fdtbl
;
263 struct kinfo_proc kp
;
266 bool do_cmdline
= false;
269 #ifdef HAVE_KINFO_GETVMMAP
270 bool do_mappings
= false;
272 bool do_status
= false;
281 #ifdef HAVE_KINFO_GETVMMAP
303 #ifdef HAVE_KINFO_GETVMMAP
309 error (_("Not supported on this target."));
312 gdb_argv
built_argv (args
);
313 if (built_argv
.count () == 0)
315 pid
= inferior_ptid
.pid ();
317 error (_("No current process: you must name one."));
319 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
320 pid
= strtol (built_argv
[0], NULL
, 10);
322 error (_("Invalid arguments."));
324 printf_filtered (_("process %d\n"), pid
);
325 #ifdef HAVE_KINFO_GETFILE
326 if (do_cwd
|| do_exe
)
327 fdtbl
.reset (kinfo_getfile (pid
, &nfd
));
332 gdb::unique_xmalloc_ptr
<char> cmdline
= fbsd_fetch_cmdline (pid
);
333 if (cmdline
!= nullptr)
334 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
336 warning (_("unable to fetch command line"));
340 const char *cwd
= NULL
;
341 #ifdef HAVE_KINFO_GETFILE
342 struct kinfo_file
*kf
= fdtbl
.get ();
343 for (int i
= 0; i
< nfd
; i
++, kf
++)
345 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_CWD
)
353 printf_filtered ("cwd = '%s'\n", cwd
);
355 warning (_("unable to fetch current working directory"));
359 const char *exe
= NULL
;
360 #ifdef HAVE_KINFO_GETFILE
361 struct kinfo_file
*kf
= fdtbl
.get ();
362 for (int i
= 0; i
< nfd
; i
++, kf
++)
364 if (kf
->kf_type
== KF_TYPE_VNODE
&& kf
->kf_fd
== KF_FD_TYPE_TEXT
)
372 exe
= pid_to_exec_file (pid
);
374 printf_filtered ("exe = '%s'\n", exe
);
376 warning (_("unable to fetch executable path name"));
378 #ifdef HAVE_KINFO_GETVMMAP
382 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
>
383 vmentl (kinfo_getvmmap (pid
, &nvment
));
385 if (vmentl
!= nullptr)
387 printf_filtered (_("Mapped address spaces:\n\n"));
389 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
392 " Size", " Offset", "Flags ", "File");
394 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
397 " Size", " Offset", "Flags ", "File");
400 struct kinfo_vmentry
*kve
= vmentl
.get ();
401 for (int i
= 0; i
< nvment
; i
++, kve
++)
405 start
= kve
->kve_start
;
408 printf_filtered (" %18s %18s %10s %10s %9s %s\n",
411 hex_string (end
- start
),
412 hex_string (kve
->kve_offset
),
413 fbsd_vm_map_entry_flags (kve
->kve_flags
,
414 kve
->kve_protection
),
417 printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
420 hex_string (end
- start
),
421 hex_string (kve
->kve_offset
),
422 fbsd_vm_map_entry_flags (kve
->kve_flags
,
423 kve
->kve_protection
),
429 warning (_("unable to fetch virtual memory map"));
434 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
435 warning (_("Failed to fetch process information"));
441 printf_filtered ("Name: %s\n", kp
.ki_comm
);
448 state
= "R (running)";
451 state
= "T (stopped)";
454 state
= "Z (zombie)";
457 state
= "S (sleeping)";
460 state
= "W (interrupt wait)";
463 state
= "L (blocked on lock)";
466 state
= "? (unknown)";
469 printf_filtered ("State: %s\n", state
);
470 printf_filtered ("Parent process: %d\n", kp
.ki_ppid
);
471 printf_filtered ("Process group: %d\n", kp
.ki_pgid
);
472 printf_filtered ("Session id: %d\n", kp
.ki_sid
);
473 printf_filtered ("TTY: %ju\n", (uintmax_t) kp
.ki_tdev
);
474 printf_filtered ("TTY owner process group: %d\n", kp
.ki_tpgid
);
475 printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
476 kp
.ki_ruid
, kp
.ki_uid
, kp
.ki_svuid
);
477 printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
478 kp
.ki_rgid
, kp
.ki_groups
[0], kp
.ki_svgid
);
479 printf_filtered ("Groups: ");
480 for (int i
= 0; i
< kp
.ki_ngroups
; i
++)
481 printf_filtered ("%d ", kp
.ki_groups
[i
]);
482 printf_filtered ("\n");
483 printf_filtered ("Minor faults (no memory page): %ld\n",
484 kp
.ki_rusage
.ru_minflt
);
485 printf_filtered ("Minor faults, children: %ld\n",
486 kp
.ki_rusage_ch
.ru_minflt
);
487 printf_filtered ("Major faults (memory page faults): %ld\n",
488 kp
.ki_rusage
.ru_majflt
);
489 printf_filtered ("Major faults, children: %ld\n",
490 kp
.ki_rusage_ch
.ru_majflt
);
491 printf_filtered ("utime: %jd.%06ld\n",
492 (intmax_t) kp
.ki_rusage
.ru_utime
.tv_sec
,
493 kp
.ki_rusage
.ru_utime
.tv_usec
);
494 printf_filtered ("stime: %jd.%06ld\n",
495 (intmax_t) kp
.ki_rusage
.ru_stime
.tv_sec
,
496 kp
.ki_rusage
.ru_stime
.tv_usec
);
497 printf_filtered ("utime, children: %jd.%06ld\n",
498 (intmax_t) kp
.ki_rusage_ch
.ru_utime
.tv_sec
,
499 kp
.ki_rusage_ch
.ru_utime
.tv_usec
);
500 printf_filtered ("stime, children: %jd.%06ld\n",
501 (intmax_t) kp
.ki_rusage_ch
.ru_stime
.tv_sec
,
502 kp
.ki_rusage_ch
.ru_stime
.tv_usec
);
503 printf_filtered ("'nice' value: %d\n", kp
.ki_nice
);
504 printf_filtered ("Start time: %jd.%06ld\n", kp
.ki_start
.tv_sec
,
505 kp
.ki_start
.tv_usec
);
506 pgtok
= getpagesize () / 1024;
507 printf_filtered ("Virtual memory size: %ju kB\n",
508 (uintmax_t) kp
.ki_size
/ 1024);
509 printf_filtered ("Data size: %ju kB\n",
510 (uintmax_t) kp
.ki_dsize
* pgtok
);
511 printf_filtered ("Stack size: %ju kB\n",
512 (uintmax_t) kp
.ki_ssize
* pgtok
);
513 printf_filtered ("Text size: %ju kB\n",
514 (uintmax_t) kp
.ki_tsize
* pgtok
);
515 printf_filtered ("Resident set size: %ju kB\n",
516 (uintmax_t) kp
.ki_rssize
* pgtok
);
517 printf_filtered ("Maximum RSS: %ju kB\n",
518 (uintmax_t) kp
.ki_rusage
.ru_maxrss
);
519 printf_filtered ("Pending Signals: ");
520 for (int i
= 0; i
< _SIG_WORDS
; i
++)
521 printf_filtered ("%08x ", kp
.ki_siglist
.__bits
[i
]);
522 printf_filtered ("\n");
523 printf_filtered ("Ignored Signals: ");
524 for (int i
= 0; i
< _SIG_WORDS
; i
++)
525 printf_filtered ("%08x ", kp
.ki_sigignore
.__bits
[i
]);
526 printf_filtered ("\n");
527 printf_filtered ("Caught Signals: ");
528 for (int i
= 0; i
< _SIG_WORDS
; i
++)
529 printf_filtered ("%08x ", kp
.ki_sigcatch
.__bits
[i
]);
530 printf_filtered ("\n");
537 #ifdef KERN_PROC_AUXV
540 /* Return the size of siginfo for the current inferior. */
548 /* This structure matches the naming and layout of `siginfo_t' in
549 <sys/signal.h>. In particular, the `si_foo' macros defined in that
550 header can be used with both types to copy fields in the `_reason'
562 union sigval32 si_value
;
595 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
597 /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
598 if (gdbarch_long_bit (gdbarch
) == 32)
599 return sizeof (struct siginfo32
);
601 return sizeof (siginfo_t
);
604 /* Convert a native 64-bit siginfo object to a 32-bit object. Note
605 that FreeBSD doesn't support writing to $_siginfo, so this only
606 needs to convert one way. */
609 fbsd_convert_siginfo (siginfo_t
*si
)
612 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
614 /* Is the inferior 32-bit? If not, nothing to do. */
615 if (gdbarch_long_bit (gdbarch
) != 32)
618 struct siginfo32 si32
;
620 si32
.si_signo
= si
->si_signo
;
621 si32
.si_errno
= si
->si_errno
;
622 si32
.si_code
= si
->si_code
;
623 si32
.si_pid
= si
->si_pid
;
624 si32
.si_uid
= si
->si_uid
;
625 si32
.si_status
= si
->si_status
;
626 si32
.si_addr
= (uintptr_t) si
->si_addr
;
628 /* If sival_ptr is being used instead of sival_int on a big-endian
629 platform, then sival_int will be zero since it holds the upper
630 32-bits of the pointer value. */
631 #if _BYTE_ORDER == _BIG_ENDIAN
632 if (si
->si_value
.sival_int
== 0)
633 si32
.si_value
.sival_ptr
= (uintptr_t) si
->si_value
.sival_ptr
;
635 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
637 si32
.si_value
.sival_int
= si
->si_value
.sival_int
;
640 /* Always copy the spare fields and then possibly overwrite them for
641 signal-specific or code-specific fields. */
642 si32
._reason
.__spare__
.__spare1__
= si
->_reason
.__spare__
.__spare1__
;
643 for (int i
= 0; i
< 7; i
++)
644 si32
._reason
.__spare__
.__spare2__
[i
] = si
->_reason
.__spare__
.__spare2__
[i
];
645 switch (si
->si_signo
) {
650 si32
.si_trapno
= si
->si_trapno
;
653 switch (si
->si_code
) {
655 si32
.si_timerid
= si
->si_timerid
;
656 si32
.si_overrun
= si
->si_overrun
;
659 si32
.si_mqd
= si
->si_mqd
;
663 memcpy(si
, &si32
, sizeof (si32
));
668 /* Implement the "xfer_partial" target_ops method. */
670 enum target_xfer_status
671 fbsd_nat_target::xfer_partial (enum target_object object
,
672 const char *annex
, gdb_byte
*readbuf
,
673 const gdb_byte
*writebuf
,
674 ULONGEST offset
, ULONGEST len
,
675 ULONGEST
*xfered_len
)
677 pid_t pid
= inferior_ptid
.pid ();
682 case TARGET_OBJECT_SIGNAL_INFO
:
684 struct ptrace_lwpinfo pl
;
687 /* FreeBSD doesn't support writing to $_siginfo. */
688 if (writebuf
!= NULL
)
689 return TARGET_XFER_E_IO
;
691 if (inferior_ptid
.lwp_p ())
692 pid
= inferior_ptid
.lwp ();
694 siginfo_size
= fbsd_siginfo_size ();
695 if (offset
> siginfo_size
)
696 return TARGET_XFER_E_IO
;
698 if (ptrace (PT_LWPINFO
, pid
, (PTRACE_TYPE_ARG3
) &pl
, sizeof (pl
)) == -1)
699 return TARGET_XFER_E_IO
;
701 if (!(pl
.pl_flags
& PL_FLAG_SI
))
702 return TARGET_XFER_E_IO
;
704 fbsd_convert_siginfo (&pl
.pl_siginfo
);
705 if (offset
+ len
> siginfo_size
)
706 len
= siginfo_size
- offset
;
708 memcpy (readbuf
, ((gdb_byte
*) &pl
.pl_siginfo
) + offset
, len
);
710 return TARGET_XFER_OK
;
713 case TARGET_OBJECT_AUXV
:
715 gdb::byte_vector buf_storage
;
720 if (writebuf
!= NULL
)
721 return TARGET_XFER_E_IO
;
724 mib
[2] = KERN_PROC_AUXV
;
733 buflen
= offset
+ len
;
734 buf_storage
.resize (buflen
);
735 buf
= buf_storage
.data ();
737 if (sysctl (mib
, 4, buf
, &buflen
, NULL
, 0) == 0)
744 memcpy (readbuf
, buf
+ offset
, buflen
);
749 *xfered_len
= buflen
;
750 return (buflen
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
752 return TARGET_XFER_E_IO
;
754 case TARGET_OBJECT_FREEBSD_VMMAP
:
755 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
757 gdb::byte_vector buf_storage
;
763 uint32_t struct_size
;
766 case TARGET_OBJECT_FREEBSD_VMMAP
:
767 proc_target
= KERN_PROC_VMMAP
;
768 struct_size
= sizeof (struct kinfo_vmentry
);
770 case TARGET_OBJECT_FREEBSD_PS_STRINGS
:
771 proc_target
= KERN_PROC_PS_STRINGS
;
772 struct_size
= sizeof (void *);
776 if (writebuf
!= NULL
)
777 return TARGET_XFER_E_IO
;
781 mib
[2] = proc_target
;
784 if (sysctl (mib
, 4, NULL
, &buflen
, NULL
, 0) != 0)
785 return TARGET_XFER_E_IO
;
786 buflen
+= sizeof (struct_size
);
788 if (offset
>= buflen
)
791 return TARGET_XFER_EOF
;
794 buf_storage
.resize (buflen
);
795 buf
= buf_storage
.data ();
797 memcpy (buf
, &struct_size
, sizeof (struct_size
));
798 buflen
-= sizeof (struct_size
);
799 if (sysctl (mib
, 4, buf
+ sizeof (struct_size
), &buflen
, NULL
, 0) != 0)
800 return TARGET_XFER_E_IO
;
801 buflen
+= sizeof (struct_size
);
803 if (buflen
- offset
< len
)
804 len
= buflen
- offset
;
805 memcpy (readbuf
, buf
+ offset
, len
);
807 return TARGET_XFER_OK
;
810 return inf_ptrace_target::xfer_partial (object
, annex
,
811 readbuf
, writebuf
, offset
,
818 static int debug_fbsd_lwp
;
819 static int debug_fbsd_nat
;
822 show_fbsd_lwp_debug (struct ui_file
*file
, int from_tty
,
823 struct cmd_list_element
*c
, const char *value
)
825 fprintf_filtered (file
, _("Debugging of FreeBSD lwp module is %s.\n"), value
);
829 show_fbsd_nat_debug (struct ui_file
*file
, int from_tty
,
830 struct cmd_list_element
*c
, const char *value
)
832 fprintf_filtered (file
, _("Debugging of FreeBSD native target is %s.\n"),
837 FreeBSD's first thread support was via a "reentrant" version of libc
838 (libc_r) that first shipped in 2.2.7. This library multiplexed all
839 of the threads in a process onto a single kernel thread. This
840 library was supported via the bsd-uthread target.
842 FreeBSD 5.1 introduced two new threading libraries that made use of
843 multiple kernel threads. The first (libkse) scheduled M user
844 threads onto N (<= M) kernel threads (LWPs). The second (libthr)
845 bound each user thread to a dedicated kernel thread. libkse shipped
846 as the default threading library (libpthread).
848 FreeBSD 5.3 added a libthread_db to abstract the interface across
849 the various thread libraries (libc_r, libkse, and libthr).
851 FreeBSD 7.0 switched the default threading library from from libkse
852 to libpthread and removed libc_r.
854 FreeBSD 8.0 removed libkse and the in-kernel support for it. The
855 only threading library supported by 8.0 and later is libthr which
856 ties each user thread directly to an LWP. To simplify the
857 implementation, this target only supports LWP-backed threads using
858 ptrace directly rather than libthread_db.
860 FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS.
863 /* Return true if PTID is still active in the inferior. */
866 fbsd_nat_target::thread_alive (ptid_t ptid
)
870 struct ptrace_lwpinfo pl
;
872 if (ptrace (PT_LWPINFO
, ptid
.lwp (), (caddr_t
) &pl
, sizeof pl
)
875 #ifdef PL_FLAG_EXITED
876 if (pl
.pl_flags
& PL_FLAG_EXITED
)
884 /* Convert PTID to a string. Returns the string in a static
888 fbsd_nat_target::pid_to_str (ptid_t ptid
)
896 int pid
= ptid
.pid ();
898 xsnprintf (buf
, sizeof buf
, "LWP %d of process %d", lwp
, pid
);
902 return normal_pid_to_str (ptid
);
905 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
906 /* Return the name assigned to a thread by an application. Returns
907 the string in a static buffer. */
910 fbsd_nat_target::thread_name (struct thread_info
*thr
)
912 struct ptrace_lwpinfo pl
;
913 struct kinfo_proc kp
;
914 int pid
= thr
->ptid
.pid ();
915 long lwp
= thr
->ptid
.lwp ();
916 static char buf
[sizeof pl
.pl_tdname
+ 1];
918 /* Note that ptrace_lwpinfo returns the process command in pl_tdname
919 if a name has not been set explicitly. Return a NULL name in
921 if (!fbsd_fetch_kinfo_proc (pid
, &kp
))
922 perror_with_name (_("Failed to fetch process information"));
923 if (ptrace (PT_LWPINFO
, lwp
, (caddr_t
) &pl
, sizeof pl
) == -1)
924 perror_with_name (("ptrace"));
925 if (strcmp (kp
.ki_comm
, pl
.pl_tdname
) == 0)
927 xsnprintf (buf
, sizeof buf
, "%s", pl
.pl_tdname
);
932 /* Enable additional event reporting on new processes.
934 To catch fork events, PTRACE_FORK is set on every traced process
935 to enable stops on returns from fork or vfork. Note that both the
936 parent and child will always stop, even if system call stops are
939 To catch LWP events, PTRACE_EVENTS is set on every traced process.
940 This enables stops on the birth for new LWPs (excluding the "main" LWP)
941 and the death of LWPs (excluding the last LWP in a process). Note
942 that unlike fork events, the LWP that creates a new LWP does not
946 fbsd_enable_proc_events (pid_t pid
)
948 #ifdef PT_GET_EVENT_MASK
951 if (ptrace (PT_GET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
952 sizeof (events
)) == -1)
953 perror_with_name (("ptrace"));
954 events
|= PTRACE_FORK
| PTRACE_LWP
;
956 events
|= PTRACE_VFORK
;
958 if (ptrace (PT_SET_EVENT_MASK
, pid
, (PTRACE_TYPE_ARG3
)&events
,
959 sizeof (events
)) == -1)
960 perror_with_name (("ptrace"));
963 if (ptrace (PT_FOLLOW_FORK
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
964 perror_with_name (("ptrace"));
967 if (ptrace (PT_LWP_EVENTS
, pid
, (PTRACE_TYPE_ARG3
)0, 1) == -1)
968 perror_with_name (("ptrace"));
973 /* Add threads for any new LWPs in a process.
975 When LWP events are used, this function is only used to detect existing
976 threads when attaching to a process. On older systems, this function is
977 called to discover new threads each time the thread list is updated. */
980 fbsd_add_threads (pid_t pid
)
984 gdb_assert (!in_thread_list (ptid_t (pid
)));
985 nlwps
= ptrace (PT_GETNUMLWPS
, pid
, NULL
, 0);
987 perror_with_name (("ptrace"));
989 gdb::unique_xmalloc_ptr
<lwpid_t
[]> lwps (XCNEWVEC (lwpid_t
, nlwps
));
991 nlwps
= ptrace (PT_GETLWPLIST
, pid
, (caddr_t
) lwps
.get (), nlwps
);
993 perror_with_name (("ptrace"));
995 for (i
= 0; i
< nlwps
; i
++)
997 ptid_t ptid
= ptid_t (pid
, lwps
[i
], 0);
999 if (!in_thread_list (ptid
))
1001 #ifdef PT_LWP_EVENTS
1002 struct ptrace_lwpinfo pl
;
1004 /* Don't add exited threads. Note that this is only called
1005 when attaching to a multi-threaded process. */
1006 if (ptrace (PT_LWPINFO
, lwps
[i
], (caddr_t
) &pl
, sizeof pl
) == -1)
1007 perror_with_name (("ptrace"));
1008 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1012 fprintf_unfiltered (gdb_stdlog
,
1013 "FLWP: adding thread for LWP %u\n",
1020 /* Implement the "update_thread_list" target_ops method. */
1023 fbsd_nat_target::update_thread_list ()
1025 #ifdef PT_LWP_EVENTS
1026 /* With support for thread events, threads are added/deleted from the
1027 list as events are reported, so just try deleting exited threads. */
1028 delete_exited_threads ();
1032 fbsd_add_threads (inferior_ptid
.pid ());
1038 To catch fork events, PT_FOLLOW_FORK is set on every traced process
1039 to enable stops on returns from fork or vfork. Note that both the
1040 parent and child will always stop, even if system call stops are not
1043 After a fork, both the child and parent process will stop and report
1044 an event. However, there is no guarantee of order. If the parent
1045 reports its stop first, then fbsd_wait explicitly waits for the new
1046 child before returning. If the child reports its stop first, then
1047 the event is saved on a list and ignored until the parent's stop is
1048 reported. fbsd_wait could have been changed to fetch the parent PID
1049 of the new child and used that to wait for the parent explicitly.
1050 However, if two threads in the parent fork at the same time, then
1051 the wait on the parent might return the "wrong" fork event.
1053 The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for
1054 the new child process. This flag could be inferred by treating any
1055 events for an unknown pid as a new child.
1057 In addition, the initial version of PT_FOLLOW_FORK did not report a
1058 stop event for the parent process of a vfork until after the child
1059 process executed a new program or exited. The kernel was changed to
1060 defer the wait for exit or exec of the child until after posting the
1061 stop event shortly after the change to introduce PL_FLAG_CHILD.
1062 This could be worked around by reporting a vfork event when the
1063 child event posted and ignoring the subsequent event from the
1066 This implementation requires both of these fixes for simplicity's
1067 sake. FreeBSD versions newer than 9.1 contain both fixes.
1070 static std::list
<ptid_t
> fbsd_pending_children
;
1072 /* Record a new child process event that is reported before the
1073 corresponding fork event in the parent. */
1076 fbsd_remember_child (ptid_t pid
)
1078 fbsd_pending_children
.push_front (pid
);
1081 /* Check for a previously-recorded new child process event for PID.
1082 If one is found, remove it from the list and return the PTID. */
1085 fbsd_is_child_pending (pid_t pid
)
1087 for (auto it
= fbsd_pending_children
.begin ();
1088 it
!= fbsd_pending_children
.end (); it
++)
1089 if (it
->pid () == pid
)
1092 fbsd_pending_children
.erase (it
);
1098 #ifndef PTRACE_VFORK
1099 static std::forward_list
<ptid_t
> fbsd_pending_vfork_done
;
1101 /* Record a pending vfork done event. */
1104 fbsd_add_vfork_done (ptid_t pid
)
1106 fbsd_pending_vfork_done
.push_front (pid
);
1109 /* Check for a pending vfork done event for a specific PID. */
1112 fbsd_is_vfork_done_pending (pid_t pid
)
1114 for (auto it
= fbsd_pending_vfork_done
.begin ();
1115 it
!= fbsd_pending_vfork_done
.end (); it
++)
1116 if (it
->pid () == pid
)
1121 /* Check for a pending vfork done event. If one is found, remove it
1122 from the list and return the PTID. */
1125 fbsd_next_vfork_done (void)
1127 if (!fbsd_pending_vfork_done
.empty ())
1129 ptid_t ptid
= fbsd_pending_vfork_done
.front ();
1130 fbsd_pending_vfork_done
.pop_front ();
1138 /* Implement the "resume" target_ops method. */
1141 fbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1143 #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
1146 /* Don't PT_CONTINUE a process which has a pending vfork done event. */
1147 if (minus_one_ptid
== ptid
)
1148 pid
= inferior_ptid
.pid ();
1151 if (fbsd_is_vfork_done_pending (pid
))
1156 fprintf_unfiltered (gdb_stdlog
,
1157 "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
1158 ptid
.pid (), ptid
.lwp (),
1162 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
1163 struct thread_info
*tp
;
1166 ALL_NON_EXITED_THREADS (tp
)
1168 if (tp
->ptid
.pid () != ptid
.pid ())
1171 if (tp
->ptid
.lwp () == ptid
.lwp ())
1172 request
= PT_RESUME
;
1174 request
= PT_SUSPEND
;
1176 if (ptrace (request
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1177 perror_with_name (("ptrace"));
1182 /* If ptid is a wildcard, resume all matching threads (they won't run
1183 until the process is continued however). */
1184 struct thread_info
*tp
;
1186 ALL_NON_EXITED_THREADS (tp
)
1188 if (!tp
->ptid
.matches (ptid
))
1191 if (ptrace (PT_RESUME
, tp
->ptid
.lwp (), NULL
, 0) == -1)
1192 perror_with_name (("ptrace"));
1194 ptid
= inferior_ptid
;
1197 #if __FreeBSD_version < 1200052
1198 /* When multiple threads within a process wish to report STOPPED
1199 events from wait(), the kernel picks one thread event as the
1200 thread event to report. The chosen thread event is retrieved via
1201 PT_LWPINFO by passing the process ID as the request pid. If
1202 multiple events are pending, then the subsequent wait() after
1203 resuming a process will report another STOPPED event after
1204 resuming the process to handle the next thread event and so on.
1206 A single thread event is cleared as a side effect of resuming the
1207 process with PT_CONTINUE, PT_STEP, etc. In older kernels,
1208 however, the request pid was used to select which thread's event
1209 was cleared rather than always clearing the event that was just
1210 reported. To avoid clearing the event of the wrong LWP, always
1211 pass the process ID instead of an LWP ID to PT_CONTINUE or
1214 In the case of stepping, the process ID cannot be used with
1215 PT_STEP since it would step the thread that reported an event
1216 which may not be the thread indicated by PTID. For stepping, use
1217 PT_SETSTEP to enable stepping on the desired thread before
1218 resuming the process via PT_CONTINUE instead of using
1222 if (ptrace (PT_SETSTEP
, get_ptrace_pid (ptid
), NULL
, 0) == -1)
1223 perror_with_name (("ptrace"));
1226 ptid
= ptid_t (ptid
.pid ());
1228 inf_ptrace_target::resume (ptid
, step
, signo
);
1231 #ifdef USE_SIGTRAP_SIGINFO
1232 /* Handle breakpoint and trace traps reported via SIGTRAP. If the
1233 trap was a breakpoint or trace trap that should be reported to the
1234 core, return true. */
1237 fbsd_handle_debug_trap (ptid_t ptid
, const struct ptrace_lwpinfo
&pl
)
1240 /* Ignore traps without valid siginfo or for signals other than
1242 if (! (pl
.pl_flags
& PL_FLAG_SI
) || pl
.pl_siginfo
.si_signo
!= SIGTRAP
)
1245 /* Trace traps are either a single step or a hardware watchpoint or
1247 if (pl
.pl_siginfo
.si_code
== TRAP_TRACE
)
1250 fprintf_unfiltered (gdb_stdlog
,
1251 "FNAT: trace trap for LWP %ld\n", ptid
.lwp ());
1255 if (pl
.pl_siginfo
.si_code
== TRAP_BRKPT
)
1257 /* Fixup PC for the software breakpoint. */
1258 struct regcache
*regcache
= get_thread_regcache (ptid
);
1259 struct gdbarch
*gdbarch
= regcache
->arch ();
1260 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
1263 fprintf_unfiltered (gdb_stdlog
,
1264 "FNAT: sw breakpoint trap for LWP %ld\n",
1270 pc
= regcache_read_pc (regcache
);
1271 regcache_write_pc (regcache
, pc
- decr_pc
);
1280 /* Wait for the child specified by PTID to do something. Return the
1281 process ID of the child, or MINUS_ONE_PTID in case of error; store
1282 the status in *OURSTATUS. */
1285 fbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1292 #ifndef PTRACE_VFORK
1293 wptid
= fbsd_next_vfork_done ();
1294 if (wptid
!= null_ptid
)
1296 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1300 wptid
= inf_ptrace_target::wait (ptid
, ourstatus
, target_options
);
1301 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
1303 struct ptrace_lwpinfo pl
;
1308 if (ptrace (PT_LWPINFO
, pid
, (caddr_t
) &pl
, sizeof pl
) == -1)
1309 perror_with_name (("ptrace"));
1311 wptid
= ptid_t (pid
, pl
.pl_lwpid
, 0);
1315 fprintf_unfiltered (gdb_stdlog
,
1316 "FNAT: stop for LWP %u event %d flags %#x\n",
1317 pl
.pl_lwpid
, pl
.pl_event
, pl
.pl_flags
);
1318 if (pl
.pl_flags
& PL_FLAG_SI
)
1319 fprintf_unfiltered (gdb_stdlog
,
1320 "FNAT: si_signo %u si_code %u\n",
1321 pl
.pl_siginfo
.si_signo
,
1322 pl
.pl_siginfo
.si_code
);
1325 #ifdef PT_LWP_EVENTS
1326 if (pl
.pl_flags
& PL_FLAG_EXITED
)
1328 /* If GDB attaches to a multi-threaded process, exiting
1329 threads might be skipped during post_attach that
1330 have not yet reported their PL_FLAG_EXITED event.
1331 Ignore EXITED events for an unknown LWP. */
1332 thread_info
*thr
= find_thread_ptid (wptid
);
1336 fprintf_unfiltered (gdb_stdlog
,
1337 "FLWP: deleting thread for LWP %u\n",
1339 if (print_thread_events
)
1340 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str
1342 delete_thread (thr
);
1344 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1345 perror_with_name (("ptrace"));
1350 /* Switch to an LWP PTID on the first stop in a new process.
1351 This is done after handling PL_FLAG_EXITED to avoid
1352 switching to an exited LWP. It is done before checking
1353 PL_FLAG_BORN in case the first stop reported after
1354 attaching to an existing process is a PL_FLAG_BORN
1356 if (in_thread_list (ptid_t (pid
)))
1359 fprintf_unfiltered (gdb_stdlog
,
1360 "FLWP: using LWP %u for first thread\n",
1362 thread_change_ptid (ptid_t (pid
), wptid
);
1365 #ifdef PT_LWP_EVENTS
1366 if (pl
.pl_flags
& PL_FLAG_BORN
)
1368 /* If GDB attaches to a multi-threaded process, newborn
1369 threads might be added by fbsd_add_threads that have
1370 not yet reported their PL_FLAG_BORN event. Ignore
1371 BORN events for an already-known LWP. */
1372 if (!in_thread_list (wptid
))
1375 fprintf_unfiltered (gdb_stdlog
,
1376 "FLWP: adding thread for LWP %u\n",
1380 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1386 if (pl
.pl_flags
& PL_FLAG_FORKED
)
1388 #ifndef PTRACE_VFORK
1389 struct kinfo_proc kp
;
1394 child
= pl
.pl_child_pid
;
1395 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1397 if (pl
.pl_flags
& PL_FLAG_VFORKED
)
1398 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1401 /* Make sure the other end of the fork is stopped too. */
1402 child_ptid
= fbsd_is_child_pending (child
);
1403 if (child_ptid
== null_ptid
)
1405 pid
= waitpid (child
, &status
, 0);
1407 perror_with_name (("waitpid"));
1409 gdb_assert (pid
== child
);
1411 if (ptrace (PT_LWPINFO
, child
, (caddr_t
)&pl
, sizeof pl
) == -1)
1412 perror_with_name (("ptrace"));
1414 gdb_assert (pl
.pl_flags
& PL_FLAG_CHILD
);
1415 child_ptid
= ptid_t (child
, pl
.pl_lwpid
, 0);
1418 /* Enable additional events on the child process. */
1419 fbsd_enable_proc_events (child_ptid
.pid ());
1421 #ifndef PTRACE_VFORK
1422 /* For vfork, the child process will have the P_PPWAIT
1424 if (fbsd_fetch_kinfo_proc (child
, &kp
))
1426 if (kp
.ki_flag
& P_PPWAIT
)
1427 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1430 warning (_("Failed to fetch process information"));
1432 ourstatus
->value
.related_pid
= child_ptid
;
1437 if (pl
.pl_flags
& PL_FLAG_CHILD
)
1439 /* Remember that this child forked, but do not report it
1440 until the parent reports its corresponding fork
1442 fbsd_remember_child (wptid
);
1447 if (pl
.pl_flags
& PL_FLAG_VFORK_DONE
)
1449 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
1456 if (pl
.pl_flags
& PL_FLAG_EXEC
)
1458 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1459 ourstatus
->value
.execd_pathname
1460 = xstrdup (pid_to_exec_file (pid
));
1465 #ifdef USE_SIGTRAP_SIGINFO
1466 if (fbsd_handle_debug_trap (wptid
, pl
))
1470 /* Note that PL_FLAG_SCE is set for any event reported while
1471 a thread is executing a system call in the kernel. In
1472 particular, signals that interrupt a sleep in a system
1473 call will report this flag as part of their event. Stops
1474 explicitly for system call entry and exit always use
1475 SIGTRAP, so only treat SIGTRAP events as system call
1476 entry/exit events. */
1477 if (pl
.pl_flags
& (PL_FLAG_SCE
| PL_FLAG_SCX
)
1478 && ourstatus
->value
.sig
== SIGTRAP
)
1480 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1481 if (catch_syscall_enabled ())
1483 if (catching_syscall_number (pl
.pl_syscall_code
))
1485 if (pl
.pl_flags
& PL_FLAG_SCE
)
1486 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1488 ourstatus
->kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
1489 ourstatus
->value
.syscall_number
= pl
.pl_syscall_code
;
1494 /* If the core isn't interested in this event, just
1495 continue the process explicitly and wait for another
1496 event. Note that PT_SYSCALL is "sticky" on FreeBSD
1497 and once system call stops are enabled on a process
1498 it stops for all system call entries and exits. */
1499 if (ptrace (PT_CONTINUE
, pid
, (caddr_t
) 1, 0) == -1)
1500 perror_with_name (("ptrace"));
1508 #ifdef USE_SIGTRAP_SIGINFO
1509 /* Implement the "stopped_by_sw_breakpoint" target_ops method. */
1512 fbsd_nat_target::stopped_by_sw_breakpoint ()
1514 struct ptrace_lwpinfo pl
;
1516 if (ptrace (PT_LWPINFO
, get_ptrace_pid (inferior_ptid
), (caddr_t
) &pl
,
1520 return ((pl
.pl_flags
& PL_FLAG_SI
)
1521 && pl
.pl_siginfo
.si_signo
== SIGTRAP
1522 && pl
.pl_siginfo
.si_code
== TRAP_BRKPT
);
1525 /* Implement the "supports_stopped_by_sw_breakpoint" target_ops
1529 fbsd_nat_target::supports_stopped_by_sw_breakpoint ()
1536 /* Target hook for follow_fork. On entry and at return inferior_ptid is
1537 the ptid of the followed inferior. */
1540 fbsd_nat_target::follow_fork (int follow_child
, int detach_fork
)
1542 if (!follow_child
&& detach_fork
)
1544 struct thread_info
*tp
= inferior_thread ();
1545 pid_t child_pid
= tp
->pending_follow
.value
.related_pid
.pid ();
1547 /* Breakpoints have already been detached from the child by
1550 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
1551 perror_with_name (("ptrace"));
1553 #ifndef PTRACE_VFORK
1554 if (tp
->pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1556 /* We can't insert breakpoints until the child process has
1557 finished with the shared memory region. The parent
1558 process doesn't wait for the child process to exit or
1559 exec until after it has been resumed from the ptrace stop
1560 to report the fork. Once it has been resumed it doesn't
1561 stop again before returning to userland, so there is no
1562 reliable way to wait on the parent.
1564 We can't stay attached to the child to wait for an exec
1565 or exit because it may invoke ptrace(PT_TRACE_ME)
1566 (e.g. if the parent process is a debugger forking a new
1569 In the end, the best we can do is to make sure it runs
1570 for a little while. Hopefully it will be out of range of
1571 any breakpoints we reinsert. Usually this is only the
1572 single-step breakpoint at vfork's return point. */
1576 /* Schedule a fake VFORK_DONE event to report on the next
1578 fbsd_add_vfork_done (inferior_ptid
);
1587 fbsd_nat_target::insert_fork_catchpoint (int pid
)
1593 fbsd_nat_target::remove_fork_catchpoint (int pid
)
1599 fbsd_nat_target::insert_vfork_catchpoint (int pid
)
1605 fbsd_nat_target::remove_vfork_catchpoint (int pid
)
1611 /* Implement the "post_startup_inferior" target_ops method. */
1614 fbsd_nat_target::post_startup_inferior (ptid_t pid
)
1616 fbsd_enable_proc_events (pid
.pid ());
1619 /* Implement the "post_attach" target_ops method. */
1622 fbsd_nat_target::post_attach (int pid
)
1624 fbsd_enable_proc_events (pid
);
1625 fbsd_add_threads (pid
);
1629 /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes
1630 will always stop after exec. */
1633 fbsd_nat_target::insert_exec_catchpoint (int pid
)
1639 fbsd_nat_target::remove_exec_catchpoint (int pid
)
1645 #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
1647 fbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
1649 gdb::array_view
<const int> syscall_counts
)
1652 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
1653 will catch all system call entries and exits. The system calls
1654 are filtered by GDB rather than the kernel. */
1661 _initialize_fbsd_nat (void)
1664 add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance
,
1665 &debug_fbsd_lwp
, _("\
1666 Set debugging of FreeBSD lwp module."), _("\
1667 Show debugging of FreeBSD lwp module."), _("\
1668 Enables printf debugging output."),
1670 &show_fbsd_lwp_debug
,
1671 &setdebuglist
, &showdebuglist
);
1672 add_setshow_boolean_cmd ("fbsd-nat", class_maintenance
,
1673 &debug_fbsd_nat
, _("\
1674 Set debugging of FreeBSD native target."), _("\
1675 Show debugging of FreeBSD native target."), _("\
1676 Enables printf debugging output."),
1678 &show_fbsd_nat_debug
,
1679 &setdebuglist
, &showdebuglist
);