#include "remote-fileio.h"
+#include "memory-map.h"
+
/* The size to align memory write packets, when practical. The protocol
does not guarantee any alignment, and gdb will generate short
writes and unaligned writes, but even as a best-effort attempt this
static struct remote_state remote_state;
static struct remote_state *
-get_remote_state (void)
+get_remote_state_raw (void)
{
return &remote_state;
}
return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
}
+/* Fetch the global remote target state. */
+
+static struct remote_state *
+get_remote_state (void)
+{
+ /* Make sure that the remote architecture state has been
+ initialized, because doing so might reallocate rs->buf. Any
+ function which calls getpkt also needs to be mindful of changes
+ to rs->buf, but this call limits the number of places which run
+ into trouble. */
+ get_remote_arch_state ();
+
+ return get_remote_state_raw ();
+}
+
static void *
init_remote_state (struct gdbarch *gdbarch)
{
int regnum;
- struct remote_state *rs = get_remote_state ();
+ struct remote_state *rs = get_remote_state_raw ();
struct remote_arch_state *rsa;
rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
}
static enum packet_result
-packet_ok (const char *buf, struct packet_config *config)
+packet_check_result (const char *buf)
{
if (buf[0] != '\0')
{
/* The stub recognized the packet request. Check that the
operation succeeded. */
+ if (buf[0] == 'E'
+ && isxdigit (buf[1]) && isxdigit (buf[2])
+ && buf[3] == '\0')
+ /* "Enn" - definitly an error. */
+ return PACKET_ERROR;
+
+ /* Always treat "E." as an error. This will be used for
+ more verbose error messages, such as E.memtypes. */
+ if (buf[0] == 'E' && buf[1] == '.')
+ return PACKET_ERROR;
+
+ /* The packet may or may not be OK. Just assume it is. */
+ return PACKET_OK;
+ }
+ else
+ /* The stub does not support the packet. */
+ return PACKET_UNKNOWN;
+}
+
+static enum packet_result
+packet_ok (const char *buf, struct packet_config *config)
+{
+ enum packet_result result;
+
+ result = packet_check_result (buf);
+ switch (result)
+ {
+ case PACKET_OK:
+ case PACKET_ERROR:
+ /* The stub recognized the packet request. */
switch (config->support)
{
case PACKET_SUPPORT_UNKNOWN:
case PACKET_ENABLE:
break;
}
- if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
- /* "OK" - definitly OK. */
- return PACKET_OK;
- if (buf[0] == 'E'
- && isxdigit (buf[1]) && isxdigit (buf[2])
- && buf[3] == '\0')
- /* "Enn" - definitly an error. */
- return PACKET_ERROR;
- /* The packet may or may not be OK. Just assume it is. */
- return PACKET_OK;
- }
- else
- {
+ break;
+ case PACKET_UNKNOWN:
/* The stub does not support the packet. */
switch (config->support)
{
case PACKET_DISABLE:
break;
}
- return PACKET_UNKNOWN;
+ break;
}
+
+ return result;
}
enum {
PACKET_Z3,
PACKET_Z4,
PACKET_qXfer_auxv,
+ PACKET_qXfer_memory_map,
PACKET_qGetTLSAddr,
PACKET_qSupported,
PACKET_MAX
{
struct remote_state *rs = get_remote_state ();
int tid = PIDGET (ptid);
- char *buf = rs->buf;
if (tid < 0)
- xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
+ xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
else
- xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
- putpkt (buf);
+ xsnprintf (rs->buf, get_remote_packet_size (), "T%08x", tid);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- return (buf[0] == 'O' && buf[1] == 'K');
+ return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
}
/* About these extended threadlist and threadinfo packets. They are
{
struct remote_state *rs = get_remote_state ();
int result;
- char *threadinfo_pkt = rs->buf;
- pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
- putpkt (threadinfo_pkt);
+ pack_threadinfo_request (rs->buf, fieldset, threadid);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
+ result = remote_unpack_thread_info_response (rs->buf + 2,
threadid, info);
return result;
}
{
struct remote_state *rs = get_remote_state ();
static threadref echo_nextthread;
- char *threadlist_packet = rs->buf;
int result = 1;
/* Trancate result limit to be smaller than the packet size. */
remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
putpkt ("qC");
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'Q' && buf[1] == 'C')
+ if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
/* Use strtoul here, so we'll correctly parse values whose highest
bit is set. The protocol carries them as a simple series of
hex digits; in the absence of a sign, strtol will see such
values as positive numbers out of range for signed 'long', and
return LONG_MAX to indicate an overflow. */
- return pid_to_ptid (strtoul (&buf[2], NULL, 16));
+ return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));
else
return oldpid;
}
if (use_threadinfo_query)
{
putpkt ("qfThreadInfo");
- bufp = rs->buf;
getpkt (&rs->buf, &rs->buf_size, 0);
+ bufp = rs->buf;
if (bufp[0] != '\0') /* q packet recognized */
{
while (*bufp++ == 'm') /* reply contains one or more TID */
}
while (*bufp++ == ','); /* comma-separated list */
putpkt ("qsThreadInfo");
- bufp = rs->buf;
getpkt (&rs->buf, &rs->buf_size, 0);
+ bufp = rs->buf;
}
return; /* done */
}
if (use_threadextra_query)
{
- char *bufp = rs->buf;
-
- xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
+ xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",
PIDGET (tp->ptid));
- putpkt (bufp);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (bufp[0] != 0)
+ if (rs->buf[0] != 0)
{
- n = min (strlen (bufp) / 2, sizeof (display_buf));
- result = hex2bin (bufp, (gdb_byte *) display_buf, n);
+ n = min (strlen (rs->buf) / 2, sizeof (display_buf));
+ result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
display_buf [result] = '\0';
return display_buf;
}
get_offsets (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ char *buf;
char *ptr;
int lose;
CORE_ADDR text_addr, data_addr, bss_addr;
putpkt ("qOffsets");
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
if (buf[0] == '\000')
return; /* Return silently. Stub doesn't support
because we need both at the same time. */
msg = alloca (get_remote_packet_size ());
- reply = rs->buf;
-
/* Invite target to request symbol lookups. */
putpkt ("qSymbol::");
getpkt (&rs->buf, &rs->buf_size, 0);
packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
+ reply = rs->buf;
while (strncmp (reply, "qSymbol:", 8) == 0)
{
&reply[8]);
putpkt (msg);
getpkt (&rs->buf, &rs->buf_size, 0);
+ reply = rs->buf;
}
}
static struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
{ "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
- PACKET_qXfer_auxv }
+ PACKET_qXfer_auxv },
+ { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_memory_map }
};
static void
static void
remote_vcont_probe (struct remote_state *rs)
{
- char *buf = rs->buf;
+ char *buf;
- strcpy (buf, "vCont?");
- putpkt (buf);
+ strcpy (rs->buf, "vCont?");
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
/* Make sure that the features we assume are supported. */
if (strncmp (buf, "vCont", 5) == 0)
remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ char *buf;
int pid = PIDGET (ptid);
last_sent_signal = siggnal;
else
set_thread (pid, 0); /* Run this thread. */
+ buf = rs->buf;
if (siggnal != TARGET_SIGNAL_0)
{
buf[0] = step ? 'S' : 'C';
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- char *p;
+ char *buf, *p;
ofunc = signal (SIGINT, remote_interrupt);
getpkt (&rs->buf, &rs->buf_size, 1);
signal (SIGINT, ofunc);
+ buf = rs->buf;
+
/* This is a hook for when we need to do something (perhaps the
collection of trace data) every time the target stops. */
if (deprecated_target_wait_loop_hook)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- char *p;
+ char *buf, *p;
if (!target_is_async_p ())
ofunc = signal (SIGINT, remote_interrupt);
if (!target_is_async_p ())
signal (SIGINT, ofunc);
+ buf = rs->buf;
+
/* This is a hook for when we need to do something (perhaps the
collection of trace data) every time the target stops. */
if (deprecated_target_wait_loop_hook)
fetch_register_using_p (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf, *p;
+ char *buf, *p;
char regp[MAX_REGISTER_SIZE];
int i;
- p = buf;
+ p = rs->buf;
*p++ = 'p';
p += hexnumstr (p, regnum);
*p++ = '\0';
remote_send (&rs->buf, &rs->buf_size);
+ buf = rs->buf;
+
/* If the stub didn't recognize the packet, or if we got an error,
tell our caller. */
if (buf[0] == '\0' || buf[0] == 'E')
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
+ char *buf;
int i;
char *p;
char *regs = alloca (rsa->sizeof_g_packet);
}
}
- sprintf (buf, "g");
+ sprintf (rs->buf, "g");
remote_send (&rs->buf, &rs->buf_size);
+ buf = rs->buf;
/* Save the size of the packet sent to us by the target. Its used
as a heuristic when determining the max size of packets that the
fprintf_unfiltered (gdb_stdlog,
"Bad register packet; fetching a new packet\n");
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
}
/* Reply describes registers byte by byte, each byte encoded as two
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
remote_send (&rs->buf, &rs->buf_size);
- return buf[0] != '\0';
+ return rs->buf[0] != '\0';
}
break;
case PACKET_SUPPORT_UNKNOWN:
{
- char *buf = rs->buf;
char *p;
- p = buf;
+ p = rs->buf;
*p++ = 'X';
p += hexnumstr (p, (ULONGEST) addr);
*p++ = ',';
*p++ = ':';
*p = '\0';
- putpkt_binary (buf, (int) (p - buf));
+ putpkt_binary (rs->buf, (int) (p - rs->buf));
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == '\0')
+ if (rs->buf[0] == '\0')
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
/* Write memory data directly to the remote machine.
This does not inform the data cache; the data cache uses this.
+ HEADER is the starting part of the packet.
MEMADDR is the address in the remote memory space.
MYADDR is the address of the buffer in our space.
LEN is the number of bytes.
+ PACKET_FORMAT should be either 'X' or 'M', and indicates if we
+ should send data as binary ('X'), or hex-encoded ('M').
- Returns number of bytes transferred, or 0 (setting errno) for
+ The function creates packet of the form
+ <HEADER><ADDRESS>,<LENGTH>:<DATA>
+
+ where encoding of <DATA> is termined by PACKET_FORMAT.
+
+ If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
+ are omitted.
+
+ Returns the number of bytes transferred, or 0 (setting errno) for
error. Only transfer a single packet. */
-int
-remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+static int
+remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
+ const gdb_byte *myaddr, int len,
+ char packet_format, int use_length)
{
struct remote_state *rs = get_remote_state ();
- char *buf;
char *p;
- char *plen;
- int plenlen;
+ char *plen = NULL;
+ int plenlen = 0;
int todo;
int nr_bytes;
int payload_size;
int payload_length;
+ int header_length;
+
+ if (packet_format != 'X' && packet_format != 'M')
+ internal_error (__FILE__, __LINE__,
+ "remote_write_bytes_aux: bad packet format");
/* Should this be the selected frame? */
gdbarch_remote_translate_xfer_address (current_gdbarch,
if (len <= 0)
return 0;
- /* Verify that the target can support a binary download. */
- check_binary_download (memaddr);
-
payload_size = get_memory_write_packet_size ();
/* The packet buffer will be large enough for the payload;
get_memory_packet_size ensures this. */
- buf = rs->buf;
+ rs->buf[0] = '\0';
/* Compute the size of the actual payload by subtracting out the
packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
*/
- payload_size -= strlen ("$M,:#NN");
+ payload_size -= strlen ("$,:#NN");
+ if (!use_length)
+ /* The comma won't be used. */
+ payload_size += 1;
+ header_length = strlen (header);
+ payload_size -= header_length;
payload_size -= hexnumlen (memaddr);
- /* Construct the packet header: "[MX]<memaddr>,<len>:". */
+ /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
- /* Append "[XM]". Compute a best guess of the number of bytes
- actually transfered. */
- p = buf;
- switch (remote_protocol_packets[PACKET_X].support)
+ strcat (rs->buf, header);
+ p = rs->buf + strlen (header);
+
+ /* Compute a best guess of the number of bytes actually transfered. */
+ if (packet_format == 'X')
{
- case PACKET_ENABLE:
- *p++ = 'X';
/* Best guess at number of bytes that will fit. */
todo = min (len, payload_size);
- payload_size -= hexnumlen (todo);
+ if (use_length)
+ payload_size -= hexnumlen (todo);
todo = min (todo, payload_size);
- break;
- case PACKET_DISABLE:
- *p++ = 'M';
+ }
+ else
+ {
/* Num bytes that will fit. */
todo = min (len, payload_size / 2);
- payload_size -= hexnumlen (todo);
+ if (use_length)
+ payload_size -= hexnumlen (todo);
todo = min (todo, payload_size / 2);
- break;
- case PACKET_SUPPORT_UNKNOWN:
- internal_error (__FILE__, __LINE__,
- _("remote_write_bytes: bad internal state"));
- default:
- internal_error (__FILE__, __LINE__, _("bad switch"));
}
+
if (todo <= 0)
internal_error (__FILE__, __LINE__,
_("minumum packet size too small to write data"));
memaddr = remote_address_masked (memaddr);
p += hexnumstr (p, (ULONGEST) memaddr);
- /* Append ",". */
- *p++ = ',';
+ if (use_length)
+ {
+ /* Append ",". */
+ *p++ = ',';
- /* Append <len>. Retain the location/size of <len>. It may need to
- be adjusted once the packet body has been created. */
- plen = p;
- plenlen = hexnumstr (p, (ULONGEST) todo);
- p += plenlen;
+ /* Append <len>. Retain the location/size of <len>. It may need to
+ be adjusted once the packet body has been created. */
+ plen = p;
+ plenlen = hexnumstr (p, (ULONGEST) todo);
+ p += plenlen;
+ }
/* Append ":". */
*p++ = ':';
*p = '\0';
/* Append the packet body. */
- switch (remote_protocol_packets[PACKET_X].support)
+ if (packet_format == 'X')
{
- case PACKET_ENABLE:
/* Binary mode. Send target system values byte by byte, in
increasing byte addresses. Only escape certain critical
characters. */
payload_size);
/* If not all TODO bytes fit, then we'll need another packet. Make
- a second try to keep the end of the packet aligned. */
- if (nr_bytes < todo)
+ a second try to keep the end of the packet aligned. Don't do
+ this if the packet is tiny. */
+ if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
{
int new_nr_bytes;
}
p += payload_length;
- if (nr_bytes < todo)
+ if (use_length && nr_bytes < todo)
{
/* Escape chars have filled up the buffer prematurely,
and we have actually sent fewer bytes than planned.
plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
*plen = ':'; /* overwrite \0 from hexnumnstr() */
}
- break;
- case PACKET_DISABLE:
+ }
+ else
+ {
/* Normal mode: Send target system values byte by byte, in
increasing byte addresses. Each byte is encoded as a two hex
value. */
nr_bytes = bin2hex (myaddr, p, todo);
p += 2 * nr_bytes;
- break;
- case PACKET_SUPPORT_UNKNOWN:
- internal_error (__FILE__, __LINE__,
- _("remote_write_bytes: bad internal state"));
- default:
- internal_error (__FILE__, __LINE__, _("bad switch"));
}
- putpkt_binary (buf, (int) (p - buf));
+ putpkt_binary (rs->buf, (int) (p - rs->buf));
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'E')
+ if (rs->buf[0] == 'E')
{
/* There is no correspondance between what the remote protocol
uses for errors and errno codes. We would like a cleaner way
return nr_bytes;
}
+/* Write memory data directly to the remote machine.
+ This does not inform the data cache; the data cache uses this.
+ MEMADDR is the address in the remote memory space.
+ MYADDR is the address of the buffer in our space.
+ LEN is the number of bytes.
+
+ Returns number of bytes transferred, or 0 (setting errno) for
+ error. Only transfer a single packet. */
+
+int
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+{
+ char *packet_format = 0;
+
+ /* Check whether the target supports binary download. */
+ check_binary_download (memaddr);
+
+ switch (remote_protocol_packets[PACKET_X].support)
+ {
+ case PACKET_ENABLE:
+ packet_format = "X";
+ break;
+ case PACKET_DISABLE:
+ packet_format = "M";
+ break;
+ case PACKET_SUPPORT_UNKNOWN:
+ internal_error (__FILE__, __LINE__,
+ _("remote_write_bytes: bad internal state"));
+ default:
+ internal_error (__FILE__, __LINE__, _("bad switch"));
+ }
+
+ return remote_write_bytes_aux (packet_format,
+ memaddr, myaddr, len, packet_format[0], 1);
+}
+
/* Read memory data directly from the remote machine.
This does not use the data cache; the data cache uses this.
MEMADDR is the address in the remote memory space.
remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
struct remote_state *rs = get_remote_state ();
- char *buf;
int max_buf_size; /* Max size of packet output buffer. */
int origlen;
max_buf_size = get_memory_read_packet_size ();
/* The packet buffer will be large enough for the payload;
get_memory_packet_size ensures this. */
- buf = rs->buf;
origlen = len;
while (len > 0)
todo = min (len, max_buf_size / 2); /* num bytes that will fit */
/* construct "m"<memaddr>","<len>" */
- /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
+ /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
memaddr = remote_address_masked (memaddr);
- p = buf;
+ p = rs->buf;
*p++ = 'm';
p += hexnumstr (p, (ULONGEST) memaddr);
*p++ = ',';
p += hexnumstr (p, (ULONGEST) todo);
*p = '\0';
- putpkt (buf);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'E'
- && isxdigit (buf[1]) && isxdigit (buf[2])
- && buf[3] == '\0')
+ if (rs->buf[0] == 'E'
+ && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
+ && rs->buf[3] == '\0')
{
/* There is no correspondance between what the remote
protocol uses for errors and errno codes. We would like
/* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
- p = buf;
+ p = rs->buf;
if ((i = hex2bin (p, myaddr, todo)) < todo)
{
/* Reply is short. This means that we were able to read
return res;
}
+/* Sends a packet with content determined by the printf format string
+ FORMAT and the remaining arguments, then gets the reply. Returns
+ whether the packet was a success, a failure, or unknown. */
+
+enum packet_result
+remote_send_printf (const char *format, ...)
+{
+ struct remote_state *rs = get_remote_state ();
+ int max_size = get_remote_packet_size ();
+
+ va_list ap;
+ va_start (ap, format);
+
+ rs->buf[0] = '\0';
+ if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
+ internal_error (__FILE__, __LINE__, "Too long remote packet.");
+
+ if (putpkt (rs->buf) < 0)
+ error (_("Communication problem with target."));
+
+ rs->buf[0] = '\0';
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ return packet_check_result (rs->buf);
+}
+
+static void
+restore_remote_timeout (void *p)
+{
+ int value = *(int *)p;
+ remote_timeout = value;
+}
+
+/* Flash writing can take quite some time. We'll set
+ effectively infinite timeout for flash operations.
+ In future, we'll need to decide on a better approach. */
+static const int remote_flash_timeout = 1000;
+
+static void
+remote_flash_erase (struct target_ops *ops,
+ ULONGEST address, LONGEST length)
+{
+ int saved_remote_timeout = remote_timeout;
+ enum packet_result ret;
+
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+ remote_timeout = remote_flash_timeout;
+
+ ret = remote_send_printf ("vFlashErase:%s,%s",
+ paddr (address),
+ phex (length, 4));
+ switch (ret)
+ {
+ case PACKET_UNKNOWN:
+ error (_("Remote target does not support flash erase"));
+ case PACKET_ERROR:
+ error (_("Error erasing flash with vFlashErase packet"));
+ default:
+ break;
+ }
+
+ do_cleanups (back_to);
+}
+
+static LONGEST
+remote_flash_write (struct target_ops *ops,
+ ULONGEST address, LONGEST length,
+ const gdb_byte *data)
+{
+ int saved_remote_timeout = remote_timeout;
+ int ret;
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+
+ remote_timeout = remote_flash_timeout;
+ ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
+ do_cleanups (back_to);
+
+ return ret;
+}
+
+static void
+remote_flash_done (struct target_ops *ops)
+{
+ int saved_remote_timeout = remote_timeout;
+ int ret;
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+
+ remote_timeout = remote_flash_timeout;
+ ret = remote_send_printf ("vFlashDone");
+ do_cleanups (back_to);
+
+ switch (ret)
+ {
+ case PACKET_UNKNOWN:
+ error (_("Remote target does not support vFlashDone"));
+ case PACKET_ERROR:
+ error (_("Error finishing flash operation"));
+ default:
+ break;
+ }
+}
+
static void
remote_files_info (struct target_ops *ignore)
{
return -1;
}
- /* Only handle reads. */
- if (writebuf != NULL || readbuf == NULL)
- return -1;
+ /* Only handle flash writes. */
+ if (writebuf != NULL)
+ {
+ LONGEST xfered;
+
+ switch (object)
+ {
+ case TARGET_OBJECT_FLASH:
+ xfered = remote_flash_write (ops, offset, len, writebuf);
+
+ if (xfered > 0)
+ return xfered;
+ else if (xfered == 0 && errno == 0)
+ return 0;
+ else
+ return -1;
+
+ default:
+ return -1;
+ }
+ }
/* Map pre-existing objects onto letters. DO NOT do this for new
objects!!! Instead specify new query packets. */
return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
&remote_protocol_packets[PACKET_qXfer_auxv]);
+ case TARGET_OBJECT_MEMORY_MAP:
+ gdb_assert (annex == NULL);
+ return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_memory_map]);
+
default:
return -1;
}
struct ui_file *outbuf)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
- char *p = buf;
+ char *p = rs->buf;
if (!remote_desc)
error (_("remote rcmd is only available after target open"));
command = "";
/* The query prefix. */
- strcpy (buf, "qRcmd,");
- p = strchr (buf, '\0');
+ strcpy (rs->buf, "qRcmd,");
+ p = strchr (rs->buf, '\0');
- if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
+ if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
error (_("\"monitor\" command ``%s'' is too long."), command);
/* Encode the actual command. */
/* get/display the response */
while (1)
{
+ char *buf;
+
/* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
- buf[0] = '\0';
+ rs->buf[0] = '\0';
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
if (buf[0] == '\0')
error (_("Target does not support this command."));
if (buf[0] == 'O' && buf[1] != 'K')
}
}
+static VEC(mem_region_s) *
+remote_memory_map (struct target_ops *ops)
+{
+ VEC(mem_region_s) *result = NULL;
+ char *text = target_read_stralloc (¤t_target,
+ TARGET_OBJECT_MEMORY_MAP, NULL);
+
+ if (text)
+ {
+ struct cleanup *back_to = make_cleanup (xfree, text);
+ result = parse_memory_map (text);
+ do_cleanups (back_to);
+ }
+
+ return result;
+}
+
static void
packet_command (char *args, int from_tty)
{
{
static char buf[32];
- xsnprintf (buf, sizeof buf, "thread %d", ptid_get_pid (ptid));
+ xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
return buf;
}
remote_ops.to_has_execution = 1;
remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
remote_ops.to_magic = OPS_MAGIC;
+ remote_ops.to_memory_map = remote_memory_map;
+ remote_ops.to_flash_erase = remote_flash_erase;
+ remote_ops.to_flash_done = remote_flash_done;
}
/* Set up the extended remote vector by making a copy of the standard
remote_async_ops.to_async = remote_async;
remote_async_ops.to_async_mask_value = 1;
remote_async_ops.to_magic = OPS_MAGIC;
+ remote_async_ops.to_memory_map = remote_memory_map;
+ remote_async_ops.to_flash_erase = remote_flash_erase;
+ remote_async_ops.to_flash_done = remote_flash_done;
}
/* Set up the async extended remote vector by making a copy of the standard
of these, not one per target. Only one target is active at a
time. The default buffer size is unimportant; it will be expanded
whenever a larger buffer is needed. */
- rs = get_remote_state ();
+ rs = get_remote_state_raw ();
rs->buf_size = 400;
rs->buf = xmalloc (rs->buf_size);
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_memory_map],
+ "qXfer:memory-map:read", "memory-map", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
"qGetTLSAddr", "get-thread-local-storage-address",
0);