| /* Native-dependent code for FreeBSD. |
| |
| Copyright (C) 2002-2016 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 "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/sysctl.h> |
| #ifdef HAVE_KINFO_GETVMMAP |
| #include <sys/user.h> |
| #include <libutil.h> |
| #endif |
| |
| #include "elf-bfd.h" |
| #include "fbsd-nat.h" |
| |
| /* 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) |
| return 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 *vmentl, *kve; |
| uint64_t size; |
| struct cleanup *cleanup; |
| int i, nitems; |
| |
| vmentl = kinfo_getvmmap (pid, &nitems); |
| if (vmentl == NULL) |
| perror_with_name (_("Couldn't fetch VM map entries.")); |
| cleanup = make_cleanup (free, vmentl); |
| |
| for (i = 0; i < nitems; i++) |
| { |
| kve = &vmentl[i]; |
| |
| /* 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); |
| } |
| do_cleanups (cleanup); |
| 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); |
| char *mapfilename; |
| FILE *mapfile; |
| unsigned long start, end, size; |
| char protection[4]; |
| int read, write, exec; |
| struct cleanup *cleanup; |
| |
| mapfilename = xstrprintf ("/proc/%ld/map", (long) pid); |
| cleanup = make_cleanup (xfree, mapfilename); |
| mapfile = fopen (mapfilename, "r"); |
| if (mapfile == NULL) |
| error (_("Couldn't open %s."), mapfilename); |
| make_cleanup_fclose (mapfile); |
| |
| if (info_verbose) |
| fprintf_filtered (gdb_stdout, |
| "Reading memory regions from %s\n", mapfilename); |
| |
| /* Now iterate until end-of-file. */ |
| while (fbsd_read_mapping (mapfile, &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); |
| } |
| |
| do_cleanups (cleanup); |
| return 0; |
| } |
| #endif |
| |
| #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); |
| |
| /* 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) |
| { |
| case TARGET_OBJECT_AUXV: |
| { |
| struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); |
| unsigned char *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 = XCNEWVEC (unsigned char, buflen); |
| cleanup = make_cleanup (xfree, buf); |
| } |
| 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; |
| } |
| do_cleanups (cleanup); |
| *xfered_len = buflen; |
| return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK; |
| } |
| do_cleanups (cleanup); |
| 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 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); |
| } |
| |
| #if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME) |
| /* Fetch the external variant of the kernel's internal process |
| structure for the process PID into KP. */ |
| |
| static void |
| 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; |
| if (sysctl (mib, 4, kp, &len, NULL, 0) == -1) |
| perror_with_name (("sysctl")); |
| } |
| #endif |
| |
| /* |
| 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 is 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 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. */ |
| fbsd_fetch_kinfo_proc (pid, &kp); |
| 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 |
| |
| #ifdef PT_LWP_EVENTS |
| /* Enable LWP events for a specific process. |
| |
| To catch LWP events, PT_LWP_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_lwp_events (pid_t pid) |
| { |
| if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) |
| perror_with_name (("ptrace")); |
| } |
| #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) |
| { |
| struct cleanup *cleanup; |
| lwpid_t *lwps; |
| 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")); |
| |
| lwps = XCNEWVEC (lwpid_t, nlwps); |
| cleanup = make_cleanup (xfree, lwps); |
| |
| nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, 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); |
| } |
| } |
| do_cleanups (cleanup); |
| } |
| |
| /* 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 |
| } |
| |
| static void (*super_resume) (struct target_ops *, |
| ptid_t, |
| int, |
| enum gdb_signal); |
| |
| static int |
| resume_one_thread_cb (struct thread_info *tp, void *data) |
| { |
| ptid_t *ptid = (ptid_t *) data; |
| int request; |
| |
| if (ptid_get_pid (tp->ptid) != ptid_get_pid (*ptid)) |
| return 0; |
| |
| 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")); |
| return 0; |
| } |
| |
| static int |
| resume_all_threads_cb (struct thread_info *tp, void *data) |
| { |
| ptid_t *filter = (ptid_t *) data; |
| |
| if (!ptid_match (tp->ptid, *filter)) |
| return 0; |
| |
| if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1) |
| perror_with_name (("ptrace")); |
| return 0; |
| } |
| |
| /* 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 (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. */ |
| iterate_over_threads (resume_one_thread_cb, &ptid); |
| } |
| else |
| { |
| /* If ptid is a wildcard, resume all matching threads (they won't run |
| until the process is continued however). */ |
| iterate_over_threads (resume_all_threads_cb, &ptid); |
| ptid = inferior_ptid; |
| } |
| super_resume (ops, ptid, step, signo); |
| } |
| |
| #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. |
| */ |
| |
| struct fbsd_fork_child_info |
| { |
| struct fbsd_fork_child_info *next; |
| ptid_t child; /* Pid of new child. */ |
| }; |
| |
| static struct fbsd_fork_child_info *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) |
| { |
| struct fbsd_fork_child_info *info = XCNEW (struct fbsd_fork_child_info); |
| |
| info->child = pid; |
| info->next = fbsd_pending_children; |
| fbsd_pending_children = info; |
| } |
| |
| /* 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) |
| { |
| struct fbsd_fork_child_info *info, *prev; |
| ptid_t ptid; |
| |
| prev = NULL; |
| for (info = fbsd_pending_children; info; prev = info, info = info->next) |
| { |
| if (ptid_get_pid (info->child) == pid) |
| { |
| if (prev == NULL) |
| fbsd_pending_children = info->next; |
| else |
| prev->next = info->next; |
| ptid = info->child; |
| xfree (info); |
| return ptid; |
| } |
| } |
| return null_ptid; |
| } |
| #endif |
| |
| /* 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) |
| { |
| 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) |
| { |
| struct kinfo_proc kp; |
| ptid_t child_ptid; |
| pid_t child; |
| |
| child = pl.pl_child_pid; |
| ourstatus->kind = TARGET_WAITKIND_FORKED; |
| |
| /* 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); |
| } |
| |
| /* For vfork, the child process will have the P_PPWAIT |
| flag set. */ |
| fbsd_fetch_kinfo_proc (child, &kp); |
| if (kp.ki_flag & P_PPWAIT) |
| ourstatus->kind = TARGET_WAITKIND_VFORKED; |
| 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; |
| } |
| #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) |
| { |
| 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")); |
| } |
| |
| 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; |
| } |
| |
| /* Enable fork tracing for a specific process. |
| |
| 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. */ |
| |
| static void |
| fbsd_enable_follow_fork (pid_t pid) |
| { |
| if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1) |
| perror_with_name (("ptrace")); |
| } |
| #endif |
| |
| /* Implement the "to_post_startup_inferior" target_ops method. */ |
| |
| static void |
| fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid) |
| { |
| #ifdef TDP_RFPPWAIT |
| fbsd_enable_follow_fork (ptid_get_pid (pid)); |
| #endif |
| #ifdef PT_LWP_EVENTS |
| fbsd_enable_lwp_events (ptid_get_pid (pid)); |
| #endif |
| } |
| |
| /* Implement the "to_post_attach" target_ops method. */ |
| |
| static void |
| fbsd_post_attach (struct target_ops *self, int pid) |
| { |
| #ifdef TDP_RFPPWAIT |
| fbsd_enable_follow_fork (pid); |
| #endif |
| #ifdef PT_LWP_EVENTS |
| fbsd_enable_lwp_events (pid); |
| #endif |
| 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, int needed, |
| int any_count, int table_size, int *table) |
| { |
| |
| /* 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; |
| #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); |
| } |
| |
| /* Provide a prototype to silence -Wmissing-prototypes. */ |
| extern initialize_file_ftype _initialize_fbsd_nat; |
| |
| 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 |
| } |