GDBserver

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