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

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