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 <unordered_map>
40 #include "gdbsupport/common-inferior.h"
41 #include "gdbsupport/job-control.h"
42 #include "gdbsupport/environ.h"
43 #include "filenames.h"
44 #include "gdbsupport/pathstuff.h"
46 #include "xml-builtin.h"
49 #include "gdbsupport/selftest.h"
50 #include "gdbsupport/scope-exit.h"
51 #include "gdbsupport/gdb_select.h"
52 #include "gdbsupport/scoped_restore.h"
53 #include "gdbsupport/search.h"
55 /* PBUFSIZ must also be at least as big as IPA_CMD_BUF_SIZE, because
56 the client state data is passed directly to some agent
58 gdb_static_assert (PBUFSIZ
>= IPA_CMD_BUF_SIZE
);
60 #define require_running_or_return(BUF) \
61 if (!target_running ()) \
67 #define require_running_or_break(BUF) \
68 if (!target_running ()) \
74 /* The environment to pass to the inferior when creating it. */
76 static gdb_environ our_environ
;
80 static bool extended_protocol
;
81 static bool response_needed
;
82 static bool exit_requested
;
84 /* --once: Exit after the first connection has closed. */
87 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
88 static bool report_no_resumed
;
90 /* The event loop checks this to decide whether to continue accepting
92 static bool keep_processing_events
= true;
97 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
99 void set (const char *path
)
103 /* Make sure we're using the absolute path of the inferior when
105 if (!contains_dir_separator (m_path
.c_str ()))
109 /* Check if the file is in our CWD. If it is, then we prefix
110 its name with CURRENT_DIRECTORY. Otherwise, we leave the
111 name as-is because we'll try searching for it in $PATH. */
112 if (is_regular_file (m_path
.c_str (), ®_file_errno
))
113 m_path
= gdb_abspath (m_path
.c_str ());
117 /* Return the PROGRAM_PATH. */
119 { return m_path
.empty () ? nullptr : m_path
.c_str (); }
122 /* The program name, adjusted if needed. */
125 static std::vector
<char *> program_args
;
126 static std::string wrapper_argv
;
128 /* The PID of the originally created or attached inferior. Used to
129 send signals to the process when GDB sends us an asynchronous interrupt
130 (user hitting Control-C in the client), and to wait for the child to exit
131 when no longer debugging it. */
133 unsigned long signal_pid
;
135 /* Set if you want to disable optional thread related packets support
136 in gdbserver, for the sake of testing GDB against stubs that don't
138 bool disable_packet_vCont
;
139 bool disable_packet_Tthread
;
140 bool disable_packet_qC
;
141 bool disable_packet_qfThreadInfo
;
142 bool disable_packet_T
;
144 static unsigned char *mem_buf
;
146 /* A sub-class of 'struct notif_event' for stop, holding information
147 relative to a single stop reply. We keep a queue of these to
148 push to GDB in non-stop mode. */
150 struct vstop_notif
: public notif_event
152 /* Thread or process that got the event. */
156 struct target_waitstatus status
;
159 /* The current btrace configuration. This is gdbserver's mirror of GDB's
160 btrace configuration. */
161 static struct btrace_config current_btrace_conf
;
163 /* The client remote protocol state. */
165 static client_state g_client_state
;
170 client_state
&cs
= g_client_state
;
175 /* Put a stop reply to the stop reply queue. */
178 queue_stop_reply (ptid_t ptid
, const target_waitstatus
&status
)
180 struct vstop_notif
*new_notif
= new struct vstop_notif
;
182 new_notif
->ptid
= ptid
;
183 new_notif
->status
= status
;
185 notif_event_enque (¬if_stop
, new_notif
);
189 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
191 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
193 return vstop_event
->ptid
.matches (filter_ptid
);
199 discard_queued_stop_replies (ptid_t ptid
)
201 std::list
<notif_event
*>::iterator iter
, next
, end
;
202 end
= notif_stop
.queue
.end ();
203 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
208 if (iter
== notif_stop
.queue
.begin ())
210 /* The head of the list contains the notification that was
211 already sent to GDB. So we can't remove it, otherwise
212 when GDB sends the vStopped, it would ack the _next_
213 notification, which hadn't been sent yet! */
217 if (remove_all_on_match_ptid (*iter
, ptid
))
220 notif_stop
.queue
.erase (iter
);
226 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
228 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
230 prepare_resume_reply (own_buf
, vstop
->ptid
, vstop
->status
);
233 /* Helper for in_queued_stop_replies. */
236 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
238 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
240 if (vstop_event
->ptid
.matches (filter_ptid
))
243 /* Don't resume fork children that GDB does not know about yet. */
244 if ((vstop_event
->status
.kind () == TARGET_WAITKIND_FORKED
245 || vstop_event
->status
.kind () == TARGET_WAITKIND_VFORKED
246 || vstop_event
->status
.kind () == TARGET_WAITKIND_THREAD_CLONED
)
247 && vstop_event
->status
.child_ptid ().matches (filter_ptid
))
256 in_queued_stop_replies (ptid_t ptid
)
258 for (notif_event
*event
: notif_stop
.queue
)
260 if (in_queued_stop_replies_ptid (event
, ptid
))
267 struct notif_server notif_stop
=
269 "vStopped", "Stop", {}, vstop_notif_reply
,
273 target_running (void)
275 return get_first_thread () != NULL
;
278 /* See gdbsupport/common-inferior.h. */
283 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
286 /* See gdbsupport/common-inferior.h. */
289 get_exec_file (int err
)
291 if (err
&& program_path
.get () == NULL
)
292 error (_("No executable file specified."));
294 return program_path
.get ();
306 attach_inferior (int pid
)
308 client_state
&cs
= get_client_state ();
309 /* myattach should return -1 if attaching is unsupported,
310 0 if it succeeded, and call error() otherwise. */
312 if (find_process_pid (pid
) != nullptr)
313 error ("Already attached to process %d\n", pid
);
315 if (myattach (pid
) != 0)
318 fprintf (stderr
, "Attached; pid = %d\n", pid
);
321 /* FIXME - It may be that we should get the SIGNAL_PID from the
322 attach function, so that it can be the main thread instead of
323 whichever we were told to attach to. */
328 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
330 /* GDB knows to ignore the first SIGSTOP after attaching to a running
331 process using the "attach" command, but this is different; it's
332 just using "target remote". Pretend it's just starting up. */
333 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
334 && cs
.last_status
.sig () == GDB_SIGNAL_STOP
)
335 cs
.last_status
.set_stopped (GDB_SIGNAL_TRAP
);
337 current_thread
->last_resume_kind
= resume_stop
;
338 current_thread
->last_status
= cs
.last_status
;
344 /* Decode a qXfer read request. Return 0 if everything looks OK,
348 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
350 /* After the read marker and annex, qXfer looks like a
351 traditional 'm' packet. */
352 decode_m_packet (buf
, ofs
, len
);
358 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
360 /* Extract and NUL-terminate the object. */
362 while (*buf
&& *buf
!= ':')
368 /* Extract and NUL-terminate the read/write action. */
370 while (*buf
&& *buf
!= ':')
376 /* Extract and NUL-terminate the annex. */
378 while (*buf
&& *buf
!= ':')
388 /* Write the response to a successful qXfer read. Returns the
389 length of the (binary) data stored in BUF, corresponding
390 to as much of DATA/LEN as we could fit. IS_MORE controls
391 the first character of the response. */
393 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
402 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
403 &out_len
, PBUFSIZ
- 2) + 1;
406 /* Handle btrace enabling in BTS format. */
409 handle_btrace_enable_bts (struct thread_info
*thread
)
411 if (thread
->btrace
!= NULL
)
412 error (_("Btrace already enabled."));
414 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
415 thread
->btrace
= target_enable_btrace (thread
, ¤t_btrace_conf
);
418 /* Handle btrace enabling in Intel Processor Trace format. */
421 handle_btrace_enable_pt (struct thread_info
*thread
)
423 if (thread
->btrace
!= NULL
)
424 error (_("Btrace already enabled."));
426 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
427 thread
->btrace
= target_enable_btrace (thread
, ¤t_btrace_conf
);
430 /* Handle btrace disabling. */
433 handle_btrace_disable (struct thread_info
*thread
)
436 if (thread
->btrace
== NULL
)
437 error (_("Branch tracing not enabled."));
439 if (target_disable_btrace (thread
->btrace
) != 0)
440 error (_("Could not disable branch tracing."));
442 thread
->btrace
= NULL
;
445 /* Handle the "Qbtrace" packet. */
448 handle_btrace_general_set (char *own_buf
)
450 client_state
&cs
= get_client_state ();
451 struct thread_info
*thread
;
454 if (!startswith (own_buf
, "Qbtrace:"))
457 op
= own_buf
+ strlen ("Qbtrace:");
459 if (cs
.general_thread
== null_ptid
460 || cs
.general_thread
== minus_one_ptid
)
462 strcpy (own_buf
, "E.Must select a single thread.");
466 thread
= find_thread_ptid (cs
.general_thread
);
469 strcpy (own_buf
, "E.No such thread.");
475 if (strcmp (op
, "bts") == 0)
476 handle_btrace_enable_bts (thread
);
477 else if (strcmp (op
, "pt") == 0)
478 handle_btrace_enable_pt (thread
);
479 else if (strcmp (op
, "off") == 0)
480 handle_btrace_disable (thread
);
482 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
486 catch (const gdb_exception_error
&exception
)
488 sprintf (own_buf
, "E.%s", exception
.what ());
494 /* Handle the "Qbtrace-conf" packet. */
497 handle_btrace_conf_general_set (char *own_buf
)
499 client_state
&cs
= get_client_state ();
500 struct thread_info
*thread
;
503 if (!startswith (own_buf
, "Qbtrace-conf:"))
506 op
= own_buf
+ strlen ("Qbtrace-conf:");
508 if (cs
.general_thread
== null_ptid
509 || cs
.general_thread
== minus_one_ptid
)
511 strcpy (own_buf
, "E.Must select a single thread.");
515 thread
= find_thread_ptid (cs
.general_thread
);
518 strcpy (own_buf
, "E.No such thread.");
522 if (startswith (op
, "bts:size="))
528 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
529 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
531 strcpy (own_buf
, "E.Bad size value.");
535 current_btrace_conf
.bts
.size
= (unsigned int) size
;
537 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
543 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
544 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
546 strcpy (own_buf
, "E.Bad size value.");
550 current_btrace_conf
.pt
.size
= (unsigned int) size
;
554 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
562 /* Create the qMemTags packet reply given TAGS.
564 Returns true if parsing succeeded and false otherwise. */
567 create_fetch_memtags_reply (char *reply
, const gdb::byte_vector
&tags
)
569 /* It is an error to pass a zero-sized tag vector. */
570 gdb_assert (tags
.size () != 0);
572 std::string
packet ("m");
574 /* Write the tag data. */
575 packet
+= bin2hex (tags
.data (), tags
.size ());
577 /* Check if the reply is too big for the packet to handle. */
578 if (PBUFSIZ
< packet
.size ())
581 strcpy (reply
, packet
.c_str ());
585 /* Parse the QMemTags request into ADDR, LEN and TAGS.
587 Returns true if parsing succeeded and false otherwise. */
590 parse_store_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
591 gdb::byte_vector
&tags
, int *type
)
593 gdb_assert (startswith (request
, "QMemTags:"));
595 const char *p
= request
+ strlen ("QMemTags:");
597 /* Read address and length. */
598 unsigned int length
= 0;
599 p
= decode_m_packet_params (p
, addr
, &length
, ':');
602 /* Read the tag type. */
603 ULONGEST tag_type
= 0;
604 p
= unpack_varlen_hex (p
, &tag_type
);
605 *type
= (int) tag_type
;
607 /* Make sure there is a colon after the type. */
611 /* Skip the colon. */
614 /* Read the tag data. */
620 /* Parse thread options starting at *P and return them. On exit,
621 advance *P past the options. */
623 static gdb_thread_options
624 parse_gdb_thread_options (const char **p
)
626 ULONGEST options
= 0;
627 *p
= unpack_varlen_hex (*p
, &options
);
628 return (gdb_thread_option
) options
;
631 /* Handle all of the extended 'Q' packets. */
634 handle_general_set (char *own_buf
)
636 client_state
&cs
= get_client_state ();
637 if (startswith (own_buf
, "QPassSignals:"))
639 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
640 const char *p
= own_buf
+ strlen ("QPassSignals:");
643 p
= decode_address_to_semicolon (&cursig
, p
);
644 for (i
= 0; i
< numsigs
; i
++)
648 cs
.pass_signals
[i
] = 1;
650 /* Keep looping, to clear the remaining signals. */
653 p
= decode_address_to_semicolon (&cursig
, p
);
656 cs
.pass_signals
[i
] = 0;
658 strcpy (own_buf
, "OK");
662 if (startswith (own_buf
, "QProgramSignals:"))
664 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
665 const char *p
= own_buf
+ strlen ("QProgramSignals:");
668 cs
.program_signals_p
= 1;
670 p
= decode_address_to_semicolon (&cursig
, p
);
671 for (i
= 0; i
< numsigs
; i
++)
675 cs
.program_signals
[i
] = 1;
677 /* Keep looping, to clear the remaining signals. */
680 p
= decode_address_to_semicolon (&cursig
, p
);
683 cs
.program_signals
[i
] = 0;
685 strcpy (own_buf
, "OK");
689 if (startswith (own_buf
, "QCatchSyscalls:"))
691 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
694 struct process_info
*process
;
696 if (!target_running () || !target_supports_catch_syscall ())
702 if (strcmp (p
, "0") == 0)
704 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
708 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
714 process
= current_process ();
715 process
->syscalls_to_catch
.clear ();
725 p
= decode_address_to_semicolon (&sysno
, p
);
726 process
->syscalls_to_catch
.push_back (sysno
);
730 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
737 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
739 our_environ
= gdb_environ::from_host_environ ();
745 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
747 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
748 /* The final form of the environment variable. FINAL_VAR will
749 hold the 'VAR=VALUE' format. */
750 std::string final_var
= hex2str (p
);
751 std::string var_name
, var_value
;
753 remote_debug_printf ("[QEnvironmentHexEncoded received '%s']", p
);
754 remote_debug_printf ("[Environment variable to be set: '%s']",
757 size_t pos
= final_var
.find ('=');
758 if (pos
== std::string::npos
)
760 warning (_("Unexpected format for environment variable: '%s'"),
766 var_name
= final_var
.substr (0, pos
);
767 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
769 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
775 if (startswith (own_buf
, "QEnvironmentUnset:"))
777 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
778 std::string varname
= hex2str (p
);
780 remote_debug_printf ("[QEnvironmentUnset received '%s']", p
);
781 remote_debug_printf ("[Environment variable to be unset: '%s']",
784 our_environ
.unset (varname
.c_str ());
790 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
792 remote_debug_printf ("[noack mode enabled]");
799 if (startswith (own_buf
, "QNonStop:"))
801 char *mode
= own_buf
+ 9;
805 if (strcmp (mode
, "0") == 0)
807 else if (strcmp (mode
, "1") == 0)
811 /* We don't know what this mode is, so complain to
813 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
819 req_str
= req
? "non-stop" : "all-stop";
820 if (the_target
->start_non_stop (req
== 1) != 0)
822 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
827 non_stop
= (req
!= 0);
829 remote_debug_printf ("[%s mode enabled]", req_str
);
835 if (startswith (own_buf
, "QDisableRandomization:"))
837 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
840 unpack_varlen_hex (packet
, &setting
);
841 cs
.disable_randomization
= setting
;
843 remote_debug_printf (cs
.disable_randomization
844 ? "[address space randomization disabled]"
845 : "[address space randomization enabled]");
851 if (target_supports_tracepoints ()
852 && handle_tracepoint_general_set (own_buf
))
855 if (startswith (own_buf
, "QAgent:"))
857 char *mode
= own_buf
+ strlen ("QAgent:");
860 if (strcmp (mode
, "0") == 0)
862 else if (strcmp (mode
, "1") == 0)
866 /* We don't know what this value is, so complain to GDB. */
867 sprintf (own_buf
, "E.Unknown QAgent value");
871 /* Update the flag. */
873 remote_debug_printf ("[%s agent]", req
? "Enable" : "Disable");
878 if (handle_btrace_general_set (own_buf
))
881 if (handle_btrace_conf_general_set (own_buf
))
884 if (startswith (own_buf
, "QThreadEvents:"))
886 char *mode
= own_buf
+ strlen ("QThreadEvents:");
887 enum tribool req
= TRIBOOL_UNKNOWN
;
889 if (strcmp (mode
, "0") == 0)
891 else if (strcmp (mode
, "1") == 0)
895 /* We don't know what this mode is, so complain to GDB. */
897 = string_printf ("E.Unknown thread-events mode requested: %s\n",
899 strcpy (own_buf
, err
.c_str ());
903 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
905 remote_debug_printf ("[thread events are now %s]\n",
906 cs
.report_thread_events
? "enabled" : "disabled");
912 if (startswith (own_buf
, "QThreadOptions;"))
914 const char *p
= own_buf
+ strlen ("QThreadOptions");
916 gdb_thread_options supported_options
= target_supported_thread_options ();
917 if (supported_options
== 0)
919 /* Something went wrong -- we don't support any option, but
920 GDB sent the packet anyway. */
925 /* We could store the options directly in thread->thread_options
926 without this map, but that would mean that a QThreadOptions
927 packet with a wildcard like "QThreadOptions;0;3:TID" would
928 result in the debug logs showing:
930 [options for TID are now 0x0]
931 [options for TID are now 0x3]
933 It's nicer if we only print the final options for each TID,
934 and if we only print about it if the options changed compared
935 to the options that were previously set on the thread. */
936 std::unordered_map
<thread_info
*, gdb_thread_options
> set_options
;
947 /* Read the options. */
949 gdb_thread_options options
= parse_gdb_thread_options (&p
);
951 if ((options
& ~supported_options
) != 0)
953 /* GDB asked for an unknown or unsupported option, so
956 = string_printf ("E.Unknown thread options requested: %s\n",
957 to_string (options
).c_str ());
958 strcpy (own_buf
, err
.c_str ());
964 if (p
[0] == ';' || p
[0] == '\0')
965 ptid
= minus_one_ptid
;
966 else if (p
[0] == ':')
970 ptid
= read_ptid (p
+ 1, &q
);
978 if (p
[0] != ';' && p
[0] != '\0')
990 /* Convert PID.-1 => PID.0 for ptid.matches. */
991 if (ptid
.lwp () == -1)
992 ptid
= ptid_t (ptid
.pid ());
994 for_each_thread ([&] (thread_info
*thread
)
996 if (ptid_of (thread
).matches (ptid
))
997 set_options
[thread
] = options
;
1001 for (const auto &iter
: set_options
)
1003 thread_info
*thread
= iter
.first
;
1004 gdb_thread_options options
= iter
.second
;
1006 if (thread
->thread_options
!= options
)
1008 threads_debug_printf ("[options for %s are now %s]\n",
1009 target_pid_to_str (ptid_of (thread
)).c_str (),
1010 to_string (options
).c_str ());
1012 thread
->thread_options
= options
;
1020 if (startswith (own_buf
, "QStartupWithShell:"))
1022 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
1024 if (strcmp (value
, "1") == 0)
1025 startup_with_shell
= true;
1026 else if (strcmp (value
, "0") == 0)
1027 startup_with_shell
= false;
1030 /* Unknown value. */
1031 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
1033 write_enn (own_buf
);
1037 remote_debug_printf ("[Inferior will %s started with shell]",
1038 startup_with_shell
? "be" : "not be");
1044 if (startswith (own_buf
, "QSetWorkingDir:"))
1046 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
1050 std::string path
= hex2str (p
);
1052 remote_debug_printf ("[Set the inferior's current directory to %s]",
1055 set_inferior_cwd (std::move (path
));
1059 /* An empty argument means that we should clear out any
1060 previously set cwd for the inferior. */
1061 set_inferior_cwd ("");
1063 remote_debug_printf ("[Unset the inferior's current directory; will "
1064 "use gdbserver's cwd]");
1072 /* Handle store memory tags packets. */
1073 if (startswith (own_buf
, "QMemTags:")
1074 && target_supports_memory_tagging ())
1076 gdb::byte_vector tags
;
1081 require_running_or_return (own_buf
);
1083 bool ret
= parse_store_memtags_request (own_buf
, &addr
, &len
, tags
,
1087 ret
= the_target
->store_memtags (addr
, len
, tags
, type
);
1090 write_enn (own_buf
);
1097 /* Otherwise we didn't know what packet it was. Say we didn't
1103 get_features_xml (const char *annex
)
1105 const struct target_desc
*desc
= current_target_desc ();
1107 /* `desc->xmltarget' defines what to return when looking for the
1108 "target.xml" file. Its contents can either be verbatim XML code
1109 (prefixed with a '@') or else the name of the actual XML file to
1110 be used in place of "target.xml".
1112 This variable is set up from the auto-generated
1113 init_registers_... routine for the current target. */
1115 if (strcmp (annex
, "target.xml") == 0)
1117 const char *ret
= tdesc_get_features_xml (desc
);
1129 /* Look for the annex. */
1130 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
1131 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
1134 if (xml_builtin
[i
][0] != NULL
)
1135 return xml_builtin
[i
][1];
1143 monitor_show_help (void)
1145 monitor_output ("The following monitor commands are supported:\n");
1146 monitor_output (" set debug <0|1>\n");
1147 monitor_output (" Enable general debugging messages\n");
1148 monitor_output (" set debug-hw-points <0|1>\n");
1149 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
1150 monitor_output (" set remote-debug <0|1>\n");
1151 monitor_output (" Enable remote protocol debugging messages\n");
1152 monitor_output (" set event-loop-debug <0|1>\n");
1153 monitor_output (" Enable event loop debugging messages\n");
1154 monitor_output (" set debug-format option1[,option2,...]\n");
1155 monitor_output (" Add additional information to debugging messages\n");
1156 monitor_output (" Options: all, none");
1157 monitor_output (", timestamp");
1158 monitor_output ("\n");
1159 monitor_output (" exit\n");
1160 monitor_output (" Quit GDBserver\n");
1163 /* Read trace frame or inferior memory. Returns the number of bytes
1164 actually read, zero when no further transfer is possible, and -1 on
1165 error. Return of a positive value smaller than LEN does not
1166 indicate there's no more to be read, only the end of the transfer.
1167 E.g., when GDB reads memory from a traceframe, a first request may
1168 be served from a memory block that does not cover the whole request
1169 length. A following request gets the rest served from either
1170 another block (of the same traceframe) or from the read-only
1174 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1176 client_state
&cs
= get_client_state ();
1179 if (cs
.current_traceframe
>= 0)
1182 ULONGEST length
= len
;
1184 if (traceframe_read_mem (cs
.current_traceframe
,
1185 memaddr
, myaddr
, len
, &nbytes
))
1187 /* Data read from trace buffer, we're done. */
1190 if (!in_readonly_region (memaddr
, length
))
1192 /* Otherwise we have a valid readonly case, fall through. */
1193 /* (assume no half-trace half-real blocks for now) */
1196 if (set_desired_process ())
1197 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1201 return res
== 0 ? len
: -1;
1204 /* Write trace frame or inferior memory. Actually, writing to trace
1205 frames is forbidden. */
1208 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1210 client_state
&cs
= get_client_state ();
1211 if (cs
.current_traceframe
>= 0)
1217 if (set_desired_process ())
1218 ret
= target_write_memory (memaddr
, myaddr
, len
);
1225 /* Handle qSearch:memory packets. */
1228 handle_search_memory (char *own_buf
, int packet_len
)
1230 CORE_ADDR start_addr
;
1231 CORE_ADDR search_space_len
;
1233 unsigned int pattern_len
;
1235 CORE_ADDR found_addr
;
1236 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1238 pattern
= (gdb_byte
*) malloc (packet_len
);
1239 if (pattern
== NULL
)
1240 error ("Unable to allocate memory to perform the search");
1242 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1243 packet_len
- cmd_name_len
,
1244 &start_addr
, &search_space_len
,
1245 pattern
, &pattern_len
) < 0)
1248 error ("Error in parsing qSearch:memory packet");
1251 auto read_memory
= [] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
1253 return gdb_read_memory (addr
, result
, len
) == len
;
1256 found
= simple_search_memory (read_memory
, start_addr
, search_space_len
,
1257 pattern
, pattern_len
, &found_addr
);
1260 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1261 else if (found
== 0)
1262 strcpy (own_buf
, "0");
1264 strcpy (own_buf
, "E00");
1269 /* Handle the "D" packet. */
1272 handle_detach (char *own_buf
)
1274 client_state
&cs
= get_client_state ();
1276 process_info
*process
;
1278 if (cs
.multi_process
)
1281 int pid
= strtol (&own_buf
[2], NULL
, 16);
1283 process
= find_process_pid (pid
);
1287 process
= (current_thread
!= nullptr
1288 ? get_thread_process (current_thread
)
1292 if (process
== NULL
)
1294 write_enn (own_buf
);
1298 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1300 if (tracing
&& disconnected_tracing
)
1302 "Disconnected tracing in effect, "
1303 "leaving gdbserver attached to the process\n");
1305 if (any_persistent_commands (process
))
1307 "Persistent commands are present, "
1308 "leaving gdbserver attached to the process\n");
1310 /* Make sure we're in non-stop/async mode, so we we can both
1311 wait for an async socket accept, and handle async target
1312 events simultaneously. There's also no point either in
1313 having the target stop all threads, when we're going to
1314 pass signals down without informing GDB. */
1317 threads_debug_printf ("Forcing non-stop mode");
1320 the_target
->start_non_stop (true);
1323 process
->gdb_detached
= 1;
1325 /* Detaching implicitly resumes all threads. */
1326 target_continue_no_signal (minus_one_ptid
);
1332 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1335 /* We'll need this after PROCESS has been destroyed. */
1336 int pid
= process
->pid
;
1338 /* If this process has an unreported fork child, that child is not known to
1339 GDB, so GDB won't take care of detaching it. We must do it here.
1341 Here, we specifically don't want to use "safe iteration", as detaching
1342 another process might delete the next thread in the iteration, which is
1343 the one saved by the safe iterator. We will never delete the currently
1344 iterated on thread, so standard iteration should be safe. */
1345 for (thread_info
*thread
: all_threads
)
1347 /* Only threads that are of the process we are detaching. */
1348 if (thread
->id
.pid () != pid
)
1351 /* Only threads that have a pending fork event. */
1352 target_waitkind kind
;
1353 thread_info
*child
= target_thread_pending_child (thread
, &kind
);
1354 if (child
== nullptr || kind
== TARGET_WAITKIND_THREAD_CLONED
)
1357 process_info
*fork_child_process
= get_thread_process (child
);
1358 gdb_assert (fork_child_process
!= nullptr);
1360 int fork_child_pid
= fork_child_process
->pid
;
1362 if (detach_inferior (fork_child_process
) != 0)
1363 warning (_("Failed to detach fork child %s, child of %s"),
1364 target_pid_to_str (ptid_t (fork_child_pid
)).c_str (),
1365 target_pid_to_str (thread
->id
).c_str ());
1368 if (detach_inferior (process
) != 0)
1369 write_enn (own_buf
);
1372 discard_queued_stop_replies (ptid_t (pid
));
1375 if (extended_protocol
|| target_running ())
1377 /* There is still at least one inferior remaining or
1378 we are in extended mode, so don't terminate gdbserver,
1379 and instead treat this like a normal program exit. */
1380 cs
.last_status
.set_exited (0);
1381 cs
.last_ptid
= ptid_t (pid
);
1383 switch_to_thread (nullptr);
1390 /* If we are attached, then we can exit. Otherwise, we
1391 need to hang around doing nothing, until the child is
1393 join_inferior (pid
);
1399 /* Parse options to --debug-format= and "monitor set debug-format".
1400 ARG is the text after "--debug-format=" or "monitor set debug-format".
1401 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1402 This triggers calls to monitor_output.
1403 The result is an empty string if all options were parsed ok, otherwise an
1404 error message which the caller must free.
1406 N.B. These commands affect all debug format settings, they are not
1407 cumulative. If a format is not specified, it is turned off.
1408 However, we don't go to extra trouble with things like
1409 "monitor set debug-format all,none,timestamp".
1410 Instead we just parse them one at a time, in order.
1412 The syntax for "monitor set debug" we support here is not identical
1413 to gdb's "set debug foo on|off" because we also use this function to
1414 parse "--debug-format=foo,bar". */
1417 parse_debug_format_options (const char *arg
, int is_monitor
)
1419 /* First turn all debug format options off. */
1420 debug_timestamp
= 0;
1422 /* First remove leading spaces, for "monitor set debug-format". */
1423 while (isspace (*arg
))
1426 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1427 = delim_string_to_char_ptr_vec (arg
, ',');
1429 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1431 if (strcmp (option
.get (), "all") == 0)
1433 debug_timestamp
= 1;
1435 monitor_output ("All extra debug format options enabled.\n");
1437 else if (strcmp (option
.get (), "none") == 0)
1439 debug_timestamp
= 0;
1441 monitor_output ("All extra debug format options disabled.\n");
1443 else if (strcmp (option
.get (), "timestamp") == 0)
1445 debug_timestamp
= 1;
1447 monitor_output ("Timestamps will be added to debug output.\n");
1449 else if (*option
== '\0')
1451 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1455 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1459 return std::string ();
1462 /* Handle monitor commands not handled by target-specific handlers. */
1465 handle_monitor_command (char *mon
, char *own_buf
)
1467 if (strcmp (mon
, "set debug 1") == 0)
1469 debug_threads
= true;
1470 monitor_output ("Debug output enabled.\n");
1472 else if (strcmp (mon
, "set debug 0") == 0)
1474 debug_threads
= false;
1475 monitor_output ("Debug output disabled.\n");
1477 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1479 show_debug_regs
= 1;
1480 monitor_output ("H/W point debugging output enabled.\n");
1482 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1484 show_debug_regs
= 0;
1485 monitor_output ("H/W point debugging output disabled.\n");
1487 else if (strcmp (mon
, "set remote-debug 1") == 0)
1489 remote_debug
= true;
1490 monitor_output ("Protocol debug output enabled.\n");
1492 else if (strcmp (mon
, "set remote-debug 0") == 0)
1494 remote_debug
= false;
1495 monitor_output ("Protocol debug output disabled.\n");
1497 else if (strcmp (mon
, "set event-loop-debug 1") == 0)
1499 debug_event_loop
= debug_event_loop_kind::ALL
;
1500 monitor_output ("Event loop debug output enabled.\n");
1502 else if (strcmp (mon
, "set event-loop-debug 0") == 0)
1504 debug_event_loop
= debug_event_loop_kind::OFF
;
1505 monitor_output ("Event loop debug output disabled.\n");
1507 else if (startswith (mon
, "set debug-format "))
1509 std::string error_msg
1510 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1513 if (!error_msg
.empty ())
1515 monitor_output (error_msg
.c_str ());
1516 monitor_show_help ();
1517 write_enn (own_buf
);
1520 else if (strcmp (mon
, "set debug-file") == 0)
1521 debug_set_output (nullptr);
1522 else if (startswith (mon
, "set debug-file "))
1523 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1524 else if (strcmp (mon
, "help") == 0)
1525 monitor_show_help ();
1526 else if (strcmp (mon
, "exit") == 0)
1527 exit_requested
= true;
1530 monitor_output ("Unknown monitor command.\n\n");
1531 monitor_show_help ();
1532 write_enn (own_buf
);
1536 /* Associates a callback with each supported qXfer'able object. */
1540 /* The object this handler handles. */
1543 /* Request that the target transfer up to LEN 8-bit bytes of the
1544 target's OBJECT. The OFFSET, for a seekable object, specifies
1545 the starting point. The ANNEX can be used to provide additional
1546 data-specific information to the target.
1548 Return the number of bytes actually transfered, zero when no
1549 further transfer is possible, -1 on error, -2 when the transfer
1550 is not supported, and -3 on a verbose error message that should
1551 be preserved. Return of a positive value smaller than LEN does
1552 not indicate the end of the object, only the end of the transfer.
1554 One, and only one, of readbuf or writebuf must be non-NULL. */
1555 int (*xfer
) (const char *annex
,
1556 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1557 ULONGEST offset
, LONGEST len
);
1560 /* Handle qXfer:auxv:read. */
1563 handle_qxfer_auxv (const char *annex
,
1564 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1565 ULONGEST offset
, LONGEST len
)
1567 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1570 if (annex
[0] != '\0' || current_thread
== NULL
)
1573 return the_target
->read_auxv (current_thread
->id
.pid (), offset
, readbuf
,
1577 /* Handle qXfer:exec-file:read. */
1580 handle_qxfer_exec_file (const char *annex
,
1581 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1582 ULONGEST offset
, LONGEST len
)
1587 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1590 if (annex
[0] == '\0')
1592 if (current_thread
== NULL
)
1595 pid
= pid_of (current_thread
);
1599 annex
= unpack_varlen_hex (annex
, &pid
);
1600 if (annex
[0] != '\0')
1607 const char *file
= the_target
->pid_to_exec_file (pid
);
1611 total_len
= strlen (file
);
1613 if (offset
> total_len
)
1616 if (offset
+ len
> total_len
)
1617 len
= total_len
- offset
;
1619 memcpy (readbuf
, file
+ offset
, len
);
1623 /* Handle qXfer:features:read. */
1626 handle_qxfer_features (const char *annex
,
1627 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1628 ULONGEST offset
, LONGEST len
)
1630 const char *document
;
1633 if (writebuf
!= NULL
)
1636 if (!target_running ())
1639 /* Grab the correct annex. */
1640 document
= get_features_xml (annex
);
1641 if (document
== NULL
)
1644 total_len
= strlen (document
);
1646 if (offset
> total_len
)
1649 if (offset
+ len
> total_len
)
1650 len
= total_len
- offset
;
1652 memcpy (readbuf
, document
+ offset
, len
);
1656 /* Handle qXfer:libraries:read. */
1659 handle_qxfer_libraries (const char *annex
,
1660 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1661 ULONGEST offset
, LONGEST len
)
1663 if (writebuf
!= NULL
)
1666 if (annex
[0] != '\0' || current_thread
== NULL
)
1669 std::string document
= "<library-list version=\"1.0\">\n";
1671 process_info
*proc
= current_process ();
1672 for (const dll_info
&dll
: proc
->all_dlls
)
1673 document
+= string_printf
1674 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1675 dll
.name
.c_str (), paddress (dll
.base_addr
));
1677 document
+= "</library-list>\n";
1679 if (offset
> document
.length ())
1682 if (offset
+ len
> document
.length ())
1683 len
= document
.length () - offset
;
1685 memcpy (readbuf
, &document
[offset
], len
);
1690 /* Handle qXfer:libraries-svr4:read. */
1693 handle_qxfer_libraries_svr4 (const char *annex
,
1694 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1695 ULONGEST offset
, LONGEST len
)
1697 if (writebuf
!= NULL
)
1700 if (current_thread
== NULL
1701 || !the_target
->supports_qxfer_libraries_svr4 ())
1704 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1708 /* Handle qXfer:osadata:read. */
1711 handle_qxfer_osdata (const char *annex
,
1712 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1713 ULONGEST offset
, LONGEST len
)
1715 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1718 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1721 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1724 handle_qxfer_siginfo (const char *annex
,
1725 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1726 ULONGEST offset
, LONGEST len
)
1728 if (!the_target
->supports_qxfer_siginfo ())
1731 if (annex
[0] != '\0' || current_thread
== NULL
)
1734 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1737 /* Handle qXfer:statictrace:read. */
1740 handle_qxfer_statictrace (const char *annex
,
1741 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1742 ULONGEST offset
, LONGEST len
)
1744 client_state
&cs
= get_client_state ();
1747 if (writebuf
!= NULL
)
1750 if (annex
[0] != '\0' || current_thread
== NULL
1751 || cs
.current_traceframe
== -1)
1754 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1755 readbuf
, len
, &nbytes
))
1760 /* Helper for handle_qxfer_threads_proper.
1761 Emit the XML to describe the thread of INF. */
1764 handle_qxfer_threads_worker (thread_info
*thread
, std::string
*buffer
)
1766 ptid_t ptid
= ptid_of (thread
);
1768 int core
= target_core_of_thread (ptid
);
1770 const char *name
= target_thread_name (ptid
);
1773 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1775 /* If this is a (v)fork/clone child (has a (v)fork/clone parent),
1776 GDB does not yet know about this thread, and must not know about
1777 it until it gets the corresponding (v)fork/clone event. Exclude
1778 this thread from the list. */
1779 if (target_thread_pending_parent (thread
) != nullptr)
1782 write_ptid (ptid_s
, ptid
);
1784 string_xml_appendf (*buffer
, "<thread id=\"%s\"", ptid_s
);
1788 sprintf (core_s
, "%d", core
);
1789 string_xml_appendf (*buffer
, " core=\"%s\"", core_s
);
1793 string_xml_appendf (*buffer
, " name=\"%s\"", name
);
1797 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1798 bin2hex (handle
, handle_s
, handle_len
);
1799 string_xml_appendf (*buffer
, " handle=\"%s\"", handle_s
);
1802 string_xml_appendf (*buffer
, "/>\n");
1805 /* Helper for handle_qxfer_threads. Return true on success, false
1809 handle_qxfer_threads_proper (std::string
*buffer
)
1811 *buffer
+= "<threads>\n";
1813 /* The target may need to access memory and registers (e.g. via
1814 libthread_db) to fetch thread properties. Even if don't need to
1815 stop threads to access memory, we still will need to be able to
1816 access registers, and other ptrace accesses like
1817 PTRACE_GET_THREAD_AREA that require a paused thread. Pause all
1818 threads here, so that we pause each thread at most once for all
1821 target_pause_all (true);
1823 for_each_thread ([&] (thread_info
*thread
)
1825 handle_qxfer_threads_worker (thread
, buffer
);
1829 target_unpause_all (true);
1831 *buffer
+= "</threads>\n";
1835 /* Handle qXfer:threads:read. */
1838 handle_qxfer_threads (const char *annex
,
1839 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1840 ULONGEST offset
, LONGEST len
)
1842 static std::string result
;
1844 if (writebuf
!= NULL
)
1847 if (annex
[0] != '\0')
1852 /* When asked for data at offset 0, generate everything and store into
1853 'result'. Successive reads will be served off 'result'. */
1856 bool res
= handle_qxfer_threads_proper (&result
);
1862 if (offset
>= result
.length ())
1864 /* We're out of data. */
1869 if (len
> result
.length () - offset
)
1870 len
= result
.length () - offset
;
1872 memcpy (readbuf
, result
.c_str () + offset
, len
);
1877 /* Handle qXfer:traceframe-info:read. */
1880 handle_qxfer_traceframe_info (const char *annex
,
1881 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1882 ULONGEST offset
, LONGEST len
)
1884 client_state
&cs
= get_client_state ();
1885 static std::string result
;
1887 if (writebuf
!= NULL
)
1890 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1895 /* When asked for data at offset 0, generate everything and
1896 store into 'result'. Successive reads will be served off
1900 traceframe_read_info (cs
.current_traceframe
, &result
);
1903 if (offset
>= result
.length ())
1905 /* We're out of data. */
1910 if (len
> result
.length () - offset
)
1911 len
= result
.length () - offset
;
1913 memcpy (readbuf
, result
.c_str () + offset
, len
);
1917 /* Handle qXfer:fdpic:read. */
1920 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1921 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1923 if (!the_target
->supports_read_loadmap ())
1926 if (current_thread
== NULL
)
1929 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1932 /* Handle qXfer:btrace:read. */
1935 handle_qxfer_btrace (const char *annex
,
1936 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1937 ULONGEST offset
, LONGEST len
)
1939 client_state
&cs
= get_client_state ();
1940 static std::string cache
;
1941 struct thread_info
*thread
;
1942 enum btrace_read_type type
;
1945 if (writebuf
!= NULL
)
1948 if (cs
.general_thread
== null_ptid
1949 || cs
.general_thread
== minus_one_ptid
)
1951 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1955 thread
= find_thread_ptid (cs
.general_thread
);
1958 strcpy (cs
.own_buf
, "E.No such thread.");
1962 if (thread
->btrace
== NULL
)
1964 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1968 if (strcmp (annex
, "all") == 0)
1969 type
= BTRACE_READ_ALL
;
1970 else if (strcmp (annex
, "new") == 0)
1971 type
= BTRACE_READ_NEW
;
1972 else if (strcmp (annex
, "delta") == 0)
1973 type
= BTRACE_READ_DELTA
;
1976 strcpy (cs
.own_buf
, "E.Bad annex.");
1986 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1988 memcpy (cs
.own_buf
, cache
.c_str (), cache
.length ());
1990 catch (const gdb_exception_error
&exception
)
1992 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1999 else if (offset
> cache
.length ())
2005 if (len
> cache
.length () - offset
)
2006 len
= cache
.length () - offset
;
2008 memcpy (readbuf
, cache
.c_str () + offset
, len
);
2013 /* Handle qXfer:btrace-conf:read. */
2016 handle_qxfer_btrace_conf (const char *annex
,
2017 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2018 ULONGEST offset
, LONGEST len
)
2020 client_state
&cs
= get_client_state ();
2021 static std::string cache
;
2022 struct thread_info
*thread
;
2025 if (writebuf
!= NULL
)
2028 if (annex
[0] != '\0')
2031 if (cs
.general_thread
== null_ptid
2032 || cs
.general_thread
== minus_one_ptid
)
2034 strcpy (cs
.own_buf
, "E.Must select a single thread.");
2038 thread
= find_thread_ptid (cs
.general_thread
);
2041 strcpy (cs
.own_buf
, "E.No such thread.");
2045 if (thread
->btrace
== NULL
)
2047 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
2057 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
2059 memcpy (cs
.own_buf
, cache
.c_str (), cache
.length ());
2061 catch (const gdb_exception_error
&exception
)
2063 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
2070 else if (offset
> cache
.length ())
2076 if (len
> cache
.length () - offset
)
2077 len
= cache
.length () - offset
;
2079 memcpy (readbuf
, cache
.c_str () + offset
, len
);
2084 static const struct qxfer qxfer_packets
[] =
2086 { "auxv", handle_qxfer_auxv
},
2087 { "btrace", handle_qxfer_btrace
},
2088 { "btrace-conf", handle_qxfer_btrace_conf
},
2089 { "exec-file", handle_qxfer_exec_file
},
2090 { "fdpic", handle_qxfer_fdpic
},
2091 { "features", handle_qxfer_features
},
2092 { "libraries", handle_qxfer_libraries
},
2093 { "libraries-svr4", handle_qxfer_libraries_svr4
},
2094 { "osdata", handle_qxfer_osdata
},
2095 { "siginfo", handle_qxfer_siginfo
},
2096 { "statictrace", handle_qxfer_statictrace
},
2097 { "threads", handle_qxfer_threads
},
2098 { "traceframe-info", handle_qxfer_traceframe_info
},
2102 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2110 if (!startswith (own_buf
, "qXfer:"))
2113 /* Grab the object, r/w and annex. */
2114 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2116 write_enn (own_buf
);
2121 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2124 const struct qxfer
*q
= &qxfer_packets
[i
];
2126 if (strcmp (object
, q
->object
) == 0)
2128 if (strcmp (rw
, "read") == 0)
2130 unsigned char *data
;
2135 /* Grab the offset and length. */
2136 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2138 write_enn (own_buf
);
2142 /* Read one extra byte, as an indicator of whether there is
2144 if (len
> PBUFSIZ
- 2)
2146 data
= (unsigned char *) malloc (len
+ 1);
2149 write_enn (own_buf
);
2152 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2160 /* Preserve error message. */
2163 write_enn (own_buf
);
2165 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2167 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2172 else if (strcmp (rw
, "write") == 0)
2177 unsigned char *data
;
2179 strcpy (own_buf
, "E00");
2180 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2183 write_enn (own_buf
);
2186 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2187 &ofs
, &len
, data
) < 0)
2190 write_enn (own_buf
);
2194 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2202 /* Preserve error message. */
2205 write_enn (own_buf
);
2207 sprintf (own_buf
, "%x", n
);
2220 /* Compute 32 bit CRC from inferior memory.
2222 On success, return 32 bit CRC.
2223 On failure, return (unsigned long long) -1. */
2225 static unsigned long long
2226 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2230 unsigned char byte
= 0;
2232 /* Return failure if memory read fails. */
2233 if (read_inferior_memory (base
, &byte
, 1) != 0)
2234 return (unsigned long long) -1;
2236 crc
= xcrc32 (&byte
, 1, crc
);
2239 return (unsigned long long) crc
;
2242 /* Parse the qMemTags packet request into ADDR and LEN. */
2245 parse_fetch_memtags_request (char *request
, CORE_ADDR
*addr
, size_t *len
,
2248 gdb_assert (startswith (request
, "qMemTags:"));
2250 const char *p
= request
+ strlen ("qMemTags:");
2252 /* Read address and length. */
2253 unsigned int length
= 0;
2254 p
= decode_m_packet_params (p
, addr
, &length
, ':');
2257 /* Read the tag type. */
2258 ULONGEST tag_type
= 0;
2259 p
= unpack_varlen_hex (p
, &tag_type
);
2260 *type
= (int) tag_type
;
2263 /* Add supported btrace packets to BUF. */
2266 supported_btrace_packets (char *buf
)
2268 strcat (buf
, ";Qbtrace:bts+");
2269 strcat (buf
, ";Qbtrace-conf:bts:size+");
2270 strcat (buf
, ";Qbtrace:pt+");
2271 strcat (buf
, ";Qbtrace-conf:pt:size+");
2272 strcat (buf
, ";Qbtrace:off+");
2273 strcat (buf
, ";qXfer:btrace:read+");
2274 strcat (buf
, ";qXfer:btrace-conf:read+");
2277 /* Handle all of the extended 'q' packets. */
2280 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2282 client_state
&cs
= get_client_state ();
2283 static std::list
<thread_info
*>::const_iterator thread_iter
;
2285 /* Reply the current thread id. */
2286 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2289 require_running_or_return (own_buf
);
2291 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2292 ptid
= cs
.general_thread
;
2295 thread_iter
= all_threads
.begin ();
2296 ptid
= (*thread_iter
)->id
;
2299 sprintf (own_buf
, "QC");
2301 write_ptid (own_buf
, ptid
);
2305 if (strcmp ("qSymbol::", own_buf
) == 0)
2307 scoped_restore_current_thread restore_thread
;
2309 /* For qSymbol, GDB only changes the current thread if the
2310 previous current thread was of a different process. So if
2311 the previous thread is gone, we need to pick another one of
2312 the same process. This can happen e.g., if we followed an
2313 exec in a non-leader thread. */
2314 if (current_thread
== NULL
)
2316 thread_info
*any_thread
2317 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2318 switch_to_thread (any_thread
);
2320 /* Just in case, if we didn't find a thread, then bail out
2321 instead of crashing. */
2322 if (current_thread
== NULL
)
2324 write_enn (own_buf
);
2329 /* GDB is suggesting new symbols have been loaded. This may
2330 mean a new shared library has been detected as loaded, so
2331 take the opportunity to check if breakpoints we think are
2332 inserted, still are. Note that it isn't guaranteed that
2333 we'll see this when a shared library is loaded, and nor will
2334 we see this for unloads (although breakpoints in unloaded
2335 libraries shouldn't trigger), as GDB may not find symbols for
2336 the library at all. We also re-validate breakpoints when we
2337 see a second GDB breakpoint for the same address, and or when
2338 we access breakpoint shadows. */
2339 validate_breakpoints ();
2341 if (target_supports_tracepoints ())
2342 tracepoint_look_up_symbols ();
2344 if (current_thread
!= NULL
)
2345 the_target
->look_up_symbols ();
2347 strcpy (own_buf
, "OK");
2351 if (!disable_packet_qfThreadInfo
)
2353 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2355 require_running_or_return (own_buf
);
2356 thread_iter
= all_threads
.begin ();
2359 ptid_t ptid
= (*thread_iter
)->id
;
2360 write_ptid (own_buf
, ptid
);
2365 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2367 require_running_or_return (own_buf
);
2368 if (thread_iter
!= all_threads
.end ())
2371 ptid_t ptid
= (*thread_iter
)->id
;
2372 write_ptid (own_buf
, ptid
);
2378 sprintf (own_buf
, "l");
2384 if (the_target
->supports_read_offsets ()
2385 && strcmp ("qOffsets", own_buf
) == 0)
2387 CORE_ADDR text
, data
;
2389 require_running_or_return (own_buf
);
2390 if (the_target
->read_offsets (&text
, &data
))
2391 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2392 (long)text
, (long)data
, (long)data
);
2394 write_enn (own_buf
);
2399 /* Protocol features query. */
2400 if (startswith (own_buf
, "qSupported")
2401 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2403 char *p
= &own_buf
[10];
2404 int gdb_supports_qRelocInsn
= 0;
2406 /* Process each feature being provided by GDB. The first
2407 feature will follow a ':', and latter features will follow
2411 std::vector
<std::string
> qsupported
;
2412 std::vector
<const char *> unknowns
;
2414 /* Two passes, to avoid nested strtok calls in
2415 target_process_qsupported. */
2417 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2419 p
= strtok_r (NULL
, ";", &saveptr
))
2420 qsupported
.emplace_back (p
);
2422 for (const std::string
&feature
: qsupported
)
2424 if (feature
== "multiprocess+")
2426 /* GDB supports and wants multi-process support if
2428 if (target_supports_multi_process ())
2429 cs
.multi_process
= 1;
2431 else if (feature
== "qRelocInsn+")
2433 /* GDB supports relocate instruction requests. */
2434 gdb_supports_qRelocInsn
= 1;
2436 else if (feature
== "swbreak+")
2438 /* GDB wants us to report whether a trap is caused
2439 by a software breakpoint and for us to handle PC
2440 adjustment if necessary on this target. */
2441 if (target_supports_stopped_by_sw_breakpoint ())
2442 cs
.swbreak_feature
= 1;
2444 else if (feature
== "hwbreak+")
2446 /* GDB wants us to report whether a trap is caused
2447 by a hardware breakpoint. */
2448 if (target_supports_stopped_by_hw_breakpoint ())
2449 cs
.hwbreak_feature
= 1;
2451 else if (feature
== "fork-events+")
2453 /* GDB supports and wants fork events if possible. */
2454 if (target_supports_fork_events ())
2455 cs
.report_fork_events
= 1;
2457 else if (feature
== "vfork-events+")
2459 /* GDB supports and wants vfork events if possible. */
2460 if (target_supports_vfork_events ())
2461 cs
.report_vfork_events
= 1;
2463 else if (feature
== "exec-events+")
2465 /* GDB supports and wants exec events if possible. */
2466 if (target_supports_exec_events ())
2467 cs
.report_exec_events
= 1;
2469 else if (feature
== "vContSupported+")
2470 cs
.vCont_supported
= 1;
2471 else if (feature
== "QThreadEvents+")
2473 else if (feature
== "QThreadOptions+")
2475 else if (feature
== "no-resumed+")
2477 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2479 report_no_resumed
= true;
2481 else if (feature
== "memory-tagging+")
2483 /* GDB supports memory tagging features. */
2484 if (target_supports_memory_tagging ())
2485 cs
.memory_tagging_feature
= true;
2489 /* Move the unknown features all together. */
2490 unknowns
.push_back (feature
.c_str ());
2494 /* Give the target backend a chance to process the unknown
2496 target_process_qsupported (unknowns
);
2500 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2501 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2502 "QEnvironmentReset+;QEnvironmentUnset+;"
2506 if (target_supports_catch_syscall ())
2507 strcat (own_buf
, ";QCatchSyscalls+");
2509 if (the_target
->supports_qxfer_libraries_svr4 ())
2510 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2511 ";augmented-libraries-svr4-read+");
2514 /* We do not have any hook to indicate whether the non-SVR4 target
2515 backend supports qXfer:libraries:read, so always report it. */
2516 strcat (own_buf
, ";qXfer:libraries:read+");
2519 if (the_target
->supports_read_auxv ())
2520 strcat (own_buf
, ";qXfer:auxv:read+");
2522 if (the_target
->supports_qxfer_siginfo ())
2523 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2525 if (the_target
->supports_read_loadmap ())
2526 strcat (own_buf
, ";qXfer:fdpic:read+");
2528 /* We always report qXfer:features:read, as targets may
2529 install XML files on a subsequent call to arch_setup.
2530 If we reported to GDB on startup that we don't support
2531 qXfer:feature:read at all, we will never be re-queried. */
2532 strcat (own_buf
, ";qXfer:features:read+");
2534 if (cs
.transport_is_reliable
)
2535 strcat (own_buf
, ";QStartNoAckMode+");
2537 if (the_target
->supports_qxfer_osdata ())
2538 strcat (own_buf
, ";qXfer:osdata:read+");
2540 if (target_supports_multi_process ())
2541 strcat (own_buf
, ";multiprocess+");
2543 if (target_supports_fork_events ())
2544 strcat (own_buf
, ";fork-events+");
2546 if (target_supports_vfork_events ())
2547 strcat (own_buf
, ";vfork-events+");
2549 if (target_supports_exec_events ())
2550 strcat (own_buf
, ";exec-events+");
2552 if (target_supports_non_stop ())
2553 strcat (own_buf
, ";QNonStop+");
2555 if (target_supports_disable_randomization ())
2556 strcat (own_buf
, ";QDisableRandomization+");
2558 strcat (own_buf
, ";qXfer:threads:read+");
2560 if (target_supports_tracepoints ())
2562 strcat (own_buf
, ";ConditionalTracepoints+");
2563 strcat (own_buf
, ";TraceStateVariables+");
2564 strcat (own_buf
, ";TracepointSource+");
2565 strcat (own_buf
, ";DisconnectedTracing+");
2566 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2567 strcat (own_buf
, ";FastTracepoints+");
2568 strcat (own_buf
, ";StaticTracepoints+");
2569 strcat (own_buf
, ";InstallInTrace+");
2570 strcat (own_buf
, ";qXfer:statictrace:read+");
2571 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2572 strcat (own_buf
, ";EnableDisableTracepoints+");
2573 strcat (own_buf
, ";QTBuffer:size+");
2574 strcat (own_buf
, ";tracenz+");
2577 if (target_supports_hardware_single_step ()
2578 || target_supports_software_single_step () )
2580 strcat (own_buf
, ";ConditionalBreakpoints+");
2582 strcat (own_buf
, ";BreakpointCommands+");
2584 if (target_supports_agent ())
2585 strcat (own_buf
, ";QAgent+");
2587 if (the_target
->supports_btrace ())
2588 supported_btrace_packets (own_buf
);
2590 if (target_supports_stopped_by_sw_breakpoint ())
2591 strcat (own_buf
, ";swbreak+");
2593 if (target_supports_stopped_by_hw_breakpoint ())
2594 strcat (own_buf
, ";hwbreak+");
2596 if (the_target
->supports_pid_to_exec_file ())
2597 strcat (own_buf
, ";qXfer:exec-file:read+");
2599 strcat (own_buf
, ";vContSupported+");
2601 gdb_thread_options supported_options
= target_supported_thread_options ();
2602 if (supported_options
!= 0)
2604 char *end_buf
= own_buf
+ strlen (own_buf
);
2605 sprintf (end_buf
, ";QThreadOptions=%s",
2606 phex_nz (supported_options
, sizeof (supported_options
)));
2609 strcat (own_buf
, ";QThreadEvents+");
2611 strcat (own_buf
, ";no-resumed+");
2613 if (target_supports_memory_tagging ())
2614 strcat (own_buf
, ";memory-tagging+");
2616 /* Reinitialize components as needed for the new connection. */
2617 hostio_handle_new_gdb_connection ();
2618 target_handle_new_gdb_connection ();
2623 /* Thread-local storage support. */
2624 if (the_target
->supports_get_tls_address ()
2625 && startswith (own_buf
, "qGetTLSAddr:"))
2627 char *p
= own_buf
+ 12;
2628 CORE_ADDR parts
[2], address
= 0;
2630 ptid_t ptid
= null_ptid
;
2632 require_running_or_return (own_buf
);
2634 for (i
= 0; i
< 3; i
++)
2642 p2
= strchr (p
, ',');
2655 ptid
= read_ptid (p
, NULL
);
2657 decode_address (&parts
[i
- 1], p
, len
);
2661 if (p
!= NULL
|| i
< 3)
2665 struct thread_info
*thread
= find_thread_ptid (ptid
);
2670 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2676 strcpy (own_buf
, paddress(address
));
2681 write_enn (own_buf
);
2685 /* Otherwise, pretend we do not understand this packet. */
2688 /* Windows OS Thread Information Block address support. */
2689 if (the_target
->supports_get_tib_address ()
2690 && startswith (own_buf
, "qGetTIBAddr:"))
2695 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2697 n
= the_target
->get_tib_address (ptid
, &tlb
);
2700 strcpy (own_buf
, paddress(tlb
));
2705 write_enn (own_buf
);
2711 /* Handle "monitor" commands. */
2712 if (startswith (own_buf
, "qRcmd,"))
2714 char *mon
= (char *) malloc (PBUFSIZ
);
2715 int len
= strlen (own_buf
+ 6);
2719 write_enn (own_buf
);
2724 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2726 write_enn (own_buf
);
2730 mon
[len
/ 2] = '\0';
2734 if (the_target
->handle_monitor_command (mon
) == 0)
2735 /* Default processing. */
2736 handle_monitor_command (mon
, own_buf
);
2742 if (startswith (own_buf
, "qSearch:memory:"))
2744 require_running_or_return (own_buf
);
2745 handle_search_memory (own_buf
, packet_len
);
2749 if (strcmp (own_buf
, "qAttached") == 0
2750 || startswith (own_buf
, "qAttached:"))
2752 struct process_info
*process
;
2754 if (own_buf
[sizeof ("qAttached") - 1])
2756 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2757 process
= find_process_pid (pid
);
2761 require_running_or_return (own_buf
);
2762 process
= current_process ();
2765 if (process
== NULL
)
2767 write_enn (own_buf
);
2771 strcpy (own_buf
, process
->attached
? "1" : "0");
2775 if (startswith (own_buf
, "qCRC:"))
2777 /* CRC check (compare-section). */
2781 unsigned long long crc
;
2783 require_running_or_return (own_buf
);
2784 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2785 if (*comma
++ != ',')
2787 write_enn (own_buf
);
2790 len
= strtoul (comma
, NULL
, 16);
2791 crc
= crc32 (base
, len
, 0xffffffff);
2792 /* Check for memory failure. */
2793 if (crc
== (unsigned long long) -1)
2795 write_enn (own_buf
);
2798 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2802 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2805 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2808 /* Handle fetch memory tags packets. */
2809 if (startswith (own_buf
, "qMemTags:")
2810 && target_supports_memory_tagging ())
2812 gdb::byte_vector tags
;
2817 require_running_or_return (own_buf
);
2819 parse_fetch_memtags_request (own_buf
, &addr
, &len
, &type
);
2821 bool ret
= the_target
->fetch_memtags (addr
, len
, tags
, type
);
2824 ret
= create_fetch_memtags_reply (own_buf
, tags
);
2827 write_enn (own_buf
);
2829 *new_packet_len_p
= strlen (own_buf
);
2833 /* Otherwise we didn't know what packet it was. Say we didn't
2838 static void gdb_wants_all_threads_stopped (void);
2839 static void resume (struct thread_resume
*actions
, size_t n
);
2841 /* The callback that is passed to visit_actioned_threads. */
2842 typedef int (visit_actioned_threads_callback_ftype
)
2843 (const struct thread_resume
*, struct thread_info
*);
2845 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2846 true if CALLBACK returns true. Returns false if no matching thread
2847 is found or CALLBACK results false.
2848 Note: This function is itself a callback for find_thread. */
2851 visit_actioned_threads (thread_info
*thread
,
2852 const struct thread_resume
*actions
,
2854 visit_actioned_threads_callback_ftype
*callback
)
2856 for (size_t i
= 0; i
< num_actions
; i
++)
2858 const struct thread_resume
*action
= &actions
[i
];
2860 if (action
->thread
== minus_one_ptid
2861 || action
->thread
== thread
->id
2862 || ((action
->thread
.pid ()
2863 == thread
->id
.pid ())
2864 && action
->thread
.lwp () == -1))
2866 if ((*callback
) (action
, thread
))
2874 /* Callback for visit_actioned_threads. If the thread has a pending
2875 status to report, report it now. */
2878 handle_pending_status (const struct thread_resume
*resumption
,
2879 struct thread_info
*thread
)
2881 client_state
&cs
= get_client_state ();
2882 if (thread
->status_pending_p
)
2884 thread
->status_pending_p
= 0;
2886 cs
.last_status
= thread
->last_status
;
2887 cs
.last_ptid
= thread
->id
;
2888 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
2894 /* Parse vCont packets. */
2896 handle_v_cont (char *own_buf
)
2900 struct thread_resume
*resume_info
;
2901 struct thread_resume default_action
{ null_ptid
};
2903 /* Count the number of semicolons in the packet. There should be one
2904 for every action. */
2910 p
= strchr (p
, ';');
2913 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2914 if (resume_info
== NULL
)
2922 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2924 if (p
[0] == 's' || p
[0] == 'S')
2925 resume_info
[i
].kind
= resume_step
;
2926 else if (p
[0] == 'r')
2927 resume_info
[i
].kind
= resume_step
;
2928 else if (p
[0] == 'c' || p
[0] == 'C')
2929 resume_info
[i
].kind
= resume_continue
;
2930 else if (p
[0] == 't')
2931 resume_info
[i
].kind
= resume_stop
;
2935 if (p
[0] == 'S' || p
[0] == 'C')
2938 int sig
= strtol (p
+ 1, &q
, 16);
2943 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2945 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2947 else if (p
[0] == 'r')
2951 p
= unpack_varlen_hex (p
+ 1, &addr
);
2952 resume_info
[i
].step_range_start
= addr
;
2957 p
= unpack_varlen_hex (p
+ 1, &addr
);
2958 resume_info
[i
].step_range_end
= addr
;
2967 resume_info
[i
].thread
= minus_one_ptid
;
2968 default_action
= resume_info
[i
];
2970 /* Note: we don't increment i here, we'll overwrite this entry
2971 the next time through. */
2973 else if (p
[0] == ':')
2976 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2981 if (p
[0] != ';' && p
[0] != 0)
2984 resume_info
[i
].thread
= ptid
;
2991 resume_info
[i
] = default_action
;
2993 resume (resume_info
, n
);
2998 write_enn (own_buf
);
3003 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
3006 resume (struct thread_resume
*actions
, size_t num_actions
)
3008 client_state
&cs
= get_client_state ();
3011 /* Check if among the threads that GDB wants actioned, there's
3012 one with a pending status to report. If so, skip actually
3013 resuming/stopping and report the pending event
3016 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
3018 return visit_actioned_threads (thread
, actions
, num_actions
,
3019 handle_pending_status
);
3022 if (thread_with_status
!= NULL
)
3028 the_target
->resume (actions
, num_actions
);
3031 write_ok (cs
.own_buf
);
3034 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
3036 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
3037 && !report_no_resumed
)
3039 /* The client does not support this stop reply. At least
3041 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
3042 disable_async_io ();
3046 if (cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
3047 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
3048 && cs
.last_status
.kind () != TARGET_WAITKIND_NO_RESUMED
)
3049 current_thread
->last_status
= cs
.last_status
;
3051 /* From the client's perspective, all-stop mode always stops all
3052 threads implicitly (and the target backend has already done
3053 so by now). Tag all threads as "want-stopped", so we don't
3054 resume them implicitly without the client telling us to. */
3055 gdb_wants_all_threads_stopped ();
3056 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, cs
.last_status
);
3057 disable_async_io ();
3059 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
3060 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
3061 target_mourn_inferior (cs
.last_ptid
);
3065 /* Attach to a new program. */
3067 handle_v_attach (char *own_buf
)
3069 client_state
&cs
= get_client_state ();
3072 pid
= strtol (own_buf
+ 8, NULL
, 16);
3073 if (pid
!= 0 && attach_inferior (pid
) == 0)
3075 /* Don't report shared library events after attaching, even if
3076 some libraries are preloaded. GDB will always poll the
3077 library list. Avoids the "stopped by shared library event"
3078 notice on the GDB side. */
3079 current_process ()->dlls_changed
= false;
3083 /* In non-stop, we don't send a resume reply. Stop events
3084 will follow up using the normal notification
3089 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
3092 write_enn (own_buf
);
3095 /* Decode an argument from the vRun packet buffer. PTR points to the
3096 first hex-encoded character in the buffer, and LEN is the number of
3097 characters to read from the packet buffer.
3099 If the argument decoding is successful, return a buffer containing the
3100 decoded argument, including a null terminator at the end.
3102 If the argument decoding fails for any reason, return nullptr. */
3104 static gdb::unique_xmalloc_ptr
<char>
3105 decode_v_run_arg (const char *ptr
, size_t len
)
3107 /* Two hex characters are required for each decoded byte. */
3111 /* The length in bytes needed for the decoded argument. */
3114 /* Buffer to decode the argument into. The '+ 1' is for the null
3115 terminator we will add. */
3116 char *arg
= (char *) xmalloc (len
+ 1);
3118 /* Decode the argument from the packet and add a null terminator. We do
3119 this within a try block as invalid characters within the PTR buffer
3120 will cause hex2bin to throw an exception. Our caller relies on us
3121 returning nullptr in order to clean up some memory allocations. */
3124 hex2bin (ptr
, (gdb_byte
*) arg
, len
);
3127 catch (const gdb_exception_error
&exception
)
3132 return gdb::unique_xmalloc_ptr
<char> (arg
);
3135 /* Run a new program. */
3137 handle_v_run (char *own_buf
)
3139 client_state
&cs
= get_client_state ();
3141 std::vector
<char *> new_argv
;
3142 gdb::unique_xmalloc_ptr
<char> new_program_name
;
3145 for (i
= 0, p
= own_buf
+ strlen ("vRun;");
3146 /* Exit condition is at the end of the loop. */;
3147 p
= next_p
+ 1, ++i
)
3149 next_p
= strchr (p
, ';');
3151 next_p
= p
+ strlen (p
);
3153 if (i
== 0 && p
== next_p
)
3155 /* No program specified. */
3156 gdb_assert (new_program_name
== nullptr);
3158 else if (p
== next_p
)
3160 /* Empty argument. */
3161 new_argv
.push_back (xstrdup (""));
3165 /* The length of the argument string in the packet. */
3166 size_t len
= next_p
- p
;
3168 gdb::unique_xmalloc_ptr
<char> arg
= decode_v_run_arg (p
, len
);
3171 write_enn (own_buf
);
3172 free_vector_argv (new_argv
);
3177 new_program_name
= std::move (arg
);
3179 new_argv
.push_back (arg
.release ());
3181 if (*next_p
== '\0')
3185 if (new_program_name
== nullptr)
3187 /* GDB didn't specify a program to run. Use the program from the
3188 last run with the new argument list. */
3189 if (program_path
.get () == nullptr)
3191 write_enn (own_buf
);
3192 free_vector_argv (new_argv
);
3197 program_path
.set (new_program_name
.get ());
3199 /* Free the old argv and install the new one. */
3200 free_vector_argv (program_args
);
3201 program_args
= new_argv
;
3203 target_create_inferior (program_path
.get (), program_args
);
3205 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
3207 prepare_resume_reply (own_buf
, cs
.last_ptid
, cs
.last_status
);
3209 /* In non-stop, sending a resume reply doesn't set the general
3210 thread, but GDB assumes a vRun sets it (this is so GDB can
3211 query which is the main thread of the new inferior. */
3213 cs
.general_thread
= cs
.last_ptid
;
3216 write_enn (own_buf
);
3221 handle_v_kill (char *own_buf
)
3223 client_state
&cs
= get_client_state ();
3225 char *p
= &own_buf
[6];
3226 if (cs
.multi_process
)
3227 pid
= strtol (p
, NULL
, 16);
3231 process_info
*proc
= find_process_pid (pid
);
3233 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3235 cs
.last_status
.set_signalled (GDB_SIGNAL_KILL
);
3236 cs
.last_ptid
= ptid_t (pid
);
3237 discard_queued_stop_replies (cs
.last_ptid
);
3241 write_enn (own_buf
);
3244 /* Handle all of the extended 'v' packets. */
3246 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3248 client_state
&cs
= get_client_state ();
3249 if (!disable_packet_vCont
)
3251 if (strcmp (own_buf
, "vCtrlC") == 0)
3253 the_target
->request_interrupt ();
3258 if (startswith (own_buf
, "vCont;"))
3260 handle_v_cont (own_buf
);
3264 if (startswith (own_buf
, "vCont?"))
3266 strcpy (own_buf
, "vCont;c;C;t");
3268 if (target_supports_hardware_single_step ()
3269 || target_supports_software_single_step ()
3270 || !cs
.vCont_supported
)
3272 /* If target supports single step either by hardware or by
3273 software, add actions s and S to the list of supported
3274 actions. On the other hand, if GDB doesn't request the
3275 supported vCont actions in qSupported packet, add s and
3276 S to the list too. */
3277 own_buf
= own_buf
+ strlen (own_buf
);
3278 strcpy (own_buf
, ";s;S");
3281 if (target_supports_range_stepping ())
3283 own_buf
= own_buf
+ strlen (own_buf
);
3284 strcpy (own_buf
, ";r");
3290 if (startswith (own_buf
, "vFile:")
3291 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3294 if (startswith (own_buf
, "vAttach;"))
3296 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3298 fprintf (stderr
, "Already debugging a process\n");
3299 write_enn (own_buf
);
3302 handle_v_attach (own_buf
);
3306 if (startswith (own_buf
, "vRun;"))
3308 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3310 fprintf (stderr
, "Already debugging a process\n");
3311 write_enn (own_buf
);
3314 handle_v_run (own_buf
);
3318 if (startswith (own_buf
, "vKill;"))
3320 if (!target_running ())
3322 fprintf (stderr
, "No process to kill\n");
3323 write_enn (own_buf
);
3326 handle_v_kill (own_buf
);
3330 if (handle_notif_ack (own_buf
, packet_len
))
3333 /* Otherwise we didn't know what packet it was. Say we didn't
3339 /* Resume thread and wait for another event. In non-stop mode,
3340 don't really wait here, but return immediately to the event
3343 myresume (char *own_buf
, int step
, int sig
)
3345 client_state
&cs
= get_client_state ();
3346 struct thread_resume resume_info
[2];
3348 int valid_cont_thread
;
3350 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3351 && cs
.cont_thread
!= minus_one_ptid
);
3353 if (step
|| sig
|| valid_cont_thread
)
3355 resume_info
[0].thread
= current_ptid
;
3357 resume_info
[0].kind
= resume_step
;
3359 resume_info
[0].kind
= resume_continue
;
3360 resume_info
[0].sig
= sig
;
3364 if (!valid_cont_thread
)
3366 resume_info
[n
].thread
= minus_one_ptid
;
3367 resume_info
[n
].kind
= resume_continue
;
3368 resume_info
[n
].sig
= 0;
3372 resume (resume_info
, n
);
3375 /* Callback for for_each_thread. Make a new stop reply for each
3379 queue_stop_reply_callback (thread_info
*thread
)
3381 /* For now, assume targets that don't have this callback also don't
3382 manage the thread's last_status field. */
3383 if (!the_target
->supports_thread_stopped ())
3385 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3387 new_notif
->ptid
= thread
->id
;
3388 new_notif
->status
= thread
->last_status
;
3389 /* Pass the last stop reply back to GDB, but don't notify
3391 notif_event_enque (¬if_stop
, new_notif
);
3395 if (target_thread_stopped (thread
))
3397 threads_debug_printf
3398 ("Reporting thread %s as already stopped with %s",
3399 target_pid_to_str (thread
->id
).c_str (),
3400 thread
->last_status
.to_string ().c_str ());
3402 gdb_assert (thread
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3404 /* Pass the last stop reply back to GDB, but don't notify
3406 queue_stop_reply (thread
->id
, thread
->last_status
);
3411 /* Set this inferior threads's state as "want-stopped". We won't
3412 resume this thread until the client gives us another action for
3416 gdb_wants_thread_stopped (thread_info
*thread
)
3418 thread
->last_resume_kind
= resume_stop
;
3420 if (thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
)
3422 /* Most threads are stopped implicitly (all-stop); tag that with
3424 thread
->last_status
.set_stopped (GDB_SIGNAL_0
);
3428 /* Set all threads' states as "want-stopped". */
3431 gdb_wants_all_threads_stopped (void)
3433 for_each_thread (gdb_wants_thread_stopped
);
3436 /* Callback for for_each_thread. If the thread is stopped with an
3437 interesting event, mark it as having a pending event. */
3440 set_pending_status_callback (thread_info
*thread
)
3442 if (thread
->last_status
.kind () != TARGET_WAITKIND_STOPPED
3443 || (thread
->last_status
.sig () != GDB_SIGNAL_0
3444 /* A breakpoint, watchpoint or finished step from a previous
3445 GDB run isn't considered interesting for a new GDB run.
3446 If we left those pending, the new GDB could consider them
3447 random SIGTRAPs. This leaves out real async traps. We'd
3448 have to peek into the (target-specific) siginfo to
3449 distinguish those. */
3450 && thread
->last_status
.sig () != GDB_SIGNAL_TRAP
))
3451 thread
->status_pending_p
= 1;
3454 /* Status handler for the '?' packet. */
3457 handle_status (char *own_buf
)
3459 client_state
&cs
= get_client_state ();
3461 /* GDB is connected, don't forward events to the target anymore. */
3462 for_each_process ([] (process_info
*process
) {
3463 process
->gdb_detached
= 0;
3466 /* In non-stop mode, we must send a stop reply for each stopped
3467 thread. In all-stop mode, just send one for the first stopped
3472 for_each_thread (queue_stop_reply_callback
);
3474 /* The first is sent immediatly. OK is sent if there is no
3475 stopped thread, which is the same handling of the vStopped
3476 packet (by design). */
3477 notif_write_event (¬if_stop
, cs
.own_buf
);
3481 thread_info
*thread
= NULL
;
3483 target_pause_all (false);
3484 target_stabilize_threads ();
3485 gdb_wants_all_threads_stopped ();
3487 /* We can only report one status, but we might be coming out of
3488 non-stop -- if more than one thread is stopped with
3489 interesting events, leave events for the threads we're not
3490 reporting now pending. They'll be reported the next time the
3491 threads are resumed. Start by marking all interesting events
3493 for_each_thread (set_pending_status_callback
);
3495 /* Prefer the last thread that reported an event to GDB (even if
3496 that was a GDB_SIGNAL_TRAP). */
3497 if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
3498 && cs
.last_status
.kind () != TARGET_WAITKIND_EXITED
3499 && cs
.last_status
.kind () != TARGET_WAITKIND_SIGNALLED
)
3500 thread
= find_thread_ptid (cs
.last_ptid
);
3502 /* If the last event thread is not found for some reason, look
3503 for some other thread that might have an event to report. */
3505 thread
= find_thread ([] (thread_info
*thr_arg
)
3507 return thr_arg
->status_pending_p
;
3510 /* If we're still out of luck, simply pick the first thread in
3513 thread
= get_first_thread ();
3517 struct thread_info
*tp
= (struct thread_info
*) thread
;
3519 /* We're reporting this event, so it's no longer
3521 tp
->status_pending_p
= 0;
3523 /* GDB assumes the current thread is the thread we're
3524 reporting the status for. */
3525 cs
.general_thread
= thread
->id
;
3526 set_desired_thread ();
3528 gdb_assert (tp
->last_status
.kind () != TARGET_WAITKIND_IGNORE
);
3529 prepare_resume_reply (own_buf
, tp
->id
, tp
->last_status
);
3532 strcpy (own_buf
, "W00");
3537 gdbserver_version (void)
3539 printf ("GNU gdbserver %s%s\n"
3540 "Copyright (C) 2023 Free Software Foundation, Inc.\n"
3541 "gdbserver is free software, covered by the "
3542 "GNU General Public License.\n"
3543 "This gdbserver was configured as \"%s\"\n",
3544 PKGVERSION
, version
, host_name
);
3548 gdbserver_usage (FILE *stream
)
3550 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3551 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3552 "\tgdbserver [OPTIONS] --multi COMM\n"
3554 "COMM may either be a tty device (for serial debugging),\n"
3555 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3556 "stdin/stdout of gdbserver.\n"
3557 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3558 "PID is the process ID to attach to, when --attach is specified.\n"
3560 "Operating modes:\n"
3562 " --attach Attach to running process PID.\n"
3563 " --multi Start server without a specific program, and\n"
3564 " only quit when explicitly commanded.\n"
3565 " --once Exit after the first connection has closed.\n"
3566 " --help Print this message and then exit.\n"
3567 " --version Display version information and exit.\n"
3571 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3572 " --disable-randomization\n"
3573 " Run PROG with address space randomization disabled.\n"
3574 " --no-disable-randomization\n"
3575 " Don't disable address space randomization when\n"
3577 " --startup-with-shell\n"
3578 " Start PROG using a shell. I.e., execs a shell that\n"
3579 " then execs PROG. (default)\n"
3580 " --no-startup-with-shell\n"
3581 " Exec PROG directly instead of using a shell.\n"
3582 " Disables argument globbing and variable substitution\n"
3583 " on UNIX-like systems.\n"
3587 " --debug Enable general debugging output.\n"
3588 " --debug-format=OPT1[,OPT2,...]\n"
3589 " Specify extra content in debugging output.\n"
3594 " --remote-debug Enable remote protocol debugging output.\n"
3595 " --event-loop-debug Enable event loop debugging output.\n"
3596 " --disable-packet=OPT1[,OPT2,...]\n"
3597 " Disable support for RSP packets or features.\n"
3599 " vCont, T, Tthread, qC, qfThreadInfo and \n"
3600 " threads (disable all threading packets).\n"
3602 "For more information, consult the GDB manual (available as on-line \n"
3603 "info or a printed manual).\n");
3604 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3605 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3609 gdbserver_show_disableable (FILE *stream
)
3611 fprintf (stream
, "Disableable packets:\n"
3612 " vCont \tAll vCont packets\n"
3613 " qC \tQuerying the current thread\n"
3614 " qfThreadInfo\tThread listing\n"
3615 " Tthread \tPassing the thread specifier in the "
3616 "T stop reply packet\n"
3617 " threads \tAll of the above\n"
3618 " T \tAll 'T' packets\n");
3621 /* Start up the event loop. This is the entry point to the event
3627 /* Loop until there is nothing to do. This is the entry point to
3628 the event loop engine. If nothing is ready at this time, wait
3629 for something to happen (via wait_for_event), then process it.
3630 Return when there are no longer event sources to wait for. */
3632 keep_processing_events
= true;
3633 while (keep_processing_events
)
3635 /* Any events already waiting in the queue? */
3636 int res
= gdb_do_one_event ();
3638 /* Was there an error? */
3643 /* We are done with the event loop. There are no more event sources
3644 to listen to. So we exit gdbserver. */
3648 kill_inferior_callback (process_info
*process
)
3650 kill_inferior (process
);
3651 discard_queued_stop_replies (ptid_t (process
->pid
));
3654 /* Call this when exiting gdbserver with possible inferiors that need
3655 to be killed or detached from. */
3658 detach_or_kill_for_exit (void)
3660 /* First print a list of the inferiors we will be killing/detaching.
3661 This is to assist the user, for example, in case the inferior unexpectedly
3662 dies after we exit: did we screw up or did the inferior exit on its own?
3663 Having this info will save some head-scratching. */
3665 if (have_started_inferiors_p ())
3667 fprintf (stderr
, "Killing process(es):");
3669 for_each_process ([] (process_info
*process
) {
3670 if (!process
->attached
)
3671 fprintf (stderr
, " %d", process
->pid
);
3674 fprintf (stderr
, "\n");
3676 if (have_attached_inferiors_p ())
3678 fprintf (stderr
, "Detaching process(es):");
3680 for_each_process ([] (process_info
*process
) {
3681 if (process
->attached
)
3682 fprintf (stderr
, " %d", process
->pid
);
3685 fprintf (stderr
, "\n");
3688 /* Now we can kill or detach the inferiors. */
3689 for_each_process ([] (process_info
*process
) {
3690 int pid
= process
->pid
;
3692 if (process
->attached
)
3693 detach_inferior (process
);
3695 kill_inferior (process
);
3697 discard_queued_stop_replies (ptid_t (pid
));
3701 /* Value that will be passed to exit(3) when gdbserver exits. */
3702 static int exit_code
;
3704 /* Wrapper for detach_or_kill_for_exit that catches and prints
3708 detach_or_kill_for_exit_cleanup ()
3712 detach_or_kill_for_exit ();
3714 catch (const gdb_exception
&exception
)
3717 fprintf (stderr
, "Detach or kill failed: %s\n",
3725 namespace selftests
{
3728 test_memory_tagging_functions (void)
3730 /* Setup testing. */
3731 gdb::char_vector packet
;
3732 gdb::byte_vector tags
, bv
;
3733 std::string expected
;
3734 packet
.resize (32000);
3739 /* Test parsing a qMemTags request. */
3741 /* Valid request, addr, len and type updated. */
3745 strcpy (packet
.data (), "qMemTags:0,0:0");
3746 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3747 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0);
3749 /* Valid request, addr, len and type updated. */
3753 strcpy (packet
.data (), "qMemTags:deadbeef,ff:5");
3754 parse_fetch_memtags_request (packet
.data (), &addr
, &len
, &type
);
3755 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5);
3757 /* Test creating a qMemTags reply. */
3759 /* Non-empty tag data. */
3762 for (int i
= 0; i
< 5; i
++)
3765 expected
= "m0001020304";
3766 SELF_CHECK (create_fetch_memtags_reply (packet
.data (), bv
) == true);
3767 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
3769 /* Test parsing a QMemTags request. */
3771 /* Valid request and empty tag data: addr, len, type and tags updated. */
3776 strcpy (packet
.data (), "QMemTags:0,0:0:");
3777 SELF_CHECK (parse_store_memtags_request (packet
.data (),
3778 &addr
, &len
, tags
, &type
) == true);
3779 SELF_CHECK (addr
== 0 && len
== 0 && type
== 0 && tags
.size () == 0);
3781 /* Valid request and non-empty tag data: addr, len, type
3782 and tags updated. */
3787 strcpy (packet
.data (),
3788 "QMemTags:deadbeef,ff:5:0001020304");
3789 SELF_CHECK (parse_store_memtags_request (packet
.data (), &addr
, &len
, tags
,
3791 SELF_CHECK (addr
== 0xdeadbeef && len
== 255 && type
== 5
3792 && tags
.size () == 5);
3795 } // namespace selftests
3796 #endif /* GDB_SELF_TEST */
3798 /* Main function. This is called by the real "main" function,
3799 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3801 static void ATTRIBUTE_NORETURN
3802 captured_main (int argc
, char *argv
[])
3807 const char *port
= NULL
;
3808 char **next_arg
= &argv
[1];
3809 volatile int multi_mode
= 0;
3810 volatile int attach
= 0;
3812 bool selftest
= false;
3814 std::vector
<const char *> selftest_filters
;
3816 selftests::register_test ("remote_memory_tagging",
3817 selftests::test_memory_tagging_functions
);
3820 current_directory
= getcwd (NULL
, 0);
3821 client_state
&cs
= get_client_state ();
3823 if (current_directory
== NULL
)
3825 error (_("Could not find current working directory: %s"),
3826 safe_strerror (errno
));
3829 while (*next_arg
!= NULL
&& **next_arg
== '-')
3831 if (strcmp (*next_arg
, "--version") == 0)
3833 gdbserver_version ();
3836 else if (strcmp (*next_arg
, "--help") == 0)
3838 gdbserver_usage (stdout
);
3841 else if (strcmp (*next_arg
, "--attach") == 0)
3843 else if (strcmp (*next_arg
, "--multi") == 0)
3845 else if (strcmp (*next_arg
, "--wrapper") == 0)
3852 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3854 wrapper_argv
+= *next_arg
;
3855 wrapper_argv
+= ' ';
3859 if (!wrapper_argv
.empty ())
3861 /* Erase the last whitespace. */
3862 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3865 if (next_arg
== tmp
|| *next_arg
== NULL
)
3867 gdbserver_usage (stderr
);
3871 /* Consume the "--". */
3874 else if (strcmp (*next_arg
, "--debug") == 0)
3875 debug_threads
= true;
3876 else if (startswith (*next_arg
, "--debug-format="))
3878 std::string error_msg
3879 = parse_debug_format_options ((*next_arg
)
3880 + sizeof ("--debug-format=") - 1, 0);
3882 if (!error_msg
.empty ())
3884 fprintf (stderr
, "%s", error_msg
.c_str ());
3888 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3889 remote_debug
= true;
3890 else if (strcmp (*next_arg
, "--event-loop-debug") == 0)
3891 debug_event_loop
= debug_event_loop_kind::ALL
;
3892 else if (startswith (*next_arg
, "--debug-file="))
3893 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3894 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3896 gdbserver_show_disableable (stdout
);
3899 else if (startswith (*next_arg
, "--disable-packet="))
3901 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3903 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3905 tok
= strtok_r (NULL
, ",", &saveptr
))
3907 if (strcmp ("vCont", tok
) == 0)
3908 disable_packet_vCont
= true;
3909 else if (strcmp ("Tthread", tok
) == 0)
3910 disable_packet_Tthread
= true;
3911 else if (strcmp ("qC", tok
) == 0)
3912 disable_packet_qC
= true;
3913 else if (strcmp ("qfThreadInfo", tok
) == 0)
3914 disable_packet_qfThreadInfo
= true;
3915 else if (strcmp ("T", tok
) == 0)
3916 disable_packet_T
= true;
3917 else if (strcmp ("threads", tok
) == 0)
3919 disable_packet_vCont
= true;
3920 disable_packet_Tthread
= true;
3921 disable_packet_qC
= true;
3922 disable_packet_qfThreadInfo
= true;
3926 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3928 gdbserver_show_disableable (stderr
);
3933 else if (strcmp (*next_arg
, "-") == 0)
3935 /* "-" specifies a stdio connection and is a form of port
3937 port
= STDIO_CONNECTION_NAME
;
3941 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3942 cs
.disable_randomization
= 1;
3943 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3944 cs
.disable_randomization
= 0;
3945 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3946 startup_with_shell
= true;
3947 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3948 startup_with_shell
= false;
3949 else if (strcmp (*next_arg
, "--once") == 0)
3951 else if (strcmp (*next_arg
, "--selftest") == 0)
3953 else if (startswith (*next_arg
, "--selftest="))
3958 const char *filter
= *next_arg
+ strlen ("--selftest=");
3959 if (*filter
== '\0')
3961 fprintf (stderr
, _("Error: selftest filter is empty.\n"));
3965 selftest_filters
.push_back (filter
);
3970 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3983 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3986 gdbserver_usage (stderr
);
3990 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3991 opened by remote_prepare. */
3994 save_original_signals_state (false);
3996 /* We need to know whether the remote connection is stdio before
3997 starting the inferior. Inferiors created in this scenario have
3998 stdin,stdout redirected. So do this here before we call
4001 remote_prepare (port
);
4006 /* --attach used to come after PORT, so allow it there for
4008 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
4015 && (*next_arg
== NULL
4016 || (*next_arg
)[0] == '\0'
4017 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
4019 || next_arg
[1] != NULL
))
4024 gdbserver_usage (stderr
);
4028 /* Gather information about the environment. */
4029 our_environ
= gdb_environ::from_host_environ ();
4031 initialize_async_io ();
4033 have_job_control ();
4034 if (target_supports_tracepoints ())
4035 initialize_tracepoint ();
4037 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
4042 selftests::run_tests (selftest_filters
);
4044 printf (_("Selftests have been disabled for this build.\n"));
4046 throw_quit ("Quit");
4049 if (pid
== 0 && *next_arg
!= NULL
)
4053 n
= argc
- (next_arg
- argv
);
4054 program_path
.set (next_arg
[0]);
4055 for (i
= 1; i
< n
; i
++)
4056 program_args
.push_back (xstrdup (next_arg
[i
]));
4058 /* Wait till we are at first instruction in program. */
4059 target_create_inferior (program_path
.get (), program_args
);
4061 /* We are now (hopefully) stopped at the first instruction of
4062 the target process. This assumes that the target process was
4063 successfully created. */
4067 if (attach_inferior (pid
) == -1)
4068 error ("Attaching not supported on this target");
4070 /* Otherwise succeeded. */
4074 cs
.last_status
.set_exited (0);
4075 cs
.last_ptid
= minus_one_ptid
;
4078 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
4080 /* Don't report shared library events on the initial connection,
4081 even if some libraries are preloaded. Avoids the "stopped by
4082 shared library event" notice on gdb side. */
4083 if (current_thread
!= nullptr)
4084 current_process ()->dlls_changed
= false;
4086 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4087 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
4092 if (!was_running
&& !multi_mode
)
4093 error ("No program to debug");
4098 cs
.multi_process
= 0;
4099 cs
.report_fork_events
= 0;
4100 cs
.report_vfork_events
= 0;
4101 cs
.report_exec_events
= 0;
4102 /* Be sure we're out of tfind mode. */
4103 cs
.current_traceframe
= -1;
4104 cs
.cont_thread
= null_ptid
;
4105 cs
.swbreak_feature
= 0;
4106 cs
.hwbreak_feature
= 0;
4107 cs
.vCont_supported
= 0;
4108 cs
.memory_tagging_feature
= false;
4114 /* Wait for events. This will return when all event sources
4115 are removed from the event loop. */
4116 start_event_loop ();
4118 /* If an exit was requested (using the "monitor exit"
4119 command), terminate now. */
4121 throw_quit ("Quit");
4123 /* The only other way to get here is for getpkt to fail:
4125 - If --once was specified, we're done.
4127 - If not in extended-remote mode, and we're no longer
4128 debugging anything, simply exit: GDB has disconnected
4129 after processing the last process exit.
4131 - Otherwise, close the connection and reopen it at the
4133 if (run_once
|| (!extended_protocol
&& !target_running ()))
4134 throw_quit ("Quit");
4137 "Remote side has terminated connection. "
4138 "GDBserver will reopen the connection.\n");
4140 /* Get rid of any pending statuses. An eventual reconnection
4141 (by the same GDB instance or another) will refresh all its
4142 state from scratch. */
4143 discard_queued_stop_replies (minus_one_ptid
);
4144 for_each_thread ([] (thread_info
*thread
)
4146 thread
->status_pending_p
= 0;
4151 if (disconnected_tracing
)
4153 /* Try to enable non-stop/async mode, so we we can
4154 both wait for an async socket accept, and handle
4155 async target events simultaneously. There's also
4156 no point either in having the target always stop
4157 all threads, when we're going to pass signals
4158 down without informing GDB. */
4161 if (the_target
->start_non_stop (true))
4164 /* Detaching implicitly resumes all threads;
4165 simply disconnecting does not. */
4171 "Disconnected tracing disabled; "
4172 "stopping trace run.\n");
4177 catch (const gdb_exception_error
&exception
)
4180 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
4182 if (response_needed
)
4184 write_enn (cs
.own_buf
);
4185 putpkt (cs
.own_buf
);
4189 throw_quit ("Quit");
4194 /* Main function. */
4197 main (int argc
, char *argv
[])
4202 captured_main (argc
, argv
);
4204 catch (const gdb_exception
&exception
)
4206 if (exception
.reason
== RETURN_ERROR
)
4209 fprintf (stderr
, "%s\n", exception
.what ());
4210 fprintf (stderr
, "Exiting\n");
4217 gdb_assert_not_reached ("captured_main should never return");
4220 /* Process options coming from Z packets for a breakpoint. PACKET is
4221 the packet buffer. *PACKET is updated to point to the first char
4222 after the last processed option. */
4225 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4227 const char *dataptr
= *packet
;
4230 /* Check if data has the correct format. */
4231 if (*dataptr
!= ';')
4238 if (*dataptr
== ';')
4241 if (*dataptr
== 'X')
4243 /* Conditional expression. */
4244 threads_debug_printf ("Found breakpoint condition.");
4245 if (!add_breakpoint_condition (bp
, &dataptr
))
4246 dataptr
= strchrnul (dataptr
, ';');
4248 else if (startswith (dataptr
, "cmds:"))
4250 dataptr
+= strlen ("cmds:");
4251 threads_debug_printf ("Found breakpoint commands %s.", dataptr
);
4252 persist
= (*dataptr
== '1');
4254 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4255 dataptr
= strchrnul (dataptr
, ';');
4259 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4261 /* Skip tokens until we find one that we recognize. */
4262 dataptr
= strchrnul (dataptr
, ';');
4268 /* Event loop callback that handles a serial event. The first byte in
4269 the serial buffer gets us here. We expect characters to arrive at
4270 a brisk pace, so we read the rest of the packet with a blocking
4274 process_serial_event (void)
4276 client_state
&cs
= get_client_state ();
4282 int new_packet_len
= -1;
4284 disable_async_io ();
4286 response_needed
= false;
4287 packet_len
= getpkt (cs
.own_buf
);
4288 if (packet_len
<= 0)
4291 /* Force an event loop break. */
4294 response_needed
= true;
4296 char ch
= cs
.own_buf
[0];
4300 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4303 handle_general_set (cs
.own_buf
);
4306 handle_detach (cs
.own_buf
);
4309 extended_protocol
= true;
4310 write_ok (cs
.own_buf
);
4313 handle_status (cs
.own_buf
);
4316 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4318 require_running_or_break (cs
.own_buf
);
4320 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4322 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4323 thread_id
= null_ptid
;
4324 else if (thread_id
.is_pid ())
4326 /* The ptid represents a pid. */
4327 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4331 write_enn (cs
.own_buf
);
4335 thread_id
= thread
->id
;
4339 /* The ptid represents a lwp/tid. */
4340 if (find_thread_ptid (thread_id
) == NULL
)
4342 write_enn (cs
.own_buf
);
4347 if (cs
.own_buf
[1] == 'g')
4349 if (thread_id
== null_ptid
)
4351 /* GDB is telling us to choose any thread. Check if
4352 the currently selected thread is still valid. If
4353 it is not, select the first available. */
4354 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4356 thread
= get_first_thread ();
4357 thread_id
= thread
->id
;
4360 cs
.general_thread
= thread_id
;
4361 set_desired_thread ();
4362 gdb_assert (current_thread
!= NULL
);
4364 else if (cs
.own_buf
[1] == 'c')
4365 cs
.cont_thread
= thread_id
;
4367 write_ok (cs
.own_buf
);
4371 /* Silently ignore it so that gdb can extend the protocol
4372 without compatibility headaches. */
4373 cs
.own_buf
[0] = '\0';
4377 require_running_or_break (cs
.own_buf
);
4378 if (cs
.current_traceframe
>= 0)
4380 struct regcache
*regcache
4381 = new_register_cache (current_target_desc ());
4383 if (fetch_traceframe_registers (cs
.current_traceframe
,
4385 registers_to_string (regcache
, cs
.own_buf
);
4387 write_enn (cs
.own_buf
);
4388 free_register_cache (regcache
);
4392 struct regcache
*regcache
;
4394 if (!set_desired_thread ())
4395 write_enn (cs
.own_buf
);
4398 regcache
= get_thread_regcache (current_thread
, 1);
4399 registers_to_string (regcache
, cs
.own_buf
);
4404 require_running_or_break (cs
.own_buf
);
4405 if (cs
.current_traceframe
>= 0)
4406 write_enn (cs
.own_buf
);
4409 struct regcache
*regcache
;
4411 if (!set_desired_thread ())
4412 write_enn (cs
.own_buf
);
4415 regcache
= get_thread_regcache (current_thread
, 1);
4416 registers_from_string (regcache
, &cs
.own_buf
[1]);
4417 write_ok (cs
.own_buf
);
4423 require_running_or_break (cs
.own_buf
);
4424 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4425 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4427 write_enn (cs
.own_buf
);
4429 bin2hex (mem_buf
, cs
.own_buf
, res
);
4433 require_running_or_break (cs
.own_buf
);
4434 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4435 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4436 write_ok (cs
.own_buf
);
4438 write_enn (cs
.own_buf
);
4441 require_running_or_break (cs
.own_buf
);
4442 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4443 &mem_addr
, &len
, &mem_buf
) < 0
4444 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4445 write_enn (cs
.own_buf
);
4447 write_ok (cs
.own_buf
);
4450 require_running_or_break (cs
.own_buf
);
4451 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4452 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4453 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4456 myresume (cs
.own_buf
, 0, signal
);
4459 require_running_or_break (cs
.own_buf
);
4460 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4461 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4462 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4465 myresume (cs
.own_buf
, 1, signal
);
4468 require_running_or_break (cs
.own_buf
);
4470 myresume (cs
.own_buf
, 0, signal
);
4473 require_running_or_break (cs
.own_buf
);
4475 myresume (cs
.own_buf
, 1, signal
);
4477 case 'Z': /* insert_ ... */
4479 case 'z': /* remove_ ... */
4484 char type
= cs
.own_buf
[1];
4486 const int insert
= ch
== 'Z';
4487 const char *p
= &cs
.own_buf
[3];
4489 p
= unpack_varlen_hex (p
, &addr
);
4490 kind
= strtol (p
+ 1, &dataptr
, 16);
4494 struct gdb_breakpoint
*bp
;
4496 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4501 /* GDB may have sent us a list of *point parameters to
4502 be evaluated on the target's side. Read such list
4503 here. If we already have a list of parameters, GDB
4504 is telling us to drop that list and use this one
4506 clear_breakpoint_conditions_and_commands (bp
);
4507 const char *options
= dataptr
;
4508 process_point_options (bp
, &options
);
4512 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4515 write_ok (cs
.own_buf
);
4518 cs
.own_buf
[0] = '\0';
4520 write_enn (cs
.own_buf
);
4524 response_needed
= false;
4525 if (!target_running ())
4526 /* The packet we received doesn't make sense - but we can't
4527 reply to it, either. */
4530 fprintf (stderr
, "Killing all inferiors\n");
4532 for_each_process (kill_inferior_callback
);
4534 /* When using the extended protocol, we wait with no program
4535 running. The traditional protocol will exit instead. */
4536 if (extended_protocol
)
4538 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4546 require_running_or_break (cs
.own_buf
);
4548 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4549 if (find_thread_ptid (thread_id
) == NULL
)
4551 write_enn (cs
.own_buf
);
4555 if (mythread_alive (thread_id
))
4556 write_ok (cs
.own_buf
);
4558 write_enn (cs
.own_buf
);
4562 response_needed
= false;
4564 /* Restarting the inferior is only supported in the extended
4566 if (extended_protocol
)
4568 if (target_running ())
4569 for_each_process (kill_inferior_callback
);
4571 fprintf (stderr
, "GDBserver restarting\n");
4573 /* Wait till we are at 1st instruction in prog. */
4574 if (program_path
.get () != NULL
)
4576 target_create_inferior (program_path
.get (), program_args
);
4578 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4580 /* Stopped at the first instruction of the target
4582 cs
.general_thread
= cs
.last_ptid
;
4586 /* Something went wrong. */
4587 cs
.general_thread
= null_ptid
;
4592 cs
.last_status
.set_exited (GDB_SIGNAL_KILL
);
4598 /* It is a request we don't understand. Respond with an
4599 empty packet so that gdb knows that we don't support this
4601 cs
.own_buf
[0] = '\0';
4605 /* Extended (long) request. */
4606 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4610 /* It is a request we don't understand. Respond with an empty
4611 packet so that gdb knows that we don't support this
4613 cs
.own_buf
[0] = '\0';
4617 if (new_packet_len
!= -1)
4618 putpkt_binary (cs
.own_buf
, new_packet_len
);
4620 putpkt (cs
.own_buf
);
4622 response_needed
= false;
4630 /* Event-loop callback for serial events. */
4633 handle_serial_event (int err
, gdb_client_data client_data
)
4635 threads_debug_printf ("handling possible serial event");
4637 /* Really handle it. */
4638 if (process_serial_event () < 0)
4640 keep_processing_events
= false;
4644 /* Be sure to not change the selected thread behind GDB's back.
4645 Important in the non-stop mode asynchronous protocol. */
4646 set_desired_thread ();
4649 /* Push a stop notification on the notification queue. */
4652 push_stop_notification (ptid_t ptid
, const target_waitstatus
&status
)
4654 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4656 vstop_notif
->status
= status
;
4657 vstop_notif
->ptid
= ptid
;
4658 /* Push Stop notification. */
4659 notif_push (¬if_stop
, vstop_notif
);
4662 /* Event-loop callback for target events. */
4665 handle_target_event (int err
, gdb_client_data client_data
)
4667 client_state
&cs
= get_client_state ();
4668 threads_debug_printf ("handling possible target event");
4670 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4673 if (cs
.last_status
.kind () == TARGET_WAITKIND_NO_RESUMED
)
4675 if (gdb_connected () && report_no_resumed
)
4676 push_stop_notification (null_ptid
, cs
.last_status
);
4678 else if (cs
.last_status
.kind () != TARGET_WAITKIND_IGNORE
)
4680 int pid
= cs
.last_ptid
.pid ();
4681 struct process_info
*process
= find_process_pid (pid
);
4682 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4684 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4685 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
)
4687 mark_breakpoints_out (process
);
4688 target_mourn_inferior (cs
.last_ptid
);
4690 else if (cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4694 /* We're reporting this thread as stopped. Update its
4695 "want-stopped" state to what the client wants, until it
4696 gets a new resume action. */
4697 current_thread
->last_resume_kind
= resume_stop
;
4698 current_thread
->last_status
= cs
.last_status
;
4703 if (!target_running ())
4705 /* The last process exited. We're done. */
4709 if (cs
.last_status
.kind () == TARGET_WAITKIND_EXITED
4710 || cs
.last_status
.kind () == TARGET_WAITKIND_SIGNALLED
4711 || cs
.last_status
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
4715 /* A thread stopped with a signal, but gdb isn't
4716 connected to handle it. Pass it down to the
4717 inferior, as if it wasn't being traced. */
4718 enum gdb_signal signal
;
4720 threads_debug_printf ("GDB not connected; forwarding event %d for"
4722 (int) cs
.last_status
.kind (),
4723 target_pid_to_str (cs
.last_ptid
).c_str ());
4725 if (cs
.last_status
.kind () == TARGET_WAITKIND_STOPPED
)
4726 signal
= cs
.last_status
.sig ();
4728 signal
= GDB_SIGNAL_0
;
4729 target_continue (cs
.last_ptid
, signal
);
4733 push_stop_notification (cs
.last_ptid
, cs
.last_status
);
4736 /* Be sure to not change the selected thread behind GDB's back.
4737 Important in the non-stop mode asynchronous protocol. */
4738 set_desired_thread ();
4741 /* See gdbsupport/event-loop.h. */
4744 invoke_async_signal_handlers ()
4749 /* See gdbsupport/event-loop.h. */
4752 check_async_event_handlers ()
4757 /* See gdbsupport/errors.h */
4766 /* See gdbsupport/gdb_select.h. */
4769 gdb_select (int n
, fd_set
*readfds
, fd_set
*writefds
,
4770 fd_set
*exceptfds
, struct timeval
*timeout
)
4772 return select (n
, readfds
, writefds
, exceptfds
, timeout
);
4783 } // namespace selftests
4784 #endif /* GDB_SELF_TEST */