"; else if (remote_multi_process_p (rs)) if (ptid.lwp () == 0) return normal_pid_to_str (ptid); else return string_printf ("Thread %d.%ld", ptid.pid (), ptid.lwp ()); else return string_printf ("Thread %ld", ptid.lwp ()); } } /* Get the address of the thread local variable in OBJFILE which is stored at OFFSET within the thread local storage for thread PTID. */ CORE_ADDR remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset) { if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); char *p = rs->buf.data (); char *endp = p + get_remote_packet_size (); enum packet_result result; strcpy (p, "qGetTLSAddr:"); p += strlen (p); p = write_ptid (p, endp, ptid); *p++ = ','; p += hexnumstr (p, offset); *p++ = ','; p += hexnumstr (p, lm); *p++ = '\0'; putpkt (rs->buf); getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]); if (result == PACKET_OK) { ULONGEST addr; unpack_varlen_hex (rs->buf.data (), &addr); return addr; } else if (result == PACKET_UNKNOWN) throw_error (TLS_GENERIC_ERROR, _("Remote target doesn't support qGetTLSAddr packet")); else throw_error (TLS_GENERIC_ERROR, _("Remote target failed to process qGetTLSAddr request")); } else throw_error (TLS_GENERIC_ERROR, _("TLS not supported or disabled on this target")); /* Not reached. */ return 0; } /* Provide thread local base, i.e. Thread Information Block address. Returns 1 if ptid is found and thread_local_base is non zero. */ bool remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) { if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); char *p = rs->buf.data (); char *endp = p + get_remote_packet_size (); enum packet_result result; strcpy (p, "qGetTIBAddr:"); p += strlen (p); p = write_ptid (p, endp, ptid); *p++ = '\0'; putpkt (rs->buf); getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTIBAddr]); if (result == PACKET_OK) { ULONGEST val; unpack_varlen_hex (rs->buf.data (), &val); if (addr) *addr = (CORE_ADDR) val; return true; } else if (result == PACKET_UNKNOWN) error (_("Remote target doesn't support qGetTIBAddr packet")); else error (_("Remote target failed to process qGetTIBAddr request")); } else error (_("qGetTIBAddr not supported or disabled on this target")); /* Not reached. */ return false; } /* Support for inferring a target description based on the current architecture and the size of a 'g' packet. While the 'g' packet can have any size (since optional registers can be left off the end), some sizes are easily recognizable given knowledge of the approximate architecture. */ struct remote_g_packet_guess { remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_) : bytes (bytes_), tdesc (tdesc_) { } int bytes; const struct target_desc *tdesc; }; struct remote_g_packet_data : public allocate_on_obstack { std::vector guesses; }; static struct gdbarch_data *remote_g_packet_data_handle; static void * remote_g_packet_data_init (struct obstack *obstack) { return new (obstack) remote_g_packet_data; } void register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes, const struct target_desc *tdesc) { struct remote_g_packet_data *data = ((struct remote_g_packet_data *) gdbarch_data (gdbarch, remote_g_packet_data_handle)); gdb_assert (tdesc != NULL); for (const remote_g_packet_guess &guess : data->guesses) if (guess.bytes == bytes) internal_error (__FILE__, __LINE__, _("Duplicate g packet description added for size %d"), bytes); data->guesses.emplace_back (bytes, tdesc); } /* Return true if remote_read_description would do anything on this target and architecture, false otherwise. */ static bool remote_read_description_p (struct target_ops *target) { struct remote_g_packet_data *data = ((struct remote_g_packet_data *) gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); return !data->guesses.empty (); } const struct target_desc * remote_target::read_description () { struct remote_g_packet_data *data = ((struct remote_g_packet_data *) gdbarch_data (target_gdbarch (), remote_g_packet_data_handle)); /* Do not try this during initial connection, when we do not know whether there is a running but stopped thread. */ if (!target_has_execution () || inferior_ptid == null_ptid) return beneath ()->read_description (); if (!data->guesses.empty ()) { int bytes = send_g_packet (); for (const remote_g_packet_guess &guess : data->guesses) if (guess.bytes == bytes) return guess.tdesc; /* We discard the g packet. A minor optimization would be to hold on to it, and fill the register cache once we have selected an architecture, but it's too tricky to do safely. */ } return beneath ()->read_description (); } /* Remote file transfer support. This is host-initiated I/O, not target-initiated; for target-initiated, see remote-fileio.c. */ /* If *LEFT is at least the length of STRING, copy STRING to *BUFFER, update *BUFFER to point to the new end of the buffer, and decrease *LEFT. Otherwise raise an error. */ static void remote_buffer_add_string (char **buffer, int *left, const char *string) { int len = strlen (string); if (len > *left) error (_("Packet too long for target.")); memcpy (*buffer, string, len); *buffer += len; *left -= len; /* NUL-terminate the buffer as a convenience, if there is room. */ if (*left) **buffer = '\0'; } /* If *LEFT is large enough, hex encode LEN bytes from BYTES into *BUFFER, update *BUFFER to point to the new end of the buffer, and decrease *LEFT. Otherwise raise an error. */ static void remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes, int len) { if (2 * len > *left) error (_("Packet too long for target.")); bin2hex (bytes, *buffer, len); *buffer += 2 * len; *left -= 2 * len; /* NUL-terminate the buffer as a convenience, if there is room. */ if (*left) **buffer = '\0'; } /* If *LEFT is large enough, convert VALUE to hex and add it to *BUFFER, update *BUFFER to point to the new end of the buffer, and decrease *LEFT. Otherwise raise an error. */ static void remote_buffer_add_int (char **buffer, int *left, ULONGEST value) { int len = hexnumlen (value); if (len > *left) error (_("Packet too long for target.")); hexnumstr (*buffer, value); *buffer += len; *left -= len; /* NUL-terminate the buffer as a convenience, if there is room. */ if (*left) **buffer = '\0'; } /* Parse an I/O result packet from BUFFER. Set RETCODE to the return value, *REMOTE_ERRNO to the remote error number or zero if none was included, and *ATTACHMENT to point to the start of the annex if any. The length of the packet isn't needed here; there may be NUL bytes in BUFFER, but they will be after *ATTACHMENT. Return 0 if the packet could be parsed, -1 if it could not. If -1 is returned, the other variables may not be initialized. */ static int remote_hostio_parse_result (const char *buffer, int *retcode, int *remote_errno, const char **attachment) { char *p, *p2; *remote_errno = 0; *attachment = NULL; if (buffer[0] != 'F') return -1; errno = 0; *retcode = strtol (&buffer[1], &p, 16); if (errno != 0 || p == &buffer[1]) return -1; /* Check for ",errno". */ if (*p == ',') { errno = 0; *remote_errno = strtol (p + 1, &p2, 16); if (errno != 0 || p + 1 == p2) return -1; p = p2; } /* Check for ";attachment". If there is no attachment, the packet should end here. */ if (*p == ';') { *attachment = p + 1; return 0; } else if (*p == '\0') return 0; else return -1; } /* Send a prepared I/O packet to the target and read its response. The prepared packet is in the global RS->BUF before this function is called, and the answer is there when we return. COMMAND_BYTES is the length of the request to send, which may include binary data. WHICH_PACKET is the packet configuration to check before attempting a packet. If an error occurs, *REMOTE_ERRNO is set to the error number and -1 is returned. Otherwise the value returned by the function is returned. ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an attachment is expected; an error will be reported if there's a mismatch. If one is found, *ATTACHMENT will be set to point into the packet buffer and *ATTACHMENT_LEN will be set to the attachment's length. */ int remote_target::remote_hostio_send_command (int command_bytes, int which_packet, int *remote_errno, const char **attachment, int *attachment_len) { struct remote_state *rs = get_remote_state (); int ret, bytes_read; const char *attachment_tmp; if (packet_support (which_packet) == PACKET_DISABLE) { *remote_errno = FILEIO_ENOSYS; return -1; } putpkt_binary (rs->buf.data (), command_bytes); bytes_read = getpkt_sane (&rs->buf, 0); /* If it timed out, something is wrong. Don't try to parse the buffer. */ if (bytes_read < 0) { *remote_errno = FILEIO_EINVAL; return -1; } switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet])) { case PACKET_ERROR: *remote_errno = FILEIO_EINVAL; return -1; case PACKET_UNKNOWN: *remote_errno = FILEIO_ENOSYS; return -1; case PACKET_OK: break; } if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno, &attachment_tmp)) { *remote_errno = FILEIO_EINVAL; return -1; } /* Make sure we saw an attachment if and only if we expected one. */ if ((attachment_tmp == NULL && attachment != NULL) || (attachment_tmp != NULL && attachment == NULL)) { *remote_errno = FILEIO_EINVAL; return -1; } /* If an attachment was found, it must point into the packet buffer; work out how many bytes there were. */ if (attachment_tmp != NULL) { *attachment = attachment_tmp; *attachment_len = bytes_read - (*attachment - rs->buf.data ()); } return ret; } /* See declaration.h. */ void readahead_cache::invalidate () { this->fd = -1; } /* See declaration.h. */ void readahead_cache::invalidate_fd (int fd) { if (this->fd == fd) this->fd = -1; } /* Set the filesystem remote_hostio functions that take FILENAME arguments will use. Return 0 on success, or -1 if an error occurs (and set *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; char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; char arg[9]; int ret; if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) return 0; if (rs->fs_pid != -1 && required_pid == rs->fs_pid) return 0; remote_buffer_add_string (&p, &left, "vFile:setfs:"); xsnprintf (arg, sizeof (arg), "%x", required_pid); remote_buffer_add_string (&p, &left, arg); ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs, remote_errno, NULL, NULL); if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) return 0; if (ret == 0) rs->fs_pid = required_pid; return ret; } /* Implementation of to_fileio_open. */ 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.data (); int left = get_remote_packet_size () - 1; if (warn_if_slow) { static int warning_issued = 0; printf_unfiltered (_("Reading %s from remote target...\n"), filename); if (!warning_issued) { warning (_("File transfers from remote targets can be slow." " Use \"set sysroot\" to access files locally" " instead.")); warning_issued = 1; } } if (remote_hostio_set_filesystem (inf, remote_errno) != 0) return -1; remote_buffer_add_string (&p, &left, "vFile:open:"); remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, strlen (filename)); remote_buffer_add_string (&p, &left, ","); remote_buffer_add_int (&p, &left, flags); remote_buffer_add_string (&p, &left, ","); remote_buffer_add_int (&p, &left, mode); return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open, remote_errno, NULL, NULL); } int remote_target::fileio_open (struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, int *remote_errno) { return remote_hostio_open (inf, filename, flags, mode, warn_if_slow, remote_errno); } /* Implementation of to_fileio_pwrite. */ 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.data (); int left = get_remote_packet_size (); int out_len; rs->readahead_cache.invalidate_fd (fd); remote_buffer_add_string (&p, &left, "vFile:pwrite:"); remote_buffer_add_int (&p, &left, fd); remote_buffer_add_string (&p, &left, ","); remote_buffer_add_int (&p, &left, offset); remote_buffer_add_string (&p, &left, ","); p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len, (get_remote_packet_size () - (p - rs->buf.data ()))); return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite, remote_errno, NULL, NULL); } int remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *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. */ 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.data (); const char *attachment; int left = get_remote_packet_size (); int ret, attachment_len; int read_len; remote_buffer_add_string (&p, &left, "vFile:pread:"); remote_buffer_add_int (&p, &left, fd); remote_buffer_add_string (&p, &left, ","); remote_buffer_add_int (&p, &left, len); remote_buffer_add_string (&p, &left, ","); remote_buffer_add_int (&p, &left, offset); ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread, remote_errno, &attachment, &attachment_len); if (ret < 0) return ret; read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, read_buf, len); if (read_len != ret) error (_("Read returned %d, but %d bytes."), ret, (int) read_len); return ret; } /* See declaration.h. */ int readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset) { if (this->fd == fd && this->offset <= offset && offset < this->offset + this->bufsize) { ULONGEST max = this->offset + this->bufsize; if (offset + len > max) len = max - offset; memcpy (read_buf, this->buf + offset - this->offset, len); return len; } return 0; } /* Implementation of to_fileio_pread. */ 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 (); readahead_cache *cache = &rs->readahead_cache; ret = cache->pread (fd, read_buf, len, offset); if (ret > 0) { cache->hit_count++; remote_debug_printf ("readahead cache hit %s", pulongest (cache->hit_count)); return ret; } cache->miss_count++; remote_debug_printf ("readahead cache miss %s", pulongest (cache->miss_count)); cache->fd = fd; cache->offset = offset; cache->bufsize = get_remote_packet_size (); cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize); ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize, cache->offset, remote_errno); if (ret <= 0) { cache->invalidate_fd (fd); return ret; } cache->bufsize = ret; return cache->pread (fd, read_buf, len, offset); } int remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *remote_errno) { return remote_hostio_pread (fd, read_buf, len, offset, remote_errno); } /* Implementation of to_fileio_close. */ int remote_target::remote_hostio_close (int fd, int *remote_errno) { struct remote_state *rs = get_remote_state (); char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; rs->readahead_cache.invalidate_fd (fd); remote_buffer_add_string (&p, &left, "vFile:close:"); remote_buffer_add_int (&p, &left, fd); return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close, remote_errno, NULL, NULL); } int remote_target::fileio_close (int fd, int *remote_errno) { return remote_hostio_close (fd, remote_errno); } /* Implementation of to_fileio_unlink. */ 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.data (); int left = get_remote_packet_size () - 1; if (remote_hostio_set_filesystem (inf, remote_errno) != 0) return -1; remote_buffer_add_string (&p, &left, "vFile:unlink:"); remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, strlen (filename)); return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink, remote_errno, NULL, NULL); } int remote_target::fileio_unlink (struct inferior *inf, const char *filename, int *remote_errno) { return remote_hostio_unlink (inf, filename, remote_errno); } /* Implementation of to_fileio_readlink. */ gdb::optional remote_target::fileio_readlink (struct inferior *inf, const char *filename, int *remote_errno) { struct remote_state *rs = get_remote_state (); char *p = rs->buf.data (); const char *attachment; int left = get_remote_packet_size (); int len, attachment_len; int read_len; if (remote_hostio_set_filesystem (inf, remote_errno) != 0) return {}; remote_buffer_add_string (&p, &left, "vFile:readlink:"); remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, strlen (filename)); len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink, remote_errno, &attachment, &attachment_len); if (len < 0) return {}; std::string ret (len, '\0'); read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, (gdb_byte *) &ret[0], len); if (read_len != len) error (_("Readlink returned %d, but %d bytes."), len, read_len); return ret; } /* Implementation of to_fileio_fstat. */ int remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno) { struct remote_state *rs = get_remote_state (); char *p = rs->buf.data (); int left = get_remote_packet_size (); int attachment_len, ret; const char *attachment; struct fio_stat fst; int read_len; remote_buffer_add_string (&p, &left, "vFile:fstat:"); remote_buffer_add_int (&p, &left, fd); ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat, remote_errno, &attachment, &attachment_len); if (ret < 0) { if (*remote_errno != FILEIO_ENOSYS) return ret; /* Strictly we should return -1, ENOSYS here, but when "set sysroot remote:" was implemented in August 2008 BFD's need for a stat function was sidestepped with this hack. This was not remedied until March 2015 so we retain the previous behavior to avoid breaking compatibility. Note that the memset is a March 2015 addition; older GDBs set st_size *and nothing else* so the structure would have garbage in all other fields. This might break something but retaining the previous behavior here would be just too wrong. */ memset (st, 0, sizeof (struct stat)); st->st_size = INT_MAX; return 0; } read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len, (gdb_byte *) &fst, sizeof (fst)); if (read_len != ret) error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len); if (read_len != sizeof (fst)) error (_("vFile:fstat returned %d bytes, but expecting %d."), read_len, (int) sizeof (fst)); remote_fileio_to_host_stat (&fst, st); return 0; } /* Implementation of to_filesystem_is_local. */ bool remote_target::filesystem_is_local () { /* Valgrind GDB presents itself as a remote target but works on the local filesystem: it does not implement remote get and users are not expected to set a sysroot. To handle this case we treat the remote filesystem as local if the sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub does not support vFile:open. */ if (gdb_sysroot == TARGET_SYSROOT_PREFIX) { enum packet_support ps = packet_support (PACKET_vFile_open); if (ps == PACKET_SUPPORT_UNKNOWN) { int fd, remote_errno; /* 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 (NULL, "just probing", FILEIO_O_RDONLY, 0700, 0, &remote_errno); if (fd >= 0) remote_hostio_close (fd, &remote_errno); ps = packet_support (PACKET_vFile_open); } if (ps == PACKET_DISABLE) { static int warning_issued = 0; if (!warning_issued) { warning (_("remote target does not support file" " transfer, attempting to access files" " from local filesystem.")); warning_issued = 1; } return true; } } return false; } static int remote_fileio_errno_to_host (int errnum) { switch (errnum) { case FILEIO_EPERM: return EPERM; case FILEIO_ENOENT: return ENOENT; case FILEIO_EINTR: return EINTR; case FILEIO_EIO: return EIO; case FILEIO_EBADF: return EBADF; case FILEIO_EACCES: return EACCES; case FILEIO_EFAULT: return EFAULT; case FILEIO_EBUSY: return EBUSY; case FILEIO_EEXIST: return EEXIST; case FILEIO_ENODEV: return ENODEV; case FILEIO_ENOTDIR: return ENOTDIR; case FILEIO_EISDIR: return EISDIR; case FILEIO_EINVAL: return EINVAL; case FILEIO_ENFILE: return ENFILE; case FILEIO_EMFILE: return EMFILE; case FILEIO_EFBIG: return EFBIG; case FILEIO_ENOSPC: return ENOSPC; case FILEIO_ESPIPE: return ESPIPE; case FILEIO_EROFS: return EROFS; case FILEIO_ENOSYS: return ENOSYS; case FILEIO_ENAMETOOLONG: return ENAMETOOLONG; } return -1; } static char * remote_hostio_error (int errnum) { int host_error = remote_fileio_errno_to_host (errnum); if (host_error == -1) error (_("Unknown remote I/O error %d"), errnum); else error (_("Remote I/O error: %s"), safe_strerror (host_error)); } /* A RAII wrapper around a remote file descriptor. */ class scoped_remote_fd { public: scoped_remote_fd (remote_target *remote, int fd) : m_remote (remote), m_fd (fd) { } ~scoped_remote_fd () { if (m_fd != -1) { try { int remote_errno; m_remote->remote_hostio_close (m_fd, &remote_errno); } catch (...) { /* Swallow exception before it escapes the dtor. If something goes wrong, likely the connection is gone, and there's nothing else that can be done. */ } } } DISABLE_COPY_AND_ASSIGN (scoped_remote_fd); /* Release ownership of the file descriptor, and return it. */ ATTRIBUTE_UNUSED_RESULT int release () noexcept { int fd = m_fd; m_fd = -1; return fd; } /* Return the owned file descriptor. */ int get () const noexcept { return m_fd; } 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) { int retcode, remote_errno, bytes, io_size; int bytes_in_buffer; int saw_eof; ULONGEST offset; gdb_file_up file = gdb_fopen_cloexec (local_file, "rb"); if (file == NULL) perror_with_name (local_file); scoped_remote_fd fd (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); /* Send up to this many bytes at once. They won't all fit in the remote packet limit, so we'll transfer slightly fewer. */ io_size = get_remote_packet_size (); gdb::byte_vector buffer (io_size); bytes_in_buffer = 0; saw_eof = 0; offset = 0; while (bytes_in_buffer || !saw_eof) { if (!saw_eof) { bytes = fread (buffer.data () + bytes_in_buffer, 1, io_size - bytes_in_buffer, file.get ()); if (bytes == 0) { if (ferror (file.get ())) error (_("Error reading %s."), local_file); else { /* EOF. Unless there is something still in the buffer from the last iteration, we are done. */ saw_eof = 1; if (bytes_in_buffer == 0) break; } } } else bytes = 0; bytes += bytes_in_buffer; bytes_in_buffer = 0; retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes, offset, &remote_errno); if (retcode < 0) remote_hostio_error (remote_errno); else if (retcode == 0) error (_("Remote write of %d bytes returned 0!"), bytes); else if (retcode < bytes) { /* Short write. Save the rest of the read data for the next write. */ bytes_in_buffer = bytes - retcode; memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer); } offset += retcode; } if (remote_hostio_close (fd.release (), &remote_errno)) remote_hostio_error (remote_errno); if (from_tty) printf_filtered (_("Successfully sent file \"%s\".\n"), local_file); } 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) { int remote_errno, bytes, io_size; ULONGEST offset; scoped_remote_fd fd (this, remote_hostio_open (NULL, remote_file, FILEIO_O_RDONLY, 0, 0, &remote_errno)); if (fd.get () == -1) remote_hostio_error (remote_errno); gdb_file_up file = gdb_fopen_cloexec (local_file, "wb"); if (file == NULL) perror_with_name (local_file); /* Send up to this many bytes at once. They won't all fit in the remote packet limit, so we'll transfer slightly fewer. */ io_size = get_remote_packet_size (); gdb::byte_vector buffer (io_size); offset = 0; while (1) { bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset, &remote_errno); if (bytes == 0) /* Success, but no bytes, means end-of-file. */ break; if (bytes == -1) remote_hostio_error (remote_errno); offset += bytes; bytes = fwrite (buffer.data (), 1, bytes, file.get ()); if (bytes == 0) perror_with_name (local_file); } if (remote_hostio_close (fd.release (), &remote_errno)) remote_hostio_error (remote_errno); if (from_tty) printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file); } void remote_file_delete (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_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); if (from_tty) printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file); } static void remote_put_command (const char *args, int from_tty) { if (args == NULL) error_no_arg (_("file to put")); gdb_argv argv (args); if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) error (_("Invalid parameters to remote put")); remote_file_put (argv[0], argv[1], from_tty); } static void remote_get_command (const char *args, int from_tty) { if (args == NULL) error_no_arg (_("file to get")); gdb_argv argv (args); if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL) error (_("Invalid parameters to remote get")); remote_file_get (argv[0], argv[1], from_tty); } static void remote_delete_command (const char *args, int from_tty) { if (args == NULL) error_no_arg (_("file to delete")); gdb_argv argv (args); if (argv[0] == NULL || argv[1] != NULL) error (_("Invalid parameters to remote delete")); remote_file_delete (argv[0], from_tty); } bool remote_target::can_execute_reverse () { if (packet_support (PACKET_bs) == PACKET_ENABLE || packet_support (PACKET_bc) == PACKET_ENABLE) return true; else return false; } bool remote_target::supports_non_stop () { return true; } bool remote_target::supports_disable_randomization () { /* Only supported in extended mode. */ return false; } bool remote_target::supports_multi_process () { struct remote_state *rs = get_remote_state (); return remote_multi_process_p (rs); } static int remote_supports_cond_tracepoints () { return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE; } bool remote_target::supports_evaluation_of_breakpoint_conditions () { return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE; } static int remote_supports_fast_tracepoints () { return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE; } static int remote_supports_static_tracepoints () { return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE; } static int remote_supports_install_in_trace () { return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE; } bool remote_target::supports_enable_disable_tracepoint () { return (packet_support (PACKET_EnableDisableTracepoints_feature) == PACKET_ENABLE); } bool remote_target::supports_string_tracing () { return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE; } bool remote_target::can_run_breakpoint_commands () { return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE; } void remote_target::trace_init () { struct remote_state *rs = get_remote_state (); putpkt ("QTinit"); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Target does not support this command.")); } /* Recursive routine to walk through command list including loops, and download packets for each command. */ 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; for (cmd = cmds; cmd; cmd = cmd->next) { QUIT; /* Allow user to bail out with ^C. */ strcpy (rs->buf.data (), "QTDPsrc:"); encode_source_string (num, addr, "cmd", cmd->line, rs->buf.data () + strlen (rs->buf.data ()), rs->buf.size () - strlen (rs->buf.data ())); putpkt (rs->buf); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); if (cmd->control_type == while_control || cmd->control_type == while_stepping_control) { remote_download_command_source (num, addr, cmd->body_list_0.get ()); QUIT; /* Allow user to bail out with ^C. */ strcpy (rs->buf.data (), "QTDPsrc:"); encode_source_string (num, addr, "cmd", "end", rs->buf.data () + strlen (rs->buf.data ()), rs->buf.size () - strlen (rs->buf.data ())); putpkt (rs->buf); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } } } void remote_target::download_tracepoint (struct bp_location *loc) { CORE_ADDR tpaddr; char addrbuf[40]; std::vector tdp_actions; std::vector stepping_actions; char *pkt; struct breakpoint *b = loc->owner; struct tracepoint *t = (struct tracepoint *) b; struct remote_state *rs = get_remote_state (); int ret; const char *err_msg = _("Tracepoint packet too large for target."); size_t size_left; /* We use a buffer other than rs->buf because we'll build strings across multiple statements, and other statements in between could modify rs->buf. */ gdb::char_vector buf (get_remote_packet_size ()); encode_actions_rsp (loc, &tdp_actions, &stepping_actions); tpaddr = loc->address; strcpy (addrbuf, phex (tpaddr, sizeof (CORE_ADDR))); ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x", b->number, addrbuf, /* address */ (b->enable_state == bp_enabled ? 'E' : 'D'), t->step_count, t->pass_count); if (ret < 0 || ret >= buf.size ()) error ("%s", err_msg); /* Fast tracepoints are mostly handled by the target, but we can tell the target how big of an instruction block should be moved around. */ if (b->type == bp_fast_tracepoint) { /* Only test for support at download time; we may not know target capabilities at definition time. */ if (remote_supports_fast_tracepoints ()) { if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr, NULL)) { size_left = buf.size () - strlen (buf.data ()); ret = snprintf (buf.data () + strlen (buf.data ()), size_left, ":F%x", gdb_insn_length (loc->gdbarch, tpaddr)); if (ret < 0 || ret >= size_left) error ("%s", err_msg); } else /* If it passed validation at definition but fails now, something is very wrong. */ internal_error (__FILE__, __LINE__, _("Fast tracepoint not " "valid during download")); } else /* Fast tracepoints are functionally identical to regular tracepoints, so don't take lack of support as a reason to give up on the trace run. */ warning (_("Target does not support fast tracepoints, " "downloading %d as regular tracepoint"), b->number); } else if (b->type == bp_static_tracepoint) { /* Only test for support at download time; we may not know target capabilities at definition time. */ if (remote_supports_static_tracepoints ()) { struct static_tracepoint_marker marker; if (target_static_tracepoint_marker_at (tpaddr, &marker)) { size_left = buf.size () - strlen (buf.data ()); ret = snprintf (buf.data () + strlen (buf.data ()), size_left, ":S"); if (ret < 0 || ret >= size_left) error ("%s", err_msg); } else error (_("Static tracepoint not valid during download")); } else /* Fast tracepoints are functionally identical to regular tracepoints, so don't take lack of support as a reason to give up on the trace run. */ error (_("Target does not support static tracepoints")); } /* If the tracepoint has a conditional, make it into an agent expression and append to the definition. */ if (loc->cond) { /* Only test support at download time, we may not know target capabilities at definition time. */ if (remote_supports_cond_tracepoints ()) { agent_expr_up aexpr = gen_eval_for_expr (tpaddr, loc->cond.get ()); size_left = buf.size () - strlen (buf.data ()); ret = snprintf (buf.data () + strlen (buf.data ()), size_left, ":X%x,", aexpr->len); if (ret < 0 || ret >= size_left) error ("%s", err_msg); size_left = buf.size () - strlen (buf.data ()); /* Two bytes to encode each aexpr byte, plus the terminating null byte. */ if (aexpr->len * 2 + 1 > size_left) error ("%s", err_msg); pkt = buf.data () + strlen (buf.data ()); for (int ndx = 0; ndx < aexpr->len; ++ndx) pkt = pack_hex_byte (pkt, aexpr->buf[ndx]); *pkt = '\0'; } else warning (_("Target does not support conditional tracepoints, " "ignoring tp %d cond"), b->number); } if (b->commands || !default_collect.empty ()) { size_left = buf.size () - strlen (buf.data ()); ret = snprintf (buf.data () + strlen (buf.data ()), size_left, "-"); if (ret < 0 || ret >= size_left) error ("%s", err_msg); } putpkt (buf.data ()); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) error (_("Target does not support tracepoints.")); /* do_single_steps (t); */ for (auto action_it = tdp_actions.begin (); action_it != tdp_actions.end (); action_it++) { QUIT; /* Allow user to bail out with ^C. */ bool has_more = ((action_it + 1) != tdp_actions.end () || !stepping_actions.empty ()); ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%c", b->number, addrbuf, /* address */ action_it->c_str (), has_more ? '-' : 0); if (ret < 0 || ret >= buf.size ()) error ("%s", err_msg); putpkt (buf.data ()); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) error (_("Error on target while setting tracepoints.")); } for (auto action_it = stepping_actions.begin (); action_it != stepping_actions.end (); action_it++) { QUIT; /* Allow user to bail out with ^C. */ bool is_first = action_it == stepping_actions.begin (); bool has_more = (action_it + 1) != stepping_actions.end (); ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%s%s", b->number, addrbuf, /* address */ is_first ? "S" : "", action_it->c_str (), has_more ? "-" : ""); if (ret < 0 || ret >= buf.size ()) error ("%s", err_msg); putpkt (buf.data ()); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) error (_("Error on target while setting tracepoints.")); } if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE) { if (b->location != NULL) { ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); if (ret < 0 || ret >= buf.size ()) error ("%s", err_msg); encode_source_string (b->number, loc->address, "at", event_location_to_string (b->location.get ()), buf.data () + strlen (buf.data ()), buf.size () - strlen (buf.data ())); putpkt (buf.data ()); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } if (b->cond_string) { ret = snprintf (buf.data (), buf.size (), "QTDPsrc:"); if (ret < 0 || ret >= buf.size ()) error ("%s", err_msg); encode_source_string (b->number, loc->address, "cond", b->cond_string.get (), buf.data () + strlen (buf.data ()), buf.size () - strlen (buf.data ())); putpkt (buf.data ()); remote_get_noisy_reply (); if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } remote_download_command_source (b->number, loc->address, breakpoint_commands (b)); } } bool remote_target::can_download_tracepoint () { struct remote_state *rs = get_remote_state (); struct trace_status *ts; int status; /* Don't try to install tracepoints until we've relocated our symbols, and fetched and merged the target's tracepoint list with ours. */ if (rs->starting_up) return false; ts = current_trace_status (); status = get_trace_status (ts); if (status == -1 || !ts->running_known || !ts->running) return false; /* If we are in a tracing experiment, but remote stub doesn't support installing tracepoint in trace, we have to return. */ if (!remote_supports_install_in_trace ()) return false; return true; } void remote_target::download_trace_state_variable (const trace_state_variable &tsv) { struct remote_state *rs = get_remote_state (); char *p; xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:", tsv.number, phex ((ULONGEST) tsv.initial_value, 8), tsv.builtin); p = rs->buf.data () + strlen (rs->buf.data ()); if ((p - rs->buf.data ()) + tsv.name.length () * 2 >= get_remote_packet_size ()) error (_("Trace state variable name too long for tsv definition packet")); p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ()); *p++ = '\0'; putpkt (rs->buf); remote_get_noisy_reply (); if (rs->buf[0] == '\0') error (_("Target does not support this command.")); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while downloading trace state variable.")); } void remote_target::enable_tracepoint (struct bp_location *location) { struct remote_state *rs = get_remote_state (); xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s", location->owner->number, phex (location->address, sizeof (CORE_ADDR))); putpkt (rs->buf); remote_get_noisy_reply (); if (rs->buf[0] == '\0') error (_("Target does not support enabling tracepoints while a trace run is ongoing.")); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while enabling tracepoint.")); } void remote_target::disable_tracepoint (struct bp_location *location) { struct remote_state *rs = get_remote_state (); xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s", location->owner->number, phex (location->address, sizeof (CORE_ADDR))); putpkt (rs->buf); remote_get_noisy_reply (); if (rs->buf[0] == '\0') error (_("Target does not support disabling tracepoints while a trace run is ongoing.")); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while disabling tracepoint.")); } void remote_target::trace_set_readonly_regions () { asection *s; bfd_size_type size; bfd_vma vma; int anysecs = 0; int offset = 0; if (!current_program_space->exec_bfd ()) return; /* No information to give. */ struct remote_state *rs = get_remote_state (); strcpy (rs->buf.data (), "QTro"); offset = strlen (rs->buf.data ()); for (s = current_program_space->exec_bfd ()->sections; s; s = s->next) { char tmp1[40], tmp2[40]; int sec_length; if ((s->flags & SEC_LOAD) == 0 || /* (s->flags & SEC_CODE) == 0 || */ (s->flags & SEC_READONLY) == 0) continue; anysecs = 1; vma = bfd_section_vma (s); size = bfd_section_size (s); sprintf_vma (tmp1, vma); sprintf_vma (tmp2, vma + size); sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2); if (offset + sec_length + 1 > rs->buf.size ()) { if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE) warning (_("\ Too many sections for read-only sections definition packet.")); break; } xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s", tmp1, tmp2); offset += sec_length; } if (anysecs) { putpkt (rs->buf); getpkt (&rs->buf, 0); } } void remote_target::trace_start () { struct remote_state *rs = get_remote_state (); putpkt ("QTStart"); remote_get_noisy_reply (); if (rs->buf[0] == '\0') error (_("Target does not support this command.")); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Bogus reply from target: %s"), rs->buf.data ()); } int remote_target::get_trace_status (struct trace_status *ts) { /* Initialize it just to avoid a GCC false warning. */ char *p = NULL; enum packet_result result; struct remote_state *rs = get_remote_state (); if (packet_support (PACKET_qTStatus) == PACKET_DISABLE) return -1; /* FIXME we need to get register block size some other way. */ trace_regblock_size = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet; putpkt ("qTStatus"); try { p = remote_get_noisy_reply (); } catch (const gdb_exception_error &ex) { if (ex.error != TARGET_CLOSE_ERROR) { exception_fprintf (gdb_stderr, ex, "qTStatus: "); return -1; } throw; } result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]); /* If the remote target doesn't do tracing, flag it. */ if (result == PACKET_UNKNOWN) return -1; /* We're working with a live target. */ ts->filename = NULL; if (*p++ != 'T') error (_("Bogus trace status reply from target: %s"), rs->buf.data ()); /* Function 'parse_trace_status' sets default value of each field of 'ts' at first, so we don't have to do it here. */ parse_trace_status (p, ts); return ts->running; } void remote_target::get_tracepoint_status (struct breakpoint *bp, struct uploaded_tp *utp) { struct remote_state *rs = get_remote_state (); char *reply; struct tracepoint *tp = (struct tracepoint *) bp; size_t size = get_remote_packet_size (); if (tp) { tp->hit_count = 0; tp->traceframe_usage = 0; for (bp_location *loc : tp->locations ()) { /* If the tracepoint was never downloaded, don't go asking for any status. */ if (tp->number_on_target == 0) continue; xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target, phex_nz (loc->address, 0)); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (reply && *reply) { if (*reply == 'V') parse_tracepoint_status (reply + 1, bp, utp); } } } else if (utp) { utp->hit_count = 0; utp->traceframe_usage = 0; xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number, phex_nz (utp->addr, 0)); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (reply && *reply) { if (*reply == 'V') parse_tracepoint_status (reply + 1, bp, utp); } } } void remote_target::trace_stop () { struct remote_state *rs = get_remote_state (); putpkt ("QTStop"); remote_get_noisy_reply (); if (rs->buf[0] == '\0') error (_("Target does not support this command.")); if (strcmp (rs->buf.data (), "OK") != 0) error (_("Bogus reply from target: %s"), rs->buf.data ()); } int remote_target::trace_find (enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) { struct remote_state *rs = get_remote_state (); char *endbuf = rs->buf.data () + get_remote_packet_size (); char *p, *reply; int target_frameno = -1, target_tracept = -1; /* Lookups other than by absolute frame number depend on the current trace selected, so make sure it is correct on the remote end first. */ if (type != tfind_number) set_remote_traceframe (); p = rs->buf.data (); strcpy (p, "QTFrame:"); p = strchr (p, '\0'); switch (type) { case tfind_number: xsnprintf (p, endbuf - p, "%x", num); break; case tfind_pc: xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0)); break; case tfind_tp: xsnprintf (p, endbuf - p, "tdp:%x", num); break; case tfind_range: xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0)); break; case tfind_outside: xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0)); break; default: error (_("Unknown trace find type %d"), type); } putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') error (_("Target does not support this command.")); while (reply && *reply) switch (*reply) { case 'F': p = ++reply; target_frameno = (int) strtol (p, &reply, 16); if (reply == p) error (_("Unable to parse trace frame number")); /* Don't update our remote traceframe number cache on failure to select a remote traceframe. */ if (target_frameno == -1) return -1; break; case 'T': p = ++reply; target_tracept = (int) strtol (p, &reply, 16); if (reply == p) error (_("Unable to parse tracepoint number")); break; case 'O': /* "OK"? */ if (reply[1] == 'K' && reply[2] == '\0') reply += 2; else error (_("Bogus reply from target: %s"), reply); break; default: error (_("Bogus reply from target: %s"), reply); } if (tpp) *tpp = target_tracept; rs->remote_traceframe_number = target_frameno; return target_frameno; } bool remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val) { struct remote_state *rs = get_remote_state (); char *reply; ULONGEST uval; set_remote_traceframe (); xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (reply && *reply) { if (*reply == 'V') { unpack_varlen_hex (reply + 1, &uval); *val = (LONGEST) uval; return true; } } return false; } int remote_target::save_trace_data (const char *filename) { struct remote_state *rs = get_remote_state (); char *p, *reply; p = rs->buf.data (); strcpy (p, "QTSave:"); p += strlen (p); if ((p - rs->buf.data ()) + strlen (filename) * 2 >= get_remote_packet_size ()) error (_("Remote file name too long for trace save packet")); p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename)); *p++ = '\0'; putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') error (_("Target does not support this command.")); if (strcmp (reply, "OK") != 0) error (_("Bogus reply from target: %s"), reply); return 0; } /* This is basically a memory transfer, but needs to be its own packet because we don't know how the target actually organizes its trace memory, plus we want to be able to ask for as much as possible, but not be unhappy if we don't get as much as we ask for. */ LONGEST remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) { struct remote_state *rs = get_remote_state (); char *reply; char *p; int rslt; p = rs->buf.data (); strcpy (p, "qTBuffer:"); p += strlen (p); p += hexnumstr (p, offset); *p++ = ','; p += hexnumstr (p, len); *p++ = '\0'; putpkt (rs->buf); reply = remote_get_noisy_reply (); if (reply && *reply) { /* 'l' by itself means we're at the end of the buffer and there is nothing more to get. */ if (*reply == 'l') return 0; /* Convert the reply into binary. Limit the number of bytes to convert according to our passed-in buffer size, rather than what was returned in the packet; if the target is unexpectedly generous and gives us a bigger reply than we asked for, we don't want to crash. */ rslt = hex2bin (reply, buf, len); return rslt; } /* Something went wrong, flag as an error. */ return -1; } void remote_target::set_disconnected_tracing (int val) { struct remote_state *rs = get_remote_state (); if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE) { char *reply; xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisconnected:%x", val); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') error (_("Target does not support this command.")); if (strcmp (reply, "OK") != 0) error (_("Bogus reply from target: %s"), reply); } else if (val) warning (_("Target does not support disconnected tracing.")); } int remote_target::core_of_thread (ptid_t ptid) { thread_info *info = find_thread_ptid (this, ptid); if (info != NULL && info->priv != NULL) return get_remote_thread_info (info)->core; return -1; } void remote_target::set_circular_trace_buffer (int val) { struct remote_state *rs = get_remote_state (); char *reply; xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTBuffer:circular:%x", val); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') error (_("Target does not support this command.")); if (strcmp (reply, "OK") != 0) error (_("Bogus reply from target: %s"), reply); } traceframe_info_up remote_target::traceframe_info () { gdb::optional text = target_read_stralloc (current_inferior ()->top_target (), TARGET_OBJECT_TRACEFRAME_INFO, NULL); if (text) return parse_traceframe_info (text->data ()); return NULL; } /* Handle the qTMinFTPILen packet. Returns the minimum length of instruction on which a fast tracepoint may be placed. Returns -1 if the packet is not supported, and 0 if the minimum instruction length is unknown. */ int remote_target::get_min_fast_tracepoint_insn_len () { struct remote_state *rs = get_remote_state (); char *reply; /* If we're not debugging a process yet, the IPA can't be loaded. */ if (!target_has_execution ()) return 0; /* Make sure the remote is pointing at the right process. */ set_general_process (); xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen"); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') return -1; else { ULONGEST min_insn_len; unpack_varlen_hex (reply, &min_insn_len); return (int) min_insn_len; } } void remote_target::set_trace_buffer_size (LONGEST val) { if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); char *buf = rs->buf.data (); char *endbuf = buf + get_remote_packet_size (); enum packet_result result; gdb_assert (val >= 0 || val == -1); buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:"); /* Send -1 as literal "-1" to avoid host size dependency. */ if (val < 0) { *buf++ = '-'; buf += hexnumstr (buf, (ULONGEST) -val); } else buf += hexnumstr (buf, (ULONGEST) val); putpkt (rs->buf); remote_get_noisy_reply (); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QTBuffer_size]); if (result != PACKET_OK) warning (_("Bogus reply from target: %s"), rs->buf.data ()); } } bool remote_target::set_trace_notes (const char *user, const char *notes, const char *stop_notes) { struct remote_state *rs = get_remote_state (); char *reply; char *buf = rs->buf.data (); char *endbuf = buf + get_remote_packet_size (); int nbytes; buf += xsnprintf (buf, endbuf - buf, "QTNotes:"); if (user) { buf += xsnprintf (buf, endbuf - buf, "user:"); nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user)); buf += 2 * nbytes; *buf++ = ';'; } if (notes) { buf += xsnprintf (buf, endbuf - buf, "notes:"); nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes)); buf += 2 * nbytes; *buf++ = ';'; } if (stop_notes) { buf += xsnprintf (buf, endbuf - buf, "tstop:"); nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes)); buf += 2 * nbytes; *buf++ = ';'; } /* Ensure the buffer is terminated. */ *buf = '\0'; putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') return false; if (strcmp (reply, "OK") != 0) error (_("Bogus reply from target: %s"), reply); return true; } bool remote_target::use_agent (bool use) { if (packet_support (PACKET_QAgent) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); /* If the stub supports QAgent. */ xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use); putpkt (rs->buf); getpkt (&rs->buf, 0); if (strcmp (rs->buf.data (), "OK") == 0) { ::use_agent = use; return true; } } return false; } bool remote_target::can_use_agent () { return (packet_support (PACKET_QAgent) != PACKET_DISABLE); } struct btrace_target_info { /* The ptid of the traced thread. */ ptid_t ptid; /* The obtained branch trace configuration. */ struct btrace_config conf; }; /* Reset our idea of our target's btrace configuration. */ static void remote_btrace_reset (remote_state *rs) { memset (&rs->btrace_config, 0, sizeof (rs->btrace_config)); } /* Synchronize the configuration with the target. */ void remote_target::btrace_sync_conf (const btrace_config *conf) { struct packet_config *packet; struct remote_state *rs; char *buf, *pos, *endbuf; rs = get_remote_state (); buf = rs->buf.data (); endbuf = buf + get_remote_packet_size (); packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size]; if (packet_config_support (packet) == PACKET_ENABLE && conf->bts.size != rs->btrace_config.bts.size) { pos = buf; pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, conf->bts.size); putpkt (buf); getpkt (&rs->buf, 0); if (packet_ok (buf, packet) == PACKET_ERROR) { if (buf[0] == 'E' && buf[1] == '.') error (_("Failed to configure the BTS buffer size: %s"), buf + 2); else error (_("Failed to configure the BTS buffer size.")); } rs->btrace_config.bts.size = conf->bts.size; } packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size]; if (packet_config_support (packet) == PACKET_ENABLE && conf->pt.size != rs->btrace_config.pt.size) { pos = buf; pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name, conf->pt.size); putpkt (buf); getpkt (&rs->buf, 0); if (packet_ok (buf, packet) == PACKET_ERROR) { if (buf[0] == 'E' && buf[1] == '.') error (_("Failed to configure the trace buffer size: %s"), buf + 2); else error (_("Failed to configure the trace buffer size.")); } rs->btrace_config.pt.size = conf->pt.size; } } /* Read the current thread's btrace configuration from the target and store it into CONF. */ static void btrace_read_config (struct btrace_config *conf) { gdb::optional xml = target_read_stralloc (current_inferior ()->top_target (), TARGET_OBJECT_BTRACE_CONF, ""); if (xml) parse_xml_btrace_conf (conf, xml->data ()); } /* Maybe reopen target btrace. */ void remote_target::remote_btrace_maybe_reopen () { struct remote_state *rs = get_remote_state (); int btrace_target_pushed = 0; #if !defined (HAVE_LIBIPT) int warned = 0; #endif /* Don't bother walking the entirety of the remote thread list when we know the feature isn't supported by the remote. */ if (packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE) return; scoped_restore_current_thread restore_thread; for (thread_info *tp : all_non_exited_threads (this)) { set_general_thread (tp->ptid); memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config)); btrace_read_config (&rs->btrace_config); if (rs->btrace_config.format == BTRACE_FORMAT_NONE) continue; #if !defined (HAVE_LIBIPT) if (rs->btrace_config.format == BTRACE_FORMAT_PT) { if (!warned) { warned = 1; warning (_("Target is recording using Intel Processor Trace " "but support was disabled at compile time.")); } continue; } #endif /* !defined (HAVE_LIBIPT) */ /* Push target, once, but before anything else happens. This way our changes to the threads will be cleaned up by unpushing the target in case btrace_read_config () throws. */ if (!btrace_target_pushed) { btrace_target_pushed = 1; record_btrace_push_target (); printf_filtered (_("Target is recording using %s.\n"), btrace_format_string (rs->btrace_config.format)); } tp->btrace.target = XCNEW (struct btrace_target_info); tp->btrace.target->ptid = tp->ptid; tp->btrace.target->conf = rs->btrace_config; } } /* Enable branch tracing. */ struct btrace_target_info * remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf) { struct btrace_target_info *tinfo = NULL; struct packet_config *packet = NULL; struct remote_state *rs = get_remote_state (); char *buf = rs->buf.data (); char *endbuf = buf + get_remote_packet_size (); switch (conf->format) { case BTRACE_FORMAT_BTS: packet = &remote_protocol_packets[PACKET_Qbtrace_bts]; break; case BTRACE_FORMAT_PT: packet = &remote_protocol_packets[PACKET_Qbtrace_pt]; break; } if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE) error (_("Target does not support branch tracing.")); btrace_sync_conf (conf); set_general_thread (ptid); buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); putpkt (rs->buf); getpkt (&rs->buf, 0); if (packet_ok (rs->buf, packet) == PACKET_ERROR) { if (rs->buf[0] == 'E' && rs->buf[1] == '.') error (_("Could not enable branch tracing for %s: %s"), target_pid_to_str (ptid).c_str (), &rs->buf[2]); else error (_("Could not enable branch tracing for %s."), target_pid_to_str (ptid).c_str ()); } tinfo = XCNEW (struct btrace_target_info); tinfo->ptid = ptid; /* If we fail to read the configuration, we lose some information, but the tracing itself is not impacted. */ try { btrace_read_config (&tinfo->conf); } catch (const gdb_exception_error &err) { if (err.message != NULL) warning ("%s", err.what ()); } return tinfo; } /* Disable branch tracing. */ void remote_target::disable_btrace (struct btrace_target_info *tinfo) { struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off]; struct remote_state *rs = get_remote_state (); char *buf = rs->buf.data (); char *endbuf = buf + get_remote_packet_size (); if (packet_config_support (packet) != PACKET_ENABLE) error (_("Target does not support branch tracing.")); set_general_thread (tinfo->ptid); buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); putpkt (rs->buf); getpkt (&rs->buf, 0); if (packet_ok (rs->buf, packet) == PACKET_ERROR) { if (rs->buf[0] == 'E' && rs->buf[1] == '.') error (_("Could not disable branch tracing for %s: %s"), target_pid_to_str (tinfo->ptid).c_str (), &rs->buf[2]); else error (_("Could not disable branch tracing for %s."), target_pid_to_str (tinfo->ptid).c_str ()); } xfree (tinfo); } /* Teardown branch tracing. */ void remote_target::teardown_btrace (struct btrace_target_info *tinfo) { /* We must not talk to the target during teardown. */ xfree (tinfo); } /* Read the branch trace. */ enum btrace_error remote_target::read_btrace (struct btrace_data *btrace, struct btrace_target_info *tinfo, enum btrace_read_type type) { struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace]; const char *annex; if (packet_config_support (packet) != PACKET_ENABLE) error (_("Target does not support branch tracing.")); #if !defined(HAVE_LIBEXPAT) error (_("Cannot process branch tracing result. XML parsing not supported.")); #endif switch (type) { case BTRACE_READ_ALL: annex = "all"; break; case BTRACE_READ_NEW: annex = "new"; break; case BTRACE_READ_DELTA: annex = "delta"; break; default: internal_error (__FILE__, __LINE__, _("Bad branch tracing read type: %u."), (unsigned int) type); } gdb::optional xml = target_read_stralloc (current_inferior ()->top_target (), TARGET_OBJECT_BTRACE, annex); if (!xml) return BTRACE_ERR_UNKNOWN; parse_xml_btrace (btrace, xml->data ()); return BTRACE_ERR_NONE; } const struct btrace_config * remote_target::btrace_conf (const struct btrace_target_info *tinfo) { return &tinfo->conf; } bool remote_target::augmented_libraries_svr4_read () { return (packet_support (PACKET_augmented_libraries_svr4_read_feature) == PACKET_ENABLE); } /* Implementation of to_load. */ void remote_target::load (const char *name, int from_tty) { generic_load (name, from_tty); } /* Accepts an integer PID; returns a string representing a file that can be opened on the remote side to get the symbols for the child process. Returns NULL if the operation is not supported. */ char * remote_target::pid_to_exec_file (int pid) { static gdb::optional filename; char *annex = NULL; if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE) return NULL; inferior *inf = find_inferior_pid (this, pid); if (inf == NULL) internal_error (__FILE__, __LINE__, _("not currently attached to process %d"), pid); if (!inf->fake_pid_p) { const int annex_size = 9; annex = (char *) alloca (annex_size); xsnprintf (annex, annex_size, "%x", pid); } filename = target_read_stralloc (current_inferior ()->top_target (), TARGET_OBJECT_EXEC_FILE, annex); return filename ? filename->data () : nullptr; } /* Implement the to_can_do_single_step target_ops method. */ int remote_target::can_do_single_step () { /* We can only tell whether target supports single step or not by supported s and S vCont actions if the stub supports vContSupported feature. If the stub doesn't support vContSupported feature, we have conservatively to think target doesn't supports single step. */ if (packet_support (PACKET_vContSupported) == PACKET_ENABLE) { struct remote_state *rs = get_remote_state (); if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) remote_vcont_probe (); return rs->supports_vCont.s && rs->supports_vCont.S; } else return 0; } /* Implementation of the to_execution_direction method for the remote target. */ enum exec_direction_kind remote_target::execution_direction () { struct remote_state *rs = get_remote_state (); return rs->last_resume_exec_dir; } /* Return pointer to the thread_info struct which corresponds to THREAD_HANDLE (having length HANDLE_LEN). */ thread_info * remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle, int handle_len, inferior *inf) { for (thread_info *tp : all_non_exited_threads (this)) { remote_thread_info *priv = get_remote_thread_info (tp); if (tp->inf == inf && priv != NULL) { if (handle_len != priv->thread_handle.size ()) error (_("Thread handle size mismatch: %d vs %zu (from remote)"), handle_len, priv->thread_handle.size ()); if (memcmp (thread_handle, priv->thread_handle.data (), handle_len) == 0) return tp; } } return NULL; } gdb::byte_vector remote_target::thread_info_to_thread_handle (struct thread_info *tp) { remote_thread_info *priv = get_remote_thread_info (tp); return priv->thread_handle; } bool remote_target::can_async_p () { struct remote_state *rs = get_remote_state (); /* We don't go async if the user has explicitly prevented it with the "maint set target-async" command. */ if (!target_async_permitted) return false; /* We're async whenever the serial device is. */ return serial_can_async_p (rs->remote_desc); } bool remote_target::is_async_p () { struct remote_state *rs = get_remote_state (); if (!target_async_permitted) /* We only enable async when the user specifically asks for it. */ return false; /* We're async whenever the serial device is. */ return serial_is_async_p (rs->remote_desc); } /* Pass the SERIAL event on and up to the client. One day this code will be able to delay notifying the client of an event until the point where an entire packet has been received. */ static serial_event_ftype remote_async_serial_handler; static void remote_async_serial_handler (struct serial *scb, void *context) { /* Don't propogate error information up to the client. Instead let the client find out about the error by querying the target. */ inferior_event_handler (INF_REG_EVENT); } static void remote_async_inferior_event_handler (gdb_client_data data) { inferior_event_handler (INF_REG_EVENT); } int remote_target::async_wait_fd () { struct remote_state *rs = get_remote_state (); return rs->remote_desc->fd; } void remote_target::async (int enable) { struct remote_state *rs = get_remote_state (); if (enable) { serial_async (rs->remote_desc, remote_async_serial_handler, rs); /* If there are pending events in the stop reply queue tell the event loop to process them. */ if (!rs->stop_reply_queue.empty ()) 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 process, this ends up being a no-op (other than a spurious event-loop wakeup). */ if (target_is_non_stop_p ()) mark_async_event_handler (rs->notif_state->get_pending_events_token); } else { serial_async (rs->remote_desc, NULL, NULL); /* 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 (rs->remote_async_inferior_event_token); if (target_is_non_stop_p ()) clear_async_event_handler (rs->notif_state->get_pending_events_token); } } /* Implementation of the to_thread_events method. */ void remote_target::thread_events (int enable) { struct remote_state *rs = get_remote_state (); size_t size = get_remote_packet_size (); if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE) return; xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0); putpkt (rs->buf); getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_QThreadEvents])) { case PACKET_OK: if (strcmp (rs->buf.data (), "OK") != 0) error (_("Remote refused setting thread events: %s"), rs->buf.data ()); break; case PACKET_ERROR: warning (_("Remote failure reply: %s"), rs->buf.data ()); break; case PACKET_UNKNOWN: break; } } static void show_remote_cmd (const char *args, int from_tty) { /* We can't just use cmd_show_list here, because we want to skip the redundant "show remote Z-packet" and the legacy aliases. */ struct cmd_list_element *list = remote_show_cmdlist; struct ui_out *uiout = current_uiout; ui_out_emit_tuple tuple_emitter (uiout, "showlist"); for (; list != NULL; list = list->next) if (strcmp (list->name, "Z-packet") == 0) continue; else if (list->type == not_set_cmd) /* Alias commands are exactly like the original, except they don't have the normal type. */ continue; else { ui_out_emit_tuple option_emitter (uiout, "option"); uiout->field_string ("name", list->name); uiout->text (": "); if (list->type == show_cmd) do_show_command (NULL, from_tty, list); else cmd_func (list, NULL, from_tty); } } /* Function to be called whenever a new objfile (shlib) is detected. */ static void remote_new_objfile (struct objfile *objfile) { remote_target *remote = get_current_remote_target (); /* First, check whether the current inferior's process target is a remote target. */ if (remote == nullptr) return; /* When we are attaching or handling a fork child and the shared library subsystem reads the list of loaded libraries, we receive new objfile events in between each found library. The libraries are read in an undefined order, so if we gave the remote side a chance to look up symbols between each objfile, we might give it an inconsistent picture of the inferior. It could appear that a library A appears loaded but a library B does not, even though library A requires library B. That would present a state that couldn't normally exist in the inferior. So, skip these events, we'll give the remote a chance to look up symbols once all the loaded libraries and their symbols are known to GDB. */ if (current_inferior ()->in_initial_library_scan) return; remote->remote_check_symbols (); } /* Pull all the tracepoints defined on the target and create local data structures representing them. We don't want to create real tracepoints yet, we don't want to mess up the user's existing collection. */ int remote_target::upload_tracepoints (struct uploaded_tp **utpp) { struct remote_state *rs = get_remote_state (); char *p; /* Ask for a first packet of tracepoint definition. */ putpkt ("qTfP"); getpkt (&rs->buf, 0); p = rs->buf.data (); while (*p && *p != 'l') { parse_tracepoint_definition (p, utpp); /* Ask for another packet of tracepoint definition. */ putpkt ("qTsP"); getpkt (&rs->buf, 0); p = rs->buf.data (); } return 0; } int remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp) { struct remote_state *rs = get_remote_state (); char *p; /* Ask for a first packet of variable definition. */ putpkt ("qTfV"); getpkt (&rs->buf, 0); p = rs->buf.data (); while (*p && *p != 'l') { parse_tsv_definition (p, utsvp); /* Ask for another packet of variable definition. */ putpkt ("qTsV"); getpkt (&rs->buf, 0); p = rs->buf.data (); } return 0; } /* The "set/show range-stepping" show hook. */ static void show_range_stepping (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("Debugger's willingness to use range stepping " "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) { /* When enabling, check whether range stepping is actually supported by the target, and warn if not. */ if (use_range_stepping) { remote_target *remote = get_current_remote_target (); if (remote == NULL || !remote->vcont_r_supported ()) warning (_("Range stepping is not supported by the current target")); } } static void show_remote_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"), value); } static void show_remote_timeout (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("Timeout limit to wait for target to respond is %s.\n"), value); } /* Implement the "supports_memory_tagging" target_ops method. */ bool remote_target::supports_memory_tagging () { return remote_memory_tagging_p (); } /* Create the qMemTags packet given ADDRESS, LEN and TYPE. */ static void create_fetch_memtags_request (gdb::char_vector &packet, CORE_ADDR address, size_t len, int type) { int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; std::string request = string_printf ("qMemTags:%s,%s:%s", phex_nz (address, addr_size), phex_nz (len, sizeof (len)), phex_nz (type, sizeof (type))); strcpy (packet.data (), request.c_str ()); } /* Parse the qMemTags packet reply into TAGS. Return true if successful, false otherwise. */ static bool parse_fetch_memtags_reply (const gdb::char_vector &reply, gdb::byte_vector &tags) { if (reply.empty () || reply[0] == 'E' || reply[0] != 'm') return false; /* Copy the tag data. */ tags = hex2bin (reply.data () + 1); return true; } /* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */ static void create_store_memtags_request (gdb::char_vector &packet, CORE_ADDR address, size_t len, int type, const gdb::byte_vector &tags) { int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8; /* Put together the main packet, address and length. */ std::string request = string_printf ("QMemTags:%s,%s:%s:", phex_nz (address, addr_size), phex_nz (len, sizeof (len)), phex_nz (type, sizeof (type))); request += bin2hex (tags.data (), tags.size ()); /* Check if we have exceeded the maximum packet size. */ if (packet.size () < request.length ()) error (_("Contents too big for packet QMemTags.")); strcpy (packet.data (), request.c_str ()); } /* Implement the "fetch_memtags" target_ops method. */ bool remote_target::fetch_memtags (CORE_ADDR address, size_t len, gdb::byte_vector &tags, int type) { /* Make sure the qMemTags packet is supported. */ if (!remote_memory_tagging_p ()) gdb_assert_not_reached ("remote fetch_memtags called with packet disabled"); struct remote_state *rs = get_remote_state (); create_fetch_memtags_request (rs->buf, address, len, type); putpkt (rs->buf); getpkt (&rs->buf, 0); return parse_fetch_memtags_reply (rs->buf, tags); } /* Implement the "store_memtags" target_ops method. */ bool remote_target::store_memtags (CORE_ADDR address, size_t len, const gdb::byte_vector &tags, int type) { /* Make sure the QMemTags packet is supported. */ if (!remote_memory_tagging_p ()) gdb_assert_not_reached ("remote store_memtags called with packet disabled"); struct remote_state *rs = get_remote_state (); create_store_memtags_request (rs->buf, address, len, type, tags); putpkt (rs->buf); getpkt (&rs->buf, 0); /* Verify if the request was successful. */ return packet_check_result (rs->buf.data ()) == PACKET_OK; } /* Return true if remote target T is non-stop. */ bool remote_target_is_non_stop_p (remote_target *t) { scoped_restore_current_thread restore_thread; switch_to_target_no_thread (t); return target_is_non_stop_p (); } #if GDB_SELF_TEST namespace selftests { static void test_memory_tagging_functions () { remote_target remote; struct packet_config *config = &remote_protocol_packets[PACKET_memory_tagging_feature]; scoped_restore restore_memtag_support_ = make_scoped_restore (&config->support); /* Test memory tagging packet support. */ config->support = PACKET_SUPPORT_UNKNOWN; SELF_CHECK (remote.supports_memory_tagging () == false); config->support = PACKET_DISABLE; SELF_CHECK (remote.supports_memory_tagging () == false); config->support = PACKET_ENABLE; SELF_CHECK (remote.supports_memory_tagging () == true); /* Setup testing. */ gdb::char_vector packet; gdb::byte_vector tags, bv; std::string expected, reply; packet.resize (32000); /* Test creating a qMemTags request. */ expected = "qMemTags:0,0:0"; create_fetch_memtags_request (packet, 0x0, 0x0, 0); SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0); expected = "qMemTags:deadbeef,10:1"; create_fetch_memtags_request (packet, 0xdeadbeef, 16, 1); SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0); /* Test parsing a qMemTags reply. */ /* Error reply, tags vector unmodified. */ reply = "E00"; strcpy (packet.data (), reply.c_str ()); tags.resize (0); SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == false); SELF_CHECK (tags.size () == 0); /* Valid reply, tags vector updated. */ tags.resize (0); bv.resize (0); for (int i = 0; i < 5; i++) bv.push_back (i); reply = "m" + bin2hex (bv.data (), bv.size ()); strcpy (packet.data (), reply.c_str ()); SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == true); SELF_CHECK (tags.size () == 5); for (int i = 0; i < 5; i++) SELF_CHECK (tags[i] == i); /* Test creating a QMemTags request. */ /* Empty tag data. */ tags.resize (0); expected = "QMemTags:0,0:0:"; create_store_memtags_request (packet, 0x0, 0x0, 0, tags); SELF_CHECK (memcmp (packet.data (), expected.c_str (), expected.length ()) == 0); /* Non-empty tag data. */ tags.resize (0); for (int i = 0; i < 5; i++) tags.push_back (i); expected = "QMemTags:deadbeef,ff:1:0001020304"; create_store_memtags_request (packet, 0xdeadbeef, 255, 1, tags); SELF_CHECK (memcmp (packet.data (), expected.c_str (), expected.length ()) == 0); } } // namespace selftests #endif /* GDB_SELF_TEST */ void _initialize_remote (); void _initialize_remote () { /* architecture specific data */ remote_g_packet_data_handle = gdbarch_data_register_pre_init (remote_g_packet_data_init); add_target (remote_target_info, remote_target::open); add_target (extended_remote_target_info, extended_remote_target::open); /* Hook into new objfile notification. */ gdb::observers::new_objfile.attach (remote_new_objfile, "remote"); #if 0 init_remote_threadtests (); #endif /* set/show remote ... */ add_basic_prefix_cmd ("remote", class_maintenance, _("\ Remote protocol specific variables.\n\ Configure various remote-protocol specific variables such as\n\ the packets being used."), &remote_set_cmdlist, 0 /* allow-unknown */, &setlist); add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\ Remote protocol specific variables.\n\ Configure various remote-protocol specific variables such as\n\ the packets being used."), &remote_show_cmdlist, 0 /* allow-unknown */, &showlist); add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\ Compare section data on target to the exec file.\n\ Argument is a single section name (default: all loaded sections).\n\ To compare only read-only loaded sections, specify the -r option."), &cmdlist); add_cmd ("packet", class_maintenance, packet_command, _("\ Send an arbitrary packet to a remote target.\n\ maintenance packet TEXT\n\ If GDB is talking to an inferior via the GDB serial protocol, then\n\ this command sends the string TEXT to the inferior, and displays the\n\ response packet. GDB supplies the initial `$' character, and the\n\ terminating `#' character and checksum."), &maintenancelist); set_show_commands remotebreak_cmds = add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\ Set whether to send break if interrupted."), _("\ Show whether to send break if interrupted."), _("\ If set, a break, instead of a cntrl-c, is sent to the remote target."), set_remotebreak, show_remotebreak, &setlist, &showlist); deprecate_cmd (remotebreak_cmds.set, "set remote interrupt-sequence"); deprecate_cmd (remotebreak_cmds.show, "show remote interrupt-sequence"); add_setshow_enum_cmd ("interrupt-sequence", class_support, interrupt_sequence_modes, &interrupt_sequence_mode, _("\ Set interrupt sequence to remote target."), _("\ Show interrupt sequence to remote target."), _("\ Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."), NULL, show_interrupt_sequence, &remote_set_cmdlist, &remote_show_cmdlist); add_setshow_boolean_cmd ("interrupt-on-connect", class_support, &interrupt_on_connect, _("\ Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\ Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\ If set, interrupt sequence is sent to remote target."), NULL, NULL, &remote_set_cmdlist, &remote_show_cmdlist); /* Install commands for configuring memory read/write packets. */ add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\ Set the maximum number of bytes per memory write packet (deprecated)."), &setlist); add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\ Show the maximum number of bytes per memory write packet (deprecated)."), &showlist); add_cmd ("memory-write-packet-size", no_class, set_memory_write_packet_size, _("\ Set the maximum number of bytes per memory-write packet.\n\ Specify the number of bytes in a packet or 0 (zero) for the\n\ default packet size. The actual limit is further reduced\n\ dependent on the target. Specify ``fixed'' to disable the\n\ further restriction and ``limit'' to enable that restriction."), &remote_set_cmdlist); add_cmd ("memory-read-packet-size", no_class, set_memory_read_packet_size, _("\ Set the maximum number of bytes per memory-read packet.\n\ Specify the number of bytes in a packet or 0 (zero) for the\n\ default packet size. The actual limit is further reduced\n\ dependent on the target. Specify ``fixed'' to disable the\n\ further restriction and ``limit'' to enable that restriction."), &remote_set_cmdlist); add_cmd ("memory-write-packet-size", no_class, show_memory_write_packet_size, _("Show the maximum number of bytes per memory-write packet."), &remote_show_cmdlist); add_cmd ("memory-read-packet-size", no_class, show_memory_read_packet_size, _("Show the maximum number of bytes per memory-read packet."), &remote_show_cmdlist); add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class, &remote_hw_watchpoint_limit, _("\ Set the maximum number of target hardware watchpoints."), _("\ Show the maximum number of target hardware watchpoints."), _("\ Specify \"unlimited\" for unlimited hardware watchpoints."), NULL, show_hardware_watchpoint_limit, &remote_set_cmdlist, &remote_show_cmdlist); add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit", no_class, &remote_hw_watchpoint_length_limit, _("\ Set the maximum length (in bytes) of a target hardware watchpoint."), _("\ Show the maximum length (in bytes) of a target hardware watchpoint."), _("\ Specify \"unlimited\" to allow watchpoints of unlimited size."), NULL, show_hardware_watchpoint_length_limit, &remote_set_cmdlist, &remote_show_cmdlist); add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class, &remote_hw_breakpoint_limit, _("\ Set the maximum number of target hardware breakpoints."), _("\ Show the maximum number of target hardware breakpoints."), _("\ Specify \"unlimited\" for unlimited hardware breakpoints."), NULL, show_hardware_breakpoint_limit, &remote_set_cmdlist, &remote_show_cmdlist); add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure, &remote_address_size, _("\ Set the maximum size of the address (in bits) in a memory packet."), _("\ Show the maximum size of the address (in bits) in a memory packet."), NULL, NULL, NULL, /* FIXME: i18n: */ &setlist, &showlist); init_all_packet_configs (); add_packet_config_cmd (&remote_protocol_packets[PACKET_X], "X", "binary-download", 1); add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont], "vCont", "verbose-resume", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals], "QPassSignals", "pass-signals", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls], "QCatchSyscalls", "catch-syscalls", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals], "QProgramSignals", "program-signals", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir], "QSetWorkingDir", "set-working-dir", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell], "QStartupWithShell", "startup-with-shell", 0); add_packet_config_cmd (&remote_protocol_packets [PACKET_QEnvironmentHexEncoded], "QEnvironmentHexEncoded", "environment-hex-encoded", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset], "QEnvironmentReset", "environment-reset", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset], "QEnvironmentUnset", "environment-unset", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol], "qSymbol", "symbol-lookup", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_P], "P", "set-register", 1); add_packet_config_cmd (&remote_protocol_packets[PACKET_p], "p", "fetch-register", 1); add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0], "Z0", "software-breakpoint", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1], "Z1", "hardware-breakpoint", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2], "Z2", "write-watchpoint", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3], "Z3", "read-watchpoint", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4], "Z4", "access-watchpoint", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv], "qXfer:auxv:read", "read-aux-vector", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file], "qXfer:exec-file:read", "pid-to-exec-file", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features], "qXfer:features:read", "target-features", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries], "qXfer:libraries:read", "library-info", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4], "qXfer:libraries-svr4:read", "library-info-svr4", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map], "qXfer:memory-map:read", "memory-map", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata], "qXfer:osdata:read", "osdata", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads], "qXfer:threads:read", "threads", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read], "qXfer:siginfo:read", "read-siginfo-object", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write], "qXfer:siginfo:write", "write-siginfo-object", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_traceframe_info], "qXfer:traceframe-info:read", "traceframe-info", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib], "qXfer:uib:read", "unwind-info-block", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr], "qGetTLSAddr", "get-thread-local-storage-address", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr], "qGetTIBAddr", "get-thread-information-block-address", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_bc], "bc", "reverse-continue", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_bs], "bs", "reverse-step", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported], "qSupported", "supported-packets", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory], "qSearch:memory", "search-memory", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus], "qTStatus", "trace-status", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs], "vFile:setfs", "hostio-setfs", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open], "vFile:open", "hostio-open", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread], "vFile:pread", "hostio-pread", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite], "vFile:pwrite", "hostio-pwrite", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close], "vFile:close", "hostio-close", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink], "vFile:unlink", "hostio-unlink", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink], "vFile:readlink", "hostio-readlink", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat], "vFile:fstat", "hostio-fstat", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach], "vAttach", "attach", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun], "vRun", "run", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode], "QStartNoAckMode", "noack", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill], "vKill", "kill", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached], "qAttached", "query-attached", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints], "ConditionalTracepoints", "conditional-tracepoints", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints], "ConditionalBreakpoints", "conditional-breakpoints", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands], "BreakpointCommands", "breakpoint-commands", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints], "FastTracepoints", "fast-tracepoints", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource], "TracepointSource", "TracepointSource", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow], "QAllow", "allow", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints], "StaticTracepoints", "static-tracepoints", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace], "InstallInTrace", "install-in-trace", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read], "qXfer:statictrace:read", "read-sdata-object", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic], "qXfer:fdpic:read", "read-fdpic-loadmap", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization], "QDisableRandomization", "disable-randomization", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent], "QAgent", "agent", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size], "QTBuffer:size", "trace-buffer-size", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off], "Qbtrace:off", "disable-btrace", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts], "Qbtrace:bts", "enable-btrace-bts", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt], "Qbtrace:pt", "enable-btrace-pt", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace], "qXfer:btrace", "read-btrace", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf], "qXfer:btrace-conf", "read-btrace-conf", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size], "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature], "multiprocess-feature", "multiprocess-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature], "swbreak-feature", "swbreak-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature], "hwbreak-feature", "hwbreak-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature], "fork-event-feature", "fork-event-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature], "vfork-event-feature", "vfork-event-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size], "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported], "vContSupported", "verbose-resume-supported", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature], "exec-event-feature", "exec-event-feature", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC], "vCtrlC", "ctrl-c", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents], "QThreadEvents", "thread-events", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed], "N stop reply", "no-resumed-stop-reply", 0); add_packet_config_cmd (&remote_protocol_packets[PACKET_memory_tagging_feature], "memory-tagging-feature", "memory-tagging-feature", 0); /* Assert that we've registered "set remote foo-packet" commands for all packet configs. */ { int i; for (i = 0; i < PACKET_MAX; i++) { /* Ideally all configs would have a command associated. Some still don't though. */ int excepted; switch (i) { case PACKET_QNonStop: case PACKET_EnableDisableTracepoints_feature: case PACKET_tracenz_feature: case PACKET_DisconnectedTracing_feature: case PACKET_augmented_libraries_svr4_read_feature: case PACKET_qCRC: /* Additions to this list need to be well justified: pre-existing packets are OK; new packets are not. */ excepted = 1; break; default: excepted = 0; break; } /* This catches both forgetting to add a config command, and forgetting to remove a packet from the exception list. */ gdb_assert (excepted == (remote_protocol_packets[i].name == NULL)); } } /* Keep the old ``set remote Z-packet ...'' working. Each individual Z sub-packet has its own set and show commands, but users may have sets to this variable in their .gdbinit files (or in their documentation). */ add_setshow_auto_boolean_cmd ("Z-packet", class_obscure, &remote_Z_packet_detect, _("\ Set use of remote protocol `Z' packets."), _("\ Show use of remote protocol `Z' packets."), _("\ When set, GDB will attempt to use the remote breakpoint and watchpoint\n\ packets."), set_remote_protocol_Z_packet_cmd, show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */ &remote_set_cmdlist, &remote_show_cmdlist); add_basic_prefix_cmd ("remote", class_files, _("\ Manipulate files on the remote system.\n\ Transfer files to and from the remote target system."), &remote_cmdlist, 0 /* allow-unknown */, &cmdlist); add_cmd ("put", class_files, remote_put_command, _("Copy a local file to the remote system."), &remote_cmdlist); add_cmd ("get", class_files, remote_get_command, _("Copy a remote file to the local system."), &remote_cmdlist); add_cmd ("delete", class_files, remote_delete_command, _("Delete a remote file."), &remote_cmdlist); add_setshow_string_noescape_cmd ("exec-file", class_files, &remote_exec_file_var, _("\ Set the remote pathname for \"run\"."), _("\ Show the remote pathname for \"run\"."), NULL, set_remote_exec_file, show_remote_exec_file, &remote_set_cmdlist, &remote_show_cmdlist); add_setshow_boolean_cmd ("range-stepping", class_run, &use_range_stepping, _("\ Enable or disable range stepping."), _("\ Show whether target-assisted range stepping is enabled."), _("\ If on, and the target supports it, when stepping a source line, GDB\n\ tells the target to step the corresponding range of addresses itself instead\n\ of issuing multiple single-steps. This speeds up source level\n\ stepping. If off, GDB always issues single-steps, even if range\n\ stepping is supported by the target. The default is on."), set_range_stepping, show_range_stepping, &setlist, &showlist); add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\ Set watchdog timer."), _("\ Show watchdog timer."), _("\ When non-zero, this timeout is used instead of waiting forever for a target\n\ to finish a low-level step or continue operation. If the specified amount\n\ of time passes without a response from the target, an error occurs."), NULL, show_watchdog, &setlist, &showlist); add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class, &remote_packet_max_chars, _("\ Set the maximum number of characters to display for each remote packet."), _("\ Show the maximum number of characters to display for each remote packet."), _("\ Specify \"unlimited\" to display all the characters."), NULL, show_remote_packet_max_chars, &setdebuglist, &showdebuglist); add_setshow_boolean_cmd ("remote", no_class, &remote_debug, _("Set debugging of remote protocol."), _("Show debugging of remote protocol."), _("\ When enabled, each packet sent or received with the remote target\n\ is displayed."), NULL, show_remote_debug, &setdebuglist, &showdebuglist); add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class, &remote_timeout, _("\ Set timeout limit to wait for target to respond."), _("\ Show timeout limit to wait for target to respond."), _("\ This value is used to set the time limit for gdb to wait for a response\n\ from the target."), NULL, show_remote_timeout, &setlist, &showlist); /* Eventually initialize fileio. See fileio.c */ initialize_remote_fileio (&remote_set_cmdlist, &remote_show_cmdlist); #if GDB_SELF_TEST selftests::register_test ("remote_memory_tagging", selftests::test_memory_tagging_functions); #endif }