vcs.maemo.org Git - qemu/blob - qemu-snapshot-2004-11-28_23/gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "vl.h"
  21
  22 #include <sys/socket.h>
  23 #include <netinet/in.h>
  24 #include <netinet/tcp.h>
  25 #include <signal.h>
  26
  27 //#define DEBUG_GDB
  28
  29 enum RSState {
  30     RS_IDLE,
  31     RS_GETLINE,
  32     RS_CHKSUM1,
  33     RS_CHKSUM2,
  34 };
  35
  36 static int gdbserver_fd;
  37
  38 typedef struct GDBState {
  39     enum RSState state;
  40     int fd;
  41     char line_buf[4096];
  42     int line_buf_index;
  43     int line_csum;
  44 } GDBState;
  45
  46 static int get_char(GDBState *s)
  47 {
  48     uint8_t ch;
  49     int ret;
  50
  51     for(;;) {
  52         ret = read(s->fd, &ch, 1);
  53         if (ret < 0) {
  54             if (errno != EINTR && errno != EAGAIN)
  55                 return -1;
  56         } else if (ret == 0) {
  57             return -1;
  58         } else {
  59             break;
  60         }
  61     }
  62     return ch;
  63 }
  64
  65 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
  66 {
  67     int ret;
  68
  69     while (len > 0) {
  70         ret = write(s->fd, buf, len);
  71         if (ret < 0) {
  72             if (errno != EINTR && errno != EAGAIN)
  73                 return;
  74         } else {
  75             buf += ret;
  76             len -= ret;
  77         }
  78     }
  79 }
  80
  81 static inline int fromhex(int v)
  82 {
  83     if (v >= '0' && v <= '9')
  84         return v - '0';
  85     else if (v >= 'A' && v <= 'F')
  86         return v - 'A' + 10;
  87     else if (v >= 'a' && v <= 'f')
  88         return v - 'a' + 10;
  89     else
  90         return 0;
  91 }
  92
  93 static inline int tohex(int v)
  94 {
  95     if (v < 10)
  96         return v + '0';
  97     else
  98         return v - 10 + 'a';
  99 }
 100
 101 static void memtohex(char *buf, const uint8_t *mem, int len)
 102 {
 103     int i, c;
 104     char *q;
 105     q = buf;
 106     for(i = 0; i < len; i++) {
 107         c = mem[i];
 108         *q++ = tohex(c >> 4);
 109         *q++ = tohex(c & 0xf);
 110     }
 111     *q = '\0';
 112 }
 113
 114 static void hextomem(uint8_t *mem, const char *buf, int len)
 115 {
 116     int i;
 117
 118     for(i = 0; i < len; i++) {
 119         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 120         buf += 2;
 121     }
 122 }
 123
 124 /* return -1 if error, 0 if OK */
 125 static int put_packet(GDBState *s, char *buf)
 126 {
 127     char buf1[3];
 128     int len, csum, ch, i;
 129
 130 #ifdef DEBUG_GDB
 131     printf("reply='%s'\n", buf);
 132 #endif
 133
 134     for(;;) {
 135         buf1[0] = '$';
 136         put_buffer(s, buf1, 1);
 137         len = strlen(buf);
 138         put_buffer(s, buf, len);
 139         csum = 0;
 140         for(i = 0; i < len; i++) {
 141             csum += buf[i];
 142         }
 143         buf1[0] = '#';
 144         buf1[1] = tohex((csum >> 4) & 0xf);
 145         buf1[2] = tohex((csum) & 0xf);
 146
 147         put_buffer(s, buf1, 3);
 148
 149         ch = get_char(s);
 150         if (ch < 0)
 151             return -1;
 152         if (ch == '+')
 153             break;
 154     }
 155     return 0;
 156 }
 157
 158 #if defined(TARGET_I386)
 159
 160 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 161 {
 162     uint32_t *registers = (uint32_t *)mem_buf;
 163     int i, fpus;
 164
 165     for(i = 0; i < 8; i++) {
 166         registers[i] = env->regs[i];
 167     }
 168     registers[8] = env->eip;
 169     registers[9] = env->eflags;
 170     registers[10] = env->segs[R_CS].selector;
 171     registers[11] = env->segs[R_SS].selector;
 172     registers[12] = env->segs[R_DS].selector;
 173     registers[13] = env->segs[R_ES].selector;
 174     registers[14] = env->segs[R_FS].selector;
 175     registers[15] = env->segs[R_GS].selector;
 176     /* XXX: convert floats */
 177     for(i = 0; i < 8; i++) {
 178         memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
 179     }
 180     registers[36] = env->fpuc;
 181     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
 182     registers[37] = fpus;
 183     registers[38] = 0; /* XXX: convert tags */
 184     registers[39] = 0; /* fiseg */
 185     registers[40] = 0; /* fioff */
 186     registers[41] = 0; /* foseg */
 187     registers[42] = 0; /* fooff */
 188     registers[43] = 0; /* fop */
 189
 190     for(i = 0; i < 16; i++)
 191         tswapls(&registers[i]);
 192     for(i = 36; i < 44; i++)
 193         tswapls(&registers[i]);
 194     return 44 * 4;
 195 }
 196
 197 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 198 {
 199     uint32_t *registers = (uint32_t *)mem_buf;
 200     int i;
 201
 202     for(i = 0; i < 8; i++) {
 203         env->regs[i] = tswapl(registers[i]);
 204     }
 205     env->eip = tswapl(registers[8]);
 206     env->eflags = tswapl(registers[9]);
 207 #if defined(CONFIG_USER_ONLY)
 208 #define LOAD_SEG(index, sreg)\
 209             if (tswapl(registers[index]) != env->segs[sreg].selector)\
 210                 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
 211             LOAD_SEG(10, R_CS);
 212             LOAD_SEG(11, R_SS);
 213             LOAD_SEG(12, R_DS);
 214             LOAD_SEG(13, R_ES);
 215             LOAD_SEG(14, R_FS);
 216             LOAD_SEG(15, R_GS);
 217 #endif
 218 }
 219
 220 #elif defined (TARGET_PPC)
 221 static uint32_t from_le32 (uint32_t *buf)
 222 {
 223     uint8_t *p = (uint8_t *)buf;
 224
 225     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 226 }
 227
 228 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 229 {
 230     uint32_t *registers = (uint32_t *)mem_buf, tmp;
 231     int i;
 232
 233     /* fill in gprs */
 234     for(i = 0; i < 32; i++) {
 235         registers[i] = tswapl(env->gpr[i]);
 236     }
 237     /* fill in fprs */
 238     for (i = 0; i < 32; i++) {
 239         registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
 240         registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
 241     }
 242     /* nip, msr, ccr, lnk, ctr, xer, mq */
 243     registers[96] = tswapl(env->nip);
 244     registers[97] = tswapl(_load_msr(env));
 245     tmp = 0;
 246     for (i = 0; i < 8; i++)
 247         tmp |= env->crf[i] << (32 - ((i + 1) * 4));
 248     registers[98] = tswapl(tmp);
 249     registers[99] = tswapl(env->lr);
 250     registers[100] = tswapl(env->ctr);
 251     registers[101] = tswapl(_load_xer(env));
 252     registers[102] = 0;
 253
 254     return 103 * 4;
 255 }
 256
 257 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 258 {
 259     uint32_t *registers = (uint32_t *)mem_buf;
 260     int i;
 261
 262     /* fill in gprs */
 263     for (i = 0; i < 32; i++) {
 264         env->gpr[i] = tswapl(registers[i]);
 265     }
 266     /* fill in fprs */
 267     for (i = 0; i < 32; i++) {
 268         *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
 269         *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
 270     }
 271     /* nip, msr, ccr, lnk, ctr, xer, mq */
 272     env->nip = tswapl(registers[96]);
 273     _store_msr(env, tswapl(registers[97]));
 274     registers[98] = tswapl(registers[98]);
 275     for (i = 0; i < 8; i++)
 276         env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
 277     env->lr = tswapl(registers[99]);
 278     env->ctr = tswapl(registers[100]);
 279     _store_xer(env, tswapl(registers[101]));
 280 }
 281 #elif defined (TARGET_SPARC)
 282 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 283 {
 284     uint32_t *registers = (uint32_t *)mem_buf, tmp;
 285     int i;
 286
 287     /* fill in g0..g7 */
 288     for(i = 0; i < 7; i++) {
 289         registers[i] = tswapl(env->gregs[i]);
 290     }
 291     /* fill in register window */
 292     for(i = 0; i < 24; i++) {
 293         registers[i + 8] = tswapl(env->regwptr[i]);
 294     }
 295     /* fill in fprs */
 296     for (i = 0; i < 32; i++) {
 297         registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
 298     }
 299     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 300     registers[64] = tswapl(env->y);
 301     tmp = (0<<28) | (4<<24) | env->psr          \
 302         | (env->psrs? PSR_S : 0)                \
 303         | (env->psrs? PSR_PS : 0)               \
 304         | (env->psret? PSR_ET : 0)              \
 305         | env->cwp;
 306     registers[65] = tswapl(tmp);
 307     registers[66] = tswapl(env->wim);
 308     registers[67] = tswapl(env->tbr);
 309     registers[68] = tswapl(env->pc);
 310     registers[69] = tswapl(env->npc);
 311     registers[70] = tswapl(env->fsr);
 312     registers[71] = 0; /* csr */
 313     registers[72] = 0;
 314
 315     return 73 * 4;
 316 }
 317
 318 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 319 {
 320     uint32_t *registers = (uint32_t *)mem_buf, tmp;
 321     int i;
 322
 323     /* fill in g0..g7 */
 324     for(i = 0; i < 7; i++) {
 325         env->gregs[i] = tswapl(registers[i]);
 326     }
 327     /* fill in register window */
 328     for(i = 0; i < 24; i++) {
 329         env->regwptr[i] = tswapl(registers[i]);
 330     }
 331     /* fill in fprs */
 332     for (i = 0; i < 32; i++) {
 333         *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
 334     }
 335     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 336     env->y = tswapl(registers[64]);
 337     tmp = tswapl(registers[65]);
 338     env->psr = tmp & ~PSR_ICC;
 339     env->psrs = (tmp & PSR_S)? 1 : 0;
 340     env->psrps = (tmp & PSR_PS)? 1 : 0;
 341     env->psret = (tmp & PSR_ET)? 1 : 0;
 342     env->cwp = (tmp & PSR_CWP);
 343     env->wim = tswapl(registers[66]);
 344     env->tbr = tswapl(registers[67]);
 345     env->pc = tswapl(registers[68]);
 346     env->npc = tswapl(registers[69]);
 347     env->fsr = tswapl(registers[70]);
 348 }
 349 #else
 350
 351 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 352 {
 353     return 0;
 354 }
 355
 356 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 357 {
 358 }
 359
 360 #endif
 361
 362 /* port = 0 means default port */
 363 static int gdb_handle_packet(GDBState *s, const char *line_buf)
 364 {
 365     CPUState *env = cpu_single_env;
 366     const char *p;
 367     int ch, reg_size, type;
 368     char buf[4096];
 369     uint8_t mem_buf[2000];
 370     uint32_t *registers;
 371     uint32_t addr, len;
 372
 373 #ifdef DEBUG_GDB
 374     printf("command='%s'\n", line_buf);
 375 #endif
 376     p = line_buf;
 377     ch = *p++;
 378     switch(ch) {
 379     case '?':
 380         snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
 381         put_packet(s, buf);
 382         break;
 383     case 'c':
 384         if (*p != '\0') {
 385             addr = strtoul(p, (char **)&p, 16);
 386 #if defined(TARGET_I386)
 387             env->eip = addr;
 388 #elif defined (TARGET_PPC)
 389             env->nip = addr;
 390 #elif defined (TARGET_SPARC)
 391             env->pc = addr;
 392             env->npc = addr + 4;
 393 #endif
 394         }
 395         vm_start();
 396         break;
 397     case 's':
 398         if (*p != '\0') {
 399             addr = strtoul(p, (char **)&p, 16);
 400 #if defined(TARGET_I386)
 401             env->eip = addr;
 402 #elif defined (TARGET_PPC)
 403             env->nip = addr;
 404 #elif defined (TARGET_SPARC)
 405             env->pc = addr;
 406             env->npc = addr + 4;
 407 #endif
 408         }
 409         cpu_single_step(env, 1);
 410         vm_start();
 411         break;
 412     case 'g':
 413         reg_size = cpu_gdb_read_registers(env, mem_buf);
 414         memtohex(buf, mem_buf, reg_size);
 415         put_packet(s, buf);
 416         break;
 417     case 'G':
 418         registers = (void *)mem_buf;
 419         len = strlen(p) / 2;
 420         hextomem((uint8_t *)registers, p, len);
 421         cpu_gdb_write_registers(env, mem_buf, len);
 422         put_packet(s, "OK");
 423         break;
 424     case 'm':
 425         addr = strtoul(p, (char **)&p, 16);
 426         if (*p == ',')
 427             p++;
 428         len = strtoul(p, NULL, 16);
 429         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0)
 430             memset(mem_buf, 0, len);
 431         memtohex(buf, mem_buf, len);
 432         put_packet(s, buf);
 433         break;
 434     case 'M':
 435         addr = strtoul(p, (char **)&p, 16);
 436         if (*p == ',')
 437             p++;
 438         len = strtoul(p, (char **)&p, 16);
 439         if (*p == ',')
 440             p++;
 441         hextomem(mem_buf, p, len);
 442         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
 443             put_packet(s, "ENN");
 444         else
 445             put_packet(s, "OK");
 446         break;
 447     case 'Z':
 448         type = strtoul(p, (char **)&p, 16);
 449         if (*p == ',')
 450             p++;
 451         addr = strtoul(p, (char **)&p, 16);
 452         if (*p == ',')
 453             p++;
 454         len = strtoul(p, (char **)&p, 16);
 455         if (type == 0 || type == 1) {
 456             if (cpu_breakpoint_insert(env, addr) < 0)
 457                 goto breakpoint_error;
 458             put_packet(s, "OK");
 459         } else {
 460         breakpoint_error:
 461             put_packet(s, "ENN");
 462         }
 463         break;
 464     case 'z':
 465         type = strtoul(p, (char **)&p, 16);
 466         if (*p == ',')
 467             p++;
 468         addr = strtoul(p, (char **)&p, 16);
 469         if (*p == ',')
 470             p++;
 471         len = strtoul(p, (char **)&p, 16);
 472         if (type == 0 || type == 1) {
 473             cpu_breakpoint_remove(env, addr);
 474             put_packet(s, "OK");
 475         } else {
 476             goto breakpoint_error;
 477         }
 478         break;
 479     default:
 480         //        unknown_command:
 481         /* put empty packet */
 482         buf[0] = '\0';
 483         put_packet(s, buf);
 484         break;
 485     }
 486     return RS_IDLE;
 487 }
 488
 489 static void gdb_vm_stopped(void *opaque, int reason)
 490 {
 491     GDBState *s = opaque;
 492     char buf[256];
 493     int ret;
 494
 495     /* disable single step if it was enable */
 496     cpu_single_step(cpu_single_env, 0);
 497
 498     if (reason == EXCP_DEBUG)
 499         ret = SIGTRAP;
 500     else
 501         ret = 0;
 502     snprintf(buf, sizeof(buf), "S%02x", ret);
 503     put_packet(s, buf);
 504 }
 505
 506 static void gdb_read_byte(GDBState *s, int ch)
 507 {
 508     int i, csum;
 509     char reply[1];
 510
 511     if (vm_running) {
 512         /* when the CPU is running, we cannot do anything except stop
 513            it when receiving a char */
 514         vm_stop(EXCP_INTERRUPT);
 515     } else {
 516         switch(s->state) {
 517         case RS_IDLE:
 518             if (ch == '$') {
 519                 s->line_buf_index = 0;
 520                 s->state = RS_GETLINE;
 521             }
 522             break;
 523         case RS_GETLINE:
 524             if (ch == '#') {
 525             s->state = RS_CHKSUM1;
 526             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
 527                 s->state = RS_IDLE;
 528             } else {
 529             s->line_buf[s->line_buf_index++] = ch;
 530             }
 531             break;
 532         case RS_CHKSUM1:
 533             s->line_buf[s->line_buf_index] = '\0';
 534             s->line_csum = fromhex(ch) << 4;
 535             s->state = RS_CHKSUM2;
 536             break;
 537         case RS_CHKSUM2:
 538             s->line_csum |= fromhex(ch);
 539             csum = 0;
 540             for(i = 0; i < s->line_buf_index; i++) {
 541                 csum += s->line_buf[i];
 542             }
 543             if (s->line_csum != (csum & 0xff)) {
 544                 reply[0] = '-';
 545                 put_buffer(s, reply, 1);
 546                 s->state = RS_IDLE;
 547             } else {
 548                 reply[0] = '+';
 549                 put_buffer(s, reply, 1);
 550                 s->state = gdb_handle_packet(s, s->line_buf);
 551             }
 552             break;
 553         }
 554     }
 555 }
 556
 557 static int gdb_can_read(void *opaque)
 558 {
 559     return 256;
 560 }
 561
 562 static void gdb_read(void *opaque, const uint8_t *buf, int size)
 563 {
 564     GDBState *s = opaque;
 565     int i;
 566     if (size == 0) {
 567         /* end of connection */
 568         qemu_del_vm_stop_handler(gdb_vm_stopped, s);
 569         qemu_del_fd_read_handler(s->fd);
 570         qemu_free(s);
 571         vm_start();
 572     } else {
 573         for(i = 0; i < size; i++)
 574             gdb_read_byte(s, buf[i]);
 575     }
 576 }
 577
 578 static void gdb_accept(void *opaque, const uint8_t *buf, int size)
 579 {
 580     GDBState *s;
 581     struct sockaddr_in sockaddr;
 582     socklen_t len;
 583     int val, fd;
 584
 585     for(;;) {
 586         len = sizeof(sockaddr);
 587         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
 588         if (fd < 0 && errno != EINTR) {
 589             perror("accept");
 590             return;
 591         } else if (fd >= 0) {
 592             break;
 593         }
 594     }
 595
 596     /* set short latency */
 597     val = 1;
 598     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
 599
 600     s = qemu_mallocz(sizeof(GDBState));
 601     if (!s) {
 602         close(fd);
 603         return;
 604     }
 605     s->fd = fd;
 606
 607     fcntl(fd, F_SETFL, O_NONBLOCK);
 608
 609     /* stop the VM */
 610     vm_stop(EXCP_INTERRUPT);
 611
 612     /* start handling I/O */
 613     qemu_add_fd_read_handler(s->fd, gdb_can_read, gdb_read, s);
 614     /* when the VM is stopped, the following callback is called */
 615     qemu_add_vm_stop_handler(gdb_vm_stopped, s);
 616 }
 617
 618 static int gdbserver_open(int port)
 619 {
 620     struct sockaddr_in sockaddr;
 621     int fd, val, ret;
 622
 623     fd = socket(PF_INET, SOCK_STREAM, 0);
 624     if (fd < 0) {
 625         perror("socket");
 626         return -1;
 627     }
 628
 629     /* allow fast reuse */
 630     val = 1;
 631     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
 632
 633     sockaddr.sin_family = AF_INET;
 634     sockaddr.sin_port = htons(port);
 635     sockaddr.sin_addr.s_addr = 0;
 636     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
 637     if (ret < 0) {
 638         perror("bind");
 639         return -1;
 640     }
 641     ret = listen(fd, 0);
 642     if (ret < 0) {
 643         perror("listen");
 644         return -1;
 645     }
 646     fcntl(fd, F_SETFL, O_NONBLOCK);
 647     return fd;
 648 }
 649
 650 int gdbserver_start(int port)
 651 {
 652     gdbserver_fd = gdbserver_open(port);
 653     if (gdbserver_fd < 0)
 654         return -1;
 655     /* accept connections */
 656     qemu_add_fd_read_handler(gdbserver_fd, NULL, gdb_accept, NULL);
 657     return 0;
 658 }