1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2018 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"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
43 #include "common/selftest.h"
45 #define require_running_or_return(BUF) \
46 if (!target_running ()) \
52 #define require_running_or_break(BUF) \
53 if (!target_running ()) \
59 /* The environment to pass to the inferior when creating it. */
61 static gdb_environ our_environ
;
63 /* Start the inferior using a shell. */
65 /* We always try to start the inferior using a shell. */
67 int startup_with_shell
= 1;
69 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
70 `vCont'. Note the multi-process extensions made `vCont' a
71 requirement, so `Hc pPID.TID' is pretty much undefined. So
72 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
73 resuming all threads of the process (again, `Hc' isn't used for
74 multi-process), or a specific thread ptid_t. */
77 /* The thread set with an `Hg' packet. */
78 ptid_t general_thread
;
82 static int extended_protocol
;
83 static int response_needed
;
84 static int exit_requested
;
86 /* --once: Exit after the first connection has closed. */
90 int report_fork_events
;
91 int report_vfork_events
;
92 int report_exec_events
;
93 int report_thread_events
;
95 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
96 static int report_no_resumed
;
102 /* True if the "vContSupported" feature is active. In that case, GDB
103 wants us to report whether single step is supported in the reply to
105 static int vCont_supported
;
107 /* Whether we should attempt to disable the operating system's address
108 space randomization feature before starting an inferior. */
109 int disable_randomization
= 1;
111 static char *program_name
= NULL
;
112 static std::vector
<char *> program_args
;
113 static std::string wrapper_argv
;
115 int pass_signals
[GDB_SIGNAL_LAST
];
116 int program_signals
[GDB_SIGNAL_LAST
];
117 int program_signals_p
;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid
;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 int disable_packet_vCont
;
130 int disable_packet_Tthread
;
131 int disable_packet_qC
;
132 int disable_packet_qfThreadInfo
;
134 /* Last status reported to GDB. */
135 struct target_waitstatus last_status
;
139 static unsigned char *mem_buf
;
141 /* A sub-class of 'struct notif_event' for stop, holding information
142 relative to a single stop reply. We keep a queue of these to
143 push to GDB in non-stop mode. */
147 struct notif_event base
;
149 /* Thread or process that got the event. */
153 struct target_waitstatus status
;
156 /* The current btrace configuration. This is gdbserver's mirror of GDB's
157 btrace configuration. */
158 static struct btrace_config current_btrace_conf
;
160 DEFINE_QUEUE_P (notif_event_p
);
162 /* Put a stop reply to the stop reply queue. */
165 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
167 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
169 new_notif
->ptid
= ptid
;
170 new_notif
->status
= *status
;
172 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
176 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
177 QUEUE_ITER (notif_event_p
) *iter
,
178 struct notif_event
*event
,
181 ptid_t filter_ptid
= *(ptid_t
*) data
;
182 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
184 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
186 if (q
->free_func
!= NULL
)
187 q
->free_func (event
);
189 QUEUE_remove_elem (notif_event_p
, q
, iter
);
198 discard_queued_stop_replies (ptid_t ptid
)
200 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
201 remove_all_on_match_ptid
, &ptid
);
205 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
207 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
209 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
212 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
215 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
216 QUEUE_ITER (notif_event_p
) *iter
,
217 struct notif_event
*event
,
220 ptid_t filter_ptid
= *(ptid_t
*) data
;
221 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
223 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
226 /* Don't resume fork children that GDB does not know about yet. */
227 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
228 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
229 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
238 in_queued_stop_replies (ptid_t ptid
)
240 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
241 in_queued_stop_replies_ptid
, &ptid
);
244 struct notif_server notif_stop
=
246 "vStopped", "Stop", NULL
, vstop_notif_reply
,
250 target_running (void)
252 return get_first_thread () != NULL
;
255 /* See common/common-inferior.h. */
260 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
263 /* See common/common-inferior.h. */
266 get_exec_file (int err
)
268 if (err
&& program_name
== NULL
)
269 error (_("No executable file specified."));
283 attach_inferior (int pid
)
285 /* myattach should return -1 if attaching is unsupported,
286 0 if it succeeded, and call error() otherwise. */
288 if (myattach (pid
) != 0)
291 fprintf (stderr
, "Attached; pid = %d\n", pid
);
294 /* FIXME - It may be that we should get the SIGNAL_PID from the
295 attach function, so that it can be the main thread instead of
296 whichever we were told to attach to. */
301 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
303 /* GDB knows to ignore the first SIGSTOP after attaching to a running
304 process using the "attach" command, but this is different; it's
305 just using "target remote". Pretend it's just starting up. */
306 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
307 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
308 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
310 current_thread
->last_resume_kind
= resume_stop
;
311 current_thread
->last_status
= last_status
;
317 extern int remote_debug
;
319 /* Decode a qXfer read request. Return 0 if everything looks OK,
323 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
325 /* After the read marker and annex, qXfer looks like a
326 traditional 'm' packet. */
327 decode_m_packet (buf
, ofs
, len
);
333 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
335 /* Extract and NUL-terminate the object. */
337 while (*buf
&& *buf
!= ':')
343 /* Extract and NUL-terminate the read/write action. */
345 while (*buf
&& *buf
!= ':')
351 /* Extract and NUL-terminate the annex. */
353 while (*buf
&& *buf
!= ':')
363 /* Write the response to a successful qXfer read. Returns the
364 length of the (binary) data stored in BUF, corresponding
365 to as much of DATA/LEN as we could fit. IS_MORE controls
366 the first character of the response. */
368 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
377 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
378 &out_len
, PBUFSIZ
- 2) + 1;
381 /* Handle btrace enabling in BTS format. */
384 handle_btrace_enable_bts (struct thread_info
*thread
)
386 if (thread
->btrace
!= NULL
)
387 error (_("Btrace already enabled."));
389 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
390 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
393 /* Handle btrace enabling in Intel Processor Trace format. */
396 handle_btrace_enable_pt (struct thread_info
*thread
)
398 if (thread
->btrace
!= NULL
)
399 error (_("Btrace already enabled."));
401 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
402 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
405 /* Handle btrace disabling. */
408 handle_btrace_disable (struct thread_info
*thread
)
411 if (thread
->btrace
== NULL
)
412 error (_("Branch tracing not enabled."));
414 if (target_disable_btrace (thread
->btrace
) != 0)
415 error (_("Could not disable branch tracing."));
417 thread
->btrace
= NULL
;
420 /* Handle the "Qbtrace" packet. */
423 handle_btrace_general_set (char *own_buf
)
425 struct thread_info
*thread
;
428 if (!startswith (own_buf
, "Qbtrace:"))
431 op
= own_buf
+ strlen ("Qbtrace:");
433 if (ptid_equal (general_thread
, null_ptid
)
434 || ptid_equal (general_thread
, minus_one_ptid
))
436 strcpy (own_buf
, "E.Must select a single thread.");
440 thread
= find_thread_ptid (general_thread
);
443 strcpy (own_buf
, "E.No such thread.");
449 if (strcmp (op
, "bts") == 0)
450 handle_btrace_enable_bts (thread
);
451 else if (strcmp (op
, "pt") == 0)
452 handle_btrace_enable_pt (thread
);
453 else if (strcmp (op
, "off") == 0)
454 handle_btrace_disable (thread
);
456 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
460 CATCH (exception
, RETURN_MASK_ERROR
)
462 sprintf (own_buf
, "E.%s", exception
.message
);
469 /* Handle the "Qbtrace-conf" packet. */
472 handle_btrace_conf_general_set (char *own_buf
)
474 struct thread_info
*thread
;
477 if (!startswith (own_buf
, "Qbtrace-conf:"))
480 op
= own_buf
+ strlen ("Qbtrace-conf:");
482 if (ptid_equal (general_thread
, null_ptid
)
483 || ptid_equal (general_thread
, minus_one_ptid
))
485 strcpy (own_buf
, "E.Must select a single thread.");
489 thread
= find_thread_ptid (general_thread
);
492 strcpy (own_buf
, "E.No such thread.");
496 if (startswith (op
, "bts:size="))
502 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
503 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
505 strcpy (own_buf
, "E.Bad size value.");
509 current_btrace_conf
.bts
.size
= (unsigned int) size
;
511 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
517 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
518 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
520 strcpy (own_buf
, "E.Bad size value.");
524 current_btrace_conf
.pt
.size
= (unsigned int) size
;
528 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
536 /* Handle all of the extended 'Q' packets. */
539 handle_general_set (char *own_buf
)
541 if (startswith (own_buf
, "QPassSignals:"))
543 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
544 const char *p
= own_buf
+ strlen ("QPassSignals:");
547 p
= decode_address_to_semicolon (&cursig
, p
);
548 for (i
= 0; i
< numsigs
; i
++)
554 /* Keep looping, to clear the remaining signals. */
557 p
= decode_address_to_semicolon (&cursig
, p
);
562 strcpy (own_buf
, "OK");
566 if (startswith (own_buf
, "QProgramSignals:"))
568 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
569 const char *p
= own_buf
+ strlen ("QProgramSignals:");
572 program_signals_p
= 1;
574 p
= decode_address_to_semicolon (&cursig
, p
);
575 for (i
= 0; i
< numsigs
; i
++)
579 program_signals
[i
] = 1;
581 /* Keep looping, to clear the remaining signals. */
584 p
= decode_address_to_semicolon (&cursig
, p
);
587 program_signals
[i
] = 0;
589 strcpy (own_buf
, "OK");
593 if (startswith (own_buf
, "QCatchSyscalls:"))
595 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
598 struct process_info
*process
;
600 if (!target_running () || !target_supports_catch_syscall ())
606 if (strcmp (p
, "0") == 0)
608 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
612 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
618 process
= current_process ();
619 process
->syscalls_to_catch
.clear ();
629 p
= decode_address_to_semicolon (&sysno
, p
);
630 process
->syscalls_to_catch
.push_back (sysno
);
634 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
641 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
643 our_environ
= gdb_environ::from_host_environ ();
649 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
651 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
652 /* The final form of the environment variable. FINAL_VAR will
653 hold the 'VAR=VALUE' format. */
654 std::string final_var
= hex2str (p
);
655 std::string var_name
, var_value
;
659 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
660 debug_printf (_("[Environment variable to be set: '%s']\n"),
665 size_t pos
= final_var
.find ('=');
666 if (pos
== std::string::npos
)
668 warning (_("Unexpected format for environment variable: '%s'"),
674 var_name
= final_var
.substr (0, pos
);
675 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
677 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
683 if (startswith (own_buf
, "QEnvironmentUnset:"))
685 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
686 std::string varname
= hex2str (p
);
690 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
691 debug_printf (_("[Environment variable to be unset: '%s']\n"),
696 our_environ
.unset (varname
.c_str ());
702 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
706 debug_printf ("[noack mode enabled]\n");
715 if (startswith (own_buf
, "QNonStop:"))
717 char *mode
= own_buf
+ 9;
721 if (strcmp (mode
, "0") == 0)
723 else if (strcmp (mode
, "1") == 0)
727 /* We don't know what this mode is, so complain to
729 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
735 req_str
= req
? "non-stop" : "all-stop";
736 if (start_non_stop (req
) != 0)
738 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
746 debug_printf ("[%s mode enabled]\n", req_str
);
752 if (startswith (own_buf
, "QDisableRandomization:"))
754 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
757 unpack_varlen_hex (packet
, &setting
);
758 disable_randomization
= setting
;
762 debug_printf (disable_randomization
763 ? "[address space randomization disabled]\n"
764 : "[address space randomization enabled]\n");
771 if (target_supports_tracepoints ()
772 && handle_tracepoint_general_set (own_buf
))
775 if (startswith (own_buf
, "QAgent:"))
777 char *mode
= own_buf
+ strlen ("QAgent:");
780 if (strcmp (mode
, "0") == 0)
782 else if (strcmp (mode
, "1") == 0)
786 /* We don't know what this value is, so complain to GDB. */
787 sprintf (own_buf
, "E.Unknown QAgent value");
791 /* Update the flag. */
794 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
799 if (handle_btrace_general_set (own_buf
))
802 if (handle_btrace_conf_general_set (own_buf
))
805 if (startswith (own_buf
, "QThreadEvents:"))
807 char *mode
= own_buf
+ strlen ("QThreadEvents:");
808 enum tribool req
= TRIBOOL_UNKNOWN
;
810 if (strcmp (mode
, "0") == 0)
812 else if (strcmp (mode
, "1") == 0)
816 char *mode_copy
= xstrdup (mode
);
818 /* We don't know what this mode is, so complain to GDB. */
819 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
825 report_thread_events
= (req
== TRIBOOL_TRUE
);
829 const char *req_str
= report_thread_events
? "enabled" : "disabled";
831 debug_printf ("[thread events are now %s]\n", req_str
);
838 if (startswith (own_buf
, "QStartupWithShell:"))
840 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
842 if (strcmp (value
, "1") == 0)
843 startup_with_shell
= true;
844 else if (strcmp (value
, "0") == 0)
845 startup_with_shell
= false;
849 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
856 debug_printf (_("[Inferior will %s started with shell]"),
857 startup_with_shell
? "be" : "not be");
863 if (startswith (own_buf
, "QSetWorkingDir:"))
865 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
869 std::string path
= hex2str (p
);
871 set_inferior_cwd (path
.c_str ());
874 debug_printf (_("[Set the inferior's current directory to %s]\n"),
879 /* An empty argument means that we should clear out any
880 previously set cwd for the inferior. */
881 set_inferior_cwd (NULL
);
885 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
892 /* Otherwise we didn't know what packet it was. Say we didn't
898 get_features_xml (const char *annex
)
900 const struct target_desc
*desc
= current_target_desc ();
902 /* `desc->xmltarget' defines what to return when looking for the
903 "target.xml" file. Its contents can either be verbatim XML code
904 (prefixed with a '@') or else the name of the actual XML file to
905 be used in place of "target.xml".
907 This variable is set up from the auto-generated
908 init_registers_... routine for the current target. */
910 if (strcmp (annex
, "target.xml") == 0)
912 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
922 extern const char *const xml_builtin
[][2];
925 /* Look for the annex. */
926 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
927 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
930 if (xml_builtin
[i
][0] != NULL
)
931 return xml_builtin
[i
][1];
939 monitor_show_help (void)
941 monitor_output ("The following monitor commands are supported:\n");
942 monitor_output (" set debug <0|1>\n");
943 monitor_output (" Enable general debugging messages\n");
944 monitor_output (" set debug-hw-points <0|1>\n");
945 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
946 monitor_output (" set remote-debug <0|1>\n");
947 monitor_output (" Enable remote protocol debugging messages\n");
948 monitor_output (" set debug-format option1[,option2,...]\n");
949 monitor_output (" Add additional information to debugging messages\n");
950 monitor_output (" Options: all, none");
951 monitor_output (", timestamp");
952 monitor_output ("\n");
953 monitor_output (" exit\n");
954 monitor_output (" Quit GDBserver\n");
957 /* Read trace frame or inferior memory. Returns the number of bytes
958 actually read, zero when no further transfer is possible, and -1 on
959 error. Return of a positive value smaller than LEN does not
960 indicate there's no more to be read, only the end of the transfer.
961 E.g., when GDB reads memory from a traceframe, a first request may
962 be served from a memory block that does not cover the whole request
963 length. A following request gets the rest served from either
964 another block (of the same traceframe) or from the read-only
968 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
972 if (current_traceframe
>= 0)
975 ULONGEST length
= len
;
977 if (traceframe_read_mem (current_traceframe
,
978 memaddr
, myaddr
, len
, &nbytes
))
980 /* Data read from trace buffer, we're done. */
983 if (!in_readonly_region (memaddr
, length
))
985 /* Otherwise we have a valid readonly case, fall through. */
986 /* (assume no half-trace half-real blocks for now) */
989 res
= prepare_to_access_memory ();
992 if (set_desired_thread ())
993 res
= read_inferior_memory (memaddr
, myaddr
, len
);
996 done_accessing_memory ();
998 return res
== 0 ? len
: -1;
1004 /* Write trace frame or inferior memory. Actually, writing to trace
1005 frames is forbidden. */
1008 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1010 if (current_traceframe
>= 0)
1016 ret
= prepare_to_access_memory ();
1019 if (set_desired_thread ())
1020 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1023 done_accessing_memory ();
1029 /* Subroutine of handle_search_memory to simplify it. */
1032 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1033 gdb_byte
*pattern
, unsigned pattern_len
,
1034 gdb_byte
*search_buf
,
1035 unsigned chunk_size
, unsigned search_buf_size
,
1036 CORE_ADDR
*found_addrp
)
1038 /* Prime the search buffer. */
1040 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1043 warning ("Unable to access %ld bytes of target "
1044 "memory at 0x%lx, halting search.",
1045 (long) search_buf_size
, (long) start_addr
);
1049 /* Perform the search.
1051 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1052 When we've scanned N bytes we copy the trailing bytes to the start and
1053 read in another N bytes. */
1055 while (search_space_len
>= pattern_len
)
1057 gdb_byte
*found_ptr
;
1058 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1062 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1065 if (found_ptr
!= NULL
)
1067 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1068 *found_addrp
= found_addr
;
1072 /* Not found in this chunk, skip to next chunk. */
1074 /* Don't let search_space_len wrap here, it's unsigned. */
1075 if (search_space_len
>= chunk_size
)
1076 search_space_len
-= chunk_size
;
1078 search_space_len
= 0;
1080 if (search_space_len
>= pattern_len
)
1082 unsigned keep_len
= search_buf_size
- chunk_size
;
1083 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1086 /* Copy the trailing part of the previous iteration to the front
1087 of the buffer for the next iteration. */
1088 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1090 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1091 ? search_space_len
- keep_len
1094 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1095 nr_to_read
) != search_buf_size
)
1097 warning ("Unable to access %ld bytes of target memory "
1098 "at 0x%lx, halting search.",
1099 (long) nr_to_read
, (long) read_addr
);
1103 start_addr
+= chunk_size
;
1112 /* Handle qSearch:memory packets. */
1115 handle_search_memory (char *own_buf
, int packet_len
)
1117 CORE_ADDR start_addr
;
1118 CORE_ADDR search_space_len
;
1120 unsigned int pattern_len
;
1121 /* NOTE: also defined in find.c testcase. */
1122 #define SEARCH_CHUNK_SIZE 16000
1123 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1124 /* Buffer to hold memory contents for searching. */
1125 gdb_byte
*search_buf
;
1126 unsigned search_buf_size
;
1128 CORE_ADDR found_addr
;
1129 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1131 pattern
= (gdb_byte
*) malloc (packet_len
);
1132 if (pattern
== NULL
)
1134 error ("Unable to allocate memory to perform the search");
1135 strcpy (own_buf
, "E00");
1138 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1139 packet_len
- cmd_name_len
,
1140 &start_addr
, &search_space_len
,
1141 pattern
, &pattern_len
) < 0)
1144 error ("Error in parsing qSearch:memory packet");
1145 strcpy (own_buf
, "E00");
1149 search_buf_size
= chunk_size
+ pattern_len
- 1;
1151 /* No point in trying to allocate a buffer larger than the search space. */
1152 if (search_space_len
< search_buf_size
)
1153 search_buf_size
= search_space_len
;
1155 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1156 if (search_buf
== NULL
)
1159 error ("Unable to allocate memory to perform the search");
1160 strcpy (own_buf
, "E00");
1164 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1165 pattern
, pattern_len
,
1166 search_buf
, chunk_size
, search_buf_size
,
1170 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1171 else if (found
== 0)
1172 strcpy (own_buf
, "0");
1174 strcpy (own_buf
, "E00");
1180 /* Handle the "D" packet. */
1183 handle_detach (char *own_buf
)
1185 require_running_or_return (own_buf
);
1192 pid
= strtol (&own_buf
[2], NULL
, 16);
1195 pid
= ptid_get_pid (current_ptid
);
1197 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1199 struct process_info
*process
= find_process_pid (pid
);
1201 if (process
== NULL
)
1203 write_enn (own_buf
);
1207 if (tracing
&& disconnected_tracing
)
1209 "Disconnected tracing in effect, "
1210 "leaving gdbserver attached to the process\n");
1212 if (any_persistent_commands ())
1214 "Persistent commands are present, "
1215 "leaving gdbserver attached to the process\n");
1217 /* Make sure we're in non-stop/async mode, so we we can both
1218 wait for an async socket accept, and handle async target
1219 events simultaneously. There's also no point either in
1220 having the target stop all threads, when we're going to
1221 pass signals down without informing GDB. */
1225 debug_printf ("Forcing non-stop mode\n");
1231 process
->gdb_detached
= 1;
1233 /* Detaching implicitly resumes all threads. */
1234 target_continue_no_signal (minus_one_ptid
);
1240 fprintf (stderr
, "Detaching from process %d\n", pid
);
1242 if (detach_inferior (pid
) != 0)
1243 write_enn (own_buf
);
1246 discard_queued_stop_replies (pid_to_ptid (pid
));
1249 if (extended_protocol
|| target_running ())
1251 /* There is still at least one inferior remaining or
1252 we are in extended mode, so don't terminate gdbserver,
1253 and instead treat this like a normal program exit. */
1254 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1255 last_status
.value
.integer
= 0;
1256 last_ptid
= pid_to_ptid (pid
);
1258 current_thread
= NULL
;
1265 /* If we are attached, then we can exit. Otherwise, we
1266 need to hang around doing nothing, until the child is
1268 join_inferior (pid
);
1274 /* Parse options to --debug-format= and "monitor set debug-format".
1275 ARG is the text after "--debug-format=" or "monitor set debug-format".
1276 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1277 This triggers calls to monitor_output.
1278 The result is NULL if all options were parsed ok, otherwise an error
1279 message which the caller must free.
1281 N.B. These commands affect all debug format settings, they are not
1282 cumulative. If a format is not specified, it is turned off.
1283 However, we don't go to extra trouble with things like
1284 "monitor set debug-format all,none,timestamp".
1285 Instead we just parse them one at a time, in order.
1287 The syntax for "monitor set debug" we support here is not identical
1288 to gdb's "set debug foo on|off" because we also use this function to
1289 parse "--debug-format=foo,bar". */
1292 parse_debug_format_options (const char *arg
, int is_monitor
)
1294 VEC (char_ptr
) *options
;
1298 /* First turn all debug format options off. */
1299 debug_timestamp
= 0;
1301 /* First remove leading spaces, for "monitor set debug-format". */
1302 while (isspace (*arg
))
1305 options
= delim_string_to_char_ptr_vec (arg
, ',');
1307 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1309 if (strcmp (option
, "all") == 0)
1311 debug_timestamp
= 1;
1313 monitor_output ("All extra debug format options enabled.\n");
1315 else if (strcmp (option
, "none") == 0)
1317 debug_timestamp
= 0;
1319 monitor_output ("All extra debug format options disabled.\n");
1321 else if (strcmp (option
, "timestamp") == 0)
1323 debug_timestamp
= 1;
1325 monitor_output ("Timestamps will be added to debug output.\n");
1327 else if (*option
== '\0')
1329 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1335 = string_printf ("Unknown debug-format argument: \"%s\"\n", option
);
1337 free_char_ptr_vec (options
);
1342 free_char_ptr_vec (options
);
1343 return std::string ();
1346 /* Handle monitor commands not handled by target-specific handlers. */
1349 handle_monitor_command (char *mon
, char *own_buf
)
1351 if (strcmp (mon
, "set debug 1") == 0)
1354 monitor_output ("Debug output enabled.\n");
1356 else if (strcmp (mon
, "set debug 0") == 0)
1359 monitor_output ("Debug output disabled.\n");
1361 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1363 show_debug_regs
= 1;
1364 monitor_output ("H/W point debugging output enabled.\n");
1366 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1368 show_debug_regs
= 0;
1369 monitor_output ("H/W point debugging output disabled.\n");
1371 else if (strcmp (mon
, "set remote-debug 1") == 0)
1374 monitor_output ("Protocol debug output enabled.\n");
1376 else if (strcmp (mon
, "set remote-debug 0") == 0)
1379 monitor_output ("Protocol debug output disabled.\n");
1381 else if (startswith (mon
, "set debug-format "))
1383 std::string error_msg
1384 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1387 if (!error_msg
.empty ())
1389 monitor_output (error_msg
.c_str ());
1390 monitor_show_help ();
1391 write_enn (own_buf
);
1394 else if (strcmp (mon
, "help") == 0)
1395 monitor_show_help ();
1396 else if (strcmp (mon
, "exit") == 0)
1400 monitor_output ("Unknown monitor command.\n\n");
1401 monitor_show_help ();
1402 write_enn (own_buf
);
1406 /* Associates a callback with each supported qXfer'able object. */
1410 /* The object this handler handles. */
1413 /* Request that the target transfer up to LEN 8-bit bytes of the
1414 target's OBJECT. The OFFSET, for a seekable object, specifies
1415 the starting point. The ANNEX can be used to provide additional
1416 data-specific information to the target.
1418 Return the number of bytes actually transfered, zero when no
1419 further transfer is possible, -1 on error, -2 when the transfer
1420 is not supported, and -3 on a verbose error message that should
1421 be preserved. Return of a positive value smaller than LEN does
1422 not indicate the end of the object, only the end of the transfer.
1424 One, and only one, of readbuf or writebuf must be non-NULL. */
1425 int (*xfer
) (const char *annex
,
1426 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1427 ULONGEST offset
, LONGEST len
);
1430 /* Handle qXfer:auxv:read. */
1433 handle_qxfer_auxv (const char *annex
,
1434 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1435 ULONGEST offset
, LONGEST len
)
1437 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1440 if (annex
[0] != '\0' || current_thread
== NULL
)
1443 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1446 /* Handle qXfer:exec-file:read. */
1449 handle_qxfer_exec_file (const char *annex
,
1450 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1451 ULONGEST offset
, LONGEST len
)
1457 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1460 if (annex
[0] == '\0')
1462 if (current_thread
== NULL
)
1465 pid
= pid_of (current_thread
);
1469 annex
= unpack_varlen_hex (annex
, &pid
);
1470 if (annex
[0] != '\0')
1477 file
= (*the_target
->pid_to_exec_file
) (pid
);
1481 total_len
= strlen (file
);
1483 if (offset
> total_len
)
1486 if (offset
+ len
> total_len
)
1487 len
= total_len
- offset
;
1489 memcpy (readbuf
, file
+ offset
, len
);
1493 /* Handle qXfer:features:read. */
1496 handle_qxfer_features (const char *annex
,
1497 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1498 ULONGEST offset
, LONGEST len
)
1500 const char *document
;
1503 if (writebuf
!= NULL
)
1506 if (!target_running ())
1509 /* Grab the correct annex. */
1510 document
= get_features_xml (annex
);
1511 if (document
== NULL
)
1514 total_len
= strlen (document
);
1516 if (offset
> total_len
)
1519 if (offset
+ len
> total_len
)
1520 len
= total_len
- offset
;
1522 memcpy (readbuf
, document
+ offset
, len
);
1526 /* Handle qXfer:libraries:read. */
1529 handle_qxfer_libraries (const char *annex
,
1530 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1531 ULONGEST offset
, LONGEST len
)
1533 if (writebuf
!= NULL
)
1536 if (annex
[0] != '\0' || current_thread
== NULL
)
1539 std::string document
= "<library-list version=\"1.0\">\n";
1541 for (const dll_info
&dll
: all_dlls
)
1542 document
+= string_printf
1543 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1544 dll
.name
.c_str (), (long) dll
.base_addr
);
1546 document
+= "</library-list>\n";
1548 if (offset
> document
.length ())
1551 if (offset
+ len
> document
.length ())
1552 len
= document
.length () - offset
;
1554 memcpy (readbuf
, &document
[offset
], len
);
1559 /* Handle qXfer:libraries-svr4:read. */
1562 handle_qxfer_libraries_svr4 (const char *annex
,
1563 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1564 ULONGEST offset
, LONGEST len
)
1566 if (writebuf
!= NULL
)
1569 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1572 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1575 /* Handle qXfer:osadata:read. */
1578 handle_qxfer_osdata (const char *annex
,
1579 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1580 ULONGEST offset
, LONGEST len
)
1582 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1585 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1588 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1591 handle_qxfer_siginfo (const char *annex
,
1592 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1593 ULONGEST offset
, LONGEST len
)
1595 if (the_target
->qxfer_siginfo
== NULL
)
1598 if (annex
[0] != '\0' || current_thread
== NULL
)
1601 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1604 /* Handle qXfer:spu:read and qXfer:spu:write. */
1607 handle_qxfer_spu (const char *annex
,
1608 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1609 ULONGEST offset
, LONGEST len
)
1611 if (the_target
->qxfer_spu
== NULL
)
1614 if (current_thread
== NULL
)
1617 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1620 /* Handle qXfer:statictrace:read. */
1623 handle_qxfer_statictrace (const char *annex
,
1624 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1625 ULONGEST offset
, LONGEST len
)
1629 if (writebuf
!= NULL
)
1632 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1635 if (traceframe_read_sdata (current_traceframe
, offset
,
1636 readbuf
, len
, &nbytes
))
1641 /* Helper for handle_qxfer_threads_proper.
1642 Emit the XML to describe the thread of INF. */
1645 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1647 ptid_t ptid
= ptid_of (thread
);
1649 int core
= target_core_of_thread (ptid
);
1651 const char *name
= target_thread_name (ptid
);
1654 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1656 write_ptid (ptid_s
, ptid
);
1658 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1662 sprintf (core_s
, "%d", core
);
1663 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1667 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1671 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1672 bin2hex (handle
, handle_s
, handle_len
);
1673 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1676 buffer_xml_printf (buffer
, "/>\n");
1679 /* Helper for handle_qxfer_threads. */
1682 handle_qxfer_threads_proper (struct buffer
*buffer
)
1684 buffer_grow_str (buffer
, "<threads>\n");
1686 for_each_thread ([&] (thread_info
*thread
)
1688 handle_qxfer_threads_worker (thread
, buffer
);
1691 buffer_grow_str0 (buffer
, "</threads>\n");
1694 /* Handle qXfer:threads:read. */
1697 handle_qxfer_threads (const char *annex
,
1698 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1699 ULONGEST offset
, LONGEST len
)
1701 static char *result
= 0;
1702 static unsigned int result_length
= 0;
1704 if (writebuf
!= NULL
)
1707 if (annex
[0] != '\0')
1712 struct buffer buffer
;
1713 /* When asked for data at offset 0, generate everything and store into
1714 'result'. Successive reads will be served off 'result'. */
1718 buffer_init (&buffer
);
1720 handle_qxfer_threads_proper (&buffer
);
1722 result
= buffer_finish (&buffer
);
1723 result_length
= strlen (result
);
1724 buffer_free (&buffer
);
1727 if (offset
>= result_length
)
1729 /* We're out of data. */
1736 if (len
> result_length
- offset
)
1737 len
= result_length
- offset
;
1739 memcpy (readbuf
, result
+ offset
, len
);
1744 /* Handle qXfer:traceframe-info:read. */
1747 handle_qxfer_traceframe_info (const char *annex
,
1748 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1749 ULONGEST offset
, LONGEST len
)
1751 static char *result
= 0;
1752 static unsigned int result_length
= 0;
1754 if (writebuf
!= NULL
)
1757 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1762 struct buffer buffer
;
1764 /* When asked for data at offset 0, generate everything and
1765 store into 'result'. Successive reads will be served off
1769 buffer_init (&buffer
);
1771 traceframe_read_info (current_traceframe
, &buffer
);
1773 result
= buffer_finish (&buffer
);
1774 result_length
= strlen (result
);
1775 buffer_free (&buffer
);
1778 if (offset
>= result_length
)
1780 /* We're out of data. */
1787 if (len
> result_length
- offset
)
1788 len
= result_length
- offset
;
1790 memcpy (readbuf
, result
+ offset
, len
);
1794 /* Handle qXfer:fdpic:read. */
1797 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1798 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1800 if (the_target
->read_loadmap
== NULL
)
1803 if (current_thread
== NULL
)
1806 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1809 /* Handle qXfer:btrace:read. */
1812 handle_qxfer_btrace (const char *annex
,
1813 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1814 ULONGEST offset
, LONGEST len
)
1816 static struct buffer cache
;
1817 struct thread_info
*thread
;
1818 enum btrace_read_type type
;
1821 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1824 if (ptid_equal (general_thread
, null_ptid
)
1825 || ptid_equal (general_thread
, minus_one_ptid
))
1827 strcpy (own_buf
, "E.Must select a single thread.");
1831 thread
= find_thread_ptid (general_thread
);
1834 strcpy (own_buf
, "E.No such thread.");
1838 if (thread
->btrace
== NULL
)
1840 strcpy (own_buf
, "E.Btrace not enabled.");
1844 if (strcmp (annex
, "all") == 0)
1845 type
= BTRACE_READ_ALL
;
1846 else if (strcmp (annex
, "new") == 0)
1847 type
= BTRACE_READ_NEW
;
1848 else if (strcmp (annex
, "delta") == 0)
1849 type
= BTRACE_READ_DELTA
;
1852 strcpy (own_buf
, "E.Bad annex.");
1858 buffer_free (&cache
);
1860 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1863 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1867 else if (offset
> cache
.used_size
)
1869 buffer_free (&cache
);
1873 if (len
> cache
.used_size
- offset
)
1874 len
= cache
.used_size
- offset
;
1876 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1881 /* Handle qXfer:btrace-conf:read. */
1884 handle_qxfer_btrace_conf (const char *annex
,
1885 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1886 ULONGEST offset
, LONGEST len
)
1888 static struct buffer cache
;
1889 struct thread_info
*thread
;
1892 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1895 if (annex
[0] != '\0')
1898 if (ptid_equal (general_thread
, null_ptid
)
1899 || ptid_equal (general_thread
, minus_one_ptid
))
1901 strcpy (own_buf
, "E.Must select a single thread.");
1905 thread
= find_thread_ptid (general_thread
);
1908 strcpy (own_buf
, "E.No such thread.");
1912 if (thread
->btrace
== NULL
)
1914 strcpy (own_buf
, "E.Btrace not enabled.");
1920 buffer_free (&cache
);
1922 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1925 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1929 else if (offset
> cache
.used_size
)
1931 buffer_free (&cache
);
1935 if (len
> cache
.used_size
- offset
)
1936 len
= cache
.used_size
- offset
;
1938 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1943 static const struct qxfer qxfer_packets
[] =
1945 { "auxv", handle_qxfer_auxv
},
1946 { "btrace", handle_qxfer_btrace
},
1947 { "btrace-conf", handle_qxfer_btrace_conf
},
1948 { "exec-file", handle_qxfer_exec_file
},
1949 { "fdpic", handle_qxfer_fdpic
},
1950 { "features", handle_qxfer_features
},
1951 { "libraries", handle_qxfer_libraries
},
1952 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1953 { "osdata", handle_qxfer_osdata
},
1954 { "siginfo", handle_qxfer_siginfo
},
1955 { "spu", handle_qxfer_spu
},
1956 { "statictrace", handle_qxfer_statictrace
},
1957 { "threads", handle_qxfer_threads
},
1958 { "traceframe-info", handle_qxfer_traceframe_info
},
1962 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1970 if (!startswith (own_buf
, "qXfer:"))
1973 /* Grab the object, r/w and annex. */
1974 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1976 write_enn (own_buf
);
1981 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1984 const struct qxfer
*q
= &qxfer_packets
[i
];
1986 if (strcmp (object
, q
->object
) == 0)
1988 if (strcmp (rw
, "read") == 0)
1990 unsigned char *data
;
1995 /* Grab the offset and length. */
1996 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1998 write_enn (own_buf
);
2002 /* Read one extra byte, as an indicator of whether there is
2004 if (len
> PBUFSIZ
- 2)
2006 data
= (unsigned char *) malloc (len
+ 1);
2009 write_enn (own_buf
);
2012 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2020 /* Preserve error message. */
2023 write_enn (own_buf
);
2025 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2027 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2032 else if (strcmp (rw
, "write") == 0)
2037 unsigned char *data
;
2039 strcpy (own_buf
, "E00");
2040 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2043 write_enn (own_buf
);
2046 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2047 &ofs
, &len
, data
) < 0)
2050 write_enn (own_buf
);
2054 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2062 /* Preserve error message. */
2065 write_enn (own_buf
);
2067 sprintf (own_buf
, "%x", n
);
2080 /* Compute 32 bit CRC from inferior memory.
2082 On success, return 32 bit CRC.
2083 On failure, return (unsigned long long) -1. */
2085 static unsigned long long
2086 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2090 unsigned char byte
= 0;
2092 /* Return failure if memory read fails. */
2093 if (read_inferior_memory (base
, &byte
, 1) != 0)
2094 return (unsigned long long) -1;
2096 crc
= xcrc32 (&byte
, 1, crc
);
2099 return (unsigned long long) crc
;
2102 /* Add supported btrace packets to BUF. */
2105 supported_btrace_packets (char *buf
)
2107 int btrace_supported
= 0;
2109 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2111 strcat (buf
, ";Qbtrace:bts+");
2112 strcat (buf
, ";Qbtrace-conf:bts:size+");
2114 btrace_supported
= 1;
2117 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2119 strcat (buf
, ";Qbtrace:pt+");
2120 strcat (buf
, ";Qbtrace-conf:pt:size+");
2122 btrace_supported
= 1;
2125 if (!btrace_supported
)
2128 strcat (buf
, ";Qbtrace:off+");
2129 strcat (buf
, ";qXfer:btrace:read+");
2130 strcat (buf
, ";qXfer:btrace-conf:read+");
2133 /* Handle all of the extended 'q' packets. */
2136 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2138 static std::list
<thread_info
*>::const_iterator thread_iter
;
2140 /* Reply the current thread id. */
2141 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2144 require_running_or_return (own_buf
);
2146 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2147 ptid
= general_thread
;
2150 thread_iter
= all_threads
.begin ();
2151 ptid
= (*thread_iter
)->id
;
2154 sprintf (own_buf
, "QC");
2156 write_ptid (own_buf
, ptid
);
2160 if (strcmp ("qSymbol::", own_buf
) == 0)
2162 struct thread_info
*save_thread
= current_thread
;
2164 /* For qSymbol, GDB only changes the current thread if the
2165 previous current thread was of a different process. So if
2166 the previous thread is gone, we need to pick another one of
2167 the same process. This can happen e.g., if we followed an
2168 exec in a non-leader thread. */
2169 if (current_thread
== NULL
)
2172 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2174 /* Just in case, if we didn't find a thread, then bail out
2175 instead of crashing. */
2176 if (current_thread
== NULL
)
2178 write_enn (own_buf
);
2179 current_thread
= save_thread
;
2184 /* GDB is suggesting new symbols have been loaded. This may
2185 mean a new shared library has been detected as loaded, so
2186 take the opportunity to check if breakpoints we think are
2187 inserted, still are. Note that it isn't guaranteed that
2188 we'll see this when a shared library is loaded, and nor will
2189 we see this for unloads (although breakpoints in unloaded
2190 libraries shouldn't trigger), as GDB may not find symbols for
2191 the library at all. We also re-validate breakpoints when we
2192 see a second GDB breakpoint for the same address, and or when
2193 we access breakpoint shadows. */
2194 validate_breakpoints ();
2196 if (target_supports_tracepoints ())
2197 tracepoint_look_up_symbols ();
2199 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2200 (*the_target
->look_up_symbols
) ();
2202 current_thread
= save_thread
;
2204 strcpy (own_buf
, "OK");
2208 if (!disable_packet_qfThreadInfo
)
2210 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2212 require_running_or_return (own_buf
);
2213 thread_iter
= all_threads
.begin ();
2216 ptid_t ptid
= (*thread_iter
)->id
;
2217 write_ptid (own_buf
, ptid
);
2222 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2224 require_running_or_return (own_buf
);
2225 if (thread_iter
!= all_threads
.end ())
2228 ptid_t ptid
= (*thread_iter
)->id
;
2229 write_ptid (own_buf
, ptid
);
2235 sprintf (own_buf
, "l");
2241 if (the_target
->read_offsets
!= NULL
2242 && strcmp ("qOffsets", own_buf
) == 0)
2244 CORE_ADDR text
, data
;
2246 require_running_or_return (own_buf
);
2247 if (the_target
->read_offsets (&text
, &data
))
2248 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2249 (long)text
, (long)data
, (long)data
);
2251 write_enn (own_buf
);
2256 /* Protocol features query. */
2257 if (startswith (own_buf
, "qSupported")
2258 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2260 char *p
= &own_buf
[10];
2261 int gdb_supports_qRelocInsn
= 0;
2263 /* Process each feature being provided by GDB. The first
2264 feature will follow a ':', and latter features will follow
2268 char **qsupported
= NULL
;
2273 /* Two passes, to avoid nested strtok calls in
2274 target_process_qsupported. */
2275 for (p
= strtok (p
+ 1, ";");
2277 p
= strtok (NULL
, ";"))
2280 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2281 qsupported
[count
- 1] = xstrdup (p
);
2284 for (i
= 0; i
< count
; i
++)
2287 if (strcmp (p
, "multiprocess+") == 0)
2289 /* GDB supports and wants multi-process support if
2291 if (target_supports_multi_process ())
2294 else if (strcmp (p
, "qRelocInsn+") == 0)
2296 /* GDB supports relocate instruction requests. */
2297 gdb_supports_qRelocInsn
= 1;
2299 else if (strcmp (p
, "swbreak+") == 0)
2301 /* GDB wants us to report whether a trap is caused
2302 by a software breakpoint and for us to handle PC
2303 adjustment if necessary on this target. */
2304 if (target_supports_stopped_by_sw_breakpoint ())
2305 swbreak_feature
= 1;
2307 else if (strcmp (p
, "hwbreak+") == 0)
2309 /* GDB wants us to report whether a trap is caused
2310 by a hardware breakpoint. */
2311 if (target_supports_stopped_by_hw_breakpoint ())
2312 hwbreak_feature
= 1;
2314 else if (strcmp (p
, "fork-events+") == 0)
2316 /* GDB supports and wants fork events if possible. */
2317 if (target_supports_fork_events ())
2318 report_fork_events
= 1;
2320 else if (strcmp (p
, "vfork-events+") == 0)
2322 /* GDB supports and wants vfork events if possible. */
2323 if (target_supports_vfork_events ())
2324 report_vfork_events
= 1;
2326 else if (strcmp (p
, "exec-events+") == 0)
2328 /* GDB supports and wants exec events if possible. */
2329 if (target_supports_exec_events ())
2330 report_exec_events
= 1;
2332 else if (strcmp (p
, "vContSupported+") == 0)
2333 vCont_supported
= 1;
2334 else if (strcmp (p
, "QThreadEvents+") == 0)
2336 else if (strcmp (p
, "no-resumed+") == 0)
2338 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2340 report_no_resumed
= 1;
2344 /* Move the unknown features all together. */
2345 qsupported
[i
] = NULL
;
2346 qsupported
[unknown
] = p
;
2351 /* Give the target backend a chance to process the unknown
2353 target_process_qsupported (qsupported
, unknown
);
2355 for (i
= 0; i
< count
; i
++)
2356 free (qsupported
[i
]);
2361 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2362 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2363 "QEnvironmentReset+;QEnvironmentUnset+;"
2367 if (target_supports_catch_syscall ())
2368 strcat (own_buf
, ";QCatchSyscalls+");
2370 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2371 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2372 ";augmented-libraries-svr4-read+");
2375 /* We do not have any hook to indicate whether the non-SVR4 target
2376 backend supports qXfer:libraries:read, so always report it. */
2377 strcat (own_buf
, ";qXfer:libraries:read+");
2380 if (the_target
->read_auxv
!= NULL
)
2381 strcat (own_buf
, ";qXfer:auxv:read+");
2383 if (the_target
->qxfer_spu
!= NULL
)
2384 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2386 if (the_target
->qxfer_siginfo
!= NULL
)
2387 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2389 if (the_target
->read_loadmap
!= NULL
)
2390 strcat (own_buf
, ";qXfer:fdpic:read+");
2392 /* We always report qXfer:features:read, as targets may
2393 install XML files on a subsequent call to arch_setup.
2394 If we reported to GDB on startup that we don't support
2395 qXfer:feature:read at all, we will never be re-queried. */
2396 strcat (own_buf
, ";qXfer:features:read+");
2398 if (transport_is_reliable
)
2399 strcat (own_buf
, ";QStartNoAckMode+");
2401 if (the_target
->qxfer_osdata
!= NULL
)
2402 strcat (own_buf
, ";qXfer:osdata:read+");
2404 if (target_supports_multi_process ())
2405 strcat (own_buf
, ";multiprocess+");
2407 if (target_supports_fork_events ())
2408 strcat (own_buf
, ";fork-events+");
2410 if (target_supports_vfork_events ())
2411 strcat (own_buf
, ";vfork-events+");
2413 if (target_supports_exec_events ())
2414 strcat (own_buf
, ";exec-events+");
2416 if (target_supports_non_stop ())
2417 strcat (own_buf
, ";QNonStop+");
2419 if (target_supports_disable_randomization ())
2420 strcat (own_buf
, ";QDisableRandomization+");
2422 strcat (own_buf
, ";qXfer:threads:read+");
2424 if (target_supports_tracepoints ())
2426 strcat (own_buf
, ";ConditionalTracepoints+");
2427 strcat (own_buf
, ";TraceStateVariables+");
2428 strcat (own_buf
, ";TracepointSource+");
2429 strcat (own_buf
, ";DisconnectedTracing+");
2430 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2431 strcat (own_buf
, ";FastTracepoints+");
2432 strcat (own_buf
, ";StaticTracepoints+");
2433 strcat (own_buf
, ";InstallInTrace+");
2434 strcat (own_buf
, ";qXfer:statictrace:read+");
2435 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2436 strcat (own_buf
, ";EnableDisableTracepoints+");
2437 strcat (own_buf
, ";QTBuffer:size+");
2438 strcat (own_buf
, ";tracenz+");
2441 if (target_supports_hardware_single_step ()
2442 || target_supports_software_single_step () )
2444 strcat (own_buf
, ";ConditionalBreakpoints+");
2446 strcat (own_buf
, ";BreakpointCommands+");
2448 if (target_supports_agent ())
2449 strcat (own_buf
, ";QAgent+");
2451 supported_btrace_packets (own_buf
);
2453 if (target_supports_stopped_by_sw_breakpoint ())
2454 strcat (own_buf
, ";swbreak+");
2456 if (target_supports_stopped_by_hw_breakpoint ())
2457 strcat (own_buf
, ";hwbreak+");
2459 if (the_target
->pid_to_exec_file
!= NULL
)
2460 strcat (own_buf
, ";qXfer:exec-file:read+");
2462 strcat (own_buf
, ";vContSupported+");
2464 strcat (own_buf
, ";QThreadEvents+");
2466 strcat (own_buf
, ";no-resumed+");
2468 /* Reinitialize components as needed for the new connection. */
2469 hostio_handle_new_gdb_connection ();
2470 target_handle_new_gdb_connection ();
2475 /* Thread-local storage support. */
2476 if (the_target
->get_tls_address
!= NULL
2477 && startswith (own_buf
, "qGetTLSAddr:"))
2479 char *p
= own_buf
+ 12;
2480 CORE_ADDR parts
[2], address
= 0;
2482 ptid_t ptid
= null_ptid
;
2484 require_running_or_return (own_buf
);
2486 for (i
= 0; i
< 3; i
++)
2494 p2
= strchr (p
, ',');
2507 ptid
= read_ptid (p
, NULL
);
2509 decode_address (&parts
[i
- 1], p
, len
);
2513 if (p
!= NULL
|| i
< 3)
2517 struct thread_info
*thread
= find_thread_ptid (ptid
);
2522 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2528 strcpy (own_buf
, paddress(address
));
2533 write_enn (own_buf
);
2537 /* Otherwise, pretend we do not understand this packet. */
2540 /* Windows OS Thread Information Block address support. */
2541 if (the_target
->get_tib_address
!= NULL
2542 && startswith (own_buf
, "qGetTIBAddr:"))
2547 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2549 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2552 strcpy (own_buf
, paddress(tlb
));
2557 write_enn (own_buf
);
2563 /* Handle "monitor" commands. */
2564 if (startswith (own_buf
, "qRcmd,"))
2566 char *mon
= (char *) malloc (PBUFSIZ
);
2567 int len
= strlen (own_buf
+ 6);
2571 write_enn (own_buf
);
2576 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2578 write_enn (own_buf
);
2582 mon
[len
/ 2] = '\0';
2586 if (the_target
->handle_monitor_command
== NULL
2587 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2588 /* Default processing. */
2589 handle_monitor_command (mon
, own_buf
);
2595 if (startswith (own_buf
, "qSearch:memory:"))
2597 require_running_or_return (own_buf
);
2598 handle_search_memory (own_buf
, packet_len
);
2602 if (strcmp (own_buf
, "qAttached") == 0
2603 || startswith (own_buf
, "qAttached:"))
2605 struct process_info
*process
;
2607 if (own_buf
[sizeof ("qAttached") - 1])
2609 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2610 process
= find_process_pid (pid
);
2614 require_running_or_return (own_buf
);
2615 process
= current_process ();
2618 if (process
== NULL
)
2620 write_enn (own_buf
);
2624 strcpy (own_buf
, process
->attached
? "1" : "0");
2628 if (startswith (own_buf
, "qCRC:"))
2630 /* CRC check (compare-section). */
2634 unsigned long long crc
;
2636 require_running_or_return (own_buf
);
2637 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2638 if (*comma
++ != ',')
2640 write_enn (own_buf
);
2643 len
= strtoul (comma
, NULL
, 16);
2644 crc
= crc32 (base
, len
, 0xffffffff);
2645 /* Check for memory failure. */
2646 if (crc
== (unsigned long long) -1)
2648 write_enn (own_buf
);
2651 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2655 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2658 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2661 /* Otherwise we didn't know what packet it was. Say we didn't
2666 static void gdb_wants_all_threads_stopped (void);
2667 static void resume (struct thread_resume
*actions
, size_t n
);
2669 /* The callback that is passed to visit_actioned_threads. */
2670 typedef int (visit_actioned_threads_callback_ftype
)
2671 (const struct thread_resume
*, struct thread_info
*);
2673 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2674 true if CALLBACK returns true. Returns false if no matching thread
2675 is found or CALLBACK results false.
2676 Note: This function is itself a callback for find_thread. */
2679 visit_actioned_threads (thread_info
*thread
,
2680 const struct thread_resume
*actions
,
2682 visit_actioned_threads_callback_ftype
*callback
)
2684 for (size_t i
= 0; i
< num_actions
; i
++)
2686 const struct thread_resume
*action
= &actions
[i
];
2688 if (ptid_equal (action
->thread
, minus_one_ptid
)
2689 || ptid_equal (action
->thread
, thread
->id
)
2690 || ((ptid_get_pid (action
->thread
)
2691 == thread
->id
.pid ())
2692 && ptid_get_lwp (action
->thread
) == -1))
2694 if ((*callback
) (action
, thread
))
2702 /* Callback for visit_actioned_threads. If the thread has a pending
2703 status to report, report it now. */
2706 handle_pending_status (const struct thread_resume
*resumption
,
2707 struct thread_info
*thread
)
2709 if (thread
->status_pending_p
)
2711 thread
->status_pending_p
= 0;
2713 last_status
= thread
->last_status
;
2714 last_ptid
= thread
->id
;
2715 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2721 /* Parse vCont packets. */
2723 handle_v_cont (char *own_buf
)
2727 struct thread_resume
*resume_info
;
2728 struct thread_resume default_action
{ null_ptid
};
2730 /* Count the number of semicolons in the packet. There should be one
2731 for every action. */
2737 p
= strchr (p
, ';');
2740 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2741 if (resume_info
== NULL
)
2749 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2751 if (p
[0] == 's' || p
[0] == 'S')
2752 resume_info
[i
].kind
= resume_step
;
2753 else if (p
[0] == 'r')
2754 resume_info
[i
].kind
= resume_step
;
2755 else if (p
[0] == 'c' || p
[0] == 'C')
2756 resume_info
[i
].kind
= resume_continue
;
2757 else if (p
[0] == 't')
2758 resume_info
[i
].kind
= resume_stop
;
2762 if (p
[0] == 'S' || p
[0] == 'C')
2765 int sig
= strtol (p
+ 1, &q
, 16);
2770 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2772 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2774 else if (p
[0] == 'r')
2778 p
= unpack_varlen_hex (p
+ 1, &addr
);
2779 resume_info
[i
].step_range_start
= addr
;
2784 p
= unpack_varlen_hex (p
+ 1, &addr
);
2785 resume_info
[i
].step_range_end
= addr
;
2794 resume_info
[i
].thread
= minus_one_ptid
;
2795 default_action
= resume_info
[i
];
2797 /* Note: we don't increment i here, we'll overwrite this entry
2798 the next time through. */
2800 else if (p
[0] == ':')
2803 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2808 if (p
[0] != ';' && p
[0] != 0)
2811 resume_info
[i
].thread
= ptid
;
2818 resume_info
[i
] = default_action
;
2820 resume (resume_info
, n
);
2825 write_enn (own_buf
);
2830 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2833 resume (struct thread_resume
*actions
, size_t num_actions
)
2837 /* Check if among the threads that GDB wants actioned, there's
2838 one with a pending status to report. If so, skip actually
2839 resuming/stopping and report the pending event
2842 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2844 return visit_actioned_threads (thread
, actions
, num_actions
,
2845 handle_pending_status
);
2848 if (thread_with_status
!= NULL
)
2854 (*the_target
->resume
) (actions
, num_actions
);
2860 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2862 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2863 && !report_no_resumed
)
2865 /* The client does not support this stop reply. At least
2867 sprintf (own_buf
, "E.No unwaited-for children left.");
2868 disable_async_io ();
2872 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2873 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2874 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2875 current_thread
->last_status
= last_status
;
2877 /* From the client's perspective, all-stop mode always stops all
2878 threads implicitly (and the target backend has already done
2879 so by now). Tag all threads as "want-stopped", so we don't
2880 resume them implicitly without the client telling us to. */
2881 gdb_wants_all_threads_stopped ();
2882 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2883 disable_async_io ();
2885 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2886 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2887 target_mourn_inferior (last_ptid
);
2891 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2893 handle_v_attach (char *own_buf
)
2897 pid
= strtol (own_buf
+ 8, NULL
, 16);
2898 if (pid
!= 0 && attach_inferior (pid
) == 0)
2900 /* Don't report shared library events after attaching, even if
2901 some libraries are preloaded. GDB will always poll the
2902 library list. Avoids the "stopped by shared library event"
2903 notice on the GDB side. */
2908 /* In non-stop, we don't send a resume reply. Stop events
2909 will follow up using the normal notification
2914 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2920 write_enn (own_buf
);
2925 /* Run a new program. Return 1 if successful, 0 if failure. */
2927 handle_v_run (char *own_buf
)
2930 std::vector
<char *> new_argv
;
2931 char *new_program_name
= NULL
;
2935 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2941 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2943 next_p
= strchr (p
, ';');
2945 next_p
= p
+ strlen (p
);
2947 if (i
== 0 && p
== next_p
)
2949 /* No program specified. */
2950 new_program_name
= NULL
;
2952 else if (p
== next_p
)
2954 /* Empty argument. */
2955 new_argv
.push_back (xstrdup ("''"));
2959 size_t len
= (next_p
- p
) / 2;
2960 /* ARG is the unquoted argument received via the RSP. */
2961 char *arg
= (char *) xmalloc (len
+ 1);
2962 /* FULL_ARGS will contain the quoted version of ARG. */
2963 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2964 /* These are pointers used to navigate the strings above. */
2965 char *tmp_arg
= arg
;
2966 char *tmp_full_arg
= full_arg
;
2969 hex2bin (p
, (gdb_byte
*) arg
, len
);
2972 while (*tmp_arg
!= '\0')
2978 *tmp_full_arg
= '\'';
2984 /* Quote single quote. */
2985 *tmp_full_arg
= '\\';
2993 *tmp_full_arg
= *tmp_arg
;
2999 *tmp_full_arg
++ = '\'';
3001 /* Finish FULL_ARG and push it into the vector containing
3003 *tmp_full_arg
= '\0';
3005 new_program_name
= full_arg
;
3007 new_argv
.push_back (full_arg
);
3013 new_argv
.push_back (NULL
);
3015 if (new_program_name
== NULL
)
3017 /* GDB didn't specify a program to run. Use the program from the
3018 last run with the new argument list. */
3019 if (program_name
== NULL
)
3021 write_enn (own_buf
);
3022 free_vector_argv (new_argv
);
3028 xfree (program_name
);
3029 program_name
= new_program_name
;
3032 /* Free the old argv and install the new one. */
3033 free_vector_argv (program_args
);
3034 program_args
= new_argv
;
3036 create_inferior (program_name
, program_args
);
3038 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3040 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3042 /* In non-stop, sending a resume reply doesn't set the general
3043 thread, but GDB assumes a vRun sets it (this is so GDB can
3044 query which is the main thread of the new inferior. */
3046 general_thread
= last_ptid
;
3052 write_enn (own_buf
);
3057 /* Kill process. Return 1 if successful, 0 if failure. */
3059 handle_v_kill (char *own_buf
)
3062 char *p
= &own_buf
[6];
3064 pid
= strtol (p
, NULL
, 16);
3067 if (pid
!= 0 && kill_inferior (pid
) == 0)
3069 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3070 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3071 last_ptid
= pid_to_ptid (pid
);
3072 discard_queued_stop_replies (last_ptid
);
3078 write_enn (own_buf
);
3083 /* Handle all of the extended 'v' packets. */
3085 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3087 if (!disable_packet_vCont
)
3089 if (strcmp (own_buf
, "vCtrlC") == 0)
3091 (*the_target
->request_interrupt
) ();
3096 if (startswith (own_buf
, "vCont;"))
3098 handle_v_cont (own_buf
);
3102 if (startswith (own_buf
, "vCont?"))
3104 strcpy (own_buf
, "vCont;c;C;t");
3106 if (target_supports_hardware_single_step ()
3107 || target_supports_software_single_step ()
3108 || !vCont_supported
)
3110 /* If target supports single step either by hardware or by
3111 software, add actions s and S to the list of supported
3112 actions. On the other hand, if GDB doesn't request the
3113 supported vCont actions in qSupported packet, add s and
3114 S to the list too. */
3115 own_buf
= own_buf
+ strlen (own_buf
);
3116 strcpy (own_buf
, ";s;S");
3119 if (target_supports_range_stepping ())
3121 own_buf
= own_buf
+ strlen (own_buf
);
3122 strcpy (own_buf
, ";r");
3128 if (startswith (own_buf
, "vFile:")
3129 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3132 if (startswith (own_buf
, "vAttach;"))
3134 if ((!extended_protocol
|| !multi_process
) && target_running ())
3136 fprintf (stderr
, "Already debugging a process\n");
3137 write_enn (own_buf
);
3140 handle_v_attach (own_buf
);
3144 if (startswith (own_buf
, "vRun;"))
3146 if ((!extended_protocol
|| !multi_process
) && target_running ())
3148 fprintf (stderr
, "Already debugging a process\n");
3149 write_enn (own_buf
);
3152 handle_v_run (own_buf
);
3156 if (startswith (own_buf
, "vKill;"))
3158 if (!target_running ())
3160 fprintf (stderr
, "No process to kill\n");
3161 write_enn (own_buf
);
3164 handle_v_kill (own_buf
);
3168 if (handle_notif_ack (own_buf
, packet_len
))
3171 /* Otherwise we didn't know what packet it was. Say we didn't
3177 /* Resume thread and wait for another event. In non-stop mode,
3178 don't really wait here, but return immediatelly to the event
3181 myresume (char *own_buf
, int step
, int sig
)
3183 struct thread_resume resume_info
[2];
3185 int valid_cont_thread
;
3187 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3188 && !ptid_equal (cont_thread
, minus_one_ptid
));
3190 if (step
|| sig
|| valid_cont_thread
)
3192 resume_info
[0].thread
= current_ptid
;
3194 resume_info
[0].kind
= resume_step
;
3196 resume_info
[0].kind
= resume_continue
;
3197 resume_info
[0].sig
= sig
;
3201 if (!valid_cont_thread
)
3203 resume_info
[n
].thread
= minus_one_ptid
;
3204 resume_info
[n
].kind
= resume_continue
;
3205 resume_info
[n
].sig
= 0;
3209 resume (resume_info
, n
);
3212 /* Callback for for_each_thread. Make a new stop reply for each
3216 queue_stop_reply_callback (thread_info
*thread
)
3218 /* For now, assume targets that don't have this callback also don't
3219 manage the thread's last_status field. */
3220 if (the_target
->thread_stopped
== NULL
)
3222 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3224 new_notif
->ptid
= thread
->id
;
3225 new_notif
->status
= thread
->last_status
;
3226 /* Pass the last stop reply back to GDB, but don't notify
3228 notif_event_enque (¬if_stop
,
3229 (struct notif_event
*) new_notif
);
3233 if (thread_stopped (thread
))
3237 std::string status_string
3238 = target_waitstatus_to_string (&thread
->last_status
);
3240 debug_printf ("Reporting thread %s as already stopped with %s\n",
3241 target_pid_to_str (thread
->id
),
3242 status_string
.c_str ());
3245 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3247 /* Pass the last stop reply back to GDB, but don't notify
3249 queue_stop_reply (thread
->id
, &thread
->last_status
);
3254 /* Set this inferior threads's state as "want-stopped". We won't
3255 resume this thread until the client gives us another action for
3259 gdb_wants_thread_stopped (thread_info
*thread
)
3261 thread
->last_resume_kind
= resume_stop
;
3263 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3265 /* Most threads are stopped implicitly (all-stop); tag that with
3267 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3268 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3272 /* Set all threads' states as "want-stopped". */
3275 gdb_wants_all_threads_stopped (void)
3277 for_each_thread (gdb_wants_thread_stopped
);
3280 /* Callback for for_each_thread. If the thread is stopped with an
3281 interesting event, mark it as having a pending event. */
3284 set_pending_status_callback (thread_info
*thread
)
3286 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3287 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3288 /* A breakpoint, watchpoint or finished step from a previous
3289 GDB run isn't considered interesting for a new GDB run.
3290 If we left those pending, the new GDB could consider them
3291 random SIGTRAPs. This leaves out real async traps. We'd
3292 have to peek into the (target-specific) siginfo to
3293 distinguish those. */
3294 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3295 thread
->status_pending_p
= 1;
3298 /* Status handler for the '?' packet. */
3301 handle_status (char *own_buf
)
3303 /* GDB is connected, don't forward events to the target anymore. */
3304 for_each_process ([] (process_info
*process
) {
3305 process
->gdb_detached
= 0;
3308 /* In non-stop mode, we must send a stop reply for each stopped
3309 thread. In all-stop mode, just send one for the first stopped
3314 for_each_thread (queue_stop_reply_callback
);
3316 /* The first is sent immediatly. OK is sent if there is no
3317 stopped thread, which is the same handling of the vStopped
3318 packet (by design). */
3319 notif_write_event (¬if_stop
, own_buf
);
3323 thread_info
*thread
= NULL
;
3326 stabilize_threads ();
3327 gdb_wants_all_threads_stopped ();
3329 /* We can only report one status, but we might be coming out of
3330 non-stop -- if more than one thread is stopped with
3331 interesting events, leave events for the threads we're not
3332 reporting now pending. They'll be reported the next time the
3333 threads are resumed. Start by marking all interesting events
3335 for_each_thread (set_pending_status_callback
);
3337 /* Prefer the last thread that reported an event to GDB (even if
3338 that was a GDB_SIGNAL_TRAP). */
3339 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3340 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3341 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3342 thread
= find_thread_ptid (last_ptid
);
3344 /* If the last event thread is not found for some reason, look
3345 for some other thread that might have an event to report. */
3347 thread
= find_thread ([] (thread_info
*thread
)
3349 return thread
->status_pending_p
;
3352 /* If we're still out of luck, simply pick the first thread in
3355 thread
= get_first_thread ();
3359 struct thread_info
*tp
= (struct thread_info
*) thread
;
3361 /* We're reporting this event, so it's no longer
3363 tp
->status_pending_p
= 0;
3365 /* GDB assumes the current thread is the thread we're
3366 reporting the status for. */
3367 general_thread
= thread
->id
;
3368 set_desired_thread ();
3370 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3371 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3374 strcpy (own_buf
, "W00");
3379 gdbserver_version (void)
3381 printf ("GNU gdbserver %s%s\n"
3382 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3383 "gdbserver is free software, covered by the "
3384 "GNU General Public License.\n"
3385 "This gdbserver was configured as \"%s\"\n",
3386 PKGVERSION
, version
, host_name
);
3390 gdbserver_usage (FILE *stream
)
3392 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3393 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3394 "\tgdbserver [OPTIONS] --multi COMM\n"
3396 "COMM may either be a tty device (for serial debugging),\n"
3397 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3398 "stdin/stdout of gdbserver.\n"
3399 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3400 "PID is the process ID to attach to, when --attach is specified.\n"
3402 "Operating modes:\n"
3404 " --attach Attach to running process PID.\n"
3405 " --multi Start server without a specific program, and\n"
3406 " only quit when explicitly commanded.\n"
3407 " --once Exit after the first connection has closed.\n"
3408 " --help Print this message and then exit.\n"
3409 " --version Display version information and exit.\n"
3413 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3414 " --disable-randomization\n"
3415 " Run PROG with address space randomization disabled.\n"
3416 " --no-disable-randomization\n"
3417 " Don't disable address space randomization when\n"
3419 " --startup-with-shell\n"
3420 " Start PROG using a shell. I.e., execs a shell that\n"
3421 " then execs PROG. (default)\n"
3422 " --no-startup-with-shell\n"
3423 " Exec PROG directly instead of using a shell.\n"
3424 " Disables argument globbing and variable substitution\n"
3425 " on UNIX-like systems.\n"
3429 " --debug Enable general debugging output.\n"
3430 " --debug-format=opt1[,opt2,...]\n"
3431 " Specify extra content in debugging output.\n"
3436 " --remote-debug Enable remote protocol debugging output.\n"
3437 " --disable-packet=opt1[,opt2,...]\n"
3438 " Disable support for RSP packets or features.\n"
3440 " vCont, Tthread, qC, qfThreadInfo and \n"
3441 " threads (disable all threading packets).\n"
3443 "For more information, consult the GDB manual (available as on-line \n"
3444 "info or a printed manual).\n");
3445 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3446 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3450 gdbserver_show_disableable (FILE *stream
)
3452 fprintf (stream
, "Disableable packets:\n"
3453 " vCont \tAll vCont packets\n"
3454 " qC \tQuerying the current thread\n"
3455 " qfThreadInfo\tThread listing\n"
3456 " Tthread \tPassing the thread specifier in the "
3457 "T stop reply packet\n"
3458 " threads \tAll of the above\n");
3462 kill_inferior_callback (process_info
*process
)
3464 int pid
= process
->pid
;
3466 kill_inferior (pid
);
3467 discard_queued_stop_replies (pid_to_ptid (pid
));
3470 /* Call this when exiting gdbserver with possible inferiors that need
3471 to be killed or detached from. */
3474 detach_or_kill_for_exit (void)
3476 /* First print a list of the inferiors we will be killing/detaching.
3477 This is to assist the user, for example, in case the inferior unexpectedly
3478 dies after we exit: did we screw up or did the inferior exit on its own?
3479 Having this info will save some head-scratching. */
3481 if (have_started_inferiors_p ())
3483 fprintf (stderr
, "Killing process(es):");
3485 for_each_process ([] (process_info
*process
) {
3486 if (!process
->attached
)
3487 fprintf (stderr
, " %d", process
->pid
);
3490 fprintf (stderr
, "\n");
3492 if (have_attached_inferiors_p ())
3494 fprintf (stderr
, "Detaching process(es):");
3496 for_each_process ([] (process_info
*process
) {
3497 if (process
->attached
)
3498 fprintf (stderr
, " %d", process
->pid
);
3501 fprintf (stderr
, "\n");
3504 /* Now we can kill or detach the inferiors. */
3505 for_each_process ([] (process_info
*process
) {
3506 int pid
= process
->pid
;
3508 if (process
->attached
)
3509 detach_inferior (pid
);
3511 kill_inferior (pid
);
3513 discard_queued_stop_replies (pid_to_ptid (pid
));
3517 /* Value that will be passed to exit(3) when gdbserver exits. */
3518 static int exit_code
;
3520 /* Cleanup version of detach_or_kill_for_exit. */
3523 detach_or_kill_for_exit_cleanup (void *ignore
)
3528 detach_or_kill_for_exit ();
3531 CATCH (exception
, RETURN_MASK_ALL
)
3534 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3540 /* Main function. This is called by the real "main" function,
3541 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3543 static void ATTRIBUTE_NORETURN
3544 captured_main (int argc
, char *argv
[])
3549 const char *port
= NULL
;
3550 char **next_arg
= &argv
[1];
3551 volatile int multi_mode
= 0;
3552 volatile int attach
= 0;
3554 bool selftest
= false;
3556 const char *selftest_filter
= NULL
;
3559 while (*next_arg
!= NULL
&& **next_arg
== '-')
3561 if (strcmp (*next_arg
, "--version") == 0)
3563 gdbserver_version ();
3566 else if (strcmp (*next_arg
, "--help") == 0)
3568 gdbserver_usage (stdout
);
3571 else if (strcmp (*next_arg
, "--attach") == 0)
3573 else if (strcmp (*next_arg
, "--multi") == 0)
3575 else if (strcmp (*next_arg
, "--wrapper") == 0)
3582 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3584 wrapper_argv
+= *next_arg
;
3585 wrapper_argv
+= ' ';
3589 if (!wrapper_argv
.empty ())
3591 /* Erase the last whitespace. */
3592 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3595 if (next_arg
== tmp
|| *next_arg
== NULL
)
3597 gdbserver_usage (stderr
);
3601 /* Consume the "--". */
3604 else if (strcmp (*next_arg
, "--debug") == 0)
3606 else if (startswith (*next_arg
, "--debug-format="))
3608 std::string error_msg
3609 = parse_debug_format_options ((*next_arg
)
3610 + sizeof ("--debug-format=") - 1, 0);
3612 if (!error_msg
.empty ())
3614 fprintf (stderr
, "%s", error_msg
.c_str ());
3618 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3620 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3622 gdbserver_show_disableable (stdout
);
3625 else if (startswith (*next_arg
, "--disable-packet="))
3627 char *packets
, *tok
;
3629 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3630 for (tok
= strtok (packets
, ",");
3632 tok
= strtok (NULL
, ","))
3634 if (strcmp ("vCont", tok
) == 0)
3635 disable_packet_vCont
= 1;
3636 else if (strcmp ("Tthread", tok
) == 0)
3637 disable_packet_Tthread
= 1;
3638 else if (strcmp ("qC", tok
) == 0)
3639 disable_packet_qC
= 1;
3640 else if (strcmp ("qfThreadInfo", tok
) == 0)
3641 disable_packet_qfThreadInfo
= 1;
3642 else if (strcmp ("threads", tok
) == 0)
3644 disable_packet_vCont
= 1;
3645 disable_packet_Tthread
= 1;
3646 disable_packet_qC
= 1;
3647 disable_packet_qfThreadInfo
= 1;
3651 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3653 gdbserver_show_disableable (stderr
);
3658 else if (strcmp (*next_arg
, "-") == 0)
3660 /* "-" specifies a stdio connection and is a form of port
3662 port
= STDIO_CONNECTION_NAME
;
3666 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3667 disable_randomization
= 1;
3668 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3669 disable_randomization
= 0;
3670 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3671 startup_with_shell
= true;
3672 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3673 startup_with_shell
= false;
3674 else if (strcmp (*next_arg
, "--once") == 0)
3676 else if (strcmp (*next_arg
, "--selftest") == 0)
3678 else if (startswith (*next_arg
, "--selftest="))
3682 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3687 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3700 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3703 gdbserver_usage (stderr
);
3707 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3708 opened by remote_prepare. */
3711 save_original_signals_state (false);
3713 /* We need to know whether the remote connection is stdio before
3714 starting the inferior. Inferiors created in this scenario have
3715 stdin,stdout redirected. So do this here before we call
3718 remote_prepare (port
);
3723 /* --attach used to come after PORT, so allow it there for
3725 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3732 && (*next_arg
== NULL
3733 || (*next_arg
)[0] == '\0'
3734 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3736 || next_arg
[1] != NULL
))
3741 gdbserver_usage (stderr
);
3745 /* Gather information about the environment. */
3746 our_environ
= gdb_environ::from_host_environ ();
3748 initialize_async_io ();
3750 have_job_control ();
3751 initialize_event_loop ();
3752 if (target_supports_tracepoints ())
3753 initialize_tracepoint ();
3754 initialize_notif ();
3756 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3757 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3762 selftests::run_tests (selftest_filter
);
3764 printf (_("Selftests are not available in a non-development build.\n"));
3766 throw_quit ("Quit");
3769 if (pid
== 0 && *next_arg
!= NULL
)
3773 n
= argc
- (next_arg
- argv
);
3774 program_name
= xstrdup (next_arg
[0]);
3775 for (i
= 1; i
< n
; i
++)
3776 program_args
.push_back (xstrdup (next_arg
[i
]));
3777 program_args
.push_back (NULL
);
3779 /* Wait till we are at first instruction in program. */
3780 create_inferior (program_name
, program_args
);
3782 /* We are now (hopefully) stopped at the first instruction of
3783 the target process. This assumes that the target process was
3784 successfully created. */
3788 if (attach_inferior (pid
) == -1)
3789 error ("Attaching not supported on this target");
3791 /* Otherwise succeeded. */
3795 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3796 last_status
.value
.integer
= 0;
3797 last_ptid
= minus_one_ptid
;
3799 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3801 /* Don't report shared library events on the initial connection,
3802 even if some libraries are preloaded. Avoids the "stopped by
3803 shared library event" notice on gdb side. */
3806 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3807 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3812 if (!was_running
&& !multi_mode
)
3813 error ("No program to debug");
3820 report_fork_events
= 0;
3821 report_vfork_events
= 0;
3822 report_exec_events
= 0;
3823 /* Be sure we're out of tfind mode. */
3824 current_traceframe
= -1;
3825 cont_thread
= null_ptid
;
3826 swbreak_feature
= 0;
3827 hwbreak_feature
= 0;
3828 vCont_supported
= 0;
3834 /* Wait for events. This will return when all event sources
3835 are removed from the event loop. */
3836 start_event_loop ();
3838 /* If an exit was requested (using the "monitor exit"
3839 command), terminate now. */
3841 throw_quit ("Quit");
3843 /* The only other way to get here is for getpkt to fail:
3845 - If --once was specified, we're done.
3847 - If not in extended-remote mode, and we're no longer
3848 debugging anything, simply exit: GDB has disconnected
3849 after processing the last process exit.
3851 - Otherwise, close the connection and reopen it at the
3853 if (run_once
|| (!extended_protocol
&& !target_running ()))
3854 throw_quit ("Quit");
3857 "Remote side has terminated connection. "
3858 "GDBserver will reopen the connection.\n");
3860 /* Get rid of any pending statuses. An eventual reconnection
3861 (by the same GDB instance or another) will refresh all its
3862 state from scratch. */
3863 discard_queued_stop_replies (minus_one_ptid
);
3864 for_each_thread ([] (thread_info
*thread
)
3866 thread
->status_pending_p
= 0;
3871 if (disconnected_tracing
)
3873 /* Try to enable non-stop/async mode, so we we can
3874 both wait for an async socket accept, and handle
3875 async target events simultaneously. There's also
3876 no point either in having the target always stop
3877 all threads, when we're going to pass signals
3878 down without informing GDB. */
3881 if (start_non_stop (1))
3884 /* Detaching implicitly resumes all threads;
3885 simply disconnecting does not. */
3891 "Disconnected tracing disabled; "
3892 "stopping trace run.\n");
3897 CATCH (exception
, RETURN_MASK_ERROR
)
3900 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3902 if (response_needed
)
3904 write_enn (own_buf
);
3909 throw_quit ("Quit");
3915 /* Main function. */
3918 main (int argc
, char *argv
[])
3923 captured_main (argc
, argv
);
3925 CATCH (exception
, RETURN_MASK_ALL
)
3927 if (exception
.reason
== RETURN_ERROR
)
3930 fprintf (stderr
, "%s\n", exception
.message
);
3931 fprintf (stderr
, "Exiting\n");
3939 gdb_assert_not_reached ("captured_main should never return");
3942 /* Process options coming from Z packets for a breakpoint. PACKET is
3943 the packet buffer. *PACKET is updated to point to the first char
3944 after the last processed option. */
3947 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3949 const char *dataptr
= *packet
;
3952 /* Check if data has the correct format. */
3953 if (*dataptr
!= ';')
3960 if (*dataptr
== ';')
3963 if (*dataptr
== 'X')
3965 /* Conditional expression. */
3967 debug_printf ("Found breakpoint condition.\n");
3968 if (!add_breakpoint_condition (bp
, &dataptr
))
3969 dataptr
= strchrnul (dataptr
, ';');
3971 else if (startswith (dataptr
, "cmds:"))
3973 dataptr
+= strlen ("cmds:");
3975 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3976 persist
= (*dataptr
== '1');
3978 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3979 dataptr
= strchrnul (dataptr
, ';');
3983 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3985 /* Skip tokens until we find one that we recognize. */
3986 dataptr
= strchrnul (dataptr
, ';');
3992 /* Event loop callback that handles a serial event. The first byte in
3993 the serial buffer gets us here. We expect characters to arrive at
3994 a brisk pace, so we read the rest of the packet with a blocking
3998 process_serial_event (void)
4006 int new_packet_len
= -1;
4008 disable_async_io ();
4010 response_needed
= 0;
4011 packet_len
= getpkt (own_buf
);
4012 if (packet_len
<= 0)
4015 /* Force an event loop break. */
4018 response_needed
= 1;
4020 char ch
= own_buf
[0];
4024 handle_query (own_buf
, packet_len
, &new_packet_len
);
4027 handle_general_set (own_buf
);
4030 handle_detach (own_buf
);
4033 extended_protocol
= 1;
4037 handle_status (own_buf
);
4040 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4042 require_running_or_break (own_buf
);
4044 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4046 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4047 thread_id
= null_ptid
;
4048 else if (thread_id
.is_pid ())
4050 /* The ptid represents a pid. */
4051 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4055 write_enn (own_buf
);
4059 thread_id
= thread
->id
;
4063 /* The ptid represents a lwp/tid. */
4064 if (find_thread_ptid (thread_id
) == NULL
)
4066 write_enn (own_buf
);
4071 if (own_buf
[1] == 'g')
4073 if (ptid_equal (thread_id
, null_ptid
))
4075 /* GDB is telling us to choose any thread. Check if
4076 the currently selected thread is still valid. If
4077 it is not, select the first available. */
4078 thread_info
*thread
= find_thread_ptid (general_thread
);
4080 thread
= get_first_thread ();
4081 thread_id
= thread
->id
;
4084 general_thread
= thread_id
;
4085 set_desired_thread ();
4086 gdb_assert (current_thread
!= NULL
);
4088 else if (own_buf
[1] == 'c')
4089 cont_thread
= thread_id
;
4095 /* Silently ignore it so that gdb can extend the protocol
4096 without compatibility headaches. */
4101 require_running_or_break (own_buf
);
4102 if (current_traceframe
>= 0)
4104 struct regcache
*regcache
4105 = new_register_cache (current_target_desc ());
4107 if (fetch_traceframe_registers (current_traceframe
,
4109 registers_to_string (regcache
, own_buf
);
4111 write_enn (own_buf
);
4112 free_register_cache (regcache
);
4116 struct regcache
*regcache
;
4118 if (!set_desired_thread ())
4119 write_enn (own_buf
);
4122 regcache
= get_thread_regcache (current_thread
, 1);
4123 registers_to_string (regcache
, own_buf
);
4128 require_running_or_break (own_buf
);
4129 if (current_traceframe
>= 0)
4130 write_enn (own_buf
);
4133 struct regcache
*regcache
;
4135 if (!set_desired_thread ())
4136 write_enn (own_buf
);
4139 regcache
= get_thread_regcache (current_thread
, 1);
4140 registers_from_string (regcache
, &own_buf
[1]);
4146 require_running_or_break (own_buf
);
4147 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4148 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4150 write_enn (own_buf
);
4152 bin2hex (mem_buf
, own_buf
, res
);
4155 require_running_or_break (own_buf
);
4156 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4157 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4160 write_enn (own_buf
);
4163 require_running_or_break (own_buf
);
4164 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4165 &mem_addr
, &len
, &mem_buf
) < 0
4166 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4167 write_enn (own_buf
);
4172 require_running_or_break (own_buf
);
4173 hex2bin (own_buf
+ 1, &sig
, 1);
4174 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4175 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4178 myresume (own_buf
, 0, signal
);
4181 require_running_or_break (own_buf
);
4182 hex2bin (own_buf
+ 1, &sig
, 1);
4183 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4184 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4187 myresume (own_buf
, 1, signal
);
4190 require_running_or_break (own_buf
);
4192 myresume (own_buf
, 0, signal
);
4195 require_running_or_break (own_buf
);
4197 myresume (own_buf
, 1, signal
);
4199 case 'Z': /* insert_ ... */
4201 case 'z': /* remove_ ... */
4206 char type
= own_buf
[1];
4208 const int insert
= ch
== 'Z';
4209 const char *p
= &own_buf
[3];
4211 p
= unpack_varlen_hex (p
, &addr
);
4212 kind
= strtol (p
+ 1, &dataptr
, 16);
4216 struct gdb_breakpoint
*bp
;
4218 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4223 /* GDB may have sent us a list of *point parameters to
4224 be evaluated on the target's side. Read such list
4225 here. If we already have a list of parameters, GDB
4226 is telling us to drop that list and use this one
4228 clear_breakpoint_conditions_and_commands (bp
);
4229 const char *options
= dataptr
;
4230 process_point_options (bp
, &options
);
4234 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4242 write_enn (own_buf
);
4246 response_needed
= 0;
4247 if (!target_running ())
4248 /* The packet we received doesn't make sense - but we can't
4249 reply to it, either. */
4252 fprintf (stderr
, "Killing all inferiors\n");
4254 for_each_process (kill_inferior_callback
);
4256 /* When using the extended protocol, we wait with no program
4257 running. The traditional protocol will exit instead. */
4258 if (extended_protocol
)
4260 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4261 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4269 require_running_or_break (own_buf
);
4271 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4272 if (find_thread_ptid (thread_id
) == NULL
)
4274 write_enn (own_buf
);
4278 if (mythread_alive (thread_id
))
4281 write_enn (own_buf
);
4285 response_needed
= 0;
4287 /* Restarting the inferior is only supported in the extended
4289 if (extended_protocol
)
4291 if (target_running ())
4292 for_each_process (kill_inferior_callback
);
4294 fprintf (stderr
, "GDBserver restarting\n");
4296 /* Wait till we are at 1st instruction in prog. */
4297 if (program_name
!= NULL
)
4299 create_inferior (program_name
, program_args
);
4301 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4303 /* Stopped at the first instruction of the target
4305 general_thread
= last_ptid
;
4309 /* Something went wrong. */
4310 general_thread
= null_ptid
;
4315 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4316 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4322 /* It is a request we don't understand. Respond with an
4323 empty packet so that gdb knows that we don't support this
4329 /* Extended (long) request. */
4330 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4334 /* It is a request we don't understand. Respond with an empty
4335 packet so that gdb knows that we don't support this
4341 if (new_packet_len
!= -1)
4342 putpkt_binary (own_buf
, new_packet_len
);
4346 response_needed
= 0;
4354 /* Event-loop callback for serial events. */
4357 handle_serial_event (int err
, gdb_client_data client_data
)
4360 debug_printf ("handling possible serial event\n");
4362 /* Really handle it. */
4363 if (process_serial_event () < 0)
4366 /* Be sure to not change the selected thread behind GDB's back.
4367 Important in the non-stop mode asynchronous protocol. */
4368 set_desired_thread ();
4373 /* Push a stop notification on the notification queue. */
4376 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4378 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4380 vstop_notif
->status
= *status
;
4381 vstop_notif
->ptid
= ptid
;
4382 /* Push Stop notification. */
4383 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4386 /* Event-loop callback for target events. */
4389 handle_target_event (int err
, gdb_client_data client_data
)
4392 debug_printf ("handling possible target event\n");
4394 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4397 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4399 if (gdb_connected () && report_no_resumed
)
4400 push_stop_notification (null_ptid
, &last_status
);
4402 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4404 int pid
= ptid_get_pid (last_ptid
);
4405 struct process_info
*process
= find_process_pid (pid
);
4406 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4408 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4409 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4411 mark_breakpoints_out (process
);
4412 target_mourn_inferior (last_ptid
);
4414 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4418 /* We're reporting this thread as stopped. Update its
4419 "want-stopped" state to what the client wants, until it
4420 gets a new resume action. */
4421 current_thread
->last_resume_kind
= resume_stop
;
4422 current_thread
->last_status
= last_status
;
4427 if (!target_running ())
4429 /* The last process exited. We're done. */
4433 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4434 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4435 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4439 /* A thread stopped with a signal, but gdb isn't
4440 connected to handle it. Pass it down to the
4441 inferior, as if it wasn't being traced. */
4442 enum gdb_signal signal
;
4445 debug_printf ("GDB not connected; forwarding event %d for"
4447 (int) last_status
.kind
,
4448 target_pid_to_str (last_ptid
));
4450 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4451 signal
= last_status
.value
.sig
;
4453 signal
= GDB_SIGNAL_0
;
4454 target_continue (last_ptid
, signal
);
4458 push_stop_notification (last_ptid
, &last_status
);
4461 /* Be sure to not change the selected thread behind GDB's back.
4462 Important in the non-stop mode asynchronous protocol. */
4463 set_desired_thread ();
4476 } // namespace selftests
4477 #endif /* GDB_SELF_TEST */