gdbstub.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: gdbstub.cc,v 1.32 2008/02/15 19:03:53 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2002-2006  The Bochs Project Team
   6 //
   7 //  This library is free software; you can redistribute it and/or
   8 //  modify it under the terms of the GNU Lesser General Public
   9 //  License as published by the Free Software Foundation; either
  10 //  version 2 of the License, or (at your option) any later version.
  11 //
  12 //  This library is distributed in the hope that it will be useful,
  13 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 //  Lesser General Public License for more details.
  16 //
  17 //  You should have received a copy of the GNU Lesser General Public
  18 //  License along with this library; if not, write to the Free Software
  19 //  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <sys/types.h>
  24 #ifdef __MINGW32__
  25 #include <winsock2.h>
  26 #define SIGTRAP 5
  27 #else
  28 #include <sys/socket.h>
  29 #include <netinet/in.h>
  30 #include <netinet/tcp.h>
  31 #include <arpa/inet.h>
  32 #include <signal.h>
  33 #include <netdb.h>
  34 #endif
  35
  36 #define NEED_CPU_REG_SHORTCUTS 1
  37
  38 #include "bochs.h"
  39 #include "cpu/cpu.h"
  40 #include "iodev/iodev.h"
  41
  42 #define LOG_THIS gdbstublog->
  43 #define IFDBG(x) x
  44
  45 static int last_stop_reason = GDBSTUB_STOP_NO_REASON;
  46
  47 #define GDBSTUB_EXECUTION_BREAKPOINT    (0xac1)
  48 #define GDBSTUB_TRACE                   (0xac2)
  49 #define GDBSTUB_USER_BREAK              (0xac3)
  50
  51 static bx_list_c *gdbstub_list;
  52 static int listen_socket_fd;
  53 static int socket_fd;
  54 static logfunctions *gdbstublog;
  55
  56 static int hex(char ch)
  57 {
  58   if ((ch >= 'a') && (ch <= 'f')) return(ch - 'a' + 10);
  59   if ((ch >= '0') && (ch <= '9')) return(ch - '0');
  60   if ((ch >= 'A') && (ch <= 'F')) return(ch - 'A' + 10);
  61   return(-1);
  62 }
  63
  64 static char buf[4096], *bufptr = buf;
  65
  66 static void flush_debug_buffer()
  67 {
  68   char *p = buf;
  69   while (p != bufptr) {
  70     int n = send(socket_fd, p, bufptr-p, 0);
  71     if (n == -1) {
  72       BX_ERROR(("error on debug socket: %m"));
  73       break;
  74     }
  75     p += n;
  76   }
  77   bufptr = buf;
  78 }
  79
  80 static void put_debug_char(char ch)
  81 {
  82   if (bufptr == buf + sizeof buf)
  83     flush_debug_buffer();
  84   *bufptr++ = ch;
  85 }
  86
  87 static char get_debug_char(void)
  88 {
  89   char ch;
  90
  91   recv(socket_fd, &ch, 1, 0);
  92
  93   return(ch);
  94 }
  95
  96 static const char hexchars[]="0123456789abcdef";
  97
  98 static void put_reply(char* buffer)
  99 {
 100   unsigned char csum;
 101   int i;
 102
 103   BX_DEBUG (("put_buffer %s", buffer));
 104
 105   do {
 106     put_debug_char('$');
 107
 108     csum = 0;
 109
 110     i = 0;
 111     while (buffer[i] != 0)
 112     {
 113       put_debug_char(buffer[i]);
 114       csum = csum + buffer[i];
 115       i++;
 116     }
 117
 118     put_debug_char('#');
 119     put_debug_char(hexchars[csum >> 4]);
 120     put_debug_char(hexchars[csum % 16]);
 121     flush_debug_buffer();
 122   } while (get_debug_char() != '+');
 123 }
 124
 125 static void get_command(char* buffer)
 126 {
 127   unsigned char checksum;
 128   unsigned char xmitcsum;
 129   char ch;
 130   unsigned int count;
 131   unsigned int i;
 132
 133   do {
 134     while ((ch = get_debug_char()) != '$');
 135
 136     checksum = 0;
 137     xmitcsum = 0;
 138     count = 0;
 139
 140     while (1)
 141     {
 142       ch = get_debug_char();
 143       if (ch == '#') break;
 144       checksum = checksum + ch;
 145       buffer[count] = ch;
 146       count++;
 147     }
 148     buffer[count] = 0;
 149
 150     if (ch == '#')
 151     {
 152       xmitcsum = hex(get_debug_char()) << 4;
 153       xmitcsum += hex(get_debug_char());
 154       if (checksum != xmitcsum)
 155       {
 156         BX_INFO(("Bad checksum"));
 157       }
 158     }
 159
 160     if (checksum != xmitcsum)
 161     {
 162       put_debug_char('-');
 163       flush_debug_buffer();
 164     }
 165     else
 166     {
 167       put_debug_char('+');
 168       if (buffer[2] == ':')
 169       {
 170         put_debug_char(buffer[0]);
 171         put_debug_char(buffer[1]);
 172         count = strlen(buffer);
 173         for (i = 3; i <= count; i++)
 174         {
 175           buffer[i - 3] = buffer[i];
 176         }
 177       }
 178       flush_debug_buffer();
 179     }
 180   } while (checksum != xmitcsum);
 181 }
 182
 183 void hex2mem(char* buf, unsigned char* mem, int count)
 184 {
 185   int i;
 186   unsigned char ch;
 187
 188   for (i = 0; i<count; i++)
 189   {
 190     ch = hex(*buf++) << 4;
 191     ch = ch + hex(*buf++);
 192     *mem = ch;
 193     mem++;
 194   }
 195 }
 196
 197 char* mem2hex(char* mem, char* buf, int count)
 198 {
 199   int i;
 200   unsigned char ch;
 201
 202   for (i = 0; i<count; i++)
 203   {
 204     ch = *mem;
 205     mem++;
 206     *buf = hexchars[ch >> 4];
 207     buf++;
 208     *buf = hexchars[ch % 16];
 209     buf++;
 210   }
 211   *buf = 0;
 212   return(buf);
 213 }
 214
 215 int hexdigit(char c)
 216 {
 217   if (isdigit(c))
 218     return c - '0';
 219   else if (isupper(c))
 220     return c - 'A' + 10;
 221   else
 222     return c - 'a' + 10;
 223 }
 224
 225 Bit64u read_little_endian_hex(char *&buf)
 226 {
 227   int byte;
 228   Bit64u ret = 0;
 229   int n = 0;
 230   while (isxdigit(*buf)) {
 231     byte = hexdigit(*buf++);
 232     if (isxdigit(*buf))
 233       byte = (byte << 4) | hexdigit(*buf++);
 234     ret |= (unsigned long long)byte << (n*8);
 235     ++n;
 236   }
 237   return ret;
 238 }
 239
 240 static int continue_thread = -1;
 241 static int other_thread = 0;
 242
 243 #if !BX_SUPPORT_X86_64
 244 #define NUMREGS (16)
 245 #define NUMREGSBYTES (NUMREGS * 4)
 246 static int registers[NUMREGS];
 247 #endif
 248
 249 #define MAX_BREAKPOINTS (255)
 250 static unsigned int breakpoints[MAX_BREAKPOINTS] = {0,};
 251 static unsigned int nr_breakpoints = 0;
 252
 253 static int stub_trace_flag = 0;
 254 static int instr_count = 0;
 255 static int saved_eip = 0;
 256 static int bx_enter_gdbstub = 0;
 257
 258 void bx_gdbstub_break(void)
 259 {
 260   bx_enter_gdbstub = 1;
 261 }
 262
 263 int bx_gdbstub_check(unsigned int eip)
 264 {
 265   unsigned int i;
 266   unsigned char ch;
 267   long arg;
 268   int r;
 269 #if defined(__CYGWIN__) || defined(__MINGW32__)
 270   fd_set fds;
 271   struct timeval tv = {0, 0};
 272 #endif
 273
 274   if (bx_enter_gdbstub)
 275   {
 276     bx_enter_gdbstub = 0;
 277     last_stop_reason = GDBSTUB_EXECUTION_BREAKPOINT;
 278     return GDBSTUB_EXECUTION_BREAKPOINT;
 279   }
 280
 281   instr_count++;
 282
 283   if ((instr_count % 500) == 0)
 284   {
 285 #if !defined(__CYGWIN__) && !defined(__MINGW32__)
 286     arg = fcntl(socket_fd, F_GETFL);
 287     fcntl(socket_fd, F_SETFL, arg | O_NONBLOCK);
 288     r = recv(socket_fd, &ch, 1, 0);
 289     fcntl(socket_fd, F_SETFL, arg);
 290 #else
 291     FD_ZERO(&fds);
 292     FD_SET(socket_fd, &fds);
 293     r = select(socket_fd + 1, &fds, NULL, NULL, &tv);
 294     if (r == 1)
 295     {
 296       r = recv(socket_fd, (char *)&ch, 1, 0);
 297     }
 298 #endif
 299     if (r == 1)
 300     {
 301       BX_INFO(("Got byte %x", (unsigned int)ch));
 302       last_stop_reason = GDBSTUB_USER_BREAK;
 303       return GDBSTUB_USER_BREAK;
 304     }
 305   }
 306
 307   for (i = 0; i < nr_breakpoints; i++)
 308   {
 309     if (eip == breakpoints[i])
 310     {
 311       BX_INFO(("found breakpoint at %x", eip));
 312       last_stop_reason = GDBSTUB_EXECUTION_BREAKPOINT;
 313       return GDBSTUB_EXECUTION_BREAKPOINT;
 314     }
 315   }
 316
 317   if (stub_trace_flag == 1)
 318   {
 319     last_stop_reason = GDBSTUB_TRACE;
 320     return GDBSTUB_TRACE;
 321   }
 322   last_stop_reason = GDBSTUB_STOP_NO_REASON;
 323   return GDBSTUB_STOP_NO_REASON;
 324 }
 325
 326 static int remove_breakpoint(unsigned int addr, int len)
 327 {
 328   unsigned int i;
 329
 330   if (len != 1)
 331   {
 332     return(0);
 333   }
 334
 335   for (i = 0; i < MAX_BREAKPOINTS; i++)
 336   {
 337     if (breakpoints[i] == addr)
 338     {
 339       BX_INFO(("Removing breakpoint at %x", addr));
 340       breakpoints[i] = 0;
 341       return(1);
 342     }
 343   }
 344   return(0);
 345 }
 346
 347 static void insert_breakpoint(unsigned int addr)
 348 {
 349   unsigned int i;
 350
 351   BX_INFO(("setting breakpoint at %x", addr));
 352
 353   for (i = 0; i < (unsigned)MAX_BREAKPOINTS; i++)
 354   {
 355     if (breakpoints[i] == 0)
 356     {
 357       breakpoints[i] = addr;
 358       if (i >= nr_breakpoints)
 359       {
 360         nr_breakpoints = i + 1;
 361       }
 362       return;
 363     }
 364   }
 365   BX_INFO(("No slot for breakpoint"));
 366 }
 367
 368 static void do_pc_breakpoint(int insert, unsigned long long addr, int len)
 369 {
 370   for (int i = 0; i < len; ++i)
 371     if (insert)
 372       insert_breakpoint(addr+i);
 373     else
 374       remove_breakpoint(addr+i, 1);
 375 }
 376
 377 static void do_breakpoint(int insert, char* buffer)
 378 {
 379   char* ebuf;
 380   unsigned long type = strtoul(buffer, &ebuf, 16);
 381   unsigned long long addr = strtoull(ebuf+1, &ebuf, 16);
 382   unsigned long len = strtoul(ebuf+1, &ebuf, 16);
 383   switch (type) {
 384   case 0:
 385   case 1:
 386     do_pc_breakpoint(insert, addr, len);
 387     put_reply("OK");
 388     break;
 389   default:
 390     put_reply("");
 391     break;
 392   }
 393 }
 394
 395 static void write_signal(char* buf, int signal)
 396 {
 397   buf[0] = hexchars[signal >> 4];
 398   buf[1] = hexchars[signal % 16];
 399   buf[2] = 0;
 400 }
 401
 402 static int access_linear(Bit64u laddress,
 403                         unsigned len,
 404                         unsigned int rw,
 405                         Bit8u* data)
 406 {
 407   bx_phy_address phys;
 408   bx_bool valid;
 409
 410   if (((laddress & 0xfff) + len) > 4096)
 411   {
 412     valid = access_linear(laddress,
 413                           4096 - (laddress & 0xfff),
 414                           rw,
 415                           data);
 416     if (!valid) return(0);
 417
 418     valid = access_linear(laddress,
 419                           len + (laddress & 0xfff) - 4096,
 420                           rw,
 421                           (Bit8u *)((unsigned long)data +
 422                                     4096 - (laddress & 0xfff)));
 423     return(valid);
 424   }
 425
 426   valid = BX_CPU(0)->dbg_xlate_linear2phy(laddress, (bx_phy_address*)&phys);
 427   if (!valid) return(0);
 428
 429   if (rw == BX_READ) {
 430     valid = BX_MEM(0)->dbg_fetch_mem(BX_CPU(0), phys, len, data);
 431   } else {
 432     valid = BX_MEM(0)->dbg_set_mem(phys, len, data);
 433   }
 434
 435   return(valid);
 436 }
 437
 438 static void debug_loop(void)
 439 {
 440   char buffer[255];
 441   char obuf[255];
 442   int ne;
 443   unsigned char mem[255];
 444
 445   ne = 0;
 446
 447   while (ne == 0)
 448   {
 449     get_command(buffer);
 450     BX_DEBUG(("get_buffer %s", buffer));
 451
 452     switch (buffer[0])
 453     {
 454       case 'c':
 455       {
 456         char buf[255];
 457         Bit32u new_eip;
 458
 459         if (buffer[1] != 0)
 460         {
 461           new_eip = (Bit32u) atoi(buffer + 1);
 462
 463           BX_INFO(("continuing at %x", new_eip));
 464
 465           for (int i=0; i<BX_SMP_PROCESSORS; i++) {
 466             BX_CPU(i)->invalidate_prefetch_q();
 467           }
 468
 469           saved_eip = EIP;
 470           BX_CPU_THIS_PTR gen_reg[BX_32BIT_REG_EIP].dword.erx = new_eip;
 471         }
 472
 473         stub_trace_flag = 0;
 474         bx_cpu.cpu_loop(0);
 475
 476         DEV_vga_refresh();
 477
 478         if (buffer[1] != 0)
 479         {
 480           bx_cpu.invalidate_prefetch_q();
 481           BX_CPU_THIS_PTR gen_reg[BX_32BIT_REG_EIP].dword.erx = saved_eip;
 482         }
 483
 484         BX_INFO(("stopped with %x", last_stop_reason));
 485         buf[0] = 'S';
 486         if (last_stop_reason == GDBSTUB_EXECUTION_BREAKPOINT ||
 487             last_stop_reason == GDBSTUB_TRACE)
 488         {
 489           write_signal(&buf[1], SIGTRAP);
 490         }
 491         else
 492         {
 493           write_signal(&buf[1], 0);
 494         }
 495         put_reply(buf);
 496         break;
 497       }
 498
 499       case 's':
 500       {
 501         char buf[255];
 502
 503         BX_INFO(("stepping"));
 504         stub_trace_flag = 1;
 505         bx_cpu.cpu_loop(0);
 506         DEV_vga_refresh();
 507         stub_trace_flag = 0;
 508         BX_INFO(("stopped with %x", last_stop_reason));
 509         buf[0] = 'S';
 510         if (last_stop_reason == GDBSTUB_EXECUTION_BREAKPOINT ||
 511             last_stop_reason == GDBSTUB_TRACE)
 512         {
 513           write_signal(&buf[1], SIGTRAP);
 514         }
 515         else
 516         {
 517           write_signal(&buf[1], SIGTRAP);
 518         }
 519         put_reply(buf);
 520         break;
 521       }
 522
 523       case 'M':
 524       {
 525         Bit64u addr;
 526         int len;
 527         unsigned char mem[255];
 528         char* ebuf;
 529
 530         addr = strtoull(&buffer[1], &ebuf, 16);
 531         len = strtoul(ebuf + 1, &ebuf, 16);
 532         hex2mem(ebuf + 1, mem, len);
 533
 534         if (len == 1 && mem[0] == 0xcc)
 535         {
 536           insert_breakpoint(addr);
 537           put_reply("OK");
 538         }
 539         else if (remove_breakpoint(addr, len))
 540         {
 541           put_reply("OK");
 542         }
 543         else
 544         {
 545           if (access_linear(addr, len, BX_WRITE, mem))
 546           {
 547             put_reply("OK");
 548           }
 549           else
 550           {
 551             put_reply("Eff");
 552           }
 553         }
 554         break;
 555       }
 556
 557       case 'm':
 558       {
 559         Bit64u addr;
 560         int len;
 561         char* ebuf;
 562
 563         addr = strtoull(&buffer[1], &ebuf, 16);
 564         len = strtoul(ebuf + 1, NULL, 16);
 565         BX_INFO(("addr %Lx len %x", addr, len));
 566
 567         access_linear(addr, len, BX_READ, mem);
 568         mem2hex((char *)mem, obuf, len);
 569         put_reply(obuf);
 570         break;
 571       }
 572
 573       case 'P':
 574       {
 575         int reg;
 576         unsigned long long value;
 577         char* ebuf;
 578
 579         reg = strtoul(&buffer[1], &ebuf, 16);
 580         ++ebuf;
 581         value = read_little_endian_hex(ebuf);
 582
 583         BX_INFO(("reg %d set to %Lx", reg, value));
 584 #if !BX_SUPPORT_X86_64
 585         switch (reg)
 586         {
 587           case 1:
 588           EAX = value;
 589           break;
 590
 591           case 2:
 592             ECX = value;
 593             break;
 594
 595           case 3:
 596             EBX = value;
 597             break;
 598
 599           case 4:
 600             ESP = value;
 601             break;
 602
 603           case 5:
 604             EBP = value;
 605             break;
 606
 607           case 6:
 608             ESI = value;
 609             break;
 610
 611           case 7:
 612             EDI = value;
 613             break;
 614
 615           case 8:
 616             EIP = value;
 617             BX_CPU_THIS_PTR invalidate_prefetch_q();
 618             break;
 619
 620           default:
 621             break;
 622         }
 623 #else
 624         switch (reg)
 625         {
 626           case 0:
 627             RAX = value;
 628             break;
 629
 630           case 1:
 631             RBX = value;
 632             break;
 633
 634           case 2:
 635             RCX = value;
 636             break;
 637
 638           case 3:
 639             RDX = value;
 640             break;
 641
 642           case 4:
 643             RSI = value;
 644             break;
 645
 646           case 5:
 647             RDI = value;
 648             break;
 649
 650           case 6:
 651             ESP = value;
 652             break;
 653
 654           case 7:
 655             RBP = value;
 656             break;
 657
 658           case 8:
 659             R8 = value;
 660             break;
 661
 662           case 9:
 663             R9 = value;
 664             break;
 665
 666           case 10:
 667             R10 = value;
 668             break;
 669
 670           case 11:
 671             R11 = value;
 672             break;
 673
 674           case 12:
 675             R12 = value;
 676             break;
 677
 678           case 13:
 679             R13 = value;
 680             break;
 681
 682           case 14:
 683             R15 = value;
 684             break;
 685
 686           case 15:
 687             R15 = value;
 688             break;
 689
 690           case 16:
 691             RIP = value;
 692             BX_CPU_THIS_PTR invalidate_prefetch_q();
 693             break;
 694
 695           default:
 696             break;
 697         }
 698 #endif
 699         put_reply("OK");
 700
 701         break;
 702       }
 703
 704       case 'g':
 705 #if !BX_SUPPORT_X86_64
 706         registers[0] = EAX;
 707         registers[1] = ECX;
 708         registers[2] = EDX;
 709         registers[3] = EBX;
 710         registers[4] = ESP;
 711         registers[5] = EBP;
 712         registers[6] = ESI;
 713         registers[7] = EDI;
 714         if (last_stop_reason == GDBSTUB_EXECUTION_BREAKPOINT)
 715         {
 716           registers[8] = EIP + 1;
 717         }
 718         else
 719         {
 720           registers[8] = EIP;
 721         }
 722         registers[9] = BX_CPU_THIS_PTR read_eflags();
 723         registers[10] =
 724           BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value;
 725         registers[11] =
 726           BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value;
 727         registers[12] =
 728           BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value;
 729         registers[13] =
 730           BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value;
 731         registers[14] =
 732           BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value;
 733         registers[15] =
 734           BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value;
 735         mem2hex((char *)registers, obuf, NUMREGSBYTES);
 736 #else
 737 #define PUTREG(buf, val, len) do { \
 738          Bit64u u = (val); \
 739          (buf) = mem2hex((char*)&u, (buf), (len)); \
 740       } while (0)
 741         char* buf;
 742         buf = obuf;
 743         PUTREG(buf, RAX, 8);
 744         PUTREG(buf, RBX, 8);
 745         PUTREG(buf, RCX, 8);
 746         PUTREG(buf, RDX, 8);
 747         PUTREG(buf, RSI, 8);
 748         PUTREG(buf, RDI, 8);
 749         PUTREG(buf, RBP, 8);
 750         PUTREG(buf, RSP, 8);
 751         PUTREG(buf, R8,  8);
 752         PUTREG(buf, R9,  8);
 753         PUTREG(buf, R10, 8);
 754         PUTREG(buf, R11, 8);
 755         PUTREG(buf, R12, 8);
 756         PUTREG(buf, R13, 8);
 757         PUTREG(buf, R14, 8);
 758         PUTREG(buf, R15, 8);
 759         Bit64u rip;
 760         rip = RIP;
 761         if (last_stop_reason == GDBSTUB_EXECUTION_BREAKPOINT)
 762         {
 763           ++rip;
 764         }
 765         PUTREG(buf, rip, 8);
 766         PUTREG(buf, BX_CPU_THIS_PTR read_eflags(), 4);
 767         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, 4);
 768         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value, 4);
 769         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value, 4);
 770         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value, 4);
 771         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value, 4);
 772         PUTREG(buf, BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value, 4);
 773 #endif
 774         put_reply(obuf);
 775         break;
 776
 777       case '?':
 778         sprintf(obuf, "S%02x", SIGTRAP);
 779         put_reply(obuf);
 780         break;
 781
 782       case 'H':
 783         if (buffer[1] == 'c')
 784         {
 785           continue_thread = strtol(&buffer[2], NULL, 16);
 786           put_reply("OK");
 787         }
 788         else if (buffer[1] == 'g')
 789         {
 790           other_thread = strtol(&buffer[2], NULL, 16);
 791           put_reply("OK");
 792         }
 793         else
 794         {
 795           put_reply("Eff");
 796         }
 797         break;
 798
 799       case 'q':
 800         if (buffer[1] == 'C')
 801         {
 802           sprintf(obuf,"%Lx", (Bit64u)1);
 803           put_reply(obuf);
 804         }
 805         else if (strncmp(&buffer[1], "Offsets", strlen("Offsets")) == 0)
 806         {
 807           sprintf(obuf, "Text=%x;Data=%x;Bss=%x",
 808                   SIM->get_param_num("text_base", gdbstub_list)->get(),
 809                   SIM->get_param_num("data_base", gdbstub_list)->get(),
 810                   SIM->get_param_num("bss_base", gdbstub_list)->get());
 811           put_reply(obuf);
 812         }
 813         else
 814         {
 815           put_reply("Eff");
 816         }
 817         break;
 818
 819       case 'Z':
 820         do_breakpoint(1, buffer+1);
 821         break;
 822       case 'z':
 823         do_breakpoint(0, buffer+1);
 824         break;
 825       case 'k':
 826         BX_PANIC(("Debugger asked us to quit"));
 827         break;
 828
 829       default:
 830         put_reply("");
 831         break;
 832     }
 833   }
 834 }
 835
 836 static void wait_for_connect(int portn)
 837 {
 838   struct sockaddr_in sockaddr;
 839   socklen_t sockaddr_len;
 840   struct protoent *protoent;
 841   int r;
 842   int opt;
 843
 844   listen_socket_fd = socket(PF_INET, SOCK_STREAM, 0);
 845   if (listen_socket_fd == -1)
 846   {
 847     BX_PANIC(("Failed to create socket"));
 848     exit(1);
 849   }
 850
 851   /* Allow rapid reuse of this port */
 852   opt = 1;
 853 #if __MINGW32__
 854   r = setsockopt(listen_socket_fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
 855 #else
 856   r = setsockopt(listen_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 857 #endif
 858   if (r == -1)
 859   {
 860     BX_INFO(("setsockopt(SO_REUSEADDR) failed"));
 861   }
 862
 863   memset (&sockaddr, '\000', sizeof sockaddr);
 864 #if BX_HAVE_SOCKADDR_IN_SIN_LEN
 865   // if you don't have sin_len change that to #if 0.  This is the subject of
 866   // bug [ 626840 ] no 'sin_len' in 'struct sockaddr_in'.
 867   sockaddr.sin_len = sizeof sockaddr;
 868 #endif
 869   sockaddr.sin_family = AF_INET;
 870   sockaddr.sin_port = htons(portn);
 871   sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 872
 873   r = bind(listen_socket_fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
 874   if (r == -1)
 875   {
 876     BX_PANIC(("Failed to bind socket"));
 877   }
 878
 879   r = listen(listen_socket_fd, 0);
 880   if (r == -1)
 881   {
 882     BX_PANIC(("Failed to listen on socket"));
 883   }
 884
 885   sockaddr_len = sizeof sockaddr;
 886   socket_fd = accept(listen_socket_fd, (struct sockaddr *)&sockaddr, &sockaddr_len);
 887   if (socket_fd == -1)
 888   {
 889     BX_PANIC(("Failed to accept on socket"));
 890   }
 891   close(listen_socket_fd);
 892
 893   protoent = getprotobyname ("tcp");
 894   if (!protoent)
 895   {
 896     BX_INFO(("getprotobyname (\"tcp\") failed"));
 897     return;
 898   }
 899
 900   /* Disable Nagle - allow small packets to be sent without delay. */
 901   opt = 1;
 902 #ifdef __MINGW32__
 903   r = setsockopt (socket_fd, protoent->p_proto, TCP_NODELAY, (const char *)&opt, sizeof(opt));
 904 #else
 905   r = setsockopt (socket_fd, protoent->p_proto, TCP_NODELAY, &opt, sizeof(opt));
 906 #endif
 907   if (r == -1)
 908   {
 909     BX_INFO(("setsockopt(TCP_NODELAY) failed"));
 910   }
 911   Bit32u ip = sockaddr.sin_addr.s_addr;
 912   printf("Connected to %d.%d.%d.%d\n", ip & 0xff, (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff);
 913 }
 914
 915 void bx_gdbstub_init(void)
 916 {
 917   gdbstublog = new logfunctions();
 918   gdbstublog->put("GDBST");
 919   gdbstublog->setonoff(LOGLEV_PANIC, ACT_FATAL);
 920
 921   gdbstub_list = (bx_list_c*) SIM->get_param(BXPN_GDBSTUB);
 922   int portn = SIM->get_param_num("port", gdbstub_list)->get();
 923
 924 #ifdef __MINGW32__
 925   WSADATA wsaData;
 926   WSAStartup(2, &wsaData);
 927 #endif
 928
 929   /* Wait for connect */
 930   printf("Waiting for gdb connection on port %d\n", portn);
 931   wait_for_connect(portn);
 932
 933   /* Do debugger command loop */
 934   debug_loop();
 935
 936   /* CPU loop */
 937   bx_cpu.cpu_loop(0);
 938 }