1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2023 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 /* PBUFSIZ must also be at least as big as IPA_CMD_BUF_SIZE, because
55 the client state data is passed directly to some agent
57 gdb_static_assert (PBUFSIZ
>= IPA_CMD_BUF_SIZE
);
59 #define require_running_or_return(BUF) \
60 if (!target_running ()) \
66 #define require_running_or_break(BUF) \
67 if (!target_running ()) \
73 /* The environment to pass to the inferior when creating it. */
75 static gdb_environ our_environ
;
79 static bool extended_protocol
;
80 static bool response_needed
;
81 static bool exit_requested
;
83 /* --once: Exit after the first connection has closed. */
86 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
87 static bool report_no_resumed
;
89 /* The event loop checks this to decide whether to continue accepting
91 static bool keep_processing_events
= true;
96 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
98 void set (const char *path
)
102 /* Make sure we're using the absolute path of the inferior when
104 if (!contains_dir_separator (m_path
.c_str ()))
108 /* Check if the file is in our CWD. If it is, then we prefix
109 its name with CURRENT_DIRECTORY. Otherwise, we leave the
110 name as-is because we'll try searching for it in $PATH. */
111 if (is_regular_file (m_path
.c_str (), ®_file_errno
))
112 m_path
= gdb_abspath (m_path
.c_str ());
116 /* Return the PROGRAM_PATH. */
118 { return m_path
.empty () ? nullptr : m_path
.c_str (); }
121 /* The program name, adjusted if needed. */
124 static std::vector
<char *> program_args
;
125 static std::string wrapper_argv
;
127 /* The PID of the originally created or attached inferior. Used to
128 send signals to the process when GDB sends us an asynchronous interrupt
129 (user hitting Control-C in the client), and to wait for the child to exit
130 when no longer debugging it. */
132 unsigned long signal_pid
;
134 /* Set if you want to disable optional thread related packets support
135 in gdbserver, for the sake of testing GDB against stubs that don't
137 bool disable_packet_vCont
;
138 bool disable_packet_Tthread
;
139 bool disable_packet_qC
;
140 bool disable_packet_qfThreadInfo
;
141 bool disable_packet_T
;
143 static unsigned char *mem_buf
;
145 /* A sub-class of 'struct notif_event' for stop, holding information
146 relative to a single stop reply. We keep a queue of these to
147 push to GDB in non-stop mode. */
149 struct vstop_notif
: public notif_event
151 /* Thread or process that got the event. */
155 struct target_waitstatus status
;
158 /* The current btrace configuration. This is gdbserver's mirror of GDB's
159 btrace configuration. */
160 static struct btrace_config current_btrace_conf
;
162 /* The client remote protocol state. */
164 static client_state g_client_state
;
169 client_state
&cs
= g_client_state
;
174 /* Put a stop reply to the stop reply queue. */
177 queue_stop_reply (ptid_t ptid
, const target_waitstatus
&status
)
179 struct vstop_notif
*new_notif
= new struct vstop_notif
;
181 new_notif
->ptid
= ptid
;
182 new_notif
->status
= status
;
184 notif_event_enque (¬if_stop
, new_notif
);
188 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
190 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
192 return vstop_event
->ptid
.matches (filter_ptid
);
198 discard_queued_stop_replies (ptid_t ptid
)
200 std::list
<notif_event
*>::iterator iter
, next
, end
;
201 end
= notif_stop
.queue
.end ();
202 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
207 if (iter
== notif_stop
.queue
.begin ())
209 /* The head of the list contains the notification that was
210 already sent to GDB. So we can't remove it, otherwise
211 when GDB sends the vStopped, it would ack the _next_
212 notification, which hadn't been sent yet! */
216 if (remove_all_on_match_ptid (*iter
, ptid
))
219 notif_stop
.queue
.erase (iter
);
225 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
227 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
229 prepare_resume_reply (own_buf
, vstop
->ptid
, vstop
->status
);
232 /* Helper for in_queued_stop_replies. */
235 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
237 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
239 if (vstop_event
->ptid
.matches (filter_ptid
))
242 /* Don't resume fork children that GDB does not know about yet. */
243 if ((vstop_event
->status
.kind () == TARGET_WAITKIND_FORKED
244 || vstop_event
->status
.kind () == TARGET_WAITKIND_VFORKED
)
245 && vstop_event
->status
.child_ptid ().matches (filter_ptid
))
254 in_queued_stop_replies (ptid_t ptid
)
256 for (notif_event
*event
: notif_stop
.queue
)
258 if (in_queued_stop_replies_ptid (event
, ptid
))
265 struct notif_server notif_stop
=
267 "vStopped", "Stop", {}, vstop_notif_reply
,
271 target_running (void)
273 return get_first_thread () != NULL
;
276 /* See gdbsupport/common-inferior.h. */
281 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
284 /* See gdbsupport/common-inferior.h. */
287 get_exec_file (int err
)
289 if (err
&& program_path
.get () == NULL
)
290 error (_("No executable file specified."));
292 return program_path
.get ();
304 attach_inferior (int pid
)
306 client_state
&cs
= get_client_state ();
307 /* myattach should return -1 if attaching is unsupported,
308 0 if it succeeded, and call error() otherwise. */
310 if (find_process_pid (pid
) != nullptr)
311 error ("Already attached to process %d\n", pid
);
313 if (myattach (pid
) != 0)
316 fprintf (stderr
, "Attached; pid = %d\n", pid
);
319 /* FIXME - It may be that we should get the SIGNAL_PID from the
320 attach function, so that it can be the main thread instead of
321 whichever we were told to attach to. */
326 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
328 /* GDB knows to ignore the first SIGSTOP after attaching to a running
329 process using the "attach" command, but this is different; it's
330 just using "target remote". Pretend it's just starting up. */
331 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
332 && cs
.last_status
.sig () == GDB_SIGNAL_STOP
)
333 cs
.last_status
.set_stopped (GDB_SIGNAL_TRAP
);
335 current_thread
->last_resume_kind
= resume_stop
;
336 current_thread
->last_status
= cs
.last_status
;
342 /* Decode a qXfer read request. Return 0 if everything looks OK,
346 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
348 /* After the read marker and annex, qXfer looks like a
349 traditional 'm' packet. */
350 decode_m_packet (buf
, ofs
, len
);
356 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
358 /* Extract and NUL-terminate the object. */
360 while (*buf
&& *buf
!= ':')
366 /* Extract and NUL-terminate the read/write action. */
368 while (*buf
&& *buf
!= ':')
374 /* Extract and NUL-terminate the annex. */
376 while (*buf
&& *buf
!= ':')
386 /* Write the response to a successful qXfer read. Returns the
387 length of the (binary) data stored in BUF, corresponding
388 to as much of DATA/LEN as we could fit. IS_MORE controls
389 the first character of the response. */
391 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
400 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
401 &out_len
, PBUFSIZ
- 2) + 1;
404 /* Handle btrace enabling in BTS format. */
407 handle_btrace_enable_bts (struct thread_info
*thread
)
409 if (thread
->btrace
!= NULL
)
410 error (_("Btrace already enabled."));
412 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
413 thread
->btrace
= target_enable_btrace (thread
, ¤t_btrace_conf
);
416 /* Handle btrace enabling in Intel Processor Trace format. */
419 handle_btrace_enable_pt (struct thread_info
*thread
)
421 if (thread
->btrace
!= NULL
)
422 error (_("Btrace already enabled."));
424 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
425 thread
->btrace
= target_enable_btrace (thread
, ¤t_btrace_conf
);
428 /* Handle btrace disabling. */
431 handle_btrace_disable (struct thread_info
*thread
)
434 if (thread
->btrace
== NULL
)
435 error (_("Branch tracing not enabled."));
437 if (target_disable_btrace (thread
->btrace
) != 0)
438 error (_("Could not disable branch tracing."));
440 thread
->btrace
= NULL
;
443 /* Handle the "Qbtrace" packet. */
446 handle_btrace_general_set (char *own_buf
)
448 client_state
&cs
= get_client_state ();
449 struct thread_info
*thread
;
452 if (!startswith (own_buf
, "Qbtrace:"))
455 op
= own_buf
+ strlen ("Qbtrace:");
457 if (cs
.general_thread
== null_ptid
458 || cs
.general_thread
== minus_one_ptid
)
460 strcpy (own_buf
, "E.Must select a single thread.");
464 thread
= find_thread_ptid (cs
.general_thread
);
467 strcpy (own_buf
, "E.No such thread.");
473 if (strcmp (op
, "bts") == 0)
474 handle_btrace_enable_bts (thread
);
475 else if (strcmp (op
, "pt") == 0)
476 handle_btrace_enable_pt (thread
);
477 else if (strcmp (op
, "off") == 0)
478 handle_btrace_disable (thread
);
480 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
484 catch (const gdb_exception_error
&exception
)
486 sprintf (own_buf
, "E.%s", exception
.what ());
492 /* Handle the "Qbtrace-conf" packet. */
495 handle_btrace_conf_general_set (char *own_buf
)
497 client_state
&cs
= get_client_state ();
498 struct thread_info
*thread
;
501 if (!startswith (own_buf
, "Qbtrace-conf:"))
504 op
= own_buf
+ strlen ("Qbtrace-conf:");
506 if (cs
.general_thread
== null_ptid
507 || cs
.general_thread
== minus_one_ptid
)
509 strcpy (own_buf
, "E.Must select a single thread.");
513 thread
= find_thread_ptid (cs
.general_thread
);
516 strcpy (own_buf
, "E.No such thread.");
520 if (startswith (op
, "bts:size="))
526 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
527 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
529 strcpy (own_buf
, "E.Bad size value.");
533 current_btrace_conf
.bts
.size
= (unsigned int) size
;
535 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
541 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
542 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
544 strcpy (own_buf
, "E.Bad size value.");
548 current_btrace_conf
.pt
.size
= (unsigned int) size
;
552 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
560 /* Create the qMemTags packet reply given TAGS.
562 Returns true if parsing succeeded and false otherwise. */
565 create_fetch_memtags_reply (char *reply
, const gdb::byte_vector
&tags
)
567 /* It is an error to pass a zero-sized tag vector. */
568 gdb_assert (tags
.size () != 0);
570 std::string
packet ("m");
572 /* Write the tag data. */
573 packet
+= bin2hex (tags
.data (), tags
.size ());
575 /* Check if the reply is too big for the packet to handle. */
576 if (PBUFSIZ
< packet
.size ())
579 strcpy (reply
, packet
.c_str ());
583 /* Parse the QMemTags request into ADDR, LEN and TAGS.
585 Returns true if parsing succeeded and false otherwise. */
588 parse_store_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
589 gdb::byte_vector
&tags
, int *type
)
591 gdb_assert (startswith (request
, "QMemTags:"));
593 const char *p
= request
+ strlen ("QMemTags:");
595 /* Read address and length. */
596 unsigned int length
= 0;
597 p
= decode_m_packet_params (p
, addr
, &length
, ':');
600 /* Read the tag type. */
601 ULONGEST tag_type
= 0;
602 p
= unpack_varlen_hex (p
, &tag_type
);
603 *type
= (int) tag_type
;
605 /* Make sure there is a colon after the type. */
609 /* Skip the colon. */
612 /* Read the tag data. */
618 /* Handle all of the extended 'Q' packets. */
621 handle_general_set (char *own_buf
)
623 client_state
&cs
= get_client_state ();
624 if (startswith (own_buf
, "QPassSignals:"))
626 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
627 const char *p
= own_buf
+ strlen ("QPassSignals:");
630 p
= decode_address_to_semicolon (&cursig
, p
);
631 for (i
= 0; i
< numsigs
; i
++)
635 cs
.pass_signals
[i
] = 1;
637 /* Keep looping, to clear the remaining signals. */
640 p
= decode_address_to_semicolon (&cursig
, p
);
643 cs
.pass_signals
[i
] = 0;
645 strcpy (own_buf
, "OK");
649 if (startswith (own_buf
, "QProgramSignals:"))
651 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
652 const char *p
= own_buf
+ strlen ("QProgramSignals:");
655 cs
.program_signals_p
= 1;
657 p
= decode_address_to_semicolon (&cursig
, p
);
658 for (i
= 0; i
< numsigs
; i
++)
662 cs
.program_signals
[i
] = 1;
664 /* Keep looping, to clear the remaining signals. */
667 p
= decode_address_to_semicolon (&cursig
, p
);
670 cs
.program_signals
[i
] = 0;
672 strcpy (own_buf
, "OK");
676 if (startswith (own_buf
, "QCatchSyscalls:"))
678 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
681 struct process_info
*process
;
683 if (!target_running () || !target_supports_catch_syscall ())
689 if (strcmp (p
, "0") == 0)
691 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
695 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
701 process
= current_process ();
702 process
->syscalls_to_catch
.clear ();
712 p
= decode_address_to_semicolon (&sysno
, p
);
713 process
->syscalls_to_catch
.push_back (sysno
);
717 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
724 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
726 our_environ
= gdb_environ::from_host_environ ();
732 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
734 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
735 /* The final form of the environment variable. FINAL_VAR will
736 hold the 'VAR=VALUE' format. */
737 std::string final_var
= hex2str (p
);
738 std::string var_name
, var_value
;
740 remote_debug_printf ("[QEnvironmentHexEncoded received '%s']", p
);
741 remote_debug_printf ("[Environment variable to be set: '%s']",
744 size_t pos
= final_var
.find ('=');
745 if (pos
== std::string::npos
)
747 warning (_("Unexpected format for environment variable: '%s'"),
753 var_name
= final_var
.substr (0, pos
);
754 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
756 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
762 if (startswith (own_buf
, "QEnvironmentUnset:"))
764 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
765 std::string varname
= hex2str (p
);
767 remote_debug_printf ("[QEnvironmentUnset received '%s']", p
);
768 remote_debug_printf ("[Environment variable to be unset: '%s']",
771 our_environ
.unset (varname
.c_str ());
777 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
779 remote_debug_printf ("[noack mode enabled]");
786 if (startswith (own_buf
, "QNonStop:"))
788 char *mode
= own_buf
+ 9;
792 if (strcmp (mode
, "0") == 0)
794 else if (strcmp (mode
, "1") == 0)
798 /* We don't know what this mode is, so complain to
800 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
806 req_str
= req
? "non-stop" : "all-stop";
807 if (the_target
->start_non_stop (req
== 1) != 0)
809 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
814 non_stop
= (req
!= 0);
816 remote_debug_printf ("[%s mode enabled]", req_str
);
822 if (startswith (own_buf
, "QDisableRandomization:"))
824 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
827 unpack_varlen_hex (packet
, &setting
);
828 cs
.disable_randomization
= setting
;
830 remote_debug_printf (cs
.disable_randomization
831 ? "[address space randomization disabled]"
832 : "[address space randomization enabled]");
838 if (target_supports_tracepoints ()
839 && handle_tracepoint_general_set (own_buf
))
842 if (startswith (own_buf
, "QAgent:"))
844 char *mode
= own_buf
+ strlen ("QAgent:");
847 if (strcmp (mode
, "0") == 0)
849 else if (strcmp (mode
, "1") == 0)
853 /* We don't know what this value is, so complain to GDB. */
854 sprintf (own_buf
, "E.Unknown QAgent value");
858 /* Update the flag. */
860 remote_debug_printf ("[%s agent]", req
? "Enable" : "Disable");
865 if (handle_btrace_general_set (own_buf
))
868 if (handle_btrace_conf_general_set (own_buf
))
871 if (startswith (own_buf
, "QThreadEvents:"))
873 char *mode
= own_buf
+ strlen ("QThreadEvents:");
874 enum tribool req
= TRIBOOL_UNKNOWN
;
876 if (strcmp (mode
, "0") == 0)
878 else if (strcmp (mode
, "1") == 0)
882 /* We don't know what this mode is, so complain to GDB. */
884 = string_printf ("E.Unknown thread-events mode requested: %s\n",
886 strcpy (own_buf
, err
.c_str ());
890 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
892 remote_debug_printf ("[thread events are now %s]\n",
893 cs
.report_thread_events
? "enabled" : "disabled");
899 if (startswith (own_buf
, "QStartupWithShell:"))
901 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
903 if (strcmp (value
, "1") == 0)
904 startup_with_shell
= true;
905 else if (strcmp (value
, "0") == 0)
906 startup_with_shell
= false;
910 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
916 remote_debug_printf ("[Inferior will %s started with shell]",
917 startup_with_shell
? "be" : "not be");
923 if (startswith (own_buf
, "QSetWorkingDir:"))
925 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
929 std::string path
= hex2str (p
);
931 remote_debug_printf ("[Set the inferior's current directory to %s]",
934 set_inferior_cwd (std::move (path
));
938 /* An empty argument means that we should clear out any
939 previously set cwd for the inferior. */
940 set_inferior_cwd ("");
942 remote_debug_printf ("[Unset the inferior's current directory; will "
943 "use gdbserver's cwd]");
951 /* Handle store memory tags packets. */
952 if (startswith (own_buf
, "QMemTags:")
953 && target_supports_memory_tagging ())
955 gdb::byte_vector tags
;
960 require_running_or_return (own_buf
);
962 bool ret
= parse_store_memtags_request (own_buf
, &addr
, &len
, tags
,
966 ret
= the_target
->store_memtags (addr
, len
, tags
, type
);
976 /* Otherwise we didn't know what packet it was. Say we didn't
982 get_features_xml (const char *annex
)
984 const struct target_desc
*desc
= current_target_desc ();
986 /* `desc->xmltarget' defines what to return when looking for the
987 "target.xml" file. Its contents can either be verbatim XML code
988 (prefixed with a '@') or else the name of the actual XML file to
989 be used in place of "target.xml".
991 This variable is set up from the auto-generated
992 init_registers_... routine for the current target. */
994 if (strcmp (annex
, "target.xml") == 0)
996 const char *ret
= tdesc_get_features_xml (desc
);
1008 /* Look for the annex. */
1009 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
1010 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
1013 if (xml_builtin
[i
][0] != NULL
)
1014 return xml_builtin
[i
][1];
1022 monitor_show_help (void)
1024 monitor_output ("The following monitor commands are supported:\n");
1025 monitor_output (" set debug <0|1>\n");
1026 monitor_output (" Enable general debugging messages\n");
1027 monitor_output (" set debug-hw-points <0|1>\n");
1028 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
1029 monitor_output (" set remote-debug <0|1>\n");
1030 monitor_output (" Enable remote protocol debugging messages\n");
1031 monitor_output (" set event-loop-debug <0|1>\n");
1032 monitor_output (" Enable event loop debugging messages\n");
1033 monitor_output (" set debug-format option1[,option2,...]\n");
1034 monitor_output (" Add additional information to debugging messages\n");
1035 monitor_output (" Options: all, none");
1036 monitor_output (", timestamp");
1037 monitor_output ("\n");
1038 monitor_output (" exit\n");
1039 monitor_output (" Quit GDBserver\n");
1042 /* Read trace frame or inferior memory. Returns the number of bytes
1043 actually read, zero when no further transfer is possible, and -1 on
1044 error. Return of a positive value smaller than LEN does not
1045 indicate there's no more to be read, only the end of the transfer.
1046 E.g., when GDB reads memory from a traceframe, a first request may
1047 be served from a memory block that does not cover the whole request
1048 length. A following request gets the rest served from either
1049 another block (of the same traceframe) or from the read-only
1053 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1055 client_state
&cs
= get_client_state ();
1058 if (cs
.current_traceframe
>= 0)
1061 ULONGEST length
= len
;
1063 if (traceframe_read_mem (cs
.current_traceframe
,
1064 memaddr
, myaddr
, len
, &nbytes
))
1066 /* Data read from trace buffer, we're done. */
1069 if (!in_readonly_region (memaddr
, length
))
1071 /* Otherwise we have a valid readonly case, fall through. */
1072 /* (assume no half-trace half-real blocks for now) */
1075 if (set_desired_process ())
1076 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1080 return res
== 0 ? len
: -1;
1083 /* Write trace frame or inferior memory. Actually, writing to trace
1084 frames is forbidden. */
1087 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1089 client_state
&cs
= get_client_state ();
1090 if (cs
.current_traceframe
>= 0)
1096 if (set_desired_process ())
1097 ret
= target_write_memory (memaddr
, myaddr
, len
);
1104 /* Handle qSearch:memory packets. */
1107 handle_search_memory (char *own_buf
, int packet_len
)
1109 CORE_ADDR start_addr
;
1110 CORE_ADDR search_space_len
;
1112 unsigned int pattern_len
;
1114 CORE_ADDR found_addr
;
1115 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1117 pattern
= (gdb_byte
*) malloc (packet_len
);
1118 if (pattern
== NULL
)
1119 error ("Unable to allocate memory to perform the search");
1121 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1122 packet_len
- cmd_name_len
,
1123 &start_addr
, &search_space_len
,
1124 pattern
, &pattern_len
) < 0)
1127 error ("Error in parsing qSearch:memory packet");
1130 auto read_memory
= [] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
1132 return gdb_read_memory (addr
, result
, len
) == len
;
1135 found
= simple_search_memory (read_memory
, start_addr
, search_space_len
,
1136 pattern
, pattern_len
, &found_addr
);
1139 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1140 else if (found
== 0)
1141 strcpy (own_buf
, "0");
1143 strcpy (own_buf
, "E00");
1148 /* Handle the "D" packet. */
1151 handle_detach (char *own_buf
)
1153 client_state
&cs
= get_client_state ();
1155 process_info
*process
;
1157 if (cs
.multi_process
)
1160 int pid
= strtol (&own_buf
[2], NULL
, 16);
1162 process
= find_process_pid (pid
);
1166 process
= (current_thread
!= nullptr
1167 ? get_thread_process (current_thread
)
1171 if (process
== NULL
)
1173 write_enn (own_buf
);
1177 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1179 if (tracing
&& disconnected_tracing
)
1181 "Disconnected tracing in effect, "
1182 "leaving gdbserver attached to the process\n");
1184 if (any_persistent_commands (process
))
1186 "Persistent commands are present, "
1187 "leaving gdbserver attached to the process\n");
1189 /* Make sure we're in non-stop/async mode, so we we can both
1190 wait for an async socket accept, and handle async target
1191 events simultaneously. There's also no point either in
1192 having the target stop all threads, when we're going to
1193 pass signals down without informing GDB. */
1196 threads_debug_printf ("Forcing non-stop mode");
1199 the_target
->start_non_stop (true);
1202 process
->gdb_detached
= 1;
1204 /* Detaching implicitly resumes all threads. */
1205 target_continue_no_signal (minus_one_ptid
);
1211 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1214 /* We'll need this after PROCESS has been destroyed. */
1215 int pid
= process
->pid
;
1217 /* If this process has an unreported fork child, that child is not known to
1218 GDB, so GDB won't take care of detaching it. We must do it here.
1220 Here, we specifically don't want to use "safe iteration", as detaching
1221 another process might delete the next thread in the iteration, which is
1222 the one saved by the safe iterator. We will never delete the currently
1223 iterated on thread, so standard iteration should be safe. */
1224 for (thread_info
*thread
: all_threads
)
1226 /* Only threads that are of the process we are detaching. */
1227 if (thread
->id
.pid () != pid
)
1230 /* Only threads that have a pending fork event. */
1231 thread_info
*child
= target_thread_pending_child (thread
);
1232 if (child
== nullptr)
1235 process_info
*fork_child_process
= get_thread_process (child
);
1236 gdb_assert (fork_child_process
!= nullptr);
1238 int fork_child_pid
= fork_child_process
->pid
;
1240 if (detach_inferior (fork_child_process
) != 0)
1241 warning (_("Failed to detach fork child %s, child of %s"),
1242 target_pid_to_str (ptid_t (fork_child_pid
)).c_str (),
1243 target_pid_to_str (thread
->id
).c_str ());
1246 if (detach_inferior (process
) != 0)
1247 write_enn (own_buf
);
1250 discard_queued_stop_replies (ptid_t (pid
));
1253 if (extended_protocol
|| target_running ())
1255 /* There is still at least one inferior remaining or
1256 we are in extended mode, so don't terminate gdbserver,
1257 and instead treat this like a normal program exit. */
1258 cs
.last_status
.set_exited (0);
1259 cs
.last_ptid
= ptid_t (pid
);
1261 switch_to_thread (nullptr);
1268 /* If we are attached, then we can exit. Otherwise, we
1269 need to hang around doing nothing, until the child is
1271 join_inferior (pid
);
1277 /* Parse options to --debug-format= and "monitor set debug-format".
1278 ARG is the text after "--debug-format=" or "monitor set debug-format".
1279 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1280 This triggers calls to monitor_output.
1281 The result is an empty string if all options were parsed ok, otherwise an
1282 error message which the caller must free.
1284 N.B. These commands affect all debug format settings, they are not
1285 cumulative. If a format is not specified, it is turned off.
1286 However, we don't go to extra trouble with things like
1287 "monitor set debug-format all,none,timestamp".
1288 Instead we just parse them one at a time, in order.
1290 The syntax for "monitor set debug" we support here is not identical
1291 to gdb's "set debug foo on|off" because we also use this function to
1292 parse "--debug-format=foo,bar". */
1295 parse_debug_format_options (const char *arg
, int is_monitor
)
1297 /* First turn all debug format options off. */
1298 debug_timestamp
= 0;
1300 /* First remove leading spaces, for "monitor set debug-format". */
1301 while (isspace (*arg
))
1304 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1305 = delim_string_to_char_ptr_vec (arg
, ',');
1307 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1309 if (strcmp (option
.get (), "all") == 0)
1311 debug_timestamp
= 1;
1313 monitor_output ("All extra debug format options enabled.\n");
1315 else if (strcmp (option
.get (), "none") == 0)
1317 debug_timestamp
= 0;
1319 monitor_output ("All extra debug format options disabled.\n");
1321 else if (strcmp (option
.get (), "timestamp") == 0)
1323 debug_timestamp
= 1;
1325 monitor_output ("Timestamps will be added to debug output.\n");
1327 else if (*option
== '\0')
1329 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1333 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1337 return std::string ();
1340 /* Handle monitor commands not handled by target-specific handlers. */
1343 handle_monitor_command (char *mon
, char *own_buf
)
1345 if (strcmp (mon
, "set debug 1") == 0)
1347 debug_threads
= true;
1348 monitor_output ("Debug output enabled.\n");
1350 else if (strcmp (mon
, "set debug 0") == 0)
1352 debug_threads
= false;
1353 monitor_output ("Debug output disabled.\n");
1355 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1357 show_debug_regs
= 1;
1358 monitor_output ("H/W point debugging output enabled.\n");
1360 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1362 show_debug_regs
= 0;
1363 monitor_output ("H/W point debugging output disabled.\n");
1365 else if (strcmp (mon
, "set remote-debug 1") == 0)
1367 remote_debug
= true;
1368 monitor_output ("Protocol debug output enabled.\n");
1370 else if (strcmp (mon
, "set remote-debug 0") == 0)
1372 remote_debug
= false;
1373 monitor_output ("Protocol debug output disabled.\n");
1375 else if (strcmp (mon
, "set event-loop-debug 1") == 0)
1377 debug_event_loop
= debug_event_loop_kind::ALL
;
1378 monitor_output ("Event loop debug output enabled.\n");
1380 else if (strcmp (mon
, "set event-loop-debug 0") == 0)
1382 debug_event_loop
= debug_event_loop_kind::OFF
;
1383 monitor_output ("Event loop debug output disabled.\n");
1385 else if (startswith (mon
, "set debug-format "))
1387 std::string error_msg
1388 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1391 if (!error_msg
.empty ())
1393 monitor_output (error_msg
.c_str ());
1394 monitor_show_help ();
1395 write_enn (own_buf
);
1398 else if (strcmp (mon
, "set debug-file") == 0)
1399 debug_set_output (nullptr);
1400 else if (startswith (mon
, "set debug-file "))
1401 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1402 else if (strcmp (mon
, "help") == 0)
1403 monitor_show_help ();
1404 else if (strcmp (mon
, "exit") == 0)
1405 exit_requested
= true;
1408 monitor_output ("Unknown monitor command.\n\n");
1409 monitor_show_help ();
1410 write_enn (own_buf
);
1414 /* Associates a callback with each supported qXfer'able object. */
1418 /* The object this handler handles. */
1421 /* Request that the target transfer up to LEN 8-bit bytes of the
1422 target's OBJECT. The OFFSET, for a seekable object, specifies
1423 the starting point. The ANNEX can be used to provide additional
1424 data-specific information to the target.
1426 Return the number of bytes actually transfered, zero when no
1427 further transfer is possible, -1 on error, -2 when the transfer
1428 is not supported, and -3 on a verbose error message that should
1429 be preserved. Return of a positive value smaller than LEN does
1430 not indicate the end of the object, only the end of the transfer.
1432 One, and only one, of readbuf or writebuf must be non-NULL. */
1433 int (*xfer
) (const char *annex
,
1434 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1435 ULONGEST offset
, LONGEST len
);
1438 /* Handle qXfer:auxv:read. */
1441 handle_qxfer_auxv (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
)
1445 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1448 if (annex
[0] != '\0' || current_thread
== NULL
)
1451 return the_target
->read_auxv (current_thread
->id
.pid (), offset
, readbuf
,
1455 /* Handle qXfer:exec-file:read. */
1458 handle_qxfer_exec_file (const char *annex
,
1459 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1460 ULONGEST offset
, LONGEST len
)
1465 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1468 if (annex
[0] == '\0')
1470 if (current_thread
== NULL
)
1473 pid
= pid_of (current_thread
);
1477 annex
= unpack_varlen_hex (annex
, &pid
);
1478 if (annex
[0] != '\0')
1485 const char *file
= the_target
->pid_to_exec_file (pid
);
1489 total_len
= strlen (file
);
1491 if (offset
> total_len
)
1494 if (offset
+ len
> total_len
)
1495 len
= total_len
- offset
;
1497 memcpy (readbuf
, file
+ offset
, len
);
1501 /* Handle qXfer:features:read. */
1504 handle_qxfer_features (const char *annex
,
1505 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1506 ULONGEST offset
, LONGEST len
)
1508 const char *document
;
1511 if (writebuf
!= NULL
)
1514 if (!target_running ())
1517 /* Grab the correct annex. */
1518 document
= get_features_xml (annex
);
1519 if (document
== NULL
)
1522 total_len
= strlen (document
);
1524 if (offset
> total_len
)
1527 if (offset
+ len
> total_len
)
1528 len
= total_len
- offset
;
1530 memcpy (readbuf
, document
+ offset
, len
);
1534 /* Handle qXfer:libraries:read. */
1537 handle_qxfer_libraries (const char *annex
,
1538 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1539 ULONGEST offset
, LONGEST len
)
1541 if (writebuf
!= NULL
)
1544 if (annex
[0] != '\0' || current_thread
== NULL
)
1547 std::string document
= "<library-list version=\"1.0\">\n";
1549 process_info
*proc
= current_process ();
1550 for (const dll_info
&dll
: proc
->all_dlls
)
1551 document
+= string_printf
1552 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1553 dll
.name
.c_str (), paddress (dll
.base_addr
));
1555 document
+= "</library-list>\n";
1557 if (offset
> document
.length ())
1560 if (offset
+ len
> document
.length ())
1561 len
= document
.length () - offset
;
1563 memcpy (readbuf
, &document
[offset
], len
);
1568 /* Handle qXfer:libraries-svr4:read. */
1571 handle_qxfer_libraries_svr4 (const char *annex
,
1572 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1573 ULONGEST offset
, LONGEST len
)
1575 if (writebuf
!= NULL
)
1578 if (current_thread
== NULL
1579 || !the_target
->supports_qxfer_libraries_svr4 ())
1582 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1586 /* Handle qXfer:osadata:read. */
1589 handle_qxfer_osdata (const char *annex
,
1590 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1591 ULONGEST offset
, LONGEST len
)
1593 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1596 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1599 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1602 handle_qxfer_siginfo (const char *annex
,
1603 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1604 ULONGEST offset
, LONGEST len
)
1606 if (!the_target
->supports_qxfer_siginfo ())
1609 if (annex
[0] != '\0' || current_thread
== NULL
)
1612 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1615 /* Handle qXfer:statictrace:read. */
1618 handle_qxfer_statictrace (const char *annex
,
1619 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1620 ULONGEST offset
, LONGEST len
)
1622 client_state
&cs
= get_client_state ();
1625 if (writebuf
!= NULL
)
1628 if (annex
[0] != '\0' || current_thread
== NULL
1629 || cs
.current_traceframe
== -1)
1632 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1633 readbuf
, len
, &nbytes
))
1638 /* Helper for handle_qxfer_threads_proper.
1639 Emit the XML to describe the thread of INF. */
1642 handle_qxfer_threads_worker (thread_info
*thread
, std::string
*buffer
)
1644 ptid_t ptid
= ptid_of (thread
);
1646 int core
= target_core_of_thread (ptid
);
1648 const char *name
= target_thread_name (ptid
);
1651 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1653 /* If this is a fork or vfork child (has a fork parent), GDB does not yet
1654 know about this process, and must not know about it until it gets the
1655 corresponding (v)fork event. Exclude this thread from the list. */
1656 if (target_thread_pending_parent (thread
) != nullptr)
1659 write_ptid (ptid_s
, ptid
);
1661 string_xml_appendf (*buffer
, "<thread id=\"%s\"", ptid_s
);
1665 sprintf (core_s
, "%d", core
);
1666 string_xml_appendf (*buffer
, " core=\"%s\"", core_s
);
1670 string_xml_appendf (*buffer
, " name=\"%s\"", name
);
1674 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1675 bin2hex (handle
, handle_s
, handle_len
);
1676 string_xml_appendf (*buffer
, " handle=\"%s\"", handle_s
);
1679 string_xml_appendf (*buffer
, "/>\n");
1682 /* Helper for handle_qxfer_threads. Return true on success, false
1686 handle_qxfer_threads_proper (std::string
*buffer
)
1688 *buffer
+= "<threads>\n";
1690 /* The target may need to access memory and registers (e.g. via
1691 libthread_db) to fetch thread properties. Even if don't need to
1692 stop threads to access memory, we still will need to be able to
1693 access registers, and other ptrace accesses like
1694 PTRACE_GET_THREAD_AREA that require a paused thread. Pause all
1695 threads here, so that we pause each thread at most once for all
1698 target_pause_all (true);
1700 for_each_thread ([&] (thread_info
*thread
)
1702 handle_qxfer_threads_worker (thread
, buffer
);
1706 target_unpause_all (true);
1708 *buffer
+= "</threads>\n";
1712 /* Handle qXfer:threads:read. */
1715 handle_qxfer_threads (const char *annex
,
1716 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1717 ULONGEST offset
, LONGEST len
)
1719 static std::string result
;
1721 if (writebuf
!= NULL
)
1724 if (annex
[0] != '\0')
1729 /* When asked for data at offset 0, generate everything and store into
1730 'result'. Successive reads will be served off 'result'. */
1733 bool res
= handle_qxfer_threads_proper (&result
);
1739 if (offset
>= result
.length ())
1741 /* We're out of data. */
1746 if (len
> result
.length () - offset
)
1747 len
= result
.length () - offset
;
1749 memcpy (readbuf
, result
.c_str () + offset
, len
);
1754 /* Handle qXfer:traceframe-info:read. */
1757 handle_qxfer_traceframe_info (const char *annex
,
1758 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1759 ULONGEST offset
, LONGEST len
)
1761 client_state
&cs
= get_client_state ();
1762 static std::string result
;
1764 if (writebuf
!= NULL
)
1767 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1772 /* When asked for data at offset 0, generate everything and
1773 store into 'result'. Successive reads will be served off
1777 traceframe_read_info (cs
.current_traceframe
, &result
);
1780 if (offset
>= result
.length ())
1782 /* We're out of data. */
1787 if (len
> result
.length () - offset
)
1788 len
= result
.length () - offset
;
1790 memcpy (readbuf
, result
.c_str () + offset
, len
);
1794 /* Handle qXfer:fdpic:read. */
1797 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1798 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1800 if (!the_target
->supports_read_loadmap ())
1803 if (current_thread
== NULL
)
1806 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1809 /* Handle qXfer:btrace:read. */
1812 handle_qxfer_btrace (const char *annex
,
1813 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1814 ULONGEST offset
, LONGEST len
)
1816 client_state
&cs
= get_client_state ();
1817 static std::string cache
;
1818 struct thread_info
*thread
;
1819 enum btrace_read_type type
;
1822 if (writebuf
!= NULL
)
1825 if (cs
.general_thread
== null_ptid
1826 || cs
.general_thread
== minus_one_ptid
)
1828 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1832 thread
= find_thread_ptid (cs
.general_thread
);
1835 strcpy (cs
.own_buf
, "E.No such thread.");
1839 if (thread
->btrace
== NULL
)
1841 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1845 if (strcmp (annex
, "all") == 0)
1846 type
= BTRACE_READ_ALL
;
1847 else if (strcmp (annex
, "new") == 0)
1848 type
= BTRACE_READ_NEW
;
1849 else if (strcmp (annex
, "delta") == 0)
1850 type
= BTRACE_READ_DELTA
;
1853 strcpy (cs
.own_buf
, "E.Bad annex.");
1863 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1865 memcpy (cs
.own_buf
, cache
.c_str (), cache
.length ());
1867 catch (const gdb_exception_error
&exception
)
1869 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1876 else if (offset
> cache
.length ())
1882 if (len
> cache
.length () - offset
)
1883 len
= cache
.length () - offset
;
1885 memcpy (readbuf
, cache
.c_str () + offset
, len
);
1890 /* Handle qXfer:btrace-conf:read. */
1893 handle_qxfer_btrace_conf (const char *annex
,
1894 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1895 ULONGEST offset
, LONGEST len
)
1897 client_state
&cs
= get_client_state ();
1898 static std::string cache
;
1899 struct thread_info
*thread
;
1902 if (writebuf
!= NULL
)
1905 if (annex
[0] != '\0')
1908 if (cs
.general_thread
== null_ptid
1909 || cs
.general_thread
== minus_one_ptid
)
1911 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1915 thread
= find_thread_ptid (cs
.general_thread
);
1918 strcpy (cs
.own_buf
, "E.No such thread.");
1922 if (thread
->btrace
== NULL
)
1924 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1934 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1936 memcpy (cs
.own_buf
, cache
.c_str (), cache
.length ());
1938 catch (const gdb_exception_error
&exception
)
1940 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1947 else if (offset
> cache
.length ())
1953 if (len
> cache
.length () - offset
)
1954 len
= cache
.length () - offset
;
1956 memcpy (readbuf
, cache
.c_str () + offset
, len
);
1961 static const struct qxfer qxfer_packets
[] =
1963 { "auxv", handle_qxfer_auxv
},
1964 { "btrace", handle_qxfer_btrace
},
1965 { "btrace-conf", handle_qxfer_btrace_conf
},
1966 { "exec-file", handle_qxfer_exec_file
},
1967 { "fdpic", handle_qxfer_fdpic
},
1968 { "features", handle_qxfer_features
},
1969 { "libraries", handle_qxfer_libraries
},
1970 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1971 { "osdata", handle_qxfer_osdata
},
1972 { "siginfo", handle_qxfer_siginfo
},
1973 { "statictrace", handle_qxfer_statictrace
},
1974 { "threads", handle_qxfer_threads
},
1975 { "traceframe-info", handle_qxfer_traceframe_info
},
1979 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1987 if (!startswith (own_buf
, "qXfer:"))
1990 /* Grab the object, r/w and annex. */
1991 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1993 write_enn (own_buf
);
1998 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2001 const struct qxfer
*q
= &qxfer_packets
[i
];
2003 if (strcmp (object
, q
->object
) == 0)
2005 if (strcmp (rw
, "read") == 0)
2007 unsigned char *data
;
2012 /* Grab the offset and length. */
2013 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2015 write_enn (own_buf
);
2019 /* Read one extra byte, as an indicator of whether there is
2021 if (len
> PBUFSIZ
- 2)
2023 data
= (unsigned char *) malloc (len
+ 1);
2026 write_enn (own_buf
);
2029 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2037 /* Preserve error message. */
2040 write_enn (own_buf
);
2042 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2044 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2049 else if (strcmp (rw
, "write") == 0)
2054 unsigned char *data
;
2056 strcpy (own_buf
, "E00");
2057 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2060 write_enn (own_buf
);
2063 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2064 &ofs
, &len
, data
) < 0)
2067 write_enn (own_buf
);
2071 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2079 /* Preserve error message. */
2082 write_enn (own_buf
);
2084 sprintf (own_buf
, "%x", n
);
2097 /* Compute 32 bit CRC from inferior memory.
2099 On success, return 32 bit CRC.
2100 On failure, return (unsigned long long) -1. */
2102 static unsigned long long
2103 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2107 unsigned char byte
= 0;
2109 /* Return failure if memory read fails. */
2110 if (read_inferior_memory (base
, &byte
, 1) != 0)
2111 return (unsigned long long) -1;
2113 crc
= xcrc32 (&byte
, 1, crc
);
2116 return (unsigned long long) crc
;
2119 /* Parse the qMemTags packet request into ADDR and LEN. */
2122 parse_fetch_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
2125 gdb_assert (startswith (request
, "qMemTags:"));
2127 const char *p
= request
+ strlen ("qMemTags:");
2129 /* Read address and length. */
2130 unsigned int length
= 0;
2131 p
= decode_m_packet_params (p
, addr
, &length
, ':');
2134 /* Read the tag type. */
2135 ULONGEST tag_type
= 0;
2136 p
= unpack_varlen_hex (p
, &tag_type
);
2137 *type
= (int) tag_type
;
2140 /* Add supported btrace packets to BUF. */
2143 supported_btrace_packets (char *buf
)
2145 strcat (buf
, ";Qbtrace:bts+");
2146 strcat (buf
, ";Qbtrace-conf:bts:size+");
2147 strcat (buf
, ";Qbtrace:pt+");
2148 strcat (buf
, ";Qbtrace-conf:pt:size+");
2149 strcat (buf
, ";Qbtrace:off+");
2150 strcat (buf
, ";qXfer:btrace:read+");
2151 strcat (buf
, ";qXfer:btrace-conf:read+");
2154 /* Handle all of the extended 'q' packets. */
2157 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2159 client_state
&cs
= get_client_state ();
2160 static std::list
<thread_info
*>::const_iterator thread_iter
;
2162 /* Reply the current thread id. */
2163 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2166 require_running_or_return (own_buf
);
2168 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2169 ptid
= cs
.general_thread
;
2172 thread_iter
= all_threads
.begin ();
2173 ptid
= (*thread_iter
)->id
;
2176 sprintf (own_buf
, "QC");
2178 write_ptid (own_buf
, ptid
);
2182 if (strcmp ("qSymbol::", own_buf
) == 0)
2184 scoped_restore_current_thread restore_thread
;
2186 /* For qSymbol, GDB only changes the current thread if the
2187 previous current thread was of a different process. So if
2188 the previous thread is gone, we need to pick another one of
2189 the same process. This can happen e.g., if we followed an
2190 exec in a non-leader thread. */
2191 if (current_thread
== NULL
)
2193 thread_info
*any_thread
2194 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2195 switch_to_thread (any_thread
);
2197 /* Just in case, if we didn't find a thread, then bail out
2198 instead of crashing. */
2199 if (current_thread
== NULL
)
2201 write_enn (own_buf
);
2206 /* GDB is suggesting new symbols have been loaded. This may
2207 mean a new shared library has been detected as loaded, so
2208 take the opportunity to check if breakpoints we think are
2209 inserted, still are. Note that it isn't guaranteed that
2210 we'll see this when a shared library is loaded, and nor will
2211 we see this for unloads (although breakpoints in unloaded
2212 libraries shouldn't trigger), as GDB may not find symbols for
2213 the library at all. We also re-validate breakpoints when we
2214 see a second GDB breakpoint for the same address, and or when
2215 we access breakpoint shadows. */
2216 validate_breakpoints ();
2218 if (target_supports_tracepoints ())
2219 tracepoint_look_up_symbols ();
2221 if (current_thread
!= NULL
)
2222 the_target
->look_up_symbols ();
2224 strcpy (own_buf
, "OK");
2228 if (!disable_packet_qfThreadInfo
)
2230 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2232 require_running_or_return (own_buf
);
2233 thread_iter
= all_threads
.begin ();
2236 ptid_t ptid
= (*thread_iter
)->id
;
2237 write_ptid (own_buf
, ptid
);
2242 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2244 require_running_or_return (own_buf
);
2245 if (thread_iter
!= all_threads
.end ())
2248 ptid_t ptid
= (*thread_iter
)->id
;
2249 write_ptid (own_buf
, ptid
);
2255 sprintf (own_buf
, "l");
2261 if (the_target
->supports_read_offsets ()
2262 && strcmp ("qOffsets", own_buf
) == 0)
2264 CORE_ADDR text
, data
;
2266 require_running_or_return (own_buf
);
2267 if (the_target
->read_offsets (&text
, &data
))
2268 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2269 (long)text
, (long)data
, (long)data
);
2271 write_enn (own_buf
);
2276 /* Protocol features query. */
2277 if (startswith (own_buf
, "qSupported")
2278 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2280 char *p
= &own_buf
[10];
2281 int gdb_supports_qRelocInsn
= 0;
2283 /* Process each feature being provided by GDB. The first
2284 feature will follow a ':', and latter features will follow
2288 std::vector
<std::string
> qsupported
;
2289 std::vector
<const char *> unknowns
;
2291 /* Two passes, to avoid nested strtok calls in
2292 target_process_qsupported. */
2294 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2296 p
= strtok_r (NULL
, ";", &saveptr
))
2297 qsupported
.emplace_back (p
);
2299 for (const std::string
&feature
: qsupported
)
2301 if (feature
== "multiprocess+")
2303 /* GDB supports and wants multi-process support if
2305 if (target_supports_multi_process ())
2306 cs
.multi_process
= 1;
2308 else if (feature
== "qRelocInsn+")
2310 /* GDB supports relocate instruction requests. */
2311 gdb_supports_qRelocInsn
= 1;
2313 else if (feature
== "swbreak+")
2315 /* GDB wants us to report whether a trap is caused
2316 by a software breakpoint and for us to handle PC
2317 adjustment if necessary on this target. */
2318 if (target_supports_stopped_by_sw_breakpoint ())
2319 cs
.swbreak_feature
= 1;
2321 else if (feature
== "hwbreak+")
2323 /* GDB wants us to report whether a trap is caused
2324 by a hardware breakpoint. */
2325 if (target_supports_stopped_by_hw_breakpoint ())
2326 cs
.hwbreak_feature
= 1;
2328 else if (feature
== "fork-events+")
2330 /* GDB supports and wants fork events if possible. */
2331 if (target_supports_fork_events ())
2332 cs
.report_fork_events
= 1;
2334 else if (feature
== "vfork-events+")
2336 /* GDB supports and wants vfork events if possible. */
2337 if (target_supports_vfork_events ())
2338 cs
.report_vfork_events
= 1;
2340 else if (feature
== "exec-events+")
2342 /* GDB supports and wants exec events if possible. */
2343 if (target_supports_exec_events ())
2344 cs
.report_exec_events
= 1;
2346 else if (feature
== "vContSupported+")
2347 cs
.vCont_supported
= 1;
2348 else if (feature
== "QThreadEvents+")
2350 else if (feature
== "no-resumed+")
2352 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2354 report_no_resumed
= true;
2356 else if (feature
== "memory-tagging+")
2358 /* GDB supports memory tagging features. */
2359 if (target_supports_memory_tagging ())
2360 cs
.memory_tagging_feature
= true;
2364 /* Move the unknown features all together. */
2365 unknowns
.push_back (feature
.c_str ());
2369 /* Give the target backend a chance to process the unknown
2371 target_process_qsupported (unknowns
);
2375 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2376 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2377 "QEnvironmentReset+;QEnvironmentUnset+;"
2381 if (target_supports_catch_syscall ())
2382 strcat (own_buf
, ";QCatchSyscalls+");
2384 if (the_target
->supports_qxfer_libraries_svr4 ())
2385 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2386 ";augmented-libraries-svr4-read+");
2389 /* We do not have any hook to indicate whether the non-SVR4 target
2390 backend supports qXfer:libraries:read, so always report it. */
2391 strcat (own_buf
, ";qXfer:libraries:read+");
2394 if (the_target
->supports_read_auxv ())
2395 strcat (own_buf
, ";qXfer:auxv:read+");
2397 if (the_target
->supports_qxfer_siginfo ())
2398 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2400 if (the_target
->supports_read_loadmap ())
2401 strcat (own_buf
, ";qXfer:fdpic:read+");
2403 /* We always report qXfer:features:read, as targets may
2404 install XML files on a subsequent call to arch_setup.
2405 If we reported to GDB on startup that we don't support
2406 qXfer:feature:read at all, we will never be re-queried. */
2407 strcat (own_buf
, ";qXfer:features:read+");
2409 if (cs
.transport_is_reliable
)
2410 strcat (own_buf
, ";QStartNoAckMode+");
2412 if (the_target
->supports_qxfer_osdata ())
2413 strcat (own_buf
, ";qXfer:osdata:read+");
2415 if (target_supports_multi_process ())
2416 strcat (own_buf
, ";multiprocess+");
2418 if (target_supports_fork_events ())
2419 strcat (own_buf
, ";fork-events+");
2421 if (target_supports_vfork_events ())
2422 strcat (own_buf
, ";vfork-events+");
2424 if (target_supports_exec_events ())
2425 strcat (own_buf
, ";exec-events+");
2427 if (target_supports_non_stop ())
2428 strcat (own_buf
, ";QNonStop+");
2430 if (target_supports_disable_randomization ())
2431 strcat (own_buf
, ";QDisableRandomization+");
2433 strcat (own_buf
, ";qXfer:threads:read+");
2435 if (target_supports_tracepoints ())
2437 strcat (own_buf
, ";ConditionalTracepoints+");
2438 strcat (own_buf
, ";TraceStateVariables+");
2439 strcat (own_buf
, ";TracepointSource+");
2440 strcat (own_buf
, ";DisconnectedTracing+");
2441 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2442 strcat (own_buf
, ";FastTracepoints+");
2443 strcat (own_buf
, ";StaticTracepoints+");
2444 strcat (own_buf
, ";InstallInTrace+");
2445 strcat (own_buf
, ";qXfer:statictrace:read+");
2446 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2447 strcat (own_buf
, ";EnableDisableTracepoints+");
2448 strcat (own_buf
, ";QTBuffer:size+");
2449 strcat (own_buf
, ";tracenz+");
2452 if (target_supports_hardware_single_step ()
2453 || target_supports_software_single_step () )
2455 strcat (own_buf
, ";ConditionalBreakpoints+");
2457 strcat (own_buf
, ";BreakpointCommands+");
2459 if (target_supports_agent ())
2460 strcat (own_buf
, ";QAgent+");
2462 if (the_target
->supports_btrace ())
2463 supported_btrace_packets (own_buf
);
2465 if (target_supports_stopped_by_sw_breakpoint ())
2466 strcat (own_buf
, ";swbreak+");
2468 if (target_supports_stopped_by_hw_breakpoint ())
2469 strcat (own_buf
, ";hwbreak+");
2471 if (the_target
->supports_pid_to_exec_file ())
2472 strcat (own_buf
, ";qXfer:exec-file:read+");
2474 strcat (own_buf
, ";vContSupported+");
2476 strcat (own_buf
, ";QThreadEvents+");
2478 strcat (own_buf
, ";no-resumed+");
2480 if (target_supports_memory_tagging ())
2481 strcat (own_buf
, ";memory-tagging+");
2483 /* Reinitialize components as needed for the new connection. */
2484 hostio_handle_new_gdb_connection ();
2485 target_handle_new_gdb_connection ();
2490 /* Thread-local storage support. */
2491 if (the_target
->supports_get_tls_address ()
2492 && startswith (own_buf
, "qGetTLSAddr:"))
2494 char *p
= own_buf
+ 12;
2495 CORE_ADDR parts
[2], address
= 0;
2497 ptid_t ptid
= null_ptid
;
2499 require_running_or_return (own_buf
);
2501 for (i
= 0; i
< 3; i
++)
2509 p2
= strchr (p
, ',');
2522 ptid
= read_ptid (p
, NULL
);
2524 decode_address (&parts
[i
- 1], p
, len
);
2528 if (p
!= NULL
|| i
< 3)
2532 struct thread_info
*thread
= find_thread_ptid (ptid
);
2537 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2543 strcpy (own_buf
, paddress(address
));
2548 write_enn (own_buf
);
2552 /* Otherwise, pretend we do not understand this packet. */
2555 /* Windows OS Thread Information Block address support. */
2556 if (the_target
->supports_get_tib_address ()
2557 && startswith (own_buf
, "qGetTIBAddr:"))
2562 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2564 n
= the_target
->get_tib_address (ptid
, &tlb
);
2567 strcpy (own_buf
, paddress(tlb
));
2572 write_enn (own_buf
);
2578 /* Handle "monitor" commands. */
2579 if (startswith (own_buf
, "qRcmd,"))
2581 char *mon
= (char *) malloc (PBUFSIZ
);
2582 int len
= strlen (own_buf
+ 6);
2586 write_enn (own_buf
);
2591 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2593 write_enn (own_buf
);
2597 mon
[len
/ 2] = '\0';
2601 if (the_target
->handle_monitor_command (mon
) == 0)
2602 /* Default processing. */
2603 handle_monitor_command (mon
, own_buf
);
2609 if (startswith (own_buf
, "qSearch:memory:"))
2611 require_running_or_return (own_buf
);
2612 handle_search_memory (own_buf
, packet_len
);
2616 if (strcmp (own_buf
, "qAttached") == 0
2617 || startswith (own_buf
, "qAttached:"))
2619 struct process_info
*process
;
2621 if (own_buf
[sizeof ("qAttached") - 1])
2623 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2624 process
= find_process_pid (pid
);
2628 require_running_or_return (own_buf
);
2629 process
= current_process ();
2632 if (process
== NULL
)
2634 write_enn (own_buf
);
2638 strcpy (own_buf
, process
->attached
? "1" : "0");
2642 if (startswith (own_buf
, "qCRC:"))
2644 /* CRC check (compare-section). */
2648 unsigned long long crc
;
2650 require_running_or_return (own_buf
);
2651 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2652 if (*comma
++ != ',')
2654 write_enn (own_buf
);
2657 len
= strtoul (comma
, NULL
, 16);
2658 crc
= crc32 (base
, len
, 0xffffffff);
2659 /* Check for memory failure. */
2660 if (crc
== (unsigned long long) -1)
2662 write_enn (own_buf
);
2665 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2669 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2672 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2675 /* Handle fetch memory tags packets. */
2676 if (startswith (own_buf
, "qMemTags:")
2677 && target_supports_memory_tagging ())
2679 gdb::byte_vector tags
;
2684 require_running_or_return (own_buf
);
2686 parse_fetch_memtags_request (own_buf
, &addr
, &len
, &type
);
2688 bool ret
= the_target
->fetch_memtags (addr
, len
, tags
, type
);
2691 ret
= create_fetch_memtags_reply (own_buf
, tags
);
2694 write_enn (own_buf
);
2696 *new_packet_len_p
= strlen (own_buf
);
2700 /* Otherwise we didn't know what packet it was. Say we didn't
2705 static void gdb_wants_all_threads_stopped (void);
2706 static void resume (struct thread_resume
*actions
, size_t n
);
2708 /* The callback that is passed to visit_actioned_threads. */
2709 typedef int (visit_actioned_threads_callback_ftype
)
2710 (const struct thread_resume
*, struct thread_info
*);
2712 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2713 true if CALLBACK returns true. Returns false if no matching thread
2714 is found or CALLBACK results false.
2715 Note: This function is itself a callback for find_thread. */
2718 visit_actioned_threads (thread_info
*thread
,
2719 const struct thread_resume
*actions
,
2721 visit_actioned_threads_callback_ftype
*callback
)
2723 for (size_t i
= 0; i
< num_actions
; i
++)
2725 const struct thread_resume
*action
= &actions
[i
];
2727 if (action
->thread
== minus_one_ptid
2728 || action
->thread
== thread
->id
2729 || ((action
->thread
.pid ()
2730 == thread
->id
.pid ())
2731 && action
->thread
.lwp () == -1))
2733 if ((*callback
) (action
, thread
))
2741 /* Callback for visit_actioned_threads. If the thread has a pending
2742 status to report, report it now. */
2745 handle_pending_status (const struct thread_resume
*resumption
,
2746 struct thread_info
*thread
)
2748 client_state
&cs
= get_client_state ();
2749 if (thread
->status_pending_p
)
2751 thread
->status_pending_p
= 0;
2753 cs
.last_status
= thread
->last_status
;
2754 cs
.last_ptid
= thread
->id
;
2755 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
2761 /* Parse vCont packets. */
2763 handle_v_cont (char *own_buf
)
2767 struct thread_resume
*resume_info
;
2768 struct thread_resume default_action
{ null_ptid
};
2770 /* Count the number of semicolons in the packet. There should be one
2771 for every action. */
2777 p
= strchr (p
, ';');
2780 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2781 if (resume_info
== NULL
)
2789 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2791 if (p
[0] == 's' || p
[0] == 'S')
2792 resume_info
[i
].kind
= resume_step
;
2793 else if (p
[0] == 'r')
2794 resume_info
[i
].kind
= resume_step
;
2795 else if (p
[0] == 'c' || p
[0] == 'C')
2796 resume_info
[i
].kind
= resume_continue
;
2797 else if (p
[0] == 't')
2798 resume_info
[i
].kind
= resume_stop
;
2802 if (p
[0] == 'S' || p
[0] == 'C')
2805 int sig
= strtol (p
+ 1, &q
, 16);
2810 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2812 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2814 else if (p
[0] == 'r')
2818 p
= unpack_varlen_hex (p
+ 1, &addr
);
2819 resume_info
[i
].step_range_start
= addr
;
2824 p
= unpack_varlen_hex (p
+ 1, &addr
);
2825 resume_info
[i
].step_range_end
= addr
;
2834 resume_info
[i
].thread
= minus_one_ptid
;
2835 default_action
= resume_info
[i
];
2837 /* Note: we don't increment i here, we'll overwrite this entry
2838 the next time through. */
2840 else if (p
[0] == ':')
2843 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2848 if (p
[0] != ';' && p
[0] != 0)
2851 resume_info
[i
].thread
= ptid
;
2858 resume_info
[i
] = default_action
;
2860 resume (resume_info
, n
);
2865 write_enn (own_buf
);
2870 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2873 resume (struct thread_resume
*actions
, size_t num_actions
)
2875 client_state
&cs
= get_client_state ();
2878 /* Check if among the threads that GDB wants actioned, there's
2879 one with a pending status to report. If so, skip actually
2880 resuming/stopping and report the pending event
2883 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2885 return visit_actioned_threads (thread
, actions
, num_actions
,
2886 handle_pending_status
);
2889 if (thread_with_status
!= NULL
)
2895 the_target
->resume (actions
, num_actions
);
2898 write_ok (cs
.own_buf
);
2901 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2903 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
2904 && !report_no_resumed
)
2906 /* The client does not support this stop reply. At least
2908 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2909 disable_async_io ();
2913 if (cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
2914 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
2915 && cs
.last_status
.kind () != TARGET_WAITKIND_NO_RESUMED
)
2916 current_thread
->last_status
= cs
.last_status
;
2918 /* From the client's perspective, all-stop mode always stops all
2919 threads implicitly (and the target backend has already done
2920 so by now). Tag all threads as "want-stopped", so we don't
2921 resume them implicitly without the client telling us to. */
2922 gdb_wants_all_threads_stopped ();
2923 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
2924 disable_async_io ();
2926 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
2927 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
2928 target_mourn_inferior (cs
.last_ptid
);
2932 /* Attach to a new program. */
2934 handle_v_attach (char *own_buf
)
2936 client_state
&cs
= get_client_state ();
2939 pid
= strtol (own_buf
+ 8, NULL
, 16);
2940 if (pid
!= 0 && attach_inferior (pid
) == 0)
2942 /* Don't report shared library events after attaching, even if
2943 some libraries are preloaded. GDB will always poll the
2944 library list. Avoids the "stopped by shared library event"
2945 notice on the GDB side. */
2946 current_process ()->dlls_changed
= false;
2950 /* In non-stop, we don't send a resume reply. Stop events
2951 will follow up using the normal notification
2956 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
2959 write_enn (own_buf
);
2962 /* Decode an argument from the vRun packet buffer. PTR points to the
2963 first hex-encoded character in the buffer, and LEN is the number of
2964 characters to read from the packet buffer.
2966 If the argument decoding is successful, return a buffer containing the
2967 decoded argument, including a null terminator at the end.
2969 If the argument decoding fails for any reason, return nullptr. */
2971 static gdb::unique_xmalloc_ptr
<char>
2972 decode_v_run_arg (const char *ptr
, size_t len
)
2974 /* Two hex characters are required for each decoded byte. */
2978 /* The length in bytes needed for the decoded argument. */
2981 /* Buffer to decode the argument into. The '+ 1' is for the null
2982 terminator we will add. */
2983 char *arg
= (char *) xmalloc (len
+ 1);
2985 /* Decode the argument from the packet and add a null terminator. We do
2986 this within a try block as invalid characters within the PTR buffer
2987 will cause hex2bin to throw an exception. Our caller relies on us
2988 returning nullptr in order to clean up some memory allocations. */
2991 hex2bin (ptr
, (gdb_byte
*) arg
, len
);
2994 catch (const gdb_exception_error
&exception
)
2999 return gdb::unique_xmalloc_ptr
<char> (arg
);
3002 /* Run a new program. */
3004 handle_v_run (char *own_buf
)
3006 client_state
&cs
= get_client_state ();
3008 std::vector
<char *> new_argv
;
3009 gdb::unique_xmalloc_ptr
<char> new_program_name
;
3012 for (i
= 0, p
= own_buf
+ strlen ("vRun;");
3013 /* Exit condition is at the end of the loop. */;
3014 p
= next_p
+ 1, ++i
)
3016 next_p
= strchr (p
, ';');
3018 next_p
= p
+ strlen (p
);
3020 if (i
== 0 && p
== next_p
)
3022 /* No program specified. */
3023 gdb_assert (new_program_name
== nullptr);
3025 else if (p
== next_p
)
3027 /* Empty argument. */
3028 new_argv
.push_back (xstrdup (""));
3032 /* The length of the argument string in the packet. */
3033 size_t len
= next_p
- p
;
3035 gdb::unique_xmalloc_ptr
<char> arg
= decode_v_run_arg (p
, len
);
3038 write_enn (own_buf
);
3039 free_vector_argv (new_argv
);
3044 new_program_name
= std::move (arg
);
3046 new_argv
.push_back (arg
.release ());
3048 if (*next_p
== '\0')
3052 if (new_program_name
== nullptr)
3054 /* GDB didn't specify a program to run. Use the program from the
3055 last run with the new argument list. */
3056 if (program_path
.get () == nullptr)
3058 write_enn (own_buf
);
3059 free_vector_argv (new_argv
);
3064 program_path
.set (new_program_name
.get ());
3066 /* Free the old argv and install the new one. */
3067 free_vector_argv (program_args
);
3068 program_args
= new_argv
;
3070 target_create_inferior (program_path
.get (), program_args
);
3072 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
3074 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
3076 /* In non-stop, sending a resume reply doesn't set the general
3077 thread, but GDB assumes a vRun sets it (this is so GDB can
3078 query which is the main thread of the new inferior. */
3080 cs
.general_thread
= cs
.last_ptid
;
3083 write_enn (own_buf
);
3088 handle_v_kill (char *own_buf
)
3090 client_state
&cs
= get_client_state ();
3092 char *p
= &own_buf
[6];
3093 if (cs
.multi_process
)
3094 pid
= strtol (p
, NULL
, 16);
3098 process_info
*proc
= find_process_pid (pid
);
3100 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3102 cs
.last_status
.set_signalled (GDB_SIGNAL_KILL
);
3103 cs
.last_ptid
= ptid_t (pid
);
3104 discard_queued_stop_replies (cs
.last_ptid
);
3108 write_enn (own_buf
);
3111 /* Handle all of the extended 'v' packets. */
3113 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3115 client_state
&cs
= get_client_state ();
3116 if (!disable_packet_vCont
)
3118 if (strcmp (own_buf
, "vCtrlC") == 0)
3120 the_target
->request_interrupt ();
3125 if (startswith (own_buf
, "vCont;"))
3127 handle_v_cont (own_buf
);
3131 if (startswith (own_buf
, "vCont?"))
3133 strcpy (own_buf
, "vCont;c;C;t");
3135 if (target_supports_hardware_single_step ()
3136 || target_supports_software_single_step ()
3137 || !cs
.vCont_supported
)
3139 /* If target supports single step either by hardware or by
3140 software, add actions s and S to the list of supported
3141 actions. On the other hand, if GDB doesn't request the
3142 supported vCont actions in qSupported packet, add s and
3143 S to the list too. */
3144 own_buf
= own_buf
+ strlen (own_buf
);
3145 strcpy (own_buf
, ";s;S");
3148 if (target_supports_range_stepping ())
3150 own_buf
= own_buf
+ strlen (own_buf
);
3151 strcpy (own_buf
, ";r");
3157 if (startswith (own_buf
, "vFile:")
3158 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3161 if (startswith (own_buf
, "vAttach;"))
3163 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3165 fprintf (stderr
, "Already debugging a process\n");
3166 write_enn (own_buf
);
3169 handle_v_attach (own_buf
);
3173 if (startswith (own_buf
, "vRun;"))
3175 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3177 fprintf (stderr
, "Already debugging a process\n");
3178 write_enn (own_buf
);
3181 handle_v_run (own_buf
);
3185 if (startswith (own_buf
, "vKill;"))
3187 if (!target_running ())
3189 fprintf (stderr
, "No process to kill\n");
3190 write_enn (own_buf
);
3193 handle_v_kill (own_buf
);
3197 if (handle_notif_ack (own_buf
, packet_len
))
3200 /* Otherwise we didn't know what packet it was. Say we didn't
3206 /* Resume thread and wait for another event. In non-stop mode,
3207 don't really wait here, but return immediately to the event
3210 myresume (char *own_buf
, int step
, int sig
)
3212 client_state
&cs
= get_client_state ();
3213 struct thread_resume resume_info
[2];
3215 int valid_cont_thread
;
3217 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3218 && cs
.cont_thread
!= minus_one_ptid
);
3220 if (step
|| sig
|| valid_cont_thread
)
3222 resume_info
[0].thread
= current_ptid
;
3224 resume_info
[0].kind
= resume_step
;
3226 resume_info
[0].kind
= resume_continue
;
3227 resume_info
[0].sig
= sig
;
3231 if (!valid_cont_thread
)
3233 resume_info
[n
].thread
= minus_one_ptid
;
3234 resume_info
[n
].kind
= resume_continue
;
3235 resume_info
[n
].sig
= 0;
3239 resume (resume_info
, n
);
3242 /* Callback for for_each_thread. Make a new stop reply for each
3246 queue_stop_reply_callback (thread_info
*thread
)
3248 /* For now, assume targets that don't have this callback also don't
3249 manage the thread's last_status field. */
3250 if (!the_target
->supports_thread_stopped ())
3252 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3254 new_notif
->ptid
= thread
->id
;
3255 new_notif
->status
= thread
->last_status
;
3256 /* Pass the last stop reply back to GDB, but don't notify
3258 notif_event_enque (¬if_stop
, new_notif
);
3262 if (target_thread_stopped (thread
))
3264 threads_debug_printf
3265 ("Reporting thread %s as already stopped with %s",
3266 target_pid_to_str (thread
->id
).c_str (),
3267 thread
->last_status
.to_string ().c_str ());
3269 gdb_assert (thread
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3271 /* Pass the last stop reply back to GDB, but don't notify
3273 queue_stop_reply (thread
->id
, thread
->last_status
);
3278 /* Set this inferior threads's state as "want-stopped". We won't
3279 resume this thread until the client gives us another action for
3283 gdb_wants_thread_stopped (thread_info
*thread
)
3285 thread
->last_resume_kind
= resume_stop
;
3287 if (thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
)
3289 /* Most threads are stopped implicitly (all-stop); tag that with
3291 thread
->last_status
.set_stopped (GDB_SIGNAL_0
);
3295 /* Set all threads' states as "want-stopped". */
3298 gdb_wants_all_threads_stopped (void)
3300 for_each_thread (gdb_wants_thread_stopped
);
3303 /* Callback for for_each_thread. If the thread is stopped with an
3304 interesting event, mark it as having a pending event. */
3307 set_pending_status_callback (thread_info
*thread
)
3309 if (thread
->last_status
.kind () != TARGET_WAITKIND_STOPPED
3310 || (thread
->last_status
.sig () != GDB_SIGNAL_0
3311 /* A breakpoint, watchpoint or finished step from a previous
3312 GDB run isn't considered interesting for a new GDB run.
3313 If we left those pending, the new GDB could consider them
3314 random SIGTRAPs. This leaves out real async traps. We'd
3315 have to peek into the (target-specific) siginfo to
3316 distinguish those. */
3317 && thread
->last_status
.sig () != GDB_SIGNAL_TRAP
))
3318 thread
->status_pending_p
= 1;
3321 /* Status handler for the '?' packet. */
3324 handle_status (char *own_buf
)
3326 client_state
&cs
= get_client_state ();
3328 /* GDB is connected, don't forward events to the target anymore. */
3329 for_each_process ([] (process_info
*process
) {
3330 process
->gdb_detached
= 0;
3333 /* In non-stop mode, we must send a stop reply for each stopped
3334 thread. In all-stop mode, just send one for the first stopped
3339 for_each_thread (queue_stop_reply_callback
);
3341 /* The first is sent immediatly. OK is sent if there is no
3342 stopped thread, which is the same handling of the vStopped
3343 packet (by design). */
3344 notif_write_event (¬if_stop
, cs
.own_buf
);
3348 thread_info
*thread
= NULL
;
3350 target_pause_all (false);
3351 target_stabilize_threads ();
3352 gdb_wants_all_threads_stopped ();
3354 /* We can only report one status, but we might be coming out of
3355 non-stop -- if more than one thread is stopped with
3356 interesting events, leave events for the threads we're not
3357 reporting now pending. They'll be reported the next time the
3358 threads are resumed. Start by marking all interesting events
3360 for_each_thread (set_pending_status_callback
);
3362 /* Prefer the last thread that reported an event to GDB (even if
3363 that was a GDB_SIGNAL_TRAP). */
3364 if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
3365 && cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
3366 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
)
3367 thread
= find_thread_ptid (cs
.last_ptid
);
3369 /* If the last event thread is not found for some reason, look
3370 for some other thread that might have an event to report. */
3372 thread
= find_thread ([] (thread_info
*thr_arg
)
3374 return thr_arg
->status_pending_p
;
3377 /* If we're still out of luck, simply pick the first thread in
3380 thread
= get_first_thread ();
3384 struct thread_info
*tp
= (struct thread_info
*) thread
;
3386 /* We're reporting this event, so it's no longer
3388 tp
->status_pending_p
= 0;
3390 /* GDB assumes the current thread is the thread we're
3391 reporting the status for. */
3392 cs
.general_thread
= thread
->id
;
3393 set_desired_thread ();
3395 gdb_assert (tp
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3396 prepare_resume_reply (own_buf
, tp
->id
, tp
->last_status
);
3399 strcpy (own_buf
, "W00");
3404 gdbserver_version (void)
3406 printf ("GNU gdbserver %s%s\n"
3407 "Copyright (C) 2023 Free Software Foundation, Inc.\n"
3408 "gdbserver is free software, covered by the "
3409 "GNU General Public License.\n"
3410 "This gdbserver was configured as \"%s\"\n",
3411 PKGVERSION
, version
, host_name
);
3415 gdbserver_usage (FILE *stream
)
3417 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3418 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3419 "\tgdbserver [OPTIONS] --multi COMM\n"
3421 "COMM may either be a tty device (for serial debugging),\n"
3422 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3423 "stdin/stdout of gdbserver.\n"
3424 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3425 "PID is the process ID to attach to, when --attach is specified.\n"
3427 "Operating modes:\n"
3429 " --attach Attach to running process PID.\n"
3430 " --multi Start server without a specific program, and\n"
3431 " only quit when explicitly commanded.\n"
3432 " --once Exit after the first connection has closed.\n"
3433 " --help Print this message and then exit.\n"
3434 " --version Display version information and exit.\n"
3438 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3439 " --disable-randomization\n"
3440 " Run PROG with address space randomization disabled.\n"
3441 " --no-disable-randomization\n"
3442 " Don't disable address space randomization when\n"
3444 " --startup-with-shell\n"
3445 " Start PROG using a shell. I.e., execs a shell that\n"
3446 " then execs PROG. (default)\n"
3447 " --no-startup-with-shell\n"
3448 " Exec PROG directly instead of using a shell.\n"
3449 " Disables argument globbing and variable substitution\n"
3450 " on UNIX-like systems.\n"
3454 " --debug Enable general debugging output.\n"
3455 " --debug-format=OPT1[,OPT2,...]\n"
3456 " Specify extra content in debugging output.\n"
3461 " --remote-debug Enable remote protocol debugging output.\n"
3462 " --event-loop-debug Enable event loop debugging output.\n"
3463 " --disable-packet=OPT1[,OPT2,...]\n"
3464 " Disable support for RSP packets or features.\n"
3466 " vCont, T, Tthread, qC, qfThreadInfo and \n"
3467 " threads (disable all threading packets).\n"
3469 "For more information, consult the GDB manual (available as on-line \n"
3470 "info or a printed manual).\n");
3471 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3472 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3476 gdbserver_show_disableable (FILE *stream
)
3478 fprintf (stream
, "Disableable packets:\n"
3479 " vCont \tAll vCont packets\n"
3480 " qC \tQuerying the current thread\n"
3481 " qfThreadInfo\tThread listing\n"
3482 " Tthread \tPassing the thread specifier in the "
3483 "T stop reply packet\n"
3484 " threads \tAll of the above\n"
3485 " T \tAll 'T' packets\n");
3488 /* Start up the event loop. This is the entry point to the event
3494 /* Loop until there is nothing to do. This is the entry point to
3495 the event loop engine. If nothing is ready at this time, wait
3496 for something to happen (via wait_for_event), then process it.
3497 Return when there are no longer event sources to wait for. */
3499 keep_processing_events
= true;
3500 while (keep_processing_events
)
3502 /* Any events already waiting in the queue? */
3503 int res
= gdb_do_one_event ();
3505 /* Was there an error? */
3510 /* We are done with the event loop. There are no more event sources
3511 to listen to. So we exit gdbserver. */
3515 kill_inferior_callback (process_info
*process
)
3517 kill_inferior (process
);
3518 discard_queued_stop_replies (ptid_t (process
->pid
));
3521 /* Call this when exiting gdbserver with possible inferiors that need
3522 to be killed or detached from. */
3525 detach_or_kill_for_exit (void)
3527 /* First print a list of the inferiors we will be killing/detaching.
3528 This is to assist the user, for example, in case the inferior unexpectedly
3529 dies after we exit: did we screw up or did the inferior exit on its own?
3530 Having this info will save some head-scratching. */
3532 if (have_started_inferiors_p ())
3534 fprintf (stderr
, "Killing process(es):");
3536 for_each_process ([] (process_info
*process
) {
3537 if (!process
->attached
)
3538 fprintf (stderr
, " %d", process
->pid
);
3541 fprintf (stderr
, "\n");
3543 if (have_attached_inferiors_p ())
3545 fprintf (stderr
, "Detaching process(es):");
3547 for_each_process ([] (process_info
*process
) {
3548 if (process
->attached
)
3549 fprintf (stderr
, " %d", process
->pid
);
3552 fprintf (stderr
, "\n");
3555 /* Now we can kill or detach the inferiors. */
3556 for_each_process ([] (process_info
*process
) {
3557 int pid
= process
->pid
;
3559 if (process
->attached
)
3560 detach_inferior (process
);
3562 kill_inferior (process
);
3564 discard_queued_stop_replies (ptid_t (pid
));
3568 /* Value that will be passed to exit(3) when gdbserver exits. */
3569 static int exit_code
;
3571 /* Wrapper for detach_or_kill_for_exit that catches and prints
3575 detach_or_kill_for_exit_cleanup ()
3579 detach_or_kill_for_exit ();
3581 catch (const gdb_exception
&exception
)
3584 fprintf (stderr
, "Detach or kill failed: %s\n",
3592 namespace selftests
{
3595 test_memory_tagging_functions (void)
3597 /* Setup testing. */
3598 gdb::char_vector packet
;
3599 gdb::byte_vector tags
, bv
;
3600 std::string expected
;
3601 packet
.resize (32000);
3606 /* Test parsing a qMemTags request. */
3608 /* Valid request, addr, len and type updated. */
3612 strcpy (packet
.data (), "qMemTags:0,0:0");
3613 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3614 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0);
3616 /* Valid request, addr, len and type updated. */
3620 strcpy (packet
.data (), "qMemTags:deadbeef,ff:5");
3621 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3622 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5);
3624 /* Test creating a qMemTags reply. */
3626 /* Non-empty tag data. */
3629 for (int i
= 0; i
< 5; i
++)
3632 expected
= "m0001020304";
3633 SELF_CHECK (create_fetch_memtags_reply (packet
.data (), bv
) == true);
3634 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
3636 /* Test parsing a QMemTags request. */
3638 /* Valid request and empty tag data: addr, len, type and tags updated. */
3643 strcpy (packet
.data (), "QMemTags:0,0:0:");
3644 SELF_CHECK (parse_store_memtags_request (packet
.data (),
3645 &addr
, &len
, tags
, &type
) == true);
3646 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0 && tags
.size () == 0);
3648 /* Valid request and non-empty tag data: addr, len, type
3649 and tags updated. */
3654 strcpy (packet
.data (),
3655 "QMemTags:deadbeef,ff:5:0001020304");
3656 SELF_CHECK (parse_store_memtags_request (packet
.data (), &addr
, &len
, tags
,
3658 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5
3659 && tags
.size () == 5);
3662 } // namespace selftests
3663 #endif /* GDB_SELF_TEST */
3665 /* Main function. This is called by the real "main" function,
3666 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3668 static void ATTRIBUTE_NORETURN
3669 captured_main (int argc
, char *argv
[])
3674 const char *port
= NULL
;
3675 char **next_arg
= &argv
[1];
3676 volatile int multi_mode
= 0;
3677 volatile int attach
= 0;
3679 bool selftest
= false;
3681 std::vector
<const char *> selftest_filters
;
3683 selftests::register_test ("remote_memory_tagging",
3684 selftests::test_memory_tagging_functions
);
3687 current_directory
= getcwd (NULL
, 0);
3688 client_state
&cs
= get_client_state ();
3690 if (current_directory
== NULL
)
3692 error (_("Could not find current working directory: %s"),
3693 safe_strerror (errno
));
3696 while (*next_arg
!= NULL
&& **next_arg
== '-')
3698 if (strcmp (*next_arg
, "--version") == 0)
3700 gdbserver_version ();
3703 else if (strcmp (*next_arg
, "--help") == 0)
3705 gdbserver_usage (stdout
);
3708 else if (strcmp (*next_arg
, "--attach") == 0)
3710 else if (strcmp (*next_arg
, "--multi") == 0)
3712 else if (strcmp (*next_arg
, "--wrapper") == 0)
3719 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3721 wrapper_argv
+= *next_arg
;
3722 wrapper_argv
+= ' ';
3726 if (!wrapper_argv
.empty ())
3728 /* Erase the last whitespace. */
3729 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3732 if (next_arg
== tmp
|| *next_arg
== NULL
)
3734 gdbserver_usage (stderr
);
3738 /* Consume the "--". */
3741 else if (strcmp (*next_arg
, "--debug") == 0)
3742 debug_threads
= true;
3743 else if (startswith (*next_arg
, "--debug-format="))
3745 std::string error_msg
3746 = parse_debug_format_options ((*next_arg
)
3747 + sizeof ("--debug-format=") - 1, 0);
3749 if (!error_msg
.empty ())
3751 fprintf (stderr
, "%s", error_msg
.c_str ());
3755 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3756 remote_debug
= true;
3757 else if (strcmp (*next_arg
, "--event-loop-debug") == 0)
3758 debug_event_loop
= debug_event_loop_kind::ALL
;
3759 else if (startswith (*next_arg
, "--debug-file="))
3760 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3761 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3763 gdbserver_show_disableable (stdout
);
3766 else if (startswith (*next_arg
, "--disable-packet="))
3768 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3770 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3772 tok
= strtok_r (NULL
, ",", &saveptr
))
3774 if (strcmp ("vCont", tok
) == 0)
3775 disable_packet_vCont
= true;
3776 else if (strcmp ("Tthread", tok
) == 0)
3777 disable_packet_Tthread
= true;
3778 else if (strcmp ("qC", tok
) == 0)
3779 disable_packet_qC
= true;
3780 else if (strcmp ("qfThreadInfo", tok
) == 0)
3781 disable_packet_qfThreadInfo
= true;
3782 else if (strcmp ("T", tok
) == 0)
3783 disable_packet_T
= true;
3784 else if (strcmp ("threads", tok
) == 0)
3786 disable_packet_vCont
= true;
3787 disable_packet_Tthread
= true;
3788 disable_packet_qC
= true;
3789 disable_packet_qfThreadInfo
= true;
3793 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3795 gdbserver_show_disableable (stderr
);
3800 else if (strcmp (*next_arg
, "-") == 0)
3802 /* "-" specifies a stdio connection and is a form of port
3804 port
= STDIO_CONNECTION_NAME
;
3808 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3809 cs
.disable_randomization
= 1;
3810 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3811 cs
.disable_randomization
= 0;
3812 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3813 startup_with_shell
= true;
3814 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3815 startup_with_shell
= false;
3816 else if (strcmp (*next_arg
, "--once") == 0)
3818 else if (strcmp (*next_arg
, "--selftest") == 0)
3820 else if (startswith (*next_arg
, "--selftest="))
3825 const char *filter
= *next_arg
+ strlen ("--selftest=");
3826 if (*filter
== '\0')
3828 fprintf (stderr
, _("Error: selftest filter is empty.\n"));
3832 selftest_filters
.push_back (filter
);
3837 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3850 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3853 gdbserver_usage (stderr
);
3857 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3858 opened by remote_prepare. */
3861 save_original_signals_state (false);
3863 /* We need to know whether the remote connection is stdio before
3864 starting the inferior. Inferiors created in this scenario have
3865 stdin,stdout redirected. So do this here before we call
3868 remote_prepare (port
);
3873 /* --attach used to come after PORT, so allow it there for
3875 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3882 && (*next_arg
== NULL
3883 || (*next_arg
)[0] == '\0'
3884 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3886 || next_arg
[1] != NULL
))
3891 gdbserver_usage (stderr
);
3895 /* Gather information about the environment. */
3896 our_environ
= gdb_environ::from_host_environ ();
3898 initialize_async_io ();
3900 have_job_control ();
3901 if (target_supports_tracepoints ())
3902 initialize_tracepoint ();
3904 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3909 selftests::run_tests (selftest_filters
);
3911 printf (_("Selftests have been disabled for this build.\n"));
3913 throw_quit ("Quit");
3916 if (pid
== 0 && *next_arg
!= NULL
)
3920 n
= argc
- (next_arg
- argv
);
3921 program_path
.set (next_arg
[0]);
3922 for (i
= 1; i
< n
; i
++)
3923 program_args
.push_back (xstrdup (next_arg
[i
]));
3925 /* Wait till we are at first instruction in program. */
3926 target_create_inferior (program_path
.get (), program_args
);
3928 /* We are now (hopefully) stopped at the first instruction of
3929 the target process. This assumes that the target process was
3930 successfully created. */
3934 if (attach_inferior (pid
) == -1)
3935 error ("Attaching not supported on this target");
3937 /* Otherwise succeeded. */
3941 cs
.last_status
.set_exited (0);
3942 cs
.last_ptid
= minus_one_ptid
;
3945 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3947 /* Don't report shared library events on the initial connection,
3948 even if some libraries are preloaded. Avoids the "stopped by
3949 shared library event" notice on gdb side. */
3950 if (current_thread
!= nullptr)
3951 current_process ()->dlls_changed
= false;
3953 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
3954 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
3959 if (!was_running
&& !multi_mode
)
3960 error ("No program to debug");
3965 cs
.multi_process
= 0;
3966 cs
.report_fork_events
= 0;
3967 cs
.report_vfork_events
= 0;
3968 cs
.report_exec_events
= 0;
3969 /* Be sure we're out of tfind mode. */
3970 cs
.current_traceframe
= -1;
3971 cs
.cont_thread
= null_ptid
;
3972 cs
.swbreak_feature
= 0;
3973 cs
.hwbreak_feature
= 0;
3974 cs
.vCont_supported
= 0;
3975 cs
.memory_tagging_feature
= false;
3981 /* Wait for events. This will return when all event sources
3982 are removed from the event loop. */
3983 start_event_loop ();
3985 /* If an exit was requested (using the "monitor exit"
3986 command), terminate now. */
3988 throw_quit ("Quit");
3990 /* The only other way to get here is for getpkt to fail:
3992 - If --once was specified, we're done.
3994 - If not in extended-remote mode, and we're no longer
3995 debugging anything, simply exit: GDB has disconnected
3996 after processing the last process exit.
3998 - Otherwise, close the connection and reopen it at the
4000 if (run_once
|| (!extended_protocol
&& !target_running ()))
4001 throw_quit ("Quit");
4004 "Remote side has terminated connection. "
4005 "GDBserver will reopen the connection.\n");
4007 /* Get rid of any pending statuses. An eventual reconnection
4008 (by the same GDB instance or another) will refresh all its
4009 state from scratch. */
4010 discard_queued_stop_replies (minus_one_ptid
);
4011 for_each_thread ([] (thread_info
*thread
)
4013 thread
->status_pending_p
= 0;
4018 if (disconnected_tracing
)
4020 /* Try to enable non-stop/async mode, so we we can
4021 both wait for an async socket accept, and handle
4022 async target events simultaneously. There's also
4023 no point either in having the target always stop
4024 all threads, when we're going to pass signals
4025 down without informing GDB. */
4028 if (the_target
->start_non_stop (true))
4031 /* Detaching implicitly resumes all threads;
4032 simply disconnecting does not. */
4038 "Disconnected tracing disabled; "
4039 "stopping trace run.\n");
4044 catch (const gdb_exception_error
&exception
)
4047 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
4049 if (response_needed
)
4051 write_enn (cs
.own_buf
);
4052 putpkt (cs
.own_buf
);
4056 throw_quit ("Quit");
4061 /* Main function. */
4064 main (int argc
, char *argv
[])
4069 captured_main (argc
, argv
);
4071 catch (const gdb_exception
&exception
)
4073 if (exception
.reason
== RETURN_ERROR
)
4076 fprintf (stderr
, "%s\n", exception
.what ());
4077 fprintf (stderr
, "Exiting\n");
4084 gdb_assert_not_reached ("captured_main should never return");
4087 /* Process options coming from Z packets for a breakpoint. PACKET is
4088 the packet buffer. *PACKET is updated to point to the first char
4089 after the last processed option. */
4092 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4094 const char *dataptr
= *packet
;
4097 /* Check if data has the correct format. */
4098 if (*dataptr
!= ';')
4105 if (*dataptr
== ';')
4108 if (*dataptr
== 'X')
4110 /* Conditional expression. */
4111 threads_debug_printf ("Found breakpoint condition.");
4112 if (!add_breakpoint_condition (bp
, &dataptr
))
4113 dataptr
= strchrnul (dataptr
, ';');
4115 else if (startswith (dataptr
, "cmds:"))
4117 dataptr
+= strlen ("cmds:");
4118 threads_debug_printf ("Found breakpoint commands %s.", dataptr
);
4119 persist
= (*dataptr
== '1');
4121 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4122 dataptr
= strchrnul (dataptr
, ';');
4126 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4128 /* Skip tokens until we find one that we recognize. */
4129 dataptr
= strchrnul (dataptr
, ';');
4135 /* Event loop callback that handles a serial event. The first byte in
4136 the serial buffer gets us here. We expect characters to arrive at
4137 a brisk pace, so we read the rest of the packet with a blocking
4141 process_serial_event (void)
4143 client_state
&cs
= get_client_state ();
4149 int new_packet_len
= -1;
4151 disable_async_io ();
4153 response_needed
= false;
4154 packet_len
= getpkt (cs
.own_buf
);
4155 if (packet_len
<= 0)
4158 /* Force an event loop break. */
4161 response_needed
= true;
4163 char ch
= cs
.own_buf
[0];
4167 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4170 handle_general_set (cs
.own_buf
);
4173 handle_detach (cs
.own_buf
);
4176 extended_protocol
= true;
4177 write_ok (cs
.own_buf
);
4180 handle_status (cs
.own_buf
);
4183 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4185 require_running_or_break (cs
.own_buf
);
4187 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4189 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4190 thread_id
= null_ptid
;
4191 else if (thread_id
.is_pid ())
4193 /* The ptid represents a pid. */
4194 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4198 write_enn (cs
.own_buf
);
4202 thread_id
= thread
->id
;
4206 /* The ptid represents a lwp/tid. */
4207 if (find_thread_ptid (thread_id
) == NULL
)
4209 write_enn (cs
.own_buf
);
4214 if (cs
.own_buf
[1] == 'g')
4216 if (thread_id
== null_ptid
)
4218 /* GDB is telling us to choose any thread. Check if
4219 the currently selected thread is still valid. If
4220 it is not, select the first available. */
4221 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4223 thread
= get_first_thread ();
4224 thread_id
= thread
->id
;
4227 cs
.general_thread
= thread_id
;
4228 set_desired_thread ();
4229 gdb_assert (current_thread
!= NULL
);
4231 else if (cs
.own_buf
[1] == 'c')
4232 cs
.cont_thread
= thread_id
;
4234 write_ok (cs
.own_buf
);
4238 /* Silently ignore it so that gdb can extend the protocol
4239 without compatibility headaches. */
4240 cs
.own_buf
[0] = '\0';
4244 require_running_or_break (cs
.own_buf
);
4245 if (cs
.current_traceframe
>= 0)
4247 struct regcache
*regcache
4248 = new_register_cache (current_target_desc ());
4250 if (fetch_traceframe_registers (cs
.current_traceframe
,
4252 registers_to_string (regcache
, cs
.own_buf
);
4254 write_enn (cs
.own_buf
);
4255 free_register_cache (regcache
);
4259 struct regcache
*regcache
;
4261 if (!set_desired_thread ())
4262 write_enn (cs
.own_buf
);
4265 regcache
= get_thread_regcache (current_thread
, 1);
4266 registers_to_string (regcache
, cs
.own_buf
);
4271 require_running_or_break (cs
.own_buf
);
4272 if (cs
.current_traceframe
>= 0)
4273 write_enn (cs
.own_buf
);
4276 struct regcache
*regcache
;
4278 if (!set_desired_thread ())
4279 write_enn (cs
.own_buf
);
4282 regcache
= get_thread_regcache (current_thread
, 1);
4283 registers_from_string (regcache
, &cs
.own_buf
[1]);
4284 write_ok (cs
.own_buf
);
4290 require_running_or_break (cs
.own_buf
);
4291 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4292 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4294 write_enn (cs
.own_buf
);
4296 bin2hex (mem_buf
, cs
.own_buf
, res
);
4300 require_running_or_break (cs
.own_buf
);
4301 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4302 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4303 write_ok (cs
.own_buf
);
4305 write_enn (cs
.own_buf
);
4308 require_running_or_break (cs
.own_buf
);
4309 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4310 &mem_addr
, &len
, &mem_buf
) < 0
4311 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4312 write_enn (cs
.own_buf
);
4314 write_ok (cs
.own_buf
);
4317 require_running_or_break (cs
.own_buf
);
4318 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4319 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4320 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4323 myresume (cs
.own_buf
, 0, signal
);
4326 require_running_or_break (cs
.own_buf
);
4327 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4328 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4329 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4332 myresume (cs
.own_buf
, 1, signal
);
4335 require_running_or_break (cs
.own_buf
);
4337 myresume (cs
.own_buf
, 0, signal
);
4340 require_running_or_break (cs
.own_buf
);
4342 myresume (cs
.own_buf
, 1, signal
);
4344 case 'Z': /* insert_ ... */
4346 case 'z': /* remove_ ... */
4351 char type
= cs
.own_buf
[1];
4353 const int insert
= ch
== 'Z';
4354 const char *p
= &cs
.own_buf
[3];
4356 p
= unpack_varlen_hex (p
, &addr
);
4357 kind
= strtol (p
+ 1, &dataptr
, 16);
4361 struct gdb_breakpoint
*bp
;
4363 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4368 /* GDB may have sent us a list of *point parameters to
4369 be evaluated on the target's side. Read such list
4370 here. If we already have a list of parameters, GDB
4371 is telling us to drop that list and use this one
4373 clear_breakpoint_conditions_and_commands (bp
);
4374 const char *options
= dataptr
;
4375 process_point_options (bp
, &options
);
4379 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4382 write_ok (cs
.own_buf
);
4385 cs
.own_buf
[0] = '\0';
4387 write_enn (cs
.own_buf
);
4391 response_needed
= false;
4392 if (!target_running ())
4393 /* The packet we received doesn't make sense - but we can't
4394 reply to it, either. */
4397 fprintf (stderr
, "Killing all inferiors\n");
4399 for_each_process (kill_inferior_callback
);
4401 /* When using the extended protocol, we wait with no program
4402 running. The traditional protocol will exit instead. */
4403 if (extended_protocol
)
4405 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4413 require_running_or_break (cs
.own_buf
);
4415 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4416 if (find_thread_ptid (thread_id
) == NULL
)
4418 write_enn (cs
.own_buf
);
4422 if (mythread_alive (thread_id
))
4423 write_ok (cs
.own_buf
);
4425 write_enn (cs
.own_buf
);
4429 response_needed
= false;
4431 /* Restarting the inferior is only supported in the extended
4433 if (extended_protocol
)
4435 if (target_running ())
4436 for_each_process (kill_inferior_callback
);
4438 fprintf (stderr
, "GDBserver restarting\n");
4440 /* Wait till we are at 1st instruction in prog. */
4441 if (program_path
.get () != NULL
)
4443 target_create_inferior (program_path
.get (), program_args
);
4445 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4447 /* Stopped at the first instruction of the target
4449 cs
.general_thread
= cs
.last_ptid
;
4453 /* Something went wrong. */
4454 cs
.general_thread
= null_ptid
;
4459 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4465 /* It is a request we don't understand. Respond with an
4466 empty packet so that gdb knows that we don't support this
4468 cs
.own_buf
[0] = '\0';
4472 /* Extended (long) request. */
4473 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4477 /* It is a request we don't understand. Respond with an empty
4478 packet so that gdb knows that we don't support this
4480 cs
.own_buf
[0] = '\0';
4484 if (new_packet_len
!= -1)
4485 putpkt_binary (cs
.own_buf
, new_packet_len
);
4487 putpkt (cs
.own_buf
);
4489 response_needed
= false;
4497 /* Event-loop callback for serial events. */
4500 handle_serial_event (int err
, gdb_client_data client_data
)
4502 threads_debug_printf ("handling possible serial event");
4504 /* Really handle it. */
4505 if (process_serial_event () < 0)
4507 keep_processing_events
= false;
4511 /* Be sure to not change the selected thread behind GDB's back.
4512 Important in the non-stop mode asynchronous protocol. */
4513 set_desired_thread ();
4516 /* Push a stop notification on the notification queue. */
4519 push_stop_notification (ptid_t ptid
, const target_waitstatus
&status
)
4521 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4523 vstop_notif
->status
= status
;
4524 vstop_notif
->ptid
= ptid
;
4525 /* Push Stop notification. */
4526 notif_push (¬if_stop
, vstop_notif
);
4529 /* Event-loop callback for target events. */
4532 handle_target_event (int err
, gdb_client_data client_data
)
4534 client_state
&cs
= get_client_state ();
4535 threads_debug_printf ("handling possible target event");
4537 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4540 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
)
4542 if (gdb_connected () && report_no_resumed
)
4543 push_stop_notification (null_ptid
, cs
.last_status
);
4545 else if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
)
4547 int pid
= cs
.last_ptid
.pid ();
4548 struct process_info
*process
= find_process_pid (pid
);
4549 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4551 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4552 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
4554 mark_breakpoints_out (process
);
4555 target_mourn_inferior (cs
.last_ptid
);
4557 else if (cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4561 /* We're reporting this thread as stopped. Update its
4562 "want-stopped" state to what the client wants, until it
4563 gets a new resume action. */
4564 current_thread
->last_resume_kind
= resume_stop
;
4565 current_thread
->last_status
= cs
.last_status
;
4570 if (!target_running ())
4572 /* The last process exited. We're done. */
4576 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4577 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
4578 || cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4582 /* A thread stopped with a signal, but gdb isn't
4583 connected to handle it. Pass it down to the
4584 inferior, as if it wasn't being traced. */
4585 enum gdb_signal signal
;
4587 threads_debug_printf ("GDB not connected; forwarding event %d for"
4589 (int) cs
.last_status
.kind (),
4590 target_pid_to_str (cs
.last_ptid
).c_str ());
4592 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4593 signal
= cs
.last_status
.sig ();
4595 signal
= GDB_SIGNAL_0
;
4596 target_continue (cs
.last_ptid
, signal
);
4600 push_stop_notification (cs
.last_ptid
, cs
.last_status
);
4603 /* Be sure to not change the selected thread behind GDB's back.
4604 Important in the non-stop mode asynchronous protocol. */
4605 set_desired_thread ();
4608 /* See gdbsupport/event-loop.h. */
4611 invoke_async_signal_handlers ()
4616 /* See gdbsupport/event-loop.h. */
4619 check_async_event_handlers ()
4624 /* See gdbsupport/errors.h */
4633 /* See gdbsupport/gdb_select.h. */
4636 gdb_select (int n
, fd_set
*readfds
, fd_set
*writefds
,
4637 fd_set
*exceptfds
, struct timeval
*timeout
)
4639 return select (n
, readfds
, writefds
, exceptfds
, timeout
);
4650 } // namespace selftests
4651 #endif /* GDB_SELF_TEST */