X-Git-Url: https://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-nat.c;h=f1b2c744bed9be01ff21a74e86d2a45b60d4eb65;hb=dda83cd783075941aabe9b0292b004b11f00c831;hp=22e830391be3690fbea24d25e499835d6b53444a;hpb=85102364b2d1845fe9ae7d70096671a3ea4bccf3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c index 22e830391b..f1b2c744be 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. @@ -47,7 +47,7 @@ #include /* for struct stat */ #include /* for O_RDONLY */ #include "inf-loop.h" -#include "event-loop.h" +#include "gdbsupport/event-loop.h" #include "event-top.h" #include #include @@ -67,6 +67,8 @@ #include "nat/linux-namespaces.h" #include "gdbsupport/fileio.h" #include "gdbsupport/scope-exit.h" +#include "gdbsupport/gdb-sigmask.h" +#include "gdbsupport/common-debug.h" /* This comment documents high-level logic of this file. @@ -197,13 +199,23 @@ show_debug_linux_nat (struct ui_file *file, int from_tty, value); } +/* Print a linux-nat debug statement. */ + +#define linux_nat_debug_printf(fmt, ...) \ + do \ + { \ + if (debug_linux_nat) \ + debug_prefixed_printf ("linux-nat", __func__, fmt, ##__VA_ARGS__); \ + } \ + while (0) + struct simple_pid_list { int pid; int status; struct simple_pid_list *next; }; -struct simple_pid_list *stopped_pids; +static struct simple_pid_list *stopped_pids; /* Whether target_thread_events is in effect. */ static int report_thread_events; @@ -439,8 +451,8 @@ typedef std::unique_ptr lwp_info_up; ptid of the followed inferior. At return, inferior_ptid will be unchanged. */ -int -linux_nat_target::follow_fork (int follow_child, int detach_fork) +bool +linux_nat_target::follow_fork (bool follow_child, bool detach_fork) { if (!follow_child) { @@ -514,9 +526,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 (); @@ -531,10 +546,8 @@ linux_nat_target::follow_fork (int follow_child, int detach_fork) if (linux_supports_tracevforkdone ()) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LCFF: waiting for VFORK_DONE on %d\n", - parent_pid); + linux_nat_debug_printf ("waiting for VFORK_DONE on %d", + parent_pid); parent_lp->stopped = 1; /* We'll handle the VFORK_DONE event like any other @@ -573,10 +586,7 @@ linux_nat_target::follow_fork (int follow_child, int detach_fork) is only the single-step breakpoint at vfork's return point. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LCFF: no VFORK_DONE " - "support, sleeping a bit\n"); + linux_nat_debug_printf ("no VFORK_DONE support, sleeping a bit"); usleep (10000); @@ -607,7 +617,7 @@ linux_nat_target::follow_fork (int follow_child, int detach_fork) check_for_thread_db (); } - return 0; + return false; } @@ -764,7 +774,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 @@ -773,7 +783,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. */ @@ -792,7 +802,7 @@ linux_nat_target::pass_signals { int target_signo = gdb_signal_from_host (signo); if (target_signo < pass_signals.size () && pass_signals[target_signo]) - sigaddset (&pass_mask, signo); + sigaddset (&pass_mask, signo); } } @@ -988,7 +998,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 @@ -1001,7 +1011,7 @@ 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) { @@ -1026,9 +1036,7 @@ linux_nat_post_attach_wait (ptid_t ptid, int *signalled) if (linux_proc_pid_is_stopped (pid)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LNPAW: Attaching to a stopped process\n"); + linux_nat_debug_printf ("Attaching to a stopped process"); /* The process is definitely stopped. It is in a job control stop, unless the kernel predates the TASK_STOPPED / @@ -1036,7 +1044,7 @@ linux_nat_post_attach_wait (ptid_t ptid, int *signalled) ptrace stop. Make sure it is in a ptrace stop; from there we can kill it, signal it, et cetera. - First make sure there is a pending SIGSTOP. Since we are + First make sure there is a pending SIGSTOP. Since we are already attached, the process can not transition from stopped to running without a PTRACE_CONT; so we know this signal will go into the queue. The SIGSTOP generated by PTRACE_ATTACH is @@ -1059,19 +1067,16 @@ linux_nat_post_attach_wait (ptid_t ptid, int *signalled) if (!WIFSTOPPED (status)) { /* The pid we tried to attach has apparently just exited. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s", - pid, status_to_str (status)); + linux_nat_debug_printf ("Failed to stop %d: %s", pid, + status_to_str (status)); return status; } if (WSTOPSIG (status) != SIGSTOP) { *signalled = 1; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LNPAW: Received %s after attaching\n", - status_to_str (status)); + linux_nat_debug_printf ("Received %s after attaching", + status_to_str (status)); } return status; @@ -1121,13 +1126,10 @@ attach_proc_task_lwp_callback (ptid_t ptid) if (err == ESRCH || (err == EPERM && linux_proc_pid_is_gone (lwpid))) { - if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "Cannot attach to lwp %d: " - "thread is gone (%d: %s)\n", - lwpid, err, safe_strerror (err)); - } + linux_nat_debug_printf + ("Cannot attach to lwp %d: thread is gone (%d: %s)", + lwpid, err, safe_strerror (err)); + } else { @@ -1140,10 +1142,8 @@ attach_proc_task_lwp_callback (ptid_t ptid) } else { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "PTRACE_ATTACH %s, 0, 0 (OK)\n", - target_pid_to_str (ptid).c_str ()); + linux_nat_debug_printf ("PTRACE_ATTACH %s, 0, 0 (OK)", + target_pid_to_str (ptid).c_str ()); lp = add_lwp (ptid); @@ -1161,9 +1161,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, true); + set_executing (linux_target, lp->ptid, true); } return 1; @@ -1202,7 +1202,7 @@ linux_nat_target::attach (const char *args, int from_tty) 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); @@ -1245,10 +1245,8 @@ linux_nat_target::attach (const char *args, int from_tty) /* Save the wait status to report later. */ lp->resumed = 1; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LNA: waitpid %ld, saving status %s\n", - (long) lp->ptid.pid (), status_to_str (status)); + linux_nat_debug_printf ("waitpid %ld, saving status %s", + (long) lp->ptid.pid (), status_to_str (status)); lp->status = status; @@ -1303,7 +1301,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) { @@ -1314,39 +1312,33 @@ 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; } } if (signo == GDB_SIGNAL_0) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "GPT: lwp %s has no pending signal\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("lwp %s has no pending signal", + target_pid_to_str (lp->ptid).c_str ()); } else if (!signal_pass_state (signo)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "GPT: lwp %s had signal %s, " - "but it is in no pass state\n", - target_pid_to_str (lp->ptid).c_str (), - gdb_signal_to_string (signo)); + linux_nat_debug_printf + ("lwp %s had signal %s but it is in no pass state", + target_pid_to_str (lp->ptid).c_str (), gdb_signal_to_string (signo)); } else { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "GPT: lwp %s has pending signal %s\n", - target_pid_to_str (lp->ptid).c_str (), - gdb_signal_to_string (signo)); + linux_nat_debug_printf ("lwp %s has pending signal %s", + target_pid_to_str (lp->ptid).c_str (), + gdb_signal_to_string (signo)); return gdb_signal_to_host (signo); } @@ -1366,18 +1358,16 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status)); - 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).c_str ()); + if (lp->status != 0) + linux_nat_debug_printf ("Pending %s for %s on detach.", + strsignal (WSTOPSIG (lp->status)), + target_pid_to_str (lp->ptid).c_str ()); /* If there is a pending SIGSTOP, get rid of it. */ if (lp->signalled) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "DC: Sending SIGCONT to %s\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Sending SIGCONT to %s", + target_pid_to_str (lp->ptid).c_str ()); kill_lwp (lwpid, SIGCONT); lp->signalled = 0; @@ -1420,7 +1410,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)) { @@ -1436,13 +1426,10 @@ detach_one_lwp (struct lwp_info *lp, int *signo_p) safe_strerror (save_errno)); } } - else if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "PTRACE_DETACH (%s, %s, 0) (OK)\n", - target_pid_to_str (lp->ptid).c_str (), - strsignal (signo)); - } + else + linux_nat_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)", + target_pid_to_str (lp->ptid).c_str (), + strsignal (signo)); delete_lwp (lp->ptid); } @@ -1468,7 +1455,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. */ @@ -1516,7 +1503,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); } @@ -1535,7 +1522,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 @@ -1594,43 +1581,33 @@ 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).c_str ()); + linux_nat_debug_printf ("Not resuming %s (vfork parent)", + 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).c_str (), - (signo != GDB_SIGNAL_0 - ? strsignal (gdb_signal_to_host (signo)) - : "0"), - step ? "step" : "resume"); + linux_nat_debug_printf ("Resuming sibling %s, %s, %s", + target_pid_to_str (lp->ptid).c_str (), + (signo != GDB_SIGNAL_0 + ? strsignal (gdb_signal_to_host (signo)) + : "0"), + step ? "step" : "resume"); linux_resume_one_lwp (lp, step, signo); } else { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "RC: Not resuming sibling %s (has pending)\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Not resuming sibling %s (has pending)", + target_pid_to_str (lp->ptid).c_str ()); } } else - { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "RC: Not resuming sibling %s (not stopped)\n", + linux_nat_debug_printf ("Not resuming sibling %s (not stopped)", target_pid_to_str (lp->ptid).c_str ()); - } } /* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing. @@ -1648,7 +1625,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; @@ -1682,20 +1659,19 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) struct lwp_info *lp; int resume_many; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLR: Preparing to %s %s, %s, inferior_ptid %s\n", - step ? "step" : "resume", - target_pid_to_str (ptid).c_str (), - (signo != GDB_SIGNAL_0 - ? strsignal (gdb_signal_to_host (signo)) : "0"), - target_pid_to_str (inferior_ptid).c_str ()); + linux_nat_debug_printf ("Preparing to %s %s, %s, inferior_ptid %s", + step ? "step" : "resume", + target_pid_to_str (ptid).c_str (), + (signo != GDB_SIGNAL_0 + ? strsignal (gdb_signal_to_host (signo)) : "0"), + target_pid_to_str (inferior_ptid).c_str ()); /* A specific PTID means `step only this process id'. */ resume_many = (minus_one_ptid == ptid || ptid.is_pid ()); - /* Mark the lwps we're resuming as resumed. */ + /* Mark the lwps we're resuming as resumed and update their + last_resume_kind to resume_continue. */ iterate_over_lwps (ptid, resume_set_callback); /* See if it's the current inferior that should be handled @@ -1723,10 +1699,8 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) && WSTOPSIG (lp->status) && sigismember (&pass_mask, WSTOPSIG (lp->status))) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLR: Not short circuiting for ignored " - "status 0x%x\n", lp->status); + linux_nat_debug_printf + ("Not short circuiting for ignored status 0x%x", lp->status); /* FIXME: What should we do if we are supposed to continue this thread with a signal? */ @@ -1742,10 +1716,8 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) this thread with a signal? */ gdb_assert (signo == GDB_SIGNAL_0); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLR: Short circuiting for status 0x%x\n", - lp->status); + linux_nat_debug_printf ("Short circuiting for status 0x%x", + lp->status); if (target_can_async_p ()) { @@ -1762,13 +1734,11 @@ linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo) return linux_nat_resume_callback (info, lp); }); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLR: %s %s, %s (resume event thread)\n", - step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid).c_str (), - (signo != GDB_SIGNAL_0 - ? strsignal (gdb_signal_to_host (signo)) : "0")); + linux_nat_debug_printf ("%s %s, %s (resume event thread)", + step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid).c_str (), + (signo != GDB_SIGNAL_0 + ? strsignal (gdb_signal_to_host (signo)) : "0")); linux_resume_one_lwp (lp, step, signo); @@ -1805,7 +1775,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) @@ -1830,13 +1800,9 @@ linux_handle_syscall_trap (struct lwp_info *lp, int stopping) actually get to execute. It seems it would be even more confusing to the user. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHST: ignoring syscall %d " - "for LWP %ld (stopping threads), " - "resuming with PTRACE_CONT for SIGSTOP\n", - syscall_number, - lp->ptid.lwp ()); + linux_nat_debug_printf + ("ignoring syscall %d for LWP %ld (stopping threads), resuming with " + "PTRACE_CONT for SIGSTOP", syscall_number, lp->ptid.lwp ()); lp->syscall_state = TARGET_WAITKIND_IGNORE; ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0); @@ -1861,26 +1827,18 @@ linux_handle_syscall_trap (struct lwp_info *lp, int stopping) ourstatus->kind = lp->syscall_state; ourstatus->value.syscall_number = syscall_number; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHST: stopping for %s of syscall %d" - " for LWP %ld\n", - lp->syscall_state - == TARGET_WAITKIND_SYSCALL_ENTRY - ? "entry" : "return", - syscall_number, - lp->ptid.lwp ()); + linux_nat_debug_printf + ("stopping for %s of syscall %d for LWP %ld", + (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY + ? "entry" : "return"), syscall_number, lp->ptid.lwp ()); + return 0; } - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHST: ignoring %s of syscall %d " - "for LWP %ld\n", - lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY - ? "entry" : "return", - syscall_number, - lp->ptid.lwp ()); + linux_nat_debug_printf + ("ignoring %s of syscall %d for LWP %ld", + (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY + ? "entry" : "return"), syscall_number, lp->ptid.lwp ()); } else { @@ -1900,13 +1858,9 @@ linux_handle_syscall_trap (struct lwp_info *lp, int stopping) The points above mean that the next resume, be it PT_STEP or PT_CONTINUE, can not trigger a syscall trace event. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHST: caught syscall event " - "with no syscall catchpoints." - " %d for LWP %ld, ignoring\n", - syscall_number, - lp->ptid.lwp ()); + linux_nat_debug_printf + ("caught syscall event with no syscall catchpoints. %d for LWP %ld, " + "ignoring", syscall_number, lp->ptid.lwp ()); lp->syscall_state = TARGET_WAITKIND_IGNORE; } @@ -1972,6 +1926,10 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) inferior. */ linux_target->low_new_fork (lp, new_pid); } + else if (event == PTRACE_EVENT_CLONE) + { + linux_target->low_new_clone (lp, new_pid); + } if (event == PTRACE_EVENT_FORK && linux_fork_checkpointing_p (lp->ptid.pid ())) @@ -2007,11 +1965,8 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) ourstatus->kind = TARGET_WAITKIND_IGNORE; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: Got clone event " - "from LWP %d, new child is LWP %ld\n", - pid, new_pid); + linux_nat_debug_printf + ("Got clone event from LWP %d, new child is LWP %ld", pid, new_pid); new_lp = add_lwp (ptid_t (lp->ptid.pid (), new_pid, 0)); new_lp->stopped = 1; @@ -2025,15 +1980,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, true); + set_executing (linux_target, new_lp->ptid, true); if (WSTOPSIG (status) != SIGSTOP) { @@ -2050,12 +2005,9 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) gdb_assert (new_lp->status == 0); /* Save the wait status to report later. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: waitpid of new LWP %ld, " - "saving status %s\n", - (long) new_lp->ptid.lwp (), - status_to_str (status)); + linux_nat_debug_printf + ("waitpid of new LWP %ld, saving status %s", + (long) new_lp->ptid.lwp (), status_to_str (status)); new_lp->status = status; } else if (report_thread_events) @@ -2072,10 +2024,7 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) if (event == PTRACE_EVENT_EXEC) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: Got exec event from LWP %ld\n", - lp->ptid.lwp ()); + linux_nat_debug_printf ("Got exec event from LWP %ld", lp->ptid.lwp ()); ourstatus->kind = TARGET_WAITKIND_EXECD; ourstatus->value.execd_pathname @@ -2092,21 +2041,17 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) { if (current_inferior ()->waiting_for_vfork_done) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: Got expected PTRACE_EVENT_" - "VFORK_DONE from LWP %ld: stopping\n", - lp->ptid.lwp ()); + linux_nat_debug_printf + ("Got expected PTRACE_EVENT_VFORK_DONE from LWP %ld: stopping", + lp->ptid.lwp ()); ourstatus->kind = TARGET_WAITKIND_VFORK_DONE; return 0; } - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: Got PTRACE_EVENT_VFORK_DONE " - "from LWP %ld: ignoring\n", - lp->ptid.lwp ()); + linux_nat_debug_printf + ("Got PTRACE_EVENT_VFORK_DONE from LWP %ld: ignoring", lp->ptid.lwp ()); + return 1; } @@ -2120,8 +2065,7 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) static void wait_for_signal () { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "linux-nat: about to sigsuspend\n"); + linux_nat_debug_printf ("about to sigsuspend"); sigsuspend (&suspend_mask); /* If the quit flag is set, it means that the user pressed Ctrl-C @@ -2165,9 +2109,8 @@ wait_lwp (struct lwp_info *lp) won't get an exit event. See comments on exec events at the top of the file. */ thread_dead = 1; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s vanished.", + target_pid_to_str (lp->ptid).c_str ()); } if (pid != 0) break; @@ -2190,10 +2133,8 @@ wait_lwp (struct lwp_info *lp) && linux_proc_pid_is_zombie (lp->ptid.lwp ())) { thread_dead = 1; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "WL: Thread group leader %s vanished.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Thread group leader %s vanished.", + target_pid_to_str (lp->ptid).c_str ()); break; } @@ -2212,13 +2153,9 @@ wait_lwp (struct lwp_info *lp) { gdb_assert (pid == lp->ptid.lwp ()); - if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "WL: waitpid %s received %s\n", + linux_nat_debug_printf ("waitpid %s received %s", target_pid_to_str (lp->ptid).c_str (), status_to_str (status)); - } /* Check if the thread has exited. */ if (WIFEXITED (status) || WIFSIGNALED (status)) @@ -2226,9 +2163,7 @@ wait_lwp (struct lwp_info *lp) if (report_thread_events || lp->ptid.pid () == lp->ptid.lwp ()) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "WL: LWP %d exited.\n", - lp->ptid.pid ()); + linux_nat_debug_printf ("LWP %d exited.", lp->ptid.pid ()); /* If this is the leader exiting, it means the whole process is gone. Store the status to report to the @@ -2239,9 +2174,8 @@ 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).c_str ()); + linux_nat_debug_printf ("%s exited.", + target_pid_to_str (lp->ptid).c_str ()); } } @@ -2256,7 +2190,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); @@ -2285,10 +2219,7 @@ wait_lwp (struct lwp_info *lp) if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "WL: Handling extended status 0x%06x\n", - status); + linux_nat_debug_printf ("Handling extended status 0x%06x", status); linux_handle_extended_wait (lp, status); return 0; } @@ -2305,21 +2236,13 @@ stop_callback (struct lwp_info *lp) { int ret; - if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "SC: kill %s ****\n", + linux_nat_debug_printf ("kill %s ****", target_pid_to_str (lp->ptid).c_str ()); - } + errno = 0; ret = kill_lwp (lp->ptid.lwp (), SIGSTOP); - if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "SC: lwp kill %d %s\n", - ret, + linux_nat_debug_printf ("lwp kill %d %s", ret, errno ? safe_strerror (errno) : "ERRNO-OK"); - } lp->signalled = 1; gdb_assert (lp->status == 0); @@ -2407,10 +2330,8 @@ maybe_clear_ignore_sigint (struct lwp_info *lp) if (!linux_nat_has_pending_sigint (lp->ptid.lwp ())) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "MCIS: Clearing bogus flag for %s\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Clearing bogus flag for %s", + target_pid_to_str (lp->ptid).c_str ()); lp->ignore_sigint = 0; } } @@ -2483,7 +2404,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. */ @@ -2506,12 +2427,10 @@ stop_wait_callback (struct lwp_info *lp) errno = 0; ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0); lp->stopped = 0; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "PTRACE_CONT %s, 0, 0 (%s) " - "(discarding SIGINT)\n", - target_pid_to_str (lp->ptid).c_str (), - errno ? safe_strerror (errno) : "OK"); + linux_nat_debug_printf + ("PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)", + target_pid_to_str (lp->ptid).c_str (), + errno ? safe_strerror (errno) : "OK"); return stop_wait_callback (lp); } @@ -2522,11 +2441,9 @@ stop_wait_callback (struct lwp_info *lp) { /* The thread was stopped with a signal other than SIGSTOP. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SWC: Pending event %s in %s\n", - status_to_str ((int) status), - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Pending event %s in %s", + status_to_str ((int) status), + target_pid_to_str (lp->ptid).c_str ()); /* Save the sigtrap event. */ lp->status = status; @@ -2537,10 +2454,8 @@ stop_wait_callback (struct lwp_info *lp) { /* We caught the SIGSTOP that we intended to catch. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SWC: Expected SIGSTOP caught for %s.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Expected SIGSTOP caught for %s.", + target_pid_to_str (lp->ptid).c_str ()); lp->signalled = 0; @@ -2576,7 +2491,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; @@ -2584,23 +2499,19 @@ status_callback (struct lwp_info *lp) if (pc != lp->stop_pc) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SC: PC of %s changed. was=%s, now=%s\n", - target_pid_to_str (lp->ptid).c_str (), - paddress (target_gdbarch (), lp->stop_pc), - paddress (target_gdbarch (), pc)); + linux_nat_debug_printf ("PC of %s changed. was=%s, now=%s", + target_pid_to_str (lp->ptid).c_str (), + paddress (target_gdbarch (), lp->stop_pc), + paddress (target_gdbarch (), pc)); discard = 1; } #if !USE_SIGTRAP_SIGINFO else if (!breakpoint_inserted_here_p (regcache->aspace (), pc)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SC: previous breakpoint of %s, at %s gone\n", - target_pid_to_str (lp->ptid).c_str (), - paddress (target_gdbarch (), lp->stop_pc)); + linux_nat_debug_printf ("previous breakpoint of %s, at %s gone", + target_pid_to_str (lp->ptid).c_str (), + paddress (target_gdbarch (), lp->stop_pc)); discard = 1; } @@ -2608,10 +2519,8 @@ status_callback (struct lwp_info *lp) if (discard) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SC: pending event of %s cancelled.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("pending event of %s cancelled.", + target_pid_to_str (lp->ptid).c_str ()); lp->status = 0; linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0); @@ -2697,7 +2606,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); @@ -2720,7 +2629,7 @@ save_stop_reason (struct lwp_info *lp) { /* If we determine the LWP stopped for a SW breakpoint, trust it. Particularly don't check watchpoint - registers, because at least on s390, we'd find + registers, because, at least on s390, we'd find stopped-by-watchpoint as long as there's a watchpoint set. */ lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT; @@ -2734,10 +2643,8 @@ save_stop_reason (struct lwp_info *lp) } else if (siginfo.si_code == TRAP_TRACE) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "CSBB: %s stopped by trace\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s stopped by trace", + target_pid_to_str (lp->ptid).c_str ()); /* We may have single stepped an instruction that triggered a watchpoint. In that case, on some @@ -2767,10 +2674,8 @@ save_stop_reason (struct lwp_info *lp) if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "CSBB: %s stopped by software breakpoint\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s stopped by software breakpoint", + target_pid_to_str (lp->ptid).c_str ()); /* Back up the PC if necessary. */ if (pc != sw_bp_pc) @@ -2781,17 +2686,13 @@ save_stop_reason (struct lwp_info *lp) } else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "CSBB: %s stopped by hardware breakpoint\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s stopped by hardware breakpoint", + 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).c_str ()); + linux_nat_debug_printf ("%s stopped by hardware watchpoint", + target_pid_to_str (lp->ptid).c_str ()); } lp->stop_pc = pc; @@ -2865,10 +2766,8 @@ select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status) event_lp = iterate_over_lwps (filter, select_singlestep_lwp_callback); if (event_lp != NULL) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "SEL: Select single-step %s\n", - target_pid_to_str (event_lp->ptid).c_str ()); + linux_nat_debug_printf ("Select single-step %s", + target_pid_to_str (event_lp->ptid).c_str ()); } } @@ -2889,10 +2788,9 @@ select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status) random_selector = (int) ((num_events * (double) rand ()) / (RAND_MAX + 1.0)); - if (debug_linux_nat && num_events > 1) - fprintf_unfiltered (gdb_stdlog, - "SEL: Found %d events, selecting #%d\n", - num_events, random_selector); + if (num_events > 1) + linux_nat_debug_printf ("Found %d events, selecting #%d", + num_events, random_selector); event_lp = (iterate_over_lwps @@ -2924,7 +2822,7 @@ resumed_callback (struct lwp_info *lp) } /* Check if we should go on and pass this event to common code. - Return the affected lwp if we are, or NULL otherwise. */ + Return the affected lwp if we should, or NULL otherwise. */ static struct lwp_info * linux_nat_filter_event (int lwpid, int status) @@ -2951,23 +2849,18 @@ linux_nat_filter_event (int lwpid, int status) && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC)) { /* A multi-thread exec after we had seen the leader exiting. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: Re-adding thread group leader LWP %d.\n", - lwpid); + linux_nat_debug_printf ("Re-adding thread group leader LWP %d.", lwpid); 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) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LHEW: saving LWP %ld status %s in stopped_pids list\n", - (long) lwpid, status_to_str (status)); + linux_nat_debug_printf ("saving LWP %ld status %s in stopped_pids list", + (long) lwpid, status_to_str (status)); add_to_pid_list (&stopped_pids, lwpid, status); return NULL; } @@ -2985,7 +2878,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); @@ -3014,10 +2907,8 @@ linux_nat_filter_event (int lwpid, int status) if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: Handling extended status 0x%06x\n", - status); + linux_nat_debug_printf ("Handling extended status 0x%06x", status); + if (linux_handle_extended_wait (lp, status)) return NULL; } @@ -3028,10 +2919,8 @@ linux_nat_filter_event (int lwpid, int status) if (!report_thread_events && num_lwps (lp->ptid.pid ()) > 1) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s exited.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s exited.", + 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 @@ -3044,10 +2933,8 @@ linux_nat_filter_event (int lwpid, int status) exit, if e.g., some other thread brings down the whole process (calls `exit'). So don't assert that the lwp is resumed. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LWP %ld exited (resumed=%d)\n", - lp->ptid.lwp (), lp->resumed); + linux_nat_debug_printf ("LWP %ld exited (resumed=%d)", + lp->ptid.lwp (), lp->resumed); /* Dead LWP's aren't expected to reported a pending sigstop. */ lp->signalled = 0; @@ -3067,21 +2954,17 @@ linux_nat_filter_event (int lwpid, int status) if (lp->last_resume_kind == resume_stop) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: resume_stop SIGSTOP caught for %s.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("resume_stop SIGSTOP caught for %s.", + target_pid_to_str (lp->ptid).c_str ()); } else { /* This is a delayed SIGSTOP. Filter out the event. */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n", - lp->step ? - "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf + ("%s %s, 0, 0 (discard delayed SIGSTOP)", + lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid).c_str ()); linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0); gdb_assert (lp->resumed); @@ -3094,21 +2977,16 @@ linux_nat_filter_event (int lwpid, int status) if (lp->ignore_sigint && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: Delayed SIGINT caught for %s.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Delayed SIGINT caught for %s.", + target_pid_to_str (lp->ptid).c_str ()); /* This is a delayed SIGINT. */ lp->ignore_sigint = 0; linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, 0, 0 (discard SIGINT)\n", - lp->step ? - "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("%s %s, 0, 0 (discard SIGINT)", + lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid).c_str ()); gdb_assert (lp->resumed); /* Discard the event. */ @@ -3117,7 +2995,7 @@ linux_nat_filter_event (int lwpid, int status) /* Don't report signals that GDB isn't interested in, such as signals that are neither printed nor stopped upon. Stopping all - threads can be a bit time-consuming so if we want decent + threads can be a bit time-consuming, so if we want decent performance with heavily multi-threaded programs, especially when they're using a high frequency timer, we'd better avoid it if we can. */ @@ -3151,19 +3029,16 @@ linux_nat_filter_event (int lwpid, int status) if (!lp->step && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)) && (WSTOPSIG (status) != SIGSTOP - || !find_thread_ptid (lp->ptid)->stop_requested) + || !find_thread_ptid (linux_target, lp->ptid)->stop_requested) && !linux_wstatus_maybe_breakpoint (status)) { linux_resume_one_lwp (lp, lp->step, signo); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, %s (preempt 'handle')\n", - lp->step ? - "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid).c_str (), - (signo != GDB_SIGNAL_0 - ? strsignal (gdb_signal_to_host (signo)) - : "0")); + linux_nat_debug_printf + ("%s %s, %s (preempt 'handle')", + lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid).c_str (), + (signo != GDB_SIGNAL_0 + ? strsignal (gdb_signal_to_host (signo)) : "0")); return NULL; } } @@ -3195,11 +3070,9 @@ check_zombie_leaders (void) && num_lwps (inf->pid) > 1 && linux_proc_pid_is_zombie (inf->pid)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "CZL: Thread group leader %d zombie " - "(it exited, or another thread execd).\n", - inf->pid); + linux_nat_debug_printf ("Thread group leader %d zombie " + "(it exited, or another thread execd).", + inf->pid); /* A leader zombie can mean one of two things: @@ -3219,10 +3092,7 @@ check_zombie_leaders (void) previous leader did exit voluntarily before some other thread execs). */ - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "CZL: Thread group leader %d vanished.\n", - inf->pid); + linux_nat_debug_printf ("Thread group leader %d vanished.", inf->pid); exit_lwp (leader_lp); } } @@ -3254,27 +3124,25 @@ filter_exit_event (struct lwp_info *event_child, static ptid_t linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, - int target_options) + target_wait_flags target_options) { sigset_t prev_mask; enum resume_kind last_resume_kind; struct lwp_info *lp; int status; - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "LLW: enter\n"); + linux_nat_debug_printf ("enter"); /* The first time we get here after starting a new inferior, we may not have added it to the LWP list yet - this is the earliest moment at which we know its PID. */ - if (inferior_ptid.is_pid ()) + if (ptid.is_pid () && find_lwp_pid (ptid) == nullptr) { - /* Upgrade the main thread's ptid. */ - thread_change_ptid (inferior_ptid, - ptid_t (inferior_ptid.pid (), - inferior_ptid.pid (), 0)); + ptid_t lwp_ptid (ptid.pid (), ptid.pid ()); - lp = add_initial_lwp (inferior_ptid); + /* Upgrade the main thread's ptid. */ + thread_change_ptid (linux_target, ptid, lwp_ptid); + lp = add_initial_lwp (lwp_ptid); lp->resumed = 1; } @@ -3285,11 +3153,9 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, lp = iterate_over_lwps (ptid, status_callback); if (lp != NULL) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: Using pending wait status %s for %s.\n", - status_to_str (lp->status), - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("Using pending wait status %s for %s.", + status_to_str (lp->status), + target_pid_to_str (lp->ptid).c_str ()); } /* But if we don't find a pending event, we'll have to wait. Always @@ -3316,19 +3182,14 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, errno = 0; lwpid = my_waitpid (-1, &status, __WALL | WNOHANG); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LNW: waitpid(-1, ...) returned %d, %s\n", - lwpid, errno ? safe_strerror (errno) : "ERRNO-OK"); + linux_nat_debug_printf ("waitpid(-1, ...) returned %d, %s", + lwpid, + errno ? safe_strerror (errno) : "ERRNO-OK"); if (lwpid > 0) { - if (debug_linux_nat) - { - fprintf_unfiltered (gdb_stdlog, - "LLW: waitpid %ld received %s\n", + linux_nat_debug_printf ("waitpid %ld received %s", (long) lwpid, status_to_str (status)); - } linux_nat_filter_event (lwpid, status); /* Retry until nothing comes out of waitpid. A single @@ -3358,8 +3219,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, forever in the sigsuspend call below otherwise. */ if (iterate_over_lwps (ptid, resumed_callback) == NULL) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n"); + linux_nat_debug_printf ("exit (no resumed LWP)"); ourstatus->kind = TARGET_WAITKIND_NO_RESUMED; @@ -3371,8 +3231,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, if (target_options & TARGET_WNOHANG) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n"); + linux_nat_debug_printf ("exit (ignore)"); ourstatus->kind = TARGET_WAITKIND_IGNORE; restore_child_signals_mask (&prev_mask); @@ -3415,7 +3274,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); @@ -3446,10 +3305,8 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, if (linux_target->low_status_is_event (status)) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LLW: trap ptid is %s.\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("trap ptid is %s.", + target_pid_to_str (lp->ptid).c_str ()); } if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE) @@ -3460,8 +3317,7 @@ linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus, else store_waitstatus (ourstatus, status); - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, "LLW: exit\n"); + linux_nat_debug_printf ("exit"); restore_child_signals_mask (&prev_mask); @@ -3495,28 +3351,22 @@ resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid) { if (!lp->stopped) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "RSRL: NOT resuming LWP %s, not stopped\n", - target_pid_to_str (lp->ptid).c_str ()); + linux_nat_debug_printf ("NOT resuming LWP %s, not stopped", + 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).c_str ()); + linux_nat_debug_printf ("NOT resuming LWP %s, not resumed", + 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).c_str ()); + linux_nat_debug_printf ("NOT resuming LWP %s, has pending status", + 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 @@ -3534,13 +3384,10 @@ resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid) if (!leave_stopped) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "RSRL: resuming stopped-resumed LWP %s at " - "%s: step=%d\n", - target_pid_to_str (lp->ptid).c_str (), - paddress (gdbarch, pc), - lp->step); + linux_nat_debug_printf + ("resuming stopped-resumed LWP %s at %s: step=%d", + target_pid_to_str (lp->ptid).c_str (), paddress (gdbarch, pc), + lp->step); linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0); } @@ -3557,18 +3404,12 @@ resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid) ptid_t linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, - int target_options) + target_wait_flags target_options) { ptid_t event_ptid; - if (debug_linux_nat) - { - 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).c_str (), - options_string.c_str ()); - } + linux_nat_debug_printf ("[%s], [%s]", target_pid_to_str (ptid).c_str (), + target_options_to_string (target_options).c_str ()); /* Flush the async file first. */ if (target_is_async_p ()) @@ -3611,13 +3452,14 @@ kill_one_lwp (pid_t pid) errno = 0; kill_lwp (pid, SIGKILL); + if (debug_linux_nat) { int save_errno = errno; - fprintf_unfiltered (gdb_stdlog, - "KC: kill (SIGKILL) %ld, 0, 0 (%s)\n", (long) pid, - save_errno ? safe_strerror (save_errno) : "OK"); + linux_nat_debug_printf + ("kill (SIGKILL) %ld, 0, 0 (%s)", (long) pid, + save_errno != 0 ? safe_strerror (save_errno) : "OK"); } /* Some kernels ignore even SIGKILL for processes under ptrace. */ @@ -3628,9 +3470,9 @@ kill_one_lwp (pid_t pid) { int save_errno = errno; - fprintf_unfiltered (gdb_stdlog, - "KC: PTRACE_KILL %ld, 0, 0 (%s)\n", (long) pid, - save_errno ? safe_strerror (save_errno) : "OK"); + linux_nat_debug_printf + ("PTRACE_KILL %ld, 0, 0 (%s)", (long) pid, + save_errno ? safe_strerror (save_errno) : "OK"); } } @@ -3650,10 +3492,8 @@ kill_wait_one_lwp (pid_t pid) res = my_waitpid (pid, NULL, __WALL); if (res != (pid_t) -1) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "KWC: wait %ld received unknown.\n", - (long) pid); + linux_nat_debug_printf ("wait %ld received unknown.", (long) pid); + /* The Linux kernel sometimes fails to kill a thread completely after PTRACE_KILL; that goes from the stop point in do_fork out to the one in get_signal_to_deliver @@ -3726,7 +3566,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. */ @@ -3781,7 +3621,7 @@ siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction) static enum target_xfer_status linux_xfer_siginfo (enum target_object object, - const char *annex, gdb_byte *readbuf, + const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) { @@ -4164,7 +4004,7 @@ linux_nat_target::can_async_p () bool linux_nat_target::supports_non_stop () { - return 1; + return true; } /* to_always_non_stop_p implementation. */ @@ -4172,27 +4012,22 @@ linux_nat_target::supports_non_stop () bool linux_nat_target::always_non_stop_p () { - return 1; + return true; } -/* True if we want to support multi-process. To be removed when GDB - supports multi-exec. */ - -int linux_multi_process = 1; - bool linux_nat_target::supports_multi_process () { - return linux_multi_process; + return true; } bool linux_nat_target::supports_disable_randomization () { #ifdef HAVE_PERSONALITY - return 1; + return true; #else - return 0; + return false; #endif } @@ -4207,8 +4042,7 @@ sigchld_handler (int signo) int old_errno = errno; if (debug_linux_nat) - ui_file_write_async_safe (gdb_stdlog, - "sigchld\n", sizeof ("sigchld\n") - 1); + gdb_stdlog->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1); if (signo == SIGCHLD && linux_nat_event_pipe[0] != -1) @@ -4223,7 +4057,7 @@ sigchld_handler (int signo) static void handle_target_event (int error, gdb_client_data client_data) { - inferior_event_handler (INF_REG_EVENT, NULL); + inferior_event_handler (INF_REG_EVENT); } /* Create/destroy the target events pipe. Returns previous state. */ @@ -4264,6 +4098,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 @@ -4274,7 +4114,8 @@ linux_nat_target::async (int enable) if (!linux_async_pipe (1)) { add_file_handler (linux_nat_event_pipe[0], - handle_target_event, NULL); + handle_target_event, NULL, + "linux-nat"); /* There may be pending events to handle. Tell the event loop to poll them. */ async_file_mark (); @@ -4296,19 +4137,14 @@ linux_nat_stop_lwp (struct lwp_info *lwp) { if (!lwp->stopped) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "LNSL: running -> suspending %s\n", - target_pid_to_str (lwp->ptid).c_str ()); + linux_nat_debug_printf ("running -> suspending %s", + target_pid_to_str (lwp->ptid).c_str ()); if (lwp->last_resume_kind == resume_stop) { - if (debug_linux_nat) - fprintf_unfiltered (gdb_stdlog, - "linux-nat: already stopping LWP %ld at " - "GDB's request\n", - lwp->ptid.lwp ()); + linux_nat_debug_printf ("already stopping LWP %ld at GDB's request", + lwp->ptid.lwp ()); return 0; } @@ -4321,15 +4157,12 @@ linux_nat_stop_lwp (struct lwp_info *lwp) if (debug_linux_nat) { - if (find_thread_ptid (lwp->ptid)->stop_requested) - fprintf_unfiltered (gdb_stdlog, - "LNSL: already stopped/stop_requested %s\n", - target_pid_to_str (lwp->ptid).c_str ()); + if (find_thread_ptid (linux_target, lwp->ptid)->stop_requested) + linux_nat_debug_printf ("already stopped/stop_requested %s", + 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).c_str ()); + linux_nat_debug_printf ("already stopped/no stop_requested yet %s", + target_pid_to_str (lwp->ptid).c_str ()); } } return 0; @@ -4378,7 +4211,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; } @@ -4534,8 +4367,9 @@ current_lwp_ptid (void) return inferior_ptid; } +void _initialize_linux_nat (); void -_initialize_linux_nat (void) +_initialize_linux_nat () { add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance, &debug_linux_nat, _("\ @@ -4564,7 +4398,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);