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