/* GNU/Linux native-dependent code common to multiple platforms.
- Copyright (C) 2001-2019 Free Software Foundation, Inc.
+ Copyright (C) 2001-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "nat/linux-nat.h"
#include "nat/linux-waitpid.h"
-#include "common/gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include <unistd.h>
#include <sys/syscall.h>
#include "nat/gdb_ptrace.h"
#include "nat/linux-osdata.h"
#include "linux-tdep.h"
#include "symfile.h"
-#include "common/agent.h"
+#include "gdbsupport/agent.h"
#include "tracepoint.h"
-#include "common/buffer.h"
+#include "gdbsupport/buffer.h"
#include "target-descriptions.h"
-#include "common/filestuff.h"
+#include "gdbsupport/filestuff.h"
#include "objfiles.h"
#include "nat/linux-namespaces.h"
-#include "common/fileio.h"
-#include "common/scope-exit.h"
-
-#ifndef SPUFS_MAGIC
-#define SPUFS_MAGIC 0x23c9b64e
-#endif
+#include "gdbsupport/fileio.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbsupport/gdb-sigmask.h"
/* This comment documents high-level logic of this file.
}
else
{
- scoped_restore save_inferior_ptid
- = make_scoped_restore (&inferior_ptid);
- inferior_ptid = child_ptid;
+ /* Switching inferior_ptid is not enough, because then
+ inferior_thread () would crash by not finding the thread
+ in the current inferior. */
+ scoped_restore_current_thread restore_current_thread;
+ thread_info *child = find_thread_ptid (this, child_ptid);
+ switch_to_thread (child);
/* Let the thread_db layer learn about this new process. */
check_for_thread_db ();
\f
-/* Original signal mask. */
-static sigset_t normal_mask;
-
/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
_initialize_linux_nat. */
static sigset_t suspend_mask;
if (!sigismember (&blocked_mask, SIGCHLD))
sigaddset (&blocked_mask, SIGCHLD);
- sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
+ gdb_sigmask (SIG_BLOCK, &blocked_mask, prev_mask);
}
/* Restore child signals mask, previously returned by
static void
restore_child_signals_mask (sigset_t *prev_mask)
{
- sigprocmask (SIG_SETMASK, prev_mask, NULL);
+ gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
}
/* Mask of signals to pass directly to the inferior. */
/* This changes the thread's ptid while preserving the gdb thread
num. Also changes the inferior pid, while preserving the
inferior num. */
- thread_change_ptid (inferior_ptid, new_ptid);
+ thread_change_ptid (linux_target, inferior_ptid, new_ptid);
/* We've just told GDB core that the thread changed target id, but,
in fact, it really is a different thread, with different register
static void
exit_lwp (struct lwp_info *lp)
{
- struct thread_info *th = find_thread_ptid (lp->ptid);
+ struct thread_info *th = find_thread_ptid (linux_target, lp->ptid);
if (th)
{
/* Also add the LWP to gdb's thread list, in case a
matching libthread_db is not found (or the process uses
raw clone). */
- add_thread (lp->ptid);
- set_running (lp->ptid, 1);
- set_executing (lp->ptid, 1);
+ add_thread (linux_target, lp->ptid);
+ set_running (linux_target, lp->ptid, 1);
+ set_executing (linux_target, lp->ptid, 1);
}
return 1;
/* Make sure we report all signals during attach. */
pass_signals ({});
- TRY
+ try
{
inf_ptrace_target::attach (args, from_tty);
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
pid_t pid = parse_pid_to_attach (args);
std::string reason = linux_ptrace_attach_fail_reason (pid);
if (!reason.empty ())
- throw_error (ex.error, "warning: %s\n%s", reason.c_str (), ex.message);
+ throw_error (ex.error, "warning: %s\n%s", reason.c_str (),
+ ex.what ());
else
- throw_error (ex.error, "%s", ex.message);
+ throw_error (ex.error, "%s", ex.what ());
}
- END_CATCH
/* The ptrace base target adds the main thread with (pid,0,0)
format. Decorate it with lwp info. */
ptid = ptid_t (inferior_ptid.pid (),
inferior_ptid.pid (),
0);
- thread_change_ptid (inferior_ptid, ptid);
+ thread_change_ptid (linux_target, inferior_ptid, ptid);
/* Add the initial process as the first LWP to the list. */
lp = add_initial_lwp (ptid);
signo = gdb_signal_from_host (WSTOPSIG (lp->status));
else
{
- struct thread_info *tp = find_thread_ptid (lp->ptid);
+ struct thread_info *tp = find_thread_ptid (linux_target, lp->ptid);
if (target_is_non_stop_p () && !tp->executing)
{
}
else if (!target_is_non_stop_p ())
{
- struct target_waitstatus last;
ptid_t last_ptid;
+ process_stratum_target *last_target;
- get_last_target_status (&last_ptid, &last);
+ get_last_target_status (&last_target, &last_ptid, nullptr);
- if (lp->ptid.lwp () == last_ptid.lwp ())
+ if (last_target == linux_target
+ && lp->ptid.lwp () == last_ptid.lwp ())
signo = tp->suspend.stop_signal;
}
}
/* Preparing to resume may try to write registers, and fail if the
lwp is zombie. If that happens, ignore the error. We'll handle
it below, when detach fails with ESRCH. */
- TRY
+ try
{
linux_target->low_prepare_to_resume (lp);
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
- throw_exception (ex);
+ throw;
}
- END_CATCH
if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0)
{
if (ret == -1)
{
warning (_("Couldn't reap LWP %d while detaching: %s"),
- lwpid, strerror (errno));
+ lwpid, safe_strerror (errno));
}
else if (!WIFEXITED (status) && !WIFSIGNALED (status))
{
inferiors running. */
/* Stop all threads before detaching. ptrace requires that the
- thread is stopped to sucessfully detach. */
+ thread is stopped to successfully detach. */
iterate_over_lwps (ptid_t (pid), stop_callback);
/* ... and wait until all of them have reported back that
they're no longer running. */
handle the case of stepping a breakpoint instruction). */
if (step)
{
- struct regcache *regcache = get_thread_regcache (lp->ptid);
+ struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
lp->stop_pc = regcache_read_pc (regcache);
}
lp->stopped = 0;
lp->core = -1;
lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
- registers_changed_ptid (lp->ptid);
+ registers_changed_ptid (linux_target, lp->ptid);
}
/* Called when we try to resume a stopped LWP and that errors out. If
static void
linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
{
- TRY
+ try
{
linux_resume_one_lwp_throw (lp, step, signo);
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
- throw_exception (ex);
+ throw;
}
- END_CATCH
}
/* Resume LP. */
{
if (lp->stopped)
{
- struct inferior *inf = find_inferior_ptid (lp->ptid);
+ struct inferior *inf = find_inferior_ptid (linux_target, lp->ptid);
if (inf->vfork_child != NULL)
{
{
struct thread_info *thread;
- thread = find_thread_ptid (lp->ptid);
+ thread = find_thread_ptid (linux_target, lp->ptid);
if (thread != NULL)
{
signo = thread->suspend.stop_signal;
{
struct target_waitstatus *ourstatus = &lp->waitstatus;
struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
- thread_info *thread = find_thread_ptid (lp->ptid);
+ thread_info *thread = find_thread_ptid (linux_target, lp->ptid);
int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, thread);
if (stopping)
/* The process is not using thread_db. Add the LWP to
GDB's list. */
target_post_attach (new_lp->ptid.lwp ());
- add_thread (new_lp->ptid);
+ add_thread (linux_target, new_lp->ptid);
}
/* Even if we're stopping the thread for some reason
internal to this module, from the perspective of infrun
and the user/frontend, this new thread is running until
it next reports a stop. */
- set_running (new_lp->ptid, 1);
- set_executing (new_lp->ptid, 1);
+ set_running (linux_target, new_lp->ptid, 1);
+ set_executing (linux_target, new_lp->ptid, 1);
if (WSTOPSIG (status) != SIGSTOP)
{
if (lp->must_set_ptrace_flags)
{
- struct inferior *inf = find_inferior_pid (lp->ptid.pid ());
+ inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ());
int options = linux_nat_ptrace_options (inf->attach_flag);
linux_enable_event_reporting (lp->ptid.lwp (), options);
static int
stop_wait_callback (struct lwp_info *lp)
{
- struct inferior *inf = find_inferior_ptid (lp->ptid);
+ inferior *inf = find_inferior_ptid (linux_target, lp->ptid);
/* If this is a vfork parent, bail out, it is not going to report
any SIGSTOP until the vfork is done with. */
if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
|| lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
{
- struct regcache *regcache = get_thread_regcache (lp->ptid);
+ struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
CORE_ADDR pc;
int discard = 0;
if (!linux_target->low_status_is_event (lp->status))
return;
- regcache = get_thread_regcache (lp->ptid);
+ regcache = get_thread_regcache (linux_target, lp->ptid);
gdbarch = regcache->arch ();
pc = regcache_read_pc (regcache);
lp = add_lwp (ptid_t (lwpid, lwpid, 0));
lp->stopped = 1;
lp->resumed = 1;
- add_thread (lp->ptid);
+ add_thread (linux_target, lp->ptid);
}
if (WIFSTOPPED (status) && !lp)
if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
{
- struct inferior *inf = find_inferior_pid (lp->ptid.pid ());
+ inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ());
int options = linux_nat_ptrace_options (inf->attach_flag);
linux_enable_event_reporting (lp->ptid.lwp (), options);
/* When using hardware single-step, we need to report every signal.
Otherwise, signals in pass_mask may be short-circuited
- except signals that might be caused by a breakpoint. */
+ except signals that might be caused by a breakpoint, or SIGSTOP
+ if we sent the SIGSTOP and are waiting for it to arrive. */
if (!lp->step
&& WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
+ && (WSTOPSIG (status) != SIGSTOP
+ || !find_thread_ptid (linux_target, lp->ptid)->stop_requested)
&& !linux_wstatus_maybe_breakpoint (status))
{
linux_resume_one_lwp (lp, lp->step, signo);
if (inferior_ptid.is_pid ())
{
/* Upgrade the main thread's ptid. */
- thread_change_ptid (inferior_ptid,
+ thread_change_ptid (linux_target, inferior_ptid,
ptid_t (inferior_ptid.pid (),
inferior_ptid.pid (), 0));
- If the thread group leader exits while other threads in the
thread group still exist, waitpid(TGID, ...) hangs. That
waitpid won't return an exit status until the other threads
- in the group are reapped.
+ in the group are reaped.
- When a non-leader thread execs, that thread just vanishes
without reporting an exit (so we'd hang if we waited for it
if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
&& !USE_SIGTRAP_SIGINFO)
{
- struct regcache *regcache = get_thread_regcache (lp->ptid);
+ struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
struct gdbarch *gdbarch = regcache->arch ();
int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
}
else
{
- struct regcache *regcache = get_thread_regcache (lp->ptid);
+ struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
struct gdbarch *gdbarch = regcache->arch ();
- TRY
+ try
{
CORE_ADDR pc = regcache_read_pc (regcache);
int leave_stopped = 0;
linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
}
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
- throw_exception (ex);
+ throw;
}
- END_CATCH
}
return 0;
ptid_t ptid = ptid_t (inferior_ptid.pid ());
/* Stop all threads before killing them, since ptrace requires
- that the thread is stopped to sucessfully PTRACE_KILL. */
+ that the thread is stopped to successfully PTRACE_KILL. */
iterate_over_lwps (ptid, stop_callback);
/* ... and wait until all of them have reported back that
they're no longer running. */
const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len);
-static enum target_xfer_status
-linux_proc_xfer_spu (enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len);
-
static enum target_xfer_status
linux_proc_xfer_partial (enum target_object object,
const char *annex, gdb_byte *readbuf,
return linux_nat_xfer_osdata (object, annex, readbuf, writebuf,
offset, len, xfered_len);
- if (object == TARGET_OBJECT_SPU)
- return linux_proc_xfer_spu (object, annex, readbuf, writebuf,
- offset, len, xfered_len);
-
/* GDB calculates all addresses in the largest possible address
width.
The address width must be masked before its final use - either by
}
-/* Enumerate spufs IDs for process PID. */
-static LONGEST
-spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
-{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
- LONGEST pos = 0;
- LONGEST written = 0;
- char path[128];
- DIR *dir;
- struct dirent *entry;
-
- xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
- dir = opendir (path);
- if (!dir)
- return -1;
-
- rewinddir (dir);
- while ((entry = readdir (dir)) != NULL)
- {
- struct stat st;
- struct statfs stfs;
- int fd;
-
- fd = atoi (entry->d_name);
- if (!fd)
- continue;
-
- xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
- if (stat (path, &st) != 0)
- continue;
- if (!S_ISDIR (st.st_mode))
- continue;
-
- if (statfs (path, &stfs) != 0)
- continue;
- if (stfs.f_type != SPUFS_MAGIC)
- continue;
-
- if (pos >= offset && pos + 4 <= offset + len)
- {
- store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
- written += 4;
- }
- pos += 4;
- }
-
- closedir (dir);
- return written;
-}
-
-/* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
- object type, using the /proc file system. */
-
-static enum target_xfer_status
-linux_proc_xfer_spu (enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
-{
- char buf[128];
- int fd = 0;
- int ret = -1;
- int pid = inferior_ptid.lwp ();
-
- if (!annex)
- {
- if (!readbuf)
- return TARGET_XFER_E_IO;
- else
- {
- LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
-
- if (l < 0)
- return TARGET_XFER_E_IO;
- else if (l == 0)
- return TARGET_XFER_EOF;
- else
- {
- *xfered_len = (ULONGEST) l;
- return TARGET_XFER_OK;
- }
- }
- }
-
- xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
- fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
- if (fd <= 0)
- return TARGET_XFER_E_IO;
-
- if (offset != 0
- && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
- {
- close (fd);
- return TARGET_XFER_EOF;
- }
-
- if (writebuf)
- ret = write (fd, writebuf, (size_t) len);
- else if (readbuf)
- ret = read (fd, readbuf, (size_t) len);
-
- close (fd);
-
- if (ret < 0)
- return TARGET_XFER_E_IO;
- else if (ret == 0)
- return TARGET_XFER_EOF;
- else
- {
- *xfered_len = (ULONGEST) ret;
- return TARGET_XFER_OK;
- }
-}
-
-
/* Parse LINE as a signal set and add its set bits to SIGS. */
static void
return previous;
}
+int
+linux_nat_target::async_wait_fd ()
+{
+ return linux_nat_event_pipe[0];
+}
+
/* target_async implementation. */
void
if (debug_linux_nat)
{
- if (find_thread_ptid (lwp->ptid)->stop_requested)
+ if (find_thread_ptid (linux_target, lwp->ptid)->stop_requested)
fprintf_unfiltered (gdb_stdlog,
"LNSL: already stopped/stop_requested %s\n",
target_pid_to_str (lwp->ptid).c_str ());
pid = ptid.pid ();
}
- inf = find_inferior_pid (pid);
+ inf = find_inferior_pid (this, pid);
gdb_assert (inf != NULL);
return inf->aspace;
}
NULL,
&setdebuglist, &showdebuglist);
- /* Save this mask as the default. */
- sigprocmask (SIG_SETMASK, NULL, &normal_mask);
-
/* Install a SIGCHLD handler. */
sigchld_action.sa_handler = sigchld_handler;
sigemptyset (&sigchld_action.sa_mask);
sigaction (SIGCHLD, &sigchld_action, NULL);
/* Make sure we don't block SIGCHLD during a sigsuspend. */
- sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
+ gdb_sigmask (SIG_SETMASK, NULL, &suspend_mask);
sigdelset (&suspend_mask, SIGCHLD);
sigemptyset (&blocked_mask);