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, HR_ATTACHED);
 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, HR_NONE);
 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: ",
 264               packet.size());
 265           print_packet(packet);
 266           recv_buf.consume(i);
 267           break;
 268         }
 269       }
 270
 271       packet.push_back(b);
 272
 273       // Packets consist of $<packet-data>#<checksum>
 274       // where <checksum> is
 275       if (packet.size() >= 4 &&
 276           packet[packet.size()-3] == '#') {
 277         handle_packet(packet);
 278         recv_buf.consume(i+1);
 279         break;
 280       }
 281     }
 282     // There's a partial packet in the buffer. Wait until we get more data to
 283     // process it.
 284     if (packet.size()) {
 285       break;
 286     }
 287   }
 288 }
 289
 290 void gdbserver_t::handle_halt_reason(const std::vector<uint8_t> &packet)
 291 {
 292   send_packet("S00");
 293 }
 294
 295 void gdbserver_t::handle_general_registers_read(const std::vector<uint8_t> &packet)
 296 {
 297   // Register order that gdb expects is:
 298   //   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 299   //   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
 300   //   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 301   //   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 302   //   "pc",
 303   //   "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 304   //   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 305   //   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 306   //   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 307
 308   // Each byte of register data is described by two hex digits. The bytes with
 309   // the register are transmitted in target byte order. The size of each
 310   // register and their position within the ‘g’ packet are determined by the
 311   // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
 312   // gdbarch_register_name.
 313
 314   send("$");
 315   running_checksum = 0;
 316   processor_t *p = sim->get_core(0);
 317   for (int r = 0; r < 32; r++) {
 318     send(p->state.XPR[r]);
 319   }
 320   send_running_checksum();
 321   expect_ack = true;
 322 }
 323
 324 uint64_t consume_hex_number(std::vector<uint8_t>::const_iterator &iter,
 325     std::vector<uint8_t>::const_iterator end)
 326 {
 327   uint64_t value = 0;
 328
 329   while (iter != end) {
 330     uint8_t c = *iter;
 331     uint64_t c_value = character_hex_value(c);
 332     if (c_value > 15)
 333       break;
 334     iter++;
 335     value <<= 4;
 336     value += c_value;
 337   }
 338   return value;
 339 }
 340
 341 void consume_string(std::string &str, std::vector<uint8_t>::const_iterator &iter,
 342     std::vector<uint8_t>::const_iterator end, uint8_t separator)
 343 {
 344   while (iter != end && *iter != separator) {
 345     str.append(1, (char) *iter);
 346     iter++;
 347   }
 348 }
 349
 350
 351 void gdbserver_t::handle_register_read(const std::vector<uint8_t> &packet)
 352 {
 353   // p n
 354
 355   // Register order that gdb expects is:
 356   //   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 357   //   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
 358   //   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 359   //   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 360   //   "pc",
 361   //   "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 362   //   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 363   //   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 364   //   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 365
 366   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 367   unsigned int n = consume_hex_number(iter, packet.end());
 368   if (*iter != '#')
 369     return send_packet("E01");
 370
 371   processor_t *p = sim->get_core(0);
 372   send("$");
 373   running_checksum = 0;
 374   if (n < 32) {
 375     send(p->state.XPR[n]);
 376   } else if (n == 0x20) {
 377     send(p->state.pc);
 378   } else {
 379     send("E02");
 380   }
 381
 382   send_running_checksum();
 383   expect_ack = true;
 384 }
 385
 386 void gdbserver_t::handle_memory_read(const std::vector<uint8_t> &packet)
 387 {
 388   // m addr,length
 389   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 390   reg_t address = consume_hex_number(iter, packet.end());
 391   if (*iter != ',')
 392     return send_packet("E10");
 393   iter++;
 394   reg_t length = consume_hex_number(iter, packet.end());
 395   if (*iter != '#')
 396     return send_packet("E11");
 397
 398   send("$");
 399   running_checksum = 0;
 400   char buffer[3];
 401   processor_t *p = sim->get_core(0);
 402   mmu_t* mmu = sim->debug_mmu;
 403
 404   for (reg_t i = 0; i < length; i++) {
 405     sprintf(buffer, "%02x", mmu->load_uint8(address + i));
 406     send(buffer);
 407   }
 408   send_running_checksum();
 409 }
 410
 411 void gdbserver_t::handle_memory_binary_write(const std::vector<uint8_t> &packet)
 412 {
 413   // X addr,length:XX...
 414   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 415   reg_t address = consume_hex_number(iter, packet.end());
 416   if (*iter != ',')
 417     return send_packet("E20");
 418   iter++;
 419   reg_t length = consume_hex_number(iter, packet.end());
 420   if (*iter != ':')
 421     return send_packet("E21");
 422   iter++;
 423
 424   processor_t *p = sim->get_core(0);
 425   mmu_t* mmu = sim->debug_mmu;
 426   for (unsigned int i = 0; i < length; i++) {
 427     if (iter == packet.end()) {
 428       return send_packet("E22");
 429     }
 430     mmu->store_uint8(address + i, *iter);
 431     iter++;
 432   }
 433   if (*iter != '#')
 434     return send_packet("E4b"); // EOVERFLOW
 435
 436   send_packet("OK");
 437 }
 438
 439 void gdbserver_t::handle_continue(const std::vector<uint8_t> &packet)
 440 {
 441   // c [addr]
 442   processor_t *p = sim->get_core(0);
 443   if (packet[2] != '#') {
 444     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 445     p->state.pc = consume_hex_number(iter, packet.end());
 446     if (*iter != '#')
 447       return send_packet("E30");
 448   }
 449
 450   p->set_halted(false, HR_NONE);
 451   running = true;
 452 }
 453
 454 void gdbserver_t::handle_step(const std::vector<uint8_t> &packet)
 455 {
 456   // s [addr]
 457   processor_t *p = sim->get_core(0);
 458   if (packet[2] != '#') {
 459     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 460     p->state.pc = consume_hex_number(iter, packet.end());
 461     if (*iter != '#')
 462       return send_packet("E40");
 463   }
 464
 465   p->set_single_step(true);
 466   running = true;
 467 }
 468
 469 void gdbserver_t::handle_kill(const std::vector<uint8_t> &packet)
 470 {
 471   // k
 472   // The exact effect of this packet is not specified.
 473   // Looks like OpenOCD disconnects?
 474   // TODO
 475 }
 476
 477 void gdbserver_t::handle_extended(const std::vector<uint8_t> &packet)
 478 {
 479   // Enable extended mode. In extended mode, the remote server is made
 480   // persistent. The ‘R’ packet is used to restart the program being debugged.
 481   send_packet("OK");
 482   extended_mode = true;
 483 }
 484
 485 void software_breakpoint_t::insert(mmu_t* mmu)
 486 {
 487   if (size == 2) {
 488     instruction = mmu->load_uint16(address);
 489     mmu->store_uint16(address, C_EBREAK);
 490   } else {
 491     instruction = mmu->load_uint32(address);
 492     mmu->store_uint32(address, EBREAK);
 493   }
 494   printf(">>> Read %x from %lx\n", instruction, address);
 495 }
 496
 497 void software_breakpoint_t::remove(mmu_t* mmu)
 498 {
 499   printf(">>> write %x to %lx\n", instruction, address);
 500   if (size == 2) {
 501     mmu->store_uint16(address, instruction);
 502   } else {
 503     mmu->store_uint32(address, instruction);
 504   }
 505 }
 506
 507 void gdbserver_t::handle_breakpoint(const std::vector<uint8_t> &packet)
 508 {
 509   // insert: Z type,addr,kind
 510   // remove: z type,addr,kind
 511
 512   software_breakpoint_t bp;
 513   bool insert = (packet[1] == 'Z');
 514   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 515   int type = consume_hex_number(iter, packet.end());
 516   if (*iter != ',')
 517     return send_packet("E50");
 518   iter++;
 519   bp.address = consume_hex_number(iter, packet.end());
 520   if (*iter != ',')
 521     return send_packet("E51");
 522   iter++;
 523   bp.size = consume_hex_number(iter, packet.end());
 524   // There may be more options after a ; here, but we don't support that.
 525   if (*iter != '#')
 526     return send_packet("E52");
 527
 528   if (bp.size != 2 && bp.size != 4) {
 529     return send_packet("E53");
 530   }
 531
 532   mmu_t* mmu = sim->debug_mmu;
 533   if (insert) {
 534     bp.insert(mmu);
 535     breakpoints[bp.address] = bp;
 536
 537   } else {
 538     bp = breakpoints[bp.address];
 539     bp.remove(mmu);
 540     breakpoints.erase(bp.address);
 541   }
 542   mmu->flush_icache();
 543   processor_t *p = sim->get_core(0);
 544   p->mmu->flush_icache();
 545   return send_packet("OK");
 546 }
 547
 548 void gdbserver_t::handle_query(const std::vector<uint8_t> &packet)
 549 {
 550   std::string name;
 551   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 552
 553   consume_string(name, iter, packet.end(), ':');
 554   if (iter != packet.end())
 555     iter++;
 556   if (name == "Supported") {
 557     send("$");
 558     running_checksum = 0;
 559     while (iter != packet.end()) {
 560       std::string feature;
 561       consume_string(feature, iter, packet.end(), ';');
 562       if (iter != packet.end())
 563         iter++;
 564       printf("is %s supported?\n", feature.c_str());
 565       if (feature == "swbreak+") {
 566         send("swbreak+;");
 567       }
 568     }
 569     return send_running_checksum();
 570   }
 571
 572   printf("Unsupported query %s\n", name.c_str());
 573   return send_packet("");
 574 }
 575
 576 void gdbserver_t::handle_packet(const std::vector<uint8_t> &packet)
 577 {
 578   if (compute_checksum(packet) != extract_checksum(packet)) {
 579     fprintf(stderr, "Received %ld-byte packet with invalid checksum\n", packet.size());
 580     fprintf(stderr, "Computed checksum: %x\n", compute_checksum(packet));
 581     print_packet(packet);
 582     send("-");
 583     return;
 584   }
 585
 586   fprintf(stderr, "Received %ld-byte packet from debug client: ", packet.size());
 587   print_packet(packet);
 588   send("+");
 589
 590   switch (packet[1]) {
 591     case '!':
 592       return handle_extended(packet);
 593     case '?':
 594       return handle_halt_reason(packet);
 595     case 'g':
 596       return handle_general_registers_read(packet);
 597     case 'k':
 598       return handle_kill(packet);
 599     case 'm':
 600       return handle_memory_read(packet);
 601 //    case 'M':
 602 //      return handle_memory_write(packet);
 603     case 'X':
 604       return handle_memory_binary_write(packet);
 605     case 'p':
 606       return handle_register_read(packet);
 607     case 'c':
 608       return handle_continue(packet);
 609     case 's':
 610       return handle_step(packet);
 611     case 'z':
 612     case 'Z':
 613       return handle_breakpoint(packet);
 614     case 'q':
 615     case 'Q':
 616       return handle_query(packet);
 617   }
 618
 619   // Not supported.
 620   fprintf(stderr, "** Unsupported packet: ");
 621   print_packet(packet);
 622   send_packet("");
 623 }
 624
 625 void gdbserver_t::handle_interrupt()
 626 {
 627   processor_t *p = sim->get_core(0);
 628   p->set_halted(true, HR_INTERRUPT);
 629   send_packet("S02");   // Pretend program received SIGINT.
 630   running = false;
 631 }
 632
 633 void gdbserver_t::handle()
 634 {
 635   processor_t *p = sim->get_core(0);
 636   if (running && p->halted) {
 637     // The core was running, but now it's halted. Better tell gdb.
 638     switch (p->halt_reason) {
 639       case HR_NONE:
 640         fprintf(stderr, "Internal error. Processor halted without reason.\n");
 641         abort();
 642       case HR_STEPPED:
 643       case HR_INTERRUPT:
 644       case HR_CMDLINE:
 645       case HR_ATTACHED:
 646         // There's no gdb code for this.
 647         send_packet("T05");
 648         break;
 649       case HR_SWBP:
 650         send_packet("T05swbreak:;");
 651         break;
 652     }
 653     send_packet("T00");
 654     // TODO: Actually include register values here
 655     running = false;
 656   }
 657
 658   if (client_fd > 0) {
 659     this->read();
 660     this->write();
 661
 662   } else {
 663     this->accept();
 664   }
 665
 666   this->process_requests();
 667 }
 668
 669 void gdbserver_t::send(const char* msg)
 670 {
 671   unsigned int length = strlen(msg);
 672   for (const char *c = msg; *c; c++)
 673     running_checksum += *c;
 674   send_buf.append((const uint8_t *) msg, length);
 675 }
 676
 677 void gdbserver_t::send(uint64_t value)
 678 {
 679   char buffer[3];
 680   for (unsigned int i = 0; i < 8; i++) {
 681     sprintf(buffer, "%02x", (int) (value & 0xff));
 682     send(buffer);
 683     value >>= 8;
 684   }
 685 }
 686
 687 void gdbserver_t::send(uint32_t value)
 688 {
 689   char buffer[3];
 690   for (unsigned int i = 0; i < 4; i++) {
 691     sprintf(buffer, "%02x", (int) (value & 0xff));
 692     send(buffer);
 693     value >>= 8;
 694   }
 695 }
 696
 697 void gdbserver_t::send_packet(const char* data)
 698 {
 699   send("$");
 700   running_checksum = 0;
 701   send(data);
 702   send_running_checksum();
 703   expect_ack = true;
 704 }
 705
 706 void gdbserver_t::send_running_checksum()
 707 {
 708   char checksum_string[4];
 709   sprintf(checksum_string, "#%02x", running_checksum);
 710   send(checksum_string);
 711 }