}
static void
-remote_fileio_reply (int retcode, int error)
+remote_fileio_reply (remote_target *remote, int retcode, int error)
{
char buf[32];
int ctrl_c = check_quit_flag ();
strcat (buf, ",C");
}
quit_handler = remote_fileio_o_quit_handler;
- putpkt (buf);
+ putpkt (remote, buf);
}
static void
-remote_fileio_ioerror (void)
+remote_fileio_ioerror (remote_target *remote)
{
- remote_fileio_reply (-1, FILEIO_EIO);
+ remote_fileio_reply (remote, -1, FILEIO_EIO);
}
static void
-remote_fileio_badfd (void)
+remote_fileio_badfd (remote_target *remote)
{
- remote_fileio_reply (-1, FILEIO_EBADF);
+ remote_fileio_reply (remote, -1, FILEIO_EBADF);
}
static void
-remote_fileio_return_errno (int retcode)
+remote_fileio_return_errno (remote_target *remote, int retcode)
{
- remote_fileio_reply (retcode, retcode < 0
+ remote_fileio_reply (remote, retcode, retcode < 0
? host_to_fileio_error (errno) : 0);
}
static void
-remote_fileio_return_success (int retcode)
+remote_fileio_return_success (remote_target *remote, int retcode)
{
- remote_fileio_reply (retcode, 0);
+ remote_fileio_reply (remote, retcode, 0);
}
static void
-remote_fileio_func_open (char *buf)
+remote_fileio_func_open (remote_target *remote, char *buf)
{
CORE_ADDR ptrval;
int length;
/* 1. Parameter: Ptr to pathname / length incl. trailing zero. */
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
/* 2. Parameter: open flags */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
flags = remote_fileio_oflags_to_host (num);
/* 3. Parameter: open mode */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
mode = remote_fileio_mode_to_host (num, 1);
pathname = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
{
if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
{
- remote_fileio_reply (-1, FILEIO_ENODEV);
+ remote_fileio_reply (remote, -1, FILEIO_ENODEV);
return;
}
if (S_ISDIR (st.st_mode)
&& ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR))
{
- remote_fileio_reply (-1, FILEIO_EISDIR);
+ remote_fileio_reply (remote, -1, FILEIO_EISDIR);
return;
}
}
fd = gdb_open_cloexec (pathname, flags, mode);
if (fd < 0)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
fd = remote_fileio_fd_to_targetfd (fd);
- remote_fileio_return_success (fd);
+ remote_fileio_return_success (remote, fd);
}
static void
-remote_fileio_func_close (char *buf)
+remote_fileio_func_close (remote_target *remote, char *buf)
{
long num;
int fd;
/* Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) num);
if (fd == FIO_FD_INVALID)
{
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
}
if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd))
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
remote_fileio_close_target_fd ((int) num);
- remote_fileio_return_success (0);
+ remote_fileio_return_success (remote, 0);
}
static void
-remote_fileio_func_read (char *buf)
+remote_fileio_func_read (remote_target *remote, char *buf)
{
long target_fd, num;
LONGEST lnum;
/* 1. Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &target_fd))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) target_fd);
if (fd == FIO_FD_INVALID)
{
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
}
/* 2. Parameter: buffer pointer */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
ptrval = (CORE_ADDR) lnum;
/* 3. Parameter: buffer length */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
length = (size_t) num;
switch (fd)
{
case FIO_FD_CONSOLE_OUT:
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
case FIO_FD_CONSOLE_IN:
{
}
if (ret < 0)
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
else
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
xfree (buffer);
}
static void
-remote_fileio_func_write (char *buf)
+remote_fileio_func_write (remote_target *remote, char *buf)
{
long target_fd, num;
LONGEST lnum;
/* 1. Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &target_fd))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) target_fd);
if (fd == FIO_FD_INVALID)
{
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
}
/* 2. Parameter: buffer pointer */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
ptrval = (CORE_ADDR) lnum;
/* 3. Parameter: buffer length */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
length = (size_t) num;
if (target_read_memory (ptrval, buffer, length) != 0)
{
xfree (buffer);
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
switch (fd)
{
case FIO_FD_CONSOLE_IN:
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
xfree (buffer);
return;
case FIO_FD_CONSOLE_OUT:
}
if (ret < 0)
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
else
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
xfree (buffer);
}
static void
-remote_fileio_func_lseek (char *buf)
+remote_fileio_func_lseek (remote_target *remote, char *buf)
{
long num;
LONGEST lnum;
/* 1. Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) num);
if (fd == FIO_FD_INVALID)
{
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
}
else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
{
- remote_fileio_reply (-1, FILEIO_ESPIPE);
+ remote_fileio_reply (remote, -1, FILEIO_ESPIPE);
return;
}
/* 2. Parameter: offset */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
offset = (off_t) lnum;
/* 3. Parameter: flag */
if (remote_fileio_extract_int (&buf, &num))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
if (remote_fileio_seek_flag_to_host (num, &flag))
{
- remote_fileio_reply (-1, FILEIO_EINVAL);
+ remote_fileio_reply (remote, -1, FILEIO_EINVAL);
return;
}
ret = lseek (fd, offset, flag);
if (ret == (off_t) -1)
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
else
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_rename (char *buf)
+remote_fileio_func_rename (remote_target *remote, char *buf)
{
CORE_ADDR old_ptr, new_ptr;
int old_len, new_len;
/* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
/* 2. Parameter: Ptr to newpath / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
oldpath = (char *) alloca (old_len);
if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
newpath = (char *) alloca (new_len);
if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
|| (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode)))
{
- remote_fileio_reply (-1, FILEIO_EACCES);
+ remote_fileio_reply (remote, -1, FILEIO_EACCES);
return;
}
}
#endif
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
}
else
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_unlink (char *buf)
+remote_fileio_func_unlink (remote_target *remote, char *buf)
{
CORE_ADDR ptrval;
int length;
/* Parameter: Ptr to pathname / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
/* Request pathname using 'm' packet */
pathname = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
the correct return code). */
if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
{
- remote_fileio_reply (-1, FILEIO_ENODEV);
+ remote_fileio_reply (remote, -1, FILEIO_ENODEV);
return;
}
ret = unlink (pathname);
if (ret == -1)
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
else
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_stat (char *buf)
+remote_fileio_func_stat (remote_target *remote, char *buf)
{
CORE_ADDR statptr, nameptr;
int ret, namelength;
/* 1. Parameter: Ptr to pathname / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
/* 2. Parameter: Ptr to struct stat */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
statptr = (CORE_ADDR) lnum;
pathname = (char *) alloca (namelength);
if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
if (ret == -1)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
/* Only operate on regular files and directories. */
if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
{
- remote_fileio_reply (-1, FILEIO_EACCES);
+ remote_fileio_reply (remote, -1, FILEIO_EACCES);
return;
}
if (statptr)
errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst);
if (errno != 0)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
}
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_fstat (char *buf)
+remote_fileio_func_fstat (remote_target *remote, char *buf)
{
CORE_ADDR ptrval;
int fd, ret;
/* 1. Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &target_fd))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) target_fd);
if (fd == FIO_FD_INVALID)
{
- remote_fileio_badfd ();
+ remote_fileio_badfd (remote);
return;
}
/* 2. Parameter: Ptr to struct stat */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
ptrval = (CORE_ADDR) lnum;
if (ret == -1)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
if (ptrval)
errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst);
if (errno != 0)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
}
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_gettimeofday (char *buf)
+remote_fileio_func_gettimeofday (remote_target *remote, char *buf)
{
LONGEST lnum;
CORE_ADDR ptrval;
/* 1. Parameter: struct timeval pointer */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
ptrval = (CORE_ADDR) lnum;
/* 2. Parameter: some pointer value... */
if (remote_fileio_extract_long (&buf, &lnum))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
/* ...which has to be NULL. */
if (lnum)
{
- remote_fileio_reply (-1, FILEIO_EINVAL);
+ remote_fileio_reply (remote, -1, FILEIO_EINVAL);
return;
}
if (ret == -1)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv);
if (errno != 0)
{
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
return;
}
}
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_isatty (char *buf)
+remote_fileio_func_isatty (remote_target *remote, char *buf)
{
long target_fd;
int fd;
/* Parameter: file descriptor */
if (remote_fileio_extract_int (&buf, &target_fd))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
fd = remote_fileio_map_fd ((int) target_fd);
- remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN ||
- fd == FIO_FD_CONSOLE_OUT ? 1 : 0);
+ int ret = fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT ? 1 : 0;
+ remote_fileio_return_success (remote, ret);
}
static void
-remote_fileio_func_system (char *buf)
+remote_fileio_func_system (remote_target *remote, char *buf)
{
CORE_ADDR ptrval;
int ret, length;
/* Parameter: Ptr to commandline / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
cmdline = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0)
{
- remote_fileio_ioerror ();
+ remote_fileio_ioerror (remote);
return;
}
}
if (!remote_fio_system_call_allowed)
{
if (!length)
- remote_fileio_return_success (0);
+ remote_fileio_return_success (remote, 0);
else
- remote_fileio_reply (-1, FILEIO_EPERM);
+ remote_fileio_reply (remote, -1, FILEIO_EPERM);
return;
}
ret = system (cmdline);
if (!length)
- remote_fileio_return_success (ret);
+ remote_fileio_return_success (remote, ret);
else if (ret == -1)
- remote_fileio_return_errno (-1);
+ remote_fileio_return_errno (remote, -1);
else
- remote_fileio_return_success (WEXITSTATUS (ret));
+ remote_fileio_return_success (remote, WEXITSTATUS (ret));
}
static struct {
const char *name;
- void (*func)(char *);
+ void (*func)(remote_target *remote, char *);
} remote_fio_func_map[] = {
{ "open", remote_fileio_func_open },
{ "close", remote_fileio_func_close },
};
static void
-do_remote_fileio_request (char *buf)
+do_remote_fileio_request (remote_target *remote, char *buf)
{
char *c;
int idx;
if (!strcmp (remote_fio_func_map[idx].name, buf))
break;
if (!remote_fio_func_map[idx].name)
- remote_fileio_reply (-1, FILEIO_ENOSYS);
+ remote_fileio_reply (remote, -1, FILEIO_ENOSYS);
else
- remote_fio_func_map[idx].func (c);
+ remote_fio_func_map[idx].func (remote, c);
}
/* Close any open descriptors, and reinitialize the file mapping. */
acknowledged the Ctrl-C sent asynchronously earlier. */
void
-remote_fileio_request (char *buf, int ctrlc_pending_p)
+remote_fileio_request (remote_target *remote, char *buf, int ctrlc_pending_p)
{
/* Save the previous quit handler, so we can restore it. No need
for a cleanup since we catch all exceptions below. Note that the
asynchronously earlier, take this opportunity to send the
Ctrl-C synchronously. */
set_quit_flag ();
- remote_fileio_reply (-1, FILEIO_EINTR);
+ remote_fileio_reply (remote, -1, FILEIO_EINTR);
}
else
{
TRY
{
- do_remote_fileio_request (buf);
+ do_remote_fileio_request (remote, buf);
}
CATCH (ex, RETURN_MASK_ALL)
{
if (ex.reason == RETURN_QUIT)
- remote_fileio_reply (-1, FILEIO_EINTR);
+ remote_fileio_reply (remote, -1, FILEIO_EINTR);
else
- remote_fileio_reply (-1, FILEIO_EIO);
+ remote_fileio_reply (remote, -1, FILEIO_EIO);
}
END_CATCH
}
Specify the serial device it is connected to\n\
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
+#define OPAQUETHREADBYTES 8
+
+/* a 64 bit opaque identifier */
+typedef unsigned char threadref[OPAQUETHREADBYTES];
+
+struct gdb_ext_thread_info;
+struct threads_listing_context;
+typedef int (*rmt_thread_action) (threadref *ref, void *context);
+struct protocol_feature;
+struct packet_reg;
+
+struct stop_reply;
+typedef struct stop_reply *stop_reply_p;
+
+DECLARE_QUEUE_P (stop_reply_p);
+DEFINE_QUEUE_P (stop_reply_p);
+
+/* Generic configuration support for packets the stub optionally
+ supports. Allows the user to specify the use of the packet as well
+ as allowing GDB to auto-detect support in the remote stub. */
+
+enum packet_support
+ {
+ PACKET_SUPPORT_UNKNOWN = 0,
+ PACKET_ENABLE,
+ PACKET_DISABLE
+ };
+
+/* Analyze a packet's return value and update the packet config
+ accordingly. */
+
+enum packet_result
+{
+ PACKET_ERROR,
+ PACKET_OK,
+ PACKET_UNKNOWN
+};
+
+struct threads_listing_context;
+struct remote_state;
+
static const target_info remote_target_info = {
"remote",
N_("Remote serial target in gdb-specific protocol"),
{
to_stratum = process_stratum;
}
+ ~remote_target () override;
const target_info &info () const override
{ return remote_target_info; }
int remove_exec_catchpoint (int) override;
enum exec_direction_kind execution_direction () override;
-protected:
+public: /* Remote specific methods. */
+
+ void remote_download_command_source (int num, ULONGEST addr,
+ struct command_line *cmds);
+
+ void remote_file_put (const char *local_file, const char *remote_file,
+ int from_tty);
+ void remote_file_get (const char *remote_file, const char *local_file,
+ int from_tty);
+ void remote_file_delete (const char *remote_file, int from_tty);
+
+ int remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *remote_errno);
+ int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *remote_errno);
+ int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *remote_errno);
+
+ int remote_hostio_send_command (int command_bytes, int which_packet,
+ int *remote_errno, char **attachment,
+ int *attachment_len);
+ int remote_hostio_set_filesystem (struct inferior *inf,
+ int *remote_errno);
+ /* We should get rid of this and use fileio_open directly. */
+ int remote_hostio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *remote_errno);
+ int remote_hostio_close (int fd, int *remote_errno);
+
+ int remote_hostio_unlink (inferior *inf, const char *filename,
+ int *remote_errno);
+
+ struct remote_state *get_remote_state ();
+
+ long get_remote_packet_size (void);
+ long get_memory_packet_size (struct memory_packet_config *config);
+
+ long get_memory_write_packet_size ();
+ long get_memory_read_packet_size ();
+
+ char *append_pending_thread_resumptions (char *p, char *endp,
+ ptid_t ptid);
static void open_1 (const char *name, int from_tty, int extended_p);
void start_remote (int from_tty, int extended_p);
+ void remote_detach_1 (int from_tty, struct inferior *inf);
+
+ char *append_resumption (char *p, char *endp,
+ ptid_t ptid, int step, gdb_signal siggnal);
+ int remote_resume_with_vcont (ptid_t ptid, int step,
+ gdb_signal siggnal);
+
+ void add_current_inferior_and_thread (char *wait_status);
+
+ ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
+ int options);
+ ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
+ int options);
+
+ ptid_t process_stop_reply (struct stop_reply *stop_reply,
+ target_waitstatus *status);
+
+ void remote_notice_new_inferior (ptid_t currthread, int executing);
+
+ void process_initial_stop_replies (int from_tty);
+
+ void remote_add_thread (ptid_t ptid, bool running, bool executing);
+
+ void btrace_sync_conf (const btrace_config *conf);
+
+ void remote_btrace_maybe_reopen ();
+
+ void remove_new_fork_children (threads_listing_context *context);
+ void kill_new_fork_children (int pid);
+ void discard_pending_stop_replies (struct inferior *inf);
+ int stop_reply_queue_length ();
+
+ void check_pending_events_prevent_wildcard_vcont
+ (int *may_global_wildcard_vcont);
+
+ void discard_pending_stop_replies_in_queue ();
+ struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
+ struct stop_reply *queued_stop_reply (ptid_t ptid);
+ int peek_stop_reply (ptid_t ptid);
+ void remote_parse_stop_reply (char *buf, stop_reply *event);
+
+ void remote_stop_ns (ptid_t ptid);
+ void remote_interrupt_as ();
+ void remote_interrupt_ns ();
+
+ char *remote_get_noisy_reply ();
+ int remote_query_attached (int pid);
+ inferior *remote_add_inferior (int fake_pid_p, int pid, int attached,
+ int try_open_exec);
+
+ ptid_t remote_current_thread (ptid_t oldpid);
+ ptid_t get_current_thread (char *wait_status);
+
+ void set_thread (ptid_t ptid, int gen);
+ void set_general_thread (ptid_t ptid);
+ void set_continue_thread (ptid_t ptid);
+ void set_general_process ();
+
+ char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
+
+ int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
+ gdb_ext_thread_info *info);
+ int remote_get_threadinfo (threadref *threadid, int fieldset,
+ gdb_ext_thread_info *info);
+
+ int parse_threadlist_response (char *pkt, int result_limit,
+ threadref *original_echo,
+ threadref *resultlist,
+ int *doneflag);
+ int remote_get_threadlist (int startflag, threadref *nextthread,
+ int result_limit, int *done, int *result_count,
+ threadref *threadlist);
+
+ int remote_threadlist_iterator (rmt_thread_action stepfunction,
+ void *context, int looplimit);
+
+ int remote_get_threads_with_ql (threads_listing_context *context);
+ int remote_get_threads_with_qxfer (threads_listing_context *context);
+ int remote_get_threads_with_qthreadinfo (threads_listing_context *context);
+
+ void extended_remote_restart ();
+
+ void get_offsets ();
+
+ void remote_check_symbols ();
+
+ void remote_supported_packet (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *argument);
+
+ void remote_query_supported ();
+
+ void remote_packet_size (const protocol_feature *feature,
+ packet_support support, const char *value);
+
+ void remote_serial_quit_handler ();
+
+ void remote_detach_pid (int pid);
+
+ void remote_vcont_probe ();
+
+ void remote_resume_with_hc (ptid_t ptid, int step,
+ gdb_signal siggnal);
+
+ void send_interrupt_sequence ();
+ void interrupt_query ();
+
+ void remote_notif_get_pending_events (notif_client *nc);
+
+ int fetch_register_using_p (struct regcache *regcache,
+ packet_reg *reg);
+ int send_g_packet ();
+ void process_g_packet (struct regcache *regcache);
+ void fetch_registers_using_g (struct regcache *regcache);
+ int store_register_using_P (const struct regcache *regcache,
+ packet_reg *reg);
+ void store_registers_using_G (const struct regcache *regcache);
+
+ void set_remote_traceframe ();
+
+ void check_binary_download (CORE_ADDR addr);
+
+ target_xfer_status remote_write_bytes_aux (const char *header,
+ CORE_ADDR memaddr,
+ const gdb_byte *myaddr,
+ ULONGEST len_units,
+ int unit_size,
+ ULONGEST *xfered_len_units,
+ char packet_format,
+ int use_length);
+
+ target_xfer_status remote_write_bytes (CORE_ADDR memaddr,
+ const gdb_byte *myaddr, ULONGEST len,
+ int unit_size, ULONGEST *xfered_len);
+
+ target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
+ ULONGEST len_units,
+ int unit_size, ULONGEST *xfered_len_units);
+
+ target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf,
+ ULONGEST memaddr,
+ ULONGEST len,
+ int unit_size,
+ ULONGEST *xfered_len);
+
+ target_xfer_status remote_read_bytes (CORE_ADDR memaddr,
+ gdb_byte *myaddr, ULONGEST len,
+ int unit_size,
+ ULONGEST *xfered_len);
+
+ packet_result remote_send_printf (const char *format, ...)
+ ATTRIBUTE_PRINTF (2, 3);
+
+ target_xfer_status remote_flash_write (ULONGEST address,
+ ULONGEST length, ULONGEST *xfered_len,
+ const gdb_byte *data);
+
+ int readchar (int timeout);
+
+ void remote_serial_write (const char *str, int len);
+
+ int putpkt (const char *buf);
+ int putpkt_binary (const char *buf, int cnt);
+
+ void skip_frame ();
+ long read_frame (char **buf_p, long *sizeof_buf);
+ void getpkt (char **buf, long *sizeof_buf, int forever);
+ int getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
+ int expecting_notif, int *is_notif);
+ int getpkt_sane (char **buf, long *sizeof_buf, int forever);
+ int getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
+ int *is_notif);
+ int remote_vkill (int pid);
+ void remote_kill_k ();
+
+ void extended_remote_disable_randomization (int val);
+ int extended_remote_run (const std::string &args);
+
+ void send_environment_packet (const char *action,
+ const char *packet,
+ const char *value);
+
+ void extended_remote_environment_support ();
+ void extended_remote_set_inferior_cwd ();
+
+ target_xfer_status remote_write_qxfer (const char *object_name,
+ const char *annex,
+ const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len,
+ ULONGEST *xfered_len,
+ struct packet_config *packet);
+
+ target_xfer_status remote_read_qxfer (const char *object_name,
+ const char *annex,
+ gdb_byte *readbuf, ULONGEST offset,
+ LONGEST len,
+ ULONGEST *xfered_len,
+ struct packet_config *packet);
+
+ void push_stop_reply (struct stop_reply *new_event);
+
+ bool vcont_r_supported ();
+
+ void packet_command (const char *args, int from_tty);
+
+private: /* data fields */
+
+ std::unique_ptr<struct remote_state> m_remote_state;
};
static const target_info extended_remote_target_info = {
enum { REMOTE_ALIGN_WRITES = 16 };
/* Prototypes for local functions. */
-static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
-static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
- int forever, int *is_notif);
-
-struct remote_state;
-
-static int remote_vkill (int pid, struct remote_state *rs);
-
-static void remote_kill_k (void);
-
-static int readchar (int timeout);
-
-static void remote_serial_write (const char *str, int len);
-
-static void interrupt_query (void);
-
-static void set_general_thread (ptid_t ptid);
-static void set_continue_thread (ptid_t ptid);
-
-static void get_offsets (void);
-
-static void skip_frame (void);
-
-static long read_frame (char **buf_p, long *sizeof_buf);
static int hexnumlen (ULONGEST num);
static int stub_unpack_int (char *buff, int fieldlength);
-static ptid_t remote_current_thread (ptid_t oldptid);
-
-static int putpkt_binary (const char *buf, int cnt);
-
-static void check_binary_download (CORE_ADDR addr);
-
struct packet_config;
static void show_packet_config_cmd (struct packet_config *config);
struct cmd_list_element *c,
const char *value);
-static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
static ptid_t read_ptid (const char *buf, const char **obuf);
-static void remote_query_supported (void);
-
-static void remote_check_symbols (void);
-
struct stop_reply;
static void stop_reply_xfree (struct stop_reply *);
-static void remote_parse_stop_reply (char *, struct stop_reply *);
-static void push_stop_reply (struct stop_reply *);
-static void discard_pending_stop_replies_in_queue (struct remote_state *);
-static int peek_stop_reply (ptid_t ptid);
-
-struct threads_listing_context;
-static void remove_new_fork_children (struct threads_listing_context *);
static void remote_async_inferior_event_handler (gdb_client_data);
static void remote_console_output (char *msg);
-static void remote_btrace_reset (void);
-
-static void remote_btrace_maybe_reopen (void);
-
-static int stop_reply_queue_length (void);
+static void remote_btrace_reset (remote_state *rs);
static void remote_unpush_and_throw (void);
-static struct remote_state *get_remote_state (void);
-
/* For "remote". */
static struct cmd_list_element *remote_cmdlist;
static int use_range_stepping = 1;
-#define OPAQUETHREADBYTES 8
-
-/* a 64 bit opaque identifier */
-typedef unsigned char threadref[OPAQUETHREADBYTES];
-
/* About this many threadisds fit in a packet. */
#define MAXTHREADLISTRESULTS 32
file descriptor at a time. */
struct readahead_cache readahead_cache;
+ /* The list of already fetched and acknowledged stop events. This
+ queue is used for notification Stop, and other notifications
+ don't need queue for their events, because the notification
+ events of Stop can't be consumed immediately, so that events
+ should be queued first, and be consumed by remote_wait_{ns,as}
+ one per time. Other notifications can consume their events
+ immediately, so queue is not needed for them. */
+ QUEUE (stop_reply_p) *stop_reply_queue;
+
+ /* Asynchronous signal handle registered as event loop source for
+ when we have pending events ready to be passed to the core. */
+ struct async_event_handler *remote_async_inferior_event_token = nullptr;
+
+ /* FIXME: cagney/1999-09-23: Even though getpkt was called with
+ ``forever'' still use the normal timeout mechanism. This is
+ currently used by the ASYNC code to guarentee that target reads
+ during the initial connect always time-out. Once getpkt has been
+ modified to return a timeout indication and, in turn
+ remote_wait()/wait_for_inferior() have gained a timeout parameter
+ this can go away. */
+ int wait_forever_enabled_p = 1;
+
private:
/* Mapping of remote protocol data for each gdbarch. Usually there
is only one entry here, though we may see more with stubs that
whenever a larger buffer is needed. */
this->buf_size = 400;
this->buf = (char *) xmalloc (this->buf_size);
+
+ this->stop_reply_queue = QUEUE_alloc (stop_reply_p, stop_reply_xfree);
}
remote_state::~remote_state ()
xfree (this->buf);
xfree (this->finished_object);
xfree (this->finished_annex);
-}
-
-/* This data could be associated with a target, but we do not always
- have access to the current target when we need it, so for now it is
- static. This will be fine for as long as only one target is in use
- at a time. */
-static struct remote_state *remote_state;
-
-static struct remote_state *
-get_remote_state_raw (void)
-{
- return remote_state;
+ QUEUE_free (stop_reply_p, this->stop_reply_queue);
}
/* Utility: generate error from an incoming stub packet. */
/* Utility: wait for reply from stub, while accepting "O" packets. */
-static char *
-remote_get_noisy_reply ()
+char *
+remote_target::remote_get_noisy_reply ()
{
struct remote_state *rs = get_remote_state ();
/* Fetch the global remote target state. */
-static struct remote_state *
-get_remote_state (void)
+remote_state *
+remote_target::get_remote_state ()
{
- struct remote_state *rs = get_remote_state_raw ();
+ if (m_remote_state == nullptr)
+ m_remote_state.reset (new remote_state ());
/* Make sure that the remote architecture state has been
initialized, because doing so might reallocate rs->buf. Any
function which calls getpkt also needs to be mindful of changes
to rs->buf, but this call limits the number of places which run
into trouble. */
- rs->get_remote_arch_state (target_gdbarch ());
+ m_remote_state->get_remote_arch_state (target_gdbarch ());
- return rs;
+ return m_remote_state.get ();
}
/* Cleanup routine for the remote module's pspace data. */
this->remote_packet_size = (this->sizeof_g_packet * 2 + 32);
}
+/* Get a pointer to the current remote target. If not connected to a
+ remote target, return NULL. */
+
+static remote_target *
+get_current_remote_target ()
+{
+ target_ops *proc_target = find_target_at (process_stratum);
+ return dynamic_cast<remote_target *> (proc_target);
+}
+
/* Return the current allowed size of a remote packet. This is
inferred from the current architecture, and should be used to
limit the length of outgoing packets. */
-static long
-get_remote_packet_size (void)
+long
+remote_target::get_remote_packet_size ()
{
struct remote_state *rs = get_remote_state ();
remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
return NULL;
}
-static remote_target remote_ops;
-
-static extended_remote_target extended_remote_ops;
-
-/* FIXME: cagney/1999-09-23: Even though getpkt was called with
- ``forever'' still use the normal timeout mechanism. This is
- currently used by the ASYNC code to guarentee that target reads
- during the initial connect always time-out. Once getpkt has been
- modified to return a timeout indication and, in turn
- remote_wait()/wait_for_inferior() have gained a timeout parameter
- this can go away. */
-static int wait_forever_enabled_p = 1;
-
/* Allow the user to specify what sequence to send to the remote
when he requests a program interruption: Although ^C is usually
what remote systems expect (this is the default, here), it is
/* Compute the current size of a read/write packet. Since this makes
use of ``actual_register_packet_size'' the computation is dynamic. */
-static long
-get_memory_packet_size (struct memory_packet_config *config)
+long
+remote_target::get_memory_packet_size (struct memory_packet_config *config)
{
struct remote_state *rs = get_remote_state ();
remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
get_fixed_memory_packet_size (config));
else
{
- struct remote_state *rs = get_remote_state ();
+ remote_target *remote = get_current_remote_target ();
- if (rs->remote_desc != NULL)
+ if (remote != NULL)
printf_filtered (_("Packets are limited to %ld bytes.\n"),
- get_memory_packet_size (config));
+ remote->get_memory_packet_size (config));
else
puts_filtered ("The actual limit will be further reduced "
"dependent on the target.\n");
show_memory_packet_size (&memory_write_packet_config);
}
-static long
-get_memory_write_packet_size (void)
+long
+remote_target::get_memory_write_packet_size ()
{
return get_memory_packet_size (&memory_write_packet_config);
}
show_memory_packet_size (&memory_read_packet_config);
}
-static long
-get_memory_read_packet_size (void)
+long
+remote_target::get_memory_read_packet_size ()
{
long size = get_memory_packet_size (&memory_read_packet_config);
}
\f
-/* Generic configuration support for packets the stub optionally
- supports. Allows the user to specify the use of the packet as well
- as allowing GDB to auto-detect support in the remote stub. */
-
-enum packet_support
- {
- PACKET_SUPPORT_UNKNOWN = 0,
- PACKET_ENABLE,
- PACKET_DISABLE
- };
struct packet_config
{
enum packet_support support;
};
-/* Analyze a packet's return value and update the packet config
- accordingly. */
-
-enum packet_result
-{
- PACKET_ERROR,
- PACKET_OK,
- PACKET_UNKNOWN
-};
-
static enum packet_support packet_config_support (struct packet_config *config);
static enum packet_support packet_support (int packet);
}
\f
-/* Asynchronous signal handle registered as event loop source for
- when we have pending events ready to be passed to the core. */
-
-static struct async_event_handler *remote_async_inferior_event_token;
-
-\f
static ptid_t magic_null_ptid;
static ptid_t not_sent_ptid;
/* Find out if the stub attached to PID (and hence GDB should offer to
detach instead of killing it when bailing out). */
-static int
-remote_query_attached (int pid)
+int
+remote_target::remote_query_attached (int pid)
{
struct remote_state *rs = get_remote_state ();
size_t size = get_remote_packet_size ();
attempt to open this inferior's executable as the main executable
if no main executable is open already. */
-static struct inferior *
-remote_add_inferior (int fake_pid_p, int pid, int attached,
- int try_open_exec)
+inferior *
+remote_target::remote_add_inferior (int fake_pid_p, int pid, int attached,
+ int try_open_exec)
{
struct inferior *inf;
/* Add thread PTID to GDB's thread list. Tag it as executing/running
according to RUNNING. */
-static void
-remote_add_thread (ptid_t ptid, int running, int executing)
+void
+remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing)
{
struct remote_state *rs = get_remote_state ();
struct thread_info *thread;
GDB's inferior list as well. EXECUTING indicates whether the
thread is (internally) executing or stopped. */
-static void
-remote_notice_new_inferior (ptid_t currthread, int executing)
+void
+remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
{
/* In non-stop mode, we assume new found threads are (externally)
running until proven otherwise with a stop reply. In all-stop,
MINUS_ONE_PTID, set the thread to -1, so the stub returns the
thread. If GEN is set, set the general thread, if not, then set
the step/continue thread. */
-static void
-set_thread (ptid_t ptid, int gen)
+void
+remote_target::set_thread (ptid_t ptid, int gen)
{
struct remote_state *rs = get_remote_state ();
ptid_t state = gen ? rs->general_thread : rs->continue_thread;
rs->continue_thread = ptid;
}
-static void
-set_general_thread (ptid_t ptid)
+void
+remote_target::set_general_thread (ptid_t ptid)
{
set_thread (ptid, 1);
}
-static void
-set_continue_thread (ptid_t ptid)
+void
+remote_target::set_continue_thread (ptid_t ptid)
{
set_thread (ptid, 0);
}
general operations is the process the selected general thread
belongs to. */
-static void
-set_general_process (void)
+void
+remote_target::set_general_process ()
{
struct remote_state *rs = get_remote_state ();
static char *pack_threadinfo_request (char *pkt, int mode,
threadref *id);
-static int remote_unpack_thread_info_response (char *pkt,
- threadref *expectedref,
- struct gdb_ext_thread_info
- *info);
-
-
-static int remote_get_threadinfo (threadref *threadid,
- int fieldset, /*TAG mask */
- struct gdb_ext_thread_info *info);
-
static char *pack_threadlist_request (char *pkt, int startflag,
int threadcount,
threadref *nextthread);
-static int parse_threadlist_response (char *pkt,
- int result_limit,
- threadref *original_echo,
- threadref *resultlist,
- int *doneflag);
-
-static int remote_get_threadlist (int startflag,
- threadref *nextthread,
- int result_limit,
- int *done,
- int *result_count,
- threadref *threadlist);
-
-typedef int (*rmt_thread_action) (threadref *ref, void *context);
-
-static int remote_threadlist_iterator (rmt_thread_action stepfunction,
- void *context, int looplimit);
-
static int remote_newthread_step (threadref *ref, void *context);
buffer we're allowed to write to. Returns
BUF+CHARACTERS_WRITTEN. */
-static char *
-write_ptid (char *buf, const char *endbuf, ptid_t ptid)
+char *
+remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid)
{
int pid, tid;
struct remote_state *rs = get_remote_state ();
#define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
the process. */
-static int
-remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
- struct gdb_ext_thread_info *info)
+int
+remote_target::remote_unpack_thread_info_response (char *pkt,
+ threadref *expectedref,
+ gdb_ext_thread_info *info)
{
struct remote_state *rs = get_remote_state ();
int mask, length;
return retval;
}
-static int
-remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
- struct gdb_ext_thread_info *info)
+int
+remote_target::remote_get_threadinfo (threadref *threadid,
+ int fieldset,
+ gdb_ext_thread_info *info)
{
struct remote_state *rs = get_remote_state ();
int result;
/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
-static int
-parse_threadlist_response (char *pkt, int result_limit,
- threadref *original_echo, threadref *resultlist,
- int *doneflag)
+int
+remote_target::parse_threadlist_response (char *pkt, int result_limit,
+ threadref *original_echo,
+ threadref *resultlist,
+ int *doneflag)
{
struct remote_state *rs = get_remote_state ();
char *limit;
/* Fetch the next batch of threads from the remote. Returns -1 if the
qL packet is not supported, 0 on error and 1 on success. */
-static int
-remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
- int *done, int *result_count, threadref *threadlist)
+int
+remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
+ int result_limit, int *done, int *result_count,
+ threadref *threadlist)
{
struct remote_state *rs = get_remote_state ();
int result = 1;
STEPFUNCTION returns false. If the packet is not supported,
returns -1. */
-static int
-remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
- int looplimit)
+int
+remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction,
+ void *context, int looplimit)
{
struct remote_state *rs = get_remote_state ();
int done, i, result_count;
#define CRAZY_MAX_THREADS 1000
-static ptid_t
-remote_current_thread (ptid_t oldpid)
+ptid_t
+remote_target::remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
/* List remote threads using the deprecated qL packet. */
-static int
-remote_get_threads_with_ql (struct target_ops *ops,
- struct threads_listing_context *context)
+int
+remote_target::remote_get_threads_with_ql (threads_listing_context *context)
{
if (remote_threadlist_iterator (remote_newthread_step, context,
CRAZY_MAX_THREADS) >= 0)
/* List remote threads using qXfer:threads:read. */
-static int
-remote_get_threads_with_qxfer (struct target_ops *ops,
- struct threads_listing_context *context)
+int
+remote_target::remote_get_threads_with_qxfer (threads_listing_context *context)
{
#if defined(HAVE_LIBEXPAT)
if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
{
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (ops, TARGET_OBJECT_THREADS, NULL);
+ = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL);
if (xml && (*xml)[0] != '\0')
{
/* List remote threads using qfThreadInfo/qsThreadInfo. */
-static int
-remote_get_threads_with_qthreadinfo (struct target_ops *ops,
- struct threads_listing_context *context)
+int
+remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context)
{
struct remote_state *rs = get_remote_state ();
/* We have a few different mechanisms to fetch the thread list. Try
them all, starting with the most preferred one first, falling
back to older methods. */
- if (remote_get_threads_with_qxfer (this, &context)
- || remote_get_threads_with_qthreadinfo (this, &context)
- || remote_get_threads_with_ql (this, &context))
+ if (remote_get_threads_with_qxfer (&context)
+ || remote_get_threads_with_qthreadinfo (&context)
+ || remote_get_threads_with_ql (&context))
{
struct thread_info *tp, *tmp;
/* Restart the remote side; this is an extended protocol operation. */
-static void
-extended_remote_restart (void)
+void
+remote_target::extended_remote_restart ()
{
struct remote_state *rs = get_remote_state ();
void
remote_target::close ()
{
- struct remote_state *rs = get_remote_state ();
-
- if (rs->remote_desc == NULL)
- return; /* already closed */
-
/* Make sure we leave stdin registered in the event loop. */
terminal_ours ();
- serial_close (rs->remote_desc);
- rs->remote_desc = NULL;
-
/* We don't have a connection to the remote stub anymore. Get rid
of all the inferiors and their threads we were controlling.
Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
inferior_ptid = null_ptid;
discard_all_inferiors ();
- /* We are closing the remote target, so we should discard
+ trace_reset_local_state ();
+
+ delete this;
+}
+
+remote_target::~remote_target ()
+{
+ struct remote_state *rs = get_remote_state ();
+
+ /* Check for NULL because we may get here with a partially
+ constructed target/connection. */
+ if (rs->remote_desc == nullptr)
+ return;
+
+ serial_close (rs->remote_desc);
+
+ /* We are destroying the remote target, so we should discard
everything of this target. */
- discard_pending_stop_replies_in_queue (rs);
+ discard_pending_stop_replies_in_queue ();
- if (remote_async_inferior_event_token)
- delete_async_event_handler (&remote_async_inferior_event_token);
+ if (rs->remote_async_inferior_event_token)
+ delete_async_event_handler (&rs->remote_async_inferior_event_token);
remote_notif_state_xfree (rs->notif_state);
-
- trace_reset_local_state ();
}
/* Query the remote side for the text, data and bss offsets. */
-static void
-get_offsets (void)
+void
+remote_target::get_offsets ()
{
struct remote_state *rs = get_remote_state ();
char *buf;
}
/* Send interrupt_sequence to remote target. */
-static void
-send_interrupt_sequence (void)
+
+void
+remote_target::send_interrupt_sequence ()
{
struct remote_state *rs = get_remote_state ();
ask the remote which is the current thread with qC. The former
method avoids a roundtrip. */
-static ptid_t
-get_current_thread (char *wait_status)
+ptid_t
+remote_target::get_current_thread (char *wait_status)
{
ptid_t ptid = null_ptid;
qC query, we infer the current thread from that stop reply, passed
in in WAIT_STATUS, which may be NULL. */
-static void
-add_current_inferior_and_thread (char *wait_status)
+void
+remote_target::add_current_inferior_and_thread (char *wait_status)
{
struct remote_state *rs = get_remote_state ();
int fake_pid_p = 0;
on initial connection. We mark these threads as stopped and print
their current frame before giving the user the prompt. */
-static void
-process_initial_stop_replies (int from_tty)
+void
+remote_target::process_initial_stop_replies (int from_tty)
{
int pending_stop_replies = stop_reply_queue_length ();
struct inferior *inf;
/* remote_notif_get_pending_replies acks this one, and gets
the rest out. */
rs->notif_state->pending_event[notif_client_stop.id]
- = remote_notif_parse (notif, rs->buf);
+ = remote_notif_parse (this, notif, rs->buf);
remote_notif_get_pending_events (notif);
}
/* Symbol look-up. */
-static void
-remote_check_symbols (void)
+void
+remote_target::remote_check_symbols ()
{
char *msg, *reply, *tmp;
int end;
not reported). The third argument may be NULL; if not NULL, it
is a NUL-terminated string taken from the packet following
this feature's name and an equals sign. */
- void (*func) (const struct protocol_feature *, enum packet_support,
- const char *);
+ void (*func) (remote_target *remote, const struct protocol_feature *,
+ enum packet_support, const char *);
/* The corresponding packet for this feature. Only used if
FUNC is remote_supported_packet. */
};
static void
-remote_supported_packet (const struct protocol_feature *feature,
+remote_supported_packet (remote_target *remote,
+ const struct protocol_feature *feature,
enum packet_support support,
const char *argument)
{
remote_protocol_packets[feature->packet].support = support;
}
-static void
-remote_packet_size (const struct protocol_feature *feature,
- enum packet_support support, const char *value)
+void
+remote_target::remote_packet_size (const protocol_feature *feature,
+ enum packet_support support, const char *value)
{
struct remote_state *rs = get_remote_state ();
rs->explicit_packet_size = packet_size;
}
+void
+remote_packet_size (remote_target *remote, const protocol_feature *feature,
+ enum packet_support support, const char *value)
+{
+ remote->remote_packet_size (feature, support, value);
+}
+
static const struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
{ "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
msg->append (append);
}
-static void
-remote_query_supported (void)
+void
+remote_target::remote_query_supported ()
{
struct remote_state *rs = get_remote_state ();
char *next;
seen[i] = 1;
feature = &remote_protocol_features[i];
- feature->func (feature, is_supported, value);
+ feature->func (this, feature, is_supported, value);
break;
}
}
const struct protocol_feature *feature;
feature = &remote_protocol_features[i];
- feature->func (feature, feature->default_support, NULL);
+ feature->func (this, feature, feature->default_support, NULL);
}
}
is probably wedged --- offer to quit/disconnect.
*/
-static void
-remote_serial_quit_handler (void)
+void
+remote_target::remote_serial_quit_handler ()
{
struct remote_state *rs = get_remote_state ();
}
}
+/* The remote_target that is current while the quit handler is
+ overridden with remote_serial_quit_handler. */
+static remote_target *curr_quit_handler_target;
+
+static void
+remote_serial_quit_handler ()
+{
+ curr_quit_handler_target->remote_serial_quit_handler ();
+}
+
/* Remove any of the remote.c targets from target stack. Upper targets depend
on it so remove them first. */
void
remote_target::open_1 (const char *name, int from_tty, int extended_p)
{
- struct remote_state *rs = get_remote_state ();
+ remote_target *curr_remote = get_current_remote_target ();
if (name == 0)
error (_("To open a remote debug connection, you need to specify what\n"
"serial device is attached to the remote system\n"
"(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
- /* See FIXME above. */
- if (!target_async_permitted)
- wait_forever_enabled_p = 1;
-
/* If we're connected to a running target, target_preopen will kill it.
Ask this question first, before target_preopen has a chance to kill
anything. */
- if (rs->remote_desc != NULL && !have_inferiors ())
+ if (curr_remote != NULL && !have_inferiors ())
{
if (from_tty
&& !query (_("Already connected to a remote target. Disconnect? ")))
/* Here the possibly existing remote target gets unpushed. */
target_preopen (from_tty);
- /* Make sure we send the passed signals list the next time we resume. */
- xfree (rs->last_pass_packet);
- rs->last_pass_packet = NULL;
-
- /* Make sure we send the program signals list the next time we
- resume. */
- xfree (rs->last_program_signals_packet);
- rs->last_program_signals_packet = NULL;
-
remote_fileio_reset ();
reopen_exec_file ();
reread_symbols ();
+ remote_target *remote
+ = (extended_p ? new extended_remote_target () : new remote_target ());
+ target_ops_up target_holder (remote);
+
+ remote_state *rs = remote->get_remote_state ();
+
+ /* See FIXME above. */
+ if (!target_async_permitted)
+ rs->wait_forever_enabled_p = 1;
+
rs->remote_desc = remote_serial_open (name);
if (!rs->remote_desc)
perror_with_name (name);
puts_filtered ("\n");
}
- remote_target *target
- = extended_p ? &extended_remote_ops : &remote_ops;
- push_target (target); /* Switch to using remote target now. */
+ /* Switch to using the remote target now. */
+ push_target (remote);
+ /* The target stack owns the target now. */
+ target_holder.release ();
/* Register extra event sources in the event loop. */
- remote_async_inferior_event_token
+ rs->remote_async_inferior_event_token
= create_async_event_handler (remote_async_inferior_event_handler,
- NULL);
- rs->notif_state = remote_notif_state_allocate ();
+ remote);
+ rs->notif_state = remote_notif_state_allocate (remote);
/* Reset the target state; these things will be queried either by
remote_query_supported or as they are needed. */
around this. Eventually a mechanism that allows
wait_for_inferior() to expect/get timeouts will be
implemented. */
- wait_forever_enabled_p = 0;
+ rs->wait_forever_enabled_p = 0;
}
/* First delete any symbols previously loaded from shared libraries. */
TRY
{
- target->start_remote (from_tty, extended_p);
+ remote->start_remote (from_tty, extended_p);
}
CATCH (ex, RETURN_MASK_ALL)
{
/* Pop the partially set up target - unless something else did
already before throwing the exception. */
- if (rs->remote_desc != NULL)
+ if (ex.error != TARGET_CLOSE_ERROR)
remote_unpush_target ();
- if (target_async_permitted)
- wait_forever_enabled_p = 1;
throw_exception (ex);
}
END_CATCH
}
- remote_btrace_reset ();
+ remote_btrace_reset (rs);
if (target_async_permitted)
- wait_forever_enabled_p = 1;
+ rs->wait_forever_enabled_p = 1;
}
/* Detach the specified process. */
-static void
-remote_detach_pid (int pid)
+void
+remote_target::remote_detach_pid (int pid)
{
struct remote_state *rs = get_remote_state ();
any breakpoints in the target program or it'll die when it hits
one. */
-static void
-remote_detach_1 (int from_tty, inferior *inf)
+void
+remote_target::remote_detach_1 (int from_tty, inferior *inf)
{
int pid = ptid_get_pid (inferior_ptid);
struct remote_state *rs = get_remote_state ();
if (target_can_async_p ())
{
struct notif_event *reply
- = remote_notif_parse (¬if_client_stop, wait_status);
+ = remote_notif_parse (this, ¬if_client_stop, wait_status);
push_stop_reply ((struct stop_reply *) reply);
/* Check for the availability of vCont. This function should also check
the response. */
-static void
-remote_vcont_probe (struct remote_state *rs)
+void
+remote_target::remote_vcont_probe ()
{
+ remote_state *rs = get_remote_state ();
char *buf;
strcpy (rs->buf, "vCont?");
the thread to be stepped and/or signalled is given in the global
INFERIOR_PTID. */
-static char *
-append_resumption (char *p, char *endp,
- ptid_t ptid, int step, enum gdb_signal siggnal)
+char *
+remote_target::append_resumption (char *p, char *endp,
+ ptid_t ptid, int step, gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
/* Append a vCont continue-with-signal action for threads that have a
non-zero stop signal. */
-static char *
-append_pending_thread_resumptions (char *p, char *endp, ptid_t ptid)
+char *
+remote_target::append_pending_thread_resumptions (char *p, char *endp,
+ ptid_t ptid)
{
struct thread_info *thread;
/* Set the target running, using the packets that use Hc
(c/s/C/S). */
-static void
-remote_resume_with_hc (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal siggnal)
+void
+remote_target::remote_resume_with_hc (ptid_t ptid, int step,
+ gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
struct thread_info *thread;
resume_clear_thread_private_info (thread);
buf = rs->buf;
- if (execution_direction == EXEC_REVERSE)
+ if (::execution_direction == EXEC_REVERSE)
{
/* We don't pass signals to the target in reverse exec mode. */
if (info_verbose && siggnal != GDB_SIGNAL_0)
This function issues a strict subset of all possible vCont commands
at the moment. */
-static int
-remote_resume_with_vcont (ptid_t ptid, int step, enum gdb_signal siggnal)
+int
+remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
+ enum gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
char *p;
char *endp;
/* No reverse execution actions defined for vCont. */
- if (execution_direction == EXEC_REVERSE)
+ if (::execution_direction == EXEC_REVERSE)
return 0;
if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs);
+ remote_vcont_probe ();
if (packet_support (PACKET_vCont) == PACKET_DISABLE)
return 0;
/* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
if (!remote_resume_with_vcont (ptid, step, siggnal))
- remote_resume_with_hc (this, ptid, step, siggnal);
+ remote_resume_with_hc (ptid, step, siggnal);
/* We are about to start executing the inferior, let's register it
with the event loop. NOTE: this is the one place where all the
rs->waiting_for_stop_reply = 1;
}
-static void check_pending_events_prevent_wildcard_vcont
- (int *may_global_wildcard_vcont);
static int is_pending_fork_parent_thread (struct thread_info *thread);
/* Private per-inferior info for target remote processes. */
class vcont_builder
{
public:
- vcont_builder ()
+ explicit vcont_builder (remote_target *remote)
+ : m_remote (remote)
{
restart ();
}
private:
void restart ();
+ /* The remote target. */
+ remote_target *m_remote;
+
/* Pointer to the first action. P points here if no action has been
appended yet. */
char *m_first_action;
void
vcont_builder::restart ()
{
- struct remote_state *rs = get_remote_state ();
+ struct remote_state *rs = m_remote->get_remote_state ();
m_p = rs->buf;
- m_endp = rs->buf + get_remote_packet_size ();
+ m_endp = rs->buf + m_remote->get_remote_packet_size ();
m_p += xsnprintf (m_p, m_endp - m_p, "vCont");
m_first_action = m_p;
}
if (m_p == m_first_action)
return;
- rs = get_remote_state ();
- putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
+ rs = m_remote->get_remote_state ();
+ m_remote->putpkt (rs->buf);
+ m_remote->getpkt (&rs->buf, &rs->buf_size, 0);
if (strcmp (rs->buf, "OK") != 0)
error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
}
{
char buf[MAX_ACTION_SIZE + 1];
- char *endp = append_resumption (buf, buf + sizeof (buf),
- ptid, step, siggnal);
+ char *endp = m_remote->append_resumption (buf, buf + sizeof (buf),
+ ptid, step, siggnal);
/* Check whether this new action would fit in the vCont packet along
with previous actions. If not, send what we've got so far and
we end up with too many actions for a single packet vcont_builder
flushes the current vCont packet to the remote side and starts a
new one. */
- struct vcont_builder vcont_builder;
+ struct vcont_builder vcont_builder (this);
/* Threads first. */
ALL_NON_EXITED_THREADS (tp)
thread, all threads of a remote process, or all threads of all
processes. */
-static void
-remote_stop_ns (ptid_t ptid)
+void
+remote_target::remote_stop_ns (ptid_t ptid)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
char *endp = rs->buf + get_remote_packet_size ();
if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs);
+ remote_vcont_probe ();
if (!rs->supports_vCont.t)
error (_("Remote server does not support stopping threads"));
interrupt the remote target. It is undefined which thread of which
process reports the interrupt. */
-static void
-remote_interrupt_as (void)
+void
+remote_target::remote_interrupt_as ()
{
struct remote_state *rs = get_remote_state ();
reports the interrupt. Throws an error if the packet is not
supported by the server. */
-static void
-remote_interrupt_ns (void)
+void
+remote_target::remote_interrupt_ns ()
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* Ask the user what to do when an interrupt is received. */
-static void
-interrupt_query (void)
+void
+remote_target::interrupt_query ()
{
struct remote_state *rs = get_remote_state ();
int core;
} *stop_reply_p;
-DECLARE_QUEUE_P (stop_reply_p);
-DEFINE_QUEUE_P (stop_reply_p);
-/* The list of already fetched and acknowledged stop events. This
- queue is used for notification Stop, and other notifications
- don't need queue for their events, because the notification events
- of Stop can't be consumed immediately, so that events should be
- queued first, and be consumed by remote_wait_{ns,as} one per
- time. Other notifications can consume their events immediately,
- so queue is not needed for them. */
-static QUEUE (stop_reply_p) *stop_reply_queue;
-
static void
stop_reply_xfree (struct stop_reply *r)
{
/* Return the length of the stop reply queue. */
-static int
-stop_reply_queue_length (void)
+int
+remote_target::stop_reply_queue_length ()
{
- return QUEUE_length (stop_reply_p, stop_reply_queue);
+ remote_state *rs = get_remote_state ();
+ return QUEUE_length (stop_reply_p, rs->stop_reply_queue);
}
-static void
-remote_notif_stop_parse (struct notif_client *self, char *buf,
+void
+remote_notif_stop_parse (remote_target *remote,
+ struct notif_client *self, char *buf,
struct notif_event *event)
{
- remote_parse_stop_reply (buf, (struct stop_reply *) event);
+ remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
}
static void
-remote_notif_stop_ack (struct notif_client *self, char *buf,
+remote_notif_stop_ack (remote_target *remote,
+ struct notif_client *self, char *buf,
struct notif_event *event)
{
struct stop_reply *stop_reply = (struct stop_reply *) event;
/* acknowledge */
- putpkt (self->ack_command);
+ putpkt (remote, self->ack_command);
if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
+ {
/* We got an unknown stop reply. */
error (_("Unknown stop reply"));
+ }
- push_stop_reply (stop_reply);
+ remote->push_stop_reply (stop_reply);
}
static int
-remote_notif_stop_can_get_pending_events (struct notif_client *self)
+remote_notif_stop_can_get_pending_events (remote_target *remote,
+ struct notif_client *self)
{
/* We can't get pending events in remote_notif_process for
notification stop, and we have to do this in remote_wait_ns
instead. If we fetch all queued events from stub, remote stub
may exit and we have no chance to process them back in
remote_wait_ns. */
- mark_async_event_handler (remote_async_inferior_event_token);
+ remote_state *rs = remote->get_remote_state ();
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
return 0;
}
struct queue_iter_param
{
+ remote_target *remote;
void *input;
struct stop_reply *output;
};
and have not yet called follow_fork, which will set up the
host-side data structures for the new process. */
-static void
-remove_new_fork_children (struct threads_listing_context *context)
+void
+remote_target::remove_new_fork_children (threads_listing_context *context)
{
struct thread_info * thread;
int pid = -1;
in process PID and remove those fork child threads from the
CONTEXT list as well. */
remote_notif_get_pending_events (notif);
+ param.remote = this;
param.input = context;
param.output = NULL;
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ QUEUE_iterate (stop_reply_p, get_remote_state ()->stop_reply_queue,
remove_child_of_pending_fork, ¶m);
}
+/* Callback data for
+ check_pending_event_prevents_wildcard_vcont_callback. */
+struct check_pending_event_prevents_wildcard_vcont_callback_data
+{
+ /* The remote target. */
+ remote_target *remote;
+
+ /* Whether we can do a global wildcard (vCont;c) */
+ int *may_global_wildcard_vcont;
+};
+
/* Check whether EVENT would prevent a global or process wildcard
vCont action. */
void *data)
{
struct inferior *inf;
- int *may_global_wildcard_vcont = (int *) data;
+ auto *cb_data = (check_pending_event_prevents_wildcard_vcont_callback_data *) data;
if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
|| event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
if (event->ws.kind == TARGET_WAITKIND_FORKED
|| event->ws.kind == TARGET_WAITKIND_VFORKED)
- *may_global_wildcard_vcont = 0;
+ *cb_data->may_global_wildcard_vcont = 0;
inf = find_inferior_ptid (event->ptid);
/* This may be the first time we heard about this process.
Regardless, we must not do a global wildcard resume, otherwise
we'd resume this process too. */
- *may_global_wildcard_vcont = 0;
+ *cb_data->may_global_wildcard_vcont = 0;
if (inf != NULL)
get_remote_inferior (inf)->may_wildcard_vcont = false;
and clear the event inferior's may_wildcard_vcont flag if we can't
do a process-wide wildcard resume (vCont;c:pPID.-1). */
-static void
-check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard)
+void
+remote_target::check_pending_events_prevent_wildcard_vcont
+ (int *may_global_wildcard)
{
struct notif_client *notif = ¬if_client_stop;
+ check_pending_event_prevents_wildcard_vcont_callback_data cb_data
+ {this, may_global_wildcard};
remote_notif_get_pending_events (notif);
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ QUEUE_iterate (stop_reply_p, get_remote_state ()->stop_reply_queue,
check_pending_event_prevents_wildcard_vcont_callback,
- may_global_wildcard);
+ &cb_data);
}
/* Remove stop replies in the queue if its pid is equal to the given
/* Discard all pending stop replies of inferior INF. */
-static void
-discard_pending_stop_replies (struct inferior *inf)
+void
+remote_target::discard_pending_stop_replies (struct inferior *inf)
{
struct queue_iter_param param;
struct stop_reply *reply;
rns->pending_event[notif_client_stop.id] = NULL;
}
+ param.remote = this;
param.input = inf;
param.output = NULL;
/* Discard the stop replies we have already pulled with
vStopped. */
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ QUEUE_iterate (stop_reply_p, rs->stop_reply_queue,
remove_stop_reply_for_inferior, ¶m);
}
/* Discard the stop replies for RS in stop_reply_queue. */
-static void
-discard_pending_stop_replies_in_queue (struct remote_state *rs)
+void
+remote_target::discard_pending_stop_replies_in_queue ()
{
+ remote_state *rs = get_remote_state ();
struct queue_iter_param param;
+ param.remote = this;
param.input = rs;
param.output = NULL;
/* Discard the stop replies we have already pulled with
vStopped. */
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ QUEUE_iterate (stop_reply_p, rs->stop_reply_queue,
remove_stop_reply_of_remote_state, ¶m);
}
/* Remove the first reply in 'stop_reply_queue' which matches
PTID. */
-static struct stop_reply *
-remote_notif_remove_queued_reply (ptid_t ptid)
+struct stop_reply *
+remote_target::remote_notif_remove_queued_reply (ptid_t ptid)
{
struct queue_iter_param param;
+ param.remote = this;
param.input = &ptid;
param.output = NULL;
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ QUEUE_iterate (stop_reply_p, get_remote_state ()->stop_reply_queue,
remote_notif_remove_once_on_match, ¶m);
if (notif_debug)
fprintf_unfiltered (gdb_stdlog,
found. If there are still queued events left to process, tell the
event loop to get back to target_wait soon. */
-static struct stop_reply *
-queued_stop_reply (ptid_t ptid)
+struct stop_reply *
+remote_target::queued_stop_reply (ptid_t ptid)
{
struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
- if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
- /* There's still at least an event left. */
- mark_async_event_handler (remote_async_inferior_event_token);
+ if (!QUEUE_is_empty (stop_reply_p, get_remote_state ()->stop_reply_queue))
+ {
+ remote_state *rs = get_remote_state ();
+ /* There's still at least an event left. */
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
+ }
return r;
}
know that we now have at least one queued event left to pass to the
core side, tell the event loop to get back to target_wait soon. */
-static void
-push_stop_reply (struct stop_reply *new_event)
+void
+remote_target::push_stop_reply (struct stop_reply *new_event)
{
- QUEUE_enque (stop_reply_p, stop_reply_queue, new_event);
+ remote_state *rs = get_remote_state ();
+ QUEUE_enque (stop_reply_p, rs->stop_reply_queue, new_event);
if (notif_debug)
fprintf_unfiltered (gdb_stdlog,
"notif: push 'Stop' %s to queue %d\n",
target_pid_to_str (new_event->ptid),
QUEUE_length (stop_reply_p,
- stop_reply_queue));
+ rs->stop_reply_queue));
- mark_async_event_handler (remote_async_inferior_event_token);
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
}
static int
/* Returns true if we have a stop reply for PTID. */
-static int
-peek_stop_reply (ptid_t ptid)
+int
+remote_target::peek_stop_reply (ptid_t ptid)
{
- return !QUEUE_iterate (stop_reply_p, stop_reply_queue,
+ remote_state *rs = get_remote_state ();
+ return !QUEUE_iterate (stop_reply_p, rs->stop_reply_queue,
stop_reply_match_ptid_and_ws, &ptid);
}
/* Parse the stop reply in BUF. Either the function succeeds, and the
result is stored in EVENT, or throws an error. */
-static void
-remote_parse_stop_reply (char *buf, struct stop_reply *event)
+void
+remote_target::remote_parse_stop_reply (char *buf, stop_reply *event)
{
remote_arch_state *rsa = NULL;
ULONGEST addr;
*/
void
-remote_notif_get_pending_events (struct notif_client *nc)
+remote_target::remote_notif_get_pending_events (notif_client *nc)
{
struct remote_state *rs = get_remote_state ();
nc->name);
/* acknowledge */
- nc->ack (nc, rs->buf, rs->notif_state->pending_event[nc->id]);
+ nc->ack (this, nc, rs->buf, rs->notif_state->pending_event[nc->id]);
rs->notif_state->pending_event[nc->id] = NULL;
while (1)
if (strcmp (rs->buf, "OK") == 0)
break;
else
- remote_notif_ack (nc, rs->buf);
+ remote_notif_ack (this, nc, rs->buf);
}
}
else
}
}
+/* Wrapper around remote_target::remote_notif_get_pending_events to
+ avoid having to export the whole remote_target class. */
+
+void
+remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
+{
+ remote->remote_notif_get_pending_events (nc);
+}
+
/* Called when it is decided that STOP_REPLY holds the info of the
event that is to be returned to the core. This function always
destroys STOP_REPLY. */
-static ptid_t
-process_stop_reply (struct stop_reply *stop_reply,
- struct target_waitstatus *status)
+ptid_t
+remote_target::process_stop_reply (struct stop_reply *stop_reply,
+ struct target_waitstatus *status)
{
ptid_t ptid;
/* The non-stop mode version of target_wait. */
-static ptid_t
-remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
+ptid_t
+remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
{
struct remote_state *rs = get_remote_state ();
struct stop_reply *stop_reply;
/* Wait until the remote machine stops, then return, storing status in
STATUS just as `wait' would. */
-static ptid_t
-remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
+ptid_t
+remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
{
struct remote_state *rs = get_remote_state ();
ptid_t event_ptid = null_ptid;
int ret;
int is_notif;
int forever = ((options & TARGET_WNOHANG) == 0
- && wait_forever_enabled_p);
+ && rs->wait_forever_enabled_p);
if (!rs->waiting_for_stop_reply)
{
for a stop reply. See the comments in putpkt_binary. Set
waiting_for_stop_reply to 0 temporarily. */
rs->waiting_for_stop_reply = 0;
- remote_fileio_request (buf, rs->ctrlc_pending_p);
+ remote_fileio_request (this, buf, rs->ctrlc_pending_p);
rs->ctrlc_pending_p = 0;
/* GDB handled the File-I/O request, and the target is running
again. Keep waiting for events. */
rs->waiting_for_stop_reply = 0;
stop_reply
- = (struct stop_reply *) remote_notif_parse (¬if_client_stop,
+ = (struct stop_reply *) remote_notif_parse (this,
+ ¬if_client_stop,
rs->buf);
event_ptid = process_stop_reply (stop_reply, status);
ptid_t event_ptid;
if (target_is_non_stop_p ())
- event_ptid = remote_wait_ns (ptid, status, options);
+ event_ptid = wait_ns (ptid, status, options);
else
- event_ptid = remote_wait_as (ptid, status, options);
+ event_ptid = wait_as (ptid, status, options);
if (target_is_async_p ())
{
+ remote_state *rs = get_remote_state ();
+
/* If there are are events left in the queue tell the event loop
to return here. */
- if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
- mark_async_event_handler (remote_async_inferior_event_token);
+ if (!QUEUE_is_empty (stop_reply_p, rs->stop_reply_queue))
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
}
return event_ptid;
/* Fetch a single register using a 'p' packet. */
-static int
-fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
+int
+remote_target::fetch_register_using_p (struct regcache *regcache,
+ packet_reg *reg)
{
struct gdbarch *gdbarch = regcache->arch ();
struct remote_state *rs = get_remote_state ();
/* Fetch the registers included in the target's 'g' packet. */
-static int
-send_g_packet (void)
+int
+remote_target::send_g_packet ()
{
struct remote_state *rs = get_remote_state ();
int buf_len;
return buf_len / 2;
}
-static void
-process_g_packet (struct regcache *regcache)
+void
+remote_target::process_g_packet (struct regcache *regcache)
{
struct gdbarch *gdbarch = regcache->arch ();
struct remote_state *rs = get_remote_state ();
}
}
-static void
-fetch_registers_using_g (struct regcache *regcache)
+void
+remote_target::fetch_registers_using_g (struct regcache *regcache)
{
send_g_packet ();
process_g_packet (regcache);
/* Make the remote selected traceframe match GDB's selected
traceframe. */
-static void
-set_remote_traceframe (void)
+void
+remote_target::set_remote_traceframe ()
{
int newnum;
struct remote_state *rs = get_remote_state ();
/* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
packet was not recognized. */
-static int
-store_register_using_P (const struct regcache *regcache,
- struct packet_reg *reg)
+int
+remote_target::store_register_using_P (const struct regcache *regcache,
+ packet_reg *reg)
{
struct gdbarch *gdbarch = regcache->arch ();
struct remote_state *rs = get_remote_state ();
/* Store register REGNUM, or all registers if REGNUM == -1, from the
contents of the register cache buffer. FIXME: ignores errors. */
-static void
-store_registers_using_G (const struct regcache *regcache)
+void
+remote_target::store_registers_using_G (const struct regcache *regcache)
{
struct remote_state *rs = get_remote_state ();
remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
clean. In cases like this, the user should clear "remote
X-packet". */
-static void
-check_binary_download (CORE_ADDR addr)
+void
+remote_target::check_binary_download (CORE_ADDR addr)
{
struct remote_state *rs = get_remote_state ();
-> $m1000,4#??
<- eeeeffffeeeedddd */
-static enum target_xfer_status
-remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
- const gdb_byte *myaddr, ULONGEST len_units,
- int unit_size, ULONGEST *xfered_len_units,
- char packet_format, int use_length)
+target_xfer_status
+remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
+ const gdb_byte *myaddr,
+ ULONGEST len_units,
+ int unit_size,
+ ULONGEST *xfered_len_units,
+ char packet_format, int use_length)
{
struct remote_state *rs = get_remote_state ();
char *p;
'enum target_xfer_status' value). Save the number of bytes
transferred in *XFERED_LEN. Only transfer a single packet. */
-static enum target_xfer_status
-remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len,
- int unit_size, ULONGEST *xfered_len)
+target_xfer_status
+remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr,
+ ULONGEST len, int unit_size,
+ ULONGEST *xfered_len)
{
const char *packet_format = NULL;
See the comment of remote_write_bytes_aux for an example of
memory read/write exchange between gdb and the stub. */
-static enum target_xfer_status
-remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len_units,
- int unit_size, ULONGEST *xfered_len_units)
+target_xfer_status
+remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
+ ULONGEST len_units,
+ int unit_size, ULONGEST *xfered_len_units)
{
struct remote_state *rs = get_remote_state ();
int buf_size_bytes; /* Max size of packet output buffer. */
For interface/parameters/return description see target.h,
to_xfer_partial. */
-static enum target_xfer_status
-remote_xfer_live_readonly_partial (struct target_ops *ops, gdb_byte *readbuf,
- ULONGEST memaddr, ULONGEST len,
- int unit_size, ULONGEST *xfered_len)
+target_xfer_status
+remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
+ ULONGEST memaddr,
+ ULONGEST len,
+ int unit_size,
+ ULONGEST *xfered_len)
{
struct target_section *secp;
struct target_section_table *table;
- secp = target_section_by_addr (ops, memaddr);
+ secp = target_section_by_addr (this, memaddr);
if (secp != NULL
&& (bfd_get_section_flags (secp->the_bfd_section->owner,
secp->the_bfd_section)
struct target_section *p;
ULONGEST memend = memaddr + len;
- table = target_get_section_table (ops);
+ table = target_get_section_table (this);
for (p = table->sections; p < table->sections_end; p++)
{
first if the requested memory is unavailable in traceframe.
Otherwise, fall back to remote_read_bytes_1. */
-static enum target_xfer_status
-remote_read_bytes (struct target_ops *ops, CORE_ADDR memaddr,
- gdb_byte *myaddr, ULONGEST len, int unit_size,
- ULONGEST *xfered_len)
+target_xfer_status
+remote_target::remote_read_bytes (CORE_ADDR memaddr,
+ gdb_byte *myaddr, ULONGEST len, int unit_size,
+ ULONGEST *xfered_len)
{
if (len == 0)
return TARGET_XFER_EOF;
}
/* This goes through the topmost target again. */
- res = remote_xfer_live_readonly_partial (ops, myaddr, memaddr,
+ res = remote_xfer_live_readonly_partial (myaddr, memaddr,
len, unit_size, xfered_len);
if (res == TARGET_XFER_OK)
return TARGET_XFER_OK;
FORMAT and the remaining arguments, then gets the reply. Returns
whether the packet was a success, a failure, or unknown. */
-static enum packet_result remote_send_printf (const char *format, ...)
- ATTRIBUTE_PRINTF (1, 2);
-
-static enum packet_result
-remote_send_printf (const char *format, ...)
+packet_result
+remote_target::remote_send_printf (const char *format, ...)
{
struct remote_state *rs = get_remote_state ();
int max_size = get_remote_packet_size ();
}
}
-static enum target_xfer_status
-remote_flash_write (struct target_ops *ops, ULONGEST address,
- ULONGEST length, ULONGEST *xfered_len,
- const gdb_byte *data)
+target_xfer_status
+remote_target::remote_flash_write (ULONGEST address,
+ ULONGEST length, ULONGEST *xfered_len,
+ const gdb_byte *data)
{
scoped_restore restore_timeout
= make_scoped_restore (&remote_timeout, remote_flash_timeout);
sequence, as that would break communication with the remote server.
See remote_serial_quit_handler for more detail. */
-static int
-readchar (int timeout)
+int
+remote_target::readchar (int timeout)
{
int ch;
struct remote_state *rs = get_remote_state ();
{
+ scoped_restore restore_quit_target
+ = make_scoped_restore (&curr_quit_handler_target, this);
scoped_restore restore_quit
- = make_scoped_restore (&quit_handler, remote_serial_quit_handler);
+ = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
rs->got_ctrlc_during_io = 0;
communication with the remote server. See
remote_serial_quit_handler for more detail. */
-static void
-remote_serial_write (const char *str, int len)
+void
+remote_target::remote_serial_write (const char *str, int len)
{
struct remote_state *rs = get_remote_state ();
+ scoped_restore restore_quit_target
+ = make_scoped_restore (&curr_quit_handler_target, this);
scoped_restore restore_quit
- = make_scoped_restore (&quit_handler, remote_serial_quit_handler);
+ = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
rs->got_ctrlc_during_io = 0;
}
int
-putpkt (const char *buf)
+remote_target::putpkt (const char *buf)
{
return putpkt_binary (buf, strlen (buf));
}
+/* Wrapper around remote_target::putpkt to avoid exporting
+ remote_target. */
+
+int
+putpkt (remote_target *remote, const char *buf)
+{
+ return remote->putpkt (buf);
+}
+
/* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF. The string in BUF can be at most
get_remote_packet_size () - 5 to account for the $, # and checksum,
and for a possible /0 if we are debugging (remote_debug) and want
to print the sent packet as a string. */
-static int
-putpkt_binary (const char *buf, int cnt)
+int
+remote_target::putpkt_binary (const char *buf, int cnt)
{
struct remote_state *rs = get_remote_state ();
int i;
/* Come here after finding the start of a frame when we expected an
ack. Do our best to discard the rest of this packet. */
-static void
-skip_frame (void)
+void
+remote_target::skip_frame ()
{
int c;
trailing NULL) on success. (could be extended to return one of the
SERIAL status indications). */
-static long
-read_frame (char **buf_p,
- long *sizeof_buf)
+long
+remote_target::read_frame (char **buf_p, long *sizeof_buf)
{
unsigned char csum;
long bc;
don't have to change all the calls to getpkt to deal with the
return value, because at the moment I don't know what the right
thing to do it for those. */
+
void
-getpkt (char **buf,
- long *sizeof_buf,
- int forever)
+remote_target::getpkt (char **buf, long *sizeof_buf, int forever)
{
getpkt_sane (buf, sizeof_buf, forever);
}
boolean that indicates whether *BUF holds a notification or not
(a regular packet). */
-static int
-getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
- int expecting_notif, int *is_notif)
+int
+remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
+ int forever, int expecting_notif,
+ int *is_notif)
{
struct remote_state *rs = get_remote_state ();
int c;
}
}
-static int
-getpkt_sane (char **buf, long *sizeof_buf, int forever)
+int
+remote_target::getpkt_sane (char **buf, long *sizeof_buf, int forever)
{
return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL);
}
-static int
-getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
- int *is_notif)
+int
+remote_target::getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
+ int *is_notif)
{
return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1,
is_notif);
/* Check whether EVENT is a fork event for the process specified
by the pid passed in DATA, and if it is, kill the fork child. */
-static int
-kill_child_of_pending_fork (QUEUE (stop_reply_p) *q,
- QUEUE_ITER (stop_reply_p) *iter,
- stop_reply_p event,
- void *data)
+int
+remote_kill_child_of_pending_fork (QUEUE (stop_reply_p) *q,
+ QUEUE_ITER (stop_reply_p) *iter,
+ stop_reply_p event,
+ void *data)
{
struct queue_iter_param *param = (struct queue_iter_param *) data;
int parent_pid = *(int *) param->input;
if (is_pending_fork_parent (&event->ws, parent_pid, event->ptid))
{
- struct remote_state *rs = get_remote_state ();
+ remote_target *remote = param->remote;
int child_pid = ptid_get_pid (event->ws.value.related_pid);
int res;
- res = remote_vkill (child_pid, rs);
+ res = remote->remote_vkill (child_pid);
if (res != 0)
error (_("Can't kill fork child process %d"), child_pid);
}
/* Kill any new fork children of process PID that haven't been
processed by follow_fork. */
-static void
-kill_new_fork_children (int pid, struct remote_state *rs)
+void
+remote_target::kill_new_fork_children (int pid)
{
+ remote_state *rs = get_remote_state ();
struct thread_info *thread;
struct notif_client *notif = ¬if_client_stop;
struct queue_iter_param param;
if (is_pending_fork_parent (ws, pid, thread->ptid))
{
- struct remote_state *rs = get_remote_state ();
int child_pid = ptid_get_pid (ws->value.related_pid);
int res;
- res = remote_vkill (child_pid, rs);
+ res = remote_vkill (child_pid);
if (res != 0)
error (_("Can't kill fork child process %d"), child_pid);
}
/* Check for any pending fork events (not reported or processed yet)
in process PID and kill those fork child threads as well. */
remote_notif_get_pending_events (notif);
+ param.remote = this;
param.input = &pid;
param.output = NULL;
- QUEUE_iterate (stop_reply_p, stop_reply_queue,
- kill_child_of_pending_fork, ¶m);
+ QUEUE_iterate (stop_reply_p, rs->stop_reply_queue,
+ remote_kill_child_of_pending_fork, ¶m);
}
\f
kill the child task. We need to do this before killing the
parent task because if this is a vfork then the parent will
be sleeping. */
- kill_new_fork_children (pid, rs);
+ kill_new_fork_children (pid);
- res = remote_vkill (pid, rs);
+ res = remote_vkill (pid);
if (res == 0)
{
target_mourn_inferior (inferior_ptid);
/* Send a kill request to the target using the 'vKill' packet. */
-static int
-remote_vkill (int pid, struct remote_state *rs)
+int
+remote_target::remote_vkill (int pid)
{
if (packet_support (PACKET_vKill) == PACKET_DISABLE)
return -1;
+ remote_state *rs = get_remote_state ();
+
/* Tell the remote target to detach. */
xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
putpkt (rs->buf);
/* Send a kill request to the target using the 'k' packet. */
-static void
-remote_kill_k (void)
+void
+remote_target::remote_kill_k ()
{
/* Catch errors so the user can quit from gdb even when we
aren't on speaking terms with the remote system. */
return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
}
-static void
-extended_remote_disable_randomization (int val)
+void
+remote_target::extended_remote_disable_randomization (int val)
{
struct remote_state *rs = get_remote_state ();
char *reply;
error (_("Bogus QDisableRandomization reply from target: %s"), reply);
}
-static int
-extended_remote_run (const std::string &args)
+int
+remote_target::extended_remote_run (const std::string &args)
{
struct remote_state *rs = get_remote_state ();
int len;
or "QEnvironmentUnsetVariable". VALUE is the variable to be
sent. */
-static void
-send_environment_packet (struct remote_state *rs,
- const char *action,
- const char *packet,
- const char *value)
+void
+remote_target::send_environment_packet (const char *action,
+ const char *packet,
+ const char *value)
{
+ remote_state *rs = get_remote_state ();
+
/* Convert the environment variable to an hex string, which
is the best format to be transmitted over the wire. */
std::string encoded_value = bin2hex ((const gdb_byte *) value,
/* Helper function to handle the QEnvironment* packets. */
-static void
-extended_remote_environment_support (struct remote_state *rs)
+void
+remote_target::extended_remote_environment_support ()
{
+ remote_state *rs = get_remote_state ();
+
if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
{
putpkt ("QEnvironmentReset");
if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
for (const std::string &el : e->user_set_env ())
- send_environment_packet (rs, "set", "QEnvironmentHexEncoded",
+ send_environment_packet ("set", "QEnvironmentHexEncoded",
el.c_str ());
if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
for (const std::string &el : e->user_unset_env ())
- send_environment_packet (rs, "unset", "QEnvironmentUnset", el.c_str ());
+ send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ());
}
/* Helper function to set the current working directory for the
inferior in the remote target. */
-static void
-extended_remote_set_inferior_cwd (struct remote_state *rs)
+void
+remote_target::extended_remote_set_inferior_cwd ()
{
if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
{
const char *inferior_cwd = get_inferior_cwd ();
+ remote_state *rs = get_remote_state ();
if (inferior_cwd != NULL)
{
rs->buf);
}
- extended_remote_environment_support (rs);
+ extended_remote_environment_support ();
- extended_remote_set_inferior_cwd (rs);
+ extended_remote_set_inferior_cwd ();
/* Now restart the remote server. */
run_worked = extended_remote_run (args) != -1;
into remote target. The number of bytes written to the remote
target is returned, or -1 for error. */
-static enum target_xfer_status
-remote_write_qxfer (const char *object_name,
- const char *annex, const gdb_byte *writebuf,
- ULONGEST offset, LONGEST len, ULONGEST *xfered_len,
- struct packet_config *packet)
+target_xfer_status
+remote_target::remote_write_qxfer (const char *object_name,
+ const char *annex, const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len,
+ ULONGEST *xfered_len,
+ struct packet_config *packet)
{
int i, buf_len;
ULONGEST n;
EOF. PACKET is checked and updated to indicate whether the remote
target supports this object. */
-static enum target_xfer_status
-remote_read_qxfer (const char *object_name,
- const char *annex,
- gdb_byte *readbuf, ULONGEST offset, LONGEST len,
- ULONGEST *xfered_len,
- struct packet_config *packet)
+target_xfer_status
+remote_target::remote_read_qxfer (const char *object_name,
+ const char *annex,
+ gdb_byte *readbuf, ULONGEST offset,
+ LONGEST len,
+ ULONGEST *xfered_len,
+ struct packet_config *packet)
{
struct remote_state *rs = get_remote_state ();
LONGEST i, n, packet_len;
return remote_write_bytes (offset, writebuf, len, unit_size,
xfered_len);
else
- return remote_read_bytes (this, offset, readbuf, len, unit_size,
+ return remote_read_bytes (offset, readbuf, len, unit_size,
xfered_len);
}
switch (object)
{
case TARGET_OBJECT_FLASH:
- return remote_flash_write (this, offset, len, xfered_len,
+ return remote_flash_write (offset, len, xfered_len,
writebuf);
default:
static void
packet_command (const char *args, int from_tty)
{
- struct remote_state *rs = get_remote_state ();
+ remote_target *remote = get_current_remote_target ();
- if (!rs->remote_desc)
+ if (remote == nullptr)
error (_("command can only be used with remote target"));
+ remote->packet_command (args, from_tty);
+}
+
+void
+remote_target::packet_command (const char *args, int from_tty)
+{
if (!args)
error (_("remote-packet command requires packet text as argument"));
puts_filtered ("\n");
putpkt (args);
+ remote_state *rs = get_remote_state ();
+
getpkt (&rs->buf, &rs->buf_size, 0);
puts_filtered ("received: ");
print_packet (rs->buf);
the packet buffer and *ATTACHMENT_LEN will be set to the
attachment's length. */
-static int
-remote_hostio_send_command (int command_bytes, int which_packet,
- int *remote_errno, char **attachment,
- int *attachment_len)
+int
+remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
+ int *remote_errno, char **attachment,
+ int *attachment_len)
{
struct remote_state *rs = get_remote_state ();
int ret, bytes_read;
arguments will use. Return 0 on success, or -1 if an error
occurs (and set *REMOTE_ERRNO). */
-static int
-remote_hostio_set_filesystem (struct inferior *inf, int *remote_errno)
+int
+remote_target::remote_hostio_set_filesystem (struct inferior *inf,
+ int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
/* Implementation of to_fileio_open. */
-static int
-remote_hostio_open (struct target_ops *self,
- struct inferior *inf, const char *filename,
- int flags, int mode, int warn_if_slow,
- int *remote_errno)
+int
+remote_target::remote_hostio_open (inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
int flags, int mode, int warn_if_slow,
int *remote_errno)
{
- return remote_hostio_open (this, inf, filename, flags, mode, warn_if_slow,
+ return remote_hostio_open (inf, filename, flags, mode, warn_if_slow,
remote_errno);
}
/* Implementation of to_fileio_pwrite. */
-static int
-remote_hostio_pwrite (struct target_ops *self,
- int fd, const gdb_byte *write_buf, int len,
- ULONGEST offset, int *remote_errno)
+int
+remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
ULONGEST offset, int *remote_errno)
{
- return remote_hostio_pwrite (this, fd, write_buf, len, offset, remote_errno);
+ return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno);
}
/* Helper for the implementation of to_fileio_pread. Read the file
from the remote side with vFile:pread. */
-static int
-remote_hostio_pread_vFile (struct target_ops *self,
- int fd, gdb_byte *read_buf, int len,
- ULONGEST offset, int *remote_errno)
+int
+remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* Implementation of to_fileio_pread. */
-static int
-remote_hostio_pread (struct target_ops *self,
- int fd, gdb_byte *read_buf, int len,
- ULONGEST offset, int *remote_errno)
+int
+remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *remote_errno)
{
int ret;
struct remote_state *rs = get_remote_state ();
cache->bufsize = get_remote_packet_size ();
cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
- ret = remote_hostio_pread_vFile (self, cache->fd, cache->buf, cache->bufsize,
+ ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize,
cache->offset, remote_errno);
if (ret <= 0)
{
remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
ULONGEST offset, int *remote_errno)
{
- return remote_hostio_pread (this, fd, read_buf, len, offset, remote_errno);
+ return remote_hostio_pread (fd, read_buf, len, offset, remote_errno);
}
/* Implementation of to_fileio_close. */
-static int
-remote_hostio_close (struct target_ops *self, int fd, int *remote_errno)
+int
+remote_target::remote_hostio_close (int fd, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
int
remote_target::fileio_close (int fd, int *remote_errno)
{
- return remote_hostio_close (this, fd, remote_errno);
+ return remote_hostio_close (fd, remote_errno);
}
/* Implementation of to_fileio_unlink. */
-static int
-remote_hostio_unlink (struct target_ops *self,
- struct inferior *inf, const char *filename,
- int *remote_errno)
+int
+remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
+ int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
remote_target::fileio_unlink (struct inferior *inf, const char *filename,
int *remote_errno)
{
- return remote_hostio_unlink (this, inf, filename, remote_errno);
+ return remote_hostio_unlink (inf, filename, remote_errno);
}
/* Implementation of to_fileio_readlink. */
/* Try opening a file to probe support. The supplied
filename is irrelevant, we only care about whether
the stub recognizes the packet or not. */
- fd = remote_hostio_open (this, NULL, "just probing",
+ fd = remote_hostio_open (NULL, "just probing",
FILEIO_O_RDONLY, 0700, 0,
&remote_errno);
if (fd >= 0)
- remote_hostio_close (this, fd, &remote_errno);
+ remote_hostio_close (fd, &remote_errno);
ps = packet_support (PACKET_vFile_open);
}
class scoped_remote_fd
{
public:
- explicit scoped_remote_fd (int fd)
- : m_fd (fd)
+ scoped_remote_fd (remote_target *remote, int fd)
+ : m_remote (remote), m_fd (fd)
{
}
try
{
int remote_errno;
- remote_hostio_close (find_target_at (process_stratum),
- m_fd, &remote_errno);
+ m_remote->remote_hostio_close (m_fd, &remote_errno);
}
catch (...)
{
}
private:
+ /* The remote target. */
+ remote_target *m_remote;
+
/* The owned remote I/O file descriptor. */
int m_fd;
};
void
remote_file_put (const char *local_file, const char *remote_file, int from_tty)
{
+ remote_target *remote = get_current_remote_target ();
+
+ if (remote == nullptr)
+ error (_("command can only be used with remote target"));
+
+ remote->remote_file_put (local_file, remote_file, from_tty);
+}
+
+void
+remote_target::remote_file_put (const char *local_file, const char *remote_file,
+ int from_tty)
+{
struct cleanup *back_to;
int retcode, remote_errno, bytes, io_size;
gdb_byte *buffer;
int bytes_in_buffer;
int saw_eof;
ULONGEST offset;
- struct remote_state *rs = get_remote_state ();
-
- if (!rs->remote_desc)
- error (_("command can only be used with remote target"));
gdb_file_up file = gdb_fopen_cloexec (local_file, "rb");
if (file == NULL)
perror_with_name (local_file);
scoped_remote_fd fd
- (remote_hostio_open (find_target_at (process_stratum), NULL,
- remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
- | FILEIO_O_TRUNC),
- 0700, 0, &remote_errno));
+ (this, remote_hostio_open (NULL,
+ remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
+ | FILEIO_O_TRUNC),
+ 0700, 0, &remote_errno));
if (fd.get () == -1)
remote_hostio_error (remote_errno);
bytes += bytes_in_buffer;
bytes_in_buffer = 0;
- retcode = remote_hostio_pwrite (find_target_at (process_stratum),
- fd.get (), buffer, bytes,
+ retcode = remote_hostio_pwrite (fd.get (), buffer, bytes,
offset, &remote_errno);
if (retcode < 0)
offset += retcode;
}
- if (remote_hostio_close (find_target_at (process_stratum),
- fd.release (), &remote_errno))
+ if (remote_hostio_close (fd.release (), &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
void
remote_file_get (const char *remote_file, const char *local_file, int from_tty)
{
+ remote_target *remote = get_current_remote_target ();
+
+ if (remote == nullptr)
+ error (_("command can only be used with remote target"));
+
+ remote->remote_file_get (remote_file, local_file, from_tty);
+}
+
+void
+remote_target::remote_file_get (const char *remote_file, const char *local_file,
+ int from_tty)
+{
struct cleanup *back_to;
int remote_errno, bytes, io_size;
gdb_byte *buffer;
ULONGEST offset;
- struct remote_state *rs = get_remote_state ();
-
- if (!rs->remote_desc)
- error (_("command can only be used with remote target"));
scoped_remote_fd fd
- (remote_hostio_open (find_target_at (process_stratum), NULL,
- remote_file, FILEIO_O_RDONLY, 0, 0,
- &remote_errno));
+ (this, remote_hostio_open (NULL,
+ remote_file, FILEIO_O_RDONLY, 0, 0,
+ &remote_errno));
if (fd.get () == -1)
remote_hostio_error (remote_errno);
offset = 0;
while (1)
{
- bytes = remote_hostio_pread (find_target_at (process_stratum),
- fd.get (), buffer, io_size, offset,
+ bytes = remote_hostio_pread (fd.get (), buffer, io_size, offset,
&remote_errno);
if (bytes == 0)
/* Success, but no bytes, means end-of-file. */
perror_with_name (local_file);
}
- if (remote_hostio_close (find_target_at (process_stratum),
- fd.release (), &remote_errno))
+ if (remote_hostio_close (fd.release (), &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
void
remote_file_delete (const char *remote_file, int from_tty)
{
- int retcode, remote_errno;
- struct remote_state *rs = get_remote_state ();
+ remote_target *remote = get_current_remote_target ();
- if (!rs->remote_desc)
+ if (remote == nullptr)
error (_("command can only be used with remote target"));
- retcode = remote_hostio_unlink (find_target_at (process_stratum),
- NULL, remote_file, &remote_errno);
+ remote->remote_file_delete (remote_file, from_tty);
+}
+
+void
+remote_target::remote_file_delete (const char *remote_file, int from_tty)
+{
+ int retcode, remote_errno;
+
+ retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno);
if (retcode == -1)
remote_hostio_error (remote_errno);
/* Recursive routine to walk through command list including loops, and
download packets for each command. */
-static void
-remote_download_command_source (int num, ULONGEST addr,
- struct command_line *cmds)
+void
+remote_target::remote_download_command_source (int num, ULONGEST addr,
+ struct command_line *cmds)
{
struct remote_state *rs = get_remote_state ();
struct command_line *cmd;
/* Reset our idea of our target's btrace configuration. */
static void
-remote_btrace_reset (void)
+remote_btrace_reset (remote_state *rs)
{
- struct remote_state *rs = get_remote_state ();
-
memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
}
/* Synchronize the configuration with the target. */
-static void
-btrace_sync_conf (const struct btrace_config *conf)
+void
+remote_target::btrace_sync_conf (const btrace_config *conf)
{
struct packet_config *packet;
struct remote_state *rs;
/* Maybe reopen target btrace. */
-static void
-remote_btrace_maybe_reopen (void)
+void
+remote_target::remote_btrace_maybe_reopen ()
{
struct remote_state *rs = get_remote_state ();
struct thread_info *tp;
struct remote_state *rs = get_remote_state ();
if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs);
+ remote_vcont_probe ();
return rs->supports_vCont.s && rs->supports_vCont.S;
}
static void
remote_async_inferior_event_handler (gdb_client_data data)
{
- inferior_event_handler (INF_REG_EVENT, NULL);
+ inferior_event_handler (INF_REG_EVENT, data);
}
void
/* If there are pending events in the stop reply queue tell the
event loop to process them. */
- if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
- mark_async_event_handler (remote_async_inferior_event_token);
+ if (!QUEUE_is_empty (stop_reply_p, rs->stop_reply_queue))
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
/* For simplicity, below we clear the pending events token
without remembering whether it is marked, so here we always
mark it. If there's actually no pending notification to
/* If the core is disabling async, it doesn't want to be
disturbed with target events. Clear all async event sources
too. */
- clear_async_event_handler (remote_async_inferior_event_token);
+ clear_async_event_handler (rs->remote_async_inferior_event_token);
if (target_is_non_stop_p ())
clear_async_event_handler (rs->notif_state->get_pending_events_token);
}
static void
remote_new_objfile (struct objfile *objfile)
{
- struct remote_state *rs = get_remote_state ();
+ remote_target *remote = get_current_remote_target ();
- if (rs->remote_desc != 0) /* Have a remote connection. */
- remote_check_symbols ();
+ if (remote != NULL) /* Have a remote connection. */
+ remote->remote_check_symbols ();
}
/* Pull all the tracepoints defined on the target and create local
"is %s.\n"), value);
}
+/* Return true if the vCont;r action is supported by the remote
+ stub. */
+
+bool
+remote_target::vcont_r_supported ()
+{
+ if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
+ remote_vcont_probe ();
+
+ return (packet_support (PACKET_vCont) == PACKET_ENABLE
+ && get_remote_state ()->supports_vCont.r);
+}
+
/* The "set/show range-stepping" set hook. */
static void
set_range_stepping (const char *ignore_args, int from_tty,
struct cmd_list_element *c)
{
- struct remote_state *rs = get_remote_state ();
-
- /* Whene enabling, check whether range stepping is actually
- supported by the target, and warn if not. */
+ /* When enabling, check whether range stepping is actually supported
+ by the target, and warn if not. */
if (use_range_stepping)
{
- if (rs->remote_desc != NULL)
- {
- if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs);
-
- if (packet_support (PACKET_vCont) == PACKET_ENABLE
- && rs->supports_vCont.r)
- return;
- }
-
- warning (_("Range stepping is not supported by the current target"));
+ remote_target *remote = get_current_remote_target ();
+ if (remote == NULL
+ || !remote->vcont_r_supported ())
+ warning (_("Range stepping is not supported by the current target"));
}
}
= register_program_space_data_with_cleanup (NULL,
remote_pspace_data_cleanup);
- /* Initialize the per-target state. At the moment there is only one
- of these, not one per target. Only one target is active at a
- time. */
- remote_state = new struct remote_state ();
-
add_target (remote_target_info, remote_target::open);
add_target (extended_remote_target_info, extended_remote_target::open);
init_remote_threadtests ();
#endif
- stop_reply_queue = QUEUE_alloc (stop_reply_p, stop_reply_xfree);
/* set/show remote ... */
add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
projects / external / binutils.git / commitdiff