#include <sys/stat.h> /* for struct stat */
#include <fcntl.h> /* for O_RDONLY */
#include "inf-loop.h"
-#include "event-loop.h"
+#include "gdbsupport/event-loop.h"
#include "event-top.h"
#include <pwd.h>
#include <sys/types.h>
#include "gdbsupport/fileio.h"
#include "gdbsupport/scope-exit.h"
#include "gdbsupport/gdb-sigmask.h"
+#include "debug.h"
/* This comment documents high-level logic of this file.
value);
}
+/* Print a debug statement. Should be used through linux_nat_debug_printf. */
+
+static void ATTRIBUTE_PRINTF (2, 3)
+linux_nat_debug_printf_1 (const char *func_name, const char *fmt, ...)
+{
+ va_list ap;
+ va_start (ap, fmt);
+ debug_prefixed_vprintf ("linux-nat", func_name, fmt, ap);
+ va_end (ap);
+}
+
+#define linux_nat_debug_printf(fmt, ...) \
+ do { \
+ if (debug_linux_nat) \
+ linux_nat_debug_printf_1 (__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;
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)
{
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
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);
check_for_thread_db ();
}
- return 0;
+ return false;
}
\f
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 /
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;
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
{
}
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);
matching libthread_db is not found (or the process uses
raw clone). */
add_thread (linux_target, lp->ptid);
- set_running (linux_target, lp->ptid, 1);
- set_executing (linux_target, lp->ptid, 1);
+ set_running (linux_target, lp->ptid, true);
+ set_executing (linux_target, lp->ptid, true);
}
return 1;
/* 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;
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);
}
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;
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);
}
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.
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
&& 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? */
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 ())
{
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);
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);
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
{
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;
}
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 ()))
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;
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 (linux_target, new_lp->ptid, 1);
- set_executing (linux_target, new_lp->ptid, 1);
+ set_running (linux_target, new_lp->ptid, true);
+ set_executing (linux_target, new_lp->ptid, true);
if (WSTOPSIG (status) != SIGSTOP)
{
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)
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
{
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;
}
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
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;
&& 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;
}
{
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))
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
}
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 ());
}
}
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;
}
{
int ret;
- if (debug_linux_nat)
- {
- fprintf_unfiltered (gdb_stdlog,
- "SC: kill %s **<SIGSTOP>**\n",
+ linux_nat_debug_printf ("kill %s **<SIGSTOP>**",
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);
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;
}
}
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);
}
{
/* 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;
{
/* 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;
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;
}
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);
{
/* 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;
}
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
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)
}
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;
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 ());
}
}
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
}
/* 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)
&& (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;
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;
}
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;
}
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
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;
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);
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. */
/* 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. */
&& !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;
}
}
&& 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:
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);
}
}
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
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
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
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;
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);
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)
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);
{
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
{
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);
}
{
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 ())
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. */
{
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");
}
}
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
bool
linux_nat_target::supports_non_stop ()
{
- return 1;
+ return true;
}
/* to_always_non_stop_p implementation. */
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
}
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)
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. */
{
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;
}
if (debug_linux_nat)
{
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).c_str ());
+ 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;
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, _("\
projects / thirdparty / binutils-gdb.git / blobdiff