/* Low level interface to ptrace, for the remote server for GDB.
- Copyright (C) 1995-2014 Free Software Foundation, Inc.
+ Copyright (C) 1995-2015 Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/ptrace.h>
#include "nat/linux-ptrace.h"
#include "nat/linux-procfs.h"
+#include "nat/linux-personality.h"
#include <signal.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#ifdef HAVE_LINUX_BTRACE
# include "nat/linux-btrace.h"
+# include "btrace-common.h"
#endif
#ifndef HAVE_ELF32_AUXV_T
} Elf64_auxv_t;
#endif
+/* LWP accessors. */
+
+/* See nat/linux-nat.h. */
+
+ptid_t
+ptid_of_lwp (struct lwp_info *lwp)
+{
+ return ptid_of (get_lwp_thread (lwp));
+}
+
+/* See nat/linux-nat.h. */
+
+void
+lwp_set_arch_private_info (struct lwp_info *lwp,
+ struct arch_lwp_info *info)
+{
+ lwp->arch_private = info;
+}
+
+/* See nat/linux-nat.h. */
+
+struct arch_lwp_info *
+lwp_arch_private_info (struct lwp_info *lwp)
+{
+ return lwp->arch_private;
+}
+
+/* See nat/linux-nat.h. */
+
+int
+lwp_is_stopped (struct lwp_info *lwp)
+{
+ return lwp->stopped;
+}
+
+/* See nat/linux-nat.h. */
+
+enum target_stop_reason
+lwp_stop_reason (struct lwp_info *lwp)
+{
+ return lwp->stop_reason;
+}
+
/* A list of all unknown processes which receive stop signals. Some
other process will presumably claim each of these as forked
children momentarily. */
static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
static void proceed_all_lwps (void);
static int finish_step_over (struct lwp_info *lwp);
-static CORE_ADDR get_stop_pc (struct lwp_info *lwp);
static int kill_lwp (unsigned long lwpid, int signo);
+/* When the event-loop is doing a step-over, this points at the thread
+ being stepped. */
+ptid_t step_over_bkpt;
+
/* True if the low target can hardware single-step. Such targets
don't need a BREAKPOINT_REINSERT_ADDR callback. */
struct process_info *proc;
proc = add_process (pid, attached);
- proc->private = xcalloc (1, sizeof (*proc->private));
+ proc->priv = xcalloc (1, sizeof (*proc->priv));
/* Set the arch when the first LWP stops. */
- proc->private->new_inferior = 1;
+ proc->priv->new_inferior = 1;
if (the_low_target.new_process != NULL)
- proc->private->arch_private = the_low_target.new_process ();
+ proc->priv->arch_private = the_low_target.new_process ();
return proc;
}
+static CORE_ADDR get_pc (struct lwp_info *lwp);
+
/* Handle a GNU/Linux extended wait response. If we see a clone
event, we need to add the new LWP to our list (and not report the
trap to higher layers). */
static void
handle_extended_wait (struct lwp_info *event_child, int wstat)
{
- int event = wstat >> 16;
+ int event = linux_ptrace_get_extended_event (wstat);
struct thread_info *event_thr = get_lwp_thread (event_child);
struct lwp_info *new_lwp;
/* Normally we will get the pending SIGSTOP. But in some cases
we might get another signal delivered to the group first.
If we do get another signal, be sure not to lose it. */
- if (WSTOPSIG (status) == SIGSTOP)
- {
- if (stopping_threads != NOT_STOPPING_THREADS)
- new_lwp->stop_pc = get_stop_pc (new_lwp);
- else
- linux_resume_one_lwp (new_lwp, 0, 0, NULL);
- }
- else
+ if (WSTOPSIG (status) != SIGSTOP)
{
new_lwp->stop_expected = 1;
-
- if (stopping_threads != NOT_STOPPING_THREADS)
- {
- new_lwp->stop_pc = get_stop_pc (new_lwp);
- new_lwp->status_pending_p = 1;
- new_lwp->status_pending = status;
- }
- else
- /* Pass the signal on. This is what GDB does - except
- shouldn't we really report it instead? */
- linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
+ new_lwp->status_pending_p = 1;
+ new_lwp->status_pending = status;
}
-
- /* Always resume the current thread. If we are stopping
- threads, it will have a pending SIGSTOP; we may as well
- collect it now. */
- linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
}
}
static CORE_ADDR
get_pc (struct lwp_info *lwp)
{
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
struct regcache *regcache;
CORE_ADDR pc;
if (the_low_target.get_pc == NULL)
return 0;
- saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (lwp);
+ saved_thread = current_thread;
+ current_thread = get_lwp_thread (lwp);
- regcache = get_thread_regcache (current_inferior, 1);
+ regcache = get_thread_regcache (current_thread, 1);
pc = (*the_low_target.get_pc) (regcache);
if (debug_threads)
debug_printf ("pc is 0x%lx\n", (long) pc);
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
return pc;
}
The SIGTRAP could mean several things.
On i386, where decr_pc_after_break is non-zero:
- If we were single-stepping this process using PTRACE_SINGLESTEP,
- we will get only the one SIGTRAP (even if the instruction we
- stepped over was a breakpoint). The value of $eip will be the
- next instruction.
+
+ If we were single-stepping this process using PTRACE_SINGLESTEP, we
+ will get only the one SIGTRAP. The value of $eip will be the next
+ instruction. If the instruction we stepped over was a breakpoint,
+ we need to decrement the PC.
+
If we continue the process using PTRACE_CONT, we will get a
SIGTRAP when we hit a breakpoint. The value of $eip will be
the instruction after the breakpoint (i.e. needs to be
decremented). If we report the SIGTRAP to GDB, we must also
- report the undecremented PC. If we cancel the SIGTRAP, we
+ report the undecremented PC. If the breakpoint is removed, we
must resume at the decremented PC.
- (Presumably, not yet tested) On a non-decr_pc_after_break machine
- with hardware or kernel single-step:
- If we single-step over a breakpoint instruction, our PC will
- point at the following instruction. If we continue and hit a
- breakpoint instruction, our PC will point at the breakpoint
+ On a non-decr_pc_after_break machine with hardware or kernel
+ single-step:
+
+ If we either single-step a breakpoint instruction, or continue and
+ hit a breakpoint instruction, our PC will point at the breakpoint
instruction. */
-static CORE_ADDR
-get_stop_pc (struct lwp_info *lwp)
+static int
+check_stopped_by_breakpoint (struct lwp_info *lwp)
{
- CORE_ADDR stop_pc;
+ CORE_ADDR pc;
+ CORE_ADDR sw_breakpoint_pc;
+ struct thread_info *saved_thread;
+#if USE_SIGTRAP_SIGINFO
+ siginfo_t siginfo;
+#endif
if (the_low_target.get_pc == NULL)
return 0;
- stop_pc = get_pc (lwp);
+ pc = get_pc (lwp);
+ sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
- if (WSTOPSIG (lwp->last_status) == SIGTRAP
- && !lwp->stepping
- && !lwp->stopped_by_watchpoint
- && lwp->last_status >> 16 == 0)
- stop_pc -= the_low_target.decr_pc_after_break;
+ /* breakpoint_at reads from the current thread. */
+ saved_thread = current_thread;
+ current_thread = get_lwp_thread (lwp);
- if (debug_threads)
- debug_printf ("stop pc is 0x%lx\n", (long) stop_pc);
+#if USE_SIGTRAP_SIGINFO
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
+ (PTRACE_TYPE_ARG3) 0, &siginfo) == 0)
+ {
+ if (siginfo.si_signo == SIGTRAP)
+ {
+ if (siginfo.si_code == GDB_ARCH_TRAP_BRKPT)
+ {
+ if (debug_threads)
+ {
+ struct thread_info *thr = get_lwp_thread (lwp);
+
+ debug_printf ("CSBB: Push back software breakpoint for %s\n",
+ target_pid_to_str (ptid_of (thr)));
+ }
+
+ /* Back up the PC if necessary. */
+ if (pc != sw_breakpoint_pc)
+ {
+ struct regcache *regcache
+ = get_thread_regcache (current_thread, 1);
+ (*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
+ }
+
+ lwp->stop_pc = sw_breakpoint_pc;
+ lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
+ current_thread = saved_thread;
+ return 1;
+ }
+ else if (siginfo.si_code == TRAP_HWBKPT)
+ {
+ if (debug_threads)
+ {
+ struct thread_info *thr = get_lwp_thread (lwp);
+
+ debug_printf ("CSBB: Push back hardware "
+ "breakpoint/watchpoint for %s\n",
+ target_pid_to_str (ptid_of (thr)));
+ }
+
+ lwp->stop_pc = pc;
+ lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
+ current_thread = saved_thread;
+ return 1;
+ }
+ }
+ }
+#else
+ /* We may have just stepped a breakpoint instruction. E.g., in
+ non-stop mode, GDB first tells the thread A to step a range, and
+ then the user inserts a breakpoint inside the range. In that
+ case we need to report the breakpoint PC. */
+ if ((!lwp->stepping || lwp->stop_pc == sw_breakpoint_pc)
+ && (*the_low_target.breakpoint_at) (sw_breakpoint_pc))
+ {
+ if (debug_threads)
+ {
+ struct thread_info *thr = get_lwp_thread (lwp);
+
+ debug_printf ("CSBB: %s stopped by software breakpoint\n",
+ target_pid_to_str (ptid_of (thr)));
+ }
+
+ /* Back up the PC if necessary. */
+ if (pc != sw_breakpoint_pc)
+ {
+ struct regcache *regcache
+ = get_thread_regcache (current_thread, 1);
+ (*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
+ }
- return stop_pc;
+ lwp->stop_pc = sw_breakpoint_pc;
+ lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
+ current_thread = saved_thread;
+ return 1;
+ }
+
+ if (hardware_breakpoint_inserted_here (pc))
+ {
+ if (debug_threads)
+ {
+ struct thread_info *thr = get_lwp_thread (lwp);
+
+ debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
+ target_pid_to_str (ptid_of (thr)));
+ }
+
+ lwp->stop_pc = pc;
+ lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
+ current_thread = saved_thread;
+ return 1;
+ }
+#endif
+
+ current_thread = saved_thread;
+ return 0;
}
static struct lwp_info *
memset (lwp, 0, sizeof (*lwp));
if (the_low_target.new_thread != NULL)
- lwp->arch_private = the_low_target.new_thread ();
+ the_low_target.new_thread (lwp);
lwp->thread = add_thread (ptid, lwp);
static int
linux_create_inferior (char *program, char **allargs)
{
-#ifdef HAVE_PERSONALITY
- int personality_orig = 0, personality_set = 0;
-#endif
struct lwp_info *new_lwp;
int pid;
ptid_t ptid;
-
-#ifdef HAVE_PERSONALITY
- if (disable_randomization)
- {
- errno = 0;
- personality_orig = personality (0xffffffff);
- if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
- {
- personality_set = 1;
- personality (personality_orig | ADDR_NO_RANDOMIZE);
- }
- if (errno != 0 || (personality_set
- && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
- warning ("Error disabling address space randomization: %s",
- strerror (errno));
- }
-#endif
+ struct cleanup *restore_personality
+ = maybe_disable_address_space_randomization (disable_randomization);
#if defined(__UCLIBC__) && defined(HAS_NOMMU)
pid = vfork ();
_exit (0177);
}
-#ifdef HAVE_PERSONALITY
- if (personality_set)
- {
- errno = 0;
- personality (personality_orig);
- if (errno != 0)
- warning ("Error restoring address space randomization: %s",
- strerror (errno));
- }
-#endif
+ do_cleanups (restore_personality);
linux_add_process (pid, 0);
return pid;
}
-char *
-linux_attach_fail_reason_string (ptid_t ptid, int err)
-{
- static char *reason_string;
- struct buffer buffer;
- char *warnings;
- long lwpid = ptid_get_lwp (ptid);
-
- xfree (reason_string);
-
- buffer_init (&buffer);
- linux_ptrace_attach_fail_reason (lwpid, &buffer);
- buffer_grow_str0 (&buffer, "");
- warnings = buffer_finish (&buffer);
- if (warnings[0] != '\0')
- reason_string = xstrprintf ("%s (%d), %s",
- strerror (err), err, warnings);
- else
- reason_string = xstrprintf ("%s (%d)",
- strerror (err), err);
- xfree (warnings);
- return reason_string;
-}
-
-/* Attach to an inferior process. */
+/* Attach to an inferior process. Returns 0 on success, ERRNO on
+ error. */
int
linux_attach_lwp (ptid_t ptid)
return 0;
}
+/* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
+ already attached. Returns true if a new LWP is found, false
+ otherwise. */
+
+static int
+attach_proc_task_lwp_callback (ptid_t ptid)
+{
+ /* Is this a new thread? */
+ if (find_thread_ptid (ptid) == NULL)
+ {
+ int lwpid = ptid_get_lwp (ptid);
+ int err;
+
+ if (debug_threads)
+ debug_printf ("Found new lwp %d\n", lwpid);
+
+ err = linux_attach_lwp (ptid);
+
+ /* Be quiet if we simply raced with the thread exiting. EPERM
+ is returned if the thread's task still exists, and is marked
+ as exited or zombie, as well as other conditions, so in that
+ case, confirm the status in /proc/PID/status. */
+ if (err == ESRCH
+ || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
+ {
+ if (debug_threads)
+ {
+ debug_printf ("Cannot attach to lwp %d: "
+ "thread is gone (%d: %s)\n",
+ lwpid, err, strerror (err));
+ }
+ }
+ else if (err != 0)
+ {
+ warning (_("Cannot attach to lwp %d: %s"),
+ lwpid,
+ linux_ptrace_attach_fail_reason_string (ptid, err));
+ }
+
+ return 1;
+ }
+ return 0;
+}
+
/* Attach to PID. If PID is the tgid, attach to it and all
of its threads. */
err = linux_attach_lwp (ptid);
if (err != 0)
error ("Cannot attach to process %ld: %s",
- pid, linux_attach_fail_reason_string (ptid, err));
+ pid, linux_ptrace_attach_fail_reason_string (ptid, err));
linux_add_process (pid, 1);
thread->last_resume_kind = resume_stop;
}
- if (linux_proc_get_tgid (pid) == pid)
- {
- DIR *dir;
- char pathname[128];
-
- sprintf (pathname, "/proc/%ld/task", pid);
-
- dir = opendir (pathname);
-
- if (!dir)
- {
- fprintf (stderr, "Could not open /proc/%ld/task.\n", pid);
- fflush (stderr);
- }
- else
- {
- /* At this point we attached to the tgid. Scan the task for
- existing threads. */
- int new_threads_found;
- int iterations = 0;
-
- while (iterations < 2)
- {
- struct dirent *dp;
-
- new_threads_found = 0;
- /* Add all the other threads. While we go through the
- threads, new threads may be spawned. Cycle through
- the list of threads until we have done two iterations without
- finding new threads. */
- while ((dp = readdir (dir)) != NULL)
- {
- unsigned long lwp;
- ptid_t ptid;
-
- /* Fetch one lwp. */
- lwp = strtoul (dp->d_name, NULL, 10);
-
- ptid = ptid_build (pid, lwp, 0);
-
- /* Is this a new thread? */
- if (lwp != 0 && find_thread_ptid (ptid) == NULL)
- {
- int err;
-
- if (debug_threads)
- debug_printf ("Found new lwp %ld\n", lwp);
-
- err = linux_attach_lwp (ptid);
- if (err != 0)
- warning ("Cannot attach to lwp %ld: %s",
- lwp,
- linux_attach_fail_reason_string (ptid, err));
-
- new_threads_found++;
- }
- }
-
- if (!new_threads_found)
- iterations++;
- else
- iterations = 0;
-
- rewinddir (dir);
- }
- closedir (dir);
- }
- }
-
+ /* We must attach to every LWP. If /proc is mounted, use that to
+ find them now. On the one hand, the inferior may be using raw
+ clone instead of using pthreads. On the other hand, even if it
+ is using pthreads, GDB may not be connected yet (thread_db needs
+ to do symbol lookups, through qSymbol). Also, thread_db walks
+ structures in the inferior's address space to find the list of
+ threads/LWPs, and those structures may well be corrupted. Note
+ that once thread_db is loaded, we'll still use it to list threads
+ and associate pthread info with each LWP. */
+ linux_proc_attach_tgid_threads (pid, attach_proc_task_lwp_callback);
return 0;
}
}
/* Extended wait statuses aren't real SIGTRAPs. */
- if (WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
+ if (WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status))
{
if (debug_threads)
debug_printf ("GPS: lwp %s had stopped with extended "
find_inferior (&all_threads, delete_lwp_callback, process);
/* Freeing all private data. */
- priv = process->private;
+ priv = process->priv;
free (priv->arch_private);
free (priv);
- process->private = NULL;
+ process->priv = NULL;
remove_process (process);
}
return 0;
}
-/* Return 1 if this lwp has an interesting status pending. */
+/* Return 1 if this lwp still has an interesting status pending. If
+ not (e.g., it had stopped for a breakpoint that is gone), return
+ false. */
+
static int
-status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
+thread_still_has_status_pending_p (struct thread_info *thread)
{
- struct thread_info *thread = (struct thread_info *) entry;
- struct lwp_info *lwp = get_thread_lwp (thread);
- ptid_t ptid = * (ptid_t *) arg;
+ struct lwp_info *lp = get_thread_lwp (thread);
- /* Check if we're only interested in events from a specific process
- or its lwps. */
- if (!ptid_equal (minus_one_ptid, ptid)
- && ptid_get_pid (ptid) != ptid_get_pid (thread->entry.id))
+ if (!lp->status_pending_p)
return 0;
/* If we got a `vCont;t', but we haven't reported a stop yet, do
&& thread->last_status.kind != TARGET_WAITKIND_IGNORE)
return 0;
- return lwp->status_pending_p;
+ if (thread->last_resume_kind != resume_stop
+ && (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
+ {
+ struct thread_info *saved_thread;
+ CORE_ADDR pc;
+ int discard = 0;
+
+ gdb_assert (lp->last_status != 0);
+
+ pc = get_pc (lp);
+
+ saved_thread = current_thread;
+ current_thread = thread;
+
+ if (pc != lp->stop_pc)
+ {
+ if (debug_threads)
+ debug_printf ("PC of %ld changed\n",
+ lwpid_of (thread));
+ discard = 1;
+ }
+
+#if !USE_SIGTRAP_SIGINFO
+ else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ && !(*the_low_target.breakpoint_at) (pc))
+ {
+ if (debug_threads)
+ debug_printf ("previous SW breakpoint of %ld gone\n",
+ lwpid_of (thread));
+ discard = 1;
+ }
+ else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
+ && !hardware_breakpoint_inserted_here (pc))
+ {
+ if (debug_threads)
+ debug_printf ("previous HW breakpoint of %ld gone\n",
+ lwpid_of (thread));
+ discard = 1;
+ }
+#endif
+
+ current_thread = saved_thread;
+
+ if (discard)
+ {
+ if (debug_threads)
+ debug_printf ("discarding pending breakpoint status\n");
+ lp->status_pending_p = 0;
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+/* Return 1 if this lwp has an interesting status pending. */
+static int
+status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
+ ptid_t ptid = * (ptid_t *) arg;
+
+ /* Check if we're only interested in events from a specific process
+ or a specific LWP. */
+ if (!ptid_match (ptid_of (thread), ptid))
+ return 0;
+
+ if (lp->status_pending_p
+ && !thread_still_has_status_pending_p (thread))
+ {
+ linux_resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
+ return 0;
+ }
+
+ return lp->status_pending_p;
}
static int
return count;
}
+/* The arguments passed to iterate_over_lwps. */
+
+struct iterate_over_lwps_args
+{
+ /* The FILTER argument passed to iterate_over_lwps. */
+ ptid_t filter;
+
+ /* The CALLBACK argument passed to iterate_over_lwps. */
+ iterate_over_lwps_ftype *callback;
+
+ /* The DATA argument passed to iterate_over_lwps. */
+ void *data;
+};
+
+/* Callback for find_inferior used by iterate_over_lwps to filter
+ calls to the callback supplied to that function. Returning a
+ nonzero value causes find_inferiors to stop iterating and return
+ the current inferior_list_entry. Returning zero indicates that
+ find_inferiors should continue iterating. */
+
+static int
+iterate_over_lwps_filter (struct inferior_list_entry *entry, void *args_p)
+{
+ struct iterate_over_lwps_args *args
+ = (struct iterate_over_lwps_args *) args_p;
+
+ if (ptid_match (entry->id, args->filter))
+ {
+ struct thread_info *thr = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thr);
+
+ return (*args->callback) (lwp, args->data);
+ }
+
+ return 0;
+}
+
+/* See nat/linux-nat.h. */
+
+struct lwp_info *
+iterate_over_lwps (ptid_t filter,
+ iterate_over_lwps_ftype callback,
+ void *data)
+{
+ struct iterate_over_lwps_args args = {filter, callback, data};
+ struct inferior_list_entry *entry;
+
+ entry = find_inferior (&all_threads, iterate_over_lwps_filter, &args);
+ if (entry == NULL)
+ return NULL;
+
+ return get_thread_lwp ((struct thread_info *) entry);
+}
+
/* Detect zombie thread group leaders, and "exit" them. We can't reap
their exits until all other threads in the group have exited. */
struct thread_info *tinfo = get_lwp_thread (lwp);
int tpoint_related_event = 0;
+ gdb_assert (lwp->suspended == 0);
+
/* If this tracepoint hit causes a tracing stop, we'll immediately
uninsert tracepoints. To do this, we temporarily pause all
threads, unpatch away, and then unpause threads. We need to make
static int
maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
{
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
- saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (lwp);
+ saved_thread = current_thread;
+ current_thread = get_lwp_thread (lwp);
if ((wstat == NULL
|| (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad.\n",
- lwpid_of (current_inferior));
+ lwpid_of (current_thread));
r = linux_fast_tracepoint_collecting (lwp, &status);
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of "
"the jump pad...it does\n",
- lwpid_of (current_inferior));
- current_inferior = saved_inferior;
+ lwpid_of (current_thread));
+ current_thread = saved_thread;
return 1;
}
|| WSTOPSIG (*wstat) == SIGFPE
|| WSTOPSIG (*wstat) == SIGBUS
|| WSTOPSIG (*wstat) == SIGSEGV)
- && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior),
+ && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
(PTRACE_TYPE_ARG3) 0, &info) == 0
/* Final check just to make sure we don't clobber
the siginfo of non-kernel-sent signals. */
&& (uintptr_t) info.si_addr == lwp->stop_pc)
{
info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
- ptrace (PTRACE_SETSIGINFO, lwpid_of (current_inferior),
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (current_thread),
(PTRACE_TYPE_ARG3) 0, &info);
}
- regcache = get_thread_regcache (current_inferior, 1);
+ regcache = get_thread_regcache (current_thread, 1);
(*the_low_target.set_pc) (regcache, status.tpoint_addr);
lwp->stop_pc = status.tpoint_addr;
"stopping all threads momentarily.\n");
stop_all_lwps (1, lwp);
- cancel_breakpoints ();
delete_breakpoint (lwp->exit_jump_pad_bkpt);
lwp->exit_jump_pad_bkpt = NULL;
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad...no\n",
- lwpid_of (current_inferior));
+ lwpid_of (current_thread));
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
return 0;
}
return 0;
}
-/* Arrange for a breakpoint to be hit again later. We don't keep the
- SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We
- will handle the current event, eventually we will resume this LWP,
- and this breakpoint will trap again. */
+/* Fetch the possibly triggered data watchpoint info and store it in
+ CHILD.
+
+ On some archs, like x86, that use debug registers to set
+ watchpoints, it's possible that the way to know which watched
+ address trapped, is to check the register that is used to select
+ which address to watch. Problem is, between setting the watchpoint
+ and reading back which data address trapped, the user may change
+ the set of watchpoints, and, as a consequence, GDB changes the
+ debug registers in the inferior. To avoid reading back a stale
+ stopped-data-address when that happens, we cache in LP the fact
+ that a watchpoint trapped, and the corresponding data address, as
+ soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
+ registers meanwhile, we have the cached data we can rely on. */
static int
-cancel_breakpoint (struct lwp_info *lwp)
+check_stopped_by_watchpoint (struct lwp_info *child)
{
- struct thread_info *saved_inferior;
-
- /* There's nothing to do if we don't support breakpoints. */
- if (!supports_breakpoints ())
- return 0;
-
- /* breakpoint_at reads from current inferior. */
- saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (lwp);
-
- if ((*the_low_target.breakpoint_at) (lwp->stop_pc))
+ if (the_low_target.stopped_by_watchpoint != NULL)
{
- if (debug_threads)
- debug_printf ("CB: Push back breakpoint for %s\n",
- target_pid_to_str (ptid_of (current_inferior)));
+ struct thread_info *saved_thread;
- /* Back up the PC if necessary. */
- if (the_low_target.decr_pc_after_break)
+ saved_thread = current_thread;
+ current_thread = get_lwp_thread (child);
+
+ if (the_low_target.stopped_by_watchpoint ())
{
- struct regcache *regcache
- = get_thread_regcache (current_inferior, 1);
- (*the_low_target.set_pc) (regcache, lwp->stop_pc);
+ child->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
+
+ if (the_low_target.stopped_data_address != NULL)
+ child->stopped_data_address
+ = the_low_target.stopped_data_address ();
+ else
+ child->stopped_data_address = 0;
}
- current_inferior = saved_inferior;
- return 1;
- }
- else
- {
- if (debug_threads)
- debug_printf ("CB: No breakpoint found at %s for [%s]\n",
- paddress (lwp->stop_pc),
- target_pid_to_str (ptid_of (current_inferior)));
+ current_thread = saved_thread;
}
- current_inferior = saved_inferior;
- return 0;
+ return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
/* Do low-level handling of the event, and check if we should go on
NULL otherwise. */
static struct lwp_info *
-linux_low_filter_event (ptid_t filter_ptid, int lwpid, int wstat)
+linux_low_filter_event (int lwpid, int wstat)
{
struct lwp_info *child;
struct thread_info *thread;
+ int have_stop_pc = 0;
child = find_lwp_pid (pid_to_ptid (lwpid));
child->last_status = wstat;
+ /* Check if the thread has exited. */
+ if ((WIFEXITED (wstat) || WIFSIGNALED (wstat)))
+ {
+ if (debug_threads)
+ debug_printf ("LLFE: %d exited.\n", lwpid);
+ if (num_lwps (pid_of (thread)) > 1)
+ {
+
+ /* If there is at least one more LWP, then the exit signal was
+ not the end of the debugged application and should be
+ ignored. */
+ delete_lwp (child);
+ return NULL;
+ }
+ else
+ {
+ /* This was the last lwp in the process. Since events are
+ serialized to GDB core, and we can't report this one
+ right now, but GDB core and the other target layers will
+ want to be notified about the exit code/signal, leave the
+ status pending for the next time we're able to report
+ it. */
+ mark_lwp_dead (child, wstat);
+ return child;
+ }
+ }
+
+ gdb_assert (WIFSTOPPED (wstat));
+
if (WIFSTOPPED (wstat))
{
struct process_info *proc;
is stopped for the first time, but before we access any
inferior registers. */
proc = find_process_pid (pid_of (thread));
- if (proc->private->new_inferior)
+ if (proc->priv->new_inferior)
{
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
- saved_inferior = current_inferior;
- current_inferior = thread;
+ saved_thread = current_thread;
+ current_thread = thread;
the_low_target.arch_setup ();
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
- proc->private->new_inferior = 0;
+ proc->priv->new_inferior = 0;
}
}
- /* Store the STOP_PC, with adjustment applied. This depends on the
- architecture being defined already (so that CHILD has a valid
- regcache), and on LAST_STATUS being set (to check for SIGTRAP or
- not). */
- if (WIFSTOPPED (wstat))
+ if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
{
- if (debug_threads
- && the_low_target.get_pc != NULL)
- {
- struct thread_info *saved_inferior;
- struct regcache *regcache;
- CORE_ADDR pc;
-
- saved_inferior = current_inferior;
- current_inferior = thread;
- regcache = get_thread_regcache (current_inferior, 1);
- pc = (*the_low_target.get_pc) (regcache);
- debug_printf ("linux_low_filter_event: pc is 0x%lx\n", (long) pc);
- current_inferior = saved_inferior;
- }
+ struct process_info *proc = find_process_pid (pid_of (thread));
- child->stop_pc = get_stop_pc (child);
+ linux_enable_event_reporting (lwpid, proc->attached);
+ child->must_set_ptrace_flags = 0;
}
- /* Fetch the possibly triggered data watchpoint info and store it in
- CHILD.
-
- On some archs, like x86, that use debug registers to set
- watchpoints, it's possible that the way to know which watched
- address trapped, is to check the register that is used to select
- which address to watch. Problem is, between setting the
- watchpoint and reading back which data address trapped, the user
- may change the set of watchpoints, and, as a consequence, GDB
- changes the debug registers in the inferior. To avoid reading
- back a stale stopped-data-address when that happens, we cache in
- LP the fact that a watchpoint trapped, and the corresponding data
- address, as soon as we see CHILD stop with a SIGTRAP. If GDB
- changes the debug registers meanwhile, we have the cached data we
- can rely on. */
-
- if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP)
+ /* Be careful to not overwrite stop_pc until
+ check_stopped_by_breakpoint is called. */
+ if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
+ && linux_is_extended_waitstatus (wstat))
{
- if (the_low_target.stopped_by_watchpoint == NULL)
- {
- child->stopped_by_watchpoint = 0;
- }
- else
- {
- struct thread_info *saved_inferior;
-
- saved_inferior = current_inferior;
- current_inferior = thread;
-
- child->stopped_by_watchpoint
- = the_low_target.stopped_by_watchpoint ();
-
- if (child->stopped_by_watchpoint)
- {
- if (the_low_target.stopped_data_address != NULL)
- child->stopped_data_address
- = the_low_target.stopped_data_address ();
- else
- child->stopped_data_address = 0;
- }
-
- current_inferior = saved_inferior;
- }
+ child->stop_pc = get_pc (child);
+ handle_extended_wait (child, wstat);
+ return NULL;
}
- if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
+ /* Check first whether this was a SW/HW breakpoint before checking
+ watchpoints, because at least s390 can't tell the data address of
+ hardware watchpoint hits, and returns stopped-by-watchpoint as
+ long as there's a watchpoint set. */
+ if (WIFSTOPPED (wstat) && linux_wstatus_maybe_breakpoint (wstat))
{
- linux_enable_event_reporting (lwpid);
- child->must_set_ptrace_flags = 0;
+ if (check_stopped_by_breakpoint (child))
+ have_stop_pc = 1;
}
+ /* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
+ or hardware watchpoint. Check which is which if we got
+ TARGET_STOPPED_BY_HW_BREAKPOINT. */
if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
- && wstat >> 16 != 0)
- {
- handle_extended_wait (child, wstat);
- return NULL;
- }
+ && (child->stop_reason == TARGET_STOPPED_BY_NO_REASON
+ || child->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
+ check_stopped_by_watchpoint (child);
+
+ if (!have_stop_pc)
+ child->stop_pc = get_pc (child);
if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGSTOP
&& child->stop_expected)
else if (stopping_threads != NOT_STOPPING_THREADS)
{
/* Stopping threads. We don't want this SIGSTOP to end up
- pending in the FILTER_PTID handling below. */
+ pending. */
return NULL;
}
else
{
- /* Filter out the event. */
- linux_resume_one_lwp (child, child->stepping, 0, NULL);
- return NULL;
- }
- }
-
- /* Check if the thread has exited. */
- if ((WIFEXITED (wstat) || WIFSIGNALED (wstat))
- && num_lwps (pid_of (thread)) > 1)
- {
- if (debug_threads)
- debug_printf ("LLW: %d exited.\n", lwpid);
-
- /* If there is at least one more LWP, then the exit signal
- was not the end of the debugged application and should be
- ignored. */
- delete_lwp (child);
- return NULL;
+ /* Filter out the event. */
+ linux_resume_one_lwp (child, child->stepping, 0, NULL);
+ return NULL;
+ }
}
- if (!ptid_match (ptid_of (thread), filter_ptid))
- {
- if (debug_threads)
- debug_printf ("LWP %d got an event %06x, leaving pending.\n",
- lwpid, wstat);
+ child->status_pending_p = 1;
+ child->status_pending = wstat;
+ return child;
+}
- if (WIFSTOPPED (wstat))
- {
- child->status_pending_p = 1;
- child->status_pending = wstat;
+/* Resume LWPs that are currently stopped without any pending status
+ to report, but are resumed from the core's perspective. */
- if (WSTOPSIG (wstat) != SIGSTOP)
- {
- /* Cancel breakpoint hits. The breakpoint may be
- removed before we fetch events from this process to
- report to the core. It is best not to assume the
- moribund breakpoints heuristic always handles these
- cases --- it could be too many events go through to
- the core before this one is handled. All-stop always
- cancels breakpoint hits in all threads. */
- if (non_stop
- && WSTOPSIG (wstat) == SIGTRAP
- && cancel_breakpoint (child))
- {
- /* Throw away the SIGTRAP. */
- child->status_pending_p = 0;
+static void
+resume_stopped_resumed_lwps (struct inferior_list_entry *entry)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
- if (debug_threads)
- debug_printf ("LLW: LWP %d hit a breakpoint while"
- " waiting for another process;"
- " cancelled it\n", lwpid);
- }
- }
- }
- else if (WIFEXITED (wstat) || WIFSIGNALED (wstat))
- {
- if (debug_threads)
- debug_printf ("LLWE: process %d exited while fetching "
- "event from another LWP\n", lwpid);
+ if (lp->stopped
+ && !lp->status_pending_p
+ && thread->last_resume_kind != resume_stop
+ && thread->last_status.kind == TARGET_WAITKIND_IGNORE)
+ {
+ int step = thread->last_resume_kind == resume_step;
- /* This was the last lwp in the process. Since events are
- serialized to GDB core, and we can't report this one
- right now, but GDB core and the other target layers will
- want to be notified about the exit code/signal, leave the
- status pending for the next time we're able to report
- it. */
- mark_lwp_dead (child, wstat);
- }
+ if (debug_threads)
+ debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
+ target_pid_to_str (ptid_of (thread)),
+ paddress (lp->stop_pc),
+ step);
- return NULL;
+ linux_resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
}
-
- return child;
}
-/* When the event-loop is doing a step-over, this points at the thread
- being stepped. */
-ptid_t step_over_bkpt;
-
/* Wait for an event from child(ren) WAIT_PTID, and return any that
match FILTER_PTID (leaving others pending). The PTIDs can be:
minus_one_ptid, to specify any child; a pid PTID, specifying all
*wstatp = event_child->status_pending;
event_child->status_pending_p = 0;
event_child->status_pending = 0;
- current_inferior = event_thread;
+ current_thread = event_thread;
return lwpid_of (event_thread);
}
sigfillset (&block_mask);
sigprocmask (SIG_BLOCK, &block_mask, &prev_mask);
+ /* Always pull all events out of the kernel. We'll randomly select
+ an event LWP out of all that have events, to prevent
+ starvation. */
while (event_child == NULL)
{
pid_t ret = 0;
(long) ret, status_to_str (*wstatp));
}
- event_child = linux_low_filter_event (filter_ptid,
- ret, *wstatp);
- if (event_child != NULL)
- {
- /* We got an event to report to the core. */
- event_thread = get_lwp_thread (event_child);
- break;
- }
-
+ /* Filter all events. IOW, leave all events pending. We'll
+ randomly select an event LWP out of all that have events
+ below. */
+ linux_low_filter_event (ret, *wstatp);
/* Retry until nothing comes out of waitpid. A single
SIGCHLD can indicate more than one child stopped. */
continue;
}
+ /* Now that we've pulled all events out of the kernel, resume
+ LWPs that don't have an interesting event to report. */
+ if (stopping_threads == NOT_STOPPING_THREADS)
+ for_each_inferior (&all_threads, resume_stopped_resumed_lwps);
+
+ /* ... and find an LWP with a status to report to the core, if
+ any. */
+ event_thread = (struct thread_info *)
+ find_inferior (&all_threads, status_pending_p_callback, &filter_ptid);
+ if (event_thread != NULL)
+ {
+ event_child = get_thread_lwp (event_thread);
+ *wstatp = event_child->status_pending;
+ event_child->status_pending_p = 0;
+ event_child->status_pending = 0;
+ break;
+ }
+
/* Check for zombie thread group leaders. Those can't be reaped
until all other threads in the thread group are. */
check_zombie_leaders ();
sigprocmask (SIG_SETMASK, &prev_mask, NULL);
- current_inferior = event_thread;
+ current_thread = event_thread;
/* Check for thread exit. */
if (! WIFSTOPPED (*wstatp))
gdb_assert (count != NULL);
- /* Count only resumed LWPs that have a SIGTRAP event pending that
- should be reported to GDB. */
+ /* Count only resumed LWPs that have an event pending. */
if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
- && thread->last_resume_kind != resume_stop
- && lp->status_pending_p
- && WIFSTOPPED (lp->status_pending)
- && WSTOPSIG (lp->status_pending) == SIGTRAP
- && !breakpoint_inserted_here (lp->stop_pc))
+ && lp->status_pending_p)
(*count)++;
return 0;
return 0;
}
-/* Select the Nth LWP that has had a SIGTRAP event that should be
- reported to GDB. */
+/* Select the Nth LWP that has had an event. */
static int
select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
gdb_assert (selector != NULL);
- /* Select only resumed LWPs that have a SIGTRAP event pending. */
- if (thread->last_resume_kind != resume_stop
- && thread->last_status.kind == TARGET_WAITKIND_IGNORE
- && lp->status_pending_p
- && WIFSTOPPED (lp->status_pending)
- && WSTOPSIG (lp->status_pending) == SIGTRAP
- && !breakpoint_inserted_here (lp->stop_pc))
+ /* Select only resumed LWPs that have an event pending. */
+ if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
+ && lp->status_pending_p)
if ((*selector)-- == 0)
return 1;
return 0;
}
-static int
-cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data)
-{
- struct thread_info *thread = (struct thread_info *) entry;
- struct lwp_info *lp = get_thread_lwp (thread);
- struct lwp_info *event_lp = data;
-
- /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
- if (lp == event_lp)
- return 0;
-
- /* If a LWP other than the LWP that we're reporting an event for has
- hit a GDB breakpoint (as opposed to some random trap signal),
- then just arrange for it to hit it again later. We don't keep
- the SIGTRAP status and don't forward the SIGTRAP signal to the
- LWP. We will handle the current event, eventually we will resume
- all LWPs, and this one will get its breakpoint trap again.
-
- If we do not do this, then we run the risk that the user will
- delete or disable the breakpoint, but the LWP will have already
- tripped on it. */
-
- if (thread->last_resume_kind != resume_stop
- && thread->last_status.kind == TARGET_WAITKIND_IGNORE
- && lp->status_pending_p
- && WIFSTOPPED (lp->status_pending)
- && WSTOPSIG (lp->status_pending) == SIGTRAP
- && !lp->stepping
- && !lp->stopped_by_watchpoint
- && cancel_breakpoint (lp))
- /* Throw away the SIGTRAP. */
- lp->status_pending_p = 0;
-
- return 0;
-}
-
-static void
-linux_cancel_breakpoints (void)
-{
- find_inferior (&all_threads, cancel_breakpoints_callback, NULL);
-}
-
/* Select one LWP out of those that have events pending. */
static void
{
int num_events = 0;
int random_selector;
- struct thread_info *event_thread;
-
- /* Give preference to any LWP that is being single-stepped. */
- event_thread
- = (struct thread_info *) find_inferior (&all_threads,
- select_singlestep_lwp_callback,
- NULL);
- if (event_thread != NULL)
+ struct thread_info *event_thread = NULL;
+
+ /* In all-stop, give preference to the LWP that is being
+ single-stepped. There will be at most one, and it's the LWP that
+ the core is most interested in. If we didn't do this, then we'd
+ have to handle pending step SIGTRAPs somehow in case the core
+ later continues the previously-stepped thread, otherwise we'd
+ report the pending SIGTRAP, and the core, not having stepped the
+ thread, wouldn't understand what the trap was for, and therefore
+ would report it to the user as a random signal. */
+ if (!non_stop)
{
- if (debug_threads)
- debug_printf ("SEL: Select single-step %s\n",
- target_pid_to_str (ptid_of (event_thread)));
+ event_thread
+ = (struct thread_info *) find_inferior (&all_threads,
+ select_singlestep_lwp_callback,
+ NULL);
+ if (event_thread != NULL)
+ {
+ if (debug_threads)
+ debug_printf ("SEL: Select single-step %s\n",
+ target_pid_to_str (ptid_of (event_thread)));
+ }
}
- else
+ if (event_thread == NULL)
{
/* No single-stepping LWP. Select one at random, out of those
- which have had SIGTRAP events. */
+ which have had events. */
- /* First see how many SIGTRAP events we have. */
+ /* First see how many events we have. */
find_inferior (&all_threads, count_events_callback, &num_events);
+ gdb_assert (num_events > 0);
- /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
+ /* Now randomly pick a LWP out of those that have had
+ events. */
random_selector = (int)
((num_events * (double) rand ()) / (RAND_MAX + 1.0));
static void
linux_stabilize_threads (void)
{
- struct thread_info *save_inferior;
+ struct thread_info *saved_thread;
struct thread_info *thread_stuck;
thread_stuck
return;
}
- save_inferior = current_inferior;
+ saved_thread = current_thread;
stabilizing_threads = 1;
if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
{
- lwp = get_thread_lwp (current_inferior);
+ lwp = get_thread_lwp (current_thread);
/* Lock it. */
lwp->suspended++;
if (ourstatus.value.sig != GDB_SIGNAL_0
- || current_inferior->last_resume_kind == resume_stop)
+ || current_thread->last_resume_kind == resume_stop)
{
wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
enqueue_one_deferred_signal (lwp, &wstat);
stabilizing_threads = 0;
- current_inferior = save_inferior;
+ current_thread = saved_thread;
if (debug_threads)
{
}
}
+static void async_file_mark (void);
+
+/* Convenience function that is called when the kernel reports an
+ event that is not passed out to GDB. */
+
+static ptid_t
+ignore_event (struct target_waitstatus *ourstatus)
+{
+ /* If we got an event, there may still be others, as a single
+ SIGCHLD can indicate more than one child stopped. This forces
+ another target_wait call. */
+ async_file_mark ();
+
+ ourstatus->kind = TARGET_WAITKIND_IGNORE;
+ return null_ptid;
+}
+
/* Wait for process, returns status. */
static ptid_t
if (target_options & TARGET_WNOHANG)
options |= WNOHANG;
-retry:
bp_explains_trap = 0;
trace_event = 0;
in_step_range = 0;
ourstatus->kind = TARGET_WAITKIND_IGNORE;
- /* If we were only supposed to resume one thread, only wait for
- that thread - if it's still alive. If it died, however - which
- can happen if we're coming from the thread death case below -
- then we need to make sure we restart the other threads. We could
- pick a thread at random or restart all; restarting all is less
- arbitrary. */
- if (!non_stop
- && !ptid_equal (cont_thread, null_ptid)
- && !ptid_equal (cont_thread, minus_one_ptid))
- {
- struct thread_info *thread;
-
- thread = (struct thread_info *) find_inferior_id (&all_threads,
- cont_thread);
-
- /* No stepping, no signal - unless one is pending already, of course. */
- if (thread == NULL)
- {
- struct thread_resume resume_info;
- resume_info.thread = minus_one_ptid;
- resume_info.kind = resume_continue;
- resume_info.sig = 0;
- linux_resume (&resume_info, 1);
- }
- else
- ptid = cont_thread;
- }
-
if (ptid_equal (step_over_bkpt, null_ptid))
pid = linux_wait_for_event (ptid, &w, options);
else
return null_ptid;
}
- event_child = get_thread_lwp (current_inferior);
+ event_child = get_thread_lwp (current_thread);
/* linux_wait_for_event only returns an exit status for the last
child of a process. Report it. */
{
debug_printf ("linux_wait_1 ret = %s, exited with "
"retcode %d\n",
- target_pid_to_str (ptid_of (current_inferior)),
+ target_pid_to_str (ptid_of (current_thread)),
WEXITSTATUS (w));
debug_exit ();
}
{
debug_printf ("linux_wait_1 ret = %s, terminated with "
"signal %d\n",
- target_pid_to_str (ptid_of (current_inferior)),
+ target_pid_to_str (ptid_of (current_thread)),
WTERMSIG (w));
debug_exit ();
}
}
- return ptid_of (current_inferior);
+ return ptid_of (current_thread);
+ }
+
+ /* If step-over executes a breakpoint instruction, it means a
+ gdb/gdbserver breakpoint had been planted on top of a permanent
+ breakpoint. The PC has been adjusted by
+ check_stopped_by_breakpoint to point at the breakpoint address.
+ Advance the PC manually past the breakpoint, otherwise the
+ program would keep trapping the permanent breakpoint forever. */
+ if (!ptid_equal (step_over_bkpt, null_ptid)
+ && event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
+ {
+ unsigned int increment_pc = the_low_target.breakpoint_len;
+
+ if (debug_threads)
+ {
+ debug_printf ("step-over for %s executed software breakpoint\n",
+ target_pid_to_str (ptid_of (current_thread)));
+ }
+
+ if (increment_pc != 0)
+ {
+ struct regcache *regcache
+ = get_thread_regcache (current_thread, 1);
+
+ event_child->stop_pc += increment_pc;
+ (*the_low_target.set_pc) (regcache, event_child->stop_pc);
+
+ if (!(*the_low_target.breakpoint_at) (event_child->stop_pc))
+ event_child->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+ }
}
/* If this event was not handled before, and is not a SIGTRAP, we
if (debug_threads)
debug_printf ("Got signal %d for LWP %ld. Check if we need "
"to defer or adjust it.\n",
- WSTOPSIG (w), lwpid_of (current_inferior));
+ WSTOPSIG (w), lwpid_of (current_thread));
/* Allow debugging the jump pad itself. */
- if (current_inferior->last_resume_kind != resume_step
+ if (current_thread->last_resume_kind != resume_step
&& maybe_move_out_of_jump_pad (event_child, &w))
{
enqueue_one_deferred_signal (event_child, &w);
if (debug_threads)
debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
- WSTOPSIG (w), lwpid_of (current_inferior));
+ WSTOPSIG (w), lwpid_of (current_thread));
linux_resume_one_lwp (event_child, 0, 0, NULL);
- goto retry;
+
+ return ignore_event (ourstatus);
}
}
if (debug_threads)
debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
"Check if we're already there.\n",
- lwpid_of (current_inferior),
+ lwpid_of (current_thread),
event_child->collecting_fast_tracepoint);
trace_event = 1;
care of while the breakpoint is still
inserted. */
stop_all_lwps (1, event_child);
- cancel_breakpoints ();
delete_breakpoint (event_child->exit_jump_pad_bkpt);
event_child->exit_jump_pad_bkpt = NULL;
{
debug_printf ("linux_wait_1 ret = %s, stopped "
"while stabilizing threads\n",
- target_pid_to_str (ptid_of (current_inferior)));
+ target_pid_to_str (ptid_of (current_thread)));
debug_exit ();
}
- return ptid_of (current_inferior);
+ return ptid_of (current_thread);
}
}
}
any that GDB specifically requested we ignore. But never ignore
SIGSTOP if we sent it ourselves, and do not ignore signals when
stepping - they may require special handling to skip the signal
- handler. */
+ handler. Also never ignore signals that could be caused by a
+ breakpoint. */
/* FIXME drow/2002-06-09: Get signal numbers from the inferior's
thread library? */
if (WIFSTOPPED (w)
- && current_inferior->last_resume_kind != resume_step
+ && current_thread->last_resume_kind != resume_step
&& (
#if defined (USE_THREAD_DB) && !defined (__ANDROID__)
- (current_process ()->private->thread_db != NULL
+ (current_process ()->priv->thread_db != NULL
&& (WSTOPSIG (w) == __SIGRTMIN
|| WSTOPSIG (w) == __SIGRTMIN + 1))
||
#endif
(pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
&& !(WSTOPSIG (w) == SIGSTOP
- && current_inferior->last_resume_kind == resume_stop))))
+ && current_thread->last_resume_kind == resume_stop)
+ && !linux_wstatus_maybe_breakpoint (w))))
{
siginfo_t info, *info_p;
if (debug_threads)
debug_printf ("Ignored signal %d for LWP %ld.\n",
- WSTOPSIG (w), lwpid_of (current_inferior));
+ WSTOPSIG (w), lwpid_of (current_thread));
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior),
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
(PTRACE_TYPE_ARG3) 0, &info) == 0)
info_p = &info;
else
info_p = NULL;
linux_resume_one_lwp (event_child, event_child->stepping,
WSTOPSIG (w), info_p);
- goto retry;
+ return ignore_event (ourstatus);
}
/* Note that all addresses are always "out of the step range" when
reporting the event to GDB. If we don't, we're out of luck, GDB
won't see the breakpoint hit. */
report_to_gdb = (!maybe_internal_trap
- || (current_inferior->last_resume_kind == resume_step
+ || (current_thread->last_resume_kind == resume_step
&& !in_step_range)
- || event_child->stopped_by_watchpoint
+ || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
|| (!step_over_finished && !in_step_range
&& !bp_explains_trap && !trace_event)
|| (gdb_breakpoint_here (event_child->stop_pc)
if (the_low_target.set_pc != NULL)
{
struct regcache *regcache
- = get_thread_regcache (current_inferior, 1);
+ = get_thread_regcache (current_thread, 1);
(*the_low_target.set_pc) (regcache, event_child->stop_pc);
}
unsuspend_all_lwps (event_child);
proceed_all_lwps ();
- goto retry;
+ return ignore_event (ourstatus);
}
if (debug_threads)
{
- if (current_inferior->last_resume_kind == resume_step)
+ if (current_thread->last_resume_kind == resume_step)
{
if (event_child->step_range_start == event_child->step_range_end)
debug_printf ("GDB wanted to single-step, reporting event.\n");
else if (!lwp_in_step_range (event_child))
debug_printf ("Out of step range, reporting event.\n");
}
- if (event_child->stopped_by_watchpoint)
+ if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
debug_printf ("Stopped by watchpoint.\n");
- if (gdb_breakpoint_here (event_child->stop_pc))
+ else if (gdb_breakpoint_here (event_child->stop_pc))
debug_printf ("Stopped by GDB breakpoint.\n");
if (debug_threads)
debug_printf ("Hit a non-gdbserver trap event.\n");
/* Alright, we're going to report a stop. */
- if (!non_stop && !stabilizing_threads)
+ if (!stabilizing_threads)
{
/* In all-stop, stop all threads. */
- stop_all_lwps (0, NULL);
+ if (!non_stop)
+ stop_all_lwps (0, NULL);
/* If we're not waiting for a specific LWP, choose an event LWP
from among those that have had events. Giving equal priority
select_event_lwp (&event_child);
- /* current_inferior and event_child must stay in sync. */
- current_inferior = get_lwp_thread (event_child);
+ /* current_thread and event_child must stay in sync. */
+ current_thread = get_lwp_thread (event_child);
event_child->status_pending_p = 0;
w = event_child->status_pending;
}
- /* Now that we've selected our final event LWP, cancel any
- breakpoints in other LWPs that have hit a GDB breakpoint.
- See the comment in cancel_breakpoints_callback to find out
- why. */
- find_inferior (&all_threads, cancel_breakpoints_callback, event_child);
-
- /* If we were going a step-over, all other threads but the stepping one
- had been paused in start_step_over, with their suspend counts
- incremented. We don't want to do a full unstop/unpause, because we're
- in all-stop mode (so we want threads stopped), but we still need to
- unsuspend the other threads, to decrement their `suspended' count
- back. */
if (step_over_finished)
- unsuspend_all_lwps (event_child);
+ {
+ if (!non_stop)
+ {
+ /* If we were doing a step-over, all other threads but
+ the stepping one had been paused in start_step_over,
+ with their suspend counts incremented. We don't want
+ to do a full unstop/unpause, because we're in
+ all-stop mode (so we want threads stopped), but we
+ still need to unsuspend the other threads, to
+ decrement their `suspended' count back. */
+ unsuspend_all_lwps (event_child);
+ }
+ else
+ {
+ /* If we just finished a step-over, then all threads had
+ been momentarily paused. In all-stop, that's fine,
+ we want threads stopped by now anyway. In non-stop,
+ we need to re-resume threads that GDB wanted to be
+ running. */
+ unstop_all_lwps (1, event_child);
+ }
+ }
/* Stabilize threads (move out of jump pads). */
- stabilize_threads ();
+ if (!non_stop)
+ stabilize_threads ();
}
else
{
ourstatus->kind = TARGET_WAITKIND_STOPPED;
- if (current_inferior->last_resume_kind == resume_stop
+ /* Now that we've selected our final event LWP, un-adjust its PC if
+ it was a software breakpoint, and the client doesn't know we can
+ adjust the breakpoint ourselves. */
+ if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ && !swbreak_feature)
+ {
+ int decr_pc = the_low_target.decr_pc_after_break;
+
+ if (decr_pc != 0)
+ {
+ struct regcache *regcache
+ = get_thread_regcache (current_thread, 1);
+ (*the_low_target.set_pc) (regcache, event_child->stop_pc + decr_pc);
+ }
+ }
+
+ if (current_thread->last_resume_kind == resume_stop
&& WSTOPSIG (w) == SIGSTOP)
{
/* A thread that has been requested to stop by GDB with vCont;t,
SIGSTOP is an implementation detail. */
ourstatus->value.sig = GDB_SIGNAL_0;
}
- else if (current_inferior->last_resume_kind == resume_stop
+ else if (current_thread->last_resume_kind == resume_stop
&& WSTOPSIG (w) != SIGSTOP)
{
/* A thread that has been requested to stop by GDB with vCont;t,
if (debug_threads)
{
debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
- target_pid_to_str (ptid_of (current_inferior)),
+ target_pid_to_str (ptid_of (current_thread)),
ourstatus->kind, ourstatus->value.sig);
debug_exit ();
}
- return ptid_of (current_inferior);
+ return ptid_of (current_thread);
}
/* Get rid of any pending event in the pipe. */
if (target_is_async_p ())
async_file_flush ();
- event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
+ do
+ {
+ event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
+ }
+ while ((target_options & TARGET_WNOHANG) == 0
+ && ptid_equal (event_ptid, null_ptid)
+ && ourstatus->kind == TARGET_WAITKIND_IGNORE);
/* If at least one stop was reported, there may be more. A single
SIGCHLD can signal more than one child stop. */
static void
wait_for_sigstop (void)
{
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
ptid_t saved_tid;
int wstat;
int ret;
- saved_inferior = current_inferior;
- if (saved_inferior != NULL)
- saved_tid = saved_inferior->entry.id;
+ saved_thread = current_thread;
+ if (saved_thread != NULL)
+ saved_tid = saved_thread->entry.id;
else
saved_tid = null_ptid; /* avoid bogus unused warning */
&wstat, __WALL);
gdb_assert (ret == -1);
- if (saved_inferior == NULL || linux_thread_alive (saved_tid))
- current_inferior = saved_inferior;
+ if (saved_thread == NULL || linux_thread_alive (saved_tid))
+ current_thread = saved_thread;
else
{
if (debug_threads)
/* We can't change the current inferior behind GDB's back,
otherwise, a subsequent command may apply to the wrong
process. */
- current_inferior = NULL;
+ current_thread = NULL;
}
else
{
/* Set a valid thread as current. */
- set_desired_inferior (0);
+ set_desired_thread (0);
}
}
}
return (supports_fast_tracepoints ()
&& agent_loaded_p ()
&& (gdb_breakpoint_here (lwp->stop_pc)
- || lwp->stopped_by_watchpoint
+ || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
|| thread->last_resume_kind == resume_step)
&& linux_fast_tracepoint_collecting (lwp, NULL));
}
/* Allow debugging the jump pad, gdb_collect, etc. */
if (!gdb_breakpoint_here (lwp->stop_pc)
- && !lwp->stopped_by_watchpoint
+ && lwp->stop_reason != TARGET_STOPPED_BY_WATCHPOINT
&& thread->last_resume_kind != resume_step
&& maybe_move_out_of_jump_pad (lwp, wstat))
{
}
}
-/* Resume execution of the inferior process.
- If STEP is nonzero, single-step it.
- If SIGNAL is nonzero, give it that signal. */
+/* Resume execution of LWP. If STEP is nonzero, single-step it. If
+ SIGNAL is nonzero, give it that signal. */
static void
-linux_resume_one_lwp (struct lwp_info *lwp,
- int step, int signal, siginfo_t *info)
+linux_resume_one_lwp_throw (struct lwp_info *lwp,
+ int step, int signal, siginfo_t *info)
{
struct thread_info *thread = get_lwp_thread (lwp);
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
int fast_tp_collecting;
if (lwp->stopped == 0)
return;
}
- saved_inferior = current_inferior;
- current_inferior = thread;
+ saved_thread = current_thread;
+ current_thread = thread;
if (debug_threads)
debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
step = 1;
}
- if (debug_threads && the_low_target.get_pc != NULL)
+ if (the_low_target.get_pc != NULL)
{
- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
- CORE_ADDR pc = (*the_low_target.get_pc) (regcache);
- debug_printf (" resuming from pc 0x%lx\n", (long) pc);
+ struct regcache *regcache = get_thread_regcache (current_thread, 1);
+
+ lwp->stop_pc = (*the_low_target.get_pc) (regcache);
+
+ if (debug_threads)
+ {
+ debug_printf (" %s from pc 0x%lx\n", step ? "step" : "continue",
+ (long) lwp->stop_pc);
+ }
}
/* If we have pending signals, consume one unless we are trying to
regcache_invalidate_thread (thread);
errno = 0;
- lwp->stopped = 0;
- lwp->stopped_by_watchpoint = 0;
lwp->stepping = step;
ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (thread),
(PTRACE_TYPE_ARG3) 0,
of coercing an 8 byte integer to a 4 byte pointer. */
(PTRACE_TYPE_ARG4) (uintptr_t) signal);
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
if (errno)
+ perror_with_name ("resuming thread");
+
+ /* Successfully resumed. Clear state that no longer makes sense,
+ and mark the LWP as running. Must not do this before resuming
+ otherwise if that fails other code will be confused. E.g., we'd
+ later try to stop the LWP and hang forever waiting for a stop
+ status. Note that we must not throw after this is cleared,
+ otherwise handle_zombie_lwp_error would get confused. */
+ lwp->stopped = 0;
+ lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+}
+
+/* Called when we try to resume a stopped LWP and that errors out. If
+ the LWP is no longer in ptrace-stopped state (meaning it's zombie,
+ or about to become), discard the error, clear any pending status
+ the LWP may have, and return true (we'll collect the exit status
+ soon enough). Otherwise, return false. */
+
+static int
+check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
+{
+ struct thread_info *thread = get_lwp_thread (lp);
+
+ /* If we get an error after resuming the LWP successfully, we'd
+ confuse !T state for the LWP being gone. */
+ gdb_assert (lp->stopped);
+
+ /* We can't just check whether the LWP is in 'Z (Zombie)' state,
+ because even if ptrace failed with ESRCH, the tracee may be "not
+ yet fully dead", but already refusing ptrace requests. In that
+ case the tracee has 'R (Running)' state for a little bit
+ (observed in Linux 3.18). See also the note on ESRCH in the
+ ptrace(2) man page. Instead, check whether the LWP has any state
+ other than ptrace-stopped. */
+
+ /* Don't assume anything if /proc/PID/status can't be read. */
+ if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread)) == 0)
{
- /* ESRCH from ptrace either means that the thread was already
- running (an error) or that it is gone (a race condition). If
- it's gone, we will get a notification the next time we wait,
- so we can ignore the error. We could differentiate these
- two, but it's tricky without waiting; the thread still exists
- as a zombie, so sending it signal 0 would succeed. So just
- ignore ESRCH. */
- if (errno == ESRCH)
- return;
+ lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+ lp->status_pending_p = 0;
+ return 1;
+ }
+ return 0;
+}
- perror_with_name ("ptrace");
+/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
+ disappears while we try to resume it. */
+
+static void
+linux_resume_one_lwp (struct lwp_info *lwp,
+ int step, int signal, siginfo_t *info)
+{
+ TRY
+ {
+ linux_resume_one_lwp_throw (lwp, step, signal, info);
}
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ if (!check_ptrace_stopped_lwp_gone (lwp))
+ throw_exception (ex);
+ }
+ END_CATCH
}
struct thread_resume_array
if (lwp->resume == NULL)
return 0;
- if (lwp->status_pending_p)
+ if (thread_still_has_status_pending_p (thread))
* (int *) flag_p = 1;
return 0;
{
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lwp = get_thread_lwp (thread);
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
CORE_ADDR pc;
/* LWPs which will not be resumed are not interesting, because we
return 0;
}
- saved_inferior = current_inferior;
- current_inferior = thread;
+ saved_thread = current_thread;
+ current_thread = thread;
/* We can only step over breakpoints we know about. */
if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
" GDB breakpoint at 0x%s; skipping step over\n",
lwpid_of (thread), paddress (pc));
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
return 0;
}
else
/* We've found an lwp that needs stepping over --- return 1 so
that find_inferior stops looking. */
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
/* If the step over is cancelled, this is set again. */
lwp->need_step_over = 0;
}
}
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
start_step_over (struct lwp_info *lwp)
{
struct thread_info *thread = get_lwp_thread (lwp);
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
CORE_ADDR pc;
int step;
shouldn't care about. */
pc = get_pc (lwp);
- saved_inferior = current_inferior;
- current_inferior = thread;
+ saved_thread = current_thread;
+ current_thread = thread;
lwp->bp_reinsert = pc;
uninsert_breakpoints_at (pc);
step = 0;
}
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
linux_resume_one_lwp (lwp, step, 0, NULL);
int pid;
struct iovec iov;
- regset = regsets_info->regsets;
-
- pid = lwpid_of (current_inferior);
- while (regset->size >= 0)
+ pid = lwpid_of (current_thread);
+ for (regset = regsets_info->regsets; regset->size >= 0; regset++)
{
void *buf, *data;
int nt_type, res;
if (regset->size == 0 || regset_disabled (regsets_info, regset))
- {
- regset ++;
- continue;
- }
+ continue;
buf = xmalloc (regset->size);
/* If we get EIO on a regset, do not try it again for
this process mode. */
disable_regset (regsets_info, regset);
- free (buf);
- continue;
+ }
+ else if (errno == ENODATA)
+ {
+ /* ENODATA may be returned if the regset is currently
+ not "active". This can happen in normal operation,
+ so suppress the warning in this case. */
}
else
{
perror (s);
}
}
- else if (regset->type == GENERAL_REGS)
- saw_general_regs = 1;
- regset->store_function (regcache, buf);
- regset ++;
+ else
+ {
+ if (regset->type == GENERAL_REGS)
+ saw_general_regs = 1;
+ regset->store_function (regcache, buf);
+ }
free (buf);
}
if (saw_general_regs)
int pid;
struct iovec iov;
- regset = regsets_info->regsets;
-
- pid = lwpid_of (current_inferior);
- while (regset->size >= 0)
+ pid = lwpid_of (current_thread);
+ for (regset = regsets_info->regsets; regset->size >= 0; regset++)
{
void *buf, *data;
int nt_type, res;
- if (regset->size == 0 || regset_disabled (regsets_info, regset))
- {
- regset ++;
- continue;
- }
+ if (regset->size == 0 || regset_disabled (regsets_info, regset)
+ || regset->fill_function == NULL)
+ continue;
buf = xmalloc (regset->size);
/* If we get EIO on a regset, do not try it again for
this process mode. */
disable_regset (regsets_info, regset);
- free (buf);
- continue;
}
else if (errno == ESRCH)
{
}
else if (regset->type == GENERAL_REGS)
saw_general_regs = 1;
- regset ++;
free (buf);
}
if (saw_general_regs)
& -sizeof (PTRACE_XFER_TYPE));
buf = alloca (size);
- pid = lwpid_of (current_inferior);
+ pid = lwpid_of (current_thread);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
else
collect_register (regcache, regno, buf);
- pid = lwpid_of (current_inferior);
+ pid = lwpid_of (current_thread);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
static int
linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
- int pid = lwpid_of (current_inferior);
+ int pid = lwpid_of (current_thread);
register PTRACE_XFER_TYPE *buffer;
register CORE_ADDR addr;
register int count;
register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
alloca (count * sizeof (PTRACE_XFER_TYPE));
- int pid = lwpid_of (current_inferior);
+ int pid = lwpid_of (current_thread);
if (len == 0)
{
#ifdef USE_THREAD_DB
struct process_info *proc = current_process ();
- if (proc->private->thread_db != NULL)
+ if (proc->priv->thread_db != NULL)
return;
/* If the kernel supports tracing clones, then we don't need to
{
extern unsigned long signal_pid;
- if (!ptid_equal (cont_thread, null_ptid)
- && !ptid_equal (cont_thread, minus_one_ptid))
- {
- int lwpid;
-
- lwpid = lwpid_of (current_inferior);
- kill_lwp (lwpid, SIGINT);
- }
- else
- kill_lwp (signal_pid, SIGINT);
+ /* Send a SIGINT to the process group. This acts just like the user
+ typed a ^C on the controlling terminal. */
+ kill (-signal_pid, SIGINT);
}
/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
{
char filename[PATH_MAX];
int fd, n;
- int pid = lwpid_of (current_inferior);
+ int pid = lwpid_of (current_thread);
xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
return 1;
}
+/* Implement the to_stopped_by_sw_breakpoint target_ops
+ method. */
+
+static int
+linux_stopped_by_sw_breakpoint (void)
+{
+ struct lwp_info *lwp = get_thread_lwp (current_thread);
+
+ return (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
+}
+
+/* Implement the to_supports_stopped_by_sw_breakpoint target_ops
+ method. */
+
+static int
+linux_supports_stopped_by_sw_breakpoint (void)
+{
+ return USE_SIGTRAP_SIGINFO;
+}
+
+/* Implement the to_stopped_by_hw_breakpoint target_ops
+ method. */
+
+static int
+linux_stopped_by_hw_breakpoint (void)
+{
+ struct lwp_info *lwp = get_thread_lwp (current_thread);
+
+ return (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
+}
+
+/* Implement the to_supports_stopped_by_hw_breakpoint target_ops
+ method. */
+
+static int
+linux_supports_stopped_by_hw_breakpoint (void)
+{
+ return USE_SIGTRAP_SIGINFO;
+}
+
static int
linux_stopped_by_watchpoint (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_inferior);
+ struct lwp_info *lwp = get_thread_lwp (current_thread);
- return lwp->stopped_by_watchpoint;
+ return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
static CORE_ADDR
linux_stopped_data_address (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_inferior);
+ struct lwp_info *lwp = get_thread_lwp (current_thread);
return lwp->stopped_data_address;
}
linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
{
unsigned long text, text_end, data;
- int pid = lwpid_of (get_thread_lwp (current_inferior));
+ int pid = lwpid_of (get_thread_lwp (current_thread));
errno = 0;
siginfo_t siginfo;
char inf_siginfo[sizeof (siginfo_t)];
- if (current_inferior == NULL)
+ if (current_thread == NULL)
return -1;
- pid = lwpid_of (current_inferior);
+ pid = lwpid_of (current_thread);
if (debug_threads)
debug_printf ("%s siginfo for lwp %d.\n",
if (enable)
{
if (pipe (linux_event_pipe) == -1)
- fatal ("creating event pipe failed.");
+ {
+ linux_event_pipe[0] = -1;
+ linux_event_pipe[1] = -1;
+ sigprocmask (SIG_UNBLOCK, &mask, NULL);
+
+ warning ("creating event pipe failed.");
+ return previous;
+ }
fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
{
/* Register or unregister from event-loop accordingly. */
linux_async (nonstop);
+
+ if (target_is_async_p () != (nonstop != 0))
+ return -1;
+
return 0;
}
unsigned const char *writebuf,
CORE_ADDR offset, int len)
{
- long pid = lwpid_of (current_inferior);
+ long pid = lwpid_of (current_thread);
char buf[128];
int fd = 0;
int ret = 0;
linux_read_loadmap (const char *annex, CORE_ADDR offset,
unsigned char *myaddr, unsigned int len)
{
- int pid = lwpid_of (current_inferior);
+ int pid = lwpid_of (current_thread);
int addr = -1;
struct target_loadmap *data = NULL;
unsigned int actual_length, copy_length;
{
char *document;
unsigned document_len;
- struct process_info_private *const priv = current_process ()->private;
+ struct process_info_private *const priv = current_process ()->priv;
char filename[PATH_MAX];
int pid, is_elf64;
if (readbuf == NULL)
return -1;
- pid = lwpid_of (current_inferior);
+ pid = lwpid_of (current_thread);
xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
is_elf64 = elf_64_file_p (filename, &machine);
lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
break;
len = sep - annex;
- if (len == 5 && strncmp (annex, "start", 5) == 0)
+ if (len == 5 && startswith (annex, "start"))
addrp = &lm_addr;
- else if (len == 4 && strncmp (annex, "prev", 4) == 0)
+ else if (len == 4 && startswith (annex, "prev"))
addrp = &lm_prev;
else
{
/* See to_enable_btrace target method. */
static struct btrace_target_info *
-linux_low_enable_btrace (ptid_t ptid)
+linux_low_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
{
struct btrace_target_info *tinfo;
- tinfo = linux_enable_btrace (ptid);
+ tinfo = linux_enable_btrace (ptid, conf);
- if (tinfo != NULL)
+ if (tinfo != NULL && tinfo->ptr_bits == 0)
{
struct thread_info *thread = find_thread_ptid (ptid);
struct regcache *regcache = get_thread_regcache (thread, 0);
linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer,
int type)
{
- VEC (btrace_block_s) *btrace;
+ struct btrace_data btrace;
struct btrace_block *block;
enum btrace_error err;
int i;
- btrace = NULL;
+ btrace_data_init (&btrace);
+
err = linux_read_btrace (&btrace, tinfo, type);
if (err != BTRACE_ERR_NONE)
{
else
buffer_grow_str0 (buffer, "E.Generic Error.");
+ btrace_data_fini (&btrace);
+ return -1;
+ }
+
+ switch (btrace.format)
+ {
+ case BTRACE_FORMAT_NONE:
+ buffer_grow_str0 (buffer, "E.No Trace.");
+ break;
+
+ case BTRACE_FORMAT_BTS:
+ buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
+ buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
+
+ for (i = 0;
+ VEC_iterate (btrace_block_s, btrace.variant.bts.blocks, i, block);
+ i++)
+ buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
+ paddress (block->begin), paddress (block->end));
+
+ buffer_grow_str0 (buffer, "</btrace>\n");
+ break;
+
+ default:
+ buffer_grow_str0 (buffer, "E.Unknown Trace Format.");
+
+ btrace_data_fini (&btrace);
return -1;
}
- buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
- buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
+ btrace_data_fini (&btrace);
+ return 0;
+}
+
+/* See to_btrace_conf target method. */
+
+static int
+linux_low_btrace_conf (const struct btrace_target_info *tinfo,
+ struct buffer *buffer)
+{
+ const struct btrace_config *conf;
- for (i = 0; VEC_iterate (btrace_block_s, btrace, i, block); i++)
- buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
- paddress (block->begin), paddress (block->end));
+ buffer_grow_str (buffer, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
+ buffer_grow_str (buffer, "<btrace-conf version=\"1.0\">\n");
- buffer_grow_str0 (buffer, "</btrace>\n");
+ conf = linux_btrace_conf (tinfo);
+ if (conf != NULL)
+ {
+ switch (conf->format)
+ {
+ case BTRACE_FORMAT_NONE:
+ break;
- VEC_free (btrace_block_s, btrace);
+ case BTRACE_FORMAT_BTS:
+ buffer_xml_printf (buffer, "<bts");
+ buffer_xml_printf (buffer, " size=\"0x%x\"", conf->bts.size);
+ buffer_xml_printf (buffer, " />\n");
+ break;
+ }
+ }
+ buffer_grow_str0 (buffer, "</btrace-conf>\n");
return 0;
}
#endif /* HAVE_LINUX_BTRACE */
+/* See nat/linux-nat.h. */
+
+ptid_t
+current_lwp_ptid (void)
+{
+ return ptid_of (current_thread);
+}
+
static struct target_ops linux_target_ops = {
linux_create_inferior,
linux_attach,
linux_supports_z_point_type,
linux_insert_point,
linux_remove_point,
+ linux_stopped_by_sw_breakpoint,
+ linux_supports_stopped_by_sw_breakpoint,
+ linux_stopped_by_hw_breakpoint,
+ linux_supports_stopped_by_hw_breakpoint,
linux_stopped_by_watchpoint,
linux_stopped_data_address,
#if defined(__UCLIBC__) && defined(HAS_NOMMU) \
NULL,
linux_pause_all,
linux_unpause_all,
- linux_cancel_breakpoints,
linux_stabilize_threads,
linux_install_fast_tracepoint_jump_pad,
linux_emit_ops,
linux_low_enable_btrace,
linux_low_disable_btrace,
linux_low_read_btrace,
+ linux_low_btrace_conf,
#else
NULL,
NULL,
NULL,
NULL,
+ NULL,
#endif
linux_supports_range_stepping,
};
projects / deliverable / binutils-gdb.git / blobdiff