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