git.rot13.org Git - simavr/blob - simavr/sim/sim_gdb.c

   1 /*
   2         sim_gdb.c
   3
   4         Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
   5
   6         This file is part of simavr.
   7
   8         simavr is free software: you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation, either version 3 of the License, or
  11         (at your option) any later version.
  12
  13         simavr is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License
  19         along with simavr.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <netinet/in.h>
  23 #include <netinet/tcp.h>
  24 #include <arpa/inet.h>
  25 #include <sys/socket.h>
  26 #include <sys/time.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <poll.h>
  33 #include <pthread.h>
  34 #include "sim_avr.h"
  35 #include "sim_hex.h"
  36 #include "avr_eeprom.h"
  37 #include "sim_gdb.h"
  38
  39 #define DBG(w)
  40
  41 #define WATCH_LIMIT (32)
  42
  43 typedef struct {
  44         uint32_t len; /**< How many points are taken (points[0] .. points[len - 1]). */
  45         struct {
  46                 uint32_t addr; /**< Which address is watched. */
  47                 uint32_t size; /**< How large is the watched segment. */
  48                 uint32_t kind; /**< Bitmask of enum avr_gdb_watch_type values. */
  49         } points[WATCH_LIMIT];
  50 } avr_gdb_watchpoints_t;
  51
  52 typedef struct avr_gdb_t {
  53         avr_t * avr;
  54         int             listen; // listen socket
  55         int             s;              // current gdb connection
  56
  57         avr_gdb_watchpoints_t breakpoints;
  58 } avr_gdb_t;
  59
  60
  61 /**
  62  * Returns the index of the watchpoint if found, -1 otherwise.
  63  */
  64 static int gdb_watch_find(const avr_gdb_watchpoints_t * w, uint32_t addr)
  65 {
  66         for (int i = 0; i < w->len; i++) {
  67                 if (w->points[i].addr == addr) {
  68                         return i;
  69                 }
  70         }
  71
  72         return -1;
  73 }
  74
  75 /**
  76  * Returns -1 on error, 0 otherwise.
  77  */
  78 static int gdb_watch_add_or_update(avr_gdb_watchpoints_t * w, enum avr_gdb_watch_type kind, uint32_t addr,
  79                 uint32_t size)
  80 {
  81         /* If the watchpoint exists, update it. */
  82         int i = gdb_watch_find(w, addr);
  83         if (i != -1) {
  84                 w->points[i].size = size;
  85                 w->points[i].kind |= kind;
  86                 return 0;
  87         }
  88
  89         /* Otherwise add it. */
  90         if (w->len == WATCH_LIMIT) {
  91                 return -1;
  92         }
  93
  94         w->points[w->len].kind = kind;
  95         w->points[w->len].addr = addr;
  96         w->points[w->len].size = size;
  97
  98         w->len++;
  99
 100         return 0;
 101 }
 102
 103 /**
 104  * Returns -1 on error or if the specified point does not exist, 0 otherwise.
 105  */
 106 static int gdb_watch_rm(avr_gdb_watchpoints_t * w, enum avr_gdb_watch_type kind, uint32_t addr)
 107 {
 108         int i = gdb_watch_find(w, addr);
 109         if (i == -1) {
 110                 return -1;
 111         }
 112
 113         w->points[i].kind &= ~kind;
 114         if (w->points[i].kind) {
 115                 return 0;
 116         }
 117
 118         for (i = i + 1; i < w->len; i++) {
 119                 w->points[i - 1] = w->points[i];
 120         }
 121
 122         w->len--;
 123
 124         return 0;
 125 }
 126
 127 static void gdb_watch_clear(avr_gdb_watchpoints_t * w)
 128 {
 129         w->len = 0;
 130 }
 131
 132 static void gdb_send_reply(avr_gdb_t * g, char * cmd)
 133 {
 134         uint8_t reply[1024];
 135         uint8_t * dst = reply;
 136         uint8_t check = 0;
 137         *dst++ = '$';
 138         while (*cmd) {
 139                 check += *cmd;
 140                 *dst++ = *cmd++;
 141         }
 142         sprintf((char*)dst, "#%02x", check);
 143         DBG(printf("%s '%s'\n", __FUNCTION__, reply);)
 144         send(g->s, reply, dst - reply + 3, 0);
 145 }
 146
 147 static void gdb_send_quick_status(avr_gdb_t * g, uint8_t signal)
 148 {
 149         char cmd[64];
 150
 151         sprintf(cmd, "T%02x20:%02x;21:%02x%02x;22:%02x%02x%02x00;",
 152                 signal ? signal : 5, g->avr->data[R_SREG],
 153                 g->avr->data[R_SPL], g->avr->data[R_SPH],
 154                 g->avr->pc & 0xff, (g->avr->pc>>8)&0xff, (g->avr->pc>>16)&0xff);
 155         gdb_send_reply(g, cmd);
 156 }
 157
 158 static int gdb_change_breakpoint(avr_gdb_watchpoints_t * w, int set, enum avr_gdb_watch_type kind,
 159                 uint32_t addr, uint32_t size)
 160 {
 161         DBG(printf("set %d kind %d addr %08x len %d\n", set, kind, addr, len);)
 162
 163         if (set) {
 164                 return gdb_watch_add_or_update(w, kind, addr, size);
 165         } else {
 166                 return gdb_watch_rm(w, kind, addr);
 167         }
 168
 169         return -1;
 170 }
 171
 172 static int gdb_write_register(avr_gdb_t * g, int regi, uint8_t * src)
 173 {
 174         switch (regi) {
 175                 case 0 ... 31:
 176                         g->avr->data[regi] = *src;
 177                         return 1;
 178                 case 32:
 179                         g->avr->data[R_SREG] = *src;
 180                         return 1;
 181                 case 33:
 182                         g->avr->data[R_SPL] = src[0];
 183                         g->avr->data[R_SPH] = src[1];
 184                         return 2;
 185                 case 34:
 186                         g->avr->pc = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
 187                         return 4;
 188         }
 189         return 1;
 190 }
 191
 192 static int gdb_read_register(avr_gdb_t * g, int regi, char * rep)
 193 {
 194         switch (regi) {
 195                 case 0 ... 31:
 196                         sprintf(rep, "%02x", g->avr->data[regi]);
 197                         break;
 198                 case 32:
 199                         sprintf(rep, "%02x", g->avr->data[R_SREG]);
 200                         break;
 201                 case 33:
 202                         sprintf(rep, "%02x%02x", g->avr->data[R_SPL], g->avr->data[R_SPH]);
 203                         break;
 204                 case 34:
 205                         sprintf(rep, "%02x%02x%02x00",
 206                                 g->avr->pc & 0xff, (g->avr->pc>>8)&0xff, (g->avr->pc>>16)&0xff);
 207                         break;
 208         }
 209         return strlen(rep);
 210 }
 211
 212 static void gdb_handle_command(avr_gdb_t * g, char * cmd)
 213 {
 214         avr_t * avr = g->avr;
 215         char rep[1024];
 216         uint8_t command = *cmd++;
 217         switch (command) {
 218                 case '?':
 219                         gdb_send_quick_status(g, 0);
 220                         break;
 221                 case 'G': {     // set all general purpose registers
 222                         // get their binary form
 223                         read_hex_string(cmd, (uint8_t*)rep, strlen(cmd));
 224                         uint8_t *src = (uint8_t*)rep;
 225                         for (int i = 0; i < 35; i++)
 226                                 src += gdb_write_register(g, i, src);
 227                         gdb_send_reply(g, "OK");
 228                 }       break;
 229                 case 'g': {     // read all general purpose registers
 230                         char * dst = rep;
 231                         for (int i = 0; i < 35; i++)
 232                                 dst += gdb_read_register(g, i, dst);
 233                         gdb_send_reply(g, rep);
 234                 }       break;
 235                 case 'p': {     // read register
 236                         unsigned int regi = 0;
 237                         sscanf(cmd, "%x", &regi);
 238                         gdb_read_register(g, regi, rep);
 239                         gdb_send_reply(g, rep);
 240                 }       break;
 241                 case 'P': {     // write register
 242                         unsigned int regi = 0;
 243                         char * val = strchr(cmd, '=');
 244                         if (!val)
 245                                 break;
 246                         *val++ = 0;
 247                         sscanf(cmd, "%x", &regi);
 248                         read_hex_string(val, (uint8_t*)rep, strlen(val));
 249                         gdb_write_register(g, regi, (uint8_t*)rep);
 250                         gdb_send_reply(g, "OK");
 251                 }       break;
 252                 case 'm': {     // read memory
 253                         avr_flashaddr_t addr;
 254                         uint32_t len;
 255                         sscanf(cmd, "%x,%x", &addr, &len);
 256                         uint8_t * src = NULL;
 257                         if (addr < avr->flashend) {
 258                                 src = avr->flash + addr;
 259                         } else if (addr >= 0x800000 && (addr - 0x800000) <= avr->ramend) {
 260                                 src = avr->data + addr - 0x800000;
 261                         } else if (addr >= 0x810000 && (addr - 0x810000) <= avr->e2end) {
 262                                 avr_eeprom_desc_t ee = {.offset = (addr - 0x810000)};
 263                                 avr_ioctl(avr, AVR_IOCTL_EEPROM_GET, &ee);
 264                                 if (ee.ee)
 265                                         src = ee.ee;
 266                                 else {
 267                                         gdb_send_reply(g, "E01");
 268                                         break;
 269                                 }
 270                         } else if (addr >= 0x800000 && (addr - 0x800000) == avr->ramend+1 && len == 2) {
 271                                 // Allow GDB to read a value just after end of stack.
 272                                 // This is necessary to make instruction stepping work when stack is empty
 273                                 printf("GDB read just past end of stack %08x, %08x; returning zero\n", addr, len);
 274                                 gdb_send_reply(g, "0000");
 275                                 break;
 276                         } else {
 277                                 printf("read memory error %08x, %08x (ramend %04x)\n", addr, len, avr->ramend+1);
 278                                 gdb_send_reply(g, "E01");
 279                                 break;
 280                         }
 281                         char * dst = rep;
 282                         while (len--) {
 283                                 sprintf(dst, "%02x", *src++);
 284                                 dst += 2;
 285                         }
 286                         *dst = 0;
 287                         gdb_send_reply(g, rep);
 288                 }       break;
 289                 case 'M': {     // write memory
 290                         uint32_t addr, len;
 291                         sscanf(cmd, "%x,%x", &addr, &len);
 292                         char * start = strchr(cmd, ':');
 293                         if (!start) {
 294                                 gdb_send_reply(g, "E01");
 295                                 break;
 296                         }
 297                         if (addr < 0xffff) {
 298                                 read_hex_string(start + 1, avr->flash + addr, strlen(start+1));
 299                                 gdb_send_reply(g, "OK");
 300                         } else if (addr >= 0x800000 && (addr - 0x800000) <= avr->ramend) {
 301                                 read_hex_string(start + 1, avr->data + addr - 0x800000, strlen(start+1));
 302                                 gdb_send_reply(g, "OK");
 303                         } else if (addr >= 0x810000 && (addr - 0x810000) <= avr->e2end) {
 304                                 read_hex_string(start + 1, (uint8_t*)rep, strlen(start+1));
 305                                 avr_eeprom_desc_t ee = {.offset = (addr - 0x810000), .size = len, .ee = (uint8_t*)rep };
 306                                 avr_ioctl(avr, AVR_IOCTL_EEPROM_SET, &ee);
 307                                 gdb_send_reply(g, "OK");
 308                         } else {
 309                                 printf("write memory error %08x, %08x\n", addr, len);
 310                                 gdb_send_reply(g, "E01");
 311                         }
 312                 }       break;
 313                 case 'c': {     // continue
 314                         avr->state = cpu_Running;
 315                 }       break;
 316                 case 's': {     // step
 317                         avr->state = cpu_Step;
 318                 }       break;
 319                 case 'r': {     // deprecated, suggested for AVRStudio compatibility
 320                         avr->state = cpu_StepDone;
 321                         avr_reset(avr);
 322                 }       break;
 323                 case 'Z':       // set clear break/watchpoint
 324                 case 'z': {
 325                         uint32_t kind, addr, len;
 326                         int set = (command == 'Z');
 327                         sscanf(cmd, "%d,%x,%x", &kind, &addr, &len);
 328 //                      printf("breakpoint %d, %08x, %08x\n", kind, addr, len);
 329                         switch (kind) {
 330                                 case 0: // software breakpoint
 331                                 case 1: // hardware breakpoint
 332                                         if (addr > avr->flashend ||
 333                                                         gdb_change_breakpoint(&g->breakpoints, set, 1 << kind, addr, len) == -1) {
 334                                                 gdb_send_reply(g, "E01");
 335                                                 break;
 336                                         }
 337
 338                                         gdb_send_reply(g, "OK");
 339                                         break;
 340                                 // TODO
 341                                 case 2: // write watchpoint
 342                                 case 3: // read watchpoint
 343                                 case 4: // access watchpoint
 344                                 default:
 345                                         gdb_send_reply(g, "");
 346                         }
 347                 }       break;
 348                 default:
 349                         gdb_send_reply(g, "");
 350                         break;
 351         }
 352 }
 353
 354 static int gdb_network_handler(avr_gdb_t * g, uint32_t dosleep)
 355 {
 356         fd_set read_set;
 357         int max;
 358         FD_ZERO(&read_set);
 359
 360         if (g->s != -1) {
 361                 FD_SET(g->s, &read_set);
 362                 max = g->s + 1;
 363         } else {
 364                 FD_SET(g->listen, &read_set);
 365                 max = g->listen + 1;
 366         }
 367         struct timeval timo = { 0, dosleep };   // short, but not too short interval
 368         int ret = select(max, &read_set, NULL, NULL, &timo);
 369
 370         if (ret == 0)
 371                 return 0;
 372
 373         if (FD_ISSET(g->listen, &read_set)) {
 374                 g->s = accept(g->listen, NULL, NULL);
 375
 376                 if (g->s == -1) {
 377                         perror("gdb_network_handler accept");
 378                         sleep(5);
 379                         return 1;
 380                 }
 381         int i = 1;
 382         setsockopt (g->s, IPPROTO_TCP, TCP_NODELAY, &i, sizeof (i));
 383                 g->avr->state = cpu_Stopped;
 384                 printf("%s connection opened\n", __FUNCTION__);
 385         }
 386
 387         if (g->s != -1 && FD_ISSET(g->s, &read_set)) {
 388                 uint8_t buffer[1024];
 389
 390                 ssize_t r = recv(g->s, buffer, sizeof(buffer)-1, 0);
 391
 392                 if (r == 0) {
 393                         printf("%s connection closed\n", __FUNCTION__);
 394                         close(g->s);
 395                         gdb_watch_clear(&g->breakpoints);
 396                         g->avr->state = cpu_Running;    // resume
 397                         g->s = -1;
 398                         return 1;
 399                 }
 400                 if (r == -1) {
 401                         perror("gdb_network_handler recv");
 402                         sleep(1);
 403                         return 1;
 404                 }
 405                 buffer[r] = 0;
 406         //      printf("%s: received %d bytes\n'%s'\n", __FUNCTION__, r, buffer);
 407         //      hdump("gdb", buffer, r);
 408
 409                 uint8_t * src = buffer;
 410                 while (*src == '+' || *src == '-')
 411                         src++;
 412                 // control C -- lets send the guy a nice status packet
 413                 if (*src == 3) {
 414                         src++;
 415                         g->avr->state = cpu_StepDone;
 416                         printf("GDB hit control-c\n");
 417                 }
 418                 if (*src  == '$') {
 419                         // strip checksum
 420                         uint8_t * end = buffer + r - 1;
 421                         while (end > src && *end != '#')
 422                                 *end-- = 0;
 423                         *end = 0;
 424                         src++;
 425                         DBG(printf("GDB command = '%s'\n", src);)
 426
 427                         send(g->s, "+", 1, 0);
 428
 429                         gdb_handle_command(g, (char*)src);
 430                 }
 431         }
 432         return 1;
 433 }
 434
 435 int avr_gdb_processor(avr_t * avr, int sleep)
 436 {
 437         if (!avr || !avr->gdb)
 438                 return 0;
 439         avr_gdb_t * g = avr->gdb;
 440
 441         if (avr->state == cpu_Running && gdb_watch_find(&g->breakpoints, avr->pc) != -1) {
 442                 DBG(printf("avr_gdb_processor hit breakpoint at %08x\n", avr->pc);)
 443                 gdb_send_quick_status(g, 0);
 444                 avr->state = cpu_Stopped;
 445         } else if (avr->state == cpu_StepDone) {
 446                 gdb_send_quick_status(g, 0);
 447                 avr->state = cpu_Stopped;
 448         }
 449         // this also sleeps for a bit
 450         return gdb_network_handler(g, sleep);
 451 }
 452
 453
 454 int avr_gdb_init(avr_t * avr)
 455 {
 456         avr_gdb_t * g = malloc(sizeof(avr_gdb_t));
 457         memset(g, 0, sizeof(avr_gdb_t));
 458
 459         avr->gdb = NULL;
 460
 461         if ((g->listen = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
 462                 fprintf(stderr, "Can't create socket: %s", strerror(errno));
 463                 return -1;
 464         }
 465
 466         int i = 1;
 467         setsockopt(g->listen, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
 468
 469         struct sockaddr_in address = { 0 };
 470         address.sin_family = AF_INET;
 471         address.sin_port = htons (avr->gdb_port);
 472
 473         if (bind(g->listen, (struct sockaddr *) &address, sizeof(address))) {
 474                 fprintf(stderr, "Can not bind socket: %s", strerror(errno));
 475                 return -1;
 476         }
 477         if (listen(g->listen, 1)) {
 478                 perror("listen");
 479                 return -1;
 480         }
 481         printf("avr_gdb_init listening on port %d\n", avr->gdb_port);
 482         g->avr = avr;
 483         g->s = -1;
 484         avr->gdb = g;
 485         // change default run behaviour to use the slightly slower versions
 486         avr->run = avr_callback_run_gdb;
 487         avr->sleep = avr_callback_sleep_gdb;
 488
 489         return 0;
 490 }