remote_gdb.cc revision 7720:65d338a8dba4
1/*
2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31/*
32 * Copyright (c) 1990, 1993
33 *      The Regents of the University of California.  All rights reserved.
34 *
35 * This software was developed by the Computer Systems Engineering group
36 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
37 * contributed to Berkeley.
38 *
39 * All advertising materials mentioning features or use of this software
40 * must display the following acknowledgement:
41 *      This product includes software developed by the University of
42 *      California, Lawrence Berkeley Laboratories.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 *    notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 *    notice, this list of conditions and the following disclaimer in the
51 *    documentation and/or other materials provided with the distribution.
52 * 3. All advertising materials mentioning features or use of this software
53 *    must display the following acknowledgement:
54 *      This product includes software developed by the University of
55 *      California, Berkeley and its contributors.
56 * 4. Neither the name of the University nor the names of its contributors
57 *    may be used to endorse or promote products derived from this software
58 *    without specific prior written permission.
59 *
60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70 * SUCH DAMAGE.
71 *
72 *      @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
73 */
74
75/*-
76 * Copyright (c) 2001 The NetBSD Foundation, Inc.
77 * All rights reserved.
78 *
79 * This code is derived from software contributed to The NetBSD Foundation
80 * by Jason R. Thorpe.
81 *
82 * Redistribution and use in source and binary forms, with or without
83 * modification, are permitted provided that the following conditions
84 * are met:
85 * 1. Redistributions of source code must retain the above copyright
86 *    notice, this list of conditions and the following disclaimer.
87 * 2. Redistributions in binary form must reproduce the above copyright
88 *    notice, this list of conditions and the following disclaimer in the
89 *    documentation and/or other materials provided with the distribution.
90 * 3. All advertising materials mentioning features or use of this software
91 *    must display the following acknowledgement:
92 *      This product includes software developed by the NetBSD
93 *      Foundation, Inc. and its contributors.
94 * 4. Neither the name of The NetBSD Foundation nor the names of its
95 *    contributors may be used to endorse or promote products derived
96 *    from this software without specific prior written permission.
97 *
98 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
99 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
100 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
101 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
102 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
108 * POSSIBILITY OF SUCH DAMAGE.
109 */
110
111/*
112 * $NetBSD: kgdb_stub.c,v 1.8 2001/07/07 22:58:00 wdk Exp $
113 *
114 * Taken from NetBSD
115 *
116 * "Stub" to allow remote cpu to debug over a serial line using gdb.
117 */
118
119#include <sys/signal.h>
120
121#include <cstdio>
122#include <string>
123#include <unistd.h>
124
125#include "config/full_system.hh"
126
127#if FULL_SYSTEM
128#include "arch/vtophys.hh"
129#endif
130
131#include "base/intmath.hh"
132#include "base/remote_gdb.hh"
133#include "base/socket.hh"
134#include "base/trace.hh"
135#include "config/the_isa.hh"
136#include "cpu/thread_context.hh"
137#include "cpu/static_inst.hh"
138#include "mem/port.hh"
139#include "mem/translating_port.hh"
140#include "sim/system.hh"
141
142using namespace std;
143using namespace TheISA;
144
145#ifndef NDEBUG
146vector<BaseRemoteGDB *> debuggers;
147
148void
149debugger()
150{
151    static int current_debugger = -1;
152    if (current_debugger >= 0 && current_debugger < (int)debuggers.size()) {
153        BaseRemoteGDB *gdb = debuggers[current_debugger];
154        if (!gdb->isattached())
155            gdb->listener->accept();
156        if (gdb->isattached())
157            gdb->trap(SIGILL);
158    }
159}
160#endif
161
162///////////////////////////////////////////////////////////
163//
164//
165//
166
167GDBListener::Event::Event(GDBListener *l, int fd, int e)
168    : PollEvent(fd, e), listener(l)
169{}
170
171void
172GDBListener::Event::process(int revent)
173{
174    listener->accept();
175}
176
177GDBListener::GDBListener(BaseRemoteGDB *g, int p)
178    : event(NULL), gdb(g), port(p)
179{
180    assert(!gdb->listener);
181    gdb->listener = this;
182}
183
184GDBListener::~GDBListener()
185{
186    if (event)
187        delete event;
188}
189
190string
191GDBListener::name()
192{
193    return gdb->name() + ".listener";
194}
195
196void
197GDBListener::listen()
198{
199    if (ListenSocket::allDisabled()) {
200        warn_once("Sockets disabled, not accepting gdb connections");
201        return;
202    }
203
204    while (!listener.listen(port, true)) {
205        DPRINTF(GDBMisc, "Can't bind port %d\n", port);
206        port++;
207    }
208
209    event = new Event(this, listener.getfd(), POLLIN);
210    pollQueue.schedule(event);
211
212#ifndef NDEBUG
213    gdb->number = debuggers.size();
214    debuggers.push_back(gdb);
215#endif
216
217#ifndef NDEBUG
218    ccprintf(cerr, "%d: %s: listening for remote gdb #%d on port %d\n",
219             curTick, name(), gdb->number, port);
220#else
221    ccprintf(cerr, "%d: %s: listening for remote gdb on port %d\n",
222             curTick, name(), port);
223#endif
224}
225
226void
227GDBListener::accept()
228{
229    if (!listener.islistening())
230        panic("GDBListener::accept(): cannot accept if we're not listening!");
231
232    int sfd = listener.accept(true);
233
234    if (sfd != -1) {
235        if (gdb->isattached())
236            close(sfd);
237        else
238            gdb->attach(sfd);
239    }
240}
241
242BaseRemoteGDB::Event::Event(BaseRemoteGDB *g, int fd, int e)
243    : PollEvent(fd, e), gdb(g)
244{}
245
246void
247BaseRemoteGDB::Event::process(int revent)
248{
249    if (revent & POLLIN)
250        gdb->trap(SIGILL);
251    else if (revent & POLLNVAL)
252        gdb->detach();
253}
254
255BaseRemoteGDB::BaseRemoteGDB(System *_system, ThreadContext *c, size_t cacheSize)
256    : event(NULL), listener(NULL), number(-1), fd(-1),
257      active(false), attached(false),
258      system(_system), pmem(_system->physmem), context(c),
259      gdbregs(cacheSize)
260{
261    memset(gdbregs.regs, 0, gdbregs.bytes());
262}
263
264BaseRemoteGDB::~BaseRemoteGDB()
265{
266    if (event)
267        delete event;
268}
269
270string
271BaseRemoteGDB::name()
272{
273    return system->name() + ".remote_gdb";
274}
275
276bool
277BaseRemoteGDB::isattached()
278{ return attached; }
279
280void
281BaseRemoteGDB::attach(int f)
282{
283    fd = f;
284
285    event = new Event(this, fd, POLLIN);
286    pollQueue.schedule(event);
287
288    attached = true;
289    DPRINTFN("remote gdb attached\n");
290}
291
292void
293BaseRemoteGDB::detach()
294{
295    attached = false;
296    close(fd);
297    fd = -1;
298
299    pollQueue.remove(event);
300    DPRINTFN("remote gdb detached\n");
301}
302
303const char *
304BaseRemoteGDB::gdb_command(char cmd)
305{
306    switch (cmd) {
307      case GDBSignal: return "KGDB_SIGNAL";
308      case GDBSetBaud: return "KGDB_SET_BAUD";
309      case GDBSetBreak: return "KGDB_SET_BREAK";
310      case GDBCont: return "KGDB_CONT";
311      case GDBAsyncCont: return "KGDB_ASYNC_CONT";
312      case GDBDebug: return "KGDB_DEBUG";
313      case GDBDetach: return "KGDB_DETACH";
314      case GDBRegR: return "KGDB_REG_R";
315      case GDBRegW: return "KGDB_REG_W";
316      case GDBSetThread: return "KGDB_SET_THREAD";
317      case GDBCycleStep: return "KGDB_CYCLE_STEP";
318      case GDBSigCycleStep: return "KGDB_SIG_CYCLE_STEP";
319      case GDBKill: return "KGDB_KILL";
320      case GDBMemW: return "KGDB_MEM_W";
321      case GDBMemR: return "KGDB_MEM_R";
322      case GDBSetReg: return "KGDB_SET_REG";
323      case GDBReadReg: return "KGDB_READ_REG";
324      case GDBQueryVar: return "KGDB_QUERY_VAR";
325      case GDBSetVar: return "KGDB_SET_VAR";
326      case GDBReset: return "KGDB_RESET";
327      case GDBStep: return "KGDB_STEP";
328      case GDBAsyncStep: return "KGDB_ASYNC_STEP";
329      case GDBThreadAlive: return "KGDB_THREAD_ALIVE";
330      case GDBTargetExit: return "KGDB_TARGET_EXIT";
331      case GDBBinaryDload: return "KGDB_BINARY_DLOAD";
332      case GDBClrHwBkpt: return "KGDB_CLR_HW_BKPT";
333      case GDBSetHwBkpt: return "KGDB_SET_HW_BKPT";
334      case GDBStart: return "KGDB_START";
335      case GDBEnd: return "KGDB_END";
336      case GDBGoodP: return "KGDB_GOODP";
337      case GDBBadP: return "KGDB_BADP";
338      default: return "KGDB_UNKNOWN";
339    }
340}
341
342/////////////////////////
343//
344//
345
346uint8_t
347BaseRemoteGDB::getbyte()
348{
349    uint8_t b;
350    if (::read(fd, &b, 1) != 1)
351        warn("could not read byte from debugger");
352    return b;
353}
354
355void
356BaseRemoteGDB::putbyte(uint8_t b)
357{
358    if (::write(fd, &b, 1) != 1)
359        warn("could not write byte to debugger");
360}
361
362// Send a packet to gdb
363void
364BaseRemoteGDB::send(const char *bp)
365{
366    const char *p;
367    uint8_t csum, c;
368
369    DPRINTF(GDBSend, "send:  %s\n", bp);
370
371    do {
372        p = bp;
373        //Start sending a packet
374        putbyte(GDBStart);
375        //Send the contents, and also keep a check sum.
376        for (csum = 0; (c = *p); p++) {
377            putbyte(c);
378            csum += c;
379        }
380        //Send the ending character.
381        putbyte(GDBEnd);
382        //Sent the checksum.
383        putbyte(i2digit(csum >> 4));
384        putbyte(i2digit(csum));
385        //Try transmitting over and over again until the other end doesn't send an
386        //error back.
387    } while ((c = getbyte() & 0x7f) == GDBBadP);
388}
389
390// Receive a packet from gdb
391int
392BaseRemoteGDB::recv(char *bp, int maxlen)
393{
394    char *p;
395    int c, csum;
396    int len;
397
398    do {
399        p = bp;
400        csum = len = 0;
401        //Find the beginning of a packet
402        while ((c = getbyte()) != GDBStart)
403            ;
404
405        //Read until you find the end of the data in the packet, and keep
406        //track of the check sum.
407        while ((c = getbyte()) != GDBEnd && len < maxlen) {
408            c &= 0x7f;
409            csum += c;
410            *p++ = c;
411            len++;
412        }
413
414        //Mask the check sum, and terminate the command string.
415        csum &= 0xff;
416        *p = '\0';
417
418        //If the command was too long, report an error.
419        if (len >= maxlen) {
420            putbyte(GDBBadP);
421            continue;
422        }
423
424        //Bring in the checksum. If the check sum matches, csum will be 0.
425        csum -= digit2i(getbyte()) * 16;
426        csum -= digit2i(getbyte());
427
428        //If the check sum was correct
429        if (csum == 0) {
430            //Report that the packet was received correctly
431            putbyte(GDBGoodP);
432            // Sequence present?
433            if (bp[2] == ':') {
434                putbyte(bp[0]);
435                putbyte(bp[1]);
436                len -= 3;
437                memcpy(bp, bp+3, len);
438            }
439            break;
440        }
441        //Otherwise, report that there was a mistake.
442        putbyte(GDBBadP);
443    } while (1);
444
445    DPRINTF(GDBRecv, "recv:  %s: %s\n", gdb_command(*bp), bp);
446
447    return (len);
448}
449
450// Read bytes from kernel address space for debugger.
451bool
452BaseRemoteGDB::read(Addr vaddr, size_t size, char *data)
453{
454    static Addr lastaddr = 0;
455    static size_t lastsize = 0;
456
457    if (vaddr < 10) {
458      DPRINTF(GDBRead, "read:  reading memory location zero!\n");
459      vaddr = lastaddr + lastsize;
460    }
461
462    DPRINTF(GDBRead, "read:  addr=%#x, size=%d", vaddr, size);
463
464#if FULL_SYSTEM
465    VirtualPort *port = context->getVirtPort();
466#else
467    TranslatingPort *port = context->getMemPort();
468#endif
469    port->readBlob(vaddr, (uint8_t*)data, size);
470
471#if TRACING_ON
472    if (DTRACE(GDBRead)) {
473        if (DTRACE(GDBExtra)) {
474            char buf[1024];
475            mem2hex(buf, data, size);
476            DPRINTFNR(": %s\n", buf);
477        } else
478            DPRINTFNR("\n");
479    }
480#endif
481
482    return true;
483}
484
485// Write bytes to kernel address space for debugger.
486bool
487BaseRemoteGDB::write(Addr vaddr, size_t size, const char *data)
488{
489    static Addr lastaddr = 0;
490    static size_t lastsize = 0;
491
492    if (vaddr < 10) {
493      DPRINTF(GDBWrite, "write: writing memory location zero!\n");
494      vaddr = lastaddr + lastsize;
495    }
496
497    if (DTRACE(GDBWrite)) {
498        DPRINTFN("write: addr=%#x, size=%d", vaddr, size);
499        if (DTRACE(GDBExtra)) {
500            char buf[1024];
501            mem2hex(buf, data, size);
502            DPRINTFNR(": %s\n", buf);
503        } else
504            DPRINTFNR("\n");
505    }
506#if FULL_SYSTEM
507    VirtualPort *port = context->getVirtPort();
508#else
509    TranslatingPort *port = context->getMemPort();
510#endif
511    port->writeBlob(vaddr, (uint8_t*)data, size);
512#if !FULL_SYSTEM
513    delete port;
514#endif
515
516    return true;
517}
518
519PCEventQueue *BaseRemoteGDB::getPcEventQueue()
520{
521    return &system->pcEventQueue;
522}
523
524BaseRemoteGDB::HardBreakpoint::HardBreakpoint(BaseRemoteGDB *_gdb, Addr pc)
525    : PCEvent(_gdb->getPcEventQueue(), "HardBreakpoint Event", pc),
526      gdb(_gdb), refcount(0)
527{
528    DPRINTF(GDBMisc, "creating hardware breakpoint at %#x\n", evpc);
529}
530
531void
532BaseRemoteGDB::HardBreakpoint::process(ThreadContext *tc)
533{
534    DPRINTF(GDBMisc, "handling hardware breakpoint at %#x\n", pc());
535
536    if (tc == gdb->context)
537        gdb->trap(SIGTRAP);
538}
539
540bool
541BaseRemoteGDB::insertSoftBreak(Addr addr, size_t len)
542{
543    if (len != sizeof(TheISA::MachInst))
544        panic("invalid length\n");
545
546    return insertHardBreak(addr, len);
547}
548
549bool
550BaseRemoteGDB::removeSoftBreak(Addr addr, size_t len)
551{
552    if (len != sizeof(MachInst))
553        panic("invalid length\n");
554
555    return removeHardBreak(addr, len);
556}
557
558bool
559BaseRemoteGDB::insertHardBreak(Addr addr, size_t len)
560{
561    if (len != sizeof(MachInst))
562        panic("invalid length\n");
563
564    DPRINTF(GDBMisc, "inserting hardware breakpoint at %#x\n", addr);
565
566    HardBreakpoint *&bkpt = hardBreakMap[addr];
567    if (bkpt == 0)
568        bkpt = new HardBreakpoint(this, addr);
569
570    bkpt->refcount++;
571
572    return true;
573}
574
575bool
576BaseRemoteGDB::removeHardBreak(Addr addr, size_t len)
577{
578    if (len != sizeof(MachInst))
579        panic("invalid length\n");
580
581    DPRINTF(GDBMisc, "removing hardware breakpoint at %#x\n", addr);
582
583    break_iter_t i = hardBreakMap.find(addr);
584    if (i == hardBreakMap.end())
585        return false;
586
587    HardBreakpoint *hbp = (*i).second;
588    if (--hbp->refcount == 0) {
589        delete hbp;
590        hardBreakMap.erase(i);
591    }
592
593    return true;
594}
595
596void
597BaseRemoteGDB::setTempBreakpoint(Addr bkpt)
598{
599    DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
600    insertHardBreak(bkpt, sizeof(TheISA::MachInst));
601}
602
603void
604BaseRemoteGDB::clearTempBreakpoint(Addr &bkpt)
605{
606    DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
607    removeHardBreak(bkpt, sizeof(TheISA::MachInst));
608    bkpt = 0;
609}
610
611const char *
612BaseRemoteGDB::break_type(char c)
613{
614    switch(c) {
615      case '0': return "software breakpoint";
616      case '1': return "hardware breakpoint";
617      case '2': return "write watchpoint";
618      case '3': return "read watchpoint";
619      case '4': return "access watchpoint";
620      default: return "unknown breakpoint/watchpoint";
621    }
622}
623
624// This function does all command processing for interfacing to a
625// remote gdb.  Note that the error codes are ignored by gdb at
626// present, but might eventually become meaningful. (XXX) It might
627// makes sense to use POSIX errno values, because that is what the
628// gdb/remote.c functions want to return.
629bool
630BaseRemoteGDB::trap(int type)
631{
632    uint64_t val;
633    size_t datalen, len;
634    char data[GDBPacketBufLen + 1];
635    char *buffer;
636    size_t bufferSize;
637    const char *p;
638    char command, subcmd;
639    string var;
640    bool ret;
641
642    if (!attached)
643        return false;
644
645    bufferSize = gdbregs.bytes() * 2 + 256;
646    buffer = (char*)malloc(bufferSize);
647
648    TheISA::PCState pc = context->pcState();
649    DPRINTF(GDBMisc, "trap: PC=%s\n", pc);
650
651    clearSingleStep();
652
653    /*
654     * The first entry to this function is normally through
655     * a breakpoint trap in kgdb_connect(), in which case we
656     * must advance past the breakpoint because gdb will not.
657     *
658     * On the first entry here, we expect that gdb is not yet
659     * listening to us, so just enter the interaction loop.
660     * After the debugger is "active" (connected) it will be
661     * waiting for a "signaled" message from us.
662     */
663    if (!active)
664        active = true;
665    else
666        // Tell remote host that an exception has occurred.
667        snprintf((char *)buffer, bufferSize, "S%02x", type);
668        send(buffer);
669
670    // Stick frame regs into our reg cache.
671    getregs();
672
673    for (;;) {
674        datalen = recv(data, sizeof(data));
675        data[sizeof(data) - 1] = 0; // Sentinel
676        command = data[0];
677        subcmd = 0;
678        p = data + 1;
679        switch (command) {
680
681          case GDBSignal:
682            // if this command came from a running gdb, answer it --
683            // the other guy has no way of knowing if we're in or out
684            // of this loop when he issues a "remote-signal".
685            snprintf((char *)buffer, bufferSize,
686                    "S%02x", type);
687            send(buffer);
688            continue;
689
690          case GDBRegR:
691            if (2 * gdbregs.bytes() > bufferSize)
692                panic("buffer too small");
693
694            mem2hex(buffer, gdbregs.regs, gdbregs.bytes());
695            send(buffer);
696            continue;
697
698          case GDBRegW:
699            p = hex2mem(gdbregs.regs, p, gdbregs.bytes());
700            if (p == NULL || *p != '\0')
701                send("E01");
702            else {
703                setregs();
704                send("OK");
705            }
706            continue;
707
708#if 0
709          case GDBSetReg:
710            val = hex2i(&p);
711            if (*p++ != '=') {
712                send("E01");
713                continue;
714            }
715            if (val < 0 && val >= KGDB_NUMREGS) {
716                send("E01");
717                continue;
718            }
719
720            gdbregs.regs[val] = hex2i(&p);
721            setregs();
722            send("OK");
723
724            continue;
725#endif
726
727          case GDBMemR:
728            val = hex2i(&p);
729            if (*p++ != ',') {
730                send("E02");
731                continue;
732            }
733            len = hex2i(&p);
734            if (*p != '\0') {
735                send("E03");
736                continue;
737            }
738            if (len > bufferSize) {
739                send("E04");
740                continue;
741            }
742            if (!acc(val, len)) {
743                send("E05");
744                continue;
745            }
746
747            if (read(val, (size_t)len, (char *)buffer)) {
748               // variable length array would be nice, but C++ doesn't
749               // officially support those...
750               char *temp = new char[2*len+1];
751               mem2hex(temp, buffer, len);
752               send(temp);
753               delete [] temp;
754            } else {
755               send("E05");
756            }
757            continue;
758
759          case GDBMemW:
760            val = hex2i(&p);
761            if (*p++ != ',') {
762                send("E06");
763                continue;
764            }
765            len = hex2i(&p);
766            if (*p++ != ':') {
767                send("E07");
768                continue;
769            }
770            if (len > datalen - (p - data)) {
771                send("E08");
772                continue;
773            }
774            p = hex2mem(buffer, p, bufferSize);
775            if (p == NULL) {
776                send("E09");
777                continue;
778            }
779            if (!acc(val, len)) {
780                send("E0A");
781                continue;
782            }
783            if (write(val, (size_t)len, (char *)buffer))
784              send("OK");
785            else
786              send("E0B");
787            continue;
788
789          case GDBSetThread:
790            subcmd = *p++;
791            val = hex2i(&p);
792            if (val == 0)
793                send("OK");
794            else
795                send("E01");
796            continue;
797
798          case GDBDetach:
799          case GDBKill:
800            active = false;
801            clearSingleStep();
802            detach();
803            goto out;
804
805          case GDBAsyncCont:
806            subcmd = hex2i(&p);
807            if (*p++ == ';') {
808                val = hex2i(&p);
809                context->pcState(val);
810            }
811            clearSingleStep();
812            goto out;
813
814          case GDBCont:
815            if (p - data < (ptrdiff_t)datalen) {
816                val = hex2i(&p);
817                context->pcState(val);
818            }
819            clearSingleStep();
820            goto out;
821
822          case GDBAsyncStep:
823            subcmd = hex2i(&p);
824            if (*p++ == ';') {
825                val = hex2i(&p);
826                context->pcState(val);
827            }
828            setSingleStep();
829            goto out;
830
831          case GDBStep:
832            if (p - data < (ptrdiff_t)datalen) {
833                val = hex2i(&p);
834                context->pcState(val);
835            }
836            setSingleStep();
837            goto out;
838
839          case GDBClrHwBkpt:
840            subcmd = *p++;
841            if (*p++ != ',') send("E0D");
842            val = hex2i(&p);
843            if (*p++ != ',') send("E0D");
844            len = hex2i(&p);
845
846            DPRINTF(GDBMisc, "clear %s, addr=%#x, len=%d\n",
847                    break_type(subcmd), val, len);
848
849            ret = false;
850
851            switch (subcmd) {
852              case '0': // software breakpoint
853                ret = removeSoftBreak(val, len);
854                break;
855
856              case '1': // hardware breakpoint
857                ret = removeHardBreak(val, len);
858                break;
859
860              case '2': // write watchpoint
861              case '3': // read watchpoint
862              case '4': // access watchpoint
863              default: // unknown
864                send("");
865                break;
866            }
867
868            send(ret ? "OK" : "E0C");
869            continue;
870
871          case GDBSetHwBkpt:
872            subcmd = *p++;
873            if (*p++ != ',') send("E0D");
874            val = hex2i(&p);
875            if (*p++ != ',') send("E0D");
876            len = hex2i(&p);
877
878            DPRINTF(GDBMisc, "set %s, addr=%#x, len=%d\n",
879                    break_type(subcmd), val, len);
880
881            ret = false;
882
883            switch (subcmd) {
884              case '0': // software breakpoint
885                ret = insertSoftBreak(val, len);
886                break;
887
888              case '1': // hardware breakpoint
889                ret = insertHardBreak(val, len);
890                break;
891
892              case '2': // write watchpoint
893              case '3': // read watchpoint
894              case '4': // access watchpoint
895              default: // unknown
896                send("");
897                break;
898            }
899
900            send(ret ? "OK" : "E0C");
901            continue;
902
903          case GDBQueryVar:
904            var = string(p, datalen - 1);
905            if (var == "C")
906                send("QC0");
907            else
908                send("");
909            continue;
910
911          case GDBSetBaud:
912          case GDBSetBreak:
913          case GDBDebug:
914          case GDBCycleStep:
915          case GDBSigCycleStep:
916          case GDBReadReg:
917          case GDBSetVar:
918          case GDBReset:
919          case GDBThreadAlive:
920          case GDBTargetExit:
921          case GDBBinaryDload:
922            // Unsupported command
923            DPRINTF(GDBMisc, "Unsupported command: %s\n",
924                    gdb_command(command));
925            DDUMP(GDBMisc, (uint8_t *)data, datalen);
926            send("");
927            continue;
928
929          default:
930            // Unknown command.
931            DPRINTF(GDBMisc, "Unknown command: %c(%#x)\n",
932                    command, command);
933            send("");
934            continue;
935
936
937        }
938    }
939
940  out:
941    free(buffer);
942    return true;
943}
944
945// Convert a hex digit into an integer.
946// This returns -1 if the argument passed is no valid hex digit.
947int
948BaseRemoteGDB::digit2i(char c)
949{
950    if (c >= '0' && c <= '9')
951        return (c - '0');
952    else if (c >= 'a' && c <= 'f')
953        return (c - 'a' + 10);
954    else if (c >= 'A' && c <= 'F')
955
956        return (c - 'A' + 10);
957    else
958        return (-1);
959}
960
961// Convert the low 4 bits of an integer into an hex digit.
962char
963BaseRemoteGDB::i2digit(int n)
964{
965    return ("0123456789abcdef"[n & 0x0f]);
966}
967
968// Convert a byte array into an hex string.
969void
970BaseRemoteGDB::mem2hex(void *vdst, const void *vsrc, int len)
971{
972    char *dst = (char *)vdst;
973    const char *src = (const char *)vsrc;
974
975    while (len--) {
976        *dst++ = i2digit(*src >> 4);
977        *dst++ = i2digit(*src++);
978    }
979    *dst = '\0';
980}
981
982// Convert an hex string into a byte array.
983// This returns a pointer to the character following the last valid
984// hex digit. If the string ends in the middle of a byte, NULL is
985// returned.
986const char *
987BaseRemoteGDB::hex2mem(void *vdst, const char *src, int maxlen)
988{
989    char *dst = (char *)vdst;
990    int msb, lsb;
991
992    while (*src && maxlen--) {
993        msb = digit2i(*src++);
994        if (msb < 0)
995            return (src - 1);
996        lsb = digit2i(*src++);
997        if (lsb < 0)
998            return (NULL);
999        *dst++ = (msb << 4) | lsb;
1000    }
1001    return (src);
1002}
1003
1004// Convert an hex string into an integer.
1005// This returns a pointer to the character following the last valid
1006// hex digit.
1007Addr
1008BaseRemoteGDB::hex2i(const char **srcp)
1009{
1010    const char *src = *srcp;
1011    Addr r = 0;
1012    int nibble;
1013
1014    while ((nibble = digit2i(*src)) >= 0) {
1015        r *= 16;
1016        r += nibble;
1017        src++;
1018    }
1019    *srcp = src;
1020    return (r);
1021}
1022
1023