gdb_server.c 56.9 KB
Newer Older
1
2
3
4
/***************************************************************************
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
 *                                                                         *
5
 *   Copyright (C) 2007,2008 yvind Harboe                                 *
6
7
 *   oyvind.harboe@zylin.com                                               *
 *                                                                         *
8
9
10
 *   Copyright (C) 2008 by Spencer Oliver                                  *
 *   spen@spen-soft.co.uk                                                  *
 *                                                                         *
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gdb_server.h"
31
32
#include "target_request.h"
#include "register.h"
33
34
#include "server.h"
#include "flash.h"
35
36
#include "image.h"
#include "jtag.h"
37
38
39
40
41
42


#if 0
#define _DEBUG_GDB_IO_
#endif

43
44
45
static int gdb_breakpoint_override;
static enum breakpoint_type gdb_breakpoint_override_type;

46
extern int gdb_error(connection_t *connection, int retval);
47
48
49
static unsigned short gdb_port;
static const char *DIGITS = "0123456789abcdef";

ntfreak's avatar
ntfreak committed
50
static void gdb_log_callback(void *priv, const char *file, int line,
51
		const char *function, const char *string);
52
53
54
55
56
57
58
59
60
61
62
63

enum gdb_detach_mode
{
	GDB_DETACH_RESUME,
	GDB_DETACH_RESET,
	GDB_DETACH_HALT,
	GDB_DETACH_NOTHING
};

/* target behaviour on gdb detach */
enum gdb_detach_mode detach_mode = GDB_DETACH_RESUME;

kc8apf's avatar
kc8apf committed
64
65
66
67
/* number of gdb connections, mainly to supress gdb related debugging spam
 * in helper/log.c when no gdb connections are actually active */
int gdb_actual_connections;

68
69
/* set if we are sending a memory map to gdb
 * via qXfer:memory-map:read packet */
70
71
72
73
/* enabled by default*/
int gdb_use_memory_map = 1;
/* enabled by default*/
int gdb_flash_program = 1;
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

/* if set, data aborts cause an error to be reported in memory read packets
 * see the code in gdb_read_memory_packet() for further explanations */
int gdb_report_data_abort = 0;

int gdb_last_signal(target_t *target)
{
	switch (target->debug_reason)
	{
		case DBG_REASON_DBGRQ:
			return 0x2; /* SIGINT */
		case DBG_REASON_BREAKPOINT:
		case DBG_REASON_WATCHPOINT:
		case DBG_REASON_WPTANDBKPT:
			return 0x05; /* SIGTRAP */
		case DBG_REASON_SINGLESTEP:
			return 0x05; /* SIGTRAP */
		case DBG_REASON_NOTHALTED:
			return 0x0; /* no signal... shouldn't happen */
		default:
94
			LOG_USER("undefined debug reason %d - target needs reset", target->debug_reason);
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
			return 0x0;
	}
}

int check_pending(connection_t *connection, int timeout_s, int *got_data)
{
	/* a non-blocking socket will block if there is 0 bytes available on the socket,
	 * but return with as many bytes as are available immediately
	 */
	struct timeval tv;
	fd_set read_fds;
	gdb_connection_t *gdb_con = connection->priv;
	int t;
	if (got_data==NULL)
		got_data=&t;
	*got_data=0;

	if (gdb_con->buf_cnt>0)
	{
		*got_data = 1;
		return ERROR_OK;
	}
117

118
119
	FD_ZERO(&read_fds);
	FD_SET(connection->fd, &read_fds);
120

121
122
	tv.tv_sec = timeout_s;
	tv.tv_usec = 0;
123
	if (socket_select(connection->fd + 1, &read_fds, NULL, NULL, &tv) == 0)
124
125
126
127
128
129
130
131
132
133
134
	{
		/* This can typically be because a "monitor" command took too long
		 * before printing any progress messages
		 */
		if (timeout_s>0)
		{
			return ERROR_GDB_TIMEOUT;
		} else
		{
			return ERROR_OK;
		}
135
	}
136
137
	*got_data=FD_ISSET(connection->fd, &read_fds)!=0;
	return ERROR_OK;
138
139
140
141
142
}

int gdb_get_char(connection_t *connection, int* next_char)
{
	gdb_connection_t *gdb_con = connection->priv;
143
	int retval=ERROR_OK;
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#ifdef _DEBUG_GDB_IO_
	char *debug_buffer;
#endif

	if (gdb_con->buf_cnt-- > 0)
	{
		*next_char = *(gdb_con->buf_p++);
		if (gdb_con->buf_cnt > 0)
			connection->input_pending = 1;
		else
			connection->input_pending = 0;

#ifdef _DEBUG_GDB_IO_
158
		LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
159
160
161
162
163
164
165
#endif

		return ERROR_OK;
	}

	for (;;)
	{
166
167
168
169
170
171
172
173
174
175
176
		if (connection->service->type == CONNECTION_PIPE)
		{
			gdb_con->buf_cnt = read(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
		}
		else
		{
			retval = check_pending(connection, 1, NULL);
			if (retval != ERROR_OK)
				return retval;
			gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
		}
177

178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
		if (gdb_con->buf_cnt > 0)
		{
			break;
		}
		if (gdb_con->buf_cnt == 0)
		{
			gdb_con->closed = 1;
			return ERROR_SERVER_REMOTE_CLOSED;
		}

#ifdef _WIN32
		errno = WSAGetLastError();

		switch(errno)
		{
			case WSAEWOULDBLOCK:
				usleep(1000);
				break;
			case WSAECONNABORTED:
197
				gdb_con->closed = 1;
198
199
				return ERROR_SERVER_REMOTE_CLOSED;
			case WSAECONNRESET:
200
				gdb_con->closed = 1;
201
202
				return ERROR_SERVER_REMOTE_CLOSED;
			default:
203
				LOG_ERROR("read: %d", errno);
204
205
206
207
208
209
210
211
212
				exit(-1);
		}
#else
		switch(errno)
		{
			case EAGAIN:
				usleep(1000);
				break;
			case ECONNABORTED:
213
				gdb_con->closed = 1;
214
215
				return ERROR_SERVER_REMOTE_CLOSED;
			case ECONNRESET:
216
				gdb_con->closed = 1;
217
218
				return ERROR_SERVER_REMOTE_CLOSED;
			default:
219
				LOG_ERROR("read: %s", strerror(errno));
220
				gdb_con->closed = 1;
221
222
223
224
225
226
227
228
229
				return ERROR_SERVER_REMOTE_CLOSED;
		}
#endif
	}

#ifdef _DEBUG_GDB_IO_
	debug_buffer = malloc(gdb_con->buf_cnt + 1);
	memcpy(debug_buffer, gdb_con->buffer, gdb_con->buf_cnt);
	debug_buffer[gdb_con->buf_cnt] = 0;
230
	LOG_DEBUG("received '%s'", debug_buffer);
231
232
233
234
235
236
237
238
239
	free(debug_buffer);
#endif

	gdb_con->buf_p = gdb_con->buffer;
	gdb_con->buf_cnt--;
	*next_char = *(gdb_con->buf_p++);
	if (gdb_con->buf_cnt > 0)
		connection->input_pending = 1;
	else
ntfreak's avatar
ntfreak committed
240
		connection->input_pending = 0;
241
#ifdef _DEBUG_GDB_IO_
242
	LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
243
244
#endif

245
	return retval;
246
247
248
249
250
251
252
253
254
255
256
257
258
}

int gdb_putback_char(connection_t *connection, int last_char)
{
	gdb_connection_t *gdb_con = connection->priv;

	if (gdb_con->buf_p > gdb_con->buffer)
	{
		*(--gdb_con->buf_p) = last_char;
		gdb_con->buf_cnt++;
	}
	else
	{
259
		LOG_ERROR("BUG: couldn't put character back");
260
261
262
263
264
265
266
267
268
269
270
271
272
	}

	return ERROR_OK;
}

/* The only way we can detect that the socket is closed is the first time
 * we write to it, we will fail. Subsequent write operations will
 * succeed. Shudder! */
int gdb_write(connection_t *connection, void *data, int len)
{
	gdb_connection_t *gdb_con = connection->priv;
	if (gdb_con->closed)
		return ERROR_SERVER_REMOTE_CLOSED;
273

274
	if (connection->service->type == CONNECTION_PIPE)
275
	{
276
277
278
279
280
281
282
283
284
285
286
287
		/* write to stdout */
		if (write(STDOUT_FILENO, data, len) == len)
		{
			return ERROR_OK;
		}
	}
	else
	{
		if (write_socket(connection->fd, data, len) == len)
		{
			return ERROR_OK;
		}
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
	}
	gdb_con->closed = 1;
	return ERROR_SERVER_REMOTE_CLOSED;
}

int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
{
	int i;
	unsigned char my_checksum = 0;
#ifdef _DEBUG_GDB_IO_
	char *debug_buffer;
#endif
	int reply;
	int retval;
	gdb_connection_t *gdb_con = connection->priv;

	for (i = 0; i < len; i++)
		my_checksum += buffer[i];

307
#ifdef _DEBUG_GDB_IO_
308
	/*
309
310
311
312
313
314
315
316
317
318
319
320
321
	 * At this point we should have nothing in the input queue from GDB,
	 * however sometimes '-' is sent even though we've already received
	 * an ACK (+) for everything we've sent off.
	 */
	int gotdata;
	for (;;)
	{
		if ((retval=check_pending(connection, 0, &gotdata))!=ERROR_OK)
			return retval;
		if (!gotdata)
			break;
		if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
			return retval;
ntfreak's avatar
ntfreak committed
322
		if( reply == '$' ){
323
			/* fix a problem with some IAR tools */
324
325
326
327
328
			gdb_putback_char( connection, reply );
			LOG_DEBUG("Unexpected start of new packet");
			break;
		}

329
		LOG_WARNING("Discard unexpected char %c", reply);
330
331
332
	}
#endif

333
334
335
336
337
338
	while (1)
	{
#ifdef _DEBUG_GDB_IO_
		debug_buffer = malloc(len + 1);
		memcpy(debug_buffer, buffer, len);
		debug_buffer[len] = 0;
339
		LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer, my_checksum);
340
341
		free(debug_buffer);
#endif
ntfreak's avatar
ntfreak committed
342

343
344
		char local_buffer[1024];
		local_buffer[0] = '$';
345
		if ((size_t)len + 4 <= sizeof(local_buffer))
346
		{
347
348
349
350
351
			/* performance gain on smaller packets by only a single call to gdb_write() */
			memcpy(local_buffer+1, buffer, len++);
			local_buffer[len++] = '#';
			local_buffer[len++] = DIGITS[(my_checksum >> 4) & 0xf];
			local_buffer[len++] = DIGITS[my_checksum & 0xf];
352
353
354
355
			if((retval = gdb_write(connection, local_buffer, len)) != ERROR_OK)
			{
				return retval;
			}
356
		}
357
		else
358
		{
359
360
361
362
363
			/* larger packets are transmitted directly from caller supplied buffer
			   by several calls to gdb_write() to avoid dynamic allocation */
			local_buffer[1] = '#';
			local_buffer[2] = DIGITS[(my_checksum >> 4) & 0xf];
			local_buffer[3] = DIGITS[my_checksum & 0xf];
364
365
366
367
368
369
370
371
372
373
374
375
			if((retval = gdb_write(connection, local_buffer, 1)) != ERROR_OK)
			{
				return retval;
			}
			if((retval = gdb_write(connection, buffer, len)) != ERROR_OK)
			{
				return retval;
			}
			if((retval = gdb_write(connection, local_buffer+1, 3)) != ERROR_OK)
			{
				return retval;
			}
376
		}
377

378
379
		if (gdb_con->noack_mode)
			break;
380

381
382
383
384
385
386
387
388
389
		if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
			return retval;

		if (reply == '+')
			break;
		else if (reply == '-')
		{
			/* Stop sending output packets for now */
			log_remove_callback(gdb_log_callback, connection);
390
			LOG_WARNING("negative reply, retrying");
391
392
393
394
395
396
397
398
399
400
401
402
		}
		else if (reply == 0x3)
		{
			gdb_con->ctrl_c = 1;
			if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
				return retval;
			if (reply == '+')
				break;
			else if (reply == '-')
			{
				/* Stop sending output packets for now */
				log_remove_callback(gdb_log_callback, connection);
403
				LOG_WARNING("negative reply, retrying");
404
			}
405
406
407
408
409
			else if( reply == '$' ){
				LOG_ERROR("GDB missing ack(1) - assumed good");
				gdb_putback_char( connection, reply );
				return ERROR_OK;
			} else {
oharboe's avatar
oharboe committed
410

411
				LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply);
412
				gdb_con->closed=1;
413
414
				return ERROR_SERVER_REMOTE_CLOSED;
			}
oharboe's avatar
oharboe committed
415
		}
416
417
418
419
		else if( reply == '$' ){
			LOG_ERROR("GDB missing ack(2) - assumed good");
			gdb_putback_char( connection, reply );
			return ERROR_OK;
oharboe's avatar
oharboe committed
420
		}
421
422
		else
		{
423
			LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply);
424
			gdb_con->closed=1;
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
			return ERROR_SERVER_REMOTE_CLOSED;
		}
	}
	if (gdb_con->closed)
		return ERROR_SERVER_REMOTE_CLOSED;

	return ERROR_OK;
}

int gdb_put_packet(connection_t *connection, char *buffer, int len)
{
	gdb_connection_t *gdb_con = connection->priv;
	gdb_con->busy = 1;
	int retval = gdb_put_packet_inner(connection, buffer, len);
	gdb_con->busy = 0;
440
441
442
443

	/* we sent some data, reset timer for keep alive messages */
	kept_alive();

444
445
446
	return retval;
}

oharboe's avatar
oharboe committed
447
static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, int noack, int *len, char *buffer)
448
{
oharboe's avatar
oharboe committed
449
450
	unsigned char my_checksum = 0;
	char checksum[3];
451
	int character;
oharboe's avatar
oharboe committed
452
	int retval;
453

oharboe's avatar
oharboe committed
454
455
	gdb_connection_t *gdb_con = connection->priv;
	my_checksum = 0;
456
	int count = 0;
oharboe's avatar
oharboe committed
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
	count = 0;
	for (;;)
	{
		/* The common case is that we have an entire packet with no escape chars.
		 * We need to leave at least 2 bytes in the buffer to have
		 * gdb_get_char() update various bits and bobs correctly.
		 */
		if ((gdb_con->buf_cnt > 2) && ((gdb_con->buf_cnt+count) < *len))
		{
			/* The compiler will struggle a bit with constant propagation and
			 * aliasing, so we help it by showing that these values do not
			 * change inside the loop
			 */
			int i;
			char *buf = gdb_con->buf_p;
			int run = gdb_con->buf_cnt - 2;
			i = 0;
			int done = 0;
			while (i < run)
			{
				character = *buf++;
				i++;
				if (character == '#')
				{
					/* Danger! character can be '#' when esc is
					 * used so we need an explicit boolean for done here.
					 */
					done = 1;
					break;
				}

				if (character == '}')
				{
					/* data transmitted in binary mode (X packet)
					 * uses 0x7d as escape character */
					my_checksum += character & 0xff;
					character = *buf++;
					i++;
					my_checksum += character & 0xff;
					buffer[count++] = (character ^ 0x20) & 0xff;
				}
				else
				{
					my_checksum += character & 0xff;
					buffer[count++] = character & 0xff;
				}
			}
			gdb_con->buf_p += i;
			gdb_con->buf_cnt -= i;
			if (done)
				break;
		}
		if (count > *len)
		{
			LOG_ERROR("packet buffer too small");
			return ERROR_GDB_BUFFER_TOO_SMALL;
		}

		if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
			return retval;

		if (character == '#')
			break;

		if (character == '}')
		{
			/* data transmitted in binary mode (X packet)
			 * uses 0x7d as escape character */
			my_checksum += character & 0xff;
			if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
				return retval;
			my_checksum += character & 0xff;
			buffer[count++] = (character ^ 0x20) & 0xff;
		}
		else
		{
			my_checksum += character & 0xff;
			buffer[count++] = character & 0xff;
		}
	}

	*len = count;

	if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
		return retval;
	checksum[0] = character;
	if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
		return retval;
	checksum[1] = character;
	checksum[2] = 0;
547

oharboe's avatar
oharboe committed
548
549
550
551
	if (!noack)
	{
		*checksum_ok=(my_checksum == strtoul(checksum, NULL, 16));
	}
552

oharboe's avatar
oharboe committed
553
554
555
556
557
558
	return ERROR_OK;
}

int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
{
	int character;
559
560
561
562
563
564
565
566
567
568
569
	int retval;
	gdb_connection_t *gdb_con = connection->priv;

	while (1)
	{
		do
		{
			if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
				return retval;

#ifdef _DEBUG_GDB_IO_
570
			LOG_DEBUG("character: '%c'", character);
571
572
573
574
575
576
577
#endif

			switch (character)
			{
				case '$':
					break;
				case '+':
578
579
					/* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
					 * incase anyone tries to debug why they receive this warning every time */
580
					LOG_WARNING("acknowledgment received, but no packet pending");
581
582
					break;
				case '-':
583
					LOG_WARNING("negative acknowledgment, but no packet pending");
584
585
586
587
588
589
					break;
				case 0x3:
					gdb_con->ctrl_c = 1;
					*len = 0;
					return ERROR_OK;
				default:
590
					LOG_WARNING("ignoring character 0x%x", character);
591
592
593
594
					break;
			}
		} while (character != '$');

ntfreak's avatar
ntfreak committed
595
596


597
		int checksum_ok = 0;
oharboe's avatar
oharboe committed
598
599
600
601
602
603
		/* explicit code expansion here to get faster inlined code in -O3 by not
		 * calculating checksum
		 */
		if (gdb_con->noack_mode)
		{
			if ((retval=fetch_packet(connection, &checksum_ok, 1, len, buffer))!=ERROR_OK)
604
				return retval;
oharboe's avatar
oharboe committed
605
		} else
606
		{
oharboe's avatar
oharboe committed
607
608
			if ((retval=fetch_packet(connection, &checksum_ok, 0, len, buffer))!=ERROR_OK)
				return retval;
609
610
		}

oharboe's avatar
oharboe committed
611
		if (gdb_con->noack_mode)
612
		{
oharboe's avatar
oharboe committed
613
614
			/* checksum is not checked in noack mode */
			break;
615
		}
oharboe's avatar
oharboe committed
616
		if (checksum_ok)
617
		{
618
619
620
621
			if ((retval = gdb_write(connection, "+", 1)) != ERROR_OK)
			{
				return retval;
			}
622
623
			break;
		}
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
	}
	if (gdb_con->closed)
		return ERROR_SERVER_REMOTE_CLOSED;

	return ERROR_OK;
}

int gdb_get_packet(connection_t *connection, char *buffer, int *len)
{
	gdb_connection_t *gdb_con = connection->priv;
	gdb_con->busy = 1;
	int retval = gdb_get_packet_inner(connection, buffer, len);
	gdb_con->busy = 0;
	return retval;
}
ntfreak's avatar
ntfreak committed
639

640
int gdb_output_con(connection_t *connection, const char* line)
641
642
643
644
645
646
{
	char *hex_buffer;
	int i, bin_size;

	bin_size = strlen(line);

647
	hex_buffer = malloc(bin_size*2 + 2);
648
649
	if (hex_buffer == NULL)
		return ERROR_GDB_BUFFER_TOO_SMALL;
650
651
652
653

	hex_buffer[0] = 'O';
	for (i=0; i<bin_size; i++)
		snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);
654
	hex_buffer[bin_size*2+1] = 0;
655

656
	int retval = gdb_put_packet(connection, hex_buffer, bin_size*2 + 1);
657
658

	free(hex_buffer);
659
	return retval;
660
661
}

oharboe's avatar
oharboe committed
662
int gdb_output(struct command_context_s *context, const char* line)
663
664
{
	/* this will be dumped to the log and also sent as an O packet if possible */
665
	LOG_USER_N("%s", line);
666
667
668
669
	return ERROR_OK;
}


670
671
672
static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
{
	gdb_connection_t *gdb_connection = connection->priv;
673

674
675
676
677
678
679
680
681
682
683
684
685
686
	/* In the GDB protocol when we are stepping or coninuing execution,
	 * we have a lingering reply. Upon receiving a halted event
	 * when we have that lingering packet, we reply to the original
	 * step or continue packet.
	 *
	 * Executing monitor commands can bring the target in and
	 * out of the running state so we'll see lots of TARGET_EVENT_XXX
	 * that are to be ignored.
	 */
	if (gdb_connection->frontend_state == TARGET_RUNNING)
	{
		char sig_reply[4];
		int signal;
687

688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
		/* stop forwarding log packets! */
		log_remove_callback(gdb_log_callback, connection);

		if (gdb_connection->ctrl_c)
		{
			signal = 0x2;
			gdb_connection->ctrl_c = 0;
		}
		else
		{
			signal = gdb_last_signal(target);
		}

		snprintf(sig_reply, 4, "T%2.2x", signal);
		gdb_put_packet(connection, sig_reply, 3);
		gdb_connection->frontend_state = TARGET_HALTED;
	}
}

707
708
int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
{
709
	int retval;
710
711
	connection_t *connection = priv;

712
	target_handle_event( target, event );
713
714
	switch (event)
	{
715
		case TARGET_EVENT_EARLY_HALTED:
716
			gdb_frontend_halted(target, connection);
717
			break;
718
719
720
		case TARGET_EVENT_HALTED:
			target_call_event_callbacks(target, TARGET_EVENT_GDB_END);
			break;
721
		case TARGET_EVENT_GDB_FLASH_ERASE_START:
722
			target_handle_event( target, TARGET_EVENT_OLD_gdb_program_config );
723
724
725
726
			if((retval = jtag_execute_queue()) != ERROR_OK)
			{
				return retval;
			}
727
728
729
730
731
732
733
			break;
		default:
			break;
	}

	return ERROR_OK;
}
ntfreak's avatar
ntfreak committed
734

735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
int gdb_new_connection(connection_t *connection)
{
	gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));
	gdb_service_t *gdb_service = connection->service->priv;
	int retval;
	int initial_ack;

	connection->priv = gdb_connection;

	/* initialize gdb connection information */
	gdb_connection->buf_p = gdb_connection->buffer;
	gdb_connection->buf_cnt = 0;
	gdb_connection->ctrl_c = 0;
	gdb_connection->frontend_state = TARGET_HALTED;
	gdb_connection->vflash_image = NULL;
	gdb_connection->closed = 0;
	gdb_connection->busy = 0;
752
	gdb_connection->noack_mode = 0;
753

754
755
	/* send ACK to GDB for debug request */
	gdb_write(connection, "+", 1);
ntfreak's avatar
ntfreak committed
756

757
758
759
	/* output goes through gdb connection */
	command_set_output_handler(connection->cmd_ctx, gdb_output, connection);

760
	/* we must remove all breakpoints registered to the target as a previous
761
	 * GDB session could leave dangling breakpoints if e.g. communication
762
763
764
765
	 * timed out.
	 */
	breakpoint_clear_target(gdb_service->target);
	watchpoint_clear_target(gdb_service->target);
766

767
	/* register callback to be informed about target events */
ntfreak's avatar
ntfreak committed
768
	target_register_event_callback(gdb_target_callback_event_handler, connection);
769

770
	/* a gdb session just attached, try to put the target in halt mode.
771
772
773
	 *
	 * DANGER!!!!
	 *
774
775
776
777
	 * If the halt fails(e.g. target needs a reset, JTAG communication not
	 * working, etc.), then the GDB connect will succeed as
	 * the get_gdb_reg_list() will lie and return a register list with
	 * dummy values.
778
	 *
779
780
	 * This allows GDB monitor commands to be run from a GDB init script to
	 * initialize the target
781
	 *
782
783
	 * Also, since the halt() is asynchronous target connect will be
	 * instantaneous and thus avoiding annoying timeout problems during
784
	 * connect.
785
	 */
786
	target_halt(gdb_service->target);
787
	/* FIX!!!! could extended-remote work better here?
788
	 *
789
	 *  wait a tiny bit for halted state or we just continue. The
790
	 * GDB register packet will then contain garbage
791
792
	 */
	target_wait_state(gdb_service->target, TARGET_HALTED, 500);
793

794
795
796
797
	/* remove the initial ACK from the incoming buffer */
	if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
		return retval;

798
	/* FIX!!!??? would we actually ever receive a + here???
799
800
	 * Not observed.
	 */
801
802
	if (initial_ack != '+')
		gdb_putback_char(connection, initial_ack);
803
	target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH );
kc8apf's avatar
kc8apf committed
804
805
806

	gdb_actual_connections++;

807
808
809
	return ERROR_OK;
}

ntfreak's avatar
ntfreak committed
810
int gdb_connection_closed(connection_t *connection)
811
812
813
814
{
	gdb_service_t *gdb_service = connection->service->priv;
	gdb_connection_t *gdb_connection = connection->priv;

kc8apf's avatar
kc8apf committed
815
816
	gdb_actual_connections--;

817
818
819
820
821
822
823
824
825
826
	/* see if an image built with vFlash commands is left */
	if (gdb_connection->vflash_image)
	{
		image_close(gdb_connection->vflash_image);
		free(gdb_connection->vflash_image);
		gdb_connection->vflash_image = NULL;
	}

	/* if this connection registered a debug-message receiver delete it */
	delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
ntfreak's avatar
ntfreak committed
827

828
829
830
831
832
833
834
	if (connection->priv)
	{
		free(connection->priv);
		connection->priv = NULL;
	}
	else
	{
835
		LOG_ERROR("BUG: connection->priv == NULL");
836
837
838
	}

	target_unregister_event_callback(gdb_target_callback_event_handler, connection);
839
	target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_END);
840
841
	log_remove_callback(gdb_log_callback, connection);

842
	target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH );
ntfreak's avatar
ntfreak committed
843
844

	return ERROR_OK;
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
}

void gdb_send_error(connection_t *connection, u8 the_error)
{
	char err[4];
	snprintf(err, 4, "E%2.2X", the_error );
	gdb_put_packet(connection, err, 3);
}

int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
	char sig_reply[4];
	int signal;

	signal = gdb_last_signal(target);

	snprintf(sig_reply, 4, "S%2.2x", signal);
	gdb_put_packet(connection, sig_reply, 3);

	return ERROR_OK;
}

867
868
869
870
871
872
873
874
875
static int gdb_reg_pos(target_t *target, int pos, int len)
{
	if (target->endianness == TARGET_LITTLE_ENDIAN)
		return pos;
	else
		return len - 1 - pos;
}

/* Convert register to string of bytes. NB! The # of bits in the
876
 * register might be non-divisible by 8(a byte), in which
877
878
879
880
881
882
883
 * case an entire byte is shown.
 *
 * NB! the format on the wire is the target endianess
 *
 * The format of reg->value is little endian
 *
 */
884
885
886
887
888
889
890
void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
{
	int i;

	u8 *buf;
	int buf_len;
	buf = reg->value;
ntfreak's avatar
ntfreak committed
891
	buf_len = CEIL(reg->size, 8);
892

oharboe's avatar
   
oharboe committed
893
	for (i = 0; i < buf_len; i++)
894
	{
895
896
897
		int j = gdb_reg_pos(target, i, buf_len);
		tstr[i*2]   = DIGITS[(buf[j]>>4) & 0xf];
		tstr[i*2+1] = DIGITS[buf[j]&0xf];
ntfreak's avatar
ntfreak committed
898
	}
899
900
}

901
static int hextoint(char c)
902
{
903
904
905
906
907
908
909
910
911
912
913
914
	if (c>='0'&&c<='9')
	{
		return c-'0';
	}
	c=toupper(c);
	if (c>='A'&&c<='F')
	{
		return c-'A'+10;
	}
	LOG_ERROR("BUG: invalid register value %08x", c);
	return 0;
}
915

916
917
918
/* copy over in register buffer */
void gdb_target_to_reg(target_t *target, char *tstr, int str_len, u8 *bin)
{
919
920
	if (str_len % 2)
	{
921
		LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
922
923
924
		exit(-1);
	}

925
	int i;
oharboe's avatar
   
oharboe committed
926
	for (i = 0; i < str_len; i+=2)
927
	{
928
		u8 t = hextoint(tstr[i])<<4;
929
		t |= hextoint(tstr[i+1]);
930
931
932

		int j = gdb_reg_pos(target, i/2, str_len/2);
		bin[j] = t;
ntfreak's avatar
ntfreak committed
933
	}
934
935
936
937
938
939
940
941
942
943
944
945
946
}

int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
	reg_t **reg_list;
	int reg_list_size;
	int retval;
	int reg_packet_size = 0;
	char *reg_packet;
	char *reg_packet_p;
	int i;

#ifdef _DEBUG_GDB_IO_
947
	LOG_DEBUG("-");
948
949
#endif

zwelch's avatar
zwelch committed
950
	if ((retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
951
	{
952
		return gdb_error(connection, retval);
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
	}

	for (i = 0; i < reg_list_size; i++)
	{
		reg_packet_size += reg_list[i]->size;
	}

	reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
	reg_packet_p = reg_packet;

	for (i = 0; i < reg_list_size; i++)
	{
		gdb_str_to_target(target, reg_packet_p, reg_list[i]);
		reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
	}

#ifdef _DEBUG_GDB_IO_
	{
		char *reg_packet_p;
		reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
973
		LOG_DEBUG("reg_packet: %s", reg_packet_p);
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
		free(reg_packet_p);
	}
#endif

	gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
	free(reg_packet);

	free(reg_list);

	return ERROR_OK;
}

int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
	int i;
	reg_t **reg_list;
	int reg_list_size;
	int retval;
	char *packet_p;

#ifdef _DEBUG_GDB_IO_
995
	LOG_DEBUG("-");
996
997
998
999
1000
#endif

	/* skip command character */
	packet++;
	packet_size--;
For faster browsing, not all history is shown. View entire blame