26#include "gdbsupport/gdb_wait.h"
28#include <sys/syscall.h>
42#include <sys/procfs.h>
50#include "gdbsupport/event-loop.h"
61#include "gdbsupport/agent.h"
63#include "gdbsupport/buffer.h"
65#include "gdbsupport/filestuff.h"
68#include "gdbsupport/block-signals.h"
69#include "gdbsupport/fileio.h"
70#include "gdbsupport/scope-exit.h"
71#include "gdbsupport/gdb-sigmask.h"
72#include "gdbsupport/common-debug.h"
73#include <unordered_map>
205 gdb_printf (file, _(
"Debugging of GNU/Linux native targets is %s.\n"),
211#define linux_nat_debug_printf(fmt, ...) \
212 debug_prefixed_printf_cond (debug_linux_nat, "linux-nat", fmt, ##__VA_ARGS__)
216#define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT \
217 scoped_debug_enter_exit (debug_linux_nat, "linux-nat")
230static int kill_lwp (
int lwpid,
int signo);
256 return lp->
ptid.pid () == lp->
ptid.lwp ();
321 new_pid->
next = *listp;
330 for (p = listp; *p != NULL; p = &(*p)->
next)
331 if ((*p)->pid ==
pid)
403 if (lp->ptid.pid () ==
pid)
437 int parent_pid = parent_ptid.lwp ();
438 int child_pid = child_ptid.lwp ();
448 int child_stop_signal = 0;
449 bool detach_child =
true;
475 if (
ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
481 detach_child = WIFSTOPPED (
status);
482 child_stop_signal = WSTOPSIG (
status);
488 int signo = child_stop_signal;
493 ptrace (PTRACE_DETACH, child_pid, 0, signo);
513 child_lp =
add_lwp (child_ptid);
558 gdb::array_view<const int> syscall_counts)
581 return iterative_hash_object (
pid, 0);
593 return entry->
ptid.lwp () == element->
ptid.lwp ();
612 gdb_assert (slot != NULL && *slot == NULL);
688 gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
697 (gdb::array_view<const unsigned char> pass_signals)
703 for (signo = 1; signo < NSIG; signo++)
705 int target_signo = gdb_signal_from_host (signo);
734 int pid = *(
int *) info;
771 gdb_assert (
ptid.lwp_p ());
817 gdb_assert (lp != NULL);
849 gdb::function_view<iterate_over_lwps_ftype> callback)
853 if (lp->ptid.matches (filter))
855 if (callback (lp) != 0)
914 pid_t new_pid,
pid = ptid.lwp ();
945 gdb_assert (
pid == new_pid);
955 if (WSTOPSIG (
status) != SIGSTOP)
967 const std::string &allargs,
968 char **env,
int from_tty)
997 int lwpid =
ptid.lwp ();
999 if (
ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1012 (
"Cannot attach to lwp %d: thread is gone (%d: %s)",
1013 lwpid,
err, safe_strerror (
err));
1021 warning (_(
"Cannot attach to lwp %d: %s"),
1022 lwpid, reason.c_str ());
1028 ptid.to_string ().c_str ());
1070 catch (
const gdb_exception_error &ex)
1075 if (!reason.empty ())
1076 throw_error (ex.error,
"warning: %s\n%s", reason.c_str (),
1079 throw_error (ex.error,
"%s", ex.what ());
1092 if (!WIFSTOPPED (
status))
1096 int exit_code = WEXITSTATUS (
status);
1101 error (_(
"Unable to attach: program exited normally."));
1103 error (_(
"Unable to attach: program exited with code %d."),
1106 else if (WIFSIGNALED (
status))
1108 enum gdb_signal signo;
1113 signo = gdb_signal_from_host (WTERMSIG (
status));
1114 error (_(
"Unable to attach: program terminated with signal "
1116 gdb_signal_to_name (signo),
1117 gdb_signal_to_string (signo));
1120 internal_error (_(
"unexpected status %d for PID %ld"),
1121 status, (
long) ptid.lwp ());
1131 (
long) lp->
ptid.pid (),
1152 if (
ptrace (PTRACE_DETACH,
pid, 0, signo) < 0)
1154 int save_errno = errno;
1160 if (save_errno == ESRCH)
1167 warning (_(
"Couldn't reap LWP %d while detaching: %s"),
1168 pid, safe_strerror (errno));
1172 warning (_(
"Reaping LWP %d while detaching "
1173 "returned unexpected status 0x%x"),
1178 error (_(
"Can't detach %d: %s"),
1179 pid, safe_strerror (save_errno));
1183 pid, strsignal (signo));
1194 enum gdb_signal signo = GDB_SIGNAL_0;
1218 signo = GDB_SIGNAL_0;
1220 signo = gdb_signal_from_host (WSTOPSIG (lp->
status));
1236 signo = GDB_SIGNAL_0;
1249 && lp->
ptid.lwp () == last_ptid.lwp ())
1254 if (signo == GDB_SIGNAL_0)
1257 lp->
ptid.to_string ().c_str ());
1262 (
"lwp %s had signal %s but it is in no pass state",
1263 lp->
ptid.to_string ().c_str (), gdb_signal_to_string (signo));
1268 lp->
ptid.to_string ().c_str (),
1269 gdb_signal_to_string (signo));
1271 return gdb_signal_to_host (signo);
1284 int lwpid = lp->
ptid.lwp ();
1287 gdb_assert (lp->
status == 0 || WIFSTOPPED (lp->
status));
1300 unsigned long child_pid;
1333 strsignal (WSTOPSIG (lp->
status)),
1334 lp->
ptid.to_string ().c_str ());
1340 lp->
ptid.to_string ().c_str ());
1346 if (signo_p == NULL)
1361 catch (
const gdb_exception_error &ex)
1378 if (lp->
ptid.lwp () != lp->
ptid.pid ())
1439 enum gdb_signal signo)
1512 catch (
const gdb_exception_error &ex)
1528 if (
inf->vfork_child != NULL)
1531 lp->
ptid.to_string ().c_str ());
1536 lp->
ptid.to_string ().c_str (),
1537 (signo != GDB_SIGNAL_0
1538 ? strsignal (gdb_signal_to_host (signo))
1540 step ?
"step" :
"resume");
1547 lp->
ptid.to_string ().c_str ());
1552 lp->
ptid.to_string ().c_str ());
1561 enum gdb_signal signo = GDB_SIGNAL_0;
1604 step ?
"step" :
"resume",
1605 scope_ptid.to_string ().c_str (),
1606 (signo != GDB_SIGNAL_0
1607 ? strsignal (gdb_signal_to_host (signo)) :
"0"),
1615 gdb_assert (lp != NULL);
1635 (
"Not short circuiting for ignored status 0x%x", lp->
status);
1639 gdb_assert (signo == GDB_SIGNAL_0);
1640 signo = gdb_signal_from_host (WSTOPSIG (lp->
status));
1649 gdb_assert (signo == GDB_SIGNAL_0);
1664 if (scope_ptid != lp->
ptid)
1671 step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
1672 lp->
ptid.to_string ().c_str (),
1673 (signo != GDB_SIGNAL_0
1674 ? strsignal (gdb_signal_to_host (signo)) :
"0"));
1687 ret =
syscall (__NR_tkill, lwpid, signo);
1688 if (errno == ENOSYS)
1734 (
"ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1735 "PTRACE_CONT for SIGSTOP", syscall_number, lp->
ptid.lwp ());
1762 gdb_assert_not_reached (
"unexpected syscall state");
1765 (
"stopping for %s of syscall %d for LWP %ld",
1767 ?
"entry" :
"return"), syscall_number, lp->
ptid.lwp ());
1773 (
"ignoring %s of syscall %d for LWP %ld",
1775 ?
"entry" :
"return"), syscall_number, lp->
ptid.lwp ());
1796 (
"caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1797 "ignoring", syscall_number, lp->
ptid.lwp ());
1833 unsigned long new_pid;
1846 else if (ret != new_pid)
1847 internal_error (_(
"wait returned unexpected PID %d"), ret);
1848 else if (!WIFSTOPPED (
status))
1849 internal_error (_(
"wait returned unexpected status 0x%x"),
status);
1903 (
"Got clone event from LWP %d, new child is LWP %ld",
pid, new_pid);
1905 new_lp =
add_lwp (ptid_t (lp->
ptid.pid (), new_pid));
1926 if (WSTOPSIG (
status) != SIGSTOP)
1938 gdb_assert (new_lp->
status == 0);
1942 (
"waitpid of new LWP %ld, saving status %s",
1983 (
"Got PTRACE_EVENT_VFORK_DONE from LWP %ld",
1989 internal_error (_(
"unknown ptrace event %d"), event);
2023 int thread_dead = 0;
2027 gdb_assert (lp->
status == 0);
2035 if (
pid == -1 && errno == ECHILD)
2043 lp->
ptid.to_string ().c_str ());
2062 if (lp->
ptid.pid () == lp->
ptid.lwp ()
2067 lp->
ptid.to_string ().c_str ());
2084 gdb_assert (
pid == lp->
ptid.lwp ());
2087 lp->
ptid.to_string ().c_str (),
2094 || lp->
ptid.pid () == lp->
ptid.lwp ())
2108 lp->
ptid.to_string ().c_str ());
2118 gdb_assert (WIFSTOPPED (
status));
2137 status = W_STOPCODE (SIGTRAP);
2149 if (WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP
2170 lp->
ptid.to_string ().c_str ());
2175 errno ? safe_strerror (errno) :
"ERRNO-OK");
2178 gdb_assert (lp->
status == 0);
2222 sigset_t
pending, blocked, ignored;
2226 if (sigismember (&
pending, SIGINT)
2227 && !sigismember (&ignored, SIGINT))
2241 && WSTOPSIG (lp->
status) == SIGINT)
2264 lp->
ptid.to_string ().c_str ());
2287 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
2307 gdb_assert (lp != NULL);
2317 gdb_assert (lp != NULL);
2329 return WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP;
2341 if (
inf->vfork_child != NULL)
2353 && WSTOPSIG (
status) == SIGINT)
2361 (
"PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2362 lp->
ptid.to_string ().c_str (),
2363 errno ? safe_strerror (errno) :
"OK");
2370 if (WSTOPSIG (
status) != SIGSTOP)
2376 lp->
ptid.to_string ().c_str ());
2388 lp->
ptid.to_string ().c_str ());
2433 lp->
ptid.to_string ().c_str (),
2439#if !USE_SIGTRAP_SIGINFO
2443 lp->
ptid.to_string ().c_str (),
2453 lp->
ptid.to_string ().c_str ());
2469 gdb_assert (count != NULL);
2529#if USE_SIGTRAP_SIGINFO
2534 gdb_assert (lp->
status != 0);
2540 if (
inf->starting_up)
2549#if USE_SIGTRAP_SIGINFO
2552 if (siginfo.si_signo == SIGTRAP)
2578 else if (siginfo.si_code == TRAP_TRACE)
2581 lp->
ptid.to_string ().c_str ());
2612 lp->
ptid.to_string ().c_str ());
2624 lp->
ptid.to_string ().c_str ());
2629 lp->
ptid.to_string ().c_str ());
2643 gdb_assert (lp != NULL);
2664 gdb_assert (lp != NULL);
2683 int random_selector;
2701 if (event_lp != NULL)
2704 event_lp->
ptid.to_string ().c_str ());
2708 if (event_lp == NULL)
2718 gdb_assert (num_events > 0);
2722 random_selector = (int)
2723 ((num_events * (
double) rand ()) / (RAND_MAX + 1.0));
2727 num_events, random_selector);
2739 if (event_lp != NULL)
2742 *orig_lp = event_lp;
2747 (*orig_lp)->status = 0;
2782 (
"Re-adding thread group leader LWP %d after exec.",
2785 lp =
add_lwp (ptid_t (lwpid, lwpid));
2798 (
"Saving LWP %d status %s in stopped_pids list",
2816 (
"Re-adding thread group leader LWP %d after exit.",
2819 lp =
add_lwp (ptid_t (lwpid, lwpid));
2851 status = W_STOPCODE (SIGTRAP);
2863 if (WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP
2878 lp->
ptid.to_string ().c_str ());
2906 && WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGSTOP)
2913 lp->
ptid.to_string ().c_str ());
2920 (
"%s %s, 0, 0 (discard delayed SIGSTOP)",
2921 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
2922 lp->
ptid.to_string ().c_str ());
2936 lp->
ptid.to_string ().c_str ());
2943 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
2944 lp->
ptid.to_string ().c_str ());
2959 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (
status));
2986 && (WSTOPSIG (
status) != SIGSTOP
2992 (
"%s %s, %s (preempt 'handle')",
2993 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
2994 lp->
ptid.to_string ().c_str (),
2995 (signo != GDB_SIGNAL_0
2996 ? strsignal (gdb_signal_to_host (signo)) :
"0"));
3021 if (leader_lp != NULL
3077 "(it exited, or another thread execd), "
3111 target_wait_flags target_options)
3125 ptid_t lwp_ptid (
ptid.pid (),
ptid.pid ());
3142 lp->
ptid.to_string ().c_str ());
3171 errno ? safe_strerror (errno) :
"ERRNO-OK");
3212 return minus_one_ptid;
3223 return minus_one_ptid;
3227 gdb_assert (lp == NULL);
3251 if (
ptid == minus_one_ptid ||
ptid.is_pid ())
3254 gdb_assert (lp != NULL);
3294 lp->
ptid.to_string ().c_str ());
3311 && WSTOPSIG (
status) == SIGSTOP)
3340 lp->
ptid.to_string ().c_str ());
3345 lp->
ptid.to_string ().c_str ());
3350 lp->
ptid.to_string ().c_str ());
3360 int leave_stopped = 0;
3364 if (!lp->
ptid.matches (wait_ptid))
3373 (
"resuming stopped-resumed LWP %s at %s: step=%d",
3380 catch (
const gdb_exception_error &ex)
3392 target_wait_flags target_options)
3425 || ptid != minus_one_ptid))
3443 int save_errno = errno;
3446 (
"kill (SIGKILL) %ld, 0, 0 (%s)", (
long)
pid,
3447 save_errno != 0 ? safe_strerror (save_errno) :
"OK");
3456 int save_errno = errno;
3459 (
"PTRACE_KILL %ld, 0, 0 (%s)", (
long)
pid,
3460 save_errno ? safe_strerror (save_errno) :
"OK");
3478 if (res != (pid_t) -1)
3491 gdb_assert (res == -1 && errno == ECHILD);
3603 memcpy (siginfo, inf_siginfo,
sizeof (siginfo_t));
3605 memcpy (inf_siginfo, siginfo,
sizeof (siginfo_t));
3611 const char *annex, gdb_byte *readbuf,
3612 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3613 ULONGEST *xfered_len)
3616 gdb_byte inf_siginfo[
sizeof (siginfo_t)];
3619 gdb_assert (readbuf || writebuf);
3621 if (offset >
sizeof (siginfo))
3635 if (offset + len >
sizeof (siginfo))
3636 len =
sizeof (siginfo) - offset;
3638 if (readbuf != NULL)
3639 memcpy (readbuf, inf_siginfo + offset, len);
3642 memcpy (inf_siginfo + offset, writebuf, len);
3660 const char *annex, gdb_byte *readbuf,
3661 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3662 ULONGEST *xfered_len);
3666 const gdb_byte *writebuf, ULONGEST offset,
3667 LONGEST len, ULONGEST *xfered_len);
3671 const char *annex, gdb_byte *readbuf,
3672 const gdb_byte *writebuf,
3673 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3677 offset, len, xfered_len);
3687 offset, len, xfered_len);
3691 offset, len, xfered_len);
3702 if (addr_bit < (
sizeof (ULONGEST) * HOST_CHAR_BIT))
3703 offset &= ((ULONGEST) 1 << addr_bit) - 1;
3713 writebuf, offset, len,
3718 offset, len, xfered_len);
3746 if (lwp->core == -1)
3755 && (ptid.pid () != ptid.lwp ()
3757 return string_printf (
"LWP %ld", ptid.lwp ());
3806 gdb_assert (
m_fd != -1);
3864 xsnprintf (filename,
sizeof filename,
3865 "/proc/%d/task/%ld/mem", ptid.pid (), ptid.lwp ());
3867 int fd = gdb_open_cloexec (filename, O_RDWR |
O_LARGEFILE, 0).release ();
3871 warning (_(
"opening /proc/PID/mem file for lwp %d.%ld failed: %s (%d)"),
3872 ptid.pid (), ptid.lwp (),
3873 safe_strerror (errno), errno);
3878 std::forward_as_tuple (ptid.pid ()),
3879 std::forward_as_tuple (ptid, fd));
3882 fd, ptid.pid (), ptid.lwp ());
3892 gdb_byte *readbuf,
const gdb_byte *writebuf,
3893 ULONGEST offset, LONGEST len,
3894 ULONGEST *xfered_len)
3898 gdb_assert (fd != -1);
3904 ret = (readbuf ? pread64 (fd, readbuf, len, offset)
3905 : pwrite64 (fd, writebuf, len, offset));
3907 ret = lseek (fd, offset,
SEEK_SET);
3909 ret = (readbuf ?
read (fd, readbuf, len)
3910 : write (fd, writebuf, len));
3916 fd,
pid, safe_strerror (errno), errno);
3942 const gdb_byte *writebuf, ULONGEST offset,
3943 LONGEST len, ULONGEST *xfered_len)
3949 int fd = iter->second.fd ();
3968 static gdb::optional<bool> writable;
3970 if (writable.has_value ())
3973 writable.emplace (
false);
3978 int fd = gdb_open_cloexec (
"/proc/self/mem", O_RDWR |
O_LARGEFILE, 0).release ();
3982 warning (_(
"opening /proc/self/mem file failed: %s (%d)"),
3983 safe_strerror (errno), errno);
3987 SCOPE_EXIT { close (fd); };
3990 volatile gdb_byte test_var = 0;
3992 gdb_byte writebuf[] = {0x55};
3993 ULONGEST offset = (uintptr_t) &test_var;
3994 ULONGEST xfered_len;
3998 offset, 1, &xfered_len);
4002 gdb_assert (xfered_len == 1);
4003 gdb_assert (test_var == 0x55);
4016 int len = strlen (line) - 1;
4020 if (line[len] !=
'\n')
4021 error (_(
"Could not parse signal set: %s"), line);
4029 if (*p >=
'0' && *p <=
'9')
4031 else if (*p >=
'a' && *p <=
'f')
4032 digit = *p -
'a' + 10;
4034 error (_(
"Could not parse signal set: %s"), line);
4039 sigaddset (sigs, signum + 1);
4041 sigaddset (sigs, signum + 2);
4043 sigaddset (sigs, signum + 3);
4045 sigaddset (sigs, signum + 4);
4056 sigset_t *blocked, sigset_t *ignored)
4058 char buffer[PATH_MAX], fname[PATH_MAX];
4061 sigemptyset (blocked);
4062 sigemptyset (ignored);
4063 xsnprintf (fname,
sizeof fname,
"/proc/%d/status",
pid);
4064 gdb_file_up procfile = gdb_fopen_cloexec (fname,
"r");
4065 if (procfile == NULL)
4066 error (_(
"Could not open %s"), fname);
4068 while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
4078 if (startswith (buffer,
"SigPnd:\t"))
4080 else if (startswith (buffer,
"ShdPnd:\t"))
4082 else if (startswith (buffer,
"SigBlk:\t"))
4084 else if (startswith (buffer,
"SigIgn:\t"))
4091 const char *annex, gdb_byte *readbuf,
4092 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4093 ULONGEST *xfered_len)
4098 if (*xfered_len == 0)
4104std::vector<static_tracepoint_marker>
4107 char s[IPA_CMD_BUF_SIZE];
4109 std::vector<static_tracepoint_marker> markers;
4111 ptid_t ptid = ptid_t (
pid, 0);
4117 memcpy (s,
"qTfSTM",
sizeof (
"qTfSTM"));
4118 s[
sizeof (
"qTfSTM")] = 0;
4120 agent_run_command (
pid, s, strlen (s) + 1);
4131 if (strid == NULL || marker.
str_id == strid)
4132 markers.push_back (std::move (marker));
4134 while (*p++ ==
',');
4136 memcpy (s,
"qTsSTM",
sizeof (
"qTsSTM"));
4137 s[
sizeof (
"qTsSTM")] = 0;
4138 agent_run_command (
pid, s, strlen (s) + 1);
4191 int old_errno = errno;
4194 gdb_stdlog->write_async_safe (
"sigchld\n",
sizeof (
"sigchld\n") - 1);
4196 if (signo == SIGCHLD)
4223 gdb::block_signals blocker;
4228 internal_error (
"creating event pipe failed.");
4253 lwp->
ptid.to_string ().c_str ());
4274 lwp->
ptid.to_string ().c_str ());
4277 lwp->
ptid.to_string ().c_str ());
4304 if (ptid.lwp () == 0)
4318 gdb_assert (
inf != NULL);
4368 int flags,
int mode,
int warn_if_slow,
4369 fileio_error *target_errno)
4375 if (fileio_to_host_openflags (
flags, &nat_flags) == -1
4376 || fileio_to_host_mode (mode, &nat_mode) == -1)
4378 *target_errno = FILEIO_EINVAL;
4383 filename, nat_flags, nat_mode);
4385 *target_errno = host_to_fileio_error (errno);
4392gdb::optional<std::string>
4394 fileio_error *target_errno)
4400 filename, buf,
sizeof (buf));
4403 *target_errno = host_to_fileio_error (errno);
4407 return std::string (buf, len);
4414 fileio_error *target_errno)
4421 *target_errno = host_to_fileio_error (errno);
4467Set debugging of GNU/Linux native target."), _(
" \
4468Show debugging of GNU/Linux native target."), _(
" \
4469When on, print debug messages relating to the GNU/Linux native target."),
4476Set debugging of GNU/Linux namespaces module."), _(
"\
4477Show debugging of GNU/Linux namespaces module."), _(
"\
4478Enables printf debugging output."),
struct gdbarch * target_gdbarch(void)
target_xfer_partial_ftype memory_xfer_auxv
int catch_syscall_enabled(void)
bool catching_syscall_number(int syscall_number)
int software_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
int detach_breakpoints(ptid_t ptid)
void remove_breakpoints_inf(inferior *inf)
int hardware_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
const target_info & info() const override
gdb::optional< std::string > fileio_readlink(struct inferior *inf, const char *filename, fileio_error *target_errno) override
struct address_space * thread_address_space(ptid_t) override
void post_startup_inferior(ptid_t) override
int core_of_thread(ptid_t ptid) override
bool always_non_stop_p() override
virtual void low_prepare_to_resume(struct lwp_info *)
bool thread_alive(ptid_t ptid) override
bool supports_stopped_by_sw_breakpoint() override
void attach(const char *, int) override
void post_attach(int) override
virtual bool low_status_is_event(int status)
~linux_nat_target() override=0
void resume(ptid_t, int, enum gdb_signal) override
int insert_exec_catchpoint(int) override
virtual void low_new_thread(struct lwp_info *)
std::string pid_to_str(ptid_t) override
const char * pid_to_exec_file(int pid) override
bool can_async_p() override
int fileio_open(struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, fileio_error *target_errno) override
int fileio_unlink(struct inferior *inf, const char *filename, fileio_error *target_errno) override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
virtual void low_resume(ptid_t ptid, int step, enum gdb_signal sig)
virtual void low_forget_process(pid_t pid)
virtual void low_delete_thread(struct arch_lwp_info *lp)
bool supports_stopped_by_hw_breakpoint() override
bool supports_disable_randomization() override
void detach(inferior *, int) override
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
bool stopped_by_sw_breakpoint() override
virtual bool low_stopped_data_address(CORE_ADDR *addr_p)
int insert_fork_catchpoint(int) override
virtual void low_new_clone(struct lwp_info *parent, pid_t child_lwp)
bool stopped_by_hw_breakpoint() override
bool stopped_by_watchpoint() override
virtual void low_new_fork(struct lwp_info *parent, pid_t child_pid)
int remove_exec_catchpoint(int) override
const char * thread_name(struct thread_info *) override
virtual bool low_stopped_by_watchpoint()
void follow_fork(inferior *, ptid_t, target_waitkind, bool, bool) override
int insert_vfork_catchpoint(int) override
bool filesystem_is_local() override
int remove_fork_catchpoint(int) override
void update_thread_list() override
void thread_events(int) override
bool supports_multi_process() override
int set_syscall_catchpoint(int pid, bool needed, int any_count, gdb::array_view< const int > syscall_counts) override
std::vector< static_tracepoint_marker > static_tracepoint_markers_by_strid(const char *id) override
void create_inferior(const char *, const std::string &, char **, int) override
void async(bool) override
int remove_vfork_catchpoint(int) override
virtual bool low_siginfo_fixup(siginfo_t *ptrace, gdb_byte *inf, int direction)
void mourn_inferior() override
bool stopped_data_address(CORE_ADDR *) override
bool supports_non_stop() override
void pass_signals(gdb::array_view< const unsigned char >) override
DISABLE_COPY_AND_ASSIGN(proc_mem_file)
proc_mem_file(ptid_t ptid, int fd)
void follow_fork(inferior *child_inf, ptid_t child_ptid, target_waitkind fork_kind, bool follow_child, bool detach_on_fork) override
const address_space * aspace() const
gdb_signal stop_signal() const
bool has_pending_waitstatus() const
struct target_waitstatus pending_follow
const target_waitstatus & pending_waitstatus() const
void set_stop_signal(gdb_signal sig)
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
int check_quit_flag(void)
ssize_t read(int fd, void *buf, size_t count)
static void handle_target_event(int error, gdb_client_data client_data)
#define ptrace(request, pid, addr, data)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
LONGEST gdbarch_get_syscall_number(struct gdbarch *gdbarch, thread_info *thread)
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
bool gdbarch_software_single_step_p(struct gdbarch *gdbarch)
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
void delete_thread(struct thread_info *thread)
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
void delete_exited_threads(void)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
target_waitstatus host_status_to_waitstatus(int hoststatus)
void inferior_event_handler(enum inferior_event_type event_type)
pid_t get_ptrace_pid(ptid_t ptid)
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
struct inferior * find_inferior_pid(process_stratum_target *targ, int pid)
struct inferior * current_inferior(void)
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
bool disable_randomization
int signal_pass_state(int signo)
void get_last_target_status(process_stratum_target **target, ptid_t *ptid, target_waitstatus *status)
int linux_fork_checkpointing_p(int pid)
void linux_fork_killall(void)
void linux_fork_mourn_inferior(void)
struct fork_info * find_fork_pid(pid_t pid)
void linux_fork_detach(int from_tty)
int linux_ns_same(pid_t pid, enum linux_ns_type type)
ssize_t linux_mntns_readlink(pid_t pid, const char *filename, char *buf, size_t bufsiz)
bool debug_linux_namespaces
int linux_mntns_open_cloexec(pid_t pid, const char *filename, int flags, mode_t mode)
int linux_mntns_unlink(pid_t pid, const char *filename)
ptid_t ptid_of_lwp(struct lwp_info *lwp)
static void detach_one_pid(int pid, int signo)
static void check_zombie_leaders(void)
void linux_stop_lwp(struct lwp_info *lwp)
static int linux_handle_syscall_trap(struct lwp_info *lp, int stopping)
static int resume_stopped_resumed_lwps(struct lwp_info *lp, const ptid_t wait_ptid)
void linux_unstop_all_lwps(void)
int lin_thread_get_thread_signal(unsigned int i)
static int lwp_lwpid_htab_remove_pid(void **slot, void *info)
static void purge_lwp_list(int pid)
static void linux_nat_filter_event(int lwpid, int status)
static struct lwp_info * find_lwp_pid(ptid_t ptid)
static void detach_one_lwp(struct lwp_info *lp, int *signo_p)
static int get_detach_signal(struct lwp_info *lp)
static void exit_lwp(struct lwp_info *lp)
static int lwp_status_pending_p(struct lwp_info *lp)
static void kill_one_lwp(pid_t pid)
static void lwp_lwpid_htab_add_lwp(struct lwp_info *lp)
static enum target_xfer_status linux_proc_xfer_memory_partial(int pid, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
std::unique_ptr< struct lwp_info, lwp_deleter > lwp_info_up
static void sigchld_handler(int signo)
static bool is_leader(lwp_info *lp)
static void lwp_list_add(struct lwp_info *lp)
#define linux_nat_debug_printf(fmt,...)
static int kill_callback(struct lwp_info *lp)
lwp_info_range all_lwps()
void linux_proc_pending_signals(int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
static int stop_callback(struct lwp_info *lp)
static void siginfo_fixup(siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
static ptid_t linux_nat_wait_1(ptid_t ptid, struct target_waitstatus *ourstatus, target_wait_flags target_options)
static int attach_proc_task_lwp_callback(ptid_t ptid)
static int status_callback(struct lwp_info *lp)
bool linux_nat_get_siginfo(ptid_t ptid, siginfo_t *siginfo)
static int set_ignore_sigint(struct lwp_info *lp)
void _initialize_linux_nat()
static struct simple_pid_list * stopped_pids
static int select_event_lwp_callback(struct lwp_info *lp, int *selector)
static int lwp_lwpid_htab_eq(const void *a, const void *b)
static void add_to_pid_list(struct simple_pid_list **listp, int pid, int status)
static void linux_resume_one_lwp_throw(struct lwp_info *lp, int step, enum gdb_signal signo)
ptid_t current_lwp_ptid(void)
static int resume_set_callback(struct lwp_info *lp)
static void maybe_clear_ignore_sigint(struct lwp_info *lp)
lwp_info_safe_range all_lwps_safe()
static int check_stopped_by_watchpoint(struct lwp_info *lp)
static void open_proc_mem_file(ptid_t ptid)
static void resume_lwp(struct lwp_info *lp, int step, enum gdb_signal signo)
static struct lwp_info * add_initial_lwp(ptid_t ptid)
static void wait_for_signal()
static int detach_callback(struct lwp_info *lp)
static enum target_xfer_status linux_nat_xfer_osdata(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
static void kill_unfollowed_fork_children(struct inferior *inf)
static int linux_nat_post_attach_wait(ptid_t ptid, int *signalled)
static int kill_wait_callback(struct lwp_info *lp)
static void lwp_lwpid_htab_create(void)
static pid_t linux_nat_fileio_pid_of(struct inferior *inf)
static void add_line_to_sigset(const char *line, sigset_t *sigs)
static int linux_handle_extended_wait(struct lwp_info *lp, int status)
static struct lwp_info * add_lwp(ptid_t ptid)
static int wait_lwp(struct lwp_info *lp)
static int linux_nat_resume_callback(struct lwp_info *lp, struct lwp_info *except)
void lwp_set_arch_private_info(struct lwp_info *lwp, struct arch_lwp_info *info)
static int linux_nat_has_pending_sigint(int pid)
static htab_t lwp_lwpid_htab
static int select_singlestep_lwp_callback(struct lwp_info *lp)
static void linux_init_ptrace_procfs(pid_t pid, int attached)
static void select_event_lwp(ptid_t filter, struct lwp_info **orig_lp, int *status)
struct arch_lwp_info * lwp_arch_private_info(struct lwp_info *lwp)
static int count_events_callback(struct lwp_info *lp, int *count)
static sigset_t pass_mask
static int pull_pid_from_list(struct simple_pid_list **listp, int pid, int *statusp)
static void lwp_list_remove(struct lwp_info *lp)
static int report_thread_events
static int linux_nat_stop_lwp(struct lwp_info *lwp)
static bool debug_linux_nat
static void linux_resume_one_lwp(struct lwp_info *lp, int step, enum gdb_signal signo)
static void restore_child_signals_mask(sigset_t *prev_mask)
unsigned int lin_thread_get_thread_signal_num(void)
static std::unordered_map< int, proc_mem_file > proc_mem_file_map
static void delete_lwp(ptid_t ptid)
static int linux_nat_ptrace_options(int attached)
static int resume_clear_callback(struct lwp_info *lp)
struct lwp_info * iterate_over_lwps(ptid_t filter, gdb::function_view< iterate_over_lwps_ftype > callback)
struct linux_nat_target * linux_target
void linux_stop_and_wait_all_lwps(void)
static enum target_xfer_status linux_xfer_siginfo(ptid_t ptid, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
static int num_lwps(int pid)
static void handle_target_event(int error, gdb_client_data client_data)
static ptid_t filter_exit_event(struct lwp_info *event_child, struct target_waitstatus *ourstatus)
enum tribool have_ptrace_getregset
static int lin_thread_signals[]
static bool proc_mem_file_is_writable()
static void save_stop_reason(struct lwp_info *lp)
int lwp_is_stepping(struct lwp_info *lwp)
static void close_proc_mem_file(pid_t pid)
static enum target_xfer_status linux_proc_xfer_memory_partial_fd(int fd, int pid, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
static int kill_lwp(int lwpid, int signo)
static int stop_wait_callback(struct lwp_info *lp)
#define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
static intrusive_list< lwp_info > lwp_list
void linux_nat_switch_fork(ptid_t new_ptid)
static hashval_t lwp_info_hash(const void *ap)
static sigset_t suspend_mask
static sigset_t blocked_mask
static int resumed_callback(struct lwp_info *lp)
static int check_ptrace_stopped_lwp_gone(struct lwp_info *lp)
static void block_child_signals(sigset_t *prev_mask)
static void kill_wait_one_lwp(pid_t pid)
static void show_debug_linux_nat(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int lwp_is_stopped(struct lwp_info *lwp)
static struct sigaction sigchld_action
enum target_stop_reason lwp_stop_reason(struct lwp_info *lwp)
lwp_info_range all_lwps()
int thread_db_notice_clone(ptid_t parent, ptid_t child)
linux_nat_target * linux_target
iterator_range< lwp_info_iterator > lwp_info_range
basic_safe_range< lwp_info_range > lwp_info_safe_range
LONGEST linux_common_xfer_osdata(const char *annex, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
int linux_common_core_of_thread(ptid_t ptid)
int linux_proc_pid_is_gone(pid_t pid)
const char * linux_proc_pid_to_exec_file(int pid)
void linux_proc_init_warnings()
int linux_proc_pid_is_trace_stopped_nowarn(pid_t pid)
int linux_proc_pid_is_zombie(pid_t pid)
void linux_proc_attach_tgid_threads(pid_t pid, linux_proc_attach_lwp_func attach_lwp)
const char * linux_proc_tid_get_name(ptid_t ptid)
int linux_proc_pid_is_stopped(pid_t pid)
int linux_is_extended_waitstatus(int wstat)
void linux_enable_event_reporting(pid_t pid, int options)
int linux_ptrace_get_extended_event(int wstat)
int linux_wstatus_maybe_breakpoint(int wstat)
void linux_ptrace_init_warnings(void)
void linux_disable_event_reporting(pid_t pid)
std::string linux_ptrace_attach_fail_reason_string(ptid_t ptid, int err)
std::string linux_ptrace_attach_fail_reason(pid_t pid)
#define PTRACE_O_TRACEEXEC
#define PTRACE_GETSIGINFO
#define USE_SIGTRAP_SIGINFO
#define PTRACE_O_TRACEFORK
#define GDB_ARCH_IS_TRAP_HWBKPT(X)
#define PTRACE_EVENT_VFORK_DONE
#define GDB_ARCH_IS_TRAP_BRKPT(X)
#define PTRACE_GETEVENTMSG
#define PTRACE_EVENT_FORK
#define PTRACE_EVENT_CLONE
#define PTRACE_O_EXITKILL
#define PTRACE_SETSIGINFO
#define PTRACE_EVENT_VFORK
#define PTRACE_O_TRACEVFORK
#define PTRACE_EVENT_EXEC
#define PTRACE_O_TRACESYSGOOD
#define PTRACE_O_TRACEVFORKDONE
int my_waitpid(int pid, int *status, int flags)
std::string status_to_str(int status)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
void registers_changed(void)
void create_inferior(const char *, const std::string &, char **, int) override
void detach_success(inferior *inf)
int async_wait_fd() override
bool is_async_p() override
void mourn_inferior() override
void attach(const char *, int) override
static void async_file_mark_if_open()
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
void operator()(struct lwp_info *lwp) const
struct target_waitstatus waitstatus
CORE_ADDR stopped_data_address
target_stop_reason stop_reason
int must_set_ptrace_flags
int stopped_data_address_p
resume_kind last_resume_kind
struct arch_lwp_info * arch_private
enum target_waitkind syscall_state
struct simple_pid_list * next
virtual gdb::byte_vector virtual thread_info_to_thread_handle(struct thread_info *) TARGET_DEFAULT_RETURN(gdb voi stop)(ptid_t) TARGET_DEFAULT_IGNORE()
target_waitstatus & set_spurious()
target_waitstatus & set_syscall_return(int syscall_number)
target_waitstatus & set_no_resumed()
target_waitstatus & set_vfork_done()
target_waitstatus & set_forked(ptid_t child_ptid)
target_waitstatus & set_execd(gdb::unique_xmalloc_ptr< char > execd_pathname)
target_waitstatus & set_stopped(gdb_signal sig)
target_waitstatus & set_vforked(ptid_t child_ptid)
target_waitstatus & set_thread_exited(int exit_status)
target_waitstatus & set_syscall_entry(int syscall_number)
target_waitstatus & set_ignore()
target_waitkind kind() const
target_waitstatus & set_thread_created()
void target_announce_detach(int from_tty)
void target_async(bool enable)
bool target_async_permitted
bool target_can_async_p()
gdbarch * target_thread_architecture(ptid_t ptid)
void target_stop(ptid_t ptid)
std::string target_options_to_string(target_wait_flags target_options)
bool target_is_non_stop_p()
std::string target_pid_to_str(ptid_t ptid)
std::string normal_pid_to_str(ptid_t ptid)
void target_continue_no_signal(ptid_t ptid)
void target_pass_ctrlc(void)
void target_mourn_inferior(ptid_t ptid)
@ TARGET_OBJECT_SIGNAL_INFO
void parse_static_tracepoint_marker_definition(const char *line, const char **pp, static_tracepoint_marker *marker)
void perror_with_name(const char *string)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void perror_warning_with_name(const char *string)
void gdb_printf(struct ui_file *stream, const char *format,...)
int parse_pid_to_attach(const char *args)
@ TARGET_WAITKIND_NO_RESUMED
@ TARGET_WAITKIND_SIGNALLED
@ TARGET_WAITKIND_STOPPED
@ TARGET_WAITKIND_SYSCALL_RETURN
@ TARGET_WAITKIND_SYSCALL_ENTRY
@ TARGET_WAITKIND_VFORKED
@ TARGET_STOPPED_BY_SW_BREAKPOINT
@ TARGET_STOPPED_BY_WATCHPOINT
@ TARGET_STOPPED_BY_HW_BREAKPOINT
@ TARGET_STOPPED_BY_NO_REASON