src/base/remote_gdb.hh

   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 #ifndef __REMOTE_GDB_HH__
  32 #define __REMOTE_GDB_HH__
  33
  34 #include <sys/signal.h>
  35
  36 #include <map>
  37
  38 #include "arch/types.hh"
  39 #include "base/pollevent.hh"
  40 #include "base/socket.hh"
  41 #include "cpu/pc_event.hh"
  42
  43 class System;
  44 class ThreadContext;
  45 class PhysicalMemory;
  46
  47 class GDBListener;
  48
  49 enum GDBCommands
  50 {
  51     GDBSignal              = '?', // last signal
  52     GDBSetBaud             = 'b', // set baud (depracated)
  53     GDBSetBreak            = 'B', // set breakpoint (depracated)
  54     GDBCont                = 'c', // resume
  55     GDBAsyncCont           = 'C', // continue with signal
  56     GDBDebug               = 'd', // toggle debug flags (deprecated)
  57     GDBDetach              = 'D', // detach remote gdb
  58     GDBRegR                = 'g', // read general registers
  59     GDBRegW                = 'G', // write general registers
  60     GDBSetThread           = 'H', // set thread
  61     GDBCycleStep           = 'i', // step a single cycle
  62     GDBSigCycleStep        = 'I', // signal then cycle step
  63     GDBKill                = 'k', // kill program
  64     GDBMemR                = 'm', // read memory
  65     GDBMemW                = 'M', // write memory
  66     GDBReadReg             = 'p', // read register
  67     GDBSetReg              = 'P', // write register
  68     GDBQueryVar            = 'q', // query variable
  69     GDBSetVar              = 'Q', // set variable
  70     GDBReset               = 'r', // reset system.  (Deprecated)
  71     GDBStep                = 's', // step
  72     GDBAsyncStep           = 'S', // signal and step
  73     GDBThreadAlive         = 'T', // find out if the thread is alive
  74     GDBTargetExit          = 'W', // target exited
  75     GDBBinaryDload         = 'X', // write memory
  76     GDBClrHwBkpt           = 'z', // remove breakpoint or watchpoint
  77     GDBSetHwBkpt           = 'Z'  // insert breakpoint or watchpoint
  78 };
  79
  80 const char GDBStart = '$';
  81 const char GDBEnd = '#';
  82 const char GDBGoodP = '+';
  83 const char GDBBadP = '-';
  84
  85 const int GDBPacketBufLen = 1024;
  86
  87 class BaseRemoteGDB
  88 {
  89   private:
  90     friend void debugger();
  91     friend class GDBListener;
  92
  93     //Helper functions
  94   protected:
  95     int digit2i(char);
  96     char i2digit(int);
  97     Addr hex2i(const char **);
  98     //Address formats, break types, and gdb commands may change
  99     //between architectures, so they're defined as virtual
 100     //functions.
 101     virtual void mem2hex(void *, const void *, int);
 102     virtual const char * hex2mem(void *, const char *, int);
 103     virtual const char * break_type(char c);
 104     virtual const char * gdb_command(char cmd);
 105
 106   protected:
 107     class Event : public PollEvent
 108     {
 109       protected:
 110         BaseRemoteGDB *gdb;
 111
 112       public:
 113         Event(BaseRemoteGDB *g, int fd, int e);
 114         void process(int revent);
 115     };
 116
 117     friend class Event;
 118     Event *event;
 119     GDBListener *listener;
 120     int number;
 121
 122   protected:
 123     //The socket commands come in through
 124     int fd;
 125
 126   protected:
 127 #ifdef notyet
 128     label_t recover;
 129 #endif
 130     bool active;
 131     bool attached;
 132
 133     System *system;
 134     PhysicalMemory *pmem;
 135     ThreadContext *context;
 136
 137   protected:
 138     class GdbRegCache
 139     {
 140       public:
 141         GdbRegCache(size_t newSize) : regs(new uint64_t[newSize]), size(newSize)
 142         {}
 143         ~GdbRegCache()
 144         {
 145             delete [] regs;
 146         }
 147
 148         uint64_t * regs;
 149         size_t size;
 150         size_t bytes() { return size * sizeof(uint64_t); }
 151     };
 152
 153     GdbRegCache gdbregs;
 154
 155   protected:
 156     uint8_t getbyte();
 157     void putbyte(uint8_t b);
 158
 159     int recv(char *data, int len);
 160     void send(const char *data);
 161
 162   protected:
 163     // Machine memory
 164     virtual bool read(Addr addr, size_t size, char *data);
 165     virtual bool write(Addr addr, size_t size, const char *data);
 166
 167     template <class T> T read(Addr addr);
 168     template <class T> void write(Addr addr, T data);
 169
 170   public:
 171     BaseRemoteGDB(System *system, ThreadContext *context, size_t cacheSize);
 172     virtual ~BaseRemoteGDB();
 173
 174     void replaceThreadContext(ThreadContext *tc) { context = tc; }
 175
 176     void attach(int fd);
 177     void detach();
 178     bool isattached();
 179
 180     virtual bool acc(Addr addr, size_t len) = 0;
 181     bool trap(int type);
 182     virtual bool breakpoint()
 183     {
 184         return trap(SIGTRAP);
 185     }
 186
 187   protected:
 188     virtual void getregs() = 0;
 189     virtual void setregs() = 0;
 190
 191     virtual void clearSingleStep() = 0;
 192     virtual void setSingleStep() = 0;
 193
 194     PCEventQueue *getPcEventQueue();
 195
 196   protected:
 197     class HardBreakpoint : public PCEvent
 198     {
 199       private:
 200         BaseRemoteGDB *gdb;
 201
 202       public:
 203         int refcount;
 204
 205       public:
 206         HardBreakpoint(BaseRemoteGDB *_gdb, Addr addr);
 207         std::string name() { return gdb->name() + ".hwbkpt"; }
 208
 209         virtual void process(ThreadContext *tc);
 210     };
 211     friend class HardBreakpoint;
 212
 213     typedef std::map<Addr, HardBreakpoint *> break_map_t;
 214     typedef break_map_t::iterator break_iter_t;
 215     break_map_t hardBreakMap;
 216
 217     bool insertSoftBreak(Addr addr, size_t len);
 218     bool removeSoftBreak(Addr addr, size_t len);
 219     bool insertHardBreak(Addr addr, size_t len);
 220     bool removeHardBreak(Addr addr, size_t len);
 221
 222   protected:
 223     void clearTempBreakpoint(Addr &bkpt);
 224     void setTempBreakpoint(Addr bkpt);
 225
 226   public:
 227     std::string name();
 228 };
 229
 230 template <class T>
 231 inline T
 232 BaseRemoteGDB::read(Addr addr)
 233 {
 234     T temp;
 235     read(addr, sizeof(T), (char *)&temp);
 236     return temp;
 237 }
 238
 239 template <class T>
 240 inline void
 241 BaseRemoteGDB::write(Addr addr, T data)
 242 { write(addr, sizeof(T), (const char *)&data); }
 243
 244 class GDBListener
 245 {
 246   protected:
 247     class Event : public PollEvent
 248     {
 249       protected:
 250         GDBListener *listener;
 251
 252       public:
 253         Event(GDBListener *l, int fd, int e);
 254         void process(int revent);
 255     };
 256
 257     friend class Event;
 258     Event *event;
 259
 260   protected:
 261     ListenSocket listener;
 262     BaseRemoteGDB *gdb;
 263     int port;
 264
 265   public:
 266     GDBListener(BaseRemoteGDB *g, int p);
 267     ~GDBListener();
 268
 269     void accept();
 270     void listen();
 271     std::string name();
 272 };
 273
 274 #endif /* __REMOTE_GDB_H__ */