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