1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
20 #include "gdbthread.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
44 multi-process), or a specific thread ptid_t.
46 We also set this when handling a single-thread `vCont' resume, as
47 some places in the backends check it to know when (and for which
48 thread) single-thread scheduler-locking is in effect. */
51 /* The thread set with an `Hg' packet. */
52 ptid_t general_thread
;
56 static int extended_protocol
;
57 static int response_needed
;
58 static int exit_requested
;
60 /* --once: Exit after the first connection has closed. */
66 /* Whether we should attempt to disable the operating system's address
67 space randomization feature before starting an inferior. */
68 int disable_randomization
= 1;
70 static char **program_argv
, **wrapper_argv
;
72 /* Enable debugging of h/w breakpoint/watchpoint support. */
75 int pass_signals
[GDB_SIGNAL_LAST
];
76 int program_signals
[GDB_SIGNAL_LAST
];
77 int program_signals_p
;
81 /* The PID of the originally created or attached inferior. Used to
82 send signals to the process when GDB sends us an asynchronous interrupt
83 (user hitting Control-C in the client), and to wait for the child to exit
84 when no longer debugging it. */
86 unsigned long signal_pid
;
89 /* A file descriptor for the controlling terminal. */
92 /* TERMINAL_FD's original foreground group. */
93 pid_t old_foreground_pgrp
;
95 /* Hand back terminal ownership to the original foreground group. */
98 restore_old_foreground_pgrp (void)
100 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
104 /* Set if you want to disable optional thread related packets support
105 in gdbserver, for the sake of testing GDB against stubs that don't
107 int disable_packet_vCont
;
108 int disable_packet_Tthread
;
109 int disable_packet_qC
;
110 int disable_packet_qfThreadInfo
;
112 /* Last status reported to GDB. */
113 static struct target_waitstatus last_status
;
114 static ptid_t last_ptid
;
116 static char *own_buf
;
117 static unsigned char *mem_buf
;
119 /* A sub-class of 'struct notif_event' for stop, holding information
120 relative to a single stop reply. We keep a queue of these to
121 push to GDB in non-stop mode. */
125 struct notif_event base
;
127 /* Thread or process that got the event. */
131 struct target_waitstatus status
;
134 DEFINE_QUEUE_P (notif_event_p
);
136 /* Put a stop reply to the stop reply queue. */
139 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
141 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
143 new_notif
->ptid
= ptid
;
144 new_notif
->status
= *status
;
146 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
150 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
151 QUEUE_ITER (notif_event_p
) *iter
,
152 struct notif_event
*event
,
158 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
160 if (q
->free_func
!= NULL
)
161 q
->free_func (event
);
163 QUEUE_remove_elem (notif_event_p
, q
, iter
);
169 /* Get rid of the currently pending stop replies for PID. If PID is
170 -1, then apply to all processes. */
173 discard_queued_stop_replies (int pid
)
175 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
176 remove_all_on_match_pid
, &pid
);
180 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
182 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
184 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
187 struct notif_server notif_stop
=
189 "vStopped", "Stop", NULL
, vstop_notif_reply
,
193 target_running (void)
195 return get_first_thread () != NULL
;
199 start_inferior (char **argv
)
201 char **new_argv
= argv
;
203 if (wrapper_argv
!= NULL
)
207 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
209 for (i
= 0; argv
[i
] != NULL
; i
++)
211 new_argv
= alloca (sizeof (char *) * count
);
213 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
214 new_argv
[count
++] = wrapper_argv
[i
];
215 for (i
= 0; argv
[i
] != NULL
; i
++)
216 new_argv
[count
++] = argv
[i
];
217 new_argv
[count
] = NULL
;
223 for (i
= 0; new_argv
[i
]; ++i
)
224 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
229 signal (SIGTTOU
, SIG_DFL
);
230 signal (SIGTTIN
, SIG_DFL
);
233 /* Clear this so the backend doesn't get confused, thinking
234 CONT_THREAD died, and it needs to resume all threads. */
235 cont_thread
= null_ptid
;
237 signal_pid
= create_inferior (new_argv
[0], new_argv
);
239 /* FIXME: we don't actually know at this point that the create
240 actually succeeded. We won't know that until we wait. */
241 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
246 signal (SIGTTOU
, SIG_IGN
);
247 signal (SIGTTIN
, SIG_IGN
);
248 terminal_fd
= fileno (stderr
);
249 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
250 tcsetpgrp (terminal_fd
, signal_pid
);
251 atexit (restore_old_foreground_pgrp
);
254 if (wrapper_argv
!= NULL
)
256 struct thread_resume resume_info
;
258 memset (&resume_info
, 0, sizeof (resume_info
));
259 resume_info
.thread
= pid_to_ptid (signal_pid
);
260 resume_info
.kind
= resume_continue
;
263 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
265 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
270 (*the_target
->resume
) (&resume_info
, 1);
272 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
273 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
276 current_inferior
->last_resume_kind
= resume_stop
;
277 current_inferior
->last_status
= last_status
;
279 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
284 /* Wait till we are at 1st instruction in program, return new pid
285 (assuming success). */
286 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
288 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
289 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
291 current_inferior
->last_resume_kind
= resume_stop
;
292 current_inferior
->last_status
= last_status
;
299 attach_inferior (int pid
)
301 /* myattach should return -1 if attaching is unsupported,
302 0 if it succeeded, and call error() otherwise. */
304 if (myattach (pid
) != 0)
307 fprintf (stderr
, "Attached; pid = %d\n", pid
);
310 /* FIXME - It may be that we should get the SIGNAL_PID from the
311 attach function, so that it can be the main thread instead of
312 whichever we were told to attach to. */
315 /* Clear this so the backend doesn't get confused, thinking
316 CONT_THREAD died, and it needs to resume all threads. */
317 cont_thread
= null_ptid
;
321 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
323 /* GDB knows to ignore the first SIGSTOP after attaching to a running
324 process using the "attach" command, but this is different; it's
325 just using "target remote". Pretend it's just starting up. */
326 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
327 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
328 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
330 current_inferior
->last_resume_kind
= resume_stop
;
331 current_inferior
->last_status
= last_status
;
337 extern int remote_debug
;
339 /* Decode a qXfer read request. Return 0 if everything looks OK,
343 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
345 /* After the read marker and annex, qXfer looks like a
346 traditional 'm' packet. */
347 decode_m_packet (buf
, ofs
, len
);
353 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
355 /* Extract and NUL-terminate the object. */
357 while (*buf
&& *buf
!= ':')
363 /* Extract and NUL-terminate the read/write action. */
365 while (*buf
&& *buf
!= ':')
371 /* Extract and NUL-terminate the annex. */
373 while (*buf
&& *buf
!= ':')
383 /* Write the response to a successful qXfer read. Returns the
384 length of the (binary) data stored in BUF, corresponding
385 to as much of DATA/LEN as we could fit. IS_MORE controls
386 the first character of the response. */
388 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
397 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
401 /* Handle btrace enabling. */
404 handle_btrace_enable (struct thread_info
*thread
)
406 if (thread
->btrace
!= NULL
)
407 return "E.Btrace already enabled.";
409 thread
->btrace
= target_enable_btrace (thread
->entry
.id
);
410 if (thread
->btrace
== NULL
)
411 return "E.Could not enable btrace.";
416 /* Handle btrace disabling. */
419 handle_btrace_disable (struct thread_info
*thread
)
422 if (thread
->btrace
== NULL
)
423 return "E.Branch tracing not enabled.";
425 if (target_disable_btrace (thread
->btrace
) != 0)
426 return "E.Could not disable branch tracing.";
428 thread
->btrace
= NULL
;
432 /* Handle the "Qbtrace" packet. */
435 handle_btrace_general_set (char *own_buf
)
437 struct thread_info
*thread
;
441 if (strncmp ("Qbtrace:", own_buf
, strlen ("Qbtrace:")) != 0)
444 op
= own_buf
+ strlen ("Qbtrace:");
446 if (!target_supports_btrace ())
448 strcpy (own_buf
, "E.Target does not support branch tracing.");
452 if (ptid_equal (general_thread
, null_ptid
)
453 || ptid_equal (general_thread
, minus_one_ptid
))
455 strcpy (own_buf
, "E.Must select a single thread.");
459 thread
= find_thread_ptid (general_thread
);
462 strcpy (own_buf
, "E.No such thread.");
468 if (strcmp (op
, "bts") == 0)
469 err
= handle_btrace_enable (thread
);
470 else if (strcmp (op
, "off") == 0)
471 err
= handle_btrace_disable (thread
);
473 err
= "E.Bad Qbtrace operation. Use bts or off.";
476 strcpy (own_buf
, err
);
483 /* Handle all of the extended 'Q' packets. */
486 handle_general_set (char *own_buf
)
488 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
490 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
491 const char *p
= own_buf
+ strlen ("QPassSignals:");
494 p
= decode_address_to_semicolon (&cursig
, p
);
495 for (i
= 0; i
< numsigs
; i
++)
501 /* Keep looping, to clear the remaining signals. */
504 p
= decode_address_to_semicolon (&cursig
, p
);
509 strcpy (own_buf
, "OK");
513 if (strncmp ("QProgramSignals:", own_buf
, strlen ("QProgramSignals:")) == 0)
515 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
516 const char *p
= own_buf
+ strlen ("QProgramSignals:");
519 program_signals_p
= 1;
521 p
= decode_address_to_semicolon (&cursig
, p
);
522 for (i
= 0; i
< numsigs
; i
++)
526 program_signals
[i
] = 1;
528 /* Keep looping, to clear the remaining signals. */
531 p
= decode_address_to_semicolon (&cursig
, p
);
534 program_signals
[i
] = 0;
536 strcpy (own_buf
, "OK");
540 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
544 fprintf (stderr
, "[noack mode enabled]\n");
553 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
555 char *mode
= own_buf
+ 9;
559 if (strcmp (mode
, "0") == 0)
561 else if (strcmp (mode
, "1") == 0)
565 /* We don't know what this mode is, so complain to
567 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
573 req_str
= req
? "non-stop" : "all-stop";
574 if (start_non_stop (req
) != 0)
576 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
584 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
590 if (strncmp ("QDisableRandomization:", own_buf
,
591 strlen ("QDisableRandomization:")) == 0)
593 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
596 unpack_varlen_hex (packet
, &setting
);
597 disable_randomization
= setting
;
601 if (disable_randomization
)
602 fprintf (stderr
, "[address space randomization disabled]\n");
604 fprintf (stderr
, "[address space randomization enabled]\n");
611 if (target_supports_tracepoints ()
612 && handle_tracepoint_general_set (own_buf
))
615 if (strncmp ("QAgent:", own_buf
, strlen ("QAgent:")) == 0)
617 char *mode
= own_buf
+ strlen ("QAgent:");
620 if (strcmp (mode
, "0") == 0)
622 else if (strcmp (mode
, "1") == 0)
626 /* We don't know what this value is, so complain to GDB. */
627 sprintf (own_buf
, "E.Unknown QAgent value");
631 /* Update the flag. */
634 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
639 if (handle_btrace_general_set (own_buf
))
642 /* Otherwise we didn't know what packet it was. Say we didn't
648 get_features_xml (const char *annex
)
650 const struct target_desc
*desc
= current_target_desc ();
652 /* `desc->xmltarget' defines what to return when looking for the
653 "target.xml" file. Its contents can either be verbatim XML code
654 (prefixed with a '@') or else the name of the actual XML file to
655 be used in place of "target.xml".
657 This variable is set up from the auto-generated
658 init_registers_... routine for the current target. */
660 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
662 if (*desc
->xmltarget
== '@')
663 return desc
->xmltarget
+ 1;
665 annex
= desc
->xmltarget
;
670 extern const char *const xml_builtin
[][2];
673 /* Look for the annex. */
674 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
675 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
678 if (xml_builtin
[i
][0] != NULL
)
679 return xml_builtin
[i
][1];
687 monitor_show_help (void)
689 monitor_output ("The following monitor commands are supported:\n");
690 monitor_output (" set debug <0|1>\n");
691 monitor_output (" Enable general debugging messages\n");
692 monitor_output (" set debug-hw-points <0|1>\n");
693 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
694 monitor_output (" set remote-debug <0|1>\n");
695 monitor_output (" Enable remote protocol debugging messages\n");
696 monitor_output (" set debug-format option1[,option2,...]\n");
697 monitor_output (" Add additional information to debugging messages\n");
698 monitor_output (" Options: all, none");
699 monitor_output (", timestamp");
700 monitor_output ("\n");
701 monitor_output (" exit\n");
702 monitor_output (" Quit GDBserver\n");
705 /* Read trace frame or inferior memory. Returns the number of bytes
706 actually read, zero when no further transfer is possible, and -1 on
707 error. Return of a positive value smaller than LEN does not
708 indicate there's no more to be read, only the end of the transfer.
709 E.g., when GDB reads memory from a traceframe, a first request may
710 be served from a memory block that does not cover the whole request
711 length. A following request gets the rest served from either
712 another block (of the same traceframe) or from the read-only
716 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
720 if (current_traceframe
>= 0)
723 ULONGEST length
= len
;
725 if (traceframe_read_mem (current_traceframe
,
726 memaddr
, myaddr
, len
, &nbytes
))
728 /* Data read from trace buffer, we're done. */
731 if (!in_readonly_region (memaddr
, length
))
733 /* Otherwise we have a valid readonly case, fall through. */
734 /* (assume no half-trace half-real blocks for now) */
737 res
= prepare_to_access_memory ();
740 res
= read_inferior_memory (memaddr
, myaddr
, len
);
741 done_accessing_memory ();
743 return res
== 0 ? len
: -1;
749 /* Write trace frame or inferior memory. Actually, writing to trace
750 frames is forbidden. */
753 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
755 if (current_traceframe
>= 0)
761 ret
= prepare_to_access_memory ();
764 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
765 done_accessing_memory ();
771 /* Subroutine of handle_search_memory to simplify it. */
774 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
775 gdb_byte
*pattern
, unsigned pattern_len
,
776 gdb_byte
*search_buf
,
777 unsigned chunk_size
, unsigned search_buf_size
,
778 CORE_ADDR
*found_addrp
)
780 /* Prime the search buffer. */
782 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
785 warning ("Unable to access %ld bytes of target "
786 "memory at 0x%lx, halting search.",
787 (long) search_buf_size
, (long) start_addr
);
791 /* Perform the search.
793 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
794 When we've scanned N bytes we copy the trailing bytes to the start and
795 read in another N bytes. */
797 while (search_space_len
>= pattern_len
)
800 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
804 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
806 if (found_ptr
!= NULL
)
808 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
809 *found_addrp
= found_addr
;
813 /* Not found in this chunk, skip to next chunk. */
815 /* Don't let search_space_len wrap here, it's unsigned. */
816 if (search_space_len
>= chunk_size
)
817 search_space_len
-= chunk_size
;
819 search_space_len
= 0;
821 if (search_space_len
>= pattern_len
)
823 unsigned keep_len
= search_buf_size
- chunk_size
;
824 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
827 /* Copy the trailing part of the previous iteration to the front
828 of the buffer for the next iteration. */
829 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
831 nr_to_read
= (search_space_len
- keep_len
< chunk_size
832 ? search_space_len
- keep_len
835 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
836 nr_to_read
) != search_buf_size
)
838 warning ("Unable to access %ld bytes of target memory "
839 "at 0x%lx, halting search.",
840 (long) nr_to_read
, (long) read_addr
);
844 start_addr
+= chunk_size
;
853 /* Handle qSearch:memory packets. */
856 handle_search_memory (char *own_buf
, int packet_len
)
858 CORE_ADDR start_addr
;
859 CORE_ADDR search_space_len
;
861 unsigned int pattern_len
;
862 /* NOTE: also defined in find.c testcase. */
863 #define SEARCH_CHUNK_SIZE 16000
864 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
865 /* Buffer to hold memory contents for searching. */
866 gdb_byte
*search_buf
;
867 unsigned search_buf_size
;
869 CORE_ADDR found_addr
;
870 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
872 pattern
= malloc (packet_len
);
875 error ("Unable to allocate memory to perform the search");
876 strcpy (own_buf
, "E00");
879 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
880 packet_len
- cmd_name_len
,
881 &start_addr
, &search_space_len
,
882 pattern
, &pattern_len
) < 0)
885 error ("Error in parsing qSearch:memory packet");
886 strcpy (own_buf
, "E00");
890 search_buf_size
= chunk_size
+ pattern_len
- 1;
892 /* No point in trying to allocate a buffer larger than the search space. */
893 if (search_space_len
< search_buf_size
)
894 search_buf_size
= search_space_len
;
896 search_buf
= malloc (search_buf_size
);
897 if (search_buf
== NULL
)
900 error ("Unable to allocate memory to perform the search");
901 strcpy (own_buf
, "E00");
905 found
= handle_search_memory_1 (start_addr
, search_space_len
,
906 pattern
, pattern_len
,
907 search_buf
, chunk_size
, search_buf_size
,
911 sprintf (own_buf
, "1,%lx", (long) found_addr
);
913 strcpy (own_buf
, "0");
915 strcpy (own_buf
, "E00");
921 #define require_running(BUF) \
922 if (!target_running ()) \
928 /* Parse options to --debug-format= and "monitor set debug-format".
929 ARG is the text after "--debug-format=" or "monitor set debug-format".
930 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
931 This triggers calls to monitor_output.
932 The result is NULL if all options were parsed ok, otherwise an error
933 message which the caller must free.
935 N.B. These commands affect all debug format settings, they are not
936 cumulative. If a format is not specified, it is turned off.
937 However, we don't go to extra trouble with things like
938 "monitor set debug-format all,none,timestamp".
939 Instead we just parse them one at a time, in order.
941 The syntax for "monitor set debug" we support here is not identical
942 to gdb's "set debug foo on|off" because we also use this function to
943 parse "--debug-format=foo,bar". */
946 parse_debug_format_options (const char *arg
, int is_monitor
)
948 VEC (char_ptr
) *options
;
952 /* First turn all debug format options off. */
955 /* First remove leading spaces, for "monitor set debug-format". */
956 while (isspace (*arg
))
959 options
= delim_string_to_char_ptr_vec (arg
, ',');
961 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
963 if (strcmp (option
, "all") == 0)
967 monitor_output ("All extra debug format options enabled.\n");
969 else if (strcmp (option
, "none") == 0)
973 monitor_output ("All extra debug format options disabled.\n");
975 else if (strcmp (option
, "timestamp") == 0)
979 monitor_output ("Timestamps will be added to debug output.\n");
981 else if (*option
== '\0')
983 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
988 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
991 free_char_ptr_vec (options
);
996 free_char_ptr_vec (options
);
1000 /* Handle monitor commands not handled by target-specific handlers. */
1003 handle_monitor_command (char *mon
, char *own_buf
)
1005 if (strcmp (mon
, "set debug 1") == 0)
1008 monitor_output ("Debug output enabled.\n");
1010 else if (strcmp (mon
, "set debug 0") == 0)
1013 monitor_output ("Debug output disabled.\n");
1015 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1017 debug_hw_points
= 1;
1018 monitor_output ("H/W point debugging output enabled.\n");
1020 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1022 debug_hw_points
= 0;
1023 monitor_output ("H/W point debugging output disabled.\n");
1025 else if (strcmp (mon
, "set remote-debug 1") == 0)
1028 monitor_output ("Protocol debug output enabled.\n");
1030 else if (strcmp (mon
, "set remote-debug 0") == 0)
1033 monitor_output ("Protocol debug output disabled.\n");
1035 else if (strncmp (mon
, "set debug-format ",
1036 sizeof ("set debug-format ") - 1) == 0)
1039 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1042 if (error_msg
!= NULL
)
1044 monitor_output (error_msg
);
1045 monitor_show_help ();
1046 write_enn (own_buf
);
1050 else if (strcmp (mon
, "help") == 0)
1051 monitor_show_help ();
1052 else if (strcmp (mon
, "exit") == 0)
1056 monitor_output ("Unknown monitor command.\n\n");
1057 monitor_show_help ();
1058 write_enn (own_buf
);
1062 /* Associates a callback with each supported qXfer'able object. */
1066 /* The object this handler handles. */
1069 /* Request that the target transfer up to LEN 8-bit bytes of the
1070 target's OBJECT. The OFFSET, for a seekable object, specifies
1071 the starting point. The ANNEX can be used to provide additional
1072 data-specific information to the target.
1074 Return the number of bytes actually transfered, zero when no
1075 further transfer is possible, -1 on error, -2 when the transfer
1076 is not supported, and -3 on a verbose error message that should
1077 be preserved. Return of a positive value smaller than LEN does
1078 not indicate the end of the object, only the end of the transfer.
1080 One, and only one, of readbuf or writebuf must be non-NULL. */
1081 int (*xfer
) (const char *annex
,
1082 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1083 ULONGEST offset
, LONGEST len
);
1086 /* Handle qXfer:auxv:read. */
1089 handle_qxfer_auxv (const char *annex
,
1090 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1091 ULONGEST offset
, LONGEST len
)
1093 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1096 if (annex
[0] != '\0' || !target_running ())
1099 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1102 /* Handle qXfer:features:read. */
1105 handle_qxfer_features (const char *annex
,
1106 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1107 ULONGEST offset
, LONGEST len
)
1109 const char *document
;
1112 if (writebuf
!= NULL
)
1115 if (!target_running ())
1118 /* Grab the correct annex. */
1119 document
= get_features_xml (annex
);
1120 if (document
== NULL
)
1123 total_len
= strlen (document
);
1125 if (offset
> total_len
)
1128 if (offset
+ len
> total_len
)
1129 len
= total_len
- offset
;
1131 memcpy (readbuf
, document
+ offset
, len
);
1135 /* Worker routine for handle_qxfer_libraries.
1136 Add to the length pointed to by ARG a conservative estimate of the
1137 length needed to transmit the file name of INF. */
1140 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1142 struct dll_info
*dll
= (struct dll_info
*) inf
;
1143 unsigned int *total_len
= arg
;
1145 /* Over-estimate the necessary memory. Assume that every character
1146 in the library name must be escaped. */
1147 *total_len
+= 128 + 6 * strlen (dll
->name
);
1150 /* Worker routine for handle_qxfer_libraries.
1151 Emit the XML to describe the library in INF. */
1154 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1156 struct dll_info
*dll
= (struct dll_info
*) inf
;
1161 strcpy (p
, " <library name=\"");
1163 name
= xml_escape_text (dll
->name
);
1167 strcpy (p
, "\"><segment address=\"");
1169 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1171 strcpy (p
, "\"/></library>\n");
1177 /* Handle qXfer:libraries:read. */
1180 handle_qxfer_libraries (const char *annex
,
1181 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1182 ULONGEST offset
, LONGEST len
)
1184 unsigned int total_len
;
1187 if (writebuf
!= NULL
)
1190 if (annex
[0] != '\0' || !target_running ())
1194 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1197 document
= malloc (total_len
);
1198 if (document
== NULL
)
1201 strcpy (document
, "<library-list>\n");
1202 p
= document
+ strlen (document
);
1204 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1206 strcpy (p
, "</library-list>\n");
1208 total_len
= strlen (document
);
1210 if (offset
> total_len
)
1216 if (offset
+ len
> total_len
)
1217 len
= total_len
- offset
;
1219 memcpy (readbuf
, document
+ offset
, len
);
1224 /* Handle qXfer:libraries-svr4:read. */
1227 handle_qxfer_libraries_svr4 (const char *annex
,
1228 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1229 ULONGEST offset
, LONGEST len
)
1231 if (writebuf
!= NULL
)
1234 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1237 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1240 /* Handle qXfer:osadata:read. */
1243 handle_qxfer_osdata (const char *annex
,
1244 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1245 ULONGEST offset
, LONGEST len
)
1247 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1250 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1253 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1256 handle_qxfer_siginfo (const char *annex
,
1257 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1258 ULONGEST offset
, LONGEST len
)
1260 if (the_target
->qxfer_siginfo
== NULL
)
1263 if (annex
[0] != '\0' || !target_running ())
1266 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1269 /* Handle qXfer:spu:read and qXfer:spu:write. */
1272 handle_qxfer_spu (const char *annex
,
1273 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1274 ULONGEST offset
, LONGEST len
)
1276 if (the_target
->qxfer_spu
== NULL
)
1279 if (!target_running ())
1282 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1285 /* Handle qXfer:statictrace:read. */
1288 handle_qxfer_statictrace (const char *annex
,
1289 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1290 ULONGEST offset
, LONGEST len
)
1294 if (writebuf
!= NULL
)
1297 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1300 if (traceframe_read_sdata (current_traceframe
, offset
,
1301 readbuf
, len
, &nbytes
))
1306 /* Helper for handle_qxfer_threads_proper.
1307 Emit the XML to describe the thread of INF. */
1310 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1312 struct thread_info
*thread
= (struct thread_info
*) inf
;
1313 struct buffer
*buffer
= arg
;
1314 ptid_t ptid
= thread_to_gdb_id (thread
);
1316 int core
= target_core_of_thread (ptid
);
1319 write_ptid (ptid_s
, ptid
);
1323 sprintf (core_s
, "%d", core
);
1324 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1329 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1334 /* Helper for handle_qxfer_threads. */
1337 handle_qxfer_threads_proper (struct buffer
*buffer
)
1339 buffer_grow_str (buffer
, "<threads>\n");
1341 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1344 buffer_grow_str0 (buffer
, "</threads>\n");
1347 /* Handle qXfer:threads:read. */
1350 handle_qxfer_threads (const char *annex
,
1351 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1352 ULONGEST offset
, LONGEST len
)
1354 static char *result
= 0;
1355 static unsigned int result_length
= 0;
1357 if (writebuf
!= NULL
)
1360 if (!target_running () || annex
[0] != '\0')
1365 struct buffer buffer
;
1366 /* When asked for data at offset 0, generate everything and store into
1367 'result'. Successive reads will be served off 'result'. */
1371 buffer_init (&buffer
);
1373 handle_qxfer_threads_proper (&buffer
);
1375 result
= buffer_finish (&buffer
);
1376 result_length
= strlen (result
);
1377 buffer_free (&buffer
);
1380 if (offset
>= result_length
)
1382 /* We're out of data. */
1389 if (len
> result_length
- offset
)
1390 len
= result_length
- offset
;
1392 memcpy (readbuf
, result
+ offset
, len
);
1397 /* Handle qXfer:traceframe-info:read. */
1400 handle_qxfer_traceframe_info (const char *annex
,
1401 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1402 ULONGEST offset
, LONGEST len
)
1404 static char *result
= 0;
1405 static unsigned int result_length
= 0;
1407 if (writebuf
!= NULL
)
1410 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1415 struct buffer buffer
;
1417 /* When asked for data at offset 0, generate everything and
1418 store into 'result'. Successive reads will be served off
1422 buffer_init (&buffer
);
1424 traceframe_read_info (current_traceframe
, &buffer
);
1426 result
= buffer_finish (&buffer
);
1427 result_length
= strlen (result
);
1428 buffer_free (&buffer
);
1431 if (offset
>= result_length
)
1433 /* We're out of data. */
1440 if (len
> result_length
- offset
)
1441 len
= result_length
- offset
;
1443 memcpy (readbuf
, result
+ offset
, len
);
1447 /* Handle qXfer:fdpic:read. */
1450 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1451 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1453 if (the_target
->read_loadmap
== NULL
)
1456 if (!target_running ())
1459 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1462 /* Handle qXfer:btrace:read. */
1465 handle_qxfer_btrace (const char *annex
,
1466 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1467 ULONGEST offset
, LONGEST len
)
1469 static struct buffer cache
;
1470 struct thread_info
*thread
;
1473 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1476 if (!target_running ())
1479 if (ptid_equal (general_thread
, null_ptid
)
1480 || ptid_equal (general_thread
, minus_one_ptid
))
1482 strcpy (own_buf
, "E.Must select a single thread.");
1486 thread
= find_thread_ptid (general_thread
);
1489 strcpy (own_buf
, "E.No such thread.");
1493 if (thread
->btrace
== NULL
)
1495 strcpy (own_buf
, "E.Btrace not enabled.");
1499 if (strcmp (annex
, "all") == 0)
1500 type
= BTRACE_READ_ALL
;
1501 else if (strcmp (annex
, "new") == 0)
1502 type
= BTRACE_READ_NEW
;
1503 else if (strcmp (annex
, "delta") == 0)
1504 type
= BTRACE_READ_DELTA
;
1507 strcpy (own_buf
, "E.Bad annex.");
1513 buffer_free (&cache
);
1515 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1518 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1522 else if (offset
> cache
.used_size
)
1524 buffer_free (&cache
);
1528 if (len
> cache
.used_size
- offset
)
1529 len
= cache
.used_size
- offset
;
1531 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1536 static const struct qxfer qxfer_packets
[] =
1538 { "auxv", handle_qxfer_auxv
},
1539 { "btrace", handle_qxfer_btrace
},
1540 { "fdpic", handle_qxfer_fdpic
},
1541 { "features", handle_qxfer_features
},
1542 { "libraries", handle_qxfer_libraries
},
1543 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1544 { "osdata", handle_qxfer_osdata
},
1545 { "siginfo", handle_qxfer_siginfo
},
1546 { "spu", handle_qxfer_spu
},
1547 { "statictrace", handle_qxfer_statictrace
},
1548 { "threads", handle_qxfer_threads
},
1549 { "traceframe-info", handle_qxfer_traceframe_info
},
1553 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1561 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1564 /* Grab the object, r/w and annex. */
1565 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1567 write_enn (own_buf
);
1572 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1575 const struct qxfer
*q
= &qxfer_packets
[i
];
1577 if (strcmp (object
, q
->object
) == 0)
1579 if (strcmp (rw
, "read") == 0)
1581 unsigned char *data
;
1586 /* Grab the offset and length. */
1587 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1589 write_enn (own_buf
);
1593 /* Read one extra byte, as an indicator of whether there is
1595 if (len
> PBUFSIZ
- 2)
1597 data
= malloc (len
+ 1);
1600 write_enn (own_buf
);
1603 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1611 /* Preserve error message. */
1614 write_enn (own_buf
);
1616 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1618 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1623 else if (strcmp (rw
, "write") == 0)
1628 unsigned char *data
;
1630 strcpy (own_buf
, "E00");
1631 data
= malloc (packet_len
- (offset
- own_buf
));
1634 write_enn (own_buf
);
1637 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1638 &ofs
, &len
, data
) < 0)
1641 write_enn (own_buf
);
1645 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1653 /* Preserve error message. */
1656 write_enn (own_buf
);
1658 sprintf (own_buf
, "%x", n
);
1671 /* Table used by the crc32 function to calcuate the checksum. */
1673 static unsigned int crc32_table
[256] =
1676 /* Compute 32 bit CRC from inferior memory.
1678 On success, return 32 bit CRC.
1679 On failure, return (unsigned long long) -1. */
1681 static unsigned long long
1682 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1684 if (!crc32_table
[1])
1686 /* Initialize the CRC table and the decoding table. */
1690 for (i
= 0; i
< 256; i
++)
1692 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1693 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1700 unsigned char byte
= 0;
1702 /* Return failure if memory read fails. */
1703 if (read_inferior_memory (base
, &byte
, 1) != 0)
1704 return (unsigned long long) -1;
1706 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1709 return (unsigned long long) crc
;
1712 /* Handle all of the extended 'q' packets. */
1715 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1717 static struct inferior_list_entry
*thread_ptr
;
1719 /* Reply the current thread id. */
1720 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1723 require_running (own_buf
);
1725 if (!ptid_equal (general_thread
, null_ptid
)
1726 && !ptid_equal (general_thread
, minus_one_ptid
))
1727 gdb_id
= general_thread
;
1730 thread_ptr
= get_first_inferior (&all_threads
);
1731 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1734 sprintf (own_buf
, "QC");
1736 write_ptid (own_buf
, gdb_id
);
1740 if (strcmp ("qSymbol::", own_buf
) == 0)
1742 /* GDB is suggesting new symbols have been loaded. This may
1743 mean a new shared library has been detected as loaded, so
1744 take the opportunity to check if breakpoints we think are
1745 inserted, still are. Note that it isn't guaranteed that
1746 we'll see this when a shared library is loaded, and nor will
1747 we see this for unloads (although breakpoints in unloaded
1748 libraries shouldn't trigger), as GDB may not find symbols for
1749 the library at all. We also re-validate breakpoints when we
1750 see a second GDB breakpoint for the same address, and or when
1751 we access breakpoint shadows. */
1752 validate_breakpoints ();
1754 if (target_supports_tracepoints ())
1755 tracepoint_look_up_symbols ();
1757 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1758 (*the_target
->look_up_symbols
) ();
1760 strcpy (own_buf
, "OK");
1764 if (!disable_packet_qfThreadInfo
)
1766 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1770 require_running (own_buf
);
1771 thread_ptr
= get_first_inferior (&all_threads
);
1774 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1775 write_ptid (own_buf
, gdb_id
);
1776 thread_ptr
= thread_ptr
->next
;
1780 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1784 require_running (own_buf
);
1785 if (thread_ptr
!= NULL
)
1788 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1789 write_ptid (own_buf
, gdb_id
);
1790 thread_ptr
= thread_ptr
->next
;
1795 sprintf (own_buf
, "l");
1801 if (the_target
->read_offsets
!= NULL
1802 && strcmp ("qOffsets", own_buf
) == 0)
1804 CORE_ADDR text
, data
;
1806 require_running (own_buf
);
1807 if (the_target
->read_offsets (&text
, &data
))
1808 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1809 (long)text
, (long)data
, (long)data
);
1811 write_enn (own_buf
);
1816 /* Protocol features query. */
1817 if (strncmp ("qSupported", own_buf
, 10) == 0
1818 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1820 char *p
= &own_buf
[10];
1821 int gdb_supports_qRelocInsn
= 0;
1823 /* Start processing qSupported packet. */
1824 target_process_qsupported (NULL
);
1826 /* Process each feature being provided by GDB. The first
1827 feature will follow a ':', and latter features will follow
1831 char **qsupported
= NULL
;
1835 /* Two passes, to avoid nested strtok calls in
1836 target_process_qsupported. */
1837 for (p
= strtok (p
+ 1, ";");
1839 p
= strtok (NULL
, ";"))
1842 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1843 qsupported
[count
- 1] = xstrdup (p
);
1846 for (i
= 0; i
< count
; i
++)
1849 if (strcmp (p
, "multiprocess+") == 0)
1851 /* GDB supports and wants multi-process support if
1853 if (target_supports_multi_process ())
1856 else if (strcmp (p
, "qRelocInsn+") == 0)
1858 /* GDB supports relocate instruction requests. */
1859 gdb_supports_qRelocInsn
= 1;
1862 target_process_qsupported (p
);
1871 "PacketSize=%x;QPassSignals+;QProgramSignals+",
1874 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1875 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
1876 ";augmented-libraries-svr4-read+");
1879 /* We do not have any hook to indicate whether the non-SVR4 target
1880 backend supports qXfer:libraries:read, so always report it. */
1881 strcat (own_buf
, ";qXfer:libraries:read+");
1884 if (the_target
->read_auxv
!= NULL
)
1885 strcat (own_buf
, ";qXfer:auxv:read+");
1887 if (the_target
->qxfer_spu
!= NULL
)
1888 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1890 if (the_target
->qxfer_siginfo
!= NULL
)
1891 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1893 if (the_target
->read_loadmap
!= NULL
)
1894 strcat (own_buf
, ";qXfer:fdpic:read+");
1896 /* We always report qXfer:features:read, as targets may
1897 install XML files on a subsequent call to arch_setup.
1898 If we reported to GDB on startup that we don't support
1899 qXfer:feature:read at all, we will never be re-queried. */
1900 strcat (own_buf
, ";qXfer:features:read+");
1902 if (transport_is_reliable
)
1903 strcat (own_buf
, ";QStartNoAckMode+");
1905 if (the_target
->qxfer_osdata
!= NULL
)
1906 strcat (own_buf
, ";qXfer:osdata:read+");
1908 if (target_supports_multi_process ())
1909 strcat (own_buf
, ";multiprocess+");
1911 if (target_supports_non_stop ())
1912 strcat (own_buf
, ";QNonStop+");
1914 if (target_supports_disable_randomization ())
1915 strcat (own_buf
, ";QDisableRandomization+");
1917 strcat (own_buf
, ";qXfer:threads:read+");
1919 if (target_supports_tracepoints ())
1921 strcat (own_buf
, ";ConditionalTracepoints+");
1922 strcat (own_buf
, ";TraceStateVariables+");
1923 strcat (own_buf
, ";TracepointSource+");
1924 strcat (own_buf
, ";DisconnectedTracing+");
1925 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1926 strcat (own_buf
, ";FastTracepoints+");
1927 strcat (own_buf
, ";StaticTracepoints+");
1928 strcat (own_buf
, ";InstallInTrace+");
1929 strcat (own_buf
, ";qXfer:statictrace:read+");
1930 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1931 strcat (own_buf
, ";EnableDisableTracepoints+");
1932 strcat (own_buf
, ";QTBuffer:size+");
1933 strcat (own_buf
, ";tracenz+");
1936 /* Support target-side breakpoint conditions and commands. */
1937 strcat (own_buf
, ";ConditionalBreakpoints+");
1938 strcat (own_buf
, ";BreakpointCommands+");
1940 if (target_supports_agent ())
1941 strcat (own_buf
, ";QAgent+");
1943 if (target_supports_btrace ())
1945 strcat (own_buf
, ";Qbtrace:bts+");
1946 strcat (own_buf
, ";Qbtrace:off+");
1947 strcat (own_buf
, ";qXfer:btrace:read+");
1953 /* Thread-local storage support. */
1954 if (the_target
->get_tls_address
!= NULL
1955 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1957 char *p
= own_buf
+ 12;
1958 CORE_ADDR parts
[2], address
= 0;
1960 ptid_t ptid
= null_ptid
;
1962 require_running (own_buf
);
1964 for (i
= 0; i
< 3; i
++)
1972 p2
= strchr (p
, ',');
1985 ptid
= read_ptid (p
, NULL
);
1987 decode_address (&parts
[i
- 1], p
, len
);
1991 if (p
!= NULL
|| i
< 3)
1995 struct thread_info
*thread
= find_thread_ptid (ptid
);
2000 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2006 strcpy (own_buf
, paddress(address
));
2011 write_enn (own_buf
);
2015 /* Otherwise, pretend we do not understand this packet. */
2018 /* Windows OS Thread Information Block address support. */
2019 if (the_target
->get_tib_address
!= NULL
2020 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
2025 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2027 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2030 strcpy (own_buf
, paddress(tlb
));
2035 write_enn (own_buf
);
2041 /* Handle "monitor" commands. */
2042 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
2044 char *mon
= malloc (PBUFSIZ
);
2045 int len
= strlen (own_buf
+ 6);
2049 write_enn (own_buf
);
2054 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2056 write_enn (own_buf
);
2060 mon
[len
/ 2] = '\0';
2064 if (the_target
->handle_monitor_command
== NULL
2065 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2066 /* Default processing. */
2067 handle_monitor_command (mon
, own_buf
);
2073 if (strncmp ("qSearch:memory:", own_buf
,
2074 sizeof ("qSearch:memory:") - 1) == 0)
2076 require_running (own_buf
);
2077 handle_search_memory (own_buf
, packet_len
);
2081 if (strcmp (own_buf
, "qAttached") == 0
2082 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
2084 struct process_info
*process
;
2086 if (own_buf
[sizeof ("qAttached") - 1])
2088 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2089 process
= (struct process_info
*)
2090 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2094 require_running (own_buf
);
2095 process
= current_process ();
2098 if (process
== NULL
)
2100 write_enn (own_buf
);
2104 strcpy (own_buf
, process
->attached
? "1" : "0");
2108 if (strncmp ("qCRC:", own_buf
, 5) == 0)
2110 /* CRC check (compare-section). */
2114 unsigned long long crc
;
2116 require_running (own_buf
);
2117 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2118 if (*comma
++ != ',')
2120 write_enn (own_buf
);
2123 len
= strtoul (comma
, NULL
, 16);
2124 crc
= crc32 (base
, len
, 0xffffffff);
2125 /* Check for memory failure. */
2126 if (crc
== (unsigned long long) -1)
2128 write_enn (own_buf
);
2131 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2135 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2138 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2141 /* Otherwise we didn't know what packet it was. Say we didn't
2146 static void gdb_wants_all_threads_stopped (void);
2147 static void resume (struct thread_resume
*actions
, size_t n
);
2149 /* The callback that is passed to visit_actioned_threads. */
2150 typedef int (visit_actioned_threads_callback_ftype
)
2151 (const struct thread_resume
*, struct thread_info
*);
2153 /* Struct to pass data to visit_actioned_threads. */
2155 struct visit_actioned_threads_data
2157 const struct thread_resume
*actions
;
2159 visit_actioned_threads_callback_ftype
*callback
;
2162 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2163 true if CALLBACK returns true. Returns false if no matching thread
2164 is found or CALLBACK results false.
2165 Note: This function is itself a callback for find_inferior. */
2168 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2170 struct visit_actioned_threads_data
*data
= datap
;
2171 const struct thread_resume
*actions
= data
->actions
;
2172 size_t num_actions
= data
->num_actions
;
2173 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2176 for (i
= 0; i
< num_actions
; i
++)
2178 const struct thread_resume
*action
= &actions
[i
];
2180 if (ptid_equal (action
->thread
, minus_one_ptid
)
2181 || ptid_equal (action
->thread
, entry
->id
)
2182 || ((ptid_get_pid (action
->thread
)
2183 == ptid_get_pid (entry
->id
))
2184 && ptid_get_lwp (action
->thread
) == -1))
2186 struct thread_info
*thread
= (struct thread_info
*) entry
;
2188 if ((*callback
) (action
, thread
))
2196 /* Callback for visit_actioned_threads. If the thread has a pending
2197 status to report, report it now. */
2200 handle_pending_status (const struct thread_resume
*resumption
,
2201 struct thread_info
*thread
)
2203 if (thread
->status_pending_p
)
2205 thread
->status_pending_p
= 0;
2207 last_status
= thread
->last_status
;
2208 last_ptid
= thread
->entry
.id
;
2209 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2215 /* Parse vCont packets. */
2217 handle_v_cont (char *own_buf
)
2221 struct thread_resume
*resume_info
;
2222 struct thread_resume default_action
= {{0}};
2224 /* Count the number of semicolons in the packet. There should be one
2225 for every action. */
2231 p
= strchr (p
, ';');
2234 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2235 if (resume_info
== NULL
)
2243 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2245 if (p
[0] == 's' || p
[0] == 'S')
2246 resume_info
[i
].kind
= resume_step
;
2247 else if (p
[0] == 'r')
2248 resume_info
[i
].kind
= resume_step
;
2249 else if (p
[0] == 'c' || p
[0] == 'C')
2250 resume_info
[i
].kind
= resume_continue
;
2251 else if (p
[0] == 't')
2252 resume_info
[i
].kind
= resume_stop
;
2256 if (p
[0] == 'S' || p
[0] == 'C')
2259 sig
= strtol (p
+ 1, &q
, 16);
2264 if (!gdb_signal_to_host_p (sig
))
2266 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2268 else if (p
[0] == 'r')
2272 p
= unpack_varlen_hex (p
+ 1, &addr
);
2273 resume_info
[i
].step_range_start
= addr
;
2278 p
= unpack_varlen_hex (p
+ 1, &addr
);
2279 resume_info
[i
].step_range_end
= addr
;
2288 resume_info
[i
].thread
= minus_one_ptid
;
2289 default_action
= resume_info
[i
];
2291 /* Note: we don't increment i here, we'll overwrite this entry
2292 the next time through. */
2294 else if (p
[0] == ':')
2296 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2301 if (p
[0] != ';' && p
[0] != 0)
2304 resume_info
[i
].thread
= ptid
;
2311 resume_info
[i
] = default_action
;
2313 /* `cont_thread' is still used in occasional places in the backend,
2314 to implement single-thread scheduler-locking. Doesn't make sense
2315 to set it if we see a stop request, or a wildcard action (one
2316 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
2318 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
2319 || ptid_get_lwp (resume_info
[0].thread
) == -1)
2320 && resume_info
[0].kind
!= resume_stop
)
2321 cont_thread
= resume_info
[0].thread
;
2323 cont_thread
= minus_one_ptid
;
2324 set_desired_inferior (0);
2326 resume (resume_info
, n
);
2331 write_enn (own_buf
);
2336 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2339 resume (struct thread_resume
*actions
, size_t num_actions
)
2343 /* Check if among the threads that GDB wants actioned, there's
2344 one with a pending status to report. If so, skip actually
2345 resuming/stopping and report the pending event
2347 struct visit_actioned_threads_data data
;
2349 data
.actions
= actions
;
2350 data
.num_actions
= num_actions
;
2351 data
.callback
= handle_pending_status
;
2352 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2358 (*the_target
->resume
) (actions
, num_actions
);
2364 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2366 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2368 /* No proper RSP support for this yet. At least return
2370 sprintf (own_buf
, "E.No unwaited-for children left.");
2371 disable_async_io ();
2375 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2376 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2377 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2378 current_inferior
->last_status
= last_status
;
2380 /* From the client's perspective, all-stop mode always stops all
2381 threads implicitly (and the target backend has already done
2382 so by now). Tag all threads as "want-stopped", so we don't
2383 resume them implicitly without the client telling us to. */
2384 gdb_wants_all_threads_stopped ();
2385 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2386 disable_async_io ();
2388 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2389 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2390 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2394 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2396 handle_v_attach (char *own_buf
)
2400 pid
= strtol (own_buf
+ 8, NULL
, 16);
2401 if (pid
!= 0 && attach_inferior (pid
) == 0)
2403 /* Don't report shared library events after attaching, even if
2404 some libraries are preloaded. GDB will always poll the
2405 library list. Avoids the "stopped by shared library event"
2406 notice on the GDB side. */
2411 /* In non-stop, we don't send a resume reply. Stop events
2412 will follow up using the normal notification
2417 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2423 write_enn (own_buf
);
2428 /* Run a new program. Return 1 if successful, 0 if failure. */
2430 handle_v_run (char *own_buf
)
2432 char *p
, *next_p
, **new_argv
;
2436 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2442 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2443 if (new_argv
== NULL
)
2445 write_enn (own_buf
);
2450 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2452 next_p
= strchr (p
, ';');
2454 next_p
= p
+ strlen (p
);
2456 if (i
== 0 && p
== next_p
)
2460 /* FIXME: Fail request if out of memory instead of dying. */
2461 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2462 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2463 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2472 if (new_argv
[0] == NULL
)
2474 /* GDB didn't specify a program to run. Use the program from the
2475 last run with the new argument list. */
2477 if (program_argv
== NULL
)
2479 write_enn (own_buf
);
2480 freeargv (new_argv
);
2484 new_argv
[0] = strdup (program_argv
[0]);
2485 if (new_argv
[0] == NULL
)
2487 write_enn (own_buf
);
2488 freeargv (new_argv
);
2493 /* Free the old argv and install the new one. */
2494 freeargv (program_argv
);
2495 program_argv
= new_argv
;
2497 start_inferior (program_argv
);
2498 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2500 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2502 /* In non-stop, sending a resume reply doesn't set the general
2503 thread, but GDB assumes a vRun sets it (this is so GDB can
2504 query which is the main thread of the new inferior. */
2506 general_thread
= last_ptid
;
2512 write_enn (own_buf
);
2517 /* Kill process. Return 1 if successful, 0 if failure. */
2519 handle_v_kill (char *own_buf
)
2522 char *p
= &own_buf
[6];
2524 pid
= strtol (p
, NULL
, 16);
2527 if (pid
!= 0 && kill_inferior (pid
) == 0)
2529 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2530 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2531 last_ptid
= pid_to_ptid (pid
);
2532 discard_queued_stop_replies (pid
);
2538 write_enn (own_buf
);
2543 /* Handle all of the extended 'v' packets. */
2545 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2547 if (!disable_packet_vCont
)
2549 if (strncmp (own_buf
, "vCont;", 6) == 0)
2551 require_running (own_buf
);
2552 handle_v_cont (own_buf
);
2556 if (strncmp (own_buf
, "vCont?", 6) == 0)
2558 strcpy (own_buf
, "vCont;c;C;s;S;t");
2559 if (target_supports_range_stepping ())
2561 own_buf
= own_buf
+ strlen (own_buf
);
2562 strcpy (own_buf
, ";r");
2568 if (strncmp (own_buf
, "vFile:", 6) == 0
2569 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2572 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2574 if ((!extended_protocol
|| !multi_process
) && target_running ())
2576 fprintf (stderr
, "Already debugging a process\n");
2577 write_enn (own_buf
);
2580 handle_v_attach (own_buf
);
2584 if (strncmp (own_buf
, "vRun;", 5) == 0)
2586 if ((!extended_protocol
|| !multi_process
) && target_running ())
2588 fprintf (stderr
, "Already debugging a process\n");
2589 write_enn (own_buf
);
2592 handle_v_run (own_buf
);
2596 if (strncmp (own_buf
, "vKill;", 6) == 0)
2598 if (!target_running ())
2600 fprintf (stderr
, "No process to kill\n");
2601 write_enn (own_buf
);
2604 handle_v_kill (own_buf
);
2608 if (handle_notif_ack (own_buf
, packet_len
))
2611 /* Otherwise we didn't know what packet it was. Say we didn't
2617 /* Resume inferior and wait for another event. In non-stop mode,
2618 don't really wait here, but return immediatelly to the event
2621 myresume (char *own_buf
, int step
, int sig
)
2623 struct thread_resume resume_info
[2];
2625 int valid_cont_thread
;
2627 set_desired_inferior (0);
2629 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2630 && !ptid_equal (cont_thread
, minus_one_ptid
));
2632 if (step
|| sig
|| valid_cont_thread
)
2634 resume_info
[0].thread
= current_ptid
;
2636 resume_info
[0].kind
= resume_step
;
2638 resume_info
[0].kind
= resume_continue
;
2639 resume_info
[0].sig
= sig
;
2643 if (!valid_cont_thread
)
2645 resume_info
[n
].thread
= minus_one_ptid
;
2646 resume_info
[n
].kind
= resume_continue
;
2647 resume_info
[n
].sig
= 0;
2651 resume (resume_info
, n
);
2654 /* Callback for for_each_inferior. Make a new stop reply for each
2658 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2660 struct thread_info
*thread
= (struct thread_info
*) entry
;
2662 /* For now, assume targets that don't have this callback also don't
2663 manage the thread's last_status field. */
2664 if (the_target
->thread_stopped
== NULL
)
2666 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2668 new_notif
->ptid
= entry
->id
;
2669 new_notif
->status
= thread
->last_status
;
2670 /* Pass the last stop reply back to GDB, but don't notify
2672 notif_event_enque (¬if_stop
,
2673 (struct notif_event
*) new_notif
);
2677 if (thread_stopped (thread
))
2682 = target_waitstatus_to_string (&thread
->last_status
);
2684 debug_printf ("Reporting thread %s as already stopped with %s\n",
2685 target_pid_to_str (entry
->id
),
2688 xfree (status_string
);
2691 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2693 /* Pass the last stop reply back to GDB, but don't notify
2695 queue_stop_reply (entry
->id
, &thread
->last_status
);
2702 /* Set this inferior threads's state as "want-stopped". We won't
2703 resume this thread until the client gives us another action for
2707 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2709 struct thread_info
*thread
= (struct thread_info
*) entry
;
2711 thread
->last_resume_kind
= resume_stop
;
2713 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2715 /* Most threads are stopped implicitly (all-stop); tag that with
2717 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2718 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2722 /* Set all threads' states as "want-stopped". */
2725 gdb_wants_all_threads_stopped (void)
2727 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2730 /* Clear the gdb_detached flag of every process. */
2733 gdb_reattached_process (struct inferior_list_entry
*entry
)
2735 struct process_info
*process
= (struct process_info
*) entry
;
2737 process
->gdb_detached
= 0;
2740 /* Callback for for_each_inferior. Clear the thread's pending status
2744 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2746 struct thread_info
*thread
= (struct thread_info
*) entry
;
2748 thread
->status_pending_p
= 0;
2751 /* Callback for for_each_inferior. If the thread is stopped with an
2752 interesting event, mark it as having a pending event. */
2755 set_pending_status_callback (struct inferior_list_entry
*entry
)
2757 struct thread_info
*thread
= (struct thread_info
*) entry
;
2759 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
2760 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
2761 /* A breakpoint, watchpoint or finished step from a previous
2762 GDB run isn't considered interesting for a new GDB run.
2763 If we left those pending, the new GDB could consider them
2764 random SIGTRAPs. This leaves out real async traps. We'd
2765 have to peek into the (target-specific) siginfo to
2766 distinguish those. */
2767 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
2768 thread
->status_pending_p
= 1;
2771 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
2772 pending status to report to GDB. */
2775 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
2777 struct thread_info
*thread
= (struct thread_info
*) entry
;
2779 return thread
->status_pending_p
;
2782 /* Status handler for the '?' packet. */
2785 handle_status (char *own_buf
)
2787 /* GDB is connected, don't forward events to the target anymore. */
2788 for_each_inferior (&all_processes
, gdb_reattached_process
);
2790 /* In non-stop mode, we must send a stop reply for each stopped
2791 thread. In all-stop mode, just send one for the first stopped
2796 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2798 /* The first is sent immediatly. OK is sent if there is no
2799 stopped thread, which is the same handling of the vStopped
2800 packet (by design). */
2801 notif_write_event (¬if_stop
, own_buf
);
2805 struct inferior_list_entry
*thread
= NULL
;
2808 stabilize_threads ();
2809 gdb_wants_all_threads_stopped ();
2811 /* We can only report one status, but we might be coming out of
2812 non-stop -- if more than one thread is stopped with
2813 interesting events, leave events for the threads we're not
2814 reporting now pending. They'll be reported the next time the
2815 threads are resumed. Start by marking all interesting events
2817 for_each_inferior (&all_threads
, set_pending_status_callback
);
2819 /* Prefer the last thread that reported an event to GDB (even if
2820 that was a GDB_SIGNAL_TRAP). */
2821 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
2822 && last_status
.kind
!= TARGET_WAITKIND_EXITED
2823 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2824 thread
= find_inferior_id (&all_threads
, last_ptid
);
2826 /* If the last event thread is not found for some reason, look
2827 for some other thread that might have an event to report. */
2829 thread
= find_inferior (&all_threads
,
2830 find_status_pending_thread_callback
, NULL
);
2832 /* If we're still out of luck, simply pick the first thread in
2835 thread
= get_first_inferior (&all_threads
);
2839 struct thread_info
*tp
= (struct thread_info
*) thread
;
2841 /* We're reporting this event, so it's no longer
2843 tp
->status_pending_p
= 0;
2845 /* GDB assumes the current thread is the thread we're
2846 reporting the status for. */
2847 general_thread
= thread
->id
;
2848 set_desired_inferior (1);
2850 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2851 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
2854 strcpy (own_buf
, "W00");
2859 gdbserver_version (void)
2861 printf ("GNU gdbserver %s%s\n"
2862 "Copyright (C) 2014 Free Software Foundation, Inc.\n"
2863 "gdbserver is free software, covered by the "
2864 "GNU General Public License.\n"
2865 "This gdbserver was configured as \"%s\"\n",
2866 PKGVERSION
, version
, host_name
);
2870 gdbserver_usage (FILE *stream
)
2872 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2873 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2874 "\tgdbserver [OPTIONS] --multi COMM\n"
2876 "COMM may either be a tty device (for serial debugging), or \n"
2877 "HOST:PORT to listen for a TCP connection.\n"
2880 " --debug Enable general debugging output.\n"
2881 " --debug-format=opt1[,opt2,...]\n"
2882 " Specify extra content in debugging output.\n"
2887 " --remote-debug Enable remote protocol debugging output.\n"
2888 " --version Display version information and exit.\n"
2889 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2890 " --once Exit after the first connection has "
2892 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2893 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2897 gdbserver_show_disableable (FILE *stream
)
2899 fprintf (stream
, "Disableable packets:\n"
2900 " vCont \tAll vCont packets\n"
2901 " qC \tQuerying the current thread\n"
2902 " qfThreadInfo\tThread listing\n"
2903 " Tthread \tPassing the thread specifier in the "
2904 "T stop reply packet\n"
2905 " threads \tAll of the above\n");
2909 #undef require_running
2910 #define require_running(BUF) \
2911 if (!target_running ()) \
2918 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2920 int pid
= * (int *) args
;
2922 if (ptid_get_pid (entry
->id
) == pid
)
2929 kill_inferior_callback (struct inferior_list_entry
*entry
)
2931 struct process_info
*process
= (struct process_info
*) entry
;
2932 int pid
= ptid_get_pid (process
->entry
.id
);
2934 kill_inferior (pid
);
2935 discard_queued_stop_replies (pid
);
2938 /* Callback for for_each_inferior to detach or kill the inferior,
2939 depending on whether we attached to it or not.
2940 We inform the user whether we're detaching or killing the process
2941 as this is only called when gdbserver is about to exit. */
2944 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2946 struct process_info
*process
= (struct process_info
*) entry
;
2947 int pid
= ptid_get_pid (process
->entry
.id
);
2949 if (process
->attached
)
2950 detach_inferior (pid
);
2952 kill_inferior (pid
);
2954 discard_queued_stop_replies (pid
);
2957 /* for_each_inferior callback for detach_or_kill_for_exit to print
2958 the pids of started inferiors. */
2961 print_started_pid (struct inferior_list_entry
*entry
)
2963 struct process_info
*process
= (struct process_info
*) entry
;
2965 if (! process
->attached
)
2967 int pid
= ptid_get_pid (process
->entry
.id
);
2968 fprintf (stderr
, " %d", pid
);
2972 /* for_each_inferior callback for detach_or_kill_for_exit to print
2973 the pids of attached inferiors. */
2976 print_attached_pid (struct inferior_list_entry
*entry
)
2978 struct process_info
*process
= (struct process_info
*) entry
;
2980 if (process
->attached
)
2982 int pid
= ptid_get_pid (process
->entry
.id
);
2983 fprintf (stderr
, " %d", pid
);
2987 /* Call this when exiting gdbserver with possible inferiors that need
2988 to be killed or detached from. */
2991 detach_or_kill_for_exit (void)
2993 /* First print a list of the inferiors we will be killing/detaching.
2994 This is to assist the user, for example, in case the inferior unexpectedly
2995 dies after we exit: did we screw up or did the inferior exit on its own?
2996 Having this info will save some head-scratching. */
2998 if (have_started_inferiors_p ())
3000 fprintf (stderr
, "Killing process(es):");
3001 for_each_inferior (&all_processes
, print_started_pid
);
3002 fprintf (stderr
, "\n");
3004 if (have_attached_inferiors_p ())
3006 fprintf (stderr
, "Detaching process(es):");
3007 for_each_inferior (&all_processes
, print_attached_pid
);
3008 fprintf (stderr
, "\n");
3011 /* Now we can kill or detach the inferiors. */
3013 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3017 main (int argc
, char *argv
[])
3021 char *arg_end
, *port
;
3022 char **next_arg
= &argv
[1];
3023 volatile int multi_mode
= 0;
3024 volatile int attach
= 0;
3027 while (*next_arg
!= NULL
&& **next_arg
== '-')
3029 if (strcmp (*next_arg
, "--version") == 0)
3031 gdbserver_version ();
3034 else if (strcmp (*next_arg
, "--help") == 0)
3036 gdbserver_usage (stdout
);
3039 else if (strcmp (*next_arg
, "--attach") == 0)
3041 else if (strcmp (*next_arg
, "--multi") == 0)
3043 else if (strcmp (*next_arg
, "--wrapper") == 0)
3047 wrapper_argv
= next_arg
;
3048 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3051 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3053 gdbserver_usage (stderr
);
3057 /* Consume the "--". */
3060 else if (strcmp (*next_arg
, "--debug") == 0)
3062 else if (strncmp (*next_arg
,
3064 sizeof ("--debug-format=") - 1) == 0)
3067 = parse_debug_format_options ((*next_arg
)
3068 + sizeof ("--debug-format=") - 1, 0);
3070 if (error_msg
!= NULL
)
3072 fprintf (stderr
, "%s", error_msg
);
3076 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3078 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3080 gdbserver_show_disableable (stdout
);
3083 else if (strncmp (*next_arg
,
3084 "--disable-packet=",
3085 sizeof ("--disable-packet=") - 1) == 0)
3087 char *packets
, *tok
;
3089 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3090 for (tok
= strtok (packets
, ",");
3092 tok
= strtok (NULL
, ","))
3094 if (strcmp ("vCont", tok
) == 0)
3095 disable_packet_vCont
= 1;
3096 else if (strcmp ("Tthread", tok
) == 0)
3097 disable_packet_Tthread
= 1;
3098 else if (strcmp ("qC", tok
) == 0)
3099 disable_packet_qC
= 1;
3100 else if (strcmp ("qfThreadInfo", tok
) == 0)
3101 disable_packet_qfThreadInfo
= 1;
3102 else if (strcmp ("threads", tok
) == 0)
3104 disable_packet_vCont
= 1;
3105 disable_packet_Tthread
= 1;
3106 disable_packet_qC
= 1;
3107 disable_packet_qfThreadInfo
= 1;
3111 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3113 gdbserver_show_disableable (stderr
);
3118 else if (strcmp (*next_arg
, "-") == 0)
3120 /* "-" specifies a stdio connection and is a form of port
3122 *next_arg
= STDIO_CONNECTION_NAME
;
3125 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3126 disable_randomization
= 1;
3127 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3128 disable_randomization
= 0;
3129 else if (strcmp (*next_arg
, "--once") == 0)
3133 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3141 if (setjmp (toplevel
))
3143 fprintf (stderr
, "Exiting\n");
3149 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3151 gdbserver_usage (stderr
);
3155 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3156 opened by remote_prepare. */
3159 /* We need to know whether the remote connection is stdio before
3160 starting the inferior. Inferiors created in this scenario have
3161 stdin,stdout redirected. So do this here before we call
3163 remote_prepare (port
);
3168 /* --attach used to come after PORT, so allow it there for
3170 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3177 && (*next_arg
== NULL
3178 || (*next_arg
)[0] == '\0'
3179 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3181 || next_arg
[1] != NULL
))
3186 gdbserver_usage (stderr
);
3190 initialize_async_io ();
3192 initialize_event_loop ();
3193 if (target_supports_tracepoints ())
3194 initialize_tracepoint ();
3196 own_buf
= xmalloc (PBUFSIZ
+ 1);
3197 mem_buf
= xmalloc (PBUFSIZ
);
3199 if (pid
== 0 && *next_arg
!= NULL
)
3203 n
= argc
- (next_arg
- argv
);
3204 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3205 for (i
= 0; i
< n
; i
++)
3206 program_argv
[i
] = xstrdup (next_arg
[i
]);
3207 program_argv
[i
] = NULL
;
3209 /* Wait till we are at first instruction in program. */
3210 start_inferior (program_argv
);
3212 /* We are now (hopefully) stopped at the first instruction of
3213 the target process. This assumes that the target process was
3214 successfully created. */
3218 if (attach_inferior (pid
) == -1)
3219 error ("Attaching not supported on this target");
3221 /* Otherwise succeeded. */
3225 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3226 last_status
.value
.integer
= 0;
3227 last_ptid
= minus_one_ptid
;
3230 initialize_notif ();
3232 /* Don't report shared library events on the initial connection,
3233 even if some libraries are preloaded. Avoids the "stopped by
3234 shared library event" notice on gdb side. */
3237 if (setjmp (toplevel
))
3239 /* If something fails and longjmps while detaching or killing
3240 inferiors, we'd end up here again, stuck in an infinite loop
3241 trap. Be sure that if that happens, we exit immediately
3243 if (setjmp (toplevel
) == 0)
3244 detach_or_kill_for_exit ();
3246 fprintf (stderr
, "Detach or kill failed. Exiting\n");
3250 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3251 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3256 if (!was_running
&& !multi_mode
)
3258 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
3266 /* Be sure we're out of tfind mode. */
3267 current_traceframe
= -1;
3271 if (setjmp (toplevel
) != 0)
3273 /* An error occurred. */
3274 if (response_needed
)
3276 write_enn (own_buf
);
3281 /* Wait for events. This will return when all event sources are
3282 removed from the event loop. */
3283 start_event_loop ();
3285 /* If an exit was requested (using the "monitor exit" command),
3286 terminate now. The only other way to get here is for
3287 getpkt to fail; close the connection and reopen it at the
3290 if (exit_requested
|| run_once
)
3292 /* If something fails and longjmps while detaching or
3293 killing inferiors, we'd end up here again, stuck in an
3294 infinite loop trap. Be sure that if that happens, we
3295 exit immediately instead. */
3296 if (setjmp (toplevel
) == 0)
3298 detach_or_kill_for_exit ();
3303 fprintf (stderr
, "Detach or kill failed. Exiting\n");
3309 "Remote side has terminated connection. "
3310 "GDBserver will reopen the connection.\n");
3312 /* Get rid of any pending statuses. An eventual reconnection
3313 (by the same GDB instance or another) will refresh all its
3314 state from scratch. */
3315 discard_queued_stop_replies (-1);
3316 for_each_inferior (&all_threads
, clear_pending_status_callback
);
3320 if (disconnected_tracing
)
3322 /* Try to enable non-stop/async mode, so we we can both
3323 wait for an async socket accept, and handle async
3324 target events simultaneously. There's also no point
3325 either in having the target always stop all threads,
3326 when we're going to pass signals down without
3330 if (start_non_stop (1))
3333 /* Detaching implicitly resumes all threads; simply
3334 disconnecting does not. */
3340 "Disconnected tracing disabled; stopping trace run.\n");
3347 /* Skip PACKET until the next semi-colon (or end of string). */
3350 skip_to_semicolon (char **packet
)
3352 while (**packet
!= '\0' && **packet
!= ';')
3356 /* Process options coming from Z packets for a breakpoint. PACKET is
3357 the packet buffer. *PACKET is updated to point to the first char
3358 after the last processed option. */
3361 process_point_options (struct breakpoint
*bp
, char **packet
)
3363 char *dataptr
= *packet
;
3366 /* Check if data has the correct format. */
3367 if (*dataptr
!= ';')
3374 if (*dataptr
== ';')
3377 if (*dataptr
== 'X')
3379 /* Conditional expression. */
3381 debug_printf ("Found breakpoint condition.\n");
3382 if (!add_breakpoint_condition (bp
, &dataptr
))
3383 skip_to_semicolon (&dataptr
);
3385 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
3387 dataptr
+= strlen ("cmds:");
3389 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3390 persist
= (*dataptr
== '1');
3392 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3393 skip_to_semicolon (&dataptr
);
3397 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3399 /* Skip tokens until we find one that we recognize. */
3400 skip_to_semicolon (&dataptr
);
3406 /* Event loop callback that handles a serial event. The first byte in
3407 the serial buffer gets us here. We expect characters to arrive at
3408 a brisk pace, so we read the rest of the packet with a blocking
3412 process_serial_event (void)
3423 int new_packet_len
= -1;
3425 /* Used to decide when gdbserver should exit in
3426 multi-mode/remote. */
3427 static int have_ran
= 0;
3430 have_ran
= target_running ();
3432 disable_async_io ();
3434 response_needed
= 0;
3435 packet_len
= getpkt (own_buf
);
3436 if (packet_len
<= 0)
3439 /* Force an event loop break. */
3442 response_needed
= 1;
3449 handle_query (own_buf
, packet_len
, &new_packet_len
);
3452 handle_general_set (own_buf
);
3455 require_running (own_buf
);
3460 pid
= strtol (&own_buf
[i
], NULL
, 16);
3463 pid
= ptid_get_pid (current_ptid
);
3465 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3467 struct thread_resume resume_info
;
3468 struct process_info
*process
= find_process_pid (pid
);
3470 if (process
== NULL
)
3472 write_enn (own_buf
);
3476 if (tracing
&& disconnected_tracing
)
3478 "Disconnected tracing in effect, "
3479 "leaving gdbserver attached to the process\n");
3481 if (any_persistent_commands ())
3483 "Persistent commands are present, "
3484 "leaving gdbserver attached to the process\n");
3486 /* Make sure we're in non-stop/async mode, so we we can both
3487 wait for an async socket accept, and handle async target
3488 events simultaneously. There's also no point either in
3489 having the target stop all threads, when we're going to
3490 pass signals down without informing GDB. */
3494 debug_printf ("Forcing non-stop mode\n");
3500 process
->gdb_detached
= 1;
3502 /* Detaching implicitly resumes all threads. */
3503 resume_info
.thread
= minus_one_ptid
;
3504 resume_info
.kind
= resume_continue
;
3505 resume_info
.sig
= 0;
3506 (*the_target
->resume
) (&resume_info
, 1);
3509 break; /* from switch/case */
3512 fprintf (stderr
, "Detaching from process %d\n", pid
);
3514 if (detach_inferior (pid
) != 0)
3515 write_enn (own_buf
);
3518 discard_queued_stop_replies (pid
);
3521 if (extended_protocol
)
3523 /* Treat this like a normal program exit. */
3524 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3525 last_status
.value
.integer
= 0;
3526 last_ptid
= pid_to_ptid (pid
);
3528 current_inferior
= NULL
;
3535 /* If we are attached, then we can exit. Otherwise, we
3536 need to hang around doing nothing, until the child is
3538 join_inferior (pid
);
3544 extended_protocol
= 1;
3548 handle_status (own_buf
);
3551 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3553 ptid_t gdb_id
, thread_id
;
3556 require_running (own_buf
);
3558 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3560 pid
= ptid_get_pid (gdb_id
);
3562 if (ptid_equal (gdb_id
, null_ptid
)
3563 || ptid_equal (gdb_id
, minus_one_ptid
))
3564 thread_id
= null_ptid
;
3566 && ptid_equal (pid_to_ptid (pid
),
3569 struct thread_info
*thread
=
3570 (struct thread_info
*) find_inferior (&all_threads
,
3575 write_enn (own_buf
);
3579 thread_id
= thread
->entry
.id
;
3583 thread_id
= gdb_id_to_thread_id (gdb_id
);
3584 if (ptid_equal (thread_id
, null_ptid
))
3586 write_enn (own_buf
);
3591 if (own_buf
[1] == 'g')
3593 if (ptid_equal (thread_id
, null_ptid
))
3595 /* GDB is telling us to choose any thread. Check if
3596 the currently selected thread is still valid. If
3597 it is not, select the first available. */
3598 struct thread_info
*thread
=
3599 (struct thread_info
*) find_inferior_id (&all_threads
,
3603 thread
= get_first_thread ();
3604 thread_id
= thread
->entry
.id
;
3608 general_thread
= thread_id
;
3609 set_desired_inferior (1);
3611 else if (own_buf
[1] == 'c')
3612 cont_thread
= thread_id
;
3618 /* Silently ignore it so that gdb can extend the protocol
3619 without compatibility headaches. */
3624 require_running (own_buf
);
3625 if (current_traceframe
>= 0)
3627 struct regcache
*regcache
3628 = new_register_cache (current_target_desc ());
3630 if (fetch_traceframe_registers (current_traceframe
,
3632 registers_to_string (regcache
, own_buf
);
3634 write_enn (own_buf
);
3635 free_register_cache (regcache
);
3639 struct regcache
*regcache
;
3641 set_desired_inferior (1);
3642 regcache
= get_thread_regcache (current_inferior
, 1);
3643 registers_to_string (regcache
, own_buf
);
3647 require_running (own_buf
);
3648 if (current_traceframe
>= 0)
3649 write_enn (own_buf
);
3652 struct regcache
*regcache
;
3654 set_desired_inferior (1);
3655 regcache
= get_thread_regcache (current_inferior
, 1);
3656 registers_from_string (regcache
, &own_buf
[1]);
3661 require_running (own_buf
);
3662 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3663 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3665 write_enn (own_buf
);
3667 bin2hex (mem_buf
, own_buf
, res
);
3670 require_running (own_buf
);
3671 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3672 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3675 write_enn (own_buf
);
3678 require_running (own_buf
);
3679 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3680 &mem_addr
, &len
, &mem_buf
) < 0
3681 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3682 write_enn (own_buf
);
3687 require_running (own_buf
);
3688 hex2bin (own_buf
+ 1, &sig
, 1);
3689 if (gdb_signal_to_host_p (sig
))
3690 signal
= gdb_signal_to_host (sig
);
3693 myresume (own_buf
, 0, signal
);
3696 require_running (own_buf
);
3697 hex2bin (own_buf
+ 1, &sig
, 1);
3698 if (gdb_signal_to_host_p (sig
))
3699 signal
= gdb_signal_to_host (sig
);
3702 myresume (own_buf
, 1, signal
);
3705 require_running (own_buf
);
3707 myresume (own_buf
, 0, signal
);
3710 require_running (own_buf
);
3712 myresume (own_buf
, 1, signal
);
3714 case 'Z': /* insert_ ... */
3716 case 'z': /* remove_ ... */
3721 char type
= own_buf
[1];
3723 const int insert
= ch
== 'Z';
3724 char *p
= &own_buf
[3];
3726 p
= unpack_varlen_hex (p
, &addr
);
3727 len
= strtol (p
+ 1, &dataptr
, 16);
3731 struct breakpoint
*bp
;
3733 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
3738 /* GDB may have sent us a list of *point parameters to
3739 be evaluated on the target's side. Read such list
3740 here. If we already have a list of parameters, GDB
3741 is telling us to drop that list and use this one
3743 clear_breakpoint_conditions_and_commands (bp
);
3744 process_point_options (bp
, &dataptr
);
3748 res
= delete_gdb_breakpoint (type
, addr
, len
);
3756 write_enn (own_buf
);
3760 response_needed
= 0;
3761 if (!target_running ())
3762 /* The packet we received doesn't make sense - but we can't
3763 reply to it, either. */
3766 fprintf (stderr
, "Killing all inferiors\n");
3767 for_each_inferior (&all_processes
, kill_inferior_callback
);
3769 /* When using the extended protocol, we wait with no program
3770 running. The traditional protocol will exit instead. */
3771 if (extended_protocol
)
3773 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3774 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3782 ptid_t gdb_id
, thread_id
;
3784 require_running (own_buf
);
3786 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3787 thread_id
= gdb_id_to_thread_id (gdb_id
);
3788 if (ptid_equal (thread_id
, null_ptid
))
3790 write_enn (own_buf
);
3794 if (mythread_alive (thread_id
))
3797 write_enn (own_buf
);
3801 response_needed
= 0;
3803 /* Restarting the inferior is only supported in the extended
3805 if (extended_protocol
)
3807 if (target_running ())
3808 for_each_inferior (&all_processes
,
3809 kill_inferior_callback
);
3810 fprintf (stderr
, "GDBserver restarting\n");
3812 /* Wait till we are at 1st instruction in prog. */
3813 if (program_argv
!= NULL
)
3814 start_inferior (program_argv
);
3817 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3818 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3824 /* It is a request we don't understand. Respond with an
3825 empty packet so that gdb knows that we don't support this
3831 /* Extended (long) request. */
3832 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3836 /* It is a request we don't understand. Respond with an empty
3837 packet so that gdb knows that we don't support this
3843 if (new_packet_len
!= -1)
3844 putpkt_binary (own_buf
, new_packet_len
);
3848 response_needed
= 0;
3850 if (!extended_protocol
&& have_ran
&& !target_running ())
3852 /* In non-stop, defer exiting until GDB had a chance to query
3853 the whole vStopped list (until it gets an OK). */
3854 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3856 /* Be transparent when GDB is connected through stdio -- no
3857 need to spam GDB's console. */
3858 if (!remote_connection_is_stdio ())
3859 fprintf (stderr
, "GDBserver exiting\n");
3871 /* Event-loop callback for serial events. */
3874 handle_serial_event (int err
, gdb_client_data client_data
)
3877 debug_printf ("handling possible serial event\n");
3879 /* Really handle it. */
3880 if (process_serial_event () < 0)
3883 /* Be sure to not change the selected inferior behind GDB's back.
3884 Important in the non-stop mode asynchronous protocol. */
3885 set_desired_inferior (1);
3890 /* Event-loop callback for target events. */
3893 handle_target_event (int err
, gdb_client_data client_data
)
3896 debug_printf ("handling possible target event\n");
3898 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3901 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
3903 /* No RSP support for this yet. */
3905 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3907 int pid
= ptid_get_pid (last_ptid
);
3908 struct process_info
*process
= find_process_pid (pid
);
3909 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3911 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3912 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3914 mark_breakpoints_out (process
);
3915 mourn_inferior (process
);
3919 /* We're reporting this thread as stopped. Update its
3920 "want-stopped" state to what the client wants, until it
3921 gets a new resume action. */
3922 current_inferior
->last_resume_kind
= resume_stop
;
3923 current_inferior
->last_status
= last_status
;
3928 if (!target_running ())
3930 /* The last process exited. We're done. */
3934 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3936 /* A thread stopped with a signal, but gdb isn't
3937 connected to handle it. Pass it down to the
3938 inferior, as if it wasn't being traced. */
3939 struct thread_resume resume_info
;
3942 debug_printf ("GDB not connected; forwarding event %d for"
3944 (int) last_status
.kind
,
3945 target_pid_to_str (last_ptid
));
3947 resume_info
.thread
= last_ptid
;
3948 resume_info
.kind
= resume_continue
;
3949 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3950 (*the_target
->resume
) (&resume_info
, 1);
3952 else if (debug_threads
)
3953 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
3954 (int) last_status
.kind
,
3955 target_pid_to_str (last_ptid
));
3959 struct vstop_notif
*vstop_notif
3960 = xmalloc (sizeof (struct vstop_notif
));
3962 vstop_notif
->status
= last_status
;
3963 vstop_notif
->ptid
= last_ptid
;
3964 /* Push Stop notification. */
3965 notif_push (¬if_stop
,
3966 (struct notif_event
*) vstop_notif
);
3970 /* Be sure to not change the selected inferior behind GDB's back.
3971 Important in the non-stop mode asynchronous protocol. */
3972 set_desired_inferior (1);