Fix PR gdb/18653: gdb disturbs inferior's inherited signal dispositions
[deliverable/binutils-gdb.git] / gdb / gdbserver / server.c
CommitLineData
c906108c 1/* Main code for remote server for GDB.
618f726f 2 Copyright (C) 1989-2016 Free Software Foundation, Inc.
c906108c 3
c5aa993b 4 This file is part of GDB.
c906108c 5
c5aa993b
JM
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
a9762ec7 8 the Free Software Foundation; either version 3 of the License, or
c5aa993b 9 (at your option) any later version.
c906108c 10
c5aa993b
JM
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
c906108c 15
c5aa993b 16 You should have received a copy of the GNU General Public License
a9762ec7 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
18
19#include "server.h"
623b6bdf 20#include "gdbthread.h"
d1feda86 21#include "agent.h"
14a00470 22#include "notif.h"
3aee8918 23#include "tdesc.h"
9c3d6531 24#include "rsp-low.h"
f348d89a 25#include "signals-state-save-restore.h"
87ce2a04 26#include <ctype.h>
a9fa9f7d 27#include <unistd.h>
68070c10 28#if HAVE_SIGNAL_H
a9fa9f7d 29#include <signal.h>
68070c10 30#endif
87ce2a04 31#include "gdb_vecs.h"
8bdce1ff 32#include "gdb_wait.h"
9accd112 33#include "btrace-common.h"
602e3198 34#include "filestuff.h"
c144c7a0 35#include "tracepoint.h"
799cdc37 36#include "dll.h"
533b0600 37#include "hostio.h"
a9fa9f7d 38
122f36ef
PA
39/* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
40e91bc7 44 multi-process), or a specific thread ptid_t. */
95954743 45ptid_t cont_thread;
122f36ef
PA
46
47/* The thread set with an `Hg' packet. */
95954743 48ptid_t general_thread;
5b1c542e 49
0d62e5e8
DJ
50int server_waiting;
51
17b1509a 52static int extended_protocol;
2d717e4f
DJ
53static int response_needed;
54static int exit_requested;
55
03f2bd59
JK
56/* --once: Exit after the first connection has closed. */
57int run_once;
58
95954743 59int multi_process;
89245bc0
DB
60int report_fork_events;
61int report_vfork_events;
94585166 62int report_exec_events;
65706a29 63int report_thread_events;
f2faf941
PA
64
65/* Whether to report TARGET_WAITKING_NO_RESUMED events. */
66static int report_no_resumed;
67
bd99dc85 68int non_stop;
1ec68e26
PA
69int swbreak_feature;
70int hwbreak_feature;
bd99dc85 71
750ce8d1
YQ
72/* True if the "vContSupported" feature is active. In that case, GDB
73 wants us to report whether single step is supported in the reply to
74 "vCont?" packet. */
75static int vCont_supported;
76
03583c20
UW
77/* Whether we should attempt to disable the operating system's address
78 space randomization feature before starting an inferior. */
79int disable_randomization = 1;
80
ccd213ac 81static char **program_argv, **wrapper_argv;
2d717e4f 82
a493e3e2
PA
83int pass_signals[GDB_SIGNAL_LAST];
84int program_signals[GDB_SIGNAL_LAST];
9b224c5e 85int program_signals_p;
89be2091 86
a9fa9f7d
DJ
87/* The PID of the originally created or attached inferior. Used to
88 send signals to the process when GDB sends us an asynchronous interrupt
89 (user hitting Control-C in the client), and to wait for the child to exit
90 when no longer debugging it. */
91
a1928bad 92unsigned long signal_pid;
a9fa9f7d 93
290fadea
RS
94#ifdef SIGTTOU
95/* A file descriptor for the controlling terminal. */
96int terminal_fd;
97
98/* TERMINAL_FD's original foreground group. */
99pid_t old_foreground_pgrp;
100
101/* Hand back terminal ownership to the original foreground group. */
102
103static void
104restore_old_foreground_pgrp (void)
105{
106 tcsetpgrp (terminal_fd, old_foreground_pgrp);
107}
108#endif
109
ec56be1b
PA
110/* Set if you want to disable optional thread related packets support
111 in gdbserver, for the sake of testing GDB against stubs that don't
112 support them. */
113int disable_packet_vCont;
114int disable_packet_Tthread;
115int disable_packet_qC;
116int disable_packet_qfThreadInfo;
117
5b1c542e
PA
118/* Last status reported to GDB. */
119static struct target_waitstatus last_status;
95954743 120static ptid_t last_ptid;
5b1c542e 121
28170b88 122char *own_buf;
bd99dc85
PA
123static unsigned char *mem_buf;
124
14a00470
YQ
125/* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
128
bd99dc85
PA
129struct vstop_notif
130{
14a00470 131 struct notif_event base;
bd99dc85
PA
132
133 /* Thread or process that got the event. */
95954743 134 ptid_t ptid;
bd99dc85
PA
135
136 /* Event info. */
137 struct target_waitstatus status;
138};
139
f4abbc16
MM
140/* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142static struct btrace_config current_btrace_conf;
143
14a00470 144DEFINE_QUEUE_P (notif_event_p);
bd99dc85
PA
145
146/* Put a stop reply to the stop reply queue. */
147
148static void
95954743 149queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
bd99dc85 150{
8d749320 151 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
bd99dc85 152
bd99dc85
PA
153 new_notif->ptid = ptid;
154 new_notif->status = *status;
155
14a00470 156 notif_event_enque (&notif_stop, (struct notif_event *) new_notif);
bd99dc85
PA
157}
158
14a00470 159static int
465a859e
PA
160remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
161 QUEUE_ITER (notif_event_p) *iter,
162 struct notif_event *event,
163 void *data)
bd99dc85 164{
465a859e
PA
165 ptid_t filter_ptid = *(ptid_t *) data;
166 struct vstop_notif *vstop_event = (struct vstop_notif *) event;
d20a8ad9 167
465a859e 168 if (ptid_match (vstop_event->ptid, filter_ptid))
bd99dc85 169 {
14a00470
YQ
170 if (q->free_func != NULL)
171 q->free_func (event);
172
173 QUEUE_remove_elem (notif_event_p, q, iter);
bd99dc85 174 }
14a00470
YQ
175
176 return 1;
bd99dc85
PA
177}
178
465a859e 179/* See server.h. */
bd99dc85 180
465a859e
PA
181void
182discard_queued_stop_replies (ptid_t ptid)
bd99dc85 183{
14a00470 184 QUEUE_iterate (notif_event_p, notif_stop.queue,
465a859e 185 remove_all_on_match_ptid, &ptid);
bd99dc85
PA
186}
187
bd99dc85 188static void
14a00470 189vstop_notif_reply (struct notif_event *event, char *own_buf)
bd99dc85 190{
14a00470
YQ
191 struct vstop_notif *vstop = (struct vstop_notif *) event;
192
193 prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
bd99dc85
PA
194}
195
14a00470
YQ
196struct notif_server notif_stop =
197{
198 "vStopped", "Stop", NULL, vstop_notif_reply,
199};
200
2d717e4f
DJ
201static int
202target_running (void)
203{
649ebbca 204 return get_first_thread () != NULL;
2d717e4f
DJ
205}
206
fc620387 207static int
5b1c542e 208start_inferior (char **argv)
c906108c 209{
ccd213ac 210 char **new_argv = argv;
2d717e4f 211
ccd213ac
DJ
212 if (wrapper_argv != NULL)
213 {
214 int i, count = 1;
215
216 for (i = 0; wrapper_argv[i] != NULL; i++)
217 count++;
218 for (i = 0; argv[i] != NULL; i++)
219 count++;
8d749320 220 new_argv = XALLOCAVEC (char *, count);
ccd213ac
DJ
221 count = 0;
222 for (i = 0; wrapper_argv[i] != NULL; i++)
223 new_argv[count++] = wrapper_argv[i];
224 for (i = 0; argv[i] != NULL; i++)
225 new_argv[count++] = argv[i];
226 new_argv[count] = NULL;
227 }
228
65730243
DE
229 if (debug_threads)
230 {
231 int i;
232 for (i = 0; new_argv[i]; ++i)
87ce2a04
DE
233 debug_printf ("new_argv[%d] = \"%s\"\n", i, new_argv[i]);
234 debug_flush ();
65730243
DE
235 }
236
b80864fb 237#ifdef SIGTTOU
a9fa9f7d
DJ
238 signal (SIGTTOU, SIG_DFL);
239 signal (SIGTTIN, SIG_DFL);
b80864fb 240#endif
a9fa9f7d 241
ccd213ac 242 signal_pid = create_inferior (new_argv[0], new_argv);
0d62e5e8 243
c588c53c
MS
244 /* FIXME: we don't actually know at this point that the create
245 actually succeeded. We won't know that until we wait. */
a1928bad 246 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
a9fa9f7d 247 signal_pid);
b80864fb 248 fflush (stderr);
a9fa9f7d 249
b80864fb 250#ifdef SIGTTOU
a9fa9f7d
DJ
251 signal (SIGTTOU, SIG_IGN);
252 signal (SIGTTIN, SIG_IGN);
290fadea
RS
253 terminal_fd = fileno (stderr);
254 old_foreground_pgrp = tcgetpgrp (terminal_fd);
255 tcsetpgrp (terminal_fd, signal_pid);
256 atexit (restore_old_foreground_pgrp);
b80864fb 257#endif
c906108c 258
ccd213ac
DJ
259 if (wrapper_argv != NULL)
260 {
261 struct thread_resume resume_info;
ccd213ac 262
ee47b2f8 263 memset (&resume_info, 0, sizeof (resume_info));
95954743 264 resume_info.thread = pid_to_ptid (signal_pid);
bd99dc85 265 resume_info.kind = resume_continue;
ccd213ac 266 resume_info.sig = 0;
ccd213ac 267
06db92f0 268 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
bd99dc85 269
eb97750b 270 if (last_status.kind == TARGET_WAITKIND_STOPPED)
ccd213ac 271 {
eb97750b
YQ
272 do
273 {
274 (*the_target->resume) (&resume_info, 1);
275
276 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
277 if (last_status.kind != TARGET_WAITKIND_STOPPED)
278 break;
279
280 current_thread->last_resume_kind = resume_stop;
281 current_thread->last_status = last_status;
282 }
283 while (last_status.value.sig != GDB_SIGNAL_TRAP);
ccd213ac 284 }
ece66d65 285 target_post_create_inferior ();
5b1c542e 286 return signal_pid;
ccd213ac
DJ
287 }
288
5b1c542e
PA
289 /* Wait till we are at 1st instruction in program, return new pid
290 (assuming success). */
95954743 291 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
5b1c542e 292
ece66d65 293 target_post_create_inferior ();
c06cbd92 294
d20a8ad9
PA
295 if (last_status.kind != TARGET_WAITKIND_EXITED
296 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
297 {
0bfdf32f
GB
298 current_thread->last_resume_kind = resume_stop;
299 current_thread->last_status = last_status;
d20a8ad9 300 }
80ad801e
PA
301 else
302 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
d20a8ad9 303
5b1c542e 304 return signal_pid;
c906108c
SS
305}
306
45b7b345 307static int
5b1c542e 308attach_inferior (int pid)
45b7b345
DJ
309{
310 /* myattach should return -1 if attaching is unsupported,
311 0 if it succeeded, and call error() otherwise. */
a9fa9f7d 312
45b7b345
DJ
313 if (myattach (pid) != 0)
314 return -1;
315
6910d122 316 fprintf (stderr, "Attached; pid = %d\n", pid);
b80864fb 317 fflush (stderr);
6910d122 318
a9fa9f7d
DJ
319 /* FIXME - It may be that we should get the SIGNAL_PID from the
320 attach function, so that it can be the main thread instead of
321 whichever we were told to attach to. */
322 signal_pid = pid;
323
bd99dc85
PA
324 if (!non_stop)
325 {
95954743 326 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
bd99dc85
PA
327
328 /* GDB knows to ignore the first SIGSTOP after attaching to a running
329 process using the "attach" command, but this is different; it's
330 just using "target remote". Pretend it's just starting up. */
331 if (last_status.kind == TARGET_WAITKIND_STOPPED
a493e3e2
PA
332 && last_status.value.sig == GDB_SIGNAL_STOP)
333 last_status.value.sig = GDB_SIGNAL_TRAP;
d20a8ad9 334
0bfdf32f
GB
335 current_thread->last_resume_kind = resume_stop;
336 current_thread->last_status = last_status;
bd99dc85 337 }
9db87ebd 338
45b7b345
DJ
339 return 0;
340}
341
c906108c 342extern int remote_debug;
ce3a066d 343
0876f84a
DJ
344/* Decode a qXfer read request. Return 0 if everything looks OK,
345 or -1 otherwise. */
346
347static int
d08aafef 348decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
0876f84a 349{
d08aafef
PA
350 /* After the read marker and annex, qXfer looks like a
351 traditional 'm' packet. */
352 decode_m_packet (buf, ofs, len);
353
354 return 0;
355}
356
357static int
358decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset)
359{
360 /* Extract and NUL-terminate the object. */
361 *object = buf;
362 while (*buf && *buf != ':')
363 buf++;
364 if (*buf == '\0')
365 return -1;
366 *buf++ = 0;
367
368 /* Extract and NUL-terminate the read/write action. */
369 *rw = buf;
370 while (*buf && *buf != ':')
371 buf++;
372 if (*buf == '\0')
373 return -1;
374 *buf++ = 0;
375
0876f84a
DJ
376 /* Extract and NUL-terminate the annex. */
377 *annex = buf;
378 while (*buf && *buf != ':')
379 buf++;
380 if (*buf == '\0')
381 return -1;
382 *buf++ = 0;
383
d08aafef 384 *offset = buf;
0876f84a
DJ
385 return 0;
386}
387
388/* Write the response to a successful qXfer read. Returns the
389 length of the (binary) data stored in BUF, corresponding
390 to as much of DATA/LEN as we could fit. IS_MORE controls
391 the first character of the response. */
392static int
f98cd059 393write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more)
0876f84a
DJ
394{
395 int out_len;
396
397 if (is_more)
398 buf[0] = 'm';
399 else
400 buf[0] = 'l';
401
124e13d9
SM
402 return remote_escape_output (data, len, 1, (unsigned char *) buf + 1,
403 &out_len, PBUFSIZ - 2) + 1;
0876f84a
DJ
404}
405
f4abbc16 406/* Handle btrace enabling in BTS format. */
9accd112
MM
407
408static const char *
f4abbc16 409handle_btrace_enable_bts (struct thread_info *thread)
9accd112
MM
410{
411 if (thread->btrace != NULL)
412 return "E.Btrace already enabled.";
413
f4abbc16
MM
414 current_btrace_conf.format = BTRACE_FORMAT_BTS;
415 thread->btrace = target_enable_btrace (thread->entry.id,
416 &current_btrace_conf);
9accd112
MM
417 if (thread->btrace == NULL)
418 return "E.Could not enable btrace.";
419
420 return NULL;
421}
422
bc504a31 423/* Handle btrace enabling in Intel Processor Trace format. */
b20a6524
MM
424
425static const char *
426handle_btrace_enable_pt (struct thread_info *thread)
427{
428 if (thread->btrace != NULL)
429 return "E.Btrace already enabled.";
430
431 current_btrace_conf.format = BTRACE_FORMAT_PT;
432 thread->btrace = target_enable_btrace (thread->entry.id,
433 &current_btrace_conf);
434 if (thread->btrace == NULL)
435 return "E.Could not enable btrace.";
436
437 return NULL;
438}
439
9accd112
MM
440/* Handle btrace disabling. */
441
442static const char *
443handle_btrace_disable (struct thread_info *thread)
444{
445
446 if (thread->btrace == NULL)
447 return "E.Branch tracing not enabled.";
448
449 if (target_disable_btrace (thread->btrace) != 0)
450 return "E.Could not disable branch tracing.";
451
452 thread->btrace = NULL;
453 return NULL;
454}
455
456/* Handle the "Qbtrace" packet. */
457
458static int
459handle_btrace_general_set (char *own_buf)
460{
461 struct thread_info *thread;
462 const char *err;
463 char *op;
464
61012eef 465 if (!startswith (own_buf, "Qbtrace:"))
9accd112
MM
466 return 0;
467
468 op = own_buf + strlen ("Qbtrace:");
469
9accd112
MM
470 if (ptid_equal (general_thread, null_ptid)
471 || ptid_equal (general_thread, minus_one_ptid))
472 {
473 strcpy (own_buf, "E.Must select a single thread.");
474 return -1;
475 }
476
477 thread = find_thread_ptid (general_thread);
478 if (thread == NULL)
479 {
480 strcpy (own_buf, "E.No such thread.");
481 return -1;
482 }
483
484 err = NULL;
485
486 if (strcmp (op, "bts") == 0)
f4abbc16 487 err = handle_btrace_enable_bts (thread);
b20a6524
MM
488 else if (strcmp (op, "pt") == 0)
489 err = handle_btrace_enable_pt (thread);
9accd112
MM
490 else if (strcmp (op, "off") == 0)
491 err = handle_btrace_disable (thread);
492 else
b20a6524 493 err = "E.Bad Qbtrace operation. Use bts, pt, or off.";
9accd112
MM
494
495 if (err != 0)
496 strcpy (own_buf, err);
497 else
498 write_ok (own_buf);
499
500 return 1;
501}
502
d33501a5
MM
503/* Handle the "Qbtrace-conf" packet. */
504
505static int
506handle_btrace_conf_general_set (char *own_buf)
507{
508 struct thread_info *thread;
509 char *op;
510
61012eef 511 if (!startswith (own_buf, "Qbtrace-conf:"))
d33501a5
MM
512 return 0;
513
514 op = own_buf + strlen ("Qbtrace-conf:");
515
516 if (ptid_equal (general_thread, null_ptid)
517 || ptid_equal (general_thread, minus_one_ptid))
518 {
519 strcpy (own_buf, "E.Must select a single thread.");
520 return -1;
521 }
522
523 thread = find_thread_ptid (general_thread);
524 if (thread == NULL)
525 {
526 strcpy (own_buf, "E.No such thread.");
527 return -1;
528 }
529
61012eef 530 if (startswith (op, "bts:size="))
d33501a5
MM
531 {
532 unsigned long size;
533 char *endp = NULL;
534
535 errno = 0;
536 size = strtoul (op + strlen ("bts:size="), &endp, 16);
537 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
538 {
539 strcpy (own_buf, "E.Bad size value.");
540 return -1;
541 }
542
543 current_btrace_conf.bts.size = (unsigned int) size;
544 }
b20a6524
MM
545 else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0)
546 {
547 unsigned long size;
548 char *endp = NULL;
549
550 errno = 0;
551 size = strtoul (op + strlen ("pt:size="), &endp, 16);
552 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
553 {
554 strcpy (own_buf, "E.Bad size value.");
555 return -1;
556 }
557
558 current_btrace_conf.pt.size = (unsigned int) size;
559 }
d33501a5
MM
560 else
561 {
562 strcpy (own_buf, "E.Bad Qbtrace configuration option.");
563 return -1;
564 }
565
566 write_ok (own_buf);
567 return 1;
568}
569
89be2091 570/* Handle all of the extended 'Q' packets. */
ae1ada35
DE
571
572static void
89be2091
DJ
573handle_general_set (char *own_buf)
574{
61012eef 575 if (startswith (own_buf, "QPassSignals:"))
89be2091 576 {
a493e3e2 577 int numsigs = (int) GDB_SIGNAL_LAST, i;
89be2091
DJ
578 const char *p = own_buf + strlen ("QPassSignals:");
579 CORE_ADDR cursig;
580
581 p = decode_address_to_semicolon (&cursig, p);
582 for (i = 0; i < numsigs; i++)
583 {
584 if (i == cursig)
585 {
586 pass_signals[i] = 1;
587 if (*p == '\0')
588 /* Keep looping, to clear the remaining signals. */
589 cursig = -1;
590 else
591 p = decode_address_to_semicolon (&cursig, p);
592 }
593 else
594 pass_signals[i] = 0;
595 }
596 strcpy (own_buf, "OK");
597 return;
598 }
599
61012eef 600 if (startswith (own_buf, "QProgramSignals:"))
9b224c5e 601 {
a493e3e2 602 int numsigs = (int) GDB_SIGNAL_LAST, i;
9b224c5e
PA
603 const char *p = own_buf + strlen ("QProgramSignals:");
604 CORE_ADDR cursig;
605
606 program_signals_p = 1;
607
608 p = decode_address_to_semicolon (&cursig, p);
609 for (i = 0; i < numsigs; i++)
610 {
611 if (i == cursig)
612 {
613 program_signals[i] = 1;
614 if (*p == '\0')
615 /* Keep looping, to clear the remaining signals. */
616 cursig = -1;
617 else
618 p = decode_address_to_semicolon (&cursig, p);
619 }
620 else
621 program_signals[i] = 0;
622 }
623 strcpy (own_buf, "OK");
624 return;
625 }
626
82075af2
JS
627 if (startswith (own_buf, "QCatchSyscalls:"))
628 {
629 const char *p = own_buf + sizeof ("QCatchSyscalls:") - 1;
630 int enabled = -1;
631 CORE_ADDR sysno;
632 struct process_info *process;
633
634 if (!target_running () || !target_supports_catch_syscall ())
635 {
636 write_enn (own_buf);
637 return;
638 }
639
640 if (strcmp (p, "0") == 0)
641 enabled = 0;
642 else if (p[0] == '1' && (p[1] == ';' || p[1] == '\0'))
643 enabled = 1;
644 else
645 {
646 fprintf (stderr, "Unknown catch-syscalls mode requested: %s\n",
647 own_buf);
648 write_enn (own_buf);
649 return;
650 }
651
652 process = current_process ();
653 VEC_truncate (int, process->syscalls_to_catch, 0);
654
655 if (enabled)
656 {
657 p += 1;
658 if (*p == ';')
659 {
660 p += 1;
661 while (*p != '\0')
662 {
663 p = decode_address_to_semicolon (&sysno, p);
664 VEC_safe_push (int, process->syscalls_to_catch, (int) sysno);
665 }
666 }
667 else
668 VEC_safe_push (int, process->syscalls_to_catch, ANY_SYSCALL);
669 }
670
671 write_ok (own_buf);
672 return;
673 }
674
a6f3e723
SL
675 if (strcmp (own_buf, "QStartNoAckMode") == 0)
676 {
677 if (remote_debug)
678 {
679 fprintf (stderr, "[noack mode enabled]\n");
680 fflush (stderr);
681 }
682
683 noack_mode = 1;
684 write_ok (own_buf);
685 return;
686 }
687
61012eef 688 if (startswith (own_buf, "QNonStop:"))
bd99dc85
PA
689 {
690 char *mode = own_buf + 9;
691 int req = -1;
b2333d22 692 const char *req_str;
bd99dc85
PA
693
694 if (strcmp (mode, "0") == 0)
695 req = 0;
696 else if (strcmp (mode, "1") == 0)
697 req = 1;
698 else
699 {
700 /* We don't know what this mode is, so complain to
701 GDB. */
702 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
703 own_buf);
704 write_enn (own_buf);
705 return;
706 }
707
708 req_str = req ? "non-stop" : "all-stop";
709 if (start_non_stop (req) != 0)
710 {
711 fprintf (stderr, "Setting %s mode failed\n", req_str);
712 write_enn (own_buf);
713 return;
714 }
715
716 non_stop = req;
717
718 if (remote_debug)
719 fprintf (stderr, "[%s mode enabled]\n", req_str);
720
721 write_ok (own_buf);
722 return;
723 }
724
61012eef 725 if (startswith (own_buf, "QDisableRandomization:"))
03583c20
UW
726 {
727 char *packet = own_buf + strlen ("QDisableRandomization:");
728 ULONGEST setting;
729
730 unpack_varlen_hex (packet, &setting);
731 disable_randomization = setting;
732
733 if (remote_debug)
734 {
735 if (disable_randomization)
736 fprintf (stderr, "[address space randomization disabled]\n");
737 else
738 fprintf (stderr, "[address space randomization enabled]\n");
739 }
740
741 write_ok (own_buf);
742 return;
743 }
744
219f2f23
PA
745 if (target_supports_tracepoints ()
746 && handle_tracepoint_general_set (own_buf))
747 return;
748
61012eef 749 if (startswith (own_buf, "QAgent:"))
d1feda86
YQ
750 {
751 char *mode = own_buf + strlen ("QAgent:");
752 int req = 0;
753
754 if (strcmp (mode, "0") == 0)
755 req = 0;
756 else if (strcmp (mode, "1") == 0)
757 req = 1;
758 else
759 {
760 /* We don't know what this value is, so complain to GDB. */
761 sprintf (own_buf, "E.Unknown QAgent value");
762 return;
763 }
764
765 /* Update the flag. */
766 use_agent = req;
767 if (remote_debug)
768 fprintf (stderr, "[%s agent]\n", req ? "Enable" : "Disable");
769 write_ok (own_buf);
770 return;
771 }
772
9accd112
MM
773 if (handle_btrace_general_set (own_buf))
774 return;
775
d33501a5
MM
776 if (handle_btrace_conf_general_set (own_buf))
777 return;
778
65706a29
PA
779 if (startswith (own_buf, "QThreadEvents:"))
780 {
781 char *mode = own_buf + strlen ("QThreadEvents:");
782 enum tribool req = TRIBOOL_UNKNOWN;
783
784 if (strcmp (mode, "0") == 0)
785 req = TRIBOOL_FALSE;
786 else if (strcmp (mode, "1") == 0)
787 req = TRIBOOL_TRUE;
788 else
789 {
790 char *mode_copy = xstrdup (mode);
791
792 /* We don't know what this mode is, so complain to GDB. */
793 sprintf (own_buf, "E.Unknown thread-events mode requested: %s\n",
794 mode_copy);
795 xfree (mode_copy);
796 return;
797 }
798
799 report_thread_events = (req == TRIBOOL_TRUE);
800
801 if (remote_debug)
802 {
803 const char *req_str = report_thread_events ? "enabled" : "disabled";
804
805 fprintf (stderr, "[thread events are now %s]\n", req_str);
806 }
807
808 write_ok (own_buf);
809 return;
810 }
811
89be2091
DJ
812 /* Otherwise we didn't know what packet it was. Say we didn't
813 understand it. */
814 own_buf[0] = 0;
815}
816
23181151 817static const char *
fb1e4ffc 818get_features_xml (const char *annex)
23181151 819{
3aee8918
PA
820 const struct target_desc *desc = current_target_desc ();
821
822 /* `desc->xmltarget' defines what to return when looking for the
823 "target.xml" file. Its contents can either be verbatim XML code
824 (prefixed with a '@') or else the name of the actual XML file to
825 be used in place of "target.xml".
fb1e4ffc 826
9b4b61c8
UW
827 This variable is set up from the auto-generated
828 init_registers_... routine for the current target. */
fb1e4ffc 829
3aee8918 830 if (desc->xmltarget != NULL && strcmp (annex, "target.xml") == 0)
23181151 831 {
3aee8918
PA
832 if (*desc->xmltarget == '@')
833 return desc->xmltarget + 1;
23181151 834 else
3aee8918 835 annex = desc->xmltarget;
23181151
DJ
836 }
837
9b4b61c8
UW
838#ifdef USE_XML
839 {
840 extern const char *const xml_builtin[][2];
841 int i;
842
843 /* Look for the annex. */
844 for (i = 0; xml_builtin[i][0] != NULL; i++)
845 if (strcmp (annex, xml_builtin[i][0]) == 0)
846 break;
847
848 if (xml_builtin[i][0] != NULL)
849 return xml_builtin[i][1];
850 }
851#endif
852
853 return NULL;
23181151
DJ
854}
855
5b3da067 856static void
c74d0ad8
DJ
857monitor_show_help (void)
858{
859 monitor_output ("The following monitor commands are supported:\n");
860 monitor_output (" set debug <0|1>\n");
1b3f6016 861 monitor_output (" Enable general debugging messages\n");
aa5ca48f
DE
862 monitor_output (" set debug-hw-points <0|1>\n");
863 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
c74d0ad8
DJ
864 monitor_output (" set remote-debug <0|1>\n");
865 monitor_output (" Enable remote protocol debugging messages\n");
87ce2a04
DE
866 monitor_output (" set debug-format option1[,option2,...]\n");
867 monitor_output (" Add additional information to debugging messages\n");
868 monitor_output (" Options: all, none");
87ce2a04 869 monitor_output (", timestamp");
87ce2a04 870 monitor_output ("\n");
ecd7ecbc
DJ
871 monitor_output (" exit\n");
872 monitor_output (" Quit GDBserver\n");
c74d0ad8
DJ
873}
874
764880b7
PA
875/* Read trace frame or inferior memory. Returns the number of bytes
876 actually read, zero when no further transfer is possible, and -1 on
877 error. Return of a positive value smaller than LEN does not
878 indicate there's no more to be read, only the end of the transfer.
879 E.g., when GDB reads memory from a traceframe, a first request may
880 be served from a memory block that does not cover the whole request
881 length. A following request gets the rest served from either
882 another block (of the same traceframe) or from the read-only
883 regions. */
219f2f23
PA
884
885static int
90d74c30 886gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
219f2f23 887{
764880b7 888 int res;
90d74c30 889
219f2f23
PA
890 if (current_traceframe >= 0)
891 {
892 ULONGEST nbytes;
893 ULONGEST length = len;
894
895 if (traceframe_read_mem (current_traceframe,
896 memaddr, myaddr, len, &nbytes))
9a13b2fa 897 return -1;
219f2f23 898 /* Data read from trace buffer, we're done. */
764880b7
PA
899 if (nbytes > 0)
900 return nbytes;
219f2f23 901 if (!in_readonly_region (memaddr, length))
764880b7 902 return -1;
219f2f23
PA
903 /* Otherwise we have a valid readonly case, fall through. */
904 /* (assume no half-trace half-real blocks for now) */
905 }
906
764880b7
PA
907 res = prepare_to_access_memory ();
908 if (res == 0)
90d74c30 909 {
f0db101d
PA
910 if (set_desired_thread (1))
911 res = read_inferior_memory (memaddr, myaddr, len);
912 else
913 res = 1;
0146f85b 914 done_accessing_memory ();
90d74c30 915
764880b7
PA
916 return res == 0 ? len : -1;
917 }
918 else
919 return -1;
219f2f23
PA
920}
921
922/* Write trace frame or inferior memory. Actually, writing to trace
923 frames is forbidden. */
924
925static int
90d74c30 926gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
219f2f23
PA
927{
928 if (current_traceframe >= 0)
929 return EIO;
930 else
90d74c30
PA
931 {
932 int ret;
933
934 ret = prepare_to_access_memory ();
935 if (ret == 0)
936 {
f0db101d
PA
937 if (set_desired_thread (1))
938 ret = write_inferior_memory (memaddr, myaddr, len);
939 else
940 ret = EIO;
0146f85b 941 done_accessing_memory ();
90d74c30
PA
942 }
943 return ret;
944 }
219f2f23
PA
945}
946
08388c79
DE
947/* Subroutine of handle_search_memory to simplify it. */
948
949static int
950handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
951 gdb_byte *pattern, unsigned pattern_len,
952 gdb_byte *search_buf,
953 unsigned chunk_size, unsigned search_buf_size,
954 CORE_ADDR *found_addrp)
955{
956 /* Prime the search buffer. */
957
764880b7
PA
958 if (gdb_read_memory (start_addr, search_buf, search_buf_size)
959 != search_buf_size)
08388c79 960 {
b3dc46ff
AB
961 warning ("Unable to access %ld bytes of target "
962 "memory at 0x%lx, halting search.",
963 (long) search_buf_size, (long) start_addr);
08388c79
DE
964 return -1;
965 }
966
967 /* Perform the search.
968
969 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
970 When we've scanned N bytes we copy the trailing bytes to the start and
971 read in another N bytes. */
972
973 while (search_space_len >= pattern_len)
974 {
975 gdb_byte *found_ptr;
976 unsigned nr_search_bytes = (search_space_len < search_buf_size
977 ? search_space_len
978 : search_buf_size);
979
d6f85c84
SM
980 found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes, pattern,
981 pattern_len);
08388c79
DE
982
983 if (found_ptr != NULL)
984 {
985 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
986 *found_addrp = found_addr;
987 return 1;
988 }
989
990 /* Not found in this chunk, skip to next chunk. */
991
992 /* Don't let search_space_len wrap here, it's unsigned. */
993 if (search_space_len >= chunk_size)
994 search_space_len -= chunk_size;
995 else
996 search_space_len = 0;
997
998 if (search_space_len >= pattern_len)
999 {
1000 unsigned keep_len = search_buf_size - chunk_size;
8a35fb51 1001 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
08388c79
DE
1002 int nr_to_read;
1003
1004 /* Copy the trailing part of the previous iteration to the front
1005 of the buffer for the next iteration. */
1006 memcpy (search_buf, search_buf + chunk_size, keep_len);
1007
1008 nr_to_read = (search_space_len - keep_len < chunk_size
1009 ? search_space_len - keep_len
1010 : chunk_size);
1011
90d74c30 1012 if (gdb_read_memory (read_addr, search_buf + keep_len,
764880b7 1013 nr_to_read) != search_buf_size)
08388c79 1014 {
b3dc46ff 1015 warning ("Unable to access %ld bytes of target memory "
493e2a69 1016 "at 0x%lx, halting search.",
b3dc46ff 1017 (long) nr_to_read, (long) read_addr);
08388c79
DE
1018 return -1;
1019 }
1020
1021 start_addr += chunk_size;
1022 }
1023 }
1024
1025 /* Not found. */
1026
1027 return 0;
1028}
1029
1030/* Handle qSearch:memory packets. */
1031
1032static void
1033handle_search_memory (char *own_buf, int packet_len)
1034{
1035 CORE_ADDR start_addr;
1036 CORE_ADDR search_space_len;
1037 gdb_byte *pattern;
1038 unsigned int pattern_len;
1039 /* NOTE: also defined in find.c testcase. */
1040#define SEARCH_CHUNK_SIZE 16000
1041 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1042 /* Buffer to hold memory contents for searching. */
1043 gdb_byte *search_buf;
1044 unsigned search_buf_size;
1045 int found;
1046 CORE_ADDR found_addr;
1047 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
1048
224c3ddb 1049 pattern = (gdb_byte *) malloc (packet_len);
08388c79
DE
1050 if (pattern == NULL)
1051 {
5e1471f5 1052 error ("Unable to allocate memory to perform the search");
08388c79
DE
1053 strcpy (own_buf, "E00");
1054 return;
1055 }
1056 if (decode_search_memory_packet (own_buf + cmd_name_len,
1057 packet_len - cmd_name_len,
1058 &start_addr, &search_space_len,
1059 pattern, &pattern_len) < 0)
1060 {
1061 free (pattern);
5e1471f5 1062 error ("Error in parsing qSearch:memory packet");
08388c79
DE
1063 strcpy (own_buf, "E00");
1064 return;
1065 }
1066
1067 search_buf_size = chunk_size + pattern_len - 1;
1068
1069 /* No point in trying to allocate a buffer larger than the search space. */
1070 if (search_space_len < search_buf_size)
1071 search_buf_size = search_space_len;
1072
224c3ddb 1073 search_buf = (gdb_byte *) malloc (search_buf_size);
08388c79
DE
1074 if (search_buf == NULL)
1075 {
1076 free (pattern);
5e1471f5 1077 error ("Unable to allocate memory to perform the search");
08388c79
DE
1078 strcpy (own_buf, "E00");
1079 return;
1080 }
1081
1082 found = handle_search_memory_1 (start_addr, search_space_len,
1083 pattern, pattern_len,
1084 search_buf, chunk_size, search_buf_size,
1085 &found_addr);
1086
1087 if (found > 0)
1088 sprintf (own_buf, "1,%lx", (long) found_addr);
1089 else if (found == 0)
1090 strcpy (own_buf, "0");
1091 else
1092 strcpy (own_buf, "E00");
1093
1094 free (search_buf);
1095 free (pattern);
1096}
1097
2d717e4f
DJ
1098#define require_running(BUF) \
1099 if (!target_running ()) \
1100 { \
1101 write_enn (BUF); \
1102 return; \
1103 }
1104
87ce2a04
DE
1105/* Parse options to --debug-format= and "monitor set debug-format".
1106 ARG is the text after "--debug-format=" or "monitor set debug-format".
1107 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1108 This triggers calls to monitor_output.
1109 The result is NULL if all options were parsed ok, otherwise an error
1110 message which the caller must free.
1111
1112 N.B. These commands affect all debug format settings, they are not
1113 cumulative. If a format is not specified, it is turned off.
1114 However, we don't go to extra trouble with things like
1115 "monitor set debug-format all,none,timestamp".
1116 Instead we just parse them one at a time, in order.
1117
1118 The syntax for "monitor set debug" we support here is not identical
1119 to gdb's "set debug foo on|off" because we also use this function to
1120 parse "--debug-format=foo,bar". */
1121
1122static char *
1123parse_debug_format_options (const char *arg, int is_monitor)
1124{
1125 VEC (char_ptr) *options;
1126 int ix;
1127 char *option;
1128
1129 /* First turn all debug format options off. */
1130 debug_timestamp = 0;
1131
1132 /* First remove leading spaces, for "monitor set debug-format". */
1133 while (isspace (*arg))
1134 ++arg;
1135
1136 options = delim_string_to_char_ptr_vec (arg, ',');
1137
1138 for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix)
1139 {
1140 if (strcmp (option, "all") == 0)
1141 {
1142 debug_timestamp = 1;
1143 if (is_monitor)
1144 monitor_output ("All extra debug format options enabled.\n");
1145 }
1146 else if (strcmp (option, "none") == 0)
1147 {
1148 debug_timestamp = 0;
1149 if (is_monitor)
1150 monitor_output ("All extra debug format options disabled.\n");
1151 }
87ce2a04
DE
1152 else if (strcmp (option, "timestamp") == 0)
1153 {
1154 debug_timestamp = 1;
1155 if (is_monitor)
1156 monitor_output ("Timestamps will be added to debug output.\n");
1157 }
87ce2a04
DE
1158 else if (*option == '\0')
1159 {
1160 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1161 continue;
1162 }
1163 else
1164 {
1165 char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1166 option);
1167
1168 free_char_ptr_vec (options);
1169 return msg;
1170 }
1171 }
1172
1173 free_char_ptr_vec (options);
1174 return NULL;
1175}
1176
cdbfd419
PP
1177/* Handle monitor commands not handled by target-specific handlers. */
1178
1179static void
d73f2619 1180handle_monitor_command (char *mon, char *own_buf)
cdbfd419
PP
1181{
1182 if (strcmp (mon, "set debug 1") == 0)
1183 {
1184 debug_threads = 1;
1185 monitor_output ("Debug output enabled.\n");
1186 }
1187 else if (strcmp (mon, "set debug 0") == 0)
1188 {
1189 debug_threads = 0;
1190 monitor_output ("Debug output disabled.\n");
1191 }
1192 else if (strcmp (mon, "set debug-hw-points 1") == 0)
1193 {
c5e92cca 1194 show_debug_regs = 1;
cdbfd419
PP
1195 monitor_output ("H/W point debugging output enabled.\n");
1196 }
1197 else if (strcmp (mon, "set debug-hw-points 0") == 0)
1198 {
c5e92cca 1199 show_debug_regs = 0;
cdbfd419
PP
1200 monitor_output ("H/W point debugging output disabled.\n");
1201 }
1202 else if (strcmp (mon, "set remote-debug 1") == 0)
1203 {
1204 remote_debug = 1;
1205 monitor_output ("Protocol debug output enabled.\n");
1206 }
1207 else if (strcmp (mon, "set remote-debug 0") == 0)
1208 {
1209 remote_debug = 0;
1210 monitor_output ("Protocol debug output disabled.\n");
1211 }
61012eef 1212 else if (startswith (mon, "set debug-format "))
87ce2a04
DE
1213 {
1214 char *error_msg
1215 = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1,
1216 1);
1217
1218 if (error_msg != NULL)
1219 {
1220 monitor_output (error_msg);
1221 monitor_show_help ();
1222 write_enn (own_buf);
1223 xfree (error_msg);
1224 }
1225 }
cdbfd419
PP
1226 else if (strcmp (mon, "help") == 0)
1227 monitor_show_help ();
1228 else if (strcmp (mon, "exit") == 0)
1229 exit_requested = 1;
1230 else
1231 {
1232 monitor_output ("Unknown monitor command.\n\n");
1233 monitor_show_help ();
1234 write_enn (own_buf);
1235 }
1236}
1237
d08aafef
PA
1238/* Associates a callback with each supported qXfer'able object. */
1239
1240struct qxfer
1241{
1242 /* The object this handler handles. */
1243 const char *object;
1244
1245 /* Request that the target transfer up to LEN 8-bit bytes of the
1246 target's OBJECT. The OFFSET, for a seekable object, specifies
1247 the starting point. The ANNEX can be used to provide additional
1248 data-specific information to the target.
1249
1250 Return the number of bytes actually transfered, zero when no
5cc22e4c
MM
1251 further transfer is possible, -1 on error, -2 when the transfer
1252 is not supported, and -3 on a verbose error message that should
1253 be preserved. Return of a positive value smaller than LEN does
1254 not indicate the end of the object, only the end of the transfer.
d08aafef
PA
1255
1256 One, and only one, of readbuf or writebuf must be non-NULL. */
1257 int (*xfer) (const char *annex,
1258 gdb_byte *readbuf, const gdb_byte *writebuf,
1259 ULONGEST offset, LONGEST len);
1260};
1261
1262/* Handle qXfer:auxv:read. */
1263
1264static int
1265handle_qxfer_auxv (const char *annex,
1266 gdb_byte *readbuf, const gdb_byte *writebuf,
1267 ULONGEST offset, LONGEST len)
1268{
1269 if (the_target->read_auxv == NULL || writebuf != NULL)
1270 return -2;
1271
f0db101d 1272 if (annex[0] != '\0' || current_thread == NULL)
d08aafef
PA
1273 return -1;
1274
1275 return (*the_target->read_auxv) (offset, readbuf, len);
1276}
1277
e57f1de3
GB
1278/* Handle qXfer:exec-file:read. */
1279
1280static int
1281handle_qxfer_exec_file (const char *const_annex,
1282 gdb_byte *readbuf, const gdb_byte *writebuf,
1283 ULONGEST offset, LONGEST len)
1284{
835205d0 1285 char *file;
e57f1de3
GB
1286 ULONGEST pid;
1287 int total_len;
1288
1289 if (the_target->pid_to_exec_file == NULL || writebuf != NULL)
1290 return -2;
1291
835205d0
GB
1292 if (const_annex[0] == '\0')
1293 {
1294 if (current_thread == NULL)
1295 return -1;
1296
1297 pid = pid_of (current_thread);
1298 }
1299 else
1300 {
224c3ddb 1301 char *annex = (char *) alloca (strlen (const_annex) + 1);
835205d0
GB
1302
1303 strcpy (annex, const_annex);
1304 annex = unpack_varlen_hex (annex, &pid);
1305
1306 if (annex[0] != '\0')
1307 return -1;
1308 }
1309
1310 if (pid <= 0)
e57f1de3
GB
1311 return -1;
1312
1313 file = (*the_target->pid_to_exec_file) (pid);
1314 if (file == NULL)
1315 return -1;
1316
1317 total_len = strlen (file);
1318
1319 if (offset > total_len)
1320 return -1;
1321
1322 if (offset + len > total_len)
1323 len = total_len - offset;
1324
1325 memcpy (readbuf, file + offset, len);
1326 return len;
1327}
1328
d08aafef
PA
1329/* Handle qXfer:features:read. */
1330
1331static int
1332handle_qxfer_features (const char *annex,
1333 gdb_byte *readbuf, const gdb_byte *writebuf,
1334 ULONGEST offset, LONGEST len)
1335{
1336 const char *document;
1337 size_t total_len;
1338
1339 if (writebuf != NULL)
1340 return -2;
1341
1342 if (!target_running ())
1343 return -1;
1344
1345 /* Grab the correct annex. */
1346 document = get_features_xml (annex);
1347 if (document == NULL)
1348 return -1;
1349
1350 total_len = strlen (document);
1351
1352 if (offset > total_len)
1353 return -1;
1354
1355 if (offset + len > total_len)
1356 len = total_len - offset;
1357
1358 memcpy (readbuf, document + offset, len);
1359 return len;
1360}
1361
649ebbca
DE
1362/* Worker routine for handle_qxfer_libraries.
1363 Add to the length pointed to by ARG a conservative estimate of the
1364 length needed to transmit the file name of INF. */
1365
1366static void
1367accumulate_file_name_length (struct inferior_list_entry *inf, void *arg)
1368{
1369 struct dll_info *dll = (struct dll_info *) inf;
9a3c8263 1370 unsigned int *total_len = (unsigned int *) arg;
649ebbca
DE
1371
1372 /* Over-estimate the necessary memory. Assume that every character
1373 in the library name must be escaped. */
1374 *total_len += 128 + 6 * strlen (dll->name);
1375}
1376
1377/* Worker routine for handle_qxfer_libraries.
1378 Emit the XML to describe the library in INF. */
1379
1380static void
1381emit_dll_description (struct inferior_list_entry *inf, void *arg)
1382{
1383 struct dll_info *dll = (struct dll_info *) inf;
9a3c8263 1384 char **p_ptr = (char **) arg;
649ebbca
DE
1385 char *p = *p_ptr;
1386 char *name;
1387
1388 strcpy (p, " <library name=\"");
1389 p = p + strlen (p);
1390 name = xml_escape_text (dll->name);
1391 strcpy (p, name);
1392 free (name);
1393 p = p + strlen (p);
1394 strcpy (p, "\"><segment address=\"");
1395 p = p + strlen (p);
1396 sprintf (p, "0x%lx", (long) dll->base_addr);
1397 p = p + strlen (p);
1398 strcpy (p, "\"/></library>\n");
1399 p = p + strlen (p);
1400
1401 *p_ptr = p;
1402}
1403
d08aafef
PA
1404/* Handle qXfer:libraries:read. */
1405
1406static int
1407handle_qxfer_libraries (const char *annex,
1408 gdb_byte *readbuf, const gdb_byte *writebuf,
1409 ULONGEST offset, LONGEST len)
1410{
1411 unsigned int total_len;
1412 char *document, *p;
d08aafef
PA
1413
1414 if (writebuf != NULL)
1415 return -2;
1416
f0db101d 1417 if (annex[0] != '\0' || current_thread == NULL)
d08aafef
PA
1418 return -1;
1419
d08aafef 1420 total_len = 64;
649ebbca
DE
1421 for_each_inferior_with_data (&all_dlls, accumulate_file_name_length,
1422 &total_len);
d08aafef 1423
224c3ddb 1424 document = (char *) malloc (total_len);
d08aafef
PA
1425 if (document == NULL)
1426 return -1;
1427
24c05f46 1428 strcpy (document, "<library-list version=\"1.0\">\n");
d08aafef
PA
1429 p = document + strlen (document);
1430
649ebbca 1431 for_each_inferior_with_data (&all_dlls, emit_dll_description, &p);
d08aafef
PA
1432
1433 strcpy (p, "</library-list>\n");
1434
1435 total_len = strlen (document);
1436
1437 if (offset > total_len)
1438 {
1439 free (document);
1440 return -1;
1441 }
1442
1443 if (offset + len > total_len)
1444 len = total_len - offset;
1445
1446 memcpy (readbuf, document + offset, len);
1447 free (document);
1448 return len;
1449}
1450
2268b414
JK
1451/* Handle qXfer:libraries-svr4:read. */
1452
1453static int
1454handle_qxfer_libraries_svr4 (const char *annex,
1455 gdb_byte *readbuf, const gdb_byte *writebuf,
1456 ULONGEST offset, LONGEST len)
1457{
1458 if (writebuf != NULL)
1459 return -2;
1460
f0db101d 1461 if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
2268b414
JK
1462 return -1;
1463
1464 return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len);
1465}
1466
d08aafef
PA
1467/* Handle qXfer:osadata:read. */
1468
1469static int
1470handle_qxfer_osdata (const char *annex,
1471 gdb_byte *readbuf, const gdb_byte *writebuf,
1472 ULONGEST offset, LONGEST len)
1473{
1474 if (the_target->qxfer_osdata == NULL || writebuf != NULL)
1475 return -2;
1476
1477 return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
1478}
1479
1480/* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1481
1482static int
1483handle_qxfer_siginfo (const char *annex,
1484 gdb_byte *readbuf, const gdb_byte *writebuf,
1485 ULONGEST offset, LONGEST len)
1486{
1487 if (the_target->qxfer_siginfo == NULL)
1488 return -2;
1489
f0db101d 1490 if (annex[0] != '\0' || current_thread == NULL)
d08aafef
PA
1491 return -1;
1492
1493 return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
1494}
1495
1496/* Handle qXfer:spu:read and qXfer:spu:write. */
1497
1498static int
1499handle_qxfer_spu (const char *annex,
1500 gdb_byte *readbuf, const gdb_byte *writebuf,
1501 ULONGEST offset, LONGEST len)
1502{
1503 if (the_target->qxfer_spu == NULL)
1504 return -2;
1505
f0db101d 1506 if (current_thread == NULL)
d08aafef
PA
1507 return -1;
1508
1509 return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1510}
1511
1512/* Handle qXfer:statictrace:read. */
1513
1514static int
1515handle_qxfer_statictrace (const char *annex,
1516 gdb_byte *readbuf, const gdb_byte *writebuf,
1517 ULONGEST offset, LONGEST len)
1518{
1519 ULONGEST nbytes;
1520
1521 if (writebuf != NULL)
1522 return -2;
1523
f0db101d 1524 if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1)
d08aafef
PA
1525 return -1;
1526
1527 if (traceframe_read_sdata (current_traceframe, offset,
1528 readbuf, len, &nbytes))
1529 return -1;
1530 return nbytes;
1531}
1532
649ebbca
DE
1533/* Helper for handle_qxfer_threads_proper.
1534 Emit the XML to describe the thread of INF. */
d08aafef 1535
dc146f7c 1536static void
649ebbca 1537handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
dc146f7c 1538{
649ebbca 1539 struct thread_info *thread = (struct thread_info *) inf;
9a3c8263 1540 struct buffer *buffer = (struct buffer *) arg;
649ebbca
DE
1541 ptid_t ptid = thread_to_gdb_id (thread);
1542 char ptid_s[100];
1543 int core = target_core_of_thread (ptid);
1544 char core_s[21];
79efa585 1545 const char *name = target_thread_name (ptid);
dc146f7c 1546
649ebbca 1547 write_ptid (ptid_s, ptid);
dc146f7c 1548
79efa585
SM
1549 buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s);
1550
649ebbca 1551 if (core != -1)
dc146f7c 1552 {
649ebbca 1553 sprintf (core_s, "%d", core);
79efa585 1554 buffer_xml_printf (buffer, " core=\"%s\"", core_s);
649ebbca 1555 }
79efa585
SM
1556
1557 if (name != NULL)
1558 buffer_xml_printf (buffer, " name=\"%s\"", name);
1559
1560 buffer_xml_printf (buffer, "/>\n");
649ebbca 1561}
dc146f7c 1562
649ebbca 1563/* Helper for handle_qxfer_threads. */
dc146f7c 1564
649ebbca
DE
1565static void
1566handle_qxfer_threads_proper (struct buffer *buffer)
1567{
1568 buffer_grow_str (buffer, "<threads>\n");
1569
1570 for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker,
1571 buffer);
dc146f7c
VP
1572
1573 buffer_grow_str0 (buffer, "</threads>\n");
1574}
1575
d08aafef
PA
1576/* Handle qXfer:threads:read. */
1577
dc146f7c 1578static int
d08aafef
PA
1579handle_qxfer_threads (const char *annex,
1580 gdb_byte *readbuf, const gdb_byte *writebuf,
1581 ULONGEST offset, LONGEST len)
dc146f7c
VP
1582{
1583 static char *result = 0;
1584 static unsigned int result_length = 0;
1585
d08aafef
PA
1586 if (writebuf != NULL)
1587 return -2;
1588
f0db101d 1589 if (annex[0] != '\0')
d08aafef 1590 return -1;
dc146f7c
VP
1591
1592 if (offset == 0)
1593 {
1594 struct buffer buffer;
1595 /* When asked for data at offset 0, generate everything and store into
1596 'result'. Successive reads will be served off 'result'. */
1597 if (result)
1598 free (result);
1599
1600 buffer_init (&buffer);
1601
d08aafef 1602 handle_qxfer_threads_proper (&buffer);
dc146f7c
VP
1603
1604 result = buffer_finish (&buffer);
1605 result_length = strlen (result);
1606 buffer_free (&buffer);
1607 }
1608
1609 if (offset >= result_length)
1610 {
1611 /* We're out of data. */
1612 free (result);
1613 result = NULL;
1614 result_length = 0;
1615 return 0;
1616 }
1617
d08aafef
PA
1618 if (len > result_length - offset)
1619 len = result_length - offset;
1620
1621 memcpy (readbuf, result + offset, len);
1622
1623 return len;
1624}
1625
b3b9301e
PA
1626/* Handle qXfer:traceframe-info:read. */
1627
1628static int
1629handle_qxfer_traceframe_info (const char *annex,
1630 gdb_byte *readbuf, const gdb_byte *writebuf,
1631 ULONGEST offset, LONGEST len)
1632{
1633 static char *result = 0;
1634 static unsigned int result_length = 0;
1635
1636 if (writebuf != NULL)
1637 return -2;
1638
1639 if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1640 return -1;
1641
1642 if (offset == 0)
1643 {
1644 struct buffer buffer;
1645
1646 /* When asked for data at offset 0, generate everything and
1647 store into 'result'. Successive reads will be served off
1648 'result'. */
1649 free (result);
1650
1651 buffer_init (&buffer);
1652
1653 traceframe_read_info (current_traceframe, &buffer);
1654
1655 result = buffer_finish (&buffer);
1656 result_length = strlen (result);
1657 buffer_free (&buffer);
1658 }
1659
1660 if (offset >= result_length)
1661 {
1662 /* We're out of data. */
1663 free (result);
1664 result = NULL;
1665 result_length = 0;
1666 return 0;
1667 }
1668
1669 if (len > result_length - offset)
1670 len = result_length - offset;
1671
1672 memcpy (readbuf, result + offset, len);
1673 return len;
1674}
1675
78d85199
YQ
1676/* Handle qXfer:fdpic:read. */
1677
1678static int
1679handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
1680 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1681{
1682 if (the_target->read_loadmap == NULL)
1683 return -2;
1684
f0db101d 1685 if (current_thread == NULL)
78d85199
YQ
1686 return -1;
1687
1688 return (*the_target->read_loadmap) (annex, offset, readbuf, len);
1689}
1690
9accd112
MM
1691/* Handle qXfer:btrace:read. */
1692
1693static int
1694handle_qxfer_btrace (const char *annex,
1695 gdb_byte *readbuf, const gdb_byte *writebuf,
1696 ULONGEST offset, LONGEST len)
1697{
1698 static struct buffer cache;
1699 struct thread_info *thread;
add67df8
PA
1700 enum btrace_read_type type;
1701 int result;
9accd112
MM
1702
1703 if (the_target->read_btrace == NULL || writebuf != NULL)
1704 return -2;
1705
9accd112
MM
1706 if (ptid_equal (general_thread, null_ptid)
1707 || ptid_equal (general_thread, minus_one_ptid))
1708 {
1709 strcpy (own_buf, "E.Must select a single thread.");
1710 return -3;
1711 }
1712
1713 thread = find_thread_ptid (general_thread);
1714 if (thread == NULL)
1715 {
1716 strcpy (own_buf, "E.No such thread.");
1717 return -3;
1718 }
1719
1720 if (thread->btrace == NULL)
1721 {
1722 strcpy (own_buf, "E.Btrace not enabled.");
1723 return -3;
1724 }
1725
1726 if (strcmp (annex, "all") == 0)
864089d2 1727 type = BTRACE_READ_ALL;
9accd112 1728 else if (strcmp (annex, "new") == 0)
864089d2 1729 type = BTRACE_READ_NEW;
969c39fb
MM
1730 else if (strcmp (annex, "delta") == 0)
1731 type = BTRACE_READ_DELTA;
9accd112
MM
1732 else
1733 {
1734 strcpy (own_buf, "E.Bad annex.");
1735 return -3;
1736 }
1737
1738 if (offset == 0)
1739 {
1740 buffer_free (&cache);
1741
969c39fb
MM
1742 result = target_read_btrace (thread->btrace, &cache, type);
1743 if (result != 0)
1744 {
1745 memcpy (own_buf, cache.buffer, cache.used_size);
1746 return -3;
1747 }
9accd112
MM
1748 }
1749 else if (offset > cache.used_size)
1750 {
1751 buffer_free (&cache);
1752 return -3;
1753 }
1754
1755 if (len > cache.used_size - offset)
1756 len = cache.used_size - offset;
1757
1758 memcpy (readbuf, cache.buffer + offset, len);
1759
1760 return len;
1761}
1762
f4abbc16
MM
1763/* Handle qXfer:btrace-conf:read. */
1764
1765static int
1766handle_qxfer_btrace_conf (const char *annex,
1767 gdb_byte *readbuf, const gdb_byte *writebuf,
1768 ULONGEST offset, LONGEST len)
1769{
1770 static struct buffer cache;
1771 struct thread_info *thread;
1772 int result;
1773
1774 if (the_target->read_btrace_conf == NULL || writebuf != NULL)
1775 return -2;
1776
f0db101d 1777 if (annex[0] != '\0')
f4abbc16
MM
1778 return -1;
1779
1780 if (ptid_equal (general_thread, null_ptid)
1781 || ptid_equal (general_thread, minus_one_ptid))
1782 {
1783 strcpy (own_buf, "E.Must select a single thread.");
1784 return -3;
1785 }
1786
1787 thread = find_thread_ptid (general_thread);
1788 if (thread == NULL)
1789 {
1790 strcpy (own_buf, "E.No such thread.");
1791 return -3;
1792 }
1793
1794 if (thread->btrace == NULL)
1795 {
1796 strcpy (own_buf, "E.Btrace not enabled.");
1797 return -3;
1798 }
1799
1800 if (offset == 0)
1801 {
1802 buffer_free (&cache);
1803
1804 result = target_read_btrace_conf (thread->btrace, &cache);
1805 if (result != 0)
1806 {
1807 memcpy (own_buf, cache.buffer, cache.used_size);
1808 return -3;
1809 }
1810 }
1811 else if (offset > cache.used_size)
1812 {
1813 buffer_free (&cache);
1814 return -3;
1815 }
1816
1817 if (len > cache.used_size - offset)
1818 len = cache.used_size - offset;
1819
1820 memcpy (readbuf, cache.buffer + offset, len);
1821
1822 return len;
1823}
1824
d08aafef
PA
1825static const struct qxfer qxfer_packets[] =
1826 {
1827 { "auxv", handle_qxfer_auxv },
9accd112 1828 { "btrace", handle_qxfer_btrace },
f4abbc16 1829 { "btrace-conf", handle_qxfer_btrace_conf },
e57f1de3 1830 { "exec-file", handle_qxfer_exec_file},
78d85199 1831 { "fdpic", handle_qxfer_fdpic},
d08aafef
PA
1832 { "features", handle_qxfer_features },
1833 { "libraries", handle_qxfer_libraries },
2268b414 1834 { "libraries-svr4", handle_qxfer_libraries_svr4 },
d08aafef
PA
1835 { "osdata", handle_qxfer_osdata },
1836 { "siginfo", handle_qxfer_siginfo },
1837 { "spu", handle_qxfer_spu },
1838 { "statictrace", handle_qxfer_statictrace },
1839 { "threads", handle_qxfer_threads },
b3b9301e 1840 { "traceframe-info", handle_qxfer_traceframe_info },
d08aafef
PA
1841 };
1842
1843static int
1844handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1845{
1846 int i;
1847 char *object;
1848 char *rw;
1849 char *annex;
1850 char *offset;
1851
61012eef 1852 if (!startswith (own_buf, "qXfer:"))
d08aafef
PA
1853 return 0;
1854
1855 /* Grab the object, r/w and annex. */
1856 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
1857 {
1858 write_enn (own_buf);
1859 return 1;
1860 }
1861
1862 for (i = 0;
1863 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
1864 i++)
1865 {
1866 const struct qxfer *q = &qxfer_packets[i];
1867
1868 if (strcmp (object, q->object) == 0)
1869 {
1870 if (strcmp (rw, "read") == 0)
1871 {
1872 unsigned char *data;
1873 int n;
1874 CORE_ADDR ofs;
1875 unsigned int len;
1876
1877 /* Grab the offset and length. */
1878 if (decode_xfer_read (offset, &ofs, &len) < 0)
1879 {
1880 write_enn (own_buf);
1881 return 1;
1882 }
1883
1884 /* Read one extra byte, as an indicator of whether there is
1885 more. */
1886 if (len > PBUFSIZ - 2)
1887 len = PBUFSIZ - 2;
224c3ddb 1888 data = (unsigned char *) malloc (len + 1);
d08aafef
PA
1889 if (data == NULL)
1890 {
1891 write_enn (own_buf);
1892 return 1;
1893 }
1894 n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
1895 if (n == -2)
1896 {
1897 free (data);
1898 return 0;
1899 }
5cc22e4c
MM
1900 else if (n == -3)
1901 {
1902 /* Preserve error message. */
1903 }
d08aafef
PA
1904 else if (n < 0)
1905 write_enn (own_buf);
1906 else if (n > len)
1907 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1908 else
1909 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1910
1911 free (data);
1912 return 1;
1913 }
1914 else if (strcmp (rw, "write") == 0)
1915 {
1916 int n;
1917 unsigned int len;
1918 CORE_ADDR ofs;
1919 unsigned char *data;
1920
1921 strcpy (own_buf, "E00");
224c3ddb 1922 data = (unsigned char *) malloc (packet_len - (offset - own_buf));
d08aafef
PA
1923 if (data == NULL)
1924 {
1925 write_enn (own_buf);
1926 return 1;
1927 }
1928 if (decode_xfer_write (offset, packet_len - (offset - own_buf),
1929 &ofs, &len, data) < 0)
1930 {
1931 free (data);
1932 write_enn (own_buf);
1933 return 1;
1934 }
1935
1936 n = (*q->xfer) (annex, NULL, data, ofs, len);
1937 if (n == -2)
1938 {
1939 free (data);
1940 return 0;
1941 }
5cc22e4c
MM
1942 else if (n == -3)
1943 {
1944 /* Preserve error message. */
1945 }
d08aafef
PA
1946 else if (n < 0)
1947 write_enn (own_buf);
1948 else
1949 sprintf (own_buf, "%x", n);
dc146f7c 1950
d08aafef
PA
1951 free (data);
1952 return 1;
1953 }
dc146f7c 1954
d08aafef
PA
1955 return 0;
1956 }
1957 }
dc146f7c 1958
d08aafef 1959 return 0;
dc146f7c
VP
1960}
1961
30ba68cb
MS
1962/* Compute 32 bit CRC from inferior memory.
1963
1964 On success, return 32 bit CRC.
1965 On failure, return (unsigned long long) -1. */
1966
1967static unsigned long long
1968crc32 (CORE_ADDR base, int len, unsigned int crc)
1969{
30ba68cb
MS
1970 while (len--)
1971 {
1972 unsigned char byte = 0;
1973
1974 /* Return failure if memory read fails. */
1975 if (read_inferior_memory (base, &byte, 1) != 0)
1976 return (unsigned long long) -1;
1977
65da7f14 1978 crc = xcrc32 (&byte, 1, crc);
30ba68cb
MS
1979 base++;
1980 }
1981 return (unsigned long long) crc;
1982}
1983
043c3577
MM
1984/* Add supported btrace packets to BUF. */
1985
1986static void
1987supported_btrace_packets (char *buf)
1988{
b20a6524
MM
1989 int btrace_supported = 0;
1990
043c3577 1991 if (target_supports_btrace (BTRACE_FORMAT_BTS))
d33501a5
MM
1992 {
1993 strcat (buf, ";Qbtrace:bts+");
1994 strcat (buf, ";Qbtrace-conf:bts:size+");
b20a6524
MM
1995
1996 btrace_supported = 1;
d33501a5 1997 }
b20a6524
MM
1998
1999 if (target_supports_btrace (BTRACE_FORMAT_PT))
2000 {
2001 strcat (buf, ";Qbtrace:pt+");
2002 strcat (buf, ";Qbtrace-conf:pt:size+");
2003
2004 btrace_supported = 1;
2005 }
2006
2007 if (!btrace_supported)
043c3577
MM
2008 return;
2009
2010 strcat (buf, ";Qbtrace:off+");
2011 strcat (buf, ";qXfer:btrace:read+");
f4abbc16 2012 strcat (buf, ";qXfer:btrace-conf:read+");
043c3577
MM
2013}
2014
ce3a066d 2015/* Handle all of the extended 'q' packets. */
d08aafef 2016
5b3da067 2017static void
0e7f50da 2018handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
ce3a066d 2019{
0d62e5e8
DJ
2020 static struct inferior_list_entry *thread_ptr;
2021
bb63802a 2022 /* Reply the current thread id. */
db42f210 2023 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
bb63802a 2024 {
95954743 2025 ptid_t gdb_id;
2d717e4f 2026 require_running (own_buf);
bd99dc85 2027
95954743
PA
2028 if (!ptid_equal (general_thread, null_ptid)
2029 && !ptid_equal (general_thread, minus_one_ptid))
bd99dc85
PA
2030 gdb_id = general_thread;
2031 else
2032 {
649ebbca 2033 thread_ptr = get_first_inferior (&all_threads);
bd99dc85
PA
2034 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
2035 }
2036
95954743
PA
2037 sprintf (own_buf, "QC");
2038 own_buf += 2;
4b812f4e 2039 write_ptid (own_buf, gdb_id);
bb63802a
UW
2040 return;
2041 }
2042
ce3a066d
DJ
2043 if (strcmp ("qSymbol::", own_buf) == 0)
2044 {
34c65914
PA
2045 struct thread_info *save_thread = current_thread;
2046
2047 /* For qSymbol, GDB only changes the current thread if the
2048 previous current thread was of a different process. So if
2049 the previous thread is gone, we need to pick another one of
2050 the same process. This can happen e.g., if we followed an
2051 exec in a non-leader thread. */
2052 if (current_thread == NULL)
2053 {
2054 current_thread
2055 = find_any_thread_of_pid (ptid_get_pid (general_thread));
2056
2057 /* Just in case, if we didn't find a thread, then bail out
2058 instead of crashing. */
2059 if (current_thread == NULL)
2060 {
2061 write_enn (own_buf);
2062 current_thread = save_thread;
2063 return;
2064 }
2065 }
2066
d3bbe7a0
PA
2067 /* GDB is suggesting new symbols have been loaded. This may
2068 mean a new shared library has been detected as loaded, so
2069 take the opportunity to check if breakpoints we think are
2070 inserted, still are. Note that it isn't guaranteed that
2071 we'll see this when a shared library is loaded, and nor will
2072 we see this for unloads (although breakpoints in unloaded
2073 libraries shouldn't trigger), as GDB may not find symbols for
2074 the library at all. We also re-validate breakpoints when we
2075 see a second GDB breakpoint for the same address, and or when
2076 we access breakpoint shadows. */
2077 validate_breakpoints ();
2078
fa593d66
PA
2079 if (target_supports_tracepoints ())
2080 tracepoint_look_up_symbols ();
2081
f0db101d 2082 if (current_thread != NULL && the_target->look_up_symbols != NULL)
2f2893d9
DJ
2083 (*the_target->look_up_symbols) ();
2084
34c65914
PA
2085 current_thread = save_thread;
2086
ce3a066d
DJ
2087 strcpy (own_buf, "OK");
2088 return;
2089 }
2090
db42f210 2091 if (!disable_packet_qfThreadInfo)
0d62e5e8 2092 {
db42f210 2093 if (strcmp ("qfThreadInfo", own_buf) == 0)
0d62e5e8 2094 {
95954743
PA
2095 ptid_t gdb_id;
2096
db42f210 2097 require_running (own_buf);
649ebbca 2098 thread_ptr = get_first_inferior (&all_threads);
95954743
PA
2099
2100 *own_buf++ = 'm';
2101 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
2102 write_ptid (own_buf, gdb_id);
0d62e5e8
DJ
2103 thread_ptr = thread_ptr->next;
2104 return;
2105 }
db42f210
PA
2106
2107 if (strcmp ("qsThreadInfo", own_buf) == 0)
0d62e5e8 2108 {
95954743
PA
2109 ptid_t gdb_id;
2110
db42f210
PA
2111 require_running (own_buf);
2112 if (thread_ptr != NULL)
2113 {
95954743
PA
2114 *own_buf++ = 'm';
2115 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
2116 write_ptid (own_buf, gdb_id);
db42f210
PA
2117 thread_ptr = thread_ptr->next;
2118 return;
2119 }
2120 else
2121 {
2122 sprintf (own_buf, "l");
2123 return;
2124 }
0d62e5e8
DJ
2125 }
2126 }
aa691b87 2127
52fb6437
NS
2128 if (the_target->read_offsets != NULL
2129 && strcmp ("qOffsets", own_buf) == 0)
2130 {
2131 CORE_ADDR text, data;
2d717e4f
DJ
2132
2133 require_running (own_buf);
52fb6437
NS
2134 if (the_target->read_offsets (&text, &data))
2135 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
2136 (long)text, (long)data, (long)data);
2137 else
2138 write_enn (own_buf);
1b3f6016 2139
52fb6437
NS
2140 return;
2141 }
2142
be2a5f71 2143 /* Protocol features query. */
61012eef 2144 if (startswith (own_buf, "qSupported")
be2a5f71
DJ
2145 && (own_buf[10] == ':' || own_buf[10] == '\0'))
2146 {
95954743 2147 char *p = &own_buf[10];
fa593d66 2148 int gdb_supports_qRelocInsn = 0;
95954743
PA
2149
2150 /* Process each feature being provided by GDB. The first
2151 feature will follow a ':', and latter features will follow
2152 ';'. */
2153 if (*p == ':')
d149dd1d
PA
2154 {
2155 char **qsupported = NULL;
2156 int count = 0;
06e03fff 2157 int unknown = 0;
d149dd1d
PA
2158 int i;
2159
2160 /* Two passes, to avoid nested strtok calls in
2161 target_process_qsupported. */
2162 for (p = strtok (p + 1, ";");
2163 p != NULL;
2164 p = strtok (NULL, ";"))
2165 {
2166 count++;
224c3ddb 2167 qsupported = XRESIZEVEC (char *, qsupported, count);
d149dd1d
PA
2168 qsupported[count - 1] = xstrdup (p);
2169 }
2170
2171 for (i = 0; i < count; i++)
2172 {
2173 p = qsupported[i];
2174 if (strcmp (p, "multiprocess+") == 0)
2175 {
2176 /* GDB supports and wants multi-process support if
2177 possible. */
2178 if (target_supports_multi_process ())
2179 multi_process = 1;
2180 }
fa593d66
PA
2181 else if (strcmp (p, "qRelocInsn+") == 0)
2182 {
2183 /* GDB supports relocate instruction requests. */
2184 gdb_supports_qRelocInsn = 1;
2185 }
1ec68e26
PA
2186 else if (strcmp (p, "swbreak+") == 0)
2187 {
2188 /* GDB wants us to report whether a trap is caused
2189 by a software breakpoint and for us to handle PC
2190 adjustment if necessary on this target. */
2191 if (target_supports_stopped_by_sw_breakpoint ())
2192 swbreak_feature = 1;
2193 }
2194 else if (strcmp (p, "hwbreak+") == 0)
2195 {
2196 /* GDB wants us to report whether a trap is caused
2197 by a hardware breakpoint. */
2198 if (target_supports_stopped_by_hw_breakpoint ())
2199 hwbreak_feature = 1;
2200 }
89245bc0
DB
2201 else if (strcmp (p, "fork-events+") == 0)
2202 {
2203 /* GDB supports and wants fork events if possible. */
2204 if (target_supports_fork_events ())
2205 report_fork_events = 1;
2206 }
2207 else if (strcmp (p, "vfork-events+") == 0)
2208 {
2209 /* GDB supports and wants vfork events if possible. */
2210 if (target_supports_vfork_events ())
2211 report_vfork_events = 1;
2212 }
7c5d0fad 2213 else if (strcmp (p, "exec-events+") == 0)
94585166
DB
2214 {
2215 /* GDB supports and wants exec events if possible. */
2216 if (target_supports_exec_events ())
2217 report_exec_events = 1;
2218 }
750ce8d1
YQ
2219 else if (strcmp (p, "vContSupported+") == 0)
2220 vCont_supported = 1;
65706a29
PA
2221 else if (strcmp (p, "QThreadEvents+") == 0)
2222 ;
f2faf941
PA
2223 else if (strcmp (p, "no-resumed+") == 0)
2224 {
2225 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2226 events. */
2227 report_no_resumed = 1;
2228 }
d149dd1d 2229 else
06e03fff
PA
2230 {
2231 /* Move the unknown features all together. */
2232 qsupported[i] = NULL;
2233 qsupported[unknown] = p;
2234 unknown++;
2235 }
d149dd1d
PA
2236 }
2237
06e03fff
PA
2238 /* Give the target backend a chance to process the unknown
2239 features. */
2240 target_process_qsupported (qsupported, unknown);
2241
2242 for (i = 0; i < count; i++)
2243 free (qsupported[i]);
d149dd1d
PA
2244 free (qsupported);
2245 }
95954743 2246
9b224c5e
PA
2247 sprintf (own_buf,
2248 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2249 PBUFSIZ - 1);
0876f84a 2250
82075af2
JS
2251 if (target_supports_catch_syscall ())
2252 strcat (own_buf, ";QCatchSyscalls+");
2253
2268b414 2254 if (the_target->qxfer_libraries_svr4 != NULL)
b1fbec62
GB
2255 strcat (own_buf, ";qXfer:libraries-svr4:read+"
2256 ";augmented-libraries-svr4-read+");
2268b414
JK
2257 else
2258 {
2259 /* We do not have any hook to indicate whether the non-SVR4 target
2260 backend supports qXfer:libraries:read, so always report it. */
2261 strcat (own_buf, ";qXfer:libraries:read+");
2262 }
255e7678 2263
0876f84a 2264 if (the_target->read_auxv != NULL)
9f2e1e63 2265 strcat (own_buf, ";qXfer:auxv:read+");
2d717e4f 2266
0e7f50da
UW
2267 if (the_target->qxfer_spu != NULL)
2268 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
0876f84a 2269
4aa995e1
PA
2270 if (the_target->qxfer_siginfo != NULL)
2271 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2272
78d85199
YQ
2273 if (the_target->read_loadmap != NULL)
2274 strcat (own_buf, ";qXfer:fdpic:read+");
2275
221c031f
UW
2276 /* We always report qXfer:features:read, as targets may
2277 install XML files on a subsequent call to arch_setup.
2278 If we reported to GDB on startup that we don't support
2279 qXfer:feature:read at all, we will never be re-queried. */
2280 strcat (own_buf, ";qXfer:features:read+");
23181151 2281
a6f3e723
SL
2282 if (transport_is_reliable)
2283 strcat (own_buf, ";QStartNoAckMode+");
07e059b5
VP
2284
2285 if (the_target->qxfer_osdata != NULL)
1b3f6016 2286 strcat (own_buf, ";qXfer:osdata:read+");
07e059b5 2287
cf8fd78b
PA
2288 if (target_supports_multi_process ())
2289 strcat (own_buf, ";multiprocess+");
95954743 2290
89245bc0
DB
2291 if (target_supports_fork_events ())
2292 strcat (own_buf, ";fork-events+");
2293
2294 if (target_supports_vfork_events ())
2295 strcat (own_buf, ";vfork-events+");
2296
94585166
DB
2297 if (target_supports_exec_events ())
2298 strcat (own_buf, ";exec-events+");
2299
bd99dc85
PA
2300 if (target_supports_non_stop ())
2301 strcat (own_buf, ";QNonStop+");
2302
03583c20
UW
2303 if (target_supports_disable_randomization ())
2304 strcat (own_buf, ";QDisableRandomization+");
2305
dc146f7c
VP
2306 strcat (own_buf, ";qXfer:threads:read+");
2307
219f2f23
PA
2308 if (target_supports_tracepoints ())
2309 {
2310 strcat (own_buf, ";ConditionalTracepoints+");
2311 strcat (own_buf, ";TraceStateVariables+");
2312 strcat (own_buf, ";TracepointSource+");
8336d594 2313 strcat (own_buf, ";DisconnectedTracing+");
fa593d66
PA
2314 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
2315 strcat (own_buf, ";FastTracepoints+");
0fb4aa4b 2316 strcat (own_buf, ";StaticTracepoints+");
1e4d1764 2317 strcat (own_buf, ";InstallInTrace+");
0fb4aa4b 2318 strcat (own_buf, ";qXfer:statictrace:read+");
b3b9301e 2319 strcat (own_buf, ";qXfer:traceframe-info:read+");
d248b706 2320 strcat (own_buf, ";EnableDisableTracepoints+");
f6f899bf 2321 strcat (own_buf, ";QTBuffer:size+");
3065dfb6 2322 strcat (own_buf, ";tracenz+");
219f2f23
PA
2323 }
2324
bd2b2909
AT
2325 if (target_supports_hardware_single_step ()
2326 || target_supports_software_single_step () )
70b90b91 2327 {
70b90b91
YQ
2328 strcat (own_buf, ";ConditionalBreakpoints+");
2329 }
d3ce09f5 2330 strcat (own_buf, ";BreakpointCommands+");
9f3a5c85 2331
d1feda86
YQ
2332 if (target_supports_agent ())
2333 strcat (own_buf, ";QAgent+");
2334
043c3577 2335 supported_btrace_packets (own_buf);
9accd112 2336
1ec68e26
PA
2337 if (target_supports_stopped_by_sw_breakpoint ())
2338 strcat (own_buf, ";swbreak+");
2339
2340 if (target_supports_stopped_by_hw_breakpoint ())
2341 strcat (own_buf, ";hwbreak+");
2342
e57f1de3
GB
2343 if (the_target->pid_to_exec_file != NULL)
2344 strcat (own_buf, ";qXfer:exec-file:read+");
2345
750ce8d1
YQ
2346 strcat (own_buf, ";vContSupported+");
2347
65706a29
PA
2348 strcat (own_buf, ";QThreadEvents+");
2349
f2faf941
PA
2350 strcat (own_buf, ";no-resumed+");
2351
14d2069a
GB
2352 /* Reinitialize components as needed for the new connection. */
2353 hostio_handle_new_gdb_connection ();
de0d863e
DB
2354 target_handle_new_gdb_connection ();
2355
be2a5f71
DJ
2356 return;
2357 }
2358
dae5f5cf
DJ
2359 /* Thread-local storage support. */
2360 if (the_target->get_tls_address != NULL
61012eef 2361 && startswith (own_buf, "qGetTLSAddr:"))
dae5f5cf
DJ
2362 {
2363 char *p = own_buf + 12;
5b1c542e 2364 CORE_ADDR parts[2], address = 0;
dae5f5cf 2365 int i, err;
95954743 2366 ptid_t ptid = null_ptid;
dae5f5cf 2367
2d717e4f
DJ
2368 require_running (own_buf);
2369
dae5f5cf
DJ
2370 for (i = 0; i < 3; i++)
2371 {
2372 char *p2;
2373 int len;
2374
2375 if (p == NULL)
2376 break;
2377
2378 p2 = strchr (p, ',');
2379 if (p2)
2380 {
2381 len = p2 - p;
2382 p2++;
2383 }
2384 else
2385 {
2386 len = strlen (p);
2387 p2 = NULL;
2388 }
2389
5b1c542e 2390 if (i == 0)
95954743 2391 ptid = read_ptid (p, NULL);
5b1c542e
PA
2392 else
2393 decode_address (&parts[i - 1], p, len);
dae5f5cf
DJ
2394 p = p2;
2395 }
2396
2397 if (p != NULL || i < 3)
2398 err = 1;
2399 else
2400 {
e09875d4 2401 struct thread_info *thread = find_thread_ptid (ptid);
dae5f5cf
DJ
2402
2403 if (thread == NULL)
2404 err = 2;
2405 else
5b1c542e 2406 err = the_target->get_tls_address (thread, parts[0], parts[1],
dae5f5cf
DJ
2407 &address);
2408 }
2409
2410 if (err == 0)
2411 {
c6f46ca0 2412 strcpy (own_buf, paddress(address));
dae5f5cf
DJ
2413 return;
2414 }
2415 else if (err > 0)
2416 {
2417 write_enn (own_buf);
2418 return;
2419 }
2420
2421 /* Otherwise, pretend we do not understand this packet. */
2422 }
2423
711e434b
PM
2424 /* Windows OS Thread Information Block address support. */
2425 if (the_target->get_tib_address != NULL
61012eef 2426 && startswith (own_buf, "qGetTIBAddr:"))
711e434b
PM
2427 {
2428 char *annex;
2429 int n;
2430 CORE_ADDR tlb;
2431 ptid_t ptid = read_ptid (own_buf + 12, &annex);
2432
2433 n = (*the_target->get_tib_address) (ptid, &tlb);
2434 if (n == 1)
2435 {
c6f46ca0 2436 strcpy (own_buf, paddress(tlb));
711e434b
PM
2437 return;
2438 }
2439 else if (n == 0)
2440 {
2441 write_enn (own_buf);
2442 return;
2443 }
2444 return;
2445 }
2446
c74d0ad8 2447 /* Handle "monitor" commands. */
61012eef 2448 if (startswith (own_buf, "qRcmd,"))
c74d0ad8 2449 {
224c3ddb 2450 char *mon = (char *) malloc (PBUFSIZ);
c74d0ad8
DJ
2451 int len = strlen (own_buf + 6);
2452
aef93bd7
DE
2453 if (mon == NULL)
2454 {
2455 write_enn (own_buf);
2456 return;
2457 }
2458
ff0e980e
TT
2459 if ((len % 2) != 0
2460 || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2)
c74d0ad8
DJ
2461 {
2462 write_enn (own_buf);
2463 free (mon);
2464 return;
2465 }
2466 mon[len / 2] = '\0';
2467
2468 write_ok (own_buf);
2469
cdbfd419
PP
2470 if (the_target->handle_monitor_command == NULL
2471 || (*the_target->handle_monitor_command) (mon) == 0)
2472 /* Default processing. */
d73f2619 2473 handle_monitor_command (mon, own_buf);
c74d0ad8
DJ
2474
2475 free (mon);
2476 return;
2477 }
2478
61012eef 2479 if (startswith (own_buf, "qSearch:memory:"))
08388c79
DE
2480 {
2481 require_running (own_buf);
2482 handle_search_memory (own_buf, packet_len);
2483 return;
2484 }
2485
95954743 2486 if (strcmp (own_buf, "qAttached") == 0
61012eef 2487 || startswith (own_buf, "qAttached:"))
0b16c5cf 2488 {
95954743
PA
2489 struct process_info *process;
2490
2491 if (own_buf[sizeof ("qAttached") - 1])
2492 {
2493 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
2494 process = (struct process_info *)
2495 find_inferior_id (&all_processes, pid_to_ptid (pid));
2496 }
2497 else
2498 {
2499 require_running (own_buf);
2500 process = current_process ();
2501 }
2502
2503 if (process == NULL)
2504 {
2505 write_enn (own_buf);
2506 return;
2507 }
2508
2509 strcpy (own_buf, process->attached ? "1" : "0");
0b16c5cf
PA
2510 return;
2511 }
2512
61012eef 2513 if (startswith (own_buf, "qCRC:"))
30ba68cb
MS
2514 {
2515 /* CRC check (compare-section). */
2516 char *comma;
aca22551 2517 ULONGEST base;
30ba68cb
MS
2518 int len;
2519 unsigned long long crc;
2520
2521 require_running (own_buf);
aca22551 2522 comma = unpack_varlen_hex (own_buf + 5, &base);
30ba68cb
MS
2523 if (*comma++ != ',')
2524 {
2525 write_enn (own_buf);
2526 return;
2527 }
2528 len = strtoul (comma, NULL, 16);
2529 crc = crc32 (base, len, 0xffffffff);
2530 /* Check for memory failure. */
2531 if (crc == (unsigned long long) -1)
2532 {
2533 write_enn (own_buf);
2534 return;
2535 }
2536 sprintf (own_buf, "C%lx", (unsigned long) crc);
2537 return;
2538 }
2539
d08aafef
PA
2540 if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
2541 return;
2542
219f2f23
PA
2543 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
2544 return;
2545
ce3a066d
DJ
2546 /* Otherwise we didn't know what packet it was. Say we didn't
2547 understand it. */
2548 own_buf[0] = 0;
2549}
2550
ce1a5b52 2551static void gdb_wants_all_threads_stopped (void);
b7ea362b
PA
2552static void resume (struct thread_resume *actions, size_t n);
2553
649ebbca
DE
2554/* The callback that is passed to visit_actioned_threads. */
2555typedef int (visit_actioned_threads_callback_ftype)
2556 (const struct thread_resume *, struct thread_info *);
2557
2558/* Struct to pass data to visit_actioned_threads. */
2559
2560struct visit_actioned_threads_data
2561{
2562 const struct thread_resume *actions;
2563 size_t num_actions;
2564 visit_actioned_threads_callback_ftype *callback;
2565};
2566
b7ea362b
PA
2567/* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2568 true if CALLBACK returns true. Returns false if no matching thread
649ebbca
DE
2569 is found or CALLBACK results false.
2570 Note: This function is itself a callback for find_inferior. */
b7ea362b
PA
2571
2572static int
649ebbca 2573visit_actioned_threads (struct inferior_list_entry *entry, void *datap)
b7ea362b 2574{
9a3c8263
SM
2575 struct visit_actioned_threads_data *data
2576 = (struct visit_actioned_threads_data *) datap;
649ebbca
DE
2577 const struct thread_resume *actions = data->actions;
2578 size_t num_actions = data->num_actions;
2579 visit_actioned_threads_callback_ftype *callback = data->callback;
2580 size_t i;
b7ea362b 2581
649ebbca 2582 for (i = 0; i < num_actions; i++)
b7ea362b 2583 {
649ebbca 2584 const struct thread_resume *action = &actions[i];
b7ea362b 2585
649ebbca
DE
2586 if (ptid_equal (action->thread, minus_one_ptid)
2587 || ptid_equal (action->thread, entry->id)
2588 || ((ptid_get_pid (action->thread)
2589 == ptid_get_pid (entry->id))
2590 && ptid_get_lwp (action->thread) == -1))
b7ea362b 2591 {
649ebbca 2592 struct thread_info *thread = (struct thread_info *) entry;
b7ea362b 2593
649ebbca
DE
2594 if ((*callback) (action, thread))
2595 return 1;
b7ea362b
PA
2596 }
2597 }
2598
2599 return 0;
2600}
2601
2602/* Callback for visit_actioned_threads. If the thread has a pending
2603 status to report, report it now. */
2604
2605static int
2606handle_pending_status (const struct thread_resume *resumption,
2607 struct thread_info *thread)
2608{
2609 if (thread->status_pending_p)
2610 {
2611 thread->status_pending_p = 0;
2612
2613 last_status = thread->last_status;
2614 last_ptid = thread->entry.id;
2615 prepare_resume_reply (own_buf, last_ptid, &last_status);
2616 return 1;
2617 }
2618 return 0;
2619}
ce1a5b52 2620
64386c31 2621/* Parse vCont packets. */
5b3da067 2622static void
5b1c542e 2623handle_v_cont (char *own_buf)
64386c31
DJ
2624{
2625 char *p, *q;
2626 int n = 0, i = 0;
2bd7c093 2627 struct thread_resume *resume_info;
95954743 2628 struct thread_resume default_action = {{0}};
64386c31
DJ
2629
2630 /* Count the number of semicolons in the packet. There should be one
2631 for every action. */
2632 p = &own_buf[5];
2633 while (p)
2634 {
2635 n++;
2636 p++;
2637 p = strchr (p, ';');
2638 }
2bd7c093 2639
224c3ddb 2640 resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0]));
aef93bd7
DE
2641 if (resume_info == NULL)
2642 goto err;
64386c31 2643
64386c31 2644 p = &own_buf[5];
64386c31
DJ
2645 while (*p)
2646 {
2647 p++;
2648
c2d6af84
PA
2649 memset (&resume_info[i], 0, sizeof resume_info[i]);
2650
64386c31 2651 if (p[0] == 's' || p[0] == 'S')
bd99dc85 2652 resume_info[i].kind = resume_step;
c2d6af84
PA
2653 else if (p[0] == 'r')
2654 resume_info[i].kind = resume_step;
64386c31 2655 else if (p[0] == 'c' || p[0] == 'C')
bd99dc85
PA
2656 resume_info[i].kind = resume_continue;
2657 else if (p[0] == 't')
2658 resume_info[i].kind = resume_stop;
64386c31
DJ
2659 else
2660 goto err;
2661
2662 if (p[0] == 'S' || p[0] == 'C')
2663 {
2664 int sig;
2665 sig = strtol (p + 1, &q, 16);
2666 if (p == q)
2667 goto err;
2668 p = q;
2669
e053fbc4 2670 if (!gdb_signal_to_host_p ((enum gdb_signal) sig))
64386c31 2671 goto err;
e053fbc4 2672 resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig);
64386c31 2673 }
c2d6af84
PA
2674 else if (p[0] == 'r')
2675 {
6740dc9c 2676 ULONGEST addr;
c2d6af84 2677
6740dc9c
PA
2678 p = unpack_varlen_hex (p + 1, &addr);
2679 resume_info[i].step_range_start = addr;
c2d6af84 2680
6740dc9c
PA
2681 if (*p != ',')
2682 goto err;
c2d6af84 2683
6740dc9c
PA
2684 p = unpack_varlen_hex (p + 1, &addr);
2685 resume_info[i].step_range_end = addr;
c2d6af84 2686 }
64386c31
DJ
2687 else
2688 {
64386c31
DJ
2689 p = p + 1;
2690 }
2691
2692 if (p[0] == 0)
2693 {
95954743 2694 resume_info[i].thread = minus_one_ptid;
64386c31
DJ
2695 default_action = resume_info[i];
2696
2697 /* Note: we don't increment i here, we'll overwrite this entry
2698 the next time through. */
2699 }
2700 else if (p[0] == ':')
2701 {
95954743 2702 ptid_t ptid = read_ptid (p + 1, &q);
a06660f7 2703
64386c31
DJ
2704 if (p == q)
2705 goto err;
2706 p = q;
2707 if (p[0] != ';' && p[0] != 0)
2708 goto err;
2709
95954743 2710 resume_info[i].thread = ptid;
a06660f7 2711
64386c31
DJ
2712 i++;
2713 }
2714 }
2715
2bd7c093
PA
2716 if (i < n)
2717 resume_info[i] = default_action;
64386c31 2718
b7ea362b
PA
2719 resume (resume_info, n);
2720 free (resume_info);
2721 return;
2722
2723err:
2724 write_enn (own_buf);
2725 free (resume_info);
2726 return;
2727}
2728
2729/* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2730
2731static void
2732resume (struct thread_resume *actions, size_t num_actions)
2733{
bd99dc85 2734 if (!non_stop)
b7ea362b
PA
2735 {
2736 /* Check if among the threads that GDB wants actioned, there's
2737 one with a pending status to report. If so, skip actually
2738 resuming/stopping and report the pending event
2739 immediately. */
649ebbca
DE
2740 struct visit_actioned_threads_data data;
2741
2742 data.actions = actions;
2743 data.num_actions = num_actions;
2744 data.callback = handle_pending_status;
2745 if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL)
b7ea362b 2746 return;
bd99dc85 2747
b7ea362b
PA
2748 enable_async_io ();
2749 }
64386c31 2750
b7ea362b 2751 (*the_target->resume) (actions, num_actions);
64386c31 2752
bd99dc85
PA
2753 if (non_stop)
2754 write_ok (own_buf);
2755 else
2756 {
95954743 2757 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
ce1a5b52 2758
f2faf941
PA
2759 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
2760 && !report_no_resumed)
fa96cb38 2761 {
f2faf941
PA
2762 /* The client does not support this stop reply. At least
2763 return error. */
fa96cb38
PA
2764 sprintf (own_buf, "E.No unwaited-for children left.");
2765 disable_async_io ();
2766 return;
2767 }
2768
d20a8ad9 2769 if (last_status.kind != TARGET_WAITKIND_EXITED
fa96cb38
PA
2770 && last_status.kind != TARGET_WAITKIND_SIGNALLED
2771 && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
0bfdf32f 2772 current_thread->last_status = last_status;
d20a8ad9 2773
ce1a5b52
PA
2774 /* From the client's perspective, all-stop mode always stops all
2775 threads implicitly (and the target backend has already done
2776 so by now). Tag all threads as "want-stopped", so we don't
2777 resume them implicitly without the client telling us to. */
2778 gdb_wants_all_threads_stopped ();
bd99dc85
PA
2779 prepare_resume_reply (own_buf, last_ptid, &last_status);
2780 disable_async_io ();
6bd31874
JB
2781
2782 if (last_status.kind == TARGET_WAITKIND_EXITED
2783 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2784 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
bd99dc85 2785 }
64386c31
DJ
2786}
2787
2d717e4f 2788/* Attach to a new program. Return 1 if successful, 0 if failure. */
5b3da067 2789static int
5b1c542e 2790handle_v_attach (char *own_buf)
2d717e4f
DJ
2791{
2792 int pid;
2793
2794 pid = strtol (own_buf + 8, NULL, 16);
5b1c542e 2795 if (pid != 0 && attach_inferior (pid) == 0)
2d717e4f 2796 {
aeba519e
PA
2797 /* Don't report shared library events after attaching, even if
2798 some libraries are preloaded. GDB will always poll the
2799 library list. Avoids the "stopped by shared library event"
2800 notice on the GDB side. */
2801 dlls_changed = 0;
bd99dc85
PA
2802
2803 if (non_stop)
2804 {
2805 /* In non-stop, we don't send a resume reply. Stop events
2806 will follow up using the normal notification
2807 mechanism. */
2808 write_ok (own_buf);
2809 }
2810 else
2811 prepare_resume_reply (own_buf, last_ptid, &last_status);
2812
2d717e4f
DJ
2813 return 1;
2814 }
2815 else
2816 {
2817 write_enn (own_buf);
2818 return 0;
2819 }
2820}
2821
2822/* Run a new program. Return 1 if successful, 0 if failure. */
2823static int
5b1c542e 2824handle_v_run (char *own_buf)
2d717e4f 2825{
aef93bd7 2826 char *p, *next_p, **new_argv;
2d717e4f
DJ
2827 int i, new_argc;
2828
2829 new_argc = 0;
2830 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
2831 {
2832 p++;
2833 new_argc++;
2834 }
2835
224c3ddb 2836 new_argv = (char **) calloc (new_argc + 2, sizeof (char *));
aef93bd7
DE
2837 if (new_argv == NULL)
2838 {
2839 write_enn (own_buf);
2840 return 0;
2841 }
2842
2d717e4f
DJ
2843 i = 0;
2844 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
2845 {
2846 next_p = strchr (p, ';');
2847 if (next_p == NULL)
2848 next_p = p + strlen (p);
2849
2850 if (i == 0 && p == next_p)
2851 new_argv[i] = NULL;
2852 else
2853 {
aef93bd7 2854 /* FIXME: Fail request if out of memory instead of dying. */
224c3ddb 2855 new_argv[i] = (char *) xmalloc (1 + (next_p - p) / 2);
ff0e980e 2856 hex2bin (p, (gdb_byte *) new_argv[i], (next_p - p) / 2);
2d717e4f
DJ
2857 new_argv[i][(next_p - p) / 2] = '\0';
2858 }
2859
2860 if (*next_p)
2861 next_p++;
2862 i++;
2863 }
2864 new_argv[i] = NULL;
2865
2866 if (new_argv[0] == NULL)
2867 {
f142445f
DJ
2868 /* GDB didn't specify a program to run. Use the program from the
2869 last run with the new argument list. */
9b710a42 2870
2d717e4f
DJ
2871 if (program_argv == NULL)
2872 {
2873 write_enn (own_buf);
b2c04452 2874 freeargv (new_argv);
2d717e4f
DJ
2875 return 0;
2876 }
2877
aef93bd7
DE
2878 new_argv[0] = strdup (program_argv[0]);
2879 if (new_argv[0] == NULL)
2880 {
aef93bd7 2881 write_enn (own_buf);
b2c04452 2882 freeargv (new_argv);
aef93bd7 2883 return 0;
1b3f6016 2884 }
2d717e4f 2885 }
f142445f 2886
aef93bd7
DE
2887 /* Free the old argv and install the new one. */
2888 freeargv (program_argv);
f142445f 2889 program_argv = new_argv;
2d717e4f 2890
5b1c542e
PA
2891 start_inferior (program_argv);
2892 if (last_status.kind == TARGET_WAITKIND_STOPPED)
2d717e4f 2893 {
5b1c542e 2894 prepare_resume_reply (own_buf, last_ptid, &last_status);
bd99dc85
PA
2895
2896 /* In non-stop, sending a resume reply doesn't set the general
2897 thread, but GDB assumes a vRun sets it (this is so GDB can
2898 query which is the main thread of the new inferior. */
2899 if (non_stop)
2900 general_thread = last_ptid;
2901
2d717e4f
DJ
2902 return 1;
2903 }
2904 else
2905 {
2906 write_enn (own_buf);
2907 return 0;
2908 }
2909}
2910
95954743 2911/* Kill process. Return 1 if successful, 0 if failure. */
5b3da067 2912static int
95954743
PA
2913handle_v_kill (char *own_buf)
2914{
2915 int pid;
2916 char *p = &own_buf[6];
0f54c268
PM
2917 if (multi_process)
2918 pid = strtol (p, NULL, 16);
2919 else
2920 pid = signal_pid;
95954743
PA
2921 if (pid != 0 && kill_inferior (pid) == 0)
2922 {
2923 last_status.kind = TARGET_WAITKIND_SIGNALLED;
a493e3e2 2924 last_status.value.sig = GDB_SIGNAL_KILL;
95954743 2925 last_ptid = pid_to_ptid (pid);
465a859e 2926 discard_queued_stop_replies (last_ptid);
95954743
PA
2927 write_ok (own_buf);
2928 return 1;
2929 }
2930 else
2931 {
2932 write_enn (own_buf);
2933 return 0;
2934 }
2935}
2936
64386c31 2937/* Handle all of the extended 'v' packets. */
28170b88 2938void
5b1c542e 2939handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
64386c31 2940{
db42f210 2941 if (!disable_packet_vCont)
64386c31 2942 {
de979965
PA
2943 if (strcmp (own_buf, "vCtrlC") == 0)
2944 {
2945 (*the_target->request_interrupt) ();
2946 write_ok (own_buf);
2947 return;
2948 }
2949
61012eef 2950 if (startswith (own_buf, "vCont;"))
db42f210
PA
2951 {
2952 require_running (own_buf);
5b1c542e 2953 handle_v_cont (own_buf);
db42f210
PA
2954 return;
2955 }
64386c31 2956
61012eef 2957 if (startswith (own_buf, "vCont?"))
db42f210 2958 {
750ce8d1
YQ
2959 strcpy (own_buf, "vCont;c;C;t");
2960
21536b36
YQ
2961 if (target_supports_hardware_single_step ()
2962 || target_supports_software_single_step ()
2963 || !vCont_supported)
750ce8d1 2964 {
21536b36
YQ
2965 /* If target supports single step either by hardware or by
2966 software, add actions s and S to the list of supported
2967 actions. On the other hand, if GDB doesn't request the
2968 supported vCont actions in qSupported packet, add s and
2969 S to the list too. */
750ce8d1
YQ
2970 own_buf = own_buf + strlen (own_buf);
2971 strcpy (own_buf, ";s;S");
2972 }
2973
c2d6af84
PA
2974 if (target_supports_range_stepping ())
2975 {
2976 own_buf = own_buf + strlen (own_buf);
2977 strcpy (own_buf, ";r");
2978 }
db42f210
PA
2979 return;
2980 }
64386c31
DJ
2981 }
2982
61012eef 2983 if (startswith (own_buf, "vFile:")
a6b151f1
DJ
2984 && handle_vFile (own_buf, packet_len, new_packet_len))
2985 return;
2986
61012eef 2987 if (startswith (own_buf, "vAttach;"))
2d717e4f 2988 {
901f9912 2989 if ((!extended_protocol || !multi_process) && target_running ())
2d717e4f 2990 {
fd96d250
PA
2991 fprintf (stderr, "Already debugging a process\n");
2992 write_enn (own_buf);
2993 return;
2d717e4f 2994 }
5b1c542e 2995 handle_v_attach (own_buf);
2d717e4f
DJ
2996 return;
2997 }
2998
61012eef 2999 if (startswith (own_buf, "vRun;"))
2d717e4f 3000 {
901f9912 3001 if ((!extended_protocol || !multi_process) && target_running ())
2d717e4f 3002 {
fd96d250
PA
3003 fprintf (stderr, "Already debugging a process\n");
3004 write_enn (own_buf);
3005 return;
2d717e4f 3006 }
5b1c542e 3007 handle_v_run (own_buf);
2d717e4f
DJ
3008 return;
3009 }
3010
61012eef 3011 if (startswith (own_buf, "vKill;"))
95954743
PA
3012 {
3013 if (!target_running ())
3014 {
3015 fprintf (stderr, "No process to kill\n");
3016 write_enn (own_buf);
3017 return;
3018 }
3019 handle_v_kill (own_buf);
3020 return;
3021 }
3022
14a00470
YQ
3023 if (handle_notif_ack (own_buf, packet_len))
3024 return;
bd99dc85 3025
64386c31
DJ
3026 /* Otherwise we didn't know what packet it was. Say we didn't
3027 understand it. */
3028 own_buf[0] = 0;
3029 return;
3030}
3031
0bfdf32f 3032/* Resume thread and wait for another event. In non-stop mode,
bd99dc85
PA
3033 don't really wait here, but return immediatelly to the event
3034 loop. */
1fd7cdc2 3035static void
5b1c542e 3036myresume (char *own_buf, int step, int sig)
64386c31
DJ
3037{
3038 struct thread_resume resume_info[2];
3039 int n = 0;
2bd7c093 3040 int valid_cont_thread;
a20d5e98 3041
95954743
PA
3042 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
3043 && !ptid_equal (cont_thread, minus_one_ptid));
2bd7c093
PA
3044
3045 if (step || sig || valid_cont_thread)
64386c31 3046 {
fbd5db48 3047 resume_info[0].thread = current_ptid;
bd99dc85
PA
3048 if (step)
3049 resume_info[0].kind = resume_step;
3050 else
3051 resume_info[0].kind = resume_continue;
64386c31 3052 resume_info[0].sig = sig;
64386c31
DJ
3053 n++;
3054 }
2bd7c093
PA
3055
3056 if (!valid_cont_thread)
3057 {
95954743 3058 resume_info[n].thread = minus_one_ptid;
bd99dc85 3059 resume_info[n].kind = resume_continue;
2bd7c093
PA
3060 resume_info[n].sig = 0;
3061 n++;
3062 }
64386c31 3063
b7ea362b 3064 resume (resume_info, n);
bd99dc85
PA
3065}
3066
3067/* Callback for for_each_inferior. Make a new stop reply for each
3068 stopped thread. */
3069
95954743
PA
3070static int
3071queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
bd99dc85 3072{
8336d594 3073 struct thread_info *thread = (struct thread_info *) entry;
bd99dc85 3074
8336d594
PA
3075 /* For now, assume targets that don't have this callback also don't
3076 manage the thread's last_status field. */
3077 if (the_target->thread_stopped == NULL)
95954743 3078 {
8d749320 3079 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
14a00470
YQ
3080
3081 new_notif->ptid = entry->id;
3082 new_notif->status = thread->last_status;
8336d594
PA
3083 /* Pass the last stop reply back to GDB, but don't notify
3084 yet. */
14a00470
YQ
3085 notif_event_enque (&notif_stop,
3086 (struct notif_event *) new_notif);
8336d594
PA
3087 }
3088 else
3089 {
3090 if (thread_stopped (thread))
3091 {
3092 if (debug_threads)
3360c0bf
LM
3093 {
3094 char *status_string
3095 = target_waitstatus_to_string (&thread->last_status);
3096
87ce2a04
DE
3097 debug_printf ("Reporting thread %s as already stopped with %s\n",
3098 target_pid_to_str (entry->id),
3099 status_string);
3360c0bf
LM
3100
3101 xfree (status_string);
3102 }
8336d594 3103
d20a8ad9
PA
3104 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
3105
8336d594
PA
3106 /* Pass the last stop reply back to GDB, but don't notify
3107 yet. */
3108 queue_stop_reply (entry->id, &thread->last_status);
3109 }
95954743
PA
3110 }
3111
3112 return 0;
64386c31
DJ
3113}
3114
ce1a5b52
PA
3115/* Set this inferior threads's state as "want-stopped". We won't
3116 resume this thread until the client gives us another action for
3117 it. */
8336d594
PA
3118
3119static void
3120gdb_wants_thread_stopped (struct inferior_list_entry *entry)
3121{
3122 struct thread_info *thread = (struct thread_info *) entry;
3123
3124 thread->last_resume_kind = resume_stop;
3125
3126 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
3127 {
ce1a5b52
PA
3128 /* Most threads are stopped implicitly (all-stop); tag that with
3129 signal 0. */
8336d594 3130 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
a493e3e2 3131 thread->last_status.value.sig = GDB_SIGNAL_0;
8336d594
PA
3132 }
3133}
3134
3135/* Set all threads' states as "want-stopped". */
3136
3137static void
3138gdb_wants_all_threads_stopped (void)
3139{
3140 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
3141}
3142
3143/* Clear the gdb_detached flag of every process. */
3144
3145static void
3146gdb_reattached_process (struct inferior_list_entry *entry)
3147{
3148 struct process_info *process = (struct process_info *) entry;
3149
3150 process->gdb_detached = 0;
3151}
3152
b7ea362b
PA
3153/* Callback for for_each_inferior. Clear the thread's pending status
3154 flag. */
3155
3156static void
3157clear_pending_status_callback (struct inferior_list_entry *entry)
3158{
3159 struct thread_info *thread = (struct thread_info *) entry;
3160
3161 thread->status_pending_p = 0;
3162}
3163
3164/* Callback for for_each_inferior. If the thread is stopped with an
3165 interesting event, mark it as having a pending event. */
3166
3167static void
3168set_pending_status_callback (struct inferior_list_entry *entry)
3169{
3170 struct thread_info *thread = (struct thread_info *) entry;
3171
3172 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
3173 || (thread->last_status.value.sig != GDB_SIGNAL_0
3174 /* A breakpoint, watchpoint or finished step from a previous
3175 GDB run isn't considered interesting for a new GDB run.
3176 If we left those pending, the new GDB could consider them
3177 random SIGTRAPs. This leaves out real async traps. We'd
3178 have to peek into the (target-specific) siginfo to
3179 distinguish those. */
3180 && thread->last_status.value.sig != GDB_SIGNAL_TRAP))
3181 thread->status_pending_p = 1;
3182}
3183
3184/* Callback for find_inferior. Return true if ENTRY (a thread) has a
3185 pending status to report to GDB. */
3186
3187static int
3188find_status_pending_thread_callback (struct inferior_list_entry *entry, void *data)
3189{
3190 struct thread_info *thread = (struct thread_info *) entry;
3191
3192 return thread->status_pending_p;
3193}
3194
5b1c542e
PA
3195/* Status handler for the '?' packet. */
3196
3197static void
3198handle_status (char *own_buf)
3199{
8336d594
PA
3200 /* GDB is connected, don't forward events to the target anymore. */
3201 for_each_inferior (&all_processes, gdb_reattached_process);
bd99dc85
PA
3202
3203 /* In non-stop mode, we must send a stop reply for each stopped
3204 thread. In all-stop mode, just send one for the first stopped
3205 thread we find. */
3206
3207 if (non_stop)
3208 {
8336d594 3209 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
bd99dc85
PA
3210
3211 /* The first is sent immediatly. OK is sent if there is no
3212 stopped thread, which is the same handling of the vStopped
3213 packet (by design). */
14a00470 3214 notif_write_event (&notif_stop, own_buf);
bd99dc85 3215 }
5b1c542e 3216 else
bd99dc85 3217 {
b7ea362b
PA
3218 struct inferior_list_entry *thread = NULL;
3219
7984d532 3220 pause_all (0);
fa593d66 3221 stabilize_threads ();
8336d594
PA
3222 gdb_wants_all_threads_stopped ();
3223
b7ea362b
PA
3224 /* We can only report one status, but we might be coming out of
3225 non-stop -- if more than one thread is stopped with
3226 interesting events, leave events for the threads we're not
3227 reporting now pending. They'll be reported the next time the
3228 threads are resumed. Start by marking all interesting events
3229 as pending. */
3230 for_each_inferior (&all_threads, set_pending_status_callback);
3231
3232 /* Prefer the last thread that reported an event to GDB (even if
3233 that was a GDB_SIGNAL_TRAP). */
3234 if (last_status.kind != TARGET_WAITKIND_IGNORE
3235 && last_status.kind != TARGET_WAITKIND_EXITED
3236 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
3237 thread = find_inferior_id (&all_threads, last_ptid);
3238
3239 /* If the last event thread is not found for some reason, look
3240 for some other thread that might have an event to report. */
3241 if (thread == NULL)
3242 thread = find_inferior (&all_threads,
3243 find_status_pending_thread_callback, NULL);
3244
3245 /* If we're still out of luck, simply pick the first thread in
3246 the thread list. */
3247 if (thread == NULL)
649ebbca 3248 thread = get_first_inferior (&all_threads);
b7ea362b
PA
3249
3250 if (thread != NULL)
8336d594 3251 {
b7ea362b
PA
3252 struct thread_info *tp = (struct thread_info *) thread;
3253
3254 /* We're reporting this event, so it's no longer
3255 pending. */
3256 tp->status_pending_p = 0;
3257
3258 /* GDB assumes the current thread is the thread we're
3259 reporting the status for. */
3260 general_thread = thread->id;
0bfdf32f 3261 set_desired_thread (1);
8336d594 3262
b7ea362b
PA
3263 gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
3264 prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status);
8336d594 3265 }
bd99dc85
PA
3266 else
3267 strcpy (own_buf, "W00");
3268 }
5b1c542e
PA
3269}
3270
dd24457d
DJ
3271static void
3272gdbserver_version (void)
3273{
c16158bc 3274 printf ("GNU gdbserver %s%s\n"
edd88788 3275 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
493e2a69
MS
3276 "gdbserver is free software, covered by the "
3277 "GNU General Public License.\n"
dd24457d 3278 "This gdbserver was configured as \"%s\"\n",
c16158bc 3279 PKGVERSION, version, host_name);
dd24457d
DJ
3280}
3281
0bc68c49 3282static void
c16158bc 3283gdbserver_usage (FILE *stream)
0bc68c49 3284{
c16158bc
JM
3285 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3286 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3287 "\tgdbserver [OPTIONS] --multi COMM\n"
3288 "\n"
41f98f02
PA
3289 "COMM may either be a tty device (for serial debugging),\n"
3290 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3291 "stdin/stdout of gdbserver.\n"
3292 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3293 "PID is the process ID to attach to, when --attach is specified.\n"
3294 "\n"
3295 "Operating modes:\n"
3296 "\n"
3297 " --attach Attach to running process PID.\n"
3298 " --multi Start server without a specific program, and\n"
3299 " only quit when explicitly commanded.\n"
3300 " --once Exit after the first connection has closed.\n"
3301 " --help Print this message and then exit.\n"
3302 " --version Display version information and exit.\n"
3303 "\n"
3304 "Other options:\n"
3305 "\n"
3306 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3307 " --disable-randomization\n"
3308 " Run PROG with address space randomization disabled.\n"
3309 " --no-disable-randomization\n"
3310 " Don't disable address space randomization when\n"
3311 " starting PROG.\n"
3312 "\n"
3313 "Debug options:\n"
c16158bc 3314 "\n"
62709adf 3315 " --debug Enable general debugging output.\n"
87ce2a04
DE
3316 " --debug-format=opt1[,opt2,...]\n"
3317 " Specify extra content in debugging output.\n"
3318 " Options:\n"
3319 " all\n"
3320 " none\n"
87ce2a04 3321 " timestamp\n"
62709adf 3322 " --remote-debug Enable remote protocol debugging output.\n"
41f98f02
PA
3323 " --disable-packet=opt1[,opt2,...]\n"
3324 " Disable support for RSP packets or features.\n"
3325 " Options:\n"
3326 " vCont, Tthread, qC, qfThreadInfo and \n"
3327 " threads (disable all threading packets).\n"
3328 "\n"
3329 "For more information, consult the GDB manual (available as on-line \n"
3330 "info or a printed manual).\n");
c16158bc
JM
3331 if (REPORT_BUGS_TO[0] && stream == stdout)
3332 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
0bc68c49
DJ
3333}
3334
db42f210
PA
3335static void
3336gdbserver_show_disableable (FILE *stream)
3337{
3338 fprintf (stream, "Disableable packets:\n"
3339 " vCont \tAll vCont packets\n"
3340 " qC \tQuerying the current thread\n"
3341 " qfThreadInfo\tThread listing\n"
493e2a69
MS
3342 " Tthread \tPassing the thread specifier in the "
3343 "T stop reply packet\n"
db42f210
PA
3344 " threads \tAll of the above\n");
3345}
3346
3347
2d717e4f
DJ
3348#undef require_running
3349#define require_running(BUF) \
3350 if (!target_running ()) \
3351 { \
3352 write_enn (BUF); \
3353 break; \
3354 }
3355
95954743
PA
3356static int
3357first_thread_of (struct inferior_list_entry *entry, void *args)
3358{
3359 int pid = * (int *) args;
3360
3361 if (ptid_get_pid (entry->id) == pid)
3362 return 1;
3363
3364 return 0;
3365}
3366
3367static void
3368kill_inferior_callback (struct inferior_list_entry *entry)
3369{
3370 struct process_info *process = (struct process_info *) entry;
80894984 3371 int pid = ptid_get_pid (process->entry.id);
95954743
PA
3372
3373 kill_inferior (pid);
465a859e 3374 discard_queued_stop_replies (pid_to_ptid (pid));
95954743
PA
3375}
3376
9f767825
DE
3377/* Callback for for_each_inferior to detach or kill the inferior,
3378 depending on whether we attached to it or not.
3379 We inform the user whether we're detaching or killing the process
3380 as this is only called when gdbserver is about to exit. */
3381
95954743
PA
3382static void
3383detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
3384{
3385 struct process_info *process = (struct process_info *) entry;
80894984 3386 int pid = ptid_get_pid (process->entry.id);
95954743
PA
3387
3388 if (process->attached)
3389 detach_inferior (pid);
3390 else
3391 kill_inferior (pid);
3392
465a859e 3393 discard_queued_stop_replies (pid_to_ptid (pid));
95954743
PA
3394}
3395
9f767825
DE
3396/* for_each_inferior callback for detach_or_kill_for_exit to print
3397 the pids of started inferiors. */
3398
3399static void
3400print_started_pid (struct inferior_list_entry *entry)
3401{
3402 struct process_info *process = (struct process_info *) entry;
3403
3404 if (! process->attached)
3405 {
80894984 3406 int pid = ptid_get_pid (process->entry.id);
9f767825
DE
3407 fprintf (stderr, " %d", pid);
3408 }
3409}
3410
3411/* for_each_inferior callback for detach_or_kill_for_exit to print
3412 the pids of attached inferiors. */
3413
3414static void
3415print_attached_pid (struct inferior_list_entry *entry)
3416{
3417 struct process_info *process = (struct process_info *) entry;
3418
3419 if (process->attached)
3420 {
80894984 3421 int pid = ptid_get_pid (process->entry.id);
9f767825
DE
3422 fprintf (stderr, " %d", pid);
3423 }
3424}
3425
3426/* Call this when exiting gdbserver with possible inferiors that need
3427 to be killed or detached from. */
3428
3429static void
3430detach_or_kill_for_exit (void)
3431{
3432 /* First print a list of the inferiors we will be killing/detaching.
3433 This is to assist the user, for example, in case the inferior unexpectedly
3434 dies after we exit: did we screw up or did the inferior exit on its own?
3435 Having this info will save some head-scratching. */
3436
3437 if (have_started_inferiors_p ())
3438 {
3439 fprintf (stderr, "Killing process(es):");
3440 for_each_inferior (&all_processes, print_started_pid);
3441 fprintf (stderr, "\n");
3442 }
3443 if (have_attached_inferiors_p ())
3444 {
3445 fprintf (stderr, "Detaching process(es):");
3446 for_each_inferior (&all_processes, print_attached_pid);
3447 fprintf (stderr, "\n");
3448 }
3449
3450 /* Now we can kill or detach the inferiors. */
3451
3452 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
3453}
3454
860789c7
GB
3455/* Value that will be passed to exit(3) when gdbserver exits. */
3456static int exit_code;
3457
3458/* Cleanup version of detach_or_kill_for_exit. */
3459
3460static void
3461detach_or_kill_for_exit_cleanup (void *ignore)
3462{
860789c7 3463
492d29ea 3464 TRY
860789c7
GB
3465 {
3466 detach_or_kill_for_exit ();
3467 }
3468
492d29ea 3469 CATCH (exception, RETURN_MASK_ALL)
860789c7
GB
3470 {
3471 fflush (stdout);
3472 fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
3473 exit_code = 1;
3474 }
492d29ea 3475 END_CATCH
860789c7
GB
3476}
3477
3478/* Main function. This is called by the real "main" function,
3479 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3480
3481static void ATTRIBUTE_NORETURN
3482captured_main (int argc, char *argv[])
c906108c 3483{
0729219d
DJ
3484 int bad_attach;
3485 int pid;
2d717e4f
DJ
3486 char *arg_end, *port;
3487 char **next_arg = &argv[1];
89dc0afd
JK
3488 volatile int multi_mode = 0;
3489 volatile int attach = 0;
2d717e4f 3490 int was_running;
c906108c 3491
2d717e4f 3492 while (*next_arg != NULL && **next_arg == '-')
dd24457d 3493 {
2d717e4f
DJ
3494 if (strcmp (*next_arg, "--version") == 0)
3495 {
3496 gdbserver_version ();
3497 exit (0);
3498 }
3499 else if (strcmp (*next_arg, "--help") == 0)
3500 {
c16158bc 3501 gdbserver_usage (stdout);
2d717e4f
DJ
3502 exit (0);
3503 }
3504 else if (strcmp (*next_arg, "--attach") == 0)
3505 attach = 1;
3506 else if (strcmp (*next_arg, "--multi") == 0)
3507 multi_mode = 1;
ccd213ac
DJ
3508 else if (strcmp (*next_arg, "--wrapper") == 0)
3509 {
3510 next_arg++;
3511
3512 wrapper_argv = next_arg;
3513 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
3514 next_arg++;
3515
3516 if (next_arg == wrapper_argv || *next_arg == NULL)
3517 {
c16158bc 3518 gdbserver_usage (stderr);
ccd213ac
DJ
3519 exit (1);
3520 }
3521
3522 /* Consume the "--". */
3523 *next_arg = NULL;
3524 }
2d717e4f
DJ
3525 else if (strcmp (*next_arg, "--debug") == 0)
3526 debug_threads = 1;
61012eef 3527 else if (startswith (*next_arg, "--debug-format="))
87ce2a04
DE
3528 {
3529 char *error_msg
3530 = parse_debug_format_options ((*next_arg)
3531 + sizeof ("--debug-format=") - 1, 0);
3532
3533 if (error_msg != NULL)
3534 {
3535 fprintf (stderr, "%s", error_msg);
3536 exit (1);
3537 }
3538 }
62709adf
PA
3539 else if (strcmp (*next_arg, "--remote-debug") == 0)
3540 remote_debug = 1;
db42f210
PA
3541 else if (strcmp (*next_arg, "--disable-packet") == 0)
3542 {
3543 gdbserver_show_disableable (stdout);
3544 exit (0);
3545 }
61012eef 3546 else if (startswith (*next_arg, "--disable-packet="))
db42f210
PA
3547 {
3548 char *packets, *tok;
3549
3550 packets = *next_arg += sizeof ("--disable-packet=") - 1;
3551 for (tok = strtok (packets, ",");
3552 tok != NULL;
3553 tok = strtok (NULL, ","))
3554 {
3555 if (strcmp ("vCont", tok) == 0)
3556 disable_packet_vCont = 1;
3557 else if (strcmp ("Tthread", tok) == 0)
3558 disable_packet_Tthread = 1;
3559 else if (strcmp ("qC", tok) == 0)
3560 disable_packet_qC = 1;
3561 else if (strcmp ("qfThreadInfo", tok) == 0)
3562 disable_packet_qfThreadInfo = 1;
3563 else if (strcmp ("threads", tok) == 0)
3564 {
3565 disable_packet_vCont = 1;
3566 disable_packet_Tthread = 1;
3567 disable_packet_qC = 1;
3568 disable_packet_qfThreadInfo = 1;
3569 }
3570 else
3571 {
3572 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
3573 tok);
3574 gdbserver_show_disableable (stderr);
3575 exit (1);
3576 }
3577 }
3578 }
e0f9f062
DE
3579 else if (strcmp (*next_arg, "-") == 0)
3580 {
3581 /* "-" specifies a stdio connection and is a form of port
3582 specification. */
3583 *next_arg = STDIO_CONNECTION_NAME;
3584 break;
3585 }
03583c20
UW
3586 else if (strcmp (*next_arg, "--disable-randomization") == 0)
3587 disable_randomization = 1;
3588 else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
3589 disable_randomization = 0;
03f2bd59
JK
3590 else if (strcmp (*next_arg, "--once") == 0)
3591 run_once = 1;
2d717e4f
DJ
3592 else
3593 {
3594 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
3595 exit (1);
3596 }
dd24457d 3597
2d717e4f
DJ
3598 next_arg++;
3599 continue;
dd24457d
DJ
3600 }
3601
2d717e4f
DJ
3602 port = *next_arg;
3603 next_arg++;
3604 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
3605 {
c16158bc 3606 gdbserver_usage (stderr);
2d717e4f
DJ
3607 exit (1);
3608 }
3609
602e3198
JK
3610 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3611 opened by remote_prepare. */
3612 notice_open_fds ();
3613
f348d89a
PA
3614 save_original_signals_state ();
3615
e0f9f062
DE
3616 /* We need to know whether the remote connection is stdio before
3617 starting the inferior. Inferiors created in this scenario have
3618 stdin,stdout redirected. So do this here before we call
3619 start_inferior. */
3620 remote_prepare (port);
3621
0729219d
DJ
3622 bad_attach = 0;
3623 pid = 0;
2d717e4f
DJ
3624
3625 /* --attach used to come after PORT, so allow it there for
3626 compatibility. */
3627 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
45b7b345 3628 {
2d717e4f
DJ
3629 attach = 1;
3630 next_arg++;
45b7b345
DJ
3631 }
3632
2d717e4f
DJ
3633 if (attach
3634 && (*next_arg == NULL
3635 || (*next_arg)[0] == '\0'
3636 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
3637 || *arg_end != '\0'
3638 || next_arg[1] != NULL))
3639 bad_attach = 1;
3640
3641 if (bad_attach)
dd24457d 3642 {
c16158bc 3643 gdbserver_usage (stderr);
dd24457d
DJ
3644 exit (1);
3645 }
c906108c 3646
a20d5e98 3647 initialize_async_io ();
4ce44c66 3648 initialize_low ();
60f662b0 3649 initialize_event_loop ();
219f2f23
PA
3650 if (target_supports_tracepoints ())
3651 initialize_tracepoint ();
465a859e 3652 initialize_notif ();
4ce44c66 3653
224c3ddb
SM
3654 own_buf = (char *) xmalloc (PBUFSIZ + 1);
3655 mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
0a30fbc4 3656
2d717e4f 3657 if (pid == 0 && *next_arg != NULL)
45b7b345 3658 {
2d717e4f
DJ
3659 int i, n;
3660
3661 n = argc - (next_arg - argv);
224c3ddb 3662 program_argv = XNEWVEC (char *, n + 1);
2d717e4f 3663 for (i = 0; i < n; i++)
bca929d3 3664 program_argv[i] = xstrdup (next_arg[i]);
2d717e4f
DJ
3665 program_argv[i] = NULL;
3666
45b7b345 3667 /* Wait till we are at first instruction in program. */
5b1c542e 3668 start_inferior (program_argv);
c906108c 3669
c588c53c
MS
3670 /* We are now (hopefully) stopped at the first instruction of
3671 the target process. This assumes that the target process was
3672 successfully created. */
45b7b345 3673 }
2d717e4f
DJ
3674 else if (pid != 0)
3675 {
5b1c542e 3676 if (attach_inferior (pid) == -1)
2d717e4f
DJ
3677 error ("Attaching not supported on this target");
3678
3679 /* Otherwise succeeded. */
3680 }
45b7b345
DJ
3681 else
3682 {
5b1c542e
PA
3683 last_status.kind = TARGET_WAITKIND_EXITED;
3684 last_status.value.integer = 0;
95954743 3685 last_ptid = minus_one_ptid;
45b7b345 3686 }
860789c7 3687 make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
c906108c 3688
311de423
PA
3689 /* Don't report shared library events on the initial connection,
3690 even if some libraries are preloaded. Avoids the "stopped by
3691 shared library event" notice on gdb side. */
3692 dlls_changed = 0;
3693
5b1c542e
PA
3694 if (last_status.kind == TARGET_WAITKIND_EXITED
3695 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2d717e4f
DJ
3696 was_running = 0;
3697 else
3698 was_running = 1;
3699
3700 if (!was_running && !multi_mode)
860789c7 3701 error ("No program to debug");
c588c53c 3702
c906108c
SS
3703 while (1)
3704 {
860789c7 3705
a6f3e723 3706 noack_mode = 0;
95954743 3707 multi_process = 0;
89245bc0
DB
3708 report_fork_events = 0;
3709 report_vfork_events = 0;
94585166 3710 report_exec_events = 0;
8336d594
PA
3711 /* Be sure we're out of tfind mode. */
3712 current_traceframe = -1;
40e91bc7 3713 cont_thread = null_ptid;
1ec68e26
PA
3714 swbreak_feature = 0;
3715 hwbreak_feature = 0;
750ce8d1 3716 vCont_supported = 0;
bd99dc85 3717
2d717e4f 3718 remote_open (port);
c906108c 3719
492d29ea 3720 TRY
2d717e4f 3721 {
860789c7
GB
3722 /* Wait for events. This will return when all event sources
3723 are removed from the event loop. */
3724 start_event_loop ();
2d717e4f 3725
860789c7 3726 /* If an exit was requested (using the "monitor exit"
fddedbe6
PA
3727 command), terminate now. */
3728 if (exit_requested)
3729 throw_quit ("Quit");
3730
3731 /* The only other way to get here is for getpkt to fail:
3732
3733 - If --once was specified, we're done.
bd99dc85 3734
fddedbe6
PA
3735 - If not in extended-remote mode, and we're no longer
3736 debugging anything, simply exit: GDB has disconnected
3737 after processing the last process exit.
3738
3739 - Otherwise, close the connection and reopen it at the
3740 top of the loop. */
3741 if (run_once || (!extended_protocol && !target_running ()))
860789c7 3742 throw_quit ("Quit");
bd99dc85 3743
860789c7
GB
3744 fprintf (stderr,
3745 "Remote side has terminated connection. "
3746 "GDBserver will reopen the connection.\n");
8336d594 3747
860789c7
GB
3748 /* Get rid of any pending statuses. An eventual reconnection
3749 (by the same GDB instance or another) will refresh all its
3750 state from scratch. */
465a859e 3751 discard_queued_stop_replies (minus_one_ptid);
860789c7
GB
3752 for_each_inferior (&all_threads,
3753 clear_pending_status_callback);
9939e131 3754
860789c7 3755 if (tracing)
8336d594 3756 {
860789c7 3757 if (disconnected_tracing)
8336d594 3758 {
860789c7
GB
3759 /* Try to enable non-stop/async mode, so we we can
3760 both wait for an async socket accept, and handle
3761 async target events simultaneously. There's also
3762 no point either in having the target always stop
3763 all threads, when we're going to pass signals
3764 down without informing GDB. */
3765 if (!non_stop)
3766 {
3767 if (start_non_stop (1))
3768 non_stop = 1;
3769
3770 /* Detaching implicitly resumes all threads;
3771 simply disconnecting does not. */
3772 }
3773 }
3774 else
3775 {
3776 fprintf (stderr,
3777 "Disconnected tracing disabled; "
3778 "stopping trace run.\n");
3779 stop_tracing ();
8336d594
PA
3780 }
3781 }
860789c7 3782 }
492d29ea 3783 CATCH (exception, RETURN_MASK_ERROR)
860789c7 3784 {
608a1e46
PA
3785 fflush (stdout);
3786 fprintf (stderr, "gdbserver: %s\n", exception.message);
3787
860789c7 3788 if (response_needed)
8336d594 3789 {
860789c7
GB
3790 write_enn (own_buf);
3791 putpkt (own_buf);
8336d594 3792 }
608a1e46
PA
3793
3794 if (run_once)
3795 throw_quit ("Quit");
8336d594 3796 }
492d29ea 3797 END_CATCH
bd99dc85
PA
3798 }
3799}
01f9e8fa 3800
860789c7
GB
3801/* Main function. */
3802
3803int
3804main (int argc, char *argv[])
3805{
860789c7 3806
492d29ea 3807 TRY
860789c7
GB
3808 {
3809 captured_main (argc, argv);
3810 }
492d29ea 3811 CATCH (exception, RETURN_MASK_ALL)
860789c7 3812 {
492d29ea
PA
3813 if (exception.reason == RETURN_ERROR)
3814 {
3815 fflush (stdout);
3816 fprintf (stderr, "%s\n", exception.message);
3817 fprintf (stderr, "Exiting\n");
3818 exit_code = 1;
3819 }
3820
3821 exit (exit_code);
860789c7 3822 }
492d29ea 3823 END_CATCH
860789c7 3824
492d29ea 3825 gdb_assert_not_reached ("captured_main should never return");
860789c7
GB
3826}
3827
802e8e6d
PA
3828/* Process options coming from Z packets for a breakpoint. PACKET is
3829 the packet buffer. *PACKET is updated to point to the first char
3830 after the last processed option. */
9f3a5c85
LM
3831
3832static void
9aa76cd0 3833process_point_options (struct gdb_breakpoint *bp, char **packet)
9f3a5c85
LM
3834{
3835 char *dataptr = *packet;
d3ce09f5 3836 int persist;
9f3a5c85
LM
3837
3838 /* Check if data has the correct format. */
3839 if (*dataptr != ';')
3840 return;
3841
3842 dataptr++;
3843
3844 while (*dataptr)
3845 {
d3ce09f5
SS
3846 if (*dataptr == ';')
3847 ++dataptr;
3848
3849 if (*dataptr == 'X')
9f3a5c85 3850 {
d3ce09f5 3851 /* Conditional expression. */
d171ca78 3852 if (debug_threads)
87ce2a04 3853 debug_printf ("Found breakpoint condition.\n");
802e8e6d 3854 if (!add_breakpoint_condition (bp, &dataptr))
8424cc97 3855 dataptr = strchrnul (dataptr, ';');
d3ce09f5 3856 }
61012eef 3857 else if (startswith (dataptr, "cmds:"))
d3ce09f5
SS
3858 {
3859 dataptr += strlen ("cmds:");
3860 if (debug_threads)
87ce2a04 3861 debug_printf ("Found breakpoint commands %s.\n", dataptr);
d3ce09f5
SS
3862 persist = (*dataptr == '1');
3863 dataptr += 2;
802e8e6d 3864 if (add_breakpoint_commands (bp, &dataptr, persist))
8424cc97 3865 dataptr = strchrnul (dataptr, ';');
d3ce09f5
SS
3866 }
3867 else
3868 {
d3ce09f5
SS
3869 fprintf (stderr, "Unknown token %c, ignoring.\n",
3870 *dataptr);
78a99e91 3871 /* Skip tokens until we find one that we recognize. */
8424cc97 3872 dataptr = strchrnul (dataptr, ';');
9f3a5c85 3873 }
9f3a5c85
LM
3874 }
3875 *packet = dataptr;
3876}
3877
bd99dc85
PA
3878/* Event loop callback that handles a serial event. The first byte in
3879 the serial buffer gets us here. We expect characters to arrive at
3880 a brisk pace, so we read the rest of the packet with a blocking
3881 getpkt call. */
01f9e8fa 3882
8336d594 3883static int
bd99dc85
PA
3884process_serial_event (void)
3885{
3886 char ch;
3887 int i = 0;
3888 int signal;
3889 unsigned int len;
764880b7 3890 int res;
bd99dc85 3891 CORE_ADDR mem_addr;
95954743 3892 int pid;
bd99dc85
PA
3893 unsigned char sig;
3894 int packet_len;
3895 int new_packet_len = -1;
3896
bd99dc85
PA
3897 disable_async_io ();
3898
3899 response_needed = 0;
3900 packet_len = getpkt (own_buf);
3901 if (packet_len <= 0)
3902 {
bd99dc85 3903 remote_close ();
8336d594
PA
3904 /* Force an event loop break. */
3905 return -1;
bd99dc85
PA
3906 }
3907 response_needed = 1;
3908
3909 i = 0;
3910 ch = own_buf[i++];
3911 switch (ch)
3912 {
3913 case 'q':
3914 handle_query (own_buf, packet_len, &new_packet_len);
3915 break;
3916 case 'Q':
3917 handle_general_set (own_buf);
3918 break;
3919 case 'D':
3920 require_running (own_buf);
95954743
PA
3921
3922 if (multi_process)
3923 {
3924 i++; /* skip ';' */
3925 pid = strtol (&own_buf[i], NULL, 16);
3926 }
3927 else
fbd5db48 3928 pid = ptid_get_pid (current_ptid);
95954743 3929
d3ce09f5 3930 if ((tracing && disconnected_tracing) || any_persistent_commands ())
8336d594
PA
3931 {
3932 struct thread_resume resume_info;
3933 struct process_info *process = find_process_pid (pid);
3934
3935 if (process == NULL)
3936 {
3937 write_enn (own_buf);
3938 break;
3939 }
3940
d3ce09f5
SS
3941 if (tracing && disconnected_tracing)
3942 fprintf (stderr,
3943 "Disconnected tracing in effect, "
3944 "leaving gdbserver attached to the process\n");
3945
3946 if (any_persistent_commands ())
3947 fprintf (stderr,
3948 "Persistent commands are present, "
3949 "leaving gdbserver attached to the process\n");
8336d594
PA
3950
3951 /* Make sure we're in non-stop/async mode, so we we can both
3952 wait for an async socket accept, and handle async target
3953 events simultaneously. There's also no point either in
3954 having the target stop all threads, when we're going to
3955 pass signals down without informing GDB. */
3956 if (!non_stop)
3957 {
3958 if (debug_threads)
87ce2a04 3959 debug_printf ("Forcing non-stop mode\n");
8336d594
PA
3960
3961 non_stop = 1;
3962 start_non_stop (1);
3963 }
3964
3965 process->gdb_detached = 1;
3966
3967 /* Detaching implicitly resumes all threads. */
3968 resume_info.thread = minus_one_ptid;
3969 resume_info.kind = resume_continue;
3970 resume_info.sig = 0;
3971 (*the_target->resume) (&resume_info, 1);
3972
3973 write_ok (own_buf);
3974 break; /* from switch/case */
3975 }
3976
95954743 3977 fprintf (stderr, "Detaching from process %d\n", pid);
8336d594 3978 stop_tracing ();
95954743 3979 if (detach_inferior (pid) != 0)
bd99dc85
PA
3980 write_enn (own_buf);
3981 else
3982 {
465a859e 3983 discard_queued_stop_replies (pid_to_ptid (pid));
bd99dc85
PA
3984 write_ok (own_buf);
3985
8020350c 3986 if (extended_protocol || target_running ())
c906108c 3987 {
8020350c
DB
3988 /* There is still at least one inferior remaining or
3989 we are in extended mode, so don't terminate gdbserver,
3990 and instead treat this like a normal program exit. */
bd99dc85
PA
3991 last_status.kind = TARGET_WAITKIND_EXITED;
3992 last_status.value.integer = 0;
95954743 3993 last_ptid = pid_to_ptid (pid);
2d717e4f 3994
0bfdf32f 3995 current_thread = NULL;
bd99dc85
PA
3996 }
3997 else
3998 {
3999 putpkt (own_buf);
4000 remote_close ();
4001
4002 /* If we are attached, then we can exit. Otherwise, we
4003 need to hang around doing nothing, until the child is
4004 gone. */
71f55dd8 4005 join_inferior (pid);
bd99dc85
PA
4006 exit (0);
4007 }
4008 }
4009 break;
4010 case '!':
4011 extended_protocol = 1;
4012 write_ok (own_buf);
4013 break;
4014 case '?':
4015 handle_status (own_buf);
4016 break;
4017 case 'H':
4018 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
4019 {
95954743
PA
4020 ptid_t gdb_id, thread_id;
4021 int pid;
bd99dc85
PA
4022
4023 require_running (own_buf);
95954743
PA
4024
4025 gdb_id = read_ptid (&own_buf[2], NULL);
4026
4027 pid = ptid_get_pid (gdb_id);
4028
4029 if (ptid_equal (gdb_id, null_ptid)
4030 || ptid_equal (gdb_id, minus_one_ptid))
4031 thread_id = null_ptid;
4032 else if (pid != 0
4033 && ptid_equal (pid_to_ptid (pid),
4034 gdb_id))
4035 {
4036 struct thread_info *thread =
4037 (struct thread_info *) find_inferior (&all_threads,
4038 first_thread_of,
4039 &pid);
4040 if (!thread)
4041 {
4042 write_enn (own_buf);
4043 break;
4044 }
4045
80894984 4046 thread_id = thread->entry.id;
95954743 4047 }
bd99dc85
PA
4048 else
4049 {
4050 thread_id = gdb_id_to_thread_id (gdb_id);
95954743 4051 if (ptid_equal (thread_id, null_ptid))
c906108c 4052 {
a06660f7 4053 write_enn (own_buf);
c906108c
SS
4054 break;
4055 }
c906108c
SS
4056 }
4057
bd99dc85 4058 if (own_buf[1] == 'g')
c906108c 4059 {
95954743 4060 if (ptid_equal (thread_id, null_ptid))
c906108c 4061 {
bd99dc85
PA
4062 /* GDB is telling us to choose any thread. Check if
4063 the currently selected thread is still valid. If
4064 it is not, select the first available. */
4065 struct thread_info *thread =
4066 (struct thread_info *) find_inferior_id (&all_threads,
4067 general_thread);
4068 if (thread == NULL)
f0db101d
PA
4069 thread = get_first_thread ();
4070 thread_id = thread->entry.id;
c906108c 4071 }
bd99dc85
PA
4072
4073 general_thread = thread_id;
0bfdf32f 4074 set_desired_thread (1);
f0db101d 4075 gdb_assert (current_thread != NULL);
c906108c 4076 }
bd99dc85
PA
4077 else if (own_buf[1] == 'c')
4078 cont_thread = thread_id;
c906108c 4079
bd99dc85
PA
4080 write_ok (own_buf);
4081 }
4082 else
4083 {
4084 /* Silently ignore it so that gdb can extend the protocol
4085 without compatibility headaches. */
4086 own_buf[0] = '\0';
2d717e4f 4087 }
bd99dc85
PA
4088 break;
4089 case 'g':
219f2f23
PA
4090 require_running (own_buf);
4091 if (current_traceframe >= 0)
4092 {
3aee8918
PA
4093 struct regcache *regcache
4094 = new_register_cache (current_target_desc ());
219f2f23
PA
4095
4096 if (fetch_traceframe_registers (current_traceframe,
4097 regcache, -1) == 0)
4098 registers_to_string (regcache, own_buf);
4099 else
4100 write_enn (own_buf);
4101 free_register_cache (regcache);
4102 }
4103 else
4104 {
4105 struct regcache *regcache;
4106
f0db101d
PA
4107 if (!set_desired_thread (1))
4108 write_enn (own_buf);
4109 else
4110 {
4111 regcache = get_thread_regcache (current_thread, 1);
4112 registers_to_string (regcache, own_buf);
4113 }
219f2f23 4114 }
bd99dc85
PA
4115 break;
4116 case 'G':
219f2f23
PA
4117 require_running (own_buf);
4118 if (current_traceframe >= 0)
4119 write_enn (own_buf);
4120 else
4121 {
442ea881
PA
4122 struct regcache *regcache;
4123
f0db101d
PA
4124 if (!set_desired_thread (1))
4125 write_enn (own_buf);
4126 else
4127 {
4128 regcache = get_thread_regcache (current_thread, 1);
4129 registers_from_string (regcache, &own_buf[1]);
4130 write_ok (own_buf);
4131 }
442ea881 4132 }
bd99dc85
PA
4133 break;
4134 case 'm':
4135 require_running (own_buf);
4136 decode_m_packet (&own_buf[1], &mem_addr, &len);
764880b7
PA
4137 res = gdb_read_memory (mem_addr, mem_buf, len);
4138 if (res < 0)
bd99dc85 4139 write_enn (own_buf);
764880b7 4140 else
e9371aff 4141 bin2hex (mem_buf, own_buf, res);
bd99dc85
PA
4142 break;
4143 case 'M':
4144 require_running (own_buf);
fa593d66 4145 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
90d74c30 4146 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
bd99dc85
PA
4147 write_ok (own_buf);
4148 else
4149 write_enn (own_buf);
4150 break;
4151 case 'X':
4152 require_running (own_buf);
4153 if (decode_X_packet (&own_buf[1], packet_len - 1,
fa593d66 4154 &mem_addr, &len, &mem_buf) < 0
90d74c30 4155 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
bd99dc85
PA
4156 write_enn (own_buf);
4157 else
4158 write_ok (own_buf);
4159 break;
4160 case 'C':
4161 require_running (own_buf);
a7191e8b 4162 hex2bin (own_buf + 1, &sig, 1);
e053fbc4
PA
4163 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4164 signal = gdb_signal_to_host ((enum gdb_signal) sig);
bd99dc85
PA
4165 else
4166 signal = 0;
4167 myresume (own_buf, 0, signal);
4168 break;
4169 case 'S':
4170 require_running (own_buf);
a7191e8b 4171 hex2bin (own_buf + 1, &sig, 1);
e053fbc4
PA
4172 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4173 signal = gdb_signal_to_host ((enum gdb_signal) sig);
bd99dc85
PA
4174 else
4175 signal = 0;
4176 myresume (own_buf, 1, signal);
4177 break;
4178 case 'c':
4179 require_running (own_buf);
4180 signal = 0;
4181 myresume (own_buf, 0, signal);
4182 break;
4183 case 's':
4184 require_running (own_buf);
4185 signal = 0;
4186 myresume (own_buf, 1, signal);
4187 break;
c6314022
AR
4188 case 'Z': /* insert_ ... */
4189 /* Fallthrough. */
4190 case 'z': /* remove_ ... */
bd99dc85 4191 {
bd99dc85 4192 char *dataptr;
aca22551 4193 ULONGEST addr;
27165294 4194 int kind;
bd99dc85 4195 char type = own_buf[1];
c6314022 4196 int res;
d993e290 4197 const int insert = ch == 'Z';
aca22551
PA
4198 char *p = &own_buf[3];
4199
4200 p = unpack_varlen_hex (p, &addr);
27165294 4201 kind = strtol (p + 1, &dataptr, 16);
c6314022 4202
802e8e6d 4203 if (insert)
d993e290 4204 {
9aa76cd0 4205 struct gdb_breakpoint *bp;
802e8e6d 4206
27165294 4207 bp = set_gdb_breakpoint (type, addr, kind, &res);
802e8e6d 4208 if (bp != NULL)
9f3a5c85 4209 {
802e8e6d
PA
4210 res = 0;
4211
4212 /* GDB may have sent us a list of *point parameters to
4213 be evaluated on the target's side. Read such list
4214 here. If we already have a list of parameters, GDB
4215 is telling us to drop that list and use this one
4216 instead. */
0a261ed8 4217 clear_breakpoint_conditions_and_commands (bp);
802e8e6d 4218 process_point_options (bp, &dataptr);
9f3a5c85 4219 }
d993e290 4220 }
802e8e6d 4221 else
27165294 4222 res = delete_gdb_breakpoint (type, addr, kind);
bd99dc85 4223
c6314022
AR
4224 if (res == 0)
4225 write_ok (own_buf);
4226 else if (res == 1)
4227 /* Unsupported. */
4228 own_buf[0] = '\0';
bd99dc85 4229 else
c6314022 4230 write_enn (own_buf);
bd99dc85
PA
4231 break;
4232 }
4233 case 'k':
4234 response_needed = 0;
4235 if (!target_running ())
95954743
PA
4236 /* The packet we received doesn't make sense - but we can't
4237 reply to it, either. */
8336d594 4238 return 0;
c906108c 4239
95954743
PA
4240 fprintf (stderr, "Killing all inferiors\n");
4241 for_each_inferior (&all_processes, kill_inferior_callback);
c906108c 4242
bd99dc85
PA
4243 /* When using the extended protocol, we wait with no program
4244 running. The traditional protocol will exit instead. */
4245 if (extended_protocol)
4246 {
4247 last_status.kind = TARGET_WAITKIND_EXITED;
a493e3e2 4248 last_status.value.sig = GDB_SIGNAL_KILL;
8336d594 4249 return 0;
bd99dc85
PA
4250 }
4251 else
8336d594
PA
4252 exit (0);
4253
bd99dc85
PA
4254 case 'T':
4255 {
95954743 4256 ptid_t gdb_id, thread_id;
bd99dc85
PA
4257
4258 require_running (own_buf);
95954743
PA
4259
4260 gdb_id = read_ptid (&own_buf[1], NULL);
bd99dc85 4261 thread_id = gdb_id_to_thread_id (gdb_id);
95954743 4262 if (ptid_equal (thread_id, null_ptid))
bd99dc85
PA
4263 {
4264 write_enn (own_buf);
4265 break;
4266 }
4267
4268 if (mythread_alive (thread_id))
4269 write_ok (own_buf);
4270 else
4271 write_enn (own_buf);
4272 }
4273 break;
4274 case 'R':
4275 response_needed = 0;
4276
4277 /* Restarting the inferior is only supported in the extended
4278 protocol. */
4279 if (extended_protocol)
4280 {
4281 if (target_running ())
95954743
PA
4282 for_each_inferior (&all_processes,
4283 kill_inferior_callback);
bd99dc85
PA
4284 fprintf (stderr, "GDBserver restarting\n");
4285
4286 /* Wait till we are at 1st instruction in prog. */
4287 if (program_argv != NULL)
51aee833
YQ
4288 {
4289 start_inferior (program_argv);
4290 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4291 {
4292 /* Stopped at the first instruction of the target
4293 process. */
4294 general_thread = last_ptid;
4295 }
4296 else
4297 {
4298 /* Something went wrong. */
4299 general_thread = null_ptid;
4300 }
4301 }
bd99dc85
PA
4302 else
4303 {
4304 last_status.kind = TARGET_WAITKIND_EXITED;
a493e3e2 4305 last_status.value.sig = GDB_SIGNAL_KILL;
bd99dc85 4306 }
8336d594 4307 return 0;
c906108c
SS
4308 }
4309 else
4310 {
bd99dc85
PA
4311 /* It is a request we don't understand. Respond with an
4312 empty packet so that gdb knows that we don't support this
4313 request. */
4314 own_buf[0] = '\0';
4315 break;
4316 }
4317 case 'v':
4318 /* Extended (long) request. */
4319 handle_v_requests (own_buf, packet_len, &new_packet_len);
4320 break;
4321
4322 default:
4323 /* It is a request we don't understand. Respond with an empty
4324 packet so that gdb knows that we don't support this
4325 request. */
4326 own_buf[0] = '\0';
4327 break;
4328 }
4329
4330 if (new_packet_len != -1)
4331 putpkt_binary (own_buf, new_packet_len);
4332 else
4333 putpkt (own_buf);
4334
4335 response_needed = 0;
4336
8336d594
PA
4337 if (exit_requested)
4338 return -1;
4339
4340 return 0;
c906108c 4341}
bd99dc85
PA
4342
4343/* Event-loop callback for serial events. */
4344
8336d594 4345int
bd99dc85
PA
4346handle_serial_event (int err, gdb_client_data client_data)
4347{
4348 if (debug_threads)
87ce2a04 4349 debug_printf ("handling possible serial event\n");
bd99dc85
PA
4350
4351 /* Really handle it. */
8336d594
PA
4352 if (process_serial_event () < 0)
4353 return -1;
bd99dc85 4354
0bfdf32f 4355 /* Be sure to not change the selected thread behind GDB's back.
bd99dc85 4356 Important in the non-stop mode asynchronous protocol. */
0bfdf32f 4357 set_desired_thread (1);
8336d594
PA
4358
4359 return 0;
bd99dc85
PA
4360}
4361
f2faf941
PA
4362/* Push a stop notification on the notification queue. */
4363
4364static void
4365push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
4366{
4367 struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
4368
4369 vstop_notif->status = *status;
4370 vstop_notif->ptid = ptid;
4371 /* Push Stop notification. */
4372 notif_push (&notif_stop, (struct notif_event *) vstop_notif);
4373}
4374
bd99dc85
PA
4375/* Event-loop callback for target events. */
4376
8336d594 4377int
bd99dc85
PA
4378handle_target_event (int err, gdb_client_data client_data)
4379{
4380 if (debug_threads)
87ce2a04 4381 debug_printf ("handling possible target event\n");
bd99dc85 4382
95954743
PA
4383 last_ptid = mywait (minus_one_ptid, &last_status,
4384 TARGET_WNOHANG, 1);
bd99dc85 4385
fa96cb38
PA
4386 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
4387 {
f2faf941
PA
4388 if (gdb_connected () && report_no_resumed)
4389 push_stop_notification (null_ptid, &last_status);
fa96cb38
PA
4390 }
4391 else if (last_status.kind != TARGET_WAITKIND_IGNORE)
bd99dc85 4392 {
8336d594
PA
4393 int pid = ptid_get_pid (last_ptid);
4394 struct process_info *process = find_process_pid (pid);
4395 int forward_event = !gdb_connected () || process->gdb_detached;
4396
4397 if (last_status.kind == TARGET_WAITKIND_EXITED
4398 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
f9e39928
PA
4399 {
4400 mark_breakpoints_out (process);
4401 mourn_inferior (process);
4402 }
65706a29
PA
4403 else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4404 ;
ce1a5b52 4405 else
d20a8ad9
PA
4406 {
4407 /* We're reporting this thread as stopped. Update its
4408 "want-stopped" state to what the client wants, until it
4409 gets a new resume action. */
0bfdf32f
GB
4410 current_thread->last_resume_kind = resume_stop;
4411 current_thread->last_status = last_status;
d20a8ad9 4412 }
8336d594
PA
4413
4414 if (forward_event)
4415 {
4416 if (!target_running ())
4417 {
4418 /* The last process exited. We're done. */
4419 exit (0);
4420 }
4421
65706a29
PA
4422 if (last_status.kind == TARGET_WAITKIND_EXITED
4423 || last_status.kind == TARGET_WAITKIND_SIGNALLED
4424 || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4425 ;
4426 else
8336d594
PA
4427 {
4428 /* A thread stopped with a signal, but gdb isn't
4429 connected to handle it. Pass it down to the
4430 inferior, as if it wasn't being traced. */
4431 struct thread_resume resume_info;
4432
4433 if (debug_threads)
87ce2a04
DE
4434 debug_printf ("GDB not connected; forwarding event %d for"
4435 " [%s]\n",
4436 (int) last_status.kind,
4437 target_pid_to_str (last_ptid));
8336d594
PA
4438
4439 resume_info.thread = last_ptid;
4440 resume_info.kind = resume_continue;
65706a29
PA
4441 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4442 resume_info.sig = gdb_signal_to_host (last_status.value.sig);
4443 else
4444 resume_info.sig = 0;
8336d594
PA
4445 (*the_target->resume) (&resume_info, 1);
4446 }
8336d594
PA
4447 }
4448 else
f2faf941 4449 push_stop_notification (last_ptid, &last_status);
bd99dc85
PA
4450 }
4451
0bfdf32f 4452 /* Be sure to not change the selected thread behind GDB's back.
bd99dc85 4453 Important in the non-stop mode asynchronous protocol. */
0bfdf32f 4454 set_desired_thread (1);
8336d594
PA
4455
4456 return 0;
bd99dc85 4457}
This page took 1.845379 seconds and 4 git commands to generate.