1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2019 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 "common/agent.h"
24 #include "common/rsp-low.h"
25 #include "common/signals-state-save-restore.h"
31 #include "common/gdb_vecs.h"
32 #include "common/gdb_wait.h"
33 #include "common/btrace-common.h"
34 #include "common/filestuff.h"
35 #include "tracepoint.h"
39 #include "common/common-inferior.h"
40 #include "common/job-control.h"
41 #include "common/environ.h"
42 #include "filenames.h"
43 #include "common/pathstuff.h"
45 #include "common/selftest.h"
46 #include "common/scope-exit.h"
48 #define require_running_or_return(BUF) \
49 if (!target_running ()) \
55 #define require_running_or_break(BUF) \
56 if (!target_running ()) \
62 /* String containing the current directory (what getwd would return). */
64 char *current_directory
;
66 /* The environment to pass to the inferior when creating it. */
68 static gdb_environ our_environ
;
70 /* Start the inferior using a shell. */
72 /* We always try to start the inferior using a shell. */
74 int startup_with_shell
= 1;
78 static int extended_protocol
;
79 static int response_needed
;
80 static int exit_requested
;
82 /* --once: Exit after the first connection has closed. */
85 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
86 static int report_no_resumed
;
91 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
93 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
95 m_path
= std::move (path
);
97 /* Make sure we're using the absolute path of the inferior when
99 if (!contains_dir_separator (m_path
.get ()))
103 /* Check if the file is in our CWD. If it is, then we prefix
104 its name with CURRENT_DIRECTORY. Otherwise, we leave the
105 name as-is because we'll try searching for it in $PATH. */
106 if (is_regular_file (m_path
.get (), ®_file_errno
))
107 m_path
= gdb_abspath (m_path
.get ());
111 /* Return the PROGRAM_PATH. */
113 { return m_path
.get (); }
116 /* The program name, adjusted if needed. */
117 gdb::unique_xmalloc_ptr
<char> m_path
;
119 static std::vector
<char *> program_args
;
120 static std::string wrapper_argv
;
122 /* The PID of the originally created or attached inferior. Used to
123 send signals to the process when GDB sends us an asynchronous interrupt
124 (user hitting Control-C in the client), and to wait for the child to exit
125 when no longer debugging it. */
127 unsigned long signal_pid
;
129 /* Set if you want to disable optional thread related packets support
130 in gdbserver, for the sake of testing GDB against stubs that don't
132 int disable_packet_vCont
;
133 int disable_packet_Tthread
;
134 int disable_packet_qC
;
135 int disable_packet_qfThreadInfo
;
137 static unsigned char *mem_buf
;
139 /* A sub-class of 'struct notif_event' for stop, holding information
140 relative to a single stop reply. We keep a queue of these to
141 push to GDB in non-stop mode. */
145 struct notif_event base
;
147 /* Thread or process that got the event. */
151 struct target_waitstatus status
;
154 /* The current btrace configuration. This is gdbserver's mirror of GDB's
155 btrace configuration. */
156 static struct btrace_config current_btrace_conf
;
158 DEFINE_QUEUE_P (notif_event_p
);
160 /* The client remote protocol state. */
162 static client_state g_client_state
;
167 client_state
&cs
= g_client_state
;
172 /* Put a stop reply to the stop reply queue. */
175 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
177 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
179 new_notif
->ptid
= ptid
;
180 new_notif
->status
= *status
;
182 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
186 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
187 QUEUE_ITER (notif_event_p
) *iter
,
188 struct notif_event
*event
,
191 ptid_t filter_ptid
= *(ptid_t
*) data
;
192 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
194 if (vstop_event
->ptid
.matches (filter_ptid
))
196 if (q
->free_func
!= NULL
)
197 q
->free_func (event
);
199 QUEUE_remove_elem (notif_event_p
, q
, iter
);
208 discard_queued_stop_replies (ptid_t ptid
)
210 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
211 remove_all_on_match_ptid
, &ptid
);
215 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
217 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
219 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
222 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
225 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
226 QUEUE_ITER (notif_event_p
) *iter
,
227 struct notif_event
*event
,
230 ptid_t filter_ptid
= *(ptid_t
*) data
;
231 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
233 if (vstop_event
->ptid
.matches (filter_ptid
))
236 /* Don't resume fork children that GDB does not know about yet. */
237 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
238 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
239 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
248 in_queued_stop_replies (ptid_t ptid
)
250 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
251 in_queued_stop_replies_ptid
, &ptid
);
254 struct notif_server notif_stop
=
256 "vStopped", "Stop", NULL
, vstop_notif_reply
,
260 target_running (void)
262 return get_first_thread () != NULL
;
265 /* See common/common-inferior.h. */
270 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
273 /* See common/common-inferior.h. */
276 get_exec_file (int err
)
278 if (err
&& program_path
.get () == NULL
)
279 error (_("No executable file specified."));
281 return program_path
.get ();
293 attach_inferior (int pid
)
295 client_state
&cs
= get_client_state ();
296 /* myattach should return -1 if attaching is unsupported,
297 0 if it succeeded, and call error() otherwise. */
299 if (find_process_pid (pid
) != nullptr)
300 error ("Already attached to process %d\n", pid
);
302 if (myattach (pid
) != 0)
305 fprintf (stderr
, "Attached; pid = %d\n", pid
);
308 /* FIXME - It may be that we should get the SIGNAL_PID from the
309 attach function, so that it can be the main thread instead of
310 whichever we were told to attach to. */
315 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
317 /* GDB knows to ignore the first SIGSTOP after attaching to a running
318 process using the "attach" command, but this is different; it's
319 just using "target remote". Pretend it's just starting up. */
320 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
321 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
322 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
324 current_thread
->last_resume_kind
= resume_stop
;
325 current_thread
->last_status
= cs
.last_status
;
331 extern int remote_debug
;
333 /* Decode a qXfer read request. Return 0 if everything looks OK,
337 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
339 /* After the read marker and annex, qXfer looks like a
340 traditional 'm' packet. */
341 decode_m_packet (buf
, ofs
, len
);
347 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
349 /* Extract and NUL-terminate the object. */
351 while (*buf
&& *buf
!= ':')
357 /* Extract and NUL-terminate the read/write action. */
359 while (*buf
&& *buf
!= ':')
365 /* Extract and NUL-terminate the annex. */
367 while (*buf
&& *buf
!= ':')
377 /* Write the response to a successful qXfer read. Returns the
378 length of the (binary) data stored in BUF, corresponding
379 to as much of DATA/LEN as we could fit. IS_MORE controls
380 the first character of the response. */
382 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
391 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
392 &out_len
, PBUFSIZ
- 2) + 1;
395 /* Handle btrace enabling in BTS format. */
398 handle_btrace_enable_bts (struct thread_info
*thread
)
400 if (thread
->btrace
!= NULL
)
401 error (_("Btrace already enabled."));
403 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
404 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
407 /* Handle btrace enabling in Intel Processor Trace format. */
410 handle_btrace_enable_pt (struct thread_info
*thread
)
412 if (thread
->btrace
!= NULL
)
413 error (_("Btrace already enabled."));
415 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
416 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
419 /* Handle btrace disabling. */
422 handle_btrace_disable (struct thread_info
*thread
)
425 if (thread
->btrace
== NULL
)
426 error (_("Branch tracing not enabled."));
428 if (target_disable_btrace (thread
->btrace
) != 0)
429 error (_("Could not disable branch tracing."));
431 thread
->btrace
= NULL
;
434 /* Handle the "Qbtrace" packet. */
437 handle_btrace_general_set (char *own_buf
)
439 client_state
&cs
= get_client_state ();
440 struct thread_info
*thread
;
443 if (!startswith (own_buf
, "Qbtrace:"))
446 op
= own_buf
+ strlen ("Qbtrace:");
448 if (cs
.general_thread
== null_ptid
449 || cs
.general_thread
== minus_one_ptid
)
451 strcpy (own_buf
, "E.Must select a single thread.");
455 thread
= find_thread_ptid (cs
.general_thread
);
458 strcpy (own_buf
, "E.No such thread.");
464 if (strcmp (op
, "bts") == 0)
465 handle_btrace_enable_bts (thread
);
466 else if (strcmp (op
, "pt") == 0)
467 handle_btrace_enable_pt (thread
);
468 else if (strcmp (op
, "off") == 0)
469 handle_btrace_disable (thread
);
471 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
475 CATCH (exception
, RETURN_MASK_ERROR
)
477 sprintf (own_buf
, "E.%s", exception
.what ());
484 /* Handle the "Qbtrace-conf" packet. */
487 handle_btrace_conf_general_set (char *own_buf
)
489 client_state
&cs
= get_client_state ();
490 struct thread_info
*thread
;
493 if (!startswith (own_buf
, "Qbtrace-conf:"))
496 op
= own_buf
+ strlen ("Qbtrace-conf:");
498 if (cs
.general_thread
== null_ptid
499 || cs
.general_thread
== minus_one_ptid
)
501 strcpy (own_buf
, "E.Must select a single thread.");
505 thread
= find_thread_ptid (cs
.general_thread
);
508 strcpy (own_buf
, "E.No such thread.");
512 if (startswith (op
, "bts:size="))
518 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
519 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
521 strcpy (own_buf
, "E.Bad size value.");
525 current_btrace_conf
.bts
.size
= (unsigned int) size
;
527 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
533 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
534 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
536 strcpy (own_buf
, "E.Bad size value.");
540 current_btrace_conf
.pt
.size
= (unsigned int) size
;
544 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
552 /* Handle all of the extended 'Q' packets. */
555 handle_general_set (char *own_buf
)
557 client_state
&cs
= get_client_state ();
558 if (startswith (own_buf
, "QPassSignals:"))
560 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
561 const char *p
= own_buf
+ strlen ("QPassSignals:");
564 p
= decode_address_to_semicolon (&cursig
, p
);
565 for (i
= 0; i
< numsigs
; i
++)
569 cs
.pass_signals
[i
] = 1;
571 /* Keep looping, to clear the remaining signals. */
574 p
= decode_address_to_semicolon (&cursig
, p
);
577 cs
.pass_signals
[i
] = 0;
579 strcpy (own_buf
, "OK");
583 if (startswith (own_buf
, "QProgramSignals:"))
585 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
586 const char *p
= own_buf
+ strlen ("QProgramSignals:");
589 cs
.program_signals_p
= 1;
591 p
= decode_address_to_semicolon (&cursig
, p
);
592 for (i
= 0; i
< numsigs
; i
++)
596 cs
.program_signals
[i
] = 1;
598 /* Keep looping, to clear the remaining signals. */
601 p
= decode_address_to_semicolon (&cursig
, p
);
604 cs
.program_signals
[i
] = 0;
606 strcpy (own_buf
, "OK");
610 if (startswith (own_buf
, "QCatchSyscalls:"))
612 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
615 struct process_info
*process
;
617 if (!target_running () || !target_supports_catch_syscall ())
623 if (strcmp (p
, "0") == 0)
625 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
629 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
635 process
= current_process ();
636 process
->syscalls_to_catch
.clear ();
646 p
= decode_address_to_semicolon (&sysno
, p
);
647 process
->syscalls_to_catch
.push_back (sysno
);
651 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
658 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
660 our_environ
= gdb_environ::from_host_environ ();
666 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
668 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
669 /* The final form of the environment variable. FINAL_VAR will
670 hold the 'VAR=VALUE' format. */
671 std::string final_var
= hex2str (p
);
672 std::string var_name
, var_value
;
676 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
677 debug_printf (_("[Environment variable to be set: '%s']\n"),
682 size_t pos
= final_var
.find ('=');
683 if (pos
== std::string::npos
)
685 warning (_("Unexpected format for environment variable: '%s'"),
691 var_name
= final_var
.substr (0, pos
);
692 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
694 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
700 if (startswith (own_buf
, "QEnvironmentUnset:"))
702 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
703 std::string varname
= hex2str (p
);
707 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
708 debug_printf (_("[Environment variable to be unset: '%s']\n"),
713 our_environ
.unset (varname
.c_str ());
719 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
723 debug_printf ("[noack mode enabled]\n");
732 if (startswith (own_buf
, "QNonStop:"))
734 char *mode
= own_buf
+ 9;
738 if (strcmp (mode
, "0") == 0)
740 else if (strcmp (mode
, "1") == 0)
744 /* We don't know what this mode is, so complain to
746 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
752 req_str
= req
? "non-stop" : "all-stop";
753 if (start_non_stop (req
) != 0)
755 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
763 debug_printf ("[%s mode enabled]\n", req_str
);
769 if (startswith (own_buf
, "QDisableRandomization:"))
771 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
774 unpack_varlen_hex (packet
, &setting
);
775 cs
.disable_randomization
= setting
;
779 debug_printf (cs
.disable_randomization
780 ? "[address space randomization disabled]\n"
781 : "[address space randomization enabled]\n");
788 if (target_supports_tracepoints ()
789 && handle_tracepoint_general_set (own_buf
))
792 if (startswith (own_buf
, "QAgent:"))
794 char *mode
= own_buf
+ strlen ("QAgent:");
797 if (strcmp (mode
, "0") == 0)
799 else if (strcmp (mode
, "1") == 0)
803 /* We don't know what this value is, so complain to GDB. */
804 sprintf (own_buf
, "E.Unknown QAgent value");
808 /* Update the flag. */
811 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
816 if (handle_btrace_general_set (own_buf
))
819 if (handle_btrace_conf_general_set (own_buf
))
822 if (startswith (own_buf
, "QThreadEvents:"))
824 char *mode
= own_buf
+ strlen ("QThreadEvents:");
825 enum tribool req
= TRIBOOL_UNKNOWN
;
827 if (strcmp (mode
, "0") == 0)
829 else if (strcmp (mode
, "1") == 0)
833 /* We don't know what this mode is, so complain to GDB. */
834 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
839 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
843 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
845 debug_printf ("[thread events are now %s]\n", req_str
);
852 if (startswith (own_buf
, "QStartupWithShell:"))
854 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
856 if (strcmp (value
, "1") == 0)
857 startup_with_shell
= true;
858 else if (strcmp (value
, "0") == 0)
859 startup_with_shell
= false;
863 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
870 debug_printf (_("[Inferior will %s started with shell]"),
871 startup_with_shell
? "be" : "not be");
877 if (startswith (own_buf
, "QSetWorkingDir:"))
879 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
883 std::string path
= hex2str (p
);
885 set_inferior_cwd (path
.c_str ());
888 debug_printf (_("[Set the inferior's current directory to %s]\n"),
893 /* An empty argument means that we should clear out any
894 previously set cwd for the inferior. */
895 set_inferior_cwd (NULL
);
899 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
906 /* Otherwise we didn't know what packet it was. Say we didn't
912 get_features_xml (const char *annex
)
914 const struct target_desc
*desc
= current_target_desc ();
916 /* `desc->xmltarget' defines what to return when looking for the
917 "target.xml" file. Its contents can either be verbatim XML code
918 (prefixed with a '@') or else the name of the actual XML file to
919 be used in place of "target.xml".
921 This variable is set up from the auto-generated
922 init_registers_... routine for the current target. */
924 if (strcmp (annex
, "target.xml") == 0)
926 const char *ret
= tdesc_get_features_xml (desc
);
936 extern const char *const xml_builtin
[][2];
939 /* Look for the annex. */
940 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
941 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
944 if (xml_builtin
[i
][0] != NULL
)
945 return xml_builtin
[i
][1];
953 monitor_show_help (void)
955 monitor_output ("The following monitor commands are supported:\n");
956 monitor_output (" set debug <0|1>\n");
957 monitor_output (" Enable general debugging messages\n");
958 monitor_output (" set debug-hw-points <0|1>\n");
959 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
960 monitor_output (" set remote-debug <0|1>\n");
961 monitor_output (" Enable remote protocol debugging messages\n");
962 monitor_output (" set debug-format option1[,option2,...]\n");
963 monitor_output (" Add additional information to debugging messages\n");
964 monitor_output (" Options: all, none");
965 monitor_output (", timestamp");
966 monitor_output ("\n");
967 monitor_output (" exit\n");
968 monitor_output (" Quit GDBserver\n");
971 /* Read trace frame or inferior memory. Returns the number of bytes
972 actually read, zero when no further transfer is possible, and -1 on
973 error. Return of a positive value smaller than LEN does not
974 indicate there's no more to be read, only the end of the transfer.
975 E.g., when GDB reads memory from a traceframe, a first request may
976 be served from a memory block that does not cover the whole request
977 length. A following request gets the rest served from either
978 another block (of the same traceframe) or from the read-only
982 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
984 client_state
&cs
= get_client_state ();
987 if (cs
.current_traceframe
>= 0)
990 ULONGEST length
= len
;
992 if (traceframe_read_mem (cs
.current_traceframe
,
993 memaddr
, myaddr
, len
, &nbytes
))
995 /* Data read from trace buffer, we're done. */
998 if (!in_readonly_region (memaddr
, length
))
1000 /* Otherwise we have a valid readonly case, fall through. */
1001 /* (assume no half-trace half-real blocks for now) */
1004 res
= prepare_to_access_memory ();
1007 if (set_desired_thread ())
1008 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1011 done_accessing_memory ();
1013 return res
== 0 ? len
: -1;
1019 /* Write trace frame or inferior memory. Actually, writing to trace
1020 frames is forbidden. */
1023 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1025 client_state
&cs
= get_client_state ();
1026 if (cs
.current_traceframe
>= 0)
1032 ret
= prepare_to_access_memory ();
1035 if (set_desired_thread ())
1036 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1039 done_accessing_memory ();
1045 /* Subroutine of handle_search_memory to simplify it. */
1048 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1049 gdb_byte
*pattern
, unsigned pattern_len
,
1050 gdb_byte
*search_buf
,
1051 unsigned chunk_size
, unsigned search_buf_size
,
1052 CORE_ADDR
*found_addrp
)
1054 /* Prime the search buffer. */
1056 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1059 warning ("Unable to access %ld bytes of target "
1060 "memory at 0x%lx, halting search.",
1061 (long) search_buf_size
, (long) start_addr
);
1065 /* Perform the search.
1067 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1068 When we've scanned N bytes we copy the trailing bytes to the start and
1069 read in another N bytes. */
1071 while (search_space_len
>= pattern_len
)
1073 gdb_byte
*found_ptr
;
1074 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1078 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1081 if (found_ptr
!= NULL
)
1083 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1084 *found_addrp
= found_addr
;
1088 /* Not found in this chunk, skip to next chunk. */
1090 /* Don't let search_space_len wrap here, it's unsigned. */
1091 if (search_space_len
>= chunk_size
)
1092 search_space_len
-= chunk_size
;
1094 search_space_len
= 0;
1096 if (search_space_len
>= pattern_len
)
1098 unsigned keep_len
= search_buf_size
- chunk_size
;
1099 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1102 /* Copy the trailing part of the previous iteration to the front
1103 of the buffer for the next iteration. */
1104 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1106 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1107 ? search_space_len
- keep_len
1110 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1111 nr_to_read
) != search_buf_size
)
1113 warning ("Unable to access %ld bytes of target memory "
1114 "at 0x%lx, halting search.",
1115 (long) nr_to_read
, (long) read_addr
);
1119 start_addr
+= chunk_size
;
1128 /* Handle qSearch:memory packets. */
1131 handle_search_memory (char *own_buf
, int packet_len
)
1133 CORE_ADDR start_addr
;
1134 CORE_ADDR search_space_len
;
1136 unsigned int pattern_len
;
1137 /* NOTE: also defined in find.c testcase. */
1138 #define SEARCH_CHUNK_SIZE 16000
1139 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1140 /* Buffer to hold memory contents for searching. */
1141 gdb_byte
*search_buf
;
1142 unsigned search_buf_size
;
1144 CORE_ADDR found_addr
;
1145 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1147 pattern
= (gdb_byte
*) malloc (packet_len
);
1148 if (pattern
== NULL
)
1150 error ("Unable to allocate memory to perform the search");
1151 strcpy (own_buf
, "E00");
1154 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1155 packet_len
- cmd_name_len
,
1156 &start_addr
, &search_space_len
,
1157 pattern
, &pattern_len
) < 0)
1160 error ("Error in parsing qSearch:memory packet");
1161 strcpy (own_buf
, "E00");
1165 search_buf_size
= chunk_size
+ pattern_len
- 1;
1167 /* No point in trying to allocate a buffer larger than the search space. */
1168 if (search_space_len
< search_buf_size
)
1169 search_buf_size
= search_space_len
;
1171 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1172 if (search_buf
== NULL
)
1175 error ("Unable to allocate memory to perform the search");
1176 strcpy (own_buf
, "E00");
1180 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1181 pattern
, pattern_len
,
1182 search_buf
, chunk_size
, search_buf_size
,
1186 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1187 else if (found
== 0)
1188 strcpy (own_buf
, "0");
1190 strcpy (own_buf
, "E00");
1196 /* Handle the "D" packet. */
1199 handle_detach (char *own_buf
)
1201 client_state
&cs
= get_client_state ();
1203 process_info
*process
;
1205 if (cs
.multi_process
)
1208 int pid
= strtol (&own_buf
[2], NULL
, 16);
1210 process
= find_process_pid (pid
);
1214 process
= (current_thread
!= nullptr
1215 ? get_thread_process (current_thread
)
1219 if (process
== NULL
)
1221 write_enn (own_buf
);
1225 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1227 if (tracing
&& disconnected_tracing
)
1229 "Disconnected tracing in effect, "
1230 "leaving gdbserver attached to the process\n");
1232 if (any_persistent_commands (process
))
1234 "Persistent commands are present, "
1235 "leaving gdbserver attached to the process\n");
1237 /* Make sure we're in non-stop/async mode, so we we can both
1238 wait for an async socket accept, and handle async target
1239 events simultaneously. There's also no point either in
1240 having the target stop all threads, when we're going to
1241 pass signals down without informing GDB. */
1245 debug_printf ("Forcing non-stop mode\n");
1251 process
->gdb_detached
= 1;
1253 /* Detaching implicitly resumes all threads. */
1254 target_continue_no_signal (minus_one_ptid
);
1260 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1263 /* We'll need this after PROCESS has been destroyed. */
1264 int pid
= process
->pid
;
1266 if (detach_inferior (process
) != 0)
1267 write_enn (own_buf
);
1270 discard_queued_stop_replies (ptid_t (pid
));
1273 if (extended_protocol
|| target_running ())
1275 /* There is still at least one inferior remaining or
1276 we are in extended mode, so don't terminate gdbserver,
1277 and instead treat this like a normal program exit. */
1278 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1279 cs
.last_status
.value
.integer
= 0;
1280 cs
.last_ptid
= ptid_t (pid
);
1282 current_thread
= NULL
;
1289 /* If we are attached, then we can exit. Otherwise, we
1290 need to hang around doing nothing, until the child is
1292 join_inferior (pid
);
1298 /* Parse options to --debug-format= and "monitor set debug-format".
1299 ARG is the text after "--debug-format=" or "monitor set debug-format".
1300 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1301 This triggers calls to monitor_output.
1302 The result is an empty string if all options were parsed ok, otherwise an
1303 error message which the caller must free.
1305 N.B. These commands affect all debug format settings, they are not
1306 cumulative. If a format is not specified, it is turned off.
1307 However, we don't go to extra trouble with things like
1308 "monitor set debug-format all,none,timestamp".
1309 Instead we just parse them one at a time, in order.
1311 The syntax for "monitor set debug" we support here is not identical
1312 to gdb's "set debug foo on|off" because we also use this function to
1313 parse "--debug-format=foo,bar". */
1316 parse_debug_format_options (const char *arg
, int is_monitor
)
1318 /* First turn all debug format options off. */
1319 debug_timestamp
= 0;
1321 /* First remove leading spaces, for "monitor set debug-format". */
1322 while (isspace (*arg
))
1325 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1326 = delim_string_to_char_ptr_vec (arg
, ',');
1328 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1330 if (strcmp (option
.get (), "all") == 0)
1332 debug_timestamp
= 1;
1334 monitor_output ("All extra debug format options enabled.\n");
1336 else if (strcmp (option
.get (), "none") == 0)
1338 debug_timestamp
= 0;
1340 monitor_output ("All extra debug format options disabled.\n");
1342 else if (strcmp (option
.get (), "timestamp") == 0)
1344 debug_timestamp
= 1;
1346 monitor_output ("Timestamps will be added to debug output.\n");
1348 else if (*option
== '\0')
1350 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1354 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1358 return std::string ();
1361 /* Handle monitor commands not handled by target-specific handlers. */
1364 handle_monitor_command (char *mon
, char *own_buf
)
1366 if (strcmp (mon
, "set debug 1") == 0)
1369 monitor_output ("Debug output enabled.\n");
1371 else if (strcmp (mon
, "set debug 0") == 0)
1374 monitor_output ("Debug output disabled.\n");
1376 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1378 show_debug_regs
= 1;
1379 monitor_output ("H/W point debugging output enabled.\n");
1381 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1383 show_debug_regs
= 0;
1384 monitor_output ("H/W point debugging output disabled.\n");
1386 else if (strcmp (mon
, "set remote-debug 1") == 0)
1389 monitor_output ("Protocol debug output enabled.\n");
1391 else if (strcmp (mon
, "set remote-debug 0") == 0)
1394 monitor_output ("Protocol debug output disabled.\n");
1396 else if (startswith (mon
, "set debug-format "))
1398 std::string error_msg
1399 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1402 if (!error_msg
.empty ())
1404 monitor_output (error_msg
.c_str ());
1405 monitor_show_help ();
1406 write_enn (own_buf
);
1409 else if (strcmp (mon
, "help") == 0)
1410 monitor_show_help ();
1411 else if (strcmp (mon
, "exit") == 0)
1415 monitor_output ("Unknown monitor command.\n\n");
1416 monitor_show_help ();
1417 write_enn (own_buf
);
1421 /* Associates a callback with each supported qXfer'able object. */
1425 /* The object this handler handles. */
1428 /* Request that the target transfer up to LEN 8-bit bytes of the
1429 target's OBJECT. The OFFSET, for a seekable object, specifies
1430 the starting point. The ANNEX can be used to provide additional
1431 data-specific information to the target.
1433 Return the number of bytes actually transfered, zero when no
1434 further transfer is possible, -1 on error, -2 when the transfer
1435 is not supported, and -3 on a verbose error message that should
1436 be preserved. Return of a positive value smaller than LEN does
1437 not indicate the end of the object, only the end of the transfer.
1439 One, and only one, of readbuf or writebuf must be non-NULL. */
1440 int (*xfer
) (const char *annex
,
1441 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1442 ULONGEST offset
, LONGEST len
);
1445 /* Handle qXfer:auxv:read. */
1448 handle_qxfer_auxv (const char *annex
,
1449 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1450 ULONGEST offset
, LONGEST len
)
1452 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1455 if (annex
[0] != '\0' || current_thread
== NULL
)
1458 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1461 /* Handle qXfer:exec-file:read. */
1464 handle_qxfer_exec_file (const char *annex
,
1465 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1466 ULONGEST offset
, LONGEST len
)
1472 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1475 if (annex
[0] == '\0')
1477 if (current_thread
== NULL
)
1480 pid
= pid_of (current_thread
);
1484 annex
= unpack_varlen_hex (annex
, &pid
);
1485 if (annex
[0] != '\0')
1492 file
= (*the_target
->pid_to_exec_file
) (pid
);
1496 total_len
= strlen (file
);
1498 if (offset
> total_len
)
1501 if (offset
+ len
> total_len
)
1502 len
= total_len
- offset
;
1504 memcpy (readbuf
, file
+ offset
, len
);
1508 /* Handle qXfer:features:read. */
1511 handle_qxfer_features (const char *annex
,
1512 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1513 ULONGEST offset
, LONGEST len
)
1515 const char *document
;
1518 if (writebuf
!= NULL
)
1521 if (!target_running ())
1524 /* Grab the correct annex. */
1525 document
= get_features_xml (annex
);
1526 if (document
== NULL
)
1529 total_len
= strlen (document
);
1531 if (offset
> total_len
)
1534 if (offset
+ len
> total_len
)
1535 len
= total_len
- offset
;
1537 memcpy (readbuf
, document
+ offset
, len
);
1541 /* Handle qXfer:libraries:read. */
1544 handle_qxfer_libraries (const char *annex
,
1545 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1546 ULONGEST offset
, LONGEST len
)
1548 if (writebuf
!= NULL
)
1551 if (annex
[0] != '\0' || current_thread
== NULL
)
1554 std::string document
= "<library-list version=\"1.0\">\n";
1556 for (const dll_info
&dll
: all_dlls
)
1557 document
+= string_printf
1558 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1559 dll
.name
.c_str (), (long) dll
.base_addr
);
1561 document
+= "</library-list>\n";
1563 if (offset
> document
.length ())
1566 if (offset
+ len
> document
.length ())
1567 len
= document
.length () - offset
;
1569 memcpy (readbuf
, &document
[offset
], len
);
1574 /* Handle qXfer:libraries-svr4:read. */
1577 handle_qxfer_libraries_svr4 (const char *annex
,
1578 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1579 ULONGEST offset
, LONGEST len
)
1581 if (writebuf
!= NULL
)
1584 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1587 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1590 /* Handle qXfer:osadata:read. */
1593 handle_qxfer_osdata (const char *annex
,
1594 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1595 ULONGEST offset
, LONGEST len
)
1597 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1600 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1603 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1606 handle_qxfer_siginfo (const char *annex
,
1607 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1608 ULONGEST offset
, LONGEST len
)
1610 if (the_target
->qxfer_siginfo
== NULL
)
1613 if (annex
[0] != '\0' || current_thread
== NULL
)
1616 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1619 /* Handle qXfer:spu:read and qXfer:spu:write. */
1622 handle_qxfer_spu (const char *annex
,
1623 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1624 ULONGEST offset
, LONGEST len
)
1626 if (the_target
->qxfer_spu
== NULL
)
1629 if (current_thread
== NULL
)
1632 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1635 /* Handle qXfer:statictrace:read. */
1638 handle_qxfer_statictrace (const char *annex
,
1639 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1640 ULONGEST offset
, LONGEST len
)
1642 client_state
&cs
= get_client_state ();
1645 if (writebuf
!= NULL
)
1648 if (annex
[0] != '\0' || current_thread
== NULL
1649 || cs
.current_traceframe
== -1)
1652 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1653 readbuf
, len
, &nbytes
))
1658 /* Helper for handle_qxfer_threads_proper.
1659 Emit the XML to describe the thread of INF. */
1662 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1664 ptid_t ptid
= ptid_of (thread
);
1666 int core
= target_core_of_thread (ptid
);
1668 const char *name
= target_thread_name (ptid
);
1671 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1673 write_ptid (ptid_s
, ptid
);
1675 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1679 sprintf (core_s
, "%d", core
);
1680 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1684 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1688 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1689 bin2hex (handle
, handle_s
, handle_len
);
1690 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1693 buffer_xml_printf (buffer
, "/>\n");
1696 /* Helper for handle_qxfer_threads. */
1699 handle_qxfer_threads_proper (struct buffer
*buffer
)
1701 buffer_grow_str (buffer
, "<threads>\n");
1703 for_each_thread ([&] (thread_info
*thread
)
1705 handle_qxfer_threads_worker (thread
, buffer
);
1708 buffer_grow_str0 (buffer
, "</threads>\n");
1711 /* Handle qXfer:threads:read. */
1714 handle_qxfer_threads (const char *annex
,
1715 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1716 ULONGEST offset
, LONGEST len
)
1718 static char *result
= 0;
1719 static unsigned int result_length
= 0;
1721 if (writebuf
!= NULL
)
1724 if (annex
[0] != '\0')
1729 struct buffer buffer
;
1730 /* When asked for data at offset 0, generate everything and store into
1731 'result'. Successive reads will be served off 'result'. */
1735 buffer_init (&buffer
);
1737 handle_qxfer_threads_proper (&buffer
);
1739 result
= buffer_finish (&buffer
);
1740 result_length
= strlen (result
);
1741 buffer_free (&buffer
);
1744 if (offset
>= result_length
)
1746 /* We're out of data. */
1753 if (len
> result_length
- offset
)
1754 len
= result_length
- offset
;
1756 memcpy (readbuf
, result
+ offset
, len
);
1761 /* Handle qXfer:traceframe-info:read. */
1764 handle_qxfer_traceframe_info (const char *annex
,
1765 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1766 ULONGEST offset
, LONGEST len
)
1768 client_state
&cs
= get_client_state ();
1769 static char *result
= 0;
1770 static unsigned int result_length
= 0;
1772 if (writebuf
!= NULL
)
1775 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1780 struct buffer buffer
;
1782 /* When asked for data at offset 0, generate everything and
1783 store into 'result'. Successive reads will be served off
1787 buffer_init (&buffer
);
1789 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1791 result
= buffer_finish (&buffer
);
1792 result_length
= strlen (result
);
1793 buffer_free (&buffer
);
1796 if (offset
>= result_length
)
1798 /* We're out of data. */
1805 if (len
> result_length
- offset
)
1806 len
= result_length
- offset
;
1808 memcpy (readbuf
, result
+ offset
, len
);
1812 /* Handle qXfer:fdpic:read. */
1815 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1816 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1818 if (the_target
->read_loadmap
== NULL
)
1821 if (current_thread
== NULL
)
1824 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1827 /* Handle qXfer:btrace:read. */
1830 handle_qxfer_btrace (const char *annex
,
1831 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1832 ULONGEST offset
, LONGEST len
)
1834 client_state
&cs
= get_client_state ();
1835 static struct buffer cache
;
1836 struct thread_info
*thread
;
1837 enum btrace_read_type type
;
1840 if (writebuf
!= NULL
)
1843 if (cs
.general_thread
== null_ptid
1844 || cs
.general_thread
== minus_one_ptid
)
1846 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1850 thread
= find_thread_ptid (cs
.general_thread
);
1853 strcpy (cs
.own_buf
, "E.No such thread.");
1857 if (thread
->btrace
== NULL
)
1859 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1863 if (strcmp (annex
, "all") == 0)
1864 type
= BTRACE_READ_ALL
;
1865 else if (strcmp (annex
, "new") == 0)
1866 type
= BTRACE_READ_NEW
;
1867 else if (strcmp (annex
, "delta") == 0)
1868 type
= BTRACE_READ_DELTA
;
1871 strcpy (cs
.own_buf
, "E.Bad annex.");
1877 buffer_free (&cache
);
1881 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1883 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1885 CATCH (exception
, RETURN_MASK_ERROR
)
1887 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1895 else if (offset
> cache
.used_size
)
1897 buffer_free (&cache
);
1901 if (len
> cache
.used_size
- offset
)
1902 len
= cache
.used_size
- offset
;
1904 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1909 /* Handle qXfer:btrace-conf:read. */
1912 handle_qxfer_btrace_conf (const char *annex
,
1913 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1914 ULONGEST offset
, LONGEST len
)
1916 client_state
&cs
= get_client_state ();
1917 static struct buffer cache
;
1918 struct thread_info
*thread
;
1921 if (writebuf
!= NULL
)
1924 if (annex
[0] != '\0')
1927 if (cs
.general_thread
== null_ptid
1928 || cs
.general_thread
== minus_one_ptid
)
1930 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1934 thread
= find_thread_ptid (cs
.general_thread
);
1937 strcpy (cs
.own_buf
, "E.No such thread.");
1941 if (thread
->btrace
== NULL
)
1943 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1949 buffer_free (&cache
);
1953 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1955 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1957 CATCH (exception
, RETURN_MASK_ERROR
)
1959 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1967 else if (offset
> cache
.used_size
)
1969 buffer_free (&cache
);
1973 if (len
> cache
.used_size
- offset
)
1974 len
= cache
.used_size
- offset
;
1976 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1981 static const struct qxfer qxfer_packets
[] =
1983 { "auxv", handle_qxfer_auxv
},
1984 { "btrace", handle_qxfer_btrace
},
1985 { "btrace-conf", handle_qxfer_btrace_conf
},
1986 { "exec-file", handle_qxfer_exec_file
},
1987 { "fdpic", handle_qxfer_fdpic
},
1988 { "features", handle_qxfer_features
},
1989 { "libraries", handle_qxfer_libraries
},
1990 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1991 { "osdata", handle_qxfer_osdata
},
1992 { "siginfo", handle_qxfer_siginfo
},
1993 { "spu", handle_qxfer_spu
},
1994 { "statictrace", handle_qxfer_statictrace
},
1995 { "threads", handle_qxfer_threads
},
1996 { "traceframe-info", handle_qxfer_traceframe_info
},
2000 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2008 if (!startswith (own_buf
, "qXfer:"))
2011 /* Grab the object, r/w and annex. */
2012 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2014 write_enn (own_buf
);
2019 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2022 const struct qxfer
*q
= &qxfer_packets
[i
];
2024 if (strcmp (object
, q
->object
) == 0)
2026 if (strcmp (rw
, "read") == 0)
2028 unsigned char *data
;
2033 /* Grab the offset and length. */
2034 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2036 write_enn (own_buf
);
2040 /* Read one extra byte, as an indicator of whether there is
2042 if (len
> PBUFSIZ
- 2)
2044 data
= (unsigned char *) malloc (len
+ 1);
2047 write_enn (own_buf
);
2050 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2058 /* Preserve error message. */
2061 write_enn (own_buf
);
2063 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2065 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2070 else if (strcmp (rw
, "write") == 0)
2075 unsigned char *data
;
2077 strcpy (own_buf
, "E00");
2078 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2081 write_enn (own_buf
);
2084 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2085 &ofs
, &len
, data
) < 0)
2088 write_enn (own_buf
);
2092 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2100 /* Preserve error message. */
2103 write_enn (own_buf
);
2105 sprintf (own_buf
, "%x", n
);
2118 /* Compute 32 bit CRC from inferior memory.
2120 On success, return 32 bit CRC.
2121 On failure, return (unsigned long long) -1. */
2123 static unsigned long long
2124 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2128 unsigned char byte
= 0;
2130 /* Return failure if memory read fails. */
2131 if (read_inferior_memory (base
, &byte
, 1) != 0)
2132 return (unsigned long long) -1;
2134 crc
= xcrc32 (&byte
, 1, crc
);
2137 return (unsigned long long) crc
;
2140 /* Add supported btrace packets to BUF. */
2143 supported_btrace_packets (char *buf
)
2145 strcat (buf
, ";Qbtrace:bts+");
2146 strcat (buf
, ";Qbtrace-conf:bts:size+");
2147 strcat (buf
, ";Qbtrace:pt+");
2148 strcat (buf
, ";Qbtrace-conf:pt:size+");
2149 strcat (buf
, ";Qbtrace:off+");
2150 strcat (buf
, ";qXfer:btrace:read+");
2151 strcat (buf
, ";qXfer:btrace-conf:read+");
2154 /* Handle all of the extended 'q' packets. */
2157 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2159 client_state
&cs
= get_client_state ();
2160 static std::list
<thread_info
*>::const_iterator thread_iter
;
2162 /* Reply the current thread id. */
2163 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2166 require_running_or_return (own_buf
);
2168 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2169 ptid
= cs
.general_thread
;
2172 thread_iter
= all_threads
.begin ();
2173 ptid
= (*thread_iter
)->id
;
2176 sprintf (own_buf
, "QC");
2178 write_ptid (own_buf
, ptid
);
2182 if (strcmp ("qSymbol::", own_buf
) == 0)
2184 struct thread_info
*save_thread
= current_thread
;
2186 /* For qSymbol, GDB only changes the current thread if the
2187 previous current thread was of a different process. So if
2188 the previous thread is gone, we need to pick another one of
2189 the same process. This can happen e.g., if we followed an
2190 exec in a non-leader thread. */
2191 if (current_thread
== NULL
)
2194 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2196 /* Just in case, if we didn't find a thread, then bail out
2197 instead of crashing. */
2198 if (current_thread
== NULL
)
2200 write_enn (own_buf
);
2201 current_thread
= save_thread
;
2206 /* GDB is suggesting new symbols have been loaded. This may
2207 mean a new shared library has been detected as loaded, so
2208 take the opportunity to check if breakpoints we think are
2209 inserted, still are. Note that it isn't guaranteed that
2210 we'll see this when a shared library is loaded, and nor will
2211 we see this for unloads (although breakpoints in unloaded
2212 libraries shouldn't trigger), as GDB may not find symbols for
2213 the library at all. We also re-validate breakpoints when we
2214 see a second GDB breakpoint for the same address, and or when
2215 we access breakpoint shadows. */
2216 validate_breakpoints ();
2218 if (target_supports_tracepoints ())
2219 tracepoint_look_up_symbols ();
2221 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2222 (*the_target
->look_up_symbols
) ();
2224 current_thread
= save_thread
;
2226 strcpy (own_buf
, "OK");
2230 if (!disable_packet_qfThreadInfo
)
2232 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2234 require_running_or_return (own_buf
);
2235 thread_iter
= all_threads
.begin ();
2238 ptid_t ptid
= (*thread_iter
)->id
;
2239 write_ptid (own_buf
, ptid
);
2244 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2246 require_running_or_return (own_buf
);
2247 if (thread_iter
!= all_threads
.end ())
2250 ptid_t ptid
= (*thread_iter
)->id
;
2251 write_ptid (own_buf
, ptid
);
2257 sprintf (own_buf
, "l");
2263 if (the_target
->read_offsets
!= NULL
2264 && strcmp ("qOffsets", own_buf
) == 0)
2266 CORE_ADDR text
, data
;
2268 require_running_or_return (own_buf
);
2269 if (the_target
->read_offsets (&text
, &data
))
2270 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2271 (long)text
, (long)data
, (long)data
);
2273 write_enn (own_buf
);
2278 /* Protocol features query. */
2279 if (startswith (own_buf
, "qSupported")
2280 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2282 char *p
= &own_buf
[10];
2283 int gdb_supports_qRelocInsn
= 0;
2285 /* Process each feature being provided by GDB. The first
2286 feature will follow a ':', and latter features will follow
2290 char **qsupported
= NULL
;
2295 /* Two passes, to avoid nested strtok calls in
2296 target_process_qsupported. */
2297 for (p
= strtok (p
+ 1, ";");
2299 p
= strtok (NULL
, ";"))
2302 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2303 qsupported
[count
- 1] = xstrdup (p
);
2306 for (i
= 0; i
< count
; i
++)
2309 if (strcmp (p
, "multiprocess+") == 0)
2311 /* GDB supports and wants multi-process support if
2313 if (target_supports_multi_process ())
2314 cs
.multi_process
= 1;
2316 else if (strcmp (p
, "qRelocInsn+") == 0)
2318 /* GDB supports relocate instruction requests. */
2319 gdb_supports_qRelocInsn
= 1;
2321 else if (strcmp (p
, "swbreak+") == 0)
2323 /* GDB wants us to report whether a trap is caused
2324 by a software breakpoint and for us to handle PC
2325 adjustment if necessary on this target. */
2326 if (target_supports_stopped_by_sw_breakpoint ())
2327 cs
.swbreak_feature
= 1;
2329 else if (strcmp (p
, "hwbreak+") == 0)
2331 /* GDB wants us to report whether a trap is caused
2332 by a hardware breakpoint. */
2333 if (target_supports_stopped_by_hw_breakpoint ())
2334 cs
.hwbreak_feature
= 1;
2336 else if (strcmp (p
, "fork-events+") == 0)
2338 /* GDB supports and wants fork events if possible. */
2339 if (target_supports_fork_events ())
2340 cs
.report_fork_events
= 1;
2342 else if (strcmp (p
, "vfork-events+") == 0)
2344 /* GDB supports and wants vfork events if possible. */
2345 if (target_supports_vfork_events ())
2346 cs
.report_vfork_events
= 1;
2348 else if (strcmp (p
, "exec-events+") == 0)
2350 /* GDB supports and wants exec events if possible. */
2351 if (target_supports_exec_events ())
2352 cs
.report_exec_events
= 1;
2354 else if (strcmp (p
, "vContSupported+") == 0)
2355 cs
.vCont_supported
= 1;
2356 else if (strcmp (p
, "QThreadEvents+") == 0)
2358 else if (strcmp (p
, "no-resumed+") == 0)
2360 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2362 report_no_resumed
= 1;
2366 /* Move the unknown features all together. */
2367 qsupported
[i
] = NULL
;
2368 qsupported
[unknown
] = p
;
2373 /* Give the target backend a chance to process the unknown
2375 target_process_qsupported (qsupported
, unknown
);
2377 for (i
= 0; i
< count
; i
++)
2378 free (qsupported
[i
]);
2383 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2384 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2385 "QEnvironmentReset+;QEnvironmentUnset+;"
2389 if (target_supports_catch_syscall ())
2390 strcat (own_buf
, ";QCatchSyscalls+");
2392 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2393 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2394 ";augmented-libraries-svr4-read+");
2397 /* We do not have any hook to indicate whether the non-SVR4 target
2398 backend supports qXfer:libraries:read, so always report it. */
2399 strcat (own_buf
, ";qXfer:libraries:read+");
2402 if (the_target
->read_auxv
!= NULL
)
2403 strcat (own_buf
, ";qXfer:auxv:read+");
2405 if (the_target
->qxfer_spu
!= NULL
)
2406 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2408 if (the_target
->qxfer_siginfo
!= NULL
)
2409 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2411 if (the_target
->read_loadmap
!= NULL
)
2412 strcat (own_buf
, ";qXfer:fdpic:read+");
2414 /* We always report qXfer:features:read, as targets may
2415 install XML files on a subsequent call to arch_setup.
2416 If we reported to GDB on startup that we don't support
2417 qXfer:feature:read at all, we will never be re-queried. */
2418 strcat (own_buf
, ";qXfer:features:read+");
2420 if (cs
.transport_is_reliable
)
2421 strcat (own_buf
, ";QStartNoAckMode+");
2423 if (the_target
->qxfer_osdata
!= NULL
)
2424 strcat (own_buf
, ";qXfer:osdata:read+");
2426 if (target_supports_multi_process ())
2427 strcat (own_buf
, ";multiprocess+");
2429 if (target_supports_fork_events ())
2430 strcat (own_buf
, ";fork-events+");
2432 if (target_supports_vfork_events ())
2433 strcat (own_buf
, ";vfork-events+");
2435 if (target_supports_exec_events ())
2436 strcat (own_buf
, ";exec-events+");
2438 if (target_supports_non_stop ())
2439 strcat (own_buf
, ";QNonStop+");
2441 if (target_supports_disable_randomization ())
2442 strcat (own_buf
, ";QDisableRandomization+");
2444 strcat (own_buf
, ";qXfer:threads:read+");
2446 if (target_supports_tracepoints ())
2448 strcat (own_buf
, ";ConditionalTracepoints+");
2449 strcat (own_buf
, ";TraceStateVariables+");
2450 strcat (own_buf
, ";TracepointSource+");
2451 strcat (own_buf
, ";DisconnectedTracing+");
2452 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2453 strcat (own_buf
, ";FastTracepoints+");
2454 strcat (own_buf
, ";StaticTracepoints+");
2455 strcat (own_buf
, ";InstallInTrace+");
2456 strcat (own_buf
, ";qXfer:statictrace:read+");
2457 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2458 strcat (own_buf
, ";EnableDisableTracepoints+");
2459 strcat (own_buf
, ";QTBuffer:size+");
2460 strcat (own_buf
, ";tracenz+");
2463 if (target_supports_hardware_single_step ()
2464 || target_supports_software_single_step () )
2466 strcat (own_buf
, ";ConditionalBreakpoints+");
2468 strcat (own_buf
, ";BreakpointCommands+");
2470 if (target_supports_agent ())
2471 strcat (own_buf
, ";QAgent+");
2473 supported_btrace_packets (own_buf
);
2475 if (target_supports_stopped_by_sw_breakpoint ())
2476 strcat (own_buf
, ";swbreak+");
2478 if (target_supports_stopped_by_hw_breakpoint ())
2479 strcat (own_buf
, ";hwbreak+");
2481 if (the_target
->pid_to_exec_file
!= NULL
)
2482 strcat (own_buf
, ";qXfer:exec-file:read+");
2484 strcat (own_buf
, ";vContSupported+");
2486 strcat (own_buf
, ";QThreadEvents+");
2488 strcat (own_buf
, ";no-resumed+");
2490 /* Reinitialize components as needed for the new connection. */
2491 hostio_handle_new_gdb_connection ();
2492 target_handle_new_gdb_connection ();
2497 /* Thread-local storage support. */
2498 if (the_target
->get_tls_address
!= NULL
2499 && startswith (own_buf
, "qGetTLSAddr:"))
2501 char *p
= own_buf
+ 12;
2502 CORE_ADDR parts
[2], address
= 0;
2504 ptid_t ptid
= null_ptid
;
2506 require_running_or_return (own_buf
);
2508 for (i
= 0; i
< 3; i
++)
2516 p2
= strchr (p
, ',');
2529 ptid
= read_ptid (p
, NULL
);
2531 decode_address (&parts
[i
- 1], p
, len
);
2535 if (p
!= NULL
|| i
< 3)
2539 struct thread_info
*thread
= find_thread_ptid (ptid
);
2544 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2550 strcpy (own_buf
, paddress(address
));
2555 write_enn (own_buf
);
2559 /* Otherwise, pretend we do not understand this packet. */
2562 /* Windows OS Thread Information Block address support. */
2563 if (the_target
->get_tib_address
!= NULL
2564 && startswith (own_buf
, "qGetTIBAddr:"))
2569 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2571 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2574 strcpy (own_buf
, paddress(tlb
));
2579 write_enn (own_buf
);
2585 /* Handle "monitor" commands. */
2586 if (startswith (own_buf
, "qRcmd,"))
2588 char *mon
= (char *) malloc (PBUFSIZ
);
2589 int len
= strlen (own_buf
+ 6);
2593 write_enn (own_buf
);
2598 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2600 write_enn (own_buf
);
2604 mon
[len
/ 2] = '\0';
2608 if (the_target
->handle_monitor_command
== NULL
2609 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2610 /* Default processing. */
2611 handle_monitor_command (mon
, own_buf
);
2617 if (startswith (own_buf
, "qSearch:memory:"))
2619 require_running_or_return (own_buf
);
2620 handle_search_memory (own_buf
, packet_len
);
2624 if (strcmp (own_buf
, "qAttached") == 0
2625 || startswith (own_buf
, "qAttached:"))
2627 struct process_info
*process
;
2629 if (own_buf
[sizeof ("qAttached") - 1])
2631 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2632 process
= find_process_pid (pid
);
2636 require_running_or_return (own_buf
);
2637 process
= current_process ();
2640 if (process
== NULL
)
2642 write_enn (own_buf
);
2646 strcpy (own_buf
, process
->attached
? "1" : "0");
2650 if (startswith (own_buf
, "qCRC:"))
2652 /* CRC check (compare-section). */
2656 unsigned long long crc
;
2658 require_running_or_return (own_buf
);
2659 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2660 if (*comma
++ != ',')
2662 write_enn (own_buf
);
2665 len
= strtoul (comma
, NULL
, 16);
2666 crc
= crc32 (base
, len
, 0xffffffff);
2667 /* Check for memory failure. */
2668 if (crc
== (unsigned long long) -1)
2670 write_enn (own_buf
);
2673 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2677 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2680 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2683 /* Otherwise we didn't know what packet it was. Say we didn't
2688 static void gdb_wants_all_threads_stopped (void);
2689 static void resume (struct thread_resume
*actions
, size_t n
);
2691 /* The callback that is passed to visit_actioned_threads. */
2692 typedef int (visit_actioned_threads_callback_ftype
)
2693 (const struct thread_resume
*, struct thread_info
*);
2695 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2696 true if CALLBACK returns true. Returns false if no matching thread
2697 is found or CALLBACK results false.
2698 Note: This function is itself a callback for find_thread. */
2701 visit_actioned_threads (thread_info
*thread
,
2702 const struct thread_resume
*actions
,
2704 visit_actioned_threads_callback_ftype
*callback
)
2706 for (size_t i
= 0; i
< num_actions
; i
++)
2708 const struct thread_resume
*action
= &actions
[i
];
2710 if (action
->thread
== minus_one_ptid
2711 || action
->thread
== thread
->id
2712 || ((action
->thread
.pid ()
2713 == thread
->id
.pid ())
2714 && action
->thread
.lwp () == -1))
2716 if ((*callback
) (action
, thread
))
2724 /* Callback for visit_actioned_threads. If the thread has a pending
2725 status to report, report it now. */
2728 handle_pending_status (const struct thread_resume
*resumption
,
2729 struct thread_info
*thread
)
2731 client_state
&cs
= get_client_state ();
2732 if (thread
->status_pending_p
)
2734 thread
->status_pending_p
= 0;
2736 cs
.last_status
= thread
->last_status
;
2737 cs
.last_ptid
= thread
->id
;
2738 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2744 /* Parse vCont packets. */
2746 handle_v_cont (char *own_buf
)
2750 struct thread_resume
*resume_info
;
2751 struct thread_resume default_action
{ null_ptid
};
2753 /* Count the number of semicolons in the packet. There should be one
2754 for every action. */
2760 p
= strchr (p
, ';');
2763 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2764 if (resume_info
== NULL
)
2772 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2774 if (p
[0] == 's' || p
[0] == 'S')
2775 resume_info
[i
].kind
= resume_step
;
2776 else if (p
[0] == 'r')
2777 resume_info
[i
].kind
= resume_step
;
2778 else if (p
[0] == 'c' || p
[0] == 'C')
2779 resume_info
[i
].kind
= resume_continue
;
2780 else if (p
[0] == 't')
2781 resume_info
[i
].kind
= resume_stop
;
2785 if (p
[0] == 'S' || p
[0] == 'C')
2788 int sig
= strtol (p
+ 1, &q
, 16);
2793 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2795 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2797 else if (p
[0] == 'r')
2801 p
= unpack_varlen_hex (p
+ 1, &addr
);
2802 resume_info
[i
].step_range_start
= addr
;
2807 p
= unpack_varlen_hex (p
+ 1, &addr
);
2808 resume_info
[i
].step_range_end
= addr
;
2817 resume_info
[i
].thread
= minus_one_ptid
;
2818 default_action
= resume_info
[i
];
2820 /* Note: we don't increment i here, we'll overwrite this entry
2821 the next time through. */
2823 else if (p
[0] == ':')
2826 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2831 if (p
[0] != ';' && p
[0] != 0)
2834 resume_info
[i
].thread
= ptid
;
2841 resume_info
[i
] = default_action
;
2843 resume (resume_info
, n
);
2848 write_enn (own_buf
);
2853 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2856 resume (struct thread_resume
*actions
, size_t num_actions
)
2858 client_state
&cs
= get_client_state ();
2861 /* Check if among the threads that GDB wants actioned, there's
2862 one with a pending status to report. If so, skip actually
2863 resuming/stopping and report the pending event
2866 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2868 return visit_actioned_threads (thread
, actions
, num_actions
,
2869 handle_pending_status
);
2872 if (thread_with_status
!= NULL
)
2878 (*the_target
->resume
) (actions
, num_actions
);
2881 write_ok (cs
.own_buf
);
2884 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2886 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2887 && !report_no_resumed
)
2889 /* The client does not support this stop reply. At least
2891 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2892 disable_async_io ();
2896 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2897 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2898 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2899 current_thread
->last_status
= cs
.last_status
;
2901 /* From the client's perspective, all-stop mode always stops all
2902 threads implicitly (and the target backend has already done
2903 so by now). Tag all threads as "want-stopped", so we don't
2904 resume them implicitly without the client telling us to. */
2905 gdb_wants_all_threads_stopped ();
2906 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2907 disable_async_io ();
2909 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2910 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2911 target_mourn_inferior (cs
.last_ptid
);
2915 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2917 handle_v_attach (char *own_buf
)
2919 client_state
&cs
= get_client_state ();
2922 pid
= strtol (own_buf
+ 8, NULL
, 16);
2923 if (pid
!= 0 && attach_inferior (pid
) == 0)
2925 /* Don't report shared library events after attaching, even if
2926 some libraries are preloaded. GDB will always poll the
2927 library list. Avoids the "stopped by shared library event"
2928 notice on the GDB side. */
2933 /* In non-stop, we don't send a resume reply. Stop events
2934 will follow up using the normal notification
2939 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2945 write_enn (own_buf
);
2950 /* Run a new program. Return 1 if successful, 0 if failure. */
2952 handle_v_run (char *own_buf
)
2954 client_state
&cs
= get_client_state ();
2956 std::vector
<char *> new_argv
;
2957 char *new_program_name
= NULL
;
2961 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2967 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2969 next_p
= strchr (p
, ';');
2971 next_p
= p
+ strlen (p
);
2973 if (i
== 0 && p
== next_p
)
2975 /* No program specified. */
2976 new_program_name
= NULL
;
2978 else if (p
== next_p
)
2980 /* Empty argument. */
2981 new_argv
.push_back (xstrdup ("''"));
2985 size_t len
= (next_p
- p
) / 2;
2986 /* ARG is the unquoted argument received via the RSP. */
2987 char *arg
= (char *) xmalloc (len
+ 1);
2988 /* FULL_ARGS will contain the quoted version of ARG. */
2989 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2990 /* These are pointers used to navigate the strings above. */
2991 char *tmp_arg
= arg
;
2992 char *tmp_full_arg
= full_arg
;
2995 hex2bin (p
, (gdb_byte
*) arg
, len
);
2998 while (*tmp_arg
!= '\0')
3004 *tmp_full_arg
= '\'';
3010 /* Quote single quote. */
3011 *tmp_full_arg
= '\\';
3019 *tmp_full_arg
= *tmp_arg
;
3025 *tmp_full_arg
++ = '\'';
3027 /* Finish FULL_ARG and push it into the vector containing
3029 *tmp_full_arg
= '\0';
3031 new_program_name
= full_arg
;
3033 new_argv
.push_back (full_arg
);
3039 new_argv
.push_back (NULL
);
3041 if (new_program_name
== NULL
)
3043 /* GDB didn't specify a program to run. Use the program from the
3044 last run with the new argument list. */
3045 if (program_path
.get () == NULL
)
3047 write_enn (own_buf
);
3048 free_vector_argv (new_argv
);
3053 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3055 /* Free the old argv and install the new one. */
3056 free_vector_argv (program_args
);
3057 program_args
= new_argv
;
3059 create_inferior (program_path
.get (), program_args
);
3061 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3063 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3065 /* In non-stop, sending a resume reply doesn't set the general
3066 thread, but GDB assumes a vRun sets it (this is so GDB can
3067 query which is the main thread of the new inferior. */
3069 cs
.general_thread
= cs
.last_ptid
;
3075 write_enn (own_buf
);
3080 /* Kill process. Return 1 if successful, 0 if failure. */
3082 handle_v_kill (char *own_buf
)
3084 client_state
&cs
= get_client_state ();
3086 char *p
= &own_buf
[6];
3087 if (cs
.multi_process
)
3088 pid
= strtol (p
, NULL
, 16);
3092 process_info
*proc
= find_process_pid (pid
);
3094 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3096 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3097 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3098 cs
.last_ptid
= ptid_t (pid
);
3099 discard_queued_stop_replies (cs
.last_ptid
);
3105 write_enn (own_buf
);
3110 /* Handle all of the extended 'v' packets. */
3112 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3114 client_state
&cs
= get_client_state ();
3115 if (!disable_packet_vCont
)
3117 if (strcmp (own_buf
, "vCtrlC") == 0)
3119 (*the_target
->request_interrupt
) ();
3124 if (startswith (own_buf
, "vCont;"))
3126 handle_v_cont (own_buf
);
3130 if (startswith (own_buf
, "vCont?"))
3132 strcpy (own_buf
, "vCont;c;C;t");
3134 if (target_supports_hardware_single_step ()
3135 || target_supports_software_single_step ()
3136 || !cs
.vCont_supported
)
3138 /* If target supports single step either by hardware or by
3139 software, add actions s and S to the list of supported
3140 actions. On the other hand, if GDB doesn't request the
3141 supported vCont actions in qSupported packet, add s and
3142 S to the list too. */
3143 own_buf
= own_buf
+ strlen (own_buf
);
3144 strcpy (own_buf
, ";s;S");
3147 if (target_supports_range_stepping ())
3149 own_buf
= own_buf
+ strlen (own_buf
);
3150 strcpy (own_buf
, ";r");
3156 if (startswith (own_buf
, "vFile:")
3157 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3160 if (startswith (own_buf
, "vAttach;"))
3162 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3164 fprintf (stderr
, "Already debugging a process\n");
3165 write_enn (own_buf
);
3168 handle_v_attach (own_buf
);
3172 if (startswith (own_buf
, "vRun;"))
3174 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3176 fprintf (stderr
, "Already debugging a process\n");
3177 write_enn (own_buf
);
3180 handle_v_run (own_buf
);
3184 if (startswith (own_buf
, "vKill;"))
3186 if (!target_running ())
3188 fprintf (stderr
, "No process to kill\n");
3189 write_enn (own_buf
);
3192 handle_v_kill (own_buf
);
3196 if (handle_notif_ack (own_buf
, packet_len
))
3199 /* Otherwise we didn't know what packet it was. Say we didn't
3205 /* Resume thread and wait for another event. In non-stop mode,
3206 don't really wait here, but return immediatelly to the event
3209 myresume (char *own_buf
, int step
, int sig
)
3211 client_state
&cs
= get_client_state ();
3212 struct thread_resume resume_info
[2];
3214 int valid_cont_thread
;
3216 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3217 && cs
.cont_thread
!= minus_one_ptid
);
3219 if (step
|| sig
|| valid_cont_thread
)
3221 resume_info
[0].thread
= current_ptid
;
3223 resume_info
[0].kind
= resume_step
;
3225 resume_info
[0].kind
= resume_continue
;
3226 resume_info
[0].sig
= sig
;
3230 if (!valid_cont_thread
)
3232 resume_info
[n
].thread
= minus_one_ptid
;
3233 resume_info
[n
].kind
= resume_continue
;
3234 resume_info
[n
].sig
= 0;
3238 resume (resume_info
, n
);
3241 /* Callback for for_each_thread. Make a new stop reply for each
3245 queue_stop_reply_callback (thread_info
*thread
)
3247 /* For now, assume targets that don't have this callback also don't
3248 manage the thread's last_status field. */
3249 if (the_target
->thread_stopped
== NULL
)
3251 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3253 new_notif
->ptid
= thread
->id
;
3254 new_notif
->status
= thread
->last_status
;
3255 /* Pass the last stop reply back to GDB, but don't notify
3257 notif_event_enque (¬if_stop
,
3258 (struct notif_event
*) new_notif
);
3262 if (thread_stopped (thread
))
3266 std::string status_string
3267 = target_waitstatus_to_string (&thread
->last_status
);
3269 debug_printf ("Reporting thread %s as already stopped with %s\n",
3270 target_pid_to_str (thread
->id
),
3271 status_string
.c_str ());
3274 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3276 /* Pass the last stop reply back to GDB, but don't notify
3278 queue_stop_reply (thread
->id
, &thread
->last_status
);
3283 /* Set this inferior threads's state as "want-stopped". We won't
3284 resume this thread until the client gives us another action for
3288 gdb_wants_thread_stopped (thread_info
*thread
)
3290 thread
->last_resume_kind
= resume_stop
;
3292 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3294 /* Most threads are stopped implicitly (all-stop); tag that with
3296 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3297 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3301 /* Set all threads' states as "want-stopped". */
3304 gdb_wants_all_threads_stopped (void)
3306 for_each_thread (gdb_wants_thread_stopped
);
3309 /* Callback for for_each_thread. If the thread is stopped with an
3310 interesting event, mark it as having a pending event. */
3313 set_pending_status_callback (thread_info
*thread
)
3315 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3316 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3317 /* A breakpoint, watchpoint or finished step from a previous
3318 GDB run isn't considered interesting for a new GDB run.
3319 If we left those pending, the new GDB could consider them
3320 random SIGTRAPs. This leaves out real async traps. We'd
3321 have to peek into the (target-specific) siginfo to
3322 distinguish those. */
3323 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3324 thread
->status_pending_p
= 1;
3327 /* Status handler for the '?' packet. */
3330 handle_status (char *own_buf
)
3332 client_state
&cs
= get_client_state ();
3334 /* GDB is connected, don't forward events to the target anymore. */
3335 for_each_process ([] (process_info
*process
) {
3336 process
->gdb_detached
= 0;
3339 /* In non-stop mode, we must send a stop reply for each stopped
3340 thread. In all-stop mode, just send one for the first stopped
3345 for_each_thread (queue_stop_reply_callback
);
3347 /* The first is sent immediatly. OK is sent if there is no
3348 stopped thread, which is the same handling of the vStopped
3349 packet (by design). */
3350 notif_write_event (¬if_stop
, cs
.own_buf
);
3354 thread_info
*thread
= NULL
;
3357 stabilize_threads ();
3358 gdb_wants_all_threads_stopped ();
3360 /* We can only report one status, but we might be coming out of
3361 non-stop -- if more than one thread is stopped with
3362 interesting events, leave events for the threads we're not
3363 reporting now pending. They'll be reported the next time the
3364 threads are resumed. Start by marking all interesting events
3366 for_each_thread (set_pending_status_callback
);
3368 /* Prefer the last thread that reported an event to GDB (even if
3369 that was a GDB_SIGNAL_TRAP). */
3370 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3371 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3372 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3373 thread
= find_thread_ptid (cs
.last_ptid
);
3375 /* If the last event thread is not found for some reason, look
3376 for some other thread that might have an event to report. */
3378 thread
= find_thread ([] (thread_info
*thr_arg
)
3380 return thr_arg
->status_pending_p
;
3383 /* If we're still out of luck, simply pick the first thread in
3386 thread
= get_first_thread ();
3390 struct thread_info
*tp
= (struct thread_info
*) thread
;
3392 /* We're reporting this event, so it's no longer
3394 tp
->status_pending_p
= 0;
3396 /* GDB assumes the current thread is the thread we're
3397 reporting the status for. */
3398 cs
.general_thread
= thread
->id
;
3399 set_desired_thread ();
3401 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3402 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3405 strcpy (own_buf
, "W00");
3410 gdbserver_version (void)
3412 printf ("GNU gdbserver %s%s\n"
3413 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3414 "gdbserver is free software, covered by the "
3415 "GNU General Public License.\n"
3416 "This gdbserver was configured as \"%s\"\n",
3417 PKGVERSION
, version
, host_name
);
3421 gdbserver_usage (FILE *stream
)
3423 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3424 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3425 "\tgdbserver [OPTIONS] --multi COMM\n"
3427 "COMM may either be a tty device (for serial debugging),\n"
3428 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3429 "stdin/stdout of gdbserver.\n"
3430 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3431 "PID is the process ID to attach to, when --attach is specified.\n"
3433 "Operating modes:\n"
3435 " --attach Attach to running process PID.\n"
3436 " --multi Start server without a specific program, and\n"
3437 " only quit when explicitly commanded.\n"
3438 " --once Exit after the first connection has closed.\n"
3439 " --help Print this message and then exit.\n"
3440 " --version Display version information and exit.\n"
3444 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3445 " --disable-randomization\n"
3446 " Run PROG with address space randomization disabled.\n"
3447 " --no-disable-randomization\n"
3448 " Don't disable address space randomization when\n"
3450 " --startup-with-shell\n"
3451 " Start PROG using a shell. I.e., execs a shell that\n"
3452 " then execs PROG. (default)\n"
3453 " --no-startup-with-shell\n"
3454 " Exec PROG directly instead of using a shell.\n"
3455 " Disables argument globbing and variable substitution\n"
3456 " on UNIX-like systems.\n"
3460 " --debug Enable general debugging output.\n"
3461 " --debug-format=OPT1[,OPT2,...]\n"
3462 " Specify extra content in debugging output.\n"
3467 " --remote-debug Enable remote protocol debugging output.\n"
3468 " --disable-packet=OPT1[,OPT2,...]\n"
3469 " Disable support for RSP packets or features.\n"
3471 " vCont, Tthread, qC, qfThreadInfo and \n"
3472 " threads (disable all threading packets).\n"
3474 "For more information, consult the GDB manual (available as on-line \n"
3475 "info or a printed manual).\n");
3476 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3477 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3481 gdbserver_show_disableable (FILE *stream
)
3483 fprintf (stream
, "Disableable packets:\n"
3484 " vCont \tAll vCont packets\n"
3485 " qC \tQuerying the current thread\n"
3486 " qfThreadInfo\tThread listing\n"
3487 " Tthread \tPassing the thread specifier in the "
3488 "T stop reply packet\n"
3489 " threads \tAll of the above\n");
3493 kill_inferior_callback (process_info
*process
)
3495 kill_inferior (process
);
3496 discard_queued_stop_replies (ptid_t (process
->pid
));
3499 /* Call this when exiting gdbserver with possible inferiors that need
3500 to be killed or detached from. */
3503 detach_or_kill_for_exit (void)
3505 /* First print a list of the inferiors we will be killing/detaching.
3506 This is to assist the user, for example, in case the inferior unexpectedly
3507 dies after we exit: did we screw up or did the inferior exit on its own?
3508 Having this info will save some head-scratching. */
3510 if (have_started_inferiors_p ())
3512 fprintf (stderr
, "Killing process(es):");
3514 for_each_process ([] (process_info
*process
) {
3515 if (!process
->attached
)
3516 fprintf (stderr
, " %d", process
->pid
);
3519 fprintf (stderr
, "\n");
3521 if (have_attached_inferiors_p ())
3523 fprintf (stderr
, "Detaching process(es):");
3525 for_each_process ([] (process_info
*process
) {
3526 if (process
->attached
)
3527 fprintf (stderr
, " %d", process
->pid
);
3530 fprintf (stderr
, "\n");
3533 /* Now we can kill or detach the inferiors. */
3534 for_each_process ([] (process_info
*process
) {
3535 int pid
= process
->pid
;
3537 if (process
->attached
)
3538 detach_inferior (process
);
3540 kill_inferior (process
);
3542 discard_queued_stop_replies (ptid_t (pid
));
3546 /* Value that will be passed to exit(3) when gdbserver exits. */
3547 static int exit_code
;
3549 /* Wrapper for detach_or_kill_for_exit that catches and prints
3553 detach_or_kill_for_exit_cleanup ()
3557 detach_or_kill_for_exit ();
3559 CATCH (exception
, RETURN_MASK_ALL
)
3562 fprintf (stderr
, "Detach or kill failed: %s\n",
3569 /* Main function. This is called by the real "main" function,
3570 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3572 static void ATTRIBUTE_NORETURN
3573 captured_main (int argc
, char *argv
[])
3578 const char *port
= NULL
;
3579 char **next_arg
= &argv
[1];
3580 volatile int multi_mode
= 0;
3581 volatile int attach
= 0;
3583 bool selftest
= false;
3585 const char *selftest_filter
= NULL
;
3588 current_directory
= getcwd (NULL
, 0);
3589 client_state
&cs
= get_client_state ();
3591 if (current_directory
== NULL
)
3593 error (_("Could not find current working directory: %s"),
3594 safe_strerror (errno
));
3597 while (*next_arg
!= NULL
&& **next_arg
== '-')
3599 if (strcmp (*next_arg
, "--version") == 0)
3601 gdbserver_version ();
3604 else if (strcmp (*next_arg
, "--help") == 0)
3606 gdbserver_usage (stdout
);
3609 else if (strcmp (*next_arg
, "--attach") == 0)
3611 else if (strcmp (*next_arg
, "--multi") == 0)
3613 else if (strcmp (*next_arg
, "--wrapper") == 0)
3620 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3622 wrapper_argv
+= *next_arg
;
3623 wrapper_argv
+= ' ';
3627 if (!wrapper_argv
.empty ())
3629 /* Erase the last whitespace. */
3630 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3633 if (next_arg
== tmp
|| *next_arg
== NULL
)
3635 gdbserver_usage (stderr
);
3639 /* Consume the "--". */
3642 else if (strcmp (*next_arg
, "--debug") == 0)
3644 else if (startswith (*next_arg
, "--debug-format="))
3646 std::string error_msg
3647 = parse_debug_format_options ((*next_arg
)
3648 + sizeof ("--debug-format=") - 1, 0);
3650 if (!error_msg
.empty ())
3652 fprintf (stderr
, "%s", error_msg
.c_str ());
3656 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3658 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3660 gdbserver_show_disableable (stdout
);
3663 else if (startswith (*next_arg
, "--disable-packet="))
3665 char *packets
, *tok
;
3667 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3668 for (tok
= strtok (packets
, ",");
3670 tok
= strtok (NULL
, ","))
3672 if (strcmp ("vCont", tok
) == 0)
3673 disable_packet_vCont
= 1;
3674 else if (strcmp ("Tthread", tok
) == 0)
3675 disable_packet_Tthread
= 1;
3676 else if (strcmp ("qC", tok
) == 0)
3677 disable_packet_qC
= 1;
3678 else if (strcmp ("qfThreadInfo", tok
) == 0)
3679 disable_packet_qfThreadInfo
= 1;
3680 else if (strcmp ("threads", tok
) == 0)
3682 disable_packet_vCont
= 1;
3683 disable_packet_Tthread
= 1;
3684 disable_packet_qC
= 1;
3685 disable_packet_qfThreadInfo
= 1;
3689 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3691 gdbserver_show_disableable (stderr
);
3696 else if (strcmp (*next_arg
, "-") == 0)
3698 /* "-" specifies a stdio connection and is a form of port
3700 port
= STDIO_CONNECTION_NAME
;
3704 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3705 cs
.disable_randomization
= 1;
3706 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3707 cs
.disable_randomization
= 0;
3708 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3709 startup_with_shell
= true;
3710 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3711 startup_with_shell
= false;
3712 else if (strcmp (*next_arg
, "--once") == 0)
3714 else if (strcmp (*next_arg
, "--selftest") == 0)
3716 else if (startswith (*next_arg
, "--selftest="))
3720 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3725 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3738 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3741 gdbserver_usage (stderr
);
3745 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3746 opened by remote_prepare. */
3749 save_original_signals_state (false);
3751 /* We need to know whether the remote connection is stdio before
3752 starting the inferior. Inferiors created in this scenario have
3753 stdin,stdout redirected. So do this here before we call
3756 remote_prepare (port
);
3761 /* --attach used to come after PORT, so allow it there for
3763 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3770 && (*next_arg
== NULL
3771 || (*next_arg
)[0] == '\0'
3772 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3774 || next_arg
[1] != NULL
))
3779 gdbserver_usage (stderr
);
3783 /* Gather information about the environment. */
3784 our_environ
= gdb_environ::from_host_environ ();
3786 initialize_async_io ();
3788 have_job_control ();
3789 initialize_event_loop ();
3790 if (target_supports_tracepoints ())
3791 initialize_tracepoint ();
3792 initialize_notif ();
3794 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3799 selftests::run_tests (selftest_filter
);
3801 printf (_("Selftests have been disabled for this build.\n"));
3803 throw_quit ("Quit");
3806 if (pid
== 0 && *next_arg
!= NULL
)
3810 n
= argc
- (next_arg
- argv
);
3811 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3812 for (i
= 1; i
< n
; i
++)
3813 program_args
.push_back (xstrdup (next_arg
[i
]));
3814 program_args
.push_back (NULL
);
3816 /* Wait till we are at first instruction in program. */
3817 create_inferior (program_path
.get (), program_args
);
3819 /* We are now (hopefully) stopped at the first instruction of
3820 the target process. This assumes that the target process was
3821 successfully created. */
3825 if (attach_inferior (pid
) == -1)
3826 error ("Attaching not supported on this target");
3828 /* Otherwise succeeded. */
3832 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3833 cs
.last_status
.value
.integer
= 0;
3834 cs
.last_ptid
= minus_one_ptid
;
3837 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3839 /* Don't report shared library events on the initial connection,
3840 even if some libraries are preloaded. Avoids the "stopped by
3841 shared library event" notice on gdb side. */
3844 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3845 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3850 if (!was_running
&& !multi_mode
)
3851 error ("No program to debug");
3856 cs
.multi_process
= 0;
3857 cs
.report_fork_events
= 0;
3858 cs
.report_vfork_events
= 0;
3859 cs
.report_exec_events
= 0;
3860 /* Be sure we're out of tfind mode. */
3861 cs
.current_traceframe
= -1;
3862 cs
.cont_thread
= null_ptid
;
3863 cs
.swbreak_feature
= 0;
3864 cs
.hwbreak_feature
= 0;
3865 cs
.vCont_supported
= 0;
3871 /* Wait for events. This will return when all event sources
3872 are removed from the event loop. */
3873 start_event_loop ();
3875 /* If an exit was requested (using the "monitor exit"
3876 command), terminate now. */
3878 throw_quit ("Quit");
3880 /* The only other way to get here is for getpkt to fail:
3882 - If --once was specified, we're done.
3884 - If not in extended-remote mode, and we're no longer
3885 debugging anything, simply exit: GDB has disconnected
3886 after processing the last process exit.
3888 - Otherwise, close the connection and reopen it at the
3890 if (run_once
|| (!extended_protocol
&& !target_running ()))
3891 throw_quit ("Quit");
3894 "Remote side has terminated connection. "
3895 "GDBserver will reopen the connection.\n");
3897 /* Get rid of any pending statuses. An eventual reconnection
3898 (by the same GDB instance or another) will refresh all its
3899 state from scratch. */
3900 discard_queued_stop_replies (minus_one_ptid
);
3901 for_each_thread ([] (thread_info
*thread
)
3903 thread
->status_pending_p
= 0;
3908 if (disconnected_tracing
)
3910 /* Try to enable non-stop/async mode, so we we can
3911 both wait for an async socket accept, and handle
3912 async target events simultaneously. There's also
3913 no point either in having the target always stop
3914 all threads, when we're going to pass signals
3915 down without informing GDB. */
3918 if (start_non_stop (1))
3921 /* Detaching implicitly resumes all threads;
3922 simply disconnecting does not. */
3928 "Disconnected tracing disabled; "
3929 "stopping trace run.\n");
3934 CATCH (exception
, RETURN_MASK_ERROR
)
3937 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3939 if (response_needed
)
3941 write_enn (cs
.own_buf
);
3942 putpkt (cs
.own_buf
);
3946 throw_quit ("Quit");
3952 /* Main function. */
3955 main (int argc
, char *argv
[])
3960 captured_main (argc
, argv
);
3962 CATCH (exception
, RETURN_MASK_ALL
)
3964 if (exception
.reason
== RETURN_ERROR
)
3967 fprintf (stderr
, "%s\n", exception
.what ());
3968 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
= 0;
4048 packet_len
= getpkt (cs
.own_buf
);
4049 if (packet_len
<= 0)
4052 /* Force an event loop break. */
4055 response_needed
= 1;
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
= 1;
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
= 0;
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
= 0;
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 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
= 0;
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)
4405 /* Be sure to not change the selected thread behind GDB's back.
4406 Important in the non-stop mode asynchronous protocol. */
4407 set_desired_thread ();
4412 /* Push a stop notification on the notification queue. */
4415 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4417 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4419 vstop_notif
->status
= *status
;
4420 vstop_notif
->ptid
= ptid
;
4421 /* Push Stop notification. */
4422 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4425 /* Event-loop callback for target events. */
4428 handle_target_event (int err
, gdb_client_data client_data
)
4430 client_state
&cs
= get_client_state ();
4432 debug_printf ("handling possible target event\n");
4434 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4437 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4439 if (gdb_connected () && report_no_resumed
)
4440 push_stop_notification (null_ptid
, &cs
.last_status
);
4442 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4444 int pid
= cs
.last_ptid
.pid ();
4445 struct process_info
*process
= find_process_pid (pid
);
4446 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4448 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4449 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4451 mark_breakpoints_out (process
);
4452 target_mourn_inferior (cs
.last_ptid
);
4454 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4458 /* We're reporting this thread as stopped. Update its
4459 "want-stopped" state to what the client wants, until it
4460 gets a new resume action. */
4461 current_thread
->last_resume_kind
= resume_stop
;
4462 current_thread
->last_status
= cs
.last_status
;
4467 if (!target_running ())
4469 /* The last process exited. We're done. */
4473 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4474 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4475 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4479 /* A thread stopped with a signal, but gdb isn't
4480 connected to handle it. Pass it down to the
4481 inferior, as if it wasn't being traced. */
4482 enum gdb_signal signal
;
4485 debug_printf ("GDB not connected; forwarding event %d for"
4487 (int) cs
.last_status
.kind
,
4488 target_pid_to_str (cs
.last_ptid
));
4490 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4491 signal
= cs
.last_status
.value
.sig
;
4493 signal
= GDB_SIGNAL_0
;
4494 target_continue (cs
.last_ptid
, signal
);
4498 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4501 /* Be sure to not change the selected thread behind GDB's back.
4502 Important in the non-stop mode asynchronous protocol. */
4503 set_desired_thread ();
4516 } // namespace selftests
4517 #endif /* GDB_SELF_TEST */