| /* Native-dependent code for FreeBSD. |
| |
| Copyright (C) 2002-2018 Free Software Foundation, Inc. |
| |
| This file is part of GDB. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "defs.h" |
| #include "byte-vector.h" |
| #include "gdbcore.h" |
| #include "inferior.h" |
| #include "regcache.h" |
| #include "regset.h" |
| #include "gdbcmd.h" |
| #include "gdbthread.h" |
| #include "gdb_wait.h" |
| #include <sys/types.h> |
| #include <sys/procfs.h> |
| #include <sys/ptrace.h> |
| #include <sys/signal.h> |
| #include <sys/sysctl.h> |
| #include <sys/user.h> |
| #if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP) |
| #include <libutil.h> |
| #endif |
| #if !defined(HAVE_KINFO_GETVMMAP) |
| #include "filestuff.h" |
| #endif |
| |
| #include "elf-bfd.h" |
| #include "fbsd-nat.h" |
| #include "fbsd-tdep.h" |
| |
| #include <list> |
| |
| /* Return the name of a file that can be opened to get the symbols for |
| the child process identified by PID. */ |
| |
| static char * |
| fbsd_pid_to_exec_file (struct target_ops *self, int pid) |
| { |
| ssize_t len; |
| static char buf[PATH_MAX]; |
| char name[PATH_MAX]; |
| |
| #ifdef KERN_PROC_PATHNAME |
| size_t buflen; |
| int mib[4]; |
| |
| mib[0] = CTL_KERN; |
| mib[1] = KERN_PROC; |
| mib[2] = KERN_PROC_PATHNAME; |
| mib[3] = pid; |
| buflen = sizeof buf; |
| if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0) |
| /* The kern.proc.pathname.<pid> sysctl returns a length of zero |
| for processes without an associated executable such as kernel |
| processes. */ |
| return buflen == 0 ? NULL : buf; |
| #endif |
| |
| xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid); |
| len = readlink (name, buf, PATH_MAX - 1); |
| if (len != -1) |
| { |
| buf[len] = '\0'; |
| return buf; |
| } |
| |
| return NULL; |
| } |
| |
| #ifdef HAVE_KINFO_GETVMMAP |
| /* Iterate over all the memory regions in the current inferior, |
| calling FUNC for each memory region. OBFD is passed as the last |
| argument to FUNC. */ |
| |
| static int |
| fbsd_find_memory_regions (struct target_ops *self, |
| find_memory_region_ftype func, void *obfd) |
| { |
| pid_t pid = ptid_get_pid (inferior_ptid); |
| struct kinfo_vmentry *kve; |
| uint64_t size; |
| int i, nitems; |
| |
| gdb::unique_xmalloc_ptr<struct kinfo_vmentry> |
| vmentl (kinfo_getvmmap (pid, &nitems)); |
| if (vmentl == NULL) |
| perror_with_name (_("Couldn't fetch VM map entries.")); |
| |
| for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++) |
| { |
| /* Skip unreadable segments and those where MAP_NOCORE has been set. */ |
| if (!(kve->kve_protection & KVME_PROT_READ) |
| || kve->kve_flags & KVME_FLAG_NOCOREDUMP) |
| continue; |
| |
| /* Skip segments with an invalid type. */ |
| if (kve->kve_type != KVME_TYPE_DEFAULT |
| && kve->kve_type != KVME_TYPE_VNODE |
| && kve->kve_type != KVME_TYPE_SWAP |
| && kve->kve_type != KVME_TYPE_PHYS) |
| continue; |
| |
| size = kve->kve_end - kve->kve_start; |
| if (info_verbose) |
| { |
| fprintf_filtered (gdb_stdout, |
| "Save segment, %ld bytes at %s (%c%c%c)\n", |
| (long) size, |
| paddress (target_gdbarch (), kve->kve_start), |
| kve->kve_protection & KVME_PROT_READ ? 'r' : '-', |
| kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-', |
| kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-'); |
| } |
| |
| /* Invoke the callback function to create the corefile segment. |
| Pass MODIFIED as true, we do not know the real modification state. */ |
| func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ, |
| kve->kve_protection & KVME_PROT_WRITE, |
| kve->kve_protection & KVME_PROT_EXEC, 1, obfd); |
| } |
| return 0; |
| } |
| #else |
| static int |
| fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end, |
| char *protection) |
| { |
| /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */ |
| char buf[256]; |
| int resident, privateresident; |
| unsigned long obj; |
| int ret = EOF; |
| |
| /* As of FreeBSD 5.0-RELEASE, the layout is described in |
| /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a |
| new column was added to the procfs map. Therefore we can't use |
| fscanf since we need to support older releases too. */ |
| if (fgets (buf, sizeof buf, mapfile) != NULL) |
| ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end, |
| &resident, &privateresident, &obj, protection); |
| |
| return (ret != 0 && ret != EOF); |
| } |
| |
| /* Iterate over all the memory regions in the current inferior, |
| calling FUNC for each memory region. OBFD is passed as the last |
| argument to FUNC. */ |
| |
| static int |
| fbsd_find_memory_regions (struct target_ops *self, |
| find_memory_region_ftype func, void *obfd) |
| { |
| pid_t pid = ptid_get_pid (inferior_ptid); |
| unsigned long start, end, size; |
| char protection[4]; |
| int read, write, exec; |
| |
| std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid); |
| gdb_file_up mapfile (fopen (mapfilename.c_str (), "r")); |
| if (mapfile == NULL) |
| error (_("Couldn't open %s."), mapfilename.c_str ()); |
| |
| if (info_verbose) |
| fprintf_filtered (gdb_stdout, |
| "Reading memory regions from %s\n", mapfilename.c_str ()); |
| |
| /* Now iterate until end-of-file. */ |
| while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0])) |
| { |
| size = end - start; |
| |
| read = (strchr (protection, 'r') != 0); |
| write = (strchr (protection, 'w') != 0); |
| exec = (strchr (protection, 'x') != 0); |
| |
| if (info_verbose) |
| { |
| fprintf_filtered (gdb_stdout, |
| "Save segment, %ld bytes at %s (%c%c%c)\n", |
| size, paddress (target_gdbarch (), start), |
| read ? 'r' : '-', |
| write ? 'w' : '-', |
| exec ? 'x' : '-'); |
| } |
| |
| /* Invoke the callback function to create the corefile segment. |
| Pass MODIFIED as true, we do not know the real modification state. */ |
| func (start, size, read, write, exec, 1, obfd); |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| /* Fetch the command line for a running process. */ |
| |
| static gdb::unique_xmalloc_ptr<char> |
| fbsd_fetch_cmdline (pid_t pid) |
| { |
| size_t len; |
| int mib[4]; |
| |
| len = 0; |
| mib[0] = CTL_KERN; |
| mib[1] = KERN_PROC; |
| mib[2] = KERN_PROC_ARGS; |
| mib[3] = pid; |
| if (sysctl (mib, 4, NULL, &len, NULL, 0) == -1) |
| return nullptr; |
| |
| if (len == 0) |
| return nullptr; |
| |
| gdb::unique_xmalloc_ptr<char> cmdline ((char *) xmalloc (len)); |
| if (sysctl (mib, 4, cmdline.get (), &len, NULL, 0) == -1) |
| return nullptr; |
| |
| return cmdline; |
| } |
| |
| /* Fetch the external variant of the kernel's internal process |
| structure for the process PID into KP. */ |
| |
| static bool |
| fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp) |
| { |
| size_t len; |
| int mib[4]; |
| |
| len = sizeof *kp; |
| mib[0] = CTL_KERN; |
| mib[1] = KERN_PROC; |
| mib[2] = KERN_PROC_PID; |
| mib[3] = pid; |
| return (sysctl (mib, 4, kp, &len, NULL, 0) == 0); |
| } |
| |
| /* Implement the "to_info_proc target_ops" method. */ |
| |
| static void |
| fbsd_info_proc (struct target_ops *ops, const char *args, |
| enum info_proc_what what) |
| { |
| #ifdef HAVE_KINFO_GETFILE |
| gdb::unique_xmalloc_ptr<struct kinfo_file> fdtbl; |
| int nfd = 0; |
| #endif |
| struct kinfo_proc kp; |
| char *tmp; |
| pid_t pid; |
| bool do_cmdline = false; |
| bool do_cwd = false; |
| bool do_exe = false; |
| #ifdef HAVE_KINFO_GETVMMAP |
| bool do_mappings = false; |
| #endif |
| bool do_status = false; |
| |
| switch (what) |
| { |
| case IP_MINIMAL: |
| do_cmdline = true; |
| do_cwd = true; |
| do_exe = true; |
| break; |
| #ifdef HAVE_KINFO_GETVMMAP |
| case IP_MAPPINGS: |
| do_mappings = true; |
| break; |
| #endif |
| case IP_STATUS: |
| case IP_STAT: |
| do_status = true; |
| break; |
| case IP_CMDLINE: |
| do_cmdline = true; |
| break; |
| case IP_EXE: |
| do_exe = true; |
| break; |
| case IP_CWD: |
| do_cwd = true; |
| break; |
| case IP_ALL: |
| do_cmdline = true; |
| do_cwd = true; |
| do_exe = true; |
| #ifdef HAVE_KINFO_GETVMMAP |
| do_mappings = true; |
| #endif |
| do_status = true; |
| break; |
| default: |
| error (_("Not supported on this target.")); |
| } |
| |
| gdb_argv built_argv (args); |
| if (built_argv.count () == 0) |
| { |
| pid = ptid_get_pid (inferior_ptid); |
| if (pid == 0) |
| error (_("No current process: you must name one.")); |
| } |
| else if (built_argv.count () == 1 && isdigit (built_argv[0][0])) |
| pid = strtol (built_argv[0], NULL, 10); |
| else |
| error (_("Invalid arguments.")); |
| |
| printf_filtered (_("process %d\n"), pid); |
| #ifdef HAVE_KINFO_GETFILE |
| if (do_cwd || do_exe) |
| fdtbl.reset (kinfo_getfile (pid, &nfd)); |
| #endif |
| |
| if (do_cmdline) |
| { |
| gdb::unique_xmalloc_ptr<char> cmdline = fbsd_fetch_cmdline (pid); |
| if (cmdline != nullptr) |
| printf_filtered ("cmdline = '%s'\n", cmdline.get ()); |
| else |
| warning (_("unable to fetch command line")); |
| } |
| if (do_cwd) |
| { |
| const char *cwd = NULL; |
| #ifdef HAVE_KINFO_GETFILE |
| struct kinfo_file *kf = fdtbl.get (); |
| for (int i = 0; i < nfd; i++, kf++) |
| { |
| if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_CWD) |
| { |
| cwd = kf->kf_path; |
| break; |
| } |
| } |
| #endif |
| if (cwd != NULL) |
| printf_filtered ("cwd = '%s'\n", cwd); |
| else |
| warning (_("unable to fetch current working directory")); |
| } |
| if (do_exe) |
| { |
| const char *exe = NULL; |
| #ifdef HAVE_KINFO_GETFILE |
| struct kinfo_file *kf = fdtbl.get (); |
| for (int i = 0; i < nfd; i++, kf++) |
| { |
| if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_TEXT) |
| { |
| exe = kf->kf_path; |
| break; |
| } |
| } |
| #endif |
| if (exe == NULL) |
| exe = fbsd_pid_to_exec_file (ops, pid); |
| if (exe != NULL) |
| printf_filtered ("exe = '%s'\n", exe); |
| else |
| warning (_("unable to fetch executable path name")); |
| } |
| #ifdef HAVE_KINFO_GETVMMAP |
| if (do_mappings) |
| { |
| int nvment; |
| gdb::unique_xmalloc_ptr<struct kinfo_vmentry> |
| vmentl (kinfo_getvmmap (pid, &nvment)); |
| |
| if (vmentl != nullptr) |
| { |
| printf_filtered (_("Mapped address spaces:\n\n")); |
| #ifdef __LP64__ |
| printf_filtered (" %18s %18s %10s %10s %9s %s\n", |
| "Start Addr", |
| " End Addr", |
| " Size", " Offset", "Flags ", "File"); |
| #else |
| printf_filtered ("\t%10s %10s %10s %10s %9s %s\n", |
| "Start Addr", |
| " End Addr", |
| " Size", " Offset", "Flags ", "File"); |
| #endif |
| |
| struct kinfo_vmentry *kve = vmentl.get (); |
| for (int i = 0; i < nvment; i++, kve++) |
| { |
| ULONGEST start, end; |
| |
| start = kve->kve_start; |
| end = kve->kve_end; |
| #ifdef __LP64__ |
| printf_filtered (" %18s %18s %10s %10s %9s %s\n", |
| hex_string (start), |
| hex_string (end), |
| hex_string (end - start), |
| hex_string (kve->kve_offset), |
| fbsd_vm_map_entry_flags (kve->kve_flags, |
| kve->kve_protection), |
| kve->kve_path); |
| #else |
| printf_filtered ("\t%10s %10s %10s %10s %9s %s\n", |
| hex_string (start), |
| hex_string (end), |
| hex_string (end - start), |
| hex_string (kve->kve_offset), |
| fbsd_vm_map_entry_flags (kve->kve_flags, |
| kve->kve_protection), |
| kve->kve_path); |
| #endif |
| } |
| } |
| else |
| warning (_("unable to fetch virtual memory map")); |
| } |
| #endif |
| if (do_status) |
| { |
| if (!fbsd_fetch_kinfo_proc (pid, &kp)) |
| warning (_("Failed to fetch process information")); |
| else |
| { |
| const char *state; |
| int pgtok; |
| |
| printf_filtered ("Name: %s\n", kp.ki_comm); |
| switch (kp.ki_stat) |
| { |
| case SIDL: |
| state = "I (idle)"; |
| break; |
| case SRUN: |
| state = "R (running)"; |
| break; |
| case SSTOP: |
| state = "T (stopped)"; |
| break; |
| case SZOMB: |
| state = "Z (zombie)"; |
| break; |
| case SSLEEP: |
| state = "S (sleeping)"; |
| break; |
| case SWAIT: |
| state = "W (interrupt wait)"; |
| break; |
| case SLOCK: |
| state = "L (blocked on lock)"; |
| break; |
| default: |
| state = "? (unknown)"; |
| break; |
| } |
| printf_filtered ("State: %s\n", state); |
| printf_filtered ("Parent process: %d\n", kp.ki_ppid); |
| printf_filtered ("Process group: %d\n", kp.ki_pgid); |
| printf_filtered ("Session id: %d\n", kp.ki_sid); |
| printf_filtered ("TTY: %ju\n", (uintmax_t) kp.ki_tdev); |
| printf_filtered ("TTY owner process group: %d\n", kp.ki_tpgid); |
| printf_filtered ("User IDs (real, effective, saved): %d %d %d\n", |
| kp.ki_ruid, kp.ki_uid, kp.ki_svuid); |
| printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n", |
| kp.ki_rgid, kp.ki_groups[0], kp.ki_svgid); |
| printf_filtered ("Groups: "); |
| for (int i = 0; i < kp.ki_ngroups; i++) |
| printf_filtered ("%d ", kp.ki_groups[i]); |
| printf_filtered ("\n"); |
| printf_filtered ("Minor faults (no memory page): %ld\n", |
| kp.ki_rusage.ru_minflt); |
| printf_filtered ("Minor faults, children: %ld\n", |
| kp.ki_rusage_ch.ru_minflt); |
| printf_filtered ("Major faults (memory page faults): %ld\n", |
| kp.ki_rusage.ru_majflt); |
| printf_filtered ("Major faults, children: %ld\n", |
| kp.ki_rusage_ch.ru_majflt); |
| printf_filtered ("utime: %jd.%06ld\n", |
| (intmax_t) kp.ki_rusage.ru_utime.tv_sec, |
| kp.ki_rusage.ru_utime.tv_usec); |
| printf_filtered ("stime: %jd.%06ld\n", |
| (intmax_t) kp.ki_rusage.ru_stime.tv_sec, |
| kp.ki_rusage.ru_stime.tv_usec); |
| printf_filtered ("utime, children: %jd.%06ld\n", |
| (intmax_t) kp.ki_rusage_ch.ru_utime.tv_sec, |
| kp.ki_rusage_ch.ru_utime.tv_usec); |
| printf_filtered ("stime, children: %jd.%06ld\n", |
| (intmax_t) kp.ki_rusage_ch.ru_stime.tv_sec, |
| kp.ki_rusage_ch.ru_stime.tv_usec); |
| printf_filtered ("'nice' value: %d\n", kp.ki_nice); |
| printf_filtered ("Start time: %jd.%06ld\n", kp.ki_start.tv_sec, |
| kp.ki_start.tv_usec); |
| pgtok = getpagesize () / 1024; |
| printf_filtered ("Virtual memory size: %ju kB\n", |
| (uintmax_t) kp.ki_size / 1024); |
| printf_filtered ("Data size: %ju kB\n", |
| (uintmax_t) kp.ki_dsize * pgtok); |
| printf_filtered ("Stack size: %ju kB\n", |
| (uintmax_t) kp.ki_ssize * pgtok); |
| printf_filtered ("Text size: %ju kB\n", |
| (uintmax_t) kp.ki_tsize * pgtok); |
| printf_filtered ("Resident set size: %ju kB\n", |
| (uintmax_t) kp.ki_rssize * pgtok); |
| printf_filtered ("Maximum RSS: %ju kB\n", |
| (uintmax_t) kp.ki_rusage.ru_maxrss); |
| printf_filtered ("Pending Signals: "); |
| for (int i = 0; i < _SIG_WORDS; i++) |
| printf_filtered ("%08x ", kp.ki_siglist.__bits[i]); |
| printf_filtered ("\n"); |
| printf_filtered ("Ignored Signals: "); |
| for (int i = 0; i < _SIG_WORDS; i++) |
| printf_filtered ("%08x ", kp.ki_sigignore.__bits[i]); |
| printf_filtered ("\n"); |
| printf_filtered ("Caught Signals: "); |
| for (int i = 0; i < _SIG_WORDS; i++) |
| printf_filtered ("%08x ", kp.ki_sigcatch.__bits[i]); |
| printf_filtered ("\n"); |
| } |
| } |
| } |
| |
| #ifdef KERN_PROC_AUXV |
| static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops, |
| enum target_object object, |
| const char *annex, |
| gdb_byte *readbuf, |
| const gdb_byte *writebuf, |
| ULONGEST offset, |
| ULONGEST len, |
| ULONGEST *xfered_len); |
| |
| #ifdef PT_LWPINFO |
| /* Return the size of siginfo for the current inferior. */ |
| |
| #ifdef __LP64__ |
| union sigval32 { |
| int sival_int; |
| uint32_t sival_ptr; |
| }; |
| |
| /* This structure matches the naming and layout of `siginfo_t' in |
| <sys/signal.h>. In particular, the `si_foo' macros defined in that |
| header can be used with both types to copy fields in the `_reason' |
| union. */ |
| |
| struct siginfo32 |
| { |
| int si_signo; |
| int si_errno; |
| int si_code; |
| __pid_t si_pid; |
| __uid_t si_uid; |
| int si_status; |
| uint32_t si_addr; |
| union sigval32 si_value; |
| union |
| { |
| struct |
| { |
| int _trapno; |
| } _fault; |
| struct |
| { |
| int _timerid; |
| int _overrun; |
| } _timer; |
| struct |
| { |
| int _mqd; |
| } _mesgq; |
| struct |
| { |
| int32_t _band; |
| } _poll; |
| struct |
| { |
| int32_t __spare1__; |
| int __spare2__[7]; |
| } __spare__; |
| } _reason; |
| }; |
| #endif |
| |
| static size_t |
| fbsd_siginfo_size () |
| { |
| #ifdef __LP64__ |
| struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); |
| |
| /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */ |
| if (gdbarch_long_bit (gdbarch) == 32) |
| return sizeof (struct siginfo32); |
| #endif |
| return sizeof (siginfo_t); |
| } |
| |
| /* Convert a native 64-bit siginfo object to a 32-bit object. Note |
| that FreeBSD doesn't support writing to $_siginfo, so this only |
| needs to convert one way. */ |
| |
| static void |
| fbsd_convert_siginfo (siginfo_t *si) |
| { |
| #ifdef __LP64__ |
| struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); |
| |
| /* Is the inferior 32-bit? If not, nothing to do. */ |
| if (gdbarch_long_bit (gdbarch) != 32) |
| return; |
| |
| struct siginfo32 si32; |
| |
| si32.si_signo = si->si_signo; |
| si32.si_errno = si->si_errno; |
| si32.si_code = si->si_code; |
| si32.si_pid = si->si_pid; |
| si32.si_uid = si->si_uid; |
| si32.si_status = si->si_status; |
| si32.si_addr = (uintptr_t) si->si_addr; |
| |
| /* If sival_ptr is being used instead of sival_int on a big-endian |
| platform, then sival_int will be zero since it holds the upper |
| 32-bits of the pointer value. */ |
| #if _BYTE_ORDER == _BIG_ENDIAN |
| if (si->si_value.sival_int == 0) |
| si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr; |
| else |
| si32.si_value.sival_int = si->si_value.sival_int; |
| #else |
| si32.si_value.sival_int = si->si_value.sival_int; |
| #endif |
| |
| /* Always copy the spare fields and then possibly overwrite them for |
| signal-specific or code-specific fields. */ |
| si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__; |
| for (int i = 0; i < 7; i++) |
| si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i]; |
| switch (si->si_signo) { |
| case SIGILL: |
| case SIGFPE: |
| case SIGSEGV: |
| case SIGBUS: |
| si32.si_trapno = si->si_trapno; |
| break; |
| } |
| switch (si->si_code) { |
| case SI_TIMER: |
| si32.si_timerid = si->si_timerid; |
| si32.si_overrun = si->si_overrun; |
| break; |
| case SI_MESGQ: |
| si32.si_mqd = si->si_mqd; |
| break; |
| } |
| |
| memcpy(si, &si32, sizeof (si32)); |
| #endif |
| } |
| #endif |
| |
| /* Implement the "to_xfer_partial target_ops" method. */ |
| |
| static enum target_xfer_status |
| fbsd_xfer_partial (struct target_ops *ops, enum target_object object, |
| const char *annex, gdb_byte *readbuf, |
| const gdb_byte *writebuf, |
| ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) |
| { |
| pid_t pid = ptid_get_pid (inferior_ptid); |
| |
| switch (object) |
| { |
| #ifdef PT_LWPINFO |
| case TARGET_OBJECT_SIGNAL_INFO: |
| { |
| struct ptrace_lwpinfo pl; |
| size_t siginfo_size; |
| |
| /* FreeBSD doesn't support writing to $_siginfo. */ |
| if (writebuf != NULL) |
| return TARGET_XFER_E_IO; |
| |
| if (inferior_ptid.lwp_p ()) |
| pid = inferior_ptid.lwp (); |
| |
| siginfo_size = fbsd_siginfo_size (); |
| if (offset > siginfo_size) |
| return TARGET_XFER_E_IO; |
| |
| if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1) |
| return TARGET_XFER_E_IO; |
| |
| if (!(pl.pl_flags & PL_FLAG_SI)) |
| return TARGET_XFER_E_IO; |
| |
| fbsd_convert_siginfo (&pl.pl_siginfo); |
| if (offset + len > siginfo_size) |
| len = siginfo_size - offset; |
| |
| memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len); |
| *xfered_len = len; |
| return TARGET_XFER_OK; |
| } |
| #endif |
| case TARGET_OBJECT_AUXV: |
| { |
| gdb::byte_vector buf_storage; |
| gdb_byte *buf; |
| size_t buflen; |
| int mib[4]; |
| |
| if (writebuf != NULL) |
| return TARGET_XFER_E_IO; |
| mib[0] = CTL_KERN; |
| mib[1] = KERN_PROC; |
| mib[2] = KERN_PROC_AUXV; |
| mib[3] = pid; |
| if (offset == 0) |
| { |
| buf = readbuf; |
| buflen = len; |
| } |
| else |
| { |
| buflen = offset + len; |
| buf_storage.resize (buflen); |
| buf = buf_storage.data (); |
| } |
| if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0) |
| { |
| if (offset != 0) |
| { |
| if (buflen > offset) |
| { |
| buflen -= offset; |
| memcpy (readbuf, buf + offset, buflen); |
| } |
| else |
| buflen = 0; |
| } |
| *xfered_len = buflen; |
| return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK; |
| } |
| return TARGET_XFER_E_IO; |
| } |
| default: |
| return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset, |
| len, xfered_len); |
| } |
| } |
| #endif |
| |
| #ifdef PT_LWPINFO |
| static int debug_fbsd_lwp; |
| |
| static void (*super_resume) (struct target_ops *, |
| ptid_t, |
| int, |
| enum gdb_signal); |
| static ptid_t (*super_wait) (struct target_ops *, |
| ptid_t, |
| struct target_waitstatus *, |
| int); |
| |
| static void |
| show_fbsd_lwp_debug (struct ui_file *file, int from_tty, |
| struct cmd_list_element *c, const char *value) |
| { |
| fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value); |
| } |
| |
| /* |
| FreeBSD's first thread support was via a "reentrant" version of libc |
| (libc_r) that first shipped in 2.2.7. This library multiplexed all |
| of the threads in a process onto a single kernel thread. This |
| library was supported via the bsd-uthread target. |
| |
| FreeBSD 5.1 introduced two new threading libraries that made use of |
| multiple kernel threads. The first (libkse) scheduled M user |
| threads onto N (<= M) kernel threads (LWPs). The second (libthr) |
| bound each user thread to a dedicated kernel thread. libkse shipped |
| as the default threading library (libpthread). |
| |
| FreeBSD 5.3 added a libthread_db to abstract the interface across |
| the various thread libraries (libc_r, libkse, and libthr). |
| |
| FreeBSD 7.0 switched the default threading library from from libkse |
| to libpthread and removed libc_r. |
| |
| FreeBSD 8.0 removed libkse and the in-kernel support for it. The |
| only threading library supported by 8.0 and later is libthr which |
| ties each user thread directly to an LWP. To simplify the |
| implementation, this target only supports LWP-backed threads using |
| ptrace directly rather than libthread_db. |
| |
| FreeBSD 11.0 introduced LWP event reporting via PT_LWP_EVENTS. |
| */ |
| |
| /* Return true if PTID is still active in the inferior. */ |
| |
| static int |
| fbsd_thread_alive (struct target_ops *ops, ptid_t ptid) |
| { |
| if (ptid_lwp_p (ptid)) |
| { |
| struct ptrace_lwpinfo pl; |
| |
| if (ptrace (PT_LWPINFO, ptid_get_lwp (ptid), (caddr_t) &pl, sizeof pl) |
| == -1) |
| return 0; |
| #ifdef PL_FLAG_EXITED |
| if (pl.pl_flags & PL_FLAG_EXITED) |
| return 0; |
| #endif |
| } |
| |
| return 1; |
| } |
| |
| /* Convert PTID to a string. Returns the string in a static |
| buffer. */ |
| |
| static const char * |
| fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid) |
| { |
| lwpid_t lwp; |
| |
| lwp = ptid_get_lwp (ptid); |
| if (lwp != 0) |
| { |
| static char buf[64]; |
| int pid = ptid_get_pid (ptid); |
| |
| xsnprintf (buf, sizeof buf, "LWP %d of process %d", lwp, pid); |
| return buf; |
| } |
| |
| return normal_pid_to_str (ptid); |
| } |
| |
| #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME |
| /* Return the name assigned to a thread by an application. Returns |
| the string in a static buffer. */ |
| |
| static const char * |
| fbsd_thread_name (struct target_ops *self, struct thread_info *thr) |
| { |
| struct ptrace_lwpinfo pl; |
| struct kinfo_proc kp; |
| int pid = ptid_get_pid (thr->ptid); |
| long lwp = ptid_get_lwp (thr->ptid); |
| static char buf[sizeof pl.pl_tdname + 1]; |
| |
| /* Note that ptrace_lwpinfo returns the process command in pl_tdname |
| if a name has not been set explicitly. Return a NULL name in |
| that case. */ |
| if (!fbsd_fetch_kinfo_proc (pid, &kp)) |
| perror_with_name (_("Failed to fetch process information")); |
| if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1) |
| perror_with_name (("ptrace")); |
| if (strcmp (kp.ki_comm, pl.pl_tdname) == 0) |
| return NULL; |
| xsnprintf (buf, sizeof buf, "%s", pl.pl_tdname); |
| return buf; |
| } |
| #endif |
| |
| /* Enable additional event reporting on new processes. |
| |
| To catch fork events, PTRACE_FORK is set on every traced process |
| to enable stops on returns from fork or vfork. Note that both the |
| parent and child will always stop, even if system call stops are |
| not enabled. |
| |
| To catch LWP events, PTRACE_EVENTS is set on every traced process. |
| This enables stops on the birth for new LWPs (excluding the "main" LWP) |
| and the death of LWPs (excluding the last LWP in a process). Note |
| that unlike fork events, the LWP that creates a new LWP does not |
| report an event. */ |
| |
| static void |
| fbsd_enable_proc_events (pid_t pid) |
| { |
| #ifdef PT_GET_EVENT_MASK |
| int events; |
| |
| if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events, |
| sizeof (events)) == -1) |
| perror_with_name (("ptrace")); |
| events |= PTRACE_FORK | PTRACE_LWP; |
| #ifdef PTRACE_VFORK |
| events |= PTRACE_VFORK; |
| #endif |
| if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events, |
| sizeof (events)) == -1) |
| perror_with_name (("ptrace")); |
| #else |
| #ifdef TDP_RFPPWAIT |
| if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) |
| perror_with_name (("ptrace")); |
| #endif |
| #ifdef PT_LWP_EVENTS |
| if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) |
| perror_with_name (("ptrace")); |
| #endif |
| #endif |
| } |
| |
| /* Add threads for any new LWPs in a process. |
| |
| When LWP events are used, this function is only used to detect existing |
| threads when attaching to a process. On older systems, this function is |
| called to discover new threads each time the thread list is updated. */ |
| |
| static void |
| fbsd_add_threads (pid_t pid) |
| { |
| int i, nlwps; |
| |
| gdb_assert (!in_thread_list (pid_to_ptid (pid))); |
| nlwps = ptrace (PT_GETNUMLWPS, pid, NULL, 0); |
| if (nlwps == -1) |
| perror_with_name (("ptrace")); |
| |
| gdb::unique_xmalloc_ptr<lwpid_t[]> lwps (XCNEWVEC (lwpid_t, nlwps)); |
| |
| nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps); |
| if (nlwps == -1) |
| perror_with_name (("ptrace")); |
| |
| for (i = 0; i < nlwps; i++) |
| { |
| ptid_t ptid = ptid_build (pid, lwps[i], 0); |
| |
| if (!in_thread_list (ptid)) |
| { |
| #ifdef PT_LWP_EVENTS |
| struct ptrace_lwpinfo pl; |
| |
| /* Don't add exited threads. Note that this is only called |
| when attaching to a multi-threaded process. */ |
| if (ptrace (PT_LWPINFO, lwps[i], (caddr_t) &pl, sizeof pl) == -1) |
| perror_with_name (("ptrace")); |
| if (pl.pl_flags & PL_FLAG_EXITED) |
| continue; |
| #endif |
| if (debug_fbsd_lwp) |
| fprintf_unfiltered (gdb_stdlog, |
| "FLWP: adding thread for LWP %u\n", |
| lwps[i]); |
| add_thread (ptid); |
| } |
| } |
| } |
| |
| /* Implement the "to_update_thread_list" target_ops method. */ |
| |
| static void |
| fbsd_update_thread_list (struct target_ops *ops) |
| { |
| #ifdef PT_LWP_EVENTS |
| /* With support for thread events, threads are added/deleted from the |
| list as events are reported, so just try deleting exited threads. */ |
| delete_exited_threads (); |
| #else |
| prune_threads (); |
| |
| fbsd_add_threads (ptid_get_pid (inferior_ptid)); |
| #endif |
| } |
| |
| #ifdef TDP_RFPPWAIT |
| /* |
| To catch fork events, PT_FOLLOW_FORK is set on every traced process |
| to enable stops on returns from fork or vfork. Note that both the |
| parent and child will always stop, even if system call stops are not |
| enabled. |
| |
| After a fork, both the child and parent process will stop and report |
| an event. However, there is no guarantee of order. If the parent |
| reports its stop first, then fbsd_wait explicitly waits for the new |
| child before returning. If the child reports its stop first, then |
| the event is saved on a list and ignored until the parent's stop is |
| reported. fbsd_wait could have been changed to fetch the parent PID |
| of the new child and used that to wait for the parent explicitly. |
| However, if two threads in the parent fork at the same time, then |
| the wait on the parent might return the "wrong" fork event. |
| |
| The initial version of PT_FOLLOW_FORK did not set PL_FLAG_CHILD for |
| the new child process. This flag could be inferred by treating any |
| events for an unknown pid as a new child. |
| |
| In addition, the initial version of PT_FOLLOW_FORK did not report a |
| stop event for the parent process of a vfork until after the child |
| process executed a new program or exited. The kernel was changed to |
| defer the wait for exit or exec of the child until after posting the |
| stop event shortly after the change to introduce PL_FLAG_CHILD. |
| This could be worked around by reporting a vfork event when the |
| child event posted and ignoring the subsequent event from the |
| parent. |
| |
| This implementation requires both of these fixes for simplicity's |
| sake. FreeBSD versions newer than 9.1 contain both fixes. |
| */ |
| |
| static std::list<ptid_t> fbsd_pending_children; |
| |
| /* Record a new child process event that is reported before the |
| corresponding fork event in the parent. */ |
| |
| static void |
| fbsd_remember_child (ptid_t pid) |
| { |
| fbsd_pending_children.push_front (pid); |
| } |
| |
| /* Check for a previously-recorded new child process event for PID. |
| If one is found, remove it from the list and return the PTID. */ |
| |
| static ptid_t |
| fbsd_is_child_pending (pid_t pid) |
| { |
| for (auto it = fbsd_pending_children.begin (); |
| it != fbsd_pending_children.end (); it++) |
| if (it->pid () == pid) |
| { |
| ptid_t ptid = *it; |
| fbsd_pending_children.erase (it); |
| return ptid; |
| } |
| return null_ptid; |
| } |
| |
| #ifndef PTRACE_VFORK |
| static std::forward_list<ptid_t> fbsd_pending_vfork_done; |
| |
| /* Record a pending vfork done event. */ |
| |
| static void |
| fbsd_add_vfork_done (ptid_t pid) |
| { |
| fbsd_pending_vfork_done.push_front (pid); |
| } |
| |
| /* Check for a pending vfork done event for a specific PID. */ |
| |
| static int |
| fbsd_is_vfork_done_pending (pid_t pid) |
| { |
| for (auto it = fbsd_pending_vfork_done.begin (); |
| it != fbsd_pending_vfork_done.end (); it++) |
| if (it->pid () == pid) |
| return 1; |
| return 0; |
| } |
| |
| /* Check for a pending vfork done event. If one is found, remove it |
| from the list and return the PTID. */ |
| |
| static ptid_t |
| fbsd_next_vfork_done (void) |
| { |
| if (!fbsd_pending_vfork_done.empty ()) |
| { |
| ptid_t ptid = fbsd_pending_vfork_done.front (); |
| fbsd_pending_vfork_done.pop_front (); |
| return ptid; |
| } |
| return null_ptid; |
| } |
| #endif |
| #endif |
| |
| /* Implement the "to_resume" target_ops method. */ |
| |
| static void |
| fbsd_resume (struct target_ops *ops, |
| ptid_t ptid, int step, enum gdb_signal signo) |
| { |
| #if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK) |
| pid_t pid; |
| |
| /* Don't PT_CONTINUE a process which has a pending vfork done event. */ |
| if (ptid_equal (minus_one_ptid, ptid)) |
| pid = ptid_get_pid (inferior_ptid); |
| else |
| pid = ptid_get_pid (ptid); |
| if (fbsd_is_vfork_done_pending (pid)) |
| return; |
| #endif |
| |
| if (debug_fbsd_lwp) |
| fprintf_unfiltered (gdb_stdlog, |
| "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n", |
| ptid_get_pid (ptid), ptid_get_lwp (ptid), |
| ptid_get_tid (ptid)); |
| if (ptid_lwp_p (ptid)) |
| { |
| /* If ptid is a specific LWP, suspend all other LWPs in the process. */ |
| struct thread_info *tp; |
| int request; |
| |
| ALL_NON_EXITED_THREADS (tp) |
| { |
| if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid)) |
| continue; |
| |
| if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid)) |
| request = PT_RESUME; |
| else |
| request = PT_SUSPEND; |
| |
| if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1) |
| perror_with_name (("ptrace")); |
| } |
| } |
| else |
| { |
| /* If ptid is a wildcard, resume all matching threads (they won't run |
| until the process is continued however). */ |
| struct thread_info *tp; |
| |
| ALL_NON_EXITED_THREADS (tp) |
| { |
| if (!ptid_match (tp->ptid, ptid)) |
| continue; |
| |
| if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1) |
| perror_with_name (("ptrace")); |
| } |
| ptid = inferior_ptid; |
| } |
| super_resume (ops, ptid, step, signo); |
| } |
| |
| /* Wait for the child specified by PTID to do something. Return the |
| process ID of the child, or MINUS_ONE_PTID in case of error; store |
| the status in *OURSTATUS. */ |
| |
| static ptid_t |
| fbsd_wait (struct target_ops *ops, |
| ptid_t ptid, struct target_waitstatus *ourstatus, |
| int target_options) |
| { |
| ptid_t wptid; |
| |
| while (1) |
| { |
| #ifndef PTRACE_VFORK |
| wptid = fbsd_next_vfork_done (); |
| if (!ptid_equal (wptid, null_ptid)) |
| { |
| ourstatus->kind = TARGET_WAITKIND_VFORK_DONE; |
| return wptid; |
| } |
| #endif |
| wptid = super_wait (ops, ptid, ourstatus, target_options); |
| if (ourstatus->kind == TARGET_WAITKIND_STOPPED) |
| { |
| struct ptrace_lwpinfo pl; |
| pid_t pid; |
| int status; |
| |
| pid = ptid_get_pid (wptid); |
| if (ptrace (PT_LWPINFO, pid, (caddr_t) &pl, sizeof pl) == -1) |
| perror_with_name (("ptrace")); |
| |
| wptid = ptid_build (pid, pl.pl_lwpid, 0); |
| |
| #ifdef PT_LWP_EVENTS |
| if (pl.pl_flags & PL_FLAG_EXITED) |
| { |
| /* If GDB attaches to a multi-threaded process, exiting |
| threads might be skipped during fbsd_post_attach that |
| have not yet reported their PL_FLAG_EXITED event. |
| Ignore EXITED events for an unknown LWP. */ |
| if (in_thread_list (wptid)) |
| { |
| if (debug_fbsd_lwp) |
| fprintf_unfiltered (gdb_stdlog, |
| "FLWP: deleting thread for LWP %u\n", |
| pl.pl_lwpid); |
| if (print_thread_events) |
| printf_unfiltered (_("[%s exited]\n"), target_pid_to_str |
| (wptid)); |
| delete_thread (wptid); |
| } |
| if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1) |
| perror_with_name (("ptrace")); |
| continue; |
| } |
| #endif |
| |
| /* Switch to an LWP PTID on the first stop in a new process. |
| This is done after handling PL_FLAG_EXITED to avoid |
| switching to an exited LWP. It is done before checking |
| PL_FLAG_BORN in case the first stop reported after |
| attaching to an existing process is a PL_FLAG_BORN |
| event. */ |
| if (in_thread_list (pid_to_ptid (pid))) |
| { |
| if (debug_fbsd_lwp) |
| fprintf_unfiltered (gdb_stdlog, |
| "FLWP: using LWP %u for first thread\n", |
| pl.pl_lwpid); |
| thread_change_ptid (pid_to_ptid (pid), wptid); |
| } |
| |
| #ifdef PT_LWP_EVENTS |
| if (pl.pl_flags & PL_FLAG_BORN) |
| { |
| /* If GDB attaches to a multi-threaded process, newborn |
| threads might be added by fbsd_add_threads that have |
| not yet reported their PL_FLAG_BORN event. Ignore |
| BORN events for an already-known LWP. */ |
| if (!in_thread_list (wptid)) |
| { |
| if (debug_fbsd_lwp) |
| fprintf_unfiltered (gdb_stdlog, |
| "FLWP: adding thread for LWP %u\n", |
| pl.pl_lwpid); |
| add_thread (wptid); |
| } |
| ourstatus->kind = TARGET_WAITKIND_SPURIOUS; |
| return wptid; |
| } |
| #endif |
| |
| #ifdef TDP_RFPPWAIT |
| if (pl.pl_flags & PL_FLAG_FORKED) |
| { |
| #ifndef PTRACE_VFORK |
| struct kinfo_proc kp; |
| #endif |
| ptid_t child_ptid; |
| pid_t child; |
| |
| child = pl.pl_child_pid; |
| ourstatus->kind = TARGET_WAITKIND_FORKED; |
| #ifdef PTRACE_VFORK |
| if (pl.pl_flags & PL_FLAG_VFORKED) |
| ourstatus->kind = TARGET_WAITKIND_VFORKED; |
| #endif |
| |
| /* Make sure the other end of the fork is stopped too. */ |
| child_ptid = fbsd_is_child_pending (child); |
| if (ptid_equal (child_ptid, null_ptid)) |
| { |
| pid = waitpid (child, &status, 0); |
| if (pid == -1) |
| perror_with_name (("waitpid")); |
| |
| gdb_assert (pid == child); |
| |
| if (ptrace (PT_LWPINFO, child, (caddr_t)&pl, sizeof pl) == -1) |
| perror_with_name (("ptrace")); |
| |
| gdb_assert (pl.pl_flags & PL_FLAG_CHILD); |
| child_ptid = ptid_build (child, pl.pl_lwpid, 0); |
| } |
| |
| /* Enable additional events on the child process. */ |
| fbsd_enable_proc_events (ptid_get_pid (child_ptid)); |
| |
| #ifndef PTRACE_VFORK |
| /* For vfork, the child process will have the P_PPWAIT |
| flag set. */ |
| if (fbsd_fetch_kinfo_proc (child, &kp)) |
| { |
| if (kp.ki_flag & P_PPWAIT) |
| ourstatus->kind = TARGET_WAITKIND_VFORKED; |
| } |
| else |
| warning (_("Failed to fetch process information")); |
| #endif |
| ourstatus->value.related_pid = child_ptid; |
| |
| return wptid; |
| } |
| |
| if (pl.pl_flags & PL_FLAG_CHILD) |
| { |
| /* Remember that this child forked, but do not report it |
| until the parent reports its corresponding fork |
| event. */ |
| fbsd_remember_child (wptid); |
| continue; |
| } |
| |
| #ifdef PTRACE_VFORK |
| if (pl.pl_flags & PL_FLAG_VFORK_DONE) |
| { |
| ourstatus->kind = TARGET_WAITKIND_VFORK_DONE; |
| return wptid; |
| } |
| #endif |
| #endif |
| |
| #ifdef PL_FLAG_EXEC |
| if (pl.pl_flags & PL_FLAG_EXEC) |
| { |
| ourstatus->kind = TARGET_WAITKIND_EXECD; |
| ourstatus->value.execd_pathname |
| = xstrdup (fbsd_pid_to_exec_file (NULL, pid)); |
| return wptid; |
| } |
| #endif |
| |
| /* Note that PL_FLAG_SCE is set for any event reported while |
| a thread is executing a system call in the kernel. In |
| particular, signals that interrupt a sleep in a system |
| call will report this flag as part of their event. Stops |
| explicitly for system call entry and exit always use |
| SIGTRAP, so only treat SIGTRAP events as system call |
| entry/exit events. */ |
| if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX) |
| && ourstatus->value.sig == SIGTRAP) |
| { |
| #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE |
| if (catch_syscall_enabled ()) |
| { |
| if (catching_syscall_number (pl.pl_syscall_code)) |
| { |
| if (pl.pl_flags & PL_FLAG_SCE) |
| ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY; |
| else |
| ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN; |
| ourstatus->value.syscall_number = pl.pl_syscall_code; |
| return wptid; |
| } |
| } |
| #endif |
| /* If the core isn't interested in this event, just |
| continue the process explicitly and wait for another |
| event. Note that PT_SYSCALL is "sticky" on FreeBSD |
| and once system call stops are enabled on a process |
| it stops for all system call entries and exits. */ |
| if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1) |
| perror_with_name (("ptrace")); |
| continue; |
| } |
| } |
| return wptid; |
| } |
| } |
| |
| #ifdef TDP_RFPPWAIT |
| /* Target hook for follow_fork. On entry and at return inferior_ptid is |
| the ptid of the followed inferior. */ |
| |
| static int |
| fbsd_follow_fork (struct target_ops *ops, int follow_child, |
| int detach_fork) |
| { |
| if (!follow_child && detach_fork) |
| { |
| struct thread_info *tp = inferior_thread (); |
| pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid); |
| |
| /* Breakpoints have already been detached from the child by |
| infrun.c. */ |
| |
| if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1) |
| perror_with_name (("ptrace")); |
| |
| #ifndef PTRACE_VFORK |
| if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED) |
| { |
| /* We can't insert breakpoints until the child process has |
| finished with the shared memory region. The parent |
| process doesn't wait for the child process to exit or |
| exec until after it has been resumed from the ptrace stop |
| to report the fork. Once it has been resumed it doesn't |
| stop again before returning to userland, so there is no |
| reliable way to wait on the parent. |
| |
| We can't stay attached to the child to wait for an exec |
| or exit because it may invoke ptrace(PT_TRACE_ME) |
| (e.g. if the parent process is a debugger forking a new |
| child process). |
| |
| In the end, the best we can do is to make sure it runs |
| for a little while. Hopefully it will be out of range of |
| any breakpoints we reinsert. Usually this is only the |
| single-step breakpoint at vfork's return point. */ |
| |
| usleep (10000); |
| |
| /* Schedule a fake VFORK_DONE event to report on the next |
| wait. */ |
| fbsd_add_vfork_done (inferior_ptid); |
| } |
| #endif |
| } |
| |
| return 0; |
| } |
| |
| static int |
| fbsd_insert_fork_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| |
| static int |
| fbsd_remove_fork_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| |
| static int |
| fbsd_insert_vfork_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| |
| static int |
| fbsd_remove_vfork_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| #endif |
| |
| /* Implement the "to_post_startup_inferior" target_ops method. */ |
| |
| static void |
| fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid) |
| { |
| fbsd_enable_proc_events (ptid_get_pid (pid)); |
| } |
| |
| /* Implement the "to_post_attach" target_ops method. */ |
| |
| static void |
| fbsd_post_attach (struct target_ops *self, int pid) |
| { |
| fbsd_enable_proc_events (pid); |
| fbsd_add_threads (pid); |
| } |
| |
| #ifdef PL_FLAG_EXEC |
| /* If the FreeBSD kernel supports PL_FLAG_EXEC, then traced processes |
| will always stop after exec. */ |
| |
| static int |
| fbsd_insert_exec_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| |
| static int |
| fbsd_remove_exec_catchpoint (struct target_ops *self, int pid) |
| { |
| return 0; |
| } |
| #endif |
| |
| #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE |
| static int |
| fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, bool needed, |
| int any_count, |
| gdb::array_view<const int> syscall_counts) |
| { |
| |
| /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which |
| will catch all system call entries and exits. The system calls |
| are filtered by GDB rather than the kernel. */ |
| return 0; |
| } |
| #endif |
| #endif |
| |
| void |
| fbsd_nat_add_target (struct target_ops *t) |
| { |
| t->to_pid_to_exec_file = fbsd_pid_to_exec_file; |
| t->to_find_memory_regions = fbsd_find_memory_regions; |
| t->to_info_proc = fbsd_info_proc; |
| #ifdef KERN_PROC_AUXV |
| super_xfer_partial = t->to_xfer_partial; |
| t->to_xfer_partial = fbsd_xfer_partial; |
| #endif |
| #ifdef PT_LWPINFO |
| t->to_thread_alive = fbsd_thread_alive; |
| t->to_pid_to_str = fbsd_pid_to_str; |
| #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME |
| t->to_thread_name = fbsd_thread_name; |
| #endif |
| t->to_update_thread_list = fbsd_update_thread_list; |
| t->to_has_thread_control = tc_schedlock; |
| super_resume = t->to_resume; |
| t->to_resume = fbsd_resume; |
| super_wait = t->to_wait; |
| t->to_wait = fbsd_wait; |
| t->to_post_startup_inferior = fbsd_post_startup_inferior; |
| t->to_post_attach = fbsd_post_attach; |
| #ifdef TDP_RFPPWAIT |
| t->to_follow_fork = fbsd_follow_fork; |
| t->to_insert_fork_catchpoint = fbsd_insert_fork_catchpoint; |
| t->to_remove_fork_catchpoint = fbsd_remove_fork_catchpoint; |
| t->to_insert_vfork_catchpoint = fbsd_insert_vfork_catchpoint; |
| t->to_remove_vfork_catchpoint = fbsd_remove_vfork_catchpoint; |
| #endif |
| #ifdef PL_FLAG_EXEC |
| t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint; |
| t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint; |
| #endif |
| #ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE |
| t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint; |
| #endif |
| #endif |
| add_target (t); |
| } |
| |
| void |
| _initialize_fbsd_nat (void) |
| { |
| #ifdef PT_LWPINFO |
| add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance, |
| &debug_fbsd_lwp, _("\ |
| Set debugging of FreeBSD lwp module."), _("\ |
| Show debugging of FreeBSD lwp module."), _("\ |
| Enables printf debugging output."), |
| NULL, |
| &show_fbsd_lwp_debug, |
| &setdebuglist, &showdebuglist); |
| #endif |
| } |