6 #include <sys/socket.h>
17 #include "gdbserver.h"
20 #define C_EBREAK 0x9002
21 #define EBREAK 0x00100073
24 unsigned int circular_buffer_t
<T
>::size() const
29 return end
+ capacity
- start
;
33 void circular_buffer_t
<T
>::consume(unsigned int bytes
)
35 start
= (start
+ bytes
) % capacity
;
39 unsigned int circular_buffer_t
<T
>::contiguous_empty_size() const
43 return capacity
- end
- 1;
45 return capacity
- end
;
47 return start
- end
- 1;
51 unsigned int circular_buffer_t
<T
>::contiguous_data_size() const
56 return capacity
- start
;
60 void circular_buffer_t
<T
>::data_added(unsigned int bytes
)
63 assert(end
<= capacity
);
69 void circular_buffer_t
<T
>::reset()
76 void circular_buffer_t
<T
>::append(const T
*src
, unsigned int count
)
78 unsigned int copy
= std::min(count
, contiguous_empty_size());
79 memcpy(contiguous_empty(), src
, copy
* sizeof(T
));
83 assert(count
< contiguous_empty_size());
84 memcpy(contiguous_empty(), src
, count
* sizeof(T
));
89 gdbserver_t::gdbserver_t(uint16_t port
, sim_t
*sim
) :
92 recv_buf(64 * 1024), send_buf(64 * 1024)
94 socket_fd
= socket(AF_INET
, SOCK_STREAM
, 0);
95 if (socket_fd
== -1) {
96 fprintf(stderr
, "failed to make socket: %s (%d)\n", strerror(errno
), errno
);
100 fcntl(socket_fd
, F_SETFL
, O_NONBLOCK
);
102 if (setsockopt(socket_fd
, SOL_SOCKET
, SO_REUSEADDR
, &reuseaddr
,
103 sizeof(int)) == -1) {
104 fprintf(stderr
, "failed setsockopt: %s (%d)\n", strerror(errno
), errno
);
108 struct sockaddr_in addr
;
109 memset(&addr
, 0, sizeof(addr
));
110 addr
.sin_family
= AF_INET
;
111 addr
.sin_addr
.s_addr
= INADDR_ANY
;
112 addr
.sin_port
= htons(port
);
114 if (bind(socket_fd
, (struct sockaddr
*) &addr
, sizeof(addr
)) == -1) {
115 fprintf(stderr
, "failed to bind socket: %s (%d)\n", strerror(errno
), errno
);
119 if (listen(socket_fd
, 1) == -1) {
120 fprintf(stderr
, "failed to listen on socket: %s (%d)\n", strerror(errno
), errno
);
125 void gdbserver_t::accept()
127 client_fd
= ::accept(socket_fd
, NULL
, NULL
);
128 if (client_fd
== -1) {
129 if (errno
== EAGAIN
) {
130 // No client waiting to connect right now.
132 fprintf(stderr
, "failed to accept on socket: %s (%d)\n", strerror(errno
),
137 fcntl(client_fd
, F_SETFL
, O_NONBLOCK
);
140 extended_mode
= false;
142 // gdb wants the core to be halted when it attaches.
143 processor_t
*p
= sim
->get_core(0);
148 void gdbserver_t::read()
150 // Reading from a non-blocking socket still blocks if there is no data
153 size_t count
= recv_buf
.contiguous_empty_size();
155 ssize_t bytes
= ::read(client_fd
, recv_buf
.contiguous_empty(), count
);
157 if (errno
== EAGAIN
) {
158 // We'll try again the next call.
160 fprintf(stderr
, "failed to read on socket: %s (%d)\n", strerror(errno
), errno
);
163 } else if (bytes
== 0) {
164 // The remote disconnected.
166 processor_t
*p
= sim
->get_core(0);
167 // TODO p->set_halted(false, HR_NONE);
171 recv_buf
.data_added(bytes
);
175 void gdbserver_t::write()
177 if (send_buf
.empty())
180 while (!send_buf
.empty()) {
181 unsigned int count
= send_buf
.contiguous_data_size();
183 ssize_t bytes
= ::write(client_fd
, send_buf
.contiguous_data(), count
);
185 fprintf(stderr
, "failed to write to socket: %s (%d)\n", strerror(errno
), errno
);
187 } else if (bytes
== 0) {
188 // Client can't take any more data right now.
191 fprintf(stderr
, "wrote %ld bytes: ", bytes
);
192 for (unsigned int i
= 0; i
< bytes
; i
++) {
193 fprintf(stderr
, "%c", send_buf
[i
]);
195 fprintf(stderr
, "\n");
196 send_buf
.consume(bytes
);
201 void print_packet(const std::vector
<uint8_t> &packet
)
203 for (uint8_t c
: packet
) {
204 if (c
>= ' ' and c
<= '~')
205 fprintf(stderr
, "%c", c
);
207 fprintf(stderr
, "\\x%x", c
);
209 fprintf(stderr
, "\n");
212 uint8_t compute_checksum(const std::vector
<uint8_t> &packet
)
214 uint8_t checksum
= 0;
215 for (auto i
= packet
.begin() + 1; i
!= packet
.end() - 3; i
++ ) {
221 uint8_t character_hex_value(uint8_t character
)
223 if (character
>= '0' && character
<= '9')
224 return character
- '0';
225 if (character
>= 'a' && character
<= 'f')
226 return 10 + character
- 'a';
227 if (character
>= 'A' && character
<= 'F')
228 return 10 + character
- 'A';
232 uint8_t extract_checksum(const std::vector
<uint8_t> &packet
)
234 return character_hex_value(*(packet
.end() - 1)) +
235 16 * character_hex_value(*(packet
.end() - 2));
238 void gdbserver_t::process_requests()
240 // See https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
242 while (!recv_buf
.empty()) {
243 std::vector
<uint8_t> packet
;
244 for (unsigned int i
= 0; i
< recv_buf
.size(); i
++) {
245 uint8_t b
= recv_buf
[i
];
247 if (packet
.empty() && expect_ack
&& b
== '+') {
252 if (packet
.empty() && b
== 3) {
253 fprintf(stderr
, "Received interrupt\n");
260 // Start of new packet.
261 if (!packet
.empty()) {
262 fprintf(stderr
, "Received malformed %ld-byte packet from debug client: ",
264 print_packet(packet
);
272 // Packets consist of $<packet-data>#<checksum>
273 // where <checksum> is
274 if (packet
.size() >= 4 &&
275 packet
[packet
.size()-3] == '#') {
276 handle_packet(packet
);
277 recv_buf
.consume(i
+1);
281 // There's a partial packet in the buffer. Wait until we get more data to
289 void gdbserver_t::handle_halt_reason(const std::vector
<uint8_t> &packet
)
294 void gdbserver_t::handle_general_registers_read(const std::vector
<uint8_t> &packet
)
296 // Register order that gdb expects is:
297 // "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
298 // "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
299 // "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
300 // "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
302 // Each byte of register data is described by two hex digits. The bytes with
303 // the register are transmitted in target byte order. The size of each
304 // register and their position within the ‘g’ packet are determined by the
305 // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
306 // gdbarch_register_name.
309 running_checksum
= 0;
310 processor_t
*p
= sim
->get_core(0);
311 for (int r
= 0; r
< 32; r
++) {
312 send(p
->state
.XPR
[r
]);
314 send_running_checksum();
318 // First byte is the most-significant one.
319 // Eg. "08675309" becomes 0x08675309.
320 uint64_t consume_hex_number(std::vector
<uint8_t>::const_iterator
&iter
,
321 std::vector
<uint8_t>::const_iterator end
)
325 while (iter
!= end
) {
327 uint64_t c_value
= character_hex_value(c
);
337 // First byte is the least-significant one.
338 // Eg. "08675309" becomes 0x09536708
339 uint64_t consume_hex_number_le(std::vector
<uint8_t>::const_iterator
&iter
,
340 std::vector
<uint8_t>::const_iterator end
)
343 unsigned int shift
= 4;
345 while (iter
!= end
) {
347 uint64_t c_value
= character_hex_value(c
);
351 value
|= c_value
<< shift
;
352 if ((shift
% 8) == 0)
360 void consume_string(std::string
&str
, std::vector
<uint8_t>::const_iterator
&iter
,
361 std::vector
<uint8_t>::const_iterator end
, uint8_t separator
)
363 while (iter
!= end
&& *iter
!= separator
) {
364 str
.append(1, (char) *iter
);
369 // gdb's register list is defined in riscv_gdb_reg_names gdb/riscv-tdep.c in
370 // its source tree. We must interpret the numbers the same here.
382 void gdbserver_t::handle_register_read(const std::vector
<uint8_t> &packet
)
386 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
387 unsigned int n
= consume_hex_number(iter
, packet
.end());
389 return send_packet("E01");
391 processor_t
*p
= sim
->get_core(0);
393 running_checksum
= 0;
395 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
396 send(p
->state
.XPR
[n
- REG_XPR0
]);
397 } else if (n
== REG_PC
) {
399 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
400 send(p
->state
.FPR
[n
- REG_FPR0
]);
401 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
403 send(p
->get_csr(n
- REG_CSR0
));
405 // It would be nicer to return an error here, but if you do that then gdb
406 // exits out of 'info registers all' as soon as it encounters a register
407 // that can't be read.
411 return send_packet("E02");
414 send_running_checksum();
418 void gdbserver_t::handle_register_write(const std::vector
<uint8_t> &packet
)
422 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
423 unsigned int n
= consume_hex_number(iter
, packet
.end());
425 return send_packet("E05");
428 reg_t value
= consume_hex_number_le(iter
, packet
.end());
430 return send_packet("E06");
432 processor_t
*p
= sim
->get_core(0);
434 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
435 p
->state
.XPR
.write(n
- REG_XPR0
, value
);
436 } else if (n
== REG_PC
) {
438 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
439 p
->state
.FPR
.write(n
- REG_FPR0
, value
);
440 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
442 p
->set_csr(n
- REG_CSR0
, value
);
444 return send_packet("EFF");
447 return send_packet("E07");
450 return send_packet("OK");
453 void gdbserver_t::handle_memory_read(const std::vector
<uint8_t> &packet
)
456 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
457 reg_t address
= consume_hex_number(iter
, packet
.end());
459 return send_packet("E10");
461 reg_t length
= consume_hex_number(iter
, packet
.end());
463 return send_packet("E11");
466 running_checksum
= 0;
468 processor_t
*p
= sim
->get_core(0);
469 mmu_t
* mmu
= sim
->debug_mmu
;
471 for (reg_t i
= 0; i
< length
; i
++) {
472 sprintf(buffer
, "%02x", mmu
->load_uint8(address
+ i
));
475 send_running_checksum();
478 void gdbserver_t::handle_memory_binary_write(const std::vector
<uint8_t> &packet
)
480 // X addr,length:XX...
481 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
482 reg_t address
= consume_hex_number(iter
, packet
.end());
484 return send_packet("E20");
486 reg_t length
= consume_hex_number(iter
, packet
.end());
488 return send_packet("E21");
491 processor_t
*p
= sim
->get_core(0);
492 mmu_t
* mmu
= sim
->debug_mmu
;
493 for (unsigned int i
= 0; i
< length
; i
++) {
494 if (iter
== packet
.end()) {
495 return send_packet("E22");
497 mmu
->store_uint8(address
+ i
, *iter
);
501 return send_packet("E4b"); // EOVERFLOW
506 void gdbserver_t::handle_continue(const std::vector
<uint8_t> &packet
)
509 processor_t
*p
= sim
->get_core(0);
510 if (packet
[2] != '#') {
511 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
512 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
514 return send_packet("E30");
517 // TODO p->set_halted(false, HR_NONE);
521 void gdbserver_t::handle_step(const std::vector
<uint8_t> &packet
)
524 processor_t
*p
= sim
->get_core(0);
525 if (packet
[2] != '#') {
526 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
527 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
529 return send_packet("E40");
532 // TODO: p->set_single_step(true);
536 void gdbserver_t::handle_kill(const std::vector
<uint8_t> &packet
)
539 // The exact effect of this packet is not specified.
540 // Looks like OpenOCD disconnects?
544 void gdbserver_t::handle_extended(const std::vector
<uint8_t> &packet
)
546 // Enable extended mode. In extended mode, the remote server is made
547 // persistent. The ‘R’ packet is used to restart the program being debugged.
549 extended_mode
= true;
552 void software_breakpoint_t::insert(mmu_t
* mmu
)
555 instruction
= mmu
->load_uint16(address
);
556 mmu
->store_uint16(address
, C_EBREAK
);
558 instruction
= mmu
->load_uint32(address
);
559 mmu
->store_uint32(address
, EBREAK
);
561 fprintf(stderr
, ">>> Read %x from %lx\n", instruction
, address
);
564 void software_breakpoint_t::remove(mmu_t
* mmu
)
566 fprintf(stderr
, ">>> write %x to %lx\n", instruction
, address
);
568 mmu
->store_uint16(address
, instruction
);
570 mmu
->store_uint32(address
, instruction
);
574 void gdbserver_t::handle_breakpoint(const std::vector
<uint8_t> &packet
)
576 // insert: Z type,addr,kind
577 // remove: z type,addr,kind
579 software_breakpoint_t bp
;
580 bool insert
= (packet
[1] == 'Z');
581 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
582 int type
= consume_hex_number(iter
, packet
.end());
584 return send_packet("E50");
586 bp
.address
= consume_hex_number(iter
, packet
.end());
588 return send_packet("E51");
590 bp
.size
= consume_hex_number(iter
, packet
.end());
591 // There may be more options after a ; here, but we don't support that.
593 return send_packet("E52");
595 if (bp
.size
!= 2 && bp
.size
!= 4) {
596 return send_packet("E53");
599 processor_t
*p
= sim
->get_core(0);
603 breakpoints
[bp
.address
] = bp
;
606 bp
= breakpoints
[bp
.address
];
608 breakpoints
.erase(bp
.address
);
611 sim
->debug_mmu
->flush_icache();
612 return send_packet("OK");
615 void gdbserver_t::handle_query(const std::vector
<uint8_t> &packet
)
618 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
620 consume_string(name
, iter
, packet
.end(), ':');
621 if (iter
!= packet
.end())
623 if (name
== "Supported") {
625 running_checksum
= 0;
626 while (iter
!= packet
.end()) {
628 consume_string(feature
, iter
, packet
.end(), ';');
629 if (iter
!= packet
.end())
631 if (feature
== "swbreak+") {
635 return send_running_checksum();
638 fprintf(stderr
, "Unsupported query %s\n", name
.c_str());
639 return send_packet("");
642 void gdbserver_t::handle_packet(const std::vector
<uint8_t> &packet
)
644 if (compute_checksum(packet
) != extract_checksum(packet
)) {
645 fprintf(stderr
, "Received %ld-byte packet with invalid checksum\n", packet
.size());
646 fprintf(stderr
, "Computed checksum: %x\n", compute_checksum(packet
));
647 print_packet(packet
);
652 fprintf(stderr
, "Received %ld-byte packet from debug client: ", packet
.size());
653 print_packet(packet
);
658 return handle_extended(packet
);
660 return handle_halt_reason(packet
);
662 return handle_general_registers_read(packet
);
664 return handle_kill(packet
);
666 return handle_memory_read(packet
);
668 // return handle_memory_write(packet);
670 return handle_memory_binary_write(packet
);
672 return handle_register_read(packet
);
674 return handle_register_write(packet
);
676 return handle_continue(packet
);
678 return handle_step(packet
);
681 return handle_breakpoint(packet
);
684 return handle_query(packet
);
688 fprintf(stderr
, "** Unsupported packet: ");
689 print_packet(packet
);
693 void gdbserver_t::handle_interrupt()
695 processor_t
*p
= sim
->get_core(0);
696 // TODO p->set_halted(true, HR_INTERRUPT);
697 send_packet("S02"); // Pretend program received SIGINT.
701 void gdbserver_t::handle()
704 processor_t
*p
= sim
->get_core(0);
706 if (running && p->halted) {
707 // The core was running, but now it's halted. Better tell gdb.
708 switch (p->halt_reason) {
710 fprintf(stderr, "Internal error. Processor halted without reason.\n");
716 // There's no gdb code for this.
720 send_packet("T05swbreak:;");
724 // TODO: Actually include register values here
736 this->process_requests();
739 void gdbserver_t::send(const char* msg
)
741 unsigned int length
= strlen(msg
);
742 for (const char *c
= msg
; *c
; c
++)
743 running_checksum
+= *c
;
744 send_buf
.append((const uint8_t *) msg
, length
);
747 void gdbserver_t::send(uint64_t value
)
750 for (unsigned int i
= 0; i
< 8; i
++) {
751 sprintf(buffer
, "%02x", (int) (value
& 0xff));
757 void gdbserver_t::send(uint32_t value
)
760 for (unsigned int i
= 0; i
< 4; i
++) {
761 sprintf(buffer
, "%02x", (int) (value
& 0xff));
767 void gdbserver_t::send_packet(const char* data
)
770 running_checksum
= 0;
772 send_running_checksum();
776 void gdbserver_t::send_running_checksum()
778 char checksum_string
[4];
779 sprintf(checksum_string
, "#%02x", running_checksum
);
780 send(checksum_string
);