1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2020 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 "gdbsupport/agent.h"
24 #include "gdbsupport/rsp-low.h"
25 #include "gdbsupport/signals-state-save-restore.h"
31 #include "gdbsupport/gdb_vecs.h"
32 #include "gdbsupport/gdb_wait.h"
33 #include "gdbsupport/btrace-common.h"
34 #include "gdbsupport/filestuff.h"
35 #include "tracepoint.h"
39 #include "gdbsupport/common-inferior.h"
40 #include "gdbsupport/job-control.h"
41 #include "gdbsupport/environ.h"
42 #include "filenames.h"
43 #include "gdbsupport/pathstuff.h"
45 #include "xml-builtin.h"
48 #include "gdbsupport/selftest.h"
49 #include "gdbsupport/scope-exit.h"
51 #define require_running_or_return(BUF) \
52 if (!target_running ()) \
58 #define require_running_or_break(BUF) \
59 if (!target_running ()) \
65 /* String containing the current directory (what getwd would return). */
67 char *current_directory
;
69 /* The environment to pass to the inferior when creating it. */
71 static gdb_environ our_environ
;
75 static bool extended_protocol
;
76 static bool response_needed
;
77 static bool exit_requested
;
79 /* --once: Exit after the first connection has closed. */
82 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
83 static bool report_no_resumed
;
88 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
90 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
92 m_path
= std::move (path
);
94 /* Make sure we're using the absolute path of the inferior when
96 if (!contains_dir_separator (m_path
.get ()))
100 /* Check if the file is in our CWD. If it is, then we prefix
101 its name with CURRENT_DIRECTORY. Otherwise, we leave the
102 name as-is because we'll try searching for it in $PATH. */
103 if (is_regular_file (m_path
.get (), ®_file_errno
))
104 m_path
= gdb_abspath (m_path
.get ());
108 /* Return the PROGRAM_PATH. */
110 { return m_path
.get (); }
113 /* The program name, adjusted if needed. */
114 gdb::unique_xmalloc_ptr
<char> m_path
;
116 static std::vector
<char *> program_args
;
117 static std::string wrapper_argv
;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid
;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 bool disable_packet_vCont
;
130 bool disable_packet_Tthread
;
131 bool disable_packet_qC
;
132 bool disable_packet_qfThreadInfo
;
133 bool disable_packet_T
;
135 static unsigned char *mem_buf
;
137 /* A sub-class of 'struct notif_event' for stop, holding information
138 relative to a single stop reply. We keep a queue of these to
139 push to GDB in non-stop mode. */
141 struct vstop_notif
: public notif_event
143 /* Thread or process that got the event. */
147 struct target_waitstatus status
;
150 /* The current btrace configuration. This is gdbserver's mirror of GDB's
151 btrace configuration. */
152 static struct btrace_config current_btrace_conf
;
154 /* The client remote protocol state. */
156 static client_state g_client_state
;
161 client_state
&cs
= g_client_state
;
166 /* Put a stop reply to the stop reply queue. */
169 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
171 struct vstop_notif
*new_notif
= new struct vstop_notif
;
173 new_notif
->ptid
= ptid
;
174 new_notif
->status
= *status
;
176 notif_event_enque (¬if_stop
, new_notif
);
180 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
182 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
184 return vstop_event
->ptid
.matches (filter_ptid
);
190 discard_queued_stop_replies (ptid_t ptid
)
192 std::list
<notif_event
*>::iterator iter
, next
, end
;
193 end
= notif_stop
.queue
.end ();
194 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
199 if (remove_all_on_match_ptid (*iter
, ptid
))
202 notif_stop
.queue
.erase (iter
);
208 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
210 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
212 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
215 /* Helper for in_queued_stop_replies. */
218 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
220 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
222 if (vstop_event
->ptid
.matches (filter_ptid
))
225 /* Don't resume fork children that GDB does not know about yet. */
226 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
227 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
228 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
237 in_queued_stop_replies (ptid_t ptid
)
239 for (notif_event
*event
: notif_stop
.queue
)
241 if (in_queued_stop_replies_ptid (event
, ptid
))
248 struct notif_server notif_stop
=
250 "vStopped", "Stop", {}, vstop_notif_reply
,
254 target_running (void)
256 return get_first_thread () != NULL
;
259 /* See gdbsupport/common-inferior.h. */
264 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
267 /* See gdbsupport/common-inferior.h. */
270 get_exec_file (int err
)
272 if (err
&& program_path
.get () == NULL
)
273 error (_("No executable file specified."));
275 return program_path
.get ();
287 attach_inferior (int pid
)
289 client_state
&cs
= get_client_state ();
290 /* myattach should return -1 if attaching is unsupported,
291 0 if it succeeded, and call error() otherwise. */
293 if (find_process_pid (pid
) != nullptr)
294 error ("Already attached to process %d\n", pid
);
296 if (myattach (pid
) != 0)
299 fprintf (stderr
, "Attached; pid = %d\n", pid
);
302 /* FIXME - It may be that we should get the SIGNAL_PID from the
303 attach function, so that it can be the main thread instead of
304 whichever we were told to attach to. */
309 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
311 /* GDB knows to ignore the first SIGSTOP after attaching to a running
312 process using the "attach" command, but this is different; it's
313 just using "target remote". Pretend it's just starting up. */
314 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
315 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
316 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
318 current_thread
->last_resume_kind
= resume_stop
;
319 current_thread
->last_status
= cs
.last_status
;
325 /* Decode a qXfer read request. Return 0 if everything looks OK,
329 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
331 /* After the read marker and annex, qXfer looks like a
332 traditional 'm' packet. */
333 decode_m_packet (buf
, ofs
, len
);
339 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
341 /* Extract and NUL-terminate the object. */
343 while (*buf
&& *buf
!= ':')
349 /* Extract and NUL-terminate the read/write action. */
351 while (*buf
&& *buf
!= ':')
357 /* Extract and NUL-terminate the annex. */
359 while (*buf
&& *buf
!= ':')
369 /* Write the response to a successful qXfer read. Returns the
370 length of the (binary) data stored in BUF, corresponding
371 to as much of DATA/LEN as we could fit. IS_MORE controls
372 the first character of the response. */
374 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
383 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
384 &out_len
, PBUFSIZ
- 2) + 1;
387 /* Handle btrace enabling in BTS format. */
390 handle_btrace_enable_bts (struct thread_info
*thread
)
392 if (thread
->btrace
!= NULL
)
393 error (_("Btrace already enabled."));
395 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
396 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
399 /* Handle btrace enabling in Intel Processor Trace format. */
402 handle_btrace_enable_pt (struct thread_info
*thread
)
404 if (thread
->btrace
!= NULL
)
405 error (_("Btrace already enabled."));
407 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
408 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
411 /* Handle btrace disabling. */
414 handle_btrace_disable (struct thread_info
*thread
)
417 if (thread
->btrace
== NULL
)
418 error (_("Branch tracing not enabled."));
420 if (target_disable_btrace (thread
->btrace
) != 0)
421 error (_("Could not disable branch tracing."));
423 thread
->btrace
= NULL
;
426 /* Handle the "Qbtrace" packet. */
429 handle_btrace_general_set (char *own_buf
)
431 client_state
&cs
= get_client_state ();
432 struct thread_info
*thread
;
435 if (!startswith (own_buf
, "Qbtrace:"))
438 op
= own_buf
+ strlen ("Qbtrace:");
440 if (cs
.general_thread
== null_ptid
441 || cs
.general_thread
== minus_one_ptid
)
443 strcpy (own_buf
, "E.Must select a single thread.");
447 thread
= find_thread_ptid (cs
.general_thread
);
450 strcpy (own_buf
, "E.No such thread.");
456 if (strcmp (op
, "bts") == 0)
457 handle_btrace_enable_bts (thread
);
458 else if (strcmp (op
, "pt") == 0)
459 handle_btrace_enable_pt (thread
);
460 else if (strcmp (op
, "off") == 0)
461 handle_btrace_disable (thread
);
463 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
467 catch (const gdb_exception_error
&exception
)
469 sprintf (own_buf
, "E.%s", exception
.what ());
475 /* Handle the "Qbtrace-conf" packet. */
478 handle_btrace_conf_general_set (char *own_buf
)
480 client_state
&cs
= get_client_state ();
481 struct thread_info
*thread
;
484 if (!startswith (own_buf
, "Qbtrace-conf:"))
487 op
= own_buf
+ strlen ("Qbtrace-conf:");
489 if (cs
.general_thread
== null_ptid
490 || cs
.general_thread
== minus_one_ptid
)
492 strcpy (own_buf
, "E.Must select a single thread.");
496 thread
= find_thread_ptid (cs
.general_thread
);
499 strcpy (own_buf
, "E.No such thread.");
503 if (startswith (op
, "bts:size="))
509 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
510 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
512 strcpy (own_buf
, "E.Bad size value.");
516 current_btrace_conf
.bts
.size
= (unsigned int) size
;
518 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
524 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
525 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
527 strcpy (own_buf
, "E.Bad size value.");
531 current_btrace_conf
.pt
.size
= (unsigned int) size
;
535 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
543 /* Handle all of the extended 'Q' packets. */
546 handle_general_set (char *own_buf
)
548 client_state
&cs
= get_client_state ();
549 if (startswith (own_buf
, "QPassSignals:"))
551 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
552 const char *p
= own_buf
+ strlen ("QPassSignals:");
555 p
= decode_address_to_semicolon (&cursig
, p
);
556 for (i
= 0; i
< numsigs
; i
++)
560 cs
.pass_signals
[i
] = 1;
562 /* Keep looping, to clear the remaining signals. */
565 p
= decode_address_to_semicolon (&cursig
, p
);
568 cs
.pass_signals
[i
] = 0;
570 strcpy (own_buf
, "OK");
574 if (startswith (own_buf
, "QProgramSignals:"))
576 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
577 const char *p
= own_buf
+ strlen ("QProgramSignals:");
580 cs
.program_signals_p
= 1;
582 p
= decode_address_to_semicolon (&cursig
, p
);
583 for (i
= 0; i
< numsigs
; i
++)
587 cs
.program_signals
[i
] = 1;
589 /* Keep looping, to clear the remaining signals. */
592 p
= decode_address_to_semicolon (&cursig
, p
);
595 cs
.program_signals
[i
] = 0;
597 strcpy (own_buf
, "OK");
601 if (startswith (own_buf
, "QCatchSyscalls:"))
603 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
606 struct process_info
*process
;
608 if (!target_running () || !target_supports_catch_syscall ())
614 if (strcmp (p
, "0") == 0)
616 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
620 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
626 process
= current_process ();
627 process
->syscalls_to_catch
.clear ();
637 p
= decode_address_to_semicolon (&sysno
, p
);
638 process
->syscalls_to_catch
.push_back (sysno
);
642 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
649 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
651 our_environ
= gdb_environ::from_host_environ ();
657 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
659 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
660 /* The final form of the environment variable. FINAL_VAR will
661 hold the 'VAR=VALUE' format. */
662 std::string final_var
= hex2str (p
);
663 std::string var_name
, var_value
;
667 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
668 debug_printf (_("[Environment variable to be set: '%s']\n"),
673 size_t pos
= final_var
.find ('=');
674 if (pos
== std::string::npos
)
676 warning (_("Unexpected format for environment variable: '%s'"),
682 var_name
= final_var
.substr (0, pos
);
683 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
685 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
691 if (startswith (own_buf
, "QEnvironmentUnset:"))
693 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
694 std::string varname
= hex2str (p
);
698 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
699 debug_printf (_("[Environment variable to be unset: '%s']\n"),
704 our_environ
.unset (varname
.c_str ());
710 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
714 debug_printf ("[noack mode enabled]\n");
723 if (startswith (own_buf
, "QNonStop:"))
725 char *mode
= own_buf
+ 9;
729 if (strcmp (mode
, "0") == 0)
731 else if (strcmp (mode
, "1") == 0)
735 /* We don't know what this mode is, so complain to
737 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
743 req_str
= req
? "non-stop" : "all-stop";
744 if (the_target
->start_non_stop (req
== 1) != 0)
746 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
751 non_stop
= (req
!= 0);
754 debug_printf ("[%s mode enabled]\n", req_str
);
760 if (startswith (own_buf
, "QDisableRandomization:"))
762 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
765 unpack_varlen_hex (packet
, &setting
);
766 cs
.disable_randomization
= setting
;
770 debug_printf (cs
.disable_randomization
771 ? "[address space randomization disabled]\n"
772 : "[address space randomization enabled]\n");
779 if (target_supports_tracepoints ()
780 && handle_tracepoint_general_set (own_buf
))
783 if (startswith (own_buf
, "QAgent:"))
785 char *mode
= own_buf
+ strlen ("QAgent:");
788 if (strcmp (mode
, "0") == 0)
790 else if (strcmp (mode
, "1") == 0)
794 /* We don't know what this value is, so complain to GDB. */
795 sprintf (own_buf
, "E.Unknown QAgent value");
799 /* Update the flag. */
802 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
807 if (handle_btrace_general_set (own_buf
))
810 if (handle_btrace_conf_general_set (own_buf
))
813 if (startswith (own_buf
, "QThreadEvents:"))
815 char *mode
= own_buf
+ strlen ("QThreadEvents:");
816 enum tribool req
= TRIBOOL_UNKNOWN
;
818 if (strcmp (mode
, "0") == 0)
820 else if (strcmp (mode
, "1") == 0)
824 /* We don't know what this mode is, so complain to GDB. */
825 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
830 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
834 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
836 debug_printf ("[thread events are now %s]\n", req_str
);
843 if (startswith (own_buf
, "QStartupWithShell:"))
845 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
847 if (strcmp (value
, "1") == 0)
848 startup_with_shell
= true;
849 else if (strcmp (value
, "0") == 0)
850 startup_with_shell
= false;
854 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
861 debug_printf (_("[Inferior will %s started with shell]"),
862 startup_with_shell
? "be" : "not be");
868 if (startswith (own_buf
, "QSetWorkingDir:"))
870 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
874 std::string path
= hex2str (p
);
876 set_inferior_cwd (path
.c_str ());
879 debug_printf (_("[Set the inferior's current directory to %s]\n"),
884 /* An empty argument means that we should clear out any
885 previously set cwd for the inferior. */
886 set_inferior_cwd (NULL
);
890 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
897 /* Otherwise we didn't know what packet it was. Say we didn't
903 get_features_xml (const char *annex
)
905 const struct target_desc
*desc
= current_target_desc ();
907 /* `desc->xmltarget' defines what to return when looking for the
908 "target.xml" file. Its contents can either be verbatim XML code
909 (prefixed with a '@') or else the name of the actual XML file to
910 be used in place of "target.xml".
912 This variable is set up from the auto-generated
913 init_registers_... routine for the current target. */
915 if (strcmp (annex
, "target.xml") == 0)
917 const char *ret
= tdesc_get_features_xml (desc
);
929 /* Look for the annex. */
930 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
931 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
934 if (xml_builtin
[i
][0] != NULL
)
935 return xml_builtin
[i
][1];
943 monitor_show_help (void)
945 monitor_output ("The following monitor commands are supported:\n");
946 monitor_output (" set debug <0|1>\n");
947 monitor_output (" Enable general debugging messages\n");
948 monitor_output (" set debug-hw-points <0|1>\n");
949 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
950 monitor_output (" set remote-debug <0|1>\n");
951 monitor_output (" Enable remote protocol debugging messages\n");
952 monitor_output (" set debug-format option1[,option2,...]\n");
953 monitor_output (" Add additional information to debugging messages\n");
954 monitor_output (" Options: all, none");
955 monitor_output (", timestamp");
956 monitor_output ("\n");
957 monitor_output (" exit\n");
958 monitor_output (" Quit GDBserver\n");
961 /* Read trace frame or inferior memory. Returns the number of bytes
962 actually read, zero when no further transfer is possible, and -1 on
963 error. Return of a positive value smaller than LEN does not
964 indicate there's no more to be read, only the end of the transfer.
965 E.g., when GDB reads memory from a traceframe, a first request may
966 be served from a memory block that does not cover the whole request
967 length. A following request gets the rest served from either
968 another block (of the same traceframe) or from the read-only
972 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
974 client_state
&cs
= get_client_state ();
977 if (cs
.current_traceframe
>= 0)
980 ULONGEST length
= len
;
982 if (traceframe_read_mem (cs
.current_traceframe
,
983 memaddr
, myaddr
, len
, &nbytes
))
985 /* Data read from trace buffer, we're done. */
988 if (!in_readonly_region (memaddr
, length
))
990 /* Otherwise we have a valid readonly case, fall through. */
991 /* (assume no half-trace half-real blocks for now) */
994 res
= prepare_to_access_memory ();
997 if (set_desired_thread ())
998 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1001 done_accessing_memory ();
1003 return res
== 0 ? len
: -1;
1009 /* Write trace frame or inferior memory. Actually, writing to trace
1010 frames is forbidden. */
1013 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1015 client_state
&cs
= get_client_state ();
1016 if (cs
.current_traceframe
>= 0)
1022 ret
= prepare_to_access_memory ();
1025 if (set_desired_thread ())
1026 ret
= target_write_memory (memaddr
, myaddr
, len
);
1029 done_accessing_memory ();
1035 /* Subroutine of handle_search_memory to simplify it. */
1038 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1039 gdb_byte
*pattern
, unsigned pattern_len
,
1040 gdb_byte
*search_buf
,
1041 unsigned chunk_size
, unsigned search_buf_size
,
1042 CORE_ADDR
*found_addrp
)
1044 /* Prime the search buffer. */
1046 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1049 warning ("Unable to access %ld bytes of target "
1050 "memory at 0x%lx, halting search.",
1051 (long) search_buf_size
, (long) start_addr
);
1055 /* Perform the search.
1057 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1058 When we've scanned N bytes we copy the trailing bytes to the start and
1059 read in another N bytes. */
1061 while (search_space_len
>= pattern_len
)
1063 gdb_byte
*found_ptr
;
1064 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1068 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1071 if (found_ptr
!= NULL
)
1073 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1074 *found_addrp
= found_addr
;
1078 /* Not found in this chunk, skip to next chunk. */
1080 /* Don't let search_space_len wrap here, it's unsigned. */
1081 if (search_space_len
>= chunk_size
)
1082 search_space_len
-= chunk_size
;
1084 search_space_len
= 0;
1086 if (search_space_len
>= pattern_len
)
1088 unsigned keep_len
= search_buf_size
- chunk_size
;
1089 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1092 /* Copy the trailing part of the previous iteration to the front
1093 of the buffer for the next iteration. */
1094 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1096 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1097 ? search_space_len
- keep_len
1100 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1101 nr_to_read
) != search_buf_size
)
1103 warning ("Unable to access %ld bytes of target memory "
1104 "at 0x%lx, halting search.",
1105 (long) nr_to_read
, (long) read_addr
);
1109 start_addr
+= chunk_size
;
1118 /* Handle qSearch:memory packets. */
1121 handle_search_memory (char *own_buf
, int packet_len
)
1123 CORE_ADDR start_addr
;
1124 CORE_ADDR search_space_len
;
1126 unsigned int pattern_len
;
1127 /* NOTE: also defined in find.c testcase. */
1128 #define SEARCH_CHUNK_SIZE 16000
1129 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1130 /* Buffer to hold memory contents for searching. */
1131 gdb_byte
*search_buf
;
1132 unsigned search_buf_size
;
1134 CORE_ADDR found_addr
;
1135 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1137 pattern
= (gdb_byte
*) malloc (packet_len
);
1138 if (pattern
== NULL
)
1140 error ("Unable to allocate memory to perform the search");
1141 strcpy (own_buf
, "E00");
1144 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1145 packet_len
- cmd_name_len
,
1146 &start_addr
, &search_space_len
,
1147 pattern
, &pattern_len
) < 0)
1150 error ("Error in parsing qSearch:memory packet");
1151 strcpy (own_buf
, "E00");
1155 search_buf_size
= chunk_size
+ pattern_len
- 1;
1157 /* No point in trying to allocate a buffer larger than the search space. */
1158 if (search_space_len
< search_buf_size
)
1159 search_buf_size
= search_space_len
;
1161 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1162 if (search_buf
== NULL
)
1165 error ("Unable to allocate memory to perform the search");
1166 strcpy (own_buf
, "E00");
1170 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1171 pattern
, pattern_len
,
1172 search_buf
, chunk_size
, search_buf_size
,
1176 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1177 else if (found
== 0)
1178 strcpy (own_buf
, "0");
1180 strcpy (own_buf
, "E00");
1186 /* Handle the "D" packet. */
1189 handle_detach (char *own_buf
)
1191 client_state
&cs
= get_client_state ();
1193 process_info
*process
;
1195 if (cs
.multi_process
)
1198 int pid
= strtol (&own_buf
[2], NULL
, 16);
1200 process
= find_process_pid (pid
);
1204 process
= (current_thread
!= nullptr
1205 ? get_thread_process (current_thread
)
1209 if (process
== NULL
)
1211 write_enn (own_buf
);
1215 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1217 if (tracing
&& disconnected_tracing
)
1219 "Disconnected tracing in effect, "
1220 "leaving gdbserver attached to the process\n");
1222 if (any_persistent_commands (process
))
1224 "Persistent commands are present, "
1225 "leaving gdbserver attached to the process\n");
1227 /* Make sure we're in non-stop/async mode, so we we can both
1228 wait for an async socket accept, and handle async target
1229 events simultaneously. There's also no point either in
1230 having the target stop all threads, when we're going to
1231 pass signals down without informing GDB. */
1235 debug_printf ("Forcing non-stop mode\n");
1238 the_target
->start_non_stop (true);
1241 process
->gdb_detached
= 1;
1243 /* Detaching implicitly resumes all threads. */
1244 target_continue_no_signal (minus_one_ptid
);
1250 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1253 /* We'll need this after PROCESS has been destroyed. */
1254 int pid
= process
->pid
;
1256 if (detach_inferior (process
) != 0)
1257 write_enn (own_buf
);
1260 discard_queued_stop_replies (ptid_t (pid
));
1263 if (extended_protocol
|| target_running ())
1265 /* There is still at least one inferior remaining or
1266 we are in extended mode, so don't terminate gdbserver,
1267 and instead treat this like a normal program exit. */
1268 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1269 cs
.last_status
.value
.integer
= 0;
1270 cs
.last_ptid
= ptid_t (pid
);
1272 current_thread
= NULL
;
1279 /* If we are attached, then we can exit. Otherwise, we
1280 need to hang around doing nothing, until the child is
1282 join_inferior (pid
);
1288 /* Parse options to --debug-format= and "monitor set debug-format".
1289 ARG is the text after "--debug-format=" or "monitor set debug-format".
1290 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1291 This triggers calls to monitor_output.
1292 The result is an empty string if all options were parsed ok, otherwise an
1293 error message which the caller must free.
1295 N.B. These commands affect all debug format settings, they are not
1296 cumulative. If a format is not specified, it is turned off.
1297 However, we don't go to extra trouble with things like
1298 "monitor set debug-format all,none,timestamp".
1299 Instead we just parse them one at a time, in order.
1301 The syntax for "monitor set debug" we support here is not identical
1302 to gdb's "set debug foo on|off" because we also use this function to
1303 parse "--debug-format=foo,bar". */
1306 parse_debug_format_options (const char *arg
, int is_monitor
)
1308 /* First turn all debug format options off. */
1309 debug_timestamp
= 0;
1311 /* First remove leading spaces, for "monitor set debug-format". */
1312 while (isspace (*arg
))
1315 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1316 = delim_string_to_char_ptr_vec (arg
, ',');
1318 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1320 if (strcmp (option
.get (), "all") == 0)
1322 debug_timestamp
= 1;
1324 monitor_output ("All extra debug format options enabled.\n");
1326 else if (strcmp (option
.get (), "none") == 0)
1328 debug_timestamp
= 0;
1330 monitor_output ("All extra debug format options disabled.\n");
1332 else if (strcmp (option
.get (), "timestamp") == 0)
1334 debug_timestamp
= 1;
1336 monitor_output ("Timestamps will be added to debug output.\n");
1338 else if (*option
== '\0')
1340 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1344 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1348 return std::string ();
1351 /* Handle monitor commands not handled by target-specific handlers. */
1354 handle_monitor_command (char *mon
, char *own_buf
)
1356 if (strcmp (mon
, "set debug 1") == 0)
1359 monitor_output ("Debug output enabled.\n");
1361 else if (strcmp (mon
, "set debug 0") == 0)
1364 monitor_output ("Debug output disabled.\n");
1366 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1368 show_debug_regs
= 1;
1369 monitor_output ("H/W point debugging output enabled.\n");
1371 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1373 show_debug_regs
= 0;
1374 monitor_output ("H/W point debugging output disabled.\n");
1376 else if (strcmp (mon
, "set remote-debug 1") == 0)
1379 monitor_output ("Protocol debug output enabled.\n");
1381 else if (strcmp (mon
, "set remote-debug 0") == 0)
1384 monitor_output ("Protocol debug output disabled.\n");
1386 else if (startswith (mon
, "set debug-format "))
1388 std::string error_msg
1389 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1392 if (!error_msg
.empty ())
1394 monitor_output (error_msg
.c_str ());
1395 monitor_show_help ();
1396 write_enn (own_buf
);
1399 else if (strcmp (mon
, "set debug-file") == 0)
1400 debug_set_output (nullptr);
1401 else if (startswith (mon
, "set debug-file "))
1402 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1403 else if (strcmp (mon
, "help") == 0)
1404 monitor_show_help ();
1405 else if (strcmp (mon
, "exit") == 0)
1406 exit_requested
= true;
1409 monitor_output ("Unknown monitor command.\n\n");
1410 monitor_show_help ();
1411 write_enn (own_buf
);
1415 /* Associates a callback with each supported qXfer'able object. */
1419 /* The object this handler handles. */
1422 /* Request that the target transfer up to LEN 8-bit bytes of the
1423 target's OBJECT. The OFFSET, for a seekable object, specifies
1424 the starting point. The ANNEX can be used to provide additional
1425 data-specific information to the target.
1427 Return the number of bytes actually transfered, zero when no
1428 further transfer is possible, -1 on error, -2 when the transfer
1429 is not supported, and -3 on a verbose error message that should
1430 be preserved. Return of a positive value smaller than LEN does
1431 not indicate the end of the object, only the end of the transfer.
1433 One, and only one, of readbuf or writebuf must be non-NULL. */
1434 int (*xfer
) (const char *annex
,
1435 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1436 ULONGEST offset
, LONGEST len
);
1439 /* Handle qXfer:auxv:read. */
1442 handle_qxfer_auxv (const char *annex
,
1443 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1444 ULONGEST offset
, LONGEST len
)
1446 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1449 if (annex
[0] != '\0' || current_thread
== NULL
)
1452 return the_target
->read_auxv (offset
, readbuf
, len
);
1455 /* Handle qXfer:exec-file:read. */
1458 handle_qxfer_exec_file (const char *annex
,
1459 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1460 ULONGEST offset
, LONGEST len
)
1466 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1469 if (annex
[0] == '\0')
1471 if (current_thread
== NULL
)
1474 pid
= pid_of (current_thread
);
1478 annex
= unpack_varlen_hex (annex
, &pid
);
1479 if (annex
[0] != '\0')
1486 file
= the_target
->pid_to_exec_file (pid
);
1490 total_len
= strlen (file
);
1492 if (offset
> total_len
)
1495 if (offset
+ len
> total_len
)
1496 len
= total_len
- offset
;
1498 memcpy (readbuf
, file
+ offset
, len
);
1502 /* Handle qXfer:features:read. */
1505 handle_qxfer_features (const char *annex
,
1506 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1507 ULONGEST offset
, LONGEST len
)
1509 const char *document
;
1512 if (writebuf
!= NULL
)
1515 if (!target_running ())
1518 /* Grab the correct annex. */
1519 document
= get_features_xml (annex
);
1520 if (document
== NULL
)
1523 total_len
= strlen (document
);
1525 if (offset
> total_len
)
1528 if (offset
+ len
> total_len
)
1529 len
= total_len
- offset
;
1531 memcpy (readbuf
, document
+ offset
, len
);
1535 /* Handle qXfer:libraries:read. */
1538 handle_qxfer_libraries (const char *annex
,
1539 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1540 ULONGEST offset
, LONGEST len
)
1542 if (writebuf
!= NULL
)
1545 if (annex
[0] != '\0' || current_thread
== NULL
)
1548 std::string document
= "<library-list version=\"1.0\">\n";
1550 for (const dll_info
&dll
: all_dlls
)
1551 document
+= string_printf
1552 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1553 dll
.name
.c_str (), paddress (dll
.base_addr
));
1555 document
+= "</library-list>\n";
1557 if (offset
> document
.length ())
1560 if (offset
+ len
> document
.length ())
1561 len
= document
.length () - offset
;
1563 memcpy (readbuf
, &document
[offset
], len
);
1568 /* Handle qXfer:libraries-svr4:read. */
1571 handle_qxfer_libraries_svr4 (const char *annex
,
1572 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1573 ULONGEST offset
, LONGEST len
)
1575 if (writebuf
!= NULL
)
1578 if (current_thread
== NULL
1579 || !the_target
->supports_qxfer_libraries_svr4 ())
1582 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1586 /* Handle qXfer:osadata:read. */
1589 handle_qxfer_osdata (const char *annex
,
1590 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1591 ULONGEST offset
, LONGEST len
)
1593 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1596 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1599 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1602 handle_qxfer_siginfo (const char *annex
,
1603 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1604 ULONGEST offset
, LONGEST len
)
1606 if (!the_target
->supports_qxfer_siginfo ())
1609 if (annex
[0] != '\0' || current_thread
== NULL
)
1612 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1615 /* Handle qXfer:statictrace:read. */
1618 handle_qxfer_statictrace (const char *annex
,
1619 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1620 ULONGEST offset
, LONGEST len
)
1622 client_state
&cs
= get_client_state ();
1625 if (writebuf
!= NULL
)
1628 if (annex
[0] != '\0' || current_thread
== NULL
1629 || cs
.current_traceframe
== -1)
1632 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1633 readbuf
, len
, &nbytes
))
1638 /* Helper for handle_qxfer_threads_proper.
1639 Emit the XML to describe the thread of INF. */
1642 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1644 ptid_t ptid
= ptid_of (thread
);
1646 int core
= target_core_of_thread (ptid
);
1648 const char *name
= target_thread_name (ptid
);
1651 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1653 write_ptid (ptid_s
, ptid
);
1655 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1659 sprintf (core_s
, "%d", core
);
1660 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1664 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1668 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1669 bin2hex (handle
, handle_s
, handle_len
);
1670 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1673 buffer_xml_printf (buffer
, "/>\n");
1676 /* Helper for handle_qxfer_threads. */
1679 handle_qxfer_threads_proper (struct buffer
*buffer
)
1681 buffer_grow_str (buffer
, "<threads>\n");
1683 for_each_thread ([&] (thread_info
*thread
)
1685 handle_qxfer_threads_worker (thread
, buffer
);
1688 buffer_grow_str0 (buffer
, "</threads>\n");
1691 /* Handle qXfer:threads:read. */
1694 handle_qxfer_threads (const char *annex
,
1695 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1696 ULONGEST offset
, LONGEST len
)
1698 static char *result
= 0;
1699 static unsigned int result_length
= 0;
1701 if (writebuf
!= NULL
)
1704 if (annex
[0] != '\0')
1709 struct buffer buffer
;
1710 /* When asked for data at offset 0, generate everything and store into
1711 'result'. Successive reads will be served off 'result'. */
1715 buffer_init (&buffer
);
1717 handle_qxfer_threads_proper (&buffer
);
1719 result
= buffer_finish (&buffer
);
1720 result_length
= strlen (result
);
1721 buffer_free (&buffer
);
1724 if (offset
>= result_length
)
1726 /* We're out of data. */
1733 if (len
> result_length
- offset
)
1734 len
= result_length
- offset
;
1736 memcpy (readbuf
, result
+ offset
, len
);
1741 /* Handle qXfer:traceframe-info:read. */
1744 handle_qxfer_traceframe_info (const char *annex
,
1745 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1746 ULONGEST offset
, LONGEST len
)
1748 client_state
&cs
= get_client_state ();
1749 static char *result
= 0;
1750 static unsigned int result_length
= 0;
1752 if (writebuf
!= NULL
)
1755 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1760 struct buffer buffer
;
1762 /* When asked for data at offset 0, generate everything and
1763 store into 'result'. Successive reads will be served off
1767 buffer_init (&buffer
);
1769 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1771 result
= buffer_finish (&buffer
);
1772 result_length
= strlen (result
);
1773 buffer_free (&buffer
);
1776 if (offset
>= result_length
)
1778 /* We're out of data. */
1785 if (len
> result_length
- offset
)
1786 len
= result_length
- offset
;
1788 memcpy (readbuf
, result
+ offset
, len
);
1792 /* Handle qXfer:fdpic:read. */
1795 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1796 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1798 if (!the_target
->supports_read_loadmap ())
1801 if (current_thread
== NULL
)
1804 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1807 /* Handle qXfer:btrace:read. */
1810 handle_qxfer_btrace (const char *annex
,
1811 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1812 ULONGEST offset
, LONGEST len
)
1814 client_state
&cs
= get_client_state ();
1815 static struct buffer cache
;
1816 struct thread_info
*thread
;
1817 enum btrace_read_type type
;
1820 if (writebuf
!= NULL
)
1823 if (cs
.general_thread
== null_ptid
1824 || cs
.general_thread
== minus_one_ptid
)
1826 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1830 thread
= find_thread_ptid (cs
.general_thread
);
1833 strcpy (cs
.own_buf
, "E.No such thread.");
1837 if (thread
->btrace
== NULL
)
1839 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1843 if (strcmp (annex
, "all") == 0)
1844 type
= BTRACE_READ_ALL
;
1845 else if (strcmp (annex
, "new") == 0)
1846 type
= BTRACE_READ_NEW
;
1847 else if (strcmp (annex
, "delta") == 0)
1848 type
= BTRACE_READ_DELTA
;
1851 strcpy (cs
.own_buf
, "E.Bad annex.");
1857 buffer_free (&cache
);
1861 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1863 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1865 catch (const gdb_exception_error
&exception
)
1867 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1874 else if (offset
> cache
.used_size
)
1876 buffer_free (&cache
);
1880 if (len
> cache
.used_size
- offset
)
1881 len
= cache
.used_size
- offset
;
1883 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1888 /* Handle qXfer:btrace-conf:read. */
1891 handle_qxfer_btrace_conf (const char *annex
,
1892 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1893 ULONGEST offset
, LONGEST len
)
1895 client_state
&cs
= get_client_state ();
1896 static struct buffer cache
;
1897 struct thread_info
*thread
;
1900 if (writebuf
!= NULL
)
1903 if (annex
[0] != '\0')
1906 if (cs
.general_thread
== null_ptid
1907 || cs
.general_thread
== minus_one_ptid
)
1909 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1913 thread
= find_thread_ptid (cs
.general_thread
);
1916 strcpy (cs
.own_buf
, "E.No such thread.");
1920 if (thread
->btrace
== NULL
)
1922 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1928 buffer_free (&cache
);
1932 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1934 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1936 catch (const gdb_exception_error
&exception
)
1938 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1945 else if (offset
> cache
.used_size
)
1947 buffer_free (&cache
);
1951 if (len
> cache
.used_size
- offset
)
1952 len
= cache
.used_size
- offset
;
1954 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1959 static const struct qxfer qxfer_packets
[] =
1961 { "auxv", handle_qxfer_auxv
},
1962 { "btrace", handle_qxfer_btrace
},
1963 { "btrace-conf", handle_qxfer_btrace_conf
},
1964 { "exec-file", handle_qxfer_exec_file
},
1965 { "fdpic", handle_qxfer_fdpic
},
1966 { "features", handle_qxfer_features
},
1967 { "libraries", handle_qxfer_libraries
},
1968 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1969 { "osdata", handle_qxfer_osdata
},
1970 { "siginfo", handle_qxfer_siginfo
},
1971 { "statictrace", handle_qxfer_statictrace
},
1972 { "threads", handle_qxfer_threads
},
1973 { "traceframe-info", handle_qxfer_traceframe_info
},
1977 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1985 if (!startswith (own_buf
, "qXfer:"))
1988 /* Grab the object, r/w and annex. */
1989 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1991 write_enn (own_buf
);
1996 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1999 const struct qxfer
*q
= &qxfer_packets
[i
];
2001 if (strcmp (object
, q
->object
) == 0)
2003 if (strcmp (rw
, "read") == 0)
2005 unsigned char *data
;
2010 /* Grab the offset and length. */
2011 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2013 write_enn (own_buf
);
2017 /* Read one extra byte, as an indicator of whether there is
2019 if (len
> PBUFSIZ
- 2)
2021 data
= (unsigned char *) malloc (len
+ 1);
2024 write_enn (own_buf
);
2027 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2035 /* Preserve error message. */
2038 write_enn (own_buf
);
2040 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2042 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2047 else if (strcmp (rw
, "write") == 0)
2052 unsigned char *data
;
2054 strcpy (own_buf
, "E00");
2055 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2058 write_enn (own_buf
);
2061 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2062 &ofs
, &len
, data
) < 0)
2065 write_enn (own_buf
);
2069 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2077 /* Preserve error message. */
2080 write_enn (own_buf
);
2082 sprintf (own_buf
, "%x", n
);
2095 /* Compute 32 bit CRC from inferior memory.
2097 On success, return 32 bit CRC.
2098 On failure, return (unsigned long long) -1. */
2100 static unsigned long long
2101 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2105 unsigned char byte
= 0;
2107 /* Return failure if memory read fails. */
2108 if (read_inferior_memory (base
, &byte
, 1) != 0)
2109 return (unsigned long long) -1;
2111 crc
= xcrc32 (&byte
, 1, crc
);
2114 return (unsigned long long) crc
;
2117 /* Add supported btrace packets to BUF. */
2120 supported_btrace_packets (char *buf
)
2122 strcat (buf
, ";Qbtrace:bts+");
2123 strcat (buf
, ";Qbtrace-conf:bts:size+");
2124 strcat (buf
, ";Qbtrace:pt+");
2125 strcat (buf
, ";Qbtrace-conf:pt:size+");
2126 strcat (buf
, ";Qbtrace:off+");
2127 strcat (buf
, ";qXfer:btrace:read+");
2128 strcat (buf
, ";qXfer:btrace-conf:read+");
2131 /* Handle all of the extended 'q' packets. */
2134 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2136 client_state
&cs
= get_client_state ();
2137 static std::list
<thread_info
*>::const_iterator thread_iter
;
2139 /* Reply the current thread id. */
2140 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2143 require_running_or_return (own_buf
);
2145 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2146 ptid
= cs
.general_thread
;
2149 thread_iter
= all_threads
.begin ();
2150 ptid
= (*thread_iter
)->id
;
2153 sprintf (own_buf
, "QC");
2155 write_ptid (own_buf
, ptid
);
2159 if (strcmp ("qSymbol::", own_buf
) == 0)
2161 struct thread_info
*save_thread
= current_thread
;
2163 /* For qSymbol, GDB only changes the current thread if the
2164 previous current thread was of a different process. So if
2165 the previous thread is gone, we need to pick another one of
2166 the same process. This can happen e.g., if we followed an
2167 exec in a non-leader thread. */
2168 if (current_thread
== NULL
)
2171 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2173 /* Just in case, if we didn't find a thread, then bail out
2174 instead of crashing. */
2175 if (current_thread
== NULL
)
2177 write_enn (own_buf
);
2178 current_thread
= save_thread
;
2183 /* GDB is suggesting new symbols have been loaded. This may
2184 mean a new shared library has been detected as loaded, so
2185 take the opportunity to check if breakpoints we think are
2186 inserted, still are. Note that it isn't guaranteed that
2187 we'll see this when a shared library is loaded, and nor will
2188 we see this for unloads (although breakpoints in unloaded
2189 libraries shouldn't trigger), as GDB may not find symbols for
2190 the library at all. We also re-validate breakpoints when we
2191 see a second GDB breakpoint for the same address, and or when
2192 we access breakpoint shadows. */
2193 validate_breakpoints ();
2195 if (target_supports_tracepoints ())
2196 tracepoint_look_up_symbols ();
2198 if (current_thread
!= NULL
)
2199 the_target
->look_up_symbols ();
2201 current_thread
= save_thread
;
2203 strcpy (own_buf
, "OK");
2207 if (!disable_packet_qfThreadInfo
)
2209 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2211 require_running_or_return (own_buf
);
2212 thread_iter
= all_threads
.begin ();
2215 ptid_t ptid
= (*thread_iter
)->id
;
2216 write_ptid (own_buf
, ptid
);
2221 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2223 require_running_or_return (own_buf
);
2224 if (thread_iter
!= all_threads
.end ())
2227 ptid_t ptid
= (*thread_iter
)->id
;
2228 write_ptid (own_buf
, ptid
);
2234 sprintf (own_buf
, "l");
2240 if (the_target
->supports_read_offsets ()
2241 && strcmp ("qOffsets", own_buf
) == 0)
2243 CORE_ADDR text
, data
;
2245 require_running_or_return (own_buf
);
2246 if (the_target
->read_offsets (&text
, &data
))
2247 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2248 (long)text
, (long)data
, (long)data
);
2250 write_enn (own_buf
);
2255 /* Protocol features query. */
2256 if (startswith (own_buf
, "qSupported")
2257 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2259 char *p
= &own_buf
[10];
2260 int gdb_supports_qRelocInsn
= 0;
2262 /* Process each feature being provided by GDB. The first
2263 feature will follow a ':', and latter features will follow
2267 char **qsupported
= NULL
;
2272 /* Two passes, to avoid nested strtok calls in
2273 target_process_qsupported. */
2275 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2277 p
= strtok_r (NULL
, ";", &saveptr
))
2280 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2281 qsupported
[count
- 1] = xstrdup (p
);
2284 for (i
= 0; i
< count
; i
++)
2287 if (strcmp (p
, "multiprocess+") == 0)
2289 /* GDB supports and wants multi-process support if
2291 if (target_supports_multi_process ())
2292 cs
.multi_process
= 1;
2294 else if (strcmp (p
, "qRelocInsn+") == 0)
2296 /* GDB supports relocate instruction requests. */
2297 gdb_supports_qRelocInsn
= 1;
2299 else if (strcmp (p
, "swbreak+") == 0)
2301 /* GDB wants us to report whether a trap is caused
2302 by a software breakpoint and for us to handle PC
2303 adjustment if necessary on this target. */
2304 if (target_supports_stopped_by_sw_breakpoint ())
2305 cs
.swbreak_feature
= 1;
2307 else if (strcmp (p
, "hwbreak+") == 0)
2309 /* GDB wants us to report whether a trap is caused
2310 by a hardware breakpoint. */
2311 if (target_supports_stopped_by_hw_breakpoint ())
2312 cs
.hwbreak_feature
= 1;
2314 else if (strcmp (p
, "fork-events+") == 0)
2316 /* GDB supports and wants fork events if possible. */
2317 if (target_supports_fork_events ())
2318 cs
.report_fork_events
= 1;
2320 else if (strcmp (p
, "vfork-events+") == 0)
2322 /* GDB supports and wants vfork events if possible. */
2323 if (target_supports_vfork_events ())
2324 cs
.report_vfork_events
= 1;
2326 else if (strcmp (p
, "exec-events+") == 0)
2328 /* GDB supports and wants exec events if possible. */
2329 if (target_supports_exec_events ())
2330 cs
.report_exec_events
= 1;
2332 else if (strcmp (p
, "vContSupported+") == 0)
2333 cs
.vCont_supported
= 1;
2334 else if (strcmp (p
, "QThreadEvents+") == 0)
2336 else if (strcmp (p
, "no-resumed+") == 0)
2338 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2340 report_no_resumed
= true;
2344 /* Move the unknown features all together. */
2345 qsupported
[i
] = NULL
;
2346 qsupported
[unknown
] = p
;
2351 /* Give the target backend a chance to process the unknown
2353 target_process_qsupported (qsupported
, unknown
);
2355 for (i
= 0; i
< count
; i
++)
2356 free (qsupported
[i
]);
2361 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2362 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2363 "QEnvironmentReset+;QEnvironmentUnset+;"
2367 if (target_supports_catch_syscall ())
2368 strcat (own_buf
, ";QCatchSyscalls+");
2370 if (the_target
->supports_qxfer_libraries_svr4 ())
2371 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2372 ";augmented-libraries-svr4-read+");
2375 /* We do not have any hook to indicate whether the non-SVR4 target
2376 backend supports qXfer:libraries:read, so always report it. */
2377 strcat (own_buf
, ";qXfer:libraries:read+");
2380 if (the_target
->supports_read_auxv ())
2381 strcat (own_buf
, ";qXfer:auxv:read+");
2383 if (the_target
->supports_qxfer_siginfo ())
2384 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2386 if (the_target
->supports_read_loadmap ())
2387 strcat (own_buf
, ";qXfer:fdpic:read+");
2389 /* We always report qXfer:features:read, as targets may
2390 install XML files on a subsequent call to arch_setup.
2391 If we reported to GDB on startup that we don't support
2392 qXfer:feature:read at all, we will never be re-queried. */
2393 strcat (own_buf
, ";qXfer:features:read+");
2395 if (cs
.transport_is_reliable
)
2396 strcat (own_buf
, ";QStartNoAckMode+");
2398 if (the_target
->supports_qxfer_osdata ())
2399 strcat (own_buf
, ";qXfer:osdata:read+");
2401 if (target_supports_multi_process ())
2402 strcat (own_buf
, ";multiprocess+");
2404 if (target_supports_fork_events ())
2405 strcat (own_buf
, ";fork-events+");
2407 if (target_supports_vfork_events ())
2408 strcat (own_buf
, ";vfork-events+");
2410 if (target_supports_exec_events ())
2411 strcat (own_buf
, ";exec-events+");
2413 if (target_supports_non_stop ())
2414 strcat (own_buf
, ";QNonStop+");
2416 if (target_supports_disable_randomization ())
2417 strcat (own_buf
, ";QDisableRandomization+");
2419 strcat (own_buf
, ";qXfer:threads:read+");
2421 if (target_supports_tracepoints ())
2423 strcat (own_buf
, ";ConditionalTracepoints+");
2424 strcat (own_buf
, ";TraceStateVariables+");
2425 strcat (own_buf
, ";TracepointSource+");
2426 strcat (own_buf
, ";DisconnectedTracing+");
2427 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2428 strcat (own_buf
, ";FastTracepoints+");
2429 strcat (own_buf
, ";StaticTracepoints+");
2430 strcat (own_buf
, ";InstallInTrace+");
2431 strcat (own_buf
, ";qXfer:statictrace:read+");
2432 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2433 strcat (own_buf
, ";EnableDisableTracepoints+");
2434 strcat (own_buf
, ";QTBuffer:size+");
2435 strcat (own_buf
, ";tracenz+");
2438 if (target_supports_hardware_single_step ()
2439 || target_supports_software_single_step () )
2441 strcat (own_buf
, ";ConditionalBreakpoints+");
2443 strcat (own_buf
, ";BreakpointCommands+");
2445 if (target_supports_agent ())
2446 strcat (own_buf
, ";QAgent+");
2448 supported_btrace_packets (own_buf
);
2450 if (target_supports_stopped_by_sw_breakpoint ())
2451 strcat (own_buf
, ";swbreak+");
2453 if (target_supports_stopped_by_hw_breakpoint ())
2454 strcat (own_buf
, ";hwbreak+");
2456 if (the_target
->supports_pid_to_exec_file ())
2457 strcat (own_buf
, ";qXfer:exec-file:read+");
2459 strcat (own_buf
, ";vContSupported+");
2461 strcat (own_buf
, ";QThreadEvents+");
2463 strcat (own_buf
, ";no-resumed+");
2465 /* Reinitialize components as needed for the new connection. */
2466 hostio_handle_new_gdb_connection ();
2467 target_handle_new_gdb_connection ();
2472 /* Thread-local storage support. */
2473 if (the_target
->supports_get_tls_address ()
2474 && startswith (own_buf
, "qGetTLSAddr:"))
2476 char *p
= own_buf
+ 12;
2477 CORE_ADDR parts
[2], address
= 0;
2479 ptid_t ptid
= null_ptid
;
2481 require_running_or_return (own_buf
);
2483 for (i
= 0; i
< 3; i
++)
2491 p2
= strchr (p
, ',');
2504 ptid
= read_ptid (p
, NULL
);
2506 decode_address (&parts
[i
- 1], p
, len
);
2510 if (p
!= NULL
|| i
< 3)
2514 struct thread_info
*thread
= find_thread_ptid (ptid
);
2519 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2525 strcpy (own_buf
, paddress(address
));
2530 write_enn (own_buf
);
2534 /* Otherwise, pretend we do not understand this packet. */
2537 /* Windows OS Thread Information Block address support. */
2538 if (the_target
->supports_get_tib_address ()
2539 && startswith (own_buf
, "qGetTIBAddr:"))
2544 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2546 n
= the_target
->get_tib_address (ptid
, &tlb
);
2549 strcpy (own_buf
, paddress(tlb
));
2554 write_enn (own_buf
);
2560 /* Handle "monitor" commands. */
2561 if (startswith (own_buf
, "qRcmd,"))
2563 char *mon
= (char *) malloc (PBUFSIZ
);
2564 int len
= strlen (own_buf
+ 6);
2568 write_enn (own_buf
);
2573 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2575 write_enn (own_buf
);
2579 mon
[len
/ 2] = '\0';
2583 if (the_target
->handle_monitor_command (mon
) == 0)
2584 /* Default processing. */
2585 handle_monitor_command (mon
, own_buf
);
2591 if (startswith (own_buf
, "qSearch:memory:"))
2593 require_running_or_return (own_buf
);
2594 handle_search_memory (own_buf
, packet_len
);
2598 if (strcmp (own_buf
, "qAttached") == 0
2599 || startswith (own_buf
, "qAttached:"))
2601 struct process_info
*process
;
2603 if (own_buf
[sizeof ("qAttached") - 1])
2605 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2606 process
= find_process_pid (pid
);
2610 require_running_or_return (own_buf
);
2611 process
= current_process ();
2614 if (process
== NULL
)
2616 write_enn (own_buf
);
2620 strcpy (own_buf
, process
->attached
? "1" : "0");
2624 if (startswith (own_buf
, "qCRC:"))
2626 /* CRC check (compare-section). */
2630 unsigned long long crc
;
2632 require_running_or_return (own_buf
);
2633 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2634 if (*comma
++ != ',')
2636 write_enn (own_buf
);
2639 len
= strtoul (comma
, NULL
, 16);
2640 crc
= crc32 (base
, len
, 0xffffffff);
2641 /* Check for memory failure. */
2642 if (crc
== (unsigned long long) -1)
2644 write_enn (own_buf
);
2647 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2651 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2654 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2657 /* Otherwise we didn't know what packet it was. Say we didn't
2662 static void gdb_wants_all_threads_stopped (void);
2663 static void resume (struct thread_resume
*actions
, size_t n
);
2665 /* The callback that is passed to visit_actioned_threads. */
2666 typedef int (visit_actioned_threads_callback_ftype
)
2667 (const struct thread_resume
*, struct thread_info
*);
2669 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2670 true if CALLBACK returns true. Returns false if no matching thread
2671 is found or CALLBACK results false.
2672 Note: This function is itself a callback for find_thread. */
2675 visit_actioned_threads (thread_info
*thread
,
2676 const struct thread_resume
*actions
,
2678 visit_actioned_threads_callback_ftype
*callback
)
2680 for (size_t i
= 0; i
< num_actions
; i
++)
2682 const struct thread_resume
*action
= &actions
[i
];
2684 if (action
->thread
== minus_one_ptid
2685 || action
->thread
== thread
->id
2686 || ((action
->thread
.pid ()
2687 == thread
->id
.pid ())
2688 && action
->thread
.lwp () == -1))
2690 if ((*callback
) (action
, thread
))
2698 /* Callback for visit_actioned_threads. If the thread has a pending
2699 status to report, report it now. */
2702 handle_pending_status (const struct thread_resume
*resumption
,
2703 struct thread_info
*thread
)
2705 client_state
&cs
= get_client_state ();
2706 if (thread
->status_pending_p
)
2708 thread
->status_pending_p
= 0;
2710 cs
.last_status
= thread
->last_status
;
2711 cs
.last_ptid
= thread
->id
;
2712 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2718 /* Parse vCont packets. */
2720 handle_v_cont (char *own_buf
)
2724 struct thread_resume
*resume_info
;
2725 struct thread_resume default_action
{ null_ptid
};
2727 /* Count the number of semicolons in the packet. There should be one
2728 for every action. */
2734 p
= strchr (p
, ';');
2737 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2738 if (resume_info
== NULL
)
2746 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2748 if (p
[0] == 's' || p
[0] == 'S')
2749 resume_info
[i
].kind
= resume_step
;
2750 else if (p
[0] == 'r')
2751 resume_info
[i
].kind
= resume_step
;
2752 else if (p
[0] == 'c' || p
[0] == 'C')
2753 resume_info
[i
].kind
= resume_continue
;
2754 else if (p
[0] == 't')
2755 resume_info
[i
].kind
= resume_stop
;
2759 if (p
[0] == 'S' || p
[0] == 'C')
2762 int sig
= strtol (p
+ 1, &q
, 16);
2767 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2769 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2771 else if (p
[0] == 'r')
2775 p
= unpack_varlen_hex (p
+ 1, &addr
);
2776 resume_info
[i
].step_range_start
= addr
;
2781 p
= unpack_varlen_hex (p
+ 1, &addr
);
2782 resume_info
[i
].step_range_end
= addr
;
2791 resume_info
[i
].thread
= minus_one_ptid
;
2792 default_action
= resume_info
[i
];
2794 /* Note: we don't increment i here, we'll overwrite this entry
2795 the next time through. */
2797 else if (p
[0] == ':')
2800 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2805 if (p
[0] != ';' && p
[0] != 0)
2808 resume_info
[i
].thread
= ptid
;
2815 resume_info
[i
] = default_action
;
2817 resume (resume_info
, n
);
2822 write_enn (own_buf
);
2827 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2830 resume (struct thread_resume
*actions
, size_t num_actions
)
2832 client_state
&cs
= get_client_state ();
2835 /* Check if among the threads that GDB wants actioned, there's
2836 one with a pending status to report. If so, skip actually
2837 resuming/stopping and report the pending event
2840 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2842 return visit_actioned_threads (thread
, actions
, num_actions
,
2843 handle_pending_status
);
2846 if (thread_with_status
!= NULL
)
2852 the_target
->resume (actions
, num_actions
);
2855 write_ok (cs
.own_buf
);
2858 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2860 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2861 && !report_no_resumed
)
2863 /* The client does not support this stop reply. At least
2865 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2866 disable_async_io ();
2870 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2871 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2872 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2873 current_thread
->last_status
= cs
.last_status
;
2875 /* From the client's perspective, all-stop mode always stops all
2876 threads implicitly (and the target backend has already done
2877 so by now). Tag all threads as "want-stopped", so we don't
2878 resume them implicitly without the client telling us to. */
2879 gdb_wants_all_threads_stopped ();
2880 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2881 disable_async_io ();
2883 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2884 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2885 target_mourn_inferior (cs
.last_ptid
);
2889 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2891 handle_v_attach (char *own_buf
)
2893 client_state
&cs
= get_client_state ();
2896 pid
= strtol (own_buf
+ 8, NULL
, 16);
2897 if (pid
!= 0 && attach_inferior (pid
) == 0)
2899 /* Don't report shared library events after attaching, even if
2900 some libraries are preloaded. GDB will always poll the
2901 library list. Avoids the "stopped by shared library event"
2902 notice on the GDB side. */
2907 /* In non-stop, we don't send a resume reply. Stop events
2908 will follow up using the normal notification
2913 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2919 write_enn (own_buf
);
2924 /* Run a new program. Return 1 if successful, 0 if failure. */
2926 handle_v_run (char *own_buf
)
2928 client_state
&cs
= get_client_state ();
2930 std::vector
<char *> new_argv
;
2931 char *new_program_name
= NULL
;
2935 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2941 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2943 next_p
= strchr (p
, ';');
2945 next_p
= p
+ strlen (p
);
2947 if (i
== 0 && p
== next_p
)
2949 /* No program specified. */
2950 new_program_name
= NULL
;
2952 else if (p
== next_p
)
2954 /* Empty argument. */
2955 new_argv
.push_back (xstrdup ("''"));
2959 size_t len
= (next_p
- p
) / 2;
2960 /* ARG is the unquoted argument received via the RSP. */
2961 char *arg
= (char *) xmalloc (len
+ 1);
2962 /* FULL_ARGS will contain the quoted version of ARG. */
2963 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2964 /* These are pointers used to navigate the strings above. */
2965 char *tmp_arg
= arg
;
2966 char *tmp_full_arg
= full_arg
;
2969 hex2bin (p
, (gdb_byte
*) arg
, len
);
2972 while (*tmp_arg
!= '\0')
2978 *tmp_full_arg
= '\'';
2984 /* Quote single quote. */
2985 *tmp_full_arg
= '\\';
2993 *tmp_full_arg
= *tmp_arg
;
2999 *tmp_full_arg
++ = '\'';
3001 /* Finish FULL_ARG and push it into the vector containing
3003 *tmp_full_arg
= '\0';
3005 new_program_name
= full_arg
;
3007 new_argv
.push_back (full_arg
);
3013 new_argv
.push_back (NULL
);
3015 if (new_program_name
== NULL
)
3017 /* GDB didn't specify a program to run. Use the program from the
3018 last run with the new argument list. */
3019 if (program_path
.get () == NULL
)
3021 write_enn (own_buf
);
3022 free_vector_argv (new_argv
);
3027 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3029 /* Free the old argv and install the new one. */
3030 free_vector_argv (program_args
);
3031 program_args
= new_argv
;
3033 target_create_inferior (program_path
.get (), program_args
);
3035 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3037 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3039 /* In non-stop, sending a resume reply doesn't set the general
3040 thread, but GDB assumes a vRun sets it (this is so GDB can
3041 query which is the main thread of the new inferior. */
3043 cs
.general_thread
= cs
.last_ptid
;
3049 write_enn (own_buf
);
3054 /* Kill process. Return 1 if successful, 0 if failure. */
3056 handle_v_kill (char *own_buf
)
3058 client_state
&cs
= get_client_state ();
3060 char *p
= &own_buf
[6];
3061 if (cs
.multi_process
)
3062 pid
= strtol (p
, NULL
, 16);
3066 process_info
*proc
= find_process_pid (pid
);
3068 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3070 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3071 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3072 cs
.last_ptid
= ptid_t (pid
);
3073 discard_queued_stop_replies (cs
.last_ptid
);
3079 write_enn (own_buf
);
3084 /* Handle all of the extended 'v' packets. */
3086 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3088 client_state
&cs
= get_client_state ();
3089 if (!disable_packet_vCont
)
3091 if (strcmp (own_buf
, "vCtrlC") == 0)
3093 the_target
->request_interrupt ();
3098 if (startswith (own_buf
, "vCont;"))
3100 handle_v_cont (own_buf
);
3104 if (startswith (own_buf
, "vCont?"))
3106 strcpy (own_buf
, "vCont;c;C;t");
3108 if (target_supports_hardware_single_step ()
3109 || target_supports_software_single_step ()
3110 || !cs
.vCont_supported
)
3112 /* If target supports single step either by hardware or by
3113 software, add actions s and S to the list of supported
3114 actions. On the other hand, if GDB doesn't request the
3115 supported vCont actions in qSupported packet, add s and
3116 S to the list too. */
3117 own_buf
= own_buf
+ strlen (own_buf
);
3118 strcpy (own_buf
, ";s;S");
3121 if (target_supports_range_stepping ())
3123 own_buf
= own_buf
+ strlen (own_buf
);
3124 strcpy (own_buf
, ";r");
3130 if (startswith (own_buf
, "vFile:")
3131 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3134 if (startswith (own_buf
, "vAttach;"))
3136 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3138 fprintf (stderr
, "Already debugging a process\n");
3139 write_enn (own_buf
);
3142 handle_v_attach (own_buf
);
3146 if (startswith (own_buf
, "vRun;"))
3148 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3150 fprintf (stderr
, "Already debugging a process\n");
3151 write_enn (own_buf
);
3154 handle_v_run (own_buf
);
3158 if (startswith (own_buf
, "vKill;"))
3160 if (!target_running ())
3162 fprintf (stderr
, "No process to kill\n");
3163 write_enn (own_buf
);
3166 handle_v_kill (own_buf
);
3170 if (handle_notif_ack (own_buf
, packet_len
))
3173 /* Otherwise we didn't know what packet it was. Say we didn't
3179 /* Resume thread and wait for another event. In non-stop mode,
3180 don't really wait here, but return immediatelly to the event
3183 myresume (char *own_buf
, int step
, int sig
)
3185 client_state
&cs
= get_client_state ();
3186 struct thread_resume resume_info
[2];
3188 int valid_cont_thread
;
3190 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3191 && cs
.cont_thread
!= minus_one_ptid
);
3193 if (step
|| sig
|| valid_cont_thread
)
3195 resume_info
[0].thread
= current_ptid
;
3197 resume_info
[0].kind
= resume_step
;
3199 resume_info
[0].kind
= resume_continue
;
3200 resume_info
[0].sig
= sig
;
3204 if (!valid_cont_thread
)
3206 resume_info
[n
].thread
= minus_one_ptid
;
3207 resume_info
[n
].kind
= resume_continue
;
3208 resume_info
[n
].sig
= 0;
3212 resume (resume_info
, n
);
3215 /* Callback for for_each_thread. Make a new stop reply for each
3219 queue_stop_reply_callback (thread_info
*thread
)
3221 /* For now, assume targets that don't have this callback also don't
3222 manage the thread's last_status field. */
3223 if (!the_target
->supports_thread_stopped ())
3225 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3227 new_notif
->ptid
= thread
->id
;
3228 new_notif
->status
= thread
->last_status
;
3229 /* Pass the last stop reply back to GDB, but don't notify
3231 notif_event_enque (¬if_stop
, new_notif
);
3235 if (target_thread_stopped (thread
))
3239 std::string status_string
3240 = target_waitstatus_to_string (&thread
->last_status
);
3242 debug_printf ("Reporting thread %s as already stopped with %s\n",
3243 target_pid_to_str (thread
->id
),
3244 status_string
.c_str ());
3247 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3249 /* Pass the last stop reply back to GDB, but don't notify
3251 queue_stop_reply (thread
->id
, &thread
->last_status
);
3256 /* Set this inferior threads's state as "want-stopped". We won't
3257 resume this thread until the client gives us another action for
3261 gdb_wants_thread_stopped (thread_info
*thread
)
3263 thread
->last_resume_kind
= resume_stop
;
3265 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3267 /* Most threads are stopped implicitly (all-stop); tag that with
3269 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3270 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3274 /* Set all threads' states as "want-stopped". */
3277 gdb_wants_all_threads_stopped (void)
3279 for_each_thread (gdb_wants_thread_stopped
);
3282 /* Callback for for_each_thread. If the thread is stopped with an
3283 interesting event, mark it as having a pending event. */
3286 set_pending_status_callback (thread_info
*thread
)
3288 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3289 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3290 /* A breakpoint, watchpoint or finished step from a previous
3291 GDB run isn't considered interesting for a new GDB run.
3292 If we left those pending, the new GDB could consider them
3293 random SIGTRAPs. This leaves out real async traps. We'd
3294 have to peek into the (target-specific) siginfo to
3295 distinguish those. */
3296 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3297 thread
->status_pending_p
= 1;
3300 /* Status handler for the '?' packet. */
3303 handle_status (char *own_buf
)
3305 client_state
&cs
= get_client_state ();
3307 /* GDB is connected, don't forward events to the target anymore. */
3308 for_each_process ([] (process_info
*process
) {
3309 process
->gdb_detached
= 0;
3312 /* In non-stop mode, we must send a stop reply for each stopped
3313 thread. In all-stop mode, just send one for the first stopped
3318 for_each_thread (queue_stop_reply_callback
);
3320 /* The first is sent immediatly. OK is sent if there is no
3321 stopped thread, which is the same handling of the vStopped
3322 packet (by design). */
3323 notif_write_event (¬if_stop
, cs
.own_buf
);
3327 thread_info
*thread
= NULL
;
3329 target_pause_all (false);
3330 target_stabilize_threads ();
3331 gdb_wants_all_threads_stopped ();
3333 /* We can only report one status, but we might be coming out of
3334 non-stop -- if more than one thread is stopped with
3335 interesting events, leave events for the threads we're not
3336 reporting now pending. They'll be reported the next time the
3337 threads are resumed. Start by marking all interesting events
3339 for_each_thread (set_pending_status_callback
);
3341 /* Prefer the last thread that reported an event to GDB (even if
3342 that was a GDB_SIGNAL_TRAP). */
3343 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3344 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3345 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3346 thread
= find_thread_ptid (cs
.last_ptid
);
3348 /* If the last event thread is not found for some reason, look
3349 for some other thread that might have an event to report. */
3351 thread
= find_thread ([] (thread_info
*thr_arg
)
3353 return thr_arg
->status_pending_p
;
3356 /* If we're still out of luck, simply pick the first thread in
3359 thread
= get_first_thread ();
3363 struct thread_info
*tp
= (struct thread_info
*) thread
;
3365 /* We're reporting this event, so it's no longer
3367 tp
->status_pending_p
= 0;
3369 /* GDB assumes the current thread is the thread we're
3370 reporting the status for. */
3371 cs
.general_thread
= thread
->id
;
3372 set_desired_thread ();
3374 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3375 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3378 strcpy (own_buf
, "W00");
3383 gdbserver_version (void)
3385 printf ("GNU gdbserver %s%s\n"
3386 "Copyright (C) 2020 Free Software Foundation, Inc.\n"
3387 "gdbserver is free software, covered by the "
3388 "GNU General Public License.\n"
3389 "This gdbserver was configured as \"%s\"\n",
3390 PKGVERSION
, version
, host_name
);
3394 gdbserver_usage (FILE *stream
)
3396 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3397 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3398 "\tgdbserver [OPTIONS] --multi COMM\n"
3400 "COMM may either be a tty device (for serial debugging),\n"
3401 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3402 "stdin/stdout of gdbserver.\n"
3403 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3404 "PID is the process ID to attach to, when --attach is specified.\n"
3406 "Operating modes:\n"
3408 " --attach Attach to running process PID.\n"
3409 " --multi Start server without a specific program, and\n"
3410 " only quit when explicitly commanded.\n"
3411 " --once Exit after the first connection has closed.\n"
3412 " --help Print this message and then exit.\n"
3413 " --version Display version information and exit.\n"
3417 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3418 " --disable-randomization\n"
3419 " Run PROG with address space randomization disabled.\n"
3420 " --no-disable-randomization\n"
3421 " Don't disable address space randomization when\n"
3423 " --startup-with-shell\n"
3424 " Start PROG using a shell. I.e., execs a shell that\n"
3425 " then execs PROG. (default)\n"
3426 " --no-startup-with-shell\n"
3427 " Exec PROG directly instead of using a shell.\n"
3428 " Disables argument globbing and variable substitution\n"
3429 " on UNIX-like systems.\n"
3433 " --debug Enable general debugging output.\n"
3434 " --debug-format=OPT1[,OPT2,...]\n"
3435 " Specify extra content in debugging output.\n"
3440 " --remote-debug Enable remote protocol debugging output.\n"
3441 " --disable-packet=OPT1[,OPT2,...]\n"
3442 " Disable support for RSP packets or features.\n"
3444 " vCont, Tthread, qC, qfThreadInfo and \n"
3445 " threads (disable all threading packets).\n"
3447 "For more information, consult the GDB manual (available as on-line \n"
3448 "info or a printed manual).\n");
3449 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3450 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3454 gdbserver_show_disableable (FILE *stream
)
3456 fprintf (stream
, "Disableable packets:\n"
3457 " vCont \tAll vCont packets\n"
3458 " qC \tQuerying the current thread\n"
3459 " qfThreadInfo\tThread listing\n"
3460 " Tthread \tPassing the thread specifier in the "
3461 "T stop reply packet\n"
3462 " threads \tAll of the above\n");
3466 kill_inferior_callback (process_info
*process
)
3468 kill_inferior (process
);
3469 discard_queued_stop_replies (ptid_t (process
->pid
));
3472 /* Call this when exiting gdbserver with possible inferiors that need
3473 to be killed or detached from. */
3476 detach_or_kill_for_exit (void)
3478 /* First print a list of the inferiors we will be killing/detaching.
3479 This is to assist the user, for example, in case the inferior unexpectedly
3480 dies after we exit: did we screw up or did the inferior exit on its own?
3481 Having this info will save some head-scratching. */
3483 if (have_started_inferiors_p ())
3485 fprintf (stderr
, "Killing process(es):");
3487 for_each_process ([] (process_info
*process
) {
3488 if (!process
->attached
)
3489 fprintf (stderr
, " %d", process
->pid
);
3492 fprintf (stderr
, "\n");
3494 if (have_attached_inferiors_p ())
3496 fprintf (stderr
, "Detaching process(es):");
3498 for_each_process ([] (process_info
*process
) {
3499 if (process
->attached
)
3500 fprintf (stderr
, " %d", process
->pid
);
3503 fprintf (stderr
, "\n");
3506 /* Now we can kill or detach the inferiors. */
3507 for_each_process ([] (process_info
*process
) {
3508 int pid
= process
->pid
;
3510 if (process
->attached
)
3511 detach_inferior (process
);
3513 kill_inferior (process
);
3515 discard_queued_stop_replies (ptid_t (pid
));
3519 /* Value that will be passed to exit(3) when gdbserver exits. */
3520 static int exit_code
;
3522 /* Wrapper for detach_or_kill_for_exit that catches and prints
3526 detach_or_kill_for_exit_cleanup ()
3530 detach_or_kill_for_exit ();
3532 catch (const gdb_exception
&exception
)
3535 fprintf (stderr
, "Detach or kill failed: %s\n",
3541 /* Main function. This is called by the real "main" function,
3542 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3544 static void ATTRIBUTE_NORETURN
3545 captured_main (int argc
, char *argv
[])
3550 const char *port
= NULL
;
3551 char **next_arg
= &argv
[1];
3552 volatile int multi_mode
= 0;
3553 volatile int attach
= 0;
3555 bool selftest
= false;
3557 const char *selftest_filter
= NULL
;
3560 current_directory
= getcwd (NULL
, 0);
3561 client_state
&cs
= get_client_state ();
3563 if (current_directory
== NULL
)
3565 error (_("Could not find current working directory: %s"),
3566 safe_strerror (errno
));
3569 while (*next_arg
!= NULL
&& **next_arg
== '-')
3571 if (strcmp (*next_arg
, "--version") == 0)
3573 gdbserver_version ();
3576 else if (strcmp (*next_arg
, "--help") == 0)
3578 gdbserver_usage (stdout
);
3581 else if (strcmp (*next_arg
, "--attach") == 0)
3583 else if (strcmp (*next_arg
, "--multi") == 0)
3585 else if (strcmp (*next_arg
, "--wrapper") == 0)
3592 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3594 wrapper_argv
+= *next_arg
;
3595 wrapper_argv
+= ' ';
3599 if (!wrapper_argv
.empty ())
3601 /* Erase the last whitespace. */
3602 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3605 if (next_arg
== tmp
|| *next_arg
== NULL
)
3607 gdbserver_usage (stderr
);
3611 /* Consume the "--". */
3614 else if (strcmp (*next_arg
, "--debug") == 0)
3616 else if (startswith (*next_arg
, "--debug-format="))
3618 std::string error_msg
3619 = parse_debug_format_options ((*next_arg
)
3620 + sizeof ("--debug-format=") - 1, 0);
3622 if (!error_msg
.empty ())
3624 fprintf (stderr
, "%s", error_msg
.c_str ());
3628 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3630 else if (startswith (*next_arg
, "--debug-file="))
3631 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3632 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3634 gdbserver_show_disableable (stdout
);
3637 else if (startswith (*next_arg
, "--disable-packet="))
3639 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3641 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3643 tok
= strtok_r (NULL
, ",", &saveptr
))
3645 if (strcmp ("vCont", tok
) == 0)
3646 disable_packet_vCont
= true;
3647 else if (strcmp ("Tthread", tok
) == 0)
3648 disable_packet_Tthread
= true;
3649 else if (strcmp ("qC", tok
) == 0)
3650 disable_packet_qC
= true;
3651 else if (strcmp ("qfThreadInfo", tok
) == 0)
3652 disable_packet_qfThreadInfo
= true;
3653 else if (strcmp ("T", tok
) == 0)
3654 disable_packet_T
= true;
3655 else if (strcmp ("threads", tok
) == 0)
3657 disable_packet_vCont
= true;
3658 disable_packet_Tthread
= true;
3659 disable_packet_qC
= true;
3660 disable_packet_qfThreadInfo
= true;
3664 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3666 gdbserver_show_disableable (stderr
);
3671 else if (strcmp (*next_arg
, "-") == 0)
3673 /* "-" specifies a stdio connection and is a form of port
3675 port
= STDIO_CONNECTION_NAME
;
3679 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3680 cs
.disable_randomization
= 1;
3681 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3682 cs
.disable_randomization
= 0;
3683 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3684 startup_with_shell
= true;
3685 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3686 startup_with_shell
= false;
3687 else if (strcmp (*next_arg
, "--once") == 0)
3689 else if (strcmp (*next_arg
, "--selftest") == 0)
3691 else if (startswith (*next_arg
, "--selftest="))
3695 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3700 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3713 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3716 gdbserver_usage (stderr
);
3720 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3721 opened by remote_prepare. */
3724 save_original_signals_state (false);
3726 /* We need to know whether the remote connection is stdio before
3727 starting the inferior. Inferiors created in this scenario have
3728 stdin,stdout redirected. So do this here before we call
3731 remote_prepare (port
);
3736 /* --attach used to come after PORT, so allow it there for
3738 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3745 && (*next_arg
== NULL
3746 || (*next_arg
)[0] == '\0'
3747 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3749 || next_arg
[1] != NULL
))
3754 gdbserver_usage (stderr
);
3758 /* Gather information about the environment. */
3759 our_environ
= gdb_environ::from_host_environ ();
3761 initialize_async_io ();
3763 have_job_control ();
3764 initialize_event_loop ();
3765 if (target_supports_tracepoints ())
3766 initialize_tracepoint ();
3768 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3773 selftests::run_tests (selftest_filter
);
3775 printf (_("Selftests have been disabled for this build.\n"));
3777 throw_quit ("Quit");
3780 if (pid
== 0 && *next_arg
!= NULL
)
3784 n
= argc
- (next_arg
- argv
);
3785 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3786 for (i
= 1; i
< n
; i
++)
3787 program_args
.push_back (xstrdup (next_arg
[i
]));
3788 program_args
.push_back (NULL
);
3790 /* Wait till we are at first instruction in program. */
3791 target_create_inferior (program_path
.get (), program_args
);
3793 /* We are now (hopefully) stopped at the first instruction of
3794 the target process. This assumes that the target process was
3795 successfully created. */
3799 if (attach_inferior (pid
) == -1)
3800 error ("Attaching not supported on this target");
3802 /* Otherwise succeeded. */
3806 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3807 cs
.last_status
.value
.integer
= 0;
3808 cs
.last_ptid
= minus_one_ptid
;
3811 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3813 /* Don't report shared library events on the initial connection,
3814 even if some libraries are preloaded. Avoids the "stopped by
3815 shared library event" notice on gdb side. */
3818 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3819 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3824 if (!was_running
&& !multi_mode
)
3825 error ("No program to debug");
3830 cs
.multi_process
= 0;
3831 cs
.report_fork_events
= 0;
3832 cs
.report_vfork_events
= 0;
3833 cs
.report_exec_events
= 0;
3834 /* Be sure we're out of tfind mode. */
3835 cs
.current_traceframe
= -1;
3836 cs
.cont_thread
= null_ptid
;
3837 cs
.swbreak_feature
= 0;
3838 cs
.hwbreak_feature
= 0;
3839 cs
.vCont_supported
= 0;
3845 /* Wait for events. This will return when all event sources
3846 are removed from the event loop. */
3847 start_event_loop ();
3849 /* If an exit was requested (using the "monitor exit"
3850 command), terminate now. */
3852 throw_quit ("Quit");
3854 /* The only other way to get here is for getpkt to fail:
3856 - If --once was specified, we're done.
3858 - If not in extended-remote mode, and we're no longer
3859 debugging anything, simply exit: GDB has disconnected
3860 after processing the last process exit.
3862 - Otherwise, close the connection and reopen it at the
3864 if (run_once
|| (!extended_protocol
&& !target_running ()))
3865 throw_quit ("Quit");
3868 "Remote side has terminated connection. "
3869 "GDBserver will reopen the connection.\n");
3871 /* Get rid of any pending statuses. An eventual reconnection
3872 (by the same GDB instance or another) will refresh all its
3873 state from scratch. */
3874 discard_queued_stop_replies (minus_one_ptid
);
3875 for_each_thread ([] (thread_info
*thread
)
3877 thread
->status_pending_p
= 0;
3882 if (disconnected_tracing
)
3884 /* Try to enable non-stop/async mode, so we we can
3885 both wait for an async socket accept, and handle
3886 async target events simultaneously. There's also
3887 no point either in having the target always stop
3888 all threads, when we're going to pass signals
3889 down without informing GDB. */
3892 if (the_target
->start_non_stop (true))
3895 /* Detaching implicitly resumes all threads;
3896 simply disconnecting does not. */
3902 "Disconnected tracing disabled; "
3903 "stopping trace run.\n");
3908 catch (const gdb_exception_error
&exception
)
3911 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3913 if (response_needed
)
3915 write_enn (cs
.own_buf
);
3916 putpkt (cs
.own_buf
);
3920 throw_quit ("Quit");
3925 /* Main function. */
3928 main (int argc
, char *argv
[])
3933 captured_main (argc
, argv
);
3935 catch (const gdb_exception
&exception
)
3937 if (exception
.reason
== RETURN_ERROR
)
3940 fprintf (stderr
, "%s\n", exception
.what ());
3941 fprintf (stderr
, "Exiting\n");
3948 gdb_assert_not_reached ("captured_main should never return");
3951 /* Process options coming from Z packets for a breakpoint. PACKET is
3952 the packet buffer. *PACKET is updated to point to the first char
3953 after the last processed option. */
3956 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3958 const char *dataptr
= *packet
;
3961 /* Check if data has the correct format. */
3962 if (*dataptr
!= ';')
3969 if (*dataptr
== ';')
3972 if (*dataptr
== 'X')
3974 /* Conditional expression. */
3976 debug_printf ("Found breakpoint condition.\n");
3977 if (!add_breakpoint_condition (bp
, &dataptr
))
3978 dataptr
= strchrnul (dataptr
, ';');
3980 else if (startswith (dataptr
, "cmds:"))
3982 dataptr
+= strlen ("cmds:");
3984 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3985 persist
= (*dataptr
== '1');
3987 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3988 dataptr
= strchrnul (dataptr
, ';');
3992 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3994 /* Skip tokens until we find one that we recognize. */
3995 dataptr
= strchrnul (dataptr
, ';');
4001 /* Event loop callback that handles a serial event. The first byte in
4002 the serial buffer gets us here. We expect characters to arrive at
4003 a brisk pace, so we read the rest of the packet with a blocking
4007 process_serial_event (void)
4009 client_state
&cs
= get_client_state ();
4015 int new_packet_len
= -1;
4017 disable_async_io ();
4019 response_needed
= false;
4020 packet_len
= getpkt (cs
.own_buf
);
4021 if (packet_len
<= 0)
4024 /* Force an event loop break. */
4027 response_needed
= true;
4029 char ch
= cs
.own_buf
[0];
4033 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4036 handle_general_set (cs
.own_buf
);
4039 handle_detach (cs
.own_buf
);
4042 extended_protocol
= true;
4043 write_ok (cs
.own_buf
);
4046 handle_status (cs
.own_buf
);
4049 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4051 require_running_or_break (cs
.own_buf
);
4053 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4055 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4056 thread_id
= null_ptid
;
4057 else if (thread_id
.is_pid ())
4059 /* The ptid represents a pid. */
4060 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4064 write_enn (cs
.own_buf
);
4068 thread_id
= thread
->id
;
4072 /* The ptid represents a lwp/tid. */
4073 if (find_thread_ptid (thread_id
) == NULL
)
4075 write_enn (cs
.own_buf
);
4080 if (cs
.own_buf
[1] == 'g')
4082 if (thread_id
== null_ptid
)
4084 /* GDB is telling us to choose any thread. Check if
4085 the currently selected thread is still valid. If
4086 it is not, select the first available. */
4087 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4089 thread
= get_first_thread ();
4090 thread_id
= thread
->id
;
4093 cs
.general_thread
= thread_id
;
4094 set_desired_thread ();
4095 gdb_assert (current_thread
!= NULL
);
4097 else if (cs
.own_buf
[1] == 'c')
4098 cs
.cont_thread
= thread_id
;
4100 write_ok (cs
.own_buf
);
4104 /* Silently ignore it so that gdb can extend the protocol
4105 without compatibility headaches. */
4106 cs
.own_buf
[0] = '\0';
4110 require_running_or_break (cs
.own_buf
);
4111 if (cs
.current_traceframe
>= 0)
4113 struct regcache
*regcache
4114 = new_register_cache (current_target_desc ());
4116 if (fetch_traceframe_registers (cs
.current_traceframe
,
4118 registers_to_string (regcache
, cs
.own_buf
);
4120 write_enn (cs
.own_buf
);
4121 free_register_cache (regcache
);
4125 struct regcache
*regcache
;
4127 if (!set_desired_thread ())
4128 write_enn (cs
.own_buf
);
4131 regcache
= get_thread_regcache (current_thread
, 1);
4132 registers_to_string (regcache
, cs
.own_buf
);
4137 require_running_or_break (cs
.own_buf
);
4138 if (cs
.current_traceframe
>= 0)
4139 write_enn (cs
.own_buf
);
4142 struct regcache
*regcache
;
4144 if (!set_desired_thread ())
4145 write_enn (cs
.own_buf
);
4148 regcache
= get_thread_regcache (current_thread
, 1);
4149 registers_from_string (regcache
, &cs
.own_buf
[1]);
4150 write_ok (cs
.own_buf
);
4156 require_running_or_break (cs
.own_buf
);
4157 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4158 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4160 write_enn (cs
.own_buf
);
4162 bin2hex (mem_buf
, cs
.own_buf
, res
);
4166 require_running_or_break (cs
.own_buf
);
4167 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4168 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4169 write_ok (cs
.own_buf
);
4171 write_enn (cs
.own_buf
);
4174 require_running_or_break (cs
.own_buf
);
4175 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4176 &mem_addr
, &len
, &mem_buf
) < 0
4177 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4178 write_enn (cs
.own_buf
);
4180 write_ok (cs
.own_buf
);
4183 require_running_or_break (cs
.own_buf
);
4184 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4185 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4186 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4189 myresume (cs
.own_buf
, 0, signal
);
4192 require_running_or_break (cs
.own_buf
);
4193 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4194 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4195 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4198 myresume (cs
.own_buf
, 1, signal
);
4201 require_running_or_break (cs
.own_buf
);
4203 myresume (cs
.own_buf
, 0, signal
);
4206 require_running_or_break (cs
.own_buf
);
4208 myresume (cs
.own_buf
, 1, signal
);
4210 case 'Z': /* insert_ ... */
4212 case 'z': /* remove_ ... */
4217 char type
= cs
.own_buf
[1];
4219 const int insert
= ch
== 'Z';
4220 const char *p
= &cs
.own_buf
[3];
4222 p
= unpack_varlen_hex (p
, &addr
);
4223 kind
= strtol (p
+ 1, &dataptr
, 16);
4227 struct gdb_breakpoint
*bp
;
4229 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4234 /* GDB may have sent us a list of *point parameters to
4235 be evaluated on the target's side. Read such list
4236 here. If we already have a list of parameters, GDB
4237 is telling us to drop that list and use this one
4239 clear_breakpoint_conditions_and_commands (bp
);
4240 const char *options
= dataptr
;
4241 process_point_options (bp
, &options
);
4245 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4248 write_ok (cs
.own_buf
);
4251 cs
.own_buf
[0] = '\0';
4253 write_enn (cs
.own_buf
);
4257 response_needed
= false;
4258 if (!target_running ())
4259 /* The packet we received doesn't make sense - but we can't
4260 reply to it, either. */
4263 fprintf (stderr
, "Killing all inferiors\n");
4265 for_each_process (kill_inferior_callback
);
4267 /* When using the extended protocol, we wait with no program
4268 running. The traditional protocol will exit instead. */
4269 if (extended_protocol
)
4271 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4272 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4280 require_running_or_break (cs
.own_buf
);
4282 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4283 if (find_thread_ptid (thread_id
) == NULL
)
4285 write_enn (cs
.own_buf
);
4289 if (mythread_alive (thread_id
))
4290 write_ok (cs
.own_buf
);
4292 write_enn (cs
.own_buf
);
4296 response_needed
= false;
4298 /* Restarting the inferior is only supported in the extended
4300 if (extended_protocol
)
4302 if (target_running ())
4303 for_each_process (kill_inferior_callback
);
4305 fprintf (stderr
, "GDBserver restarting\n");
4307 /* Wait till we are at 1st instruction in prog. */
4308 if (program_path
.get () != NULL
)
4310 target_create_inferior (program_path
.get (), program_args
);
4312 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4314 /* Stopped at the first instruction of the target
4316 cs
.general_thread
= cs
.last_ptid
;
4320 /* Something went wrong. */
4321 cs
.general_thread
= null_ptid
;
4326 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4327 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4333 /* It is a request we don't understand. Respond with an
4334 empty packet so that gdb knows that we don't support this
4336 cs
.own_buf
[0] = '\0';
4340 /* Extended (long) request. */
4341 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4345 /* It is a request we don't understand. Respond with an empty
4346 packet so that gdb knows that we don't support this
4348 cs
.own_buf
[0] = '\0';
4352 if (new_packet_len
!= -1)
4353 putpkt_binary (cs
.own_buf
, new_packet_len
);
4355 putpkt (cs
.own_buf
);
4357 response_needed
= false;
4365 /* Event-loop callback for serial events. */
4368 handle_serial_event (int err
, gdb_client_data client_data
)
4371 debug_printf ("handling possible serial event\n");
4373 /* Really handle it. */
4374 if (process_serial_event () < 0)
4377 /* Be sure to not change the selected thread behind GDB's back.
4378 Important in the non-stop mode asynchronous protocol. */
4379 set_desired_thread ();
4384 /* Push a stop notification on the notification queue. */
4387 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4389 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4391 vstop_notif
->status
= *status
;
4392 vstop_notif
->ptid
= ptid
;
4393 /* Push Stop notification. */
4394 notif_push (¬if_stop
, vstop_notif
);
4397 /* Event-loop callback for target events. */
4400 handle_target_event (int err
, gdb_client_data client_data
)
4402 client_state
&cs
= get_client_state ();
4404 debug_printf ("handling possible target event\n");
4406 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4409 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4411 if (gdb_connected () && report_no_resumed
)
4412 push_stop_notification (null_ptid
, &cs
.last_status
);
4414 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4416 int pid
= cs
.last_ptid
.pid ();
4417 struct process_info
*process
= find_process_pid (pid
);
4418 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4420 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4421 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4423 mark_breakpoints_out (process
);
4424 target_mourn_inferior (cs
.last_ptid
);
4426 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4430 /* We're reporting this thread as stopped. Update its
4431 "want-stopped" state to what the client wants, until it
4432 gets a new resume action. */
4433 current_thread
->last_resume_kind
= resume_stop
;
4434 current_thread
->last_status
= cs
.last_status
;
4439 if (!target_running ())
4441 /* The last process exited. We're done. */
4445 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4446 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4447 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4451 /* A thread stopped with a signal, but gdb isn't
4452 connected to handle it. Pass it down to the
4453 inferior, as if it wasn't being traced. */
4454 enum gdb_signal signal
;
4457 debug_printf ("GDB not connected; forwarding event %d for"
4459 (int) cs
.last_status
.kind
,
4460 target_pid_to_str (cs
.last_ptid
));
4462 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4463 signal
= cs
.last_status
.value
.sig
;
4465 signal
= GDB_SIGNAL_0
;
4466 target_continue (cs
.last_ptid
, signal
);
4470 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4473 /* Be sure to not change the selected thread behind GDB's back.
4474 Important in the non-stop mode asynchronous protocol. */
4475 set_desired_thread ();
4488 } // namespace selftests
4489 #endif /* GDB_SELF_TEST */