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