Make xml_escape_text return an std::string
[deliverable/binutils-gdb.git] / gdb / gdbserver / server.c
1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
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.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19 #include "server.h"
20 #include "gdbthread.h"
21 #include "agent.h"
22 #include "notif.h"
23 #include "tdesc.h"
24 #include "rsp-low.h"
25 #include "signals-state-save-restore.h"
26 #include <ctype.h>
27 #include <unistd.h>
28 #if HAVE_SIGNAL_H
29 #include <signal.h>
30 #endif
31 #include "gdb_vecs.h"
32 #include "gdb_wait.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
36 #include "dll.h"
37 #include "hostio.h"
38 #include <vector>
39 #include "common-inferior.h"
40 #include "job-control.h"
41 #include "environ.h"
42
43 #include "common/selftest.h"
44
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
59 /* The environment to pass to the inferior when creating it. */
60
61 static gdb_environ our_environ;
62
63 /* Start the inferior using a shell. */
64
65 /* We always try to start the inferior using a shell. */
66
67 int startup_with_shell = 1;
68
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
74 multi-process), or a specific thread ptid_t. */
75 ptid_t cont_thread;
76
77 /* The thread set with an `Hg' packet. */
78 ptid_t general_thread;
79
80 int server_waiting;
81
82 static int extended_protocol;
83 static int response_needed;
84 static int exit_requested;
85
86 /* --once: Exit after the first connection has closed. */
87 int run_once;
88
89 int multi_process;
90 int report_fork_events;
91 int report_vfork_events;
92 int report_exec_events;
93 int report_thread_events;
94
95 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
96 static int report_no_resumed;
97
98 int non_stop;
99 int swbreak_feature;
100 int hwbreak_feature;
101
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. */
105 static int vCont_supported;
106
107 /* Whether we should attempt to disable the operating system's address
108 space randomization feature before starting an inferior. */
109 int disable_randomization = 1;
110
111 static char *program_name = NULL;
112 static std::vector<char *> program_args;
113 static std::string wrapper_argv;
114
115 int pass_signals[GDB_SIGNAL_LAST];
116 int program_signals[GDB_SIGNAL_LAST];
117 int program_signals_p;
118
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
124 unsigned long signal_pid;
125
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. */
129 int disable_packet_vCont;
130 int disable_packet_Tthread;
131 int disable_packet_qC;
132 int disable_packet_qfThreadInfo;
133
134 /* Last status reported to GDB. */
135 struct target_waitstatus last_status;
136 ptid_t last_ptid;
137
138 char *own_buf;
139 static unsigned char *mem_buf;
140
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
145 struct vstop_notif
146 {
147 struct notif_event base;
148
149 /* Thread or process that got the event. */
150 ptid_t ptid;
151
152 /* Event info. */
153 struct target_waitstatus status;
154 };
155
156 /* The current btrace configuration. This is gdbserver's mirror of GDB's
157 btrace configuration. */
158 static struct btrace_config current_btrace_conf;
159
160 DEFINE_QUEUE_P (notif_event_p);
161
162 /* Put a stop reply to the stop reply queue. */
163
164 static void
165 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
166 {
167 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
168
169 new_notif->ptid = ptid;
170 new_notif->status = *status;
171
172 notif_event_enque (&notif_stop, (struct notif_event *) new_notif);
173 }
174
175 static int
176 remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
177 QUEUE_ITER (notif_event_p) *iter,
178 struct notif_event *event,
179 void *data)
180 {
181 ptid_t filter_ptid = *(ptid_t *) data;
182 struct vstop_notif *vstop_event = (struct vstop_notif *) event;
183
184 if (ptid_match (vstop_event->ptid, filter_ptid))
185 {
186 if (q->free_func != NULL)
187 q->free_func (event);
188
189 QUEUE_remove_elem (notif_event_p, q, iter);
190 }
191
192 return 1;
193 }
194
195 /* See server.h. */
196
197 void
198 discard_queued_stop_replies (ptid_t ptid)
199 {
200 QUEUE_iterate (notif_event_p, notif_stop.queue,
201 remove_all_on_match_ptid, &ptid);
202 }
203
204 static void
205 vstop_notif_reply (struct notif_event *event, char *own_buf)
206 {
207 struct vstop_notif *vstop = (struct vstop_notif *) event;
208
209 prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
210 }
211
212 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
213
214 static int
215 in_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
237 int
238 in_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
244 struct notif_server notif_stop =
245 {
246 "vStopped", "Stop", NULL, vstop_notif_reply,
247 };
248
249 static int
250 target_running (void)
251 {
252 return get_first_thread () != NULL;
253 }
254
255 /* See common/common-inferior.h. */
256
257 const char *
258 get_exec_wrapper ()
259 {
260 return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL;
261 }
262
263 /* See common/common-inferior.h. */
264
265 char *
266 get_exec_file (int err)
267 {
268 if (err && program_name == NULL)
269 error (_("No executable file specified."));
270
271 return program_name;
272 }
273
274 /* See server.h. */
275
276 gdb_environ *
277 get_environ ()
278 {
279 return &our_environ;
280 }
281
282 static int
283 attach_inferior (int pid)
284 {
285 /* myattach should return -1 if attaching is unsupported,
286 0 if it succeeded, and call error() otherwise. */
287
288 if (myattach (pid) != 0)
289 return -1;
290
291 fprintf (stderr, "Attached; pid = %d\n", pid);
292 fflush (stderr);
293
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
299 if (!non_stop)
300 {
301 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
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
307 && last_status.value.sig == GDB_SIGNAL_STOP)
308 last_status.value.sig = GDB_SIGNAL_TRAP;
309
310 current_thread->last_resume_kind = resume_stop;
311 current_thread->last_status = last_status;
312 }
313
314 return 0;
315 }
316
317 extern int remote_debug;
318
319 /* Decode a qXfer read request. Return 0 if everything looks OK,
320 or -1 otherwise. */
321
322 static int
323 decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
324 {
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
332 static int
333 decode_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
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
359 *offset = buf;
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. */
367 static int
368 write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more)
369 {
370 int out_len;
371
372 if (is_more)
373 buf[0] = 'm';
374 else
375 buf[0] = 'l';
376
377 return remote_escape_output (data, len, 1, (unsigned char *) buf + 1,
378 &out_len, PBUFSIZ - 2) + 1;
379 }
380
381 /* Handle btrace enabling in BTS format. */
382
383 static const char *
384 handle_btrace_enable_bts (struct thread_info *thread)
385 {
386 if (thread->btrace != NULL)
387 return "E.Btrace already enabled.";
388
389 current_btrace_conf.format = BTRACE_FORMAT_BTS;
390 thread->btrace = target_enable_btrace (thread->entry.id,
391 &current_btrace_conf);
392 if (thread->btrace == NULL)
393 return "E.Could not enable btrace.";
394
395 return NULL;
396 }
397
398 /* Handle btrace enabling in Intel Processor Trace format. */
399
400 static const char *
401 handle_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
415 /* Handle btrace disabling. */
416
417 static const char *
418 handle_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
433 static int
434 handle_btrace_general_set (char *own_buf)
435 {
436 struct thread_info *thread;
437 const char *err;
438 char *op;
439
440 if (!startswith (own_buf, "Qbtrace:"))
441 return 0;
442
443 op = own_buf + strlen ("Qbtrace:");
444
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)
462 err = handle_btrace_enable_bts (thread);
463 else if (strcmp (op, "pt") == 0)
464 err = handle_btrace_enable_pt (thread);
465 else if (strcmp (op, "off") == 0)
466 err = handle_btrace_disable (thread);
467 else
468 err = "E.Bad Qbtrace operation. Use bts, pt, or off.";
469
470 if (err != 0)
471 strcpy (own_buf, err);
472 else
473 write_ok (own_buf);
474
475 return 1;
476 }
477
478 /* Handle the "Qbtrace-conf" packet. */
479
480 static int
481 handle_btrace_conf_general_set (char *own_buf)
482 {
483 struct thread_info *thread;
484 char *op;
485
486 if (!startswith (own_buf, "Qbtrace-conf:"))
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
505 if (startswith (op, "bts:size="))
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 }
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 }
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
545 /* Handle all of the extended 'Q' packets. */
546
547 static void
548 handle_general_set (char *own_buf)
549 {
550 if (startswith (own_buf, "QPassSignals:"))
551 {
552 int numsigs = (int) GDB_SIGNAL_LAST, i;
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
575 if (startswith (own_buf, "QProgramSignals:"))
576 {
577 int numsigs = (int) GDB_SIGNAL_LAST, i;
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
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
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
711 if (strcmp (own_buf, "QStartNoAckMode") == 0)
712 {
713 if (remote_debug)
714 {
715 debug_printf ("[noack mode enabled]\n");
716 debug_flush ();
717 }
718
719 noack_mode = 1;
720 write_ok (own_buf);
721 return;
722 }
723
724 if (startswith (own_buf, "QNonStop:"))
725 {
726 char *mode = own_buf + 9;
727 int req = -1;
728 const char *req_str;
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)
755 debug_printf ("[%s mode enabled]\n", req_str);
756
757 write_ok (own_buf);
758 return;
759 }
760
761 if (startswith (own_buf, "QDisableRandomization:"))
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 {
771 debug_printf (disable_randomization
772 ? "[address space randomization disabled]\n"
773 : "[address space randomization enabled]\n");
774 }
775
776 write_ok (own_buf);
777 return;
778 }
779
780 if (target_supports_tracepoints ()
781 && handle_tracepoint_general_set (own_buf))
782 return;
783
784 if (startswith (own_buf, "QAgent:"))
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)
803 debug_printf ("[%s agent]\n", req ? "Enable" : "Disable");
804 write_ok (own_buf);
805 return;
806 }
807
808 if (handle_btrace_general_set (own_buf))
809 return;
810
811 if (handle_btrace_conf_general_set (own_buf))
812 return;
813
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
840 debug_printf ("[thread events are now %s]\n", req_str);
841 }
842
843 write_ok (own_buf);
844 return;
845 }
846
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
872 /* Otherwise we didn't know what packet it was. Say we didn't
873 understand it. */
874 own_buf[0] = 0;
875 }
876
877 static const char *
878 get_features_xml (const char *annex)
879 {
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".
886
887 This variable is set up from the auto-generated
888 init_registers_... routine for the current target. */
889
890 if (strcmp (annex, "target.xml") == 0)
891 {
892 const char *ret = tdesc_get_features_xml ((target_desc*) desc);
893
894 if (*ret == '@')
895 return ret + 1;
896 else
897 annex = ret;
898 }
899
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;
916 }
917
918 static void
919 monitor_show_help (void)
920 {
921 monitor_output ("The following monitor commands are supported:\n");
922 monitor_output (" set debug <0|1>\n");
923 monitor_output (" Enable general debugging messages\n");
924 monitor_output (" set debug-hw-points <0|1>\n");
925 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
926 monitor_output (" set remote-debug <0|1>\n");
927 monitor_output (" Enable remote protocol debugging messages\n");
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");
931 monitor_output (", timestamp");
932 monitor_output ("\n");
933 monitor_output (" exit\n");
934 monitor_output (" Quit GDBserver\n");
935 }
936
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. */
946
947 static int
948 gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
949 {
950 int res;
951
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))
959 return -1;
960 /* Data read from trace buffer, we're done. */
961 if (nbytes > 0)
962 return nbytes;
963 if (!in_readonly_region (memaddr, length))
964 return -1;
965 /* Otherwise we have a valid readonly case, fall through. */
966 /* (assume no half-trace half-real blocks for now) */
967 }
968
969 res = prepare_to_access_memory ();
970 if (res == 0)
971 {
972 if (set_desired_thread (1))
973 res = read_inferior_memory (memaddr, myaddr, len);
974 else
975 res = 1;
976 done_accessing_memory ();
977
978 return res == 0 ? len : -1;
979 }
980 else
981 return -1;
982 }
983
984 /* Write trace frame or inferior memory. Actually, writing to trace
985 frames is forbidden. */
986
987 static int
988 gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
989 {
990 if (current_traceframe >= 0)
991 return EIO;
992 else
993 {
994 int ret;
995
996 ret = prepare_to_access_memory ();
997 if (ret == 0)
998 {
999 if (set_desired_thread (1))
1000 ret = write_inferior_memory (memaddr, myaddr, len);
1001 else
1002 ret = EIO;
1003 done_accessing_memory ();
1004 }
1005 return ret;
1006 }
1007 }
1008
1009 /* Subroutine of handle_search_memory to simplify it. */
1010
1011 static int
1012 handle_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
1020 if (gdb_read_memory (start_addr, search_buf, search_buf_size)
1021 != search_buf_size)
1022 {
1023 warning ("Unable to access %ld bytes of target "
1024 "memory at 0x%lx, halting search.",
1025 (long) search_buf_size, (long) start_addr);
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
1042 found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes, pattern,
1043 pattern_len);
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;
1063 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
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
1074 if (gdb_read_memory (read_addr, search_buf + keep_len,
1075 nr_to_read) != search_buf_size)
1076 {
1077 warning ("Unable to access %ld bytes of target memory "
1078 "at 0x%lx, halting search.",
1079 (long) nr_to_read, (long) read_addr);
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
1094 static void
1095 handle_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
1111 pattern = (gdb_byte *) malloc (packet_len);
1112 if (pattern == NULL)
1113 {
1114 error ("Unable to allocate memory to perform the search");
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);
1124 error ("Error in parsing qSearch:memory packet");
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
1135 search_buf = (gdb_byte *) malloc (search_buf_size);
1136 if (search_buf == NULL)
1137 {
1138 free (pattern);
1139 error ("Unable to allocate memory to perform the search");
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
1160 /* Handle the "D" packet. */
1161
1162 static void
1163 handle_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
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
1271 static char *
1272 parse_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 }
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 }
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
1326 /* Handle monitor commands not handled by target-specific handlers. */
1327
1328 static void
1329 handle_monitor_command (char *mon, char *own_buf)
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 {
1343 show_debug_regs = 1;
1344 monitor_output ("H/W point debugging output enabled.\n");
1345 }
1346 else if (strcmp (mon, "set debug-hw-points 0") == 0)
1347 {
1348 show_debug_regs = 0;
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 }
1361 else if (startswith (mon, "set debug-format "))
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 }
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
1387 /* Associates a callback with each supported qXfer'able object. */
1388
1389 struct 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
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.
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
1413 static int
1414 handle_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
1421 if (annex[0] != '\0' || current_thread == NULL)
1422 return -1;
1423
1424 return (*the_target->read_auxv) (offset, readbuf, len);
1425 }
1426
1427 /* Handle qXfer:exec-file:read. */
1428
1429 static int
1430 handle_qxfer_exec_file (const char *const_annex,
1431 gdb_byte *readbuf, const gdb_byte *writebuf,
1432 ULONGEST offset, LONGEST len)
1433 {
1434 char *file;
1435 ULONGEST pid;
1436 int total_len;
1437
1438 if (the_target->pid_to_exec_file == NULL || writebuf != NULL)
1439 return -2;
1440
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 {
1450 char *annex = (char *) alloca (strlen (const_annex) + 1);
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)
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
1478 /* Handle qXfer:features:read. */
1479
1480 static int
1481 handle_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
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
1515 static void
1516 accumulate_file_name_length (struct inferior_list_entry *inf, void *arg)
1517 {
1518 struct dll_info *dll = (struct dll_info *) inf;
1519 unsigned int *total_len = (unsigned int *) arg;
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
1529 static void
1530 emit_dll_description (struct inferior_list_entry *inf, void *arg)
1531 {
1532 struct dll_info *dll = (struct dll_info *) inf;
1533 char **p_ptr = (char **) arg;
1534 char *p = *p_ptr;
1535
1536 strcpy (p, " <library name=\"");
1537 p = p + strlen (p);
1538 std::string name = xml_escape_text (dll->name);
1539 strcpy (p, name.c_str ());
1540 p = p + strlen (p);
1541 strcpy (p, "\"><segment address=\"");
1542 p = p + strlen (p);
1543 sprintf (p, "0x%lx", (long) dll->base_addr);
1544 p = p + strlen (p);
1545 strcpy (p, "\"/></library>\n");
1546 p = p + strlen (p);
1547
1548 *p_ptr = p;
1549 }
1550
1551 /* Handle qXfer:libraries:read. */
1552
1553 static int
1554 handle_qxfer_libraries (const char *annex,
1555 gdb_byte *readbuf, const gdb_byte *writebuf,
1556 ULONGEST offset, LONGEST len)
1557 {
1558 unsigned int total_len;
1559 char *document, *p;
1560
1561 if (writebuf != NULL)
1562 return -2;
1563
1564 if (annex[0] != '\0' || current_thread == NULL)
1565 return -1;
1566
1567 total_len = 64;
1568 for_each_inferior_with_data (&all_dlls, accumulate_file_name_length,
1569 &total_len);
1570
1571 document = (char *) malloc (total_len);
1572 if (document == NULL)
1573 return -1;
1574
1575 strcpy (document, "<library-list version=\"1.0\">\n");
1576 p = document + strlen (document);
1577
1578 for_each_inferior_with_data (&all_dlls, emit_dll_description, &p);
1579
1580 strcpy (p, "</library-list>\n");
1581
1582 total_len = strlen (document);
1583
1584 if (offset > total_len)
1585 {
1586 free (document);
1587 return -1;
1588 }
1589
1590 if (offset + len > total_len)
1591 len = total_len - offset;
1592
1593 memcpy (readbuf, document + offset, len);
1594 free (document);
1595 return len;
1596 }
1597
1598 /* Handle qXfer:libraries-svr4:read. */
1599
1600 static int
1601 handle_qxfer_libraries_svr4 (const char *annex,
1602 gdb_byte *readbuf, const gdb_byte *writebuf,
1603 ULONGEST offset, LONGEST len)
1604 {
1605 if (writebuf != NULL)
1606 return -2;
1607
1608 if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
1609 return -1;
1610
1611 return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len);
1612 }
1613
1614 /* Handle qXfer:osadata:read. */
1615
1616 static int
1617 handle_qxfer_osdata (const char *annex,
1618 gdb_byte *readbuf, const gdb_byte *writebuf,
1619 ULONGEST offset, LONGEST len)
1620 {
1621 if (the_target->qxfer_osdata == NULL || writebuf != NULL)
1622 return -2;
1623
1624 return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
1625 }
1626
1627 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1628
1629 static int
1630 handle_qxfer_siginfo (const char *annex,
1631 gdb_byte *readbuf, const gdb_byte *writebuf,
1632 ULONGEST offset, LONGEST len)
1633 {
1634 if (the_target->qxfer_siginfo == NULL)
1635 return -2;
1636
1637 if (annex[0] != '\0' || current_thread == NULL)
1638 return -1;
1639
1640 return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
1641 }
1642
1643 /* Handle qXfer:spu:read and qXfer:spu:write. */
1644
1645 static int
1646 handle_qxfer_spu (const char *annex,
1647 gdb_byte *readbuf, const gdb_byte *writebuf,
1648 ULONGEST offset, LONGEST len)
1649 {
1650 if (the_target->qxfer_spu == NULL)
1651 return -2;
1652
1653 if (current_thread == NULL)
1654 return -1;
1655
1656 return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1657 }
1658
1659 /* Handle qXfer:statictrace:read. */
1660
1661 static int
1662 handle_qxfer_statictrace (const char *annex,
1663 gdb_byte *readbuf, const gdb_byte *writebuf,
1664 ULONGEST offset, LONGEST len)
1665 {
1666 ULONGEST nbytes;
1667
1668 if (writebuf != NULL)
1669 return -2;
1670
1671 if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1)
1672 return -1;
1673
1674 if (traceframe_read_sdata (current_traceframe, offset,
1675 readbuf, len, &nbytes))
1676 return -1;
1677 return nbytes;
1678 }
1679
1680 /* Helper for handle_qxfer_threads_proper.
1681 Emit the XML to describe the thread of INF. */
1682
1683 static void
1684 handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
1685 {
1686 struct thread_info *thread = (struct thread_info *) inf;
1687 struct buffer *buffer = (struct buffer *) arg;
1688 ptid_t ptid = ptid_of (thread);
1689 char ptid_s[100];
1690 int core = target_core_of_thread (ptid);
1691 char core_s[21];
1692 const char *name = target_thread_name (ptid);
1693
1694 write_ptid (ptid_s, ptid);
1695
1696 buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s);
1697
1698 if (core != -1)
1699 {
1700 sprintf (core_s, "%d", core);
1701 buffer_xml_printf (buffer, " core=\"%s\"", core_s);
1702 }
1703
1704 if (name != NULL)
1705 buffer_xml_printf (buffer, " name=\"%s\"", name);
1706
1707 buffer_xml_printf (buffer, "/>\n");
1708 }
1709
1710 /* Helper for handle_qxfer_threads. */
1711
1712 static void
1713 handle_qxfer_threads_proper (struct buffer *buffer)
1714 {
1715 buffer_grow_str (buffer, "<threads>\n");
1716
1717 for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker,
1718 buffer);
1719
1720 buffer_grow_str0 (buffer, "</threads>\n");
1721 }
1722
1723 /* Handle qXfer:threads:read. */
1724
1725 static int
1726 handle_qxfer_threads (const char *annex,
1727 gdb_byte *readbuf, const gdb_byte *writebuf,
1728 ULONGEST offset, LONGEST len)
1729 {
1730 static char *result = 0;
1731 static unsigned int result_length = 0;
1732
1733 if (writebuf != NULL)
1734 return -2;
1735
1736 if (annex[0] != '\0')
1737 return -1;
1738
1739 if (offset == 0)
1740 {
1741 struct buffer buffer;
1742 /* When asked for data at offset 0, generate everything and store into
1743 'result'. Successive reads will be served off 'result'. */
1744 if (result)
1745 free (result);
1746
1747 buffer_init (&buffer);
1748
1749 handle_qxfer_threads_proper (&buffer);
1750
1751 result = buffer_finish (&buffer);
1752 result_length = strlen (result);
1753 buffer_free (&buffer);
1754 }
1755
1756 if (offset >= result_length)
1757 {
1758 /* We're out of data. */
1759 free (result);
1760 result = NULL;
1761 result_length = 0;
1762 return 0;
1763 }
1764
1765 if (len > result_length - offset)
1766 len = result_length - offset;
1767
1768 memcpy (readbuf, result + offset, len);
1769
1770 return len;
1771 }
1772
1773 /* Handle qXfer:traceframe-info:read. */
1774
1775 static int
1776 handle_qxfer_traceframe_info (const char *annex,
1777 gdb_byte *readbuf, const gdb_byte *writebuf,
1778 ULONGEST offset, LONGEST len)
1779 {
1780 static char *result = 0;
1781 static unsigned int result_length = 0;
1782
1783 if (writebuf != NULL)
1784 return -2;
1785
1786 if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1787 return -1;
1788
1789 if (offset == 0)
1790 {
1791 struct buffer buffer;
1792
1793 /* When asked for data at offset 0, generate everything and
1794 store into 'result'. Successive reads will be served off
1795 'result'. */
1796 free (result);
1797
1798 buffer_init (&buffer);
1799
1800 traceframe_read_info (current_traceframe, &buffer);
1801
1802 result = buffer_finish (&buffer);
1803 result_length = strlen (result);
1804 buffer_free (&buffer);
1805 }
1806
1807 if (offset >= result_length)
1808 {
1809 /* We're out of data. */
1810 free (result);
1811 result = NULL;
1812 result_length = 0;
1813 return 0;
1814 }
1815
1816 if (len > result_length - offset)
1817 len = result_length - offset;
1818
1819 memcpy (readbuf, result + offset, len);
1820 return len;
1821 }
1822
1823 /* Handle qXfer:fdpic:read. */
1824
1825 static int
1826 handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
1827 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1828 {
1829 if (the_target->read_loadmap == NULL)
1830 return -2;
1831
1832 if (current_thread == NULL)
1833 return -1;
1834
1835 return (*the_target->read_loadmap) (annex, offset, readbuf, len);
1836 }
1837
1838 /* Handle qXfer:btrace:read. */
1839
1840 static int
1841 handle_qxfer_btrace (const char *annex,
1842 gdb_byte *readbuf, const gdb_byte *writebuf,
1843 ULONGEST offset, LONGEST len)
1844 {
1845 static struct buffer cache;
1846 struct thread_info *thread;
1847 enum btrace_read_type type;
1848 int result;
1849
1850 if (the_target->read_btrace == NULL || writebuf != NULL)
1851 return -2;
1852
1853 if (ptid_equal (general_thread, null_ptid)
1854 || ptid_equal (general_thread, minus_one_ptid))
1855 {
1856 strcpy (own_buf, "E.Must select a single thread.");
1857 return -3;
1858 }
1859
1860 thread = find_thread_ptid (general_thread);
1861 if (thread == NULL)
1862 {
1863 strcpy (own_buf, "E.No such thread.");
1864 return -3;
1865 }
1866
1867 if (thread->btrace == NULL)
1868 {
1869 strcpy (own_buf, "E.Btrace not enabled.");
1870 return -3;
1871 }
1872
1873 if (strcmp (annex, "all") == 0)
1874 type = BTRACE_READ_ALL;
1875 else if (strcmp (annex, "new") == 0)
1876 type = BTRACE_READ_NEW;
1877 else if (strcmp (annex, "delta") == 0)
1878 type = BTRACE_READ_DELTA;
1879 else
1880 {
1881 strcpy (own_buf, "E.Bad annex.");
1882 return -3;
1883 }
1884
1885 if (offset == 0)
1886 {
1887 buffer_free (&cache);
1888
1889 result = target_read_btrace (thread->btrace, &cache, type);
1890 if (result != 0)
1891 {
1892 memcpy (own_buf, cache.buffer, cache.used_size);
1893 return -3;
1894 }
1895 }
1896 else if (offset > cache.used_size)
1897 {
1898 buffer_free (&cache);
1899 return -3;
1900 }
1901
1902 if (len > cache.used_size - offset)
1903 len = cache.used_size - offset;
1904
1905 memcpy (readbuf, cache.buffer + offset, len);
1906
1907 return len;
1908 }
1909
1910 /* Handle qXfer:btrace-conf:read. */
1911
1912 static int
1913 handle_qxfer_btrace_conf (const char *annex,
1914 gdb_byte *readbuf, const gdb_byte *writebuf,
1915 ULONGEST offset, LONGEST len)
1916 {
1917 static struct buffer cache;
1918 struct thread_info *thread;
1919 int result;
1920
1921 if (the_target->read_btrace_conf == NULL || writebuf != NULL)
1922 return -2;
1923
1924 if (annex[0] != '\0')
1925 return -1;
1926
1927 if (ptid_equal (general_thread, null_ptid)
1928 || ptid_equal (general_thread, minus_one_ptid))
1929 {
1930 strcpy (own_buf, "E.Must select a single thread.");
1931 return -3;
1932 }
1933
1934 thread = find_thread_ptid (general_thread);
1935 if (thread == NULL)
1936 {
1937 strcpy (own_buf, "E.No such thread.");
1938 return -3;
1939 }
1940
1941 if (thread->btrace == NULL)
1942 {
1943 strcpy (own_buf, "E.Btrace not enabled.");
1944 return -3;
1945 }
1946
1947 if (offset == 0)
1948 {
1949 buffer_free (&cache);
1950
1951 result = target_read_btrace_conf (thread->btrace, &cache);
1952 if (result != 0)
1953 {
1954 memcpy (own_buf, cache.buffer, cache.used_size);
1955 return -3;
1956 }
1957 }
1958 else if (offset > cache.used_size)
1959 {
1960 buffer_free (&cache);
1961 return -3;
1962 }
1963
1964 if (len > cache.used_size - offset)
1965 len = cache.used_size - offset;
1966
1967 memcpy (readbuf, cache.buffer + offset, len);
1968
1969 return len;
1970 }
1971
1972 static const struct qxfer qxfer_packets[] =
1973 {
1974 { "auxv", handle_qxfer_auxv },
1975 { "btrace", handle_qxfer_btrace },
1976 { "btrace-conf", handle_qxfer_btrace_conf },
1977 { "exec-file", handle_qxfer_exec_file},
1978 { "fdpic", handle_qxfer_fdpic},
1979 { "features", handle_qxfer_features },
1980 { "libraries", handle_qxfer_libraries },
1981 { "libraries-svr4", handle_qxfer_libraries_svr4 },
1982 { "osdata", handle_qxfer_osdata },
1983 { "siginfo", handle_qxfer_siginfo },
1984 { "spu", handle_qxfer_spu },
1985 { "statictrace", handle_qxfer_statictrace },
1986 { "threads", handle_qxfer_threads },
1987 { "traceframe-info", handle_qxfer_traceframe_info },
1988 };
1989
1990 static int
1991 handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1992 {
1993 int i;
1994 char *object;
1995 char *rw;
1996 char *annex;
1997 char *offset;
1998
1999 if (!startswith (own_buf, "qXfer:"))
2000 return 0;
2001
2002 /* Grab the object, r/w and annex. */
2003 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
2004 {
2005 write_enn (own_buf);
2006 return 1;
2007 }
2008
2009 for (i = 0;
2010 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
2011 i++)
2012 {
2013 const struct qxfer *q = &qxfer_packets[i];
2014
2015 if (strcmp (object, q->object) == 0)
2016 {
2017 if (strcmp (rw, "read") == 0)
2018 {
2019 unsigned char *data;
2020 int n;
2021 CORE_ADDR ofs;
2022 unsigned int len;
2023
2024 /* Grab the offset and length. */
2025 if (decode_xfer_read (offset, &ofs, &len) < 0)
2026 {
2027 write_enn (own_buf);
2028 return 1;
2029 }
2030
2031 /* Read one extra byte, as an indicator of whether there is
2032 more. */
2033 if (len > PBUFSIZ - 2)
2034 len = PBUFSIZ - 2;
2035 data = (unsigned char *) malloc (len + 1);
2036 if (data == NULL)
2037 {
2038 write_enn (own_buf);
2039 return 1;
2040 }
2041 n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
2042 if (n == -2)
2043 {
2044 free (data);
2045 return 0;
2046 }
2047 else if (n == -3)
2048 {
2049 /* Preserve error message. */
2050 }
2051 else if (n < 0)
2052 write_enn (own_buf);
2053 else if (n > len)
2054 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
2055 else
2056 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
2057
2058 free (data);
2059 return 1;
2060 }
2061 else if (strcmp (rw, "write") == 0)
2062 {
2063 int n;
2064 unsigned int len;
2065 CORE_ADDR ofs;
2066 unsigned char *data;
2067
2068 strcpy (own_buf, "E00");
2069 data = (unsigned char *) malloc (packet_len - (offset - own_buf));
2070 if (data == NULL)
2071 {
2072 write_enn (own_buf);
2073 return 1;
2074 }
2075 if (decode_xfer_write (offset, packet_len - (offset - own_buf),
2076 &ofs, &len, data) < 0)
2077 {
2078 free (data);
2079 write_enn (own_buf);
2080 return 1;
2081 }
2082
2083 n = (*q->xfer) (annex, NULL, data, ofs, len);
2084 if (n == -2)
2085 {
2086 free (data);
2087 return 0;
2088 }
2089 else if (n == -3)
2090 {
2091 /* Preserve error message. */
2092 }
2093 else if (n < 0)
2094 write_enn (own_buf);
2095 else
2096 sprintf (own_buf, "%x", n);
2097
2098 free (data);
2099 return 1;
2100 }
2101
2102 return 0;
2103 }
2104 }
2105
2106 return 0;
2107 }
2108
2109 /* Compute 32 bit CRC from inferior memory.
2110
2111 On success, return 32 bit CRC.
2112 On failure, return (unsigned long long) -1. */
2113
2114 static unsigned long long
2115 crc32 (CORE_ADDR base, int len, unsigned int crc)
2116 {
2117 while (len--)
2118 {
2119 unsigned char byte = 0;
2120
2121 /* Return failure if memory read fails. */
2122 if (read_inferior_memory (base, &byte, 1) != 0)
2123 return (unsigned long long) -1;
2124
2125 crc = xcrc32 (&byte, 1, crc);
2126 base++;
2127 }
2128 return (unsigned long long) crc;
2129 }
2130
2131 /* Add supported btrace packets to BUF. */
2132
2133 static void
2134 supported_btrace_packets (char *buf)
2135 {
2136 int btrace_supported = 0;
2137
2138 if (target_supports_btrace (BTRACE_FORMAT_BTS))
2139 {
2140 strcat (buf, ";Qbtrace:bts+");
2141 strcat (buf, ";Qbtrace-conf:bts:size+");
2142
2143 btrace_supported = 1;
2144 }
2145
2146 if (target_supports_btrace (BTRACE_FORMAT_PT))
2147 {
2148 strcat (buf, ";Qbtrace:pt+");
2149 strcat (buf, ";Qbtrace-conf:pt:size+");
2150
2151 btrace_supported = 1;
2152 }
2153
2154 if (!btrace_supported)
2155 return;
2156
2157 strcat (buf, ";Qbtrace:off+");
2158 strcat (buf, ";qXfer:btrace:read+");
2159 strcat (buf, ";qXfer:btrace-conf:read+");
2160 }
2161
2162 /* Handle all of the extended 'q' packets. */
2163
2164 static void
2165 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
2166 {
2167 static struct inferior_list_entry *thread_ptr;
2168
2169 /* Reply the current thread id. */
2170 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
2171 {
2172 ptid_t ptid;
2173 require_running_or_return (own_buf);
2174
2175 if (general_thread != null_ptid && general_thread != minus_one_ptid)
2176 ptid = general_thread;
2177 else
2178 {
2179 thread_ptr = get_first_inferior (&all_threads);
2180 ptid = thread_ptr->id;
2181 }
2182
2183 sprintf (own_buf, "QC");
2184 own_buf += 2;
2185 write_ptid (own_buf, ptid);
2186 return;
2187 }
2188
2189 if (strcmp ("qSymbol::", own_buf) == 0)
2190 {
2191 struct thread_info *save_thread = current_thread;
2192
2193 /* For qSymbol, GDB only changes the current thread if the
2194 previous current thread was of a different process. So if
2195 the previous thread is gone, we need to pick another one of
2196 the same process. This can happen e.g., if we followed an
2197 exec in a non-leader thread. */
2198 if (current_thread == NULL)
2199 {
2200 current_thread
2201 = find_any_thread_of_pid (ptid_get_pid (general_thread));
2202
2203 /* Just in case, if we didn't find a thread, then bail out
2204 instead of crashing. */
2205 if (current_thread == NULL)
2206 {
2207 write_enn (own_buf);
2208 current_thread = save_thread;
2209 return;
2210 }
2211 }
2212
2213 /* GDB is suggesting new symbols have been loaded. This may
2214 mean a new shared library has been detected as loaded, so
2215 take the opportunity to check if breakpoints we think are
2216 inserted, still are. Note that it isn't guaranteed that
2217 we'll see this when a shared library is loaded, and nor will
2218 we see this for unloads (although breakpoints in unloaded
2219 libraries shouldn't trigger), as GDB may not find symbols for
2220 the library at all. We also re-validate breakpoints when we
2221 see a second GDB breakpoint for the same address, and or when
2222 we access breakpoint shadows. */
2223 validate_breakpoints ();
2224
2225 if (target_supports_tracepoints ())
2226 tracepoint_look_up_symbols ();
2227
2228 if (current_thread != NULL && the_target->look_up_symbols != NULL)
2229 (*the_target->look_up_symbols) ();
2230
2231 current_thread = save_thread;
2232
2233 strcpy (own_buf, "OK");
2234 return;
2235 }
2236
2237 if (!disable_packet_qfThreadInfo)
2238 {
2239 if (strcmp ("qfThreadInfo", own_buf) == 0)
2240 {
2241 require_running_or_return (own_buf);
2242 thread_ptr = get_first_inferior (&all_threads);
2243
2244 *own_buf++ = 'm';
2245 write_ptid (own_buf, thread_ptr->id);
2246 thread_ptr = thread_ptr->next;
2247 return;
2248 }
2249
2250 if (strcmp ("qsThreadInfo", own_buf) == 0)
2251 {
2252 require_running_or_return (own_buf);
2253 if (thread_ptr != NULL)
2254 {
2255 *own_buf++ = 'm';
2256 write_ptid (own_buf, thread_ptr->id);
2257 thread_ptr = thread_ptr->next;
2258 return;
2259 }
2260 else
2261 {
2262 sprintf (own_buf, "l");
2263 return;
2264 }
2265 }
2266 }
2267
2268 if (the_target->read_offsets != NULL
2269 && strcmp ("qOffsets", own_buf) == 0)
2270 {
2271 CORE_ADDR text, data;
2272
2273 require_running_or_return (own_buf);
2274 if (the_target->read_offsets (&text, &data))
2275 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
2276 (long)text, (long)data, (long)data);
2277 else
2278 write_enn (own_buf);
2279
2280 return;
2281 }
2282
2283 /* Protocol features query. */
2284 if (startswith (own_buf, "qSupported")
2285 && (own_buf[10] == ':' || own_buf[10] == '\0'))
2286 {
2287 char *p = &own_buf[10];
2288 int gdb_supports_qRelocInsn = 0;
2289
2290 /* Process each feature being provided by GDB. The first
2291 feature will follow a ':', and latter features will follow
2292 ';'. */
2293 if (*p == ':')
2294 {
2295 char **qsupported = NULL;
2296 int count = 0;
2297 int unknown = 0;
2298 int i;
2299
2300 /* Two passes, to avoid nested strtok calls in
2301 target_process_qsupported. */
2302 for (p = strtok (p + 1, ";");
2303 p != NULL;
2304 p = strtok (NULL, ";"))
2305 {
2306 count++;
2307 qsupported = XRESIZEVEC (char *, qsupported, count);
2308 qsupported[count - 1] = xstrdup (p);
2309 }
2310
2311 for (i = 0; i < count; i++)
2312 {
2313 p = qsupported[i];
2314 if (strcmp (p, "multiprocess+") == 0)
2315 {
2316 /* GDB supports and wants multi-process support if
2317 possible. */
2318 if (target_supports_multi_process ())
2319 multi_process = 1;
2320 }
2321 else if (strcmp (p, "qRelocInsn+") == 0)
2322 {
2323 /* GDB supports relocate instruction requests. */
2324 gdb_supports_qRelocInsn = 1;
2325 }
2326 else if (strcmp (p, "swbreak+") == 0)
2327 {
2328 /* GDB wants us to report whether a trap is caused
2329 by a software breakpoint and for us to handle PC
2330 adjustment if necessary on this target. */
2331 if (target_supports_stopped_by_sw_breakpoint ())
2332 swbreak_feature = 1;
2333 }
2334 else if (strcmp (p, "hwbreak+") == 0)
2335 {
2336 /* GDB wants us to report whether a trap is caused
2337 by a hardware breakpoint. */
2338 if (target_supports_stopped_by_hw_breakpoint ())
2339 hwbreak_feature = 1;
2340 }
2341 else if (strcmp (p, "fork-events+") == 0)
2342 {
2343 /* GDB supports and wants fork events if possible. */
2344 if (target_supports_fork_events ())
2345 report_fork_events = 1;
2346 }
2347 else if (strcmp (p, "vfork-events+") == 0)
2348 {
2349 /* GDB supports and wants vfork events if possible. */
2350 if (target_supports_vfork_events ())
2351 report_vfork_events = 1;
2352 }
2353 else if (strcmp (p, "exec-events+") == 0)
2354 {
2355 /* GDB supports and wants exec events if possible. */
2356 if (target_supports_exec_events ())
2357 report_exec_events = 1;
2358 }
2359 else if (strcmp (p, "vContSupported+") == 0)
2360 vCont_supported = 1;
2361 else if (strcmp (p, "QThreadEvents+") == 0)
2362 ;
2363 else if (strcmp (p, "no-resumed+") == 0)
2364 {
2365 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2366 events. */
2367 report_no_resumed = 1;
2368 }
2369 else
2370 {
2371 /* Move the unknown features all together. */
2372 qsupported[i] = NULL;
2373 qsupported[unknown] = p;
2374 unknown++;
2375 }
2376 }
2377
2378 /* Give the target backend a chance to process the unknown
2379 features. */
2380 target_process_qsupported (qsupported, unknown);
2381
2382 for (i = 0; i < count; i++)
2383 free (qsupported[i]);
2384 free (qsupported);
2385 }
2386
2387 sprintf (own_buf,
2388 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2389 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2390 "QEnvironmentReset+;QEnvironmentUnset+",
2391 PBUFSIZ - 1);
2392
2393 if (target_supports_catch_syscall ())
2394 strcat (own_buf, ";QCatchSyscalls+");
2395
2396 if (the_target->qxfer_libraries_svr4 != NULL)
2397 strcat (own_buf, ";qXfer:libraries-svr4:read+"
2398 ";augmented-libraries-svr4-read+");
2399 else
2400 {
2401 /* We do not have any hook to indicate whether the non-SVR4 target
2402 backend supports qXfer:libraries:read, so always report it. */
2403 strcat (own_buf, ";qXfer:libraries:read+");
2404 }
2405
2406 if (the_target->read_auxv != NULL)
2407 strcat (own_buf, ";qXfer:auxv:read+");
2408
2409 if (the_target->qxfer_spu != NULL)
2410 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
2411
2412 if (the_target->qxfer_siginfo != NULL)
2413 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2414
2415 if (the_target->read_loadmap != NULL)
2416 strcat (own_buf, ";qXfer:fdpic:read+");
2417
2418 /* We always report qXfer:features:read, as targets may
2419 install XML files on a subsequent call to arch_setup.
2420 If we reported to GDB on startup that we don't support
2421 qXfer:feature:read at all, we will never be re-queried. */
2422 strcat (own_buf, ";qXfer:features:read+");
2423
2424 if (transport_is_reliable)
2425 strcat (own_buf, ";QStartNoAckMode+");
2426
2427 if (the_target->qxfer_osdata != NULL)
2428 strcat (own_buf, ";qXfer:osdata:read+");
2429
2430 if (target_supports_multi_process ())
2431 strcat (own_buf, ";multiprocess+");
2432
2433 if (target_supports_fork_events ())
2434 strcat (own_buf, ";fork-events+");
2435
2436 if (target_supports_vfork_events ())
2437 strcat (own_buf, ";vfork-events+");
2438
2439 if (target_supports_exec_events ())
2440 strcat (own_buf, ";exec-events+");
2441
2442 if (target_supports_non_stop ())
2443 strcat (own_buf, ";QNonStop+");
2444
2445 if (target_supports_disable_randomization ())
2446 strcat (own_buf, ";QDisableRandomization+");
2447
2448 strcat (own_buf, ";qXfer:threads:read+");
2449
2450 if (target_supports_tracepoints ())
2451 {
2452 strcat (own_buf, ";ConditionalTracepoints+");
2453 strcat (own_buf, ";TraceStateVariables+");
2454 strcat (own_buf, ";TracepointSource+");
2455 strcat (own_buf, ";DisconnectedTracing+");
2456 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
2457 strcat (own_buf, ";FastTracepoints+");
2458 strcat (own_buf, ";StaticTracepoints+");
2459 strcat (own_buf, ";InstallInTrace+");
2460 strcat (own_buf, ";qXfer:statictrace:read+");
2461 strcat (own_buf, ";qXfer:traceframe-info:read+");
2462 strcat (own_buf, ";EnableDisableTracepoints+");
2463 strcat (own_buf, ";QTBuffer:size+");
2464 strcat (own_buf, ";tracenz+");
2465 }
2466
2467 if (target_supports_hardware_single_step ()
2468 || target_supports_software_single_step () )
2469 {
2470 strcat (own_buf, ";ConditionalBreakpoints+");
2471 }
2472 strcat (own_buf, ";BreakpointCommands+");
2473
2474 if (target_supports_agent ())
2475 strcat (own_buf, ";QAgent+");
2476
2477 supported_btrace_packets (own_buf);
2478
2479 if (target_supports_stopped_by_sw_breakpoint ())
2480 strcat (own_buf, ";swbreak+");
2481
2482 if (target_supports_stopped_by_hw_breakpoint ())
2483 strcat (own_buf, ";hwbreak+");
2484
2485 if (the_target->pid_to_exec_file != NULL)
2486 strcat (own_buf, ";qXfer:exec-file:read+");
2487
2488 strcat (own_buf, ";vContSupported+");
2489
2490 strcat (own_buf, ";QThreadEvents+");
2491
2492 strcat (own_buf, ";no-resumed+");
2493
2494 /* Reinitialize components as needed for the new connection. */
2495 hostio_handle_new_gdb_connection ();
2496 target_handle_new_gdb_connection ();
2497
2498 return;
2499 }
2500
2501 /* Thread-local storage support. */
2502 if (the_target->get_tls_address != NULL
2503 && startswith (own_buf, "qGetTLSAddr:"))
2504 {
2505 char *p = own_buf + 12;
2506 CORE_ADDR parts[2], address = 0;
2507 int i, err;
2508 ptid_t ptid = null_ptid;
2509
2510 require_running_or_return (own_buf);
2511
2512 for (i = 0; i < 3; i++)
2513 {
2514 char *p2;
2515 int len;
2516
2517 if (p == NULL)
2518 break;
2519
2520 p2 = strchr (p, ',');
2521 if (p2)
2522 {
2523 len = p2 - p;
2524 p2++;
2525 }
2526 else
2527 {
2528 len = strlen (p);
2529 p2 = NULL;
2530 }
2531
2532 if (i == 0)
2533 ptid = read_ptid (p, NULL);
2534 else
2535 decode_address (&parts[i - 1], p, len);
2536 p = p2;
2537 }
2538
2539 if (p != NULL || i < 3)
2540 err = 1;
2541 else
2542 {
2543 struct thread_info *thread = find_thread_ptid (ptid);
2544
2545 if (thread == NULL)
2546 err = 2;
2547 else
2548 err = the_target->get_tls_address (thread, parts[0], parts[1],
2549 &address);
2550 }
2551
2552 if (err == 0)
2553 {
2554 strcpy (own_buf, paddress(address));
2555 return;
2556 }
2557 else if (err > 0)
2558 {
2559 write_enn (own_buf);
2560 return;
2561 }
2562
2563 /* Otherwise, pretend we do not understand this packet. */
2564 }
2565
2566 /* Windows OS Thread Information Block address support. */
2567 if (the_target->get_tib_address != NULL
2568 && startswith (own_buf, "qGetTIBAddr:"))
2569 {
2570 char *annex;
2571 int n;
2572 CORE_ADDR tlb;
2573 ptid_t ptid = read_ptid (own_buf + 12, &annex);
2574
2575 n = (*the_target->get_tib_address) (ptid, &tlb);
2576 if (n == 1)
2577 {
2578 strcpy (own_buf, paddress(tlb));
2579 return;
2580 }
2581 else if (n == 0)
2582 {
2583 write_enn (own_buf);
2584 return;
2585 }
2586 return;
2587 }
2588
2589 /* Handle "monitor" commands. */
2590 if (startswith (own_buf, "qRcmd,"))
2591 {
2592 char *mon = (char *) malloc (PBUFSIZ);
2593 int len = strlen (own_buf + 6);
2594
2595 if (mon == NULL)
2596 {
2597 write_enn (own_buf);
2598 return;
2599 }
2600
2601 if ((len % 2) != 0
2602 || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2)
2603 {
2604 write_enn (own_buf);
2605 free (mon);
2606 return;
2607 }
2608 mon[len / 2] = '\0';
2609
2610 write_ok (own_buf);
2611
2612 if (the_target->handle_monitor_command == NULL
2613 || (*the_target->handle_monitor_command) (mon) == 0)
2614 /* Default processing. */
2615 handle_monitor_command (mon, own_buf);
2616
2617 free (mon);
2618 return;
2619 }
2620
2621 if (startswith (own_buf, "qSearch:memory:"))
2622 {
2623 require_running_or_return (own_buf);
2624 handle_search_memory (own_buf, packet_len);
2625 return;
2626 }
2627
2628 if (strcmp (own_buf, "qAttached") == 0
2629 || startswith (own_buf, "qAttached:"))
2630 {
2631 struct process_info *process;
2632
2633 if (own_buf[sizeof ("qAttached") - 1])
2634 {
2635 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
2636 process = (struct process_info *)
2637 find_inferior_id (&all_processes, pid_to_ptid (pid));
2638 }
2639 else
2640 {
2641 require_running_or_return (own_buf);
2642 process = current_process ();
2643 }
2644
2645 if (process == NULL)
2646 {
2647 write_enn (own_buf);
2648 return;
2649 }
2650
2651 strcpy (own_buf, process->attached ? "1" : "0");
2652 return;
2653 }
2654
2655 if (startswith (own_buf, "qCRC:"))
2656 {
2657 /* CRC check (compare-section). */
2658 char *comma;
2659 ULONGEST base;
2660 int len;
2661 unsigned long long crc;
2662
2663 require_running_or_return (own_buf);
2664 comma = unpack_varlen_hex (own_buf + 5, &base);
2665 if (*comma++ != ',')
2666 {
2667 write_enn (own_buf);
2668 return;
2669 }
2670 len = strtoul (comma, NULL, 16);
2671 crc = crc32 (base, len, 0xffffffff);
2672 /* Check for memory failure. */
2673 if (crc == (unsigned long long) -1)
2674 {
2675 write_enn (own_buf);
2676 return;
2677 }
2678 sprintf (own_buf, "C%lx", (unsigned long) crc);
2679 return;
2680 }
2681
2682 if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
2683 return;
2684
2685 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
2686 return;
2687
2688 /* Otherwise we didn't know what packet it was. Say we didn't
2689 understand it. */
2690 own_buf[0] = 0;
2691 }
2692
2693 static void gdb_wants_all_threads_stopped (void);
2694 static void resume (struct thread_resume *actions, size_t n);
2695
2696 /* The callback that is passed to visit_actioned_threads. */
2697 typedef int (visit_actioned_threads_callback_ftype)
2698 (const struct thread_resume *, struct thread_info *);
2699
2700 /* Struct to pass data to visit_actioned_threads. */
2701
2702 struct visit_actioned_threads_data
2703 {
2704 const struct thread_resume *actions;
2705 size_t num_actions;
2706 visit_actioned_threads_callback_ftype *callback;
2707 };
2708
2709 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2710 true if CALLBACK returns true. Returns false if no matching thread
2711 is found or CALLBACK results false.
2712 Note: This function is itself a callback for find_inferior. */
2713
2714 static int
2715 visit_actioned_threads (struct inferior_list_entry *entry, void *datap)
2716 {
2717 struct visit_actioned_threads_data *data
2718 = (struct visit_actioned_threads_data *) datap;
2719 const struct thread_resume *actions = data->actions;
2720 size_t num_actions = data->num_actions;
2721 visit_actioned_threads_callback_ftype *callback = data->callback;
2722 size_t i;
2723
2724 for (i = 0; i < num_actions; i++)
2725 {
2726 const struct thread_resume *action = &actions[i];
2727
2728 if (ptid_equal (action->thread, minus_one_ptid)
2729 || ptid_equal (action->thread, entry->id)
2730 || ((ptid_get_pid (action->thread)
2731 == ptid_get_pid (entry->id))
2732 && ptid_get_lwp (action->thread) == -1))
2733 {
2734 struct thread_info *thread = (struct thread_info *) entry;
2735
2736 if ((*callback) (action, thread))
2737 return 1;
2738 }
2739 }
2740
2741 return 0;
2742 }
2743
2744 /* Callback for visit_actioned_threads. If the thread has a pending
2745 status to report, report it now. */
2746
2747 static int
2748 handle_pending_status (const struct thread_resume *resumption,
2749 struct thread_info *thread)
2750 {
2751 if (thread->status_pending_p)
2752 {
2753 thread->status_pending_p = 0;
2754
2755 last_status = thread->last_status;
2756 last_ptid = thread->entry.id;
2757 prepare_resume_reply (own_buf, last_ptid, &last_status);
2758 return 1;
2759 }
2760 return 0;
2761 }
2762
2763 /* Parse vCont packets. */
2764 static void
2765 handle_v_cont (char *own_buf)
2766 {
2767 char *p, *q;
2768 int n = 0, i = 0;
2769 struct thread_resume *resume_info;
2770 struct thread_resume default_action { null_ptid };
2771
2772 /* Count the number of semicolons in the packet. There should be one
2773 for every action. */
2774 p = &own_buf[5];
2775 while (p)
2776 {
2777 n++;
2778 p++;
2779 p = strchr (p, ';');
2780 }
2781
2782 resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0]));
2783 if (resume_info == NULL)
2784 goto err;
2785
2786 p = &own_buf[5];
2787 while (*p)
2788 {
2789 p++;
2790
2791 memset (&resume_info[i], 0, sizeof resume_info[i]);
2792
2793 if (p[0] == 's' || p[0] == 'S')
2794 resume_info[i].kind = resume_step;
2795 else if (p[0] == 'r')
2796 resume_info[i].kind = resume_step;
2797 else if (p[0] == 'c' || p[0] == 'C')
2798 resume_info[i].kind = resume_continue;
2799 else if (p[0] == 't')
2800 resume_info[i].kind = resume_stop;
2801 else
2802 goto err;
2803
2804 if (p[0] == 'S' || p[0] == 'C')
2805 {
2806 int sig;
2807 sig = strtol (p + 1, &q, 16);
2808 if (p == q)
2809 goto err;
2810 p = q;
2811
2812 if (!gdb_signal_to_host_p ((enum gdb_signal) sig))
2813 goto err;
2814 resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig);
2815 }
2816 else if (p[0] == 'r')
2817 {
2818 ULONGEST addr;
2819
2820 p = unpack_varlen_hex (p + 1, &addr);
2821 resume_info[i].step_range_start = addr;
2822
2823 if (*p != ',')
2824 goto err;
2825
2826 p = unpack_varlen_hex (p + 1, &addr);
2827 resume_info[i].step_range_end = addr;
2828 }
2829 else
2830 {
2831 p = p + 1;
2832 }
2833
2834 if (p[0] == 0)
2835 {
2836 resume_info[i].thread = minus_one_ptid;
2837 default_action = resume_info[i];
2838
2839 /* Note: we don't increment i here, we'll overwrite this entry
2840 the next time through. */
2841 }
2842 else if (p[0] == ':')
2843 {
2844 ptid_t ptid = read_ptid (p + 1, &q);
2845
2846 if (p == q)
2847 goto err;
2848 p = q;
2849 if (p[0] != ';' && p[0] != 0)
2850 goto err;
2851
2852 resume_info[i].thread = ptid;
2853
2854 i++;
2855 }
2856 }
2857
2858 if (i < n)
2859 resume_info[i] = default_action;
2860
2861 resume (resume_info, n);
2862 free (resume_info);
2863 return;
2864
2865 err:
2866 write_enn (own_buf);
2867 free (resume_info);
2868 return;
2869 }
2870
2871 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2872
2873 static void
2874 resume (struct thread_resume *actions, size_t num_actions)
2875 {
2876 if (!non_stop)
2877 {
2878 /* Check if among the threads that GDB wants actioned, there's
2879 one with a pending status to report. If so, skip actually
2880 resuming/stopping and report the pending event
2881 immediately. */
2882 struct visit_actioned_threads_data data;
2883
2884 data.actions = actions;
2885 data.num_actions = num_actions;
2886 data.callback = handle_pending_status;
2887 if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL)
2888 return;
2889
2890 enable_async_io ();
2891 }
2892
2893 (*the_target->resume) (actions, num_actions);
2894
2895 if (non_stop)
2896 write_ok (own_buf);
2897 else
2898 {
2899 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
2900
2901 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
2902 && !report_no_resumed)
2903 {
2904 /* The client does not support this stop reply. At least
2905 return error. */
2906 sprintf (own_buf, "E.No unwaited-for children left.");
2907 disable_async_io ();
2908 return;
2909 }
2910
2911 if (last_status.kind != TARGET_WAITKIND_EXITED
2912 && last_status.kind != TARGET_WAITKIND_SIGNALLED
2913 && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
2914 current_thread->last_status = last_status;
2915
2916 /* From the client's perspective, all-stop mode always stops all
2917 threads implicitly (and the target backend has already done
2918 so by now). Tag all threads as "want-stopped", so we don't
2919 resume them implicitly without the client telling us to. */
2920 gdb_wants_all_threads_stopped ();
2921 prepare_resume_reply (own_buf, last_ptid, &last_status);
2922 disable_async_io ();
2923
2924 if (last_status.kind == TARGET_WAITKIND_EXITED
2925 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2926 target_mourn_inferior (last_ptid);
2927 }
2928 }
2929
2930 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2931 static int
2932 handle_v_attach (char *own_buf)
2933 {
2934 int pid;
2935
2936 pid = strtol (own_buf + 8, NULL, 16);
2937 if (pid != 0 && attach_inferior (pid) == 0)
2938 {
2939 /* Don't report shared library events after attaching, even if
2940 some libraries are preloaded. GDB will always poll the
2941 library list. Avoids the "stopped by shared library event"
2942 notice on the GDB side. */
2943 dlls_changed = 0;
2944
2945 if (non_stop)
2946 {
2947 /* In non-stop, we don't send a resume reply. Stop events
2948 will follow up using the normal notification
2949 mechanism. */
2950 write_ok (own_buf);
2951 }
2952 else
2953 prepare_resume_reply (own_buf, last_ptid, &last_status);
2954
2955 return 1;
2956 }
2957 else
2958 {
2959 write_enn (own_buf);
2960 return 0;
2961 }
2962 }
2963
2964 /* Run a new program. Return 1 if successful, 0 if failure. */
2965 static int
2966 handle_v_run (char *own_buf)
2967 {
2968 char *p, *next_p;
2969 std::vector<char *> new_argv;
2970 char *new_program_name = NULL;
2971 int i, new_argc;
2972
2973 new_argc = 0;
2974 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
2975 {
2976 p++;
2977 new_argc++;
2978 }
2979
2980 for (i = 0, p = own_buf + strlen ("vRun;"); *p; p = next_p, ++i)
2981 {
2982 next_p = strchr (p, ';');
2983 if (next_p == NULL)
2984 next_p = p + strlen (p);
2985
2986 if (i == 0 && p == next_p)
2987 {
2988 /* No program specified. */
2989 new_program_name = NULL;
2990 }
2991 else if (p == next_p)
2992 {
2993 /* Empty argument. */
2994 new_argv.push_back (xstrdup ("''"));
2995 }
2996 else
2997 {
2998 size_t len = (next_p - p) / 2;
2999 /* ARG is the unquoted argument received via the RSP. */
3000 char *arg = (char *) xmalloc (len + 1);
3001 /* FULL_ARGS will contain the quoted version of ARG. */
3002 char *full_arg = (char *) xmalloc ((len + 1) * 2);
3003 /* These are pointers used to navigate the strings above. */
3004 char *tmp_arg = arg;
3005 char *tmp_full_arg = full_arg;
3006 int need_quote = 0;
3007
3008 hex2bin (p, (gdb_byte *) arg, len);
3009 arg[len] = '\0';
3010
3011 while (*tmp_arg != '\0')
3012 {
3013 switch (*tmp_arg)
3014 {
3015 case '\n':
3016 /* Quote \n. */
3017 *tmp_full_arg = '\'';
3018 ++tmp_full_arg;
3019 need_quote = 1;
3020 break;
3021
3022 case '\'':
3023 /* Quote single quote. */
3024 *tmp_full_arg = '\\';
3025 ++tmp_full_arg;
3026 break;
3027
3028 default:
3029 break;
3030 }
3031
3032 *tmp_full_arg = *tmp_arg;
3033 ++tmp_full_arg;
3034 ++tmp_arg;
3035 }
3036
3037 if (need_quote)
3038 *tmp_full_arg++ = '\'';
3039
3040 /* Finish FULL_ARG and push it into the vector containing
3041 the argv. */
3042 *tmp_full_arg = '\0';
3043 if (i == 0)
3044 new_program_name = full_arg;
3045 else
3046 new_argv.push_back (full_arg);
3047 xfree (arg);
3048 }
3049 if (*next_p)
3050 next_p++;
3051 }
3052 new_argv.push_back (NULL);
3053
3054 if (new_program_name == NULL)
3055 {
3056 /* GDB didn't specify a program to run. Use the program from the
3057 last run with the new argument list. */
3058 if (program_name == NULL)
3059 {
3060 write_enn (own_buf);
3061 free_vector_argv (new_argv);
3062 return 0;
3063 }
3064 }
3065 else
3066 {
3067 xfree (program_name);
3068 program_name = new_program_name;
3069 }
3070
3071 /* Free the old argv and install the new one. */
3072 free_vector_argv (program_args);
3073 program_args = new_argv;
3074
3075 create_inferior (program_name, program_args);
3076
3077 if (last_status.kind == TARGET_WAITKIND_STOPPED)
3078 {
3079 prepare_resume_reply (own_buf, last_ptid, &last_status);
3080
3081 /* In non-stop, sending a resume reply doesn't set the general
3082 thread, but GDB assumes a vRun sets it (this is so GDB can
3083 query which is the main thread of the new inferior. */
3084 if (non_stop)
3085 general_thread = last_ptid;
3086
3087 return 1;
3088 }
3089 else
3090 {
3091 write_enn (own_buf);
3092 return 0;
3093 }
3094 }
3095
3096 /* Kill process. Return 1 if successful, 0 if failure. */
3097 static int
3098 handle_v_kill (char *own_buf)
3099 {
3100 int pid;
3101 char *p = &own_buf[6];
3102 if (multi_process)
3103 pid = strtol (p, NULL, 16);
3104 else
3105 pid = signal_pid;
3106 if (pid != 0 && kill_inferior (pid) == 0)
3107 {
3108 last_status.kind = TARGET_WAITKIND_SIGNALLED;
3109 last_status.value.sig = GDB_SIGNAL_KILL;
3110 last_ptid = pid_to_ptid (pid);
3111 discard_queued_stop_replies (last_ptid);
3112 write_ok (own_buf);
3113 return 1;
3114 }
3115 else
3116 {
3117 write_enn (own_buf);
3118 return 0;
3119 }
3120 }
3121
3122 /* Handle all of the extended 'v' packets. */
3123 void
3124 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
3125 {
3126 if (!disable_packet_vCont)
3127 {
3128 if (strcmp (own_buf, "vCtrlC") == 0)
3129 {
3130 (*the_target->request_interrupt) ();
3131 write_ok (own_buf);
3132 return;
3133 }
3134
3135 if (startswith (own_buf, "vCont;"))
3136 {
3137 handle_v_cont (own_buf);
3138 return;
3139 }
3140
3141 if (startswith (own_buf, "vCont?"))
3142 {
3143 strcpy (own_buf, "vCont;c;C;t");
3144
3145 if (target_supports_hardware_single_step ()
3146 || target_supports_software_single_step ()
3147 || !vCont_supported)
3148 {
3149 /* If target supports single step either by hardware or by
3150 software, add actions s and S to the list of supported
3151 actions. On the other hand, if GDB doesn't request the
3152 supported vCont actions in qSupported packet, add s and
3153 S to the list too. */
3154 own_buf = own_buf + strlen (own_buf);
3155 strcpy (own_buf, ";s;S");
3156 }
3157
3158 if (target_supports_range_stepping ())
3159 {
3160 own_buf = own_buf + strlen (own_buf);
3161 strcpy (own_buf, ";r");
3162 }
3163 return;
3164 }
3165 }
3166
3167 if (startswith (own_buf, "vFile:")
3168 && handle_vFile (own_buf, packet_len, new_packet_len))
3169 return;
3170
3171 if (startswith (own_buf, "vAttach;"))
3172 {
3173 if ((!extended_protocol || !multi_process) && target_running ())
3174 {
3175 fprintf (stderr, "Already debugging a process\n");
3176 write_enn (own_buf);
3177 return;
3178 }
3179 handle_v_attach (own_buf);
3180 return;
3181 }
3182
3183 if (startswith (own_buf, "vRun;"))
3184 {
3185 if ((!extended_protocol || !multi_process) && target_running ())
3186 {
3187 fprintf (stderr, "Already debugging a process\n");
3188 write_enn (own_buf);
3189 return;
3190 }
3191 handle_v_run (own_buf);
3192 return;
3193 }
3194
3195 if (startswith (own_buf, "vKill;"))
3196 {
3197 if (!target_running ())
3198 {
3199 fprintf (stderr, "No process to kill\n");
3200 write_enn (own_buf);
3201 return;
3202 }
3203 handle_v_kill (own_buf);
3204 return;
3205 }
3206
3207 if (handle_notif_ack (own_buf, packet_len))
3208 return;
3209
3210 /* Otherwise we didn't know what packet it was. Say we didn't
3211 understand it. */
3212 own_buf[0] = 0;
3213 return;
3214 }
3215
3216 /* Resume thread and wait for another event. In non-stop mode,
3217 don't really wait here, but return immediatelly to the event
3218 loop. */
3219 static void
3220 myresume (char *own_buf, int step, int sig)
3221 {
3222 struct thread_resume resume_info[2];
3223 int n = 0;
3224 int valid_cont_thread;
3225
3226 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
3227 && !ptid_equal (cont_thread, minus_one_ptid));
3228
3229 if (step || sig || valid_cont_thread)
3230 {
3231 resume_info[0].thread = current_ptid;
3232 if (step)
3233 resume_info[0].kind = resume_step;
3234 else
3235 resume_info[0].kind = resume_continue;
3236 resume_info[0].sig = sig;
3237 n++;
3238 }
3239
3240 if (!valid_cont_thread)
3241 {
3242 resume_info[n].thread = minus_one_ptid;
3243 resume_info[n].kind = resume_continue;
3244 resume_info[n].sig = 0;
3245 n++;
3246 }
3247
3248 resume (resume_info, n);
3249 }
3250
3251 /* Callback for for_each_inferior. Make a new stop reply for each
3252 stopped thread. */
3253
3254 static int
3255 queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
3256 {
3257 struct thread_info *thread = (struct thread_info *) entry;
3258
3259 /* For now, assume targets that don't have this callback also don't
3260 manage the thread's last_status field. */
3261 if (the_target->thread_stopped == NULL)
3262 {
3263 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
3264
3265 new_notif->ptid = entry->id;
3266 new_notif->status = thread->last_status;
3267 /* Pass the last stop reply back to GDB, but don't notify
3268 yet. */
3269 notif_event_enque (&notif_stop,
3270 (struct notif_event *) new_notif);
3271 }
3272 else
3273 {
3274 if (thread_stopped (thread))
3275 {
3276 if (debug_threads)
3277 {
3278 std::string status_string
3279 = target_waitstatus_to_string (&thread->last_status);
3280
3281 debug_printf ("Reporting thread %s as already stopped with %s\n",
3282 target_pid_to_str (entry->id),
3283 status_string.c_str ());
3284 }
3285
3286 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
3287
3288 /* Pass the last stop reply back to GDB, but don't notify
3289 yet. */
3290 queue_stop_reply (entry->id, &thread->last_status);
3291 }
3292 }
3293
3294 return 0;
3295 }
3296
3297 /* Set this inferior threads's state as "want-stopped". We won't
3298 resume this thread until the client gives us another action for
3299 it. */
3300
3301 static void
3302 gdb_wants_thread_stopped (struct inferior_list_entry *entry)
3303 {
3304 struct thread_info *thread = (struct thread_info *) entry;
3305
3306 thread->last_resume_kind = resume_stop;
3307
3308 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
3309 {
3310 /* Most threads are stopped implicitly (all-stop); tag that with
3311 signal 0. */
3312 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
3313 thread->last_status.value.sig = GDB_SIGNAL_0;
3314 }
3315 }
3316
3317 /* Set all threads' states as "want-stopped". */
3318
3319 static void
3320 gdb_wants_all_threads_stopped (void)
3321 {
3322 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
3323 }
3324
3325 /* Clear the gdb_detached flag of every process. */
3326
3327 static void
3328 gdb_reattached_process (struct inferior_list_entry *entry)
3329 {
3330 struct process_info *process = (struct process_info *) entry;
3331
3332 process->gdb_detached = 0;
3333 }
3334
3335 /* Callback for for_each_inferior. Clear the thread's pending status
3336 flag. */
3337
3338 static void
3339 clear_pending_status_callback (struct inferior_list_entry *entry)
3340 {
3341 struct thread_info *thread = (struct thread_info *) entry;
3342
3343 thread->status_pending_p = 0;
3344 }
3345
3346 /* Callback for for_each_inferior. If the thread is stopped with an
3347 interesting event, mark it as having a pending event. */
3348
3349 static void
3350 set_pending_status_callback (struct inferior_list_entry *entry)
3351 {
3352 struct thread_info *thread = (struct thread_info *) entry;
3353
3354 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
3355 || (thread->last_status.value.sig != GDB_SIGNAL_0
3356 /* A breakpoint, watchpoint or finished step from a previous
3357 GDB run isn't considered interesting for a new GDB run.
3358 If we left those pending, the new GDB could consider them
3359 random SIGTRAPs. This leaves out real async traps. We'd
3360 have to peek into the (target-specific) siginfo to
3361 distinguish those. */
3362 && thread->last_status.value.sig != GDB_SIGNAL_TRAP))
3363 thread->status_pending_p = 1;
3364 }
3365
3366 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3367 pending status to report to GDB. */
3368
3369 static int
3370 find_status_pending_thread_callback (struct inferior_list_entry *entry, void *data)
3371 {
3372 struct thread_info *thread = (struct thread_info *) entry;
3373
3374 return thread->status_pending_p;
3375 }
3376
3377 /* Status handler for the '?' packet. */
3378
3379 static void
3380 handle_status (char *own_buf)
3381 {
3382 /* GDB is connected, don't forward events to the target anymore. */
3383 for_each_inferior (&all_processes, gdb_reattached_process);
3384
3385 /* In non-stop mode, we must send a stop reply for each stopped
3386 thread. In all-stop mode, just send one for the first stopped
3387 thread we find. */
3388
3389 if (non_stop)
3390 {
3391 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
3392
3393 /* The first is sent immediatly. OK is sent if there is no
3394 stopped thread, which is the same handling of the vStopped
3395 packet (by design). */
3396 notif_write_event (&notif_stop, own_buf);
3397 }
3398 else
3399 {
3400 struct inferior_list_entry *thread = NULL;
3401
3402 pause_all (0);
3403 stabilize_threads ();
3404 gdb_wants_all_threads_stopped ();
3405
3406 /* We can only report one status, but we might be coming out of
3407 non-stop -- if more than one thread is stopped with
3408 interesting events, leave events for the threads we're not
3409 reporting now pending. They'll be reported the next time the
3410 threads are resumed. Start by marking all interesting events
3411 as pending. */
3412 for_each_inferior (&all_threads, set_pending_status_callback);
3413
3414 /* Prefer the last thread that reported an event to GDB (even if
3415 that was a GDB_SIGNAL_TRAP). */
3416 if (last_status.kind != TARGET_WAITKIND_IGNORE
3417 && last_status.kind != TARGET_WAITKIND_EXITED
3418 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
3419 thread = find_inferior_id (&all_threads, last_ptid);
3420
3421 /* If the last event thread is not found for some reason, look
3422 for some other thread that might have an event to report. */
3423 if (thread == NULL)
3424 thread = find_inferior (&all_threads,
3425 find_status_pending_thread_callback, NULL);
3426
3427 /* If we're still out of luck, simply pick the first thread in
3428 the thread list. */
3429 if (thread == NULL)
3430 thread = get_first_inferior (&all_threads);
3431
3432 if (thread != NULL)
3433 {
3434 struct thread_info *tp = (struct thread_info *) thread;
3435
3436 /* We're reporting this event, so it's no longer
3437 pending. */
3438 tp->status_pending_p = 0;
3439
3440 /* GDB assumes the current thread is the thread we're
3441 reporting the status for. */
3442 general_thread = thread->id;
3443 set_desired_thread (1);
3444
3445 gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
3446 prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status);
3447 }
3448 else
3449 strcpy (own_buf, "W00");
3450 }
3451 }
3452
3453 static void
3454 gdbserver_version (void)
3455 {
3456 printf ("GNU gdbserver %s%s\n"
3457 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3458 "gdbserver is free software, covered by the "
3459 "GNU General Public License.\n"
3460 "This gdbserver was configured as \"%s\"\n",
3461 PKGVERSION, version, host_name);
3462 }
3463
3464 static void
3465 gdbserver_usage (FILE *stream)
3466 {
3467 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3468 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3469 "\tgdbserver [OPTIONS] --multi COMM\n"
3470 "\n"
3471 "COMM may either be a tty device (for serial debugging),\n"
3472 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3473 "stdin/stdout of gdbserver.\n"
3474 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3475 "PID is the process ID to attach to, when --attach is specified.\n"
3476 "\n"
3477 "Operating modes:\n"
3478 "\n"
3479 " --attach Attach to running process PID.\n"
3480 " --multi Start server without a specific program, and\n"
3481 " only quit when explicitly commanded.\n"
3482 " --once Exit after the first connection has closed.\n"
3483 " --help Print this message and then exit.\n"
3484 " --version Display version information and exit.\n"
3485 "\n"
3486 "Other options:\n"
3487 "\n"
3488 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3489 " --disable-randomization\n"
3490 " Run PROG with address space randomization disabled.\n"
3491 " --no-disable-randomization\n"
3492 " Don't disable address space randomization when\n"
3493 " starting PROG.\n"
3494 " --startup-with-shell\n"
3495 " Start PROG using a shell. I.e., execs a shell that\n"
3496 " then execs PROG. (default)\n"
3497 " --no-startup-with-shell\n"
3498 " Exec PROG directly instead of using a shell.\n"
3499 " Disables argument globbing and variable substitution\n"
3500 " on UNIX-like systems.\n"
3501 "\n"
3502 "Debug options:\n"
3503 "\n"
3504 " --debug Enable general debugging output.\n"
3505 " --debug-format=opt1[,opt2,...]\n"
3506 " Specify extra content in debugging output.\n"
3507 " Options:\n"
3508 " all\n"
3509 " none\n"
3510 " timestamp\n"
3511 " --remote-debug Enable remote protocol debugging output.\n"
3512 " --disable-packet=opt1[,opt2,...]\n"
3513 " Disable support for RSP packets or features.\n"
3514 " Options:\n"
3515 " vCont, Tthread, qC, qfThreadInfo and \n"
3516 " threads (disable all threading packets).\n"
3517 "\n"
3518 "For more information, consult the GDB manual (available as on-line \n"
3519 "info or a printed manual).\n");
3520 if (REPORT_BUGS_TO[0] && stream == stdout)
3521 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
3522 }
3523
3524 static void
3525 gdbserver_show_disableable (FILE *stream)
3526 {
3527 fprintf (stream, "Disableable packets:\n"
3528 " vCont \tAll vCont packets\n"
3529 " qC \tQuerying the current thread\n"
3530 " qfThreadInfo\tThread listing\n"
3531 " Tthread \tPassing the thread specifier in the "
3532 "T stop reply packet\n"
3533 " threads \tAll of the above\n");
3534 }
3535
3536 static void
3537 kill_inferior_callback (struct inferior_list_entry *entry)
3538 {
3539 struct process_info *process = (struct process_info *) entry;
3540 int pid = ptid_get_pid (process->entry.id);
3541
3542 kill_inferior (pid);
3543 discard_queued_stop_replies (pid_to_ptid (pid));
3544 }
3545
3546 /* Callback for for_each_inferior to detach or kill the inferior,
3547 depending on whether we attached to it or not.
3548 We inform the user whether we're detaching or killing the process
3549 as this is only called when gdbserver is about to exit. */
3550
3551 static void
3552 detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
3553 {
3554 struct process_info *process = (struct process_info *) entry;
3555 int pid = ptid_get_pid (process->entry.id);
3556
3557 if (process->attached)
3558 detach_inferior (pid);
3559 else
3560 kill_inferior (pid);
3561
3562 discard_queued_stop_replies (pid_to_ptid (pid));
3563 }
3564
3565 /* for_each_inferior callback for detach_or_kill_for_exit to print
3566 the pids of started inferiors. */
3567
3568 static void
3569 print_started_pid (struct inferior_list_entry *entry)
3570 {
3571 struct process_info *process = (struct process_info *) entry;
3572
3573 if (! process->attached)
3574 {
3575 int pid = ptid_get_pid (process->entry.id);
3576 fprintf (stderr, " %d", pid);
3577 }
3578 }
3579
3580 /* for_each_inferior callback for detach_or_kill_for_exit to print
3581 the pids of attached inferiors. */
3582
3583 static void
3584 print_attached_pid (struct inferior_list_entry *entry)
3585 {
3586 struct process_info *process = (struct process_info *) entry;
3587
3588 if (process->attached)
3589 {
3590 int pid = ptid_get_pid (process->entry.id);
3591 fprintf (stderr, " %d", pid);
3592 }
3593 }
3594
3595 /* Call this when exiting gdbserver with possible inferiors that need
3596 to be killed or detached from. */
3597
3598 static void
3599 detach_or_kill_for_exit (void)
3600 {
3601 /* First print a list of the inferiors we will be killing/detaching.
3602 This is to assist the user, for example, in case the inferior unexpectedly
3603 dies after we exit: did we screw up or did the inferior exit on its own?
3604 Having this info will save some head-scratching. */
3605
3606 if (have_started_inferiors_p ())
3607 {
3608 fprintf (stderr, "Killing process(es):");
3609 for_each_inferior (&all_processes, print_started_pid);
3610 fprintf (stderr, "\n");
3611 }
3612 if (have_attached_inferiors_p ())
3613 {
3614 fprintf (stderr, "Detaching process(es):");
3615 for_each_inferior (&all_processes, print_attached_pid);
3616 fprintf (stderr, "\n");
3617 }
3618
3619 /* Now we can kill or detach the inferiors. */
3620
3621 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
3622 }
3623
3624 /* Value that will be passed to exit(3) when gdbserver exits. */
3625 static int exit_code;
3626
3627 /* Cleanup version of detach_or_kill_for_exit. */
3628
3629 static void
3630 detach_or_kill_for_exit_cleanup (void *ignore)
3631 {
3632
3633 TRY
3634 {
3635 detach_or_kill_for_exit ();
3636 }
3637
3638 CATCH (exception, RETURN_MASK_ALL)
3639 {
3640 fflush (stdout);
3641 fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
3642 exit_code = 1;
3643 }
3644 END_CATCH
3645 }
3646
3647 /* Main function. This is called by the real "main" function,
3648 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3649
3650 static void ATTRIBUTE_NORETURN
3651 captured_main (int argc, char *argv[])
3652 {
3653 int bad_attach;
3654 int pid;
3655 char *arg_end;
3656 const char *port = NULL;
3657 char **next_arg = &argv[1];
3658 volatile int multi_mode = 0;
3659 volatile int attach = 0;
3660 int was_running;
3661 bool selftest = false;
3662 const char *selftest_filter = NULL;
3663
3664 while (*next_arg != NULL && **next_arg == '-')
3665 {
3666 if (strcmp (*next_arg, "--version") == 0)
3667 {
3668 gdbserver_version ();
3669 exit (0);
3670 }
3671 else if (strcmp (*next_arg, "--help") == 0)
3672 {
3673 gdbserver_usage (stdout);
3674 exit (0);
3675 }
3676 else if (strcmp (*next_arg, "--attach") == 0)
3677 attach = 1;
3678 else if (strcmp (*next_arg, "--multi") == 0)
3679 multi_mode = 1;
3680 else if (strcmp (*next_arg, "--wrapper") == 0)
3681 {
3682 char **tmp;
3683
3684 next_arg++;
3685
3686 tmp = next_arg;
3687 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
3688 {
3689 wrapper_argv += *next_arg;
3690 wrapper_argv += ' ';
3691 next_arg++;
3692 }
3693
3694 if (!wrapper_argv.empty ())
3695 {
3696 /* Erase the last whitespace. */
3697 wrapper_argv.erase (wrapper_argv.end () - 1);
3698 }
3699
3700 if (next_arg == tmp || *next_arg == NULL)
3701 {
3702 gdbserver_usage (stderr);
3703 exit (1);
3704 }
3705
3706 /* Consume the "--". */
3707 *next_arg = NULL;
3708 }
3709 else if (strcmp (*next_arg, "--debug") == 0)
3710 debug_threads = 1;
3711 else if (startswith (*next_arg, "--debug-format="))
3712 {
3713 char *error_msg
3714 = parse_debug_format_options ((*next_arg)
3715 + sizeof ("--debug-format=") - 1, 0);
3716
3717 if (error_msg != NULL)
3718 {
3719 fprintf (stderr, "%s", error_msg);
3720 exit (1);
3721 }
3722 }
3723 else if (strcmp (*next_arg, "--remote-debug") == 0)
3724 remote_debug = 1;
3725 else if (strcmp (*next_arg, "--disable-packet") == 0)
3726 {
3727 gdbserver_show_disableable (stdout);
3728 exit (0);
3729 }
3730 else if (startswith (*next_arg, "--disable-packet="))
3731 {
3732 char *packets, *tok;
3733
3734 packets = *next_arg += sizeof ("--disable-packet=") - 1;
3735 for (tok = strtok (packets, ",");
3736 tok != NULL;
3737 tok = strtok (NULL, ","))
3738 {
3739 if (strcmp ("vCont", tok) == 0)
3740 disable_packet_vCont = 1;
3741 else if (strcmp ("Tthread", tok) == 0)
3742 disable_packet_Tthread = 1;
3743 else if (strcmp ("qC", tok) == 0)
3744 disable_packet_qC = 1;
3745 else if (strcmp ("qfThreadInfo", tok) == 0)
3746 disable_packet_qfThreadInfo = 1;
3747 else if (strcmp ("threads", tok) == 0)
3748 {
3749 disable_packet_vCont = 1;
3750 disable_packet_Tthread = 1;
3751 disable_packet_qC = 1;
3752 disable_packet_qfThreadInfo = 1;
3753 }
3754 else
3755 {
3756 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
3757 tok);
3758 gdbserver_show_disableable (stderr);
3759 exit (1);
3760 }
3761 }
3762 }
3763 else if (strcmp (*next_arg, "-") == 0)
3764 {
3765 /* "-" specifies a stdio connection and is a form of port
3766 specification. */
3767 port = STDIO_CONNECTION_NAME;
3768 next_arg++;
3769 break;
3770 }
3771 else if (strcmp (*next_arg, "--disable-randomization") == 0)
3772 disable_randomization = 1;
3773 else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
3774 disable_randomization = 0;
3775 else if (strcmp (*next_arg, "--startup-with-shell") == 0)
3776 startup_with_shell = true;
3777 else if (strcmp (*next_arg, "--no-startup-with-shell") == 0)
3778 startup_with_shell = false;
3779 else if (strcmp (*next_arg, "--once") == 0)
3780 run_once = 1;
3781 else if (strcmp (*next_arg, "--selftest") == 0)
3782 selftest = true;
3783 else if (startswith (*next_arg, "--selftest="))
3784 {
3785 selftest = true;
3786 selftest_filter = *next_arg + strlen ("--selftest=");
3787 }
3788 else
3789 {
3790 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
3791 exit (1);
3792 }
3793
3794 next_arg++;
3795 continue;
3796 }
3797
3798 if (port == NULL)
3799 {
3800 port = *next_arg;
3801 next_arg++;
3802 }
3803 if ((port == NULL || (!attach && !multi_mode && *next_arg == NULL))
3804 && !selftest)
3805 {
3806 gdbserver_usage (stderr);
3807 exit (1);
3808 }
3809
3810 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3811 opened by remote_prepare. */
3812 notice_open_fds ();
3813
3814 save_original_signals_state ();
3815
3816 /* We need to know whether the remote connection is stdio before
3817 starting the inferior. Inferiors created in this scenario have
3818 stdin,stdout redirected. So do this here before we call
3819 start_inferior. */
3820 if (port != NULL)
3821 remote_prepare (port);
3822
3823 bad_attach = 0;
3824 pid = 0;
3825
3826 /* --attach used to come after PORT, so allow it there for
3827 compatibility. */
3828 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
3829 {
3830 attach = 1;
3831 next_arg++;
3832 }
3833
3834 if (attach
3835 && (*next_arg == NULL
3836 || (*next_arg)[0] == '\0'
3837 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
3838 || *arg_end != '\0'
3839 || next_arg[1] != NULL))
3840 bad_attach = 1;
3841
3842 if (bad_attach)
3843 {
3844 gdbserver_usage (stderr);
3845 exit (1);
3846 }
3847
3848 /* Gather information about the environment. */
3849 our_environ = gdb_environ::from_host_environ ();
3850
3851 initialize_async_io ();
3852 initialize_low ();
3853 have_job_control ();
3854 initialize_event_loop ();
3855 if (target_supports_tracepoints ())
3856 initialize_tracepoint ();
3857 initialize_notif ();
3858
3859 own_buf = (char *) xmalloc (PBUFSIZ + 1);
3860 mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
3861
3862 if (selftest)
3863 {
3864 selftests::run_tests (selftest_filter);
3865 throw_quit ("Quit");
3866 }
3867
3868 if (pid == 0 && *next_arg != NULL)
3869 {
3870 int i, n;
3871
3872 n = argc - (next_arg - argv);
3873 program_name = xstrdup (next_arg[0]);
3874 for (i = 1; i < n; i++)
3875 program_args.push_back (xstrdup (next_arg[i]));
3876 program_args.push_back (NULL);
3877
3878 /* Wait till we are at first instruction in program. */
3879 create_inferior (program_name, program_args);
3880
3881 /* We are now (hopefully) stopped at the first instruction of
3882 the target process. This assumes that the target process was
3883 successfully created. */
3884 }
3885 else if (pid != 0)
3886 {
3887 if (attach_inferior (pid) == -1)
3888 error ("Attaching not supported on this target");
3889
3890 /* Otherwise succeeded. */
3891 }
3892 else
3893 {
3894 last_status.kind = TARGET_WAITKIND_EXITED;
3895 last_status.value.integer = 0;
3896 last_ptid = minus_one_ptid;
3897 }
3898 make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
3899
3900 /* Don't report shared library events on the initial connection,
3901 even if some libraries are preloaded. Avoids the "stopped by
3902 shared library event" notice on gdb side. */
3903 dlls_changed = 0;
3904
3905 if (last_status.kind == TARGET_WAITKIND_EXITED
3906 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
3907 was_running = 0;
3908 else
3909 was_running = 1;
3910
3911 if (!was_running && !multi_mode)
3912 error ("No program to debug");
3913
3914 while (1)
3915 {
3916
3917 noack_mode = 0;
3918 multi_process = 0;
3919 report_fork_events = 0;
3920 report_vfork_events = 0;
3921 report_exec_events = 0;
3922 /* Be sure we're out of tfind mode. */
3923 current_traceframe = -1;
3924 cont_thread = null_ptid;
3925 swbreak_feature = 0;
3926 hwbreak_feature = 0;
3927 vCont_supported = 0;
3928
3929 remote_open (port);
3930
3931 TRY
3932 {
3933 /* Wait for events. This will return when all event sources
3934 are removed from the event loop. */
3935 start_event_loop ();
3936
3937 /* If an exit was requested (using the "monitor exit"
3938 command), terminate now. */
3939 if (exit_requested)
3940 throw_quit ("Quit");
3941
3942 /* The only other way to get here is for getpkt to fail:
3943
3944 - If --once was specified, we're done.
3945
3946 - If not in extended-remote mode, and we're no longer
3947 debugging anything, simply exit: GDB has disconnected
3948 after processing the last process exit.
3949
3950 - Otherwise, close the connection and reopen it at the
3951 top of the loop. */
3952 if (run_once || (!extended_protocol && !target_running ()))
3953 throw_quit ("Quit");
3954
3955 fprintf (stderr,
3956 "Remote side has terminated connection. "
3957 "GDBserver will reopen the connection.\n");
3958
3959 /* Get rid of any pending statuses. An eventual reconnection
3960 (by the same GDB instance or another) will refresh all its
3961 state from scratch. */
3962 discard_queued_stop_replies (minus_one_ptid);
3963 for_each_inferior (&all_threads,
3964 clear_pending_status_callback);
3965
3966 if (tracing)
3967 {
3968 if (disconnected_tracing)
3969 {
3970 /* Try to enable non-stop/async mode, so we we can
3971 both wait for an async socket accept, and handle
3972 async target events simultaneously. There's also
3973 no point either in having the target always stop
3974 all threads, when we're going to pass signals
3975 down without informing GDB. */
3976 if (!non_stop)
3977 {
3978 if (start_non_stop (1))
3979 non_stop = 1;
3980
3981 /* Detaching implicitly resumes all threads;
3982 simply disconnecting does not. */
3983 }
3984 }
3985 else
3986 {
3987 fprintf (stderr,
3988 "Disconnected tracing disabled; "
3989 "stopping trace run.\n");
3990 stop_tracing ();
3991 }
3992 }
3993 }
3994 CATCH (exception, RETURN_MASK_ERROR)
3995 {
3996 fflush (stdout);
3997 fprintf (stderr, "gdbserver: %s\n", exception.message);
3998
3999 if (response_needed)
4000 {
4001 write_enn (own_buf);
4002 putpkt (own_buf);
4003 }
4004
4005 if (run_once)
4006 throw_quit ("Quit");
4007 }
4008 END_CATCH
4009 }
4010 }
4011
4012 /* Main function. */
4013
4014 int
4015 main (int argc, char *argv[])
4016 {
4017
4018 TRY
4019 {
4020 captured_main (argc, argv);
4021 }
4022 CATCH (exception, RETURN_MASK_ALL)
4023 {
4024 if (exception.reason == RETURN_ERROR)
4025 {
4026 fflush (stdout);
4027 fprintf (stderr, "%s\n", exception.message);
4028 fprintf (stderr, "Exiting\n");
4029 exit_code = 1;
4030 }
4031
4032 exit (exit_code);
4033 }
4034 END_CATCH
4035
4036 gdb_assert_not_reached ("captured_main should never return");
4037 }
4038
4039 /* Process options coming from Z packets for a breakpoint. PACKET is
4040 the packet buffer. *PACKET is updated to point to the first char
4041 after the last processed option. */
4042
4043 static void
4044 process_point_options (struct gdb_breakpoint *bp, char **packet)
4045 {
4046 char *dataptr = *packet;
4047 int persist;
4048
4049 /* Check if data has the correct format. */
4050 if (*dataptr != ';')
4051 return;
4052
4053 dataptr++;
4054
4055 while (*dataptr)
4056 {
4057 if (*dataptr == ';')
4058 ++dataptr;
4059
4060 if (*dataptr == 'X')
4061 {
4062 /* Conditional expression. */
4063 if (debug_threads)
4064 debug_printf ("Found breakpoint condition.\n");
4065 if (!add_breakpoint_condition (bp, &dataptr))
4066 dataptr = strchrnul (dataptr, ';');
4067 }
4068 else if (startswith (dataptr, "cmds:"))
4069 {
4070 dataptr += strlen ("cmds:");
4071 if (debug_threads)
4072 debug_printf ("Found breakpoint commands %s.\n", dataptr);
4073 persist = (*dataptr == '1');
4074 dataptr += 2;
4075 if (add_breakpoint_commands (bp, &dataptr, persist))
4076 dataptr = strchrnul (dataptr, ';');
4077 }
4078 else
4079 {
4080 fprintf (stderr, "Unknown token %c, ignoring.\n",
4081 *dataptr);
4082 /* Skip tokens until we find one that we recognize. */
4083 dataptr = strchrnul (dataptr, ';');
4084 }
4085 }
4086 *packet = dataptr;
4087 }
4088
4089 /* Event loop callback that handles a serial event. The first byte in
4090 the serial buffer gets us here. We expect characters to arrive at
4091 a brisk pace, so we read the rest of the packet with a blocking
4092 getpkt call. */
4093
4094 static int
4095 process_serial_event (void)
4096 {
4097 int signal;
4098 unsigned int len;
4099 int res;
4100 CORE_ADDR mem_addr;
4101 unsigned char sig;
4102 int packet_len;
4103 int new_packet_len = -1;
4104
4105 disable_async_io ();
4106
4107 response_needed = 0;
4108 packet_len = getpkt (own_buf);
4109 if (packet_len <= 0)
4110 {
4111 remote_close ();
4112 /* Force an event loop break. */
4113 return -1;
4114 }
4115 response_needed = 1;
4116
4117 char ch = own_buf[0];
4118 switch (ch)
4119 {
4120 case 'q':
4121 handle_query (own_buf, packet_len, &new_packet_len);
4122 break;
4123 case 'Q':
4124 handle_general_set (own_buf);
4125 break;
4126 case 'D':
4127 handle_detach (own_buf);
4128 break;
4129 case '!':
4130 extended_protocol = 1;
4131 write_ok (own_buf);
4132 break;
4133 case '?':
4134 handle_status (own_buf);
4135 break;
4136 case 'H':
4137 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
4138 {
4139 require_running_or_break (own_buf);
4140
4141 ptid_t thread_id = read_ptid (&own_buf[2], NULL);
4142
4143 if (thread_id == null_ptid || thread_id == minus_one_ptid)
4144 thread_id = null_ptid;
4145 else if (thread_id.is_pid ())
4146 {
4147 /* The ptid represents a pid. */
4148 thread_info *thread = find_any_thread_of_pid (thread_id.pid ());
4149
4150 if (thread == NULL)
4151 {
4152 write_enn (own_buf);
4153 break;
4154 }
4155
4156 thread_id = thread->entry.id;
4157 }
4158 else
4159 {
4160 /* The ptid represents a lwp/tid. */
4161 if (find_thread_ptid (thread_id) == NULL)
4162 {
4163 write_enn (own_buf);
4164 break;
4165 }
4166 }
4167
4168 if (own_buf[1] == 'g')
4169 {
4170 if (ptid_equal (thread_id, null_ptid))
4171 {
4172 /* GDB is telling us to choose any thread. Check if
4173 the currently selected thread is still valid. If
4174 it is not, select the first available. */
4175 struct thread_info *thread =
4176 (struct thread_info *) find_inferior_id (&all_threads,
4177 general_thread);
4178 if (thread == NULL)
4179 thread = get_first_thread ();
4180 thread_id = thread->entry.id;
4181 }
4182
4183 general_thread = thread_id;
4184 set_desired_thread (1);
4185 gdb_assert (current_thread != NULL);
4186 }
4187 else if (own_buf[1] == 'c')
4188 cont_thread = thread_id;
4189
4190 write_ok (own_buf);
4191 }
4192 else
4193 {
4194 /* Silently ignore it so that gdb can extend the protocol
4195 without compatibility headaches. */
4196 own_buf[0] = '\0';
4197 }
4198 break;
4199 case 'g':
4200 require_running_or_break (own_buf);
4201 if (current_traceframe >= 0)
4202 {
4203 struct regcache *regcache
4204 = new_register_cache (current_target_desc ());
4205
4206 if (fetch_traceframe_registers (current_traceframe,
4207 regcache, -1) == 0)
4208 registers_to_string (regcache, own_buf);
4209 else
4210 write_enn (own_buf);
4211 free_register_cache (regcache);
4212 }
4213 else
4214 {
4215 struct regcache *regcache;
4216
4217 if (!set_desired_thread (1))
4218 write_enn (own_buf);
4219 else
4220 {
4221 regcache = get_thread_regcache (current_thread, 1);
4222 registers_to_string (regcache, own_buf);
4223 }
4224 }
4225 break;
4226 case 'G':
4227 require_running_or_break (own_buf);
4228 if (current_traceframe >= 0)
4229 write_enn (own_buf);
4230 else
4231 {
4232 struct regcache *regcache;
4233
4234 if (!set_desired_thread (1))
4235 write_enn (own_buf);
4236 else
4237 {
4238 regcache = get_thread_regcache (current_thread, 1);
4239 registers_from_string (regcache, &own_buf[1]);
4240 write_ok (own_buf);
4241 }
4242 }
4243 break;
4244 case 'm':
4245 require_running_or_break (own_buf);
4246 decode_m_packet (&own_buf[1], &mem_addr, &len);
4247 res = gdb_read_memory (mem_addr, mem_buf, len);
4248 if (res < 0)
4249 write_enn (own_buf);
4250 else
4251 bin2hex (mem_buf, own_buf, res);
4252 break;
4253 case 'M':
4254 require_running_or_break (own_buf);
4255 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
4256 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
4257 write_ok (own_buf);
4258 else
4259 write_enn (own_buf);
4260 break;
4261 case 'X':
4262 require_running_or_break (own_buf);
4263 if (decode_X_packet (&own_buf[1], packet_len - 1,
4264 &mem_addr, &len, &mem_buf) < 0
4265 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
4266 write_enn (own_buf);
4267 else
4268 write_ok (own_buf);
4269 break;
4270 case 'C':
4271 require_running_or_break (own_buf);
4272 hex2bin (own_buf + 1, &sig, 1);
4273 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4274 signal = gdb_signal_to_host ((enum gdb_signal) sig);
4275 else
4276 signal = 0;
4277 myresume (own_buf, 0, signal);
4278 break;
4279 case 'S':
4280 require_running_or_break (own_buf);
4281 hex2bin (own_buf + 1, &sig, 1);
4282 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4283 signal = gdb_signal_to_host ((enum gdb_signal) sig);
4284 else
4285 signal = 0;
4286 myresume (own_buf, 1, signal);
4287 break;
4288 case 'c':
4289 require_running_or_break (own_buf);
4290 signal = 0;
4291 myresume (own_buf, 0, signal);
4292 break;
4293 case 's':
4294 require_running_or_break (own_buf);
4295 signal = 0;
4296 myresume (own_buf, 1, signal);
4297 break;
4298 case 'Z': /* insert_ ... */
4299 /* Fallthrough. */
4300 case 'z': /* remove_ ... */
4301 {
4302 char *dataptr;
4303 ULONGEST addr;
4304 int kind;
4305 char type = own_buf[1];
4306 int res;
4307 const int insert = ch == 'Z';
4308 char *p = &own_buf[3];
4309
4310 p = unpack_varlen_hex (p, &addr);
4311 kind = strtol (p + 1, &dataptr, 16);
4312
4313 if (insert)
4314 {
4315 struct gdb_breakpoint *bp;
4316
4317 bp = set_gdb_breakpoint (type, addr, kind, &res);
4318 if (bp != NULL)
4319 {
4320 res = 0;
4321
4322 /* GDB may have sent us a list of *point parameters to
4323 be evaluated on the target's side. Read such list
4324 here. If we already have a list of parameters, GDB
4325 is telling us to drop that list and use this one
4326 instead. */
4327 clear_breakpoint_conditions_and_commands (bp);
4328 process_point_options (bp, &dataptr);
4329 }
4330 }
4331 else
4332 res = delete_gdb_breakpoint (type, addr, kind);
4333
4334 if (res == 0)
4335 write_ok (own_buf);
4336 else if (res == 1)
4337 /* Unsupported. */
4338 own_buf[0] = '\0';
4339 else
4340 write_enn (own_buf);
4341 break;
4342 }
4343 case 'k':
4344 response_needed = 0;
4345 if (!target_running ())
4346 /* The packet we received doesn't make sense - but we can't
4347 reply to it, either. */
4348 return 0;
4349
4350 fprintf (stderr, "Killing all inferiors\n");
4351 for_each_inferior (&all_processes, kill_inferior_callback);
4352
4353 /* When using the extended protocol, we wait with no program
4354 running. The traditional protocol will exit instead. */
4355 if (extended_protocol)
4356 {
4357 last_status.kind = TARGET_WAITKIND_EXITED;
4358 last_status.value.sig = GDB_SIGNAL_KILL;
4359 return 0;
4360 }
4361 else
4362 exit (0);
4363
4364 case 'T':
4365 {
4366 require_running_or_break (own_buf);
4367
4368 ptid_t thread_id = read_ptid (&own_buf[1], NULL);
4369 if (find_thread_ptid (thread_id) == NULL)
4370 {
4371 write_enn (own_buf);
4372 break;
4373 }
4374
4375 if (mythread_alive (thread_id))
4376 write_ok (own_buf);
4377 else
4378 write_enn (own_buf);
4379 }
4380 break;
4381 case 'R':
4382 response_needed = 0;
4383
4384 /* Restarting the inferior is only supported in the extended
4385 protocol. */
4386 if (extended_protocol)
4387 {
4388 if (target_running ())
4389 for_each_inferior (&all_processes,
4390 kill_inferior_callback);
4391 fprintf (stderr, "GDBserver restarting\n");
4392
4393 /* Wait till we are at 1st instruction in prog. */
4394 if (program_name != NULL)
4395 {
4396 create_inferior (program_name, program_args);
4397
4398 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4399 {
4400 /* Stopped at the first instruction of the target
4401 process. */
4402 general_thread = last_ptid;
4403 }
4404 else
4405 {
4406 /* Something went wrong. */
4407 general_thread = null_ptid;
4408 }
4409 }
4410 else
4411 {
4412 last_status.kind = TARGET_WAITKIND_EXITED;
4413 last_status.value.sig = GDB_SIGNAL_KILL;
4414 }
4415 return 0;
4416 }
4417 else
4418 {
4419 /* It is a request we don't understand. Respond with an
4420 empty packet so that gdb knows that we don't support this
4421 request. */
4422 own_buf[0] = '\0';
4423 break;
4424 }
4425 case 'v':
4426 /* Extended (long) request. */
4427 handle_v_requests (own_buf, packet_len, &new_packet_len);
4428 break;
4429
4430 default:
4431 /* It is a request we don't understand. Respond with an empty
4432 packet so that gdb knows that we don't support this
4433 request. */
4434 own_buf[0] = '\0';
4435 break;
4436 }
4437
4438 if (new_packet_len != -1)
4439 putpkt_binary (own_buf, new_packet_len);
4440 else
4441 putpkt (own_buf);
4442
4443 response_needed = 0;
4444
4445 if (exit_requested)
4446 return -1;
4447
4448 return 0;
4449 }
4450
4451 /* Event-loop callback for serial events. */
4452
4453 int
4454 handle_serial_event (int err, gdb_client_data client_data)
4455 {
4456 if (debug_threads)
4457 debug_printf ("handling possible serial event\n");
4458
4459 /* Really handle it. */
4460 if (process_serial_event () < 0)
4461 return -1;
4462
4463 /* Be sure to not change the selected thread behind GDB's back.
4464 Important in the non-stop mode asynchronous protocol. */
4465 set_desired_thread (1);
4466
4467 return 0;
4468 }
4469
4470 /* Push a stop notification on the notification queue. */
4471
4472 static void
4473 push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
4474 {
4475 struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
4476
4477 vstop_notif->status = *status;
4478 vstop_notif->ptid = ptid;
4479 /* Push Stop notification. */
4480 notif_push (&notif_stop, (struct notif_event *) vstop_notif);
4481 }
4482
4483 /* Event-loop callback for target events. */
4484
4485 int
4486 handle_target_event (int err, gdb_client_data client_data)
4487 {
4488 if (debug_threads)
4489 debug_printf ("handling possible target event\n");
4490
4491 last_ptid = mywait (minus_one_ptid, &last_status,
4492 TARGET_WNOHANG, 1);
4493
4494 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
4495 {
4496 if (gdb_connected () && report_no_resumed)
4497 push_stop_notification (null_ptid, &last_status);
4498 }
4499 else if (last_status.kind != TARGET_WAITKIND_IGNORE)
4500 {
4501 int pid = ptid_get_pid (last_ptid);
4502 struct process_info *process = find_process_pid (pid);
4503 int forward_event = !gdb_connected () || process->gdb_detached;
4504
4505 if (last_status.kind == TARGET_WAITKIND_EXITED
4506 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
4507 {
4508 mark_breakpoints_out (process);
4509 target_mourn_inferior (last_ptid);
4510 }
4511 else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4512 ;
4513 else
4514 {
4515 /* We're reporting this thread as stopped. Update its
4516 "want-stopped" state to what the client wants, until it
4517 gets a new resume action. */
4518 current_thread->last_resume_kind = resume_stop;
4519 current_thread->last_status = last_status;
4520 }
4521
4522 if (forward_event)
4523 {
4524 if (!target_running ())
4525 {
4526 /* The last process exited. We're done. */
4527 exit (0);
4528 }
4529
4530 if (last_status.kind == TARGET_WAITKIND_EXITED
4531 || last_status.kind == TARGET_WAITKIND_SIGNALLED
4532 || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4533 ;
4534 else
4535 {
4536 /* A thread stopped with a signal, but gdb isn't
4537 connected to handle it. Pass it down to the
4538 inferior, as if it wasn't being traced. */
4539 enum gdb_signal signal;
4540
4541 if (debug_threads)
4542 debug_printf ("GDB not connected; forwarding event %d for"
4543 " [%s]\n",
4544 (int) last_status.kind,
4545 target_pid_to_str (last_ptid));
4546
4547 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4548 signal = last_status.value.sig;
4549 else
4550 signal = GDB_SIGNAL_0;
4551 target_continue (last_ptid, signal);
4552 }
4553 }
4554 else
4555 push_stop_notification (last_ptid, &last_status);
4556 }
4557
4558 /* Be sure to not change the selected thread behind GDB's back.
4559 Important in the non-stop mode asynchronous protocol. */
4560 set_desired_thread (1);
4561
4562 return 0;
4563 }
4564
4565 #if GDB_SELF_TEST
4566 namespace selftests
4567 {
4568
4569 void
4570 reset ()
4571 {}
4572
4573 } // namespace selftests
4574 #endif /* GDB_SELF_TEST */
This page took 0.12735 seconds and 5 git commands to generate.