git.gag.com Git - fw/openocd/blob - src/server/gdb_server.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2005 by Dominic Rath                                    *\r
   3  *   Dominic.Rath@gmx.de                                                   *\r
   4  *                                                                         *\r
   5  *   This program is free software; you can redistribute it and/or modify  *\r
   6  *   it under the terms of the GNU General Public License as published by  *\r
   7  *   the Free Software Foundation; either version 2 of the License, or     *\r
   8  *   (at your option) any later version.                                   *\r
   9  *                                                                         *\r
  10  *   This program is distributed in the hope that it will be useful,       *\r
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  13  *   GNU General Public License for more details.                          *\r
  14  *                                                                         *\r
  15  *   You should have received a copy of the GNU General Public License     *\r
  16  *   along with this program; if not, write to the                         *\r
  17  *   Free Software Foundation, Inc.,                                       *\r
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  19  ***************************************************************************/\r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "replacements.h"\r
  25 \r
  26 #include "gdb_server.h"\r
  27 \r
  28 #include "server.h"\r
  29 #include "log.h"\r
  30 #include "binarybuffer.h"\r
  31 #include "jtag.h"\r
  32 #include "breakpoints.h"\r
  33 #include "flash.h"\r
  34 #include "target_request.h"\r
  35 #include "configuration.h"\r
  36 \r
  37 #include <string.h>\r
  38 #include <errno.h>\r
  39 #include <unistd.h>\r
  40 #include <stdlib.h>\r
  41 \r
  42 #if 0\r
  43 #define _DEBUG_GDB_IO_\r
  44 #endif\r
  45 \r
  46 static unsigned short gdb_port;\r
  47 static const char *DIGITS = "0123456789abcdef";\r
  48 \r
  49 static void gdb_log_callback(void *priv, const char *file, int line, \r
  50                 const char *function, const char *format, va_list args);\r
  51 \r
  52 enum gdb_detach_mode\r
  53 {\r
  54         GDB_DETACH_RESUME,\r
  55         GDB_DETACH_RESET,\r
  56         GDB_DETACH_HALT,\r
  57         GDB_DETACH_NOTHING\r
  58 };\r
  59 \r
  60 /* target behaviour on gdb detach */\r
  61 enum gdb_detach_mode detach_mode = GDB_DETACH_RESUME;\r
  62 \r
  63 /* set if we are sending a memory map to gdb\r
  64  * via qXfer:memory-map:read packet */\r
  65 int gdb_use_memory_map = 0;\r
  66 int gdb_flash_program = 0;\r
  67 \r
  68 /* if set, data aborts cause an error to be reported in memory read packets\r
  69  * see the code in gdb_read_memory_packet() for further explanations */\r
  70 int gdb_report_data_abort = 0;\r
  71 \r
  72 int gdb_last_signal(target_t *target)\r
  73 {\r
  74         switch (target->debug_reason)\r
  75         {\r
  76                 case DBG_REASON_DBGRQ:\r
  77                         return 0x2; /* SIGINT */\r
  78                 case DBG_REASON_BREAKPOINT:\r
  79                 case DBG_REASON_WATCHPOINT:\r
  80                 case DBG_REASON_WPTANDBKPT:\r
  81                         return 0x05; /* SIGTRAP */\r
  82                 case DBG_REASON_SINGLESTEP:\r
  83                         return 0x05; /* SIGTRAP */\r
  84                 case DBG_REASON_NOTHALTED:\r
  85                         return 0x0; /* no signal... shouldn't happen */\r
  86                 default:\r
  87                         ERROR("BUG: undefined debug reason");\r
  88                         exit(-1);\r
  89         }\r
  90 }\r
  91 \r
  92 int gdb_get_char(connection_t *connection, int* next_char)\r
  93 {\r
  94         gdb_connection_t *gdb_con = connection->priv;\r
  95 \r
  96 #ifdef _DEBUG_GDB_IO_\r
  97         char *debug_buffer;\r
  98 #endif\r
  99 \r
 100         if (gdb_con->buf_cnt-- > 0)\r
 101         {\r
 102                 *next_char = *(gdb_con->buf_p++);\r
 103                 if (gdb_con->buf_cnt > 0)\r
 104                         connection->input_pending = 1;\r
 105                 else\r
 106                         connection->input_pending = 0;\r
 107 \r
 108 #ifdef _DEBUG_GDB_IO_\r
 109                 DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);\r
 110 #endif\r
 111 \r
 112                 return ERROR_OK;\r
 113         }\r
 114 \r
 115         for (;;)\r
 116         {\r
 117 #ifndef _WIN32\r
 118                 /* a non-blocking socket will block if there is 0 bytes available on the socket,\r
 119                  * but return with as many bytes as are available immediately\r
 120                  */\r
 121                 struct timeval tv;\r
 122                 fd_set read_fds;\r
 123                 \r
 124                 FD_ZERO(&read_fds);\r
 125                 FD_SET(connection->fd, &read_fds);\r
 126                 \r
 127                 tv.tv_sec = 1;\r
 128                 tv.tv_usec = 0;\r
 129                 if (select(connection->fd + 1, &read_fds, NULL, NULL, &tv) == 0)\r
 130                 {\r
 131                         /* This can typically be because a "monitor" command took too long\r
 132                          * before printing any progress messages\r
 133                          */\r
 134                         return ERROR_GDB_TIMEOUT; \r
 135                 }\r
 136 #endif\r
 137                 gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);\r
 138                 if (gdb_con->buf_cnt > 0)\r
 139                 {\r
 140                         break;\r
 141                 }\r
 142                 if (gdb_con->buf_cnt == 0)\r
 143                 {\r
 144                         gdb_con->closed = 1;\r
 145                         return ERROR_SERVER_REMOTE_CLOSED;\r
 146                 }\r
 147 \r
 148 #ifdef _WIN32\r
 149                 errno = WSAGetLastError();\r
 150 \r
 151                 switch(errno)\r
 152                 {\r
 153                         case WSAEWOULDBLOCK:\r
 154                                 usleep(1000);\r
 155                                 break;\r
 156                         case WSAECONNABORTED:\r
 157                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 158                         case WSAECONNRESET:\r
 159                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 160                         default:\r
 161                                 ERROR("read: %d", errno);\r
 162                                 exit(-1);\r
 163                 }\r
 164 #else\r
 165                 switch(errno)\r
 166                 {\r
 167                         case EAGAIN:\r
 168                                 usleep(1000);\r
 169                                 break;\r
 170                         case ECONNABORTED:\r
 171                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 172                         case ECONNRESET:\r
 173                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 174                         default:\r
 175                                 ERROR("read: %s", strerror(errno));\r
 176                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 177                 }\r
 178 #endif\r
 179         }\r
 180 \r
 181 #ifdef _DEBUG_GDB_IO_\r
 182         debug_buffer = malloc(gdb_con->buf_cnt + 1);\r
 183         memcpy(debug_buffer, gdb_con->buffer, gdb_con->buf_cnt);\r
 184         debug_buffer[gdb_con->buf_cnt] = 0;\r
 185         DEBUG("received '%s'", debug_buffer);\r
 186         free(debug_buffer);\r
 187 #endif\r
 188 \r
 189         gdb_con->buf_p = gdb_con->buffer;\r
 190         gdb_con->buf_cnt--;\r
 191         *next_char = *(gdb_con->buf_p++);\r
 192         if (gdb_con->buf_cnt > 0)\r
 193                 connection->input_pending = 1;\r
 194         else\r
 195                 connection->input_pending = 0;  \r
 196 #ifdef _DEBUG_GDB_IO_\r
 197         DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);\r
 198 #endif\r
 199 \r
 200         return ERROR_OK;\r
 201 }\r
 202 \r
 203 int gdb_putback_char(connection_t *connection, int last_char)\r
 204 {\r
 205         gdb_connection_t *gdb_con = connection->priv;\r
 206 \r
 207         if (gdb_con->buf_p > gdb_con->buffer)\r
 208         {\r
 209                 *(--gdb_con->buf_p) = last_char;\r
 210                 gdb_con->buf_cnt++;\r
 211         }\r
 212         else\r
 213         {\r
 214                 ERROR("BUG: couldn't put character back");      \r
 215         }\r
 216 \r
 217         return ERROR_OK;\r
 218 }\r
 219 \r
 220 /* The only way we can detect that the socket is closed is the first time\r
 221  * we write to it, we will fail. Subsequent write operations will\r
 222  * succeed. Shudder! */\r
 223 int gdb_write(connection_t *connection, void *data, int len)\r
 224 {\r
 225         gdb_connection_t *gdb_con = connection->priv;\r
 226         if (gdb_con->closed)\r
 227                 return ERROR_SERVER_REMOTE_CLOSED;\r
 228 \r
 229         if (write_socket(connection->fd, data, len) == len)\r
 230         {\r
 231                 return ERROR_OK;\r
 232         }\r
 233         gdb_con->closed = 1;\r
 234         return ERROR_SERVER_REMOTE_CLOSED;\r
 235 }\r
 236 \r
 237 int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)\r
 238 {\r
 239         int i;\r
 240         unsigned char my_checksum = 0;\r
 241 #ifdef _DEBUG_GDB_IO_\r
 242         char *debug_buffer;\r
 243 #endif\r
 244         int reply;\r
 245         int retval;\r
 246         gdb_connection_t *gdb_con = connection->priv;\r
 247 \r
 248         for (i = 0; i < len; i++)\r
 249                 my_checksum += buffer[i];\r
 250 \r
 251         while (1)\r
 252         {\r
 253 #ifdef _DEBUG_GDB_IO_\r
 254                 debug_buffer = malloc(len + 1);\r
 255                 memcpy(debug_buffer, buffer, len);\r
 256                 debug_buffer[len] = 0;\r
 257                 DEBUG("sending packet '$%s#%2.2x'", debug_buffer, my_checksum);\r
 258                 free(debug_buffer);\r
 259 #endif\r
 260 #if 0\r
 261                 char checksum[3];\r
 262                 gdb_write(connection, "$", 1);\r
 263                 if (len > 0)\r
 264                         gdb_write(connection, buffer, len);\r
 265                 gdb_write(connection, "#", 1);\r
 266                 \r
 267                 snprintf(checksum, 3, "%2.2x", my_checksum);\r
 268                 \r
 269                 gdb_write(connection, checksum, 2);\r
 270 #else\r
 271                 void *allocated = NULL;\r
 272                 char stackAlloc[1024];\r
 273                 char *t = stackAlloc;\r
 274                 int totalLen = 1 + len + 1 + 2;\r
 275                 if (totalLen > sizeof(stackAlloc))\r
 276                 {\r
 277                         allocated = malloc(totalLen);\r
 278                         t = allocated;\r
 279                         if (allocated == NULL)\r
 280                         {\r
 281                                 ERROR("Ran out of memory trying to reply packet %d\n", totalLen);\r
 282                                 exit(-1);\r
 283                         }\r
 284                 }\r
 285                 t[0] = '$';\r
 286                 memcpy(t + 1, buffer, len);\r
 287                 t[1 + len] = '#';\r
 288                 t[1 + len + 1] = DIGITS[(my_checksum >> 4) & 0xf];\r
 289                 t[1 + len + 2] = DIGITS[my_checksum & 0xf];\r
 290                 \r
 291                 gdb_write(connection, t, totalLen);\r
 292                 \r
 293                 if (allocated)\r
 294                 {\r
 295                         free(allocated);\r
 296                 }\r
 297 #endif\r
 298                 if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)\r
 299                         return retval;\r
 300 \r
 301                 if (reply == '+')\r
 302                         break;\r
 303                 else if (reply == '-')\r
 304                 {\r
 305                         /* Stop sending output packets for now */\r
 306                         log_setCallback(NULL, NULL);\r
 307                         WARNING("negative reply, retrying");\r
 308                 }\r
 309                 else if (reply == 0x3)\r
 310                 {\r
 311                         gdb_con->ctrl_c = 1;\r
 312                         if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)\r
 313                                 return retval;\r
 314                         if (reply == '+')\r
 315                                 break;\r
 316                         else if (reply == '-')\r
 317                         {\r
 318                                 /* Stop sending output packets for now */\r
 319                                 log_setCallback(NULL, NULL);\r
 320                                 WARNING("negative reply, retrying");\r
 321                         }\r
 322                         else\r
 323                         {\r
 324                                 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply);\r
 325                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 326                         }\r
 327                 }\r
 328                 else\r
 329                 {\r
 330                         ERROR("unknown character 0x%2.2x in reply, dropping connection", reply);\r
 331                         return ERROR_SERVER_REMOTE_CLOSED;\r
 332                 }\r
 333         }\r
 334         if (gdb_con->closed)\r
 335                 return ERROR_SERVER_REMOTE_CLOSED;\r
 336 \r
 337         return ERROR_OK;\r
 338 }\r
 339 \r
 340 int gdb_put_packet(connection_t *connection, char *buffer, int len)\r
 341 {\r
 342         gdb_connection_t *gdb_con = connection->priv;\r
 343         gdb_con->busy = 1;\r
 344         int retval = gdb_put_packet_inner(connection, buffer, len);\r
 345         gdb_con->busy = 0;\r
 346         return retval;\r
 347 }\r
 348 \r
 349 int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)\r
 350 {\r
 351         int character;\r
 352         int count = 0;\r
 353         int retval;\r
 354         char checksum[3];\r
 355         unsigned char my_checksum = 0;\r
 356         gdb_connection_t *gdb_con = connection->priv;\r
 357 \r
 358         while (1)\r
 359         {\r
 360                 do\r
 361                 {\r
 362                         if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)\r
 363                                 return retval;\r
 364 \r
 365 #ifdef _DEBUG_GDB_IO_\r
 366                         DEBUG("character: '%c'", character);\r
 367 #endif\r
 368 \r
 369                         switch (character)\r
 370                         {\r
 371                                 case '$':\r
 372                                         break;\r
 373                                 case '+':\r
 374                                         WARNING("acknowledgment received, but no packet pending");\r
 375                                         break;\r
 376                                 case '-':\r
 377                                         WARNING("negative acknowledgment, but no packet pending");\r
 378                                         break;\r
 379                                 case 0x3:\r
 380                                         gdb_con->ctrl_c = 1;\r
 381                                         *len = 0;\r
 382                                         return ERROR_OK;\r
 383                                 default:\r
 384                                         WARNING("ignoring character 0x%x", character);\r
 385                                         break;\r
 386                         }\r
 387                 } while (character != '$');\r
 388 \r
 389                 my_checksum = 0;\r
 390                 \r
 391                 count = 0;\r
 392                 gdb_connection_t *gdb_con = connection->priv;\r
 393                 for (;;)\r
 394                 {\r
 395                         /* The common case is that we have an entire packet with no escape chars.\r
 396                          * We need to leave at least 2 bytes in the buffer to have\r
 397                          * gdb_get_char() update various bits and bobs correctly. \r
 398                          */\r
 399                         if ((gdb_con->buf_cnt > 2) && ((gdb_con->buf_cnt+count) < *len))\r
 400                         {\r
 401                                 /* The compiler will struggle a bit with constant propagation and\r
 402                                  * aliasing, so we help it by showing that these values do not\r
 403                                  * change inside the loop \r
 404                                  */ \r
 405                                 int i;\r
 406                                 char *buf = gdb_con->buf_p;\r
 407                                 int run = gdb_con->buf_cnt - 2;\r
 408                                 i = 0;\r
 409                                 int done = 0;\r
 410                                 while (i < run)\r
 411                                 {\r
 412                                         character = *buf++;\r
 413                                         i++;\r
 414                                         if (character == '#')\r
 415                                         {\r
 416                                                 /* Danger! character can be '#' when esc is \r
 417                                                  * used so we need an explicit boolean for done here.\r
 418                                                  */\r
 419                                                 done = 1;\r
 420                                                 break;\r
 421                                         }\r
 422                                         \r
 423                                         if (character == '}')\r
 424                                         {\r
 425                                                 /* data transmitted in binary mode (X packet)\r
 426                                                  * uses 0x7d as escape character */\r
 427                                                 my_checksum += character & 0xff;\r
 428                                                 character = *buf++;\r
 429                                                 i++;\r
 430                                                 my_checksum += character & 0xff;\r
 431                                                 buffer[count++] = (character ^ 0x20) & 0xff;\r
 432                                         } else\r
 433                                         {\r
 434                                                 my_checksum += character & 0xff;\r
 435                                                 buffer[count++] = character & 0xff;\r
 436                                         }\r
 437                                 }\r
 438                                 gdb_con->buf_p += i;\r
 439                                 gdb_con->buf_cnt -= i;\r
 440                                 if (done) \r
 441                                         break;\r
 442                         } \r
 443                         if (count > *len)\r
 444                         {\r
 445                                 ERROR("packet buffer too small");\r
 446                                 return ERROR_GDB_BUFFER_TOO_SMALL;\r
 447                         }\r
 448                         \r
 449                         if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)\r
 450                                 return retval;\r
 451 \r
 452                         if (character == '#')\r
 453                                 break;\r
 454 \r
 455                         if (character == '}')\r
 456                         {\r
 457                                 /* data transmitted in binary mode (X packet)\r
 458                                  * uses 0x7d as escape character */\r
 459                                 my_checksum += character & 0xff;\r
 460                                 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)\r
 461                                         return retval;\r
 462                                 my_checksum += character & 0xff;\r
 463                                 buffer[count++] = (character ^ 0x20) & 0xff;\r
 464                         }\r
 465                         else\r
 466                         {\r
 467                                 my_checksum += character & 0xff;\r
 468                                 buffer[count++] = character & 0xff;\r
 469                         }\r
 470 \r
 471                 }\r
 472 \r
 473                 *len = count;\r
 474 \r
 475                 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)\r
 476                         return retval;\r
 477                 checksum[0] = character;\r
 478                 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)\r
 479                         return retval;\r
 480                 checksum[1] = character;\r
 481                 checksum[2] = 0;\r
 482 \r
 483                 if (my_checksum == strtoul(checksum, NULL, 16))\r
 484                 {\r
 485                         gdb_write(connection, "+", 1);\r
 486                         break;\r
 487                 }\r
 488 \r
 489                 WARNING("checksum error, requesting retransmission");\r
 490                 gdb_write(connection, "-", 1);\r
 491         }\r
 492         if (gdb_con->closed)\r
 493                 return ERROR_SERVER_REMOTE_CLOSED;\r
 494 \r
 495         return ERROR_OK;\r
 496 }\r
 497 \r
 498 int gdb_get_packet(connection_t *connection, char *buffer, int *len)\r
 499 {\r
 500         gdb_connection_t *gdb_con = connection->priv;\r
 501         gdb_con->busy = 1;\r
 502         int retval = gdb_get_packet_inner(connection, buffer, len);\r
 503         gdb_con->busy = 0;\r
 504         return retval;\r
 505 }\r
 506         \r
 507 int gdb_output_con(connection_t *connection, char* line)\r
 508 {\r
 509         char *hex_buffer;\r
 510         int i, bin_size;\r
 511 \r
 512         bin_size = strlen(line);\r
 513 \r
 514         hex_buffer = malloc(bin_size*2 + 4);\r
 515 \r
 516         hex_buffer[0] = 'O';\r
 517         for (i=0; i<bin_size; i++)\r
 518                 snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);\r
 519         hex_buffer[bin_size*2+1] = '0';\r
 520         hex_buffer[bin_size*2+2] = 'a';\r
 521         hex_buffer[bin_size*2+3] = 0x0;\r
 522 \r
 523         gdb_put_packet(connection, hex_buffer, bin_size*2 + 3);\r
 524 \r
 525         free(hex_buffer);\r
 526         return ERROR_OK;\r
 527 }\r
 528 \r
 529 int gdb_output(struct command_context_s *context, char* line)\r
 530 {\r
 531         /* this will be dumped to the log and also sent as an O packet if possible */\r
 532         USER(line); \r
 533         return ERROR_OK;\r
 534 }\r
 535 \r
 536 int gdb_program_handler(struct target_s *target, enum target_event event, void *priv)\r
 537 {\r
 538         FILE *script;\r
 539         struct command_context_s *cmd_ctx = priv;\r
 540         \r
 541         if (target->gdb_program_script)\r
 542         {\r
 543                 script = open_file_from_path(cmd_ctx, target->gdb_program_script, "r");\r
 544                 if (!script)\r
 545                 {\r
 546                         ERROR("couldn't open script file %s", target->gdb_program_script);\r
 547                                 return ERROR_OK;\r
 548                 }\r
 549 \r
 550                 INFO("executing gdb_program script '%s'", target->gdb_program_script);\r
 551                 command_run_file(cmd_ctx, script, COMMAND_EXEC);\r
 552                 fclose(script);\r
 553                 \r
 554                 jtag_execute_queue();\r
 555         }\r
 556         \r
 557         return ERROR_OK;\r
 558 }\r
 559 \r
 560 int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)\r
 561 {\r
 562         connection_t *connection = priv;\r
 563         gdb_connection_t *gdb_connection = connection->priv;\r
 564         char sig_reply[4];\r
 565         int signal;\r
 566 \r
 567         switch (event)\r
 568         {\r
 569                 case TARGET_EVENT_HALTED:\r
 570                         /* In the GDB protocol when we are stepping or coninuing execution,\r
 571                          * we have a lingering reply. Upon receiving a halted event \r
 572                          * when we have that lingering packet, we reply to the original\r
 573                          * step or continue packet.\r
 574                          * \r
 575                          * Executing monitor commands can bring the target in and\r
 576                          * out of the running state so we'll see lots of TARGET_EVENT_XXX\r
 577                          * that are to be ignored.\r
 578                          */\r
 579                         if (gdb_connection->frontend_state == TARGET_RUNNING)\r
 580                         {\r
 581                                 /* stop forwarding log packets! */\r
 582                                 log_setCallback(NULL, NULL);\r
 583                                 \r
 584                                 if (gdb_connection->ctrl_c)\r
 585                                 {\r
 586                                         signal = 0x2;\r
 587                                         gdb_connection->ctrl_c = 0;\r
 588                                 }\r
 589                                 else\r
 590                                 {\r
 591                                         signal = gdb_last_signal(target);\r
 592                                 }\r
 593 \r
 594                                 snprintf(sig_reply, 4, "T%2.2x", signal);\r
 595                                 gdb_put_packet(connection, sig_reply, 3);\r
 596                                 gdb_connection->frontend_state = TARGET_HALTED;\r
 597                         }\r
 598                         break;\r
 599                 case TARGET_EVENT_GDB_PROGRAM:\r
 600                         gdb_program_handler(target, event, connection->cmd_ctx);\r
 601                         break;\r
 602                 default:\r
 603                         break;\r
 604         }\r
 605 \r
 606         return ERROR_OK;\r
 607 }\r
 608 \r
 609 int gdb_new_connection(connection_t *connection)\r
 610 {\r
 611         gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));\r
 612         gdb_service_t *gdb_service = connection->service->priv;\r
 613         int retval;\r
 614         int initial_ack;\r
 615 \r
 616         connection->priv = gdb_connection;\r
 617 \r
 618         /* initialize gdb connection information */\r
 619         gdb_connection->buf_p = gdb_connection->buffer;\r
 620         gdb_connection->buf_cnt = 0;\r
 621         gdb_connection->ctrl_c = 0;\r
 622         gdb_connection->frontend_state = TARGET_HALTED;\r
 623         gdb_connection->vflash_image = NULL;\r
 624         gdb_connection->closed = 0;\r
 625         gdb_connection->busy = 0;\r
 626         \r
 627         /* output goes through gdb connection */\r
 628         command_set_output_handler(connection->cmd_ctx, gdb_output, connection);\r
 629 \r
 630         /* register callback to be informed about target events */\r
 631         target_register_event_callback(gdb_target_callback_event_handler, connection);  \r
 632 \r
 633         /* a gdb session just attached, put the target in halt mode */\r
 634         if (((retval = gdb_service->target->type->halt(gdb_service->target)) != ERROR_OK) &&\r
 635                         (retval != ERROR_TARGET_ALREADY_HALTED))\r
 636         {\r
 637                 ERROR("error(%d) when trying to halt target, falling back to \"reset halt\"", retval);\r
 638                 command_run_line(connection->cmd_ctx, "reset halt");\r
 639         }\r
 640 \r
 641         /* This will time out after 1 second */\r
 642         command_run_line(connection->cmd_ctx, "wait_halt 1");\r
 643 \r
 644         /* remove the initial ACK from the incoming buffer */\r
 645         if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)\r
 646                 return retval;\r
 647 \r
 648         if (initial_ack != '+')\r
 649                 gdb_putback_char(connection, initial_ack);\r
 650 \r
 651         return ERROR_OK;\r
 652 }\r
 653 \r
 654 int gdb_connection_closed(connection_t *connection)\r
 655 {\r
 656         gdb_service_t *gdb_service = connection->service->priv;\r
 657         gdb_connection_t *gdb_connection = connection->priv;\r
 658 \r
 659         /* see if an image built with vFlash commands is left */\r
 660         if (gdb_connection->vflash_image)\r
 661         {\r
 662                 image_close(gdb_connection->vflash_image);\r
 663                 free(gdb_connection->vflash_image);\r
 664                 gdb_connection->vflash_image = NULL;\r
 665         }\r
 666 \r
 667         /* if this connection registered a debug-message receiver delete it */\r
 668         delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);\r
 669         \r
 670         if (connection->priv)\r
 671         {\r
 672                 free(connection->priv);\r
 673                 connection->priv = NULL;\r
 674         }\r
 675         else\r
 676         {\r
 677                 ERROR("BUG: connection->priv == NULL");\r
 678         }\r
 679 \r
 680         target_unregister_event_callback(gdb_target_callback_event_handler, connection);\r
 681         log_setCallback(NULL, NULL);\r
 682 \r
 683         return ERROR_OK;\r
 684 }\r
 685 \r
 686 void gdb_send_error(connection_t *connection, u8 the_error)\r
 687 {\r
 688         char err[4];\r
 689         snprintf(err, 4, "E%2.2X", the_error );\r
 690         gdb_put_packet(connection, err, 3);\r
 691 }\r
 692 \r
 693 int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)\r
 694 {\r
 695         char sig_reply[4];\r
 696         int signal;\r
 697 \r
 698         signal = gdb_last_signal(target);\r
 699 \r
 700         snprintf(sig_reply, 4, "S%2.2x", signal);\r
 701         gdb_put_packet(connection, sig_reply, 3);\r
 702 \r
 703         return ERROR_OK;\r
 704 }\r
 705 \r
 706 /* Convert register to string of bits. NB! The # of bits in the\r
 707  * register might be non-divisible by 8(a byte), in which\r
 708  * case an entire byte is shown. */\r
 709 void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)\r
 710 {\r
 711         int i;\r
 712 \r
 713         u8 *buf;\r
 714         int buf_len;\r
 715         buf = reg->value;\r
 716         buf_len = CEIL(reg->size, 8); \r
 717 \r
 718         if (target->endianness == TARGET_LITTLE_ENDIAN)\r
 719         {\r
 720                 for (i = 0; i < buf_len; i++)\r
 721                 {\r
 722                         tstr[i*2]   = DIGITS[(buf[i]>>4) & 0xf];\r
 723                         tstr[i*2+1] = DIGITS[buf[i]&0xf];\r
 724                 }\r
 725         }\r
 726         else\r
 727         {\r
 728                 for (i = 0; i < buf_len; i++)\r
 729                 {\r
 730                         tstr[(buf_len-1-i)*2]   = DIGITS[(buf[i]>>4)&0xf];\r
 731                         tstr[(buf_len-1-i)*2+1] = DIGITS[buf[i]&0xf];\r
 732                 }\r
 733         }       \r
 734 }\r
 735 \r
 736 void gdb_target_to_str(target_t *target, char *tstr, char *str)\r
 737 {\r
 738         int str_len = strlen(tstr);\r
 739         int i;\r
 740 \r
 741         if (str_len % 2)\r
 742         {\r
 743                 ERROR("BUG: gdb value with uneven number of characters encountered");\r
 744                 exit(-1);\r
 745         }\r
 746 \r
 747         if (target->endianness == TARGET_LITTLE_ENDIAN)\r
 748         {\r
 749                 for (i = 0; i < str_len; i+=2)\r
 750                 {\r
 751                         str[str_len - i - 1] = tstr[i + 1];\r
 752                         str[str_len - i - 2] = tstr[i];\r
 753                 }\r
 754         }\r
 755         else\r
 756         {\r
 757                 for (i = 0; i < str_len; i++)\r
 758                 {\r
 759                         str[i] = tstr[i];\r
 760                 }\r
 761         }       \r
 762 }\r
 763 \r
 764 int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)\r
 765 {\r
 766         reg_t **reg_list;\r
 767         int reg_list_size;\r
 768         int retval;\r
 769         int reg_packet_size = 0;\r
 770         char *reg_packet;\r
 771         char *reg_packet_p;\r
 772         int i;\r
 773 \r
 774 #ifdef _DEBUG_GDB_IO_\r
 775         DEBUG("-");\r
 776 #endif\r
 777 \r
 778         if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)\r
 779         {\r
 780                 switch (retval)\r
 781                 {\r
 782                         case ERROR_TARGET_NOT_HALTED:\r
 783                                 ERROR("gdb requested registers but we're not halted, dropping connection");\r
 784                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 785                         default:\r
 786                                 /* this is a bug condition - get_gdb_reg_list() may not return any other error */\r
 787                                 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");\r
 788                                 exit(-1);\r
 789                 }\r
 790         }\r
 791 \r
 792         for (i = 0; i < reg_list_size; i++)\r
 793         {\r
 794                 reg_packet_size += reg_list[i]->size;\r
 795         }\r
 796 \r
 797         reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);\r
 798         reg_packet_p = reg_packet;\r
 799 \r
 800         for (i = 0; i < reg_list_size; i++)\r
 801         {\r
 802                 gdb_str_to_target(target, reg_packet_p, reg_list[i]);\r
 803                 reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;\r
 804         }\r
 805 \r
 806 #ifdef _DEBUG_GDB_IO_\r
 807         {\r
 808                 char *reg_packet_p;\r
 809                 reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);\r
 810                 DEBUG("reg_packet: %s", reg_packet_p);\r
 811                 free(reg_packet_p);\r
 812         }\r
 813 #endif\r
 814 \r
 815         gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);\r
 816         free(reg_packet);\r
 817 \r
 818         free(reg_list);\r
 819 \r
 820         return ERROR_OK;\r
 821 }\r
 822 \r
 823 int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
 824 {\r
 825         int i;\r
 826         reg_t **reg_list;\r
 827         int reg_list_size;\r
 828         int retval;\r
 829         char *packet_p;\r
 830 \r
 831 #ifdef _DEBUG_GDB_IO_\r
 832         DEBUG("-");\r
 833 #endif\r
 834 \r
 835         /* skip command character */\r
 836         packet++;\r
 837         packet_size--;\r
 838 \r
 839         if (packet_size % 2)\r
 840         {\r
 841                 WARNING("GDB set_registers packet with uneven characters received, dropping connection");\r
 842                 return ERROR_SERVER_REMOTE_CLOSED;\r
 843         }\r
 844 \r
 845         if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)\r
 846         {\r
 847                 switch (retval)\r
 848                 {\r
 849                         case ERROR_TARGET_NOT_HALTED:\r
 850                                 ERROR("gdb tried to registers but we're not halted, dropping connection");\r
 851                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 852                         default:\r
 853                                 /* this is a bug condition - get_gdb_reg_list() may not return any other error */\r
 854                                 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");\r
 855                                 exit(-1);\r
 856                 }\r
 857         }\r
 858 \r
 859         packet_p = packet;\r
 860         for (i = 0; i < reg_list_size; i++)\r
 861         {\r
 862                 u8 *bin_buf;\r
 863                 char *hex_buf;\r
 864                 reg_arch_type_t *arch_type;\r
 865 \r
 866                 /* convert from GDB-string (target-endian) to hex-string (big-endian) */\r
 867                 hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2);\r
 868                 gdb_target_to_str(target, packet_p, hex_buf);\r
 869 \r
 870                 /* convert hex-string to binary buffer */\r
 871                 bin_buf = malloc(CEIL(reg_list[i]->size, 8));\r
 872                 str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16);\r
 873 \r
 874                 /* get register arch_type, and call set method */       \r
 875                 arch_type = register_get_arch_type(reg_list[i]->arch_type);\r
 876                 if (arch_type == NULL)\r
 877                 {\r
 878                         ERROR("BUG: encountered unregistered arch type");\r
 879                         exit(-1);\r
 880                 }\r
 881                 arch_type->set(reg_list[i], bin_buf);\r
 882 \r
 883                 /* advance packet pointer */            \r
 884                 packet_p += (CEIL(reg_list[i]->size, 8) * 2);\r
 885 \r
 886                 free(bin_buf);\r
 887                 free(hex_buf);\r
 888         }\r
 889 \r
 890         /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */ \r
 891         free(reg_list);\r
 892 \r
 893         gdb_put_packet(connection, "OK", 2);\r
 894 \r
 895         return ERROR_OK;\r
 896 }\r
 897 \r
 898 int gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
 899 {\r
 900         char *reg_packet;\r
 901         int reg_num = strtoul(packet + 1, NULL, 16);\r
 902         reg_t **reg_list;\r
 903         int reg_list_size;\r
 904         int retval;\r
 905 \r
 906 #ifdef _DEBUG_GDB_IO_\r
 907         DEBUG("-");\r
 908 #endif\r
 909 \r
 910         if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)\r
 911         {\r
 912                 switch (retval)\r
 913                 {\r
 914                         case ERROR_TARGET_NOT_HALTED:\r
 915                                 ERROR("gdb requested registers but we're not halted, dropping connection");\r
 916                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 917                         default:\r
 918                                 /* this is a bug condition - get_gdb_reg_list() may not return any other error */\r
 919                                 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");\r
 920                                 exit(-1);\r
 921                 }\r
 922         }\r
 923 \r
 924         if (reg_list_size <= reg_num)\r
 925         {\r
 926                 ERROR("gdb requested a non-existing register");\r
 927                 exit(-1);\r
 928         }\r
 929 \r
 930         reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);\r
 931 \r
 932         gdb_str_to_target(target, reg_packet, reg_list[reg_num]);\r
 933 \r
 934         gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);\r
 935 \r
 936         free(reg_list);\r
 937         free(reg_packet);\r
 938 \r
 939         return ERROR_OK;\r
 940 }\r
 941 \r
 942 int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
 943 {\r
 944         char *separator;\r
 945         char *hex_buf;\r
 946         u8 *bin_buf;\r
 947         int reg_num = strtoul(packet + 1, &separator, 16);\r
 948         reg_t **reg_list;\r
 949         int reg_list_size;\r
 950         int retval;\r
 951         reg_arch_type_t *arch_type;\r
 952 \r
 953         DEBUG("-");\r
 954 \r
 955         if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)\r
 956         {\r
 957                 switch (retval)\r
 958                 {\r
 959                         case ERROR_TARGET_NOT_HALTED:\r
 960                                 ERROR("gdb tried to set a register but we're not halted, dropping connection");\r
 961                                 return ERROR_SERVER_REMOTE_CLOSED;\r
 962                         default:\r
 963                                 /* this is a bug condition - get_gdb_reg_list() may not return any other error */\r
 964                                 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");\r
 965                                 exit(-1);\r
 966                 }\r
 967         }\r
 968 \r
 969         if (reg_list_size < reg_num)\r
 970         {\r
 971                 ERROR("gdb requested a non-existing register");\r
 972                 return ERROR_SERVER_REMOTE_CLOSED;\r
 973         }\r
 974 \r
 975         if (*separator != '=')\r
 976         {\r
 977                 ERROR("GDB 'set register packet', but no '=' following the register number");\r
 978                 return ERROR_SERVER_REMOTE_CLOSED;\r
 979         }\r
 980 \r
 981         /* convert from GDB-string (target-endian) to hex-string (big-endian) */\r
 982         hex_buf = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);\r
 983         gdb_target_to_str(target, separator + 1, hex_buf);\r
 984 \r
 985         /* convert hex-string to binary buffer */\r
 986         bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));\r
 987         str_to_buf(hex_buf, CEIL(reg_list[reg_num]->size, 8) * 2, bin_buf, reg_list[reg_num]->size, 16);\r
 988 \r
 989         /* get register arch_type, and call set method */       \r
 990         arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);\r
 991         if (arch_type == NULL)\r
 992         {\r
 993                 ERROR("BUG: encountered unregistered arch type");\r
 994                 exit(-1);\r
 995         }\r
 996         arch_type->set(reg_list[reg_num], bin_buf);\r
 997 \r
 998         gdb_put_packet(connection, "OK", 2);\r
 999 \r
1000         free(bin_buf);\r
1001         free(hex_buf);\r
1002         free(reg_list);\r
1003 \r
1004         return ERROR_OK;\r
1005 }\r
1006 \r
1007 int gdb_memory_packet_error(connection_t *connection, int retval)\r
1008 {\r
1009         switch (retval)\r
1010         {\r
1011                 case ERROR_TARGET_NOT_HALTED:\r
1012                         ERROR("gdb tried to read memory but we're not halted, dropping connection");\r
1013                         return ERROR_SERVER_REMOTE_CLOSED;\r
1014                 case ERROR_TARGET_DATA_ABORT:\r
1015                         gdb_send_error(connection, EIO);\r
1016                         break;\r
1017                 case ERROR_TARGET_TRANSLATION_FAULT:\r
1018                         gdb_send_error(connection, EFAULT);\r
1019                         break;\r
1020                 case ERROR_TARGET_UNALIGNED_ACCESS:\r
1021                         gdb_send_error(connection, EFAULT);\r
1022                         break;\r
1023                 default:\r
1024                         /* This could be that the target reset itself. */\r
1025                         ERROR("unexpected error %i. Dropping connection.", retval);\r
1026                         return ERROR_SERVER_REMOTE_CLOSED;\r
1027         }\r
1028 \r
1029         return ERROR_OK;\r
1030 }\r
1031 \r
1032 /* We don't have to worry about the default 2 second timeout for GDB packets,\r
1033  * because GDB breaks up large memory reads into smaller reads.\r
1034  * \r
1035  * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????\r
1036  */\r
1037 int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1038 {\r
1039         char *separator;\r
1040         u32 addr = 0;\r
1041         u32 len = 0;\r
1042 \r
1043         u8 *buffer;\r
1044         char *hex_buffer;\r
1045 \r
1046         int retval = ERROR_OK;\r
1047 \r
1048         /* skip command character */\r
1049         packet++;\r
1050 \r
1051         addr = strtoul(packet, &separator, 16);\r
1052 \r
1053         if (*separator != ',')\r
1054         {\r
1055                 ERROR("incomplete read memory packet received, dropping connection");\r
1056                 return ERROR_SERVER_REMOTE_CLOSED;\r
1057         }\r
1058 \r
1059         len = strtoul(separator+1, NULL, 16);\r
1060 \r
1061         buffer = malloc(len);\r
1062 \r
1063         DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);\r
1064 \r
1065         retval = target_read_buffer(target, addr, len, buffer);\r
1066 \r
1067         if ((retval == ERROR_TARGET_DATA_ABORT) && (!gdb_report_data_abort))\r
1068         {\r
1069                 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.\r
1070                  * At some point this might be fixed in GDB, in which case this code can be removed.\r
1071                  * \r
1072                  * OpenOCD developers are acutely aware of this problem, but there is nothing\r
1073                  * gained by involving the user in this problem that hopefully will get resolved\r
1074                  * eventually\r
1075                  * \r
1076                  * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395\r
1077                  *\r
1078                  * For now, the default is to fix up things to make current GDB versions work.\r
1079                  * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.\r
1080                  */\r
1081                 memset(buffer, 0, len);\r
1082                 retval = ERROR_OK;\r
1083         }\r
1084 \r
1085         if (retval == ERROR_OK)\r
1086         {\r
1087                 hex_buffer = malloc(len * 2 + 1);\r
1088 \r
1089                 int i;\r
1090                 for (i = 0; i < len; i++)\r
1091                 {\r
1092                         u8 t = buffer[i];\r
1093                         hex_buffer[2 * i] = DIGITS[(t >> 4) & 0xf];\r
1094                         hex_buffer[2 * i + 1] = DIGITS[t & 0xf];\r
1095                 }\r
1096 \r
1097                 gdb_put_packet(connection, hex_buffer, len * 2);\r
1098 \r
1099                 free(hex_buffer);\r
1100         }\r
1101         else\r
1102         {\r
1103                 retval = gdb_memory_packet_error(connection, retval);\r
1104         }\r
1105 \r
1106         free(buffer);\r
1107 \r
1108         return retval;\r
1109 }\r
1110 \r
1111 int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1112 {\r
1113         char *separator;\r
1114         u32 addr = 0;\r
1115         u32 len = 0;\r
1116 \r
1117         u8 *buffer;\r
1118 \r
1119         int i;\r
1120         int retval;\r
1121 \r
1122         /* skip command character */\r
1123         packet++;\r
1124 \r
1125         addr = strtoul(packet, &separator, 16);\r
1126 \r
1127         if (*separator != ',')\r
1128         {\r
1129                 ERROR("incomplete write memory packet received, dropping connection");\r
1130                 return ERROR_SERVER_REMOTE_CLOSED;\r
1131         }\r
1132 \r
1133         len = strtoul(separator+1, &separator, 16);\r
1134 \r
1135         if (*(separator++) != ':')\r
1136         {\r
1137                 ERROR("incomplete write memory packet received, dropping connection");\r
1138                 return ERROR_SERVER_REMOTE_CLOSED;\r
1139         }\r
1140 \r
1141         buffer = malloc(len);\r
1142 \r
1143         DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);\r
1144 \r
1145         for (i=0; i<len; i++)\r
1146         {\r
1147                 u32 tmp;\r
1148                 sscanf(separator + 2*i, "%2x", &tmp);\r
1149                 buffer[i] = tmp;\r
1150         }\r
1151 \r
1152         retval = target_write_buffer(target, addr, len, buffer);\r
1153 \r
1154         if (retval == ERROR_OK)\r
1155         {\r
1156                 gdb_put_packet(connection, "OK", 2);\r
1157         }\r
1158         else\r
1159         {\r
1160                 if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)\r
1161                         return retval; \r
1162         }\r
1163 \r
1164         free(buffer);\r
1165 \r
1166         return ERROR_OK;\r
1167 }\r
1168 \r
1169 int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1170 {\r
1171         char *separator;\r
1172         u32 addr = 0;\r
1173         u32 len = 0;\r
1174 \r
1175         int retval;\r
1176 \r
1177         /* skip command character */\r
1178         packet++;\r
1179 \r
1180         addr = strtoul(packet, &separator, 16);\r
1181 \r
1182         if (*separator != ',')\r
1183         {\r
1184                 ERROR("incomplete write memory binary packet received, dropping connection");\r
1185                 return ERROR_SERVER_REMOTE_CLOSED;\r
1186         }\r
1187 \r
1188         len = strtoul(separator+1, &separator, 16);\r
1189 \r
1190         if (*(separator++) != ':')\r
1191         {\r
1192                 ERROR("incomplete write memory binary packet received, dropping connection");\r
1193                 return ERROR_SERVER_REMOTE_CLOSED;\r
1194         }\r
1195 \r
1196         retval = ERROR_OK;\r
1197         if (len)\r
1198         {\r
1199                 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);\r
1200 \r
1201                 retval = target_write_buffer(target, addr, len, (u8*)separator);\r
1202         }\r
1203 \r
1204         if (retval == ERROR_OK)\r
1205         {\r
1206                 gdb_put_packet(connection, "OK", 2);\r
1207         }\r
1208         else\r
1209         {\r
1210                 if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)\r
1211                         return retval; \r
1212         }\r
1213 \r
1214         return ERROR_OK;\r
1215 }\r
1216 \r
1217 void gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1218 {\r
1219         int current = 0;\r
1220         u32 address = 0x0;\r
1221 \r
1222         DEBUG("-");\r
1223 \r
1224         if (packet_size > 1)\r
1225         {\r
1226                 packet[packet_size] = 0;\r
1227                 address = strtoul(packet + 1, NULL, 16);\r
1228         }\r
1229         else\r
1230         {\r
1231                 current = 1;\r
1232         }\r
1233 \r
1234         if (packet[0] == 'c')\r
1235         {\r
1236                 DEBUG("continue");\r
1237                 target->type->resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */\r
1238         }\r
1239         else if (packet[0] == 's')\r
1240         {\r
1241                 DEBUG("step");\r
1242                 target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */\r
1243         }\r
1244 }\r
1245 \r
1246 int gdb_bp_wp_packet_error(connection_t *connection, int retval)\r
1247 {\r
1248         switch (retval)\r
1249         {\r
1250                 case ERROR_TARGET_NOT_HALTED:\r
1251                         ERROR("gdb tried to set a breakpoint but we're not halted, dropping connection");\r
1252                         return ERROR_SERVER_REMOTE_CLOSED;\r
1253                         break;\r
1254                 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:\r
1255                         gdb_send_error(connection, EBUSY);\r
1256                         break;\r
1257                 default:\r
1258                         ERROR("BUG: unexpected error %i", retval);\r
1259                         exit(-1);\r
1260         }\r
1261 \r
1262         return ERROR_OK;\r
1263 }\r
1264 \r
1265 int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1266 {\r
1267         int type;\r
1268         enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;\r
1269         enum watchpoint_rw wp_type;\r
1270         u32 address;\r
1271         u32 size;\r
1272         char *separator;\r
1273         int retval;\r
1274 \r
1275         DEBUG("-");\r
1276 \r
1277         type = strtoul(packet + 1, &separator, 16);\r
1278 \r
1279         if (type == 0)  /* memory breakpoint */\r
1280                 bp_type = BKPT_SOFT;\r
1281         else if (type == 1) /* hardware breakpoint */\r
1282                 bp_type = BKPT_HARD;\r
1283         else if (type == 2) /* write watchpoint */\r
1284                 wp_type = WPT_WRITE;\r
1285         else if (type == 3) /* read watchpoint */\r
1286                 wp_type = WPT_READ;\r
1287         else if (type == 4) /* access watchpoint */\r
1288                 wp_type = WPT_ACCESS;\r
1289 \r
1290         if (*separator != ',')\r
1291         {\r
1292                 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");\r
1293                 return ERROR_SERVER_REMOTE_CLOSED;\r
1294         }\r
1295 \r
1296         address = strtoul(separator+1, &separator, 16);\r
1297 \r
1298         if (*separator != ',')\r
1299         {\r
1300                 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");\r
1301                 return ERROR_SERVER_REMOTE_CLOSED;\r
1302         }\r
1303 \r
1304         size = strtoul(separator+1, &separator, 16);\r
1305 \r
1306         switch (type)\r
1307         {\r
1308                 case 0:\r
1309                 case 1:\r
1310                         if (packet[0] == 'Z')\r
1311                         {\r
1312                                 if ((retval = breakpoint_add(target, address, size, bp_type)) != ERROR_OK)\r
1313                                 {\r
1314                                         if ((retval = gdb_bp_wp_packet_error(connection, retval)) != ERROR_OK)\r
1315                                                 return retval;\r
1316                                 }\r
1317                                 else\r
1318                                 {\r
1319                                         gdb_put_packet(connection, "OK", 2);\r
1320                                 }\r
1321                         }\r
1322                         else\r
1323                         {\r
1324                                 breakpoint_remove(target, address);\r
1325                                 gdb_put_packet(connection, "OK", 2);\r
1326                         }\r
1327                         break;\r
1328                 case 2:\r
1329                 case 3:\r
1330                 case 4:\r
1331                 {\r
1332                         if (packet[0] == 'Z')\r
1333                         {\r
1334                                 if ((retval = watchpoint_add(target, address, size, type-2, 0, 0xffffffffu)) != ERROR_OK)\r
1335                                 {\r
1336                                         if ((retval = gdb_bp_wp_packet_error(connection, retval)) != ERROR_OK)\r
1337                                                 return retval;\r
1338                                 }\r
1339                                 else\r
1340                                 {\r
1341                                         gdb_put_packet(connection, "OK", 2);\r
1342                                 }\r
1343                         }\r
1344                         else\r
1345                         {\r
1346                                 watchpoint_remove(target, address);\r
1347                                 gdb_put_packet(connection, "OK", 2);\r
1348                         }\r
1349                         break;\r
1350                 }\r
1351                 default:\r
1352                         break;\r
1353         }\r
1354 \r
1355         return ERROR_OK;\r
1356 }\r
1357 \r
1358 /* print out a string and allocate more space as needed, mainly used for XML at this point */\r
1359 void xml_printf(int *retval, char **xml, int *pos, int *size, const char *fmt, ...)\r
1360 {\r
1361         if (*retval != ERROR_OK)\r
1362         {\r
1363                 return;\r
1364         }\r
1365         int first = 1;\r
1366         \r
1367         for (;;)\r
1368         {\r
1369                 if ((*xml == NULL) || (!first))\r
1370                 {\r
1371                         /* start by 0 to exercise all the code paths.\r
1372                          * Need minimum 2 bytes to fit 1 char and 0 terminator. */\r
1373                          \r
1374                         *size = *size * 2 + 2;\r
1375                         char *t = *xml;\r
1376                         *xml = realloc(*xml, *size);\r
1377                         if (*xml == NULL)\r
1378                         {\r
1379                                 if (t)\r
1380                                         free(t);\r
1381                                 *retval = ERROR_SERVER_REMOTE_CLOSED;\r
1382                                 return;\r
1383                         }\r
1384                 }\r
1385                 \r
1386             va_list ap;\r
1387             int ret;\r
1388             va_start(ap, fmt);\r
1389             ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);\r
1390             va_end(ap);\r
1391             if ((ret > 0) && ((ret + 1) < *size - *pos))\r
1392             {\r
1393                 *pos += ret;\r
1394                 return;\r
1395             }\r
1396             /* there was just enough or not enough space, allocate more. */\r
1397             first = 0;\r
1398         }\r
1399 }\r
1400 \r
1401 static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len)\r
1402 {\r
1403         char *separator;\r
1404         \r
1405         /* Extract and NUL-terminate the annex. */\r
1406         *annex = buf;\r
1407         while (*buf && *buf != ':')\r
1408                 buf++;\r
1409         if (*buf == '\0')\r
1410                 return -1;\r
1411         *buf++ = 0;\r
1412         \r
1413         /* After the read marker and annex, qXfer looks like a\r
1414          * traditional 'm' packet. */\r
1415         \r
1416         *ofs = strtoul(buf, &separator, 16);\r
1417 \r
1418         if (*separator != ',')\r
1419                 return -1;\r
1420 \r
1421         *len = strtoul(separator+1, NULL, 16);\r
1422         \r
1423         return 0;\r
1424 }\r
1425 \r
1426 int gdb_calc_blocksize(flash_bank_t *bank)\r
1427 {\r
1428         int i;\r
1429         int block_size = 0xffffffff;\r
1430         \r
1431         /* loop through all sectors and return smallest sector size */\r
1432         \r
1433         for (i = 0; i < bank->num_sectors; i++)\r
1434         {\r
1435                 if (bank->sectors[i].size < block_size)\r
1436                         block_size = bank->sectors[i].size;\r
1437         }\r
1438         \r
1439         return block_size;\r
1440 }\r
1441 \r
1442 int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1443 {\r
1444         command_context_t *cmd_ctx = connection->cmd_ctx;\r
1445         \r
1446         if (strstr(packet, "qRcmd,"))\r
1447         {\r
1448                 if (packet_size > 6)\r
1449                 {\r
1450                         char *cmd;\r
1451                         int i;\r
1452                         cmd = malloc((packet_size - 6)/2 + 1);\r
1453                         for (i=0; i < (packet_size - 6)/2; i++)\r
1454                         {\r
1455                                 u32 tmp;\r
1456                                 sscanf(packet + 6 + 2*i, "%2x", &tmp);\r
1457                                 cmd[i] = tmp;\r
1458                         }\r
1459                         cmd[(packet_size - 6)/2] = 0x0;\r
1460                         \r
1461                         /* We want to print all debug output to GDB connection */\r
1462                         log_setCallback(gdb_log_callback, connection);\r
1463                         target_call_timer_callbacks();\r
1464                         command_run_line(cmd_ctx, cmd);\r
1465                         free(cmd);\r
1466                 }\r
1467                 gdb_put_packet(connection, "OK", 2);\r
1468                 return ERROR_OK;\r
1469         }\r
1470         else if (strstr(packet, "qCRC:"))\r
1471         {\r
1472                 if (packet_size > 5)\r
1473                 {\r
1474                         int retval;\r
1475                         char gdb_reply[10];\r
1476                         char *separator;\r
1477                         u32 checksum;\r
1478                         u32 addr = 0;\r
1479                         u32 len = 0;\r
1480                         \r
1481                         /* skip command character */\r
1482                         packet += 5;\r
1483                         \r
1484                         addr = strtoul(packet, &separator, 16);\r
1485                         \r
1486                         if (*separator != ',')\r
1487                         {\r
1488                                 ERROR("incomplete read memory packet received, dropping connection");\r
1489                                 return ERROR_SERVER_REMOTE_CLOSED;\r
1490                         }\r
1491                         \r
1492                         len = strtoul(separator + 1, NULL, 16);\r
1493                         \r
1494                         retval = target_checksum_memory(target, addr, len, &checksum);\r
1495                         \r
1496                         if (retval == ERROR_OK)\r
1497                         {\r
1498                                 snprintf(gdb_reply, 10, "C%8.8x", checksum);\r
1499                                 gdb_put_packet(connection, gdb_reply, 9);\r
1500                         }\r
1501                         else\r
1502                         {\r
1503                                 if ((retval = gdb_memory_packet_error(connection, retval)) != ERROR_OK)\r
1504                                         return retval; \r
1505                         }\r
1506                         \r
1507                         return ERROR_OK;\r
1508                 }\r
1509         }\r
1510         else if (strstr(packet, "qSupported"))\r
1511         {\r
1512                 /* we currently support packet size and qXfer:memory-map:read (if enabled)\r
1513                  * disable qXfer:features:read for the moment */\r
1514                 int retval = ERROR_OK;\r
1515                 char *buffer = NULL;\r
1516                 int pos = 0;\r
1517                 int size = 0;\r
1518 \r
1519                 xml_printf(&retval, &buffer, &pos, &size, \r
1520                                 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",\r
1521                                 (GDB_BUFFER_SIZE - 1), gdb_use_memory_map == 1 ? '+' : '-');\r
1522                 \r
1523                 if (retval != ERROR_OK)\r
1524                 {\r
1525                         gdb_send_error(connection, 01);\r
1526                         return ERROR_OK;\r
1527                 }\r
1528                 \r
1529                 gdb_put_packet(connection, buffer, strlen(buffer));\r
1530                 free(buffer);\r
1531                 \r
1532                 return ERROR_OK;\r
1533         }\r
1534         else if (strstr(packet, "qXfer:memory-map:read::"))\r
1535         {\r
1536                 /* We get away with only specifying flash here. Regions that are not\r
1537                  * specified are treated as if we provided no memory map(if not we \r
1538                  * could detect the holes and mark them as RAM).\r
1539                  * Normally we only execute this code once, but no big deal if we\r
1540                  * have to regenerate it a couple of times. */\r
1541                  \r
1542                 flash_bank_t *p;\r
1543                 char *xml = NULL;\r
1544                 int size = 0;\r
1545                 int pos = 0;\r
1546                 int retval = ERROR_OK;\r
1547                 \r
1548                 int offset;\r
1549                 int length;\r
1550                 char *separator;\r
1551                 int blocksize;\r
1552                 \r
1553                 /* skip command character */\r
1554                 packet += 23;\r
1555                 \r
1556                 offset = strtoul(packet, &separator, 16);\r
1557                 length = strtoul(separator + 1, &separator, 16);\r
1558                 \r
1559                 xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");\r
1560                 \r
1561                 int i = 0;\r
1562                 for (;;)\r
1563                 {\r
1564                         p = get_flash_bank_by_num(i);\r
1565                         if (p == NULL)\r
1566                                 break;\r
1567                         \r
1568                         /* if device has uneven sector sizes, eg. str7, lpc\r
1569                          * we pass the smallest sector size to gdb memory map */\r
1570                         blocksize = gdb_calc_blocksize(p);\r
1571                         \r
1572                         xml_printf(&retval, &xml, &pos, &size, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \\r
1573                                 "<property name=\"blocksize\">0x%x</property>\n" \\r
1574                                 "</memory>\n", \\r
1575                                 p->base, p->size, blocksize);\r
1576                         i++;\r
1577                 }\r
1578                 \r
1579                 xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");\r
1580 \r
1581                 if (retval != ERROR_OK)\r
1582                 {\r
1583                         gdb_send_error(connection, retval);\r
1584                         return retval;\r
1585                 }\r
1586                                 \r
1587                 if (offset + length > pos)\r
1588                 {\r
1589                         length = pos - offset;\r
1590                 }\r
1591 \r
1592                 char *t = malloc(length + 1);\r
1593                 t[0] = 'l';\r
1594                 memcpy(t + 1, xml + offset, length);\r
1595                 gdb_put_packet(connection, t, length + 1);\r
1596                 \r
1597                 free(t);\r
1598                 free(xml);\r
1599                 return ERROR_OK;\r
1600         }\r
1601         else if (strstr(packet, "qXfer:features:read:"))\r
1602         {                \r
1603                 char *xml = NULL;\r
1604                 int size = 0;\r
1605                 int pos = 0;\r
1606                 int retval = ERROR_OK;\r
1607                 \r
1608                 int offset;\r
1609                 unsigned int length;\r
1610                 char *annex;\r
1611                 \r
1612                 /* skip command character */\r
1613                 packet += 20;\r
1614                 \r
1615                 if (decode_xfer_read(packet, &annex, &offset, &length) < 0)\r
1616                 {\r
1617                         gdb_send_error(connection, 01);\r
1618                         return ERROR_OK;\r
1619                 }\r
1620                 \r
1621                 if (strcmp(annex, "target.xml") != 0)\r
1622                 {\r
1623                         gdb_send_error(connection, 01);\r
1624                         return ERROR_OK;\r
1625                 }\r
1626                                 \r
1627                 xml_printf(&retval, &xml, &pos, &size, \\r
1628                         "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");\r
1629                                         \r
1630                 if (retval != ERROR_OK)\r
1631                 {\r
1632                         gdb_send_error(connection, retval);\r
1633                         return retval;\r
1634                 }\r
1635                 \r
1636                 gdb_put_packet(connection, xml, strlen(xml) + 1);\r
1637                 \r
1638                 free(xml);\r
1639                 return ERROR_OK;\r
1640         }\r
1641         \r
1642         gdb_put_packet(connection, "", 0);\r
1643         return ERROR_OK;\r
1644 }\r
1645 \r
1646 int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int packet_size)\r
1647 {\r
1648         gdb_connection_t *gdb_connection = connection->priv;\r
1649         gdb_service_t *gdb_service = connection->service->priv;\r
1650         int result;\r
1651 \r
1652         /* if flash programming disabled - send a empty reply */\r
1653         \r
1654         if (gdb_flash_program == 0)\r
1655         {\r
1656                 gdb_put_packet(connection, "", 0);\r
1657                 return ERROR_OK;\r
1658         }\r
1659         \r
1660         if (strstr(packet, "vFlashErase:"))\r
1661         {\r
1662                 unsigned long addr;\r
1663                 unsigned long length;\r
1664         \r
1665                 char *parse = packet + 12;\r
1666                 if (*parse == '\0')\r
1667                 {\r
1668                         ERROR("incomplete vFlashErase packet received, dropping connection");\r
1669                         return ERROR_SERVER_REMOTE_CLOSED;\r
1670                 }\r
1671 \r
1672                 addr = strtoul(parse, &parse, 16);\r
1673 \r
1674                 if (*(parse++) != ',' || *parse == '\0')\r
1675                 {\r
1676                         ERROR("incomplete vFlashErase packet received, dropping connection");\r
1677                         return ERROR_SERVER_REMOTE_CLOSED;\r
1678                 }\r
1679 \r
1680                 length = strtoul(parse, &parse, 16);\r
1681 \r
1682                 if (*parse != '\0')\r
1683                 {\r
1684                         ERROR("incomplete vFlashErase packet received, dropping connection");\r
1685                         return ERROR_SERVER_REMOTE_CLOSED;\r
1686                 }\r
1687                 \r
1688                 /* assume all sectors need erasing - stops any problems\r
1689                  * when flash_write is called multiple times */\r
1690                 flash_set_dirty();\r
1691                 \r
1692                 /* perform any target specific operations before the erase */\r
1693                 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_PROGRAM);\r
1694                 \r
1695                 /* perform erase */\r
1696                 if ((result = flash_erase_address_range(gdb_service->target, addr, length)) != ERROR_OK)\r
1697                 {\r
1698                         /* GDB doesn't evaluate the actual error number returned,\r
1699                          * treat a failed erase as an I/O error\r
1700                          */\r
1701                         gdb_send_error(connection, EIO);\r
1702                         ERROR("flash_erase returned %i", result);\r
1703                 }\r
1704                 else\r
1705                         gdb_put_packet(connection, "OK", 2);\r
1706                 \r
1707                 return ERROR_OK;\r
1708         }\r
1709 \r
1710         if (strstr(packet, "vFlashWrite:"))\r
1711         {\r
1712                 unsigned long addr;\r
1713                 unsigned long length;\r
1714                 char *parse = packet + 12;\r
1715 \r
1716                 if (*parse == '\0')\r
1717                 {\r
1718                         ERROR("incomplete vFlashErase packet received, dropping connection");\r
1719                         return ERROR_SERVER_REMOTE_CLOSED;\r
1720                 }\r
1721                 addr = strtoul(parse, &parse, 16);\r
1722                 if (*(parse++) != ':')\r
1723                 {\r
1724                         ERROR("incomplete vFlashErase packet received, dropping connection");\r
1725                         return ERROR_SERVER_REMOTE_CLOSED;\r
1726                 }\r
1727                 length = packet_size - (parse - packet);\r
1728                 \r
1729                 /* create a new image if there isn't already one */\r
1730                 if (gdb_connection->vflash_image == NULL)\r
1731                 {\r
1732                         gdb_connection->vflash_image = malloc(sizeof(image_t));\r
1733                         image_open(gdb_connection->vflash_image, "", "build");\r
1734                 }\r
1735 \r
1736                 /* create new section with content from packet buffer */\r
1737                 image_add_section(gdb_connection->vflash_image, addr, length, 0x0, (u8*)parse);\r
1738 \r
1739                 gdb_put_packet(connection, "OK", 2);\r
1740 \r
1741                 return ERROR_OK;\r
1742         }\r
1743 \r
1744         if (!strcmp(packet, "vFlashDone"))\r
1745         {\r
1746                 u32 written;\r
1747 \r
1748                 /* process the flashing buffer. No need to erase as GDB\r
1749                  * always issues a vFlashErase first. */\r
1750                 if ((result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0)) != ERROR_OK)\r
1751                 {\r
1752                         if (result == ERROR_FLASH_DST_OUT_OF_BANK)\r
1753                                 gdb_put_packet(connection, "E.memtype", 9);\r
1754                         else\r
1755                                 gdb_send_error(connection, EIO);\r
1756                         }\r
1757                 else\r
1758                 {\r
1759                         DEBUG("wrote %u bytes from vFlash image to flash", written);\r
1760                         gdb_put_packet(connection, "OK", 2);\r
1761                 }\r
1762                 \r
1763                 image_close(gdb_connection->vflash_image);\r
1764                 free(gdb_connection->vflash_image);\r
1765                 gdb_connection->vflash_image = NULL;\r
1766                 \r
1767                 return ERROR_OK;\r
1768         }\r
1769 \r
1770         gdb_put_packet(connection, "", 0);\r
1771         return ERROR_OK;\r
1772 }\r
1773 \r
1774 int gdb_detach(connection_t *connection, target_t *target)\r
1775 {\r
1776         switch( detach_mode )\r
1777         {\r
1778                 case GDB_DETACH_RESUME:\r
1779                         target->type->resume(target, 1, 0, 1, 0);\r
1780                         break;\r
1781                 \r
1782                 case GDB_DETACH_RESET:\r
1783                         target_process_reset(connection->cmd_ctx);\r
1784                         break;\r
1785                 \r
1786                 case GDB_DETACH_HALT:\r
1787                         target->type->halt(target);\r
1788                         break;\r
1789                 \r
1790                 case GDB_DETACH_NOTHING:\r
1791                         break;\r
1792         }\r
1793         \r
1794         gdb_put_packet(connection, "OK", 2);\r
1795         \r
1796         return ERROR_OK;\r
1797 }\r
1798 \r
1799 static void gdb_log_callback(void *priv, const char *file, int line, \r
1800                 const char *function, const char *format, va_list args)\r
1801 {\r
1802         connection_t *connection = priv;\r
1803         gdb_connection_t *gdb_con = connection->priv;\r
1804         \r
1805         if (gdb_con->busy)\r
1806         {\r
1807                 /* do not reply this using the O packet */\r
1808                 return;\r
1809         }\r
1810 \r
1811         char *t = allocPrintf(format, args);\r
1812         if (t == NULL)\r
1813                 return;\r
1814         \r
1815         gdb_output_con(connection, t); \r
1816         \r
1817         free(t);\r
1818 }\r
1819 \r
1820 int gdb_input_inner(connection_t *connection)\r
1821 {\r
1822         gdb_service_t *gdb_service = connection->service->priv;\r
1823         target_t *target = gdb_service->target;\r
1824         char packet[GDB_BUFFER_SIZE];\r
1825         int packet_size;\r
1826         int retval;\r
1827         gdb_connection_t *gdb_con = connection->priv;\r
1828         static int extended_protocol = 0;\r
1829 \r
1830         /* drain input buffer */\r
1831         do\r
1832         {\r
1833                 packet_size = GDB_BUFFER_SIZE-1;\r
1834                 if ((retval = gdb_get_packet(connection, packet, &packet_size)) != ERROR_OK)\r
1835                 {\r
1836                         return retval;\r
1837                 }\r
1838 \r
1839                 /* terminate with zero */\r
1840                 packet[packet_size] = 0;\r
1841 \r
1842                 DEBUG("received packet: '%s'", packet);\r
1843 \r
1844                 if (packet_size > 0)\r
1845                 {\r
1846                         retval = ERROR_OK;\r
1847                         switch (packet[0])\r
1848                         {\r
1849                                 case 'H':\r
1850                                         /* Hct... -- set thread \r
1851                                          * we don't have threads, send empty reply */\r
1852                                         gdb_put_packet(connection, NULL, 0);\r
1853                                         break;\r
1854                                 case 'q':\r
1855                                         retval = gdb_query_packet(connection, target, packet, packet_size);\r
1856                                         break;\r
1857                                 case 'g':\r
1858                                         retval = gdb_get_registers_packet(connection, target, packet, packet_size);\r
1859                                         break;\r
1860                                 case 'G':\r
1861                                         retval = gdb_set_registers_packet(connection, target, packet, packet_size);\r
1862                                         break;\r
1863                                 case 'p':\r
1864                                         retval = gdb_get_register_packet(connection, target, packet, packet_size);\r
1865                                         break;\r
1866                                 case 'P':\r
1867                                         retval = gdb_set_register_packet(connection, target, packet, packet_size);\r
1868                                         break;\r
1869                                 case 'm':\r
1870                                         retval = gdb_read_memory_packet(connection, target, packet, packet_size);\r
1871                                         break;\r
1872                                 case 'M':\r
1873                                         retval = gdb_write_memory_packet(connection, target, packet, packet_size);\r
1874                                         break;\r
1875                                 case 'z':\r
1876                                 case 'Z':\r
1877                                         retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);\r
1878                                         break;\r
1879                                 case '?':\r
1880                                         gdb_last_signal_packet(connection, target, packet, packet_size);\r
1881                                         break;\r
1882                                 case 'c':\r
1883                                 case 's':\r
1884                                         {\r
1885                                         /* We're running/stepping, in which case we can \r
1886                                          * forward log output until the target is halted */\r
1887                                                 gdb_connection_t *gdb_con = connection->priv;\r
1888                                                 gdb_con->frontend_state = TARGET_RUNNING;\r
1889                                                 log_setCallback(gdb_log_callback, connection);\r
1890                                                 gdb_step_continue_packet(connection, target, packet, packet_size);\r
1891                                         }\r
1892                                         break;\r
1893                                 case 'v':\r
1894                                         retval = gdb_v_packet(connection, target, packet, packet_size);\r
1895                                         break;\r
1896                                 case 'D':\r
1897                                         retval = gdb_detach(connection, target);\r
1898                                         extended_protocol = 0;\r
1899                                         break;\r
1900                                 case 'X':\r
1901                                         if ((retval = gdb_write_memory_binary_packet(connection, target, packet, packet_size)) != ERROR_OK)\r
1902                                                 return retval;\r
1903                                         break;\r
1904                                 case 'k':\r
1905                                         if (extended_protocol != 0)\r
1906                                                 break;\r
1907                                         gdb_put_packet(connection, "OK", 2);\r
1908                                         return ERROR_SERVER_REMOTE_CLOSED;\r
1909                                 case '!':\r
1910                                         /* handle extended remote protocol */\r
1911                                         extended_protocol = 1;\r
1912                                         gdb_put_packet(connection, "OK", 2);\r
1913                                         break;\r
1914                                 case 'R':\r
1915                                         /* handle extended restart packet */\r
1916                                         target_process_reset(connection->cmd_ctx);\r
1917                                         break;\r
1918                                 default:\r
1919                                         /* ignore unkown packets */\r
1920                                         DEBUG("ignoring 0x%2.2x packet", packet[0]);\r
1921                                         gdb_put_packet(connection, NULL, 0);\r
1922                                         break;\r
1923                         }\r
1924 \r
1925                         /* if a packet handler returned an error, exit input loop */\r
1926                         if (retval != ERROR_OK)\r
1927                                 return retval;\r
1928                 }\r
1929 \r
1930                 if (gdb_con->ctrl_c)\r
1931                 {\r
1932                         if (target->state == TARGET_RUNNING)\r
1933                         {\r
1934                                 target->type->halt(target);\r
1935                                 gdb_con->ctrl_c = 0;\r
1936                         }\r
1937                 }\r
1938 \r
1939         } while (gdb_con->buf_cnt > 0);\r
1940 \r
1941         return ERROR_OK;\r
1942 }\r
1943 \r
1944 int gdb_input(connection_t *connection)\r
1945 {\r
1946         int retval = gdb_input_inner(connection);\r
1947         if (retval == ERROR_SERVER_REMOTE_CLOSED)\r
1948                 return retval;\r
1949         /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */\r
1950         return ERROR_OK;\r
1951 }\r
1952 \r
1953 int gdb_init()\r
1954 {\r
1955         gdb_service_t *gdb_service;\r
1956         target_t *target = targets;\r
1957         int i = 0;\r
1958 \r
1959         if (!target)\r
1960         {\r
1961                 WARNING("no gdb ports allocated as no target has been specified");\r
1962                 return ERROR_OK;\r
1963         }\r
1964 \r
1965         if (gdb_port == 0)\r
1966         {\r
1967                 WARNING("no gdb port specified, using default port 3333");\r
1968                 gdb_port = 3333;\r
1969         }\r
1970 \r
1971         while (target)\r
1972         {\r
1973                 char service_name[8];\r
1974 \r
1975                 snprintf(service_name, 8, "gdb-%2.2i", i);\r
1976 \r
1977                 gdb_service = malloc(sizeof(gdb_service_t));\r
1978                 gdb_service->target = target;\r
1979 \r
1980                 add_service("gdb", CONNECTION_GDB, gdb_port + i, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service);\r
1981 \r
1982                 DEBUG("gdb service for target %s at port %i", target->type->name, gdb_port + i);\r
1983 \r
1984                 i++;\r
1985                 target = target->next;\r
1986         }\r
1987 \r
1988         return ERROR_OK;\r
1989 }\r
1990 \r
1991 /* daemon configuration command gdb_port */\r
1992 int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
1993 {\r
1994         if (argc == 0)\r
1995                 return ERROR_OK;\r
1996 \r
1997         /* only if the port wasn't overwritten by cmdline */\r
1998         if (gdb_port == 0)\r
1999                 gdb_port = strtoul(args[0], NULL, 0);\r
2000 \r
2001         return ERROR_OK;\r
2002 }\r
2003 \r
2004 int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
2005 {\r
2006         if (argc == 1)\r
2007         {\r
2008                 if (strcmp(args[0], "resume") == 0)\r
2009                 {\r
2010                         detach_mode = GDB_DETACH_RESUME;\r
2011                         return ERROR_OK;\r
2012                 }\r
2013                 else if (strcmp(args[0], "reset") == 0)\r
2014                 {\r
2015                         detach_mode = GDB_DETACH_RESET;\r
2016                         return ERROR_OK;\r
2017                 }\r
2018                 else if (strcmp(args[0], "halt") == 0)\r
2019                 {\r
2020                         detach_mode = GDB_DETACH_HALT;\r
2021                         return ERROR_OK;\r
2022                 }\r
2023                 else if (strcmp(args[0], "nothing") == 0)\r
2024                 {\r
2025                         detach_mode = GDB_DETACH_NOTHING;\r
2026                         return ERROR_OK;\r
2027                 }\r
2028         }\r
2029         \r
2030         WARNING("invalid gdb_detach configuration directive: %s", args[0]);\r
2031         return ERROR_OK;\r
2032 }\r
2033 \r
2034 int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
2035 {\r
2036         if (argc == 1)\r
2037         {\r
2038                 if (strcmp(args[0], "enable") == 0)\r
2039                 {\r
2040                         gdb_use_memory_map = 1;\r
2041                         return ERROR_OK;\r
2042                 }\r
2043                 else if (strcmp(args[0], "disable") == 0)\r
2044                 {\r
2045                         gdb_use_memory_map = 0;\r
2046                         return ERROR_OK;\r
2047                 }\r
2048         }\r
2049         \r
2050         WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);\r
2051         return ERROR_OK;\r
2052 }\r
2053 \r
2054 int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
2055 {\r
2056         if (argc == 1)\r
2057         {\r
2058                 if (strcmp(args[0], "enable") == 0)\r
2059                 {\r
2060                         gdb_flash_program = 1;\r
2061                         return ERROR_OK;\r
2062                 }\r
2063                 else if (strcmp(args[0], "disable") == 0)\r
2064                 {\r
2065                         gdb_flash_program = 0;\r
2066                         return ERROR_OK;\r
2067                 }\r
2068         }\r
2069         \r
2070         WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);\r
2071         return ERROR_OK;\r
2072 }\r
2073 \r
2074 int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
2075 {\r
2076         if (argc == 1)\r
2077         {\r
2078                 if (strcmp(args[0], "enable") == 0)\r
2079                 {\r
2080                         gdb_report_data_abort = 1;\r
2081                         return ERROR_OK;\r
2082                 }\r
2083                 else if (strcmp(args[0], "disable") == 0)\r
2084                 {\r
2085                         gdb_report_data_abort = 0;\r
2086                         return ERROR_OK;\r
2087                 }\r
2088         }\r
2089         \r
2090         WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]);\r
2091         return ERROR_OK;\r
2092 }\r
2093 \r
2094 int gdb_register_commands(command_context_t *command_context)\r
2095 {\r
2096         register_command(command_context, NULL, "gdb_port", handle_gdb_port_command,\r
2097                         COMMAND_CONFIG, "");\r
2098         register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command,\r
2099                         COMMAND_CONFIG, "");\r
2100         register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command,\r
2101                         COMMAND_CONFIG, "");\r
2102         register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command,\r
2103                         COMMAND_CONFIG, "");\r
2104         register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command,\r
2105                         COMMAND_CONFIG, "");\r
2106         return ERROR_OK;\r
2107 }\r