riscv/gdbserver.cc

   1 #include <arpa/inet.h>
   2 #include <errno.h>
   3 #include <fcntl.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <sys/socket.h>
   7 #include <sys/types.h>
   8 #include <unistd.h>
   9
  10 #include <algorithm>
  11 #include <cassert>
  12 #include <cstdio>
  13 #include <vector>
  14
  15 #include "disasm.h"
  16 #include "sim.h"
  17 #include "gdbserver.h"
  18 #include "mmu.h"
  19
  20 template <typename T>
  21 unsigned int circular_buffer_t<T>::size() const
  22 {
  23   if (end >= start)
  24     return end - start;
  25   else
  26     return end + capacity - start;
  27 }
  28
  29 template <typename T>
  30 void circular_buffer_t<T>::consume(unsigned int bytes)
  31 {
  32   start = (start + bytes) % capacity;
  33 }
  34
  35 template <typename T>
  36 unsigned int circular_buffer_t<T>::contiguous_empty_size() const
  37 {
  38   if (end >= start)
  39     if (start == 0)
  40       return capacity - end - 1;
  41     else
  42       return capacity - end;
  43   else
  44     return start - end - 1;
  45 }
  46
  47 template <typename T>
  48 unsigned int circular_buffer_t<T>::contiguous_data_size() const
  49 {
  50   if (end >= start)
  51     return end - start;
  52   else
  53     return capacity - start;
  54 }
  55
  56 template <typename T>
  57 void circular_buffer_t<T>::data_added(unsigned int bytes)
  58 {
  59   end += bytes;
  60   assert(end <= capacity);
  61   if (end == capacity)
  62     end = 0;
  63 }
  64
  65 template <typename T>
  66 void circular_buffer_t<T>::reset()
  67 {
  68   start = 0;
  69   end = 0;
  70 }
  71
  72 template <typename T>
  73 void circular_buffer_t<T>::append(const T *src, unsigned int count)
  74 {
  75   unsigned int copy = std::min(count, contiguous_empty_size());
  76   memcpy(contiguous_empty(), src, copy * sizeof(T));
  77   data_added(copy);
  78   count -= copy;
  79   if (count > 0) {
  80     assert(count < contiguous_empty_size());
  81     memcpy(contiguous_empty(), src, count * sizeof(T));
  82     data_added(count);
  83   }
  84 }
  85
  86 gdbserver_t::gdbserver_t(uint16_t port, sim_t *sim) :
  87   sim(sim),
  88   client_fd(0),
  89   recv_buf(64 * 1024), send_buf(64 * 1024)
  90 {
  91   // TODO: listen on socket
  92   socket_fd = socket(AF_INET, SOCK_STREAM, 0);
  93   if (socket_fd == -1) {
  94     fprintf(stderr, "failed to make socket: %s (%d)\n", strerror(errno), errno);
  95     abort();
  96   }
  97
  98   fcntl(socket_fd, F_SETFL, O_NONBLOCK);
  99
 100   struct sockaddr_in addr;
 101   memset(&addr, 0, sizeof(addr));
 102   addr.sin_family = AF_INET;
 103   addr.sin_addr.s_addr = INADDR_ANY;
 104   addr.sin_port = htons(port);
 105
 106   if (bind(socket_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
 107     fprintf(stderr, "failed to bind socket: %s (%d)\n", strerror(errno), errno);
 108     abort();
 109   }
 110
 111   if (listen(socket_fd, 1) == -1) {
 112     fprintf(stderr, "failed to listen on socket: %s (%d)\n", strerror(errno), errno);
 113     abort();
 114   }
 115 }
 116
 117 void gdbserver_t::accept()
 118 {
 119   client_fd = ::accept(socket_fd, NULL, NULL);
 120   if (client_fd == -1) {
 121     if (errno == EAGAIN) {
 122       // No client waiting to connect right now.
 123     } else {
 124       fprintf(stderr, "failed to accept on socket: %s (%d)\n", strerror(errno),
 125           errno);
 126       abort();
 127     }
 128   } else {
 129     fcntl(client_fd, F_SETFL, O_NONBLOCK);
 130
 131     expect_ack = false;
 132     extended_mode = false;
 133
 134     // gdb wants the core to be halted when it attaches.
 135     processor_t *p = sim->get_core(0);
 136     p->set_halted(true);
 137   }
 138 }
 139
 140 void gdbserver_t::read()
 141 {
 142   // Reading from a non-blocking socket still blocks if there is no data
 143   // available.
 144
 145   size_t count = recv_buf.contiguous_empty_size();
 146   assert(count > 0);
 147   ssize_t bytes = ::read(client_fd, recv_buf.contiguous_empty(), count);
 148   if (bytes == -1) {
 149     if (errno == EAGAIN) {
 150       // We'll try again the next call.
 151     } else {
 152       fprintf(stderr, "failed to read on socket: %s (%d)\n", strerror(errno), errno);
 153       abort();
 154     }
 155   } else if (bytes == 0) {
 156     // The remote disconnected.
 157     client_fd = 0;
 158     processor_t *p = sim->get_core(0);
 159     p->set_halted(false);
 160     recv_buf.reset();
 161     send_buf.reset();
 162   } else {
 163     recv_buf.data_added(bytes);
 164   }
 165 }
 166
 167 void gdbserver_t::write()
 168 {
 169   if (send_buf.empty())
 170     return;
 171
 172   while (!send_buf.empty()) {
 173     unsigned int count = send_buf.contiguous_data_size();
 174     assert(count > 0);
 175     ssize_t bytes = ::write(client_fd, send_buf.contiguous_data(), count);
 176     if (bytes == -1) {
 177       fprintf(stderr, "failed to write to socket: %s (%d)\n", strerror(errno), errno);
 178       abort();
 179     } else if (bytes == 0) {
 180       // Client can't take any more data right now.
 181       break;
 182     } else {
 183       printf("wrote %ld bytes: ", bytes);
 184       for (unsigned int i = 0; i < bytes; i++) {
 185         printf("%c", send_buf[i]);
 186       }
 187       printf("\n");
 188       send_buf.consume(bytes);
 189     }
 190   }
 191 }
 192
 193 void print_packet(const std::vector<uint8_t> &packet)
 194 {
 195   for (uint8_t c : packet) {
 196     if (c >= ' ' and c <= '~')
 197       fprintf(stderr, "%c", c);
 198     else
 199       fprintf(stderr, "\\x%x", c);
 200   }
 201   fprintf(stderr, "\n");
 202 }
 203
 204 uint8_t compute_checksum(const std::vector<uint8_t> &packet)
 205 {
 206   uint8_t checksum = 0;
 207   for (auto i = packet.begin() + 1; i != packet.end() - 3; i++ ) {
 208     checksum += *i;
 209   }
 210   return checksum;
 211 }
 212
 213 uint8_t character_hex_value(uint8_t character)
 214 {
 215   if (character >= '0' && character <= '9')
 216     return character - '0';
 217   if (character >= 'a' && character <= 'f')
 218     return 10 + character - 'a';
 219   if (character >= 'A' && character <= 'F')
 220     return 10 + character - 'A';
 221   return 0xff;
 222 }
 223
 224 uint8_t extract_checksum(const std::vector<uint8_t> &packet)
 225 {
 226   return character_hex_value(*(packet.end() - 1)) +
 227     16 * character_hex_value(*(packet.end() - 2));
 228 }
 229
 230 void gdbserver_t::process_requests()
 231 {
 232   // See https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
 233
 234   while (!recv_buf.empty()) {
 235     std::vector<uint8_t> packet;
 236     for (unsigned int i = 0; i < recv_buf.size(); i++) {
 237       uint8_t b = recv_buf[i];
 238
 239       if (packet.empty() && expect_ack && b == '+') {
 240         recv_buf.consume(1);
 241         break;
 242       }
 243
 244       if (packet.empty() && b == 3) {
 245         fprintf(stderr, "Received interrupt\n");
 246         recv_buf.consume(1);
 247         handle_interrupt();
 248         break;
 249       }
 250
 251       if (b == '$') {
 252         // Start of new packet.
 253         if (!packet.empty()) {
 254           fprintf(stderr, "Received malformed %ld-byte packet from debug client: ", packet.size());
 255           print_packet(packet);
 256           recv_buf.consume(i);
 257           break;
 258         }
 259       }
 260
 261       packet.push_back(b);
 262
 263       // Packets consist of $<packet-data>#<checksum>
 264       // where <checksum> is
 265       if (packet.size() >= 4 &&
 266           packet[packet.size()-3] == '#') {
 267         handle_packet(packet);
 268         recv_buf.consume(i+1);
 269         break;
 270       }
 271     }
 272     // There's a partial packet in the buffer. Wait until we get more data to
 273     // process it.
 274     if (packet.size()) {
 275       break;
 276     }
 277   }
 278 }
 279
 280 void gdbserver_t::handle_halt_reason(const std::vector<uint8_t> &packet)
 281 {
 282   send_packet("S00");
 283 }
 284
 285 void gdbserver_t::handle_general_registers_read(const std::vector<uint8_t> &packet)
 286 {
 287   // Register order that gdb expects is:
 288   //   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 289   //   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
 290   //   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 291   //   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 292   //   "pc",
 293   //   "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 294   //   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 295   //   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 296   //   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 297
 298   // Each byte of register data is described by two hex digits. The bytes with
 299   // the register are transmitted in target byte order. The size of each
 300   // register and their position within the ‘g’ packet are determined by the
 301   // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
 302   // gdbarch_register_name.
 303
 304   send("$");
 305   running_checksum = 0;
 306   processor_t *p = sim->get_core(0);
 307   for (int r = 0; r < 32; r++) {
 308     send(p->state.XPR[r]);
 309   }
 310   send_running_checksum();
 311   expect_ack = true;
 312 }
 313
 314 uint64_t consume_hex_number(std::vector<uint8_t>::const_iterator &iter,
 315     std::vector<uint8_t>::const_iterator end)
 316 {
 317   uint64_t value = 0;
 318
 319   while (iter != end) {
 320     uint8_t c = *iter;
 321     uint64_t c_value = character_hex_value(c);
 322     if (c_value > 15)
 323       break;
 324     iter++;
 325     value <<= 4;
 326     value += c_value;
 327   }
 328   return value;
 329 }
 330
 331 void gdbserver_t::handle_register_read(const std::vector<uint8_t> &packet)
 332 {
 333   // p n
 334
 335   // Register order that gdb expects is:
 336   //   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 337   //   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
 338   //   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 339   //   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 340   //   "pc",
 341   //   "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 342   //   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 343   //   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 344   //   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 345
 346   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 347   unsigned int n = consume_hex_number(iter, packet.end());
 348   if (*iter != '#')
 349     return send_packet("E16"); // EINVAL
 350
 351   processor_t *p = sim->get_core(0);
 352   send("$");
 353   running_checksum = 0;
 354   if (n < 32) {
 355     send(p->state.XPR[n]);
 356   } else if (n == 0x20) {
 357     send(p->state.pc);
 358   } else {
 359     send("E16");        // EINVAL
 360   }
 361
 362   send_running_checksum();
 363   expect_ack = true;
 364 }
 365
 366 void gdbserver_t::handle_memory_read(const std::vector<uint8_t> &packet)
 367 {
 368   // m addr,length
 369   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 370   reg_t address = consume_hex_number(iter, packet.end());
 371   if (*iter != ',')
 372     return send_packet("E16"); // EINVAL
 373   iter++;
 374   reg_t length = consume_hex_number(iter, packet.end());
 375   if (*iter != '#')
 376     return send_packet("E16"); // EINVAL
 377
 378   send("$");
 379   running_checksum = 0;
 380   char buffer[3];
 381   processor_t *p = sim->get_core(0);
 382   mmu_t* mmu = sim->debug_mmu;
 383
 384   for (reg_t i = 0; i < length; i++) {
 385     sprintf(buffer, "%02x", mmu->load_uint8(address + i));
 386     send(buffer);
 387   }
 388   send_running_checksum();
 389 }
 390
 391 void gdbserver_t::handle_memory_binary_write(const std::vector<uint8_t> &packet)
 392 {
 393   // X addr,length:XX...
 394   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 395   reg_t address = consume_hex_number(iter, packet.end());
 396   if (*iter != ',')
 397     return send_packet("E16"); // EINVAL
 398   iter++;
 399   reg_t length = consume_hex_number(iter, packet.end());
 400   if (*iter != ':')
 401     return send_packet("E16"); // EINVAL
 402   iter++;
 403
 404   processor_t *p = sim->get_core(0);
 405   mmu_t* mmu = sim->debug_mmu;
 406   for (unsigned int i = 0; i < length; i++) {
 407     if (iter == packet.end()) {
 408       return send_packet("E16"); // EINVAL
 409     }
 410     mmu->store_uint8(address + i, *iter);
 411     iter++;
 412   }
 413   if (*iter != '#')
 414     return send_packet("E4b"); // EOVERFLOW
 415
 416   send_packet("OK");
 417 }
 418
 419 void gdbserver_t::handle_continue(const std::vector<uint8_t> &packet)
 420 {
 421   // c [addr]
 422   processor_t *p = sim->get_core(0);
 423   if (packet[2] != '#') {
 424     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 425     p->state.pc = consume_hex_number(iter, packet.end());
 426     if (*iter != '#')
 427       return send_packet("E16"); // EINVAL
 428   }
 429
 430   p->set_halted(false);
 431   running = true;
 432 }
 433
 434 void gdbserver_t::handle_step(const std::vector<uint8_t> &packet)
 435 {
 436   // s [addr]
 437   processor_t *p = sim->get_core(0);
 438   if (packet[2] != '#') {
 439     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 440     p->state.pc = consume_hex_number(iter, packet.end());
 441     if (*iter != '#')
 442       return send_packet("E16"); // EINVAL
 443   }
 444
 445   p->set_single_step(true);
 446   running = true;
 447 }
 448
 449 void gdbserver_t::handle_kill(const std::vector<uint8_t> &packet)
 450 {
 451   // k
 452   // The exact effect of this packet is not specified.
 453   // Looks like OpenOCD disconnects?
 454   // TODO
 455 }
 456
 457 void gdbserver_t::handle_extended(const std::vector<uint8_t> &packet)
 458 {
 459   // Enable extended mode. In extended mode, the remote server is made
 460   // persistent. The ‘R’ packet is used to restart the program being debugged.
 461   send_packet("OK");
 462   extended_mode = true;
 463 }
 464
 465 void gdbserver_t::handle_packet(const std::vector<uint8_t> &packet)
 466 {
 467   if (compute_checksum(packet) != extract_checksum(packet)) {
 468     fprintf(stderr, "Received %ld-byte packet with invalid checksum\n", packet.size());
 469     fprintf(stderr, "Computed checksum: %x\n", compute_checksum(packet));
 470     print_packet(packet);
 471     send("-");
 472     return;
 473   }
 474
 475   fprintf(stderr, "Received %ld-byte packet from debug client: ", packet.size());
 476   print_packet(packet);
 477   send("+");
 478
 479   switch (packet[1]) {
 480     case '!':
 481       return handle_extended(packet);
 482     case '?':
 483       return handle_halt_reason(packet);
 484     case 'g':
 485       return handle_general_registers_read(packet);
 486     case 'k':
 487       return handle_kill(packet);
 488     case 'm':
 489       return handle_memory_read(packet);
 490 //    case 'M':
 491 //      return handle_memory_write(packet);
 492     case 'X':
 493       return handle_memory_binary_write(packet);
 494     case 'p':
 495       return handle_register_read(packet);
 496     case 'c':
 497       return handle_continue(packet);
 498     case 's':
 499       return handle_step(packet);
 500   }
 501
 502   // Not supported.
 503   fprintf(stderr, "** Unsupported packet: ");
 504   print_packet(packet);
 505   send_packet("");
 506 }
 507
 508 void gdbserver_t::handle_interrupt()
 509 {
 510   processor_t *p = sim->get_core(0);
 511   p->set_halted(true);
 512   send_packet("S02");   // Pretend program received SIGINT.
 513   running = false;
 514 }
 515
 516 void gdbserver_t::handle()
 517 {
 518   processor_t *p = sim->get_core(0);
 519   if (running && p->halted) {
 520     // The core was running, but now it's halted. Better tell gdb.
 521     send_packet("T00");
 522     // TODO: Actually include register values here
 523     running = false;
 524   }
 525
 526   if (client_fd > 0) {
 527     this->read();
 528     this->write();
 529
 530   } else {
 531     this->accept();
 532   }
 533
 534   this->process_requests();
 535 }
 536
 537 void gdbserver_t::send(const char* msg)
 538 {
 539   unsigned int length = strlen(msg);
 540   for (const char *c = msg; *c; c++)
 541     running_checksum += *c;
 542   send_buf.append((const uint8_t *) msg, length);
 543 }
 544
 545 void gdbserver_t::send(uint64_t value)
 546 {
 547   char buffer[3];
 548   for (unsigned int i = 0; i < 8; i++) {
 549     sprintf(buffer, "%02x", (int) (value & 0xff));
 550     send(buffer);
 551     value >>= 8;
 552   }
 553 }
 554
 555 void gdbserver_t::send(uint32_t value)
 556 {
 557   char buffer[3];
 558   for (unsigned int i = 0; i < 4; i++) {
 559     sprintf(buffer, "%02x", (int) (value & 0xff));
 560     send(buffer);
 561     value >>= 8;
 562   }
 563 }
 564
 565 void gdbserver_t::send_packet(const char* data)
 566 {
 567   send("$");
 568   running_checksum = 0;
 569   send(data);
 570   send_running_checksum();
 571   expect_ack = true;
 572 }
 573
 574 void gdbserver_t::send_running_checksum()
 575 {
 576   char checksum_string[4];
 577   sprintf(checksum_string, "#%02x", running_checksum);
 578   send(checksum_string);
 579 }