1: /*
    2:  * gdb server stub
    3:  *
    4:  * Copyright (c) 2003-2005 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 "config.h"
   21: #ifdef CONFIG_USER_ONLY
   22: #include <stdlib.h>
   23: #include <stdio.h>
   24: #include <stdarg.h>
   25: #include <string.h>
   26: #include <errno.h>
   27: #include <unistd.h>
   28: #include <fcntl.h>
   29: 
   30: #include "qemu.h"
   31: #else
   32: #include "qemu-common.h"
   33: #include "qemu-char.h"
   34: #include "sysemu.h"
   35: #include "gdbstub.h"
   36: #endif
   37: 
   38: #include "qemu_socket.h"
   39: #ifdef _WIN32
   40: /* XXX: these constants may be independent of the host ones even for Unix */
   41: #ifndef SIGTRAP
   42: #define SIGTRAP 5
   43: #endif
   44: #ifndef SIGINT
   45: #define SIGINT 2
   46: #endif
   47: #else
   48: #include <signal.h>
   49: #endif
   50: 
   51: //#define DEBUG_GDB
   52: 
   53: enum RSState {
   54:     RS_IDLE,
   55:     RS_GETLINE,
   56:     RS_CHKSUM1,
   57:     RS_CHKSUM2,
   58:     RS_SYSCALL,
   59: };
   60: typedef struct GDBState {
   61:     CPUState *env; /* current CPU */
   62:     enum RSState state; /* parsing state */
   63:     char line_buf[4096];
   64:     int line_buf_index;
   65:     int line_csum;
   66:     uint8_t last_packet[4100];
   67:     int last_packet_len;
   68: #ifdef CONFIG_USER_ONLY
   69:     int fd;
   70:     int running_state;
   71: #else
   72:     CharDriverState *chr;
   73: #endif
   74: } GDBState;
   75: 
   76: #ifdef CONFIG_USER_ONLY
   77: /* XXX: This is not thread safe.  Do we care?  */
   78: static int gdbserver_fd = -1;
   79: 
   80: /* XXX: remove this hack.  */
   81: static GDBState gdbserver_state;
   82: 
   83: static int get_char(GDBState *s)
   84: {
   85:     uint8_t ch;
   86:     int ret;
   87: 
   88:     for(;;) {
   89:         ret = recv(s->fd, &ch, 1, 0);
   90:         if (ret < 0) {
   91:             if (errno != EINTR && errno != EAGAIN)
   92:                 return -1;
   93:         } else if (ret == 0) {
   94:             return -1;
   95:         } else {
   96:             break;
   97:         }
   98:     }
   99:     return ch;
  100: }
  101: #endif
  102: 
  103: /* GDB stub state for use by semihosting syscalls.  */
  104: static GDBState *gdb_syscall_state;
  105: static gdb_syscall_complete_cb gdb_current_syscall_cb;
  106: 
  107: enum {
  108:     GDB_SYS_UNKNOWN,
  109:     GDB_SYS_ENABLED,
  110:     GDB_SYS_DISABLED,
  111: } gdb_syscall_mode;
  112: 
  113: /* If gdb is connected when the first semihosting syscall occurs then use
  114:    remote gdb syscalls.  Otherwise use native file IO.  */
  115: int use_gdb_syscalls(void)
  116: {
  117:     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
  118:         gdb_syscall_mode = (gdb_syscall_state ? GDB_SYS_ENABLED
  119:                                               : GDB_SYS_DISABLED);
  120:     }
  121:     return gdb_syscall_mode == GDB_SYS_ENABLED;
  122: }
  123: 
  124: static void put_buffer(GDBState *s, const uint8_t *buf, int len)
  125: {
  126: #ifdef CONFIG_USER_ONLY
  127:     int ret;
  128: 
  129:     while (len > 0) {
  130:         ret = send(s->fd, buf, len, 0);
  131:         if (ret < 0) {
  132:             if (errno != EINTR && errno != EAGAIN)
  133:                 return;
  134:         } else {
  135:             buf += ret;
  136:             len -= ret;
  137:         }
  138:     }
  139: #else
  140:     qemu_chr_write(s->chr, buf, len);
  141: #endif
  142: }
  143: 
  144: static inline int fromhex(int v)
  145: {
  146:     if (v >= '0' && v <= '9')
  147:         return v - '0';
  148:     else if (v >= 'A' && v <= 'F')
  149:         return v - 'A' + 10;
  150:     else if (v >= 'a' && v <= 'f')
  151:         return v - 'a' + 10;
  152:     else
  153:         return 0;
  154: }
  155: 
  156: static inline int tohex(int v)
  157: {
  158:     if (v < 10)
  159:         return v + '0';
  160:     else
  161:         return v - 10 + 'a';
  162: }
  163: 
  164: static void memtohex(char *buf, const uint8_t *mem, int len)
  165: {
  166:     int i, c;
  167:     char *q;
  168:     q = buf;
  169:     for(i = 0; i < len; i++) {
  170:         c = mem[i];
  171:         *q++ = tohex(c >> 4);
  172:         *q++ = tohex(c & 0xf);
  173:     }
  174:     *q = '\0';
  175: }
  176: 
  177: static void hextomem(uint8_t *mem, const char *buf, int len)
  178: {
  179:     int i;
  180: 
  181:     for(i = 0; i < len; i++) {
  182:         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
  183:         buf += 2;
  184:     }
  185: }
  186: 
  187: /* return -1 if error, 0 if OK */
  188: static int put_packet(GDBState *s, char *buf)
  189: {
  190:     int len, csum, i;
  191:     uint8_t *p;
  192: 
  193: #ifdef DEBUG_GDB
  194:     printf("reply='%s'\n", buf);
  195: #endif
  196: 
  197:     for(;;) {
  198:         p = s->last_packet;
  199:         *(p++) = '$';
  200:         len = strlen(buf);
  201:         memcpy(p, buf, len);
  202:         p += len;
  203:         csum = 0;
  204:         for(i = 0; i < len; i++) {
  205:             csum += buf[i];
  206:         }
  207:         *(p++) = '#';
  208:         *(p++) = tohex((csum >> 4) & 0xf);
  209:         *(p++) = tohex((csum) & 0xf);
  210: 
  211:         s->last_packet_len = p - s->last_packet;
  212:         put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
  213: 
  214: #ifdef CONFIG_USER_ONLY
  215:         i = get_char(s);
  216:         if (i < 0)
  217:             return -1;
  218:         if (i == '+')
  219:             break;
  220: #else
  221:         break;
  222: #endif
  223:     }
  224:     return 0;
  225: }
  226: 
  227: #if defined(TARGET_I386)
  228: 
  229: static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
  230: {
  231:     int i, fpus;
  232:     uint32_t *registers = (uint32_t *)mem_buf;
  233: 
  234: #ifdef TARGET_X86_64
  235:     /* This corresponds with amd64_register_info[] in gdb/amd64-tdep.c */
  236:     uint64_t *registers64 = (uint64_t *)mem_buf;
  237: 
  238:     if (env->hflags & HF_CS64_MASK) {
  239:         registers64[0] = tswap64(env->regs[R_EAX]);
  240:         registers64[1] = tswap64(env->regs[R_EBX]);
  241:         registers64[2] = tswap64(env->regs[R_ECX]);
  242:         registers64[3] = tswap64(env->regs[R_EDX]);
  243:         registers64[4] = tswap64(env->regs[R_ESI]);
  244:         registers64[5] = tswap64(env->regs[R_EDI]);
  245:         registers64[6] = tswap64(env->regs[R_EBP]);
  246:         registers64[7] = tswap64(env->regs[R_ESP]);
  247:         for(i = 8; i < 16; i++) {
  248:             registers64[i] = tswap64(env->regs[i]);
  249:         }
  250:         registers64[16] = tswap64(env->eip);
  251: 
  252:         registers = (uint32_t *)&registers64[17];
  253:         registers[0] = tswap32(env->eflags);
  254:         registers[1] = tswap32(env->segs[R_CS].selector);
  255:         registers[2] = tswap32(env->segs[R_SS].selector);
  256:         registers[3] = tswap32(env->segs[R_DS].selector);
  257:         registers[4] = tswap32(env->segs[R_ES].selector);
  258:         registers[5] = tswap32(env->segs[R_FS].selector);
  259:         registers[6] = tswap32(env->segs[R_GS].selector);
  260:         /* XXX: convert floats */
  261:         for(i = 0; i < 8; i++) {
  262:             memcpy(mem_buf + 16 * 8 + 7 * 4 + i * 10, &env->fpregs[i], 10);
  263:         }
  264:         registers[27] = tswap32(env->fpuc); /* fctrl */
  265:         fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
  266:         registers[28] = tswap32(fpus); /* fstat */
  267:         registers[29] = 0; /* ftag */
  268:         registers[30] = 0; /* fiseg */
  269:         registers[31] = 0; /* fioff */
  270:         registers[32] = 0; /* foseg */
  271:         registers[33] = 0; /* fooff */
  272:         registers[34] = 0; /* fop */
  273:         for(i = 0; i < 16; i++) {
  274:             memcpy(mem_buf + 16 * 8 + 35 * 4 + i * 16, &env->xmm_regs[i], 16);
  275:         }
  276:         registers[99] = tswap32(env->mxcsr);
  277: 
  278:         return 8 * 17 + 4 * 7 + 10 * 8 + 4 * 8 + 16 * 16 + 4;
  279:     }
  280: #endif
  281: 
  282:     for(i = 0; i < 8; i++) {
  283:         registers[i] = env->regs[i];
  284:     }
  285:     registers[8] = env->eip;
  286:     registers[9] = env->eflags;
  287:     registers[10] = env->segs[R_CS].selector;
  288:     registers[11] = env->segs[R_SS].selector;
  289:     registers[12] = env->segs[R_DS].selector;
  290:     registers[13] = env->segs[R_ES].selector;
  291:     registers[14] = env->segs[R_FS].selector;
  292:     registers[15] = env->segs[R_GS].selector;
  293:     /* XXX: convert floats */
  294:     for(i = 0; i < 8; i++) {
  295:         memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
  296:     }
  297:     registers[36] = env->fpuc;
  298:     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
  299:     registers[37] = fpus;
  300:     registers[38] = 0; /* XXX: convert tags */
  301:     registers[39] = 0; /* fiseg */
  302:     registers[40] = 0; /* fioff */
  303:     registers[41] = 0; /* foseg */
  304:     registers[42] = 0; /* fooff */
  305:     registers[43] = 0; /* fop */
  306: 
  307:     for(i = 0; i < 16; i++)
  308:         tswapls(&registers[i]);
  309:     for(i = 36; i < 44; i++)
  310:         tswapls(&registers[i]);
  311:     return 44 * 4;
  312: }
  313: 
  314: static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
  315: {
  316:     uint32_t *registers = (uint32_t *)mem_buf;
  317:     int i;
  318: 
  319:     for(i = 0; i < 8; i++) {
  320:         env->regs[i] = tswapl(registers[i]);
  321:     }
  322:     env->eip = tswapl(registers[8]);
  323:     env->eflags = tswapl(registers[9]);
  324: #if defined(CONFIG_USER_ONLY)
  325: #define LOAD_SEG(index, sreg)\
  326:             if (tswapl(registers[index]) != env->segs[sreg].selector)\
  327:                 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
  328:             LOAD_SEG(10, R_CS);
  329:             LOAD_SEG(11, R_SS);
  330:             LOAD_SEG(12, R_DS);
  331:             LOAD_SEG(13, R_ES);
  332:             LOAD_SEG(14, R_FS);
  333:             LOAD_SEG(15, R_GS);
  334: #endif
  335: }
  336: 
  337: #elif defined (TARGET_PPC)
  338: static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
  339: {
  340:     uint32_t *registers = (uint32_t *)mem_buf, tmp;
  341:     int i;
  342: 
  343:     /* fill in gprs */
  344:     for(i = 0; i < 32; i++) {
  345:         registers[i] = tswapl(env->gpr[i]);
  346:     }
  347:     /* fill in fprs */
  348:     for (i = 0; i < 32; i++) {
  349:         registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
  350:         registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
  351:     }
  352:     /* nip, msr, ccr, lnk, ctr, xer, mq */
  353:     registers[96] = tswapl(env->nip);
  354:     registers[97] = tswapl(env->msr);
  355:     tmp = 0;
  356:     for (i = 0; i < 8; i++)
  357:         tmp |= env->crf[i] << (32 - ((i + 1) * 4));
  358:     registers[98] = tswapl(tmp);
  359:     registers[99] = tswapl(env->lr);
  360:     registers[100] = tswapl(env->ctr);
  361:     registers[101] = tswapl(ppc_load_xer(env));
  362:     registers[102] = 0;
  363: 
  364:     return 103 * 4;
  365: }
  366: 
  367: static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
  368: {
  369:     uint32_t *registers = (uint32_t *)mem_buf;
  370:     int i;
  371: 
  372:     /* fill in gprs */
  373:     for (i = 0; i < 32; i++) {
  374:         env->gpr[i] = tswapl(registers[i]);
  375:     }
  376:     /* fill in fprs */
  377:     for (i = 0; i < 32; i++) {
  378:         *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
  379:         *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
  380:     }
  381:     /* nip, msr, ccr, lnk, ctr, xer, mq */
  382:     env->nip = tswapl(registers[96]);
  383:     ppc_store_msr(env, tswapl(registers[97]));
  384:     registers[98] = tswapl(registers[98]);
  385:     for (i = 0; i < 8; i++)
  386:         env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
  387:     env->lr = tswapl(registers[99]);
  388:     env->ctr = tswapl(registers[100]);
  389:     ppc_store_xer(env, tswapl(registers[101]));
  390: }
  391: #elif defined (TARGET_SPARC)
  392: static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
  393: {
  394:     target_ulong *registers = (target_ulong *)mem_buf;
  395:     int i;
  396: 
  397:     /* fill in g0..g7 */
  398:     for(i = 0; i < 8; i++) {
  399:         registers[i] = tswapl(env->gregs[i]);
  400:     }
  401:     /* fill in register window */
  402:     for(i = 0; i < 24; i++) {
  403:         registers[i + 8] = tswapl(env->regwptr[i]);
  404:     }
  405: #ifndef TARGET_SPARC64
  406:     /* fill in fprs */
  407:     for (i = 0; i < 32; i++) {
  408:         registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
  409:     }
  410:     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
  411:     registers[64] = tswapl(env->y);
  412:     {
  413:         target_ulong tmp;
  414: 
  415:         tmp = GET_PSR(env);
  416:         registers[65] = tswapl(tmp);
  417:     }
  418:     registers[66] = tswapl(env->wim);
  419:     registers[67] = tswapl(env->tbr);
  420:     registers[68] = tswapl(env->pc);
  421:     registers[69] = tswapl(env->npc);
  422:     registers[70] = tswapl(env->fsr);
  423:     registers[71] = 0; /* csr */
  424:     registers[72] = 0;
  425:     return 73 * sizeof(target_ulong);
  426: #else
  427:     /* fill in fprs */
  428:     for (i = 0; i < 64; i += 2) {
  429:         uint64_t tmp;
  430: 
  431:         tmp = ((uint64_t)*(uint32_t *)&env->fpr[i]) << 32;
  432:         tmp |= *(uint32_t *)&env->fpr[i + 1];
  433:         registers[i / 2 + 32] = tswap64(tmp);
  434:     }
  435:     registers[64] = tswapl(env->pc);
  436:     registers[65] = tswapl(env->npc);
  437:     registers[66] = tswapl(((uint64_t)GET_CCR(env) << 32) |
  438:                            ((env->asi & 0xff) << 24) |
  439:                            ((env->pstate & 0xfff) << 8) |
  440:                            GET_CWP64(env));
  441:     registers[67] = tswapl(env->fsr);
  442:     registers[68] = tswapl(env->fprs);
  443:     registers[69] = tswapl(env->y);
  444:     return 70 * sizeof(target_ulong);
  445: #endif
  446: }
  447: 
  448: static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
  449: {
  450:     target_ulong *registers = (target_ulong *)mem_buf;
  451:     int i;
  452: 
  453:     /* fill in g0..g7 */
  454:     for(i = 0; i < 7; i++) {
  455:         env->gregs[i] = tswapl(registers[i]);
  456:     }
  457:     /* fill in register window */
  458:     for(i = 0; i < 24; i++) {
  459:         env->regwptr[i] = tswapl(registers[i + 8]);
  460:     }
  461: #ifndef TARGET_SPARC64
  462:     /* fill in fprs */
  463:     for (i = 0; i < 32; i++) {
  464:         *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
  465:     }
  466:     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
  467:     env->y = tswapl(registers[64]);
  468:     PUT_PSR(env, tswapl(registers[65]));
  469:     env->wim = tswapl(registers[66]);
  470:     env->tbr = tswapl(registers[67]);
  471:     env->pc = tswapl(registers[68]);
  472:     env->npc = tswapl(registers[69]);
  473:     env->fsr = tswapl(registers[70]);
  474: #else
  475:     for (i = 0; i < 64; i += 2) {
  476:         uint64_t tmp;
  477: 
  478:         tmp = tswap64(registers[i / 2 + 32]);
  479:         *((uint32_t *)&env->fpr[i]) = tmp >> 32;
  480:         *((uint32_t *)&env->fpr[i + 1]) = tmp & 0xffffffff;
  481:     }
  482:     env->pc = tswapl(registers[64]);
  483:     env->npc = tswapl(registers[65]);
  484:     {
  485:         uint64_t tmp = tswapl(registers[66]);
  486: 
  487:         PUT_CCR(env, tmp >> 32);
  488:         env->asi = (tmp >> 24) & 0xff;
  489:         env->pstate = (tmp >> 8) & 0xfff;
  490:         PUT_CWP64(env, tmp & 0xff);
  491:     }
  492:     env->fsr = tswapl(registers[67]);
  493:     env->fprs = tswapl(registers[68]);
  494:     env->y = tswapl(registers[69]);
  495: #endif
  496: }
  497: #elif defined (TARGET_ARM)
  498: static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
  499: {
  500:     int i;
  501:     uint8_t *ptr;
  502: 
  503:     ptr = mem_buf;
  504:     /* 16 core integer registers (4 bytes each).  */
  505:     for (i = 0; i < 16; i++)
  506:       {
  507:         *(uint32_t *)ptr = tswapl(env->regs[i]);
  508:         ptr += 4;
  509:       }
  510:     /* 8 FPA registers (12 bytes each), FPS (4 bytes).
  511:        Not yet implemented.  */
  512:     memset (ptr, 0, 8 * 12 + 4);
  513:     ptr += 8 * 12 + 4;
  514:     /* CPSR (4 bytes).  */
  515:     *(uint32_t *)ptr = tswapl (cpsr_read(env));
  516:     ptr += 4;
  517: 
  518:     return ptr - mem_buf;
  519: }
  520: 
  521: static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
  522: {
  523:     int i;
  524:     uint8_t *ptr;
  525: 
  526:     ptr = mem_buf;
  527:     /* Core integer registers.  */
  528:     for (i = 0; i < 16; i++)
  529:       {
  530:         env->regs[i] = tswapl(*(uint32_t *)ptr);
  531:         ptr += 4;
  532:       }
  533:     /* Ignore FPA regs and scr.  */
  534:     ptr += 8 * 12 + 4;
  535:     cpsr_write (env, tswapl(*(uint32_t *)ptr),