X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fnbsd-nat.c;h=7a07fbf6d8a74f377dea82ebc20d035bd0437836;hb=5bb6e9dd7090cacb02bbe9f20d8b101a59a3bf99;hp=b04e634b54911efe2fd570c800e281bc20c9cd17;hpb=f94b2e038757eeefd7351e8122160715d6e3ce3c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/nbsd-nat.c b/gdb/nbsd-nat.c index b04e634b54..7a07fbf6d8 100644 --- a/gdb/nbsd-nat.c +++ b/gdb/nbsd-nat.c @@ -20,6 +20,7 @@ #include "defs.h" #include "nbsd-nat.h" +#include "nat/netbsd-nat.h" #include "gdbthread.h" #include "nbsd-tdep.h" #include "inferior.h" @@ -36,13 +37,7 @@ char * nbsd_nat_target::pid_to_exec_file (int pid) { - static char buf[PATH_MAX]; - size_t buflen; - int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_PATHNAME}; - buflen = sizeof (buf); - if (sysctl (mib, ARRAY_SIZE (mib), buf, &buflen, NULL, 0)) - return NULL; - return buf; + return const_cast (netbsd_nat::pid_to_exec_file (pid)); } /* Return the current directory for the process identified by PID. */ @@ -80,12 +75,12 @@ nbsd_pid_to_cmdline (int pid) int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV}; size_t size = 0; - if (sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0) + if (::sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0) return nullptr; gdb::unique_xmalloc_ptr args (XNEWVAR (char, size)); - if (sysctl (mib, ARRAY_SIZE (mib), args.get (), &size, NULL, 0) == -1 + if (::sysctl (mib, ARRAY_SIZE (mib), args.get (), &size, NULL, 0) == -1 || size == 0) return nullptr; @@ -99,76 +94,12 @@ nbsd_pid_to_cmdline (int pid) return args; } -/* Generic thread (LWP) lister within a specified process. The callback - parameters is a C++ function that is called for each detected thread. */ - -static bool -nbsd_thread_lister (const pid_t pid, - gdb::function_view - callback) -{ - int mib[5] = {CTL_KERN, KERN_LWP, pid, sizeof (struct kinfo_lwp), 0}; - size_t size; - - if (sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0) - perror_with_name (("sysctl")); - - mib[4] = size / sizeof (size_t); - - gdb::unique_xmalloc_ptr kl - ((struct kinfo_lwp *) xcalloc (size, 1)); - - if (sysctl (mib, ARRAY_SIZE (mib), kl.get (), &size, NULL, 0) == -1 - || size == 0) - perror_with_name (("sysctl")); - - for (size_t i = 0; i < size / sizeof (struct kinfo_lwp); i++) - { - struct kinfo_lwp *l = &kl[i]; - - /* Return true if the specified thread is alive. */ - auto lwp_alive - = [] (struct kinfo_lwp *lwp) - { - switch (lwp->l_stat) - { - case LSSLEEP: - case LSRUN: - case LSONPROC: - case LSSTOP: - case LSSUSPENDED: - return true; - default: - return false; - } - }; - - /* Ignore embryonic or demised threads. */ - if (!lwp_alive (l)) - continue; - - if (callback (l)) - return true; - } - - return false; -} - /* Return true if PTID is still active in the inferior. */ bool nbsd_nat_target::thread_alive (ptid_t ptid) { - pid_t pid = ptid.pid (); - int lwp = ptid.lwp (); - - auto fn - = [&lwp] (const struct kinfo_lwp *kl) - { - return kl->l_lid == lwp; - }; - - return nbsd_thread_lister (pid, fn); + return netbsd_nat::thread_alive (ptid); } /* Return the name assigned to a thread by an application. Returns @@ -178,26 +109,7 @@ const char * nbsd_nat_target::thread_name (struct thread_info *thr) { ptid_t ptid = thr->ptid; - pid_t pid = ptid.pid (); - int lwp = ptid.lwp (); - - static char buf[KI_LNAMELEN] = {}; - - auto fn - = [&lwp] (const struct kinfo_lwp *kl) - { - if (kl->l_lid == lwp) - { - xsnprintf (buf, sizeof buf, "%s", kl->l_name); - return true; - } - return false; - }; - - if (nbsd_thread_lister (pid, fn)) - return buf; - else - return NULL; + return netbsd_nat::thread_name (ptid); } /* Implement the "post_attach" target_ops method. */ @@ -206,9 +118,8 @@ static void nbsd_add_threads (nbsd_nat_target *target, pid_t pid) { auto fn - = [&target, &pid] (const struct kinfo_lwp *kl) + = [&target] (ptid_t ptid) { - ptid_t ptid = ptid_t (pid, kl->l_lid, 0); if (!in_thread_list (target, ptid)) { if (inferior_ptid.lwp () == 0) @@ -216,10 +127,17 @@ nbsd_add_threads (nbsd_nat_target *target, pid_t pid) else add_thread (target, ptid); } - return false; }; - nbsd_thread_lister (pid, fn); + netbsd_nat::for_each_thread (pid, fn); +} + +/* Implement the "post_startup_inferior" target_ops method. */ + +void +nbsd_nat_target::post_startup_inferior (ptid_t ptid) +{ + netbsd_nat::enable_proc_events (ptid.pid ()); } /* Implement the "post_attach" target_ops method. */ @@ -227,6 +145,7 @@ nbsd_add_threads (nbsd_nat_target *target, pid_t pid) void nbsd_nat_target::post_attach (int pid) { + netbsd_nat::enable_proc_events (pid); nbsd_add_threads (this, pid); } @@ -235,9 +154,7 @@ nbsd_nat_target::post_attach (int pid) void nbsd_nat_target::update_thread_list () { - prune_threads (); - - nbsd_add_threads (this, inferior_ptid.pid ()); + delete_exited_threads (); } /* Convert PTID to a string. */ @@ -623,7 +540,8 @@ nbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal) /* Implement a safe wrapper around waitpid(). */ static pid_t -nbsd_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) +nbsd_wait (ptid_t ptid, struct target_waitstatus *ourstatus, + target_wait_flags options) { pid_t pid; int status; @@ -652,7 +570,7 @@ nbsd_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) ptid_t nbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, - int target_options) + target_wait_flags target_options) { pid_t pid = nbsd_wait (ptid, ourstatus, target_options); ptid_t wptid = ptid_t (pid); @@ -686,9 +604,61 @@ nbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, if (code <= SI_USER || code == SI_NOINFO) return wptid; + /* Process state for threading events */ + ptrace_state_t pst = {}; + if (code == TRAP_LWP) + { + if (ptrace (PT_GET_PROCESS_STATE, pid, &pst, sizeof (pst)) == -1) + perror_with_name (("ptrace")); + } + + if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_EXIT) + { + /* If GDB attaches to a multi-threaded process, exiting + threads might be skipped during post_attach that + have not yet reported their PTRACE_LWP_EXIT event. + Ignore exited events for an unknown LWP. */ + thread_info *thr = find_thread_ptid (this, wptid); + if (thr == nullptr) + ourstatus->kind = TARGET_WAITKIND_SPURIOUS; + else + { + ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED; + /* NetBSD does not store an LWP exit status. */ + ourstatus->value.integer = 0; + + if (print_thread_events) + printf_unfiltered (_("[%s exited]\n"), + target_pid_to_str (wptid).c_str ()); + delete_thread (thr); + } + + /* The GDB core expects that the rest of the threads are running. */ + if (ptrace (PT_CONTINUE, pid, (void *) 1, 0) == -1) + perror_with_name (("ptrace")); + + return wptid; + } + if (in_thread_list (this, ptid_t (pid))) thread_change_ptid (this, ptid_t (pid), wptid); + if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_CREATE) + { + /* If GDB attaches to a multi-threaded process, newborn + threads might be added by nbsd_add_threads that have + not yet reported their PTRACE_LWP_CREATE event. Ignore + born events for an already-known LWP. */ + if (in_thread_list (this, wptid)) + ourstatus->kind = TARGET_WAITKIND_SPURIOUS; + else + { + add_thread (this, wptid); + ourstatus->kind = TARGET_WAITKIND_THREAD_CREATED; + } + return wptid; + } + if (code == TRAP_EXEC) { ourstatus->kind = TARGET_WAITKIND_EXECD; @@ -761,3 +731,62 @@ nbsd_nat_target::set_syscall_catchpoint (int pid, bool needed, are filtered by GDB rather than the kernel. */ return 0; } + +/* Implement the "supports_multi_process" target_ops method. */ + +bool +nbsd_nat_target::supports_multi_process () +{ + return true; +} + +/* Implement the "xfer_partial" target_ops method. */ + +enum target_xfer_status +nbsd_nat_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) +{ + pid_t pid = inferior_ptid.pid (); + + switch (object) + { + case TARGET_OBJECT_SIGNAL_INFO: + { + len = netbsd_nat::qxfer_siginfo(pid, annex, readbuf, writebuf, offset, + len); + + if (len == -1) + return TARGET_XFER_E_IO; + + *xfered_len = len; + return TARGET_XFER_OK; + } + default: + return inf_ptrace_target::xfer_partial (object, annex, + readbuf, writebuf, offset, + len, xfered_len); + } +} + +/* Implement the "supports_dumpcore" target_ops method. */ + +bool +nbsd_nat_target::supports_dumpcore () +{ + return true; +} + +/* Implement the "dumpcore" target_ops method. */ + +void +nbsd_nat_target::dumpcore (const char *filename) +{ + pid_t pid = inferior_ptid.pid (); + + if (ptrace (PT_DUMPCORE, pid, const_cast(filename), + strlen (filename)) == -1) + perror_with_name (("ptrace")); +}