1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2019 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"
21 #include "common/agent.h"
24 #include "common/rsp-low.h"
25 #include "common/signals-state-save-restore.h"
31 #include "common/gdb_vecs.h"
32 #include "common/gdb_wait.h"
33 #include "common/btrace-common.h"
34 #include "common/filestuff.h"
35 #include "tracepoint.h"
39 #include "common/common-inferior.h"
40 #include "common/job-control.h"
41 #include "common/environ.h"
42 #include "filenames.h"
43 #include "common/pathstuff.h"
45 #include "common/selftest.h"
46 #include "common/scope-exit.h"
48 #define require_running_or_return(BUF) \
49 if (!target_running ()) \
55 #define require_running_or_break(BUF) \
56 if (!target_running ()) \
62 /* String containing the current directory (what getwd would return). */
64 char *current_directory
;
66 /* The environment to pass to the inferior when creating it. */
68 static gdb_environ our_environ
;
70 /* Start the inferior using a shell. */
72 /* We always try to start the inferior using a shell. */
74 int startup_with_shell
= 1;
78 static int extended_protocol
;
79 static int response_needed
;
80 static int exit_requested
;
82 /* --once: Exit after the first connection has closed. */
85 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
86 static int report_no_resumed
;
91 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
93 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
95 m_path
= std::move (path
);
97 /* Make sure we're using the absolute path of the inferior when
99 if (!contains_dir_separator (m_path
.get ()))
103 /* Check if the file is in our CWD. If it is, then we prefix
104 its name with CURRENT_DIRECTORY. Otherwise, we leave the
105 name as-is because we'll try searching for it in $PATH. */
106 if (is_regular_file (m_path
.get (), ®_file_errno
))
107 m_path
= gdb_abspath (m_path
.get ());
111 /* Return the PROGRAM_PATH. */
113 { return m_path
.get (); }
116 /* The program name, adjusted if needed. */
117 gdb::unique_xmalloc_ptr
<char> m_path
;
119 static std::vector
<char *> program_args
;
120 static std::string wrapper_argv
;
122 /* The PID of the originally created or attached inferior. Used to
123 send signals to the process when GDB sends us an asynchronous interrupt
124 (user hitting Control-C in the client), and to wait for the child to exit
125 when no longer debugging it. */
127 unsigned long signal_pid
;
129 /* Set if you want to disable optional thread related packets support
130 in gdbserver, for the sake of testing GDB against stubs that don't
132 int disable_packet_vCont
;
133 int disable_packet_Tthread
;
134 int disable_packet_qC
;
135 int disable_packet_qfThreadInfo
;
137 static unsigned char *mem_buf
;
139 /* A sub-class of 'struct notif_event' for stop, holding information
140 relative to a single stop reply. We keep a queue of these to
141 push to GDB in non-stop mode. */
145 struct notif_event base
;
147 /* Thread or process that got the event. */
151 struct target_waitstatus status
;
154 /* The current btrace configuration. This is gdbserver's mirror of GDB's
155 btrace configuration. */
156 static struct btrace_config current_btrace_conf
;
158 DEFINE_QUEUE_P (notif_event_p
);
160 /* The client remote protocol state. */
162 static client_state g_client_state
;
167 client_state
&cs
= g_client_state
;
172 /* Put a stop reply to the stop reply queue. */
175 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
177 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
179 new_notif
->ptid
= ptid
;
180 new_notif
->status
= *status
;
182 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
186 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
187 QUEUE_ITER (notif_event_p
) *iter
,
188 struct notif_event
*event
,
191 ptid_t filter_ptid
= *(ptid_t
*) data
;
192 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
194 if (vstop_event
->ptid
.matches (filter_ptid
))
196 if (q
->free_func
!= NULL
)
197 q
->free_func (event
);
199 QUEUE_remove_elem (notif_event_p
, q
, iter
);
208 discard_queued_stop_replies (ptid_t ptid
)
210 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
211 remove_all_on_match_ptid
, &ptid
);
215 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
217 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
219 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
222 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
225 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
226 QUEUE_ITER (notif_event_p
) *iter
,
227 struct notif_event
*event
,
230 ptid_t filter_ptid
= *(ptid_t
*) data
;
231 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
233 if (vstop_event
->ptid
.matches (filter_ptid
))
236 /* Don't resume fork children that GDB does not know about yet. */
237 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
238 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
239 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
248 in_queued_stop_replies (ptid_t ptid
)
250 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
251 in_queued_stop_replies_ptid
, &ptid
);
254 struct notif_server notif_stop
=
256 "vStopped", "Stop", NULL
, vstop_notif_reply
,
260 target_running (void)
262 return get_first_thread () != NULL
;
265 /* See common/common-inferior.h. */
270 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
273 /* See common/common-inferior.h. */
276 get_exec_file (int err
)
278 if (err
&& program_path
.get () == NULL
)
279 error (_("No executable file specified."));
281 return program_path
.get ();
293 attach_inferior (int pid
)
295 client_state
&cs
= get_client_state ();
296 /* myattach should return -1 if attaching is unsupported,
297 0 if it succeeded, and call error() otherwise. */
299 if (find_process_pid (pid
) != nullptr)
300 error ("Already attached to process %d\n", pid
);
302 if (myattach (pid
) != 0)
305 fprintf (stderr
, "Attached; pid = %d\n", pid
);
308 /* FIXME - It may be that we should get the SIGNAL_PID from the
309 attach function, so that it can be the main thread instead of
310 whichever we were told to attach to. */
315 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
317 /* GDB knows to ignore the first SIGSTOP after attaching to a running
318 process using the "attach" command, but this is different; it's
319 just using "target remote". Pretend it's just starting up. */
320 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
321 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
322 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
324 current_thread
->last_resume_kind
= resume_stop
;
325 current_thread
->last_status
= cs
.last_status
;
331 extern int remote_debug
;
333 /* Decode a qXfer read request. Return 0 if everything looks OK,
337 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
339 /* After the read marker and annex, qXfer looks like a
340 traditional 'm' packet. */
341 decode_m_packet (buf
, ofs
, len
);
347 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
349 /* Extract and NUL-terminate the object. */
351 while (*buf
&& *buf
!= ':')
357 /* Extract and NUL-terminate the read/write action. */
359 while (*buf
&& *buf
!= ':')
365 /* Extract and NUL-terminate the annex. */
367 while (*buf
&& *buf
!= ':')
377 /* Write the response to a successful qXfer read. Returns the
378 length of the (binary) data stored in BUF, corresponding
379 to as much of DATA/LEN as we could fit. IS_MORE controls
380 the first character of the response. */
382 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
391 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
392 &out_len
, PBUFSIZ
- 2) + 1;
395 /* Handle btrace enabling in BTS format. */
398 handle_btrace_enable_bts (struct thread_info
*thread
)
400 if (thread
->btrace
!= NULL
)
401 error (_("Btrace already enabled."));
403 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
404 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
407 /* Handle btrace enabling in Intel Processor Trace format. */
410 handle_btrace_enable_pt (struct thread_info
*thread
)
412 if (thread
->btrace
!= NULL
)
413 error (_("Btrace already enabled."));
415 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
416 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
419 /* Handle btrace disabling. */
422 handle_btrace_disable (struct thread_info
*thread
)
425 if (thread
->btrace
== NULL
)
426 error (_("Branch tracing not enabled."));
428 if (target_disable_btrace (thread
->btrace
) != 0)
429 error (_("Could not disable branch tracing."));
431 thread
->btrace
= NULL
;
434 /* Handle the "Qbtrace" packet. */
437 handle_btrace_general_set (char *own_buf
)
439 client_state
&cs
= get_client_state ();
440 struct thread_info
*thread
;
443 if (!startswith (own_buf
, "Qbtrace:"))
446 op
= own_buf
+ strlen ("Qbtrace:");
448 if (cs
.general_thread
== null_ptid
449 || cs
.general_thread
== minus_one_ptid
)
451 strcpy (own_buf
, "E.Must select a single thread.");
455 thread
= find_thread_ptid (cs
.general_thread
);
458 strcpy (own_buf
, "E.No such thread.");
464 if (strcmp (op
, "bts") == 0)
465 handle_btrace_enable_bts (thread
);
466 else if (strcmp (op
, "pt") == 0)
467 handle_btrace_enable_pt (thread
);
468 else if (strcmp (op
, "off") == 0)
469 handle_btrace_disable (thread
);
471 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
475 catch (const gdb_exception_error
&exception
)
477 sprintf (own_buf
, "E.%s", exception
.what ());
483 /* Handle the "Qbtrace-conf" packet. */
486 handle_btrace_conf_general_set (char *own_buf
)
488 client_state
&cs
= get_client_state ();
489 struct thread_info
*thread
;
492 if (!startswith (own_buf
, "Qbtrace-conf:"))
495 op
= own_buf
+ strlen ("Qbtrace-conf:");
497 if (cs
.general_thread
== null_ptid
498 || cs
.general_thread
== minus_one_ptid
)
500 strcpy (own_buf
, "E.Must select a single thread.");
504 thread
= find_thread_ptid (cs
.general_thread
);
507 strcpy (own_buf
, "E.No such thread.");
511 if (startswith (op
, "bts:size="))
517 size
= strtoul (op
+ strlen ("bts: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
.bts
.size
= (unsigned int) size
;
526 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
532 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
533 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
535 strcpy (own_buf
, "E.Bad size value.");
539 current_btrace_conf
.pt
.size
= (unsigned int) size
;
543 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
551 /* Handle all of the extended 'Q' packets. */
554 handle_general_set (char *own_buf
)
556 client_state
&cs
= get_client_state ();
557 if (startswith (own_buf
, "QPassSignals:"))
559 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
560 const char *p
= own_buf
+ strlen ("QPassSignals:");
563 p
= decode_address_to_semicolon (&cursig
, p
);
564 for (i
= 0; i
< numsigs
; i
++)
568 cs
.pass_signals
[i
] = 1;
570 /* Keep looping, to clear the remaining signals. */
573 p
= decode_address_to_semicolon (&cursig
, p
);
576 cs
.pass_signals
[i
] = 0;
578 strcpy (own_buf
, "OK");
582 if (startswith (own_buf
, "QProgramSignals:"))
584 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
585 const char *p
= own_buf
+ strlen ("QProgramSignals:");
588 cs
.program_signals_p
= 1;
590 p
= decode_address_to_semicolon (&cursig
, p
);
591 for (i
= 0; i
< numsigs
; i
++)
595 cs
.program_signals
[i
] = 1;
597 /* Keep looping, to clear the remaining signals. */
600 p
= decode_address_to_semicolon (&cursig
, p
);
603 cs
.program_signals
[i
] = 0;
605 strcpy (own_buf
, "OK");
609 if (startswith (own_buf
, "QCatchSyscalls:"))
611 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
614 struct process_info
*process
;
616 if (!target_running () || !target_supports_catch_syscall ())
622 if (strcmp (p
, "0") == 0)
624 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
628 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
634 process
= current_process ();
635 process
->syscalls_to_catch
.clear ();
645 p
= decode_address_to_semicolon (&sysno
, p
);
646 process
->syscalls_to_catch
.push_back (sysno
);
650 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
657 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
659 our_environ
= gdb_environ::from_host_environ ();
665 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
667 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
668 /* The final form of the environment variable. FINAL_VAR will
669 hold the 'VAR=VALUE' format. */
670 std::string final_var
= hex2str (p
);
671 std::string var_name
, var_value
;
675 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
676 debug_printf (_("[Environment variable to be set: '%s']\n"),
681 size_t pos
= final_var
.find ('=');
682 if (pos
== std::string::npos
)
684 warning (_("Unexpected format for environment variable: '%s'"),
690 var_name
= final_var
.substr (0, pos
);
691 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
693 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
699 if (startswith (own_buf
, "QEnvironmentUnset:"))
701 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
702 std::string varname
= hex2str (p
);
706 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
707 debug_printf (_("[Environment variable to be unset: '%s']\n"),
712 our_environ
.unset (varname
.c_str ());
718 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
722 debug_printf ("[noack mode enabled]\n");
731 if (startswith (own_buf
, "QNonStop:"))
733 char *mode
= own_buf
+ 9;
737 if (strcmp (mode
, "0") == 0)
739 else if (strcmp (mode
, "1") == 0)
743 /* We don't know what this mode is, so complain to
745 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
751 req_str
= req
? "non-stop" : "all-stop";
752 if (start_non_stop (req
) != 0)
754 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
762 debug_printf ("[%s mode enabled]\n", req_str
);
768 if (startswith (own_buf
, "QDisableRandomization:"))
770 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
773 unpack_varlen_hex (packet
, &setting
);
774 cs
.disable_randomization
= setting
;
778 debug_printf (cs
.disable_randomization
779 ? "[address space randomization disabled]\n"
780 : "[address space randomization enabled]\n");
787 if (target_supports_tracepoints ()
788 && handle_tracepoint_general_set (own_buf
))
791 if (startswith (own_buf
, "QAgent:"))
793 char *mode
= own_buf
+ strlen ("QAgent:");
796 if (strcmp (mode
, "0") == 0)
798 else if (strcmp (mode
, "1") == 0)
802 /* We don't know what this value is, so complain to GDB. */
803 sprintf (own_buf
, "E.Unknown QAgent value");
807 /* Update the flag. */
810 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
815 if (handle_btrace_general_set (own_buf
))
818 if (handle_btrace_conf_general_set (own_buf
))
821 if (startswith (own_buf
, "QThreadEvents:"))
823 char *mode
= own_buf
+ strlen ("QThreadEvents:");
824 enum tribool req
= TRIBOOL_UNKNOWN
;
826 if (strcmp (mode
, "0") == 0)
828 else if (strcmp (mode
, "1") == 0)
832 /* We don't know what this mode is, so complain to GDB. */
833 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
838 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
842 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
844 debug_printf ("[thread events are now %s]\n", req_str
);
851 if (startswith (own_buf
, "QStartupWithShell:"))
853 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
855 if (strcmp (value
, "1") == 0)
856 startup_with_shell
= true;
857 else if (strcmp (value
, "0") == 0)
858 startup_with_shell
= false;
862 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
869 debug_printf (_("[Inferior will %s started with shell]"),
870 startup_with_shell
? "be" : "not be");
876 if (startswith (own_buf
, "QSetWorkingDir:"))
878 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
882 std::string path
= hex2str (p
);
884 set_inferior_cwd (path
.c_str ());
887 debug_printf (_("[Set the inferior's current directory to %s]\n"),
892 /* An empty argument means that we should clear out any
893 previously set cwd for the inferior. */
894 set_inferior_cwd (NULL
);
898 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
905 /* Otherwise we didn't know what packet it was. Say we didn't
911 get_features_xml (const char *annex
)
913 const struct target_desc
*desc
= current_target_desc ();
915 /* `desc->xmltarget' defines what to return when looking for the
916 "target.xml" file. Its contents can either be verbatim XML code
917 (prefixed with a '@') or else the name of the actual XML file to
918 be used in place of "target.xml".
920 This variable is set up from the auto-generated
921 init_registers_... routine for the current target. */
923 if (strcmp (annex
, "target.xml") == 0)
925 const char *ret
= tdesc_get_features_xml (desc
);
935 extern const char *const xml_builtin
[][2];
938 /* Look for the annex. */
939 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
940 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
943 if (xml_builtin
[i
][0] != NULL
)
944 return xml_builtin
[i
][1];
952 monitor_show_help (void)
954 monitor_output ("The following monitor commands are supported:\n");
955 monitor_output (" set debug <0|1>\n");
956 monitor_output (" Enable general debugging messages\n");
957 monitor_output (" set debug-hw-points <0|1>\n");
958 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
959 monitor_output (" set remote-debug <0|1>\n");
960 monitor_output (" Enable remote protocol debugging messages\n");
961 monitor_output (" set debug-format option1[,option2,...]\n");
962 monitor_output (" Add additional information to debugging messages\n");
963 monitor_output (" Options: all, none");
964 monitor_output (", timestamp");
965 monitor_output ("\n");
966 monitor_output (" exit\n");
967 monitor_output (" Quit GDBserver\n");
970 /* Read trace frame or inferior memory. Returns the number of bytes
971 actually read, zero when no further transfer is possible, and -1 on
972 error. Return of a positive value smaller than LEN does not
973 indicate there's no more to be read, only the end of the transfer.
974 E.g., when GDB reads memory from a traceframe, a first request may
975 be served from a memory block that does not cover the whole request
976 length. A following request gets the rest served from either
977 another block (of the same traceframe) or from the read-only
981 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
983 client_state
&cs
= get_client_state ();
986 if (cs
.current_traceframe
>= 0)
989 ULONGEST length
= len
;
991 if (traceframe_read_mem (cs
.current_traceframe
,
992 memaddr
, myaddr
, len
, &nbytes
))
994 /* Data read from trace buffer, we're done. */
997 if (!in_readonly_region (memaddr
, length
))
999 /* Otherwise we have a valid readonly case, fall through. */
1000 /* (assume no half-trace half-real blocks for now) */
1003 res
= prepare_to_access_memory ();
1006 if (set_desired_thread ())
1007 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1010 done_accessing_memory ();
1012 return res
== 0 ? len
: -1;
1018 /* Write trace frame or inferior memory. Actually, writing to trace
1019 frames is forbidden. */
1022 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1024 client_state
&cs
= get_client_state ();
1025 if (cs
.current_traceframe
>= 0)
1031 ret
= prepare_to_access_memory ();
1034 if (set_desired_thread ())
1035 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1038 done_accessing_memory ();
1044 /* Subroutine of handle_search_memory to simplify it. */
1047 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1048 gdb_byte
*pattern
, unsigned pattern_len
,
1049 gdb_byte
*search_buf
,
1050 unsigned chunk_size
, unsigned search_buf_size
,
1051 CORE_ADDR
*found_addrp
)
1053 /* Prime the search buffer. */
1055 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1058 warning ("Unable to access %ld bytes of target "
1059 "memory at 0x%lx, halting search.",
1060 (long) search_buf_size
, (long) start_addr
);
1064 /* Perform the search.
1066 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1067 When we've scanned N bytes we copy the trailing bytes to the start and
1068 read in another N bytes. */
1070 while (search_space_len
>= pattern_len
)
1072 gdb_byte
*found_ptr
;
1073 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1077 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1080 if (found_ptr
!= NULL
)
1082 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1083 *found_addrp
= found_addr
;
1087 /* Not found in this chunk, skip to next chunk. */
1089 /* Don't let search_space_len wrap here, it's unsigned. */
1090 if (search_space_len
>= chunk_size
)
1091 search_space_len
-= chunk_size
;
1093 search_space_len
= 0;
1095 if (search_space_len
>= pattern_len
)
1097 unsigned keep_len
= search_buf_size
- chunk_size
;
1098 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1101 /* Copy the trailing part of the previous iteration to the front
1102 of the buffer for the next iteration. */
1103 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1105 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1106 ? search_space_len
- keep_len
1109 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1110 nr_to_read
) != search_buf_size
)
1112 warning ("Unable to access %ld bytes of target memory "
1113 "at 0x%lx, halting search.",
1114 (long) nr_to_read
, (long) read_addr
);
1118 start_addr
+= chunk_size
;
1127 /* Handle qSearch:memory packets. */
1130 handle_search_memory (char *own_buf
, int packet_len
)
1132 CORE_ADDR start_addr
;
1133 CORE_ADDR search_space_len
;
1135 unsigned int pattern_len
;
1136 /* NOTE: also defined in find.c testcase. */
1137 #define SEARCH_CHUNK_SIZE 16000
1138 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1139 /* Buffer to hold memory contents for searching. */
1140 gdb_byte
*search_buf
;
1141 unsigned search_buf_size
;
1143 CORE_ADDR found_addr
;
1144 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1146 pattern
= (gdb_byte
*) malloc (packet_len
);
1147 if (pattern
== NULL
)
1149 error ("Unable to allocate memory to perform the search");
1150 strcpy (own_buf
, "E00");
1153 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1154 packet_len
- cmd_name_len
,
1155 &start_addr
, &search_space_len
,
1156 pattern
, &pattern_len
) < 0)
1159 error ("Error in parsing qSearch:memory packet");
1160 strcpy (own_buf
, "E00");
1164 search_buf_size
= chunk_size
+ pattern_len
- 1;
1166 /* No point in trying to allocate a buffer larger than the search space. */
1167 if (search_space_len
< search_buf_size
)
1168 search_buf_size
= search_space_len
;
1170 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1171 if (search_buf
== NULL
)
1174 error ("Unable to allocate memory to perform the search");
1175 strcpy (own_buf
, "E00");
1179 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1180 pattern
, pattern_len
,
1181 search_buf
, chunk_size
, search_buf_size
,
1185 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1186 else if (found
== 0)
1187 strcpy (own_buf
, "0");
1189 strcpy (own_buf
, "E00");
1195 /* Handle the "D" packet. */
1198 handle_detach (char *own_buf
)
1200 client_state
&cs
= get_client_state ();
1202 process_info
*process
;
1204 if (cs
.multi_process
)
1207 int pid
= strtol (&own_buf
[2], NULL
, 16);
1209 process
= find_process_pid (pid
);
1213 process
= (current_thread
!= nullptr
1214 ? get_thread_process (current_thread
)
1218 if (process
== NULL
)
1220 write_enn (own_buf
);
1224 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1226 if (tracing
&& disconnected_tracing
)
1228 "Disconnected tracing in effect, "
1229 "leaving gdbserver attached to the process\n");
1231 if (any_persistent_commands (process
))
1233 "Persistent commands are present, "
1234 "leaving gdbserver attached to the process\n");
1236 /* Make sure we're in non-stop/async mode, so we we can both
1237 wait for an async socket accept, and handle async target
1238 events simultaneously. There's also no point either in
1239 having the target stop all threads, when we're going to
1240 pass signals down without informing GDB. */
1244 debug_printf ("Forcing non-stop mode\n");
1250 process
->gdb_detached
= 1;
1252 /* Detaching implicitly resumes all threads. */
1253 target_continue_no_signal (minus_one_ptid
);
1259 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1262 /* We'll need this after PROCESS has been destroyed. */
1263 int pid
= process
->pid
;
1265 if (detach_inferior (process
) != 0)
1266 write_enn (own_buf
);
1269 discard_queued_stop_replies (ptid_t (pid
));
1272 if (extended_protocol
|| target_running ())
1274 /* There is still at least one inferior remaining or
1275 we are in extended mode, so don't terminate gdbserver,
1276 and instead treat this like a normal program exit. */
1277 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1278 cs
.last_status
.value
.integer
= 0;
1279 cs
.last_ptid
= ptid_t (pid
);
1281 current_thread
= NULL
;
1288 /* If we are attached, then we can exit. Otherwise, we
1289 need to hang around doing nothing, until the child is
1291 join_inferior (pid
);
1297 /* Parse options to --debug-format= and "monitor set debug-format".
1298 ARG is the text after "--debug-format=" or "monitor set debug-format".
1299 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1300 This triggers calls to monitor_output.
1301 The result is an empty string if all options were parsed ok, otherwise an
1302 error message which the caller must free.
1304 N.B. These commands affect all debug format settings, they are not
1305 cumulative. If a format is not specified, it is turned off.
1306 However, we don't go to extra trouble with things like
1307 "monitor set debug-format all,none,timestamp".
1308 Instead we just parse them one at a time, in order.
1310 The syntax for "monitor set debug" we support here is not identical
1311 to gdb's "set debug foo on|off" because we also use this function to
1312 parse "--debug-format=foo,bar". */
1315 parse_debug_format_options (const char *arg
, int is_monitor
)
1317 /* First turn all debug format options off. */
1318 debug_timestamp
= 0;
1320 /* First remove leading spaces, for "monitor set debug-format". */
1321 while (isspace (*arg
))
1324 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1325 = delim_string_to_char_ptr_vec (arg
, ',');
1327 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1329 if (strcmp (option
.get (), "all") == 0)
1331 debug_timestamp
= 1;
1333 monitor_output ("All extra debug format options enabled.\n");
1335 else if (strcmp (option
.get (), "none") == 0)
1337 debug_timestamp
= 0;
1339 monitor_output ("All extra debug format options disabled.\n");
1341 else if (strcmp (option
.get (), "timestamp") == 0)
1343 debug_timestamp
= 1;
1345 monitor_output ("Timestamps will be added to debug output.\n");
1347 else if (*option
== '\0')
1349 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1353 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1357 return std::string ();
1360 /* Handle monitor commands not handled by target-specific handlers. */
1363 handle_monitor_command (char *mon
, char *own_buf
)
1365 if (strcmp (mon
, "set debug 1") == 0)
1368 monitor_output ("Debug output enabled.\n");
1370 else if (strcmp (mon
, "set debug 0") == 0)
1373 monitor_output ("Debug output disabled.\n");
1375 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1377 show_debug_regs
= 1;
1378 monitor_output ("H/W point debugging output enabled.\n");
1380 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1382 show_debug_regs
= 0;
1383 monitor_output ("H/W point debugging output disabled.\n");
1385 else if (strcmp (mon
, "set remote-debug 1") == 0)
1388 monitor_output ("Protocol debug output enabled.\n");
1390 else if (strcmp (mon
, "set remote-debug 0") == 0)
1393 monitor_output ("Protocol debug output disabled.\n");
1395 else if (startswith (mon
, "set debug-format "))
1397 std::string error_msg
1398 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1401 if (!error_msg
.empty ())
1403 monitor_output (error_msg
.c_str ());
1404 monitor_show_help ();
1405 write_enn (own_buf
);
1408 else if (strcmp (mon
, "help") == 0)
1409 monitor_show_help ();
1410 else if (strcmp (mon
, "exit") == 0)
1414 monitor_output ("Unknown monitor command.\n\n");
1415 monitor_show_help ();
1416 write_enn (own_buf
);
1420 /* Associates a callback with each supported qXfer'able object. */
1424 /* The object this handler handles. */
1427 /* Request that the target transfer up to LEN 8-bit bytes of the
1428 target's OBJECT. The OFFSET, for a seekable object, specifies
1429 the starting point. The ANNEX can be used to provide additional
1430 data-specific information to the target.
1432 Return the number of bytes actually transfered, zero when no
1433 further transfer is possible, -1 on error, -2 when the transfer
1434 is not supported, and -3 on a verbose error message that should
1435 be preserved. Return of a positive value smaller than LEN does
1436 not indicate the end of the object, only the end of the transfer.
1438 One, and only one, of readbuf or writebuf must be non-NULL. */
1439 int (*xfer
) (const char *annex
,
1440 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1441 ULONGEST offset
, LONGEST len
);
1444 /* Handle qXfer:auxv:read. */
1447 handle_qxfer_auxv (const char *annex
,
1448 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1449 ULONGEST offset
, LONGEST len
)
1451 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1454 if (annex
[0] != '\0' || current_thread
== NULL
)
1457 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1460 /* Handle qXfer:exec-file:read. */
1463 handle_qxfer_exec_file (const char *annex
,
1464 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1465 ULONGEST offset
, LONGEST len
)
1471 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1474 if (annex
[0] == '\0')
1476 if (current_thread
== NULL
)
1479 pid
= pid_of (current_thread
);
1483 annex
= unpack_varlen_hex (annex
, &pid
);
1484 if (annex
[0] != '\0')
1491 file
= (*the_target
->pid_to_exec_file
) (pid
);
1495 total_len
= strlen (file
);
1497 if (offset
> total_len
)
1500 if (offset
+ len
> total_len
)
1501 len
= total_len
- offset
;
1503 memcpy (readbuf
, file
+ offset
, len
);
1507 /* Handle qXfer:features:read. */
1510 handle_qxfer_features (const char *annex
,
1511 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1512 ULONGEST offset
, LONGEST len
)
1514 const char *document
;
1517 if (writebuf
!= NULL
)
1520 if (!target_running ())
1523 /* Grab the correct annex. */
1524 document
= get_features_xml (annex
);
1525 if (document
== NULL
)
1528 total_len
= strlen (document
);
1530 if (offset
> total_len
)
1533 if (offset
+ len
> total_len
)
1534 len
= total_len
- offset
;
1536 memcpy (readbuf
, document
+ offset
, len
);
1540 /* Handle qXfer:libraries:read. */
1543 handle_qxfer_libraries (const char *annex
,
1544 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1545 ULONGEST offset
, LONGEST len
)
1547 if (writebuf
!= NULL
)
1550 if (annex
[0] != '\0' || current_thread
== NULL
)
1553 std::string document
= "<library-list version=\"1.0\">\n";
1555 for (const dll_info
&dll
: all_dlls
)
1556 document
+= string_printf
1557 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1558 dll
.name
.c_str (), (long) dll
.base_addr
);
1560 document
+= "</library-list>\n";
1562 if (offset
> document
.length ())
1565 if (offset
+ len
> document
.length ())
1566 len
= document
.length () - offset
;
1568 memcpy (readbuf
, &document
[offset
], len
);
1573 /* Handle qXfer:libraries-svr4:read. */
1576 handle_qxfer_libraries_svr4 (const char *annex
,
1577 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1578 ULONGEST offset
, LONGEST len
)
1580 if (writebuf
!= NULL
)
1583 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1586 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1589 /* Handle qXfer:osadata:read. */
1592 handle_qxfer_osdata (const char *annex
,
1593 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1594 ULONGEST offset
, LONGEST len
)
1596 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1599 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1602 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1605 handle_qxfer_siginfo (const char *annex
,
1606 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1607 ULONGEST offset
, LONGEST len
)
1609 if (the_target
->qxfer_siginfo
== NULL
)
1612 if (annex
[0] != '\0' || current_thread
== NULL
)
1615 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1618 /* Handle qXfer:spu:read and qXfer:spu:write. */
1621 handle_qxfer_spu (const char *annex
,
1622 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1623 ULONGEST offset
, LONGEST len
)
1625 if (the_target
->qxfer_spu
== NULL
)
1628 if (current_thread
== NULL
)
1631 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1634 /* Handle qXfer:statictrace:read. */
1637 handle_qxfer_statictrace (const char *annex
,
1638 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1639 ULONGEST offset
, LONGEST len
)
1641 client_state
&cs
= get_client_state ();
1644 if (writebuf
!= NULL
)
1647 if (annex
[0] != '\0' || current_thread
== NULL
1648 || cs
.current_traceframe
== -1)
1651 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1652 readbuf
, len
, &nbytes
))
1657 /* Helper for handle_qxfer_threads_proper.
1658 Emit the XML to describe the thread of INF. */
1661 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1663 ptid_t ptid
= ptid_of (thread
);
1665 int core
= target_core_of_thread (ptid
);
1667 const char *name
= target_thread_name (ptid
);
1670 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1672 write_ptid (ptid_s
, ptid
);
1674 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1678 sprintf (core_s
, "%d", core
);
1679 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1683 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1687 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1688 bin2hex (handle
, handle_s
, handle_len
);
1689 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1692 buffer_xml_printf (buffer
, "/>\n");
1695 /* Helper for handle_qxfer_threads. */
1698 handle_qxfer_threads_proper (struct buffer
*buffer
)
1700 buffer_grow_str (buffer
, "<threads>\n");
1702 for_each_thread ([&] (thread_info
*thread
)
1704 handle_qxfer_threads_worker (thread
, buffer
);
1707 buffer_grow_str0 (buffer
, "</threads>\n");
1710 /* Handle qXfer:threads:read. */
1713 handle_qxfer_threads (const char *annex
,
1714 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1715 ULONGEST offset
, LONGEST len
)
1717 static char *result
= 0;
1718 static unsigned int result_length
= 0;
1720 if (writebuf
!= NULL
)
1723 if (annex
[0] != '\0')
1728 struct buffer buffer
;
1729 /* When asked for data at offset 0, generate everything and store into
1730 'result'. Successive reads will be served off 'result'. */
1734 buffer_init (&buffer
);
1736 handle_qxfer_threads_proper (&buffer
);
1738 result
= buffer_finish (&buffer
);
1739 result_length
= strlen (result
);
1740 buffer_free (&buffer
);
1743 if (offset
>= result_length
)
1745 /* We're out of data. */
1752 if (len
> result_length
- offset
)
1753 len
= result_length
- offset
;
1755 memcpy (readbuf
, result
+ offset
, len
);
1760 /* Handle qXfer:traceframe-info:read. */
1763 handle_qxfer_traceframe_info (const char *annex
,
1764 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1765 ULONGEST offset
, LONGEST len
)
1767 client_state
&cs
= get_client_state ();
1768 static char *result
= 0;
1769 static unsigned int result_length
= 0;
1771 if (writebuf
!= NULL
)
1774 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1779 struct buffer buffer
;
1781 /* When asked for data at offset 0, generate everything and
1782 store into 'result'. Successive reads will be served off
1786 buffer_init (&buffer
);
1788 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1790 result
= buffer_finish (&buffer
);
1791 result_length
= strlen (result
);
1792 buffer_free (&buffer
);
1795 if (offset
>= result_length
)
1797 /* We're out of data. */
1804 if (len
> result_length
- offset
)
1805 len
= result_length
- offset
;
1807 memcpy (readbuf
, result
+ offset
, len
);
1811 /* Handle qXfer:fdpic:read. */
1814 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1815 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1817 if (the_target
->read_loadmap
== NULL
)
1820 if (current_thread
== NULL
)
1823 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1826 /* Handle qXfer:btrace:read. */
1829 handle_qxfer_btrace (const char *annex
,
1830 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1831 ULONGEST offset
, LONGEST len
)
1833 client_state
&cs
= get_client_state ();
1834 static struct buffer cache
;
1835 struct thread_info
*thread
;
1836 enum btrace_read_type type
;
1839 if (writebuf
!= NULL
)
1842 if (cs
.general_thread
== null_ptid
1843 || cs
.general_thread
== minus_one_ptid
)
1845 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1849 thread
= find_thread_ptid (cs
.general_thread
);
1852 strcpy (cs
.own_buf
, "E.No such thread.");
1856 if (thread
->btrace
== NULL
)
1858 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1862 if (strcmp (annex
, "all") == 0)
1863 type
= BTRACE_READ_ALL
;
1864 else if (strcmp (annex
, "new") == 0)
1865 type
= BTRACE_READ_NEW
;
1866 else if (strcmp (annex
, "delta") == 0)
1867 type
= BTRACE_READ_DELTA
;
1870 strcpy (cs
.own_buf
, "E.Bad annex.");
1876 buffer_free (&cache
);
1880 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1882 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1884 catch (const gdb_exception_error
&exception
)
1886 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1893 else if (offset
> cache
.used_size
)
1895 buffer_free (&cache
);
1899 if (len
> cache
.used_size
- offset
)
1900 len
= cache
.used_size
- offset
;
1902 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1907 /* Handle qXfer:btrace-conf:read. */
1910 handle_qxfer_btrace_conf (const char *annex
,
1911 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1912 ULONGEST offset
, LONGEST len
)
1914 client_state
&cs
= get_client_state ();
1915 static struct buffer cache
;
1916 struct thread_info
*thread
;
1919 if (writebuf
!= NULL
)
1922 if (annex
[0] != '\0')
1925 if (cs
.general_thread
== null_ptid
1926 || cs
.general_thread
== minus_one_ptid
)
1928 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1932 thread
= find_thread_ptid (cs
.general_thread
);
1935 strcpy (cs
.own_buf
, "E.No such thread.");
1939 if (thread
->btrace
== NULL
)
1941 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1947 buffer_free (&cache
);
1951 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1953 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1955 catch (const gdb_exception_error
&exception
)
1957 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1964 else if (offset
> cache
.used_size
)
1966 buffer_free (&cache
);
1970 if (len
> cache
.used_size
- offset
)
1971 len
= cache
.used_size
- offset
;
1973 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1978 static const struct qxfer qxfer_packets
[] =
1980 { "auxv", handle_qxfer_auxv
},
1981 { "btrace", handle_qxfer_btrace
},
1982 { "btrace-conf", handle_qxfer_btrace_conf
},
1983 { "exec-file", handle_qxfer_exec_file
},
1984 { "fdpic", handle_qxfer_fdpic
},
1985 { "features", handle_qxfer_features
},
1986 { "libraries", handle_qxfer_libraries
},
1987 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1988 { "osdata", handle_qxfer_osdata
},
1989 { "siginfo", handle_qxfer_siginfo
},
1990 { "spu", handle_qxfer_spu
},
1991 { "statictrace", handle_qxfer_statictrace
},
1992 { "threads", handle_qxfer_threads
},
1993 { "traceframe-info", handle_qxfer_traceframe_info
},
1997 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2005 if (!startswith (own_buf
, "qXfer:"))
2008 /* Grab the object, r/w and annex. */
2009 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2011 write_enn (own_buf
);
2016 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2019 const struct qxfer
*q
= &qxfer_packets
[i
];
2021 if (strcmp (object
, q
->object
) == 0)
2023 if (strcmp (rw
, "read") == 0)
2025 unsigned char *data
;
2030 /* Grab the offset and length. */
2031 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2033 write_enn (own_buf
);
2037 /* Read one extra byte, as an indicator of whether there is
2039 if (len
> PBUFSIZ
- 2)
2041 data
= (unsigned char *) malloc (len
+ 1);
2044 write_enn (own_buf
);
2047 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2055 /* Preserve error message. */
2058 write_enn (own_buf
);
2060 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2062 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2067 else if (strcmp (rw
, "write") == 0)
2072 unsigned char *data
;
2074 strcpy (own_buf
, "E00");
2075 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2078 write_enn (own_buf
);
2081 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2082 &ofs
, &len
, data
) < 0)
2085 write_enn (own_buf
);
2089 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2097 /* Preserve error message. */
2100 write_enn (own_buf
);
2102 sprintf (own_buf
, "%x", n
);
2115 /* Compute 32 bit CRC from inferior memory.
2117 On success, return 32 bit CRC.
2118 On failure, return (unsigned long long) -1. */
2120 static unsigned long long
2121 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2125 unsigned char byte
= 0;
2127 /* Return failure if memory read fails. */
2128 if (read_inferior_memory (base
, &byte
, 1) != 0)
2129 return (unsigned long long) -1;
2131 crc
= xcrc32 (&byte
, 1, crc
);
2134 return (unsigned long long) crc
;
2137 /* Add supported btrace packets to BUF. */
2140 supported_btrace_packets (char *buf
)
2142 strcat (buf
, ";Qbtrace:bts+");
2143 strcat (buf
, ";Qbtrace-conf:bts:size+");
2144 strcat (buf
, ";Qbtrace:pt+");
2145 strcat (buf
, ";Qbtrace-conf:pt:size+");
2146 strcat (buf
, ";Qbtrace:off+");
2147 strcat (buf
, ";qXfer:btrace:read+");
2148 strcat (buf
, ";qXfer:btrace-conf:read+");
2151 /* Handle all of the extended 'q' packets. */
2154 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2156 client_state
&cs
= get_client_state ();
2157 static std::list
<thread_info
*>::const_iterator thread_iter
;
2159 /* Reply the current thread id. */
2160 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2163 require_running_or_return (own_buf
);
2165 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2166 ptid
= cs
.general_thread
;
2169 thread_iter
= all_threads
.begin ();
2170 ptid
= (*thread_iter
)->id
;
2173 sprintf (own_buf
, "QC");
2175 write_ptid (own_buf
, ptid
);
2179 if (strcmp ("qSymbol::", own_buf
) == 0)
2181 struct thread_info
*save_thread
= current_thread
;
2183 /* For qSymbol, GDB only changes the current thread if the
2184 previous current thread was of a different process. So if
2185 the previous thread is gone, we need to pick another one of
2186 the same process. This can happen e.g., if we followed an
2187 exec in a non-leader thread. */
2188 if (current_thread
== NULL
)
2191 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2193 /* Just in case, if we didn't find a thread, then bail out
2194 instead of crashing. */
2195 if (current_thread
== NULL
)
2197 write_enn (own_buf
);
2198 current_thread
= save_thread
;
2203 /* GDB is suggesting new symbols have been loaded. This may
2204 mean a new shared library has been detected as loaded, so
2205 take the opportunity to check if breakpoints we think are
2206 inserted, still are. Note that it isn't guaranteed that
2207 we'll see this when a shared library is loaded, and nor will
2208 we see this for unloads (although breakpoints in unloaded
2209 libraries shouldn't trigger), as GDB may not find symbols for
2210 the library at all. We also re-validate breakpoints when we
2211 see a second GDB breakpoint for the same address, and or when
2212 we access breakpoint shadows. */
2213 validate_breakpoints ();
2215 if (target_supports_tracepoints ())
2216 tracepoint_look_up_symbols ();
2218 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2219 (*the_target
->look_up_symbols
) ();
2221 current_thread
= save_thread
;
2223 strcpy (own_buf
, "OK");
2227 if (!disable_packet_qfThreadInfo
)
2229 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2231 require_running_or_return (own_buf
);
2232 thread_iter
= all_threads
.begin ();
2235 ptid_t ptid
= (*thread_iter
)->id
;
2236 write_ptid (own_buf
, ptid
);
2241 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2243 require_running_or_return (own_buf
);
2244 if (thread_iter
!= all_threads
.end ())
2247 ptid_t ptid
= (*thread_iter
)->id
;
2248 write_ptid (own_buf
, ptid
);
2254 sprintf (own_buf
, "l");
2260 if (the_target
->read_offsets
!= NULL
2261 && strcmp ("qOffsets", own_buf
) == 0)
2263 CORE_ADDR text
, data
;
2265 require_running_or_return (own_buf
);
2266 if (the_target
->read_offsets (&text
, &data
))
2267 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2268 (long)text
, (long)data
, (long)data
);
2270 write_enn (own_buf
);
2275 /* Protocol features query. */
2276 if (startswith (own_buf
, "qSupported")
2277 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2279 char *p
= &own_buf
[10];
2280 int gdb_supports_qRelocInsn
= 0;
2282 /* Process each feature being provided by GDB. The first
2283 feature will follow a ':', and latter features will follow
2287 char **qsupported
= NULL
;
2292 /* Two passes, to avoid nested strtok calls in
2293 target_process_qsupported. */
2294 for (p
= strtok (p
+ 1, ";");
2296 p
= strtok (NULL
, ";"))
2299 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2300 qsupported
[count
- 1] = xstrdup (p
);
2303 for (i
= 0; i
< count
; i
++)
2306 if (strcmp (p
, "multiprocess+") == 0)
2308 /* GDB supports and wants multi-process support if
2310 if (target_supports_multi_process ())
2311 cs
.multi_process
= 1;
2313 else if (strcmp (p
, "qRelocInsn+") == 0)
2315 /* GDB supports relocate instruction requests. */
2316 gdb_supports_qRelocInsn
= 1;
2318 else if (strcmp (p
, "swbreak+") == 0)
2320 /* GDB wants us to report whether a trap is caused
2321 by a software breakpoint and for us to handle PC
2322 adjustment if necessary on this target. */
2323 if (target_supports_stopped_by_sw_breakpoint ())
2324 cs
.swbreak_feature
= 1;
2326 else if (strcmp (p
, "hwbreak+") == 0)
2328 /* GDB wants us to report whether a trap is caused
2329 by a hardware breakpoint. */
2330 if (target_supports_stopped_by_hw_breakpoint ())
2331 cs
.hwbreak_feature
= 1;
2333 else if (strcmp (p
, "fork-events+") == 0)
2335 /* GDB supports and wants fork events if possible. */
2336 if (target_supports_fork_events ())
2337 cs
.report_fork_events
= 1;
2339 else if (strcmp (p
, "vfork-events+") == 0)
2341 /* GDB supports and wants vfork events if possible. */
2342 if (target_supports_vfork_events ())
2343 cs
.report_vfork_events
= 1;
2345 else if (strcmp (p
, "exec-events+") == 0)
2347 /* GDB supports and wants exec events if possible. */
2348 if (target_supports_exec_events ())
2349 cs
.report_exec_events
= 1;
2351 else if (strcmp (p
, "vContSupported+") == 0)
2352 cs
.vCont_supported
= 1;
2353 else if (strcmp (p
, "QThreadEvents+") == 0)
2355 else if (strcmp (p
, "no-resumed+") == 0)
2357 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2359 report_no_resumed
= 1;
2363 /* Move the unknown features all together. */
2364 qsupported
[i
] = NULL
;
2365 qsupported
[unknown
] = p
;
2370 /* Give the target backend a chance to process the unknown
2372 target_process_qsupported (qsupported
, unknown
);
2374 for (i
= 0; i
< count
; i
++)
2375 free (qsupported
[i
]);
2380 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2381 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2382 "QEnvironmentReset+;QEnvironmentUnset+;"
2386 if (target_supports_catch_syscall ())
2387 strcat (own_buf
, ";QCatchSyscalls+");
2389 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2390 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2391 ";augmented-libraries-svr4-read+");
2394 /* We do not have any hook to indicate whether the non-SVR4 target
2395 backend supports qXfer:libraries:read, so always report it. */
2396 strcat (own_buf
, ";qXfer:libraries:read+");
2399 if (the_target
->read_auxv
!= NULL
)
2400 strcat (own_buf
, ";qXfer:auxv:read+");
2402 if (the_target
->qxfer_spu
!= NULL
)
2403 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2405 if (the_target
->qxfer_siginfo
!= NULL
)
2406 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2408 if (the_target
->read_loadmap
!= NULL
)
2409 strcat (own_buf
, ";qXfer:fdpic:read+");
2411 /* We always report qXfer:features:read, as targets may
2412 install XML files on a subsequent call to arch_setup.
2413 If we reported to GDB on startup that we don't support
2414 qXfer:feature:read at all, we will never be re-queried. */
2415 strcat (own_buf
, ";qXfer:features:read+");
2417 if (cs
.transport_is_reliable
)
2418 strcat (own_buf
, ";QStartNoAckMode+");
2420 if (the_target
->qxfer_osdata
!= NULL
)
2421 strcat (own_buf
, ";qXfer:osdata:read+");
2423 if (target_supports_multi_process ())
2424 strcat (own_buf
, ";multiprocess+");
2426 if (target_supports_fork_events ())
2427 strcat (own_buf
, ";fork-events+");
2429 if (target_supports_vfork_events ())
2430 strcat (own_buf
, ";vfork-events+");
2432 if (target_supports_exec_events ())
2433 strcat (own_buf
, ";exec-events+");
2435 if (target_supports_non_stop ())
2436 strcat (own_buf
, ";QNonStop+");
2438 if (target_supports_disable_randomization ())
2439 strcat (own_buf
, ";QDisableRandomization+");
2441 strcat (own_buf
, ";qXfer:threads:read+");
2443 if (target_supports_tracepoints ())
2445 strcat (own_buf
, ";ConditionalTracepoints+");
2446 strcat (own_buf
, ";TraceStateVariables+");
2447 strcat (own_buf
, ";TracepointSource+");
2448 strcat (own_buf
, ";DisconnectedTracing+");
2449 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2450 strcat (own_buf
, ";FastTracepoints+");
2451 strcat (own_buf
, ";StaticTracepoints+");
2452 strcat (own_buf
, ";InstallInTrace+");
2453 strcat (own_buf
, ";qXfer:statictrace:read+");
2454 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2455 strcat (own_buf
, ";EnableDisableTracepoints+");
2456 strcat (own_buf
, ";QTBuffer:size+");
2457 strcat (own_buf
, ";tracenz+");
2460 if (target_supports_hardware_single_step ()
2461 || target_supports_software_single_step () )
2463 strcat (own_buf
, ";ConditionalBreakpoints+");
2465 strcat (own_buf
, ";BreakpointCommands+");
2467 if (target_supports_agent ())
2468 strcat (own_buf
, ";QAgent+");
2470 supported_btrace_packets (own_buf
);
2472 if (target_supports_stopped_by_sw_breakpoint ())
2473 strcat (own_buf
, ";swbreak+");
2475 if (target_supports_stopped_by_hw_breakpoint ())
2476 strcat (own_buf
, ";hwbreak+");
2478 if (the_target
->pid_to_exec_file
!= NULL
)
2479 strcat (own_buf
, ";qXfer:exec-file:read+");
2481 strcat (own_buf
, ";vContSupported+");
2483 strcat (own_buf
, ";QThreadEvents+");
2485 strcat (own_buf
, ";no-resumed+");
2487 /* Reinitialize components as needed for the new connection. */
2488 hostio_handle_new_gdb_connection ();
2489 target_handle_new_gdb_connection ();
2494 /* Thread-local storage support. */
2495 if (the_target
->get_tls_address
!= NULL
2496 && startswith (own_buf
, "qGetTLSAddr:"))
2498 char *p
= own_buf
+ 12;
2499 CORE_ADDR parts
[2], address
= 0;
2501 ptid_t ptid
= null_ptid
;
2503 require_running_or_return (own_buf
);
2505 for (i
= 0; i
< 3; i
++)
2513 p2
= strchr (p
, ',');
2526 ptid
= read_ptid (p
, NULL
);
2528 decode_address (&parts
[i
- 1], p
, len
);
2532 if (p
!= NULL
|| i
< 3)
2536 struct thread_info
*thread
= find_thread_ptid (ptid
);
2541 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2547 strcpy (own_buf
, paddress(address
));
2552 write_enn (own_buf
);
2556 /* Otherwise, pretend we do not understand this packet. */
2559 /* Windows OS Thread Information Block address support. */
2560 if (the_target
->get_tib_address
!= NULL
2561 && startswith (own_buf
, "qGetTIBAddr:"))
2566 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2568 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2571 strcpy (own_buf
, paddress(tlb
));
2576 write_enn (own_buf
);
2582 /* Handle "monitor" commands. */
2583 if (startswith (own_buf
, "qRcmd,"))
2585 char *mon
= (char *) malloc (PBUFSIZ
);
2586 int len
= strlen (own_buf
+ 6);
2590 write_enn (own_buf
);
2595 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2597 write_enn (own_buf
);
2601 mon
[len
/ 2] = '\0';
2605 if (the_target
->handle_monitor_command
== NULL
2606 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2607 /* Default processing. */
2608 handle_monitor_command (mon
, own_buf
);
2614 if (startswith (own_buf
, "qSearch:memory:"))
2616 require_running_or_return (own_buf
);
2617 handle_search_memory (own_buf
, packet_len
);
2621 if (strcmp (own_buf
, "qAttached") == 0
2622 || startswith (own_buf
, "qAttached:"))
2624 struct process_info
*process
;
2626 if (own_buf
[sizeof ("qAttached") - 1])
2628 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2629 process
= find_process_pid (pid
);
2633 require_running_or_return (own_buf
);
2634 process
= current_process ();
2637 if (process
== NULL
)
2639 write_enn (own_buf
);
2643 strcpy (own_buf
, process
->attached
? "1" : "0");
2647 if (startswith (own_buf
, "qCRC:"))
2649 /* CRC check (compare-section). */
2653 unsigned long long crc
;
2655 require_running_or_return (own_buf
);
2656 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2657 if (*comma
++ != ',')
2659 write_enn (own_buf
);
2662 len
= strtoul (comma
, NULL
, 16);
2663 crc
= crc32 (base
, len
, 0xffffffff);
2664 /* Check for memory failure. */
2665 if (crc
== (unsigned long long) -1)
2667 write_enn (own_buf
);
2670 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2674 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2677 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2680 /* Otherwise we didn't know what packet it was. Say we didn't
2685 static void gdb_wants_all_threads_stopped (void);
2686 static void resume (struct thread_resume
*actions
, size_t n
);
2688 /* The callback that is passed to visit_actioned_threads. */
2689 typedef int (visit_actioned_threads_callback_ftype
)
2690 (const struct thread_resume
*, struct thread_info
*);
2692 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2693 true if CALLBACK returns true. Returns false if no matching thread
2694 is found or CALLBACK results false.
2695 Note: This function is itself a callback for find_thread. */
2698 visit_actioned_threads (thread_info
*thread
,
2699 const struct thread_resume
*actions
,
2701 visit_actioned_threads_callback_ftype
*callback
)
2703 for (size_t i
= 0; i
< num_actions
; i
++)
2705 const struct thread_resume
*action
= &actions
[i
];
2707 if (action
->thread
== minus_one_ptid
2708 || action
->thread
== thread
->id
2709 || ((action
->thread
.pid ()
2710 == thread
->id
.pid ())
2711 && action
->thread
.lwp () == -1))
2713 if ((*callback
) (action
, thread
))
2721 /* Callback for visit_actioned_threads. If the thread has a pending
2722 status to report, report it now. */
2725 handle_pending_status (const struct thread_resume
*resumption
,
2726 struct thread_info
*thread
)
2728 client_state
&cs
= get_client_state ();
2729 if (thread
->status_pending_p
)
2731 thread
->status_pending_p
= 0;
2733 cs
.last_status
= thread
->last_status
;
2734 cs
.last_ptid
= thread
->id
;
2735 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2741 /* Parse vCont packets. */
2743 handle_v_cont (char *own_buf
)
2747 struct thread_resume
*resume_info
;
2748 struct thread_resume default_action
{ null_ptid
};
2750 /* Count the number of semicolons in the packet. There should be one
2751 for every action. */
2757 p
= strchr (p
, ';');
2760 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2761 if (resume_info
== NULL
)
2769 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2771 if (p
[0] == 's' || p
[0] == 'S')
2772 resume_info
[i
].kind
= resume_step
;
2773 else if (p
[0] == 'r')
2774 resume_info
[i
].kind
= resume_step
;
2775 else if (p
[0] == 'c' || p
[0] == 'C')
2776 resume_info
[i
].kind
= resume_continue
;
2777 else if (p
[0] == 't')
2778 resume_info
[i
].kind
= resume_stop
;
2782 if (p
[0] == 'S' || p
[0] == 'C')
2785 int sig
= strtol (p
+ 1, &q
, 16);
2790 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2792 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2794 else if (p
[0] == 'r')
2798 p
= unpack_varlen_hex (p
+ 1, &addr
);
2799 resume_info
[i
].step_range_start
= addr
;
2804 p
= unpack_varlen_hex (p
+ 1, &addr
);
2805 resume_info
[i
].step_range_end
= addr
;
2814 resume_info
[i
].thread
= minus_one_ptid
;
2815 default_action
= resume_info
[i
];
2817 /* Note: we don't increment i here, we'll overwrite this entry
2818 the next time through. */
2820 else if (p
[0] == ':')
2823 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2828 if (p
[0] != ';' && p
[0] != 0)
2831 resume_info
[i
].thread
= ptid
;
2838 resume_info
[i
] = default_action
;
2840 resume (resume_info
, n
);
2845 write_enn (own_buf
);
2850 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2853 resume (struct thread_resume
*actions
, size_t num_actions
)
2855 client_state
&cs
= get_client_state ();
2858 /* Check if among the threads that GDB wants actioned, there's
2859 one with a pending status to report. If so, skip actually
2860 resuming/stopping and report the pending event
2863 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2865 return visit_actioned_threads (thread
, actions
, num_actions
,
2866 handle_pending_status
);
2869 if (thread_with_status
!= NULL
)
2875 (*the_target
->resume
) (actions
, num_actions
);
2878 write_ok (cs
.own_buf
);
2881 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2883 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2884 && !report_no_resumed
)
2886 /* The client does not support this stop reply. At least
2888 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2889 disable_async_io ();
2893 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2894 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2895 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2896 current_thread
->last_status
= cs
.last_status
;
2898 /* From the client's perspective, all-stop mode always stops all
2899 threads implicitly (and the target backend has already done
2900 so by now). Tag all threads as "want-stopped", so we don't
2901 resume them implicitly without the client telling us to. */
2902 gdb_wants_all_threads_stopped ();
2903 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2904 disable_async_io ();
2906 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2907 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2908 target_mourn_inferior (cs
.last_ptid
);
2912 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2914 handle_v_attach (char *own_buf
)
2916 client_state
&cs
= get_client_state ();
2919 pid
= strtol (own_buf
+ 8, NULL
, 16);
2920 if (pid
!= 0 && attach_inferior (pid
) == 0)
2922 /* Don't report shared library events after attaching, even if
2923 some libraries are preloaded. GDB will always poll the
2924 library list. Avoids the "stopped by shared library event"
2925 notice on the GDB side. */
2930 /* In non-stop, we don't send a resume reply. Stop events
2931 will follow up using the normal notification
2936 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2942 write_enn (own_buf
);
2947 /* Run a new program. Return 1 if successful, 0 if failure. */
2949 handle_v_run (char *own_buf
)
2951 client_state
&cs
= get_client_state ();
2953 std::vector
<char *> new_argv
;
2954 char *new_program_name
= NULL
;
2958 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2964 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2966 next_p
= strchr (p
, ';');
2968 next_p
= p
+ strlen (p
);
2970 if (i
== 0 && p
== next_p
)
2972 /* No program specified. */
2973 new_program_name
= NULL
;
2975 else if (p
== next_p
)
2977 /* Empty argument. */
2978 new_argv
.push_back (xstrdup ("''"));
2982 size_t len
= (next_p
- p
) / 2;
2983 /* ARG is the unquoted argument received via the RSP. */
2984 char *arg
= (char *) xmalloc (len
+ 1);
2985 /* FULL_ARGS will contain the quoted version of ARG. */
2986 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2987 /* These are pointers used to navigate the strings above. */
2988 char *tmp_arg
= arg
;
2989 char *tmp_full_arg
= full_arg
;
2992 hex2bin (p
, (gdb_byte
*) arg
, len
);
2995 while (*tmp_arg
!= '\0')
3001 *tmp_full_arg
= '\'';
3007 /* Quote single quote. */
3008 *tmp_full_arg
= '\\';
3016 *tmp_full_arg
= *tmp_arg
;
3022 *tmp_full_arg
++ = '\'';
3024 /* Finish FULL_ARG and push it into the vector containing
3026 *tmp_full_arg
= '\0';
3028 new_program_name
= full_arg
;
3030 new_argv
.push_back (full_arg
);
3036 new_argv
.push_back (NULL
);
3038 if (new_program_name
== NULL
)
3040 /* GDB didn't specify a program to run. Use the program from the
3041 last run with the new argument list. */
3042 if (program_path
.get () == NULL
)
3044 write_enn (own_buf
);
3045 free_vector_argv (new_argv
);
3050 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3052 /* Free the old argv and install the new one. */
3053 free_vector_argv (program_args
);
3054 program_args
= new_argv
;
3056 create_inferior (program_path
.get (), program_args
);
3058 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3060 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3062 /* In non-stop, sending a resume reply doesn't set the general
3063 thread, but GDB assumes a vRun sets it (this is so GDB can
3064 query which is the main thread of the new inferior. */
3066 cs
.general_thread
= cs
.last_ptid
;
3072 write_enn (own_buf
);
3077 /* Kill process. Return 1 if successful, 0 if failure. */
3079 handle_v_kill (char *own_buf
)
3081 client_state
&cs
= get_client_state ();
3083 char *p
= &own_buf
[6];
3084 if (cs
.multi_process
)
3085 pid
= strtol (p
, NULL
, 16);
3089 process_info
*proc
= find_process_pid (pid
);
3091 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3093 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3094 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3095 cs
.last_ptid
= ptid_t (pid
);
3096 discard_queued_stop_replies (cs
.last_ptid
);
3102 write_enn (own_buf
);
3107 /* Handle all of the extended 'v' packets. */
3109 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3111 client_state
&cs
= get_client_state ();
3112 if (!disable_packet_vCont
)
3114 if (strcmp (own_buf
, "vCtrlC") == 0)
3116 (*the_target
->request_interrupt
) ();
3121 if (startswith (own_buf
, "vCont;"))
3123 handle_v_cont (own_buf
);
3127 if (startswith (own_buf
, "vCont?"))
3129 strcpy (own_buf
, "vCont;c;C;t");
3131 if (target_supports_hardware_single_step ()
3132 || target_supports_software_single_step ()
3133 || !cs
.vCont_supported
)
3135 /* If target supports single step either by hardware or by
3136 software, add actions s and S to the list of supported
3137 actions. On the other hand, if GDB doesn't request the
3138 supported vCont actions in qSupported packet, add s and
3139 S to the list too. */
3140 own_buf
= own_buf
+ strlen (own_buf
);
3141 strcpy (own_buf
, ";s;S");
3144 if (target_supports_range_stepping ())
3146 own_buf
= own_buf
+ strlen (own_buf
);
3147 strcpy (own_buf
, ";r");
3153 if (startswith (own_buf
, "vFile:")
3154 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3157 if (startswith (own_buf
, "vAttach;"))
3159 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3161 fprintf (stderr
, "Already debugging a process\n");
3162 write_enn (own_buf
);
3165 handle_v_attach (own_buf
);
3169 if (startswith (own_buf
, "vRun;"))
3171 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3173 fprintf (stderr
, "Already debugging a process\n");
3174 write_enn (own_buf
);
3177 handle_v_run (own_buf
);
3181 if (startswith (own_buf
, "vKill;"))
3183 if (!target_running ())
3185 fprintf (stderr
, "No process to kill\n");
3186 write_enn (own_buf
);
3189 handle_v_kill (own_buf
);
3193 if (handle_notif_ack (own_buf
, packet_len
))
3196 /* Otherwise we didn't know what packet it was. Say we didn't
3202 /* Resume thread and wait for another event. In non-stop mode,
3203 don't really wait here, but return immediatelly to the event
3206 myresume (char *own_buf
, int step
, int sig
)
3208 client_state
&cs
= get_client_state ();
3209 struct thread_resume resume_info
[2];
3211 int valid_cont_thread
;
3213 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3214 && cs
.cont_thread
!= minus_one_ptid
);
3216 if (step
|| sig
|| valid_cont_thread
)
3218 resume_info
[0].thread
= current_ptid
;
3220 resume_info
[0].kind
= resume_step
;
3222 resume_info
[0].kind
= resume_continue
;
3223 resume_info
[0].sig
= sig
;
3227 if (!valid_cont_thread
)
3229 resume_info
[n
].thread
= minus_one_ptid
;
3230 resume_info
[n
].kind
= resume_continue
;
3231 resume_info
[n
].sig
= 0;
3235 resume (resume_info
, n
);
3238 /* Callback for for_each_thread. Make a new stop reply for each
3242 queue_stop_reply_callback (thread_info
*thread
)
3244 /* For now, assume targets that don't have this callback also don't
3245 manage the thread's last_status field. */
3246 if (the_target
->thread_stopped
== NULL
)
3248 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3250 new_notif
->ptid
= thread
->id
;
3251 new_notif
->status
= thread
->last_status
;
3252 /* Pass the last stop reply back to GDB, but don't notify
3254 notif_event_enque (¬if_stop
,
3255 (struct notif_event
*) new_notif
);
3259 if (thread_stopped (thread
))
3263 std::string status_string
3264 = target_waitstatus_to_string (&thread
->last_status
);
3266 debug_printf ("Reporting thread %s as already stopped with %s\n",
3267 target_pid_to_str (thread
->id
),
3268 status_string
.c_str ());
3271 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3273 /* Pass the last stop reply back to GDB, but don't notify
3275 queue_stop_reply (thread
->id
, &thread
->last_status
);
3280 /* Set this inferior threads's state as "want-stopped". We won't
3281 resume this thread until the client gives us another action for
3285 gdb_wants_thread_stopped (thread_info
*thread
)
3287 thread
->last_resume_kind
= resume_stop
;
3289 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3291 /* Most threads are stopped implicitly (all-stop); tag that with
3293 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3294 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3298 /* Set all threads' states as "want-stopped". */
3301 gdb_wants_all_threads_stopped (void)
3303 for_each_thread (gdb_wants_thread_stopped
);
3306 /* Callback for for_each_thread. If the thread is stopped with an
3307 interesting event, mark it as having a pending event. */
3310 set_pending_status_callback (thread_info
*thread
)
3312 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3313 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3314 /* A breakpoint, watchpoint or finished step from a previous
3315 GDB run isn't considered interesting for a new GDB run.
3316 If we left those pending, the new GDB could consider them
3317 random SIGTRAPs. This leaves out real async traps. We'd
3318 have to peek into the (target-specific) siginfo to
3319 distinguish those. */
3320 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3321 thread
->status_pending_p
= 1;
3324 /* Status handler for the '?' packet. */
3327 handle_status (char *own_buf
)
3329 client_state
&cs
= get_client_state ();
3331 /* GDB is connected, don't forward events to the target anymore. */
3332 for_each_process ([] (process_info
*process
) {
3333 process
->gdb_detached
= 0;
3336 /* In non-stop mode, we must send a stop reply for each stopped
3337 thread. In all-stop mode, just send one for the first stopped
3342 for_each_thread (queue_stop_reply_callback
);
3344 /* The first is sent immediatly. OK is sent if there is no
3345 stopped thread, which is the same handling of the vStopped
3346 packet (by design). */
3347 notif_write_event (¬if_stop
, cs
.own_buf
);
3351 thread_info
*thread
= NULL
;
3354 stabilize_threads ();
3355 gdb_wants_all_threads_stopped ();
3357 /* We can only report one status, but we might be coming out of
3358 non-stop -- if more than one thread is stopped with
3359 interesting events, leave events for the threads we're not
3360 reporting now pending. They'll be reported the next time the
3361 threads are resumed. Start by marking all interesting events
3363 for_each_thread (set_pending_status_callback
);
3365 /* Prefer the last thread that reported an event to GDB (even if
3366 that was a GDB_SIGNAL_TRAP). */
3367 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3368 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3369 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3370 thread
= find_thread_ptid (cs
.last_ptid
);
3372 /* If the last event thread is not found for some reason, look
3373 for some other thread that might have an event to report. */
3375 thread
= find_thread ([] (thread_info
*thr_arg
)
3377 return thr_arg
->status_pending_p
;
3380 /* If we're still out of luck, simply pick the first thread in
3383 thread
= get_first_thread ();
3387 struct thread_info
*tp
= (struct thread_info
*) thread
;
3389 /* We're reporting this event, so it's no longer
3391 tp
->status_pending_p
= 0;
3393 /* GDB assumes the current thread is the thread we're
3394 reporting the status for. */
3395 cs
.general_thread
= thread
->id
;
3396 set_desired_thread ();
3398 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3399 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3402 strcpy (own_buf
, "W00");
3407 gdbserver_version (void)
3409 printf ("GNU gdbserver %s%s\n"
3410 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3411 "gdbserver is free software, covered by the "
3412 "GNU General Public License.\n"
3413 "This gdbserver was configured as \"%s\"\n",
3414 PKGVERSION
, version
, host_name
);
3418 gdbserver_usage (FILE *stream
)
3420 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3421 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3422 "\tgdbserver [OPTIONS] --multi COMM\n"
3424 "COMM may either be a tty device (for serial debugging),\n"
3425 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3426 "stdin/stdout of gdbserver.\n"
3427 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3428 "PID is the process ID to attach to, when --attach is specified.\n"
3430 "Operating modes:\n"
3432 " --attach Attach to running process PID.\n"
3433 " --multi Start server without a specific program, and\n"
3434 " only quit when explicitly commanded.\n"
3435 " --once Exit after the first connection has closed.\n"
3436 " --help Print this message and then exit.\n"
3437 " --version Display version information and exit.\n"
3441 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3442 " --disable-randomization\n"
3443 " Run PROG with address space randomization disabled.\n"
3444 " --no-disable-randomization\n"
3445 " Don't disable address space randomization when\n"
3447 " --startup-with-shell\n"
3448 " Start PROG using a shell. I.e., execs a shell that\n"
3449 " then execs PROG. (default)\n"
3450 " --no-startup-with-shell\n"
3451 " Exec PROG directly instead of using a shell.\n"
3452 " Disables argument globbing and variable substitution\n"
3453 " on UNIX-like systems.\n"
3457 " --debug Enable general debugging output.\n"
3458 " --debug-format=OPT1[,OPT2,...]\n"
3459 " Specify extra content in debugging output.\n"
3464 " --remote-debug Enable remote protocol debugging output.\n"
3465 " --disable-packet=OPT1[,OPT2,...]\n"
3466 " Disable support for RSP packets or features.\n"
3468 " vCont, Tthread, qC, qfThreadInfo and \n"
3469 " threads (disable all threading packets).\n"
3471 "For more information, consult the GDB manual (available as on-line \n"
3472 "info or a printed manual).\n");
3473 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3474 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3478 gdbserver_show_disableable (FILE *stream
)
3480 fprintf (stream
, "Disableable packets:\n"
3481 " vCont \tAll vCont packets\n"
3482 " qC \tQuerying the current thread\n"
3483 " qfThreadInfo\tThread listing\n"
3484 " Tthread \tPassing the thread specifier in the "
3485 "T stop reply packet\n"
3486 " threads \tAll of the above\n");
3490 kill_inferior_callback (process_info
*process
)
3492 kill_inferior (process
);
3493 discard_queued_stop_replies (ptid_t (process
->pid
));
3496 /* Call this when exiting gdbserver with possible inferiors that need
3497 to be killed or detached from. */
3500 detach_or_kill_for_exit (void)
3502 /* First print a list of the inferiors we will be killing/detaching.
3503 This is to assist the user, for example, in case the inferior unexpectedly
3504 dies after we exit: did we screw up or did the inferior exit on its own?
3505 Having this info will save some head-scratching. */
3507 if (have_started_inferiors_p ())
3509 fprintf (stderr
, "Killing process(es):");
3511 for_each_process ([] (process_info
*process
) {
3512 if (!process
->attached
)
3513 fprintf (stderr
, " %d", process
->pid
);
3516 fprintf (stderr
, "\n");
3518 if (have_attached_inferiors_p ())
3520 fprintf (stderr
, "Detaching process(es):");
3522 for_each_process ([] (process_info
*process
) {
3523 if (process
->attached
)
3524 fprintf (stderr
, " %d", process
->pid
);
3527 fprintf (stderr
, "\n");
3530 /* Now we can kill or detach the inferiors. */
3531 for_each_process ([] (process_info
*process
) {
3532 int pid
= process
->pid
;
3534 if (process
->attached
)
3535 detach_inferior (process
);
3537 kill_inferior (process
);
3539 discard_queued_stop_replies (ptid_t (pid
));
3543 /* Value that will be passed to exit(3) when gdbserver exits. */
3544 static int exit_code
;
3546 /* Wrapper for detach_or_kill_for_exit that catches and prints
3550 detach_or_kill_for_exit_cleanup ()
3554 detach_or_kill_for_exit ();
3556 catch (const gdb_exception
&exception
)
3559 fprintf (stderr
, "Detach or kill failed: %s\n",
3565 /* Main function. This is called by the real "main" function,
3566 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3568 static void ATTRIBUTE_NORETURN
3569 captured_main (int argc
, char *argv
[])
3574 const char *port
= NULL
;
3575 char **next_arg
= &argv
[1];
3576 volatile int multi_mode
= 0;
3577 volatile int attach
= 0;
3579 bool selftest
= false;
3581 const char *selftest_filter
= NULL
;
3584 current_directory
= getcwd (NULL
, 0);
3585 client_state
&cs
= get_client_state ();
3587 if (current_directory
== NULL
)
3589 error (_("Could not find current working directory: %s"),
3590 safe_strerror (errno
));
3593 while (*next_arg
!= NULL
&& **next_arg
== '-')
3595 if (strcmp (*next_arg
, "--version") == 0)
3597 gdbserver_version ();
3600 else if (strcmp (*next_arg
, "--help") == 0)
3602 gdbserver_usage (stdout
);
3605 else if (strcmp (*next_arg
, "--attach") == 0)
3607 else if (strcmp (*next_arg
, "--multi") == 0)
3609 else if (strcmp (*next_arg
, "--wrapper") == 0)
3616 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3618 wrapper_argv
+= *next_arg
;
3619 wrapper_argv
+= ' ';
3623 if (!wrapper_argv
.empty ())
3625 /* Erase the last whitespace. */
3626 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3629 if (next_arg
== tmp
|| *next_arg
== NULL
)
3631 gdbserver_usage (stderr
);
3635 /* Consume the "--". */
3638 else if (strcmp (*next_arg
, "--debug") == 0)
3640 else if (startswith (*next_arg
, "--debug-format="))
3642 std::string error_msg
3643 = parse_debug_format_options ((*next_arg
)
3644 + sizeof ("--debug-format=") - 1, 0);
3646 if (!error_msg
.empty ())
3648 fprintf (stderr
, "%s", error_msg
.c_str ());
3652 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3654 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3656 gdbserver_show_disableable (stdout
);
3659 else if (startswith (*next_arg
, "--disable-packet="))
3661 char *packets
, *tok
;
3663 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3664 for (tok
= strtok (packets
, ",");
3666 tok
= strtok (NULL
, ","))
3668 if (strcmp ("vCont", tok
) == 0)
3669 disable_packet_vCont
= 1;
3670 else if (strcmp ("Tthread", tok
) == 0)
3671 disable_packet_Tthread
= 1;
3672 else if (strcmp ("qC", tok
) == 0)
3673 disable_packet_qC
= 1;
3674 else if (strcmp ("qfThreadInfo", tok
) == 0)
3675 disable_packet_qfThreadInfo
= 1;
3676 else if (strcmp ("threads", tok
) == 0)
3678 disable_packet_vCont
= 1;
3679 disable_packet_Tthread
= 1;
3680 disable_packet_qC
= 1;
3681 disable_packet_qfThreadInfo
= 1;
3685 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3687 gdbserver_show_disableable (stderr
);
3692 else if (strcmp (*next_arg
, "-") == 0)
3694 /* "-" specifies a stdio connection and is a form of port
3696 port
= STDIO_CONNECTION_NAME
;
3700 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3701 cs
.disable_randomization
= 1;
3702 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3703 cs
.disable_randomization
= 0;
3704 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3705 startup_with_shell
= true;
3706 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3707 startup_with_shell
= false;
3708 else if (strcmp (*next_arg
, "--once") == 0)
3710 else if (strcmp (*next_arg
, "--selftest") == 0)
3712 else if (startswith (*next_arg
, "--selftest="))
3716 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3721 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3734 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3737 gdbserver_usage (stderr
);
3741 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3742 opened by remote_prepare. */
3745 save_original_signals_state (false);
3747 /* We need to know whether the remote connection is stdio before
3748 starting the inferior. Inferiors created in this scenario have
3749 stdin,stdout redirected. So do this here before we call
3752 remote_prepare (port
);
3757 /* --attach used to come after PORT, so allow it there for
3759 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3766 && (*next_arg
== NULL
3767 || (*next_arg
)[0] == '\0'
3768 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3770 || next_arg
[1] != NULL
))
3775 gdbserver_usage (stderr
);
3779 /* Gather information about the environment. */
3780 our_environ
= gdb_environ::from_host_environ ();
3782 initialize_async_io ();
3784 have_job_control ();
3785 initialize_event_loop ();
3786 if (target_supports_tracepoints ())
3787 initialize_tracepoint ();
3788 initialize_notif ();
3790 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3795 selftests::run_tests (selftest_filter
);
3797 printf (_("Selftests have been disabled for this build.\n"));
3799 throw_quit ("Quit");
3802 if (pid
== 0 && *next_arg
!= NULL
)
3806 n
= argc
- (next_arg
- argv
);
3807 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3808 for (i
= 1; i
< n
; i
++)
3809 program_args
.push_back (xstrdup (next_arg
[i
]));
3810 program_args
.push_back (NULL
);
3812 /* Wait till we are at first instruction in program. */
3813 create_inferior (program_path
.get (), program_args
);
3815 /* We are now (hopefully) stopped at the first instruction of
3816 the target process. This assumes that the target process was
3817 successfully created. */
3821 if (attach_inferior (pid
) == -1)
3822 error ("Attaching not supported on this target");
3824 /* Otherwise succeeded. */
3828 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3829 cs
.last_status
.value
.integer
= 0;
3830 cs
.last_ptid
= minus_one_ptid
;
3833 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3835 /* Don't report shared library events on the initial connection,
3836 even if some libraries are preloaded. Avoids the "stopped by
3837 shared library event" notice on gdb side. */
3840 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3841 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3846 if (!was_running
&& !multi_mode
)
3847 error ("No program to debug");
3852 cs
.multi_process
= 0;
3853 cs
.report_fork_events
= 0;
3854 cs
.report_vfork_events
= 0;
3855 cs
.report_exec_events
= 0;
3856 /* Be sure we're out of tfind mode. */
3857 cs
.current_traceframe
= -1;
3858 cs
.cont_thread
= null_ptid
;
3859 cs
.swbreak_feature
= 0;
3860 cs
.hwbreak_feature
= 0;
3861 cs
.vCont_supported
= 0;
3867 /* Wait for events. This will return when all event sources
3868 are removed from the event loop. */
3869 start_event_loop ();
3871 /* If an exit was requested (using the "monitor exit"
3872 command), terminate now. */
3874 throw_quit ("Quit");
3876 /* The only other way to get here is for getpkt to fail:
3878 - If --once was specified, we're done.
3880 - If not in extended-remote mode, and we're no longer
3881 debugging anything, simply exit: GDB has disconnected
3882 after processing the last process exit.
3884 - Otherwise, close the connection and reopen it at the
3886 if (run_once
|| (!extended_protocol
&& !target_running ()))
3887 throw_quit ("Quit");
3890 "Remote side has terminated connection. "
3891 "GDBserver will reopen the connection.\n");
3893 /* Get rid of any pending statuses. An eventual reconnection
3894 (by the same GDB instance or another) will refresh all its
3895 state from scratch. */
3896 discard_queued_stop_replies (minus_one_ptid
);
3897 for_each_thread ([] (thread_info
*thread
)
3899 thread
->status_pending_p
= 0;
3904 if (disconnected_tracing
)
3906 /* Try to enable non-stop/async mode, so we we can
3907 both wait for an async socket accept, and handle
3908 async target events simultaneously. There's also
3909 no point either in having the target always stop
3910 all threads, when we're going to pass signals
3911 down without informing GDB. */
3914 if (start_non_stop (1))
3917 /* Detaching implicitly resumes all threads;
3918 simply disconnecting does not. */
3924 "Disconnected tracing disabled; "
3925 "stopping trace run.\n");
3930 catch (const gdb_exception_error
&exception
)
3933 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3935 if (response_needed
)
3937 write_enn (cs
.own_buf
);
3938 putpkt (cs
.own_buf
);
3942 throw_quit ("Quit");
3947 /* Main function. */
3950 main (int argc
, char *argv
[])
3955 captured_main (argc
, argv
);
3957 catch (const gdb_exception
&exception
)
3959 if (exception
.reason
== RETURN_ERROR
)
3962 fprintf (stderr
, "%s\n", exception
.what ());
3963 fprintf (stderr
, "Exiting\n");
3970 gdb_assert_not_reached ("captured_main should never return");
3973 /* Process options coming from Z packets for a breakpoint. PACKET is
3974 the packet buffer. *PACKET is updated to point to the first char
3975 after the last processed option. */
3978 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3980 const char *dataptr
= *packet
;
3983 /* Check if data has the correct format. */
3984 if (*dataptr
!= ';')
3991 if (*dataptr
== ';')
3994 if (*dataptr
== 'X')
3996 /* Conditional expression. */
3998 debug_printf ("Found breakpoint condition.\n");
3999 if (!add_breakpoint_condition (bp
, &dataptr
))
4000 dataptr
= strchrnul (dataptr
, ';');
4002 else if (startswith (dataptr
, "cmds:"))
4004 dataptr
+= strlen ("cmds:");
4006 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4007 persist
= (*dataptr
== '1');
4009 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4010 dataptr
= strchrnul (dataptr
, ';');
4014 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4016 /* Skip tokens until we find one that we recognize. */
4017 dataptr
= strchrnul (dataptr
, ';');
4023 /* Event loop callback that handles a serial event. The first byte in
4024 the serial buffer gets us here. We expect characters to arrive at
4025 a brisk pace, so we read the rest of the packet with a blocking
4029 process_serial_event (void)
4031 client_state
&cs
= get_client_state ();
4037 int new_packet_len
= -1;
4039 disable_async_io ();
4041 response_needed
= 0;
4042 packet_len
= getpkt (cs
.own_buf
);
4043 if (packet_len
<= 0)
4046 /* Force an event loop break. */
4049 response_needed
= 1;
4051 char ch
= cs
.own_buf
[0];
4055 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4058 handle_general_set (cs
.own_buf
);
4061 handle_detach (cs
.own_buf
);
4064 extended_protocol
= 1;
4065 write_ok (cs
.own_buf
);
4068 handle_status (cs
.own_buf
);
4071 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4073 require_running_or_break (cs
.own_buf
);
4075 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4077 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4078 thread_id
= null_ptid
;
4079 else if (thread_id
.is_pid ())
4081 /* The ptid represents a pid. */
4082 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4086 write_enn (cs
.own_buf
);
4090 thread_id
= thread
->id
;
4094 /* The ptid represents a lwp/tid. */
4095 if (find_thread_ptid (thread_id
) == NULL
)
4097 write_enn (cs
.own_buf
);
4102 if (cs
.own_buf
[1] == 'g')
4104 if (thread_id
== null_ptid
)
4106 /* GDB is telling us to choose any thread. Check if
4107 the currently selected thread is still valid. If
4108 it is not, select the first available. */
4109 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4111 thread
= get_first_thread ();
4112 thread_id
= thread
->id
;
4115 cs
.general_thread
= thread_id
;
4116 set_desired_thread ();
4117 gdb_assert (current_thread
!= NULL
);
4119 else if (cs
.own_buf
[1] == 'c')
4120 cs
.cont_thread
= thread_id
;
4122 write_ok (cs
.own_buf
);
4126 /* Silently ignore it so that gdb can extend the protocol
4127 without compatibility headaches. */
4128 cs
.own_buf
[0] = '\0';
4132 require_running_or_break (cs
.own_buf
);
4133 if (cs
.current_traceframe
>= 0)
4135 struct regcache
*regcache
4136 = new_register_cache (current_target_desc ());
4138 if (fetch_traceframe_registers (cs
.current_traceframe
,
4140 registers_to_string (regcache
, cs
.own_buf
);
4142 write_enn (cs
.own_buf
);
4143 free_register_cache (regcache
);
4147 struct regcache
*regcache
;
4149 if (!set_desired_thread ())
4150 write_enn (cs
.own_buf
);
4153 regcache
= get_thread_regcache (current_thread
, 1);
4154 registers_to_string (regcache
, cs
.own_buf
);
4159 require_running_or_break (cs
.own_buf
);
4160 if (cs
.current_traceframe
>= 0)
4161 write_enn (cs
.own_buf
);
4164 struct regcache
*regcache
;
4166 if (!set_desired_thread ())
4167 write_enn (cs
.own_buf
);
4170 regcache
= get_thread_regcache (current_thread
, 1);
4171 registers_from_string (regcache
, &cs
.own_buf
[1]);
4172 write_ok (cs
.own_buf
);
4178 require_running_or_break (cs
.own_buf
);
4179 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4180 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4182 write_enn (cs
.own_buf
);
4184 bin2hex (mem_buf
, cs
.own_buf
, res
);
4188 require_running_or_break (cs
.own_buf
);
4189 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4190 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4191 write_ok (cs
.own_buf
);
4193 write_enn (cs
.own_buf
);
4196 require_running_or_break (cs
.own_buf
);
4197 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4198 &mem_addr
, &len
, &mem_buf
) < 0
4199 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4200 write_enn (cs
.own_buf
);
4202 write_ok (cs
.own_buf
);
4205 require_running_or_break (cs
.own_buf
);
4206 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4207 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4208 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4211 myresume (cs
.own_buf
, 0, signal
);
4214 require_running_or_break (cs
.own_buf
);
4215 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4216 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4217 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4220 myresume (cs
.own_buf
, 1, signal
);
4223 require_running_or_break (cs
.own_buf
);
4225 myresume (cs
.own_buf
, 0, signal
);
4228 require_running_or_break (cs
.own_buf
);
4230 myresume (cs
.own_buf
, 1, signal
);
4232 case 'Z': /* insert_ ... */
4234 case 'z': /* remove_ ... */
4239 char type
= cs
.own_buf
[1];
4241 const int insert
= ch
== 'Z';
4242 const char *p
= &cs
.own_buf
[3];
4244 p
= unpack_varlen_hex (p
, &addr
);
4245 kind
= strtol (p
+ 1, &dataptr
, 16);
4249 struct gdb_breakpoint
*bp
;
4251 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4256 /* GDB may have sent us a list of *point parameters to
4257 be evaluated on the target's side. Read such list
4258 here. If we already have a list of parameters, GDB
4259 is telling us to drop that list and use this one
4261 clear_breakpoint_conditions_and_commands (bp
);
4262 const char *options
= dataptr
;
4263 process_point_options (bp
, &options
);
4267 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4270 write_ok (cs
.own_buf
);
4273 cs
.own_buf
[0] = '\0';
4275 write_enn (cs
.own_buf
);
4279 response_needed
= 0;
4280 if (!target_running ())
4281 /* The packet we received doesn't make sense - but we can't
4282 reply to it, either. */
4285 fprintf (stderr
, "Killing all inferiors\n");
4287 for_each_process (kill_inferior_callback
);
4289 /* When using the extended protocol, we wait with no program
4290 running. The traditional protocol will exit instead. */
4291 if (extended_protocol
)
4293 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4294 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4302 require_running_or_break (cs
.own_buf
);
4304 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4305 if (find_thread_ptid (thread_id
) == NULL
)
4307 write_enn (cs
.own_buf
);
4311 if (mythread_alive (thread_id
))
4312 write_ok (cs
.own_buf
);
4314 write_enn (cs
.own_buf
);
4318 response_needed
= 0;
4320 /* Restarting the inferior is only supported in the extended
4322 if (extended_protocol
)
4324 if (target_running ())
4325 for_each_process (kill_inferior_callback
);
4327 fprintf (stderr
, "GDBserver restarting\n");
4329 /* Wait till we are at 1st instruction in prog. */
4330 if (program_path
.get () != NULL
)
4332 create_inferior (program_path
.get (), program_args
);
4334 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4336 /* Stopped at the first instruction of the target
4338 cs
.general_thread
= cs
.last_ptid
;
4342 /* Something went wrong. */
4343 cs
.general_thread
= null_ptid
;
4348 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4349 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4355 /* It is a request we don't understand. Respond with an
4356 empty packet so that gdb knows that we don't support this
4358 cs
.own_buf
[0] = '\0';
4362 /* Extended (long) request. */
4363 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4367 /* It is a request we don't understand. Respond with an empty
4368 packet so that gdb knows that we don't support this
4370 cs
.own_buf
[0] = '\0';
4374 if (new_packet_len
!= -1)
4375 putpkt_binary (cs
.own_buf
, new_packet_len
);
4377 putpkt (cs
.own_buf
);
4379 response_needed
= 0;
4387 /* Event-loop callback for serial events. */
4390 handle_serial_event (int err
, gdb_client_data client_data
)
4393 debug_printf ("handling possible serial event\n");
4395 /* Really handle it. */
4396 if (process_serial_event () < 0)
4399 /* Be sure to not change the selected thread behind GDB's back.
4400 Important in the non-stop mode asynchronous protocol. */
4401 set_desired_thread ();
4406 /* Push a stop notification on the notification queue. */
4409 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4411 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4413 vstop_notif
->status
= *status
;
4414 vstop_notif
->ptid
= ptid
;
4415 /* Push Stop notification. */
4416 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4419 /* Event-loop callback for target events. */
4422 handle_target_event (int err
, gdb_client_data client_data
)
4424 client_state
&cs
= get_client_state ();
4426 debug_printf ("handling possible target event\n");
4428 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4431 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4433 if (gdb_connected () && report_no_resumed
)
4434 push_stop_notification (null_ptid
, &cs
.last_status
);
4436 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4438 int pid
= cs
.last_ptid
.pid ();
4439 struct process_info
*process
= find_process_pid (pid
);
4440 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4442 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4443 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4445 mark_breakpoints_out (process
);
4446 target_mourn_inferior (cs
.last_ptid
);
4448 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4452 /* We're reporting this thread as stopped. Update its
4453 "want-stopped" state to what the client wants, until it
4454 gets a new resume action. */
4455 current_thread
->last_resume_kind
= resume_stop
;
4456 current_thread
->last_status
= cs
.last_status
;
4461 if (!target_running ())
4463 /* The last process exited. We're done. */
4467 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4468 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4469 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4473 /* A thread stopped with a signal, but gdb isn't
4474 connected to handle it. Pass it down to the
4475 inferior, as if it wasn't being traced. */
4476 enum gdb_signal signal
;
4479 debug_printf ("GDB not connected; forwarding event %d for"
4481 (int) cs
.last_status
.kind
,
4482 target_pid_to_str (cs
.last_ptid
));
4484 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4485 signal
= cs
.last_status
.value
.sig
;
4487 signal
= GDB_SIGNAL_0
;
4488 target_continue (cs
.last_ptid
, signal
);
4492 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4495 /* Be sure to not change the selected thread behind GDB's back.
4496 Important in the non-stop mode asynchronous protocol. */
4497 set_desired_thread ();
4510 } // namespace selftests
4511 #endif /* GDB_SELF_TEST */