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       fprintf(stderr, "wrote %ld bytes: ", bytes);
 193       for (unsigned int i = 0; i < bytes; i++) {
 194         fprintf(stderr, "%c", send_buf[i]);
 195       }
 196       fprintf(stderr, "\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 typedef enum {
 351   RC_XPR,
 352   RC_PC,
 353   RC_FPR,
 354   RC_CSR
 355 } register_class_t;
 356
 357 typedef struct {
 358   register_class_t clss;
 359   int index;
 360 } register_access_t;
 361
 362 // gdb's register list is defined in riscv_gdb_reg_names gdb/riscv-tdep.c in
 363 // its source tree. The definition here must match that one.
 364 const register_access_t register_access[] = {
 365   { RC_XPR, 0 },
 366   { RC_XPR, 1 },
 367   { RC_XPR, 2 },
 368   { RC_XPR, 3 },
 369   { RC_XPR, 4 },
 370   { RC_XPR, 5 },
 371   { RC_XPR, 6 },
 372   { RC_XPR, 7 },
 373   { RC_XPR, 8 },
 374   { RC_XPR, 9 },
 375   { RC_XPR, 10 },
 376   { RC_XPR, 11 },
 377   { RC_XPR, 12 },
 378   { RC_XPR, 13 },
 379   { RC_XPR, 14 },
 380   { RC_XPR, 15 },
 381   { RC_XPR, 16 },
 382   { RC_XPR, 17 },
 383   { RC_XPR, 18 },
 384   { RC_XPR, 19 },
 385   { RC_XPR, 20 },
 386   { RC_XPR, 21 },
 387   { RC_XPR, 22 },
 388   { RC_XPR, 23 },
 389   { RC_XPR, 24 },
 390   { RC_XPR, 25 },
 391   { RC_XPR, 26 },
 392   { RC_XPR, 27 },
 393   { RC_XPR, 28 },
 394   { RC_XPR, 29 },
 395   { RC_XPR, 30 },
 396   { RC_XPR, 31 },
 397   { RC_PC, 0 },
 398   { RC_FPR, 0 },
 399   { RC_FPR, 1 },
 400   { RC_FPR, 2 },
 401   { RC_FPR, 3 },
 402   { RC_FPR, 4 },
 403   { RC_FPR, 5 },
 404   { RC_FPR, 6 },
 405   { RC_FPR, 7 },
 406   { RC_FPR, 8 },
 407   { RC_FPR, 9 },
 408   { RC_FPR, 10 },
 409   { RC_FPR, 11 },
 410   { RC_FPR, 12 },
 411   { RC_FPR, 13 },
 412   { RC_FPR, 14 },
 413   { RC_FPR, 15 },
 414   { RC_FPR, 16 },
 415   { RC_FPR, 17 },
 416   { RC_FPR, 18 },
 417   { RC_FPR, 19 },
 418   { RC_FPR, 20 },
 419   { RC_FPR, 21 },
 420   { RC_FPR, 22 },
 421   { RC_FPR, 23 },
 422   { RC_FPR, 24 },
 423   { RC_FPR, 25 },
 424   { RC_FPR, 26 },
 425   { RC_FPR, 27 },
 426   { RC_FPR, 28 },
 427   { RC_FPR, 29 },
 428   { RC_FPR, 30 },
 429   { RC_FPR, 31 },
 430
 431 #define DECLARE_CSR(name, num) { RC_CSR, num },
 432 #include "encoding.h"
 433 #undef DECLARE_CSR
 434 };
 435
 436 void gdbserver_t::handle_register_read(const std::vector<uint8_t> &packet)
 437 {
 438   // p n
 439
 440   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 441   unsigned int n = consume_hex_number(iter, packet.end());
 442   if (*iter != '#')
 443     return send_packet("E01");
 444
 445   if (n >= sizeof(register_access) / sizeof(*register_access))
 446     return send_packet("E02");
 447
 448   processor_t *p = sim->get_core(0);
 449   send("$");
 450   running_checksum = 0;
 451
 452   register_access_t access = register_access[n];
 453   switch (access.clss) {
 454     case RC_XPR:
 455       send(p->state.XPR[access.index]);
 456       break;
 457     case RC_PC:
 458       send(p->state.pc);
 459       break;
 460     case RC_FPR:
 461       send(p->state.FPR[access.index]);
 462       break;
 463     case RC_CSR:
 464       try {
 465         send(p->get_csr(access.index));
 466       } catch(trap_t& t) {
 467         send((reg_t) 0);
 468       }
 469       break;
 470   }
 471
 472   send_running_checksum();
 473   expect_ack = true;
 474 }
 475
 476 void gdbserver_t::handle_memory_read(const std::vector<uint8_t> &packet)
 477 {
 478   // m addr,length
 479   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 480   reg_t address = consume_hex_number(iter, packet.end());
 481   if (*iter != ',')
 482     return send_packet("E10");
 483   iter++;
 484   reg_t length = consume_hex_number(iter, packet.end());
 485   if (*iter != '#')
 486     return send_packet("E11");
 487
 488   send("$");
 489   running_checksum = 0;
 490   char buffer[3];
 491   processor_t *p = sim->get_core(0);
 492   mmu_t* mmu = sim->debug_mmu;
 493
 494   for (reg_t i = 0; i < length; i++) {
 495     sprintf(buffer, "%02x", mmu->load_uint8(address + i));
 496     send(buffer);
 497   }
 498   send_running_checksum();
 499 }
 500
 501 void gdbserver_t::handle_memory_binary_write(const std::vector<uint8_t> &packet)
 502 {
 503   // X addr,length:XX...
 504   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 505   reg_t address = consume_hex_number(iter, packet.end());
 506   if (*iter != ',')
 507     return send_packet("E20");
 508   iter++;
 509   reg_t length = consume_hex_number(iter, packet.end());
 510   if (*iter != ':')
 511     return send_packet("E21");
 512   iter++;
 513
 514   processor_t *p = sim->get_core(0);
 515   mmu_t* mmu = sim->debug_mmu;
 516   for (unsigned int i = 0; i < length; i++) {
 517     if (iter == packet.end()) {
 518       return send_packet("E22");
 519     }
 520     mmu->store_uint8(address + i, *iter);
 521     iter++;
 522   }
 523   if (*iter != '#')
 524     return send_packet("E4b"); // EOVERFLOW
 525
 526   send_packet("OK");
 527 }
 528
 529 void gdbserver_t::handle_continue(const std::vector<uint8_t> &packet)
 530 {
 531   // c [addr]
 532   processor_t *p = sim->get_core(0);
 533   if (packet[2] != '#') {
 534     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 535     p->state.pc = consume_hex_number(iter, packet.end());
 536     if (*iter != '#')
 537       return send_packet("E30");
 538   }
 539
 540   p->set_halted(false, HR_NONE);
 541   running = true;
 542 }
 543
 544 void gdbserver_t::handle_step(const std::vector<uint8_t> &packet)
 545 {
 546   // s [addr]
 547   processor_t *p = sim->get_core(0);
 548   if (packet[2] != '#') {
 549     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 550     p->state.pc = consume_hex_number(iter, packet.end());
 551     if (*iter != '#')
 552       return send_packet("E40");
 553   }
 554
 555   p->set_single_step(true);
 556   running = true;
 557 }
 558
 559 void gdbserver_t::handle_kill(const std::vector<uint8_t> &packet)
 560 {
 561   // k
 562   // The exact effect of this packet is not specified.
 563   // Looks like OpenOCD disconnects?
 564   // TODO
 565 }
 566
 567 void gdbserver_t::handle_extended(const std::vector<uint8_t> &packet)
 568 {
 569   // Enable extended mode. In extended mode, the remote server is made
 570   // persistent. The ‘R’ packet is used to restart the program being debugged.
 571   send_packet("OK");
 572   extended_mode = true;
 573 }
 574
 575 void software_breakpoint_t::insert(mmu_t* mmu)
 576 {
 577   if (size == 2) {
 578     instruction = mmu->load_uint16(address);
 579     mmu->store_uint16(address, C_EBREAK);
 580   } else {
 581     instruction = mmu->load_uint32(address);
 582     mmu->store_uint32(address, EBREAK);
 583   }
 584   fprintf(stderr, ">>> Read %x from %lx\n", instruction, address);
 585 }
 586
 587 void software_breakpoint_t::remove(mmu_t* mmu)
 588 {
 589   fprintf(stderr, ">>> write %x to %lx\n", instruction, address);
 590   if (size == 2) {
 591     mmu->store_uint16(address, instruction);
 592   } else {
 593     mmu->store_uint32(address, instruction);
 594   }
 595 }
 596
 597 void gdbserver_t::handle_breakpoint(const std::vector<uint8_t> &packet)
 598 {
 599   // insert: Z type,addr,kind
 600   // remove: z type,addr,kind
 601
 602   software_breakpoint_t bp;
 603   bool insert = (packet[1] == 'Z');
 604   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 605   int type = consume_hex_number(iter, packet.end());
 606   if (*iter != ',')
 607     return send_packet("E50");
 608   iter++;
 609   bp.address = consume_hex_number(iter, packet.end());
 610   if (*iter != ',')
 611     return send_packet("E51");
 612   iter++;
 613   bp.size = consume_hex_number(iter, packet.end());
 614   // There may be more options after a ; here, but we don't support that.
 615   if (*iter != '#')
 616     return send_packet("E52");
 617
 618   if (bp.size != 2 && bp.size != 4) {
 619     return send_packet("E53");
 620   }
 621
 622   processor_t *p = sim->get_core(0);
 623   mmu_t* mmu = p->mmu;
 624   if (insert) {
 625     bp.insert(mmu);
 626     breakpoints[bp.address] = bp;
 627
 628   } else {
 629     bp = breakpoints[bp.address];
 630     bp.remove(mmu);
 631     breakpoints.erase(bp.address);
 632   }
 633   mmu->flush_icache();
 634   sim->debug_mmu->flush_icache();
 635   return send_packet("OK");
 636 }
 637
 638 void gdbserver_t::handle_query(const std::vector<uint8_t> &packet)
 639 {
 640   std::string name;
 641   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 642
 643   consume_string(name, iter, packet.end(), ':');
 644   if (iter != packet.end())
 645     iter++;
 646   if (name == "Supported") {
 647     send("$");
 648     running_checksum = 0;
 649     while (iter != packet.end()) {
 650       std::string feature;
 651       consume_string(feature, iter, packet.end(), ';');
 652       if (iter != packet.end())
 653         iter++;
 654       if (feature == "swbreak+") {
 655         send("swbreak+;");
 656       }
 657     }
 658     return send_running_checksum();
 659   }
 660
 661   fprintf(stderr, "Unsupported query %s\n", name.c_str());
 662   return send_packet("");
 663 }
 664
 665 void gdbserver_t::handle_packet(const std::vector<uint8_t> &packet)
 666 {
 667   if (compute_checksum(packet) != extract_checksum(packet)) {
 668     fprintf(stderr, "Received %ld-byte packet with invalid checksum\n", packet.size());
 669     fprintf(stderr, "Computed checksum: %x\n", compute_checksum(packet));
 670     print_packet(packet);
 671     send("-");
 672     return;
 673   }
 674
 675   fprintf(stderr, "Received %ld-byte packet from debug client: ", packet.size());
 676   print_packet(packet);
 677   send("+");
 678
 679   switch (packet[1]) {
 680     case '!':
 681       return handle_extended(packet);
 682     case '?':
 683       return handle_halt_reason(packet);
 684     case 'g':
 685       return handle_general_registers_read(packet);
 686     case 'k':
 687       return handle_kill(packet);
 688     case 'm':
 689       return handle_memory_read(packet);
 690 //    case 'M':
 691 //      return handle_memory_write(packet);
 692     case 'X':
 693       return handle_memory_binary_write(packet);
 694     case 'p':
 695       return handle_register_read(packet);
 696     case 'c':
 697       return handle_continue(packet);
 698     case 's':
 699       return handle_step(packet);
 700     case 'z':
 701     case 'Z':
 702       return handle_breakpoint(packet);
 703     case 'q':
 704     case 'Q':
 705       return handle_query(packet);
 706   }
 707
 708   // Not supported.
 709   fprintf(stderr, "** Unsupported packet: ");
 710   print_packet(packet);
 711   send_packet("");
 712 }
 713
 714 void gdbserver_t::handle_interrupt()
 715 {
 716   processor_t *p = sim->get_core(0);
 717   p->set_halted(true, HR_INTERRUPT);
 718   send_packet("S02");   // Pretend program received SIGINT.
 719   running = false;
 720 }
 721
 722 void gdbserver_t::handle()
 723 {
 724   processor_t *p = sim->get_core(0);
 725   if (running && p->halted) {
 726     // The core was running, but now it's halted. Better tell gdb.
 727     switch (p->halt_reason) {
 728       case HR_NONE:
 729         fprintf(stderr, "Internal error. Processor halted without reason.\n");
 730         abort();
 731       case HR_STEPPED:
 732       case HR_INTERRUPT:
 733       case HR_CMDLINE:
 734       case HR_ATTACHED:
 735         // There's no gdb code for this.
 736         send_packet("T05");
 737         break;
 738       case HR_SWBP:
 739         send_packet("T05swbreak:;");
 740         break;
 741     }
 742     send_packet("T00");
 743     // TODO: Actually include register values here
 744     running = false;
 745   }
 746
 747   if (client_fd > 0) {
 748     this->read();
 749     this->write();
 750
 751   } else {
 752     this->accept();
 753   }
 754
 755   this->process_requests();
 756 }
 757
 758 void gdbserver_t::send(const char* msg)
 759 {
 760   unsigned int length = strlen(msg);
 761   for (const char *c = msg; *c; c++)
 762     running_checksum += *c;
 763   send_buf.append((const uint8_t *) msg, length);
 764 }
 765
 766 void gdbserver_t::send(uint64_t value)
 767 {
 768   char buffer[3];
 769   for (unsigned int i = 0; i < 8; i++) {
 770     sprintf(buffer, "%02x", (int) (value & 0xff));
 771     send(buffer);
 772     value >>= 8;
 773   }
 774 }
 775
 776 void gdbserver_t::send(uint32_t value)
 777 {
 778   char buffer[3];
 779   for (unsigned int i = 0; i < 4; i++) {
 780     sprintf(buffer, "%02x", (int) (value & 0xff));
 781     send(buffer);
 782     value >>= 8;
 783   }
 784 }
 785
 786 void gdbserver_t::send_packet(const char* data)
 787 {
 788   send("$");
 789   running_checksum = 0;
 790   send(data);
 791   send_running_checksum();
 792   expect_ack = true;
 793 }
 794
 795 void gdbserver_t::send_running_checksum()
 796 {
 797   char checksum_string[4];
 798   sprintf(checksum_string, "#%02x", running_checksum);
 799   send(checksum_string);
 800 }