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