gdb_server.c 49.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/***************************************************************************
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
 *                                                                         *
 *   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.             *
 ***************************************************************************/
20
#ifdef HAVE_CONFIG_H
21
#include "config.h"
22
23
24
#endif

#include "replacements.h"
25

26
27
28
29
30
#include "gdb_server.h"

#include "server.h"
#include "log.h"
#include "binarybuffer.h"
31
#include "jtag.h"
32
#include "breakpoints.h"
33
34
#include "flash.h"
#include "target_request.h"
35
#include "configuration.h"
36
37
38
39
40
41

#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>

42
#if 0
43
44
45
46
#define _DEBUG_GDB_IO_
#endif

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
51
		const char *function, const char *format, va_list args);

52
53
54
55
56
57
58
59
enum gdb_detach_mode
{
	GDB_DETACH_RESUME,
	GDB_DETACH_RESET,
	GDB_DETACH_HALT,
	GDB_DETACH_NOTHING
};

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

63
64
65
66
67
/* set if we are sending a memory map to gdb
 * via qXfer:memory-map:read packet */
int gdb_use_memory_map = 0;
int gdb_flash_program = 0;

68
69
70
71
/* 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;

72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
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:
			ERROR("BUG: undefined debug reason");
			exit(-1);
	}
}

int gdb_get_char(connection_t *connection, int* next_char)
{
	gdb_connection_t *gdb_con = connection->priv;
95
96

#ifdef _DEBUG_GDB_IO_
97
	char *debug_buffer;
98
#endif
99

100
101
102
103
104
105
106
	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;
107

108
109
110
#ifdef _DEBUG_GDB_IO_
		DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
#endif
111

112
113
114
		return ERROR_OK;
	}

115
	for (;;)
116
	{
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#ifndef _WIN32
		/* 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;
		
		FD_ZERO(&read_fds);
		FD_SET(connection->fd, &read_fds);
		
		tv.tv_sec = 1;
		tv.tv_usec = 0;
		if (select(connection->fd + 1, &read_fds, NULL, NULL, &tv) == 0)
		{
			/* This can typically be because a "monitor" command took too long
			 * before printing any progress messages
			 */
			return ERROR_GDB_TIMEOUT; 
		}
#endif
		gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
		if (gdb_con->buf_cnt > 0)
		{
			break;
		}
142
		if (gdb_con->buf_cnt == 0)
143
144
		{
			gdb_con->closed = 1;
145
			return ERROR_SERVER_REMOTE_CLOSED;
146
		}
147

148
149
150
151
152
153
154
155
156
157
#ifdef _WIN32
		errno = WSAGetLastError();

		switch(errno)
		{
			case WSAEWOULDBLOCK:
				usleep(1000);
				break;
			case WSAECONNABORTED:
				return ERROR_SERVER_REMOTE_CLOSED;
158
159
			case WSAECONNRESET:
				return ERROR_SERVER_REMOTE_CLOSED;
160
			default:
161
				ERROR("read: %d", errno);
162
163
164
				exit(-1);
		}
#else
165
166
167
168
169
170
171
172
173
174
175
		switch(errno)
		{
			case EAGAIN:
				usleep(1000);
				break;
			case ECONNABORTED:
				return ERROR_SERVER_REMOTE_CLOSED;
			case ECONNRESET:
				return ERROR_SERVER_REMOTE_CLOSED;
			default:
				ERROR("read: %s", strerror(errno));
176
				return ERROR_SERVER_REMOTE_CLOSED;
177
		}
178
#endif
179
	}
180

181
#ifdef _DEBUG_GDB_IO_
182
183
184
185
186
	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;
	DEBUG("received '%s'", debug_buffer);
	free(debug_buffer);
187
#endif
188
189
190
191
192
193
194
195
196

	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
		connection->input_pending = 0;	
#ifdef _DEBUG_GDB_IO_
197
	DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
198
#endif
199

200
201
202
	return ERROR_OK;
}

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

207
208
209
210
211
212
213
214
215
	if (gdb_con->buf_p > gdb_con->buffer)
	{
		*(--gdb_con->buf_p) = last_char;
		gdb_con->buf_cnt++;
	}
	else
	{
		ERROR("BUG: couldn't put character back"); 	
	}
216

217
218
219
	return ERROR_OK;
}

220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
/* 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;

	if (write_socket(connection->fd, data, len) == len)
	{
		return ERROR_OK;
	}
	gdb_con->closed = 1;
	return ERROR_SERVER_REMOTE_CLOSED;
}

237
int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
238
239
240
{
	int i;
	unsigned char my_checksum = 0;
241
#ifdef _DEBUG_GDB_IO_
242
	char *debug_buffer;
243
#endif
244
245
246
247
248
249
	int reply;
	int retval;
	gdb_connection_t *gdb_con = connection->priv;

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

251
252
	while (1)
	{
253
#ifdef _DEBUG_GDB_IO_
254
255
256
257
258
		debug_buffer = malloc(len + 1);
		memcpy(debug_buffer, buffer, len);
		debug_buffer[len] = 0;
		DEBUG("sending packet '$%s#%2.2x'", debug_buffer, my_checksum);
		free(debug_buffer);
259
#endif
260
261
262
#if 0
		char checksum[3];
		gdb_write(connection, "$", 1);
263
		if (len > 0)
264
265
266
			gdb_write(connection, buffer, len);
		gdb_write(connection, "#", 1);
		
267
		snprintf(checksum, 3, "%2.2x", my_checksum);
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
		
		gdb_write(connection, checksum, 2);
#else
		void *allocated = NULL;
		char stackAlloc[1024];
		char *t = stackAlloc;
		int totalLen = 1 + len + 1 + 2;
		if (totalLen > sizeof(stackAlloc))
		{
			allocated = malloc(totalLen);
			t = allocated;
			if (allocated == NULL)
			{
				ERROR("Ran out of memory trying to reply packet %d\n", totalLen);
				exit(-1);
			}
		}
		t[0] = '$';
		memcpy(t + 1, buffer, len);
		t[1 + len] = '#';
		t[1 + len + 1] = DIGITS[(my_checksum >> 4) & 0xf];
		t[1 + len + 2] = DIGITS[my_checksum & 0xf];
		
		gdb_write(connection, t, totalLen);
		
		if (allocated)
		{
			free(allocated);
		}
#endif
298
299
300
301
302
303
		if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
			return retval;

		if (reply == '+')
			break;
		else if (reply == '-')
304
305
306
		{
			/* Stop sending output packets for now */
			log_setCallback(NULL, NULL);
307
			WARNING("negative reply, retrying");
308
		}
309
310
311
312
313
314
315
316
		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 == '-')
317
318
319
			{
				/* Stop sending output packets for now */
				log_setCallback(NULL, NULL);
320
				WARNING("negative reply, retrying");
321
			}
322
323
324
325
326
327
328
329
330
331
332
333
			else
			{
				ERROR("unknown character 0x%2.2x in reply, dropping connection", reply);
				return ERROR_SERVER_REMOTE_CLOSED;
			}
		}
		else
		{
			ERROR("unknown character 0x%2.2x in reply, dropping connection", reply);
			return ERROR_SERVER_REMOTE_CLOSED;
		}
	}
334
335
	if (gdb_con->closed)
		return ERROR_SERVER_REMOTE_CLOSED;
336

337
338
339
	return ERROR_OK;
}

340
341
int gdb_put_packet(connection_t *connection, char *buffer, int len)
{
342
343
344
345
	gdb_connection_t *gdb_con = connection->priv;
	gdb_con->busy = 1;
	int retval = gdb_put_packet_inner(connection, buffer, len);
	gdb_con->busy = 0;
346
347
348
349
	return retval;
}

int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
350
351
{
	int character;
352
	int count = 0;
353
354
355
356
357
358
359
360
361
362
363
364
	int retval;
	char checksum[3];
	unsigned char my_checksum = 0;
	gdb_connection_t *gdb_con = connection->priv;

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

365
#ifdef _DEBUG_GDB_IO_
366
			DEBUG("character: '%c'", character);
367
#endif
368

369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
			switch (character)
			{
				case '$':
					break;
				case '+':
					WARNING("acknowledgment received, but no packet pending");
					break;
				case '-':
					WARNING("negative acknowledgment, but no packet pending");
					break;
				case 0x3:
					gdb_con->ctrl_c = 1;
					*len = 0;
					return ERROR_OK;
				default:
					WARNING("ignoring character 0x%x", character);
					break;
			}
		} while (character != '$');

		my_checksum = 0;
390
		
391
		count = 0;
392
		gdb_connection_t *gdb_con = connection->priv;
393
		for (;;)
394
		{
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
			/* 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)
			{
				ERROR("packet buffer too small");
				return ERROR_GDB_BUFFER_TOO_SMALL;
			}
			
449
450
			if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
				return retval;
451

452
453
			if (character == '#')
				break;
454
455

			if (character == '}')
456
			{
457
				/* data transmitted in binary mode (X packet)
458
				 * uses 0x7d as escape character */
459
460
461
462
463
				my_checksum += character & 0xff;
				if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
					return retval;
				my_checksum += character & 0xff;
				buffer[count++] = (character ^ 0x20) & 0xff;
464
465
466
			}
			else
			{
467
468
469
470
				my_checksum += character & 0xff;
				buffer[count++] = character & 0xff;
			}

471
		}
472
473

		*len = count;
474

475
476
477
478
479
480
481
		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;
482

483
484
		if (my_checksum == strtoul(checksum, NULL, 16))
		{
485
			gdb_write(connection, "+", 1);
486
487
488
489
			break;
		}

		WARNING("checksum error, requesting retransmission");
490
		gdb_write(connection, "-", 1);
491
	}
492
493
	if (gdb_con->closed)
		return ERROR_SERVER_REMOTE_CLOSED;
494
495
496
497

	return ERROR_OK;
}

498
int gdb_get_packet(connection_t *connection, char *buffer, int *len)
499
{
500
501
502
503
	gdb_connection_t *gdb_con = connection->priv;
	gdb_con->busy = 1;
	int retval = gdb_get_packet_inner(connection, buffer, len);
	gdb_con->busy = 0;
504
505
	return retval;
}
506
	
507
508
int gdb_output_con(connection_t *connection, char* line)
{
509
510
511
512
	char *hex_buffer;
	int i, bin_size;

	bin_size = strlen(line);
513

514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
	hex_buffer = malloc(bin_size*2 + 4);

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

	gdb_put_packet(connection, hex_buffer, bin_size*2 + 3);

	free(hex_buffer);
	return ERROR_OK;
}

529
530
int gdb_output(struct command_context_s *context, char* line)
{
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
537
538
539
540
541
542
int gdb_program_handler(struct target_s *target, enum target_event event, void *priv)
{
	FILE *script;
	struct command_context_s *cmd_ctx = priv;
	
	if (target->gdb_program_script)
	{
543
		script = open_file_from_path(cmd_ctx, target->gdb_program_script, "r");
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
		if (!script)
		{
			ERROR("couldn't open script file %s", target->gdb_program_script);
				return ERROR_OK;
		}

		INFO("executing gdb_program script '%s'", target->gdb_program_script);
		command_run_file(cmd_ctx, script, COMMAND_EXEC);
		fclose(script);
		
		jtag_execute_queue();
	}
	
	return ERROR_OK;
}

560
561
562
563
564
565
int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
{
	connection_t *connection = priv;
	gdb_connection_t *gdb_connection = connection->priv;
	char sig_reply[4];
	int signal;
566

567
568
569
	switch (event)
	{
		case TARGET_EVENT_HALTED:
570
571
572
573
574
575
576
577
578
			/* 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.
			 */
579
580
			if (gdb_connection->frontend_state == TARGET_RUNNING)
			{
581
				/* stop forwarding log packets! */
582
583
				log_setCallback(NULL, NULL);
				
584
585
586
587
588
589
590
591
592
				if (gdb_connection->ctrl_c)
				{
					signal = 0x2;
					gdb_connection->ctrl_c = 0;
				}
				else
				{
					signal = gdb_last_signal(target);
				}
593

594
595
596
597
598
				snprintf(sig_reply, 4, "T%2.2x", signal);
				gdb_put_packet(connection, sig_reply, 3);
				gdb_connection->frontend_state = TARGET_HALTED;
			}
			break;
599
600
601
		case TARGET_EVENT_GDB_PROGRAM:
			gdb_program_handler(target, event, connection->cmd_ctx);
			break;
602
603
604
605
606
607
608
609
610
611
612
613
614
		default:
			break;
	}

	return ERROR_OK;
}

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;
615

616
	connection->priv = gdb_connection;
617

618
619
620
621
622
	/* 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;
623
	gdb_connection->vflash_image = NULL;
624
625
	gdb_connection->closed = 0;
	gdb_connection->busy = 0;
626
	
627
628
	/* output goes through gdb connection */
	command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
629

630
631
	/* register callback to be informed about target events */
	target_register_event_callback(gdb_target_callback_event_handler, connection);	
632

633
634
	/* a gdb session just attached, put the target in halt mode */
	if (((retval = gdb_service->target->type->halt(gdb_service->target)) != ERROR_OK) &&
635
			(retval != ERROR_TARGET_ALREADY_HALTED))
636
	{
637
638
		ERROR("error(%d) when trying to halt target, falling back to \"reset halt\"", retval);
		command_run_line(connection->cmd_ctx, "reset halt");
639
	}
640

641
642
	/* This will time out after 1 second */
	command_run_line(connection->cmd_ctx, "wait_halt 1");
643

644
645
646
	/* remove the initial ACK from the incoming buffer */
	if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
		return retval;
647

648
649
	if (initial_ack != '+')
		gdb_putback_char(connection, initial_ack);
650

651
652
653
654
655
	return ERROR_OK;
}

int gdb_connection_closed(connection_t *connection)
{
656
657
658
659
660
661
662
663
664
665
666
667
668
669
	gdb_service_t *gdb_service = connection->service->priv;
	gdb_connection_t *gdb_connection = connection->priv;

	/* 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);
	
670
	if (connection->priv)
671
	{
672
		free(connection->priv);
673
674
		connection->priv = NULL;
	}
675
	else
676
	{
677
		ERROR("BUG: connection->priv == NULL");
678
	}
679

680
681
682
683
684
	target_unregister_event_callback(gdb_target_callback_event_handler, connection);

	return ERROR_OK;
}

685
686
void gdb_send_error(connection_t *connection, u8 the_error)
{
687
688
689
	char err[4];
	snprintf(err, 4, "E%2.2X", the_error );
	gdb_put_packet(connection, err, 3);
690
691
}

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

697
698
699
700
	signal = gdb_last_signal(target);

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

702
703
704
	return ERROR_OK;
}

705
706
707
708
/* Convert register to string of bits. NB! The # of bits in the
 * register might be non-divisible by 8(a byte), in which
 * case an entire byte is shown. */
void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
709
710
{
	int i;
711

712
713
714
715
	u8 *buf;
	int buf_len;
	buf = reg->value;
	buf_len = CEIL(reg->size, 8); 
716

717
718
	if (target->endianness == TARGET_LITTLE_ENDIAN)
	{
719
		for (i = 0; i < buf_len; i++)
720
		{
721
722
			tstr[i*2]   = DIGITS[(buf[i]>>4) & 0xf];
			tstr[i*2+1] = DIGITS[buf[i]&0xf];
723
724
725
726
		}
	}
	else
	{
727
		for (i = 0; i < buf_len; i++)
728
		{
729
730
			tstr[(buf_len-1-i)*2]   = DIGITS[(buf[i]>>4)&0xf];
			tstr[(buf_len-1-i)*2+1] = DIGITS[buf[i]&0xf];
731
732
733
734
735
736
737
738
739
740
741
742
743
744
		}
	}	
}

void gdb_target_to_str(target_t *target, char *tstr, char *str)
{
	int str_len = strlen(tstr);
	int i;

	if (str_len % 2)
	{
		ERROR("BUG: gdb value with uneven number of characters encountered");
		exit(-1);
	}
745

746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
	if (target->endianness == TARGET_LITTLE_ENDIAN)
	{
		for (i = 0; i < str_len; i+=2)
		{
			str[str_len - i - 1] = tstr[i + 1];
			str[str_len - i - 2] = tstr[i];
		}
	}
	else
	{
		for (i = 0; i < str_len; i++)
		{
			str[i] = tstr[i];
		}
	}	
}

int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
764
765
766
767
768
769
770
771
{
	reg_t **reg_list;
	int reg_list_size;
	int retval;
	int reg_packet_size = 0;
	char *reg_packet;
	char *reg_packet_p;
	int i;
772

773
#ifdef _DEBUG_GDB_IO_
774
	DEBUG("-");
775
#endif
776
777
778
779
780
781

	if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
	{
		switch (retval)
		{
			case ERROR_TARGET_NOT_HALTED:
782
783
				ERROR("gdb requested registers but we're not halted, dropping connection");
				return ERROR_SERVER_REMOTE_CLOSED;
784
			default:
785
				/* this is a bug condition - get_gdb_reg_list() may not return any other error */
786
787
788
789
790
791
792
793
794
				ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
				exit(-1);
		}
	}

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

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

799
800
	for (i = 0; i < reg_list_size; i++)
	{
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
806
807
808
809
810
811
812
#ifdef _DEBUG_GDB_IO_
	{
		char *reg_packet_p;
		reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
		DEBUG("reg_packet: %s", reg_packet_p);
		free(reg_packet_p);
	}
#endif
813

814
815
	gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
	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
825
826
827
828
{
	int i;
	reg_t **reg_list;
	int reg_list_size;
	int retval;
	char *packet_p;
829

830
#ifdef _DEBUG_GDB_IO_
831
	DEBUG("-");
832
#endif
833
834
835
836
837
838
839

	/* skip command character */
	packet++;
	packet_size--;

	if (packet_size % 2)
	{
840
841
		WARNING("GDB set_registers packet with uneven characters received, dropping connection");
		return ERROR_SERVER_REMOTE_CLOSED;
842
843
844
845
846
847
848
	}

	if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
	{
		switch (retval)
		{
			case ERROR_TARGET_NOT_HALTED:
849
850
				ERROR("gdb tried to registers but we're not halted, dropping connection");
				return ERROR_SERVER_REMOTE_CLOSED;
851
			default:
852
				/* this is a bug condition - get_gdb_reg_list() may not return any other error */
853
854
855
856
857
858
859
860
				ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
				exit(-1);
		}
	}

	packet_p = packet;
	for (i = 0; i < reg_list_size; i++)
	{
861
862
863
		u8 *bin_buf;
		char *hex_buf;
		reg_arch_type_t *arch_type;
864

865
866
867
		/* convert from GDB-string (target-endian) to hex-string (big-endian) */
		hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2);
		gdb_target_to_str(target, packet_p, hex_buf);
868

869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
		/* convert hex-string to binary buffer */
		bin_buf = malloc(CEIL(reg_list[i]->size, 8));
		str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16);

		/* get register arch_type, and call set method */	
		arch_type = register_get_arch_type(reg_list[i]->arch_type);
		if (arch_type == NULL)
		{
			ERROR("BUG: encountered unregistered arch type");
			exit(-1);
		}
		arch_type->set(reg_list[i], bin_buf);

		/* advance packet pointer */		
		packet_p += (CEIL(reg_list[i]->size, 8) * 2);
884

885
886
		free(bin_buf);
		free(hex_buf);
887
	}
888

889
890
	/* free reg_t *reg_list[] array allocated by get_gdb_reg_list */ 
	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
900
901
902
903
{
	char *reg_packet;
	int reg_num = strtoul(packet + 1, NULL, 16);
	reg_t **reg_list;
	int reg_list_size;
	int retval;
904

905
#ifdef _DEBUG_GDB_IO_
906
	DEBUG("-");
907
#endif
908

909
910
911
912
913
	if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
	{
		switch (retval)
		{
			case ERROR_TARGET_NOT_HALTED:
914
915
				ERROR("gdb requested registers but we're not halted, dropping connection");
				return ERROR_SERVER_REMOTE_CLOSED;
916
			default:
917
				/* this is a bug condition - get_gdb_reg_list() may not return any other error */
918
919
920
921
				ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
				exit(-1);
		}
	}
922

923
924
925
926
927
928
	if (reg_list_size <= reg_num)
	{
		ERROR("gdb requested a non-existing register");
		exit(-1);
	}

929
930
	reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);

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
945
	char *hex_buf;
	u8 *bin_buf;
946
947
948
949
	int reg_num = strtoul(packet + 1, &separator, 16);
	reg_t **reg_list;
	int reg_list_size;
	int retval;
950
	reg_arch_type_t *arch_type;
951

952
	DEBUG("-");
953

954
955
956
957
958
	if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
	{
		switch (retval)
		{
			case ERROR_TARGET_NOT_HALTED:
959
960
				ERROR("gdb tried to set a register but we're not halted, dropping connection");
				return ERROR_SERVER_REMOTE_CLOSED;
961
			default:
962
				/* this is a bug condition - get_gdb_reg_list() may not return any other error */
963
964
965
966
				ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
				exit(-1);
		}
	}
967

968
969
970
	if (reg_list_size < reg_num)
	{
		ERROR("gdb requested a non-existing register");
971
		return ERROR_SERVER_REMOTE_CLOSED;
972
973
974
975
	}

	if (*separator != '=')
	{
976
977
		ERROR("GDB 'set register packet', but no '=' following the register number");
		return ERROR_SERVER_REMOTE_CLOSED;
978
	}
979

980
981
982
	/* convert from GDB-string (target-endian) to hex-string (big-endian) */
	hex_buf = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
	gdb_target_to_str(target, separator + 1, hex_buf);
983

984
985
986
987
988
989
990
991
992
993
994
995
	/* convert hex-string to binary buffer */
	bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
	str_to_buf(hex_buf, CEIL(reg_list[reg_num]->size, 8) * 2, bin_buf, reg_list[reg_num]->size, 16);

	/* get register arch_type, and call set method */	
	arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
	if (arch_type == NULL)
	{
		ERROR("BUG: encountered unregistered arch type");
		exit(-1);
	}
	arch_type->set(reg_list[reg_num], bin_buf);
996
997
998

	gdb_put_packet(connection, "OK", 2);

999
1000
	free(bin_buf);
	free(hex_buf);
For faster browsing, not all history is shown. View entire blame