gdb/
[deliverable/binutils-gdb.git] / gdb / gdbserver / server.c
CommitLineData
c906108c 1/* Main code for remote server for GDB.
6aba47ca 2 Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
7b6bb8da
JB
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
c906108c 5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
20
21#include "server.h"
22
68070c10 23#if HAVE_UNISTD_H
a9fa9f7d 24#include <unistd.h>
68070c10
PA
25#endif
26#if HAVE_SIGNAL_H
a9fa9f7d 27#include <signal.h>
68070c10 28#endif
b80864fb 29#if HAVE_SYS_WAIT_H
a9fa9f7d 30#include <sys/wait.h>
b80864fb 31#endif
a9fa9f7d 32
95954743
PA
33ptid_t cont_thread;
34ptid_t general_thread;
35ptid_t step_thread;
5b1c542e 36
0d62e5e8
DJ
37int server_waiting;
38
2d717e4f 39static int extended_protocol;
2d717e4f
DJ
40static int response_needed;
41static int exit_requested;
42
03f2bd59
JK
43/* --once: Exit after the first connection has closed. */
44int run_once;
45
95954743 46int multi_process;
bd99dc85
PA
47int non_stop;
48
ccd213ac 49static char **program_argv, **wrapper_argv;
2d717e4f 50
c74d0ad8
DJ
51/* Enable miscellaneous debugging output. The name is historical - it
52 was originally used to debug LinuxThreads support. */
53int debug_threads;
54
aa5ca48f
DE
55/* Enable debugging of h/w breakpoint/watchpoint support. */
56int debug_hw_points;
57
89be2091
DJ
58int pass_signals[TARGET_SIGNAL_LAST];
59
c906108c 60jmp_buf toplevel;
c906108c 61
9b4b61c8
UW
62const char *gdbserver_xmltarget;
63
a9fa9f7d
DJ
64/* The PID of the originally created or attached inferior. Used to
65 send signals to the process when GDB sends us an asynchronous interrupt
66 (user hitting Control-C in the client), and to wait for the child to exit
67 when no longer debugging it. */
68
a1928bad 69unsigned long signal_pid;
a9fa9f7d 70
290fadea
RS
71#ifdef SIGTTOU
72/* A file descriptor for the controlling terminal. */
73int terminal_fd;
74
75/* TERMINAL_FD's original foreground group. */
76pid_t old_foreground_pgrp;
77
78/* Hand back terminal ownership to the original foreground group. */
79
80static void
81restore_old_foreground_pgrp (void)
82{
83 tcsetpgrp (terminal_fd, old_foreground_pgrp);
84}
85#endif
86
ec56be1b
PA
87/* Set if you want to disable optional thread related packets support
88 in gdbserver, for the sake of testing GDB against stubs that don't
89 support them. */
90int disable_packet_vCont;
91int disable_packet_Tthread;
92int disable_packet_qC;
93int disable_packet_qfThreadInfo;
94
5b1c542e
PA
95/* Last status reported to GDB. */
96static struct target_waitstatus last_status;
95954743 97static ptid_t last_ptid;
5b1c542e 98
bd99dc85
PA
99static char *own_buf;
100static unsigned char *mem_buf;
101
102/* Structure holding information relative to a single stop reply. We
103 keep a queue of these (really a singly-linked list) to push to GDB
104 in non-stop mode. */
105struct vstop_notif
106{
107 /* Pointer to next in list. */
108 struct vstop_notif *next;
109
110 /* Thread or process that got the event. */
95954743 111 ptid_t ptid;
bd99dc85
PA
112
113 /* Event info. */
114 struct target_waitstatus status;
115};
116
117/* The pending stop replies list head. */
118static struct vstop_notif *notif_queue = NULL;
119
120/* Put a stop reply to the stop reply queue. */
121
122static void
95954743 123queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
bd99dc85
PA
124{
125 struct vstop_notif *new_notif;
126
cfdee94a 127 new_notif = xmalloc (sizeof (*new_notif));
bd99dc85
PA
128 new_notif->next = NULL;
129 new_notif->ptid = ptid;
130 new_notif->status = *status;
131
132 if (notif_queue)
133 {
134 struct vstop_notif *tail;
135 for (tail = notif_queue;
136 tail && tail->next;
137 tail = tail->next)
138 ;
139 tail->next = new_notif;
140 }
141 else
142 notif_queue = new_notif;
143
144 if (remote_debug)
145 {
146 int i = 0;
147 struct vstop_notif *n;
148
149 for (n = notif_queue; n; n = n->next)
150 i++;
151
152 fprintf (stderr, "pending stop replies: %d\n", i);
153 }
154}
155
156/* Place an event in the stop reply queue, and push a notification if
157 we aren't sending one yet. */
158
159void
95954743 160push_event (ptid_t ptid, struct target_waitstatus *status)
bd99dc85 161{
d20a8ad9
PA
162 gdb_assert (status->kind != TARGET_WAITKIND_IGNORE);
163
bd99dc85
PA
164 queue_stop_reply (ptid, status);
165
166 /* If this is the first stop reply in the queue, then inform GDB
167 about it, by sending a Stop notification. */
168 if (notif_queue->next == NULL)
169 {
170 char *p = own_buf;
171 strcpy (p, "Stop:");
172 p += strlen (p);
173 prepare_resume_reply (p,
174 notif_queue->ptid, &notif_queue->status);
175 putpkt_notif (own_buf);
176 }
177}
178
95954743
PA
179/* Get rid of the currently pending stop replies for PID. If PID is
180 -1, then apply to all processes. */
bd99dc85
PA
181
182static void
95954743 183discard_queued_stop_replies (int pid)
bd99dc85 184{
95954743 185 struct vstop_notif *prev = NULL, *reply, *next;
bd99dc85 186
95954743 187 for (reply = notif_queue; reply; reply = next)
bd99dc85 188 {
95954743
PA
189 next = reply->next;
190
191 if (pid == -1
192 || ptid_get_pid (reply->ptid) == pid)
193 {
194 if (reply == notif_queue)
195 notif_queue = next;
196 else
197 prev->next = reply->next;
bd99dc85 198
95954743
PA
199 free (reply);
200 }
201 else
202 prev = reply;
bd99dc85
PA
203 }
204}
205
206/* If there are more stop replies to push, push one now. */
207
208static void
209send_next_stop_reply (char *own_buf)
210{
211 if (notif_queue)
212 prepare_resume_reply (own_buf,
213 notif_queue->ptid,
214 &notif_queue->status);
215 else
216 write_ok (own_buf);
217}
218
2d717e4f
DJ
219static int
220target_running (void)
221{
222 return all_threads.head != NULL;
223}
224
fc620387 225static int
5b1c542e 226start_inferior (char **argv)
c906108c 227{
ccd213ac 228 char **new_argv = argv;
2d717e4f 229
ccd213ac
DJ
230 if (wrapper_argv != NULL)
231 {
232 int i, count = 1;
233
234 for (i = 0; wrapper_argv[i] != NULL; i++)
235 count++;
236 for (i = 0; argv[i] != NULL; i++)
237 count++;
238 new_argv = alloca (sizeof (char *) * count);
239 count = 0;
240 for (i = 0; wrapper_argv[i] != NULL; i++)
241 new_argv[count++] = wrapper_argv[i];
242 for (i = 0; argv[i] != NULL; i++)
243 new_argv[count++] = argv[i];
244 new_argv[count] = NULL;
245 }
246
65730243
DE
247 if (debug_threads)
248 {
249 int i;
250 for (i = 0; new_argv[i]; ++i)
251 fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]);
252 fflush (stderr);
253 }
254
b80864fb 255#ifdef SIGTTOU
a9fa9f7d
DJ
256 signal (SIGTTOU, SIG_DFL);
257 signal (SIGTTIN, SIG_DFL);
b80864fb 258#endif
a9fa9f7d 259
ccd213ac 260 signal_pid = create_inferior (new_argv[0], new_argv);
0d62e5e8 261
c588c53c
MS
262 /* FIXME: we don't actually know at this point that the create
263 actually succeeded. We won't know that until we wait. */
a1928bad 264 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
a9fa9f7d 265 signal_pid);
b80864fb 266 fflush (stderr);
a9fa9f7d 267
b80864fb 268#ifdef SIGTTOU
a9fa9f7d
DJ
269 signal (SIGTTOU, SIG_IGN);
270 signal (SIGTTIN, SIG_IGN);
290fadea
RS
271 terminal_fd = fileno (stderr);
272 old_foreground_pgrp = tcgetpgrp (terminal_fd);
273 tcsetpgrp (terminal_fd, signal_pid);
274 atexit (restore_old_foreground_pgrp);
b80864fb 275#endif
c906108c 276
ccd213ac
DJ
277 if (wrapper_argv != NULL)
278 {
279 struct thread_resume resume_info;
ccd213ac 280
95954743 281 resume_info.thread = pid_to_ptid (signal_pid);
bd99dc85 282 resume_info.kind = resume_continue;
ccd213ac 283 resume_info.sig = 0;
ccd213ac 284
32fcada3 285 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
bd99dc85 286
5b1c542e
PA
287 if (last_status.kind != TARGET_WAITKIND_STOPPED)
288 return signal_pid;
ccd213ac
DJ
289
290 do
291 {
2bd7c093 292 (*the_target->resume) (&resume_info, 1);
ccd213ac 293
95954743 294 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
5b1c542e
PA
295 if (last_status.kind != TARGET_WAITKIND_STOPPED)
296 return signal_pid;
d20a8ad9
PA
297
298 current_inferior->last_resume_kind = resume_stop;
299 current_inferior->last_status = last_status;
ccd213ac 300 }
5b1c542e 301 while (last_status.value.sig != TARGET_SIGNAL_TRAP);
ccd213ac 302
d20a8ad9
PA
303 current_inferior->last_resume_kind = resume_stop;
304 current_inferior->last_status = last_status;
5b1c542e 305 return signal_pid;
ccd213ac
DJ
306 }
307
5b1c542e
PA
308 /* Wait till we are at 1st instruction in program, return new pid
309 (assuming success). */
95954743 310 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
5b1c542e 311
d20a8ad9
PA
312 if (last_status.kind != TARGET_WAITKIND_EXITED
313 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
314 {
315 current_inferior->last_resume_kind = resume_stop;
316 current_inferior->last_status = last_status;
317 }
318
5b1c542e 319 return signal_pid;
c906108c
SS
320}
321
45b7b345 322static int
5b1c542e 323attach_inferior (int pid)
45b7b345
DJ
324{
325 /* myattach should return -1 if attaching is unsupported,
326 0 if it succeeded, and call error() otherwise. */
a9fa9f7d 327
45b7b345
DJ
328 if (myattach (pid) != 0)
329 return -1;
330
6910d122 331 fprintf (stderr, "Attached; pid = %d\n", pid);
b80864fb 332 fflush (stderr);
6910d122 333
a9fa9f7d
DJ
334 /* FIXME - It may be that we should get the SIGNAL_PID from the
335 attach function, so that it can be the main thread instead of
336 whichever we were told to attach to. */
337 signal_pid = pid;
338
bd99dc85
PA
339 if (!non_stop)
340 {
95954743 341 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
bd99dc85
PA
342
343 /* GDB knows to ignore the first SIGSTOP after attaching to a running
344 process using the "attach" command, but this is different; it's
345 just using "target remote". Pretend it's just starting up. */
346 if (last_status.kind == TARGET_WAITKIND_STOPPED
347 && last_status.value.sig == TARGET_SIGNAL_STOP)
348 last_status.value.sig = TARGET_SIGNAL_TRAP;
d20a8ad9
PA
349
350 current_inferior->last_resume_kind = resume_stop;
351 current_inferior->last_status = last_status;
bd99dc85 352 }
9db87ebd 353
45b7b345
DJ
354 return 0;
355}
356
c906108c 357extern int remote_debug;
ce3a066d 358
0876f84a
DJ
359/* Decode a qXfer read request. Return 0 if everything looks OK,
360 or -1 otherwise. */
361
362static int
d08aafef 363decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
0876f84a 364{
d08aafef
PA
365 /* After the read marker and annex, qXfer looks like a
366 traditional 'm' packet. */
367 decode_m_packet (buf, ofs, len);
368
369 return 0;
370}
371
372static int
373decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset)
374{
375 /* Extract and NUL-terminate the object. */
376 *object = buf;
377 while (*buf && *buf != ':')
378 buf++;
379 if (*buf == '\0')
380 return -1;
381 *buf++ = 0;
382
383 /* Extract and NUL-terminate the read/write action. */
384 *rw = buf;
385 while (*buf && *buf != ':')
386 buf++;
387 if (*buf == '\0')
388 return -1;
389 *buf++ = 0;
390
0876f84a
DJ
391 /* Extract and NUL-terminate the annex. */
392 *annex = buf;
393 while (*buf && *buf != ':')
394 buf++;
395 if (*buf == '\0')
396 return -1;
397 *buf++ = 0;
398
d08aafef 399 *offset = buf;
0876f84a
DJ
400 return 0;
401}
402
403/* Write the response to a successful qXfer read. Returns the
404 length of the (binary) data stored in BUF, corresponding
405 to as much of DATA/LEN as we could fit. IS_MORE controls
406 the first character of the response. */
407static int
23181151 408write_qxfer_response (char *buf, const void *data, int len, int is_more)
0876f84a
DJ
409{
410 int out_len;
411
412 if (is_more)
413 buf[0] = 'm';
414 else
415 buf[0] = 'l';
416
417 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
418 PBUFSIZ - 2) + 1;
419}
420
89be2091 421/* Handle all of the extended 'Q' packets. */
ae1ada35
DE
422
423static void
89be2091
DJ
424handle_general_set (char *own_buf)
425{
426 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
427 {
428 int numsigs = (int) TARGET_SIGNAL_LAST, i;
429 const char *p = own_buf + strlen ("QPassSignals:");
430 CORE_ADDR cursig;
431
432 p = decode_address_to_semicolon (&cursig, p);
433 for (i = 0; i < numsigs; i++)
434 {
435 if (i == cursig)
436 {
437 pass_signals[i] = 1;
438 if (*p == '\0')
439 /* Keep looping, to clear the remaining signals. */
440 cursig = -1;
441 else
442 p = decode_address_to_semicolon (&cursig, p);
443 }
444 else
445 pass_signals[i] = 0;
446 }
447 strcpy (own_buf, "OK");
448 return;
449 }
450
a6f3e723
SL
451 if (strcmp (own_buf, "QStartNoAckMode") == 0)
452 {
453 if (remote_debug)
454 {
455 fprintf (stderr, "[noack mode enabled]\n");
456 fflush (stderr);
457 }
458
459 noack_mode = 1;
460 write_ok (own_buf);
461 return;
462 }
463
bd99dc85
PA
464 if (strncmp (own_buf, "QNonStop:", 9) == 0)
465 {
466 char *mode = own_buf + 9;
467 int req = -1;
468 char *req_str;
469
470 if (strcmp (mode, "0") == 0)
471 req = 0;
472 else if (strcmp (mode, "1") == 0)
473 req = 1;
474 else
475 {
476 /* We don't know what this mode is, so complain to
477 GDB. */
478 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
479 own_buf);
480 write_enn (own_buf);
481 return;
482 }
483
484 req_str = req ? "non-stop" : "all-stop";
485 if (start_non_stop (req) != 0)
486 {
487 fprintf (stderr, "Setting %s mode failed\n", req_str);
488 write_enn (own_buf);
489 return;
490 }
491
492 non_stop = req;
493
494 if (remote_debug)
495 fprintf (stderr, "[%s mode enabled]\n", req_str);
496
497 write_ok (own_buf);
498 return;
499 }
500
219f2f23
PA
501 if (target_supports_tracepoints ()
502 && handle_tracepoint_general_set (own_buf))
503 return;
504
89be2091
DJ
505 /* Otherwise we didn't know what packet it was. Say we didn't
506 understand it. */
507 own_buf[0] = 0;
508}
509
23181151 510static const char *
fb1e4ffc 511get_features_xml (const char *annex)
23181151 512{
9b4b61c8
UW
513 /* gdbserver_xmltarget defines what to return when looking
514 for the "target.xml" file. Its contents can either be
515 verbatim XML code (prefixed with a '@') or else the name
516 of the actual XML file to be used in place of "target.xml".
fb1e4ffc 517
9b4b61c8
UW
518 This variable is set up from the auto-generated
519 init_registers_... routine for the current target. */
fb1e4ffc 520
9b4b61c8 521 if (gdbserver_xmltarget
221c031f 522 && strcmp (annex, "target.xml") == 0)
23181151 523 {
9b4b61c8
UW
524 if (*gdbserver_xmltarget == '@')
525 return gdbserver_xmltarget + 1;
23181151 526 else
9b4b61c8 527 annex = gdbserver_xmltarget;
23181151
DJ
528 }
529
9b4b61c8
UW
530#ifdef USE_XML
531 {
532 extern const char *const xml_builtin[][2];
533 int i;
534
535 /* Look for the annex. */
536 for (i = 0; xml_builtin[i][0] != NULL; i++)
537 if (strcmp (annex, xml_builtin[i][0]) == 0)
538 break;
539
540 if (xml_builtin[i][0] != NULL)
541 return xml_builtin[i][1];
542 }
543#endif
544
545 return NULL;
23181151
DJ
546}
547
c74d0ad8
DJ
548void
549monitor_show_help (void)
550{
551 monitor_output ("The following monitor commands are supported:\n");
552 monitor_output (" set debug <0|1>\n");
1b3f6016 553 monitor_output (" Enable general debugging messages\n");
aa5ca48f
DE
554 monitor_output (" set debug-hw-points <0|1>\n");
555 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
c74d0ad8
DJ
556 monitor_output (" set remote-debug <0|1>\n");
557 monitor_output (" Enable remote protocol debugging messages\n");
ecd7ecbc
DJ
558 monitor_output (" exit\n");
559 monitor_output (" Quit GDBserver\n");
c74d0ad8
DJ
560}
561
764880b7
PA
562/* Read trace frame or inferior memory. Returns the number of bytes
563 actually read, zero when no further transfer is possible, and -1 on
564 error. Return of a positive value smaller than LEN does not
565 indicate there's no more to be read, only the end of the transfer.
566 E.g., when GDB reads memory from a traceframe, a first request may
567 be served from a memory block that does not cover the whole request
568 length. A following request gets the rest served from either
569 another block (of the same traceframe) or from the read-only
570 regions. */
219f2f23
PA
571
572static int
90d74c30 573gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
219f2f23 574{
764880b7 575 int res;
90d74c30 576
219f2f23
PA
577 if (current_traceframe >= 0)
578 {
579 ULONGEST nbytes;
580 ULONGEST length = len;
581
582 if (traceframe_read_mem (current_traceframe,
583 memaddr, myaddr, len, &nbytes))
584 return EIO;
585 /* Data read from trace buffer, we're done. */
764880b7
PA
586 if (nbytes > 0)
587 return nbytes;
219f2f23 588 if (!in_readonly_region (memaddr, length))
764880b7 589 return -1;
219f2f23
PA
590 /* Otherwise we have a valid readonly case, fall through. */
591 /* (assume no half-trace half-real blocks for now) */
592 }
593
764880b7
PA
594 res = prepare_to_access_memory ();
595 if (res == 0)
90d74c30 596 {
764880b7 597 res = read_inferior_memory (memaddr, myaddr, len);
0146f85b 598 done_accessing_memory ();
90d74c30 599
764880b7
PA
600 return res == 0 ? len : -1;
601 }
602 else
603 return -1;
219f2f23
PA
604}
605
606/* Write trace frame or inferior memory. Actually, writing to trace
607 frames is forbidden. */
608
609static int
90d74c30 610gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
219f2f23
PA
611{
612 if (current_traceframe >= 0)
613 return EIO;
614 else
90d74c30
PA
615 {
616 int ret;
617
618 ret = prepare_to_access_memory ();
619 if (ret == 0)
620 {
621 ret = write_inferior_memory (memaddr, myaddr, len);
0146f85b 622 done_accessing_memory ();
90d74c30
PA
623 }
624 return ret;
625 }
219f2f23
PA
626}
627
08388c79
DE
628/* Subroutine of handle_search_memory to simplify it. */
629
630static int
631handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
632 gdb_byte *pattern, unsigned pattern_len,
633 gdb_byte *search_buf,
634 unsigned chunk_size, unsigned search_buf_size,
635 CORE_ADDR *found_addrp)
636{
637 /* Prime the search buffer. */
638
764880b7
PA
639 if (gdb_read_memory (start_addr, search_buf, search_buf_size)
640 != search_buf_size)
08388c79 641 {
5e1471f5 642 warning ("Unable to access target memory at 0x%lx, halting search.",
08388c79
DE
643 (long) start_addr);
644 return -1;
645 }
646
647 /* Perform the search.
648
649 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
650 When we've scanned N bytes we copy the trailing bytes to the start and
651 read in another N bytes. */
652
653 while (search_space_len >= pattern_len)
654 {
655 gdb_byte *found_ptr;
656 unsigned nr_search_bytes = (search_space_len < search_buf_size
657 ? search_space_len
658 : search_buf_size);
659
660 found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
661
662 if (found_ptr != NULL)
663 {
664 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
665 *found_addrp = found_addr;
666 return 1;
667 }
668
669 /* Not found in this chunk, skip to next chunk. */
670
671 /* Don't let search_space_len wrap here, it's unsigned. */
672 if (search_space_len >= chunk_size)
673 search_space_len -= chunk_size;
674 else
675 search_space_len = 0;
676
677 if (search_space_len >= pattern_len)
678 {
679 unsigned keep_len = search_buf_size - chunk_size;
8a35fb51 680 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
08388c79
DE
681 int nr_to_read;
682
683 /* Copy the trailing part of the previous iteration to the front
684 of the buffer for the next iteration. */
685 memcpy (search_buf, search_buf + chunk_size, keep_len);
686
687 nr_to_read = (search_space_len - keep_len < chunk_size
688 ? search_space_len - keep_len
689 : chunk_size);
690
90d74c30 691 if (gdb_read_memory (read_addr, search_buf + keep_len,
764880b7 692 nr_to_read) != search_buf_size)
08388c79 693 {
493e2a69
MS
694 warning ("Unable to access target memory "
695 "at 0x%lx, halting search.",
08388c79
DE
696 (long) read_addr);
697 return -1;
698 }
699
700 start_addr += chunk_size;
701 }
702 }
703
704 /* Not found. */
705
706 return 0;
707}
708
709/* Handle qSearch:memory packets. */
710
711static void
712handle_search_memory (char *own_buf, int packet_len)
713{
714 CORE_ADDR start_addr;
715 CORE_ADDR search_space_len;
716 gdb_byte *pattern;
717 unsigned int pattern_len;
718 /* NOTE: also defined in find.c testcase. */
719#define SEARCH_CHUNK_SIZE 16000
720 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
721 /* Buffer to hold memory contents for searching. */
722 gdb_byte *search_buf;
723 unsigned search_buf_size;
724 int found;
725 CORE_ADDR found_addr;
726 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
727
aef93bd7 728 pattern = malloc (packet_len);
08388c79
DE
729 if (pattern == NULL)
730 {
5e1471f5 731 error ("Unable to allocate memory to perform the search");
08388c79
DE
732 strcpy (own_buf, "E00");
733 return;
734 }
735 if (decode_search_memory_packet (own_buf + cmd_name_len,
736 packet_len - cmd_name_len,
737 &start_addr, &search_space_len,
738 pattern, &pattern_len) < 0)
739 {
740 free (pattern);
5e1471f5 741 error ("Error in parsing qSearch:memory packet");
08388c79
DE
742 strcpy (own_buf, "E00");
743 return;
744 }
745
746 search_buf_size = chunk_size + pattern_len - 1;
747
748 /* No point in trying to allocate a buffer larger than the search space. */
749 if (search_space_len < search_buf_size)
750 search_buf_size = search_space_len;
751
aef93bd7 752 search_buf = malloc (search_buf_size);
08388c79
DE
753 if (search_buf == NULL)
754 {
755 free (pattern);
5e1471f5 756 error ("Unable to allocate memory to perform the search");
08388c79
DE
757 strcpy (own_buf, "E00");
758 return;
759 }
760
761 found = handle_search_memory_1 (start_addr, search_space_len,
762 pattern, pattern_len,
763 search_buf, chunk_size, search_buf_size,
764 &found_addr);
765
766 if (found > 0)
767 sprintf (own_buf, "1,%lx", (long) found_addr);
768 else if (found == 0)
769 strcpy (own_buf, "0");
770 else
771 strcpy (own_buf, "E00");
772
773 free (search_buf);
774 free (pattern);
775}
776
2d717e4f
DJ
777#define require_running(BUF) \
778 if (!target_running ()) \
779 { \
780 write_enn (BUF); \
781 return; \
782 }
783
cdbfd419
PP
784/* Handle monitor commands not handled by target-specific handlers. */
785
786static void
787handle_monitor_command (char *mon)
788{
789 if (strcmp (mon, "set debug 1") == 0)
790 {
791 debug_threads = 1;
792 monitor_output ("Debug output enabled.\n");
793 }
794 else if (strcmp (mon, "set debug 0") == 0)
795 {
796 debug_threads = 0;
797 monitor_output ("Debug output disabled.\n");
798 }
799 else if (strcmp (mon, "set debug-hw-points 1") == 0)
800 {
801 debug_hw_points = 1;
802 monitor_output ("H/W point debugging output enabled.\n");
803 }
804 else if (strcmp (mon, "set debug-hw-points 0") == 0)
805 {
806 debug_hw_points = 0;
807 monitor_output ("H/W point debugging output disabled.\n");
808 }
809 else if (strcmp (mon, "set remote-debug 1") == 0)
810 {
811 remote_debug = 1;
812 monitor_output ("Protocol debug output enabled.\n");
813 }
814 else if (strcmp (mon, "set remote-debug 0") == 0)
815 {
816 remote_debug = 0;
817 monitor_output ("Protocol debug output disabled.\n");
818 }
819 else if (strcmp (mon, "help") == 0)
820 monitor_show_help ();
821 else if (strcmp (mon, "exit") == 0)
822 exit_requested = 1;
823 else
824 {
825 monitor_output ("Unknown monitor command.\n\n");
826 monitor_show_help ();
827 write_enn (own_buf);
828 }
829}
830
d08aafef
PA
831/* Associates a callback with each supported qXfer'able object. */
832
833struct qxfer
834{
835 /* The object this handler handles. */
836 const char *object;
837
838 /* Request that the target transfer up to LEN 8-bit bytes of the
839 target's OBJECT. The OFFSET, for a seekable object, specifies
840 the starting point. The ANNEX can be used to provide additional
841 data-specific information to the target.
842
843 Return the number of bytes actually transfered, zero when no
844 further transfer is possible, -1 on error, and -2 when the
845 transfer is not supported. Return of a positive value smaller
846 than LEN does not indicate the end of the object, only the end of
847 the transfer.
848
849 One, and only one, of readbuf or writebuf must be non-NULL. */
850 int (*xfer) (const char *annex,
851 gdb_byte *readbuf, const gdb_byte *writebuf,
852 ULONGEST offset, LONGEST len);
853};
854
855/* Handle qXfer:auxv:read. */
856
857static int
858handle_qxfer_auxv (const char *annex,
859 gdb_byte *readbuf, const gdb_byte *writebuf,
860 ULONGEST offset, LONGEST len)
861{
862 if (the_target->read_auxv == NULL || writebuf != NULL)
863 return -2;
864
865 if (annex[0] != '\0' || !target_running ())
866 return -1;
867
868 return (*the_target->read_auxv) (offset, readbuf, len);
869}
870
871/* Handle qXfer:features:read. */
872
873static int
874handle_qxfer_features (const char *annex,
875 gdb_byte *readbuf, const gdb_byte *writebuf,
876 ULONGEST offset, LONGEST len)
877{
878 const char *document;
879 size_t total_len;
880
881 if (writebuf != NULL)
882 return -2;
883
884 if (!target_running ())
885 return -1;
886
887 /* Grab the correct annex. */
888 document = get_features_xml (annex);
889 if (document == NULL)
890 return -1;
891
892 total_len = strlen (document);
893
894 if (offset > total_len)
895 return -1;
896
897 if (offset + len > total_len)
898 len = total_len - offset;
899
900 memcpy (readbuf, document + offset, len);
901 return len;
902}
903
904/* Handle qXfer:libraries:read. */
905
906static int
907handle_qxfer_libraries (const char *annex,
908 gdb_byte *readbuf, const gdb_byte *writebuf,
909 ULONGEST offset, LONGEST len)
910{
911 unsigned int total_len;
912 char *document, *p;
913 struct inferior_list_entry *dll_ptr;
914
915 if (writebuf != NULL)
916 return -2;
917
918 if (annex[0] != '\0' || !target_running ())
919 return -1;
920
921 /* Over-estimate the necessary memory. Assume that every character
922 in the library name must be escaped. */
923 total_len = 64;
924 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
925 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
926
927 document = malloc (total_len);
928 if (document == NULL)
929 return -1;
930
931 strcpy (document, "<library-list>\n");
932 p = document + strlen (document);
933
934 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
935 {
936 struct dll_info *dll = (struct dll_info *) dll_ptr;
937 char *name;
938
939 strcpy (p, " <library name=\"");
940 p = p + strlen (p);
941 name = xml_escape_text (dll->name);
942 strcpy (p, name);
943 free (name);
944 p = p + strlen (p);
945 strcpy (p, "\"><segment address=\"");
946 p = p + strlen (p);
947 sprintf (p, "0x%lx", (long) dll->base_addr);
948 p = p + strlen (p);
949 strcpy (p, "\"/></library>\n");
950 p = p + strlen (p);
951 }
952
953 strcpy (p, "</library-list>\n");
954
955 total_len = strlen (document);
956
957 if (offset > total_len)
958 {
959 free (document);
960 return -1;
961 }
962
963 if (offset + len > total_len)
964 len = total_len - offset;
965
966 memcpy (readbuf, document + offset, len);
967 free (document);
968 return len;
969}
970
971/* Handle qXfer:osadata:read. */
972
973static int
974handle_qxfer_osdata (const char *annex,
975 gdb_byte *readbuf, const gdb_byte *writebuf,
976 ULONGEST offset, LONGEST len)
977{
978 if (the_target->qxfer_osdata == NULL || writebuf != NULL)
979 return -2;
980
981 return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
982}
983
984/* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
985
986static int
987handle_qxfer_siginfo (const char *annex,
988 gdb_byte *readbuf, const gdb_byte *writebuf,
989 ULONGEST offset, LONGEST len)
990{
991 if (the_target->qxfer_siginfo == NULL)
992 return -2;
993
994 if (annex[0] != '\0' || !target_running ())
995 return -1;
996
997 return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
998}
999
1000/* Handle qXfer:spu:read and qXfer:spu:write. */
1001
1002static int
1003handle_qxfer_spu (const char *annex,
1004 gdb_byte *readbuf, const gdb_byte *writebuf,
1005 ULONGEST offset, LONGEST len)
1006{
1007 if (the_target->qxfer_spu == NULL)
1008 return -2;
1009
1010 if (!target_running ())
1011 return -1;
1012
1013 return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1014}
1015
1016/* Handle qXfer:statictrace:read. */
1017
1018static int
1019handle_qxfer_statictrace (const char *annex,
1020 gdb_byte *readbuf, const gdb_byte *writebuf,
1021 ULONGEST offset, LONGEST len)
1022{
1023 ULONGEST nbytes;
1024
1025 if (writebuf != NULL)
1026 return -2;
1027
1028 if (annex[0] != '\0' || !target_running () || current_traceframe == -1)
1029 return -1;
1030
1031 if (traceframe_read_sdata (current_traceframe, offset,
1032 readbuf, len, &nbytes))
1033 return -1;
1034 return nbytes;
1035}
1036
1037/* Helper for handle_qxfer_threads. */
1038
dc146f7c 1039static void
d08aafef 1040handle_qxfer_threads_proper (struct buffer *buffer)
dc146f7c
VP
1041{
1042 struct inferior_list_entry *thread;
1043
1044 buffer_grow_str (buffer, "<threads>\n");
1045
1046 for (thread = all_threads.head; thread; thread = thread->next)
1047 {
1048 ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
1049 char ptid_s[100];
1050 int core = -1;
1051 char core_s[21];
1052
1053 write_ptid (ptid_s, ptid);
1054
1055 if (the_target->core_of_thread)
1056 core = (*the_target->core_of_thread) (ptid);
1057
1058 if (core != -1)
1059 {
1060 sprintf (core_s, "%d", core);
1061 buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
1062 ptid_s, core_s);
1063 }
1064 else
1065 {
1066 buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
1067 ptid_s);
1068 }
1069 }
1070
1071 buffer_grow_str0 (buffer, "</threads>\n");
1072}
1073
d08aafef
PA
1074/* Handle qXfer:threads:read. */
1075
dc146f7c 1076static int
d08aafef
PA
1077handle_qxfer_threads (const char *annex,
1078 gdb_byte *readbuf, const gdb_byte *writebuf,
1079 ULONGEST offset, LONGEST len)
dc146f7c
VP
1080{
1081 static char *result = 0;
1082 static unsigned int result_length = 0;
1083
d08aafef
PA
1084 if (writebuf != NULL)
1085 return -2;
1086
1087 if (!target_running () || annex[0] != '\0')
1088 return -1;
dc146f7c
VP
1089
1090 if (offset == 0)
1091 {
1092 struct buffer buffer;
1093 /* When asked for data at offset 0, generate everything and store into
1094 'result'. Successive reads will be served off 'result'. */
1095 if (result)
1096 free (result);
1097
1098 buffer_init (&buffer);
1099
d08aafef 1100 handle_qxfer_threads_proper (&buffer);
dc146f7c
VP
1101
1102 result = buffer_finish (&buffer);
1103 result_length = strlen (result);
1104 buffer_free (&buffer);
1105 }
1106
1107 if (offset >= result_length)
1108 {
1109 /* We're out of data. */
1110 free (result);
1111 result = NULL;
1112 result_length = 0;
1113 return 0;
1114 }
1115
d08aafef
PA
1116 if (len > result_length - offset)
1117 len = result_length - offset;
1118
1119 memcpy (readbuf, result + offset, len);
1120
1121 return len;
1122}
1123
b3b9301e
PA
1124/* Handle qXfer:traceframe-info:read. */
1125
1126static int
1127handle_qxfer_traceframe_info (const char *annex,
1128 gdb_byte *readbuf, const gdb_byte *writebuf,
1129 ULONGEST offset, LONGEST len)
1130{
1131 static char *result = 0;
1132 static unsigned int result_length = 0;
1133
1134 if (writebuf != NULL)
1135 return -2;
1136
1137 if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1138 return -1;
1139
1140 if (offset == 0)
1141 {
1142 struct buffer buffer;
1143
1144 /* When asked for data at offset 0, generate everything and
1145 store into 'result'. Successive reads will be served off
1146 'result'. */
1147 free (result);
1148
1149 buffer_init (&buffer);
1150
1151 traceframe_read_info (current_traceframe, &buffer);
1152
1153 result = buffer_finish (&buffer);
1154 result_length = strlen (result);
1155 buffer_free (&buffer);
1156 }
1157
1158 if (offset >= result_length)
1159 {
1160 /* We're out of data. */
1161 free (result);
1162 result = NULL;
1163 result_length = 0;
1164 return 0;
1165 }
1166
1167 if (len > result_length - offset)
1168 len = result_length - offset;
1169
1170 memcpy (readbuf, result + offset, len);
1171 return len;
1172}
1173
d08aafef
PA
1174static const struct qxfer qxfer_packets[] =
1175 {
1176 { "auxv", handle_qxfer_auxv },
1177 { "features", handle_qxfer_features },
1178 { "libraries", handle_qxfer_libraries },
1179 { "osdata", handle_qxfer_osdata },
1180 { "siginfo", handle_qxfer_siginfo },
1181 { "spu", handle_qxfer_spu },
1182 { "statictrace", handle_qxfer_statictrace },
1183 { "threads", handle_qxfer_threads },
b3b9301e 1184 { "traceframe-info", handle_qxfer_traceframe_info },
d08aafef
PA
1185 };
1186
1187static int
1188handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1189{
1190 int i;
1191 char *object;
1192 char *rw;
1193 char *annex;
1194 char *offset;
1195
1196 if (strncmp (own_buf, "qXfer:", 6) != 0)
1197 return 0;
1198
1199 /* Grab the object, r/w and annex. */
1200 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
1201 {
1202 write_enn (own_buf);
1203 return 1;
1204 }
1205
1206 for (i = 0;
1207 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
1208 i++)
1209 {
1210 const struct qxfer *q = &qxfer_packets[i];
1211
1212 if (strcmp (object, q->object) == 0)
1213 {
1214 if (strcmp (rw, "read") == 0)
1215 {
1216 unsigned char *data;
1217 int n;
1218 CORE_ADDR ofs;
1219 unsigned int len;
1220
1221 /* Grab the offset and length. */
1222 if (decode_xfer_read (offset, &ofs, &len) < 0)
1223 {
1224 write_enn (own_buf);
1225 return 1;
1226 }
1227
1228 /* Read one extra byte, as an indicator of whether there is
1229 more. */
1230 if (len > PBUFSIZ - 2)
1231 len = PBUFSIZ - 2;
1232 data = malloc (len + 1);
1233 if (data == NULL)
1234 {
1235 write_enn (own_buf);
1236 return 1;
1237 }
1238 n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
1239 if (n == -2)
1240 {
1241 free (data);
1242 return 0;
1243 }
1244 else if (n < 0)
1245 write_enn (own_buf);
1246 else if (n > len)
1247 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1248 else
1249 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1250
1251 free (data);
1252 return 1;
1253 }
1254 else if (strcmp (rw, "write") == 0)
1255 {
1256 int n;
1257 unsigned int len;
1258 CORE_ADDR ofs;
1259 unsigned char *data;
1260
1261 strcpy (own_buf, "E00");
1262 data = malloc (packet_len - (offset - own_buf));
1263 if (data == NULL)
1264 {
1265 write_enn (own_buf);
1266 return 1;
1267 }
1268 if (decode_xfer_write (offset, packet_len - (offset - own_buf),
1269 &ofs, &len, data) < 0)
1270 {
1271 free (data);
1272 write_enn (own_buf);
1273 return 1;
1274 }
1275
1276 n = (*q->xfer) (annex, NULL, data, ofs, len);
1277 if (n == -2)
1278 {
1279 free (data);
1280 return 0;
1281 }
1282 else if (n < 0)
1283 write_enn (own_buf);
1284 else
1285 sprintf (own_buf, "%x", n);
dc146f7c 1286
d08aafef
PA
1287 free (data);
1288 return 1;
1289 }
dc146f7c 1290
d08aafef
PA
1291 return 0;
1292 }
1293 }
dc146f7c 1294
d08aafef 1295 return 0;
dc146f7c
VP
1296}
1297
30ba68cb
MS
1298/* Table used by the crc32 function to calcuate the checksum. */
1299
1300static unsigned int crc32_table[256] =
1301{0, 0};
1302
1303/* Compute 32 bit CRC from inferior memory.
1304
1305 On success, return 32 bit CRC.
1306 On failure, return (unsigned long long) -1. */
1307
1308static unsigned long long
1309crc32 (CORE_ADDR base, int len, unsigned int crc)
1310{
1311 if (!crc32_table[1])
1312 {
1313 /* Initialize the CRC table and the decoding table. */
1314 int i, j;
1315 unsigned int c;
1316
1317 for (i = 0; i < 256; i++)
1318 {
1319 for (c = i << 24, j = 8; j > 0; --j)
1320 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
1321 crc32_table[i] = c;
1322 }
1323 }
1324
1325 while (len--)
1326 {
1327 unsigned char byte = 0;
1328
1329 /* Return failure if memory read fails. */
1330 if (read_inferior_memory (base, &byte, 1) != 0)
1331 return (unsigned long long) -1;
1332
1333 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ byte) & 255];
1334 base++;
1335 }
1336 return (unsigned long long) crc;
1337}
1338
ce3a066d 1339/* Handle all of the extended 'q' packets. */
d08aafef 1340
ce3a066d 1341void
0e7f50da 1342handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
ce3a066d 1343{
0d62e5e8
DJ
1344 static struct inferior_list_entry *thread_ptr;
1345
bb63802a 1346 /* Reply the current thread id. */
db42f210 1347 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
bb63802a 1348 {
95954743 1349 ptid_t gdb_id;
2d717e4f 1350 require_running (own_buf);
bd99dc85 1351
95954743
PA
1352 if (!ptid_equal (general_thread, null_ptid)
1353 && !ptid_equal (general_thread, minus_one_ptid))
bd99dc85
PA
1354 gdb_id = general_thread;
1355 else
1356 {
1357 thread_ptr = all_threads.head;
1358 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1359 }
1360
95954743
PA
1361 sprintf (own_buf, "QC");
1362 own_buf += 2;
4b812f4e 1363 write_ptid (own_buf, gdb_id);
bb63802a
UW
1364 return;
1365 }
1366
ce3a066d
DJ
1367 if (strcmp ("qSymbol::", own_buf) == 0)
1368 {
d3bbe7a0
PA
1369 /* GDB is suggesting new symbols have been loaded. This may
1370 mean a new shared library has been detected as loaded, so
1371 take the opportunity to check if breakpoints we think are
1372 inserted, still are. Note that it isn't guaranteed that
1373 we'll see this when a shared library is loaded, and nor will
1374 we see this for unloads (although breakpoints in unloaded
1375 libraries shouldn't trigger), as GDB may not find symbols for
1376 the library at all. We also re-validate breakpoints when we
1377 see a second GDB breakpoint for the same address, and or when
1378 we access breakpoint shadows. */
1379 validate_breakpoints ();
1380
fa593d66
PA
1381 if (target_supports_tracepoints ())
1382 tracepoint_look_up_symbols ();
1383
2d717e4f 1384 if (target_running () && the_target->look_up_symbols != NULL)
2f2893d9
DJ
1385 (*the_target->look_up_symbols) ();
1386
ce3a066d
DJ
1387 strcpy (own_buf, "OK");
1388 return;
1389 }
1390
db42f210 1391 if (!disable_packet_qfThreadInfo)
0d62e5e8 1392 {
db42f210 1393 if (strcmp ("qfThreadInfo", own_buf) == 0)
0d62e5e8 1394 {
95954743
PA
1395 ptid_t gdb_id;
1396
db42f210
PA
1397 require_running (own_buf);
1398 thread_ptr = all_threads.head;
95954743
PA
1399
1400 *own_buf++ = 'm';
1401 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1402 write_ptid (own_buf, gdb_id);
0d62e5e8
DJ
1403 thread_ptr = thread_ptr->next;
1404 return;
1405 }
db42f210
PA
1406
1407 if (strcmp ("qsThreadInfo", own_buf) == 0)
0d62e5e8 1408 {
95954743
PA
1409 ptid_t gdb_id;
1410
db42f210
PA
1411 require_running (own_buf);
1412 if (thread_ptr != NULL)
1413 {
95954743
PA
1414 *own_buf++ = 'm';
1415 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1416 write_ptid (own_buf, gdb_id);
db42f210
PA
1417 thread_ptr = thread_ptr->next;
1418 return;
1419 }
1420 else
1421 {
1422 sprintf (own_buf, "l");
1423 return;
1424 }
0d62e5e8
DJ
1425 }
1426 }
aa691b87 1427
52fb6437
NS
1428 if (the_target->read_offsets != NULL
1429 && strcmp ("qOffsets", own_buf) == 0)
1430 {
1431 CORE_ADDR text, data;
2d717e4f
DJ
1432
1433 require_running (own_buf);
52fb6437
NS
1434 if (the_target->read_offsets (&text, &data))
1435 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
1436 (long)text, (long)data, (long)data);
1437 else
1438 write_enn (own_buf);
1b3f6016 1439
52fb6437
NS
1440 return;
1441 }
1442
be2a5f71
DJ
1443 /* Protocol features query. */
1444 if (strncmp ("qSupported", own_buf, 10) == 0
1445 && (own_buf[10] == ':' || own_buf[10] == '\0'))
1446 {
95954743 1447 char *p = &own_buf[10];
fa593d66 1448 int gdb_supports_qRelocInsn = 0;
95954743 1449
1570b33e
L
1450 /* Start processing qSupported packet. */
1451 target_process_qsupported (NULL);
1452
95954743
PA
1453 /* Process each feature being provided by GDB. The first
1454 feature will follow a ':', and latter features will follow
1455 ';'. */
1456 if (*p == ':')
d149dd1d
PA
1457 {
1458 char **qsupported = NULL;
1459 int count = 0;
1460 int i;
1461
1462 /* Two passes, to avoid nested strtok calls in
1463 target_process_qsupported. */
1464 for (p = strtok (p + 1, ";");
1465 p != NULL;
1466 p = strtok (NULL, ";"))
1467 {
1468 count++;
1469 qsupported = xrealloc (qsupported, count * sizeof (char *));
1470 qsupported[count - 1] = xstrdup (p);
1471 }
1472
1473 for (i = 0; i < count; i++)
1474 {
1475 p = qsupported[i];
1476 if (strcmp (p, "multiprocess+") == 0)
1477 {
1478 /* GDB supports and wants multi-process support if
1479 possible. */
1480 if (target_supports_multi_process ())
1481 multi_process = 1;
1482 }
fa593d66
PA
1483 else if (strcmp (p, "qRelocInsn+") == 0)
1484 {
1485 /* GDB supports relocate instruction requests. */
1486 gdb_supports_qRelocInsn = 1;
1487 }
d149dd1d
PA
1488 else
1489 target_process_qsupported (p);
1490
1491 free (p);
1492 }
1493
1494 free (qsupported);
1495 }
95954743 1496
89be2091 1497 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
0876f84a 1498
255e7678
DJ
1499 /* We do not have any hook to indicate whether the target backend
1500 supports qXfer:libraries:read, so always report it. */
1501 strcat (own_buf, ";qXfer:libraries:read+");
1502
0876f84a 1503 if (the_target->read_auxv != NULL)
9f2e1e63 1504 strcat (own_buf, ";qXfer:auxv:read+");
2d717e4f 1505
0e7f50da
UW
1506 if (the_target->qxfer_spu != NULL)
1507 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
0876f84a 1508
4aa995e1
PA
1509 if (the_target->qxfer_siginfo != NULL)
1510 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1511
221c031f
UW
1512 /* We always report qXfer:features:read, as targets may
1513 install XML files on a subsequent call to arch_setup.
1514 If we reported to GDB on startup that we don't support
1515 qXfer:feature:read at all, we will never be re-queried. */
1516 strcat (own_buf, ";qXfer:features:read+");
23181151 1517
a6f3e723
SL
1518 if (transport_is_reliable)
1519 strcat (own_buf, ";QStartNoAckMode+");
07e059b5
VP
1520
1521 if (the_target->qxfer_osdata != NULL)
1b3f6016 1522 strcat (own_buf, ";qXfer:osdata:read+");
07e059b5 1523
cf8fd78b
PA
1524 if (target_supports_multi_process ())
1525 strcat (own_buf, ";multiprocess+");
95954743 1526
bd99dc85
PA
1527 if (target_supports_non_stop ())
1528 strcat (own_buf, ";QNonStop+");
1529
dc146f7c
VP
1530 strcat (own_buf, ";qXfer:threads:read+");
1531
219f2f23
PA
1532 if (target_supports_tracepoints ())
1533 {
1534 strcat (own_buf, ";ConditionalTracepoints+");
1535 strcat (own_buf, ";TraceStateVariables+");
1536 strcat (own_buf, ";TracepointSource+");
8336d594 1537 strcat (own_buf, ";DisconnectedTracing+");
fa593d66
PA
1538 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
1539 strcat (own_buf, ";FastTracepoints+");
0fb4aa4b
PA
1540 strcat (own_buf, ";StaticTracepoints+");
1541 strcat (own_buf, ";qXfer:statictrace:read+");
b3b9301e 1542 strcat (own_buf, ";qXfer:traceframe-info:read+");
219f2f23
PA
1543 }
1544
be2a5f71
DJ
1545 return;
1546 }
1547
dae5f5cf
DJ
1548 /* Thread-local storage support. */
1549 if (the_target->get_tls_address != NULL
1550 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
1551 {
1552 char *p = own_buf + 12;
5b1c542e 1553 CORE_ADDR parts[2], address = 0;
dae5f5cf 1554 int i, err;
95954743 1555 ptid_t ptid = null_ptid;
dae5f5cf 1556
2d717e4f
DJ
1557 require_running (own_buf);
1558
dae5f5cf
DJ
1559 for (i = 0; i < 3; i++)
1560 {
1561 char *p2;
1562 int len;
1563
1564 if (p == NULL)
1565 break;
1566
1567 p2 = strchr (p, ',');
1568 if (p2)
1569 {
1570 len = p2 - p;
1571 p2++;
1572 }
1573 else
1574 {
1575 len = strlen (p);
1576 p2 = NULL;
1577 }
1578
5b1c542e 1579 if (i == 0)
95954743 1580 ptid = read_ptid (p, NULL);
5b1c542e
PA
1581 else
1582 decode_address (&parts[i - 1], p, len);
dae5f5cf
DJ
1583 p = p2;
1584 }
1585
1586 if (p != NULL || i < 3)
1587 err = 1;
1588 else
1589 {
e09875d4 1590 struct thread_info *thread = find_thread_ptid (ptid);
dae5f5cf
DJ
1591
1592 if (thread == NULL)
1593 err = 2;
1594 else
5b1c542e 1595 err = the_target->get_tls_address (thread, parts[0], parts[1],
dae5f5cf
DJ
1596 &address);
1597 }
1598
1599 if (err == 0)
1600 {
c6f46ca0 1601 strcpy (own_buf, paddress(address));
dae5f5cf
DJ
1602 return;
1603 }
1604 else if (err > 0)
1605 {
1606 write_enn (own_buf);
1607 return;
1608 }
1609
1610 /* Otherwise, pretend we do not understand this packet. */
1611 }
1612
711e434b
PM
1613 /* Windows OS Thread Information Block address support. */
1614 if (the_target->get_tib_address != NULL
1615 && strncmp ("qGetTIBAddr:", own_buf, 12) == 0)
1616 {
1617 char *annex;
1618 int n;
1619 CORE_ADDR tlb;
1620 ptid_t ptid = read_ptid (own_buf + 12, &annex);
1621
1622 n = (*the_target->get_tib_address) (ptid, &tlb);
1623 if (n == 1)
1624 {
c6f46ca0 1625 strcpy (own_buf, paddress(tlb));
711e434b
PM
1626 return;
1627 }
1628 else if (n == 0)
1629 {
1630 write_enn (own_buf);
1631 return;
1632 }
1633 return;
1634 }
1635
c74d0ad8
DJ
1636 /* Handle "monitor" commands. */
1637 if (strncmp ("qRcmd,", own_buf, 6) == 0)
1638 {
aef93bd7 1639 char *mon = malloc (PBUFSIZ);
c74d0ad8
DJ
1640 int len = strlen (own_buf + 6);
1641
aef93bd7
DE
1642 if (mon == NULL)
1643 {
1644 write_enn (own_buf);
1645 return;
1646 }
1647
d41b6bb4 1648 if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
c74d0ad8
DJ
1649 {
1650 write_enn (own_buf);
1651 free (mon);
1652 return;
1653 }
1654 mon[len / 2] = '\0';
1655
1656 write_ok (own_buf);
1657
cdbfd419
PP
1658 if (the_target->handle_monitor_command == NULL
1659 || (*the_target->handle_monitor_command) (mon) == 0)
1660 /* Default processing. */
1661 handle_monitor_command (mon);
c74d0ad8
DJ
1662
1663 free (mon);
1664 return;
1665 }
1666
493e2a69
MS
1667 if (strncmp ("qSearch:memory:", own_buf,
1668 sizeof ("qSearch:memory:") - 1) == 0)
08388c79
DE
1669 {
1670 require_running (own_buf);
1671 handle_search_memory (own_buf, packet_len);
1672 return;
1673 }
1674
95954743
PA
1675 if (strcmp (own_buf, "qAttached") == 0
1676 || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0)
0b16c5cf 1677 {
95954743
PA
1678 struct process_info *process;
1679
1680 if (own_buf[sizeof ("qAttached") - 1])
1681 {
1682 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
1683 process = (struct process_info *)
1684 find_inferior_id (&all_processes, pid_to_ptid (pid));
1685 }
1686 else
1687 {
1688 require_running (own_buf);
1689 process = current_process ();
1690 }
1691
1692 if (process == NULL)
1693 {
1694 write_enn (own_buf);
1695 return;
1696 }
1697
1698 strcpy (own_buf, process->attached ? "1" : "0");
0b16c5cf
PA
1699 return;
1700 }
1701
30ba68cb
MS
1702 if (strncmp ("qCRC:", own_buf, 5) == 0)
1703 {
1704 /* CRC check (compare-section). */
1705 char *comma;
1706 CORE_ADDR base;
1707 int len;
1708 unsigned long long crc;
1709
1710 require_running (own_buf);
2280c721 1711 base = strtoul (own_buf + 5, &comma, 16);
30ba68cb
MS
1712 if (*comma++ != ',')
1713 {
1714 write_enn (own_buf);
1715 return;
1716 }
1717 len = strtoul (comma, NULL, 16);
1718 crc = crc32 (base, len, 0xffffffff);
1719 /* Check for memory failure. */
1720 if (crc == (unsigned long long) -1)
1721 {
1722 write_enn (own_buf);
1723 return;
1724 }
1725 sprintf (own_buf, "C%lx", (unsigned long) crc);
1726 return;
1727 }
1728
d08aafef
PA
1729 if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
1730 return;
1731
219f2f23
PA
1732 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
1733 return;
1734
ce3a066d
DJ
1735 /* Otherwise we didn't know what packet it was. Say we didn't
1736 understand it. */
1737 own_buf[0] = 0;
1738}
1739
ce1a5b52
PA
1740static void gdb_wants_all_threads_stopped (void);
1741
64386c31
DJ
1742/* Parse vCont packets. */
1743void
5b1c542e 1744handle_v_cont (char *own_buf)
64386c31
DJ
1745{
1746 char *p, *q;
1747 int n = 0, i = 0;
2bd7c093 1748 struct thread_resume *resume_info;
95954743 1749 struct thread_resume default_action = {{0}};
64386c31
DJ
1750
1751 /* Count the number of semicolons in the packet. There should be one
1752 for every action. */
1753 p = &own_buf[5];
1754 while (p)
1755 {
1756 n++;
1757 p++;
1758 p = strchr (p, ';');
1759 }
2bd7c093
PA
1760
1761 resume_info = malloc (n * sizeof (resume_info[0]));
aef93bd7
DE
1762 if (resume_info == NULL)
1763 goto err;
64386c31 1764
64386c31 1765 p = &own_buf[5];
64386c31
DJ
1766 while (*p)
1767 {
1768 p++;
1769
64386c31 1770 if (p[0] == 's' || p[0] == 'S')
bd99dc85 1771 resume_info[i].kind = resume_step;
64386c31 1772 else if (p[0] == 'c' || p[0] == 'C')
bd99dc85
PA
1773 resume_info[i].kind = resume_continue;
1774 else if (p[0] == 't')
1775 resume_info[i].kind = resume_stop;
64386c31
DJ
1776 else
1777 goto err;
1778
1779 if (p[0] == 'S' || p[0] == 'C')
1780 {
1781 int sig;
1782 sig = strtol (p + 1, &q, 16);
1783 if (p == q)
1784 goto err;
1785 p = q;
1786
1787 if (!target_signal_to_host_p (sig))
1788 goto err;
1789 resume_info[i].sig = target_signal_to_host (sig);
1790 }
1791 else
1792 {
1793 resume_info[i].sig = 0;
1794 p = p + 1;
1795 }
1796
1797 if (p[0] == 0)
1798 {
95954743 1799 resume_info[i].thread = minus_one_ptid;
64386c31
DJ
1800 default_action = resume_info[i];
1801
1802 /* Note: we don't increment i here, we'll overwrite this entry
1803 the next time through. */
1804 }
1805 else if (p[0] == ':')
1806 {
95954743 1807 ptid_t ptid = read_ptid (p + 1, &q);
a06660f7 1808
64386c31
DJ
1809 if (p == q)
1810 goto err;
1811 p = q;
1812 if (p[0] != ';' && p[0] != 0)
1813 goto err;
1814
95954743 1815 resume_info[i].thread = ptid;
a06660f7 1816
64386c31
DJ
1817 i++;
1818 }
1819 }
1820
2bd7c093
PA
1821 if (i < n)
1822 resume_info[i] = default_action;
64386c31
DJ
1823
1824 /* Still used in occasional places in the backend. */
bd99dc85 1825 if (n == 1
95954743 1826 && !ptid_equal (resume_info[0].thread, minus_one_ptid)
bd99dc85 1827 && resume_info[0].kind != resume_stop)
64386c31
DJ
1828 cont_thread = resume_info[0].thread;
1829 else
95954743 1830 cont_thread = minus_one_ptid;
dc3f8883 1831 set_desired_inferior (0);
64386c31 1832
bd99dc85
PA
1833 if (!non_stop)
1834 enable_async_io ();
1835
2bd7c093 1836 (*the_target->resume) (resume_info, n);
64386c31
DJ
1837
1838 free (resume_info);
1839
bd99dc85
PA
1840 if (non_stop)
1841 write_ok (own_buf);
1842 else
1843 {
95954743 1844 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
ce1a5b52 1845
d20a8ad9
PA
1846 if (last_status.kind != TARGET_WAITKIND_EXITED
1847 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
1848 current_inferior->last_status = last_status;
1849
ce1a5b52
PA
1850 /* From the client's perspective, all-stop mode always stops all
1851 threads implicitly (and the target backend has already done
1852 so by now). Tag all threads as "want-stopped", so we don't
1853 resume them implicitly without the client telling us to. */
1854 gdb_wants_all_threads_stopped ();
bd99dc85
PA
1855 prepare_resume_reply (own_buf, last_ptid, &last_status);
1856 disable_async_io ();
6bd31874
JB
1857
1858 if (last_status.kind == TARGET_WAITKIND_EXITED
1859 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
1860 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
bd99dc85 1861 }
64386c31
DJ
1862 return;
1863
1864err:
255e7678 1865 write_enn (own_buf);
64386c31
DJ
1866 free (resume_info);
1867 return;
1868}
1869
2d717e4f
DJ
1870/* Attach to a new program. Return 1 if successful, 0 if failure. */
1871int
5b1c542e 1872handle_v_attach (char *own_buf)
2d717e4f
DJ
1873{
1874 int pid;
1875
1876 pid = strtol (own_buf + 8, NULL, 16);
5b1c542e 1877 if (pid != 0 && attach_inferior (pid) == 0)
2d717e4f 1878 {
aeba519e
PA
1879 /* Don't report shared library events after attaching, even if
1880 some libraries are preloaded. GDB will always poll the
1881 library list. Avoids the "stopped by shared library event"
1882 notice on the GDB side. */
1883 dlls_changed = 0;
bd99dc85
PA
1884
1885 if (non_stop)
1886 {
1887 /* In non-stop, we don't send a resume reply. Stop events
1888 will follow up using the normal notification
1889 mechanism. */
1890 write_ok (own_buf);
1891 }
1892 else
1893 prepare_resume_reply (own_buf, last_ptid, &last_status);
1894
2d717e4f
DJ
1895 return 1;
1896 }
1897 else
1898 {
1899 write_enn (own_buf);
1900 return 0;
1901 }
1902}
1903
1904/* Run a new program. Return 1 if successful, 0 if failure. */
1905static int
5b1c542e 1906handle_v_run (char *own_buf)
2d717e4f 1907{
aef93bd7 1908 char *p, *next_p, **new_argv;
2d717e4f
DJ
1909 int i, new_argc;
1910
1911 new_argc = 0;
1912 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1913 {
1914 p++;
1915 new_argc++;
1916 }
1917
aef93bd7
DE
1918 new_argv = calloc (new_argc + 2, sizeof (char *));
1919 if (new_argv == NULL)
1920 {
1921 write_enn (own_buf);
1922 return 0;
1923 }
1924
2d717e4f
DJ
1925 i = 0;
1926 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1927 {
1928 next_p = strchr (p, ';');
1929 if (next_p == NULL)
1930 next_p = p + strlen (p);
1931
1932 if (i == 0 && p == next_p)
1933 new_argv[i] = NULL;
1934 else
1935 {
aef93bd7 1936 /* FIXME: Fail request if out of memory instead of dying. */
bca929d3 1937 new_argv[i] = xmalloc (1 + (next_p - p) / 2);
2d717e4f
DJ
1938 unhexify (new_argv[i], p, (next_p - p) / 2);
1939 new_argv[i][(next_p - p) / 2] = '\0';
1940 }
1941
1942 if (*next_p)
1943 next_p++;
1944 i++;
1945 }
1946 new_argv[i] = NULL;
1947
1948 if (new_argv[0] == NULL)
1949 {
f142445f
DJ
1950 /* GDB didn't specify a program to run. Use the program from the
1951 last run with the new argument list. */
9b710a42 1952
2d717e4f
DJ
1953 if (program_argv == NULL)
1954 {
1955 write_enn (own_buf);
b2c04452 1956 freeargv (new_argv);
2d717e4f
DJ
1957 return 0;
1958 }
1959
aef93bd7
DE
1960 new_argv[0] = strdup (program_argv[0]);
1961 if (new_argv[0] == NULL)
1962 {
aef93bd7 1963 write_enn (own_buf);
b2c04452 1964 freeargv (new_argv);
aef93bd7 1965 return 0;
1b3f6016 1966 }
2d717e4f 1967 }
f142445f 1968
aef93bd7
DE
1969 /* Free the old argv and install the new one. */
1970 freeargv (program_argv);
f142445f 1971 program_argv = new_argv;
2d717e4f 1972
5b1c542e
PA
1973 start_inferior (program_argv);
1974 if (last_status.kind == TARGET_WAITKIND_STOPPED)
2d717e4f 1975 {
5b1c542e 1976 prepare_resume_reply (own_buf, last_ptid, &last_status);
bd99dc85
PA
1977
1978 /* In non-stop, sending a resume reply doesn't set the general
1979 thread, but GDB assumes a vRun sets it (this is so GDB can
1980 query which is the main thread of the new inferior. */
1981 if (non_stop)
1982 general_thread = last_ptid;
1983
2d717e4f
DJ
1984 return 1;
1985 }
1986 else
1987 {
1988 write_enn (own_buf);
1989 return 0;
1990 }
1991}
1992
95954743
PA
1993/* Kill process. Return 1 if successful, 0 if failure. */
1994int
1995handle_v_kill (char *own_buf)
1996{
1997 int pid;
1998 char *p = &own_buf[6];
0f54c268
PM
1999 if (multi_process)
2000 pid = strtol (p, NULL, 16);
2001 else
2002 pid = signal_pid;
95954743
PA
2003 if (pid != 0 && kill_inferior (pid) == 0)
2004 {
2005 last_status.kind = TARGET_WAITKIND_SIGNALLED;
2006 last_status.value.sig = TARGET_SIGNAL_KILL;
2007 last_ptid = pid_to_ptid (pid);
2008 discard_queued_stop_replies (pid);
2009 write_ok (own_buf);
2010 return 1;
2011 }
2012 else
2013 {
2014 write_enn (own_buf);
2015 return 0;
2016 }
2017}
2018
bd99dc85
PA
2019/* Handle a 'vStopped' packet. */
2020static void
2021handle_v_stopped (char *own_buf)
2022{
2023 /* If we're waiting for GDB to acknowledge a pending stop reply,
2024 consider that done. */
2025 if (notif_queue)
2026 {
2027 struct vstop_notif *head;
2028
2029 if (remote_debug)
95954743
PA
2030 fprintf (stderr, "vStopped: acking %s\n",
2031 target_pid_to_str (notif_queue->ptid));
bd99dc85
PA
2032
2033 head = notif_queue;
2034 notif_queue = notif_queue->next;
2035 free (head);
2036 }
2037
2038 /* Push another stop reply, or if there are no more left, an OK. */
2039 send_next_stop_reply (own_buf);
2040}
2041
64386c31
DJ
2042/* Handle all of the extended 'v' packets. */
2043void
5b1c542e 2044handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
64386c31 2045{
db42f210 2046 if (!disable_packet_vCont)
64386c31 2047 {
db42f210
PA
2048 if (strncmp (own_buf, "vCont;", 6) == 0)
2049 {
2050 require_running (own_buf);
5b1c542e 2051 handle_v_cont (own_buf);
db42f210
PA
2052 return;
2053 }
64386c31 2054
db42f210
PA
2055 if (strncmp (own_buf, "vCont?", 6) == 0)
2056 {
bd99dc85 2057 strcpy (own_buf, "vCont;c;C;s;S;t");
db42f210
PA
2058 return;
2059 }
64386c31
DJ
2060 }
2061
a6b151f1
DJ
2062 if (strncmp (own_buf, "vFile:", 6) == 0
2063 && handle_vFile (own_buf, packet_len, new_packet_len))
2064 return;
2065
2d717e4f
DJ
2066 if (strncmp (own_buf, "vAttach;", 8) == 0)
2067 {
95954743 2068 if (!multi_process && target_running ())
2d717e4f 2069 {
fd96d250
PA
2070 fprintf (stderr, "Already debugging a process\n");
2071 write_enn (own_buf);
2072 return;
2d717e4f 2073 }
5b1c542e 2074 handle_v_attach (own_buf);
2d717e4f
DJ
2075 return;
2076 }
2077
2078 if (strncmp (own_buf, "vRun;", 5) == 0)
2079 {
95954743 2080 if (!multi_process && target_running ())
2d717e4f 2081 {
fd96d250
PA
2082 fprintf (stderr, "Already debugging a process\n");
2083 write_enn (own_buf);
2084 return;
2d717e4f 2085 }
5b1c542e 2086 handle_v_run (own_buf);
2d717e4f
DJ
2087 return;
2088 }
2089
95954743
PA
2090 if (strncmp (own_buf, "vKill;", 6) == 0)
2091 {
2092 if (!target_running ())
2093 {
2094 fprintf (stderr, "No process to kill\n");
2095 write_enn (own_buf);
2096 return;
2097 }
2098 handle_v_kill (own_buf);
2099 return;
2100 }
2101
bd99dc85
PA
2102 if (strncmp (own_buf, "vStopped", 8) == 0)
2103 {
2104 handle_v_stopped (own_buf);
2105 return;
2106 }
2107
64386c31
DJ
2108 /* Otherwise we didn't know what packet it was. Say we didn't
2109 understand it. */
2110 own_buf[0] = 0;
2111 return;
2112}
2113
bd99dc85
PA
2114/* Resume inferior and wait for another event. In non-stop mode,
2115 don't really wait here, but return immediatelly to the event
2116 loop. */
1fd7cdc2 2117static void
5b1c542e 2118myresume (char *own_buf, int step, int sig)
64386c31
DJ
2119{
2120 struct thread_resume resume_info[2];
2121 int n = 0;
2bd7c093 2122 int valid_cont_thread;
a20d5e98
DJ
2123
2124 set_desired_inferior (0);
64386c31 2125
95954743
PA
2126 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
2127 && !ptid_equal (cont_thread, minus_one_ptid));
2bd7c093
PA
2128
2129 if (step || sig || valid_cont_thread)
64386c31
DJ
2130 {
2131 resume_info[0].thread
2132 = ((struct inferior_list_entry *) current_inferior)->id;
bd99dc85
PA
2133 if (step)
2134 resume_info[0].kind = resume_step;
2135 else
2136 resume_info[0].kind = resume_continue;
64386c31 2137 resume_info[0].sig = sig;
64386c31
DJ
2138 n++;
2139 }
2bd7c093
PA
2140
2141 if (!valid_cont_thread)
2142 {
95954743 2143 resume_info[n].thread = minus_one_ptid;
bd99dc85 2144 resume_info[n].kind = resume_continue;
2bd7c093
PA
2145 resume_info[n].sig = 0;
2146 n++;
2147 }
64386c31 2148
bd99dc85
PA
2149 if (!non_stop)
2150 enable_async_io ();
2151
2bd7c093 2152 (*the_target->resume) (resume_info, n);
bd99dc85
PA
2153
2154 if (non_stop)
2155 write_ok (own_buf);
2156 else
2157 {
95954743 2158 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
d20a8ad9
PA
2159
2160 if (last_status.kind != TARGET_WAITKIND_EXITED
2161 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
2162 {
2163 current_inferior->last_resume_kind = resume_stop;
2164 current_inferior->last_status = last_status;
2165 }
2166
bd99dc85
PA
2167 prepare_resume_reply (own_buf, last_ptid, &last_status);
2168 disable_async_io ();
6bd31874
JB
2169
2170 if (last_status.kind == TARGET_WAITKIND_EXITED
2171 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2172 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
bd99dc85
PA
2173 }
2174}
2175
2176/* Callback for for_each_inferior. Make a new stop reply for each
2177 stopped thread. */
2178
95954743
PA
2179static int
2180queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
bd99dc85 2181{
8336d594 2182 struct thread_info *thread = (struct thread_info *) entry;
bd99dc85 2183
8336d594
PA
2184 /* For now, assume targets that don't have this callback also don't
2185 manage the thread's last_status field. */
2186 if (the_target->thread_stopped == NULL)
95954743 2187 {
8336d594
PA
2188 /* Pass the last stop reply back to GDB, but don't notify
2189 yet. */
2190 queue_stop_reply (entry->id, &thread->last_status);
2191 }
2192 else
2193 {
2194 if (thread_stopped (thread))
2195 {
2196 if (debug_threads)
493e2a69
MS
2197 fprintf (stderr,
2198 "Reporting thread %s as already stopped with %s\n",
8336d594
PA
2199 target_pid_to_str (entry->id),
2200 target_waitstatus_to_string (&thread->last_status));
2201
d20a8ad9
PA
2202 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
2203
8336d594
PA
2204 /* Pass the last stop reply back to GDB, but don't notify
2205 yet. */
2206 queue_stop_reply (entry->id, &thread->last_status);
2207 }
95954743
PA
2208 }
2209
2210 return 0;
64386c31
DJ
2211}
2212
ce1a5b52
PA
2213/* Set this inferior threads's state as "want-stopped". We won't
2214 resume this thread until the client gives us another action for
2215 it. */
8336d594
PA
2216
2217static void
2218gdb_wants_thread_stopped (struct inferior_list_entry *entry)
2219{
2220 struct thread_info *thread = (struct thread_info *) entry;
2221
2222 thread->last_resume_kind = resume_stop;
2223
2224 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
2225 {
ce1a5b52
PA
2226 /* Most threads are stopped implicitly (all-stop); tag that with
2227 signal 0. */
8336d594
PA
2228 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
2229 thread->last_status.value.sig = TARGET_SIGNAL_0;
2230 }
2231}
2232
2233/* Set all threads' states as "want-stopped". */
2234
2235static void
2236gdb_wants_all_threads_stopped (void)
2237{
2238 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
2239}
2240
2241/* Clear the gdb_detached flag of every process. */
2242
2243static void
2244gdb_reattached_process (struct inferior_list_entry *entry)
2245{
2246 struct process_info *process = (struct process_info *) entry;
2247
2248 process->gdb_detached = 0;
2249}
2250
5b1c542e
PA
2251/* Status handler for the '?' packet. */
2252
2253static void
2254handle_status (char *own_buf)
2255{
8336d594
PA
2256 /* GDB is connected, don't forward events to the target anymore. */
2257 for_each_inferior (&all_processes, gdb_reattached_process);
bd99dc85
PA
2258
2259 /* In non-stop mode, we must send a stop reply for each stopped
2260 thread. In all-stop mode, just send one for the first stopped
2261 thread we find. */
2262
2263 if (non_stop)
2264 {
8336d594
PA
2265 discard_queued_stop_replies (-1);
2266 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
bd99dc85
PA
2267
2268 /* The first is sent immediatly. OK is sent if there is no
2269 stopped thread, which is the same handling of the vStopped
2270 packet (by design). */
2271 send_next_stop_reply (own_buf);
2272 }
5b1c542e 2273 else
bd99dc85 2274 {
7984d532 2275 pause_all (0);
fa593d66 2276 stabilize_threads ();
8336d594
PA
2277 gdb_wants_all_threads_stopped ();
2278
bd99dc85 2279 if (all_threads.head)
8336d594
PA
2280 {
2281 struct target_waitstatus status;
2282
2283 status.kind = TARGET_WAITKIND_STOPPED;
2284 status.value.sig = TARGET_SIGNAL_TRAP;
2285 prepare_resume_reply (own_buf,
2286 all_threads.head->id, &status);
2287 }
bd99dc85
PA
2288 else
2289 strcpy (own_buf, "W00");
2290 }
5b1c542e
PA
2291}
2292
dd24457d
DJ
2293static void
2294gdbserver_version (void)
2295{
c16158bc 2296 printf ("GNU gdbserver %s%s\n"
71ce852c 2297 "Copyright (C) 2011 Free Software Foundation, Inc.\n"
493e2a69
MS
2298 "gdbserver is free software, covered by the "
2299 "GNU General Public License.\n"
dd24457d 2300 "This gdbserver was configured as \"%s\"\n",
c16158bc 2301 PKGVERSION, version, host_name);
dd24457d
DJ
2302}
2303
0bc68c49 2304static void
c16158bc 2305gdbserver_usage (FILE *stream)
0bc68c49 2306{
c16158bc
JM
2307 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2308 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2309 "\tgdbserver [OPTIONS] --multi COMM\n"
2310 "\n"
2311 "COMM may either be a tty device (for serial debugging), or \n"
2312 "HOST:PORT to listen for a TCP connection.\n"
2313 "\n"
2314 "Options:\n"
62709adf
PA
2315 " --debug Enable general debugging output.\n"
2316 " --remote-debug Enable remote protocol debugging output.\n"
2317 " --version Display version information and exit.\n"
03f2bd59
JK
2318 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2319 " --once Exit after the first connection has "
2320 "closed.\n");
c16158bc
JM
2321 if (REPORT_BUGS_TO[0] && stream == stdout)
2322 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
0bc68c49
DJ
2323}
2324
db42f210
PA
2325static void
2326gdbserver_show_disableable (FILE *stream)
2327{
2328 fprintf (stream, "Disableable packets:\n"
2329 " vCont \tAll vCont packets\n"
2330 " qC \tQuerying the current thread\n"
2331 " qfThreadInfo\tThread listing\n"
493e2a69
MS
2332 " Tthread \tPassing the thread specifier in the "
2333 "T stop reply packet\n"
db42f210
PA
2334 " threads \tAll of the above\n");
2335}
2336
2337
2d717e4f
DJ
2338#undef require_running
2339#define require_running(BUF) \
2340 if (!target_running ()) \
2341 { \
2342 write_enn (BUF); \
2343 break; \
2344 }
2345
95954743
PA
2346static int
2347first_thread_of (struct inferior_list_entry *entry, void *args)
2348{
2349 int pid = * (int *) args;
2350
2351 if (ptid_get_pid (entry->id) == pid)
2352 return 1;
2353
2354 return 0;
2355}
2356
2357static void
2358kill_inferior_callback (struct inferior_list_entry *entry)
2359{
2360 struct process_info *process = (struct process_info *) entry;
2361 int pid = ptid_get_pid (process->head.id);
2362
2363 kill_inferior (pid);
2364 discard_queued_stop_replies (pid);
2365}
2366
9f767825
DE
2367/* Callback for for_each_inferior to detach or kill the inferior,
2368 depending on whether we attached to it or not.
2369 We inform the user whether we're detaching or killing the process
2370 as this is only called when gdbserver is about to exit. */
2371
95954743
PA
2372static void
2373detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
2374{
2375 struct process_info *process = (struct process_info *) entry;
2376 int pid = ptid_get_pid (process->head.id);
2377
2378 if (process->attached)
2379 detach_inferior (pid);
2380 else
2381 kill_inferior (pid);
2382
2383 discard_queued_stop_replies (pid);
2384}
2385
9f767825
DE
2386/* for_each_inferior callback for detach_or_kill_for_exit to print
2387 the pids of started inferiors. */
2388
2389static void
2390print_started_pid (struct inferior_list_entry *entry)
2391{
2392 struct process_info *process = (struct process_info *) entry;
2393
2394 if (! process->attached)
2395 {
2396 int pid = ptid_get_pid (process->head.id);
2397 fprintf (stderr, " %d", pid);
2398 }
2399}
2400
2401/* for_each_inferior callback for detach_or_kill_for_exit to print
2402 the pids of attached inferiors. */
2403
2404static void
2405print_attached_pid (struct inferior_list_entry *entry)
2406{
2407 struct process_info *process = (struct process_info *) entry;
2408
2409 if (process->attached)
2410 {
2411 int pid = ptid_get_pid (process->head.id);
2412 fprintf (stderr, " %d", pid);
2413 }
2414}
2415
2416/* Call this when exiting gdbserver with possible inferiors that need
2417 to be killed or detached from. */
2418
2419static void
2420detach_or_kill_for_exit (void)
2421{
2422 /* First print a list of the inferiors we will be killing/detaching.
2423 This is to assist the user, for example, in case the inferior unexpectedly
2424 dies after we exit: did we screw up or did the inferior exit on its own?
2425 Having this info will save some head-scratching. */
2426
2427 if (have_started_inferiors_p ())
2428 {
2429 fprintf (stderr, "Killing process(es):");
2430 for_each_inferior (&all_processes, print_started_pid);
2431 fprintf (stderr, "\n");
2432 }
2433 if (have_attached_inferiors_p ())
2434 {
2435 fprintf (stderr, "Detaching process(es):");
2436 for_each_inferior (&all_processes, print_attached_pid);
2437 fprintf (stderr, "\n");
2438 }
2439
2440 /* Now we can kill or detach the inferiors. */
2441
2442 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
2443}
2444
95954743
PA
2445static void
2446join_inferiors_callback (struct inferior_list_entry *entry)
2447{
2448 struct process_info *process = (struct process_info *) entry;
2449
2450 /* If we are attached, then we can exit. Otherwise, we need to hang
2451 around doing nothing, until the child is gone. */
2452 if (!process->attached)
2453 join_inferior (ptid_get_pid (process->head.id));
2454}
2455
c906108c 2456int
da85418c 2457main (int argc, char *argv[])
c906108c 2458{
0729219d
DJ
2459 int bad_attach;
2460 int pid;
2d717e4f
DJ
2461 char *arg_end, *port;
2462 char **next_arg = &argv[1];
2463 int multi_mode = 0;
2464 int attach = 0;
2465 int was_running;
c906108c 2466
2d717e4f 2467 while (*next_arg != NULL && **next_arg == '-')
dd24457d 2468 {
2d717e4f
DJ
2469 if (strcmp (*next_arg, "--version") == 0)
2470 {
2471 gdbserver_version ();
2472 exit (0);
2473 }
2474 else if (strcmp (*next_arg, "--help") == 0)
2475 {
c16158bc 2476 gdbserver_usage (stdout);
2d717e4f
DJ
2477 exit (0);
2478 }
2479 else if (strcmp (*next_arg, "--attach") == 0)
2480 attach = 1;
2481 else if (strcmp (*next_arg, "--multi") == 0)
2482 multi_mode = 1;
ccd213ac
DJ
2483 else if (strcmp (*next_arg, "--wrapper") == 0)
2484 {
2485 next_arg++;
2486
2487 wrapper_argv = next_arg;
2488 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
2489 next_arg++;
2490
2491 if (next_arg == wrapper_argv || *next_arg == NULL)
2492 {
c16158bc 2493 gdbserver_usage (stderr);
ccd213ac
DJ
2494 exit (1);
2495 }
2496
2497 /* Consume the "--". */
2498 *next_arg = NULL;
2499 }
2d717e4f
DJ
2500 else if (strcmp (*next_arg, "--debug") == 0)
2501 debug_threads = 1;
62709adf
PA
2502 else if (strcmp (*next_arg, "--remote-debug") == 0)
2503 remote_debug = 1;
db42f210
PA
2504 else if (strcmp (*next_arg, "--disable-packet") == 0)
2505 {
2506 gdbserver_show_disableable (stdout);
2507 exit (0);
2508 }
2509 else if (strncmp (*next_arg,
2510 "--disable-packet=",
2511 sizeof ("--disable-packet=") - 1) == 0)
2512 {
2513 char *packets, *tok;
2514
2515 packets = *next_arg += sizeof ("--disable-packet=") - 1;
2516 for (tok = strtok (packets, ",");
2517 tok != NULL;
2518 tok = strtok (NULL, ","))
2519 {
2520 if (strcmp ("vCont", tok) == 0)
2521 disable_packet_vCont = 1;
2522 else if (strcmp ("Tthread", tok) == 0)
2523 disable_packet_Tthread = 1;
2524 else if (strcmp ("qC", tok) == 0)
2525 disable_packet_qC = 1;
2526 else if (strcmp ("qfThreadInfo", tok) == 0)
2527 disable_packet_qfThreadInfo = 1;
2528 else if (strcmp ("threads", tok) == 0)
2529 {
2530 disable_packet_vCont = 1;
2531 disable_packet_Tthread = 1;
2532 disable_packet_qC = 1;
2533 disable_packet_qfThreadInfo = 1;
2534 }
2535 else
2536 {
2537 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
2538 tok);
2539 gdbserver_show_disableable (stderr);
2540 exit (1);
2541 }
2542 }
2543 }
03f2bd59
JK
2544 else if (strcmp (*next_arg, "--once") == 0)
2545 run_once = 1;
2d717e4f
DJ
2546 else
2547 {
2548 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
2549 exit (1);
2550 }
dd24457d 2551
2d717e4f
DJ
2552 next_arg++;
2553 continue;
dd24457d
DJ
2554 }
2555
c5aa993b 2556 if (setjmp (toplevel))
c906108c 2557 {
c5aa993b
JM
2558 fprintf (stderr, "Exiting\n");
2559 exit (1);
c906108c
SS
2560 }
2561
2d717e4f
DJ
2562 port = *next_arg;
2563 next_arg++;
2564 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
2565 {
c16158bc 2566 gdbserver_usage (stderr);
2d717e4f
DJ
2567 exit (1);
2568 }
2569
0729219d
DJ
2570 bad_attach = 0;
2571 pid = 0;
2d717e4f
DJ
2572
2573 /* --attach used to come after PORT, so allow it there for
2574 compatibility. */
2575 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
45b7b345 2576 {
2d717e4f
DJ
2577 attach = 1;
2578 next_arg++;
45b7b345
DJ
2579 }
2580
2d717e4f
DJ
2581 if (attach
2582 && (*next_arg == NULL
2583 || (*next_arg)[0] == '\0'
2584 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
2585 || *arg_end != '\0'
2586 || next_arg[1] != NULL))
2587 bad_attach = 1;
2588
2589 if (bad_attach)
dd24457d 2590 {
c16158bc 2591 gdbserver_usage (stderr);
dd24457d
DJ
2592 exit (1);
2593 }
c906108c 2594
95954743 2595 initialize_inferiors ();
a20d5e98 2596 initialize_async_io ();
4ce44c66 2597 initialize_low ();
219f2f23
PA
2598 if (target_supports_tracepoints ())
2599 initialize_tracepoint ();
4ce44c66 2600
bca929d3
DE
2601 own_buf = xmalloc (PBUFSIZ + 1);
2602 mem_buf = xmalloc (PBUFSIZ);
0a30fbc4 2603
2d717e4f 2604 if (pid == 0 && *next_arg != NULL)
45b7b345 2605 {
2d717e4f
DJ
2606 int i, n;
2607
2608 n = argc - (next_arg - argv);
bca929d3 2609 program_argv = xmalloc (sizeof (char *) * (n + 1));
2d717e4f 2610 for (i = 0; i < n; i++)
bca929d3 2611 program_argv[i] = xstrdup (next_arg[i]);
2d717e4f
DJ
2612 program_argv[i] = NULL;
2613
45b7b345 2614 /* Wait till we are at first instruction in program. */
5b1c542e 2615 start_inferior (program_argv);
c906108c 2616
c588c53c
MS
2617 /* We are now (hopefully) stopped at the first instruction of
2618 the target process. This assumes that the target process was
2619 successfully created. */
45b7b345 2620 }
2d717e4f
DJ
2621 else if (pid != 0)
2622 {
5b1c542e 2623 if (attach_inferior (pid) == -1)
2d717e4f
DJ
2624 error ("Attaching not supported on this target");
2625
2626 /* Otherwise succeeded. */
2627 }
45b7b345
DJ
2628 else
2629 {
5b1c542e
PA
2630 last_status.kind = TARGET_WAITKIND_EXITED;
2631 last_status.value.integer = 0;
95954743 2632 last_ptid = minus_one_ptid;
45b7b345 2633 }
c906108c 2634
311de423
PA
2635 /* Don't report shared library events on the initial connection,
2636 even if some libraries are preloaded. Avoids the "stopped by
2637 shared library event" notice on gdb side. */
2638 dlls_changed = 0;
2639
8264bb58
DJ
2640 if (setjmp (toplevel))
2641 {
9f767825 2642 detach_or_kill_for_exit ();
8264bb58
DJ
2643 exit (1);
2644 }
2645
5b1c542e
PA
2646 if (last_status.kind == TARGET_WAITKIND_EXITED
2647 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2d717e4f
DJ
2648 was_running = 0;
2649 else
2650 was_running = 1;
2651
2652 if (!was_running && !multi_mode)
c588c53c 2653 {
2d717e4f 2654 fprintf (stderr, "No program to debug. GDBserver exiting.\n");
c588c53c
MS
2655 exit (1);
2656 }
2657
03f2bd59
JK
2658 remote_prepare (port);
2659
c906108c
SS
2660 while (1)
2661 {
a6f3e723 2662 noack_mode = 0;
95954743 2663 multi_process = 0;
8336d594
PA
2664 /* Be sure we're out of tfind mode. */
2665 current_traceframe = -1;
bd99dc85 2666
2d717e4f 2667 remote_open (port);
c906108c 2668
2d717e4f
DJ
2669 if (setjmp (toplevel) != 0)
2670 {
2671 /* An error occurred. */
2672 if (response_needed)
2673 {
2674 write_enn (own_buf);
2675 putpkt (own_buf);
2676 }
2677 }
2678
bd99dc85 2679 /* Wait for events. This will return when all event sources are
8336d594 2680 removed from the event loop. */
bd99dc85
PA
2681 start_event_loop ();
2682
2683 /* If an exit was requested (using the "monitor exit" command),
2684 terminate now. The only other way to get here is for
2685 getpkt to fail; close the connection and reopen it at the
2686 top of the loop. */
2687
03f2bd59 2688 if (exit_requested || run_once)
c906108c 2689 {
9f767825 2690 detach_or_kill_for_exit ();
bd99dc85
PA
2691 exit (0);
2692 }
8336d594
PA
2693
2694 fprintf (stderr,
2695 "Remote side has terminated connection. "
2696 "GDBserver will reopen the connection.\n");
2697
2698 if (tracing)
2699 {
2700 if (disconnected_tracing)
2701 {
2702 /* Try to enable non-stop/async mode, so we we can both
2703 wait for an async socket accept, and handle async
2704 target events simultaneously. There's also no point
2705 either in having the target always stop all threads,
2706 when we're going to pass signals down without
2707 informing GDB. */
2708 if (!non_stop)
2709 {
2710 if (start_non_stop (1))
2711 non_stop = 1;
2712
2713 /* Detaching implicitly resumes all threads; simply
2714 disconnecting does not. */
2715 }
2716 }
2717 else
2718 {
2719 fprintf (stderr,
2720 "Disconnected tracing disabled; stopping trace run.\n");
2721 stop_tracing ();
2722 }
2723 }
bd99dc85
PA
2724 }
2725}
01f9e8fa 2726
bd99dc85
PA
2727/* Event loop callback that handles a serial event. The first byte in
2728 the serial buffer gets us here. We expect characters to arrive at
2729 a brisk pace, so we read the rest of the packet with a blocking
2730 getpkt call. */
01f9e8fa 2731
8336d594 2732static int
bd99dc85
PA
2733process_serial_event (void)
2734{
2735 char ch;
2736 int i = 0;
2737 int signal;
2738 unsigned int len;
764880b7 2739 int res;
bd99dc85 2740 CORE_ADDR mem_addr;
95954743 2741 int pid;
bd99dc85
PA
2742 unsigned char sig;
2743 int packet_len;
2744 int new_packet_len = -1;
2745
2746 /* Used to decide when gdbserver should exit in
2747 multi-mode/remote. */
2748 static int have_ran = 0;
2749
2750 if (!have_ran)
2751 have_ran = target_running ();
2752
2753 disable_async_io ();
2754
2755 response_needed = 0;
2756 packet_len = getpkt (own_buf);
2757 if (packet_len <= 0)
2758 {
bd99dc85 2759 remote_close ();
8336d594
PA
2760 /* Force an event loop break. */
2761 return -1;
bd99dc85
PA
2762 }
2763 response_needed = 1;
2764
2765 i = 0;
2766 ch = own_buf[i++];
2767 switch (ch)
2768 {
2769 case 'q':
2770 handle_query (own_buf, packet_len, &new_packet_len);
2771 break;
2772 case 'Q':
2773 handle_general_set (own_buf);
2774 break;
2775 case 'D':
2776 require_running (own_buf);
95954743
PA
2777
2778 if (multi_process)
2779 {
2780 i++; /* skip ';' */
2781 pid = strtol (&own_buf[i], NULL, 16);
2782 }
2783 else
2784 pid =
2785 ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
2786
8336d594
PA
2787 if (tracing && disconnected_tracing)
2788 {
2789 struct thread_resume resume_info;
2790 struct process_info *process = find_process_pid (pid);
2791
2792 if (process == NULL)
2793 {
2794 write_enn (own_buf);
2795 break;
2796 }
2797
2798 fprintf (stderr,
2799 "Disconnected tracing in effect, "
2800 "leaving gdbserver attached to the process\n");
2801
2802 /* Make sure we're in non-stop/async mode, so we we can both
2803 wait for an async socket accept, and handle async target
2804 events simultaneously. There's also no point either in
2805 having the target stop all threads, when we're going to
2806 pass signals down without informing GDB. */
2807 if (!non_stop)
2808 {
2809 if (debug_threads)
2810 fprintf (stderr, "Forcing non-stop mode\n");
2811
2812 non_stop = 1;
2813 start_non_stop (1);
2814 }
2815
2816 process->gdb_detached = 1;
2817
2818 /* Detaching implicitly resumes all threads. */
2819 resume_info.thread = minus_one_ptid;
2820 resume_info.kind = resume_continue;
2821 resume_info.sig = 0;
2822 (*the_target->resume) (&resume_info, 1);
2823
2824 write_ok (own_buf);
2825 break; /* from switch/case */
2826 }
2827
95954743 2828 fprintf (stderr, "Detaching from process %d\n", pid);
8336d594 2829 stop_tracing ();
95954743 2830 if (detach_inferior (pid) != 0)
bd99dc85
PA
2831 write_enn (own_buf);
2832 else
2833 {
95954743 2834 discard_queued_stop_replies (pid);
bd99dc85
PA
2835 write_ok (own_buf);
2836
2837 if (extended_protocol)
c906108c 2838 {
bd99dc85
PA
2839 /* Treat this like a normal program exit. */
2840 last_status.kind = TARGET_WAITKIND_EXITED;
2841 last_status.value.integer = 0;
95954743 2842 last_ptid = pid_to_ptid (pid);
2d717e4f 2843
bd99dc85
PA
2844 current_inferior = NULL;
2845 }
2846 else
2847 {
2848 putpkt (own_buf);
2849 remote_close ();
2850
2851 /* If we are attached, then we can exit. Otherwise, we
2852 need to hang around doing nothing, until the child is
2853 gone. */
95954743
PA
2854 for_each_inferior (&all_processes,
2855 join_inferiors_callback);
bd99dc85
PA
2856 exit (0);
2857 }
2858 }
2859 break;
2860 case '!':
2861 extended_protocol = 1;
2862 write_ok (own_buf);
2863 break;
2864 case '?':
2865 handle_status (own_buf);
2866 break;
2867 case 'H':
2868 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
2869 {
95954743
PA
2870 ptid_t gdb_id, thread_id;
2871 int pid;
bd99dc85
PA
2872
2873 require_running (own_buf);
95954743
PA
2874
2875 gdb_id = read_ptid (&own_buf[2], NULL);
2876
2877 pid = ptid_get_pid (gdb_id);
2878
2879 if (ptid_equal (gdb_id, null_ptid)
2880 || ptid_equal (gdb_id, minus_one_ptid))
2881 thread_id = null_ptid;
2882 else if (pid != 0
2883 && ptid_equal (pid_to_ptid (pid),
2884 gdb_id))
2885 {
2886 struct thread_info *thread =
2887 (struct thread_info *) find_inferior (&all_threads,
2888 first_thread_of,
2889 &pid);
2890 if (!thread)
2891 {
2892 write_enn (own_buf);
2893 break;
2894 }
2895
2896 thread_id = ((struct inferior_list_entry *)thread)->id;
2897 }
bd99dc85
PA
2898 else
2899 {
2900 thread_id = gdb_id_to_thread_id (gdb_id);
95954743 2901 if (ptid_equal (thread_id, null_ptid))
c906108c 2902 {
a06660f7 2903 write_enn (own_buf);
c906108c
SS
2904 break;
2905 }
c906108c
SS
2906 }
2907
bd99dc85 2908 if (own_buf[1] == 'g')
c906108c 2909 {
95954743 2910 if (ptid_equal (thread_id, null_ptid))
c906108c 2911 {
bd99dc85
PA
2912 /* GDB is telling us to choose any thread. Check if
2913 the currently selected thread is still valid. If
2914 it is not, select the first available. */
2915 struct thread_info *thread =
2916 (struct thread_info *) find_inferior_id (&all_threads,
2917 general_thread);
2918 if (thread == NULL)
2919 thread_id = all_threads.head->id;
c906108c 2920 }
bd99dc85
PA
2921
2922 general_thread = thread_id;
2923 set_desired_inferior (1);
c906108c 2924 }
bd99dc85
PA
2925 else if (own_buf[1] == 'c')
2926 cont_thread = thread_id;
2927 else if (own_buf[1] == 's')
2928 step_thread = thread_id;
c906108c 2929
bd99dc85
PA
2930 write_ok (own_buf);
2931 }
2932 else
2933 {
2934 /* Silently ignore it so that gdb can extend the protocol
2935 without compatibility headaches. */
2936 own_buf[0] = '\0';
2d717e4f 2937 }
bd99dc85
PA
2938 break;
2939 case 'g':
219f2f23
PA
2940 require_running (own_buf);
2941 if (current_traceframe >= 0)
2942 {
2943 struct regcache *regcache = new_register_cache ();
2944
2945 if (fetch_traceframe_registers (current_traceframe,
2946 regcache, -1) == 0)
2947 registers_to_string (regcache, own_buf);
2948 else
2949 write_enn (own_buf);
2950 free_register_cache (regcache);
2951 }
2952 else
2953 {
2954 struct regcache *regcache;
2955
2956 set_desired_inferior (1);
2957 regcache = get_thread_regcache (current_inferior, 1);
2958 registers_to_string (regcache, own_buf);
2959 }
bd99dc85
PA
2960 break;
2961 case 'G':
219f2f23
PA
2962 require_running (own_buf);
2963 if (current_traceframe >= 0)
2964 write_enn (own_buf);
2965 else
2966 {
442ea881
PA
2967 struct regcache *regcache;
2968
442ea881
PA
2969 set_desired_inferior (1);
2970 regcache = get_thread_regcache (current_inferior, 1);
2971 registers_from_string (regcache, &own_buf[1]);
2972 write_ok (own_buf);
2973 }
bd99dc85
PA
2974 break;
2975 case 'm':
2976 require_running (own_buf);
2977 decode_m_packet (&own_buf[1], &mem_addr, &len);
764880b7
PA
2978 res = gdb_read_memory (mem_addr, mem_buf, len);
2979 if (res < 0)
bd99dc85 2980 write_enn (own_buf);
764880b7
PA
2981 else
2982 convert_int_to_ascii (mem_buf, own_buf, res);
bd99dc85
PA
2983 break;
2984 case 'M':
2985 require_running (own_buf);
fa593d66 2986 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
90d74c30 2987 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
bd99dc85
PA
2988 write_ok (own_buf);
2989 else
2990 write_enn (own_buf);
2991 break;
2992 case 'X':
2993 require_running (own_buf);
2994 if (decode_X_packet (&own_buf[1], packet_len - 1,
fa593d66 2995 &mem_addr, &len, &mem_buf) < 0
90d74c30 2996 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
bd99dc85
PA
2997 write_enn (own_buf);
2998 else
2999 write_ok (own_buf);
3000 break;
3001 case 'C':
3002 require_running (own_buf);
3003 convert_ascii_to_int (own_buf + 1, &sig, 1);
3004 if (target_signal_to_host_p (sig))
3005 signal = target_signal_to_host (sig);
3006 else
3007 signal = 0;
3008 myresume (own_buf, 0, signal);
3009 break;
3010 case 'S':
3011 require_running (own_buf);
3012 convert_ascii_to_int (own_buf + 1, &sig, 1);
3013 if (target_signal_to_host_p (sig))
3014 signal = target_signal_to_host (sig);
3015 else
3016 signal = 0;
3017 myresume (own_buf, 1, signal);
3018 break;
3019 case 'c':
3020 require_running (own_buf);
3021 signal = 0;
3022 myresume (own_buf, 0, signal);
3023 break;
3024 case 's':
3025 require_running (own_buf);
3026 signal = 0;
3027 myresume (own_buf, 1, signal);
3028 break;
c6314022
AR
3029 case 'Z': /* insert_ ... */
3030 /* Fallthrough. */
3031 case 'z': /* remove_ ... */
bd99dc85
PA
3032 {
3033 char *lenptr;
3034 char *dataptr;
3035 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
3036 int len = strtol (lenptr + 1, &dataptr, 16);
3037 char type = own_buf[1];
c6314022 3038 int res;
d993e290 3039 const int insert = ch == 'Z';
c6314022 3040
d993e290
PA
3041 /* Default to unrecognized/unsupported. */
3042 res = 1;
3043 switch (type)
3044 {
3045 case '0': /* software-breakpoint */
3046 case '1': /* hardware-breakpoint */
3047 case '2': /* write watchpoint */
3048 case '3': /* read watchpoint */
3049 case '4': /* access watchpoint */
3050 require_running (own_buf);
3051 if (insert && the_target->insert_point != NULL)
3052 res = (*the_target->insert_point) (type, addr, len);
3053 else if (!insert && the_target->remove_point != NULL)
3054 res = (*the_target->remove_point) (type, addr, len);
3055 break;
3056 default:
3057 break;
3058 }
bd99dc85 3059
c6314022
AR
3060 if (res == 0)
3061 write_ok (own_buf);
3062 else if (res == 1)
3063 /* Unsupported. */
3064 own_buf[0] = '\0';
bd99dc85 3065 else
c6314022 3066 write_enn (own_buf);
bd99dc85
PA
3067 break;
3068 }
3069 case 'k':
3070 response_needed = 0;
3071 if (!target_running ())
95954743
PA
3072 /* The packet we received doesn't make sense - but we can't
3073 reply to it, either. */
8336d594 3074 return 0;
c906108c 3075
95954743
PA
3076 fprintf (stderr, "Killing all inferiors\n");
3077 for_each_inferior (&all_processes, kill_inferior_callback);
c906108c 3078
bd99dc85
PA
3079 /* When using the extended protocol, we wait with no program
3080 running. The traditional protocol will exit instead. */
3081 if (extended_protocol)
3082 {
3083 last_status.kind = TARGET_WAITKIND_EXITED;
3084 last_status.value.sig = TARGET_SIGNAL_KILL;
8336d594 3085 return 0;
bd99dc85
PA
3086 }
3087 else
8336d594
PA
3088 exit (0);
3089
bd99dc85
PA
3090 case 'T':
3091 {
95954743 3092 ptid_t gdb_id, thread_id;
bd99dc85
PA
3093
3094 require_running (own_buf);
95954743
PA
3095
3096 gdb_id = read_ptid (&own_buf[1], NULL);
bd99dc85 3097 thread_id = gdb_id_to_thread_id (gdb_id);
95954743 3098 if (ptid_equal (thread_id, null_ptid))
bd99dc85
PA
3099 {
3100 write_enn (own_buf);
3101 break;
3102 }
3103
3104 if (mythread_alive (thread_id))
3105 write_ok (own_buf);
3106 else
3107 write_enn (own_buf);
3108 }
3109 break;
3110 case 'R':
3111 response_needed = 0;
3112
3113 /* Restarting the inferior is only supported in the extended
3114 protocol. */
3115 if (extended_protocol)
3116 {
3117 if (target_running ())
95954743
PA
3118 for_each_inferior (&all_processes,
3119 kill_inferior_callback);
bd99dc85
PA
3120 fprintf (stderr, "GDBserver restarting\n");
3121
3122 /* Wait till we are at 1st instruction in prog. */
3123 if (program_argv != NULL)
3124 start_inferior (program_argv);
3125 else
3126 {
3127 last_status.kind = TARGET_WAITKIND_EXITED;
3128 last_status.value.sig = TARGET_SIGNAL_KILL;
3129 }
8336d594 3130 return 0;
c906108c
SS
3131 }
3132 else
3133 {
bd99dc85
PA
3134 /* It is a request we don't understand. Respond with an
3135 empty packet so that gdb knows that we don't support this
3136 request. */
3137 own_buf[0] = '\0';
3138 break;
3139 }
3140 case 'v':
3141 /* Extended (long) request. */
3142 handle_v_requests (own_buf, packet_len, &new_packet_len);
3143 break;
3144
3145 default:
3146 /* It is a request we don't understand. Respond with an empty
3147 packet so that gdb knows that we don't support this
3148 request. */
3149 own_buf[0] = '\0';
3150 break;
3151 }
3152
3153 if (new_packet_len != -1)
3154 putpkt_binary (own_buf, new_packet_len);
3155 else
3156 putpkt (own_buf);
3157
3158 response_needed = 0;
3159
3160 if (!extended_protocol && have_ran && !target_running ())
3161 {
3162 /* In non-stop, defer exiting until GDB had a chance to query
3163 the whole vStopped list (until it gets an OK). */
3164 if (!notif_queue)
3165 {
3166 fprintf (stderr, "GDBserver exiting\n");
c906108c 3167 remote_close ();
bd99dc85 3168 exit (0);
c906108c
SS
3169 }
3170 }
8336d594
PA
3171
3172 if (exit_requested)
3173 return -1;
3174
3175 return 0;
c906108c 3176}
bd99dc85
PA
3177
3178/* Event-loop callback for serial events. */
3179
8336d594 3180int
bd99dc85
PA
3181handle_serial_event (int err, gdb_client_data client_data)
3182{
3183 if (debug_threads)
3184 fprintf (stderr, "handling possible serial event\n");
3185
3186 /* Really handle it. */
8336d594
PA
3187 if (process_serial_event () < 0)
3188 return -1;
bd99dc85
PA
3189
3190 /* Be sure to not change the selected inferior behind GDB's back.
3191 Important in the non-stop mode asynchronous protocol. */
3192 set_desired_inferior (1);
8336d594
PA
3193
3194 return 0;
bd99dc85
PA
3195}
3196
3197/* Event-loop callback for target events. */
3198
8336d594 3199int
bd99dc85
PA
3200handle_target_event (int err, gdb_client_data client_data)
3201{
3202 if (debug_threads)
3203 fprintf (stderr, "handling possible target event\n");
3204
95954743
PA
3205 last_ptid = mywait (minus_one_ptid, &last_status,
3206 TARGET_WNOHANG, 1);
bd99dc85
PA
3207
3208 if (last_status.kind != TARGET_WAITKIND_IGNORE)
3209 {
8336d594
PA
3210 int pid = ptid_get_pid (last_ptid);
3211 struct process_info *process = find_process_pid (pid);
3212 int forward_event = !gdb_connected () || process->gdb_detached;
3213
3214 if (last_status.kind == TARGET_WAITKIND_EXITED
3215 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
f9e39928
PA
3216 {
3217 mark_breakpoints_out (process);
3218 mourn_inferior (process);
3219 }
ce1a5b52 3220 else
d20a8ad9
PA
3221 {
3222 /* We're reporting this thread as stopped. Update its
3223 "want-stopped" state to what the client wants, until it
3224 gets a new resume action. */
3225 current_inferior->last_resume_kind = resume_stop;
3226 current_inferior->last_status = last_status;
3227 }
8336d594
PA
3228
3229 if (forward_event)
3230 {
3231 if (!target_running ())
3232 {
3233 /* The last process exited. We're done. */
3234 exit (0);
3235 }
3236
3237 if (last_status.kind == TARGET_WAITKIND_STOPPED)
3238 {
3239 /* A thread stopped with a signal, but gdb isn't
3240 connected to handle it. Pass it down to the
3241 inferior, as if it wasn't being traced. */
3242 struct thread_resume resume_info;
3243
3244 if (debug_threads)
3245 fprintf (stderr,
3246 "GDB not connected; forwarding event %d for [%s]\n",
3247 (int) last_status.kind,
3248 target_pid_to_str (last_ptid));
3249
3250 resume_info.thread = last_ptid;
3251 resume_info.kind = resume_continue;
30d50328 3252 resume_info.sig = target_signal_to_host (last_status.value.sig);
8336d594
PA
3253 (*the_target->resume) (&resume_info, 1);
3254 }
3255 else if (debug_threads)
3256 fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n",
3257 (int) last_status.kind,
3258 target_pid_to_str (last_ptid));
3259 }
3260 else
3261 {
3262 /* Something interesting. Tell GDB about it. */
3263 push_event (last_ptid, &last_status);
3264 }
bd99dc85
PA
3265 }
3266
3267 /* Be sure to not change the selected inferior behind GDB's back.
3268 Important in the non-stop mode asynchronous protocol. */
3269 set_desired_inferior (1);
8336d594
PA
3270
3271 return 0;
bd99dc85 3272}
This page took 0.990942 seconds and 4 git commands to generate.