1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2021 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"
50 #include "gdbsupport/gdb_select.h"
51 #include "gdbsupport/scoped_restore.h"
52 #include "gdbsupport/search.h"
54 #define require_running_or_return(BUF) \
55 if (!target_running ()) \
61 #define require_running_or_break(BUF) \
62 if (!target_running ()) \
68 /* String containing the current directory (what getwd would return). */
70 char *current_directory
;
72 /* The environment to pass to the inferior when creating it. */
74 static gdb_environ our_environ
;
78 static bool extended_protocol
;
79 static bool response_needed
;
80 static bool exit_requested
;
82 /* --once: Exit after the first connection has closed. */
85 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
86 static bool report_no_resumed
;
88 /* The event loop checks this to decide whether to continue accepting
90 static bool keep_processing_events
= true;
95 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
97 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
99 m_path
= std::move (path
);
101 /* Make sure we're using the absolute path of the inferior when
103 if (!contains_dir_separator (m_path
.get ()))
107 /* Check if the file is in our CWD. If it is, then we prefix
108 its name with CURRENT_DIRECTORY. Otherwise, we leave the
109 name as-is because we'll try searching for it in $PATH. */
110 if (is_regular_file (m_path
.get (), ®_file_errno
))
111 m_path
= gdb_abspath (m_path
.get ());
115 /* Return the PROGRAM_PATH. */
117 { return m_path
.get (); }
120 /* The program name, adjusted if needed. */
121 gdb::unique_xmalloc_ptr
<char> m_path
;
123 static std::vector
<char *> program_args
;
124 static std::string wrapper_argv
;
126 /* The PID of the originally created or attached inferior. Used to
127 send signals to the process when GDB sends us an asynchronous interrupt
128 (user hitting Control-C in the client), and to wait for the child to exit
129 when no longer debugging it. */
131 unsigned long signal_pid
;
133 /* Set if you want to disable optional thread related packets support
134 in gdbserver, for the sake of testing GDB against stubs that don't
136 bool disable_packet_vCont
;
137 bool disable_packet_Tthread
;
138 bool disable_packet_qC
;
139 bool disable_packet_qfThreadInfo
;
140 bool disable_packet_T
;
142 static unsigned char *mem_buf
;
144 /* A sub-class of 'struct notif_event' for stop, holding information
145 relative to a single stop reply. We keep a queue of these to
146 push to GDB in non-stop mode. */
148 struct vstop_notif
: public notif_event
150 /* Thread or process that got the event. */
154 struct target_waitstatus status
;
157 /* The current btrace configuration. This is gdbserver's mirror of GDB's
158 btrace configuration. */
159 static struct btrace_config current_btrace_conf
;
161 /* The client remote protocol state. */
163 static client_state g_client_state
;
168 client_state
&cs
= g_client_state
;
173 /* Put a stop reply to the stop reply queue. */
176 queue_stop_reply (ptid_t ptid
, const target_waitstatus
&status
)
178 struct vstop_notif
*new_notif
= new struct vstop_notif
;
180 new_notif
->ptid
= ptid
;
181 new_notif
->status
= status
;
183 notif_event_enque (¬if_stop
, new_notif
);
187 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
189 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
191 return vstop_event
->ptid
.matches (filter_ptid
);
197 discard_queued_stop_replies (ptid_t ptid
)
199 std::list
<notif_event
*>::iterator iter
, next
, end
;
200 end
= notif_stop
.queue
.end ();
201 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
206 if (iter
== notif_stop
.queue
.begin ())
208 /* The head of the list contains the notification that was
209 already sent to GDB. So we can't remove it, otherwise
210 when GDB sends the vStopped, it would ack the _next_
211 notification, which hadn't been sent yet! */
215 if (remove_all_on_match_ptid (*iter
, ptid
))
218 notif_stop
.queue
.erase (iter
);
224 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
226 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
228 prepare_resume_reply (own_buf
, vstop
->ptid
, vstop
->status
);
231 /* Helper for in_queued_stop_replies. */
234 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
236 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
238 if (vstop_event
->ptid
.matches (filter_ptid
))
241 /* Don't resume fork children that GDB does not know about yet. */
242 if ((vstop_event
->status
.kind () == TARGET_WAITKIND_FORKED
243 || vstop_event
->status
.kind () == TARGET_WAITKIND_VFORKED
)
244 && vstop_event
->status
.child_ptid ().matches (filter_ptid
))
253 in_queued_stop_replies (ptid_t ptid
)
255 for (notif_event
*event
: notif_stop
.queue
)
257 if (in_queued_stop_replies_ptid (event
, ptid
))
264 struct notif_server notif_stop
=
266 "vStopped", "Stop", {}, vstop_notif_reply
,
270 target_running (void)
272 return get_first_thread () != NULL
;
275 /* See gdbsupport/common-inferior.h. */
280 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
283 /* See gdbsupport/common-inferior.h. */
286 get_exec_file (int err
)
288 if (err
&& program_path
.get () == NULL
)
289 error (_("No executable file specified."));
291 return program_path
.get ();
303 attach_inferior (int pid
)
305 client_state
&cs
= get_client_state ();
306 /* myattach should return -1 if attaching is unsupported,
307 0 if it succeeded, and call error() otherwise. */
309 if (find_process_pid (pid
) != nullptr)
310 error ("Already attached to process %d\n", pid
);
312 if (myattach (pid
) != 0)
315 fprintf (stderr
, "Attached; pid = %d\n", pid
);
318 /* FIXME - It may be that we should get the SIGNAL_PID from the
319 attach function, so that it can be the main thread instead of
320 whichever we were told to attach to. */
325 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
327 /* GDB knows to ignore the first SIGSTOP after attaching to a running
328 process using the "attach" command, but this is different; it's
329 just using "target remote". Pretend it's just starting up. */
330 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
331 && cs
.last_status
.sig () == GDB_SIGNAL_STOP
)
332 cs
.last_status
.set_stopped (GDB_SIGNAL_TRAP
);
334 current_thread
->last_resume_kind
= resume_stop
;
335 current_thread
->last_status
= cs
.last_status
;
341 /* Decode a qXfer read request. Return 0 if everything looks OK,
345 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
347 /* After the read marker and annex, qXfer looks like a
348 traditional 'm' packet. */
349 decode_m_packet (buf
, ofs
, len
);
355 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
357 /* Extract and NUL-terminate the object. */
359 while (*buf
&& *buf
!= ':')
365 /* Extract and NUL-terminate the read/write action. */
367 while (*buf
&& *buf
!= ':')
373 /* Extract and NUL-terminate the annex. */
375 while (*buf
&& *buf
!= ':')
385 /* Write the response to a successful qXfer read. Returns the
386 length of the (binary) data stored in BUF, corresponding
387 to as much of DATA/LEN as we could fit. IS_MORE controls
388 the first character of the response. */
390 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
399 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
400 &out_len
, PBUFSIZ
- 2) + 1;
403 /* Handle btrace enabling in BTS format. */
406 handle_btrace_enable_bts (struct thread_info
*thread
)
408 if (thread
->btrace
!= NULL
)
409 error (_("Btrace already enabled."));
411 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
412 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
415 /* Handle btrace enabling in Intel Processor Trace format. */
418 handle_btrace_enable_pt (struct thread_info
*thread
)
420 if (thread
->btrace
!= NULL
)
421 error (_("Btrace already enabled."));
423 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
424 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
427 /* Handle btrace disabling. */
430 handle_btrace_disable (struct thread_info
*thread
)
433 if (thread
->btrace
== NULL
)
434 error (_("Branch tracing not enabled."));
436 if (target_disable_btrace (thread
->btrace
) != 0)
437 error (_("Could not disable branch tracing."));
439 thread
->btrace
= NULL
;
442 /* Handle the "Qbtrace" packet. */
445 handle_btrace_general_set (char *own_buf
)
447 client_state
&cs
= get_client_state ();
448 struct thread_info
*thread
;
451 if (!startswith (own_buf
, "Qbtrace:"))
454 op
= own_buf
+ strlen ("Qbtrace:");
456 if (cs
.general_thread
== null_ptid
457 || cs
.general_thread
== minus_one_ptid
)
459 strcpy (own_buf
, "E.Must select a single thread.");
463 thread
= find_thread_ptid (cs
.general_thread
);
466 strcpy (own_buf
, "E.No such thread.");
472 if (strcmp (op
, "bts") == 0)
473 handle_btrace_enable_bts (thread
);
474 else if (strcmp (op
, "pt") == 0)
475 handle_btrace_enable_pt (thread
);
476 else if (strcmp (op
, "off") == 0)
477 handle_btrace_disable (thread
);
479 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
483 catch (const gdb_exception_error
&exception
)
485 sprintf (own_buf
, "E.%s", exception
.what ());
491 /* Handle the "Qbtrace-conf" packet. */
494 handle_btrace_conf_general_set (char *own_buf
)
496 client_state
&cs
= get_client_state ();
497 struct thread_info
*thread
;
500 if (!startswith (own_buf
, "Qbtrace-conf:"))
503 op
= own_buf
+ strlen ("Qbtrace-conf:");
505 if (cs
.general_thread
== null_ptid
506 || cs
.general_thread
== minus_one_ptid
)
508 strcpy (own_buf
, "E.Must select a single thread.");
512 thread
= find_thread_ptid (cs
.general_thread
);
515 strcpy (own_buf
, "E.No such thread.");
519 if (startswith (op
, "bts:size="))
525 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
526 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
528 strcpy (own_buf
, "E.Bad size value.");
532 current_btrace_conf
.bts
.size
= (unsigned int) size
;
534 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
540 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
541 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
543 strcpy (own_buf
, "E.Bad size value.");
547 current_btrace_conf
.pt
.size
= (unsigned int) size
;
551 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
559 /* Create the qMemTags packet reply given TAGS.
561 Returns true if parsing succeeded and false otherwise. */
564 create_fetch_memtags_reply (char *reply
, const gdb::byte_vector
&tags
)
566 /* It is an error to pass a zero-sized tag vector. */
567 gdb_assert (tags
.size () != 0);
569 std::string
packet ("m");
571 /* Write the tag data. */
572 packet
+= bin2hex (tags
.data (), tags
.size ());
574 /* Check if the reply is too big for the packet to handle. */
575 if (PBUFSIZ
< packet
.size ())
578 strcpy (reply
, packet
.c_str ());
582 /* Parse the QMemTags request into ADDR, LEN and TAGS.
584 Returns true if parsing succeeded and false otherwise. */
587 parse_store_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
588 gdb::byte_vector
&tags
, int *type
)
590 gdb_assert (startswith (request
, "QMemTags:"));
592 const char *p
= request
+ strlen ("QMemTags:");
594 /* Read address and length. */
595 unsigned int length
= 0;
596 p
= decode_m_packet_params (p
, addr
, &length
, ':');
599 /* Read the tag type. */
600 ULONGEST tag_type
= 0;
601 p
= unpack_varlen_hex (p
, &tag_type
);
602 *type
= (int) tag_type
;
604 /* Make sure there is a colon after the type. */
608 /* Skip the colon. */
611 /* Read the tag data. */
617 /* Handle all of the extended 'Q' packets. */
620 handle_general_set (char *own_buf
)
622 client_state
&cs
= get_client_state ();
623 if (startswith (own_buf
, "QPassSignals:"))
625 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
626 const char *p
= own_buf
+ strlen ("QPassSignals:");
629 p
= decode_address_to_semicolon (&cursig
, p
);
630 for (i
= 0; i
< numsigs
; i
++)
634 cs
.pass_signals
[i
] = 1;
636 /* Keep looping, to clear the remaining signals. */
639 p
= decode_address_to_semicolon (&cursig
, p
);
642 cs
.pass_signals
[i
] = 0;
644 strcpy (own_buf
, "OK");
648 if (startswith (own_buf
, "QProgramSignals:"))
650 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
651 const char *p
= own_buf
+ strlen ("QProgramSignals:");
654 cs
.program_signals_p
= 1;
656 p
= decode_address_to_semicolon (&cursig
, p
);
657 for (i
= 0; i
< numsigs
; i
++)
661 cs
.program_signals
[i
] = 1;
663 /* Keep looping, to clear the remaining signals. */
666 p
= decode_address_to_semicolon (&cursig
, p
);
669 cs
.program_signals
[i
] = 0;
671 strcpy (own_buf
, "OK");
675 if (startswith (own_buf
, "QCatchSyscalls:"))
677 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
680 struct process_info
*process
;
682 if (!target_running () || !target_supports_catch_syscall ())
688 if (strcmp (p
, "0") == 0)
690 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
694 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
700 process
= current_process ();
701 process
->syscalls_to_catch
.clear ();
711 p
= decode_address_to_semicolon (&sysno
, p
);
712 process
->syscalls_to_catch
.push_back (sysno
);
716 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
723 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
725 our_environ
= gdb_environ::from_host_environ ();
731 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
733 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
734 /* The final form of the environment variable. FINAL_VAR will
735 hold the 'VAR=VALUE' format. */
736 std::string final_var
= hex2str (p
);
737 std::string var_name
, var_value
;
741 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
742 debug_printf (_("[Environment variable to be set: '%s']\n"),
747 size_t pos
= final_var
.find ('=');
748 if (pos
== std::string::npos
)
750 warning (_("Unexpected format for environment variable: '%s'"),
756 var_name
= final_var
.substr (0, pos
);
757 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
759 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
765 if (startswith (own_buf
, "QEnvironmentUnset:"))
767 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
768 std::string varname
= hex2str (p
);
772 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
773 debug_printf (_("[Environment variable to be unset: '%s']\n"),
778 our_environ
.unset (varname
.c_str ());
784 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
788 debug_printf ("[noack mode enabled]\n");
797 if (startswith (own_buf
, "QNonStop:"))
799 char *mode
= own_buf
+ 9;
803 if (strcmp (mode
, "0") == 0)
805 else if (strcmp (mode
, "1") == 0)
809 /* We don't know what this mode is, so complain to
811 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
817 req_str
= req
? "non-stop" : "all-stop";
818 if (the_target
->start_non_stop (req
== 1) != 0)
820 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
825 non_stop
= (req
!= 0);
828 debug_printf ("[%s mode enabled]\n", req_str
);
834 if (startswith (own_buf
, "QDisableRandomization:"))
836 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
839 unpack_varlen_hex (packet
, &setting
);
840 cs
.disable_randomization
= setting
;
844 debug_printf (cs
.disable_randomization
845 ? "[address space randomization disabled]\n"
846 : "[address space randomization enabled]\n");
853 if (target_supports_tracepoints ()
854 && handle_tracepoint_general_set (own_buf
))
857 if (startswith (own_buf
, "QAgent:"))
859 char *mode
= own_buf
+ strlen ("QAgent:");
862 if (strcmp (mode
, "0") == 0)
864 else if (strcmp (mode
, "1") == 0)
868 /* We don't know what this value is, so complain to GDB. */
869 sprintf (own_buf
, "E.Unknown QAgent value");
873 /* Update the flag. */
876 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
881 if (handle_btrace_general_set (own_buf
))
884 if (handle_btrace_conf_general_set (own_buf
))
887 if (startswith (own_buf
, "QThreadEvents:"))
889 char *mode
= own_buf
+ strlen ("QThreadEvents:");
890 enum tribool req
= TRIBOOL_UNKNOWN
;
892 if (strcmp (mode
, "0") == 0)
894 else if (strcmp (mode
, "1") == 0)
898 /* We don't know what this mode is, so complain to GDB. */
900 = string_printf ("E.Unknown thread-events mode requested: %s\n",
902 strcpy (own_buf
, err
.c_str ());
906 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
910 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
912 debug_printf ("[thread events are now %s]\n", req_str
);
919 if (startswith (own_buf
, "QStartupWithShell:"))
921 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
923 if (strcmp (value
, "1") == 0)
924 startup_with_shell
= true;
925 else if (strcmp (value
, "0") == 0)
926 startup_with_shell
= false;
930 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
937 debug_printf (_("[Inferior will %s started with shell]"),
938 startup_with_shell
? "be" : "not be");
944 if (startswith (own_buf
, "QSetWorkingDir:"))
946 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
950 std::string path
= hex2str (p
);
953 debug_printf (_("[Set the inferior's current directory to %s]\n"),
956 set_inferior_cwd (std::move (path
));
960 /* An empty argument means that we should clear out any
961 previously set cwd for the inferior. */
962 set_inferior_cwd ("");
966 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
974 /* Handle store memory tags packets. */
975 if (startswith (own_buf
, "QMemTags:")
976 && target_supports_memory_tagging ())
978 gdb::byte_vector tags
;
983 require_running_or_return (own_buf
);
985 bool ret
= parse_store_memtags_request (own_buf
, &addr
, &len
, tags
,
989 ret
= the_target
->store_memtags (addr
, len
, tags
, type
);
999 /* Otherwise we didn't know what packet it was. Say we didn't
1005 get_features_xml (const char *annex
)
1007 const struct target_desc
*desc
= current_target_desc ();
1009 /* `desc->xmltarget' defines what to return when looking for the
1010 "target.xml" file. Its contents can either be verbatim XML code
1011 (prefixed with a '@') or else the name of the actual XML file to
1012 be used in place of "target.xml".
1014 This variable is set up from the auto-generated
1015 init_registers_... routine for the current target. */
1017 if (strcmp (annex
, "target.xml") == 0)
1019 const char *ret
= tdesc_get_features_xml (desc
);
1031 /* Look for the annex. */
1032 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
1033 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
1036 if (xml_builtin
[i
][0] != NULL
)
1037 return xml_builtin
[i
][1];
1045 monitor_show_help (void)
1047 monitor_output ("The following monitor commands are supported:\n");
1048 monitor_output (" set debug <0|1>\n");
1049 monitor_output (" Enable general debugging messages\n");
1050 monitor_output (" set debug-hw-points <0|1>\n");
1051 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
1052 monitor_output (" set remote-debug <0|1>\n");
1053 monitor_output (" Enable remote protocol debugging messages\n");
1054 monitor_output (" set event-loop-debug <0|1>\n");
1055 monitor_output (" Enable event loop debugging messages\n");
1056 monitor_output (" set debug-format option1[,option2,...]\n");
1057 monitor_output (" Add additional information to debugging messages\n");
1058 monitor_output (" Options: all, none");
1059 monitor_output (", timestamp");
1060 monitor_output ("\n");
1061 monitor_output (" exit\n");
1062 monitor_output (" Quit GDBserver\n");
1065 /* Read trace frame or inferior memory. Returns the number of bytes
1066 actually read, zero when no further transfer is possible, and -1 on
1067 error. Return of a positive value smaller than LEN does not
1068 indicate there's no more to be read, only the end of the transfer.
1069 E.g., when GDB reads memory from a traceframe, a first request may
1070 be served from a memory block that does not cover the whole request
1071 length. A following request gets the rest served from either
1072 another block (of the same traceframe) or from the read-only
1076 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1078 client_state
&cs
= get_client_state ();
1081 if (cs
.current_traceframe
>= 0)
1084 ULONGEST length
= len
;
1086 if (traceframe_read_mem (cs
.current_traceframe
,
1087 memaddr
, myaddr
, len
, &nbytes
))
1089 /* Data read from trace buffer, we're done. */
1092 if (!in_readonly_region (memaddr
, length
))
1094 /* Otherwise we have a valid readonly case, fall through. */
1095 /* (assume no half-trace half-real blocks for now) */
1098 res
= prepare_to_access_memory ();
1101 if (set_desired_thread ())
1102 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1105 done_accessing_memory ();
1107 return res
== 0 ? len
: -1;
1113 /* Write trace frame or inferior memory. Actually, writing to trace
1114 frames is forbidden. */
1117 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1119 client_state
&cs
= get_client_state ();
1120 if (cs
.current_traceframe
>= 0)
1126 ret
= prepare_to_access_memory ();
1129 if (set_desired_thread ())
1130 ret
= target_write_memory (memaddr
, myaddr
, len
);
1133 done_accessing_memory ();
1139 /* Handle qSearch:memory packets. */
1142 handle_search_memory (char *own_buf
, int packet_len
)
1144 CORE_ADDR start_addr
;
1145 CORE_ADDR search_space_len
;
1147 unsigned int pattern_len
;
1149 CORE_ADDR found_addr
;
1150 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1152 pattern
= (gdb_byte
*) malloc (packet_len
);
1153 if (pattern
== NULL
)
1154 error ("Unable to allocate memory to perform the search");
1156 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1157 packet_len
- cmd_name_len
,
1158 &start_addr
, &search_space_len
,
1159 pattern
, &pattern_len
) < 0)
1162 error ("Error in parsing qSearch:memory packet");
1165 auto read_memory
= [] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
1167 return gdb_read_memory (addr
, result
, len
) == len
;
1170 found
= simple_search_memory (read_memory
, start_addr
, search_space_len
,
1171 pattern
, pattern_len
, &found_addr
);
1174 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1175 else if (found
== 0)
1176 strcpy (own_buf
, "0");
1178 strcpy (own_buf
, "E00");
1183 /* Handle the "D" packet. */
1186 handle_detach (char *own_buf
)
1188 client_state
&cs
= get_client_state ();
1190 process_info
*process
;
1192 if (cs
.multi_process
)
1195 int pid
= strtol (&own_buf
[2], NULL
, 16);
1197 process
= find_process_pid (pid
);
1201 process
= (current_thread
!= nullptr
1202 ? get_thread_process (current_thread
)
1206 if (process
== NULL
)
1208 write_enn (own_buf
);
1212 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1214 if (tracing
&& disconnected_tracing
)
1216 "Disconnected tracing in effect, "
1217 "leaving gdbserver attached to the process\n");
1219 if (any_persistent_commands (process
))
1221 "Persistent commands are present, "
1222 "leaving gdbserver attached to the process\n");
1224 /* Make sure we're in non-stop/async mode, so we we can both
1225 wait for an async socket accept, and handle async target
1226 events simultaneously. There's also no point either in
1227 having the target stop all threads, when we're going to
1228 pass signals down without informing GDB. */
1232 debug_printf ("Forcing non-stop mode\n");
1235 the_target
->start_non_stop (true);
1238 process
->gdb_detached
= 1;
1240 /* Detaching implicitly resumes all threads. */
1241 target_continue_no_signal (minus_one_ptid
);
1247 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1250 /* We'll need this after PROCESS has been destroyed. */
1251 int pid
= process
->pid
;
1253 if (detach_inferior (process
) != 0)
1254 write_enn (own_buf
);
1257 discard_queued_stop_replies (ptid_t (pid
));
1260 if (extended_protocol
|| target_running ())
1262 /* There is still at least one inferior remaining or
1263 we are in extended mode, so don't terminate gdbserver,
1264 and instead treat this like a normal program exit. */
1265 cs
.last_status
.set_exited (0);
1266 cs
.last_ptid
= ptid_t (pid
);
1268 current_thread
= NULL
;
1275 /* If we are attached, then we can exit. Otherwise, we
1276 need to hang around doing nothing, until the child is
1278 join_inferior (pid
);
1284 /* Parse options to --debug-format= and "monitor set debug-format".
1285 ARG is the text after "--debug-format=" or "monitor set debug-format".
1286 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1287 This triggers calls to monitor_output.
1288 The result is an empty string if all options were parsed ok, otherwise an
1289 error message which the caller must free.
1291 N.B. These commands affect all debug format settings, they are not
1292 cumulative. If a format is not specified, it is turned off.
1293 However, we don't go to extra trouble with things like
1294 "monitor set debug-format all,none,timestamp".
1295 Instead we just parse them one at a time, in order.
1297 The syntax for "monitor set debug" we support here is not identical
1298 to gdb's "set debug foo on|off" because we also use this function to
1299 parse "--debug-format=foo,bar". */
1302 parse_debug_format_options (const char *arg
, int is_monitor
)
1304 /* First turn all debug format options off. */
1305 debug_timestamp
= 0;
1307 /* First remove leading spaces, for "monitor set debug-format". */
1308 while (isspace (*arg
))
1311 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1312 = delim_string_to_char_ptr_vec (arg
, ',');
1314 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1316 if (strcmp (option
.get (), "all") == 0)
1318 debug_timestamp
= 1;
1320 monitor_output ("All extra debug format options enabled.\n");
1322 else if (strcmp (option
.get (), "none") == 0)
1324 debug_timestamp
= 0;
1326 monitor_output ("All extra debug format options disabled.\n");
1328 else if (strcmp (option
.get (), "timestamp") == 0)
1330 debug_timestamp
= 1;
1332 monitor_output ("Timestamps will be added to debug output.\n");
1334 else if (*option
== '\0')
1336 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1340 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1344 return std::string ();
1347 /* Handle monitor commands not handled by target-specific handlers. */
1350 handle_monitor_command (char *mon
, char *own_buf
)
1352 if (strcmp (mon
, "set debug 1") == 0)
1355 monitor_output ("Debug output enabled.\n");
1357 else if (strcmp (mon
, "set debug 0") == 0)
1360 monitor_output ("Debug output disabled.\n");
1362 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1364 show_debug_regs
= 1;
1365 monitor_output ("H/W point debugging output enabled.\n");
1367 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1369 show_debug_regs
= 0;
1370 monitor_output ("H/W point debugging output disabled.\n");
1372 else if (strcmp (mon
, "set remote-debug 1") == 0)
1375 monitor_output ("Protocol debug output enabled.\n");
1377 else if (strcmp (mon
, "set remote-debug 0") == 0)
1380 monitor_output ("Protocol debug output disabled.\n");
1382 else if (strcmp (mon
, "set event-loop-debug 1") == 0)
1384 debug_event_loop
= debug_event_loop_kind::ALL
;
1385 monitor_output ("Event loop debug output enabled.\n");
1387 else if (strcmp (mon
, "set event-loop-debug 0") == 0)
1389 debug_event_loop
= debug_event_loop_kind::OFF
;
1390 monitor_output ("Event loop debug output disabled.\n");
1392 else if (startswith (mon
, "set debug-format "))
1394 std::string error_msg
1395 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1398 if (!error_msg
.empty ())
1400 monitor_output (error_msg
.c_str ());
1401 monitor_show_help ();
1402 write_enn (own_buf
);
1405 else if (strcmp (mon
, "set debug-file") == 0)
1406 debug_set_output (nullptr);
1407 else if (startswith (mon
, "set debug-file "))
1408 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1409 else if (strcmp (mon
, "help") == 0)
1410 monitor_show_help ();
1411 else if (strcmp (mon
, "exit") == 0)
1412 exit_requested
= true;
1415 monitor_output ("Unknown monitor command.\n\n");
1416 monitor_show_help ();
1417 write_enn (own_buf
);
1421 /* Associates a callback with each supported qXfer'able object. */
1425 /* The object this handler handles. */
1428 /* Request that the target transfer up to LEN 8-bit bytes of the
1429 target's OBJECT. The OFFSET, for a seekable object, specifies
1430 the starting point. The ANNEX can be used to provide additional
1431 data-specific information to the target.
1433 Return the number of bytes actually transfered, zero when no
1434 further transfer is possible, -1 on error, -2 when the transfer
1435 is not supported, and -3 on a verbose error message that should
1436 be preserved. Return of a positive value smaller than LEN does
1437 not indicate the end of the object, only the end of the transfer.
1439 One, and only one, of readbuf or writebuf must be non-NULL. */
1440 int (*xfer
) (const char *annex
,
1441 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1442 ULONGEST offset
, LONGEST len
);
1445 /* Handle qXfer:auxv:read. */
1448 handle_qxfer_auxv (const char *annex
,
1449 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1450 ULONGEST offset
, LONGEST len
)
1452 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1455 if (annex
[0] != '\0' || current_thread
== NULL
)
1458 return the_target
->read_auxv (offset
, readbuf
, len
);
1461 /* Handle qXfer:exec-file:read. */
1464 handle_qxfer_exec_file (const char *annex
,
1465 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1466 ULONGEST offset
, LONGEST len
)
1471 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1474 if (annex
[0] == '\0')
1476 if (current_thread
== NULL
)
1479 pid
= pid_of (current_thread
);
1483 annex
= unpack_varlen_hex (annex
, &pid
);
1484 if (annex
[0] != '\0')
1491 const char *file
= the_target
->pid_to_exec_file (pid
);
1495 total_len
= strlen (file
);
1497 if (offset
> total_len
)
1500 if (offset
+ len
> total_len
)
1501 len
= total_len
- offset
;
1503 memcpy (readbuf
, file
+ offset
, len
);
1507 /* Handle qXfer:features:read. */
1510 handle_qxfer_features (const char *annex
,
1511 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1512 ULONGEST offset
, LONGEST len
)
1514 const char *document
;
1517 if (writebuf
!= NULL
)
1520 if (!target_running ())
1523 /* Grab the correct annex. */
1524 document
= get_features_xml (annex
);
1525 if (document
== NULL
)
1528 total_len
= strlen (document
);
1530 if (offset
> total_len
)
1533 if (offset
+ len
> total_len
)
1534 len
= total_len
- offset
;
1536 memcpy (readbuf
, document
+ offset
, len
);
1540 /* Handle qXfer:libraries:read. */
1543 handle_qxfer_libraries (const char *annex
,
1544 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1545 ULONGEST offset
, LONGEST len
)
1547 if (writebuf
!= NULL
)
1550 if (annex
[0] != '\0' || current_thread
== NULL
)
1553 std::string document
= "<library-list version=\"1.0\">\n";
1555 process_info
*proc
= current_process ();
1556 for (const dll_info
&dll
: proc
->all_dlls
)
1557 document
+= string_printf
1558 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1559 dll
.name
.c_str (), paddress (dll
.base_addr
));
1561 document
+= "</library-list>\n";
1563 if (offset
> document
.length ())
1566 if (offset
+ len
> document
.length ())
1567 len
= document
.length () - offset
;
1569 memcpy (readbuf
, &document
[offset
], len
);
1574 /* Handle qXfer:libraries-svr4:read. */
1577 handle_qxfer_libraries_svr4 (const char *annex
,
1578 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1579 ULONGEST offset
, LONGEST len
)
1581 if (writebuf
!= NULL
)
1584 if (current_thread
== NULL
1585 || !the_target
->supports_qxfer_libraries_svr4 ())
1588 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1592 /* Handle qXfer:osadata:read. */
1595 handle_qxfer_osdata (const char *annex
,
1596 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1597 ULONGEST offset
, LONGEST len
)
1599 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1602 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1605 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1608 handle_qxfer_siginfo (const char *annex
,
1609 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1610 ULONGEST offset
, LONGEST len
)
1612 if (!the_target
->supports_qxfer_siginfo ())
1615 if (annex
[0] != '\0' || current_thread
== NULL
)
1618 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1621 /* Handle qXfer:statictrace:read. */
1624 handle_qxfer_statictrace (const char *annex
,
1625 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1626 ULONGEST offset
, LONGEST len
)
1628 client_state
&cs
= get_client_state ();
1631 if (writebuf
!= NULL
)
1634 if (annex
[0] != '\0' || current_thread
== NULL
1635 || cs
.current_traceframe
== -1)
1638 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1639 readbuf
, len
, &nbytes
))
1644 /* Helper for handle_qxfer_threads_proper.
1645 Emit the XML to describe the thread of INF. */
1648 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1650 ptid_t ptid
= ptid_of (thread
);
1652 int core
= target_core_of_thread (ptid
);
1654 const char *name
= target_thread_name (ptid
);
1657 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1659 /* If this is a fork or vfork child (has a fork parent), GDB does not yet
1660 know about this process, and must not know about it until it gets the
1661 corresponding (v)fork event. Exclude this thread from the list. */
1662 if (target_thread_pending_parent (thread
) != nullptr)
1665 write_ptid (ptid_s
, ptid
);
1667 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1671 sprintf (core_s
, "%d", core
);
1672 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1676 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1680 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1681 bin2hex (handle
, handle_s
, handle_len
);
1682 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1685 buffer_xml_printf (buffer
, "/>\n");
1688 /* Helper for handle_qxfer_threads. Return true on success, false
1692 handle_qxfer_threads_proper (struct buffer
*buffer
)
1694 client_state
&cs
= get_client_state ();
1696 scoped_restore save_current_thread
1697 = make_scoped_restore (¤t_thread
);
1698 scoped_restore save_current_general_thread
1699 = make_scoped_restore (&cs
.general_thread
);
1701 buffer_grow_str (buffer
, "<threads>\n");
1703 process_info
*error_proc
= find_process ([&] (process_info
*process
)
1705 /* The target may need to access memory and registers (e.g. via
1706 libthread_db) to fetch thread properties. Prepare for memory
1707 access here, so that we potentially pause threads just once
1708 for all accesses. Note that even if someday we stop needing
1709 to pause threads to access memory, we will need to be able to
1710 access registers, or other ptrace accesses like
1711 PTRACE_GET_THREAD_AREA. */
1713 /* Need to switch to each process in turn, because
1714 prepare_to_access_memory prepares for an access in the
1715 current process pointed to by general_thread. */
1716 switch_to_process (process
);
1717 cs
.general_thread
= current_thread
->id
;
1719 int res
= prepare_to_access_memory ();
1722 for_each_thread (process
->pid
, [&] (thread_info
*thread
)
1724 handle_qxfer_threads_worker (thread
, buffer
);
1727 done_accessing_memory ();
1734 buffer_grow_str0 (buffer
, "</threads>\n");
1735 return error_proc
== nullptr;
1738 /* Handle qXfer:threads:read. */
1741 handle_qxfer_threads (const char *annex
,
1742 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1743 ULONGEST offset
, LONGEST len
)
1745 static char *result
= 0;
1746 static unsigned int result_length
= 0;
1748 if (writebuf
!= NULL
)
1751 if (annex
[0] != '\0')
1756 struct buffer buffer
;
1757 /* When asked for data at offset 0, generate everything and store into
1758 'result'. Successive reads will be served off 'result'. */
1762 buffer_init (&buffer
);
1764 bool res
= handle_qxfer_threads_proper (&buffer
);
1766 result
= buffer_finish (&buffer
);
1767 result_length
= strlen (result
);
1768 buffer_free (&buffer
);
1774 if (offset
>= result_length
)
1776 /* We're out of data. */
1783 if (len
> result_length
- offset
)
1784 len
= result_length
- offset
;
1786 memcpy (readbuf
, result
+ offset
, len
);
1791 /* Handle qXfer:traceframe-info:read. */
1794 handle_qxfer_traceframe_info (const char *annex
,
1795 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1796 ULONGEST offset
, LONGEST len
)
1798 client_state
&cs
= get_client_state ();
1799 static char *result
= 0;
1800 static unsigned int result_length
= 0;
1802 if (writebuf
!= NULL
)
1805 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1810 struct buffer buffer
;
1812 /* When asked for data at offset 0, generate everything and
1813 store into 'result'. Successive reads will be served off
1817 buffer_init (&buffer
);
1819 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1821 result
= buffer_finish (&buffer
);
1822 result_length
= strlen (result
);
1823 buffer_free (&buffer
);
1826 if (offset
>= result_length
)
1828 /* We're out of data. */
1835 if (len
> result_length
- offset
)
1836 len
= result_length
- offset
;
1838 memcpy (readbuf
, result
+ offset
, len
);
1842 /* Handle qXfer:fdpic:read. */
1845 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1846 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1848 if (!the_target
->supports_read_loadmap ())
1851 if (current_thread
== NULL
)
1854 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1857 /* Handle qXfer:btrace:read. */
1860 handle_qxfer_btrace (const char *annex
,
1861 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1862 ULONGEST offset
, LONGEST len
)
1864 client_state
&cs
= get_client_state ();
1865 static struct buffer cache
;
1866 struct thread_info
*thread
;
1867 enum btrace_read_type type
;
1870 if (writebuf
!= NULL
)
1873 if (cs
.general_thread
== null_ptid
1874 || cs
.general_thread
== minus_one_ptid
)
1876 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1880 thread
= find_thread_ptid (cs
.general_thread
);
1883 strcpy (cs
.own_buf
, "E.No such thread.");
1887 if (thread
->btrace
== NULL
)
1889 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1893 if (strcmp (annex
, "all") == 0)
1894 type
= BTRACE_READ_ALL
;
1895 else if (strcmp (annex
, "new") == 0)
1896 type
= BTRACE_READ_NEW
;
1897 else if (strcmp (annex
, "delta") == 0)
1898 type
= BTRACE_READ_DELTA
;
1901 strcpy (cs
.own_buf
, "E.Bad annex.");
1907 buffer_free (&cache
);
1911 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1913 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1915 catch (const gdb_exception_error
&exception
)
1917 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1924 else if (offset
> cache
.used_size
)
1926 buffer_free (&cache
);
1930 if (len
> cache
.used_size
- offset
)
1931 len
= cache
.used_size
- offset
;
1933 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1938 /* Handle qXfer:btrace-conf:read. */
1941 handle_qxfer_btrace_conf (const char *annex
,
1942 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1943 ULONGEST offset
, LONGEST len
)
1945 client_state
&cs
= get_client_state ();
1946 static struct buffer cache
;
1947 struct thread_info
*thread
;
1950 if (writebuf
!= NULL
)
1953 if (annex
[0] != '\0')
1956 if (cs
.general_thread
== null_ptid
1957 || cs
.general_thread
== minus_one_ptid
)
1959 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1963 thread
= find_thread_ptid (cs
.general_thread
);
1966 strcpy (cs
.own_buf
, "E.No such thread.");
1970 if (thread
->btrace
== NULL
)
1972 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1978 buffer_free (&cache
);
1982 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1984 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1986 catch (const gdb_exception_error
&exception
)
1988 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1995 else if (offset
> cache
.used_size
)
1997 buffer_free (&cache
);
2001 if (len
> cache
.used_size
- offset
)
2002 len
= cache
.used_size
- offset
;
2004 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
2009 static const struct qxfer qxfer_packets
[] =
2011 { "auxv", handle_qxfer_auxv
},
2012 { "btrace", handle_qxfer_btrace
},
2013 { "btrace-conf", handle_qxfer_btrace_conf
},
2014 { "exec-file", handle_qxfer_exec_file
},
2015 { "fdpic", handle_qxfer_fdpic
},
2016 { "features", handle_qxfer_features
},
2017 { "libraries", handle_qxfer_libraries
},
2018 { "libraries-svr4", handle_qxfer_libraries_svr4
},
2019 { "osdata", handle_qxfer_osdata
},
2020 { "siginfo", handle_qxfer_siginfo
},
2021 { "statictrace", handle_qxfer_statictrace
},
2022 { "threads", handle_qxfer_threads
},
2023 { "traceframe-info", handle_qxfer_traceframe_info
},
2027 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2035 if (!startswith (own_buf
, "qXfer:"))
2038 /* Grab the object, r/w and annex. */
2039 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2041 write_enn (own_buf
);
2046 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2049 const struct qxfer
*q
= &qxfer_packets
[i
];
2051 if (strcmp (object
, q
->object
) == 0)
2053 if (strcmp (rw
, "read") == 0)
2055 unsigned char *data
;
2060 /* Grab the offset and length. */
2061 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2063 write_enn (own_buf
);
2067 /* Read one extra byte, as an indicator of whether there is
2069 if (len
> PBUFSIZ
- 2)
2071 data
= (unsigned char *) malloc (len
+ 1);
2074 write_enn (own_buf
);
2077 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2085 /* Preserve error message. */
2088 write_enn (own_buf
);
2090 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2092 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2097 else if (strcmp (rw
, "write") == 0)
2102 unsigned char *data
;
2104 strcpy (own_buf
, "E00");
2105 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2108 write_enn (own_buf
);
2111 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2112 &ofs
, &len
, data
) < 0)
2115 write_enn (own_buf
);
2119 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2127 /* Preserve error message. */
2130 write_enn (own_buf
);
2132 sprintf (own_buf
, "%x", n
);
2145 /* Compute 32 bit CRC from inferior memory.
2147 On success, return 32 bit CRC.
2148 On failure, return (unsigned long long) -1. */
2150 static unsigned long long
2151 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2155 unsigned char byte
= 0;
2157 /* Return failure if memory read fails. */
2158 if (read_inferior_memory (base
, &byte
, 1) != 0)
2159 return (unsigned long long) -1;
2161 crc
= xcrc32 (&byte
, 1, crc
);
2164 return (unsigned long long) crc
;
2167 /* Parse the qMemTags packet request into ADDR and LEN. */
2170 parse_fetch_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
2173 gdb_assert (startswith (request
, "qMemTags:"));
2175 const char *p
= request
+ strlen ("qMemTags:");
2177 /* Read address and length. */
2178 unsigned int length
= 0;
2179 p
= decode_m_packet_params (p
, addr
, &length
, ':');
2182 /* Read the tag type. */
2183 ULONGEST tag_type
= 0;
2184 p
= unpack_varlen_hex (p
, &tag_type
);
2185 *type
= (int) tag_type
;
2188 /* Add supported btrace packets to BUF. */
2191 supported_btrace_packets (char *buf
)
2193 strcat (buf
, ";Qbtrace:bts+");
2194 strcat (buf
, ";Qbtrace-conf:bts:size+");
2195 strcat (buf
, ";Qbtrace:pt+");
2196 strcat (buf
, ";Qbtrace-conf:pt:size+");
2197 strcat (buf
, ";Qbtrace:off+");
2198 strcat (buf
, ";qXfer:btrace:read+");
2199 strcat (buf
, ";qXfer:btrace-conf:read+");
2202 /* Handle all of the extended 'q' packets. */
2205 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2207 client_state
&cs
= get_client_state ();
2208 static std::list
<thread_info
*>::const_iterator thread_iter
;
2210 /* Reply the current thread id. */
2211 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2214 require_running_or_return (own_buf
);
2216 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2217 ptid
= cs
.general_thread
;
2220 thread_iter
= all_threads
.begin ();
2221 ptid
= (*thread_iter
)->id
;
2224 sprintf (own_buf
, "QC");
2226 write_ptid (own_buf
, ptid
);
2230 if (strcmp ("qSymbol::", own_buf
) == 0)
2232 struct thread_info
*save_thread
= current_thread
;
2234 /* For qSymbol, GDB only changes the current thread if the
2235 previous current thread was of a different process. So if
2236 the previous thread is gone, we need to pick another one of
2237 the same process. This can happen e.g., if we followed an
2238 exec in a non-leader thread. */
2239 if (current_thread
== NULL
)
2242 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2244 /* Just in case, if we didn't find a thread, then bail out
2245 instead of crashing. */
2246 if (current_thread
== NULL
)
2248 write_enn (own_buf
);
2249 current_thread
= save_thread
;
2254 /* GDB is suggesting new symbols have been loaded. This may
2255 mean a new shared library has been detected as loaded, so
2256 take the opportunity to check if breakpoints we think are
2257 inserted, still are. Note that it isn't guaranteed that
2258 we'll see this when a shared library is loaded, and nor will
2259 we see this for unloads (although breakpoints in unloaded
2260 libraries shouldn't trigger), as GDB may not find symbols for
2261 the library at all. We also re-validate breakpoints when we
2262 see a second GDB breakpoint for the same address, and or when
2263 we access breakpoint shadows. */
2264 validate_breakpoints ();
2266 if (target_supports_tracepoints ())
2267 tracepoint_look_up_symbols ();
2269 if (current_thread
!= NULL
)
2270 the_target
->look_up_symbols ();
2272 current_thread
= save_thread
;
2274 strcpy (own_buf
, "OK");
2278 if (!disable_packet_qfThreadInfo
)
2280 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2282 require_running_or_return (own_buf
);
2283 thread_iter
= all_threads
.begin ();
2286 ptid_t ptid
= (*thread_iter
)->id
;
2287 write_ptid (own_buf
, ptid
);
2292 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2294 require_running_or_return (own_buf
);
2295 if (thread_iter
!= all_threads
.end ())
2298 ptid_t ptid
= (*thread_iter
)->id
;
2299 write_ptid (own_buf
, ptid
);
2305 sprintf (own_buf
, "l");
2311 if (the_target
->supports_read_offsets ()
2312 && strcmp ("qOffsets", own_buf
) == 0)
2314 CORE_ADDR text
, data
;
2316 require_running_or_return (own_buf
);
2317 if (the_target
->read_offsets (&text
, &data
))
2318 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2319 (long)text
, (long)data
, (long)data
);
2321 write_enn (own_buf
);
2326 /* Protocol features query. */
2327 if (startswith (own_buf
, "qSupported")
2328 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2330 char *p
= &own_buf
[10];
2331 int gdb_supports_qRelocInsn
= 0;
2333 /* Process each feature being provided by GDB. The first
2334 feature will follow a ':', and latter features will follow
2338 std::vector
<std::string
> qsupported
;
2339 std::vector
<const char *> unknowns
;
2341 /* Two passes, to avoid nested strtok calls in
2342 target_process_qsupported. */
2344 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2346 p
= strtok_r (NULL
, ";", &saveptr
))
2347 qsupported
.emplace_back (p
);
2349 for (const std::string
&feature
: qsupported
)
2351 if (feature
== "multiprocess+")
2353 /* GDB supports and wants multi-process support if
2355 if (target_supports_multi_process ())
2356 cs
.multi_process
= 1;
2358 else if (feature
== "qRelocInsn+")
2360 /* GDB supports relocate instruction requests. */
2361 gdb_supports_qRelocInsn
= 1;
2363 else if (feature
== "swbreak+")
2365 /* GDB wants us to report whether a trap is caused
2366 by a software breakpoint and for us to handle PC
2367 adjustment if necessary on this target. */
2368 if (target_supports_stopped_by_sw_breakpoint ())
2369 cs
.swbreak_feature
= 1;
2371 else if (feature
== "hwbreak+")
2373 /* GDB wants us to report whether a trap is caused
2374 by a hardware breakpoint. */
2375 if (target_supports_stopped_by_hw_breakpoint ())
2376 cs
.hwbreak_feature
= 1;
2378 else if (feature
== "fork-events+")
2380 /* GDB supports and wants fork events if possible. */
2381 if (target_supports_fork_events ())
2382 cs
.report_fork_events
= 1;
2384 else if (feature
== "vfork-events+")
2386 /* GDB supports and wants vfork events if possible. */
2387 if (target_supports_vfork_events ())
2388 cs
.report_vfork_events
= 1;
2390 else if (feature
== "exec-events+")
2392 /* GDB supports and wants exec events if possible. */
2393 if (target_supports_exec_events ())
2394 cs
.report_exec_events
= 1;
2396 else if (feature
== "vContSupported+")
2397 cs
.vCont_supported
= 1;
2398 else if (feature
== "QThreadEvents+")
2400 else if (feature
== "no-resumed+")
2402 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2404 report_no_resumed
= true;
2406 else if (feature
== "memory-tagging+")
2408 /* GDB supports memory tagging features. */
2409 if (target_supports_memory_tagging ())
2410 cs
.memory_tagging_feature
= true;
2414 /* Move the unknown features all together. */
2415 unknowns
.push_back (feature
.c_str ());
2419 /* Give the target backend a chance to process the unknown
2421 target_process_qsupported (unknowns
);
2425 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2426 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2427 "QEnvironmentReset+;QEnvironmentUnset+;"
2431 if (target_supports_catch_syscall ())
2432 strcat (own_buf
, ";QCatchSyscalls+");
2434 if (the_target
->supports_qxfer_libraries_svr4 ())
2435 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2436 ";augmented-libraries-svr4-read+");
2439 /* We do not have any hook to indicate whether the non-SVR4 target
2440 backend supports qXfer:libraries:read, so always report it. */
2441 strcat (own_buf
, ";qXfer:libraries:read+");
2444 if (the_target
->supports_read_auxv ())
2445 strcat (own_buf
, ";qXfer:auxv:read+");
2447 if (the_target
->supports_qxfer_siginfo ())
2448 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2450 if (the_target
->supports_read_loadmap ())
2451 strcat (own_buf
, ";qXfer:fdpic:read+");
2453 /* We always report qXfer:features:read, as targets may
2454 install XML files on a subsequent call to arch_setup.
2455 If we reported to GDB on startup that we don't support
2456 qXfer:feature:read at all, we will never be re-queried. */
2457 strcat (own_buf
, ";qXfer:features:read+");
2459 if (cs
.transport_is_reliable
)
2460 strcat (own_buf
, ";QStartNoAckMode+");
2462 if (the_target
->supports_qxfer_osdata ())
2463 strcat (own_buf
, ";qXfer:osdata:read+");
2465 if (target_supports_multi_process ())
2466 strcat (own_buf
, ";multiprocess+");
2468 if (target_supports_fork_events ())
2469 strcat (own_buf
, ";fork-events+");
2471 if (target_supports_vfork_events ())
2472 strcat (own_buf
, ";vfork-events+");
2474 if (target_supports_exec_events ())
2475 strcat (own_buf
, ";exec-events+");
2477 if (target_supports_non_stop ())
2478 strcat (own_buf
, ";QNonStop+");
2480 if (target_supports_disable_randomization ())
2481 strcat (own_buf
, ";QDisableRandomization+");
2483 strcat (own_buf
, ";qXfer:threads:read+");
2485 if (target_supports_tracepoints ())
2487 strcat (own_buf
, ";ConditionalTracepoints+");
2488 strcat (own_buf
, ";TraceStateVariables+");
2489 strcat (own_buf
, ";TracepointSource+");
2490 strcat (own_buf
, ";DisconnectedTracing+");
2491 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2492 strcat (own_buf
, ";FastTracepoints+");
2493 strcat (own_buf
, ";StaticTracepoints+");
2494 strcat (own_buf
, ";InstallInTrace+");
2495 strcat (own_buf
, ";qXfer:statictrace:read+");
2496 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2497 strcat (own_buf
, ";EnableDisableTracepoints+");
2498 strcat (own_buf
, ";QTBuffer:size+");
2499 strcat (own_buf
, ";tracenz+");
2502 if (target_supports_hardware_single_step ()
2503 || target_supports_software_single_step () )
2505 strcat (own_buf
, ";ConditionalBreakpoints+");
2507 strcat (own_buf
, ";BreakpointCommands+");
2509 if (target_supports_agent ())
2510 strcat (own_buf
, ";QAgent+");
2512 supported_btrace_packets (own_buf
);
2514 if (target_supports_stopped_by_sw_breakpoint ())
2515 strcat (own_buf
, ";swbreak+");
2517 if (target_supports_stopped_by_hw_breakpoint ())
2518 strcat (own_buf
, ";hwbreak+");
2520 if (the_target
->supports_pid_to_exec_file ())
2521 strcat (own_buf
, ";qXfer:exec-file:read+");
2523 strcat (own_buf
, ";vContSupported+");
2525 strcat (own_buf
, ";QThreadEvents+");
2527 strcat (own_buf
, ";no-resumed+");
2529 if (target_supports_memory_tagging ())
2530 strcat (own_buf
, ";memory-tagging+");
2532 /* Reinitialize components as needed for the new connection. */
2533 hostio_handle_new_gdb_connection ();
2534 target_handle_new_gdb_connection ();
2539 /* Thread-local storage support. */
2540 if (the_target
->supports_get_tls_address ()
2541 && startswith (own_buf
, "qGetTLSAddr:"))
2543 char *p
= own_buf
+ 12;
2544 CORE_ADDR parts
[2], address
= 0;
2546 ptid_t ptid
= null_ptid
;
2548 require_running_or_return (own_buf
);
2550 for (i
= 0; i
< 3; i
++)
2558 p2
= strchr (p
, ',');
2571 ptid
= read_ptid (p
, NULL
);
2573 decode_address (&parts
[i
- 1], p
, len
);
2577 if (p
!= NULL
|| i
< 3)
2581 struct thread_info
*thread
= find_thread_ptid (ptid
);
2586 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2592 strcpy (own_buf
, paddress(address
));
2597 write_enn (own_buf
);
2601 /* Otherwise, pretend we do not understand this packet. */
2604 /* Windows OS Thread Information Block address support. */
2605 if (the_target
->supports_get_tib_address ()
2606 && startswith (own_buf
, "qGetTIBAddr:"))
2611 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2613 n
= the_target
->get_tib_address (ptid
, &tlb
);
2616 strcpy (own_buf
, paddress(tlb
));
2621 write_enn (own_buf
);
2627 /* Handle "monitor" commands. */
2628 if (startswith (own_buf
, "qRcmd,"))
2630 char *mon
= (char *) malloc (PBUFSIZ
);
2631 int len
= strlen (own_buf
+ 6);
2635 write_enn (own_buf
);
2640 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2642 write_enn (own_buf
);
2646 mon
[len
/ 2] = '\0';
2650 if (the_target
->handle_monitor_command (mon
) == 0)
2651 /* Default processing. */
2652 handle_monitor_command (mon
, own_buf
);
2658 if (startswith (own_buf
, "qSearch:memory:"))
2660 require_running_or_return (own_buf
);
2661 handle_search_memory (own_buf
, packet_len
);
2665 if (strcmp (own_buf
, "qAttached") == 0
2666 || startswith (own_buf
, "qAttached:"))
2668 struct process_info
*process
;
2670 if (own_buf
[sizeof ("qAttached") - 1])
2672 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2673 process
= find_process_pid (pid
);
2677 require_running_or_return (own_buf
);
2678 process
= current_process ();
2681 if (process
== NULL
)
2683 write_enn (own_buf
);
2687 strcpy (own_buf
, process
->attached
? "1" : "0");
2691 if (startswith (own_buf
, "qCRC:"))
2693 /* CRC check (compare-section). */
2697 unsigned long long crc
;
2699 require_running_or_return (own_buf
);
2700 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2701 if (*comma
++ != ',')
2703 write_enn (own_buf
);
2706 len
= strtoul (comma
, NULL
, 16);
2707 crc
= crc32 (base
, len
, 0xffffffff);
2708 /* Check for memory failure. */
2709 if (crc
== (unsigned long long) -1)
2711 write_enn (own_buf
);
2714 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2718 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2721 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2724 /* Handle fetch memory tags packets. */
2725 if (startswith (own_buf
, "qMemTags:")
2726 && target_supports_memory_tagging ())
2728 gdb::byte_vector tags
;
2733 require_running_or_return (own_buf
);
2735 parse_fetch_memtags_request (own_buf
, &addr
, &len
, &type
);
2737 bool ret
= the_target
->fetch_memtags (addr
, len
, tags
, type
);
2740 ret
= create_fetch_memtags_reply (own_buf
, tags
);
2743 write_enn (own_buf
);
2745 *new_packet_len_p
= strlen (own_buf
);
2749 /* Otherwise we didn't know what packet it was. Say we didn't
2754 static void gdb_wants_all_threads_stopped (void);
2755 static void resume (struct thread_resume
*actions
, size_t n
);
2757 /* The callback that is passed to visit_actioned_threads. */
2758 typedef int (visit_actioned_threads_callback_ftype
)
2759 (const struct thread_resume
*, struct thread_info
*);
2761 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2762 true if CALLBACK returns true. Returns false if no matching thread
2763 is found or CALLBACK results false.
2764 Note: This function is itself a callback for find_thread. */
2767 visit_actioned_threads (thread_info
*thread
,
2768 const struct thread_resume
*actions
,
2770 visit_actioned_threads_callback_ftype
*callback
)
2772 for (size_t i
= 0; i
< num_actions
; i
++)
2774 const struct thread_resume
*action
= &actions
[i
];
2776 if (action
->thread
== minus_one_ptid
2777 || action
->thread
== thread
->id
2778 || ((action
->thread
.pid ()
2779 == thread
->id
.pid ())
2780 && action
->thread
.lwp () == -1))
2782 if ((*callback
) (action
, thread
))
2790 /* Callback for visit_actioned_threads. If the thread has a pending
2791 status to report, report it now. */
2794 handle_pending_status (const struct thread_resume
*resumption
,
2795 struct thread_info
*thread
)
2797 client_state
&cs
= get_client_state ();
2798 if (thread
->status_pending_p
)
2800 thread
->status_pending_p
= 0;
2802 cs
.last_status
= thread
->last_status
;
2803 cs
.last_ptid
= thread
->id
;
2804 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
2810 /* Parse vCont packets. */
2812 handle_v_cont (char *own_buf
)
2816 struct thread_resume
*resume_info
;
2817 struct thread_resume default_action
{ null_ptid
};
2819 /* Count the number of semicolons in the packet. There should be one
2820 for every action. */
2826 p
= strchr (p
, ';');
2829 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2830 if (resume_info
== NULL
)
2838 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2840 if (p
[0] == 's' || p
[0] == 'S')
2841 resume_info
[i
].kind
= resume_step
;
2842 else if (p
[0] == 'r')
2843 resume_info
[i
].kind
= resume_step
;
2844 else if (p
[0] == 'c' || p
[0] == 'C')
2845 resume_info
[i
].kind
= resume_continue
;
2846 else if (p
[0] == 't')
2847 resume_info
[i
].kind
= resume_stop
;
2851 if (p
[0] == 'S' || p
[0] == 'C')
2854 int sig
= strtol (p
+ 1, &q
, 16);
2859 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2861 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2863 else if (p
[0] == 'r')
2867 p
= unpack_varlen_hex (p
+ 1, &addr
);
2868 resume_info
[i
].step_range_start
= addr
;
2873 p
= unpack_varlen_hex (p
+ 1, &addr
);
2874 resume_info
[i
].step_range_end
= addr
;
2883 resume_info
[i
].thread
= minus_one_ptid
;
2884 default_action
= resume_info
[i
];
2886 /* Note: we don't increment i here, we'll overwrite this entry
2887 the next time through. */
2889 else if (p
[0] == ':')
2892 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2897 if (p
[0] != ';' && p
[0] != 0)
2900 resume_info
[i
].thread
= ptid
;
2907 resume_info
[i
] = default_action
;
2909 resume (resume_info
, n
);
2914 write_enn (own_buf
);
2919 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2922 resume (struct thread_resume
*actions
, size_t num_actions
)
2924 client_state
&cs
= get_client_state ();
2927 /* Check if among the threads that GDB wants actioned, there's
2928 one with a pending status to report. If so, skip actually
2929 resuming/stopping and report the pending event
2932 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2934 return visit_actioned_threads (thread
, actions
, num_actions
,
2935 handle_pending_status
);
2938 if (thread_with_status
!= NULL
)
2944 the_target
->resume (actions
, num_actions
);
2947 write_ok (cs
.own_buf
);
2950 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2952 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
2953 && !report_no_resumed
)
2955 /* The client does not support this stop reply. At least
2957 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2958 disable_async_io ();
2962 if (cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
2963 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
2964 && cs
.last_status
.kind () != TARGET_WAITKIND_NO_RESUMED
)
2965 current_thread
->last_status
= cs
.last_status
;
2967 /* From the client's perspective, all-stop mode always stops all
2968 threads implicitly (and the target backend has already done
2969 so by now). Tag all threads as "want-stopped", so we don't
2970 resume them implicitly without the client telling us to. */
2971 gdb_wants_all_threads_stopped ();
2972 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
2973 disable_async_io ();
2975 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
2976 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
2977 target_mourn_inferior (cs
.last_ptid
);
2981 /* Attach to a new program. */
2983 handle_v_attach (char *own_buf
)
2985 client_state
&cs
= get_client_state ();
2988 pid
= strtol (own_buf
+ 8, NULL
, 16);
2989 if (pid
!= 0 && attach_inferior (pid
) == 0)
2991 /* Don't report shared library events after attaching, even if
2992 some libraries are preloaded. GDB will always poll the
2993 library list. Avoids the "stopped by shared library event"
2994 notice on the GDB side. */
2995 current_process ()->dlls_changed
= false;
2999 /* In non-stop, we don't send a resume reply. Stop events
3000 will follow up using the normal notification
3005 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
3008 write_enn (own_buf
);
3011 /* Run a new program. */
3013 handle_v_run (char *own_buf
)
3015 client_state
&cs
= get_client_state ();
3017 std::vector
<char *> new_argv
;
3018 char *new_program_name
= NULL
;
3022 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
3028 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
3030 next_p
= strchr (p
, ';');
3032 next_p
= p
+ strlen (p
);
3034 if (i
== 0 && p
== next_p
)
3036 /* No program specified. */
3037 new_program_name
= NULL
;
3039 else if (p
== next_p
)
3041 /* Empty argument. */
3042 new_argv
.push_back (xstrdup (""));
3046 size_t len
= (next_p
- p
) / 2;
3047 /* ARG is the unquoted argument received via the RSP. */
3048 char *arg
= (char *) xmalloc (len
+ 1);
3049 /* FULL_ARGS will contain the quoted version of ARG. */
3050 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
3051 /* These are pointers used to navigate the strings above. */
3052 char *tmp_arg
= arg
;
3053 char *tmp_full_arg
= full_arg
;
3056 hex2bin (p
, (gdb_byte
*) arg
, len
);
3059 while (*tmp_arg
!= '\0')
3065 *tmp_full_arg
= '\'';
3071 /* Quote single quote. */
3072 *tmp_full_arg
= '\\';
3080 *tmp_full_arg
= *tmp_arg
;
3086 *tmp_full_arg
++ = '\'';
3088 /* Finish FULL_ARG and push it into the vector containing
3090 *tmp_full_arg
= '\0';
3092 new_program_name
= full_arg
;
3094 new_argv
.push_back (full_arg
);
3101 if (new_program_name
== NULL
)
3103 /* GDB didn't specify a program to run. Use the program from the
3104 last run with the new argument list. */
3105 if (program_path
.get () == NULL
)
3107 write_enn (own_buf
);
3108 free_vector_argv (new_argv
);
3113 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3115 /* Free the old argv and install the new one. */
3116 free_vector_argv (program_args
);
3117 program_args
= new_argv
;
3119 target_create_inferior (program_path
.get (), program_args
);
3121 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
3123 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
3125 /* In non-stop, sending a resume reply doesn't set the general
3126 thread, but GDB assumes a vRun sets it (this is so GDB can
3127 query which is the main thread of the new inferior. */
3129 cs
.general_thread
= cs
.last_ptid
;
3132 write_enn (own_buf
);
3137 handle_v_kill (char *own_buf
)
3139 client_state
&cs
= get_client_state ();
3141 char *p
= &own_buf
[6];
3142 if (cs
.multi_process
)
3143 pid
= strtol (p
, NULL
, 16);
3147 process_info
*proc
= find_process_pid (pid
);
3149 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3151 cs
.last_status
.set_signalled (GDB_SIGNAL_KILL
);
3152 cs
.last_ptid
= ptid_t (pid
);
3153 discard_queued_stop_replies (cs
.last_ptid
);
3157 write_enn (own_buf
);
3160 /* Handle all of the extended 'v' packets. */
3162 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3164 client_state
&cs
= get_client_state ();
3165 if (!disable_packet_vCont
)
3167 if (strcmp (own_buf
, "vCtrlC") == 0)
3169 the_target
->request_interrupt ();
3174 if (startswith (own_buf
, "vCont;"))
3176 handle_v_cont (own_buf
);
3180 if (startswith (own_buf
, "vCont?"))
3182 strcpy (own_buf
, "vCont;c;C;t");
3184 if (target_supports_hardware_single_step ()
3185 || target_supports_software_single_step ()
3186 || !cs
.vCont_supported
)
3188 /* If target supports single step either by hardware or by
3189 software, add actions s and S to the list of supported
3190 actions. On the other hand, if GDB doesn't request the
3191 supported vCont actions in qSupported packet, add s and
3192 S to the list too. */
3193 own_buf
= own_buf
+ strlen (own_buf
);
3194 strcpy (own_buf
, ";s;S");
3197 if (target_supports_range_stepping ())
3199 own_buf
= own_buf
+ strlen (own_buf
);
3200 strcpy (own_buf
, ";r");
3206 if (startswith (own_buf
, "vFile:")
3207 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3210 if (startswith (own_buf
, "vAttach;"))
3212 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3214 fprintf (stderr
, "Already debugging a process\n");
3215 write_enn (own_buf
);
3218 handle_v_attach (own_buf
);
3222 if (startswith (own_buf
, "vRun;"))
3224 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3226 fprintf (stderr
, "Already debugging a process\n");
3227 write_enn (own_buf
);
3230 handle_v_run (own_buf
);
3234 if (startswith (own_buf
, "vKill;"))
3236 if (!target_running ())
3238 fprintf (stderr
, "No process to kill\n");
3239 write_enn (own_buf
);
3242 handle_v_kill (own_buf
);
3246 if (handle_notif_ack (own_buf
, packet_len
))
3249 /* Otherwise we didn't know what packet it was. Say we didn't
3255 /* Resume thread and wait for another event. In non-stop mode,
3256 don't really wait here, but return immediatelly to the event
3259 myresume (char *own_buf
, int step
, int sig
)
3261 client_state
&cs
= get_client_state ();
3262 struct thread_resume resume_info
[2];
3264 int valid_cont_thread
;
3266 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3267 && cs
.cont_thread
!= minus_one_ptid
);
3269 if (step
|| sig
|| valid_cont_thread
)
3271 resume_info
[0].thread
= current_ptid
;
3273 resume_info
[0].kind
= resume_step
;
3275 resume_info
[0].kind
= resume_continue
;
3276 resume_info
[0].sig
= sig
;
3280 if (!valid_cont_thread
)
3282 resume_info
[n
].thread
= minus_one_ptid
;
3283 resume_info
[n
].kind
= resume_continue
;
3284 resume_info
[n
].sig
= 0;
3288 resume (resume_info
, n
);
3291 /* Callback for for_each_thread. Make a new stop reply for each
3295 queue_stop_reply_callback (thread_info
*thread
)
3297 /* For now, assume targets that don't have this callback also don't
3298 manage the thread's last_status field. */
3299 if (!the_target
->supports_thread_stopped ())
3301 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3303 new_notif
->ptid
= thread
->id
;
3304 new_notif
->status
= thread
->last_status
;
3305 /* Pass the last stop reply back to GDB, but don't notify
3307 notif_event_enque (¬if_stop
, new_notif
);
3311 if (target_thread_stopped (thread
))
3314 debug_printf ("Reporting thread %s as already stopped with %s\n",
3315 target_pid_to_str (thread
->id
).c_str (),
3316 thread
->last_status
.to_string ().c_str ());
3318 gdb_assert (thread
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3320 /* Pass the last stop reply back to GDB, but don't notify
3322 queue_stop_reply (thread
->id
, thread
->last_status
);
3327 /* Set this inferior threads's state as "want-stopped". We won't
3328 resume this thread until the client gives us another action for
3332 gdb_wants_thread_stopped (thread_info
*thread
)
3334 thread
->last_resume_kind
= resume_stop
;
3336 if (thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
)
3338 /* Most threads are stopped implicitly (all-stop); tag that with
3340 thread
->last_status
.set_stopped (GDB_SIGNAL_0
);
3344 /* Set all threads' states as "want-stopped". */
3347 gdb_wants_all_threads_stopped (void)
3349 for_each_thread (gdb_wants_thread_stopped
);
3352 /* Callback for for_each_thread. If the thread is stopped with an
3353 interesting event, mark it as having a pending event. */
3356 set_pending_status_callback (thread_info
*thread
)
3358 if (thread
->last_status
.kind () != TARGET_WAITKIND_STOPPED
3359 || (thread
->last_status
.sig () != GDB_SIGNAL_0
3360 /* A breakpoint, watchpoint or finished step from a previous
3361 GDB run isn't considered interesting for a new GDB run.
3362 If we left those pending, the new GDB could consider them
3363 random SIGTRAPs. This leaves out real async traps. We'd
3364 have to peek into the (target-specific) siginfo to
3365 distinguish those. */
3366 && thread
->last_status
.sig () != GDB_SIGNAL_TRAP
))
3367 thread
->status_pending_p
= 1;
3370 /* Status handler for the '?' packet. */
3373 handle_status (char *own_buf
)
3375 client_state
&cs
= get_client_state ();
3377 /* GDB is connected, don't forward events to the target anymore. */
3378 for_each_process ([] (process_info
*process
) {
3379 process
->gdb_detached
= 0;
3382 /* In non-stop mode, we must send a stop reply for each stopped
3383 thread. In all-stop mode, just send one for the first stopped
3388 for_each_thread (queue_stop_reply_callback
);
3390 /* The first is sent immediatly. OK is sent if there is no
3391 stopped thread, which is the same handling of the vStopped
3392 packet (by design). */
3393 notif_write_event (¬if_stop
, cs
.own_buf
);
3397 thread_info
*thread
= NULL
;
3399 target_pause_all (false);
3400 target_stabilize_threads ();
3401 gdb_wants_all_threads_stopped ();
3403 /* We can only report one status, but we might be coming out of
3404 non-stop -- if more than one thread is stopped with
3405 interesting events, leave events for the threads we're not
3406 reporting now pending. They'll be reported the next time the
3407 threads are resumed. Start by marking all interesting events
3409 for_each_thread (set_pending_status_callback
);
3411 /* Prefer the last thread that reported an event to GDB (even if
3412 that was a GDB_SIGNAL_TRAP). */
3413 if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
3414 && cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
3415 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
)
3416 thread
= find_thread_ptid (cs
.last_ptid
);
3418 /* If the last event thread is not found for some reason, look
3419 for some other thread that might have an event to report. */
3421 thread
= find_thread ([] (thread_info
*thr_arg
)
3423 return thr_arg
->status_pending_p
;
3426 /* If we're still out of luck, simply pick the first thread in
3429 thread
= get_first_thread ();
3433 struct thread_info
*tp
= (struct thread_info
*) thread
;
3435 /* We're reporting this event, so it's no longer
3437 tp
->status_pending_p
= 0;
3439 /* GDB assumes the current thread is the thread we're
3440 reporting the status for. */
3441 cs
.general_thread
= thread
->id
;
3442 set_desired_thread ();
3444 gdb_assert (tp
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3445 prepare_resume_reply (own_buf
, tp
->id
, tp
->last_status
);
3448 strcpy (own_buf
, "W00");
3453 gdbserver_version (void)
3455 printf ("GNU gdbserver %s%s\n"
3456 "Copyright (C) 2021 Free Software Foundation, Inc.\n"
3457 "gdbserver is free software, covered by the "
3458 "GNU General Public License.\n"
3459 "This gdbserver was configured as \"%s\"\n",
3460 PKGVERSION
, version
, host_name
);
3464 gdbserver_usage (FILE *stream
)
3466 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3467 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3468 "\tgdbserver [OPTIONS] --multi COMM\n"
3470 "COMM may either be a tty device (for serial debugging),\n"
3471 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3472 "stdin/stdout of gdbserver.\n"
3473 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3474 "PID is the process ID to attach to, when --attach is specified.\n"
3476 "Operating modes:\n"
3478 " --attach Attach to running process PID.\n"
3479 " --multi Start server without a specific program, and\n"
3480 " only quit when explicitly commanded.\n"
3481 " --once Exit after the first connection has closed.\n"
3482 " --help Print this message and then exit.\n"
3483 " --version Display version information and exit.\n"
3487 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3488 " --disable-randomization\n"
3489 " Run PROG with address space randomization disabled.\n"
3490 " --no-disable-randomization\n"
3491 " Don't disable address space randomization when\n"
3493 " --startup-with-shell\n"
3494 " Start PROG using a shell. I.e., execs a shell that\n"
3495 " then execs PROG. (default)\n"
3496 " --no-startup-with-shell\n"
3497 " Exec PROG directly instead of using a shell.\n"
3498 " Disables argument globbing and variable substitution\n"
3499 " on UNIX-like systems.\n"
3503 " --debug Enable general debugging output.\n"
3504 " --debug-format=OPT1[,OPT2,...]\n"
3505 " Specify extra content in debugging output.\n"
3510 " --remote-debug Enable remote protocol debugging output.\n"
3511 " --event-loop-debug Enable event loop debugging output.\n"
3512 " --disable-packet=OPT1[,OPT2,...]\n"
3513 " Disable support for RSP packets or features.\n"
3515 " vCont, T, Tthread, qC, qfThreadInfo and \n"
3516 " threads (disable all threading packets).\n"
3518 "For more information, consult the GDB manual (available as on-line \n"
3519 "info or a printed manual).\n");
3520 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3521 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3525 gdbserver_show_disableable (FILE *stream
)
3527 fprintf (stream
, "Disableable packets:\n"
3528 " vCont \tAll vCont packets\n"
3529 " qC \tQuerying the current thread\n"
3530 " qfThreadInfo\tThread listing\n"
3531 " Tthread \tPassing the thread specifier in the "
3532 "T stop reply packet\n"
3533 " threads \tAll of the above\n"
3534 " T \tAll 'T' packets\n");
3537 /* Start up the event loop. This is the entry point to the event
3543 /* Loop until there is nothing to do. This is the entry point to
3544 the event loop engine. If nothing is ready at this time, wait
3545 for something to happen (via wait_for_event), then process it.
3546 Return when there are no longer event sources to wait for. */
3548 keep_processing_events
= true;
3549 while (keep_processing_events
)
3551 /* Any events already waiting in the queue? */
3552 int res
= gdb_do_one_event ();
3554 /* Was there an error? */
3559 /* We are done with the event loop. There are no more event sources
3560 to listen to. So we exit gdbserver. */
3564 kill_inferior_callback (process_info
*process
)
3566 kill_inferior (process
);
3567 discard_queued_stop_replies (ptid_t (process
->pid
));
3570 /* Call this when exiting gdbserver with possible inferiors that need
3571 to be killed or detached from. */
3574 detach_or_kill_for_exit (void)
3576 /* First print a list of the inferiors we will be killing/detaching.
3577 This is to assist the user, for example, in case the inferior unexpectedly
3578 dies after we exit: did we screw up or did the inferior exit on its own?
3579 Having this info will save some head-scratching. */
3581 if (have_started_inferiors_p ())
3583 fprintf (stderr
, "Killing process(es):");
3585 for_each_process ([] (process_info
*process
) {
3586 if (!process
->attached
)
3587 fprintf (stderr
, " %d", process
->pid
);
3590 fprintf (stderr
, "\n");
3592 if (have_attached_inferiors_p ())
3594 fprintf (stderr
, "Detaching process(es):");
3596 for_each_process ([] (process_info
*process
) {
3597 if (process
->attached
)
3598 fprintf (stderr
, " %d", process
->pid
);
3601 fprintf (stderr
, "\n");
3604 /* Now we can kill or detach the inferiors. */
3605 for_each_process ([] (process_info
*process
) {
3606 int pid
= process
->pid
;
3608 if (process
->attached
)
3609 detach_inferior (process
);
3611 kill_inferior (process
);
3613 discard_queued_stop_replies (ptid_t (pid
));
3617 /* Value that will be passed to exit(3) when gdbserver exits. */
3618 static int exit_code
;
3620 /* Wrapper for detach_or_kill_for_exit that catches and prints
3624 detach_or_kill_for_exit_cleanup ()
3628 detach_or_kill_for_exit ();
3630 catch (const gdb_exception
&exception
)
3633 fprintf (stderr
, "Detach or kill failed: %s\n",
3641 namespace selftests
{
3644 test_memory_tagging_functions (void)
3646 /* Setup testing. */
3647 gdb::char_vector packet
;
3648 gdb::byte_vector tags
, bv
;
3649 std::string expected
;
3650 packet
.resize (32000);
3655 /* Test parsing a qMemTags request. */
3657 /* Valid request, addr, len and type updated. */
3661 strcpy (packet
.data (), "qMemTags:0,0:0");
3662 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3663 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0);
3665 /* Valid request, addr, len and type updated. */
3669 strcpy (packet
.data (), "qMemTags:deadbeef,ff:5");
3670 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3671 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5);
3673 /* Test creating a qMemTags reply. */
3675 /* Non-empty tag data. */
3678 for (int i
= 0; i
< 5; i
++)
3681 expected
= "m0001020304";
3682 SELF_CHECK (create_fetch_memtags_reply (packet
.data (), bv
) == true);
3683 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
3685 /* Test parsing a QMemTags request. */
3687 /* Valid request and empty tag data: addr, len, type and tags updated. */
3692 strcpy (packet
.data (), "QMemTags:0,0:0:");
3693 SELF_CHECK (parse_store_memtags_request (packet
.data (),
3694 &addr
, &len
, tags
, &type
) == true);
3695 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0 && tags
.size () == 0);
3697 /* Valid request and non-empty tag data: addr, len, type
3698 and tags updated. */
3703 strcpy (packet
.data (),
3704 "QMemTags:deadbeef,ff:5:0001020304");
3705 SELF_CHECK (parse_store_memtags_request (packet
.data (), &addr
, &len
, tags
,
3707 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5
3708 && tags
.size () == 5);
3711 } // namespace selftests
3712 #endif /* GDB_SELF_TEST */
3714 /* Main function. This is called by the real "main" function,
3715 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3717 static void ATTRIBUTE_NORETURN
3718 captured_main (int argc
, char *argv
[])
3723 const char *port
= NULL
;
3724 char **next_arg
= &argv
[1];
3725 volatile int multi_mode
= 0;
3726 volatile int attach
= 0;
3728 bool selftest
= false;
3730 std::vector
<const char *> selftest_filters
;
3732 selftests::register_test ("remote_memory_tagging",
3733 selftests::test_memory_tagging_functions
);
3736 current_directory
= getcwd (NULL
, 0);
3737 client_state
&cs
= get_client_state ();
3739 if (current_directory
== NULL
)
3741 error (_("Could not find current working directory: %s"),
3742 safe_strerror (errno
));
3745 while (*next_arg
!= NULL
&& **next_arg
== '-')
3747 if (strcmp (*next_arg
, "--version") == 0)
3749 gdbserver_version ();
3752 else if (strcmp (*next_arg
, "--help") == 0)
3754 gdbserver_usage (stdout
);
3757 else if (strcmp (*next_arg
, "--attach") == 0)
3759 else if (strcmp (*next_arg
, "--multi") == 0)
3761 else if (strcmp (*next_arg
, "--wrapper") == 0)
3768 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3770 wrapper_argv
+= *next_arg
;
3771 wrapper_argv
+= ' ';
3775 if (!wrapper_argv
.empty ())
3777 /* Erase the last whitespace. */
3778 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3781 if (next_arg
== tmp
|| *next_arg
== NULL
)
3783 gdbserver_usage (stderr
);
3787 /* Consume the "--". */
3790 else if (strcmp (*next_arg
, "--debug") == 0)
3792 else if (startswith (*next_arg
, "--debug-format="))
3794 std::string error_msg
3795 = parse_debug_format_options ((*next_arg
)
3796 + sizeof ("--debug-format=") - 1, 0);
3798 if (!error_msg
.empty ())
3800 fprintf (stderr
, "%s", error_msg
.c_str ());
3804 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3806 else if (strcmp (*next_arg
, "--event-loop-debug") == 0)
3807 debug_event_loop
= debug_event_loop_kind::ALL
;
3808 else if (startswith (*next_arg
, "--debug-file="))
3809 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3810 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3812 gdbserver_show_disableable (stdout
);
3815 else if (startswith (*next_arg
, "--disable-packet="))
3817 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3819 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3821 tok
= strtok_r (NULL
, ",", &saveptr
))
3823 if (strcmp ("vCont", tok
) == 0)
3824 disable_packet_vCont
= true;
3825 else if (strcmp ("Tthread", tok
) == 0)
3826 disable_packet_Tthread
= true;
3827 else if (strcmp ("qC", tok
) == 0)
3828 disable_packet_qC
= true;
3829 else if (strcmp ("qfThreadInfo", tok
) == 0)
3830 disable_packet_qfThreadInfo
= true;
3831 else if (strcmp ("T", tok
) == 0)
3832 disable_packet_T
= true;
3833 else if (strcmp ("threads", tok
) == 0)
3835 disable_packet_vCont
= true;
3836 disable_packet_Tthread
= true;
3837 disable_packet_qC
= true;
3838 disable_packet_qfThreadInfo
= true;
3842 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3844 gdbserver_show_disableable (stderr
);
3849 else if (strcmp (*next_arg
, "-") == 0)
3851 /* "-" specifies a stdio connection and is a form of port
3853 port
= STDIO_CONNECTION_NAME
;
3857 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3858 cs
.disable_randomization
= 1;
3859 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3860 cs
.disable_randomization
= 0;
3861 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3862 startup_with_shell
= true;
3863 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3864 startup_with_shell
= false;
3865 else if (strcmp (*next_arg
, "--once") == 0)
3867 else if (strcmp (*next_arg
, "--selftest") == 0)
3869 else if (startswith (*next_arg
, "--selftest="))
3874 const char *filter
= *next_arg
+ strlen ("--selftest=");
3875 if (*filter
== '\0')
3877 fprintf (stderr
, _("Error: selftest filter is empty.\n"));
3881 selftest_filters
.push_back (filter
);
3886 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3899 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3902 gdbserver_usage (stderr
);
3906 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3907 opened by remote_prepare. */
3910 save_original_signals_state (false);
3912 /* We need to know whether the remote connection is stdio before
3913 starting the inferior. Inferiors created in this scenario have
3914 stdin,stdout redirected. So do this here before we call
3917 remote_prepare (port
);
3922 /* --attach used to come after PORT, so allow it there for
3924 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3931 && (*next_arg
== NULL
3932 || (*next_arg
)[0] == '\0'
3933 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3935 || next_arg
[1] != NULL
))
3940 gdbserver_usage (stderr
);
3944 /* Gather information about the environment. */
3945 our_environ
= gdb_environ::from_host_environ ();
3947 initialize_async_io ();
3949 have_job_control ();
3950 if (target_supports_tracepoints ())
3951 initialize_tracepoint ();
3953 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3958 selftests::run_tests (selftest_filters
);
3960 printf (_("Selftests have been disabled for this build.\n"));
3962 throw_quit ("Quit");
3965 if (pid
== 0 && *next_arg
!= NULL
)
3969 n
= argc
- (next_arg
- argv
);
3970 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3971 for (i
= 1; i
< n
; i
++)
3972 program_args
.push_back (xstrdup (next_arg
[i
]));
3974 /* Wait till we are at first instruction in program. */
3975 target_create_inferior (program_path
.get (), program_args
);
3977 /* We are now (hopefully) stopped at the first instruction of
3978 the target process. This assumes that the target process was
3979 successfully created. */
3983 if (attach_inferior (pid
) == -1)
3984 error ("Attaching not supported on this target");
3986 /* Otherwise succeeded. */
3990 cs
.last_status
.set_exited (0);
3991 cs
.last_ptid
= minus_one_ptid
;
3994 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3996 /* Don't report shared library events on the initial connection,
3997 even if some libraries are preloaded. Avoids the "stopped by
3998 shared library event" notice on gdb side. */
3999 if (current_thread
!= nullptr)
4000 current_process ()->dlls_changed
= false;
4002 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4003 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
4008 if (!was_running
&& !multi_mode
)
4009 error ("No program to debug");
4014 cs
.multi_process
= 0;
4015 cs
.report_fork_events
= 0;
4016 cs
.report_vfork_events
= 0;
4017 cs
.report_exec_events
= 0;
4018 /* Be sure we're out of tfind mode. */
4019 cs
.current_traceframe
= -1;
4020 cs
.cont_thread
= null_ptid
;
4021 cs
.swbreak_feature
= 0;
4022 cs
.hwbreak_feature
= 0;
4023 cs
.vCont_supported
= 0;
4024 cs
.memory_tagging_feature
= false;
4030 /* Wait for events. This will return when all event sources
4031 are removed from the event loop. */
4032 start_event_loop ();
4034 /* If an exit was requested (using the "monitor exit"
4035 command), terminate now. */
4037 throw_quit ("Quit");
4039 /* The only other way to get here is for getpkt to fail:
4041 - If --once was specified, we're done.
4043 - If not in extended-remote mode, and we're no longer
4044 debugging anything, simply exit: GDB has disconnected
4045 after processing the last process exit.
4047 - Otherwise, close the connection and reopen it at the
4049 if (run_once
|| (!extended_protocol
&& !target_running ()))
4050 throw_quit ("Quit");
4053 "Remote side has terminated connection. "
4054 "GDBserver will reopen the connection.\n");
4056 /* Get rid of any pending statuses. An eventual reconnection
4057 (by the same GDB instance or another) will refresh all its
4058 state from scratch. */
4059 discard_queued_stop_replies (minus_one_ptid
);
4060 for_each_thread ([] (thread_info
*thread
)
4062 thread
->status_pending_p
= 0;
4067 if (disconnected_tracing
)
4069 /* Try to enable non-stop/async mode, so we we can
4070 both wait for an async socket accept, and handle
4071 async target events simultaneously. There's also
4072 no point either in having the target always stop
4073 all threads, when we're going to pass signals
4074 down without informing GDB. */
4077 if (the_target
->start_non_stop (true))
4080 /* Detaching implicitly resumes all threads;
4081 simply disconnecting does not. */
4087 "Disconnected tracing disabled; "
4088 "stopping trace run.\n");
4093 catch (const gdb_exception_error
&exception
)
4096 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
4098 if (response_needed
)
4100 write_enn (cs
.own_buf
);
4101 putpkt (cs
.own_buf
);
4105 throw_quit ("Quit");
4110 /* Main function. */
4113 main (int argc
, char *argv
[])
4118 captured_main (argc
, argv
);
4120 catch (const gdb_exception
&exception
)
4122 if (exception
.reason
== RETURN_ERROR
)
4125 fprintf (stderr
, "%s\n", exception
.what ());
4126 fprintf (stderr
, "Exiting\n");
4133 gdb_assert_not_reached ("captured_main should never return");
4136 /* Process options coming from Z packets for a breakpoint. PACKET is
4137 the packet buffer. *PACKET is updated to point to the first char
4138 after the last processed option. */
4141 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4143 const char *dataptr
= *packet
;
4146 /* Check if data has the correct format. */
4147 if (*dataptr
!= ';')
4154 if (*dataptr
== ';')
4157 if (*dataptr
== 'X')
4159 /* Conditional expression. */
4161 debug_printf ("Found breakpoint condition.\n");
4162 if (!add_breakpoint_condition (bp
, &dataptr
))
4163 dataptr
= strchrnul (dataptr
, ';');
4165 else if (startswith (dataptr
, "cmds:"))
4167 dataptr
+= strlen ("cmds:");
4169 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4170 persist
= (*dataptr
== '1');
4172 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4173 dataptr
= strchrnul (dataptr
, ';');
4177 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4179 /* Skip tokens until we find one that we recognize. */
4180 dataptr
= strchrnul (dataptr
, ';');
4186 /* Event loop callback that handles a serial event. The first byte in
4187 the serial buffer gets us here. We expect characters to arrive at
4188 a brisk pace, so we read the rest of the packet with a blocking
4192 process_serial_event (void)
4194 client_state
&cs
= get_client_state ();
4200 int new_packet_len
= -1;
4202 disable_async_io ();
4204 response_needed
= false;
4205 packet_len
= getpkt (cs
.own_buf
);
4206 if (packet_len
<= 0)
4209 /* Force an event loop break. */
4212 response_needed
= true;
4214 char ch
= cs
.own_buf
[0];
4218 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4221 handle_general_set (cs
.own_buf
);
4224 handle_detach (cs
.own_buf
);
4227 extended_protocol
= true;
4228 write_ok (cs
.own_buf
);
4231 handle_status (cs
.own_buf
);
4234 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4236 require_running_or_break (cs
.own_buf
);
4238 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4240 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4241 thread_id
= null_ptid
;
4242 else if (thread_id
.is_pid ())
4244 /* The ptid represents a pid. */
4245 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4249 write_enn (cs
.own_buf
);
4253 thread_id
= thread
->id
;
4257 /* The ptid represents a lwp/tid. */
4258 if (find_thread_ptid (thread_id
) == NULL
)
4260 write_enn (cs
.own_buf
);
4265 if (cs
.own_buf
[1] == 'g')
4267 if (thread_id
== null_ptid
)
4269 /* GDB is telling us to choose any thread. Check if
4270 the currently selected thread is still valid. If
4271 it is not, select the first available. */
4272 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4274 thread
= get_first_thread ();
4275 thread_id
= thread
->id
;
4278 cs
.general_thread
= thread_id
;
4279 set_desired_thread ();
4280 gdb_assert (current_thread
!= NULL
);
4282 else if (cs
.own_buf
[1] == 'c')
4283 cs
.cont_thread
= thread_id
;
4285 write_ok (cs
.own_buf
);
4289 /* Silently ignore it so that gdb can extend the protocol
4290 without compatibility headaches. */
4291 cs
.own_buf
[0] = '\0';
4295 require_running_or_break (cs
.own_buf
);
4296 if (cs
.current_traceframe
>= 0)
4298 struct regcache
*regcache
4299 = new_register_cache (current_target_desc ());
4301 if (fetch_traceframe_registers (cs
.current_traceframe
,
4303 registers_to_string (regcache
, cs
.own_buf
);
4305 write_enn (cs
.own_buf
);
4306 free_register_cache (regcache
);
4310 struct regcache
*regcache
;
4312 if (!set_desired_thread ())
4313 write_enn (cs
.own_buf
);
4316 regcache
= get_thread_regcache (current_thread
, 1);
4317 registers_to_string (regcache
, cs
.own_buf
);
4322 require_running_or_break (cs
.own_buf
);
4323 if (cs
.current_traceframe
>= 0)
4324 write_enn (cs
.own_buf
);
4327 struct regcache
*regcache
;
4329 if (!set_desired_thread ())
4330 write_enn (cs
.own_buf
);
4333 regcache
= get_thread_regcache (current_thread
, 1);
4334 registers_from_string (regcache
, &cs
.own_buf
[1]);
4335 write_ok (cs
.own_buf
);
4341 require_running_or_break (cs
.own_buf
);
4342 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4343 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4345 write_enn (cs
.own_buf
);
4347 bin2hex (mem_buf
, cs
.own_buf
, res
);
4351 require_running_or_break (cs
.own_buf
);
4352 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4353 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4354 write_ok (cs
.own_buf
);
4356 write_enn (cs
.own_buf
);
4359 require_running_or_break (cs
.own_buf
);
4360 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4361 &mem_addr
, &len
, &mem_buf
) < 0
4362 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4363 write_enn (cs
.own_buf
);
4365 write_ok (cs
.own_buf
);
4368 require_running_or_break (cs
.own_buf
);
4369 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4370 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4371 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4374 myresume (cs
.own_buf
, 0, signal
);
4377 require_running_or_break (cs
.own_buf
);
4378 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4379 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4380 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4383 myresume (cs
.own_buf
, 1, signal
);
4386 require_running_or_break (cs
.own_buf
);
4388 myresume (cs
.own_buf
, 0, signal
);
4391 require_running_or_break (cs
.own_buf
);
4393 myresume (cs
.own_buf
, 1, signal
);
4395 case 'Z': /* insert_ ... */
4397 case 'z': /* remove_ ... */
4402 char type
= cs
.own_buf
[1];
4404 const int insert
= ch
== 'Z';
4405 const char *p
= &cs
.own_buf
[3];
4407 p
= unpack_varlen_hex (p
, &addr
);
4408 kind
= strtol (p
+ 1, &dataptr
, 16);
4412 struct gdb_breakpoint
*bp
;
4414 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4419 /* GDB may have sent us a list of *point parameters to
4420 be evaluated on the target's side. Read such list
4421 here. If we already have a list of parameters, GDB
4422 is telling us to drop that list and use this one
4424 clear_breakpoint_conditions_and_commands (bp
);
4425 const char *options
= dataptr
;
4426 process_point_options (bp
, &options
);
4430 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4433 write_ok (cs
.own_buf
);
4436 cs
.own_buf
[0] = '\0';
4438 write_enn (cs
.own_buf
);
4442 response_needed
= false;
4443 if (!target_running ())
4444 /* The packet we received doesn't make sense - but we can't
4445 reply to it, either. */
4448 fprintf (stderr
, "Killing all inferiors\n");
4450 for_each_process (kill_inferior_callback
);
4452 /* When using the extended protocol, we wait with no program
4453 running. The traditional protocol will exit instead. */
4454 if (extended_protocol
)
4456 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4464 require_running_or_break (cs
.own_buf
);
4466 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4467 if (find_thread_ptid (thread_id
) == NULL
)
4469 write_enn (cs
.own_buf
);
4473 if (mythread_alive (thread_id
))
4474 write_ok (cs
.own_buf
);
4476 write_enn (cs
.own_buf
);
4480 response_needed
= false;
4482 /* Restarting the inferior is only supported in the extended
4484 if (extended_protocol
)
4486 if (target_running ())
4487 for_each_process (kill_inferior_callback
);
4489 fprintf (stderr
, "GDBserver restarting\n");
4491 /* Wait till we are at 1st instruction in prog. */
4492 if (program_path
.get () != NULL
)
4494 target_create_inferior (program_path
.get (), program_args
);
4496 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4498 /* Stopped at the first instruction of the target
4500 cs
.general_thread
= cs
.last_ptid
;
4504 /* Something went wrong. */
4505 cs
.general_thread
= null_ptid
;
4510 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4516 /* It is a request we don't understand. Respond with an
4517 empty packet so that gdb knows that we don't support this
4519 cs
.own_buf
[0] = '\0';
4523 /* Extended (long) request. */
4524 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4528 /* It is a request we don't understand. Respond with an empty
4529 packet so that gdb knows that we don't support this
4531 cs
.own_buf
[0] = '\0';
4535 if (new_packet_len
!= -1)
4536 putpkt_binary (cs
.own_buf
, new_packet_len
);
4538 putpkt (cs
.own_buf
);
4540 response_needed
= false;
4548 /* Event-loop callback for serial events. */
4551 handle_serial_event (int err
, gdb_client_data client_data
)
4554 debug_printf ("handling possible serial event\n");
4556 /* Really handle it. */
4557 if (process_serial_event () < 0)
4559 keep_processing_events
= false;
4563 /* Be sure to not change the selected thread behind GDB's back.
4564 Important in the non-stop mode asynchronous protocol. */
4565 set_desired_thread ();
4568 /* Push a stop notification on the notification queue. */
4571 push_stop_notification (ptid_t ptid
, const target_waitstatus
&status
)
4573 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4575 vstop_notif
->status
= status
;
4576 vstop_notif
->ptid
= ptid
;
4577 /* Push Stop notification. */
4578 notif_push (¬if_stop
, vstop_notif
);
4581 /* Event-loop callback for target events. */
4584 handle_target_event (int err
, gdb_client_data client_data
)
4586 client_state
&cs
= get_client_state ();
4588 debug_printf ("handling possible target event\n");
4590 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4593 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
)
4595 if (gdb_connected () && report_no_resumed
)
4596 push_stop_notification (null_ptid
, cs
.last_status
);
4598 else if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
)
4600 int pid
= cs
.last_ptid
.pid ();
4601 struct process_info
*process
= find_process_pid (pid
);
4602 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4604 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4605 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
4607 mark_breakpoints_out (process
);
4608 target_mourn_inferior (cs
.last_ptid
);
4610 else if (cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4614 /* We're reporting this thread as stopped. Update its
4615 "want-stopped" state to what the client wants, until it
4616 gets a new resume action. */
4617 current_thread
->last_resume_kind
= resume_stop
;
4618 current_thread
->last_status
= cs
.last_status
;
4623 if (!target_running ())
4625 /* The last process exited. We're done. */
4629 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4630 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
4631 || cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4635 /* A thread stopped with a signal, but gdb isn't
4636 connected to handle it. Pass it down to the
4637 inferior, as if it wasn't being traced. */
4638 enum gdb_signal signal
;
4641 debug_printf ("GDB not connected; forwarding event %d for"
4643 (int) cs
.last_status
.kind (),
4644 target_pid_to_str (cs
.last_ptid
).c_str ());
4646 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4647 signal
= cs
.last_status
.sig ();
4649 signal
= GDB_SIGNAL_0
;
4650 target_continue (cs
.last_ptid
, signal
);
4654 push_stop_notification (cs
.last_ptid
, cs
.last_status
);
4657 /* Be sure to not change the selected thread behind GDB's back.
4658 Important in the non-stop mode asynchronous protocol. */
4659 set_desired_thread ();
4662 /* See gdbsupport/event-loop.h. */
4665 invoke_async_signal_handlers ()
4670 /* See gdbsupport/event-loop.h. */
4673 check_async_event_handlers ()
4678 /* See gdbsupport/errors.h */
4687 /* See gdbsupport/gdb_select.h. */
4690 gdb_select (int n
, fd_set
*readfds
, fd_set
*writefds
,
4691 fd_set
*exceptfds
, struct timeval
*timeout
)
4693 return select (n
, readfds
, writefds
, exceptfds
, timeout
);
4704 } // namespace selftests
4705 #endif /* GDB_SELF_TEST */