1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2020 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
21 #include "gdbsupport/agent.h"
24 #include "gdbsupport/rsp-low.h"
25 #include "gdbsupport/signals-state-save-restore.h"
31 #include "gdbsupport/gdb_vecs.h"
32 #include "gdbsupport/gdb_wait.h"
33 #include "gdbsupport/btrace-common.h"
34 #include "gdbsupport/filestuff.h"
35 #include "tracepoint.h"
39 #include "gdbsupport/common-inferior.h"
40 #include "gdbsupport/job-control.h"
41 #include "gdbsupport/environ.h"
42 #include "filenames.h"
43 #include "gdbsupport/pathstuff.h"
45 #include "xml-builtin.h"
48 #include "gdbsupport/selftest.h"
49 #include "gdbsupport/scope-exit.h"
50 #include "gdbsupport/gdb_select.h"
52 #define require_running_or_return(BUF) \
53 if (!target_running ()) \
59 #define require_running_or_break(BUF) \
60 if (!target_running ()) \
66 /* String containing the current directory (what getwd would return). */
68 char *current_directory
;
70 /* The environment to pass to the inferior when creating it. */
72 static gdb_environ our_environ
;
76 static bool extended_protocol
;
77 static bool response_needed
;
78 static bool exit_requested
;
80 /* --once: Exit after the first connection has closed. */
83 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
84 static bool report_no_resumed
;
86 /* The event loop checks this to decide whether to continue accepting
88 static bool keep_processing_events
= true;
93 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
95 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
97 m_path
= std::move (path
);
99 /* Make sure we're using the absolute path of the inferior when
101 if (!contains_dir_separator (m_path
.get ()))
105 /* Check if the file is in our CWD. If it is, then we prefix
106 its name with CURRENT_DIRECTORY. Otherwise, we leave the
107 name as-is because we'll try searching for it in $PATH. */
108 if (is_regular_file (m_path
.get (), ®_file_errno
))
109 m_path
= gdb_abspath (m_path
.get ());
113 /* Return the PROGRAM_PATH. */
115 { return m_path
.get (); }
118 /* The program name, adjusted if needed. */
119 gdb::unique_xmalloc_ptr
<char> m_path
;
121 static std::vector
<char *> program_args
;
122 static std::string wrapper_argv
;
124 /* The PID of the originally created or attached inferior. Used to
125 send signals to the process when GDB sends us an asynchronous interrupt
126 (user hitting Control-C in the client), and to wait for the child to exit
127 when no longer debugging it. */
129 unsigned long signal_pid
;
131 /* Set if you want to disable optional thread related packets support
132 in gdbserver, for the sake of testing GDB against stubs that don't
134 bool disable_packet_vCont
;
135 bool disable_packet_Tthread
;
136 bool disable_packet_qC
;
137 bool disable_packet_qfThreadInfo
;
138 bool disable_packet_T
;
140 static unsigned char *mem_buf
;
142 /* A sub-class of 'struct notif_event' for stop, holding information
143 relative to a single stop reply. We keep a queue of these to
144 push to GDB in non-stop mode. */
146 struct vstop_notif
: public notif_event
148 /* Thread or process that got the event. */
152 struct target_waitstatus status
;
155 /* The current btrace configuration. This is gdbserver's mirror of GDB's
156 btrace configuration. */
157 static struct btrace_config current_btrace_conf
;
159 /* The client remote protocol state. */
161 static client_state g_client_state
;
166 client_state
&cs
= g_client_state
;
171 /* Put a stop reply to the stop reply queue. */
174 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
176 struct vstop_notif
*new_notif
= new struct vstop_notif
;
178 new_notif
->ptid
= ptid
;
179 new_notif
->status
= *status
;
181 notif_event_enque (¬if_stop
, new_notif
);
185 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
187 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
189 return vstop_event
->ptid
.matches (filter_ptid
);
195 discard_queued_stop_replies (ptid_t ptid
)
197 std::list
<notif_event
*>::iterator iter
, next
, end
;
198 end
= notif_stop
.queue
.end ();
199 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
204 if (remove_all_on_match_ptid (*iter
, ptid
))
207 notif_stop
.queue
.erase (iter
);
213 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
215 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
217 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
220 /* Helper for in_queued_stop_replies. */
223 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
225 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
227 if (vstop_event
->ptid
.matches (filter_ptid
))
230 /* Don't resume fork children that GDB does not know about yet. */
231 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
232 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
233 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
242 in_queued_stop_replies (ptid_t ptid
)
244 for (notif_event
*event
: notif_stop
.queue
)
246 if (in_queued_stop_replies_ptid (event
, ptid
))
253 struct notif_server notif_stop
=
255 "vStopped", "Stop", {}, vstop_notif_reply
,
259 target_running (void)
261 return get_first_thread () != NULL
;
264 /* See gdbsupport/common-inferior.h. */
269 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
272 /* See gdbsupport/common-inferior.h. */
275 get_exec_file (int err
)
277 if (err
&& program_path
.get () == NULL
)
278 error (_("No executable file specified."));
280 return program_path
.get ();
292 attach_inferior (int pid
)
294 client_state
&cs
= get_client_state ();
295 /* myattach should return -1 if attaching is unsupported,
296 0 if it succeeded, and call error() otherwise. */
298 if (find_process_pid (pid
) != nullptr)
299 error ("Already attached to process %d\n", pid
);
301 if (myattach (pid
) != 0)
304 fprintf (stderr
, "Attached; pid = %d\n", pid
);
307 /* FIXME - It may be that we should get the SIGNAL_PID from the
308 attach function, so that it can be the main thread instead of
309 whichever we were told to attach to. */
314 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
316 /* GDB knows to ignore the first SIGSTOP after attaching to a running
317 process using the "attach" command, but this is different; it's
318 just using "target remote". Pretend it's just starting up. */
319 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
320 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
321 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
323 current_thread
->last_resume_kind
= resume_stop
;
324 current_thread
->last_status
= cs
.last_status
;
330 /* Decode a qXfer read request. Return 0 if everything looks OK,
334 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
336 /* After the read marker and annex, qXfer looks like a
337 traditional 'm' packet. */
338 decode_m_packet (buf
, ofs
, len
);
344 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
346 /* Extract and NUL-terminate the object. */
348 while (*buf
&& *buf
!= ':')
354 /* Extract and NUL-terminate the read/write action. */
356 while (*buf
&& *buf
!= ':')
362 /* Extract and NUL-terminate the annex. */
364 while (*buf
&& *buf
!= ':')
374 /* Write the response to a successful qXfer read. Returns the
375 length of the (binary) data stored in BUF, corresponding
376 to as much of DATA/LEN as we could fit. IS_MORE controls
377 the first character of the response. */
379 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
388 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
389 &out_len
, PBUFSIZ
- 2) + 1;
392 /* Handle btrace enabling in BTS format. */
395 handle_btrace_enable_bts (struct thread_info
*thread
)
397 if (thread
->btrace
!= NULL
)
398 error (_("Btrace already enabled."));
400 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
401 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
404 /* Handle btrace enabling in Intel Processor Trace format. */
407 handle_btrace_enable_pt (struct thread_info
*thread
)
409 if (thread
->btrace
!= NULL
)
410 error (_("Btrace already enabled."));
412 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
413 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
416 /* Handle btrace disabling. */
419 handle_btrace_disable (struct thread_info
*thread
)
422 if (thread
->btrace
== NULL
)
423 error (_("Branch tracing not enabled."));
425 if (target_disable_btrace (thread
->btrace
) != 0)
426 error (_("Could not disable branch tracing."));
428 thread
->btrace
= NULL
;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf
)
436 client_state
&cs
= get_client_state ();
437 struct thread_info
*thread
;
440 if (!startswith (own_buf
, "Qbtrace:"))
443 op
= own_buf
+ strlen ("Qbtrace:");
445 if (cs
.general_thread
== null_ptid
446 || cs
.general_thread
== minus_one_ptid
)
448 strcpy (own_buf
, "E.Must select a single thread.");
452 thread
= find_thread_ptid (cs
.general_thread
);
455 strcpy (own_buf
, "E.No such thread.");
461 if (strcmp (op
, "bts") == 0)
462 handle_btrace_enable_bts (thread
);
463 else if (strcmp (op
, "pt") == 0)
464 handle_btrace_enable_pt (thread
);
465 else if (strcmp (op
, "off") == 0)
466 handle_btrace_disable (thread
);
468 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
472 catch (const gdb_exception_error
&exception
)
474 sprintf (own_buf
, "E.%s", exception
.what ());
480 /* Handle the "Qbtrace-conf" packet. */
483 handle_btrace_conf_general_set (char *own_buf
)
485 client_state
&cs
= get_client_state ();
486 struct thread_info
*thread
;
489 if (!startswith (own_buf
, "Qbtrace-conf:"))
492 op
= own_buf
+ strlen ("Qbtrace-conf:");
494 if (cs
.general_thread
== null_ptid
495 || cs
.general_thread
== minus_one_ptid
)
497 strcpy (own_buf
, "E.Must select a single thread.");
501 thread
= find_thread_ptid (cs
.general_thread
);
504 strcpy (own_buf
, "E.No such thread.");
508 if (startswith (op
, "bts:size="))
514 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
515 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
517 strcpy (own_buf
, "E.Bad size value.");
521 current_btrace_conf
.bts
.size
= (unsigned int) size
;
523 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
529 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
530 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
532 strcpy (own_buf
, "E.Bad size value.");
536 current_btrace_conf
.pt
.size
= (unsigned int) size
;
540 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
548 /* Handle all of the extended 'Q' packets. */
551 handle_general_set (char *own_buf
)
553 client_state
&cs
= get_client_state ();
554 if (startswith (own_buf
, "QPassSignals:"))
556 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
557 const char *p
= own_buf
+ strlen ("QPassSignals:");
560 p
= decode_address_to_semicolon (&cursig
, p
);
561 for (i
= 0; i
< numsigs
; i
++)
565 cs
.pass_signals
[i
] = 1;
567 /* Keep looping, to clear the remaining signals. */
570 p
= decode_address_to_semicolon (&cursig
, p
);
573 cs
.pass_signals
[i
] = 0;
575 strcpy (own_buf
, "OK");
579 if (startswith (own_buf
, "QProgramSignals:"))
581 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
582 const char *p
= own_buf
+ strlen ("QProgramSignals:");
585 cs
.program_signals_p
= 1;
587 p
= decode_address_to_semicolon (&cursig
, p
);
588 for (i
= 0; i
< numsigs
; i
++)
592 cs
.program_signals
[i
] = 1;
594 /* Keep looping, to clear the remaining signals. */
597 p
= decode_address_to_semicolon (&cursig
, p
);
600 cs
.program_signals
[i
] = 0;
602 strcpy (own_buf
, "OK");
606 if (startswith (own_buf
, "QCatchSyscalls:"))
608 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
611 struct process_info
*process
;
613 if (!target_running () || !target_supports_catch_syscall ())
619 if (strcmp (p
, "0") == 0)
621 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
625 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
631 process
= current_process ();
632 process
->syscalls_to_catch
.clear ();
642 p
= decode_address_to_semicolon (&sysno
, p
);
643 process
->syscalls_to_catch
.push_back (sysno
);
647 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
654 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
656 our_environ
= gdb_environ::from_host_environ ();
662 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
664 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
665 /* The final form of the environment variable. FINAL_VAR will
666 hold the 'VAR=VALUE' format. */
667 std::string final_var
= hex2str (p
);
668 std::string var_name
, var_value
;
672 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
673 debug_printf (_("[Environment variable to be set: '%s']\n"),
678 size_t pos
= final_var
.find ('=');
679 if (pos
== std::string::npos
)
681 warning (_("Unexpected format for environment variable: '%s'"),
687 var_name
= final_var
.substr (0, pos
);
688 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
690 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
696 if (startswith (own_buf
, "QEnvironmentUnset:"))
698 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
699 std::string varname
= hex2str (p
);
703 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
704 debug_printf (_("[Environment variable to be unset: '%s']\n"),
709 our_environ
.unset (varname
.c_str ());
715 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
719 debug_printf ("[noack mode enabled]\n");
728 if (startswith (own_buf
, "QNonStop:"))
730 char *mode
= own_buf
+ 9;
734 if (strcmp (mode
, "0") == 0)
736 else if (strcmp (mode
, "1") == 0)
740 /* We don't know what this mode is, so complain to
742 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
748 req_str
= req
? "non-stop" : "all-stop";
749 if (the_target
->start_non_stop (req
== 1) != 0)
751 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
756 non_stop
= (req
!= 0);
759 debug_printf ("[%s mode enabled]\n", req_str
);
765 if (startswith (own_buf
, "QDisableRandomization:"))
767 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
770 unpack_varlen_hex (packet
, &setting
);
771 cs
.disable_randomization
= setting
;
775 debug_printf (cs
.disable_randomization
776 ? "[address space randomization disabled]\n"
777 : "[address space randomization enabled]\n");
784 if (target_supports_tracepoints ()
785 && handle_tracepoint_general_set (own_buf
))
788 if (startswith (own_buf
, "QAgent:"))
790 char *mode
= own_buf
+ strlen ("QAgent:");
793 if (strcmp (mode
, "0") == 0)
795 else if (strcmp (mode
, "1") == 0)
799 /* We don't know what this value is, so complain to GDB. */
800 sprintf (own_buf
, "E.Unknown QAgent value");
804 /* Update the flag. */
807 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
812 if (handle_btrace_general_set (own_buf
))
815 if (handle_btrace_conf_general_set (own_buf
))
818 if (startswith (own_buf
, "QThreadEvents:"))
820 char *mode
= own_buf
+ strlen ("QThreadEvents:");
821 enum tribool req
= TRIBOOL_UNKNOWN
;
823 if (strcmp (mode
, "0") == 0)
825 else if (strcmp (mode
, "1") == 0)
829 /* We don't know what this mode is, so complain to GDB. */
830 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
835 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
839 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
841 debug_printf ("[thread events are now %s]\n", req_str
);
848 if (startswith (own_buf
, "QStartupWithShell:"))
850 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
852 if (strcmp (value
, "1") == 0)
853 startup_with_shell
= true;
854 else if (strcmp (value
, "0") == 0)
855 startup_with_shell
= false;
859 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
866 debug_printf (_("[Inferior will %s started with shell]"),
867 startup_with_shell
? "be" : "not be");
873 if (startswith (own_buf
, "QSetWorkingDir:"))
875 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
879 std::string path
= hex2str (p
);
881 set_inferior_cwd (path
.c_str ());
884 debug_printf (_("[Set the inferior's current directory to %s]\n"),
889 /* An empty argument means that we should clear out any
890 previously set cwd for the inferior. */
891 set_inferior_cwd (NULL
);
895 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
902 /* Otherwise we didn't know what packet it was. Say we didn't
908 get_features_xml (const char *annex
)
910 const struct target_desc
*desc
= current_target_desc ();
912 /* `desc->xmltarget' defines what to return when looking for the
913 "target.xml" file. Its contents can either be verbatim XML code
914 (prefixed with a '@') or else the name of the actual XML file to
915 be used in place of "target.xml".
917 This variable is set up from the auto-generated
918 init_registers_... routine for the current target. */
920 if (strcmp (annex
, "target.xml") == 0)
922 const char *ret
= tdesc_get_features_xml (desc
);
934 /* Look for the annex. */
935 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
936 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
939 if (xml_builtin
[i
][0] != NULL
)
940 return xml_builtin
[i
][1];
948 monitor_show_help (void)
950 monitor_output ("The following monitor commands are supported:\n");
951 monitor_output (" set debug <0|1>\n");
952 monitor_output (" Enable general debugging messages\n");
953 monitor_output (" set debug-hw-points <0|1>\n");
954 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
955 monitor_output (" set remote-debug <0|1>\n");
956 monitor_output (" Enable remote protocol debugging messages\n");
957 monitor_output (" set debug-format option1[,option2,...]\n");
958 monitor_output (" Add additional information to debugging messages\n");
959 monitor_output (" Options: all, none");
960 monitor_output (", timestamp");
961 monitor_output ("\n");
962 monitor_output (" exit\n");
963 monitor_output (" Quit GDBserver\n");
966 /* Read trace frame or inferior memory. Returns the number of bytes
967 actually read, zero when no further transfer is possible, and -1 on
968 error. Return of a positive value smaller than LEN does not
969 indicate there's no more to be read, only the end of the transfer.
970 E.g., when GDB reads memory from a traceframe, a first request may
971 be served from a memory block that does not cover the whole request
972 length. A following request gets the rest served from either
973 another block (of the same traceframe) or from the read-only
977 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
979 client_state
&cs
= get_client_state ();
982 if (cs
.current_traceframe
>= 0)
985 ULONGEST length
= len
;
987 if (traceframe_read_mem (cs
.current_traceframe
,
988 memaddr
, myaddr
, len
, &nbytes
))
990 /* Data read from trace buffer, we're done. */
993 if (!in_readonly_region (memaddr
, length
))
995 /* Otherwise we have a valid readonly case, fall through. */
996 /* (assume no half-trace half-real blocks for now) */
999 res
= prepare_to_access_memory ();
1002 if (set_desired_thread ())
1003 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1006 done_accessing_memory ();
1008 return res
== 0 ? len
: -1;
1014 /* Write trace frame or inferior memory. Actually, writing to trace
1015 frames is forbidden. */
1018 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1020 client_state
&cs
= get_client_state ();
1021 if (cs
.current_traceframe
>= 0)
1027 ret
= prepare_to_access_memory ();
1030 if (set_desired_thread ())
1031 ret
= target_write_memory (memaddr
, myaddr
, len
);
1034 done_accessing_memory ();
1040 /* Subroutine of handle_search_memory to simplify it. */
1043 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1044 gdb_byte
*pattern
, unsigned pattern_len
,
1045 gdb_byte
*search_buf
,
1046 unsigned chunk_size
, unsigned search_buf_size
,
1047 CORE_ADDR
*found_addrp
)
1049 /* Prime the search buffer. */
1051 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1054 warning ("Unable to access %ld bytes of target "
1055 "memory at 0x%lx, halting search.",
1056 (long) search_buf_size
, (long) start_addr
);
1060 /* Perform the search.
1062 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1063 When we've scanned N bytes we copy the trailing bytes to the start and
1064 read in another N bytes. */
1066 while (search_space_len
>= pattern_len
)
1068 gdb_byte
*found_ptr
;
1069 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1073 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1076 if (found_ptr
!= NULL
)
1078 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1079 *found_addrp
= found_addr
;
1083 /* Not found in this chunk, skip to next chunk. */
1085 /* Don't let search_space_len wrap here, it's unsigned. */
1086 if (search_space_len
>= chunk_size
)
1087 search_space_len
-= chunk_size
;
1089 search_space_len
= 0;
1091 if (search_space_len
>= pattern_len
)
1093 unsigned keep_len
= search_buf_size
- chunk_size
;
1094 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1097 /* Copy the trailing part of the previous iteration to the front
1098 of the buffer for the next iteration. */
1099 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1101 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1102 ? search_space_len
- keep_len
1105 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1106 nr_to_read
) != nr_to_read
)
1108 warning ("Unable to access %ld bytes of target memory "
1109 "at 0x%lx, halting search.",
1110 (long) nr_to_read
, (long) read_addr
);
1114 start_addr
+= chunk_size
;
1123 /* Handle qSearch:memory packets. */
1126 handle_search_memory (char *own_buf
, int packet_len
)
1128 CORE_ADDR start_addr
;
1129 CORE_ADDR search_space_len
;
1131 unsigned int pattern_len
;
1132 /* NOTE: also defined in find.c testcase. */
1133 #define SEARCH_CHUNK_SIZE 16000
1134 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1135 /* Buffer to hold memory contents for searching. */
1136 gdb_byte
*search_buf
;
1137 unsigned search_buf_size
;
1139 CORE_ADDR found_addr
;
1140 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1142 pattern
= (gdb_byte
*) malloc (packet_len
);
1143 if (pattern
== NULL
)
1145 error ("Unable to allocate memory to perform the search");
1146 strcpy (own_buf
, "E00");
1149 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1150 packet_len
- cmd_name_len
,
1151 &start_addr
, &search_space_len
,
1152 pattern
, &pattern_len
) < 0)
1155 error ("Error in parsing qSearch:memory packet");
1156 strcpy (own_buf
, "E00");
1160 search_buf_size
= chunk_size
+ pattern_len
- 1;
1162 /* No point in trying to allocate a buffer larger than the search space. */
1163 if (search_space_len
< search_buf_size
)
1164 search_buf_size
= search_space_len
;
1166 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1167 if (search_buf
== NULL
)
1170 error ("Unable to allocate memory to perform the search");
1171 strcpy (own_buf
, "E00");
1175 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1176 pattern
, pattern_len
,
1177 search_buf
, chunk_size
, search_buf_size
,
1181 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1182 else if (found
== 0)
1183 strcpy (own_buf
, "0");
1185 strcpy (own_buf
, "E00");
1191 /* Handle the "D" packet. */
1194 handle_detach (char *own_buf
)
1196 client_state
&cs
= get_client_state ();
1198 process_info
*process
;
1200 if (cs
.multi_process
)
1203 int pid
= strtol (&own_buf
[2], NULL
, 16);
1205 process
= find_process_pid (pid
);
1209 process
= (current_thread
!= nullptr
1210 ? get_thread_process (current_thread
)
1214 if (process
== NULL
)
1216 write_enn (own_buf
);
1220 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1222 if (tracing
&& disconnected_tracing
)
1224 "Disconnected tracing in effect, "
1225 "leaving gdbserver attached to the process\n");
1227 if (any_persistent_commands (process
))
1229 "Persistent commands are present, "
1230 "leaving gdbserver attached to the process\n");
1232 /* Make sure we're in non-stop/async mode, so we we can both
1233 wait for an async socket accept, and handle async target
1234 events simultaneously. There's also no point either in
1235 having the target stop all threads, when we're going to
1236 pass signals down without informing GDB. */
1240 debug_printf ("Forcing non-stop mode\n");
1243 the_target
->start_non_stop (true);
1246 process
->gdb_detached
= 1;
1248 /* Detaching implicitly resumes all threads. */
1249 target_continue_no_signal (minus_one_ptid
);
1255 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1258 /* We'll need this after PROCESS has been destroyed. */
1259 int pid
= process
->pid
;
1261 if (detach_inferior (process
) != 0)
1262 write_enn (own_buf
);
1265 discard_queued_stop_replies (ptid_t (pid
));
1268 if (extended_protocol
|| target_running ())
1270 /* There is still at least one inferior remaining or
1271 we are in extended mode, so don't terminate gdbserver,
1272 and instead treat this like a normal program exit. */
1273 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1274 cs
.last_status
.value
.integer
= 0;
1275 cs
.last_ptid
= ptid_t (pid
);
1277 current_thread
= NULL
;
1284 /* If we are attached, then we can exit. Otherwise, we
1285 need to hang around doing nothing, until the child is
1287 join_inferior (pid
);
1293 /* Parse options to --debug-format= and "monitor set debug-format".
1294 ARG is the text after "--debug-format=" or "monitor set debug-format".
1295 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1296 This triggers calls to monitor_output.
1297 The result is an empty string if all options were parsed ok, otherwise an
1298 error message which the caller must free.
1300 N.B. These commands affect all debug format settings, they are not
1301 cumulative. If a format is not specified, it is turned off.
1302 However, we don't go to extra trouble with things like
1303 "monitor set debug-format all,none,timestamp".
1304 Instead we just parse them one at a time, in order.
1306 The syntax for "monitor set debug" we support here is not identical
1307 to gdb's "set debug foo on|off" because we also use this function to
1308 parse "--debug-format=foo,bar". */
1311 parse_debug_format_options (const char *arg
, int is_monitor
)
1313 /* First turn all debug format options off. */
1314 debug_timestamp
= 0;
1316 /* First remove leading spaces, for "monitor set debug-format". */
1317 while (isspace (*arg
))
1320 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1321 = delim_string_to_char_ptr_vec (arg
, ',');
1323 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1325 if (strcmp (option
.get (), "all") == 0)
1327 debug_timestamp
= 1;
1329 monitor_output ("All extra debug format options enabled.\n");
1331 else if (strcmp (option
.get (), "none") == 0)
1333 debug_timestamp
= 0;
1335 monitor_output ("All extra debug format options disabled.\n");
1337 else if (strcmp (option
.get (), "timestamp") == 0)
1339 debug_timestamp
= 1;
1341 monitor_output ("Timestamps will be added to debug output.\n");
1343 else if (*option
== '\0')
1345 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1349 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1353 return std::string ();
1356 /* Handle monitor commands not handled by target-specific handlers. */
1359 handle_monitor_command (char *mon
, char *own_buf
)
1361 if (strcmp (mon
, "set debug 1") == 0)
1364 monitor_output ("Debug output enabled.\n");
1366 else if (strcmp (mon
, "set debug 0") == 0)
1369 monitor_output ("Debug output disabled.\n");
1371 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1373 show_debug_regs
= 1;
1374 monitor_output ("H/W point debugging output enabled.\n");
1376 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1378 show_debug_regs
= 0;
1379 monitor_output ("H/W point debugging output disabled.\n");
1381 else if (strcmp (mon
, "set remote-debug 1") == 0)
1384 monitor_output ("Protocol debug output enabled.\n");
1386 else if (strcmp (mon
, "set remote-debug 0") == 0)
1389 monitor_output ("Protocol debug output disabled.\n");
1391 else if (startswith (mon
, "set debug-format "))
1393 std::string error_msg
1394 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1397 if (!error_msg
.empty ())
1399 monitor_output (error_msg
.c_str ());
1400 monitor_show_help ();
1401 write_enn (own_buf
);
1404 else if (strcmp (mon
, "set debug-file") == 0)
1405 debug_set_output (nullptr);
1406 else if (startswith (mon
, "set debug-file "))
1407 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1408 else if (strcmp (mon
, "help") == 0)
1409 monitor_show_help ();
1410 else if (strcmp (mon
, "exit") == 0)
1411 exit_requested
= true;
1414 monitor_output ("Unknown monitor command.\n\n");
1415 monitor_show_help ();
1416 write_enn (own_buf
);
1420 /* Associates a callback with each supported qXfer'able object. */
1424 /* The object this handler handles. */
1427 /* Request that the target transfer up to LEN 8-bit bytes of the
1428 target's OBJECT. The OFFSET, for a seekable object, specifies
1429 the starting point. The ANNEX can be used to provide additional
1430 data-specific information to the target.
1432 Return the number of bytes actually transfered, zero when no
1433 further transfer is possible, -1 on error, -2 when the transfer
1434 is not supported, and -3 on a verbose error message that should
1435 be preserved. Return of a positive value smaller than LEN does
1436 not indicate the end of the object, only the end of the transfer.
1438 One, and only one, of readbuf or writebuf must be non-NULL. */
1439 int (*xfer
) (const char *annex
,
1440 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1441 ULONGEST offset
, LONGEST len
);
1444 /* Handle qXfer:auxv:read. */
1447 handle_qxfer_auxv (const char *annex
,
1448 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1449 ULONGEST offset
, LONGEST len
)
1451 if (!the_target
->supports_read_auxv () || writebuf
!= NULL
)
1454 if (annex
[0] != '\0' || current_thread
== NULL
)
1457 return the_target
->read_auxv (offset
, readbuf
, len
);
1460 /* Handle qXfer:exec-file:read. */
1463 handle_qxfer_exec_file (const char *annex
,
1464 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1465 ULONGEST offset
, LONGEST len
)
1471 if (!the_target
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1474 if (annex
[0] == '\0')
1476 if (current_thread
== NULL
)
1479 pid
= pid_of (current_thread
);
1483 annex
= unpack_varlen_hex (annex
, &pid
);
1484 if (annex
[0] != '\0')
1491 file
= the_target
->pid_to_exec_file (pid
);
1495 total_len
= strlen (file
);
1497 if (offset
> total_len
)
1500 if (offset
+ len
> total_len
)
1501 len
= total_len
- offset
;
1503 memcpy (readbuf
, file
+ offset
, len
);
1507 /* Handle qXfer:features:read. */
1510 handle_qxfer_features (const char *annex
,
1511 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1512 ULONGEST offset
, LONGEST len
)
1514 const char *document
;
1517 if (writebuf
!= NULL
)
1520 if (!target_running ())
1523 /* Grab the correct annex. */
1524 document
= get_features_xml (annex
);
1525 if (document
== NULL
)
1528 total_len
= strlen (document
);
1530 if (offset
> total_len
)
1533 if (offset
+ len
> total_len
)
1534 len
= total_len
- offset
;
1536 memcpy (readbuf
, document
+ offset
, len
);
1540 /* Handle qXfer:libraries:read. */
1543 handle_qxfer_libraries (const char *annex
,
1544 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1545 ULONGEST offset
, LONGEST len
)
1547 if (writebuf
!= NULL
)
1550 if (annex
[0] != '\0' || current_thread
== NULL
)
1553 std::string document
= "<library-list version=\"1.0\">\n";
1555 for (const dll_info
&dll
: all_dlls
)
1556 document
+= string_printf
1557 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1558 dll
.name
.c_str (), paddress (dll
.base_addr
));
1560 document
+= "</library-list>\n";
1562 if (offset
> document
.length ())
1565 if (offset
+ len
> document
.length ())
1566 len
= document
.length () - offset
;
1568 memcpy (readbuf
, &document
[offset
], len
);
1573 /* Handle qXfer:libraries-svr4:read. */
1576 handle_qxfer_libraries_svr4 (const char *annex
,
1577 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1578 ULONGEST offset
, LONGEST len
)
1580 if (writebuf
!= NULL
)
1583 if (current_thread
== NULL
1584 || !the_target
->supports_qxfer_libraries_svr4 ())
1587 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1591 /* Handle qXfer:osadata:read. */
1594 handle_qxfer_osdata (const char *annex
,
1595 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1596 ULONGEST offset
, LONGEST len
)
1598 if (!the_target
->supports_qxfer_osdata () || writebuf
!= NULL
)
1601 return the_target
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1604 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1607 handle_qxfer_siginfo (const char *annex
,
1608 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1609 ULONGEST offset
, LONGEST len
)
1611 if (!the_target
->supports_qxfer_siginfo ())
1614 if (annex
[0] != '\0' || current_thread
== NULL
)
1617 return the_target
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1620 /* Handle qXfer:statictrace:read. */
1623 handle_qxfer_statictrace (const char *annex
,
1624 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1625 ULONGEST offset
, LONGEST len
)
1627 client_state
&cs
= get_client_state ();
1630 if (writebuf
!= NULL
)
1633 if (annex
[0] != '\0' || current_thread
== NULL
1634 || cs
.current_traceframe
== -1)
1637 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1638 readbuf
, len
, &nbytes
))
1643 /* Helper for handle_qxfer_threads_proper.
1644 Emit the XML to describe the thread of INF. */
1647 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1649 ptid_t ptid
= ptid_of (thread
);
1651 int core
= target_core_of_thread (ptid
);
1653 const char *name
= target_thread_name (ptid
);
1656 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1658 write_ptid (ptid_s
, ptid
);
1660 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1664 sprintf (core_s
, "%d", core
);
1665 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1669 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1673 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1674 bin2hex (handle
, handle_s
, handle_len
);
1675 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1678 buffer_xml_printf (buffer
, "/>\n");
1681 /* Helper for handle_qxfer_threads. */
1684 handle_qxfer_threads_proper (struct buffer
*buffer
)
1686 buffer_grow_str (buffer
, "<threads>\n");
1688 for_each_thread ([&] (thread_info
*thread
)
1690 handle_qxfer_threads_worker (thread
, buffer
);
1693 buffer_grow_str0 (buffer
, "</threads>\n");
1696 /* Handle qXfer:threads:read. */
1699 handle_qxfer_threads (const char *annex
,
1700 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1701 ULONGEST offset
, LONGEST len
)
1703 static char *result
= 0;
1704 static unsigned int result_length
= 0;
1706 if (writebuf
!= NULL
)
1709 if (annex
[0] != '\0')
1714 struct buffer buffer
;
1715 /* When asked for data at offset 0, generate everything and store into
1716 'result'. Successive reads will be served off 'result'. */
1720 buffer_init (&buffer
);
1722 handle_qxfer_threads_proper (&buffer
);
1724 result
= buffer_finish (&buffer
);
1725 result_length
= strlen (result
);
1726 buffer_free (&buffer
);
1729 if (offset
>= result_length
)
1731 /* We're out of data. */
1738 if (len
> result_length
- offset
)
1739 len
= result_length
- offset
;
1741 memcpy (readbuf
, result
+ offset
, len
);
1746 /* Handle qXfer:traceframe-info:read. */
1749 handle_qxfer_traceframe_info (const char *annex
,
1750 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1751 ULONGEST offset
, LONGEST len
)
1753 client_state
&cs
= get_client_state ();
1754 static char *result
= 0;
1755 static unsigned int result_length
= 0;
1757 if (writebuf
!= NULL
)
1760 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1765 struct buffer buffer
;
1767 /* When asked for data at offset 0, generate everything and
1768 store into 'result'. Successive reads will be served off
1772 buffer_init (&buffer
);
1774 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1776 result
= buffer_finish (&buffer
);
1777 result_length
= strlen (result
);
1778 buffer_free (&buffer
);
1781 if (offset
>= result_length
)
1783 /* We're out of data. */
1790 if (len
> result_length
- offset
)
1791 len
= result_length
- offset
;
1793 memcpy (readbuf
, result
+ offset
, len
);
1797 /* Handle qXfer:fdpic:read. */
1800 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1801 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1803 if (!the_target
->supports_read_loadmap ())
1806 if (current_thread
== NULL
)
1809 return the_target
->read_loadmap (annex
, offset
, readbuf
, len
);
1812 /* Handle qXfer:btrace:read. */
1815 handle_qxfer_btrace (const char *annex
,
1816 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1817 ULONGEST offset
, LONGEST len
)
1819 client_state
&cs
= get_client_state ();
1820 static struct buffer cache
;
1821 struct thread_info
*thread
;
1822 enum btrace_read_type type
;
1825 if (writebuf
!= NULL
)
1828 if (cs
.general_thread
== null_ptid
1829 || cs
.general_thread
== minus_one_ptid
)
1831 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1835 thread
= find_thread_ptid (cs
.general_thread
);
1838 strcpy (cs
.own_buf
, "E.No such thread.");
1842 if (thread
->btrace
== NULL
)
1844 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1848 if (strcmp (annex
, "all") == 0)
1849 type
= BTRACE_READ_ALL
;
1850 else if (strcmp (annex
, "new") == 0)
1851 type
= BTRACE_READ_NEW
;
1852 else if (strcmp (annex
, "delta") == 0)
1853 type
= BTRACE_READ_DELTA
;
1856 strcpy (cs
.own_buf
, "E.Bad annex.");
1862 buffer_free (&cache
);
1866 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1868 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1870 catch (const gdb_exception_error
&exception
)
1872 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1879 else if (offset
> cache
.used_size
)
1881 buffer_free (&cache
);
1885 if (len
> cache
.used_size
- offset
)
1886 len
= cache
.used_size
- offset
;
1888 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1893 /* Handle qXfer:btrace-conf:read. */
1896 handle_qxfer_btrace_conf (const char *annex
,
1897 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1898 ULONGEST offset
, LONGEST len
)
1900 client_state
&cs
= get_client_state ();
1901 static struct buffer cache
;
1902 struct thread_info
*thread
;
1905 if (writebuf
!= NULL
)
1908 if (annex
[0] != '\0')
1911 if (cs
.general_thread
== null_ptid
1912 || cs
.general_thread
== minus_one_ptid
)
1914 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1918 thread
= find_thread_ptid (cs
.general_thread
);
1921 strcpy (cs
.own_buf
, "E.No such thread.");
1925 if (thread
->btrace
== NULL
)
1927 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1933 buffer_free (&cache
);
1937 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1939 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1941 catch (const gdb_exception_error
&exception
)
1943 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1950 else if (offset
> cache
.used_size
)
1952 buffer_free (&cache
);
1956 if (len
> cache
.used_size
- offset
)
1957 len
= cache
.used_size
- offset
;
1959 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1964 static const struct qxfer qxfer_packets
[] =
1966 { "auxv", handle_qxfer_auxv
},
1967 { "btrace", handle_qxfer_btrace
},
1968 { "btrace-conf", handle_qxfer_btrace_conf
},
1969 { "exec-file", handle_qxfer_exec_file
},
1970 { "fdpic", handle_qxfer_fdpic
},
1971 { "features", handle_qxfer_features
},
1972 { "libraries", handle_qxfer_libraries
},
1973 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1974 { "osdata", handle_qxfer_osdata
},
1975 { "siginfo", handle_qxfer_siginfo
},
1976 { "statictrace", handle_qxfer_statictrace
},
1977 { "threads", handle_qxfer_threads
},
1978 { "traceframe-info", handle_qxfer_traceframe_info
},
1982 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1990 if (!startswith (own_buf
, "qXfer:"))
1993 /* Grab the object, r/w and annex. */
1994 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1996 write_enn (own_buf
);
2001 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2004 const struct qxfer
*q
= &qxfer_packets
[i
];
2006 if (strcmp (object
, q
->object
) == 0)
2008 if (strcmp (rw
, "read") == 0)
2010 unsigned char *data
;
2015 /* Grab the offset and length. */
2016 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2018 write_enn (own_buf
);
2022 /* Read one extra byte, as an indicator of whether there is
2024 if (len
> PBUFSIZ
- 2)
2026 data
= (unsigned char *) malloc (len
+ 1);
2029 write_enn (own_buf
);
2032 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2040 /* Preserve error message. */
2043 write_enn (own_buf
);
2045 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2047 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2052 else if (strcmp (rw
, "write") == 0)
2057 unsigned char *data
;
2059 strcpy (own_buf
, "E00");
2060 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2063 write_enn (own_buf
);
2066 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2067 &ofs
, &len
, data
) < 0)
2070 write_enn (own_buf
);
2074 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2082 /* Preserve error message. */
2085 write_enn (own_buf
);
2087 sprintf (own_buf
, "%x", n
);
2100 /* Compute 32 bit CRC from inferior memory.
2102 On success, return 32 bit CRC.
2103 On failure, return (unsigned long long) -1. */
2105 static unsigned long long
2106 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2110 unsigned char byte
= 0;
2112 /* Return failure if memory read fails. */
2113 if (read_inferior_memory (base
, &byte
, 1) != 0)
2114 return (unsigned long long) -1;
2116 crc
= xcrc32 (&byte
, 1, crc
);
2119 return (unsigned long long) crc
;
2122 /* Add supported btrace packets to BUF. */
2125 supported_btrace_packets (char *buf
)
2127 strcat (buf
, ";Qbtrace:bts+");
2128 strcat (buf
, ";Qbtrace-conf:bts:size+");
2129 strcat (buf
, ";Qbtrace:pt+");
2130 strcat (buf
, ";Qbtrace-conf:pt:size+");
2131 strcat (buf
, ";Qbtrace:off+");
2132 strcat (buf
, ";qXfer:btrace:read+");
2133 strcat (buf
, ";qXfer:btrace-conf:read+");
2136 /* Handle all of the extended 'q' packets. */
2139 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2141 client_state
&cs
= get_client_state ();
2142 static std::list
<thread_info
*>::const_iterator thread_iter
;
2144 /* Reply the current thread id. */
2145 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2148 require_running_or_return (own_buf
);
2150 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2151 ptid
= cs
.general_thread
;
2154 thread_iter
= all_threads
.begin ();
2155 ptid
= (*thread_iter
)->id
;
2158 sprintf (own_buf
, "QC");
2160 write_ptid (own_buf
, ptid
);
2164 if (strcmp ("qSymbol::", own_buf
) == 0)
2166 struct thread_info
*save_thread
= current_thread
;
2168 /* For qSymbol, GDB only changes the current thread if the
2169 previous current thread was of a different process. So if
2170 the previous thread is gone, we need to pick another one of
2171 the same process. This can happen e.g., if we followed an
2172 exec in a non-leader thread. */
2173 if (current_thread
== NULL
)
2176 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2178 /* Just in case, if we didn't find a thread, then bail out
2179 instead of crashing. */
2180 if (current_thread
== NULL
)
2182 write_enn (own_buf
);
2183 current_thread
= save_thread
;
2188 /* GDB is suggesting new symbols have been loaded. This may
2189 mean a new shared library has been detected as loaded, so
2190 take the opportunity to check if breakpoints we think are
2191 inserted, still are. Note that it isn't guaranteed that
2192 we'll see this when a shared library is loaded, and nor will
2193 we see this for unloads (although breakpoints in unloaded
2194 libraries shouldn't trigger), as GDB may not find symbols for
2195 the library at all. We also re-validate breakpoints when we
2196 see a second GDB breakpoint for the same address, and or when
2197 we access breakpoint shadows. */
2198 validate_breakpoints ();
2200 if (target_supports_tracepoints ())
2201 tracepoint_look_up_symbols ();
2203 if (current_thread
!= NULL
)
2204 the_target
->look_up_symbols ();
2206 current_thread
= save_thread
;
2208 strcpy (own_buf
, "OK");
2212 if (!disable_packet_qfThreadInfo
)
2214 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2216 require_running_or_return (own_buf
);
2217 thread_iter
= all_threads
.begin ();
2220 ptid_t ptid
= (*thread_iter
)->id
;
2221 write_ptid (own_buf
, ptid
);
2226 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2228 require_running_or_return (own_buf
);
2229 if (thread_iter
!= all_threads
.end ())
2232 ptid_t ptid
= (*thread_iter
)->id
;
2233 write_ptid (own_buf
, ptid
);
2239 sprintf (own_buf
, "l");
2245 if (the_target
->supports_read_offsets ()
2246 && strcmp ("qOffsets", own_buf
) == 0)
2248 CORE_ADDR text
, data
;
2250 require_running_or_return (own_buf
);
2251 if (the_target
->read_offsets (&text
, &data
))
2252 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2253 (long)text
, (long)data
, (long)data
);
2255 write_enn (own_buf
);
2260 /* Protocol features query. */
2261 if (startswith (own_buf
, "qSupported")
2262 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2264 char *p
= &own_buf
[10];
2265 int gdb_supports_qRelocInsn
= 0;
2267 /* Process each feature being provided by GDB. The first
2268 feature will follow a ':', and latter features will follow
2272 char **qsupported
= NULL
;
2277 /* Two passes, to avoid nested strtok calls in
2278 target_process_qsupported. */
2280 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2282 p
= strtok_r (NULL
, ";", &saveptr
))
2285 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2286 qsupported
[count
- 1] = xstrdup (p
);
2289 for (i
= 0; i
< count
; i
++)
2292 if (strcmp (p
, "multiprocess+") == 0)
2294 /* GDB supports and wants multi-process support if
2296 if (target_supports_multi_process ())
2297 cs
.multi_process
= 1;
2299 else if (strcmp (p
, "qRelocInsn+") == 0)
2301 /* GDB supports relocate instruction requests. */
2302 gdb_supports_qRelocInsn
= 1;
2304 else if (strcmp (p
, "swbreak+") == 0)
2306 /* GDB wants us to report whether a trap is caused
2307 by a software breakpoint and for us to handle PC
2308 adjustment if necessary on this target. */
2309 if (target_supports_stopped_by_sw_breakpoint ())
2310 cs
.swbreak_feature
= 1;
2312 else if (strcmp (p
, "hwbreak+") == 0)
2314 /* GDB wants us to report whether a trap is caused
2315 by a hardware breakpoint. */
2316 if (target_supports_stopped_by_hw_breakpoint ())
2317 cs
.hwbreak_feature
= 1;
2319 else if (strcmp (p
, "fork-events+") == 0)
2321 /* GDB supports and wants fork events if possible. */
2322 if (target_supports_fork_events ())
2323 cs
.report_fork_events
= 1;
2325 else if (strcmp (p
, "vfork-events+") == 0)
2327 /* GDB supports and wants vfork events if possible. */
2328 if (target_supports_vfork_events ())
2329 cs
.report_vfork_events
= 1;
2331 else if (strcmp (p
, "exec-events+") == 0)
2333 /* GDB supports and wants exec events if possible. */
2334 if (target_supports_exec_events ())
2335 cs
.report_exec_events
= 1;
2337 else if (strcmp (p
, "vContSupported+") == 0)
2338 cs
.vCont_supported
= 1;
2339 else if (strcmp (p
, "QThreadEvents+") == 0)
2341 else if (strcmp (p
, "no-resumed+") == 0)
2343 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2345 report_no_resumed
= true;
2349 /* Move the unknown features all together. */
2350 qsupported
[i
] = NULL
;
2351 qsupported
[unknown
] = p
;
2356 /* Give the target backend a chance to process the unknown
2358 target_process_qsupported (qsupported
, unknown
);
2360 for (i
= 0; i
< count
; i
++)
2361 free (qsupported
[i
]);
2366 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2367 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2368 "QEnvironmentReset+;QEnvironmentUnset+;"
2372 if (target_supports_catch_syscall ())
2373 strcat (own_buf
, ";QCatchSyscalls+");
2375 if (the_target
->supports_qxfer_libraries_svr4 ())
2376 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2377 ";augmented-libraries-svr4-read+");
2380 /* We do not have any hook to indicate whether the non-SVR4 target
2381 backend supports qXfer:libraries:read, so always report it. */
2382 strcat (own_buf
, ";qXfer:libraries:read+");
2385 if (the_target
->supports_read_auxv ())
2386 strcat (own_buf
, ";qXfer:auxv:read+");
2388 if (the_target
->supports_qxfer_siginfo ())
2389 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2391 if (the_target
->supports_read_loadmap ())
2392 strcat (own_buf
, ";qXfer:fdpic:read+");
2394 /* We always report qXfer:features:read, as targets may
2395 install XML files on a subsequent call to arch_setup.
2396 If we reported to GDB on startup that we don't support
2397 qXfer:feature:read at all, we will never be re-queried. */
2398 strcat (own_buf
, ";qXfer:features:read+");
2400 if (cs
.transport_is_reliable
)
2401 strcat (own_buf
, ";QStartNoAckMode+");
2403 if (the_target
->supports_qxfer_osdata ())
2404 strcat (own_buf
, ";qXfer:osdata:read+");
2406 if (target_supports_multi_process ())
2407 strcat (own_buf
, ";multiprocess+");
2409 if (target_supports_fork_events ())
2410 strcat (own_buf
, ";fork-events+");
2412 if (target_supports_vfork_events ())
2413 strcat (own_buf
, ";vfork-events+");
2415 if (target_supports_exec_events ())
2416 strcat (own_buf
, ";exec-events+");
2418 if (target_supports_non_stop ())
2419 strcat (own_buf
, ";QNonStop+");
2421 if (target_supports_disable_randomization ())
2422 strcat (own_buf
, ";QDisableRandomization+");
2424 strcat (own_buf
, ";qXfer:threads:read+");
2426 if (target_supports_tracepoints ())
2428 strcat (own_buf
, ";ConditionalTracepoints+");
2429 strcat (own_buf
, ";TraceStateVariables+");
2430 strcat (own_buf
, ";TracepointSource+");
2431 strcat (own_buf
, ";DisconnectedTracing+");
2432 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2433 strcat (own_buf
, ";FastTracepoints+");
2434 strcat (own_buf
, ";StaticTracepoints+");
2435 strcat (own_buf
, ";InstallInTrace+");
2436 strcat (own_buf
, ";qXfer:statictrace:read+");
2437 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2438 strcat (own_buf
, ";EnableDisableTracepoints+");
2439 strcat (own_buf
, ";QTBuffer:size+");
2440 strcat (own_buf
, ";tracenz+");
2443 if (target_supports_hardware_single_step ()
2444 || target_supports_software_single_step () )
2446 strcat (own_buf
, ";ConditionalBreakpoints+");
2448 strcat (own_buf
, ";BreakpointCommands+");
2450 if (target_supports_agent ())
2451 strcat (own_buf
, ";QAgent+");
2453 supported_btrace_packets (own_buf
);
2455 if (target_supports_stopped_by_sw_breakpoint ())
2456 strcat (own_buf
, ";swbreak+");
2458 if (target_supports_stopped_by_hw_breakpoint ())
2459 strcat (own_buf
, ";hwbreak+");
2461 if (the_target
->supports_pid_to_exec_file ())
2462 strcat (own_buf
, ";qXfer:exec-file:read+");
2464 strcat (own_buf
, ";vContSupported+");
2466 strcat (own_buf
, ";QThreadEvents+");
2468 strcat (own_buf
, ";no-resumed+");
2470 /* Reinitialize components as needed for the new connection. */
2471 hostio_handle_new_gdb_connection ();
2472 target_handle_new_gdb_connection ();
2477 /* Thread-local storage support. */
2478 if (the_target
->supports_get_tls_address ()
2479 && startswith (own_buf
, "qGetTLSAddr:"))
2481 char *p
= own_buf
+ 12;
2482 CORE_ADDR parts
[2], address
= 0;
2484 ptid_t ptid
= null_ptid
;
2486 require_running_or_return (own_buf
);
2488 for (i
= 0; i
< 3; i
++)
2496 p2
= strchr (p
, ',');
2509 ptid
= read_ptid (p
, NULL
);
2511 decode_address (&parts
[i
- 1], p
, len
);
2515 if (p
!= NULL
|| i
< 3)
2519 struct thread_info
*thread
= find_thread_ptid (ptid
);
2524 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2530 strcpy (own_buf
, paddress(address
));
2535 write_enn (own_buf
);
2539 /* Otherwise, pretend we do not understand this packet. */
2542 /* Windows OS Thread Information Block address support. */
2543 if (the_target
->supports_get_tib_address ()
2544 && startswith (own_buf
, "qGetTIBAddr:"))
2549 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2551 n
= the_target
->get_tib_address (ptid
, &tlb
);
2554 strcpy (own_buf
, paddress(tlb
));
2559 write_enn (own_buf
);
2565 /* Handle "monitor" commands. */
2566 if (startswith (own_buf
, "qRcmd,"))
2568 char *mon
= (char *) malloc (PBUFSIZ
);
2569 int len
= strlen (own_buf
+ 6);
2573 write_enn (own_buf
);
2578 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2580 write_enn (own_buf
);
2584 mon
[len
/ 2] = '\0';
2588 if (the_target
->handle_monitor_command (mon
) == 0)
2589 /* Default processing. */
2590 handle_monitor_command (mon
, own_buf
);
2596 if (startswith (own_buf
, "qSearch:memory:"))
2598 require_running_or_return (own_buf
);
2599 handle_search_memory (own_buf
, packet_len
);
2603 if (strcmp (own_buf
, "qAttached") == 0
2604 || startswith (own_buf
, "qAttached:"))
2606 struct process_info
*process
;
2608 if (own_buf
[sizeof ("qAttached") - 1])
2610 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2611 process
= find_process_pid (pid
);
2615 require_running_or_return (own_buf
);
2616 process
= current_process ();
2619 if (process
== NULL
)
2621 write_enn (own_buf
);
2625 strcpy (own_buf
, process
->attached
? "1" : "0");
2629 if (startswith (own_buf
, "qCRC:"))
2631 /* CRC check (compare-section). */
2635 unsigned long long crc
;
2637 require_running_or_return (own_buf
);
2638 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2639 if (*comma
++ != ',')
2641 write_enn (own_buf
);
2644 len
= strtoul (comma
, NULL
, 16);
2645 crc
= crc32 (base
, len
, 0xffffffff);
2646 /* Check for memory failure. */
2647 if (crc
== (unsigned long long) -1)
2649 write_enn (own_buf
);
2652 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2656 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2659 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2662 /* Otherwise we didn't know what packet it was. Say we didn't
2667 static void gdb_wants_all_threads_stopped (void);
2668 static void resume (struct thread_resume
*actions
, size_t n
);
2670 /* The callback that is passed to visit_actioned_threads. */
2671 typedef int (visit_actioned_threads_callback_ftype
)
2672 (const struct thread_resume
*, struct thread_info
*);
2674 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2675 true if CALLBACK returns true. Returns false if no matching thread
2676 is found or CALLBACK results false.
2677 Note: This function is itself a callback for find_thread. */
2680 visit_actioned_threads (thread_info
*thread
,
2681 const struct thread_resume
*actions
,
2683 visit_actioned_threads_callback_ftype
*callback
)
2685 for (size_t i
= 0; i
< num_actions
; i
++)
2687 const struct thread_resume
*action
= &actions
[i
];
2689 if (action
->thread
== minus_one_ptid
2690 || action
->thread
== thread
->id
2691 || ((action
->thread
.pid ()
2692 == thread
->id
.pid ())
2693 && action
->thread
.lwp () == -1))
2695 if ((*callback
) (action
, thread
))
2703 /* Callback for visit_actioned_threads. If the thread has a pending
2704 status to report, report it now. */
2707 handle_pending_status (const struct thread_resume
*resumption
,
2708 struct thread_info
*thread
)
2710 client_state
&cs
= get_client_state ();
2711 if (thread
->status_pending_p
)
2713 thread
->status_pending_p
= 0;
2715 cs
.last_status
= thread
->last_status
;
2716 cs
.last_ptid
= thread
->id
;
2717 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2723 /* Parse vCont packets. */
2725 handle_v_cont (char *own_buf
)
2729 struct thread_resume
*resume_info
;
2730 struct thread_resume default_action
{ null_ptid
};
2732 /* Count the number of semicolons in the packet. There should be one
2733 for every action. */
2739 p
= strchr (p
, ';');
2742 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2743 if (resume_info
== NULL
)
2751 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2753 if (p
[0] == 's' || p
[0] == 'S')
2754 resume_info
[i
].kind
= resume_step
;
2755 else if (p
[0] == 'r')
2756 resume_info
[i
].kind
= resume_step
;
2757 else if (p
[0] == 'c' || p
[0] == 'C')
2758 resume_info
[i
].kind
= resume_continue
;
2759 else if (p
[0] == 't')
2760 resume_info
[i
].kind
= resume_stop
;
2764 if (p
[0] == 'S' || p
[0] == 'C')
2767 int sig
= strtol (p
+ 1, &q
, 16);
2772 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2774 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2776 else if (p
[0] == 'r')
2780 p
= unpack_varlen_hex (p
+ 1, &addr
);
2781 resume_info
[i
].step_range_start
= addr
;
2786 p
= unpack_varlen_hex (p
+ 1, &addr
);
2787 resume_info
[i
].step_range_end
= addr
;
2796 resume_info
[i
].thread
= minus_one_ptid
;
2797 default_action
= resume_info
[i
];
2799 /* Note: we don't increment i here, we'll overwrite this entry
2800 the next time through. */
2802 else if (p
[0] == ':')
2805 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2810 if (p
[0] != ';' && p
[0] != 0)
2813 resume_info
[i
].thread
= ptid
;
2820 resume_info
[i
] = default_action
;
2822 resume (resume_info
, n
);
2827 write_enn (own_buf
);
2832 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2835 resume (struct thread_resume
*actions
, size_t num_actions
)
2837 client_state
&cs
= get_client_state ();
2840 /* Check if among the threads that GDB wants actioned, there's
2841 one with a pending status to report. If so, skip actually
2842 resuming/stopping and report the pending event
2845 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2847 return visit_actioned_threads (thread
, actions
, num_actions
,
2848 handle_pending_status
);
2851 if (thread_with_status
!= NULL
)
2857 the_target
->resume (actions
, num_actions
);
2860 write_ok (cs
.own_buf
);
2863 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2865 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2866 && !report_no_resumed
)
2868 /* The client does not support this stop reply. At least
2870 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2871 disable_async_io ();
2875 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2876 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2877 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2878 current_thread
->last_status
= cs
.last_status
;
2880 /* From the client's perspective, all-stop mode always stops all
2881 threads implicitly (and the target backend has already done
2882 so by now). Tag all threads as "want-stopped", so we don't
2883 resume them implicitly without the client telling us to. */
2884 gdb_wants_all_threads_stopped ();
2885 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2886 disable_async_io ();
2888 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2889 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2890 target_mourn_inferior (cs
.last_ptid
);
2894 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2896 handle_v_attach (char *own_buf
)
2898 client_state
&cs
= get_client_state ();
2901 pid
= strtol (own_buf
+ 8, NULL
, 16);
2902 if (pid
!= 0 && attach_inferior (pid
) == 0)
2904 /* Don't report shared library events after attaching, even if
2905 some libraries are preloaded. GDB will always poll the
2906 library list. Avoids the "stopped by shared library event"
2907 notice on the GDB side. */
2912 /* In non-stop, we don't send a resume reply. Stop events
2913 will follow up using the normal notification
2918 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2924 write_enn (own_buf
);
2929 /* Run a new program. Return 1 if successful, 0 if failure. */
2931 handle_v_run (char *own_buf
)
2933 client_state
&cs
= get_client_state ();
2935 std::vector
<char *> new_argv
;
2936 char *new_program_name
= NULL
;
2940 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2946 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2948 next_p
= strchr (p
, ';');
2950 next_p
= p
+ strlen (p
);
2952 if (i
== 0 && p
== next_p
)
2954 /* No program specified. */
2955 new_program_name
= NULL
;
2957 else if (p
== next_p
)
2959 /* Empty argument. */
2960 new_argv
.push_back (xstrdup (""));
2964 size_t len
= (next_p
- p
) / 2;
2965 /* ARG is the unquoted argument received via the RSP. */
2966 char *arg
= (char *) xmalloc (len
+ 1);
2967 /* FULL_ARGS will contain the quoted version of ARG. */
2968 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2969 /* These are pointers used to navigate the strings above. */
2970 char *tmp_arg
= arg
;
2971 char *tmp_full_arg
= full_arg
;
2974 hex2bin (p
, (gdb_byte
*) arg
, len
);
2977 while (*tmp_arg
!= '\0')
2983 *tmp_full_arg
= '\'';
2989 /* Quote single quote. */
2990 *tmp_full_arg
= '\\';
2998 *tmp_full_arg
= *tmp_arg
;
3004 *tmp_full_arg
++ = '\'';
3006 /* Finish FULL_ARG and push it into the vector containing
3008 *tmp_full_arg
= '\0';
3010 new_program_name
= full_arg
;
3012 new_argv
.push_back (full_arg
);
3019 if (new_program_name
== NULL
)
3021 /* GDB didn't specify a program to run. Use the program from the
3022 last run with the new argument list. */
3023 if (program_path
.get () == NULL
)
3025 write_enn (own_buf
);
3026 free_vector_argv (new_argv
);
3031 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3033 /* Free the old argv and install the new one. */
3034 free_vector_argv (program_args
);
3035 program_args
= new_argv
;
3037 target_create_inferior (program_path
.get (), program_args
);
3039 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3041 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3043 /* In non-stop, sending a resume reply doesn't set the general
3044 thread, but GDB assumes a vRun sets it (this is so GDB can
3045 query which is the main thread of the new inferior. */
3047 cs
.general_thread
= cs
.last_ptid
;
3053 write_enn (own_buf
);
3058 /* Kill process. Return 1 if successful, 0 if failure. */
3060 handle_v_kill (char *own_buf
)
3062 client_state
&cs
= get_client_state ();
3064 char *p
= &own_buf
[6];
3065 if (cs
.multi_process
)
3066 pid
= strtol (p
, NULL
, 16);
3070 process_info
*proc
= find_process_pid (pid
);
3072 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3074 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3075 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3076 cs
.last_ptid
= ptid_t (pid
);
3077 discard_queued_stop_replies (cs
.last_ptid
);
3083 write_enn (own_buf
);
3088 /* Handle all of the extended 'v' packets. */
3090 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3092 client_state
&cs
= get_client_state ();
3093 if (!disable_packet_vCont
)
3095 if (strcmp (own_buf
, "vCtrlC") == 0)
3097 the_target
->request_interrupt ();
3102 if (startswith (own_buf
, "vCont;"))
3104 handle_v_cont (own_buf
);
3108 if (startswith (own_buf
, "vCont?"))
3110 strcpy (own_buf
, "vCont;c;C;t");
3112 if (target_supports_hardware_single_step ()
3113 || target_supports_software_single_step ()
3114 || !cs
.vCont_supported
)
3116 /* If target supports single step either by hardware or by
3117 software, add actions s and S to the list of supported
3118 actions. On the other hand, if GDB doesn't request the
3119 supported vCont actions in qSupported packet, add s and
3120 S to the list too. */
3121 own_buf
= own_buf
+ strlen (own_buf
);
3122 strcpy (own_buf
, ";s;S");
3125 if (target_supports_range_stepping ())
3127 own_buf
= own_buf
+ strlen (own_buf
);
3128 strcpy (own_buf
, ";r");
3134 if (startswith (own_buf
, "vFile:")
3135 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3138 if (startswith (own_buf
, "vAttach;"))
3140 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3142 fprintf (stderr
, "Already debugging a process\n");
3143 write_enn (own_buf
);
3146 handle_v_attach (own_buf
);
3150 if (startswith (own_buf
, "vRun;"))
3152 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3154 fprintf (stderr
, "Already debugging a process\n");
3155 write_enn (own_buf
);
3158 handle_v_run (own_buf
);
3162 if (startswith (own_buf
, "vKill;"))
3164 if (!target_running ())
3166 fprintf (stderr
, "No process to kill\n");
3167 write_enn (own_buf
);
3170 handle_v_kill (own_buf
);
3174 if (handle_notif_ack (own_buf
, packet_len
))
3177 /* Otherwise we didn't know what packet it was. Say we didn't
3183 /* Resume thread and wait for another event. In non-stop mode,
3184 don't really wait here, but return immediatelly to the event
3187 myresume (char *own_buf
, int step
, int sig
)
3189 client_state
&cs
= get_client_state ();
3190 struct thread_resume resume_info
[2];
3192 int valid_cont_thread
;
3194 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3195 && cs
.cont_thread
!= minus_one_ptid
);
3197 if (step
|| sig
|| valid_cont_thread
)
3199 resume_info
[0].thread
= current_ptid
;
3201 resume_info
[0].kind
= resume_step
;
3203 resume_info
[0].kind
= resume_continue
;
3204 resume_info
[0].sig
= sig
;
3208 if (!valid_cont_thread
)
3210 resume_info
[n
].thread
= minus_one_ptid
;
3211 resume_info
[n
].kind
= resume_continue
;
3212 resume_info
[n
].sig
= 0;
3216 resume (resume_info
, n
);
3219 /* Callback for for_each_thread. Make a new stop reply for each
3223 queue_stop_reply_callback (thread_info
*thread
)
3225 /* For now, assume targets that don't have this callback also don't
3226 manage the thread's last_status field. */
3227 if (!the_target
->supports_thread_stopped ())
3229 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3231 new_notif
->ptid
= thread
->id
;
3232 new_notif
->status
= thread
->last_status
;
3233 /* Pass the last stop reply back to GDB, but don't notify
3235 notif_event_enque (¬if_stop
, new_notif
);
3239 if (target_thread_stopped (thread
))
3243 std::string status_string
3244 = target_waitstatus_to_string (&thread
->last_status
);
3246 debug_printf ("Reporting thread %s as already stopped with %s\n",
3247 target_pid_to_str (thread
->id
),
3248 status_string
.c_str ());
3251 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3253 /* Pass the last stop reply back to GDB, but don't notify
3255 queue_stop_reply (thread
->id
, &thread
->last_status
);
3260 /* Set this inferior threads's state as "want-stopped". We won't
3261 resume this thread until the client gives us another action for
3265 gdb_wants_thread_stopped (thread_info
*thread
)
3267 thread
->last_resume_kind
= resume_stop
;
3269 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3271 /* Most threads are stopped implicitly (all-stop); tag that with
3273 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3274 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3278 /* Set all threads' states as "want-stopped". */
3281 gdb_wants_all_threads_stopped (void)
3283 for_each_thread (gdb_wants_thread_stopped
);
3286 /* Callback for for_each_thread. If the thread is stopped with an
3287 interesting event, mark it as having a pending event. */
3290 set_pending_status_callback (thread_info
*thread
)
3292 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3293 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3294 /* A breakpoint, watchpoint or finished step from a previous
3295 GDB run isn't considered interesting for a new GDB run.
3296 If we left those pending, the new GDB could consider them
3297 random SIGTRAPs. This leaves out real async traps. We'd
3298 have to peek into the (target-specific) siginfo to
3299 distinguish those. */
3300 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3301 thread
->status_pending_p
= 1;
3304 /* Status handler for the '?' packet. */
3307 handle_status (char *own_buf
)
3309 client_state
&cs
= get_client_state ();
3311 /* GDB is connected, don't forward events to the target anymore. */
3312 for_each_process ([] (process_info
*process
) {
3313 process
->gdb_detached
= 0;
3316 /* In non-stop mode, we must send a stop reply for each stopped
3317 thread. In all-stop mode, just send one for the first stopped
3322 for_each_thread (queue_stop_reply_callback
);
3324 /* The first is sent immediatly. OK is sent if there is no
3325 stopped thread, which is the same handling of the vStopped
3326 packet (by design). */
3327 notif_write_event (¬if_stop
, cs
.own_buf
);
3331 thread_info
*thread
= NULL
;
3333 target_pause_all (false);
3334 target_stabilize_threads ();
3335 gdb_wants_all_threads_stopped ();
3337 /* We can only report one status, but we might be coming out of
3338 non-stop -- if more than one thread is stopped with
3339 interesting events, leave events for the threads we're not
3340 reporting now pending. They'll be reported the next time the
3341 threads are resumed. Start by marking all interesting events
3343 for_each_thread (set_pending_status_callback
);
3345 /* Prefer the last thread that reported an event to GDB (even if
3346 that was a GDB_SIGNAL_TRAP). */
3347 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3348 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3349 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3350 thread
= find_thread_ptid (cs
.last_ptid
);
3352 /* If the last event thread is not found for some reason, look
3353 for some other thread that might have an event to report. */
3355 thread
= find_thread ([] (thread_info
*thr_arg
)
3357 return thr_arg
->status_pending_p
;
3360 /* If we're still out of luck, simply pick the first thread in
3363 thread
= get_first_thread ();
3367 struct thread_info
*tp
= (struct thread_info
*) thread
;
3369 /* We're reporting this event, so it's no longer
3371 tp
->status_pending_p
= 0;
3373 /* GDB assumes the current thread is the thread we're
3374 reporting the status for. */
3375 cs
.general_thread
= thread
->id
;
3376 set_desired_thread ();
3378 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3379 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3382 strcpy (own_buf
, "W00");
3387 gdbserver_version (void)
3389 printf ("GNU gdbserver %s%s\n"
3390 "Copyright (C) 2020 Free Software Foundation, Inc.\n"
3391 "gdbserver is free software, covered by the "
3392 "GNU General Public License.\n"
3393 "This gdbserver was configured as \"%s\"\n",
3394 PKGVERSION
, version
, host_name
);
3398 gdbserver_usage (FILE *stream
)
3400 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3401 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3402 "\tgdbserver [OPTIONS] --multi COMM\n"
3404 "COMM may either be a tty device (for serial debugging),\n"
3405 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3406 "stdin/stdout of gdbserver.\n"
3407 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3408 "PID is the process ID to attach to, when --attach is specified.\n"
3410 "Operating modes:\n"
3412 " --attach Attach to running process PID.\n"
3413 " --multi Start server without a specific program, and\n"
3414 " only quit when explicitly commanded.\n"
3415 " --once Exit after the first connection has closed.\n"
3416 " --help Print this message and then exit.\n"
3417 " --version Display version information and exit.\n"
3421 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3422 " --disable-randomization\n"
3423 " Run PROG with address space randomization disabled.\n"
3424 " --no-disable-randomization\n"
3425 " Don't disable address space randomization when\n"
3427 " --startup-with-shell\n"
3428 " Start PROG using a shell. I.e., execs a shell that\n"
3429 " then execs PROG. (default)\n"
3430 " --no-startup-with-shell\n"
3431 " Exec PROG directly instead of using a shell.\n"
3432 " Disables argument globbing and variable substitution\n"
3433 " on UNIX-like systems.\n"
3437 " --debug Enable general debugging output.\n"
3438 " --debug-format=OPT1[,OPT2,...]\n"
3439 " Specify extra content in debugging output.\n"
3444 " --remote-debug Enable remote protocol debugging output.\n"
3445 " --disable-packet=OPT1[,OPT2,...]\n"
3446 " Disable support for RSP packets or features.\n"
3448 " vCont, Tthread, qC, qfThreadInfo and \n"
3449 " threads (disable all threading packets).\n"
3451 "For more information, consult the GDB manual (available as on-line \n"
3452 "info or a printed manual).\n");
3453 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3454 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3458 gdbserver_show_disableable (FILE *stream
)
3460 fprintf (stream
, "Disableable packets:\n"
3461 " vCont \tAll vCont packets\n"
3462 " qC \tQuerying the current thread\n"
3463 " qfThreadInfo\tThread listing\n"
3464 " Tthread \tPassing the thread specifier in the "
3465 "T stop reply packet\n"
3466 " threads \tAll of the above\n");
3469 /* Start up the event loop. This is the entry point to the event
3475 /* Loop until there is nothing to do. This is the entry point to
3476 the event loop engine. If nothing is ready at this time, wait
3477 for something to happen (via wait_for_event), then process it.
3478 Return when there are no longer event sources to wait for. */
3480 keep_processing_events
= true;
3481 while (keep_processing_events
)
3483 /* Any events already waiting in the queue? */
3484 int res
= gdb_do_one_event ();
3486 /* Was there an error? */
3491 /* We are done with the event loop. There are no more event sources
3492 to listen to. So we exit gdbserver. */
3496 kill_inferior_callback (process_info
*process
)
3498 kill_inferior (process
);
3499 discard_queued_stop_replies (ptid_t (process
->pid
));
3502 /* Call this when exiting gdbserver with possible inferiors that need
3503 to be killed or detached from. */
3506 detach_or_kill_for_exit (void)
3508 /* First print a list of the inferiors we will be killing/detaching.
3509 This is to assist the user, for example, in case the inferior unexpectedly
3510 dies after we exit: did we screw up or did the inferior exit on its own?
3511 Having this info will save some head-scratching. */
3513 if (have_started_inferiors_p ())
3515 fprintf (stderr
, "Killing process(es):");
3517 for_each_process ([] (process_info
*process
) {
3518 if (!process
->attached
)
3519 fprintf (stderr
, " %d", process
->pid
);
3522 fprintf (stderr
, "\n");
3524 if (have_attached_inferiors_p ())
3526 fprintf (stderr
, "Detaching process(es):");
3528 for_each_process ([] (process_info
*process
) {
3529 if (process
->attached
)
3530 fprintf (stderr
, " %d", process
->pid
);
3533 fprintf (stderr
, "\n");
3536 /* Now we can kill or detach the inferiors. */
3537 for_each_process ([] (process_info
*process
) {
3538 int pid
= process
->pid
;
3540 if (process
->attached
)
3541 detach_inferior (process
);
3543 kill_inferior (process
);
3545 discard_queued_stop_replies (ptid_t (pid
));
3549 /* Value that will be passed to exit(3) when gdbserver exits. */
3550 static int exit_code
;
3552 /* Wrapper for detach_or_kill_for_exit that catches and prints
3556 detach_or_kill_for_exit_cleanup ()
3560 detach_or_kill_for_exit ();
3562 catch (const gdb_exception
&exception
)
3565 fprintf (stderr
, "Detach or kill failed: %s\n",
3571 /* Main function. This is called by the real "main" function,
3572 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3574 static void ATTRIBUTE_NORETURN
3575 captured_main (int argc
, char *argv
[])
3580 const char *port
= NULL
;
3581 char **next_arg
= &argv
[1];
3582 volatile int multi_mode
= 0;
3583 volatile int attach
= 0;
3585 bool selftest
= false;
3587 const char *selftest_filter
= NULL
;
3590 current_directory
= getcwd (NULL
, 0);
3591 client_state
&cs
= get_client_state ();
3593 if (current_directory
== NULL
)
3595 error (_("Could not find current working directory: %s"),
3596 safe_strerror (errno
));
3599 while (*next_arg
!= NULL
&& **next_arg
== '-')
3601 if (strcmp (*next_arg
, "--version") == 0)
3603 gdbserver_version ();
3606 else if (strcmp (*next_arg
, "--help") == 0)
3608 gdbserver_usage (stdout
);
3611 else if (strcmp (*next_arg
, "--attach") == 0)
3613 else if (strcmp (*next_arg
, "--multi") == 0)
3615 else if (strcmp (*next_arg
, "--wrapper") == 0)
3622 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3624 wrapper_argv
+= *next_arg
;
3625 wrapper_argv
+= ' ';
3629 if (!wrapper_argv
.empty ())
3631 /* Erase the last whitespace. */
3632 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3635 if (next_arg
== tmp
|| *next_arg
== NULL
)
3637 gdbserver_usage (stderr
);
3641 /* Consume the "--". */
3644 else if (strcmp (*next_arg
, "--debug") == 0)
3646 else if (startswith (*next_arg
, "--debug-format="))
3648 std::string error_msg
3649 = parse_debug_format_options ((*next_arg
)
3650 + sizeof ("--debug-format=") - 1, 0);
3652 if (!error_msg
.empty ())
3654 fprintf (stderr
, "%s", error_msg
.c_str ());
3658 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3660 else if (startswith (*next_arg
, "--debug-file="))
3661 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3662 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3664 gdbserver_show_disableable (stdout
);
3667 else if (startswith (*next_arg
, "--disable-packet="))
3669 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3671 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3673 tok
= strtok_r (NULL
, ",", &saveptr
))
3675 if (strcmp ("vCont", tok
) == 0)
3676 disable_packet_vCont
= true;
3677 else if (strcmp ("Tthread", tok
) == 0)
3678 disable_packet_Tthread
= true;
3679 else if (strcmp ("qC", tok
) == 0)
3680 disable_packet_qC
= true;
3681 else if (strcmp ("qfThreadInfo", tok
) == 0)
3682 disable_packet_qfThreadInfo
= true;
3683 else if (strcmp ("T", tok
) == 0)
3684 disable_packet_T
= true;
3685 else if (strcmp ("threads", tok
) == 0)
3687 disable_packet_vCont
= true;
3688 disable_packet_Tthread
= true;
3689 disable_packet_qC
= true;
3690 disable_packet_qfThreadInfo
= true;
3694 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3696 gdbserver_show_disableable (stderr
);
3701 else if (strcmp (*next_arg
, "-") == 0)
3703 /* "-" specifies a stdio connection and is a form of port
3705 port
= STDIO_CONNECTION_NAME
;
3709 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3710 cs
.disable_randomization
= 1;
3711 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3712 cs
.disable_randomization
= 0;
3713 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3714 startup_with_shell
= true;
3715 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3716 startup_with_shell
= false;
3717 else if (strcmp (*next_arg
, "--once") == 0)
3719 else if (strcmp (*next_arg
, "--selftest") == 0)
3721 else if (startswith (*next_arg
, "--selftest="))
3725 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3730 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3743 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3746 gdbserver_usage (stderr
);
3750 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3751 opened by remote_prepare. */
3754 save_original_signals_state (false);
3756 /* We need to know whether the remote connection is stdio before
3757 starting the inferior. Inferiors created in this scenario have
3758 stdin,stdout redirected. So do this here before we call
3761 remote_prepare (port
);
3766 /* --attach used to come after PORT, so allow it there for
3768 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3775 && (*next_arg
== NULL
3776 || (*next_arg
)[0] == '\0'
3777 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3779 || next_arg
[1] != NULL
))
3784 gdbserver_usage (stderr
);
3788 /* Gather information about the environment. */
3789 our_environ
= gdb_environ::from_host_environ ();
3791 initialize_async_io ();
3793 have_job_control ();
3794 if (target_supports_tracepoints ())
3795 initialize_tracepoint ();
3797 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3802 selftests::run_tests (selftest_filter
);
3804 printf (_("Selftests have been disabled for this build.\n"));
3806 throw_quit ("Quit");
3809 if (pid
== 0 && *next_arg
!= NULL
)
3813 n
= argc
- (next_arg
- argv
);
3814 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3815 for (i
= 1; i
< n
; i
++)
3816 program_args
.push_back (xstrdup (next_arg
[i
]));
3818 /* Wait till we are at first instruction in program. */
3819 target_create_inferior (program_path
.get (), program_args
);
3821 /* We are now (hopefully) stopped at the first instruction of
3822 the target process. This assumes that the target process was
3823 successfully created. */
3827 if (attach_inferior (pid
) == -1)
3828 error ("Attaching not supported on this target");
3830 /* Otherwise succeeded. */
3834 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3835 cs
.last_status
.value
.integer
= 0;
3836 cs
.last_ptid
= minus_one_ptid
;
3839 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3841 /* Don't report shared library events on the initial connection,
3842 even if some libraries are preloaded. Avoids the "stopped by
3843 shared library event" notice on gdb side. */
3846 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3847 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3852 if (!was_running
&& !multi_mode
)
3853 error ("No program to debug");
3858 cs
.multi_process
= 0;
3859 cs
.report_fork_events
= 0;
3860 cs
.report_vfork_events
= 0;
3861 cs
.report_exec_events
= 0;
3862 /* Be sure we're out of tfind mode. */
3863 cs
.current_traceframe
= -1;
3864 cs
.cont_thread
= null_ptid
;
3865 cs
.swbreak_feature
= 0;
3866 cs
.hwbreak_feature
= 0;
3867 cs
.vCont_supported
= 0;
3873 /* Wait for events. This will return when all event sources
3874 are removed from the event loop. */
3875 start_event_loop ();
3877 /* If an exit was requested (using the "monitor exit"
3878 command), terminate now. */
3880 throw_quit ("Quit");
3882 /* The only other way to get here is for getpkt to fail:
3884 - If --once was specified, we're done.
3886 - If not in extended-remote mode, and we're no longer
3887 debugging anything, simply exit: GDB has disconnected
3888 after processing the last process exit.
3890 - Otherwise, close the connection and reopen it at the
3892 if (run_once
|| (!extended_protocol
&& !target_running ()))
3893 throw_quit ("Quit");
3896 "Remote side has terminated connection. "
3897 "GDBserver will reopen the connection.\n");
3899 /* Get rid of any pending statuses. An eventual reconnection
3900 (by the same GDB instance or another) will refresh all its
3901 state from scratch. */
3902 discard_queued_stop_replies (minus_one_ptid
);
3903 for_each_thread ([] (thread_info
*thread
)
3905 thread
->status_pending_p
= 0;
3910 if (disconnected_tracing
)
3912 /* Try to enable non-stop/async mode, so we we can
3913 both wait for an async socket accept, and handle
3914 async target events simultaneously. There's also
3915 no point either in having the target always stop
3916 all threads, when we're going to pass signals
3917 down without informing GDB. */
3920 if (the_target
->start_non_stop (true))
3923 /* Detaching implicitly resumes all threads;
3924 simply disconnecting does not. */
3930 "Disconnected tracing disabled; "
3931 "stopping trace run.\n");
3936 catch (const gdb_exception_error
&exception
)
3939 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3941 if (response_needed
)
3943 write_enn (cs
.own_buf
);
3944 putpkt (cs
.own_buf
);
3948 throw_quit ("Quit");
3953 /* Main function. */
3956 main (int argc
, char *argv
[])
3961 captured_main (argc
, argv
);
3963 catch (const gdb_exception
&exception
)
3965 if (exception
.reason
== RETURN_ERROR
)
3968 fprintf (stderr
, "%s\n", exception
.what ());
3969 fprintf (stderr
, "Exiting\n");
3976 gdb_assert_not_reached ("captured_main should never return");
3979 /* Process options coming from Z packets for a breakpoint. PACKET is
3980 the packet buffer. *PACKET is updated to point to the first char
3981 after the last processed option. */
3984 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3986 const char *dataptr
= *packet
;
3989 /* Check if data has the correct format. */
3990 if (*dataptr
!= ';')
3997 if (*dataptr
== ';')
4000 if (*dataptr
== 'X')
4002 /* Conditional expression. */
4004 debug_printf ("Found breakpoint condition.\n");
4005 if (!add_breakpoint_condition (bp
, &dataptr
))
4006 dataptr
= strchrnul (dataptr
, ';');
4008 else if (startswith (dataptr
, "cmds:"))
4010 dataptr
+= strlen ("cmds:");
4012 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4013 persist
= (*dataptr
== '1');
4015 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4016 dataptr
= strchrnul (dataptr
, ';');
4020 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4022 /* Skip tokens until we find one that we recognize. */
4023 dataptr
= strchrnul (dataptr
, ';');
4029 /* Event loop callback that handles a serial event. The first byte in
4030 the serial buffer gets us here. We expect characters to arrive at
4031 a brisk pace, so we read the rest of the packet with a blocking
4035 process_serial_event (void)
4037 client_state
&cs
= get_client_state ();
4043 int new_packet_len
= -1;
4045 disable_async_io ();
4047 response_needed
= false;
4048 packet_len
= getpkt (cs
.own_buf
);
4049 if (packet_len
<= 0)
4052 /* Force an event loop break. */
4055 response_needed
= true;
4057 char ch
= cs
.own_buf
[0];
4061 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4064 handle_general_set (cs
.own_buf
);
4067 handle_detach (cs
.own_buf
);
4070 extended_protocol
= true;
4071 write_ok (cs
.own_buf
);
4074 handle_status (cs
.own_buf
);
4077 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4079 require_running_or_break (cs
.own_buf
);
4081 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4083 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4084 thread_id
= null_ptid
;
4085 else if (thread_id
.is_pid ())
4087 /* The ptid represents a pid. */
4088 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4092 write_enn (cs
.own_buf
);
4096 thread_id
= thread
->id
;
4100 /* The ptid represents a lwp/tid. */
4101 if (find_thread_ptid (thread_id
) == NULL
)
4103 write_enn (cs
.own_buf
);
4108 if (cs
.own_buf
[1] == 'g')
4110 if (thread_id
== null_ptid
)
4112 /* GDB is telling us to choose any thread. Check if
4113 the currently selected thread is still valid. If
4114 it is not, select the first available. */
4115 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4117 thread
= get_first_thread ();
4118 thread_id
= thread
->id
;
4121 cs
.general_thread
= thread_id
;
4122 set_desired_thread ();
4123 gdb_assert (current_thread
!= NULL
);
4125 else if (cs
.own_buf
[1] == 'c')
4126 cs
.cont_thread
= thread_id
;
4128 write_ok (cs
.own_buf
);
4132 /* Silently ignore it so that gdb can extend the protocol
4133 without compatibility headaches. */
4134 cs
.own_buf
[0] = '\0';
4138 require_running_or_break (cs
.own_buf
);
4139 if (cs
.current_traceframe
>= 0)
4141 struct regcache
*regcache
4142 = new_register_cache (current_target_desc ());
4144 if (fetch_traceframe_registers (cs
.current_traceframe
,
4146 registers_to_string (regcache
, cs
.own_buf
);
4148 write_enn (cs
.own_buf
);
4149 free_register_cache (regcache
);
4153 struct regcache
*regcache
;
4155 if (!set_desired_thread ())
4156 write_enn (cs
.own_buf
);
4159 regcache
= get_thread_regcache (current_thread
, 1);
4160 registers_to_string (regcache
, cs
.own_buf
);
4165 require_running_or_break (cs
.own_buf
);
4166 if (cs
.current_traceframe
>= 0)
4167 write_enn (cs
.own_buf
);
4170 struct regcache
*regcache
;
4172 if (!set_desired_thread ())
4173 write_enn (cs
.own_buf
);
4176 regcache
= get_thread_regcache (current_thread
, 1);
4177 registers_from_string (regcache
, &cs
.own_buf
[1]);
4178 write_ok (cs
.own_buf
);
4184 require_running_or_break (cs
.own_buf
);
4185 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4186 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4188 write_enn (cs
.own_buf
);
4190 bin2hex (mem_buf
, cs
.own_buf
, res
);
4194 require_running_or_break (cs
.own_buf
);
4195 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4196 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4197 write_ok (cs
.own_buf
);
4199 write_enn (cs
.own_buf
);
4202 require_running_or_break (cs
.own_buf
);
4203 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4204 &mem_addr
, &len
, &mem_buf
) < 0
4205 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4206 write_enn (cs
.own_buf
);
4208 write_ok (cs
.own_buf
);
4211 require_running_or_break (cs
.own_buf
);
4212 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4213 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4214 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4217 myresume (cs
.own_buf
, 0, signal
);
4220 require_running_or_break (cs
.own_buf
);
4221 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4222 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4223 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4226 myresume (cs
.own_buf
, 1, signal
);
4229 require_running_or_break (cs
.own_buf
);
4231 myresume (cs
.own_buf
, 0, signal
);
4234 require_running_or_break (cs
.own_buf
);
4236 myresume (cs
.own_buf
, 1, signal
);
4238 case 'Z': /* insert_ ... */
4240 case 'z': /* remove_ ... */
4245 char type
= cs
.own_buf
[1];
4247 const int insert
= ch
== 'Z';
4248 const char *p
= &cs
.own_buf
[3];
4250 p
= unpack_varlen_hex (p
, &addr
);
4251 kind
= strtol (p
+ 1, &dataptr
, 16);
4255 struct gdb_breakpoint
*bp
;
4257 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4262 /* GDB may have sent us a list of *point parameters to
4263 be evaluated on the target's side. Read such list
4264 here. If we already have a list of parameters, GDB
4265 is telling us to drop that list and use this one
4267 clear_breakpoint_conditions_and_commands (bp
);
4268 const char *options
= dataptr
;
4269 process_point_options (bp
, &options
);
4273 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4276 write_ok (cs
.own_buf
);
4279 cs
.own_buf
[0] = '\0';
4281 write_enn (cs
.own_buf
);
4285 response_needed
= false;
4286 if (!target_running ())
4287 /* The packet we received doesn't make sense - but we can't
4288 reply to it, either. */
4291 fprintf (stderr
, "Killing all inferiors\n");
4293 for_each_process (kill_inferior_callback
);
4295 /* When using the extended protocol, we wait with no program
4296 running. The traditional protocol will exit instead. */
4297 if (extended_protocol
)
4299 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4300 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4308 require_running_or_break (cs
.own_buf
);
4310 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4311 if (find_thread_ptid (thread_id
) == NULL
)
4313 write_enn (cs
.own_buf
);
4317 if (mythread_alive (thread_id
))
4318 write_ok (cs
.own_buf
);
4320 write_enn (cs
.own_buf
);
4324 response_needed
= false;
4326 /* Restarting the inferior is only supported in the extended
4328 if (extended_protocol
)
4330 if (target_running ())
4331 for_each_process (kill_inferior_callback
);
4333 fprintf (stderr
, "GDBserver restarting\n");
4335 /* Wait till we are at 1st instruction in prog. */
4336 if (program_path
.get () != NULL
)
4338 target_create_inferior (program_path
.get (), program_args
);
4340 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4342 /* Stopped at the first instruction of the target
4344 cs
.general_thread
= cs
.last_ptid
;
4348 /* Something went wrong. */
4349 cs
.general_thread
= null_ptid
;
4354 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4355 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4361 /* It is a request we don't understand. Respond with an
4362 empty packet so that gdb knows that we don't support this
4364 cs
.own_buf
[0] = '\0';
4368 /* Extended (long) request. */
4369 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4373 /* It is a request we don't understand. Respond with an empty
4374 packet so that gdb knows that we don't support this
4376 cs
.own_buf
[0] = '\0';
4380 if (new_packet_len
!= -1)
4381 putpkt_binary (cs
.own_buf
, new_packet_len
);
4383 putpkt (cs
.own_buf
);
4385 response_needed
= false;
4393 /* Event-loop callback for serial events. */
4396 handle_serial_event (int err
, gdb_client_data client_data
)
4399 debug_printf ("handling possible serial event\n");
4401 /* Really handle it. */
4402 if (process_serial_event () < 0)
4404 keep_processing_events
= false;
4408 /* Be sure to not change the selected thread behind GDB's back.
4409 Important in the non-stop mode asynchronous protocol. */
4410 set_desired_thread ();
4413 /* Push a stop notification on the notification queue. */
4416 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4418 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4420 vstop_notif
->status
= *status
;
4421 vstop_notif
->ptid
= ptid
;
4422 /* Push Stop notification. */
4423 notif_push (¬if_stop
, vstop_notif
);
4426 /* Event-loop callback for target events. */
4429 handle_target_event (int err
, gdb_client_data client_data
)
4431 client_state
&cs
= get_client_state ();
4433 debug_printf ("handling possible target event\n");
4435 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4438 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4440 if (gdb_connected () && report_no_resumed
)
4441 push_stop_notification (null_ptid
, &cs
.last_status
);
4443 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4445 int pid
= cs
.last_ptid
.pid ();
4446 struct process_info
*process
= find_process_pid (pid
);
4447 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4449 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4450 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4452 mark_breakpoints_out (process
);
4453 target_mourn_inferior (cs
.last_ptid
);
4455 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4459 /* We're reporting this thread as stopped. Update its
4460 "want-stopped" state to what the client wants, until it
4461 gets a new resume action. */
4462 current_thread
->last_resume_kind
= resume_stop
;
4463 current_thread
->last_status
= cs
.last_status
;
4468 if (!target_running ())
4470 /* The last process exited. We're done. */
4474 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4475 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4476 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4480 /* A thread stopped with a signal, but gdb isn't
4481 connected to handle it. Pass it down to the
4482 inferior, as if it wasn't being traced. */
4483 enum gdb_signal signal
;
4486 debug_printf ("GDB not connected; forwarding event %d for"
4488 (int) cs
.last_status
.kind
,
4489 target_pid_to_str (cs
.last_ptid
));
4491 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4492 signal
= cs
.last_status
.value
.sig
;
4494 signal
= GDB_SIGNAL_0
;
4495 target_continue (cs
.last_ptid
, signal
);
4499 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4502 /* Be sure to not change the selected thread behind GDB's back.
4503 Important in the non-stop mode asynchronous protocol. */
4504 set_desired_thread ();
4507 /* See gdbsupport/event-loop.h. */
4510 invoke_async_signal_handlers ()
4515 /* See gdbsupport/event-loop.h. */
4518 check_async_event_handlers ()
4523 /* See gdbsupport/errors.h */
4532 /* See gdbsupport/gdb_select.h. */
4535 gdb_select (int n
, fd_set
*readfds
, fd_set
*writefds
,
4536 fd_set
*exceptfds
, struct timeval
*timeout
)
4538 return select (n
, readfds
, writefds
, exceptfds
, timeout
);
4549 } // namespace selftests
4550 #endif /* GDB_SELF_TEST */