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
, struct 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
.value
.related_pid
.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
.value
.sig
== GDB_SIGNAL_STOP
)
332 cs
.last_status
.value
.sig
= 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
);
952 set_inferior_cwd (path
.c_str ());
955 debug_printf (_("[Set the inferior's current directory to %s]\n"),
960 /* An empty argument means that we should clear out any
961 previously set cwd for the inferior. */
962 set_inferior_cwd (NULL
);
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
.kind
= TARGET_WAITKIND_EXITED
;
1266 cs
.last_status
.value
.integer
= 0;
1267 cs
.last_ptid
= ptid_t (pid
);
1269 current_thread
= NULL
;
1276 /* If we are attached, then we can exit. Otherwise, we
1277 need to hang around doing nothing, until the child is
1279 join_inferior (pid
);
1285 /* Parse options to --debug-format= and "monitor set debug-format".
1286 ARG is the text after "--debug-format=" or "monitor set debug-format".
1287 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1288 This triggers calls to monitor_output.
1289 The result is an empty string if all options were parsed ok, otherwise an
1290 error message which the caller must free.
1292 N.B. These commands affect all debug format settings, they are not
1293 cumulative. If a format is not specified, it is turned off.
1294 However, we don't go to extra trouble with things like
1295 "monitor set debug-format all,none,timestamp".
1296 Instead we just parse them one at a time, in order.
1298 The syntax for "monitor set debug" we support here is not identical
1299 to gdb's "set debug foo on|off" because we also use this function to
1300 parse "--debug-format=foo,bar". */
1303 parse_debug_format_options (const char *arg
, int is_monitor
)
1305 /* First turn all debug format options off. */
1306 debug_timestamp
= 0;
1308 /* First remove leading spaces, for "monitor set debug-format". */
1309 while (isspace (*arg
))
1312 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1313 = delim_string_to_char_ptr_vec (arg
, ',');
1315 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1317 if (strcmp (option
.get (), "all") == 0)
1319 debug_timestamp
= 1;
1321 monitor_output ("All extra debug format options enabled.\n");
1323 else if (strcmp (option
.get (), "none") == 0)
1325 debug_timestamp
= 0;
1327 monitor_output ("All extra debug format options disabled.\n");
1329 else if (strcmp (option
.get (), "timestamp") == 0)
1331 debug_timestamp
= 1;
1333 monitor_output ("Timestamps will be added to debug output.\n");
1335 else if (*option
== '\0')
1337 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1341 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1345 return std::string ();
1348 /* Handle monitor commands not handled by target-specific handlers. */
1351 handle_monitor_command (char *mon
, char *own_buf
)
1353 if (strcmp (mon
, "set debug 1") == 0)
1356 monitor_output ("Debug output enabled.\n");
1358 else if (strcmp (mon
, "set debug 0") == 0)
1361 monitor_output ("Debug output disabled.\n");
1363 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1365 show_debug_regs
= 1;
1366 monitor_output ("H/W point debugging output enabled.\n");
1368 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1370 show_debug_regs
= 0;
1371 monitor_output ("H/W point debugging output disabled.\n");
1373 else if (strcmp (mon
, "set remote-debug 1") == 0)
1376 monitor_output ("Protocol debug output enabled.\n");
1378 else if (strcmp (mon
, "set remote-debug 0") == 0)
1381 monitor_output ("Protocol debug output disabled.\n");
1383 else if (strcmp (mon
, "set event-loop-debug 1") == 0)
1385 debug_event_loop
= debug_event_loop_kind::ALL
;
1386 monitor_output ("Event loop debug output enabled.\n");
1388 else if (strcmp (mon
, "set event-loop-debug 0") == 0)
1390 debug_event_loop
= debug_event_loop_kind::OFF
;
1391 monitor_output ("Event loop debug output disabled.\n");
1393 else if (startswith (mon
, "set debug-format "))
1395 std::string error_msg
1396 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1399 if (!error_msg
.empty ())
1401 monitor_output (error_msg
.c_str ());
1402 monitor_show_help ();
1403 write_enn (own_buf
);
1406 else if (strcmp (mon
, "set debug-file") == 0)
1407 debug_set_output (nullptr);
1408 else if (startswith (mon
, "set debug-file "))
1409 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1410 else if (strcmp (mon
, "help") == 0)
1411 monitor_show_help ();
1412 else if (strcmp (mon
, "exit") == 0)
1413 exit_requested
= true;
1416 monitor_output ("Unknown monitor command.\n\n");
1417 monitor_show_help ();
1418 write_enn (own_buf
);
1422 /* Associates a callback with each supported qXfer'able object. */
1426 /* The object this handler handles. */
1429 /* Request that the target transfer up to LEN 8-bit bytes of the
1430 target's OBJECT. The OFFSET, for a seekable object, specifies
1431 the starting point. The ANNEX can be used to provide additional
1432 data-specific information to the target.
1434 Return the number of bytes actually transfered, zero when no
1435 further transfer is possible, -1 on error, -2 when the transfer
1436 is not supported, and -3 on a verbose error message that should
1437 be preserved. Return of a positive value smaller than LEN does
1438 not indicate the end of the object, only the end of the transfer.
1440 One, and only one, of readbuf or writebuf must be non-NULL. */
1441 int (*xfer
) (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
);
1446 /* Handle qXfer:auxv:read. */
1449 handle_qxfer_auxv (const char *annex
,
1450 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1451 ULONGEST offset
, LONGEST len
)
1453 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1456 if (annex
[0] != '\0' || current_thread
== NULL
)
1459 return the_target
->read_auxv (offset
, readbuf
, len
);
1462 /* Handle qXfer:exec-file:read. */
1465 handle_qxfer_exec_file (const char *annex
,
1466 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1467 ULONGEST offset
, LONGEST len
)
1472 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1475 if (annex
[0] == '\0')
1477 if (current_thread
== NULL
)
1480 pid
= pid_of (current_thread
);
1484 annex
= unpack_varlen_hex (annex
, &pid
);
1485 if (annex
[0] != '\0')
1492 const char *file
= the_target
->pid_to_exec_file (pid
);
1496 total_len
= strlen (file
);
1498 if (offset
> total_len
)
1501 if (offset
+ len
> total_len
)
1502 len
= total_len
- offset
;
1504 memcpy (readbuf
, file
+ offset
, len
);
1508 /* Handle qXfer:features:read. */
1511 handle_qxfer_features (const char *annex
,
1512 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1513 ULONGEST offset
, LONGEST len
)
1515 const char *document
;
1518 if (writebuf
!= NULL
)
1521 if (!target_running ())
1524 /* Grab the correct annex. */
1525 document
= get_features_xml (annex
);
1526 if (document
== NULL
)
1529 total_len
= strlen (document
);
1531 if (offset
> total_len
)
1534 if (offset
+ len
> total_len
)
1535 len
= total_len
- offset
;
1537 memcpy (readbuf
, document
+ offset
, len
);
1541 /* Handle qXfer:libraries:read. */
1544 handle_qxfer_libraries (const char *annex
,
1545 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1546 ULONGEST offset
, LONGEST len
)
1548 if (writebuf
!= NULL
)
1551 if (annex
[0] != '\0' || current_thread
== NULL
)
1554 std::string document
= "<library-list version=\"1.0\">\n";
1556 process_info
*proc
= current_process ();
1557 for (const dll_info
&dll
: proc
->all_dlls
)
1558 document
+= string_printf
1559 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1560 dll
.name
.c_str (), paddress (dll
.base_addr
));
1562 document
+= "</library-list>\n";
1564 if (offset
> document
.length ())
1567 if (offset
+ len
> document
.length ())
1568 len
= document
.length () - offset
;
1570 memcpy (readbuf
, &document
[offset
], len
);
1575 /* Handle qXfer:libraries-svr4:read. */
1578 handle_qxfer_libraries_svr4 (const char *annex
,
1579 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1580 ULONGEST offset
, LONGEST len
)
1582 if (writebuf
!= NULL
)
1585 if (current_thread
== NULL
1586 || !the_target
->supports_qxfer_libraries_svr4 ())
1589 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1593 /* Handle qXfer:osadata:read. */
1596 handle_qxfer_osdata (const char *annex
,
1597 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1598 ULONGEST offset
, LONGEST len
)
1600 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1603 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1606 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1609 handle_qxfer_siginfo (const char *annex
,
1610 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1611 ULONGEST offset
, LONGEST len
)
1613 if (!the_target
->supports_qxfer_siginfo ())
1616 if (annex
[0] != '\0' || current_thread
== NULL
)
1619 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1622 /* Handle qXfer:statictrace:read. */
1625 handle_qxfer_statictrace (const char *annex
,
1626 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1627 ULONGEST offset
, LONGEST len
)
1629 client_state
&cs
= get_client_state ();
1632 if (writebuf
!= NULL
)
1635 if (annex
[0] != '\0' || current_thread
== NULL
1636 || cs
.current_traceframe
== -1)
1639 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1640 readbuf
, len
, &nbytes
))
1645 /* Helper for handle_qxfer_threads_proper.
1646 Emit the XML to describe the thread of INF. */
1649 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1651 ptid_t ptid
= ptid_of (thread
);
1653 int core
= target_core_of_thread (ptid
);
1655 const char *name
= target_thread_name (ptid
);
1658 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1660 write_ptid (ptid_s
, ptid
);
1662 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1666 sprintf (core_s
, "%d", core
);
1667 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1671 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1675 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1676 bin2hex (handle
, handle_s
, handle_len
);
1677 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1680 buffer_xml_printf (buffer
, "/>\n");
1683 /* Helper for handle_qxfer_threads. Return true on success, false
1687 handle_qxfer_threads_proper (struct buffer
*buffer
)
1689 client_state
&cs
= get_client_state ();
1691 scoped_restore save_current_thread
1692 = make_scoped_restore (¤t_thread
);
1693 scoped_restore save_current_general_thread
1694 = make_scoped_restore (&cs
.general_thread
);
1696 buffer_grow_str (buffer
, "<threads>\n");
1698 process_info
*error_proc
= find_process ([&] (process_info
*process
)
1700 /* The target may need to access memory and registers (e.g. via
1701 libthread_db) to fetch thread properties. Prepare for memory
1702 access here, so that we potentially pause threads just once
1703 for all accesses. Note that even if someday we stop needing
1704 to pause threads to access memory, we will need to be able to
1705 access registers, or other ptrace accesses like
1706 PTRACE_GET_THREAD_AREA. */
1708 /* Need to switch to each process in turn, because
1709 prepare_to_access_memory prepares for an access in the
1710 current process pointed to by general_thread. */
1711 switch_to_process (process
);
1712 cs
.general_thread
= current_thread
->id
;
1714 int res
= prepare_to_access_memory ();
1717 for_each_thread (process
->pid
, [&] (thread_info
*thread
)
1719 handle_qxfer_threads_worker (thread
, buffer
);
1722 done_accessing_memory ();
1729 buffer_grow_str0 (buffer
, "</threads>\n");
1730 return error_proc
== nullptr;
1733 /* Handle qXfer:threads:read. */
1736 handle_qxfer_threads (const char *annex
,
1737 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1738 ULONGEST offset
, LONGEST len
)
1740 static char *result
= 0;
1741 static unsigned int result_length
= 0;
1743 if (writebuf
!= NULL
)
1746 if (annex
[0] != '\0')
1751 struct buffer buffer
;
1752 /* When asked for data at offset 0, generate everything and store into
1753 'result'. Successive reads will be served off 'result'. */
1757 buffer_init (&buffer
);
1759 bool res
= handle_qxfer_threads_proper (&buffer
);
1761 result
= buffer_finish (&buffer
);
1762 result_length
= strlen (result
);
1763 buffer_free (&buffer
);
1769 if (offset
>= result_length
)
1771 /* We're out of data. */
1778 if (len
> result_length
- offset
)
1779 len
= result_length
- offset
;
1781 memcpy (readbuf
, result
+ offset
, len
);
1786 /* Handle qXfer:traceframe-info:read. */
1789 handle_qxfer_traceframe_info (const char *annex
,
1790 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1791 ULONGEST offset
, LONGEST len
)
1793 client_state
&cs
= get_client_state ();
1794 static char *result
= 0;
1795 static unsigned int result_length
= 0;
1797 if (writebuf
!= NULL
)
1800 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1805 struct buffer buffer
;
1807 /* When asked for data at offset 0, generate everything and
1808 store into 'result'. Successive reads will be served off
1812 buffer_init (&buffer
);
1814 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1816 result
= buffer_finish (&buffer
);
1817 result_length
= strlen (result
);
1818 buffer_free (&buffer
);
1821 if (offset
>= result_length
)
1823 /* We're out of data. */
1830 if (len
> result_length
- offset
)
1831 len
= result_length
- offset
;
1833 memcpy (readbuf
, result
+ offset
, len
);
1837 /* Handle qXfer:fdpic:read. */
1840 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1841 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1843 if (!the_target
->supports_read_loadmap ())
1846 if (current_thread
== NULL
)
1849 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1852 /* Handle qXfer:btrace:read. */
1855 handle_qxfer_btrace (const char *annex
,
1856 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1857 ULONGEST offset
, LONGEST len
)
1859 client_state
&cs
= get_client_state ();
1860 static struct buffer cache
;
1861 struct thread_info
*thread
;
1862 enum btrace_read_type type
;
1865 if (writebuf
!= NULL
)
1868 if (cs
.general_thread
== null_ptid
1869 || cs
.general_thread
== minus_one_ptid
)
1871 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1875 thread
= find_thread_ptid (cs
.general_thread
);
1878 strcpy (cs
.own_buf
, "E.No such thread.");
1882 if (thread
->btrace
== NULL
)
1884 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1888 if (strcmp (annex
, "all") == 0)
1889 type
= BTRACE_READ_ALL
;
1890 else if (strcmp (annex
, "new") == 0)
1891 type
= BTRACE_READ_NEW
;
1892 else if (strcmp (annex
, "delta") == 0)
1893 type
= BTRACE_READ_DELTA
;
1896 strcpy (cs
.own_buf
, "E.Bad annex.");
1902 buffer_free (&cache
);
1906 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1908 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1910 catch (const gdb_exception_error
&exception
)
1912 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1919 else if (offset
> cache
.used_size
)
1921 buffer_free (&cache
);
1925 if (len
> cache
.used_size
- offset
)
1926 len
= cache
.used_size
- offset
;
1928 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1933 /* Handle qXfer:btrace-conf:read. */
1936 handle_qxfer_btrace_conf (const char *annex
,
1937 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1938 ULONGEST offset
, LONGEST len
)
1940 client_state
&cs
= get_client_state ();
1941 static struct buffer cache
;
1942 struct thread_info
*thread
;
1945 if (writebuf
!= NULL
)
1948 if (annex
[0] != '\0')
1951 if (cs
.general_thread
== null_ptid
1952 || cs
.general_thread
== minus_one_ptid
)
1954 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1958 thread
= find_thread_ptid (cs
.general_thread
);
1961 strcpy (cs
.own_buf
, "E.No such thread.");
1965 if (thread
->btrace
== NULL
)
1967 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1973 buffer_free (&cache
);
1977 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1979 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1981 catch (const gdb_exception_error
&exception
)
1983 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1990 else if (offset
> cache
.used_size
)
1992 buffer_free (&cache
);
1996 if (len
> cache
.used_size
- offset
)
1997 len
= cache
.used_size
- offset
;
1999 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
2004 static const struct qxfer qxfer_packets
[] =
2006 { "auxv", handle_qxfer_auxv
},
2007 { "btrace", handle_qxfer_btrace
},
2008 { "btrace-conf", handle_qxfer_btrace_conf
},
2009 { "exec-file", handle_qxfer_exec_file
},
2010 { "fdpic", handle_qxfer_fdpic
},
2011 { "features", handle_qxfer_features
},
2012 { "libraries", handle_qxfer_libraries
},
2013 { "libraries-svr4", handle_qxfer_libraries_svr4
},
2014 { "osdata", handle_qxfer_osdata
},
2015 { "siginfo", handle_qxfer_siginfo
},
2016 { "statictrace", handle_qxfer_statictrace
},
2017 { "threads", handle_qxfer_threads
},
2018 { "traceframe-info", handle_qxfer_traceframe_info
},
2022 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2030 if (!startswith (own_buf
, "qXfer:"))
2033 /* Grab the object, r/w and annex. */
2034 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2036 write_enn (own_buf
);
2041 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2044 const struct qxfer
*q
= &qxfer_packets
[i
];
2046 if (strcmp (object
, q
->object
) == 0)
2048 if (strcmp (rw
, "read") == 0)
2050 unsigned char *data
;
2055 /* Grab the offset and length. */
2056 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2058 write_enn (own_buf
);
2062 /* Read one extra byte, as an indicator of whether there is
2064 if (len
> PBUFSIZ
- 2)
2066 data
= (unsigned char *) malloc (len
+ 1);
2069 write_enn (own_buf
);
2072 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2080 /* Preserve error message. */
2083 write_enn (own_buf
);
2085 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2087 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2092 else if (strcmp (rw
, "write") == 0)
2097 unsigned char *data
;
2099 strcpy (own_buf
, "E00");
2100 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2103 write_enn (own_buf
);
2106 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2107 &ofs
, &len
, data
) < 0)
2110 write_enn (own_buf
);
2114 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2122 /* Preserve error message. */
2125 write_enn (own_buf
);
2127 sprintf (own_buf
, "%x", n
);
2140 /* Compute 32 bit CRC from inferior memory.
2142 On success, return 32 bit CRC.
2143 On failure, return (unsigned long long) -1. */
2145 static unsigned long long
2146 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2150 unsigned char byte
= 0;
2152 /* Return failure if memory read fails. */
2153 if (read_inferior_memory (base
, &byte
, 1) != 0)
2154 return (unsigned long long) -1;
2156 crc
= xcrc32 (&byte
, 1, crc
);
2159 return (unsigned long long) crc
;
2162 /* Parse the qMemTags packet request into ADDR and LEN. */
2165 parse_fetch_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
2168 gdb_assert (startswith (request
, "qMemTags:"));
2170 const char *p
= request
+ strlen ("qMemTags:");
2172 /* Read address and length. */
2173 unsigned int length
= 0;
2174 p
= decode_m_packet_params (p
, addr
, &length
, ':');
2177 /* Read the tag type. */
2178 ULONGEST tag_type
= 0;
2179 p
= unpack_varlen_hex (p
, &tag_type
);
2180 *type
= (int) tag_type
;
2183 /* Add supported btrace packets to BUF. */
2186 supported_btrace_packets (char *buf
)
2188 strcat (buf
, ";Qbtrace:bts+");
2189 strcat (buf
, ";Qbtrace-conf:bts:size+");
2190 strcat (buf
, ";Qbtrace:pt+");
2191 strcat (buf
, ";Qbtrace-conf:pt:size+");
2192 strcat (buf
, ";Qbtrace:off+");
2193 strcat (buf
, ";qXfer:btrace:read+");
2194 strcat (buf
, ";qXfer:btrace-conf:read+");
2197 /* Handle all of the extended 'q' packets. */
2200 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2202 client_state
&cs
= get_client_state ();
2203 static std::list
<thread_info
*>::const_iterator thread_iter
;
2205 /* Reply the current thread id. */
2206 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2209 require_running_or_return (own_buf
);
2211 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2212 ptid
= cs
.general_thread
;
2215 thread_iter
= all_threads
.begin ();
2216 ptid
= (*thread_iter
)->id
;
2219 sprintf (own_buf
, "QC");
2221 write_ptid (own_buf
, ptid
);
2225 if (strcmp ("qSymbol::", own_buf
) == 0)
2227 struct thread_info
*save_thread
= current_thread
;
2229 /* For qSymbol, GDB only changes the current thread if the
2230 previous current thread was of a different process. So if
2231 the previous thread is gone, we need to pick another one of
2232 the same process. This can happen e.g., if we followed an
2233 exec in a non-leader thread. */
2234 if (current_thread
== NULL
)
2237 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2239 /* Just in case, if we didn't find a thread, then bail out
2240 instead of crashing. */
2241 if (current_thread
== NULL
)
2243 write_enn (own_buf
);
2244 current_thread
= save_thread
;
2249 /* GDB is suggesting new symbols have been loaded. This may
2250 mean a new shared library has been detected as loaded, so
2251 take the opportunity to check if breakpoints we think are
2252 inserted, still are. Note that it isn't guaranteed that
2253 we'll see this when a shared library is loaded, and nor will
2254 we see this for unloads (although breakpoints in unloaded
2255 libraries shouldn't trigger), as GDB may not find symbols for
2256 the library at all. We also re-validate breakpoints when we
2257 see a second GDB breakpoint for the same address, and or when
2258 we access breakpoint shadows. */
2259 validate_breakpoints ();
2261 if (target_supports_tracepoints ())
2262 tracepoint_look_up_symbols ();
2264 if (current_thread
!= NULL
)
2265 the_target
->look_up_symbols ();
2267 current_thread
= save_thread
;
2269 strcpy (own_buf
, "OK");
2273 if (!disable_packet_qfThreadInfo
)
2275 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2277 require_running_or_return (own_buf
);
2278 thread_iter
= all_threads
.begin ();
2281 ptid_t ptid
= (*thread_iter
)->id
;
2282 write_ptid (own_buf
, ptid
);
2287 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2289 require_running_or_return (own_buf
);
2290 if (thread_iter
!= all_threads
.end ())
2293 ptid_t ptid
= (*thread_iter
)->id
;
2294 write_ptid (own_buf
, ptid
);
2300 sprintf (own_buf
, "l");
2306 if (the_target
->supports_read_offsets ()
2307 && strcmp ("qOffsets", own_buf
) == 0)
2309 CORE_ADDR text
, data
;
2311 require_running_or_return (own_buf
);
2312 if (the_target
->read_offsets (&text
, &data
))
2313 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2314 (long)text
, (long)data
, (long)data
);
2316 write_enn (own_buf
);
2321 /* Protocol features query. */
2322 if (startswith (own_buf
, "qSupported")
2323 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2325 char *p
= &own_buf
[10];
2326 int gdb_supports_qRelocInsn
= 0;
2328 /* Process each feature being provided by GDB. The first
2329 feature will follow a ':', and latter features will follow
2333 std::vector
<std::string
> qsupported
;
2334 std::vector
<const char *> unknowns
;
2336 /* Two passes, to avoid nested strtok calls in
2337 target_process_qsupported. */
2339 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2341 p
= strtok_r (NULL
, ";", &saveptr
))
2342 qsupported
.emplace_back (p
);
2344 for (const std::string
&feature
: qsupported
)
2346 if (feature
== "multiprocess+")
2348 /* GDB supports and wants multi-process support if
2350 if (target_supports_multi_process ())
2351 cs
.multi_process
= 1;
2353 else if (feature
== "qRelocInsn+")
2355 /* GDB supports relocate instruction requests. */
2356 gdb_supports_qRelocInsn
= 1;
2358 else if (feature
== "swbreak+")
2360 /* GDB wants us to report whether a trap is caused
2361 by a software breakpoint and for us to handle PC
2362 adjustment if necessary on this target. */
2363 if (target_supports_stopped_by_sw_breakpoint ())
2364 cs
.swbreak_feature
= 1;
2366 else if (feature
== "hwbreak+")
2368 /* GDB wants us to report whether a trap is caused
2369 by a hardware breakpoint. */
2370 if (target_supports_stopped_by_hw_breakpoint ())
2371 cs
.hwbreak_feature
= 1;
2373 else if (feature
== "fork-events+")
2375 /* GDB supports and wants fork events if possible. */
2376 if (target_supports_fork_events ())
2377 cs
.report_fork_events
= 1;
2379 else if (feature
== "vfork-events+")
2381 /* GDB supports and wants vfork events if possible. */
2382 if (target_supports_vfork_events ())
2383 cs
.report_vfork_events
= 1;
2385 else if (feature
== "exec-events+")
2387 /* GDB supports and wants exec events if possible. */
2388 if (target_supports_exec_events ())
2389 cs
.report_exec_events
= 1;
2391 else if (feature
== "vContSupported+")
2392 cs
.vCont_supported
= 1;
2393 else if (feature
== "QThreadEvents+")
2395 else if (feature
== "no-resumed+")
2397 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2399 report_no_resumed
= true;
2401 else if (feature
== "memory-tagging+")
2403 /* GDB supports memory tagging features. */
2404 if (target_supports_memory_tagging ())
2405 cs
.memory_tagging_feature
= true;
2409 /* Move the unknown features all together. */
2410 unknowns
.push_back (feature
.c_str ());
2414 /* Give the target backend a chance to process the unknown
2416 target_process_qsupported (unknowns
);
2420 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2421 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2422 "QEnvironmentReset+;QEnvironmentUnset+;"
2426 if (target_supports_catch_syscall ())
2427 strcat (own_buf
, ";QCatchSyscalls+");
2429 if (the_target
->supports_qxfer_libraries_svr4 ())
2430 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2431 ";augmented-libraries-svr4-read+");
2434 /* We do not have any hook to indicate whether the non-SVR4 target
2435 backend supports qXfer:libraries:read, so always report it. */
2436 strcat (own_buf
, ";qXfer:libraries:read+");
2439 if (the_target
->supports_read_auxv ())
2440 strcat (own_buf
, ";qXfer:auxv:read+");
2442 if (the_target
->supports_qxfer_siginfo ())
2443 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2445 if (the_target
->supports_read_loadmap ())
2446 strcat (own_buf
, ";qXfer:fdpic:read+");
2448 /* We always report qXfer:features:read, as targets may
2449 install XML files on a subsequent call to arch_setup.
2450 If we reported to GDB on startup that we don't support
2451 qXfer:feature:read at all, we will never be re-queried. */
2452 strcat (own_buf
, ";qXfer:features:read+");
2454 if (cs
.transport_is_reliable
)
2455 strcat (own_buf
, ";QStartNoAckMode+");
2457 if (the_target
->supports_qxfer_osdata ())
2458 strcat (own_buf
, ";qXfer:osdata:read+");
2460 if (target_supports_multi_process ())
2461 strcat (own_buf
, ";multiprocess+");
2463 if (target_supports_fork_events ())
2464 strcat (own_buf
, ";fork-events+");
2466 if (target_supports_vfork_events ())
2467 strcat (own_buf
, ";vfork-events+");
2469 if (target_supports_exec_events ())
2470 strcat (own_buf
, ";exec-events+");
2472 if (target_supports_non_stop ())
2473 strcat (own_buf
, ";QNonStop+");
2475 if (target_supports_disable_randomization ())
2476 strcat (own_buf
, ";QDisableRandomization+");
2478 strcat (own_buf
, ";qXfer:threads:read+");
2480 if (target_supports_tracepoints ())
2482 strcat (own_buf
, ";ConditionalTracepoints+");
2483 strcat (own_buf
, ";TraceStateVariables+");
2484 strcat (own_buf
, ";TracepointSource+");
2485 strcat (own_buf
, ";DisconnectedTracing+");
2486 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2487 strcat (own_buf
, ";FastTracepoints+");
2488 strcat (own_buf
, ";StaticTracepoints+");
2489 strcat (own_buf
, ";InstallInTrace+");
2490 strcat (own_buf
, ";qXfer:statictrace:read+");
2491 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2492 strcat (own_buf
, ";EnableDisableTracepoints+");
2493 strcat (own_buf
, ";QTBuffer:size+");
2494 strcat (own_buf
, ";tracenz+");
2497 if (target_supports_hardware_single_step ()
2498 || target_supports_software_single_step () )
2500 strcat (own_buf
, ";ConditionalBreakpoints+");
2502 strcat (own_buf
, ";BreakpointCommands+");
2504 if (target_supports_agent ())
2505 strcat (own_buf
, ";QAgent+");
2507 supported_btrace_packets (own_buf
);
2509 if (target_supports_stopped_by_sw_breakpoint ())
2510 strcat (own_buf
, ";swbreak+");
2512 if (target_supports_stopped_by_hw_breakpoint ())
2513 strcat (own_buf
, ";hwbreak+");
2515 if (the_target
->supports_pid_to_exec_file ())
2516 strcat (own_buf
, ";qXfer:exec-file:read+");
2518 strcat (own_buf
, ";vContSupported+");
2520 strcat (own_buf
, ";QThreadEvents+");
2522 strcat (own_buf
, ";no-resumed+");
2524 if (target_supports_memory_tagging ())
2525 strcat (own_buf
, ";memory-tagging+");
2527 /* Reinitialize components as needed for the new connection. */
2528 hostio_handle_new_gdb_connection ();
2529 target_handle_new_gdb_connection ();
2534 /* Thread-local storage support. */
2535 if (the_target
->supports_get_tls_address ()
2536 && startswith (own_buf
, "qGetTLSAddr:"))
2538 char *p
= own_buf
+ 12;
2539 CORE_ADDR parts
[2], address
= 0;
2541 ptid_t ptid
= null_ptid
;
2543 require_running_or_return (own_buf
);
2545 for (i
= 0; i
< 3; i
++)
2553 p2
= strchr (p
, ',');
2566 ptid
= read_ptid (p
, NULL
);
2568 decode_address (&parts
[i
- 1], p
, len
);
2572 if (p
!= NULL
|| i
< 3)
2576 struct thread_info
*thread
= find_thread_ptid (ptid
);
2581 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2587 strcpy (own_buf
, paddress(address
));
2592 write_enn (own_buf
);
2596 /* Otherwise, pretend we do not understand this packet. */
2599 /* Windows OS Thread Information Block address support. */
2600 if (the_target
->supports_get_tib_address ()
2601 && startswith (own_buf
, "qGetTIBAddr:"))
2606 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2608 n
= the_target
->get_tib_address (ptid
, &tlb
);
2611 strcpy (own_buf
, paddress(tlb
));
2616 write_enn (own_buf
);
2622 /* Handle "monitor" commands. */
2623 if (startswith (own_buf
, "qRcmd,"))
2625 char *mon
= (char *) malloc (PBUFSIZ
);
2626 int len
= strlen (own_buf
+ 6);
2630 write_enn (own_buf
);
2635 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2637 write_enn (own_buf
);
2641 mon
[len
/ 2] = '\0';
2645 if (the_target
->handle_monitor_command (mon
) == 0)
2646 /* Default processing. */
2647 handle_monitor_command (mon
, own_buf
);
2653 if (startswith (own_buf
, "qSearch:memory:"))
2655 require_running_or_return (own_buf
);
2656 handle_search_memory (own_buf
, packet_len
);
2660 if (strcmp (own_buf
, "qAttached") == 0
2661 || startswith (own_buf
, "qAttached:"))
2663 struct process_info
*process
;
2665 if (own_buf
[sizeof ("qAttached") - 1])
2667 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2668 process
= find_process_pid (pid
);
2672 require_running_or_return (own_buf
);
2673 process
= current_process ();
2676 if (process
== NULL
)
2678 write_enn (own_buf
);
2682 strcpy (own_buf
, process
->attached
? "1" : "0");
2686 if (startswith (own_buf
, "qCRC:"))
2688 /* CRC check (compare-section). */
2692 unsigned long long crc
;
2694 require_running_or_return (own_buf
);
2695 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2696 if (*comma
++ != ',')
2698 write_enn (own_buf
);
2701 len
= strtoul (comma
, NULL
, 16);
2702 crc
= crc32 (base
, len
, 0xffffffff);
2703 /* Check for memory failure. */
2704 if (crc
== (unsigned long long) -1)
2706 write_enn (own_buf
);
2709 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2713 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2716 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2719 /* Handle fetch memory tags packets. */
2720 if (startswith (own_buf
, "qMemTags:")
2721 && target_supports_memory_tagging ())
2723 gdb::byte_vector tags
;
2728 require_running_or_return (own_buf
);
2730 parse_fetch_memtags_request (own_buf
, &addr
, &len
, &type
);
2732 bool ret
= the_target
->fetch_memtags (addr
, len
, tags
, type
);
2735 ret
= create_fetch_memtags_reply (own_buf
, tags
);
2738 write_enn (own_buf
);
2740 *new_packet_len_p
= strlen (own_buf
);
2744 /* Otherwise we didn't know what packet it was. Say we didn't
2749 static void gdb_wants_all_threads_stopped (void);
2750 static void resume (struct thread_resume
*actions
, size_t n
);
2752 /* The callback that is passed to visit_actioned_threads. */
2753 typedef int (visit_actioned_threads_callback_ftype
)
2754 (const struct thread_resume
*, struct thread_info
*);
2756 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2757 true if CALLBACK returns true. Returns false if no matching thread
2758 is found or CALLBACK results false.
2759 Note: This function is itself a callback for find_thread. */
2762 visit_actioned_threads (thread_info
*thread
,
2763 const struct thread_resume
*actions
,
2765 visit_actioned_threads_callback_ftype
*callback
)
2767 for (size_t i
= 0; i
< num_actions
; i
++)
2769 const struct thread_resume
*action
= &actions
[i
];
2771 if (action
->thread
== minus_one_ptid
2772 || action
->thread
== thread
->id
2773 || ((action
->thread
.pid ()
2774 == thread
->id
.pid ())
2775 && action
->thread
.lwp () == -1))
2777 if ((*callback
) (action
, thread
))
2785 /* Callback for visit_actioned_threads. If the thread has a pending
2786 status to report, report it now. */
2789 handle_pending_status (const struct thread_resume
*resumption
,
2790 struct thread_info
*thread
)
2792 client_state
&cs
= get_client_state ();
2793 if (thread
->status_pending_p
)
2795 thread
->status_pending_p
= 0;
2797 cs
.last_status
= thread
->last_status
;
2798 cs
.last_ptid
= thread
->id
;
2799 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2805 /* Parse vCont packets. */
2807 handle_v_cont (char *own_buf
)
2811 struct thread_resume
*resume_info
;
2812 struct thread_resume default_action
{ null_ptid
};
2814 /* Count the number of semicolons in the packet. There should be one
2815 for every action. */
2821 p
= strchr (p
, ';');
2824 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2825 if (resume_info
== NULL
)
2833 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2835 if (p
[0] == 's' || p
[0] == 'S')
2836 resume_info
[i
].kind
= resume_step
;
2837 else if (p
[0] == 'r')
2838 resume_info
[i
].kind
= resume_step
;
2839 else if (p
[0] == 'c' || p
[0] == 'C')
2840 resume_info
[i
].kind
= resume_continue
;
2841 else if (p
[0] == 't')
2842 resume_info
[i
].kind
= resume_stop
;
2846 if (p
[0] == 'S' || p
[0] == 'C')
2849 int sig
= strtol (p
+ 1, &q
, 16);
2854 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2856 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2858 else if (p
[0] == 'r')
2862 p
= unpack_varlen_hex (p
+ 1, &addr
);
2863 resume_info
[i
].step_range_start
= addr
;
2868 p
= unpack_varlen_hex (p
+ 1, &addr
);
2869 resume_info
[i
].step_range_end
= addr
;
2878 resume_info
[i
].thread
= minus_one_ptid
;
2879 default_action
= resume_info
[i
];
2881 /* Note: we don't increment i here, we'll overwrite this entry
2882 the next time through. */
2884 else if (p
[0] == ':')
2887 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2892 if (p
[0] != ';' && p
[0] != 0)
2895 resume_info
[i
].thread
= ptid
;
2902 resume_info
[i
] = default_action
;
2904 resume (resume_info
, n
);
2909 write_enn (own_buf
);
2914 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2917 resume (struct thread_resume
*actions
, size_t num_actions
)
2919 client_state
&cs
= get_client_state ();
2922 /* Check if among the threads that GDB wants actioned, there's
2923 one with a pending status to report. If so, skip actually
2924 resuming/stopping and report the pending event
2927 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2929 return visit_actioned_threads (thread
, actions
, num_actions
,
2930 handle_pending_status
);
2933 if (thread_with_status
!= NULL
)
2939 the_target
->resume (actions
, num_actions
);
2942 write_ok (cs
.own_buf
);
2945 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2947 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2948 && !report_no_resumed
)
2950 /* The client does not support this stop reply. At least
2952 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2953 disable_async_io ();
2957 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2958 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2959 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2960 current_thread
->last_status
= cs
.last_status
;
2962 /* From the client's perspective, all-stop mode always stops all
2963 threads implicitly (and the target backend has already done
2964 so by now). Tag all threads as "want-stopped", so we don't
2965 resume them implicitly without the client telling us to. */
2966 gdb_wants_all_threads_stopped ();
2967 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2968 disable_async_io ();
2970 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2971 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2972 target_mourn_inferior (cs
.last_ptid
);
2976 /* Attach to a new program. */
2978 handle_v_attach (char *own_buf
)
2980 client_state
&cs
= get_client_state ();
2983 pid
= strtol (own_buf
+ 8, NULL
, 16);
2984 if (pid
!= 0 && attach_inferior (pid
) == 0)
2986 /* Don't report shared library events after attaching, even if
2987 some libraries are preloaded. GDB will always poll the
2988 library list. Avoids the "stopped by shared library event"
2989 notice on the GDB side. */
2990 current_process ()->dlls_changed
= false;
2994 /* In non-stop, we don't send a resume reply. Stop events
2995 will follow up using the normal notification
3000 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3003 write_enn (own_buf
);
3006 /* Run a new program. */
3008 handle_v_run (char *own_buf
)
3010 client_state
&cs
= get_client_state ();
3012 std::vector
<char *> new_argv
;
3013 char *new_program_name
= NULL
;
3017 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
3023 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
3025 next_p
= strchr (p
, ';');
3027 next_p
= p
+ strlen (p
);
3029 if (i
== 0 && p
== next_p
)
3031 /* No program specified. */
3032 new_program_name
= NULL
;
3034 else if (p
== next_p
)
3036 /* Empty argument. */
3037 new_argv
.push_back (xstrdup (""));
3041 size_t len
= (next_p
- p
) / 2;
3042 /* ARG is the unquoted argument received via the RSP. */
3043 char *arg
= (char *) xmalloc (len
+ 1);
3044 /* FULL_ARGS will contain the quoted version of ARG. */
3045 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
3046 /* These are pointers used to navigate the strings above. */
3047 char *tmp_arg
= arg
;
3048 char *tmp_full_arg
= full_arg
;
3051 hex2bin (p
, (gdb_byte
*) arg
, len
);
3054 while (*tmp_arg
!= '\0')
3060 *tmp_full_arg
= '\'';
3066 /* Quote single quote. */
3067 *tmp_full_arg
= '\\';
3075 *tmp_full_arg
= *tmp_arg
;
3081 *tmp_full_arg
++ = '\'';
3083 /* Finish FULL_ARG and push it into the vector containing
3085 *tmp_full_arg
= '\0';
3087 new_program_name
= full_arg
;
3089 new_argv
.push_back (full_arg
);
3096 if (new_program_name
== NULL
)
3098 /* GDB didn't specify a program to run. Use the program from the
3099 last run with the new argument list. */
3100 if (program_path
.get () == NULL
)
3102 write_enn (own_buf
);
3103 free_vector_argv (new_argv
);
3108 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3110 /* Free the old argv and install the new one. */
3111 free_vector_argv (program_args
);
3112 program_args
= new_argv
;
3114 target_create_inferior (program_path
.get (), program_args
);
3116 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3118 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3120 /* In non-stop, sending a resume reply doesn't set the general
3121 thread, but GDB assumes a vRun sets it (this is so GDB can
3122 query which is the main thread of the new inferior. */
3124 cs
.general_thread
= cs
.last_ptid
;
3127 write_enn (own_buf
);
3132 handle_v_kill (char *own_buf
)
3134 client_state
&cs
= get_client_state ();
3136 char *p
= &own_buf
[6];
3137 if (cs
.multi_process
)
3138 pid
= strtol (p
, NULL
, 16);
3142 process_info
*proc
= find_process_pid (pid
);
3144 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3146 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3147 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3148 cs
.last_ptid
= ptid_t (pid
);
3149 discard_queued_stop_replies (cs
.last_ptid
);
3153 write_enn (own_buf
);
3156 /* Handle all of the extended 'v' packets. */
3158 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3160 client_state
&cs
= get_client_state ();
3161 if (!disable_packet_vCont
)
3163 if (strcmp (own_buf
, "vCtrlC") == 0)
3165 the_target
->request_interrupt ();
3170 if (startswith (own_buf
, "vCont;"))
3172 handle_v_cont (own_buf
);
3176 if (startswith (own_buf
, "vCont?"))
3178 strcpy (own_buf
, "vCont;c;C;t");
3180 if (target_supports_hardware_single_step ()
3181 || target_supports_software_single_step ()
3182 || !cs
.vCont_supported
)
3184 /* If target supports single step either by hardware or by
3185 software, add actions s and S to the list of supported
3186 actions. On the other hand, if GDB doesn't request the
3187 supported vCont actions in qSupported packet, add s and
3188 S to the list too. */
3189 own_buf
= own_buf
+ strlen (own_buf
);
3190 strcpy (own_buf
, ";s;S");
3193 if (target_supports_range_stepping ())
3195 own_buf
= own_buf
+ strlen (own_buf
);
3196 strcpy (own_buf
, ";r");
3202 if (startswith (own_buf
, "vFile:")
3203 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3206 if (startswith (own_buf
, "vAttach;"))
3208 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3210 fprintf (stderr
, "Already debugging a process\n");
3211 write_enn (own_buf
);
3214 handle_v_attach (own_buf
);
3218 if (startswith (own_buf
, "vRun;"))
3220 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3222 fprintf (stderr
, "Already debugging a process\n");
3223 write_enn (own_buf
);
3226 handle_v_run (own_buf
);
3230 if (startswith (own_buf
, "vKill;"))
3232 if (!target_running ())
3234 fprintf (stderr
, "No process to kill\n");
3235 write_enn (own_buf
);
3238 handle_v_kill (own_buf
);
3242 if (handle_notif_ack (own_buf
, packet_len
))
3245 /* Otherwise we didn't know what packet it was. Say we didn't
3251 /* Resume thread and wait for another event. In non-stop mode,
3252 don't really wait here, but return immediatelly to the event
3255 myresume (char *own_buf
, int step
, int sig
)
3257 client_state
&cs
= get_client_state ();
3258 struct thread_resume resume_info
[2];
3260 int valid_cont_thread
;
3262 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3263 && cs
.cont_thread
!= minus_one_ptid
);
3265 if (step
|| sig
|| valid_cont_thread
)
3267 resume_info
[0].thread
= current_ptid
;
3269 resume_info
[0].kind
= resume_step
;
3271 resume_info
[0].kind
= resume_continue
;
3272 resume_info
[0].sig
= sig
;
3276 if (!valid_cont_thread
)
3278 resume_info
[n
].thread
= minus_one_ptid
;
3279 resume_info
[n
].kind
= resume_continue
;
3280 resume_info
[n
].sig
= 0;
3284 resume (resume_info
, n
);
3287 /* Callback for for_each_thread. Make a new stop reply for each
3291 queue_stop_reply_callback (thread_info
*thread
)
3293 /* For now, assume targets that don't have this callback also don't
3294 manage the thread's last_status field. */
3295 if (!the_target
->supports_thread_stopped ())
3297 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3299 new_notif
->ptid
= thread
->id
;
3300 new_notif
->status
= thread
->last_status
;
3301 /* Pass the last stop reply back to GDB, but don't notify
3303 notif_event_enque (¬if_stop
, new_notif
);
3307 if (target_thread_stopped (thread
))
3311 std::string status_string
3312 = target_waitstatus_to_string (&thread
->last_status
);
3314 debug_printf ("Reporting thread %s as already stopped with %s\n",
3315 target_pid_to_str (thread
->id
),
3316 status_string
.c_str ());
3319 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3321 /* Pass the last stop reply back to GDB, but don't notify
3323 queue_stop_reply (thread
->id
, &thread
->last_status
);
3328 /* Set this inferior threads's state as "want-stopped". We won't
3329 resume this thread until the client gives us another action for
3333 gdb_wants_thread_stopped (thread_info
*thread
)
3335 thread
->last_resume_kind
= resume_stop
;
3337 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3339 /* Most threads are stopped implicitly (all-stop); tag that with
3341 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3342 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3346 /* Set all threads' states as "want-stopped". */
3349 gdb_wants_all_threads_stopped (void)
3351 for_each_thread (gdb_wants_thread_stopped
);
3354 /* Callback for for_each_thread. If the thread is stopped with an
3355 interesting event, mark it as having a pending event. */
3358 set_pending_status_callback (thread_info
*thread
)
3360 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3361 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3362 /* A breakpoint, watchpoint or finished step from a previous
3363 GDB run isn't considered interesting for a new GDB run.
3364 If we left those pending, the new GDB could consider them
3365 random SIGTRAPs. This leaves out real async traps. We'd
3366 have to peek into the (target-specific) siginfo to
3367 distinguish those. */
3368 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3369 thread
->status_pending_p
= 1;
3372 /* Status handler for the '?' packet. */
3375 handle_status (char *own_buf
)
3377 client_state
&cs
= get_client_state ();
3379 /* GDB is connected, don't forward events to the target anymore. */
3380 for_each_process ([] (process_info
*process
) {
3381 process
->gdb_detached
= 0;
3384 /* In non-stop mode, we must send a stop reply for each stopped
3385 thread. In all-stop mode, just send one for the first stopped
3390 for_each_thread (queue_stop_reply_callback
);
3392 /* The first is sent immediatly. OK is sent if there is no
3393 stopped thread, which is the same handling of the vStopped
3394 packet (by design). */
3395 notif_write_event (¬if_stop
, cs
.own_buf
);
3399 thread_info
*thread
= NULL
;
3401 target_pause_all (false);
3402 target_stabilize_threads ();
3403 gdb_wants_all_threads_stopped ();
3405 /* We can only report one status, but we might be coming out of
3406 non-stop -- if more than one thread is stopped with
3407 interesting events, leave events for the threads we're not
3408 reporting now pending. They'll be reported the next time the
3409 threads are resumed. Start by marking all interesting events
3411 for_each_thread (set_pending_status_callback
);
3413 /* Prefer the last thread that reported an event to GDB (even if
3414 that was a GDB_SIGNAL_TRAP). */
3415 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3416 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3417 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3418 thread
= find_thread_ptid (cs
.last_ptid
);
3420 /* If the last event thread is not found for some reason, look
3421 for some other thread that might have an event to report. */
3423 thread
= find_thread ([] (thread_info
*thr_arg
)
3425 return thr_arg
->status_pending_p
;
3428 /* If we're still out of luck, simply pick the first thread in
3431 thread
= get_first_thread ();
3435 struct thread_info
*tp
= (struct thread_info
*) thread
;
3437 /* We're reporting this event, so it's no longer
3439 tp
->status_pending_p
= 0;
3441 /* GDB assumes the current thread is the thread we're
3442 reporting the status for. */
3443 cs
.general_thread
= thread
->id
;
3444 set_desired_thread ();
3446 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3447 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3450 strcpy (own_buf
, "W00");
3455 gdbserver_version (void)
3457 printf ("GNU gdbserver %s%s\n"
3458 "Copyright (C) 2021 Free Software Foundation, Inc.\n"
3459 "gdbserver is free software, covered by the "
3460 "GNU General Public License.\n"
3461 "This gdbserver was configured as \"%s\"\n",
3462 PKGVERSION
, version
, host_name
);
3466 gdbserver_usage (FILE *stream
)
3468 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3469 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3470 "\tgdbserver [OPTIONS] --multi COMM\n"
3472 "COMM may either be a tty device (for serial debugging),\n"
3473 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3474 "stdin/stdout of gdbserver.\n"
3475 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3476 "PID is the process ID to attach to, when --attach is specified.\n"
3478 "Operating modes:\n"
3480 " --attach Attach to running process PID.\n"
3481 " --multi Start server without a specific program, and\n"
3482 " only quit when explicitly commanded.\n"
3483 " --once Exit after the first connection has closed.\n"
3484 " --help Print this message and then exit.\n"
3485 " --version Display version information and exit.\n"
3489 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3490 " --disable-randomization\n"
3491 " Run PROG with address space randomization disabled.\n"
3492 " --no-disable-randomization\n"
3493 " Don't disable address space randomization when\n"
3495 " --startup-with-shell\n"
3496 " Start PROG using a shell. I.e., execs a shell that\n"
3497 " then execs PROG. (default)\n"
3498 " --no-startup-with-shell\n"
3499 " Exec PROG directly instead of using a shell.\n"
3500 " Disables argument globbing and variable substitution\n"
3501 " on UNIX-like systems.\n"
3505 " --debug Enable general debugging output.\n"
3506 " --debug-format=OPT1[,OPT2,...]\n"
3507 " Specify extra content in debugging output.\n"
3512 " --remote-debug Enable remote protocol debugging output.\n"
3513 " --event-loop-debug Enable event loop debugging output.\n"
3514 " --disable-packet=OPT1[,OPT2,...]\n"
3515 " Disable support for RSP packets or features.\n"
3517 " vCont, T, Tthread, qC, qfThreadInfo and \n"
3518 " threads (disable all threading packets).\n"
3520 "For more information, consult the GDB manual (available as on-line \n"
3521 "info or a printed manual).\n");
3522 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3523 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3527 gdbserver_show_disableable (FILE *stream
)
3529 fprintf (stream
, "Disableable packets:\n"
3530 " vCont \tAll vCont packets\n"
3531 " qC \tQuerying the current thread\n"
3532 " qfThreadInfo\tThread listing\n"
3533 " Tthread \tPassing the thread specifier in the "
3534 "T stop reply packet\n"
3535 " threads \tAll of the above\n"
3536 " T \tAll 'T' packets\n");
3539 /* Start up the event loop. This is the entry point to the event
3545 /* Loop until there is nothing to do. This is the entry point to
3546 the event loop engine. If nothing is ready at this time, wait
3547 for something to happen (via wait_for_event), then process it.
3548 Return when there are no longer event sources to wait for. */
3550 keep_processing_events
= true;
3551 while (keep_processing_events
)
3553 /* Any events already waiting in the queue? */
3554 int res
= gdb_do_one_event ();
3556 /* Was there an error? */
3561 /* We are done with the event loop. There are no more event sources
3562 to listen to. So we exit gdbserver. */
3566 kill_inferior_callback (process_info
*process
)
3568 kill_inferior (process
);
3569 discard_queued_stop_replies (ptid_t (process
->pid
));
3572 /* Call this when exiting gdbserver with possible inferiors that need
3573 to be killed or detached from. */
3576 detach_or_kill_for_exit (void)
3578 /* First print a list of the inferiors we will be killing/detaching.
3579 This is to assist the user, for example, in case the inferior unexpectedly
3580 dies after we exit: did we screw up or did the inferior exit on its own?
3581 Having this info will save some head-scratching. */
3583 if (have_started_inferiors_p ())
3585 fprintf (stderr
, "Killing process(es):");
3587 for_each_process ([] (process_info
*process
) {
3588 if (!process
->attached
)
3589 fprintf (stderr
, " %d", process
->pid
);
3592 fprintf (stderr
, "\n");
3594 if (have_attached_inferiors_p ())
3596 fprintf (stderr
, "Detaching process(es):");
3598 for_each_process ([] (process_info
*process
) {
3599 if (process
->attached
)
3600 fprintf (stderr
, " %d", process
->pid
);
3603 fprintf (stderr
, "\n");
3606 /* Now we can kill or detach the inferiors. */
3607 for_each_process ([] (process_info
*process
) {
3608 int pid
= process
->pid
;
3610 if (process
->attached
)
3611 detach_inferior (process
);
3613 kill_inferior (process
);
3615 discard_queued_stop_replies (ptid_t (pid
));
3619 /* Value that will be passed to exit(3) when gdbserver exits. */
3620 static int exit_code
;
3622 /* Wrapper for detach_or_kill_for_exit that catches and prints
3626 detach_or_kill_for_exit_cleanup ()
3630 detach_or_kill_for_exit ();
3632 catch (const gdb_exception
&exception
)
3635 fprintf (stderr
, "Detach or kill failed: %s\n",
3643 namespace selftests
{
3646 test_memory_tagging_functions (void)
3648 /* Setup testing. */
3649 gdb::char_vector packet
;
3650 gdb::byte_vector tags
, bv
;
3651 std::string expected
;
3652 packet
.resize (32000);
3657 /* Test parsing a qMemTags request. */
3659 /* Valid request, addr, len and type updated. */
3663 strcpy (packet
.data (), "qMemTags:0,0:0");
3664 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3665 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0);
3667 /* Valid request, addr, len and type updated. */
3671 strcpy (packet
.data (), "qMemTags:deadbeef,ff:5");
3672 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3673 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5);
3675 /* Test creating a qMemTags reply. */
3677 /* Non-empty tag data. */
3680 for (int i
= 0; i
< 5; i
++)
3683 expected
= "m0001020304";
3684 SELF_CHECK (create_fetch_memtags_reply (packet
.data (), bv
) == true);
3685 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
3687 /* Test parsing a QMemTags request. */
3689 /* Valid request and empty tag data: addr, len, type and tags updated. */
3694 strcpy (packet
.data (), "QMemTags:0,0:0:");
3695 SELF_CHECK (parse_store_memtags_request (packet
.data (),
3696 &addr
, &len
, tags
, &type
) == true);
3697 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0 && tags
.size () == 0);
3699 /* Valid request and non-empty tag data: addr, len, type
3700 and tags updated. */
3705 strcpy (packet
.data (),
3706 "QMemTags:deadbeef,ff:5:0001020304");
3707 SELF_CHECK (parse_store_memtags_request (packet
.data (), &addr
, &len
, tags
,
3709 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5
3710 && tags
.size () == 5);
3713 } // namespace selftests
3714 #endif /* GDB_SELF_TEST */
3716 /* Main function. This is called by the real "main" function,
3717 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3719 static void ATTRIBUTE_NORETURN
3720 captured_main (int argc
, char *argv
[])
3725 const char *port
= NULL
;
3726 char **next_arg
= &argv
[1];
3727 volatile int multi_mode
= 0;
3728 volatile int attach
= 0;
3730 bool selftest
= false;
3732 std::vector
<const char *> selftest_filters
;
3734 selftests::register_test ("remote_memory_tagging",
3735 selftests::test_memory_tagging_functions
);
3738 current_directory
= getcwd (NULL
, 0);
3739 client_state
&cs
= get_client_state ();
3741 if (current_directory
== NULL
)
3743 error (_("Could not find current working directory: %s"),
3744 safe_strerror (errno
));
3747 while (*next_arg
!= NULL
&& **next_arg
== '-')
3749 if (strcmp (*next_arg
, "--version") == 0)
3751 gdbserver_version ();
3754 else if (strcmp (*next_arg
, "--help") == 0)
3756 gdbserver_usage (stdout
);
3759 else if (strcmp (*next_arg
, "--attach") == 0)
3761 else if (strcmp (*next_arg
, "--multi") == 0)
3763 else if (strcmp (*next_arg
, "--wrapper") == 0)
3770 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3772 wrapper_argv
+= *next_arg
;
3773 wrapper_argv
+= ' ';
3777 if (!wrapper_argv
.empty ())
3779 /* Erase the last whitespace. */
3780 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3783 if (next_arg
== tmp
|| *next_arg
== NULL
)
3785 gdbserver_usage (stderr
);
3789 /* Consume the "--". */
3792 else if (strcmp (*next_arg
, "--debug") == 0)
3794 else if (startswith (*next_arg
, "--debug-format="))
3796 std::string error_msg
3797 = parse_debug_format_options ((*next_arg
)
3798 + sizeof ("--debug-format=") - 1, 0);
3800 if (!error_msg
.empty ())
3802 fprintf (stderr
, "%s", error_msg
.c_str ());
3806 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3808 else if (strcmp (*next_arg
, "--event-loop-debug") == 0)
3809 debug_event_loop
= debug_event_loop_kind::ALL
;
3810 else if (startswith (*next_arg
, "--debug-file="))
3811 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3812 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3814 gdbserver_show_disableable (stdout
);
3817 else if (startswith (*next_arg
, "--disable-packet="))
3819 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3821 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3823 tok
= strtok_r (NULL
, ",", &saveptr
))
3825 if (strcmp ("vCont", tok
) == 0)
3826 disable_packet_vCont
= true;
3827 else if (strcmp ("Tthread", tok
) == 0)
3828 disable_packet_Tthread
= true;
3829 else if (strcmp ("qC", tok
) == 0)
3830 disable_packet_qC
= true;
3831 else if (strcmp ("qfThreadInfo", tok
) == 0)
3832 disable_packet_qfThreadInfo
= true;
3833 else if (strcmp ("T", tok
) == 0)
3834 disable_packet_T
= true;
3835 else if (strcmp ("threads", tok
) == 0)
3837 disable_packet_vCont
= true;
3838 disable_packet_Tthread
= true;
3839 disable_packet_qC
= true;
3840 disable_packet_qfThreadInfo
= true;
3844 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3846 gdbserver_show_disableable (stderr
);
3851 else if (strcmp (*next_arg
, "-") == 0)
3853 /* "-" specifies a stdio connection and is a form of port
3855 port
= STDIO_CONNECTION_NAME
;
3859 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3860 cs
.disable_randomization
= 1;
3861 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3862 cs
.disable_randomization
= 0;
3863 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3864 startup_with_shell
= true;
3865 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3866 startup_with_shell
= false;
3867 else if (strcmp (*next_arg
, "--once") == 0)
3869 else if (strcmp (*next_arg
, "--selftest") == 0)
3871 else if (startswith (*next_arg
, "--selftest="))
3876 const char *filter
= *next_arg
+ strlen ("--selftest=");
3877 if (*filter
== '\0')
3879 fprintf (stderr
, _("Error: selftest filter is empty.\n"));
3883 selftest_filters
.push_back (filter
);
3888 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3901 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3904 gdbserver_usage (stderr
);
3908 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3909 opened by remote_prepare. */
3912 save_original_signals_state (false);
3914 /* We need to know whether the remote connection is stdio before
3915 starting the inferior. Inferiors created in this scenario have
3916 stdin,stdout redirected. So do this here before we call
3919 remote_prepare (port
);
3924 /* --attach used to come after PORT, so allow it there for
3926 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3933 && (*next_arg
== NULL
3934 || (*next_arg
)[0] == '\0'
3935 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3937 || next_arg
[1] != NULL
))
3942 gdbserver_usage (stderr
);
3946 /* Gather information about the environment. */
3947 our_environ
= gdb_environ::from_host_environ ();
3949 initialize_async_io ();
3951 have_job_control ();
3952 if (target_supports_tracepoints ())
3953 initialize_tracepoint ();
3955 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3960 selftests::run_tests (selftest_filters
);
3962 printf (_("Selftests have been disabled for this build.\n"));
3964 throw_quit ("Quit");
3967 if (pid
== 0 && *next_arg
!= NULL
)
3971 n
= argc
- (next_arg
- argv
);
3972 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3973 for (i
= 1; i
< n
; i
++)
3974 program_args
.push_back (xstrdup (next_arg
[i
]));
3976 /* Wait till we are at first instruction in program. */
3977 target_create_inferior (program_path
.get (), program_args
);
3979 /* We are now (hopefully) stopped at the first instruction of
3980 the target process. This assumes that the target process was
3981 successfully created. */
3985 if (attach_inferior (pid
) == -1)
3986 error ("Attaching not supported on this target");
3988 /* Otherwise succeeded. */
3992 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3993 cs
.last_status
.value
.integer
= 0;
3994 cs
.last_ptid
= minus_one_ptid
;
3997 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3999 /* Don't report shared library events on the initial connection,
4000 even if some libraries are preloaded. Avoids the "stopped by
4001 shared library event" notice on gdb side. */
4002 if (current_thread
!= nullptr)
4003 current_process ()->dlls_changed
= false;
4005 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4006 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4011 if (!was_running
&& !multi_mode
)
4012 error ("No program to debug");
4017 cs
.multi_process
= 0;
4018 cs
.report_fork_events
= 0;
4019 cs
.report_vfork_events
= 0;
4020 cs
.report_exec_events
= 0;
4021 /* Be sure we're out of tfind mode. */
4022 cs
.current_traceframe
= -1;
4023 cs
.cont_thread
= null_ptid
;
4024 cs
.swbreak_feature
= 0;
4025 cs
.hwbreak_feature
= 0;
4026 cs
.vCont_supported
= 0;
4027 cs
.memory_tagging_feature
= false;
4033 /* Wait for events. This will return when all event sources
4034 are removed from the event loop. */
4035 start_event_loop ();
4037 /* If an exit was requested (using the "monitor exit"
4038 command), terminate now. */
4040 throw_quit ("Quit");
4042 /* The only other way to get here is for getpkt to fail:
4044 - If --once was specified, we're done.
4046 - If not in extended-remote mode, and we're no longer
4047 debugging anything, simply exit: GDB has disconnected
4048 after processing the last process exit.
4050 - Otherwise, close the connection and reopen it at the
4052 if (run_once
|| (!extended_protocol
&& !target_running ()))
4053 throw_quit ("Quit");
4056 "Remote side has terminated connection. "
4057 "GDBserver will reopen the connection.\n");
4059 /* Get rid of any pending statuses. An eventual reconnection
4060 (by the same GDB instance or another) will refresh all its
4061 state from scratch. */
4062 discard_queued_stop_replies (minus_one_ptid
);
4063 for_each_thread ([] (thread_info
*thread
)
4065 thread
->status_pending_p
= 0;
4070 if (disconnected_tracing
)
4072 /* Try to enable non-stop/async mode, so we we can
4073 both wait for an async socket accept, and handle
4074 async target events simultaneously. There's also
4075 no point either in having the target always stop
4076 all threads, when we're going to pass signals
4077 down without informing GDB. */
4080 if (the_target
->start_non_stop (true))
4083 /* Detaching implicitly resumes all threads;
4084 simply disconnecting does not. */
4090 "Disconnected tracing disabled; "
4091 "stopping trace run.\n");
4096 catch (const gdb_exception_error
&exception
)
4099 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
4101 if (response_needed
)
4103 write_enn (cs
.own_buf
);
4104 putpkt (cs
.own_buf
);
4108 throw_quit ("Quit");
4113 /* Main function. */
4116 main (int argc
, char *argv
[])
4121 captured_main (argc
, argv
);
4123 catch (const gdb_exception
&exception
)
4125 if (exception
.reason
== RETURN_ERROR
)
4128 fprintf (stderr
, "%s\n", exception
.what ());
4129 fprintf (stderr
, "Exiting\n");
4136 gdb_assert_not_reached ("captured_main should never return");
4139 /* Process options coming from Z packets for a breakpoint. PACKET is
4140 the packet buffer. *PACKET is updated to point to the first char
4141 after the last processed option. */
4144 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4146 const char *dataptr
= *packet
;
4149 /* Check if data has the correct format. */
4150 if (*dataptr
!= ';')
4157 if (*dataptr
== ';')
4160 if (*dataptr
== 'X')
4162 /* Conditional expression. */
4164 debug_printf ("Found breakpoint condition.\n");
4165 if (!add_breakpoint_condition (bp
, &dataptr
))
4166 dataptr
= strchrnul (dataptr
, ';');
4168 else if (startswith (dataptr
, "cmds:"))
4170 dataptr
+= strlen ("cmds:");
4172 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4173 persist
= (*dataptr
== '1');
4175 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4176 dataptr
= strchrnul (dataptr
, ';');
4180 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4182 /* Skip tokens until we find one that we recognize. */
4183 dataptr
= strchrnul (dataptr
, ';');
4189 /* Event loop callback that handles a serial event. The first byte in
4190 the serial buffer gets us here. We expect characters to arrive at
4191 a brisk pace, so we read the rest of the packet with a blocking
4195 process_serial_event (void)
4197 client_state
&cs
= get_client_state ();
4203 int new_packet_len
= -1;
4205 disable_async_io ();
4207 response_needed
= false;
4208 packet_len
= getpkt (cs
.own_buf
);
4209 if (packet_len
<= 0)
4212 /* Force an event loop break. */
4215 response_needed
= true;
4217 char ch
= cs
.own_buf
[0];
4221 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4224 handle_general_set (cs
.own_buf
);
4227 handle_detach (cs
.own_buf
);
4230 extended_protocol
= true;
4231 write_ok (cs
.own_buf
);
4234 handle_status (cs
.own_buf
);
4237 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4239 require_running_or_break (cs
.own_buf
);
4241 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4243 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4244 thread_id
= null_ptid
;
4245 else if (thread_id
.is_pid ())
4247 /* The ptid represents a pid. */
4248 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4252 write_enn (cs
.own_buf
);
4256 thread_id
= thread
->id
;
4260 /* The ptid represents a lwp/tid. */
4261 if (find_thread_ptid (thread_id
) == NULL
)
4263 write_enn (cs
.own_buf
);
4268 if (cs
.own_buf
[1] == 'g')
4270 if (thread_id
== null_ptid
)
4272 /* GDB is telling us to choose any thread. Check if
4273 the currently selected thread is still valid. If
4274 it is not, select the first available. */
4275 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4277 thread
= get_first_thread ();
4278 thread_id
= thread
->id
;
4281 cs
.general_thread
= thread_id
;
4282 set_desired_thread ();
4283 gdb_assert (current_thread
!= NULL
);
4285 else if (cs
.own_buf
[1] == 'c')
4286 cs
.cont_thread
= thread_id
;
4288 write_ok (cs
.own_buf
);
4292 /* Silently ignore it so that gdb can extend the protocol
4293 without compatibility headaches. */
4294 cs
.own_buf
[0] = '\0';
4298 require_running_or_break (cs
.own_buf
);
4299 if (cs
.current_traceframe
>= 0)
4301 struct regcache
*regcache
4302 = new_register_cache (current_target_desc ());
4304 if (fetch_traceframe_registers (cs
.current_traceframe
,
4306 registers_to_string (regcache
, cs
.own_buf
);
4308 write_enn (cs
.own_buf
);
4309 free_register_cache (regcache
);
4313 struct regcache
*regcache
;
4315 if (!set_desired_thread ())
4316 write_enn (cs
.own_buf
);
4319 regcache
= get_thread_regcache (current_thread
, 1);
4320 registers_to_string (regcache
, cs
.own_buf
);
4325 require_running_or_break (cs
.own_buf
);
4326 if (cs
.current_traceframe
>= 0)
4327 write_enn (cs
.own_buf
);
4330 struct regcache
*regcache
;
4332 if (!set_desired_thread ())
4333 write_enn (cs
.own_buf
);
4336 regcache
= get_thread_regcache (current_thread
, 1);
4337 registers_from_string (regcache
, &cs
.own_buf
[1]);
4338 write_ok (cs
.own_buf
);
4344 require_running_or_break (cs
.own_buf
);
4345 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4346 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4348 write_enn (cs
.own_buf
);
4350 bin2hex (mem_buf
, cs
.own_buf
, res
);
4354 require_running_or_break (cs
.own_buf
);
4355 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4356 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4357 write_ok (cs
.own_buf
);
4359 write_enn (cs
.own_buf
);
4362 require_running_or_break (cs
.own_buf
);
4363 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4364 &mem_addr
, &len
, &mem_buf
) < 0
4365 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4366 write_enn (cs
.own_buf
);
4368 write_ok (cs
.own_buf
);
4371 require_running_or_break (cs
.own_buf
);
4372 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4373 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4374 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4377 myresume (cs
.own_buf
, 0, signal
);
4380 require_running_or_break (cs
.own_buf
);
4381 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4382 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4383 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4386 myresume (cs
.own_buf
, 1, signal
);
4389 require_running_or_break (cs
.own_buf
);
4391 myresume (cs
.own_buf
, 0, signal
);
4394 require_running_or_break (cs
.own_buf
);
4396 myresume (cs
.own_buf
, 1, signal
);
4398 case 'Z': /* insert_ ... */
4400 case 'z': /* remove_ ... */
4405 char type
= cs
.own_buf
[1];
4407 const int insert
= ch
== 'Z';
4408 const char *p
= &cs
.own_buf
[3];
4410 p
= unpack_varlen_hex (p
, &addr
);
4411 kind
= strtol (p
+ 1, &dataptr
, 16);
4415 struct gdb_breakpoint
*bp
;
4417 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4422 /* GDB may have sent us a list of *point parameters to
4423 be evaluated on the target's side. Read such list
4424 here. If we already have a list of parameters, GDB
4425 is telling us to drop that list and use this one
4427 clear_breakpoint_conditions_and_commands (bp
);
4428 const char *options
= dataptr
;
4429 process_point_options (bp
, &options
);
4433 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4436 write_ok (cs
.own_buf
);
4439 cs
.own_buf
[0] = '\0';
4441 write_enn (cs
.own_buf
);
4445 response_needed
= false;
4446 if (!target_running ())
4447 /* The packet we received doesn't make sense - but we can't
4448 reply to it, either. */
4451 fprintf (stderr
, "Killing all inferiors\n");
4453 for_each_process (kill_inferior_callback
);
4455 /* When using the extended protocol, we wait with no program
4456 running. The traditional protocol will exit instead. */
4457 if (extended_protocol
)
4459 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4460 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4468 require_running_or_break (cs
.own_buf
);
4470 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4471 if (find_thread_ptid (thread_id
) == NULL
)
4473 write_enn (cs
.own_buf
);
4477 if (mythread_alive (thread_id
))
4478 write_ok (cs
.own_buf
);
4480 write_enn (cs
.own_buf
);
4484 response_needed
= false;
4486 /* Restarting the inferior is only supported in the extended
4488 if (extended_protocol
)
4490 if (target_running ())
4491 for_each_process (kill_inferior_callback
);
4493 fprintf (stderr
, "GDBserver restarting\n");
4495 /* Wait till we are at 1st instruction in prog. */
4496 if (program_path
.get () != NULL
)
4498 target_create_inferior (program_path
.get (), program_args
);
4500 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4502 /* Stopped at the first instruction of the target
4504 cs
.general_thread
= cs
.last_ptid
;
4508 /* Something went wrong. */
4509 cs
.general_thread
= null_ptid
;
4514 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4515 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4521 /* It is a request we don't understand. Respond with an
4522 empty packet so that gdb knows that we don't support this
4524 cs
.own_buf
[0] = '\0';
4528 /* Extended (long) request. */
4529 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4533 /* It is a request we don't understand. Respond with an empty
4534 packet so that gdb knows that we don't support this
4536 cs
.own_buf
[0] = '\0';
4540 if (new_packet_len
!= -1)
4541 putpkt_binary (cs
.own_buf
, new_packet_len
);
4543 putpkt (cs
.own_buf
);
4545 response_needed
= false;
4553 /* Event-loop callback for serial events. */
4556 handle_serial_event (int err
, gdb_client_data client_data
)
4559 debug_printf ("handling possible serial event\n");
4561 /* Really handle it. */
4562 if (process_serial_event () < 0)
4564 keep_processing_events
= false;
4568 /* Be sure to not change the selected thread behind GDB's back.
4569 Important in the non-stop mode asynchronous protocol. */
4570 set_desired_thread ();
4573 /* Push a stop notification on the notification queue. */
4576 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4578 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4580 vstop_notif
->status
= *status
;
4581 vstop_notif
->ptid
= ptid
;
4582 /* Push Stop notification. */
4583 notif_push (¬if_stop
, vstop_notif
);
4586 /* Event-loop callback for target events. */
4589 handle_target_event (int err
, gdb_client_data client_data
)
4591 client_state
&cs
= get_client_state ();
4593 debug_printf ("handling possible target event\n");
4595 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4598 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4600 if (gdb_connected () && report_no_resumed
)
4601 push_stop_notification (null_ptid
, &cs
.last_status
);
4603 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4605 int pid
= cs
.last_ptid
.pid ();
4606 struct process_info
*process
= find_process_pid (pid
);
4607 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4609 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4610 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4612 mark_breakpoints_out (process
);
4613 target_mourn_inferior (cs
.last_ptid
);
4615 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4619 /* We're reporting this thread as stopped. Update its
4620 "want-stopped" state to what the client wants, until it
4621 gets a new resume action. */
4622 current_thread
->last_resume_kind
= resume_stop
;
4623 current_thread
->last_status
= cs
.last_status
;
4628 if (!target_running ())
4630 /* The last process exited. We're done. */
4634 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4635 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4636 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4640 /* A thread stopped with a signal, but gdb isn't
4641 connected to handle it. Pass it down to the
4642 inferior, as if it wasn't being traced. */
4643 enum gdb_signal signal
;
4646 debug_printf ("GDB not connected; forwarding event %d for"
4648 (int) cs
.last_status
.kind
,
4649 target_pid_to_str (cs
.last_ptid
));
4651 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4652 signal
= cs
.last_status
.value
.sig
;
4654 signal
= GDB_SIGNAL_0
;
4655 target_continue (cs
.last_ptid
, signal
);
4659 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4662 /* Be sure to not change the selected thread behind GDB's back.
4663 Important in the non-stop mode asynchronous protocol. */
4664 set_desired_thread ();
4667 /* See gdbsupport/event-loop.h. */
4670 invoke_async_signal_handlers ()
4675 /* See gdbsupport/event-loop.h. */
4678 check_async_event_handlers ()
4683 /* See gdbsupport/errors.h */
4692 /* See gdbsupport/gdb_select.h. */
4695 gdb_select (int n
, fd_set
*readfds
, fd_set
*writefds
,
4696 fd_set
*exceptfds
, struct timeval
*timeout
)
4698 return select (n
, readfds
, writefds
, exceptfds
, timeout
);
4709 } // namespace selftests
4710 #endif /* GDB_SELF_TEST */