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