Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
added yours sincerely for files where I feel that I've made non-trivial contributions.
[openocd.git] / 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 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 int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
592 {
593 connection_t *connection = priv;
594 gdb_connection_t *gdb_connection = connection->priv;
595 char sig_reply[4];
596 int signal;
597
598 switch (event)
599 {
600 case TARGET_EVENT_HALTED:
601 /* In the GDB protocol when we are stepping or coninuing execution,
602 * we have a lingering reply. Upon receiving a halted event
603 * when we have that lingering packet, we reply to the original
604 * step or continue packet.
605 *
606 * Executing monitor commands can bring the target in and
607 * out of the running state so we'll see lots of TARGET_EVENT_XXX
608 * that are to be ignored.
609 */
610 if (gdb_connection->frontend_state == TARGET_RUNNING)
611 {
612 /* stop forwarding log packets! */
613 log_remove_callback(gdb_log_callback, connection);
614
615 if (gdb_connection->ctrl_c)
616 {
617 signal = 0x2;
618 gdb_connection->ctrl_c = 0;
619 }
620 else
621 {
622 signal = gdb_last_signal(target);
623 }
624
625 snprintf(sig_reply, 4, "T%2.2x", signal);
626 gdb_put_packet(connection, sig_reply, 3);
627 gdb_connection->frontend_state = TARGET_HALTED;
628 }
629 break;
630 case TARGET_EVENT_GDB_PROGRAM:
631 gdb_program_handler(target, event, connection->cmd_ctx);
632 break;
633 default:
634 break;
635 }
636
637 return ERROR_OK;
638 }
639
640
641 int gdb_new_connection(connection_t *connection)
642 {
643 gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));
644 gdb_service_t *gdb_service = connection->service->priv;
645 int retval;
646 int initial_ack;
647
648 connection->priv = gdb_connection;
649
650 /* initialize gdb connection information */
651 gdb_connection->buf_p = gdb_connection->buffer;
652 gdb_connection->buf_cnt = 0;
653 gdb_connection->ctrl_c = 0;
654 gdb_connection->frontend_state = TARGET_HALTED;
655 gdb_connection->vflash_image = NULL;
656 gdb_connection->closed = 0;
657 gdb_connection->busy = 0;
658
659 /* send ACK to GDB for debug request */
660 gdb_write(connection, "+", 1);
661
662 /* output goes through gdb connection */
663 command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
664
665 /* register callback to be informed about target events */
666 target_register_event_callback(gdb_target_callback_event_handler, connection);
667
668 /* a gdb session just attached, try to put the target in halt mode.
669 *
670 * DANGER!!!!
671 *
672 * If the halt fails(e.g. target needs a reset, JTAG communication not
673 * working, etc.), then the GDB connect will succeed as
674 * the get_gdb_reg_list() will lie and return a register list with
675 * dummy values.
676 *
677 * This allows GDB monitor commands to be run from a GDB init script to
678 * initialize the target
679 *
680 * Also, since the halt() is asynchronous target connect will be
681 * instantaneous and thus avoiding annoying timeout problems during
682 * connect.
683 */
684 target_halt(gdb_service->target);
685 /* FIX!!!! could extended-remote work better here?
686 *
687 * wait a tiny bit for halted state or we just continue. The
688 * GDB register packet will then contain garbage
689 */
690 target_wait_state(gdb_service->target, TARGET_HALTED, 500);
691
692 /* remove the initial ACK from the incoming buffer */
693 if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
694 return retval;
695
696 /* FIX!!!??? would we actually ever receive a + here???
697 * Not observed.
698 */
699 if (initial_ack != '+')
700 gdb_putback_char(connection, initial_ack);
701
702 return ERROR_OK;
703 }
704
705 int gdb_connection_closed(connection_t *connection)
706 {
707 gdb_service_t *gdb_service = connection->service->priv;
708 gdb_connection_t *gdb_connection = connection->priv;
709
710 /* see if an image built with vFlash commands is left */
711 if (gdb_connection->vflash_image)
712 {
713 image_close(gdb_connection->vflash_image);
714 free(gdb_connection->vflash_image);
715 gdb_connection->vflash_image = NULL;
716 }
717
718 /* if this connection registered a debug-message receiver delete it */
719 delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
720
721 if (connection->priv)
722 {
723 free(connection->priv);
724 connection->priv = NULL;
725 }
726 else
727 {
728 LOG_ERROR("BUG: connection->priv == NULL");
729 }
730
731 target_unregister_event_callback(gdb_target_callback_event_handler, connection);
732 log_remove_callback(gdb_log_callback, connection);
733
734 return ERROR_OK;
735 }
736
737 void gdb_send_error(connection_t *connection, u8 the_error)
738 {
739 char err[4];
740 snprintf(err, 4, "E%2.2X", the_error );
741 gdb_put_packet(connection, err, 3);
742 }
743
744 int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
745 {
746 char sig_reply[4];
747 int signal;
748
749 signal = gdb_last_signal(target);
750
751 snprintf(sig_reply, 4, "S%2.2x", signal);
752 gdb_put_packet(connection, sig_reply, 3);
753
754 return ERROR_OK;
755 }
756
757 /* Convert register to string of bits. NB! The # of bits in the
758 * register might be non-divisible by 8(a byte), in which
759 * case an entire byte is shown. */
760 void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
761 {
762 int i;
763
764 u8 *buf;
765 int buf_len;
766 buf = reg->value;
767 buf_len = CEIL(reg->size, 8);
768
769 for (i = 0; i < buf_len; i++)
770 {
771 tstr[i*2] = DIGITS[(buf[i]>>4) & 0xf];
772 tstr[i*2+1] = DIGITS[buf[i]&0xf];
773 }
774 }
775
776 void gdb_target_to_str(target_t *target, char *tstr, char *str)
777 {
778 int str_len = strlen(tstr);
779 int i;
780
781 if (str_len % 2)
782 {
783 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
784 exit(-1);
785 }
786
787 for (i = 0; i < str_len; i+=2)
788 {
789 str[str_len - i - 1] = tstr[i + 1];
790 str[str_len - i - 2] = tstr[i];
791 }
792 }
793
794 int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
795 {
796 reg_t **reg_list;
797 int reg_list_size;
798 int retval;
799 int reg_packet_size = 0;
800 char *reg_packet;
801 char *reg_packet_p;
802 int i;
803
804 #ifdef _DEBUG_GDB_IO_
805 LOG_DEBUG("-");
806 #endif
807
808 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
809 {
810 return gdb_error(connection, retval);
811 }
812
813 for (i = 0; i < reg_list_size; i++)
814 {
815 reg_packet_size += reg_list[i]->size;
816 }
817
818 reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
819 reg_packet_p = reg_packet;
820
821 for (i = 0; i < reg_list_size; i++)
822 {
823 gdb_str_to_target(target, reg_packet_p, reg_list[i]);
824 reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
825 }
826
827 #ifdef _DEBUG_GDB_IO_
828 {
829 char *reg_packet_p;
830 reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
831 LOG_DEBUG("reg_packet: %s", reg_packet_p);
832 free(reg_packet_p);
833 }
834 #endif
835
836 gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
837 free(reg_packet);
838
839 free(reg_list);
840
841 return ERROR_OK;
842 }
843
844 int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
845 {
846 int i;
847 reg_t **reg_list;
848 int reg_list_size;
849 int retval;
850 char *packet_p;
851
852 #ifdef _DEBUG_GDB_IO_
853 LOG_DEBUG("-");
854 #endif
855
856 /* skip command character */
857 packet++;
858 packet_size--;
859
860 if (packet_size % 2)
861 {
862 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
863 return ERROR_SERVER_REMOTE_CLOSED;
864 }
865
866 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
867 {
868 return gdb_error(connection, retval);
869 }
870
871 packet_p = packet;
872 for (i = 0; i < reg_list_size; i++)
873 {
874 u8 *bin_buf;
875 char *hex_buf;
876 reg_arch_type_t *arch_type;
877
878 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
879 hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2);
880 gdb_target_to_str(target, packet_p, hex_buf);
881
882 /* convert hex-string to binary buffer */
883 bin_buf = malloc(CEIL(reg_list[i]->size, 8));
884 str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16);
885
886 /* get register arch_type, and call set method */
887 arch_type = register_get_arch_type(reg_list[i]->arch_type);
888 if (arch_type == NULL)
889 {
890 LOG_ERROR("BUG: encountered unregistered arch type");
891 exit(-1);
892 }
893 arch_type->set(reg_list[i], bin_buf);
894
895 /* advance packet pointer */
896 packet_p += (CEIL(reg_list[i]->size, 8) * 2);
897
898 free(bin_buf);
899 free(hex_buf);
900 }
901
902 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
903 free(reg_list);
904
905 gdb_put_packet(connection, "OK", 2);
906
907 return ERROR_OK;
908 }
909
910 int gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
911 {
912 char *reg_packet;
913 int reg_num = strtoul(packet + 1, NULL, 16);
914 reg_t **reg_list;
915 int reg_list_size;
916 int retval;
917
918 #ifdef _DEBUG_GDB_IO_
919 LOG_DEBUG("-");
920 #endif
921
922 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
923 {
924 return gdb_error(connection, retval);
925 }
926
927 if (reg_list_size <= reg_num)
928 {
929 LOG_ERROR("gdb requested a non-existing register");
930 exit(-1);
931 }
932
933 reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
934
935 gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
936
937 gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);
938
939 free(reg_list);
940 free(reg_packet);
941
942 return ERROR_OK;
943 }
944
945 int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
946 {
947 char *separator;
948 char *hex_buf;
949 u8 *bin_buf;
950 int reg_num = strtoul(packet + 1, &separator, 16);
951 reg_t **reg_list;
952 int reg_list_size;
953 int retval;
954 reg_arch_type_t *arch_type;
955
956 LOG_DEBUG("-");
957
958 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
959 {
960 return gdb_error(connection, retval);
961 }
962
963 if (reg_list_size < reg_num)
964 {
965 LOG_ERROR("gdb requested a non-existing register");
966 return ERROR_SERVER_REMOTE_CLOSED;
967 }
968
969 if (*separator != '=')
970 {
971 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
972 return ERROR_SERVER_REMOTE_CLOSED;
973 }
974
975 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
976 hex_buf = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
977 gdb_target_to_str(target, separator + 1, hex_buf);
978
979 /* convert hex-string to binary buffer */
980 bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
981 str_to_buf(hex_buf, CEIL(reg_list[reg_num]->size, 8) * 2, bin_buf, reg_list[reg_num]->size, 16);
982
983 /* get register arch_type, and call set method */
984 arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
985 if (arch_type == NULL)
986 {
987 LOG_ERROR("BUG: encountered unregistered arch type");
988 exit(-1);
989 }
990 arch_type->set(reg_list[reg_num], bin_buf);
991
992 gdb_put_packet(connection, "OK", 2);
993
994 free(bin_buf);
995 free(hex_buf);
996 free(reg_list);
997
998 return ERROR_OK;
999 }
1000
1001 int gdb_error(connection_t *connection, int retval)
1002 {
1003 switch (retval)
1004 {
1005 case ERROR_TARGET_DATA_ABORT:
1006 gdb_send_error(connection, EIO);
1007 break;
1008 case ERROR_TARGET_TRANSLATION_FAULT:
1009 gdb_send_error(connection, EFAULT);
1010 break;
1011 case ERROR_TARGET_UNALIGNED_ACCESS:
1012 gdb_send_error(connection, EFAULT);
1013 break;
1014 case ERROR_TARGET_NOT_HALTED:
1015 gdb_send_error(connection, EFAULT);
1016 break;
1017 default:
1018 /* This could be that the target reset itself. */
1019 LOG_ERROR("unexpected error %i", retval);
1020 gdb_send_error(connection, EFAULT);
1021 break;
1022 }
1023
1024 return ERROR_OK;
1025 }
1026
1027 /* We don't have to worry about the default 2 second timeout for GDB packets,
1028 * because GDB breaks up large memory reads into smaller reads.
1029 *
1030 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1031 */
1032 int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1033 {
1034 char *separator;
1035 u32 addr = 0;
1036 u32 len = 0;
1037
1038 u8 *buffer;
1039 char *hex_buffer;
1040
1041 int retval = ERROR_OK;
1042
1043 /* skip command character */
1044 packet++;
1045
1046 addr = strtoul(packet, &separator, 16);
1047
1048 if (*separator != ',')
1049 {
1050 LOG_ERROR("incomplete read memory packet received, dropping connection");
1051 return ERROR_SERVER_REMOTE_CLOSED;
1052 }
1053
1054 len = strtoul(separator+1, NULL, 16);
1055
1056 buffer = malloc(len);
1057
1058 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1059
1060 retval = target_read_buffer(target, addr, len, buffer);
1061
1062 if ((retval == ERROR_TARGET_DATA_ABORT) && (!gdb_report_data_abort))
1063 {
1064 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1065 * At some point this might be fixed in GDB, in which case this code can be removed.
1066 *
1067 * OpenOCD developers are acutely aware of this problem, but there is nothing
1068 * gained by involving the user in this problem that hopefully will get resolved
1069 * eventually
1070 *
1071 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1072 *
1073 * For now, the default is to fix up things to make current GDB versions work.
1074 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1075 */
1076 memset(buffer, 0, len);
1077 retval = ERROR_OK;
1078 }
1079
1080 if (retval == ERROR_OK)
1081 {
1082 hex_buffer = malloc(len * 2 + 1);
1083
1084 int i;
1085 for (i = 0; i < len; i++)
1086 {
1087 u8 t = buffer[i];
1088 hex_buffer[2 * i] = DIGITS[(t >> 4) & 0xf];
1089 hex_buffer[2 * i + 1] = DIGITS[t & 0xf];
1090 }
1091
1092 gdb_put_packet(connection, hex_buffer, len * 2);
1093
1094 free(hex_buffer);
1095 }
1096 else
1097 {
1098 retval = gdb_error(connection, retval);
1099 }
1100
1101 free(buffer);
1102
1103 return retval;
1104 }
1105
1106 int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1107 {
1108 char *separator;
1109 u32 addr = 0;
1110 u32 len = 0;
1111
1112 u8 *buffer;
1113
1114 int i;
1115 int retval;
1116
1117 /* skip command character */
1118 packet++;
1119
1120 addr = strtoul(packet, &separator, 16);
1121
1122 if (*separator != ',')
1123 {
1124 LOG_ERROR("incomplete write memory packet received, dropping connection");
1125 return ERROR_SERVER_REMOTE_CLOSED;
1126 }
1127
1128 len = strtoul(separator+1, &separator, 16);
1129
1130 if (*(separator++) != ':')
1131 {
1132 LOG_ERROR("incomplete write memory packet received, dropping connection");
1133 return ERROR_SERVER_REMOTE_CLOSED;
1134 }
1135
1136 buffer = malloc(len);
1137
1138 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1139
1140 for (i=0; i<len; i++)
1141 {
1142 u32 tmp;
1143 sscanf(separator + 2*i, "%2x", &tmp);
1144 buffer[i] = tmp;
1145 }
1146
1147 retval = target_write_buffer(target, addr, len, buffer);
1148
1149 if (retval == ERROR_OK)
1150 {
1151 gdb_put_packet(connection, "OK", 2);
1152 }
1153 else
1154 {
1155 retval = gdb_error(connection, retval);
1156 }
1157
1158 free(buffer);
1159
1160 return retval;
1161 }
1162
1163 int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1164 {
1165 char *separator;
1166 u32 addr = 0;
1167 u32 len = 0;
1168
1169 int retval;
1170
1171 /* skip command character */
1172 packet++;
1173
1174 addr = strtoul(packet, &separator, 16);
1175
1176 if (*separator != ',')
1177 {
1178 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1179 return ERROR_SERVER_REMOTE_CLOSED;
1180 }
1181
1182 len = strtoul(separator+1, &separator, 16);
1183
1184 if (*(separator++) != ':')
1185 {
1186 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1187 return ERROR_SERVER_REMOTE_CLOSED;
1188 }
1189
1190 retval = ERROR_OK;
1191 if (len)
1192 {
1193 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1194
1195 retval = target_write_buffer(target, addr, len, (u8*)separator);
1196 }
1197
1198 if (retval == ERROR_OK)
1199 {
1200 gdb_put_packet(connection, "OK", 2);
1201 }
1202 else
1203 {
1204 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1205 return retval;
1206 }
1207
1208 return ERROR_OK;
1209 }
1210
1211 void gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1212 {
1213 int current = 0;
1214 u32 address = 0x0;
1215
1216 LOG_DEBUG("-");
1217
1218 if (packet_size > 1)
1219 {
1220 packet[packet_size] = 0;
1221 address = strtoul(packet + 1, NULL, 16);
1222 }
1223 else
1224 {
1225 current = 1;
1226 }
1227
1228 if (packet[0] == 'c')
1229 {
1230 LOG_DEBUG("continue");
1231 target_invoke_script(connection->cmd_ctx, target, "pre_resume");
1232 target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1233 }
1234 else if (packet[0] == 's')
1235 {
1236 LOG_DEBUG("step");
1237 target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */
1238 }
1239 }
1240
1241 int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1242 {
1243 int type;
1244 enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
1245 enum watchpoint_rw wp_type;
1246 u32 address;
1247 u32 size;
1248 char *separator;
1249 int retval;
1250
1251 LOG_DEBUG("-");
1252
1253 type = strtoul(packet + 1, &separator, 16);
1254
1255 if (type == 0) /* memory breakpoint */
1256 bp_type = BKPT_SOFT;
1257 else if (type == 1) /* hardware breakpoint */
1258 bp_type = BKPT_HARD;
1259 else if (type == 2) /* write watchpoint */
1260 wp_type = WPT_WRITE;
1261 else if (type == 3) /* read watchpoint */
1262 wp_type = WPT_READ;
1263 else if (type == 4) /* access watchpoint */
1264 wp_type = WPT_ACCESS;
1265
1266 if (*separator != ',')
1267 {
1268 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1269 return ERROR_SERVER_REMOTE_CLOSED;
1270 }
1271
1272 address = strtoul(separator+1, &separator, 16);
1273
1274 if (*separator != ',')
1275 {
1276 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1277 return ERROR_SERVER_REMOTE_CLOSED;
1278 }
1279
1280 size = strtoul(separator+1, &separator, 16);
1281
1282 switch (type)
1283 {
1284 case 0:
1285 case 1:
1286 if (packet[0] == 'Z')
1287 {
1288 if ((retval = breakpoint_add(target, address, size, bp_type)) != ERROR_OK)
1289 {
1290 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1291 return retval;
1292 }
1293 else
1294 {
1295 gdb_put_packet(connection, "OK", 2);
1296 }
1297 }
1298 else
1299 {
1300 breakpoint_remove(target, address);
1301 gdb_put_packet(connection, "OK", 2);
1302 }
1303 break;
1304 case 2:
1305 case 3:
1306 case 4:
1307 {
1308 if (packet[0] == 'Z')
1309 {
1310 if ((retval = watchpoint_add(target, address, size, type-2, 0, 0xffffffffu)) != ERROR_OK)
1311 {
1312 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1313 return retval;
1314 }
1315 else
1316 {
1317 gdb_put_packet(connection, "OK", 2);
1318 }
1319 }
1320 else
1321 {
1322 watchpoint_remove(target, address);
1323 gdb_put_packet(connection, "OK", 2);
1324 }
1325 break;
1326 }
1327 default:
1328 break;
1329 }
1330
1331 return ERROR_OK;
1332 }
1333
1334 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1335 void xml_printf(int *retval, char **xml, int *pos, int *size, const char *fmt, ...)
1336 {
1337 if (*retval != ERROR_OK)
1338 {
1339 return;
1340 }
1341 int first = 1;
1342
1343 for (;;)
1344 {
1345 if ((*xml == NULL) || (!first))
1346 {
1347 /* start by 0 to exercise all the code paths.
1348 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1349
1350 *size = *size * 2 + 2;
1351 char *t = *xml;
1352 *xml = realloc(*xml, *size);
1353 if (*xml == NULL)
1354 {
1355 if (t)
1356 free(t);
1357 *retval = ERROR_SERVER_REMOTE_CLOSED;
1358 return;
1359 }
1360 }
1361
1362 va_list ap;
1363 int ret;
1364 va_start(ap, fmt);
1365 ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);
1366 va_end(ap);
1367 if ((ret > 0) && ((ret + 1) < *size - *pos))
1368 {
1369 *pos += ret;
1370 return;
1371 }
1372 /* there was just enough or not enough space, allocate more. */
1373 first = 0;
1374 }
1375 }
1376
1377 static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len)
1378 {
1379 char *separator;
1380
1381 /* Extract and NUL-terminate the annex. */
1382 *annex = buf;
1383 while (*buf && *buf != ':')
1384 buf++;
1385 if (*buf == '\0')
1386 return -1;
1387 *buf++ = 0;
1388
1389 /* After the read marker and annex, qXfer looks like a
1390 * traditional 'm' packet. */
1391
1392 *ofs = strtoul(buf, &separator, 16);
1393
1394 if (*separator != ',')
1395 return -1;
1396
1397 *len = strtoul(separator+1, NULL, 16);
1398
1399 return 0;
1400 }
1401
1402 int gdb_calc_blocksize(flash_bank_t *bank)
1403 {
1404 int i;
1405 int block_size = 0xffffffff;
1406
1407 /* loop through all sectors and return smallest sector size */
1408
1409 for (i = 0; i < bank->num_sectors; i++)
1410 {
1411 if (bank->sectors[i].size < block_size)
1412 block_size = bank->sectors[i].size;
1413 }
1414
1415 return block_size;
1416 }
1417
1418 static int compare_bank (const void * a, const void * b)
1419 {
1420 flash_bank_t *b1, *b2;
1421 b1=*((flash_bank_t **)a);
1422 b2=*((flash_bank_t **)b);
1423
1424 if (b1->base==b2->base)
1425 {
1426 return 0;
1427 } else if (b1->base>b2->base)
1428 {
1429 return 1;
1430 } else
1431 {
1432 return -1;
1433 }
1434 }
1435
1436 int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1437 {
1438 command_context_t *cmd_ctx = connection->cmd_ctx;
1439
1440 if (strstr(packet, "qRcmd,"))
1441 {
1442 if (packet_size > 6)
1443 {
1444 char *cmd;
1445 int i;
1446 cmd = malloc((packet_size - 6)/2 + 1);
1447 for (i=0; i < (packet_size - 6)/2; i++)
1448 {
1449 u32 tmp;
1450 sscanf(packet + 6 + 2*i, "%2x", &tmp);
1451 cmd[i] = tmp;
1452 }
1453 cmd[(packet_size - 6)/2] = 0x0;
1454
1455 /* We want to print all debug output to GDB connection */
1456 log_add_callback(gdb_log_callback, connection);
1457 target_call_timer_callbacks_now();
1458 command_run_line(cmd_ctx, cmd);
1459 target_call_timer_callbacks_now();
1460 log_remove_callback(gdb_log_callback, connection);
1461 free(cmd);
1462 }
1463 gdb_put_packet(connection, "OK", 2);
1464 return ERROR_OK;
1465 }
1466 else if (strstr(packet, "qCRC:"))
1467 {
1468 if (packet_size > 5)
1469 {
1470 int retval;
1471 char gdb_reply[10];
1472 char *separator;
1473 u32 checksum;
1474 u32 addr = 0;
1475 u32 len = 0;
1476
1477 /* skip command character */
1478 packet += 5;
1479
1480 addr = strtoul(packet, &separator, 16);
1481
1482 if (*separator != ',')
1483 {
1484 LOG_ERROR("incomplete read memory packet received, dropping connection");
1485 return ERROR_SERVER_REMOTE_CLOSED;
1486 }
1487
1488 len = strtoul(separator + 1, NULL, 16);
1489
1490 retval = target_checksum_memory(target, addr, len, &checksum);
1491
1492 if (retval == ERROR_OK)
1493 {
1494 snprintf(gdb_reply, 10, "C%8.8x", checksum);
1495 gdb_put_packet(connection, gdb_reply, 9);
1496 }
1497 else
1498 {
1499 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1500 return retval;
1501 }
1502
1503 return ERROR_OK;
1504 }
1505 }
1506 else if (strstr(packet, "qSupported"))
1507 {
1508 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1509 * disable qXfer:features:read for the moment */
1510 int retval = ERROR_OK;
1511 char *buffer = NULL;
1512 int pos = 0;
1513 int size = 0;
1514
1515 xml_printf(&retval, &buffer, &pos, &size,
1516 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
1517 (GDB_BUFFER_SIZE - 1), ((gdb_use_memory_map == 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1518
1519 if (retval != ERROR_OK)
1520 {
1521 gdb_send_error(connection, 01);
1522 return ERROR_OK;
1523 }
1524
1525 gdb_put_packet(connection, buffer, strlen(buffer));
1526 free(buffer);
1527
1528 return ERROR_OK;
1529 }
1530 else if (strstr(packet, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1531 {
1532 /* We get away with only specifying flash here. Regions that are not
1533 * specified are treated as if we provided no memory map(if not we
1534 * could detect the holes and mark them as RAM).
1535 * Normally we only execute this code once, but no big deal if we
1536 * have to regenerate it a couple of times. */
1537
1538 flash_bank_t *p;
1539 char *xml = NULL;
1540 int size = 0;
1541 int pos = 0;
1542 int retval = ERROR_OK;
1543
1544 int offset;
1545 int length;
1546 char *separator;
1547 int blocksize;
1548
1549 /* skip command character */
1550 packet += 23;
1551
1552 offset = strtoul(packet, &separator, 16);
1553 length = strtoul(separator + 1, &separator, 16);
1554
1555 xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");
1556
1557 /*
1558 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1559 read/write) by default for GDB.
1560 GDB does not have a concept of non-cacheable read/write memory.
1561 */
1562 flash_bank_t **banks=malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
1563 int i;
1564
1565 for (i=0; i<flash_get_bank_count(); i++)
1566 {
1567 p = get_flash_bank_by_num(i);
1568 if (p == NULL)
1569 {
1570 free(banks);
1571 retval = ERROR_FAIL;
1572 gdb_send_error(connection, retval);
1573 return retval;
1574 }
1575 banks[i]=p;
1576 }
1577
1578 qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
1579
1580 u32 ram_start=0;
1581 for (i=0; i<flash_get_bank_count(); i++)
1582 {
1583 p = banks[i];
1584
1585 if (ram_start<p->base)
1586 {
1587 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1588 ram_start, p->base-ram_start);
1589 }
1590
1591 /* if device has uneven sector sizes, eg. str7, lpc
1592 * we pass the smallest sector size to gdb memory map */
1593 blocksize = gdb_calc_blocksize(p);
1594
1595 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1596 "<property name=\"blocksize\">0x%x</property>\n" \
1597 "</memory>\n", \
1598 p->base, p->size, blocksize);
1599 ram_start=p->base+p->size;
1600 }
1601 if (ram_start!=0)
1602 {
1603 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1604 ram_start, 0-ram_start);
1605 } else
1606 {
1607 /* a flash chip could be at the very end of the 32 bit address space, in which case
1608 ram_start will be precisely 0 */
1609 }
1610
1611 free(banks);
1612 banks = NULL;
1613
1614 xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
1615
1616 if (retval != ERROR_OK)
1617 {
1618 gdb_send_error(connection, retval);
1619 return retval;
1620 }
1621
1622 if (offset + length > pos)
1623 {
1624 length = pos - offset;
1625 }
1626
1627 char *t = malloc(length + 1);
1628 t[0] = 'l';
1629 memcpy(t + 1, xml + offset, length);
1630 gdb_put_packet(connection, t, length + 1);
1631
1632 free(t);
1633 free(xml);
1634 return ERROR_OK;
1635 }
1636 else if (strstr(packet, "qXfer:features:read:"))
1637 {
1638 char *xml = NULL;
1639 int size = 0;
1640 int pos = 0;
1641 int retval = ERROR_OK;
1642
1643 int offset;
1644 unsigned int length;
1645 char *annex;
1646
1647 /* skip command character */
1648 packet += 20;
1649
1650 if (decode_xfer_read(packet, &annex, &offset, &length) < 0)
1651 {
1652 gdb_send_error(connection, 01);
1653 return ERROR_OK;
1654 }
1655
1656 if (strcmp(annex, "target.xml") != 0)
1657 {
1658 gdb_send_error(connection, 01);
1659 return ERROR_OK;
1660 }
1661
1662 xml_printf(&retval, &xml, &pos, &size, \
1663 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1664
1665 if (retval != ERROR_OK)
1666 {
1667 gdb_send_error(connection, retval);
1668 return retval;
1669 }
1670
1671 gdb_put_packet(connection, xml, strlen(xml));
1672
1673 free(xml);
1674 return ERROR_OK;
1675 }
1676
1677 gdb_put_packet(connection, "", 0);
1678 return ERROR_OK;
1679 }
1680
1681 int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1682 {
1683 gdb_connection_t *gdb_connection = connection->priv;
1684 gdb_service_t *gdb_service = connection->service->priv;
1685 int result;
1686
1687 /* if flash programming disabled - send a empty reply */
1688
1689 if (gdb_flash_program == 0)
1690 {
1691 gdb_put_packet(connection, "", 0);
1692 return ERROR_OK;
1693 }
1694
1695 if (strstr(packet, "vFlashErase:"))
1696 {
1697 unsigned long addr;
1698 unsigned long length;
1699
1700 char *parse = packet + 12;
1701 if (*parse == '\0')
1702 {
1703 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1704 return ERROR_SERVER_REMOTE_CLOSED;
1705 }
1706
1707 addr = strtoul(parse, &parse, 16);
1708
1709 if (*(parse++) != ',' || *parse == '\0')
1710 {
1711 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1712 return ERROR_SERVER_REMOTE_CLOSED;
1713 }
1714
1715 length = strtoul(parse, &parse, 16);
1716
1717 if (*parse != '\0')
1718 {
1719 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1720 return ERROR_SERVER_REMOTE_CLOSED;
1721 }
1722
1723 /* assume all sectors need erasing - stops any problems
1724 * when flash_write is called multiple times */
1725 flash_set_dirty();
1726
1727 /* perform any target specific operations before the erase */
1728 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_PROGRAM);
1729
1730 /* perform erase */
1731 if ((result = flash_erase_address_range(gdb_service->target, addr, length)) != ERROR_OK)
1732 {
1733 /* GDB doesn't evaluate the actual error number returned,
1734 * treat a failed erase as an I/O error
1735 */
1736 gdb_send_error(connection, EIO);
1737 LOG_ERROR("flash_erase returned %i", result);
1738 }
1739 else
1740 gdb_put_packet(connection, "OK", 2);
1741
1742 return ERROR_OK;
1743 }
1744
1745 if (strstr(packet, "vFlashWrite:"))
1746 {
1747 unsigned long addr;
1748 unsigned long length;
1749 char *parse = packet + 12;
1750
1751 if (*parse == '\0')
1752 {
1753 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1754 return ERROR_SERVER_REMOTE_CLOSED;
1755 }
1756 addr = strtoul(parse, &parse, 16);
1757 if (*(parse++) != ':')
1758 {
1759 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1760 return ERROR_SERVER_REMOTE_CLOSED;
1761 }
1762 length = packet_size - (parse - packet);
1763
1764 /* create a new image if there isn't already one */
1765 if (gdb_connection->vflash_image == NULL)
1766 {
1767 gdb_connection->vflash_image = malloc(sizeof(image_t));
1768 image_open(gdb_connection->vflash_image, "", "build");
1769 }
1770
1771 /* create new section with content from packet buffer */
1772 image_add_section(gdb_connection->vflash_image, addr, length, 0x0, (u8*)parse);
1773
1774 gdb_put_packet(connection, "OK", 2);
1775
1776 return ERROR_OK;
1777 }
1778
1779 if (!strcmp(packet, "vFlashDone"))
1780 {
1781 u32 written;
1782
1783 /* process the flashing buffer. No need to erase as GDB
1784 * always issues a vFlashErase first. */
1785 if ((result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0)) != ERROR_OK)
1786 {
1787 if (result == ERROR_FLASH_DST_OUT_OF_BANK)
1788 gdb_put_packet(connection, "E.memtype", 9);
1789 else
1790 gdb_send_error(connection, EIO);
1791 }
1792 else
1793 {
1794 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written);
1795 gdb_put_packet(connection, "OK", 2);
1796 }
1797
1798 image_close(gdb_connection->vflash_image);
1799 free(gdb_connection->vflash_image);
1800 gdb_connection->vflash_image = NULL;
1801
1802 return ERROR_OK;
1803 }
1804
1805 gdb_put_packet(connection, "", 0);
1806 return ERROR_OK;
1807 }
1808
1809 int gdb_detach(connection_t *connection, target_t *target)
1810 {
1811 switch( detach_mode )
1812 {
1813 case GDB_DETACH_RESUME:
1814 target_invoke_script(connection->cmd_ctx, target, "pre_resume");
1815 target_resume(target, 1, 0, 1, 0);
1816 break;
1817
1818 case GDB_DETACH_RESET:
1819 /* FIX?? make this configurable?? */
1820 target_process_reset(connection->cmd_ctx, RESET_HALT);
1821 break;
1822
1823 case GDB_DETACH_HALT:
1824 target_halt(target);
1825 break;
1826
1827 case GDB_DETACH_NOTHING:
1828 break;
1829 }
1830
1831 gdb_put_packet(connection, "OK", 2);
1832
1833 return ERROR_OK;
1834 }
1835
1836 static void gdb_log_callback(void *priv, const char *file, int line,
1837 const char *function, const char *string)
1838 {
1839 connection_t *connection = priv;
1840 gdb_connection_t *gdb_con = connection->priv;
1841
1842 if (gdb_con->busy)
1843 {
1844 /* do not reply this using the O packet */
1845 return;
1846 }
1847
1848 gdb_output_con(connection, string);
1849 }
1850
1851 /* Do not allocate this on the stack */
1852 char gdb_packet_buffer[GDB_BUFFER_SIZE];
1853
1854 int gdb_input_inner(connection_t *connection)
1855 {
1856 gdb_service_t *gdb_service = connection->service->priv;
1857 target_t *target = gdb_service->target;
1858 char *packet=gdb_packet_buffer;
1859 int packet_size;
1860 int retval;
1861 gdb_connection_t *gdb_con = connection->priv;
1862 static int extended_protocol = 0;
1863
1864 /* drain input buffer */
1865 do
1866 {
1867 packet_size = GDB_BUFFER_SIZE-1;
1868 if ((retval = gdb_get_packet(connection, packet, &packet_size)) != ERROR_OK)
1869 {
1870 return retval;
1871 }
1872
1873 /* terminate with zero */
1874 packet[packet_size] = 0;
1875
1876 LOG_DEBUG("received packet: '%s'", packet);
1877
1878 if (packet_size > 0)
1879 {
1880 retval = ERROR_OK;
1881 switch (packet[0])
1882 {
1883 case 'H':
1884 /* Hct... -- set thread
1885 * we don't have threads, send empty reply */
1886 gdb_put_packet(connection, NULL, 0);
1887 break;
1888 case 'q':
1889 retval = gdb_query_packet(connection, target, packet, packet_size);
1890 break;
1891 case 'g':
1892 retval = gdb_get_registers_packet(connection, target, packet, packet_size);
1893 break;
1894 case 'G':
1895 retval = gdb_set_registers_packet(connection, target, packet, packet_size);
1896 break;
1897 case 'p':
1898 retval = gdb_get_register_packet(connection, target, packet, packet_size);
1899 break;
1900 case 'P':
1901 retval = gdb_set_register_packet(connection, target, packet, packet_size);
1902 break;
1903 case 'm':
1904 retval = gdb_read_memory_packet(connection, target, packet, packet_size);
1905 break;
1906 case 'M':
1907 retval = gdb_write_memory_packet(connection, target, packet, packet_size);
1908 break;
1909 case 'z':
1910 case 'Z':
1911 retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);
1912 break;
1913 case '?':
1914 gdb_last_signal_packet(connection, target, packet, packet_size);
1915 break;
1916 case 'c':
1917 case 's':
1918 {
1919 if (target->state != TARGET_HALTED)
1920 {
1921 /* If the target isn't in the halted state, then we can't
1922 * step/continue. This might be early setup, etc.
1923 */
1924 char sig_reply[4];
1925 snprintf(sig_reply, 4, "T%2.2x", 2);
1926 gdb_put_packet(connection, sig_reply, 3);
1927 } else
1928 {
1929 /* We're running/stepping, in which case we can
1930 * forward log output until the target is halted
1931 */
1932 gdb_connection_t *gdb_con = connection->priv;
1933 gdb_con->frontend_state = TARGET_RUNNING;
1934 log_add_callback(gdb_log_callback, connection);
1935 gdb_step_continue_packet(connection, target, packet, packet_size);
1936 }
1937 }
1938 break;
1939 case 'v':
1940 retval = gdb_v_packet(connection, target, packet, packet_size);
1941 break;
1942 case 'D':
1943 retval = gdb_detach(connection, target);
1944 extended_protocol = 0;
1945 break;
1946 case 'X':
1947 if ((retval = gdb_write_memory_binary_packet(connection, target, packet, packet_size)) != ERROR_OK)
1948 return retval;
1949 break;
1950 case 'k':
1951 if (extended_protocol != 0)
1952 break;
1953 gdb_put_packet(connection, "OK", 2);
1954 return ERROR_SERVER_REMOTE_CLOSED;
1955 case '!':
1956 /* handle extended remote protocol */
1957 extended_protocol = 1;
1958 gdb_put_packet(connection, "OK", 2);
1959 break;
1960 case 'R':
1961 /* handle extended restart packet */
1962 command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %d", get_num_by_target(target));
1963 break;
1964 default:
1965 /* ignore unkown packets */
1966 LOG_DEBUG("ignoring 0x%2.2x packet", packet[0]);
1967 gdb_put_packet(connection, NULL, 0);
1968 break;
1969 }
1970
1971 /* if a packet handler returned an error, exit input loop */
1972 if (retval != ERROR_OK)
1973 return retval;
1974 }
1975
1976 if (gdb_con->ctrl_c)
1977 {
1978 if (target->state == TARGET_RUNNING)
1979 {
1980 target_halt(target);
1981 gdb_con->ctrl_c = 0;
1982 }
1983 }
1984
1985 } while (gdb_con->buf_cnt > 0);
1986
1987 return ERROR_OK;
1988 }
1989
1990 int gdb_input(connection_t *connection)
1991 {
1992 int retval = gdb_input_inner(connection);
1993 gdb_connection_t *gdb_con = connection->priv;
1994 if (retval == ERROR_SERVER_REMOTE_CLOSED)
1995 return retval;
1996
1997 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
1998 if (gdb_con->closed)
1999 return ERROR_SERVER_REMOTE_CLOSED;
2000
2001 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2002 return ERROR_OK;
2003 }
2004
2005 int gdb_init()
2006 {
2007 gdb_service_t *gdb_service;
2008 target_t *target = targets;
2009 int i = 0;
2010
2011 if (!target)
2012 {
2013 LOG_WARNING("no gdb ports allocated as no target has been specified");
2014 return ERROR_OK;
2015 }
2016
2017 if (gdb_port == 0)
2018 {
2019 LOG_WARNING("no gdb port specified, using default port 3333");
2020 gdb_port = 3333;
2021 }
2022
2023 while (target)
2024 {
2025 char service_name[8];
2026
2027 snprintf(service_name, 8, "gdb-%2.2i", i);
2028
2029 gdb_service = malloc(sizeof(gdb_service_t));
2030 gdb_service->target = target;
2031
2032 add_service("gdb", CONNECTION_GDB, gdb_port + i, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service);
2033
2034 LOG_DEBUG("gdb service for target %s at port %i", target->type->name, gdb_port + i);
2035
2036 i++;
2037 target = target->next;
2038 }
2039
2040 return ERROR_OK;
2041 }
2042
2043 /* daemon configuration command gdb_port */
2044 int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2045 {
2046 if (argc == 0)
2047 return ERROR_OK;
2048
2049 /* only if the port wasn't overwritten by cmdline */
2050 if (gdb_port == 0)
2051 gdb_port = strtoul(args[0], NULL, 0);
2052
2053 return ERROR_OK;
2054 }
2055
2056 int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2057 {
2058 if (argc == 1)
2059 {
2060 if (strcmp(args[0], "resume") == 0)
2061 {
2062 detach_mode = GDB_DETACH_RESUME;
2063 return ERROR_OK;
2064 }
2065 else if (strcmp(args[0], "reset") == 0)
2066 {
2067 detach_mode = GDB_DETACH_RESET;
2068 return ERROR_OK;
2069 }
2070 else if (strcmp(args[0], "halt") == 0)
2071 {
2072 detach_mode = GDB_DETACH_HALT;
2073 return ERROR_OK;
2074 }
2075 else if (strcmp(args[0], "nothing") == 0)
2076 {
2077 detach_mode = GDB_DETACH_NOTHING;
2078 return ERROR_OK;
2079 }
2080 }
2081
2082 LOG_WARNING("invalid gdb_detach configuration directive: %s", args[0]);
2083 return ERROR_OK;
2084 }
2085
2086 int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2087 {
2088 if (argc == 1)
2089 {
2090 if (strcmp(args[0], "enable") == 0)
2091 {
2092 gdb_use_memory_map = 1;
2093 return ERROR_OK;
2094 }
2095 else if (strcmp(args[0], "disable") == 0)
2096 {
2097 gdb_use_memory_map = 0;
2098 return ERROR_OK;
2099 }
2100 }
2101
2102 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
2103 return ERROR_OK;
2104 }
2105
2106 int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2107 {
2108 if (argc == 1)
2109 {
2110 if (strcmp(args[0], "enable") == 0)
2111 {
2112 gdb_flash_program = 1;
2113 return ERROR_OK;
2114 }
2115 else if (strcmp(args[0], "disable") == 0)
2116 {
2117 gdb_flash_program = 0;
2118 return ERROR_OK;
2119 }
2120 }
2121
2122 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
2123 return ERROR_OK;
2124 }
2125
2126 int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2127 {
2128 if (argc == 1)
2129 {
2130 if (strcmp(args[0], "enable") == 0)
2131 {
2132 gdb_report_data_abort = 1;
2133 return ERROR_OK;
2134 }
2135 else if (strcmp(args[0], "disable") == 0)
2136 {
2137 gdb_report_data_abort = 0;
2138 return ERROR_OK;
2139 }
2140 }
2141
2142 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]);
2143 return ERROR_OK;
2144 }
2145
2146 int gdb_register_commands(command_context_t *command_context)
2147 {
2148 register_command(command_context, NULL, "gdb_port", handle_gdb_port_command,
2149 COMMAND_CONFIG, "");
2150 register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command,
2151 COMMAND_CONFIG, "");
2152 register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command,
2153 COMMAND_CONFIG, "");
2154 register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command,
2155 COMMAND_CONFIG, "");
2156 register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command,
2157 COMMAND_CONFIG, "");
2158 return ERROR_OK;
2159 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)