Blame view

gdbstub.c 21.4 KB
bellard authored
1
2
3
/*
 * gdb server stub
 * 
bellard authored
4
 * Copyright (c) 2003-2005 Fabrice Bellard
bellard authored
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
20
21
22
23
24
25
26
27
28
29
#ifdef CONFIG_USER_ONLY
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

#include "qemu.h"
#else
30
#include "vl.h"
31
#endif
32
bellard authored
33
34
35
36
37
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <signal.h>
bellard authored
38
//#define DEBUG_GDB
bellard authored
39
40
41
42
43
44
45
enum RSState {
    RS_IDLE,
    RS_GETLINE,
    RS_CHKSUM1,
    RS_CHKSUM2,
};
46
47
/* XXX: This is not thread safe.  Do we care?  */
static int gdbserver_fd = -1;
bellard authored
48
49
typedef struct GDBState {
bellard authored
50
    CPUState *env; /* current CPU */
bellard authored
51
    enum RSState state; /* parsing state */
52
53
54
55
    int fd;
    char line_buf[4096];
    int line_buf_index;
    int line_csum;
bellard authored
56
57
58
#ifdef CONFIG_USER_ONLY
    int running_state;
#endif
59
} GDBState;
bellard authored
60
61
62
63
64
65
#ifdef CONFIG_USER_ONLY
/* XXX: remove this hack.  */
static GDBState gdbserver_state;
#endif
66
static int get_char(GDBState *s)
bellard authored
67
68
69
70
71
{
    uint8_t ch;
    int ret;

    for(;;) {
72
        ret = read(s->fd, &ch, 1);
bellard authored
73
74
75
76
77
78
79
80
81
82
83
84
        if (ret < 0) {
            if (errno != EINTR && errno != EAGAIN)
                return -1;
        } else if (ret == 0) {
            return -1;
        } else {
            break;
        }
    }
    return ch;
}
85
static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellard authored
86
87
88
89
{
    int ret;

    while (len > 0) {
90
        ret = write(s->fd, buf, len);
bellard authored
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
        if (ret < 0) {
            if (errno != EINTR && errno != EAGAIN)
                return;
        } else {
            buf += ret;
            len -= ret;
        }
    }
}

static inline int fromhex(int v)
{
    if (v >= '0' && v <= '9')
        return v - '0';
    else if (v >= 'A' && v <= 'F')
        return v - 'A' + 10;
    else if (v >= 'a' && v <= 'f')
        return v - 'a' + 10;
    else
        return 0;
}

static inline int tohex(int v)
{
    if (v < 10)
        return v + '0';
    else
        return v - 10 + 'a';
}

static void memtohex(char *buf, const uint8_t *mem, int len)
{
    int i, c;
    char *q;
    q = buf;
    for(i = 0; i < len; i++) {
        c = mem[i];
        *q++ = tohex(c >> 4);
        *q++ = tohex(c & 0xf);
    }
    *q = '\0';
}

static void hextomem(uint8_t *mem, const char *buf, int len)
{
    int i;

    for(i = 0; i < len; i++) {
        mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
        buf += 2;
    }
}

/* return -1 if error, 0 if OK */
145
static int put_packet(GDBState *s, char *buf)
bellard authored
146
147
148
149
150
151
152
153
154
155
{
    char buf1[3];
    int len, csum, ch, i;

#ifdef DEBUG_GDB
    printf("reply='%s'\n", buf);
#endif

    for(;;) {
        buf1[0] = '$';
156
        put_buffer(s, buf1, 1);
bellard authored
157
        len = strlen(buf);
158
        put_buffer(s, buf, len);
bellard authored
159
160
161
162
163
164
165
166
        csum = 0;
        for(i = 0; i < len; i++) {
            csum += buf[i];
        }
        buf1[0] = '#';
        buf1[1] = tohex((csum >> 4) & 0xf);
        buf1[2] = tohex((csum) & 0xf);
167
        put_buffer(s, buf1, 3);
bellard authored
168
169
        ch = get_char(s);
bellard authored
170
171
172
173
174
175
176
177
        if (ch < 0)
            return -1;
        if (ch == '+')
            break;
    }
    return 0;
}
bellard authored
178
179
180
181
#if defined(TARGET_I386)

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
182
    uint32_t *registers = (uint32_t *)mem_buf;
bellard authored
183
184
185
    int i, fpus;

    for(i = 0; i < 8; i++) {
186
        registers[i] = env->regs[i];
bellard authored
187
    }
188
189
190
191
192
193
194
195
    registers[8] = env->eip;
    registers[9] = env->eflags;
    registers[10] = env->segs[R_CS].selector;
    registers[11] = env->segs[R_SS].selector;
    registers[12] = env->segs[R_DS].selector;
    registers[13] = env->segs[R_ES].selector;
    registers[14] = env->segs[R_FS].selector;
    registers[15] = env->segs[R_GS].selector;
bellard authored
196
197
198
199
    /* XXX: convert floats */
    for(i = 0; i < 8; i++) {
        memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
    }
200
    registers[36] = env->fpuc;
bellard authored
201
    fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
202
203
204
205
206
207
208
209
210
211
212
213
    registers[37] = fpus;
    registers[38] = 0; /* XXX: convert tags */
    registers[39] = 0; /* fiseg */
    registers[40] = 0; /* fioff */
    registers[41] = 0; /* foseg */
    registers[42] = 0; /* fooff */
    registers[43] = 0; /* fop */

    for(i = 0; i < 16; i++)
        tswapls(&registers[i]);
    for(i = 36; i < 44; i++)
        tswapls(&registers[i]);
bellard authored
214
215
216
217
218
219
220
221
222
223
224
    return 44 * 4;
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
    uint32_t *registers = (uint32_t *)mem_buf;
    int i;

    for(i = 0; i < 8; i++) {
        env->regs[i] = tswapl(registers[i]);
    }
225
226
    env->eip = tswapl(registers[8]);
    env->eflags = tswapl(registers[9]);
bellard authored
227
228
229
230
231
232
233
234
235
236
237
238
239
#if defined(CONFIG_USER_ONLY)
#define LOAD_SEG(index, sreg)\
            if (tswapl(registers[index]) != env->segs[sreg].selector)\
                cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
            LOAD_SEG(10, R_CS);
            LOAD_SEG(11, R_SS);
            LOAD_SEG(12, R_DS);
            LOAD_SEG(13, R_ES);
            LOAD_SEG(14, R_FS);
            LOAD_SEG(15, R_GS);
#endif
}
bellard authored
240
241
242
#elif defined (TARGET_PPC)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
243
    uint32_t *registers = (uint32_t *)mem_buf, tmp;
bellard authored
244
245
246
    int i;

    /* fill in gprs */
247
    for(i = 0; i < 32; i++) {
248
        registers[i] = tswapl(env->gpr[i]);
bellard authored
249
250
251
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
252
253
        registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
	registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
bellard authored
254
255
    }
    /* nip, msr, ccr, lnk, ctr, xer, mq */
256
    registers[96] = tswapl(env->nip);
257
    registers[97] = tswapl(do_load_msr(env));
bellard authored
258
259
    tmp = 0;
    for (i = 0; i < 8; i++)
260
        tmp |= env->crf[i] << (32 - ((i + 1) * 4));
261
262
263
    registers[98] = tswapl(tmp);
    registers[99] = tswapl(env->lr);
    registers[100] = tswapl(env->ctr);
264
    registers[101] = tswapl(do_load_xer(env));
265
    registers[102] = 0;
266
267

    return 103 * 4;
bellard authored
268
269
270
271
272
273
274
275
276
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
    uint32_t *registers = (uint32_t *)mem_buf;
    int i;

    /* fill in gprs */
    for (i = 0; i < 32; i++) {
277
        env->gpr[i] = tswapl(registers[i]);
bellard authored
278
279
280
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
281
282
        *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
	*((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
bellard authored
283
284
    }
    /* nip, msr, ccr, lnk, ctr, xer, mq */
285
    env->nip = tswapl(registers[96]);
286
    do_store_msr(env, tswapl(registers[97]));
287
    registers[98] = tswapl(registers[98]);
bellard authored
288
    for (i = 0; i < 8; i++)
289
        env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
290
291
    env->lr = tswapl(registers[99]);
    env->ctr = tswapl(registers[100]);
292
    do_store_xer(env, tswapl(registers[101]));
293
294
295
296
}
#elif defined (TARGET_SPARC)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
bellard authored
297
    target_ulong *registers = (target_ulong *)mem_buf;
298
299
300
    int i;

    /* fill in g0..g7 */
bellard authored
301
    for(i = 0; i < 8; i++) {
302
303
304
305
306
307
308
309
310
311
        registers[i] = tswapl(env->gregs[i]);
    }
    /* fill in register window */
    for(i = 0; i < 24; i++) {
        registers[i + 8] = tswapl(env->regwptr[i]);
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
        registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
    }
bellard authored
312
#ifndef TARGET_SPARC64
313
314
    /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
    registers[64] = tswapl(env->y);
bellard authored
315
316
317
318
319
320
    {
	target_ulong tmp;

	tmp = GET_PSR(env);
	registers[65] = tswapl(tmp);
    }
321
322
323
324
325
326
327
    registers[66] = tswapl(env->wim);
    registers[67] = tswapl(env->tbr);
    registers[68] = tswapl(env->pc);
    registers[69] = tswapl(env->npc);
    registers[70] = tswapl(env->fsr);
    registers[71] = 0; /* csr */
    registers[72] = 0;
bellard authored
328
329
330
331
332
333
334
335
336
337
338
339
340
    return 73 * sizeof(target_ulong);
#else
    for (i = 0; i < 32; i += 2) {
        registers[i/2 + 64] = tswapl(*((uint64_t *)&env->fpr[i]));
    }
    registers[81] = tswapl(env->pc);
    registers[82] = tswapl(env->npc);
    registers[83] = tswapl(env->tstate[env->tl]);
    registers[84] = tswapl(env->fsr);
    registers[85] = tswapl(env->fprs);
    registers[86] = tswapl(env->y);
    return 87 * sizeof(target_ulong);
#endif
341
342
343
344
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
bellard authored
345
    target_ulong *registers = (target_ulong *)mem_buf;
346
347
348
349
350
351
352
353
    int i;

    /* fill in g0..g7 */
    for(i = 0; i < 7; i++) {
        env->gregs[i] = tswapl(registers[i]);
    }
    /* fill in register window */
    for(i = 0; i < 24; i++) {
bellard authored
354
        env->regwptr[i] = tswapl(registers[i + 8]);
355
356
357
358
359
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
        *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
    }
bellard authored
360
#ifndef TARGET_SPARC64
361
362
    /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
    env->y = tswapl(registers[64]);
bellard authored
363
    PUT_PSR(env, tswapl(registers[65]));
364
365
366
367
368
    env->wim = tswapl(registers[66]);
    env->tbr = tswapl(registers[67]);
    env->pc = tswapl(registers[68]);
    env->npc = tswapl(registers[69]);
    env->fsr = tswapl(registers[70]);
bellard authored
369
370
371
372
373
374
375
376
377
378
379
380
381
382
#else
    for (i = 0; i < 32; i += 2) {
	uint64_t tmp;
	tmp = tswapl(registers[i/2 + 64]) << 32;
	tmp |= tswapl(registers[i/2 + 64 + 1]);
        *((uint64_t *)&env->fpr[i]) = tmp;
    }
    env->pc = tswapl(registers[81]);
    env->npc = tswapl(registers[82]);
    env->tstate[env->tl] = tswapl(registers[83]);
    env->fsr = tswapl(registers[84]);
    env->fprs = tswapl(registers[85]);
    env->y = tswapl(registers[86]);
#endif
bellard authored
383
}
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
#elif defined (TARGET_ARM)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
    int i;
    uint8_t *ptr;

    ptr = mem_buf;
    /* 16 core integer registers (4 bytes each).  */
    for (i = 0; i < 16; i++)
      {
        *(uint32_t *)ptr = tswapl(env->regs[i]);
        ptr += 4;
      }
    /* 8 FPA registers (12 bytes each), FPS (4 bytes).
       Not yet implemented.  */
    memset (ptr, 0, 8 * 12 + 4);
    ptr += 8 * 12 + 4;
    /* CPSR (4 bytes).  */
402
    *(uint32_t *)ptr = tswapl (cpsr_read(env));
403
404
405
406
    ptr += 4;

    return ptr - mem_buf;
}
bellard authored
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
    int i;
    uint8_t *ptr;

    ptr = mem_buf;
    /* Core integer registers.  */
    for (i = 0; i < 16; i++)
      {
        env->regs[i] = tswapl(*(uint32_t *)ptr);
        ptr += 4;
      }
    /* Ignore FPA regs and scr.  */
    ptr += 8 * 12 + 4;
422
    cpsr_write (env, tswapl(*(uint32_t *)ptr), 0xffffffff);
423
}
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
#elif defined (TARGET_MIPS)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
    int i;
    uint8_t *ptr;

    ptr = mem_buf;
    for (i = 0; i < 32; i++)
      {
        *(uint32_t *)ptr = tswapl(env->gpr[i]);
        ptr += 4;
      }

    *(uint32_t *)ptr = tswapl(env->CP0_Status);
    ptr += 4;

    *(uint32_t *)ptr = tswapl(env->LO);
    ptr += 4;

    *(uint32_t *)ptr = tswapl(env->HI);
    ptr += 4;

    *(uint32_t *)ptr = tswapl(env->CP0_BadVAddr);
    ptr += 4;

    *(uint32_t *)ptr = tswapl(env->CP0_Cause);
    ptr += 4;

    *(uint32_t *)ptr = tswapl(env->PC);
    ptr += 4;

    /* 32 FP registers, fsr, fir, fp.  Not yet implemented.  */

    return ptr - mem_buf;
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
    int i;
    uint8_t *ptr;

    ptr = mem_buf;
    for (i = 0; i < 32; i++)
      {
        env->gpr[i] = tswapl(*(uint32_t *)ptr);
        ptr += 4;
      }

    env->CP0_Status = tswapl(*(uint32_t *)ptr);
    ptr += 4;

    env->LO = tswapl(*(uint32_t *)ptr);
    ptr += 4;

    env->HI = tswapl(*(uint32_t *)ptr);
    ptr += 4;

    env->CP0_BadVAddr = tswapl(*(uint32_t *)ptr);
    ptr += 4;

    env->CP0_Cause = tswapl(*(uint32_t *)ptr);
    ptr += 4;

    env->PC = tswapl(*(uint32_t *)ptr);
    ptr += 4;
}
490
#else
bellard authored
491
492
493
494
495
496
497
498
499
500
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
    return 0;
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
}

#endif
bellard authored
501
502
static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
bellard authored
503
504
{
    const char *p;
505
    int ch, reg_size, type;
bellard authored
506
507
508
509
510
    char buf[4096];
    uint8_t mem_buf[2000];
    uint32_t *registers;
    uint32_t addr, len;
511
512
513
514
515
516
517
#ifdef DEBUG_GDB
    printf("command='%s'\n", line_buf);
#endif
    p = line_buf;
    ch = *p++;
    switch(ch) {
    case '?':
518
        /* TODO: Make this return the correct value for user-mode.  */
519
520
521
522
523
524
        snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
        put_packet(s, buf);
        break;
    case 'c':
        if (*p != '\0') {
            addr = strtoul(p, (char **)&p, 16);
bellard authored
525
#if defined(TARGET_I386)
526
            env->eip = addr;
bellard authored
527
#elif defined (TARGET_PPC)
528
            env->nip = addr;
bellard authored
529
530
531
#elif defined (TARGET_SPARC)
            env->pc = addr;
            env->npc = addr + 4;
532
533
#elif defined (TARGET_ARM)
            env->regs[15] = addr;
bellard authored
534
#endif
535
        }
bellard authored
536
537
538
539
540
541
#ifdef CONFIG_USER_ONLY
        s->running_state = 1;
#else
        vm_start();
#endif
	return RS_IDLE;
542
543
544
    case 's':
        if (*p != '\0') {
            addr = strtoul(p, (char **)&p, 16);
545
#if defined(TARGET_I386)
546
            env->eip = addr;
bellard authored
547
#elif defined (TARGET_PPC)
548
            env->nip = addr;
bellard authored
549
550
551
#elif defined (TARGET_SPARC)
            env->pc = addr;
            env->npc = addr + 4;
552
553
#elif defined (TARGET_ARM)
            env->regs[15] = addr;
554
#endif
555
556
        }
        cpu_single_step(env, 1);
bellard authored
557
558
559
560
561
562
#ifdef CONFIG_USER_ONLY
        s->running_state = 1;
#else
        vm_start();
#endif
	return RS_IDLE;
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
    case 'g':
        reg_size = cpu_gdb_read_registers(env, mem_buf);
        memtohex(buf, mem_buf, reg_size);
        put_packet(s, buf);
        break;
    case 'G':
        registers = (void *)mem_buf;
        len = strlen(p) / 2;
        hextomem((uint8_t *)registers, p, len);
        cpu_gdb_write_registers(env, mem_buf, len);
        put_packet(s, "OK");
        break;
    case 'm':
        addr = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoul(p, NULL, 16);
580
581
582
583
584
585
        if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
            put_packet (s, "E14");
        } else {
            memtohex(buf, mem_buf, len);
            put_packet(s, buf);
        }
586
587
588
589
590
591
        break;
    case 'M':
        addr = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoul(p, (char **)&p, 16);
592
        if (*p == ':')
593
594
595
            p++;
        hextomem(mem_buf, p, len);
        if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
596
            put_packet(s, "E14");
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
        else
            put_packet(s, "OK");
        break;
    case 'Z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        addr = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoul(p, (char **)&p, 16);
        if (type == 0 || type == 1) {
            if (cpu_breakpoint_insert(env, addr) < 0)
                goto breakpoint_error;
            put_packet(s, "OK");
        } else {
        breakpoint_error:
614
            put_packet(s, "E22");
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
        }
        break;
    case 'z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        addr = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoul(p, (char **)&p, 16);
        if (type == 0 || type == 1) {
            cpu_breakpoint_remove(env, addr);
            put_packet(s, "OK");
        } else {
            goto breakpoint_error;
        }
        break;
    default:
        //        unknown_command:
        /* put empty packet */
        buf[0] = '\0';
        put_packet(s, buf);
        break;
    }
    return RS_IDLE;
}
bellard authored
642
643
extern void tb_flush(CPUState *env);
644
#ifndef CONFIG_USER_ONLY
645
646
647
648
649
650
651
static void gdb_vm_stopped(void *opaque, int reason)
{
    GDBState *s = opaque;
    char buf[256];
    int ret;

    /* disable single step if it was enable */
bellard authored
652
    cpu_single_step(s->env, 0);
653
bellard authored
654
    if (reason == EXCP_DEBUG) {
bellard authored
655
	tb_flush(s->env);
656
        ret = SIGTRAP;
bellard authored
657
    }
658
659
660
661
662
    else
        ret = 0;
    snprintf(buf, sizeof(buf), "S%02x", ret);
    put_packet(s, buf);
}
663
#endif
664
bellard authored
665
static void gdb_read_byte(GDBState *s, int ch)
666
{
bellard authored
667
    CPUState *env = s->env;
668
669
670
    int i, csum;
    char reply[1];
671
#ifndef CONFIG_USER_ONLY
672
673
674
675
    if (vm_running) {
        /* when the CPU is running, we cannot do anything except stop
           it when receiving a char */
        vm_stop(EXCP_INTERRUPT);
bellard authored
676
    } else 
677
#endif
bellard authored
678
    {
679
680
681
682
683
        switch(s->state) {
        case RS_IDLE:
            if (ch == '$') {
                s->line_buf_index = 0;
                s->state = RS_GETLINE;
684
            }
bellard authored
685
            break;
686
687
688
689
690
        case RS_GETLINE:
            if (ch == '#') {
            s->state = RS_CHKSUM1;
            } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
                s->state = RS_IDLE;
bellard authored
691
            } else {
692
            s->line_buf[s->line_buf_index++] = ch;
bellard authored
693
694
            }
            break;
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
        case RS_CHKSUM1:
            s->line_buf[s->line_buf_index] = '\0';
            s->line_csum = fromhex(ch) << 4;
            s->state = RS_CHKSUM2;
            break;
        case RS_CHKSUM2:
            s->line_csum |= fromhex(ch);
            csum = 0;
            for(i = 0; i < s->line_buf_index; i++) {
                csum += s->line_buf[i];
            }
            if (s->line_csum != (csum & 0xff)) {
                reply[0] = '-';
                put_buffer(s, reply, 1);
                s->state = RS_IDLE;
bellard authored
710
            } else {
711
712
                reply[0] = '+';
                put_buffer(s, reply, 1);
713
                s->state = gdb_handle_packet(s, env, s->line_buf);
bellard authored
714
715
            }
            break;
716
717
718
719
        }
    }
}
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
#ifdef CONFIG_USER_ONLY
int
gdb_handlesig (CPUState *env, int sig)
{
  GDBState *s;
  char buf[256];
  int n;

  if (gdbserver_fd < 0)
    return sig;

  s = &gdbserver_state;

  /* disable single step if it was enabled */
  cpu_single_step(env, 0);
  tb_flush(env);

  if (sig != 0)
    {
      snprintf(buf, sizeof(buf), "S%02x", sig);
      put_packet(s, buf);
    }

  sig = 0;
  s->state = RS_IDLE;
bellard authored
745
746
  s->running_state = 0;
  while (s->running_state == 0) {
747
748
749
750
751
752
      n = read (s->fd, buf, 256);
      if (n > 0)
        {
          int i;

          for (i = 0; i < n; i++)
bellard authored
753
            gdb_read_byte (s, buf[i]);
754
755
756
757
758
759
760
        }
      else if (n == 0 || errno != EAGAIN)
        {
          /* XXX: Connection closed.  Should probably wait for annother
             connection before continuing.  */
          return sig;
        }
bellard authored
761
  }
762
763
  return sig;
}
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779

/* Tell the remote gdb that the process has exited.  */
void gdb_exit(CPUState *env, int code)
{
  GDBState *s;
  char buf[4];

  if (gdbserver_fd < 0)
    return;

  s = &gdbserver_state;

  snprintf(buf, sizeof(buf), "W%02x", code);
  put_packet(s, buf);
}
780
#else
bellard authored
781
static void gdb_read(void *opaque)
782
783
{
    GDBState *s = opaque;
bellard authored
784
785
786
787
788
789
    int i, size;
    uint8_t buf[4096];

    size = read(s->fd, buf, sizeof(buf));
    if (size < 0)
        return;
790
791
792
    if (size == 0) {
        /* end of connection */
        qemu_del_vm_stop_handler(gdb_vm_stopped, s);
bellard authored
793
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
794
795
796
797
        qemu_free(s);
        vm_start();
    } else {
        for(i = 0; i < size; i++)
bellard authored
798
            gdb_read_byte(s, buf[i]);
799
800
801
    }
}
802
803
#endif
bellard authored
804
static void gdb_accept(void *opaque)
805
806
807
808
809
810
811
812
813
814
815
816
817
{
    GDBState *s;
    struct sockaddr_in sockaddr;
    socklen_t len;
    int val, fd;

    for(;;) {
        len = sizeof(sockaddr);
        fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
        if (fd < 0 && errno != EINTR) {
            perror("accept");
            return;
        } else if (fd >= 0) {
bellard authored
818
819
820
            break;
        }
    }
821
822
823

    /* set short latency */
    val = 1;
bellard authored
824
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
825
826
827
828
829
#ifdef CONFIG_USER_ONLY
    s = &gdbserver_state;
    memset (s, 0, sizeof (GDBState));
#else
830
831
832
833
834
    s = qemu_mallocz(sizeof(GDBState));
    if (!s) {
        close(fd);
        return;
    }
835
#endif
bellard authored
836
    s->env = first_cpu; /* XXX: allow to change CPU */
837
838
839
840
    s->fd = fd;

    fcntl(fd, F_SETFL, O_NONBLOCK);
841
#ifndef CONFIG_USER_ONLY
842
843
844
845
    /* stop the VM */
    vm_stop(EXCP_INTERRUPT);

    /* start handling I/O */
bellard authored
846
    qemu_set_fd_handler(s->fd, gdb_read, NULL, s);
847
848
    /* when the VM is stopped, the following callback is called */
    qemu_add_vm_stop_handler(gdb_vm_stopped, s);
849
#endif
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
}

static int gdbserver_open(int port)
{
    struct sockaddr_in sockaddr;
    int fd, val, ret;

    fd = socket(PF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        perror("socket");
        return -1;
    }

    /* allow fast reuse */
    val = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));

    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(port);
    sockaddr.sin_addr.s_addr = 0;
    ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
    if (ret < 0) {
        perror("bind");
        return -1;
    }
    ret = listen(fd, 0);
    if (ret < 0) {
        perror("listen");
        return -1;
    }
880
#ifndef CONFIG_USER_ONLY
881
    fcntl(fd, F_SETFL, O_NONBLOCK);
882
#endif
883
884
885
886
887
888
889
890
891
    return fd;
}

int gdbserver_start(int port)
{
    gdbserver_fd = gdbserver_open(port);
    if (gdbserver_fd < 0)
        return -1;
    /* accept connections */
892
#ifdef CONFIG_USER_ONLY
bellard authored
893
    gdb_accept (NULL);
894
#else
bellard authored
895
    qemu_set_fd_handler(gdbserver_fd, gdb_accept, NULL, NULL);
896
#endif
bellard authored
897
898
    return 0;
}