]>
Commit | Line | Data |
---|---|---|
4a5b6a35 WD |
1 | /* |
2 | * taken from gdb/remote.c | |
3 | * | |
4 | * I am only interested in the write to memory stuff - everything else | |
5 | * has been ripped out | |
6 | * | |
7 | * all the copyright notices etc have been left in | |
8 | */ | |
9 | ||
10 | /* enough so that it will compile */ | |
11 | #include <stdio.h> | |
12 | #include <stdlib.h> | |
13 | #include <string.h> | |
14 | #include <errno.h> | |
15 | ||
16 | /*nicked from gcc..*/ | |
17 | ||
18 | #ifndef alloca | |
19 | #ifdef __GNUC__ | |
20 | #define alloca __builtin_alloca | |
21 | #else /* not GNU C. */ | |
22 | #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) | |
23 | #include <alloca.h> | |
24 | #else /* not sparc */ | |
25 | #if defined (MSDOS) && !defined (__TURBOC__) | |
26 | #include <malloc.h> | |
27 | #else /* not MSDOS, or __TURBOC__ */ | |
28 | #if defined(_AIX) | |
29 | #include <malloc.h> | |
30 | #pragma alloca | |
31 | #else /* not MSDOS, __TURBOC__, or _AIX */ | |
32 | #ifdef __hpux | |
33 | #endif /* __hpux */ | |
34 | #endif /* not _AIX */ | |
35 | #endif /* not MSDOS, or __TURBOC__ */ | |
36 | #endif /* not sparc. */ | |
37 | #endif /* not GNU C. */ | |
38 | #ifdef __cplusplus | |
39 | extern "C" { | |
40 | #endif | |
41 | void* alloca(size_t); | |
42 | #ifdef __cplusplus | |
43 | } | |
44 | #endif | |
45 | #endif /* alloca not defined. */ | |
46 | ||
47 | ||
48 | #include "serial.h" | |
49 | #include "error.h" | |
50 | #include "remote.h" | |
51 | #define REGISTER_BYTES 0 | |
52 | #define fprintf_unfiltered fprintf | |
53 | #define fprintf_filtered fprintf | |
54 | #define fputs_unfiltered fputs | |
55 | #define fputs_filtered fputs | |
56 | #define fputc_unfiltered fputc | |
57 | #define fputc_filtered fputc | |
58 | #define printf_unfiltered printf | |
59 | #define printf_filtered printf | |
60 | #define puts_unfiltered puts | |
61 | #define puts_filtered puts | |
62 | #define putchar_unfiltered putchar | |
63 | #define putchar_filtered putchar | |
64 | #define fputstr_unfiltered(a,b,c) fputs((a), (c)) | |
65 | #define gdb_stdlog stderr | |
66 | #define SERIAL_READCHAR(fd,timo) serialreadchar((fd), (timo)) | |
67 | #define SERIAL_WRITE(fd, addr, len) serialwrite((fd), (addr), (len)) | |
68 | #define error Error | |
69 | #define perror_with_name Perror | |
70 | #define gdb_flush fflush | |
71 | #define max(a,b) (((a)>(b))?(a):(b)) | |
72 | #define min(a,b) (((a)<(b))?(a):(b)) | |
73 | #define target_mourn_inferior() {} | |
74 | #define ULONGEST unsigned long | |
75 | #define CORE_ADDR unsigned long | |
76 | ||
77 | static int putpkt (char *); | |
78 | static int putpkt_binary(char *, int); | |
79 | static void getpkt (char *, int); | |
80 | ||
81 | static int remote_debug = 0, remote_register_buf_size = 0, watchdog = 0; | |
82 | ||
83 | int remote_desc = -1, remote_timeout = 10; | |
84 | ||
85 | static void | |
86 | fputstrn_unfiltered(char *s, int n, int x, FILE *fp) | |
87 | { | |
88 | while (n-- > 0) | |
89 | fputc(*s++, fp); | |
90 | } | |
91 | ||
92 | void | |
93 | remote_reset(void) | |
94 | { | |
95 | SERIAL_WRITE(remote_desc, "+", 1); | |
96 | } | |
97 | ||
98 | void | |
99 | remote_continue(void) | |
100 | { | |
101 | putpkt("c"); | |
102 | } | |
103 | ||
104 | /* Remote target communications for serial-line targets in custom GDB protocol | |
105 | Copyright 1988, 91, 92, 93, 94, 95, 96, 97, 98, 1999 | |
106 | Free Software Foundation, Inc. | |
107 | ||
108 | This file is part of GDB. | |
109 | ||
110 | This program is free software; you can redistribute it and/or modify | |
111 | it under the terms of the GNU General Public License as published by | |
112 | the Free Software Foundation; either version 2 of the License, or | |
113 | (at your option) any later version. | |
114 | ||
115 | This program is distributed in the hope that it will be useful, | |
116 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
117 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
118 | GNU General Public License for more details. | |
119 | ||
120 | You should have received a copy of the GNU General Public License | |
121 | along with this program; if not, write to the Free Software | |
122 | Foundation, Inc., 59 Temple Place - Suite 330, | |
123 | Boston, MA 02111-1307, USA. */ | |
124 | /* *INDENT-OFF* */ | |
125 | /* Remote communication protocol. | |
126 | ||
127 | A debug packet whose contents are <data> | |
128 | is encapsulated for transmission in the form: | |
129 | ||
130 | $ <data> # CSUM1 CSUM2 | |
131 | ||
132 | <data> must be ASCII alphanumeric and cannot include characters | |
133 | '$' or '#'. If <data> starts with two characters followed by | |
134 | ':', then the existing stubs interpret this as a sequence number. | |
135 | ||
136 | CSUM1 and CSUM2 are ascii hex representation of an 8-bit | |
137 | checksum of <data>, the most significant nibble is sent first. | |
138 | the hex digits 0-9,a-f are used. | |
139 | ||
140 | Receiver responds with: | |
141 | ||
142 | + - if CSUM is correct and ready for next packet | |
143 | - - if CSUM is incorrect | |
144 | ||
145 | <data> is as follows: | |
146 | Most values are encoded in ascii hex digits. Signal numbers are according | |
147 | to the numbering in target.h. | |
148 | ||
149 | Request Packet | |
150 | ||
151 | set thread Hct... Set thread for subsequent operations. | |
152 | c = 'c' for thread used in step and | |
153 | continue; t... can be -1 for all | |
154 | threads. | |
155 | c = 'g' for thread used in other | |
156 | operations. If zero, pick a thread, | |
157 | any thread. | |
158 | reply OK for success | |
159 | ENN for an error. | |
160 | ||
161 | read registers g | |
162 | reply XX....X Each byte of register data | |
163 | is described by two hex digits. | |
164 | Registers are in the internal order | |
165 | for GDB, and the bytes in a register | |
166 | are in the same order the machine uses. | |
167 | or ENN for an error. | |
168 | ||
169 | write regs GXX..XX Each byte of register data | |
170 | is described by two hex digits. | |
171 | reply OK for success | |
172 | ENN for an error | |
173 | ||
8bde7f77 | 174 | write reg Pn...=r... Write register n... with value r..., |
4a5b6a35 WD |
175 | which contains two hex digits for each |
176 | byte in the register (target byte | |
177 | order). | |
178 | reply OK for success | |
179 | ENN for an error | |
180 | (not supported by all stubs). | |
181 | ||
182 | read mem mAA..AA,LLLL AA..AA is address, LLLL is length. | |
183 | reply XX..XX XX..XX is mem contents | |
184 | Can be fewer bytes than requested | |
185 | if able to read only part of the data. | |
186 | or ENN NN is errno | |
187 | ||
188 | write mem MAA..AA,LLLL:XX..XX | |
189 | AA..AA is address, | |
190 | LLLL is number of bytes, | |
191 | XX..XX is data | |
192 | reply OK for success | |
193 | ENN for an error (this includes the case | |
194 | where only part of the data was | |
195 | written). | |
196 | ||
8bde7f77 WD |
197 | write mem XAA..AA,LLLL:XX..XX |
198 | (binary) AA..AA is address, | |
199 | LLLL is number of bytes, | |
200 | XX..XX is binary data | |
201 | reply OK for success | |
202 | ENN for an error | |
4a5b6a35 WD |
203 | |
204 | continue cAA..AA AA..AA is address to resume | |
205 | If AA..AA is omitted, | |
206 | resume at same address. | |
207 | ||
208 | step sAA..AA AA..AA is address to resume | |
209 | If AA..AA is omitted, | |
210 | resume at same address. | |
211 | ||
212 | continue with Csig;AA..AA Continue with signal sig (hex signal | |
213 | signal number). If ;AA..AA is omitted, | |
214 | resume at same address. | |
215 | ||
216 | step with Ssig;AA..AA Like 'C' but step not continue. | |
217 | signal | |
218 | ||
219 | last signal ? Reply the current reason for stopping. | |
8bde7f77 | 220 | This is the same reply as is generated |
4a5b6a35 WD |
221 | for step or cont : SAA where AA is the |
222 | signal number. | |
223 | ||
224 | detach D Reply OK. | |
225 | ||
226 | There is no immediate reply to step or cont. | |
227 | The reply comes when the machine stops. | |
228 | It is SAA AA is the signal number. | |
229 | ||
230 | or... TAAn...:r...;n...:r...;n...:r...; | |
231 | AA = signal number | |
232 | n... = register number (hex) | |
233 | r... = register contents | |
234 | n... = `thread' | |
235 | r... = thread process ID. This is | |
236 | a hex integer. | |
237 | n... = other string not starting | |
238 | with valid hex digit. | |
239 | gdb should ignore this n,r pair | |
240 | and go on to the next. This way | |
241 | we can extend the protocol. | |
242 | or... WAA The process exited, and AA is | |
243 | the exit status. This is only | |
244 | applicable for certains sorts of | |
245 | targets. | |
246 | or... XAA The process terminated with signal | |
247 | AA. | |
248 | or (obsolete) NAA;tttttttt;dddddddd;bbbbbbbb | |
249 | AA = signal number | |
250 | tttttttt = address of symbol "_start" | |
251 | dddddddd = base of data section | |
252 | bbbbbbbb = base of bss section. | |
253 | Note: only used by Cisco Systems | |
254 | targets. The difference between this | |
255 | reply and the "qOffsets" query is that | |
256 | the 'N' packet may arrive spontaneously | |
257 | whereas the 'qOffsets' is a query | |
258 | initiated by the host debugger. | |
8bde7f77 | 259 | or... OXX..XX XX..XX is hex encoding of ASCII data. This |
4a5b6a35 WD |
260 | can happen at any time while the |
261 | program is running and the debugger | |
262 | should continue to wait for | |
263 | 'W', 'T', etc. | |
264 | ||
265 | thread alive TXX Find out if the thread XX is alive. | |
266 | reply OK thread is still alive | |
267 | ENN thread is dead | |
268 | ||
269 | remote restart RXX Restart the remote server | |
270 | ||
53677ef1 | 271 | extended ops ! Use the extended remote protocol. |
4a5b6a35 WD |
272 | Sticky -- only needs to be set once. |
273 | ||
274 | kill request k | |
275 | ||
276 | toggle debug d toggle debug flag (see 386 & 68k stubs) | |
277 | reset r reset -- see sparc stub. | |
278 | reserved <other> On other requests, the stub should | |
279 | ignore the request and send an empty | |
280 | response ($#<checksum>). This way | |
281 | we can extend the protocol and GDB | |
282 | can tell whether the stub it is | |
283 | talking to uses the old or the new. | |
284 | search tAA:PP,MM Search backwards starting at address | |
285 | AA for a match with pattern PP and | |
286 | mask MM. PP and MM are 4 bytes. | |
287 | Not supported by all stubs. | |
288 | ||
289 | general query qXXXX Request info about XXXX. | |
290 | general set QXXXX=yyyy Set value of XXXX to yyyy. | |
291 | query sect offs qOffsets Get section offsets. Reply is | |
292 | Text=xxx;Data=yyy;Bss=zzz | |
293 | ||
294 | Responses can be run-length encoded to save space. A '*' means that | |
295 | the next character is an ASCII encoding giving a repeat count which | |
296 | stands for that many repititions of the character preceding the '*'. | |
297 | The encoding is n+29, yielding a printable character where n >=3 | |
298 | (which is where rle starts to win). Don't use an n > 126. | |
299 | ||
300 | So | |
301 | "0* " means the same as "0000". */ | |
302 | /* *INDENT-ON* */ | |
303 | ||
304 | /* This variable (available to the user via "set remotebinarydownload") | |
305 | dictates whether downloads are sent in binary (via the 'X' packet). | |
306 | We assume that the stub can, and attempt to do it. This will be cleared if | |
307 | the stub does not understand it. This switch is still needed, though | |
308 | in cases when the packet is supported in the stub, but the connection | |
309 | does not allow it (i.e., 7-bit serial connection only). */ | |
310 | static int remote_binary_download = 1; | |
311 | ||
312 | /* Have we already checked whether binary downloads work? */ | |
313 | static int remote_binary_checked; | |
314 | ||
315 | /* Maximum number of bytes to read/write at once. The value here | |
316 | is chosen to fill up a packet (the headers account for the 32). */ | |
317 | #define MAXBUFBYTES(N) (((N)-32)/2) | |
318 | ||
319 | /* Having this larger than 400 causes us to be incompatible with m68k-stub.c | |
320 | and i386-stub.c. Normally, no one would notice because it only matters | |
321 | for writing large chunks of memory (e.g. in downloads). Also, this needs | |
322 | to be more than 400 if required to hold the registers (see below, where | |
323 | we round it up based on REGISTER_BYTES). */ | |
324 | /* Round up PBUFSIZ to hold all the registers, at least. */ | |
325 | #define PBUFSIZ ((REGISTER_BYTES > MAXBUFBYTES (400)) \ | |
326 | ? (REGISTER_BYTES * 2 + 32) \ | |
327 | : 400) | |
328 | ||
329 | ||
330 | /* This variable sets the number of bytes to be written to the target | |
331 | in a single packet. Normally PBUFSIZ is satisfactory, but some | |
332 | targets need smaller values (perhaps because the receiving end | |
333 | is slow). */ | |
334 | ||
335 | static int remote_write_size = 0x7fffffff; | |
336 | ||
337 | /* This variable sets the number of bits in an address that are to be | |
338 | sent in a memory ("M" or "m") packet. Normally, after stripping | |
339 | leading zeros, the entire address would be sent. This variable | |
340 | restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The | |
341 | initial implementation of remote.c restricted the address sent in | |
342 | memory packets to ``host::sizeof long'' bytes - (typically 32 | |
343 | bits). Consequently, for 64 bit targets, the upper 32 bits of an | |
344 | address was never sent. Since fixing this bug may cause a break in | |
345 | some remote targets this variable is principly provided to | |
346 | facilitate backward compatibility. */ | |
347 | ||
348 | static int remote_address_size; | |
349 | ||
350 | /* Convert hex digit A to a number. */ | |
351 | ||
352 | static int | |
353 | fromhex (int a) | |
354 | { | |
355 | if (a >= '0' && a <= '9') | |
356 | return a - '0'; | |
357 | else if (a >= 'a' && a <= 'f') | |
358 | return a - 'a' + 10; | |
359 | else if (a >= 'A' && a <= 'F') | |
360 | return a - 'A' + 10; | |
361 | else { | |
362 | error ("Reply contains invalid hex digit %d", a); | |
363 | return -1; | |
364 | } | |
365 | } | |
366 | ||
367 | /* Convert number NIB to a hex digit. */ | |
368 | ||
369 | static int | |
370 | tohex (int nib) | |
371 | { | |
372 | if (nib < 10) | |
373 | return '0' + nib; | |
374 | else | |
375 | return 'a' + nib - 10; | |
376 | } | |
377 | ||
378 | /* Return the number of hex digits in num. */ | |
379 | ||
380 | static int | |
381 | hexnumlen (ULONGEST num) | |
382 | { | |
383 | int i; | |
384 | ||
385 | for (i = 0; num != 0; i++) | |
386 | num >>= 4; | |
387 | ||
388 | return max (i, 1); | |
389 | } | |
390 | ||
391 | /* Set BUF to the hex digits representing NUM. */ | |
392 | ||
393 | static int | |
394 | hexnumstr (char *buf, ULONGEST num) | |
395 | { | |
396 | int i; | |
397 | int len = hexnumlen (num); | |
398 | ||
399 | buf[len] = '\0'; | |
400 | ||
401 | for (i = len - 1; i >= 0; i--) | |
402 | { | |
403 | buf[i] = "0123456789abcdef"[(num & 0xf)]; | |
404 | num >>= 4; | |
405 | } | |
406 | ||
407 | return len; | |
408 | } | |
409 | ||
410 | /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */ | |
411 | ||
412 | static CORE_ADDR | |
413 | remote_address_masked (CORE_ADDR addr) | |
414 | { | |
415 | if (remote_address_size > 0 | |
416 | && remote_address_size < (sizeof (ULONGEST) * 8)) | |
417 | { | |
418 | /* Only create a mask when that mask can safely be constructed | |
8bde7f77 | 419 | in a ULONGEST variable. */ |
4a5b6a35 WD |
420 | ULONGEST mask = 1; |
421 | mask = (mask << remote_address_size) - 1; | |
422 | addr &= mask; | |
423 | } | |
424 | return addr; | |
425 | } | |
426 | ||
427 | /* Determine whether the remote target supports binary downloading. | |
428 | This is accomplished by sending a no-op memory write of zero length | |
429 | to the target at the specified address. It does not suffice to send | |
430 | the whole packet, since many stubs strip the eighth bit and subsequently | |
431 | compute a wrong checksum, which causes real havoc with remote_write_bytes. | |
432 | ||
433 | NOTE: This can still lose if the serial line is not eight-bit clean. In | |
434 | cases like this, the user should clear "remotebinarydownload". */ | |
435 | static void | |
436 | check_binary_download (CORE_ADDR addr) | |
437 | { | |
438 | if (remote_binary_download && !remote_binary_checked) | |
439 | { | |
440 | char *buf = alloca (PBUFSIZ); | |
441 | char *p; | |
442 | remote_binary_checked = 1; | |
443 | ||
444 | p = buf; | |
445 | *p++ = 'X'; | |
446 | p += hexnumstr (p, (ULONGEST) addr); | |
447 | *p++ = ','; | |
448 | p += hexnumstr (p, (ULONGEST) 0); | |
449 | *p++ = ':'; | |
450 | *p = '\0'; | |
451 | ||
452 | putpkt_binary (buf, (int) (p - buf)); | |
453 | getpkt (buf, 0); | |
454 | ||
455 | if (buf[0] == '\0') | |
456 | remote_binary_download = 0; | |
457 | } | |
458 | ||
459 | if (remote_debug) | |
460 | { | |
461 | if (remote_binary_download) | |
462 | fprintf_unfiltered (gdb_stdlog, | |
463 | "binary downloading suppported by target\n"); | |
464 | else | |
465 | fprintf_unfiltered (gdb_stdlog, | |
466 | "binary downloading NOT suppported by target\n"); | |
467 | } | |
468 | } | |
469 | ||
470 | /* Write memory data directly to the remote machine. | |
471 | This does not inform the data cache; the data cache uses this. | |
472 | MEMADDR is the address in the remote memory space. | |
473 | MYADDR is the address of the buffer in our space. | |
474 | LEN is the number of bytes. | |
475 | ||
476 | Returns number of bytes transferred, or 0 for error. */ | |
477 | ||
478 | int | |
479 | remote_write_bytes (memaddr, myaddr, len) | |
480 | CORE_ADDR memaddr; | |
481 | char *myaddr; | |
482 | int len; | |
483 | { | |
484 | unsigned char *buf = alloca (PBUFSIZ); | |
485 | int max_buf_size; /* Max size of packet output buffer */ | |
486 | int origlen; | |
487 | extern int verbose; | |
488 | ||
489 | /* Verify that the target can support a binary download */ | |
490 | check_binary_download (memaddr); | |
491 | ||
492 | /* Chop the transfer down if necessary */ | |
493 | ||
494 | max_buf_size = min (remote_write_size, PBUFSIZ); | |
495 | if (remote_register_buf_size != 0) | |
496 | max_buf_size = min (max_buf_size, remote_register_buf_size); | |
497 | ||
498 | /* Subtract header overhead from max payload size - $M<memaddr>,<len>:#nn */ | |
499 | max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4; | |
500 | ||
501 | origlen = len; | |
502 | while (len > 0) | |
503 | { | |
504 | unsigned char *p, *plen; | |
505 | int todo; | |
506 | int i; | |
507 | ||
508 | /* construct "M"<memaddr>","<len>":" */ | |
509 | /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */ | |
510 | memaddr = remote_address_masked (memaddr); | |
511 | p = buf; | |
512 | if (remote_binary_download) | |
513 | { | |
514 | *p++ = 'X'; | |
515 | todo = min (len, max_buf_size); | |
516 | } | |
517 | else | |
518 | { | |
519 | *p++ = 'M'; | |
520 | todo = min (len, max_buf_size / 2); /* num bytes that will fit */ | |
521 | } | |
522 | ||
523 | p += hexnumstr ((char *)p, (ULONGEST) memaddr); | |
524 | *p++ = ','; | |
525 | ||
526 | plen = p; /* remember where len field goes */ | |
527 | p += hexnumstr ((char *)p, (ULONGEST) todo); | |
528 | *p++ = ':'; | |
529 | *p = '\0'; | |
530 | ||
531 | /* We send target system values byte by byte, in increasing byte | |
8bde7f77 WD |
532 | addresses, each byte encoded as two hex characters (or one |
533 | binary character). */ | |
4a5b6a35 WD |
534 | if (remote_binary_download) |
535 | { | |
536 | int escaped = 0; | |
537 | for (i = 0; | |
538 | (i < todo) && (i + escaped) < (max_buf_size - 2); | |
539 | i++) | |
540 | { | |
541 | switch (myaddr[i] & 0xff) | |
542 | { | |
543 | case '$': | |
544 | case '#': | |
545 | case 0x7d: | |
546 | /* These must be escaped */ | |
547 | escaped++; | |
548 | *p++ = 0x7d; | |
549 | *p++ = (myaddr[i] & 0xff) ^ 0x20; | |
550 | break; | |
551 | default: | |
552 | *p++ = myaddr[i] & 0xff; | |
553 | break; | |
554 | } | |
555 | } | |
556 | ||
557 | if (i < todo) | |
558 | { | |
559 | /* Escape chars have filled up the buffer prematurely, | |
8bde7f77 WD |
560 | and we have actually sent fewer bytes than planned. |
561 | Fix-up the length field of the packet. */ | |
4a5b6a35 WD |
562 | |
563 | /* FIXME: will fail if new len is a shorter string than | |
8bde7f77 | 564 | old len. */ |
4a5b6a35 WD |
565 | |
566 | plen += hexnumstr ((char *)plen, (ULONGEST) i); | |
567 | *plen++ = ':'; | |
568 | } | |
569 | } | |
570 | else | |
571 | { | |
572 | for (i = 0; i < todo; i++) | |
573 | { | |
574 | *p++ = tohex ((myaddr[i] >> 4) & 0xf); | |
575 | *p++ = tohex (myaddr[i] & 0xf); | |
576 | } | |
577 | *p = '\0'; | |
578 | } | |
579 | ||
580 | putpkt_binary ((char *)buf, (int) (p - buf)); | |
581 | getpkt ((char *)buf, 0); | |
582 | ||
583 | if (buf[0] == 'E') | |
584 | { | |
585 | /* There is no correspondance between what the remote protocol uses | |
586 | for errors and errno codes. We would like a cleaner way of | |
587 | representing errors (big enough to include errno codes, bfd_error | |
588 | codes, and others). But for now just return EIO. */ | |
589 | errno = EIO; | |
590 | return 0; | |
591 | } | |
592 | ||
593 | /* Increment by i, not by todo, in case escape chars | |
8bde7f77 | 594 | caused us to send fewer bytes than we'd planned. */ |
4a5b6a35 WD |
595 | myaddr += i; |
596 | memaddr += i; | |
597 | len -= i; | |
598 | ||
599 | if (verbose) | |
600 | putc('.', stderr); | |
601 | } | |
602 | return origlen; | |
603 | } | |
604 | ||
605 | /* Stuff for dealing with the packets which are part of this protocol. | |
606 | See comment at top of file for details. */ | |
607 | ||
608 | /* Read a single character from the remote end, masking it down to 7 bits. */ | |
609 | ||
610 | static int | |
611 | readchar (int timeout) | |
612 | { | |
613 | int ch; | |
614 | ||
615 | ch = SERIAL_READCHAR (remote_desc, timeout); | |
616 | ||
617 | switch (ch) | |
618 | { | |
619 | case SERIAL_EOF: | |
620 | error ("Remote connection closed"); | |
621 | case SERIAL_ERROR: | |
622 | perror_with_name ("Remote communication error"); | |
623 | case SERIAL_TIMEOUT: | |
624 | return ch; | |
625 | default: | |
626 | return ch & 0x7f; | |
627 | } | |
628 | } | |
629 | ||
630 | static int | |
631 | putpkt (buf) | |
632 | char *buf; | |
633 | { | |
634 | return putpkt_binary (buf, strlen (buf)); | |
635 | } | |
636 | ||
637 | /* Send a packet to the remote machine, with error checking. The data | |
638 | of the packet is in BUF. The string in BUF can be at most PBUFSIZ - 5 | |
639 | to account for the $, # and checksum, and for a possible /0 if we are | |
640 | debugging (remote_debug) and want to print the sent packet as a string */ | |
641 | ||
642 | static int | |
643 | putpkt_binary (buf, cnt) | |
644 | char *buf; | |
645 | int cnt; | |
646 | { | |
647 | int i; | |
648 | unsigned char csum = 0; | |
649 | char *buf2 = alloca (PBUFSIZ); | |
650 | char *junkbuf = alloca (PBUFSIZ); | |
651 | ||
652 | int ch; | |
653 | int tcount = 0; | |
654 | char *p; | |
655 | ||
656 | /* Copy the packet into buffer BUF2, encapsulating it | |
657 | and giving it a checksum. */ | |
658 | ||
659 | if (cnt > BUFSIZ - 5) /* Prosanity check */ | |
660 | abort (); | |
661 | ||
662 | p = buf2; | |
663 | *p++ = '$'; | |
664 | ||
665 | for (i = 0; i < cnt; i++) | |
666 | { | |
667 | csum += buf[i]; | |
668 | *p++ = buf[i]; | |
669 | } | |
670 | *p++ = '#'; | |
671 | *p++ = tohex ((csum >> 4) & 0xf); | |
672 | *p++ = tohex (csum & 0xf); | |
673 | ||
674 | /* Send it over and over until we get a positive ack. */ | |
675 | ||
676 | while (1) | |
677 | { | |
678 | int started_error_output = 0; | |
679 | ||
680 | if (remote_debug) | |
681 | { | |
682 | *p = '\0'; | |
683 | fprintf_unfiltered (gdb_stdlog, "Sending packet: "); | |
684 | fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog); | |
685 | fprintf_unfiltered (gdb_stdlog, "..."); | |
686 | gdb_flush (gdb_stdlog); | |
687 | } | |
688 | if (SERIAL_WRITE (remote_desc, buf2, p - buf2)) | |
689 | perror_with_name ("putpkt: write failed"); | |
690 | ||
691 | /* read until either a timeout occurs (-2) or '+' is read */ | |
692 | while (1) | |
693 | { | |
694 | ch = readchar (remote_timeout); | |
695 | ||
696 | if (remote_debug) | |
697 | { | |
698 | switch (ch) | |
699 | { | |
700 | case '+': | |
701 | case SERIAL_TIMEOUT: | |
702 | case '$': | |
703 | if (started_error_output) | |
704 | { | |
705 | putchar_unfiltered ('\n'); | |
706 | started_error_output = 0; | |
707 | } | |
708 | } | |
709 | } | |
710 | ||
711 | switch (ch) | |
712 | { | |
713 | case '+': | |
714 | if (remote_debug) | |
715 | fprintf_unfiltered (gdb_stdlog, "Ack\n"); | |
716 | return 1; | |
717 | case SERIAL_TIMEOUT: | |
718 | tcount++; | |
719 | if (tcount > 3) | |
720 | return 0; | |
721 | break; /* Retransmit buffer */ | |
722 | case '$': | |
723 | { | |
724 | /* It's probably an old response, and we're out of sync. | |
725 | Just gobble up the packet and ignore it. */ | |
726 | getpkt (junkbuf, 0); | |
727 | continue; /* Now, go look for + */ | |
728 | } | |
729 | default: | |
730 | if (remote_debug) | |
731 | { | |
732 | if (!started_error_output) | |
733 | { | |
734 | started_error_output = 1; | |
735 | fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); | |
736 | } | |
737 | fputc_unfiltered (ch & 0177, gdb_stdlog); | |
738 | } | |
739 | continue; | |
740 | } | |
741 | break; /* Here to retransmit */ | |
742 | } | |
743 | ||
744 | #if 0 | |
745 | /* This is wrong. If doing a long backtrace, the user should be | |
8bde7f77 WD |
746 | able to get out next time we call QUIT, without anything as |
747 | violent as interrupt_query. If we want to provide a way out of | |
748 | here without getting to the next QUIT, it should be based on | |
749 | hitting ^C twice as in remote_wait. */ | |
4a5b6a35 WD |
750 | if (quit_flag) |
751 | { | |
752 | quit_flag = 0; | |
753 | interrupt_query (); | |
754 | } | |
755 | #endif | |
756 | } | |
757 | } | |
758 | ||
759 | /* Come here after finding the start of the frame. Collect the rest | |
760 | into BUF, verifying the checksum, length, and handling run-length | |
761 | compression. Returns 0 on any error, 1 on success. */ | |
762 | ||
763 | static int | |
764 | read_frame (char *buf) | |
765 | { | |
766 | unsigned char csum; | |
767 | char *bp; | |
768 | int c; | |
769 | ||
770 | csum = 0; | |
771 | bp = buf; | |
772 | ||
773 | while (1) | |
774 | { | |
775 | c = readchar (remote_timeout); | |
776 | ||
777 | switch (c) | |
778 | { | |
779 | case SERIAL_TIMEOUT: | |
780 | if (remote_debug) | |
781 | fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog); | |
782 | return 0; | |
783 | case '$': | |
784 | if (remote_debug) | |
785 | fputs_filtered ("Saw new packet start in middle of old one\n", | |
786 | gdb_stdlog); | |
787 | return 0; /* Start a new packet, count retries */ | |
788 | case '#': | |
789 | { | |
790 | unsigned char pktcsum; | |
791 | ||
792 | *bp = '\000'; | |
793 | ||
794 | pktcsum = fromhex (readchar (remote_timeout)) << 4; | |
795 | pktcsum |= fromhex (readchar (remote_timeout)); | |
796 | ||
797 | if (csum == pktcsum) | |
798 | { | |
799 | return 1; | |
800 | } | |
801 | ||
802 | if (remote_debug) | |
803 | { | |
804 | fprintf_filtered (gdb_stdlog, | |
805 | "Bad checksum, sentsum=0x%x, csum=0x%x, buf=", | |
806 | pktcsum, csum); | |
807 | fputs_filtered (buf, gdb_stdlog); | |
808 | fputs_filtered ("\n", gdb_stdlog); | |
809 | } | |
810 | return 0; | |
811 | } | |
812 | case '*': /* Run length encoding */ | |
813 | csum += c; | |
814 | c = readchar (remote_timeout); | |
815 | csum += c; | |
816 | c = c - ' ' + 3; /* Compute repeat count */ | |
817 | ||
818 | if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1) | |
819 | { | |
820 | memset (bp, *(bp - 1), c); | |
821 | bp += c; | |
822 | continue; | |
823 | } | |
824 | ||
825 | *bp = '\0'; | |
826 | printf_filtered ("Repeat count %d too large for buffer: ", c); | |
827 | puts_filtered (buf); | |
828 | puts_filtered ("\n"); | |
829 | return 0; | |
830 | default: | |
831 | if (bp < buf + PBUFSIZ - 1) | |
832 | { | |
833 | *bp++ = c; | |
834 | csum += c; | |
835 | continue; | |
836 | } | |
837 | ||
838 | *bp = '\0'; | |
839 | puts_filtered ("Remote packet too long: "); | |
840 | puts_filtered (buf); | |
841 | puts_filtered ("\n"); | |
842 | ||
843 | return 0; | |
844 | } | |
845 | } | |
846 | } | |
847 | ||
848 | /* Read a packet from the remote machine, with error checking, and | |
849 | store it in BUF. BUF is expected to be of size PBUFSIZ. If | |
850 | FOREVER, wait forever rather than timing out; this is used while | |
851 | the target is executing user code. */ | |
852 | ||
853 | static void | |
854 | getpkt (buf, forever) | |
855 | char *buf; | |
856 | int forever; | |
857 | { | |
858 | int c; | |
859 | int tries; | |
860 | int timeout; | |
861 | int val; | |
862 | ||
863 | strcpy (buf, "timeout"); | |
864 | ||
865 | if (forever) | |
866 | { | |
867 | timeout = watchdog > 0 ? watchdog : -1; | |
868 | } | |
869 | ||
870 | else | |
871 | timeout = remote_timeout; | |
872 | ||
873 | #define MAX_TRIES 3 | |
874 | ||
875 | for (tries = 1; tries <= MAX_TRIES; tries++) | |
876 | { | |
877 | /* This can loop forever if the remote side sends us characters | |
8bde7f77 WD |
878 | continuously, but if it pauses, we'll get a zero from readchar |
879 | because of timeout. Then we'll count that as a retry. */ | |
4a5b6a35 WD |
880 | |
881 | /* Note that we will only wait forever prior to the start of a packet. | |
8bde7f77 WD |
882 | After that, we expect characters to arrive at a brisk pace. They |
883 | should show up within remote_timeout intervals. */ | |
4a5b6a35 WD |
884 | |
885 | do | |
886 | { | |
887 | c = readchar (timeout); | |
888 | ||
889 | if (c == SERIAL_TIMEOUT) | |
890 | { | |
891 | if (forever) /* Watchdog went off. Kill the target. */ | |
892 | { | |
893 | target_mourn_inferior (); | |
894 | error ("Watchdog has expired. Target detached.\n"); | |
895 | } | |
896 | if (remote_debug) | |
897 | fputs_filtered ("Timed out.\n", gdb_stdlog); | |
898 | goto retry; | |
899 | } | |
900 | } | |
901 | while (c != '$'); | |
902 | ||
903 | /* We've found the start of a packet, now collect the data. */ | |
904 | ||
905 | val = read_frame (buf); | |
906 | ||
907 | if (val == 1) | |
908 | { | |
909 | if (remote_debug) | |
910 | { | |
911 | fprintf_unfiltered (gdb_stdlog, "Packet received: "); | |
912 | fputstr_unfiltered (buf, 0, gdb_stdlog); | |
913 | fprintf_unfiltered (gdb_stdlog, "\n"); | |
914 | } | |
915 | SERIAL_WRITE (remote_desc, "+", 1); | |
916 | return; | |
917 | } | |
918 | ||
919 | /* Try the whole thing again. */ | |
920 | retry: | |
921 | SERIAL_WRITE (remote_desc, "-", 1); | |
922 | } | |
923 | ||
924 | /* We have tried hard enough, and just can't receive the packet. Give up. */ | |
925 | ||
926 | printf_unfiltered ("Ignoring packet error, continuing...\n"); | |
927 | SERIAL_WRITE (remote_desc, "+", 1); | |
928 | } |