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"
64#include "gdbsupport/filestuff.h"
67#include "gdbsupport/block-signals.h"
68#include "gdbsupport/fileio.h"
69#include "gdbsupport/scope-exit.h"
70#include "gdbsupport/gdb-sigmask.h"
71#include "gdbsupport/common-debug.h"
72#include <unordered_map>
204 gdb_printf (file, _(
"Debugging of GNU/Linux native targets is %s.\n"),
210#define linux_nat_debug_printf(fmt, ...) \
211 debug_prefixed_printf_cond (debug_linux_nat, "linux-nat", fmt, ##__VA_ARGS__)
215#define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT \
216 scoped_debug_enter_exit (debug_linux_nat, "linux-nat")
229static int kill_lwp (
int lwpid,
int signo);
255 return lp->
ptid.pid () == lp->
ptid.lwp ();
333 new_pid->
next = *listp;
342 for (p = listp; *p != NULL; p = &(*p)->
next)
343 if ((*p)->pid ==
pid)
415 if (lp->ptid.pid () ==
pid)
449 int parent_pid = parent_ptid.lwp ();
450 int child_pid = child_ptid.lwp ();
460 int child_stop_signal = 0;
461 bool detach_child =
true;
487 if (
ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
488 perror_with_name (_(
"Couldn't do single step"));
490 perror_with_name (_(
"Couldn't wait vfork process"));
493 detach_child = WIFSTOPPED (
status);
494 child_stop_signal = WSTOPSIG (
status);
500 int signo = child_stop_signal;
505 ptrace (PTRACE_DETACH, child_pid, 0, signo);
525 child_lp =
add_lwp (child_ptid);
570 gdb::array_view<const int> syscall_counts)
593 return iterative_hash_object (
pid, 0);
605 return entry->ptid.lwp () == element->
ptid.lwp ();
624 gdb_assert (slot != NULL && *slot == NULL);
700 gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
709 (gdb::array_view<const unsigned char> pass_signals)
715 for (signo = 1; signo < NSIG; signo++)
717 int target_signo = gdb_signal_from_host (signo);
746 int pid = *(
int *) info;
783 gdb_assert (
ptid.lwp_p ());
829 gdb_assert (lp != NULL);
861 gdb::function_view<iterate_over_lwps_ftype> callback)
865 if (lp->ptid.matches (filter))
867 if (callback (lp) != 0)
920 pid_t new_pid,
pid = ptid.lwp ();
951 gdb_assert (
pid == new_pid);
961 if (WSTOPSIG (
status) != SIGSTOP)
973 const std::string &allargs,
974 char **env,
int from_tty)
1003 int lwpid =
ptid.lwp ();
1005 if (
ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1018 (
"Cannot attach to lwp %d: thread is gone (%d: %s)",
1019 lwpid,
err, safe_strerror (
err));
1027 warning (_(
"Cannot attach to lwp %d: %s"),
1028 lwpid, reason.c_str ());
1034 ptid.to_string ().c_str ());
1076 catch (
const gdb_exception_error &ex)
1081 if (!reason.empty ())
1082 throw_error (ex.error,
"warning: %s\n%s", reason.c_str (),
1085 throw_error (ex.error,
"%s", ex.what ());
1098 if (!WIFSTOPPED (
status))
1102 int exit_code = WEXITSTATUS (
status);
1107 error (_(
"Unable to attach: program exited normally."));
1109 error (_(
"Unable to attach: program exited with code %d."),
1112 else if (WIFSIGNALED (
status))
1114 enum gdb_signal signo;
1119 signo = gdb_signal_from_host (WTERMSIG (
status));
1120 error (_(
"Unable to attach: program terminated with signal "
1122 gdb_signal_to_name (signo),
1123 gdb_signal_to_string (signo));
1126 internal_error (_(
"unexpected status %d for PID %ld"),
1127 status, (
long) ptid.lwp ());
1137 (
long) lp->
ptid.pid (),
1158 if (
ptrace (PTRACE_DETACH,
pid, 0, signo) < 0)
1160 int save_errno = errno;
1166 if (save_errno == ESRCH)
1173 warning (_(
"Couldn't reap LWP %d while detaching: %s"),
1174 pid, safe_strerror (errno));
1178 warning (_(
"Reaping LWP %d while detaching "
1179 "returned unexpected status 0x%x"),
1184 error (_(
"Can't detach %d: %s"),
1185 pid, safe_strerror (save_errno));
1189 pid, strsignal (signo));
1200 enum gdb_signal signo = GDB_SIGNAL_0;
1224 signo = GDB_SIGNAL_0;
1226 signo = gdb_signal_from_host (WSTOPSIG (lp->
status));
1242 signo = GDB_SIGNAL_0;
1255 && lp->
ptid.lwp () == last_ptid.lwp ())
1260 if (signo == GDB_SIGNAL_0)
1263 lp->
ptid.to_string ().c_str ());
1268 (
"lwp %s had signal %s but it is in no pass state",
1269 lp->
ptid.to_string ().c_str (), gdb_signal_to_string (signo));
1274 lp->
ptid.to_string ().c_str (),
1275 gdb_signal_to_string (signo));
1277 return gdb_signal_to_host (signo);
1295 int lwpid = lp->
ptid.lwp ();
1298 gdb_assert (lp->
status == 0 || WIFSTOPPED (lp->
status));
1311 unsigned long child_pid;
1344 strsignal (WSTOPSIG (lp->
status)),
1345 lp->
ptid.to_string ().c_str ());
1351 lp->
ptid.to_string ().c_str ());
1357 if (signo_p == NULL)
1366 lp->
ptid.to_string ().c_str (),
1376 catch (
const gdb_exception_error &ex)
1393 if (lp->
ptid.lwp () != lp->
ptid.pid ())
1456 enum gdb_signal signo)
1529 catch (
const gdb_exception_error &ex)
1545 if (
inf->vfork_child != NULL)
1548 lp->
ptid.to_string ().c_str ());
1553 lp->
ptid.to_string ().c_str (),
1554 (signo != GDB_SIGNAL_0
1555 ? strsignal (gdb_signal_to_host (signo))
1557 step ?
"step" :
"resume");
1564 lp->
ptid.to_string ().c_str ());
1569 lp->
ptid.to_string ().c_str ());
1578 enum gdb_signal signo = GDB_SIGNAL_0;
1621 step ?
"step" :
"resume",
1622 scope_ptid.to_string ().c_str (),
1623 (signo != GDB_SIGNAL_0
1624 ? strsignal (gdb_signal_to_host (signo)) :
"0"),
1632 gdb_assert (lp != NULL);
1652 (
"Not short circuiting for ignored status 0x%x", lp->
status);
1656 gdb_assert (signo == GDB_SIGNAL_0);
1657 signo = gdb_signal_from_host (WSTOPSIG (lp->
status));
1666 gdb_assert (signo == GDB_SIGNAL_0);
1681 if (scope_ptid != lp->
ptid)
1688 step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
1689 lp->
ptid.to_string ().c_str (),
1690 (signo != GDB_SIGNAL_0
1691 ? strsignal (gdb_signal_to_host (signo)) :
"0"));
1704 ret =
syscall (__NR_tkill, lwpid, signo);
1705 if (errno == ENOSYS)
1709 perror_with_name ((
"tkill"));
1751 (
"ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1752 "PTRACE_CONT for SIGSTOP", syscall_number, lp->
ptid.lwp ());
1779 gdb_assert_not_reached (
"unexpected syscall state");
1782 (
"stopping for %s of syscall %d for LWP %ld",
1784 ?
"entry" :
"return"), syscall_number, lp->
ptid.lwp ());
1790 (
"ignoring %s of syscall %d for LWP %ld",
1792 ?
"entry" :
"return"), syscall_number, lp->
ptid.lwp ());
1813 (
"caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1814 "ignoring", syscall_number, lp->
ptid.lwp ());
1850 unsigned long new_pid;
1862 perror_with_name (_(
"waiting for new child"));
1863 else if (ret != new_pid)
1864 internal_error (_(
"wait returned unexpected PID %d"), ret);
1865 else if (!WIFSTOPPED (
status))
1866 internal_error (_(
"wait returned unexpected status 0x%x"),
status);
1920 (
"Got clone event from LWP %d, new child is LWP %ld",
pid, new_pid);
1922 new_lp =
add_lwp (ptid_t (lp->
ptid.pid (), new_pid));
1943 if (WSTOPSIG (
status) != SIGSTOP)
1955 gdb_assert (new_lp->
status == 0);
1959 (
"waitpid of new LWP %ld, saving status %s",
2000 (
"Got PTRACE_EVENT_VFORK_DONE from LWP %ld",
2006 internal_error (_(
"unknown ptrace event %d"), event);
2040 int thread_dead = 0;
2044 gdb_assert (lp->
status == 0);
2052 if (
pid == -1 && errno == ECHILD)
2060 lp->
ptid.to_string ().c_str ());
2079 if (lp->
ptid.pid () == lp->
ptid.lwp ()
2084 lp->
ptid.to_string ().c_str ());
2101 gdb_assert (
pid == lp->
ptid.lwp ());
2104 lp->
ptid.to_string ().c_str (),
2111 || lp->
ptid.pid () == lp->
ptid.lwp ())
2125 lp->
ptid.to_string ().c_str ());
2135 gdb_assert (WIFSTOPPED (
status));
2154 status = W_STOPCODE (SIGTRAP);
2166 if (WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP
2187 lp->
ptid.to_string ().c_str ());
2192 errno ? safe_strerror (errno) :
"ERRNO-OK");
2195 gdb_assert (lp->
status == 0);
2239 sigset_t
pending, blocked, ignored;
2243 if (sigismember (&
pending, SIGINT)
2244 && !sigismember (&ignored, SIGINT))
2258 && WSTOPSIG (lp->
status) == SIGINT)
2281 lp->
ptid.to_string ().c_str ());
2304 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
2324 gdb_assert (lp != NULL);
2334 gdb_assert (lp != NULL);
2346 return WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP;
2358 if (
inf->vfork_child != NULL)
2370 && WSTOPSIG (
status) == SIGINT)
2378 (
"PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2379 lp->
ptid.to_string ().c_str (),
2380 errno ? safe_strerror (errno) :
"OK");
2387 if (WSTOPSIG (
status) != SIGSTOP)
2393 lp->
ptid.to_string ().c_str ());
2405 lp->
ptid.to_string ().c_str ());
2450 lp->
ptid.to_string ().c_str (),
2456#if !USE_SIGTRAP_SIGINFO
2460 lp->
ptid.to_string ().c_str (),
2470 lp->
ptid.to_string ().c_str ());
2486 gdb_assert (count != NULL);
2546#if USE_SIGTRAP_SIGINFO
2551 gdb_assert (lp->
status != 0);
2557 if (
inf->starting_up)
2566#if USE_SIGTRAP_SIGINFO
2569 if (siginfo.si_signo == SIGTRAP)
2595 else if (siginfo.si_code == TRAP_TRACE)
2598 lp->
ptid.to_string ().c_str ());
2629 lp->
ptid.to_string ().c_str ());
2641 lp->
ptid.to_string ().c_str ());
2646 lp->
ptid.to_string ().c_str ());
2660 gdb_assert (lp != NULL);
2681 gdb_assert (lp != NULL);
2700 int random_selector;
2718 if (event_lp != NULL)
2721 event_lp->
ptid.to_string ().c_str ());
2725 if (event_lp == NULL)
2735 gdb_assert (num_events > 0);
2739 random_selector = (int)
2740 ((num_events * (
double) rand ()) / (RAND_MAX + 1.0));
2744 num_events, random_selector);
2756 if (event_lp != NULL)
2759 *orig_lp = event_lp;
2764 (*orig_lp)->status = 0;
2799 (
"Re-adding thread group leader LWP %d after exec.",
2802 lp =
add_lwp (ptid_t (lwpid, lwpid));
2815 (
"Saving LWP %d status %s in stopped_pids list",
2833 (
"Re-adding thread group leader LWP %d after exit.",
2836 lp =
add_lwp (ptid_t (lwpid, lwpid));
2868 status = W_STOPCODE (SIGTRAP);
2880 if (WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGTRAP
2895 lp->
ptid.to_string ().c_str ());
2923 && WIFSTOPPED (
status) && WSTOPSIG (
status) == SIGSTOP)
2930 lp->
ptid.to_string ().c_str ());
2937 (
"%s %s, 0, 0 (discard delayed SIGSTOP)",
2938 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
2939 lp->
ptid.to_string ().c_str ());
2953 lp->
ptid.to_string ().c_str ());
2960 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
2961 lp->
ptid.to_string ().c_str ());
2976 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (
status));
3003 && (WSTOPSIG (
status) != SIGSTOP
3009 (
"%s %s, %s (preempt 'handle')",
3010 lp->
step ?
"PTRACE_SINGLESTEP" :
"PTRACE_CONT",
3011 lp->
ptid.to_string ().c_str (),
3012 (signo != GDB_SIGNAL_0
3013 ? strsignal (gdb_signal_to_host (signo)) :
"0"));
3038 if (leader_lp != NULL
3094 "(it exited, or another thread execd), "
3128 target_wait_flags target_options)
3142 ptid_t lwp_ptid (
ptid.pid (),
ptid.pid ());
3159 lp->
ptid.to_string ().c_str ());
3188 errno ? safe_strerror (errno) :
"ERRNO-OK");
3229 return minus_one_ptid;
3240 return minus_one_ptid;
3244 gdb_assert (lp == NULL);
3268 if (
ptid == minus_one_ptid ||
ptid.is_pid ())
3271 gdb_assert (lp != NULL);
3311 lp->
ptid.to_string ().c_str ());
3328 && WSTOPSIG (
status) == SIGSTOP)
3359 lp->
ptid.to_string ().c_str ());
3364 lp->
ptid.to_string ().c_str ());
3369 lp->
ptid.to_string ().c_str ());
3371 else if (
inf->vfork_child !=
nullptr)
3374 lp->
ptid.to_string ().c_str ());
3384 int leave_stopped = 0;
3388 if (!lp->
ptid.matches (wait_ptid))
3397 (
"resuming stopped-resumed LWP %s at %s: step=%d",
3404 catch (
const gdb_exception_error &ex)
3416 target_wait_flags target_options)
3451 || ptid != minus_one_ptid))
3469 int save_errno = errno;
3472 (
"kill (SIGKILL) %ld, 0, 0 (%s)", (
long)
pid,
3473 save_errno != 0 ? safe_strerror (save_errno) :
"OK");
3482 int save_errno = errno;
3485 (
"PTRACE_KILL %ld, 0, 0 (%s)", (
long)
pid,
3486 save_errno ? safe_strerror (save_errno) :
"OK");
3504 if (res != (pid_t) -1)
3517 gdb_assert (res == -1 && errno == ECHILD);
3631 memcpy (siginfo, inf_siginfo,
sizeof (siginfo_t));
3633 memcpy (inf_siginfo, siginfo,
sizeof (siginfo_t));
3639 const char *annex, gdb_byte *readbuf,
3640 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3641 ULONGEST *xfered_len)
3644 gdb_byte inf_siginfo[
sizeof (siginfo_t)];
3647 gdb_assert (readbuf || writebuf);
3649 if (offset >
sizeof (siginfo))
3663 if (offset + len >
sizeof (siginfo))
3664 len =
sizeof (siginfo) - offset;
3666 if (readbuf != NULL)
3667 memcpy (readbuf, inf_siginfo + offset, len);
3670 memcpy (inf_siginfo + offset, writebuf, len);
3688 const char *annex, gdb_byte *readbuf,
3689 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3690 ULONGEST *xfered_len);
3694 const gdb_byte *writebuf, ULONGEST offset,
3695 LONGEST len, ULONGEST *xfered_len);
3699 const char *annex, gdb_byte *readbuf,
3700 const gdb_byte *writebuf,
3701 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3705 offset, len, xfered_len);
3715 offset, len, xfered_len);
3719 offset, len, xfered_len);
3730 if (addr_bit < (
sizeof (ULONGEST) * HOST_CHAR_BIT))
3731 offset &= ((ULONGEST) 1 << addr_bit) - 1;
3741 writebuf, offset, len,
3746 offset, len, xfered_len);
3774 if (lwp->core == -1)
3783 && (ptid.pid () != ptid.lwp ()
3785 return string_printf (
"LWP %ld", ptid.lwp ());
3834 gdb_assert (
m_fd != -1);
3892 xsnprintf (filename,
sizeof filename,
3893 "/proc/%d/task/%ld/mem", ptid.pid (), ptid.lwp ());
3895 int fd = gdb_open_cloexec (filename, O_RDWR |
O_LARGEFILE, 0).release ();
3899 warning (_(
"opening /proc/PID/mem file for lwp %d.%ld failed: %s (%d)"),
3900 ptid.pid (), ptid.lwp (),
3901 safe_strerror (errno), errno);
3906 std::forward_as_tuple (ptid.pid ()),
3907 std::forward_as_tuple (ptid, fd));
3910 fd, ptid.pid (), ptid.lwp ());
3920 gdb_byte *readbuf,
const gdb_byte *writebuf,
3921 ULONGEST offset, LONGEST len,
3922 ULONGEST *xfered_len)
3926 gdb_assert (fd != -1);
3935 if ((off_t) offset >= 0)
3936 ret = (readbuf !=
nullptr
3937 ? pread64 (fd, readbuf, len, offset)
3938 : pwrite64 (fd, writebuf, len, offset));
3942 ret = lseek (fd, offset,
SEEK_SET);
3944 ret = (readbuf !=
nullptr
3945 ?
read (fd, readbuf, len)
3946 : write (fd, writebuf, len));
3952 fd,
pid, safe_strerror (errno), errno);
3978 const gdb_byte *writebuf, ULONGEST offset,
3979 LONGEST len, ULONGEST *xfered_len)
3985 int fd = iter->second.fd ();
4004 static gdb::optional<bool> writable;
4006 if (writable.has_value ())
4009 writable.emplace (
false);
4014 int fd = gdb_open_cloexec (
"/proc/self/mem", O_RDWR |
O_LARGEFILE, 0).release ();
4018 warning (_(
"opening /proc/self/mem file failed: %s (%d)"),
4019 safe_strerror (errno), errno);
4023 SCOPE_EXIT { close (fd); };
4026 volatile gdb_byte test_var = 0;
4028 gdb_byte writebuf[] = {0x55};
4029 ULONGEST offset = (uintptr_t) &test_var;
4030 ULONGEST xfered_len;
4034 offset, 1, &xfered_len);
4038 gdb_assert (xfered_len == 1);
4039 gdb_assert (test_var == 0x55);
4052 int len = strlen (line) - 1;
4056 if (line[len] !=
'\n')
4057 error (_(
"Could not parse signal set: %s"), line);
4065 if (*p >=
'0' && *p <=
'9')
4067 else if (*p >=
'a' && *p <=
'f')
4068 digit = *p -
'a' + 10;
4070 error (_(
"Could not parse signal set: %s"), line);
4075 sigaddset (sigs, signum + 1);
4077 sigaddset (sigs, signum + 2);
4079 sigaddset (sigs, signum + 3);
4081 sigaddset (sigs, signum + 4);
4092 sigset_t *blocked, sigset_t *ignored)
4094 char buffer[PATH_MAX], fname[PATH_MAX];
4097 sigemptyset (blocked);
4098 sigemptyset (ignored);
4099 xsnprintf (fname,
sizeof fname,
"/proc/%d/status",
pid);
4100 gdb_file_up procfile = gdb_fopen_cloexec (fname,
"r");
4101 if (procfile == NULL)
4102 error (_(
"Could not open %s"), fname);
4104 while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
4114 if (startswith (buffer,
"SigPnd:\t"))
4116 else if (startswith (buffer,
"ShdPnd:\t"))
4118 else if (startswith (buffer,
"SigBlk:\t"))
4120 else if (startswith (buffer,
"SigIgn:\t"))
4127 const char *annex, gdb_byte *readbuf,
4128 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4129 ULONGEST *xfered_len)
4134 if (*xfered_len == 0)
4140std::vector<static_tracepoint_marker>
4143 char s[IPA_CMD_BUF_SIZE];
4145 std::vector<static_tracepoint_marker> markers;
4147 ptid_t ptid = ptid_t (
pid, 0);
4153 strcpy (s,
"qTfSTM");
4154 agent_run_command (
pid, s, strlen (s) + 1);
4165 if (strid == NULL || marker.
str_id == strid)
4166 markers.push_back (std::move (marker));
4168 while (*p++ ==
',');
4170 strcpy (s,
"qTsSTM");
4171 agent_run_command (
pid, s, strlen (s) + 1);
4224 int old_errno = errno;
4227 gdb_stdlog->write_async_safe (
"sigchld\n",
sizeof (
"sigchld\n") - 1);
4229 if (signo == SIGCHLD)
4256 gdb::block_signals blocker;
4261 internal_error (
"creating event pipe failed.");
4286 lwp->
ptid.to_string ().c_str ());
4307 lwp->
ptid.to_string ().c_str ());
4310 lwp->
ptid.to_string ().c_str ());
4337 if (ptid.lwp () == 0)
4351 gdb_assert (
inf != NULL);
4401 int flags,
int mode,
int warn_if_slow,
4402 fileio_error *target_errno)
4408 if (fileio_to_host_openflags (
flags, &nat_flags) == -1
4409 || fileio_to_host_mode (mode, &nat_mode) == -1)
4411 *target_errno = FILEIO_EINVAL;
4416 filename, nat_flags, nat_mode);
4418 *target_errno = host_to_fileio_error (errno);
4425gdb::optional<std::string>
4427 fileio_error *target_errno)
4433 filename, buf,
sizeof (buf));
4436 *target_errno = host_to_fileio_error (errno);
4440 return std::string (buf, len);
4447 fileio_error *target_errno)
4454 *target_errno = host_to_fileio_error (errno);
4500Set debugging of GNU/Linux native target."), _(
" \
4501Show debugging of GNU/Linux native target."), _(
" \
4502When on, print debug messages relating to the GNU/Linux native target."),
4509Set debugging of GNU/Linux namespaces module."), _(
"\
4510Show debugging of GNU/Linux namespaces module."), _(
"\
4511Enables printf debugging output."),
static void handle_target_event(gdb_client_data client_data)
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
thread_info * find_thread(ptid_t ptid)
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)
#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)
void delete_thread(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)
static std::string pending_status_str(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::array_view< const_gdb_byte > 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
std::string to_string() 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 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)
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