X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-nat.c;h=45b71ea8627fbf372a7af854a703dd22ad5aa138;hb=0c0adcc52478ebb707ed780173e18262df6eab7e;hp=ad5ec3d0b570bffd8be895321108dcec36f1c5fb;hpb=d3a70e03cf51c8fb6bc183eaff7559edffec2045;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c index ad5ec3d0b5..45b71ea862 100644 --- a/gdb/linux-nat.c +++ b/gdb/linux-nat.c @@ -1,6 +1,6 @@ /* GNU/Linux native-dependent code common to multiple platforms. - Copyright (C) 2001-2019 Free Software Foundation, Inc. + Copyright (C) 2001-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -23,7 +23,7 @@ #include "target.h" #include "nat/linux-nat.h" #include "nat/linux-waitpid.h" -#include "common/gdb_wait.h" +#include "gdbsupport/gdb_wait.h" #include #include #include "nat/gdb_ptrace.h" @@ -58,19 +58,16 @@ #include "nat/linux-osdata.h" #include "linux-tdep.h" #include "symfile.h" -#include "common/agent.h" +#include "gdbsupport/agent.h" #include "tracepoint.h" -#include "common/buffer.h" +#include "gdbsupport/buffer.h" #include "target-descriptions.h" -#include "common/filestuff.h" +#include "gdbsupport/filestuff.h" #include "objfiles.h" #include "nat/linux-namespaces.h" -#include "common/fileio.h" -#include "common/scope-exit.h" - -#ifndef SPUFS_MAGIC -#define SPUFS_MAGIC 0x23c9b64e -#endif +#include "gdbsupport/fileio.h" +#include "gdbsupport/scope-exit.h" +#include "gdbsupport/gdb-sigmask.h" /* This comment documents high-level logic of this file. @@ -518,9 +515,12 @@ linux_nat_target::follow_fork (int follow_child, int detach_fork) } else { - scoped_restore save_inferior_ptid - = make_scoped_restore (&inferior_ptid); - inferior_ptid = child_ptid; + /* Switching inferior_ptid is not enough, because then + inferior_thread () would crash by not finding the thread + in the current inferior. */ + scoped_restore_current_thread restore_current_thread; + thread_info *child = find_thread_ptid (this, child_ptid); + switch_to_thread (child); /* Let the thread_db layer learn about this new process. */ check_for_thread_db (); @@ -748,9 +748,6 @@ lwp_list_remove (struct lwp_info *lp) -/* Original signal mask. */ -static sigset_t normal_mask; - /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in _initialize_linux_nat. */ static sigset_t suspend_mask; @@ -771,7 +768,7 @@ block_child_signals (sigset_t *prev_mask) if (!sigismember (&blocked_mask, SIGCHLD)) sigaddset (&blocked_mask, SIGCHLD); - sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask); + gdb_sigmask (SIG_BLOCK, &blocked_mask, prev_mask); } /* Restore child signals mask, previously returned by @@ -780,7 +777,7 @@ block_child_signals (sigset_t *prev_mask) static void restore_child_signals_mask (sigset_t *prev_mask) { - sigprocmask (SIG_SETMASK, prev_mask, NULL); + gdb_sigmask (SIG_SETMASK, prev_mask, NULL); } /* Mask of signals to pass directly to the inferior. */ @@ -995,7 +992,7 @@ linux_nat_switch_fork (ptid_t new_ptid) /* This changes the thread's ptid while preserving the gdb thread num. Also changes the inferior pid, while preserving the inferior num. */ - thread_change_ptid (inferior_ptid, new_ptid); + thread_change_ptid (linux_target, inferior_ptid, new_ptid); /* We've just told GDB core that the thread changed target id, but, in fact, it really is a different thread, with different register @@ -1008,12 +1005,13 @@ linux_nat_switch_fork (ptid_t new_ptid) static void exit_lwp (struct lwp_info *lp) { - struct thread_info *th = find_thread_ptid (lp->ptid); + struct thread_info *th = find_thread_ptid (linux_target, lp->ptid); if (th) { if (print_thread_events) - printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid)); + printf_unfiltered (_("[%s exited]\n"), + target_pid_to_str (lp->ptid).c_str ()); delete_thread (th); } @@ -1149,7 +1147,7 @@ attach_proc_task_lwp_callback (ptid_t ptid) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "PTRACE_ATTACH %s, 0, 0 (OK)\n", - target_pid_to_str (ptid)); + target_pid_to_str (ptid).c_str ()); lp = add_lwp (ptid); @@ -1167,9 +1165,9 @@ attach_proc_task_lwp_callback (ptid_t ptid) /* Also add the LWP to gdb's thread list, in case a matching libthread_db is not found (or the process uses raw clone). */ - add_thread (lp->ptid); - set_running (lp->ptid, 1); - set_executing (lp->ptid, 1); + add_thread (linux_target, lp->ptid); + set_running (linux_target, lp->ptid, 1); + set_executing (linux_target, lp->ptid, 1); } return 1; @@ -1187,28 +1185,28 @@ linux_nat_target::attach (const char *args, int from_tty) /* Make sure we report all signals during attach. */ pass_signals ({}); - TRY + try { inf_ptrace_target::attach (args, from_tty); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { pid_t pid = parse_pid_to_attach (args); std::string reason = linux_ptrace_attach_fail_reason (pid); if (!reason.empty ()) - throw_error (ex.error, "warning: %s\n%s", reason.c_str (), ex.message); + throw_error (ex.error, "warning: %s\n%s", reason.c_str (), + ex.what ()); else - throw_error (ex.error, "%s", ex.message); + throw_error (ex.error, "%s", ex.what ()); } - END_CATCH /* The ptrace base target adds the main thread with (pid,0,0) format. Decorate it with lwp info. */ ptid = ptid_t (inferior_ptid.pid (), inferior_ptid.pid (), 0); - thread_change_ptid (inferior_ptid, ptid); + thread_change_ptid (linux_target, inferior_ptid, ptid); /* Add the initial process as the first LWP to the list. */ lp = add_initial_lwp (ptid); @@ -1309,7 +1307,7 @@ get_detach_signal (struct lwp_info *lp) signo = gdb_signal_from_host (WSTOPSIG (lp->status)); else { - struct thread_info *tp = find_thread_ptid (lp->ptid); + struct thread_info *tp = find_thread_ptid (linux_target, lp->ptid); if (target_is_non_stop_p () && !tp->executing) { @@ -1320,12 +1318,13 @@ get_detach_signal (struct lwp_info *lp) } else if (!target_is_non_stop_p ()) { - struct target_waitstatus last; ptid_t last_ptid; + process_stratum_target *last_target; - get_last_target_status (&last_ptid, &last); + get_last_target_status (&last_target, &last_ptid, nullptr); - if (lp->ptid.lwp () == last_ptid.lwp ()) + if (last_target == linux_target + && lp->ptid.lwp () == last_ptid.lwp ()) signo = tp->suspend.stop_signal; } } @@ -1335,7 +1334,7 @@ get_detach_signal (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "GPT: lwp %s has no pending signal\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else if (!signal_pass_state (signo)) { @@ -1343,7 +1342,7 @@ get_detach_signal (struct lwp_info *lp) fprintf_unfiltered (gdb_stdlog, "GPT: lwp %s had signal %s, " "but it is in no pass state\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), gdb_signal_to_string (signo)); } else @@ -1351,7 +1350,7 @@ get_detach_signal (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "GPT: lwp %s has pending signal %s\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), gdb_signal_to_string (signo)); return gdb_signal_to_host (signo); @@ -1375,7 +1374,7 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) if (debug_linux_nat && lp->status) fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n", strsignal (WSTOPSIG (lp->status)), - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* If there is a pending SIGSTOP, get rid of it. */ if (lp->signalled) @@ -1383,7 +1382,7 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "DC: Sending SIGCONT to %s\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); kill_lwp (lwpid, SIGCONT); lp->signalled = 0; @@ -1400,16 +1399,15 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) /* Preparing to resume may try to write registers, and fail if the lwp is zombie. If that happens, ignore the error. We'll handle it below, when detach fails with ESRCH. */ - TRY + try { linux_target->low_prepare_to_resume (lp); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (!check_ptrace_stopped_lwp_gone (lp)) - throw_exception (ex); + throw; } - END_CATCH if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0) { @@ -1427,7 +1425,7 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) if (ret == -1) { warning (_("Couldn't reap LWP %d while detaching: %s"), - lwpid, strerror (errno)); + lwpid, safe_strerror (errno)); } else if (!WIFEXITED (status) && !WIFSIGNALED (status)) { @@ -1438,7 +1436,8 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) } else { - error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid), + error (_("Can't detach %s: %s"), + target_pid_to_str (lp->ptid).c_str (), safe_strerror (save_errno)); } } @@ -1446,7 +1445,7 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) { fprintf_unfiltered (gdb_stdlog, "PTRACE_DETACH (%s, %s, 0) (OK)\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), strsignal (signo)); } @@ -1474,7 +1473,7 @@ linux_nat_target::detach (inferior *inf, int from_tty) inferiors running. */ /* Stop all threads before detaching. ptrace requires that the - thread is stopped to sucessfully detach. */ + thread is stopped to successfully detach. */ iterate_over_lwps (ptid_t (pid), stop_callback); /* ... and wait until all of them have reported back that they're no longer running. */ @@ -1522,7 +1521,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lp, int step, handle the case of stepping a breakpoint instruction). */ if (step) { - struct regcache *regcache = get_thread_regcache (lp->ptid); + struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid); lp->stop_pc = regcache_read_pc (regcache); } @@ -1541,7 +1540,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lp, int step, lp->stopped = 0; lp->core = -1; lp->stop_reason = TARGET_STOPPED_BY_NO_REASON; - registers_changed_ptid (lp->ptid); + registers_changed_ptid (linux_target, lp->ptid); } /* Called when we try to resume a stopped LWP and that errors out. If @@ -1582,16 +1581,15 @@ check_ptrace_stopped_lwp_gone (struct lwp_info *lp) static void linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo) { - TRY + try { linux_resume_one_lwp_throw (lp, step, signo); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (!check_ptrace_stopped_lwp_gone (lp)) - throw_exception (ex); + throw; } - END_CATCH } /* Resume LP. */ @@ -1601,21 +1599,21 @@ resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo) { if (lp->stopped) { - struct inferior *inf = find_inferior_ptid (lp->ptid); + struct inferior *inf = find_inferior_ptid (linux_target, lp->ptid); if (inf->vfork_child != NULL) { if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RC: Not resuming %s (vfork parent)\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else if (!lwp_status_pending_p (lp)) { if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RC: Resuming sibling %s, %s, %s\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), (signo != GDB_SIGNAL_0 ? strsignal (gdb_signal_to_host (signo)) : "0"), @@ -1628,7 +1626,7 @@ resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (has pending)\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } } else @@ -1636,7 +1634,7 @@ resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RC: Not resuming sibling %s (not stopped)\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } } @@ -1655,7 +1653,7 @@ linux_nat_resume_callback (struct lwp_info *lp, struct lwp_info *except) { struct thread_info *thread; - thread = find_thread_ptid (lp->ptid); + thread = find_thread_ptid (linux_target, lp->ptid); if (thread != NULL) { signo = thread->suspend.stop_signal; @@ -1693,10 +1691,10 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) fprintf_unfiltered (gdb_stdlog, "LLR: Preparing to %s %s, %s, inferior_ptid %s\n", step ? "step" : "resume", - target_pid_to_str (ptid), + target_pid_to_str (ptid).c_str (), (signo != GDB_SIGNAL_0 ? strsignal (gdb_signal_to_host (signo)) : "0"), - target_pid_to_str (inferior_ptid)); + target_pid_to_str (inferior_ptid).c_str ()); /* A specific PTID means `step only this process id'. */ resume_many = (minus_one_ptid == ptid @@ -1773,7 +1771,7 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) fprintf_unfiltered (gdb_stdlog, "LLR: %s %s, %s (resume event thread)\n", step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), (signo != GDB_SIGNAL_0 ? strsignal (gdb_signal_to_host (signo)) : "0")); @@ -1812,7 +1810,7 @@ linux_handle_syscall_trap (struct lwp_info *lp, int stopping) { struct target_waitstatus *ourstatus = &lp->waitstatus; struct gdbarch *gdbarch = target_thread_architecture (lp->ptid); - thread_info *thread = find_thread_ptid (lp->ptid); + thread_info *thread = find_thread_ptid (linux_target, lp->ptid); int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, thread); if (stopping) @@ -2032,15 +2030,15 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) /* The process is not using thread_db. Add the LWP to GDB's list. */ target_post_attach (new_lp->ptid.lwp ()); - add_thread (new_lp->ptid); + add_thread (linux_target, new_lp->ptid); } /* Even if we're stopping the thread for some reason internal to this module, from the perspective of infrun and the user/frontend, this new thread is running until it next reports a stop. */ - set_running (new_lp->ptid, 1); - set_executing (new_lp->ptid, 1); + set_running (linux_target, new_lp->ptid, 1); + set_executing (linux_target, new_lp->ptid, 1); if (WSTOPSIG (status) != SIGSTOP) { @@ -2174,7 +2172,7 @@ wait_lwp (struct lwp_info *lp) thread_dead = 1; if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } if (pid != 0) break; @@ -2200,7 +2198,7 @@ wait_lwp (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "WL: Thread group leader %s vanished.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); break; } @@ -2223,7 +2221,7 @@ wait_lwp (struct lwp_info *lp) { fprintf_unfiltered (gdb_stdlog, "WL: waitpid %s received %s\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), status_to_str (status)); } @@ -2248,7 +2246,7 @@ wait_lwp (struct lwp_info *lp) thread_dead = 1; if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } } @@ -2263,7 +2261,7 @@ wait_lwp (struct lwp_info *lp) if (lp->must_set_ptrace_flags) { - struct inferior *inf = find_inferior_pid (lp->ptid.pid ()); + inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ()); int options = linux_nat_ptrace_options (inf->attach_flag); linux_enable_event_reporting (lp->ptid.lwp (), options); @@ -2316,7 +2314,7 @@ stop_callback (struct lwp_info *lp) { fprintf_unfiltered (gdb_stdlog, "SC: kill %s ****\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } errno = 0; ret = kill_lwp (lp->ptid.lwp (), SIGSTOP); @@ -2417,7 +2415,7 @@ maybe_clear_ignore_sigint (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "MCIS: Clearing bogus flag for %s\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); lp->ignore_sigint = 0; } } @@ -2490,7 +2488,7 @@ linux_nat_target::low_status_is_event (int status) static int stop_wait_callback (struct lwp_info *lp) { - struct inferior *inf = find_inferior_ptid (lp->ptid); + inferior *inf = find_inferior_ptid (linux_target, lp->ptid); /* If this is a vfork parent, bail out, it is not going to report any SIGSTOP until the vfork is done with. */ @@ -2517,7 +2515,7 @@ stop_wait_callback (struct lwp_info *lp) fprintf_unfiltered (gdb_stdlog, "PTRACE_CONT %s, 0, 0 (%s) " "(discarding SIGINT)\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), errno ? safe_strerror (errno) : "OK"); return stop_wait_callback (lp); @@ -2533,7 +2531,7 @@ stop_wait_callback (struct lwp_info *lp) fprintf_unfiltered (gdb_stdlog, "SWC: Pending event %s in %s\n", status_to_str ((int) status), - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* Save the sigtrap event. */ lp->status = status; @@ -2547,7 +2545,7 @@ stop_wait_callback (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "SWC: Expected SIGSTOP caught for %s.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); lp->signalled = 0; @@ -2583,7 +2581,7 @@ status_callback (struct lwp_info *lp) if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT) { - struct regcache *regcache = get_thread_regcache (lp->ptid); + struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid); CORE_ADDR pc; int discard = 0; @@ -2594,7 +2592,7 @@ status_callback (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "SC: PC of %s changed. was=%s, now=%s\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), paddress (target_gdbarch (), lp->stop_pc), paddress (target_gdbarch (), pc)); discard = 1; @@ -2606,7 +2604,7 @@ status_callback (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "SC: previous breakpoint of %s, at %s gone\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), paddress (target_gdbarch (), lp->stop_pc)); discard = 1; @@ -2618,7 +2616,7 @@ status_callback (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "SC: pending event of %s cancelled.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); lp->status = 0; linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0); @@ -2704,7 +2702,7 @@ save_stop_reason (struct lwp_info *lp) if (!linux_target->low_status_is_event (lp->status)) return; - regcache = get_thread_regcache (lp->ptid); + regcache = get_thread_regcache (linux_target, lp->ptid); gdbarch = regcache->arch (); pc = regcache_read_pc (regcache); @@ -2744,7 +2742,7 @@ save_stop_reason (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "CSBB: %s stopped by trace\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* We may have single stepped an instruction that triggered a watchpoint. In that case, on some @@ -2777,7 +2775,7 @@ save_stop_reason (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "CSBB: %s stopped by software breakpoint\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* Back up the PC if necessary. */ if (pc != sw_bp_pc) @@ -2791,14 +2789,14 @@ save_stop_reason (struct lwp_info *lp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "CSBB: %s stopped by hardware breakpoint\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else if (lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT) { if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "CSBB: %s stopped by hardware watchpoint\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } lp->stop_pc = pc; @@ -2875,7 +2873,7 @@ select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "SEL: Select single-step %s\n", - target_pid_to_str (event_lp->ptid)); + target_pid_to_str (event_lp->ptid).c_str ()); } } @@ -2966,7 +2964,7 @@ linux_nat_filter_event (int lwpid, int status) lp = add_lwp (ptid_t (lwpid, lwpid, 0)); lp->stopped = 1; lp->resumed = 1; - add_thread (lp->ptid); + add_thread (linux_target, lp->ptid); } if (WIFSTOPPED (status) && !lp) @@ -2992,7 +2990,7 @@ linux_nat_filter_event (int lwpid, int status) if (WIFSTOPPED (status) && lp->must_set_ptrace_flags) { - struct inferior *inf = find_inferior_pid (lp->ptid.pid ()); + inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ()); int options = linux_nat_ptrace_options (inf->attach_flag); linux_enable_event_reporting (lp->ptid.lwp (), options); @@ -3038,7 +3036,7 @@ linux_nat_filter_event (int lwpid, int status) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "LLW: %s exited.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* If there is at least one more LWP, then the exit signal was not the end of the debugged application and should be @@ -3077,7 +3075,7 @@ linux_nat_filter_event (int lwpid, int status) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "LLW: resume_stop SIGSTOP caught for %s.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else { @@ -3088,7 +3086,7 @@ linux_nat_filter_event (int lwpid, int status) "LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n", lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0); gdb_assert (lp->resumed); @@ -3104,7 +3102,7 @@ linux_nat_filter_event (int lwpid, int status) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "LLW: Delayed SIGINT caught for %s.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); /* This is a delayed SIGINT. */ lp->ignore_sigint = 0; @@ -3115,7 +3113,7 @@ linux_nat_filter_event (int lwpid, int status) "LLW: %s %s, 0, 0 (discard SIGINT)\n", lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); gdb_assert (lp->resumed); /* Discard the event. */ @@ -3153,9 +3151,12 @@ linux_nat_filter_event (int lwpid, int status) /* When using hardware single-step, we need to report every signal. Otherwise, signals in pass_mask may be short-circuited - except signals that might be caused by a breakpoint. */ + except signals that might be caused by a breakpoint, or SIGSTOP + if we sent the SIGSTOP and are waiting for it to arrive. */ if (!lp->step && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)) + && (WSTOPSIG (status) != SIGSTOP + || !find_thread_ptid (linux_target, lp->ptid)->stop_requested) && !linux_wstatus_maybe_breakpoint (status)) { linux_resume_one_lwp (lp, lp->step, signo); @@ -3164,7 +3165,7 @@ linux_nat_filter_event (int lwpid, int status) "LLW: %s %s, %s (preempt 'handle')\n", lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), (signo != GDB_SIGNAL_0 ? strsignal (gdb_signal_to_host (signo)) : "0")); @@ -3274,7 +3275,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, if (inferior_ptid.is_pid ()) { /* Upgrade the main thread's ptid. */ - thread_change_ptid (inferior_ptid, + thread_change_ptid (linux_target, inferior_ptid, ptid_t (inferior_ptid.pid (), inferior_ptid.pid (), 0)); @@ -3293,7 +3294,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, fprintf_unfiltered (gdb_stdlog, "LLW: Using pending wait status %s for %s.\n", status_to_str (lp->status), - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } /* But if we don't find a pending event, we'll have to wait. Always @@ -3310,7 +3311,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, - If the thread group leader exits while other threads in the thread group still exist, waitpid(TGID, ...) hangs. That waitpid won't return an exit status until the other threads - in the group are reapped. + in the group are reaped. - When a non-leader thread execs, that thread just vanishes without reporting an exit (so we'd hang if we waited for it @@ -3419,7 +3420,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT && !USE_SIGTRAP_SIGINFO) { - struct regcache *regcache = get_thread_regcache (lp->ptid); + struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid); struct gdbarch *gdbarch = regcache->arch (); int decr_pc = gdbarch_decr_pc_after_break (gdbarch); @@ -3453,7 +3454,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "LLW: trap ptid is %s.\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE) @@ -3502,28 +3503,28 @@ resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RSRL: NOT resuming LWP %s, not stopped\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else if (!lp->resumed) { if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RSRL: NOT resuming LWP %s, not resumed\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else if (lwp_status_pending_p (lp)) { if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "RSRL: NOT resuming LWP %s, has pending status\n", - target_pid_to_str (lp->ptid)); + target_pid_to_str (lp->ptid).c_str ()); } else { - struct regcache *regcache = get_thread_regcache (lp->ptid); + struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid); struct gdbarch *gdbarch = regcache->arch (); - TRY + try { CORE_ADDR pc = regcache_read_pc (regcache); int leave_stopped = 0; @@ -3542,19 +3543,18 @@ resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid) fprintf_unfiltered (gdb_stdlog, "RSRL: resuming stopped-resumed LWP %s at " "%s: step=%d\n", - target_pid_to_str (lp->ptid), + target_pid_to_str (lp->ptid).c_str (), paddress (gdbarch, pc), lp->step); linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0); } } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (!check_ptrace_stopped_lwp_gone (lp)) - throw_exception (ex); + throw; } - END_CATCH } return 0; @@ -3571,7 +3571,7 @@ linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, std::string options_string = target_options_to_string (target_options); fprintf_unfiltered (gdb_stdlog, "linux_nat_wait: [%s], [%s]\n", - target_pid_to_str (ptid), + target_pid_to_str (ptid).c_str (), options_string.c_str ()); } @@ -3731,7 +3731,7 @@ linux_nat_target::kill () ptid_t ptid = ptid_t (inferior_ptid.pid ()); /* Stop all threads before killing them, since ptrace requires - that the thread is stopped to sucessfully PTRACE_KILL. */ + that the thread is stopped to successfully PTRACE_KILL. */ iterate_over_lwps (ptid, stop_callback); /* ... and wait until all of them have reported back that they're no longer running. */ @@ -3845,12 +3845,6 @@ linux_nat_xfer_osdata (enum target_object object, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len); -static enum target_xfer_status -linux_proc_xfer_spu (enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len); - static enum target_xfer_status linux_proc_xfer_partial (enum target_object object, const char *annex, gdb_byte *readbuf, @@ -3883,10 +3877,6 @@ linux_nat_target::xfer_partial (enum target_object object, return linux_nat_xfer_osdata (object, annex, readbuf, writebuf, offset, len, xfered_len); - if (object == TARGET_OBJECT_SPU) - return linux_proc_xfer_spu (object, annex, readbuf, writebuf, - offset, len, xfered_len); - /* GDB calculates all addresses in the largest possible address width. The address width must be masked before its final use - either by @@ -3943,18 +3933,13 @@ linux_nat_target::update_thread_list () } } -const char * +std::string linux_nat_target::pid_to_str (ptid_t ptid) { - static char buf[64]; - if (ptid.lwp_p () && (ptid.pid () != ptid.lwp () || num_lwps (ptid.pid ()) > 1)) - { - snprintf (buf, sizeof (buf), "LWP %ld", ptid.lwp ()); - return buf; - } + return string_printf ("LWP %ld", ptid.lwp ()); return normal_pid_to_str (ptid); } @@ -4029,121 +4014,6 @@ linux_proc_xfer_partial (enum target_object object, } -/* Enumerate spufs IDs for process PID. */ -static LONGEST -spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len) -{ - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); - LONGEST pos = 0; - LONGEST written = 0; - char path[128]; - DIR *dir; - struct dirent *entry; - - xsnprintf (path, sizeof path, "/proc/%d/fd", pid); - dir = opendir (path); - if (!dir) - return -1; - - rewinddir (dir); - while ((entry = readdir (dir)) != NULL) - { - struct stat st; - struct statfs stfs; - int fd; - - fd = atoi (entry->d_name); - if (!fd) - continue; - - xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd); - if (stat (path, &st) != 0) - continue; - if (!S_ISDIR (st.st_mode)) - continue; - - if (statfs (path, &stfs) != 0) - continue; - if (stfs.f_type != SPUFS_MAGIC) - continue; - - if (pos >= offset && pos + 4 <= offset + len) - { - store_unsigned_integer (buf + pos - offset, 4, byte_order, fd); - written += 4; - } - pos += 4; - } - - closedir (dir); - return written; -} - -/* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU - object type, using the /proc file system. */ - -static enum target_xfer_status -linux_proc_xfer_spu (enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) -{ - char buf[128]; - int fd = 0; - int ret = -1; - int pid = inferior_ptid.lwp (); - - if (!annex) - { - if (!readbuf) - return TARGET_XFER_E_IO; - else - { - LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len); - - if (l < 0) - return TARGET_XFER_E_IO; - else if (l == 0) - return TARGET_XFER_EOF; - else - { - *xfered_len = (ULONGEST) l; - return TARGET_XFER_OK; - } - } - } - - xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex); - fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0); - if (fd <= 0) - return TARGET_XFER_E_IO; - - if (offset != 0 - && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset) - { - close (fd); - return TARGET_XFER_EOF; - } - - if (writebuf) - ret = write (fd, writebuf, (size_t) len); - else if (readbuf) - ret = read (fd, readbuf, (size_t) len); - - close (fd); - - if (ret < 0) - return TARGET_XFER_E_IO; - else if (ret == 0) - return TARGET_XFER_EOF; - else - { - *xfered_len = (ULONGEST) ret; - return TARGET_XFER_OK; - } -} - - /* Parse LINE as a signal set and add its set bits to SIGS. */ static void @@ -4399,6 +4269,12 @@ linux_async_pipe (int enable) return previous; } +int +linux_nat_target::async_wait_fd () +{ + return linux_nat_event_pipe[0]; +} + /* target_async implementation. */ void @@ -4434,7 +4310,7 @@ linux_nat_stop_lwp (struct lwp_info *lwp) if (debug_linux_nat) fprintf_unfiltered (gdb_stdlog, "LNSL: running -> suspending %s\n", - target_pid_to_str (lwp->ptid)); + target_pid_to_str (lwp->ptid).c_str ()); if (lwp->last_resume_kind == resume_stop) @@ -4456,15 +4332,15 @@ linux_nat_stop_lwp (struct lwp_info *lwp) if (debug_linux_nat) { - if (find_thread_ptid (lwp->ptid)->stop_requested) + if (find_thread_ptid (linux_target, lwp->ptid)->stop_requested) fprintf_unfiltered (gdb_stdlog, "LNSL: already stopped/stop_requested %s\n", - target_pid_to_str (lwp->ptid)); + target_pid_to_str (lwp->ptid).c_str ()); else fprintf_unfiltered (gdb_stdlog, "LNSL: already stopped/no " "stop_requested yet %s\n", - target_pid_to_str (lwp->ptid)); + target_pid_to_str (lwp->ptid).c_str ()); } } return 0; @@ -4513,7 +4389,7 @@ linux_nat_target::thread_address_space (ptid_t ptid) pid = ptid.pid (); } - inf = find_inferior_pid (pid); + inf = find_inferior_pid (this, pid); gdb_assert (inf != NULL); return inf->aspace; } @@ -4690,9 +4566,6 @@ Enables printf debugging output."), NULL, &setdebuglist, &showdebuglist); - /* Save this mask as the default. */ - sigprocmask (SIG_SETMASK, NULL, &normal_mask); - /* Install a SIGCHLD handler. */ sigchld_action.sa_handler = sigchld_handler; sigemptyset (&sigchld_action.sa_mask); @@ -4702,7 +4575,7 @@ Enables printf debugging output."), sigaction (SIGCHLD, &sigchld_action, NULL); /* Make sure we don't block SIGCHLD during a sigsuspend. */ - sigprocmask (SIG_SETMASK, NULL, &suspend_mask); + gdb_sigmask (SIG_SETMASK, NULL, &suspend_mask); sigdelset (&suspend_mask, SIGCHLD); sigemptyset (&blocked_mask);