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 /* Decode a qXfer read request. Return 0 if everything looks OK,
335 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
337 /* After the read marker and annex, qXfer looks like a
338 traditional 'm' packet. */
339 decode_m_packet (buf
, ofs
, len
);
345 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
347 /* Extract and NUL-terminate the object. */
349 while (*buf
&& *buf
!= ':')
355 /* Extract and NUL-terminate the read/write action. */
357 while (*buf
&& *buf
!= ':')
363 /* Extract and NUL-terminate the annex. */
365 while (*buf
&& *buf
!= ':')
375 /* Write the response to a successful qXfer read. Returns the
376 length of the (binary) data stored in BUF, corresponding
377 to as much of DATA/LEN as we could fit. IS_MORE controls
378 the first character of the response. */
380 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
389 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
390 &out_len
, PBUFSIZ
- 2) + 1;
393 /* Handle btrace enabling in BTS format. */
396 handle_btrace_enable_bts (struct thread_info
*thread
)
398 if (thread
->btrace
!= NULL
)
399 error (_("Btrace already enabled."));
401 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
402 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
405 /* Handle btrace enabling in Intel Processor Trace format. */
408 handle_btrace_enable_pt (struct thread_info
*thread
)
410 if (thread
->btrace
!= NULL
)
411 error (_("Btrace already enabled."));
413 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
414 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
417 /* Handle btrace disabling. */
420 handle_btrace_disable (struct thread_info
*thread
)
423 if (thread
->btrace
== NULL
)
424 error (_("Branch tracing not enabled."));
426 if (target_disable_btrace (thread
->btrace
) != 0)
427 error (_("Could not disable branch tracing."));
429 thread
->btrace
= NULL
;
432 /* Handle the "Qbtrace" packet. */
435 handle_btrace_general_set (char *own_buf
)
437 client_state
&cs
= get_client_state ();
438 struct thread_info
*thread
;
441 if (!startswith (own_buf
, "Qbtrace:"))
444 op
= own_buf
+ strlen ("Qbtrace:");
446 if (cs
.general_thread
== null_ptid
447 || cs
.general_thread
== minus_one_ptid
)
449 strcpy (own_buf
, "E.Must select a single thread.");
453 thread
= find_thread_ptid (cs
.general_thread
);
456 strcpy (own_buf
, "E.No such thread.");
462 if (strcmp (op
, "bts") == 0)
463 handle_btrace_enable_bts (thread
);
464 else if (strcmp (op
, "pt") == 0)
465 handle_btrace_enable_pt (thread
);
466 else if (strcmp (op
, "off") == 0)
467 handle_btrace_disable (thread
);
469 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
473 catch (const gdb_exception_error
&exception
)
475 sprintf (own_buf
, "E.%s", exception
.what ());
481 /* Handle the "Qbtrace-conf" packet. */
484 handle_btrace_conf_general_set (char *own_buf
)
486 client_state
&cs
= get_client_state ();
487 struct thread_info
*thread
;
490 if (!startswith (own_buf
, "Qbtrace-conf:"))
493 op
= own_buf
+ strlen ("Qbtrace-conf:");
495 if (cs
.general_thread
== null_ptid
496 || cs
.general_thread
== minus_one_ptid
)
498 strcpy (own_buf
, "E.Must select a single thread.");
502 thread
= find_thread_ptid (cs
.general_thread
);
505 strcpy (own_buf
, "E.No such thread.");
509 if (startswith (op
, "bts:size="))
515 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
516 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
518 strcpy (own_buf
, "E.Bad size value.");
522 current_btrace_conf
.bts
.size
= (unsigned int) size
;
524 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
530 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
531 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
533 strcpy (own_buf
, "E.Bad size value.");
537 current_btrace_conf
.pt
.size
= (unsigned int) size
;
541 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
549 /* Handle all of the extended 'Q' packets. */
552 handle_general_set (char *own_buf
)
554 client_state
&cs
= get_client_state ();
555 if (startswith (own_buf
, "QPassSignals:"))
557 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
558 const char *p
= own_buf
+ strlen ("QPassSignals:");
561 p
= decode_address_to_semicolon (&cursig
, p
);
562 for (i
= 0; i
< numsigs
; i
++)
566 cs
.pass_signals
[i
] = 1;
568 /* Keep looping, to clear the remaining signals. */
571 p
= decode_address_to_semicolon (&cursig
, p
);
574 cs
.pass_signals
[i
] = 0;
576 strcpy (own_buf
, "OK");
580 if (startswith (own_buf
, "QProgramSignals:"))
582 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
583 const char *p
= own_buf
+ strlen ("QProgramSignals:");
586 cs
.program_signals_p
= 1;
588 p
= decode_address_to_semicolon (&cursig
, p
);
589 for (i
= 0; i
< numsigs
; i
++)
593 cs
.program_signals
[i
] = 1;
595 /* Keep looping, to clear the remaining signals. */
598 p
= decode_address_to_semicolon (&cursig
, p
);
601 cs
.program_signals
[i
] = 0;
603 strcpy (own_buf
, "OK");
607 if (startswith (own_buf
, "QCatchSyscalls:"))
609 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
612 struct process_info
*process
;
614 if (!target_running () || !target_supports_catch_syscall ())
620 if (strcmp (p
, "0") == 0)
622 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
626 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
632 process
= current_process ();
633 process
->syscalls_to_catch
.clear ();
643 p
= decode_address_to_semicolon (&sysno
, p
);
644 process
->syscalls_to_catch
.push_back (sysno
);
648 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
655 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
657 our_environ
= gdb_environ::from_host_environ ();
663 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
665 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
666 /* The final form of the environment variable. FINAL_VAR will
667 hold the 'VAR=VALUE' format. */
668 std::string final_var
= hex2str (p
);
669 std::string var_name
, var_value
;
673 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
674 debug_printf (_("[Environment variable to be set: '%s']\n"),
679 size_t pos
= final_var
.find ('=');
680 if (pos
== std::string::npos
)
682 warning (_("Unexpected format for environment variable: '%s'"),
688 var_name
= final_var
.substr (0, pos
);
689 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
691 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
697 if (startswith (own_buf
, "QEnvironmentUnset:"))
699 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
700 std::string varname
= hex2str (p
);
704 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
705 debug_printf (_("[Environment variable to be unset: '%s']\n"),
710 our_environ
.unset (varname
.c_str ());
716 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
720 debug_printf ("[noack mode enabled]\n");
729 if (startswith (own_buf
, "QNonStop:"))
731 char *mode
= own_buf
+ 9;
735 if (strcmp (mode
, "0") == 0)
737 else if (strcmp (mode
, "1") == 0)
741 /* We don't know what this mode is, so complain to
743 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
749 req_str
= req
? "non-stop" : "all-stop";
750 if (start_non_stop (req
) != 0)
752 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
760 debug_printf ("[%s mode enabled]\n", req_str
);
766 if (startswith (own_buf
, "QDisableRandomization:"))
768 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
771 unpack_varlen_hex (packet
, &setting
);
772 cs
.disable_randomization
= setting
;
776 debug_printf (cs
.disable_randomization
777 ? "[address space randomization disabled]\n"
778 : "[address space randomization enabled]\n");
785 if (target_supports_tracepoints ()
786 && handle_tracepoint_general_set (own_buf
))
789 if (startswith (own_buf
, "QAgent:"))
791 char *mode
= own_buf
+ strlen ("QAgent:");
794 if (strcmp (mode
, "0") == 0)
796 else if (strcmp (mode
, "1") == 0)
800 /* We don't know what this value is, so complain to GDB. */
801 sprintf (own_buf
, "E.Unknown QAgent value");
805 /* Update the flag. */
808 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
813 if (handle_btrace_general_set (own_buf
))
816 if (handle_btrace_conf_general_set (own_buf
))
819 if (startswith (own_buf
, "QThreadEvents:"))
821 char *mode
= own_buf
+ strlen ("QThreadEvents:");
822 enum tribool req
= TRIBOOL_UNKNOWN
;
824 if (strcmp (mode
, "0") == 0)
826 else if (strcmp (mode
, "1") == 0)
830 /* We don't know what this mode is, so complain to GDB. */
831 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
836 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
840 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
842 debug_printf ("[thread events are now %s]\n", req_str
);
849 if (startswith (own_buf
, "QStartupWithShell:"))
851 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
853 if (strcmp (value
, "1") == 0)
854 startup_with_shell
= true;
855 else if (strcmp (value
, "0") == 0)
856 startup_with_shell
= false;
860 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
867 debug_printf (_("[Inferior will %s started with shell]"),
868 startup_with_shell
? "be" : "not be");
874 if (startswith (own_buf
, "QSetWorkingDir:"))
876 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
880 std::string path
= hex2str (p
);
882 set_inferior_cwd (path
.c_str ());
885 debug_printf (_("[Set the inferior's current directory to %s]\n"),
890 /* An empty argument means that we should clear out any
891 previously set cwd for the inferior. */
892 set_inferior_cwd (NULL
);
896 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
903 /* Otherwise we didn't know what packet it was. Say we didn't
909 get_features_xml (const char *annex
)
911 const struct target_desc
*desc
= current_target_desc ();
913 /* `desc->xmltarget' defines what to return when looking for the
914 "target.xml" file. Its contents can either be verbatim XML code
915 (prefixed with a '@') or else the name of the actual XML file to
916 be used in place of "target.xml".
918 This variable is set up from the auto-generated
919 init_registers_... routine for the current target. */
921 if (strcmp (annex
, "target.xml") == 0)
923 const char *ret
= tdesc_get_features_xml (desc
);
933 extern const char *const xml_builtin
[][2];
936 /* Look for the annex. */
937 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
938 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
941 if (xml_builtin
[i
][0] != NULL
)
942 return xml_builtin
[i
][1];
950 monitor_show_help (void)
952 monitor_output ("The following monitor commands are supported:\n");
953 monitor_output (" set debug <0|1>\n");
954 monitor_output (" Enable general debugging messages\n");
955 monitor_output (" set debug-hw-points <0|1>\n");
956 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
957 monitor_output (" set remote-debug <0|1>\n");
958 monitor_output (" Enable remote protocol debugging messages\n");
959 monitor_output (" set debug-format option1[,option2,...]\n");
960 monitor_output (" Add additional information to debugging messages\n");
961 monitor_output (" Options: all, none");
962 monitor_output (", timestamp");
963 monitor_output ("\n");
964 monitor_output (" exit\n");
965 monitor_output (" Quit GDBserver\n");
968 /* Read trace frame or inferior memory. Returns the number of bytes
969 actually read, zero when no further transfer is possible, and -1 on
970 error. Return of a positive value smaller than LEN does not
971 indicate there's no more to be read, only the end of the transfer.
972 E.g., when GDB reads memory from a traceframe, a first request may
973 be served from a memory block that does not cover the whole request
974 length. A following request gets the rest served from either
975 another block (of the same traceframe) or from the read-only
979 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
981 client_state
&cs
= get_client_state ();
984 if (cs
.current_traceframe
>= 0)
987 ULONGEST length
= len
;
989 if (traceframe_read_mem (cs
.current_traceframe
,
990 memaddr
, myaddr
, len
, &nbytes
))
992 /* Data read from trace buffer, we're done. */
995 if (!in_readonly_region (memaddr
, length
))
997 /* Otherwise we have a valid readonly case, fall through. */
998 /* (assume no half-trace half-real blocks for now) */
1001 res
= prepare_to_access_memory ();
1004 if (set_desired_thread ())
1005 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1008 done_accessing_memory ();
1010 return res
== 0 ? len
: -1;
1016 /* Write trace frame or inferior memory. Actually, writing to trace
1017 frames is forbidden. */
1020 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1022 client_state
&cs
= get_client_state ();
1023 if (cs
.current_traceframe
>= 0)
1029 ret
= prepare_to_access_memory ();
1032 if (set_desired_thread ())
1033 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1036 done_accessing_memory ();
1042 /* Subroutine of handle_search_memory to simplify it. */
1045 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1046 gdb_byte
*pattern
, unsigned pattern_len
,
1047 gdb_byte
*search_buf
,
1048 unsigned chunk_size
, unsigned search_buf_size
,
1049 CORE_ADDR
*found_addrp
)
1051 /* Prime the search buffer. */
1053 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1056 warning ("Unable to access %ld bytes of target "
1057 "memory at 0x%lx, halting search.",
1058 (long) search_buf_size
, (long) start_addr
);
1062 /* Perform the search.
1064 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1065 When we've scanned N bytes we copy the trailing bytes to the start and
1066 read in another N bytes. */
1068 while (search_space_len
>= pattern_len
)
1070 gdb_byte
*found_ptr
;
1071 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1075 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1078 if (found_ptr
!= NULL
)
1080 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1081 *found_addrp
= found_addr
;
1085 /* Not found in this chunk, skip to next chunk. */
1087 /* Don't let search_space_len wrap here, it's unsigned. */
1088 if (search_space_len
>= chunk_size
)
1089 search_space_len
-= chunk_size
;
1091 search_space_len
= 0;
1093 if (search_space_len
>= pattern_len
)
1095 unsigned keep_len
= search_buf_size
- chunk_size
;
1096 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1099 /* Copy the trailing part of the previous iteration to the front
1100 of the buffer for the next iteration. */
1101 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1103 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1104 ? search_space_len
- keep_len
1107 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1108 nr_to_read
) != search_buf_size
)
1110 warning ("Unable to access %ld bytes of target memory "
1111 "at 0x%lx, halting search.",
1112 (long) nr_to_read
, (long) read_addr
);
1116 start_addr
+= chunk_size
;
1125 /* Handle qSearch:memory packets. */
1128 handle_search_memory (char *own_buf
, int packet_len
)
1130 CORE_ADDR start_addr
;
1131 CORE_ADDR search_space_len
;
1133 unsigned int pattern_len
;
1134 /* NOTE: also defined in find.c testcase. */
1135 #define SEARCH_CHUNK_SIZE 16000
1136 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1137 /* Buffer to hold memory contents for searching. */
1138 gdb_byte
*search_buf
;
1139 unsigned search_buf_size
;
1141 CORE_ADDR found_addr
;
1142 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1144 pattern
= (gdb_byte
*) malloc (packet_len
);
1145 if (pattern
== NULL
)
1147 error ("Unable to allocate memory to perform the search");
1148 strcpy (own_buf
, "E00");
1151 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1152 packet_len
- cmd_name_len
,
1153 &start_addr
, &search_space_len
,
1154 pattern
, &pattern_len
) < 0)
1157 error ("Error in parsing qSearch:memory packet");
1158 strcpy (own_buf
, "E00");
1162 search_buf_size
= chunk_size
+ pattern_len
- 1;
1164 /* No point in trying to allocate a buffer larger than the search space. */
1165 if (search_space_len
< search_buf_size
)
1166 search_buf_size
= search_space_len
;
1168 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1169 if (search_buf
== NULL
)
1172 error ("Unable to allocate memory to perform the search");
1173 strcpy (own_buf
, "E00");
1177 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1178 pattern
, pattern_len
,
1179 search_buf
, chunk_size
, search_buf_size
,
1183 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1184 else if (found
== 0)
1185 strcpy (own_buf
, "0");
1187 strcpy (own_buf
, "E00");
1193 /* Handle the "D" packet. */
1196 handle_detach (char *own_buf
)
1198 client_state
&cs
= get_client_state ();
1200 process_info
*process
;
1202 if (cs
.multi_process
)
1205 int pid
= strtol (&own_buf
[2], NULL
, 16);
1207 process
= find_process_pid (pid
);
1211 process
= (current_thread
!= nullptr
1212 ? get_thread_process (current_thread
)
1216 if (process
== NULL
)
1218 write_enn (own_buf
);
1222 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1224 if (tracing
&& disconnected_tracing
)
1226 "Disconnected tracing in effect, "
1227 "leaving gdbserver attached to the process\n");
1229 if (any_persistent_commands (process
))
1231 "Persistent commands are present, "
1232 "leaving gdbserver attached to the process\n");
1234 /* Make sure we're in non-stop/async mode, so we we can both
1235 wait for an async socket accept, and handle async target
1236 events simultaneously. There's also no point either in
1237 having the target stop all threads, when we're going to
1238 pass signals down without informing GDB. */
1242 debug_printf ("Forcing non-stop mode\n");
1248 process
->gdb_detached
= 1;
1250 /* Detaching implicitly resumes all threads. */
1251 target_continue_no_signal (minus_one_ptid
);
1257 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1260 /* We'll need this after PROCESS has been destroyed. */
1261 int pid
= process
->pid
;
1263 if (detach_inferior (process
) != 0)
1264 write_enn (own_buf
);
1267 discard_queued_stop_replies (ptid_t (pid
));
1270 if (extended_protocol
|| target_running ())
1272 /* There is still at least one inferior remaining or
1273 we are in extended mode, so don't terminate gdbserver,
1274 and instead treat this like a normal program exit. */
1275 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1276 cs
.last_status
.value
.integer
= 0;
1277 cs
.last_ptid
= ptid_t (pid
);
1279 current_thread
= NULL
;
1286 /* If we are attached, then we can exit. Otherwise, we
1287 need to hang around doing nothing, until the child is
1289 join_inferior (pid
);
1295 /* Parse options to --debug-format= and "monitor set debug-format".
1296 ARG is the text after "--debug-format=" or "monitor set debug-format".
1297 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1298 This triggers calls to monitor_output.
1299 The result is an empty string if all options were parsed ok, otherwise an
1300 error message which the caller must free.
1302 N.B. These commands affect all debug format settings, they are not
1303 cumulative. If a format is not specified, it is turned off.
1304 However, we don't go to extra trouble with things like
1305 "monitor set debug-format all,none,timestamp".
1306 Instead we just parse them one at a time, in order.
1308 The syntax for "monitor set debug" we support here is not identical
1309 to gdb's "set debug foo on|off" because we also use this function to
1310 parse "--debug-format=foo,bar". */
1313 parse_debug_format_options (const char *arg
, int is_monitor
)
1315 /* First turn all debug format options off. */
1316 debug_timestamp
= 0;
1318 /* First remove leading spaces, for "monitor set debug-format". */
1319 while (isspace (*arg
))
1322 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1323 = delim_string_to_char_ptr_vec (arg
, ',');
1325 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1327 if (strcmp (option
.get (), "all") == 0)
1329 debug_timestamp
= 1;
1331 monitor_output ("All extra debug format options enabled.\n");
1333 else if (strcmp (option
.get (), "none") == 0)
1335 debug_timestamp
= 0;
1337 monitor_output ("All extra debug format options disabled.\n");
1339 else if (strcmp (option
.get (), "timestamp") == 0)
1341 debug_timestamp
= 1;
1343 monitor_output ("Timestamps will be added to debug output.\n");
1345 else if (*option
== '\0')
1347 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1351 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1355 return std::string ();
1358 /* Handle monitor commands not handled by target-specific handlers. */
1361 handle_monitor_command (char *mon
, char *own_buf
)
1363 if (strcmp (mon
, "set debug 1") == 0)
1366 monitor_output ("Debug output enabled.\n");
1368 else if (strcmp (mon
, "set debug 0") == 0)
1371 monitor_output ("Debug output disabled.\n");
1373 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1375 show_debug_regs
= 1;
1376 monitor_output ("H/W point debugging output enabled.\n");
1378 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1380 show_debug_regs
= 0;
1381 monitor_output ("H/W point debugging output disabled.\n");
1383 else if (strcmp (mon
, "set remote-debug 1") == 0)
1386 monitor_output ("Protocol debug output enabled.\n");
1388 else if (strcmp (mon
, "set remote-debug 0") == 0)
1391 monitor_output ("Protocol debug output disabled.\n");
1393 else if (startswith (mon
, "set debug-format "))
1395 std::string error_msg
1396 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1399 if (!error_msg
.empty ())
1401 monitor_output (error_msg
.c_str ());
1402 monitor_show_help ();
1403 write_enn (own_buf
);
1406 else if (strcmp (mon
, "set debug-file") == 0)
1407 debug_set_output (nullptr);
1408 else if (startswith (mon
, "set debug-file "))
1409 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1410 else if (strcmp (mon
, "help") == 0)
1411 monitor_show_help ();
1412 else if (strcmp (mon
, "exit") == 0)
1416 monitor_output ("Unknown monitor command.\n\n");
1417 monitor_show_help ();
1418 write_enn (own_buf
);
1422 /* Associates a callback with each supported qXfer'able object. */
1426 /* The object this handler handles. */
1429 /* Request that the target transfer up to LEN 8-bit bytes of the
1430 target's OBJECT. The OFFSET, for a seekable object, specifies
1431 the starting point. The ANNEX can be used to provide additional
1432 data-specific information to the target.
1434 Return the number of bytes actually transfered, zero when no
1435 further transfer is possible, -1 on error, -2 when the transfer
1436 is not supported, and -3 on a verbose error message that should
1437 be preserved. Return of a positive value smaller than LEN does
1438 not indicate the end of the object, only the end of the transfer.
1440 One, and only one, of readbuf or writebuf must be non-NULL. */
1441 int (*xfer
) (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
);
1446 /* Handle qXfer:auxv:read. */
1449 handle_qxfer_auxv (const char *annex
,
1450 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1451 ULONGEST offset
, LONGEST len
)
1453 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1456 if (annex
[0] != '\0' || current_thread
== NULL
)
1459 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1462 /* Handle qXfer:exec-file:read. */
1465 handle_qxfer_exec_file (const char *annex
,
1466 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1467 ULONGEST offset
, LONGEST len
)
1473 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1476 if (annex
[0] == '\0')
1478 if (current_thread
== NULL
)
1481 pid
= pid_of (current_thread
);
1485 annex
= unpack_varlen_hex (annex
, &pid
);
1486 if (annex
[0] != '\0')
1493 file
= (*the_target
->pid_to_exec_file
) (pid
);
1497 total_len
= strlen (file
);
1499 if (offset
> total_len
)
1502 if (offset
+ len
> total_len
)
1503 len
= total_len
- offset
;
1505 memcpy (readbuf
, file
+ offset
, len
);
1509 /* Handle qXfer:features:read. */
1512 handle_qxfer_features (const char *annex
,
1513 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1514 ULONGEST offset
, LONGEST len
)
1516 const char *document
;
1519 if (writebuf
!= NULL
)
1522 if (!target_running ())
1525 /* Grab the correct annex. */
1526 document
= get_features_xml (annex
);
1527 if (document
== NULL
)
1530 total_len
= strlen (document
);
1532 if (offset
> total_len
)
1535 if (offset
+ len
> total_len
)
1536 len
= total_len
- offset
;
1538 memcpy (readbuf
, document
+ offset
, len
);
1542 /* Handle qXfer:libraries:read. */
1545 handle_qxfer_libraries (const char *annex
,
1546 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1547 ULONGEST offset
, LONGEST len
)
1549 if (writebuf
!= NULL
)
1552 if (annex
[0] != '\0' || current_thread
== NULL
)
1555 std::string document
= "<library-list version=\"1.0\">\n";
1557 for (const dll_info
&dll
: all_dlls
)
1558 document
+= string_printf
1559 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1560 dll
.name
.c_str (), (long) dll
.base_addr
);
1562 document
+= "</library-list>\n";
1564 if (offset
> document
.length ())
1567 if (offset
+ len
> document
.length ())
1568 len
= document
.length () - offset
;
1570 memcpy (readbuf
, &document
[offset
], len
);
1575 /* Handle qXfer:libraries-svr4:read. */
1578 handle_qxfer_libraries_svr4 (const char *annex
,
1579 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1580 ULONGEST offset
, LONGEST len
)
1582 if (writebuf
!= NULL
)
1585 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1588 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1591 /* Handle qXfer:osadata:read. */
1594 handle_qxfer_osdata (const char *annex
,
1595 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1596 ULONGEST offset
, LONGEST len
)
1598 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1601 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1604 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1607 handle_qxfer_siginfo (const char *annex
,
1608 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1609 ULONGEST offset
, LONGEST len
)
1611 if (the_target
->qxfer_siginfo
== NULL
)
1614 if (annex
[0] != '\0' || current_thread
== NULL
)
1617 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1620 /* Handle qXfer:spu:read and qXfer:spu:write. */
1623 handle_qxfer_spu (const char *annex
,
1624 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1625 ULONGEST offset
, LONGEST len
)
1627 if (the_target
->qxfer_spu
== NULL
)
1630 if (current_thread
== NULL
)
1633 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1636 /* Handle qXfer:statictrace:read. */
1639 handle_qxfer_statictrace (const char *annex
,
1640 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1641 ULONGEST offset
, LONGEST len
)
1643 client_state
&cs
= get_client_state ();
1646 if (writebuf
!= NULL
)
1649 if (annex
[0] != '\0' || current_thread
== NULL
1650 || cs
.current_traceframe
== -1)
1653 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1654 readbuf
, len
, &nbytes
))
1659 /* Helper for handle_qxfer_threads_proper.
1660 Emit the XML to describe the thread of INF. */
1663 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1665 ptid_t ptid
= ptid_of (thread
);
1667 int core
= target_core_of_thread (ptid
);
1669 const char *name
= target_thread_name (ptid
);
1672 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1674 write_ptid (ptid_s
, ptid
);
1676 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1680 sprintf (core_s
, "%d", core
);
1681 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1685 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1689 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1690 bin2hex (handle
, handle_s
, handle_len
);
1691 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1694 buffer_xml_printf (buffer
, "/>\n");
1697 /* Helper for handle_qxfer_threads. */
1700 handle_qxfer_threads_proper (struct buffer
*buffer
)
1702 buffer_grow_str (buffer
, "<threads>\n");
1704 for_each_thread ([&] (thread_info
*thread
)
1706 handle_qxfer_threads_worker (thread
, buffer
);
1709 buffer_grow_str0 (buffer
, "</threads>\n");
1712 /* Handle qXfer:threads:read. */
1715 handle_qxfer_threads (const char *annex
,
1716 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1717 ULONGEST offset
, LONGEST len
)
1719 static char *result
= 0;
1720 static unsigned int result_length
= 0;
1722 if (writebuf
!= NULL
)
1725 if (annex
[0] != '\0')
1730 struct buffer buffer
;
1731 /* When asked for data at offset 0, generate everything and store into
1732 'result'. Successive reads will be served off 'result'. */
1736 buffer_init (&buffer
);
1738 handle_qxfer_threads_proper (&buffer
);
1740 result
= buffer_finish (&buffer
);
1741 result_length
= strlen (result
);
1742 buffer_free (&buffer
);
1745 if (offset
>= result_length
)
1747 /* We're out of data. */
1754 if (len
> result_length
- offset
)
1755 len
= result_length
- offset
;
1757 memcpy (readbuf
, result
+ offset
, len
);
1762 /* Handle qXfer:traceframe-info:read. */
1765 handle_qxfer_traceframe_info (const char *annex
,
1766 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1767 ULONGEST offset
, LONGEST len
)
1769 client_state
&cs
= get_client_state ();
1770 static char *result
= 0;
1771 static unsigned int result_length
= 0;
1773 if (writebuf
!= NULL
)
1776 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1781 struct buffer buffer
;
1783 /* When asked for data at offset 0, generate everything and
1784 store into 'result'. Successive reads will be served off
1788 buffer_init (&buffer
);
1790 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1792 result
= buffer_finish (&buffer
);
1793 result_length
= strlen (result
);
1794 buffer_free (&buffer
);
1797 if (offset
>= result_length
)
1799 /* We're out of data. */
1806 if (len
> result_length
- offset
)
1807 len
= result_length
- offset
;
1809 memcpy (readbuf
, result
+ offset
, len
);
1813 /* Handle qXfer:fdpic:read. */
1816 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1817 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1819 if (the_target
->read_loadmap
== NULL
)
1822 if (current_thread
== NULL
)
1825 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1828 /* Handle qXfer:btrace:read. */
1831 handle_qxfer_btrace (const char *annex
,
1832 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1833 ULONGEST offset
, LONGEST len
)
1835 client_state
&cs
= get_client_state ();
1836 static struct buffer cache
;
1837 struct thread_info
*thread
;
1838 enum btrace_read_type type
;
1841 if (writebuf
!= NULL
)
1844 if (cs
.general_thread
== null_ptid
1845 || cs
.general_thread
== minus_one_ptid
)
1847 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1851 thread
= find_thread_ptid (cs
.general_thread
);
1854 strcpy (cs
.own_buf
, "E.No such thread.");
1858 if (thread
->btrace
== NULL
)
1860 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1864 if (strcmp (annex
, "all") == 0)
1865 type
= BTRACE_READ_ALL
;
1866 else if (strcmp (annex
, "new") == 0)
1867 type
= BTRACE_READ_NEW
;
1868 else if (strcmp (annex
, "delta") == 0)
1869 type
= BTRACE_READ_DELTA
;
1872 strcpy (cs
.own_buf
, "E.Bad annex.");
1878 buffer_free (&cache
);
1882 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1884 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1886 catch (const gdb_exception_error
&exception
)
1888 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 (const gdb_exception_error
&exception
)
1959 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1966 else if (offset
> cache
.used_size
)
1968 buffer_free (&cache
);
1972 if (len
> cache
.used_size
- offset
)
1973 len
= cache
.used_size
- offset
;
1975 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1980 static const struct qxfer qxfer_packets
[] =
1982 { "auxv", handle_qxfer_auxv
},
1983 { "btrace", handle_qxfer_btrace
},
1984 { "btrace-conf", handle_qxfer_btrace_conf
},
1985 { "exec-file", handle_qxfer_exec_file
},
1986 { "fdpic", handle_qxfer_fdpic
},
1987 { "features", handle_qxfer_features
},
1988 { "libraries", handle_qxfer_libraries
},
1989 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1990 { "osdata", handle_qxfer_osdata
},
1991 { "siginfo", handle_qxfer_siginfo
},
1992 { "spu", handle_qxfer_spu
},
1993 { "statictrace", handle_qxfer_statictrace
},
1994 { "threads", handle_qxfer_threads
},
1995 { "traceframe-info", handle_qxfer_traceframe_info
},
1999 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2007 if (!startswith (own_buf
, "qXfer:"))
2010 /* Grab the object, r/w and annex. */
2011 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2013 write_enn (own_buf
);
2018 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2021 const struct qxfer
*q
= &qxfer_packets
[i
];
2023 if (strcmp (object
, q
->object
) == 0)
2025 if (strcmp (rw
, "read") == 0)
2027 unsigned char *data
;
2032 /* Grab the offset and length. */
2033 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2035 write_enn (own_buf
);
2039 /* Read one extra byte, as an indicator of whether there is
2041 if (len
> PBUFSIZ
- 2)
2043 data
= (unsigned char *) malloc (len
+ 1);
2046 write_enn (own_buf
);
2049 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2057 /* Preserve error message. */
2060 write_enn (own_buf
);
2062 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2064 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2069 else if (strcmp (rw
, "write") == 0)
2074 unsigned char *data
;
2076 strcpy (own_buf
, "E00");
2077 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2080 write_enn (own_buf
);
2083 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2084 &ofs
, &len
, data
) < 0)
2087 write_enn (own_buf
);
2091 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2099 /* Preserve error message. */
2102 write_enn (own_buf
);
2104 sprintf (own_buf
, "%x", n
);
2117 /* Compute 32 bit CRC from inferior memory.
2119 On success, return 32 bit CRC.
2120 On failure, return (unsigned long long) -1. */
2122 static unsigned long long
2123 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2127 unsigned char byte
= 0;
2129 /* Return failure if memory read fails. */
2130 if (read_inferior_memory (base
, &byte
, 1) != 0)
2131 return (unsigned long long) -1;
2133 crc
= xcrc32 (&byte
, 1, crc
);
2136 return (unsigned long long) crc
;
2139 /* Add supported btrace packets to BUF. */
2142 supported_btrace_packets (char *buf
)
2144 strcat (buf
, ";Qbtrace:bts+");
2145 strcat (buf
, ";Qbtrace-conf:bts:size+");
2146 strcat (buf
, ";Qbtrace:pt+");
2147 strcat (buf
, ";Qbtrace-conf:pt:size+");
2148 strcat (buf
, ";Qbtrace:off+");
2149 strcat (buf
, ";qXfer:btrace:read+");
2150 strcat (buf
, ";qXfer:btrace-conf:read+");
2153 /* Handle all of the extended 'q' packets. */
2156 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2158 client_state
&cs
= get_client_state ();
2159 static std::list
<thread_info
*>::const_iterator thread_iter
;
2161 /* Reply the current thread id. */
2162 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2165 require_running_or_return (own_buf
);
2167 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2168 ptid
= cs
.general_thread
;
2171 thread_iter
= all_threads
.begin ();
2172 ptid
= (*thread_iter
)->id
;
2175 sprintf (own_buf
, "QC");
2177 write_ptid (own_buf
, ptid
);
2181 if (strcmp ("qSymbol::", own_buf
) == 0)
2183 struct thread_info
*save_thread
= current_thread
;
2185 /* For qSymbol, GDB only changes the current thread if the
2186 previous current thread was of a different process. So if
2187 the previous thread is gone, we need to pick another one of
2188 the same process. This can happen e.g., if we followed an
2189 exec in a non-leader thread. */
2190 if (current_thread
== NULL
)
2193 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2195 /* Just in case, if we didn't find a thread, then bail out
2196 instead of crashing. */
2197 if (current_thread
== NULL
)
2199 write_enn (own_buf
);
2200 current_thread
= save_thread
;
2205 /* GDB is suggesting new symbols have been loaded. This may
2206 mean a new shared library has been detected as loaded, so
2207 take the opportunity to check if breakpoints we think are
2208 inserted, still are. Note that it isn't guaranteed that
2209 we'll see this when a shared library is loaded, and nor will
2210 we see this for unloads (although breakpoints in unloaded
2211 libraries shouldn't trigger), as GDB may not find symbols for
2212 the library at all. We also re-validate breakpoints when we
2213 see a second GDB breakpoint for the same address, and or when
2214 we access breakpoint shadows. */
2215 validate_breakpoints ();
2217 if (target_supports_tracepoints ())
2218 tracepoint_look_up_symbols ();
2220 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2221 (*the_target
->look_up_symbols
) ();
2223 current_thread
= save_thread
;
2225 strcpy (own_buf
, "OK");
2229 if (!disable_packet_qfThreadInfo
)
2231 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2233 require_running_or_return (own_buf
);
2234 thread_iter
= all_threads
.begin ();
2237 ptid_t ptid
= (*thread_iter
)->id
;
2238 write_ptid (own_buf
, ptid
);
2243 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2245 require_running_or_return (own_buf
);
2246 if (thread_iter
!= all_threads
.end ())
2249 ptid_t ptid
= (*thread_iter
)->id
;
2250 write_ptid (own_buf
, ptid
);
2256 sprintf (own_buf
, "l");
2262 if (the_target
->read_offsets
!= NULL
2263 && strcmp ("qOffsets", own_buf
) == 0)
2265 CORE_ADDR text
, data
;
2267 require_running_or_return (own_buf
);
2268 if (the_target
->read_offsets (&text
, &data
))
2269 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2270 (long)text
, (long)data
, (long)data
);
2272 write_enn (own_buf
);
2277 /* Protocol features query. */
2278 if (startswith (own_buf
, "qSupported")
2279 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2281 char *p
= &own_buf
[10];
2282 int gdb_supports_qRelocInsn
= 0;
2284 /* Process each feature being provided by GDB. The first
2285 feature will follow a ':', and latter features will follow
2289 char **qsupported
= NULL
;
2294 /* Two passes, to avoid nested strtok calls in
2295 target_process_qsupported. */
2296 for (p
= strtok (p
+ 1, ";");
2298 p
= strtok (NULL
, ";"))
2301 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2302 qsupported
[count
- 1] = xstrdup (p
);
2305 for (i
= 0; i
< count
; i
++)
2308 if (strcmp (p
, "multiprocess+") == 0)
2310 /* GDB supports and wants multi-process support if
2312 if (target_supports_multi_process ())
2313 cs
.multi_process
= 1;
2315 else if (strcmp (p
, "qRelocInsn+") == 0)
2317 /* GDB supports relocate instruction requests. */
2318 gdb_supports_qRelocInsn
= 1;
2320 else if (strcmp (p
, "swbreak+") == 0)
2322 /* GDB wants us to report whether a trap is caused
2323 by a software breakpoint and for us to handle PC
2324 adjustment if necessary on this target. */
2325 if (target_supports_stopped_by_sw_breakpoint ())
2326 cs
.swbreak_feature
= 1;
2328 else if (strcmp (p
, "hwbreak+") == 0)
2330 /* GDB wants us to report whether a trap is caused
2331 by a hardware breakpoint. */
2332 if (target_supports_stopped_by_hw_breakpoint ())
2333 cs
.hwbreak_feature
= 1;
2335 else if (strcmp (p
, "fork-events+") == 0)
2337 /* GDB supports and wants fork events if possible. */
2338 if (target_supports_fork_events ())
2339 cs
.report_fork_events
= 1;
2341 else if (strcmp (p
, "vfork-events+") == 0)
2343 /* GDB supports and wants vfork events if possible. */
2344 if (target_supports_vfork_events ())
2345 cs
.report_vfork_events
= 1;
2347 else if (strcmp (p
, "exec-events+") == 0)
2349 /* GDB supports and wants exec events if possible. */
2350 if (target_supports_exec_events ())
2351 cs
.report_exec_events
= 1;
2353 else if (strcmp (p
, "vContSupported+") == 0)
2354 cs
.vCont_supported
= 1;
2355 else if (strcmp (p
, "QThreadEvents+") == 0)
2357 else if (strcmp (p
, "no-resumed+") == 0)
2359 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2361 report_no_resumed
= 1;
2365 /* Move the unknown features all together. */
2366 qsupported
[i
] = NULL
;
2367 qsupported
[unknown
] = p
;
2372 /* Give the target backend a chance to process the unknown
2374 target_process_qsupported (qsupported
, unknown
);
2376 for (i
= 0; i
< count
; i
++)
2377 free (qsupported
[i
]);
2382 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2383 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2384 "QEnvironmentReset+;QEnvironmentUnset+;"
2388 if (target_supports_catch_syscall ())
2389 strcat (own_buf
, ";QCatchSyscalls+");
2391 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2392 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2393 ";augmented-libraries-svr4-read+");
2396 /* We do not have any hook to indicate whether the non-SVR4 target
2397 backend supports qXfer:libraries:read, so always report it. */
2398 strcat (own_buf
, ";qXfer:libraries:read+");
2401 if (the_target
->read_auxv
!= NULL
)
2402 strcat (own_buf
, ";qXfer:auxv:read+");
2404 if (the_target
->qxfer_spu
!= NULL
)
2405 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2407 if (the_target
->qxfer_siginfo
!= NULL
)
2408 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2410 if (the_target
->read_loadmap
!= NULL
)
2411 strcat (own_buf
, ";qXfer:fdpic:read+");
2413 /* We always report qXfer:features:read, as targets may
2414 install XML files on a subsequent call to arch_setup.
2415 If we reported to GDB on startup that we don't support
2416 qXfer:feature:read at all, we will never be re-queried. */
2417 strcat (own_buf
, ";qXfer:features:read+");
2419 if (cs
.transport_is_reliable
)
2420 strcat (own_buf
, ";QStartNoAckMode+");
2422 if (the_target
->qxfer_osdata
!= NULL
)
2423 strcat (own_buf
, ";qXfer:osdata:read+");
2425 if (target_supports_multi_process ())
2426 strcat (own_buf
, ";multiprocess+");
2428 if (target_supports_fork_events ())
2429 strcat (own_buf
, ";fork-events+");
2431 if (target_supports_vfork_events ())
2432 strcat (own_buf
, ";vfork-events+");
2434 if (target_supports_exec_events ())
2435 strcat (own_buf
, ";exec-events+");
2437 if (target_supports_non_stop ())
2438 strcat (own_buf
, ";QNonStop+");
2440 if (target_supports_disable_randomization ())
2441 strcat (own_buf
, ";QDisableRandomization+");
2443 strcat (own_buf
, ";qXfer:threads:read+");
2445 if (target_supports_tracepoints ())
2447 strcat (own_buf
, ";ConditionalTracepoints+");
2448 strcat (own_buf
, ";TraceStateVariables+");
2449 strcat (own_buf
, ";TracepointSource+");
2450 strcat (own_buf
, ";DisconnectedTracing+");
2451 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2452 strcat (own_buf
, ";FastTracepoints+");
2453 strcat (own_buf
, ";StaticTracepoints+");
2454 strcat (own_buf
, ";InstallInTrace+");
2455 strcat (own_buf
, ";qXfer:statictrace:read+");
2456 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2457 strcat (own_buf
, ";EnableDisableTracepoints+");
2458 strcat (own_buf
, ";QTBuffer:size+");
2459 strcat (own_buf
, ";tracenz+");
2462 if (target_supports_hardware_single_step ()
2463 || target_supports_software_single_step () )
2465 strcat (own_buf
, ";ConditionalBreakpoints+");
2467 strcat (own_buf
, ";BreakpointCommands+");
2469 if (target_supports_agent ())
2470 strcat (own_buf
, ";QAgent+");
2472 supported_btrace_packets (own_buf
);
2474 if (target_supports_stopped_by_sw_breakpoint ())
2475 strcat (own_buf
, ";swbreak+");
2477 if (target_supports_stopped_by_hw_breakpoint ())
2478 strcat (own_buf
, ";hwbreak+");
2480 if (the_target
->pid_to_exec_file
!= NULL
)
2481 strcat (own_buf
, ";qXfer:exec-file:read+");
2483 strcat (own_buf
, ";vContSupported+");
2485 strcat (own_buf
, ";QThreadEvents+");
2487 strcat (own_buf
, ";no-resumed+");
2489 /* Reinitialize components as needed for the new connection. */
2490 hostio_handle_new_gdb_connection ();
2491 target_handle_new_gdb_connection ();
2496 /* Thread-local storage support. */
2497 if (the_target
->get_tls_address
!= NULL
2498 && startswith (own_buf
, "qGetTLSAddr:"))
2500 char *p
= own_buf
+ 12;
2501 CORE_ADDR parts
[2], address
= 0;
2503 ptid_t ptid
= null_ptid
;
2505 require_running_or_return (own_buf
);
2507 for (i
= 0; i
< 3; i
++)
2515 p2
= strchr (p
, ',');
2528 ptid
= read_ptid (p
, NULL
);
2530 decode_address (&parts
[i
- 1], p
, len
);
2534 if (p
!= NULL
|| i
< 3)
2538 struct thread_info
*thread
= find_thread_ptid (ptid
);
2543 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2549 strcpy (own_buf
, paddress(address
));
2554 write_enn (own_buf
);
2558 /* Otherwise, pretend we do not understand this packet. */
2561 /* Windows OS Thread Information Block address support. */
2562 if (the_target
->get_tib_address
!= NULL
2563 && startswith (own_buf
, "qGetTIBAddr:"))
2568 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2570 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2573 strcpy (own_buf
, paddress(tlb
));
2578 write_enn (own_buf
);
2584 /* Handle "monitor" commands. */
2585 if (startswith (own_buf
, "qRcmd,"))
2587 char *mon
= (char *) malloc (PBUFSIZ
);
2588 int len
= strlen (own_buf
+ 6);
2592 write_enn (own_buf
);
2597 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2599 write_enn (own_buf
);
2603 mon
[len
/ 2] = '\0';
2607 if (the_target
->handle_monitor_command
== NULL
2608 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2609 /* Default processing. */
2610 handle_monitor_command (mon
, own_buf
);
2616 if (startswith (own_buf
, "qSearch:memory:"))
2618 require_running_or_return (own_buf
);
2619 handle_search_memory (own_buf
, packet_len
);
2623 if (strcmp (own_buf
, "qAttached") == 0
2624 || startswith (own_buf
, "qAttached:"))
2626 struct process_info
*process
;
2628 if (own_buf
[sizeof ("qAttached") - 1])
2630 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2631 process
= find_process_pid (pid
);
2635 require_running_or_return (own_buf
);
2636 process
= current_process ();
2639 if (process
== NULL
)
2641 write_enn (own_buf
);
2645 strcpy (own_buf
, process
->attached
? "1" : "0");
2649 if (startswith (own_buf
, "qCRC:"))
2651 /* CRC check (compare-section). */
2655 unsigned long long crc
;
2657 require_running_or_return (own_buf
);
2658 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2659 if (*comma
++ != ',')
2661 write_enn (own_buf
);
2664 len
= strtoul (comma
, NULL
, 16);
2665 crc
= crc32 (base
, len
, 0xffffffff);
2666 /* Check for memory failure. */
2667 if (crc
== (unsigned long long) -1)
2669 write_enn (own_buf
);
2672 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2676 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2679 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2682 /* Otherwise we didn't know what packet it was. Say we didn't
2687 static void gdb_wants_all_threads_stopped (void);
2688 static void resume (struct thread_resume
*actions
, size_t n
);
2690 /* The callback that is passed to visit_actioned_threads. */
2691 typedef int (visit_actioned_threads_callback_ftype
)
2692 (const struct thread_resume
*, struct thread_info
*);
2694 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2695 true if CALLBACK returns true. Returns false if no matching thread
2696 is found or CALLBACK results false.
2697 Note: This function is itself a callback for find_thread. */
2700 visit_actioned_threads (thread_info
*thread
,
2701 const struct thread_resume
*actions
,
2703 visit_actioned_threads_callback_ftype
*callback
)
2705 for (size_t i
= 0; i
< num_actions
; i
++)
2707 const struct thread_resume
*action
= &actions
[i
];
2709 if (action
->thread
== minus_one_ptid
2710 || action
->thread
== thread
->id
2711 || ((action
->thread
.pid ()
2712 == thread
->id
.pid ())
2713 && action
->thread
.lwp () == -1))
2715 if ((*callback
) (action
, thread
))
2723 /* Callback for visit_actioned_threads. If the thread has a pending
2724 status to report, report it now. */
2727 handle_pending_status (const struct thread_resume
*resumption
,
2728 struct thread_info
*thread
)
2730 client_state
&cs
= get_client_state ();
2731 if (thread
->status_pending_p
)
2733 thread
->status_pending_p
= 0;
2735 cs
.last_status
= thread
->last_status
;
2736 cs
.last_ptid
= thread
->id
;
2737 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2743 /* Parse vCont packets. */
2745 handle_v_cont (char *own_buf
)
2749 struct thread_resume
*resume_info
;
2750 struct thread_resume default_action
{ null_ptid
};
2752 /* Count the number of semicolons in the packet. There should be one
2753 for every action. */
2759 p
= strchr (p
, ';');
2762 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2763 if (resume_info
== NULL
)
2771 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2773 if (p
[0] == 's' || p
[0] == 'S')
2774 resume_info
[i
].kind
= resume_step
;
2775 else if (p
[0] == 'r')
2776 resume_info
[i
].kind
= resume_step
;
2777 else if (p
[0] == 'c' || p
[0] == 'C')
2778 resume_info
[i
].kind
= resume_continue
;
2779 else if (p
[0] == 't')
2780 resume_info
[i
].kind
= resume_stop
;
2784 if (p
[0] == 'S' || p
[0] == 'C')
2787 int sig
= strtol (p
+ 1, &q
, 16);
2792 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2794 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2796 else if (p
[0] == 'r')
2800 p
= unpack_varlen_hex (p
+ 1, &addr
);
2801 resume_info
[i
].step_range_start
= addr
;
2806 p
= unpack_varlen_hex (p
+ 1, &addr
);
2807 resume_info
[i
].step_range_end
= addr
;
2816 resume_info
[i
].thread
= minus_one_ptid
;
2817 default_action
= resume_info
[i
];
2819 /* Note: we don't increment i here, we'll overwrite this entry
2820 the next time through. */
2822 else if (p
[0] == ':')
2825 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2830 if (p
[0] != ';' && p
[0] != 0)
2833 resume_info
[i
].thread
= ptid
;
2840 resume_info
[i
] = default_action
;
2842 resume (resume_info
, n
);
2847 write_enn (own_buf
);
2852 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2855 resume (struct thread_resume
*actions
, size_t num_actions
)
2857 client_state
&cs
= get_client_state ();
2860 /* Check if among the threads that GDB wants actioned, there's
2861 one with a pending status to report. If so, skip actually
2862 resuming/stopping and report the pending event
2865 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2867 return visit_actioned_threads (thread
, actions
, num_actions
,
2868 handle_pending_status
);
2871 if (thread_with_status
!= NULL
)
2877 (*the_target
->resume
) (actions
, num_actions
);
2880 write_ok (cs
.own_buf
);
2883 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2885 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2886 && !report_no_resumed
)
2888 /* The client does not support this stop reply. At least
2890 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2891 disable_async_io ();
2895 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2896 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2897 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2898 current_thread
->last_status
= cs
.last_status
;
2900 /* From the client's perspective, all-stop mode always stops all
2901 threads implicitly (and the target backend has already done
2902 so by now). Tag all threads as "want-stopped", so we don't
2903 resume them implicitly without the client telling us to. */
2904 gdb_wants_all_threads_stopped ();
2905 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2906 disable_async_io ();
2908 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2909 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2910 target_mourn_inferior (cs
.last_ptid
);
2914 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2916 handle_v_attach (char *own_buf
)
2918 client_state
&cs
= get_client_state ();
2921 pid
= strtol (own_buf
+ 8, NULL
, 16);
2922 if (pid
!= 0 && attach_inferior (pid
) == 0)
2924 /* Don't report shared library events after attaching, even if
2925 some libraries are preloaded. GDB will always poll the
2926 library list. Avoids the "stopped by shared library event"
2927 notice on the GDB side. */
2932 /* In non-stop, we don't send a resume reply. Stop events
2933 will follow up using the normal notification
2938 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2944 write_enn (own_buf
);
2949 /* Run a new program. Return 1 if successful, 0 if failure. */
2951 handle_v_run (char *own_buf
)
2953 client_state
&cs
= get_client_state ();
2955 std::vector
<char *> new_argv
;
2956 char *new_program_name
= NULL
;
2960 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2966 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2968 next_p
= strchr (p
, ';');
2970 next_p
= p
+ strlen (p
);
2972 if (i
== 0 && p
== next_p
)
2974 /* No program specified. */
2975 new_program_name
= NULL
;
2977 else if (p
== next_p
)
2979 /* Empty argument. */
2980 new_argv
.push_back (xstrdup ("''"));
2984 size_t len
= (next_p
- p
) / 2;
2985 /* ARG is the unquoted argument received via the RSP. */
2986 char *arg
= (char *) xmalloc (len
+ 1);
2987 /* FULL_ARGS will contain the quoted version of ARG. */
2988 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2989 /* These are pointers used to navigate the strings above. */
2990 char *tmp_arg
= arg
;
2991 char *tmp_full_arg
= full_arg
;
2994 hex2bin (p
, (gdb_byte
*) arg
, len
);
2997 while (*tmp_arg
!= '\0')
3003 *tmp_full_arg
= '\'';
3009 /* Quote single quote. */
3010 *tmp_full_arg
= '\\';
3018 *tmp_full_arg
= *tmp_arg
;
3024 *tmp_full_arg
++ = '\'';
3026 /* Finish FULL_ARG and push it into the vector containing
3028 *tmp_full_arg
= '\0';
3030 new_program_name
= full_arg
;
3032 new_argv
.push_back (full_arg
);
3038 new_argv
.push_back (NULL
);
3040 if (new_program_name
== NULL
)
3042 /* GDB didn't specify a program to run. Use the program from the
3043 last run with the new argument list. */
3044 if (program_path
.get () == NULL
)
3046 write_enn (own_buf
);
3047 free_vector_argv (new_argv
);
3052 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3054 /* Free the old argv and install the new one. */
3055 free_vector_argv (program_args
);
3056 program_args
= new_argv
;
3058 create_inferior (program_path
.get (), program_args
);
3060 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3062 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3064 /* In non-stop, sending a resume reply doesn't set the general
3065 thread, but GDB assumes a vRun sets it (this is so GDB can
3066 query which is the main thread of the new inferior. */
3068 cs
.general_thread
= cs
.last_ptid
;
3074 write_enn (own_buf
);
3079 /* Kill process. Return 1 if successful, 0 if failure. */
3081 handle_v_kill (char *own_buf
)
3083 client_state
&cs
= get_client_state ();
3085 char *p
= &own_buf
[6];
3086 if (cs
.multi_process
)
3087 pid
= strtol (p
, NULL
, 16);
3091 process_info
*proc
= find_process_pid (pid
);
3093 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3095 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3096 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3097 cs
.last_ptid
= ptid_t (pid
);
3098 discard_queued_stop_replies (cs
.last_ptid
);
3104 write_enn (own_buf
);
3109 /* Handle all of the extended 'v' packets. */
3111 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3113 client_state
&cs
= get_client_state ();
3114 if (!disable_packet_vCont
)
3116 if (strcmp (own_buf
, "vCtrlC") == 0)
3118 (*the_target
->request_interrupt
) ();
3123 if (startswith (own_buf
, "vCont;"))
3125 handle_v_cont (own_buf
);
3129 if (startswith (own_buf
, "vCont?"))
3131 strcpy (own_buf
, "vCont;c;C;t");
3133 if (target_supports_hardware_single_step ()
3134 || target_supports_software_single_step ()
3135 || !cs
.vCont_supported
)
3137 /* If target supports single step either by hardware or by
3138 software, add actions s and S to the list of supported
3139 actions. On the other hand, if GDB doesn't request the
3140 supported vCont actions in qSupported packet, add s and
3141 S to the list too. */
3142 own_buf
= own_buf
+ strlen (own_buf
);
3143 strcpy (own_buf
, ";s;S");
3146 if (target_supports_range_stepping ())
3148 own_buf
= own_buf
+ strlen (own_buf
);
3149 strcpy (own_buf
, ";r");
3155 if (startswith (own_buf
, "vFile:")
3156 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3159 if (startswith (own_buf
, "vAttach;"))
3161 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3163 fprintf (stderr
, "Already debugging a process\n");
3164 write_enn (own_buf
);
3167 handle_v_attach (own_buf
);
3171 if (startswith (own_buf
, "vRun;"))
3173 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3175 fprintf (stderr
, "Already debugging a process\n");
3176 write_enn (own_buf
);
3179 handle_v_run (own_buf
);
3183 if (startswith (own_buf
, "vKill;"))
3185 if (!target_running ())
3187 fprintf (stderr
, "No process to kill\n");
3188 write_enn (own_buf
);
3191 handle_v_kill (own_buf
);
3195 if (handle_notif_ack (own_buf
, packet_len
))
3198 /* Otherwise we didn't know what packet it was. Say we didn't
3204 /* Resume thread and wait for another event. In non-stop mode,
3205 don't really wait here, but return immediatelly to the event
3208 myresume (char *own_buf
, int step
, int sig
)
3210 client_state
&cs
= get_client_state ();
3211 struct thread_resume resume_info
[2];
3213 int valid_cont_thread
;
3215 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3216 && cs
.cont_thread
!= minus_one_ptid
);
3218 if (step
|| sig
|| valid_cont_thread
)
3220 resume_info
[0].thread
= current_ptid
;
3222 resume_info
[0].kind
= resume_step
;
3224 resume_info
[0].kind
= resume_continue
;
3225 resume_info
[0].sig
= sig
;
3229 if (!valid_cont_thread
)
3231 resume_info
[n
].thread
= minus_one_ptid
;
3232 resume_info
[n
].kind
= resume_continue
;
3233 resume_info
[n
].sig
= 0;
3237 resume (resume_info
, n
);
3240 /* Callback for for_each_thread. Make a new stop reply for each
3244 queue_stop_reply_callback (thread_info
*thread
)
3246 /* For now, assume targets that don't have this callback also don't
3247 manage the thread's last_status field. */
3248 if (the_target
->thread_stopped
== NULL
)
3250 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3252 new_notif
->ptid
= thread
->id
;
3253 new_notif
->status
= thread
->last_status
;
3254 /* Pass the last stop reply back to GDB, but don't notify
3256 notif_event_enque (¬if_stop
,
3257 (struct notif_event
*) new_notif
);
3261 if (thread_stopped (thread
))
3265 std::string status_string
3266 = target_waitstatus_to_string (&thread
->last_status
);
3268 debug_printf ("Reporting thread %s as already stopped with %s\n",
3269 target_pid_to_str (thread
->id
),
3270 status_string
.c_str ());
3273 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3275 /* Pass the last stop reply back to GDB, but don't notify
3277 queue_stop_reply (thread
->id
, &thread
->last_status
);
3282 /* Set this inferior threads's state as "want-stopped". We won't
3283 resume this thread until the client gives us another action for
3287 gdb_wants_thread_stopped (thread_info
*thread
)
3289 thread
->last_resume_kind
= resume_stop
;
3291 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3293 /* Most threads are stopped implicitly (all-stop); tag that with
3295 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3296 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3300 /* Set all threads' states as "want-stopped". */
3303 gdb_wants_all_threads_stopped (void)
3305 for_each_thread (gdb_wants_thread_stopped
);
3308 /* Callback for for_each_thread. If the thread is stopped with an
3309 interesting event, mark it as having a pending event. */
3312 set_pending_status_callback (thread_info
*thread
)
3314 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3315 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3316 /* A breakpoint, watchpoint or finished step from a previous
3317 GDB run isn't considered interesting for a new GDB run.
3318 If we left those pending, the new GDB could consider them
3319 random SIGTRAPs. This leaves out real async traps. We'd
3320 have to peek into the (target-specific) siginfo to
3321 distinguish those. */
3322 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3323 thread
->status_pending_p
= 1;
3326 /* Status handler for the '?' packet. */
3329 handle_status (char *own_buf
)
3331 client_state
&cs
= get_client_state ();
3333 /* GDB is connected, don't forward events to the target anymore. */
3334 for_each_process ([] (process_info
*process
) {
3335 process
->gdb_detached
= 0;
3338 /* In non-stop mode, we must send a stop reply for each stopped
3339 thread. In all-stop mode, just send one for the first stopped
3344 for_each_thread (queue_stop_reply_callback
);
3346 /* The first is sent immediatly. OK is sent if there is no
3347 stopped thread, which is the same handling of the vStopped
3348 packet (by design). */
3349 notif_write_event (¬if_stop
, cs
.own_buf
);
3353 thread_info
*thread
= NULL
;
3356 stabilize_threads ();
3357 gdb_wants_all_threads_stopped ();
3359 /* We can only report one status, but we might be coming out of
3360 non-stop -- if more than one thread is stopped with
3361 interesting events, leave events for the threads we're not
3362 reporting now pending. They'll be reported the next time the
3363 threads are resumed. Start by marking all interesting events
3365 for_each_thread (set_pending_status_callback
);
3367 /* Prefer the last thread that reported an event to GDB (even if
3368 that was a GDB_SIGNAL_TRAP). */
3369 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3370 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3371 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3372 thread
= find_thread_ptid (cs
.last_ptid
);
3374 /* If the last event thread is not found for some reason, look
3375 for some other thread that might have an event to report. */
3377 thread
= find_thread ([] (thread_info
*thr_arg
)
3379 return thr_arg
->status_pending_p
;
3382 /* If we're still out of luck, simply pick the first thread in
3385 thread
= get_first_thread ();
3389 struct thread_info
*tp
= (struct thread_info
*) thread
;
3391 /* We're reporting this event, so it's no longer
3393 tp
->status_pending_p
= 0;
3395 /* GDB assumes the current thread is the thread we're
3396 reporting the status for. */
3397 cs
.general_thread
= thread
->id
;
3398 set_desired_thread ();
3400 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3401 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3404 strcpy (own_buf
, "W00");
3409 gdbserver_version (void)
3411 printf ("GNU gdbserver %s%s\n"
3412 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3413 "gdbserver is free software, covered by the "
3414 "GNU General Public License.\n"
3415 "This gdbserver was configured as \"%s\"\n",
3416 PKGVERSION
, version
, host_name
);
3420 gdbserver_usage (FILE *stream
)
3422 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3423 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3424 "\tgdbserver [OPTIONS] --multi COMM\n"
3426 "COMM may either be a tty device (for serial debugging),\n"
3427 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3428 "stdin/stdout of gdbserver.\n"
3429 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3430 "PID is the process ID to attach to, when --attach is specified.\n"
3432 "Operating modes:\n"
3434 " --attach Attach to running process PID.\n"
3435 " --multi Start server without a specific program, and\n"
3436 " only quit when explicitly commanded.\n"
3437 " --once Exit after the first connection has closed.\n"
3438 " --help Print this message and then exit.\n"
3439 " --version Display version information and exit.\n"
3443 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3444 " --disable-randomization\n"
3445 " Run PROG with address space randomization disabled.\n"
3446 " --no-disable-randomization\n"
3447 " Don't disable address space randomization when\n"
3449 " --startup-with-shell\n"
3450 " Start PROG using a shell. I.e., execs a shell that\n"
3451 " then execs PROG. (default)\n"
3452 " --no-startup-with-shell\n"
3453 " Exec PROG directly instead of using a shell.\n"
3454 " Disables argument globbing and variable substitution\n"
3455 " on UNIX-like systems.\n"
3459 " --debug Enable general debugging output.\n"
3460 " --debug-format=OPT1[,OPT2,...]\n"
3461 " Specify extra content in debugging output.\n"
3466 " --remote-debug Enable remote protocol debugging output.\n"
3467 " --disable-packet=OPT1[,OPT2,...]\n"
3468 " Disable support for RSP packets or features.\n"
3470 " vCont, Tthread, qC, qfThreadInfo and \n"
3471 " threads (disable all threading packets).\n"
3473 "For more information, consult the GDB manual (available as on-line \n"
3474 "info or a printed manual).\n");
3475 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3476 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3480 gdbserver_show_disableable (FILE *stream
)
3482 fprintf (stream
, "Disableable packets:\n"
3483 " vCont \tAll vCont packets\n"
3484 " qC \tQuerying the current thread\n"
3485 " qfThreadInfo\tThread listing\n"
3486 " Tthread \tPassing the thread specifier in the "
3487 "T stop reply packet\n"
3488 " threads \tAll of the above\n");
3492 kill_inferior_callback (process_info
*process
)
3494 kill_inferior (process
);
3495 discard_queued_stop_replies (ptid_t (process
->pid
));
3498 /* Call this when exiting gdbserver with possible inferiors that need
3499 to be killed or detached from. */
3502 detach_or_kill_for_exit (void)
3504 /* First print a list of the inferiors we will be killing/detaching.
3505 This is to assist the user, for example, in case the inferior unexpectedly
3506 dies after we exit: did we screw up or did the inferior exit on its own?
3507 Having this info will save some head-scratching. */
3509 if (have_started_inferiors_p ())
3511 fprintf (stderr
, "Killing process(es):");
3513 for_each_process ([] (process_info
*process
) {
3514 if (!process
->attached
)
3515 fprintf (stderr
, " %d", process
->pid
);
3518 fprintf (stderr
, "\n");
3520 if (have_attached_inferiors_p ())
3522 fprintf (stderr
, "Detaching process(es):");
3524 for_each_process ([] (process_info
*process
) {
3525 if (process
->attached
)
3526 fprintf (stderr
, " %d", process
->pid
);
3529 fprintf (stderr
, "\n");
3532 /* Now we can kill or detach the inferiors. */
3533 for_each_process ([] (process_info
*process
) {
3534 int pid
= process
->pid
;
3536 if (process
->attached
)
3537 detach_inferior (process
);
3539 kill_inferior (process
);
3541 discard_queued_stop_replies (ptid_t (pid
));
3545 /* Value that will be passed to exit(3) when gdbserver exits. */
3546 static int exit_code
;
3548 /* Wrapper for detach_or_kill_for_exit that catches and prints
3552 detach_or_kill_for_exit_cleanup ()
3556 detach_or_kill_for_exit ();
3558 catch (const gdb_exception
&exception
)
3561 fprintf (stderr
, "Detach or kill failed: %s\n",
3567 /* Main function. This is called by the real "main" function,
3568 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3570 static void ATTRIBUTE_NORETURN
3571 captured_main (int argc
, char *argv
[])
3576 const char *port
= NULL
;
3577 char **next_arg
= &argv
[1];
3578 volatile int multi_mode
= 0;
3579 volatile int attach
= 0;
3581 bool selftest
= false;
3583 const char *selftest_filter
= NULL
;
3586 current_directory
= getcwd (NULL
, 0);
3587 client_state
&cs
= get_client_state ();
3589 if (current_directory
== NULL
)
3591 error (_("Could not find current working directory: %s"),
3592 safe_strerror (errno
));
3595 while (*next_arg
!= NULL
&& **next_arg
== '-')
3597 if (strcmp (*next_arg
, "--version") == 0)
3599 gdbserver_version ();
3602 else if (strcmp (*next_arg
, "--help") == 0)
3604 gdbserver_usage (stdout
);
3607 else if (strcmp (*next_arg
, "--attach") == 0)
3609 else if (strcmp (*next_arg
, "--multi") == 0)
3611 else if (strcmp (*next_arg
, "--wrapper") == 0)
3618 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3620 wrapper_argv
+= *next_arg
;
3621 wrapper_argv
+= ' ';
3625 if (!wrapper_argv
.empty ())
3627 /* Erase the last whitespace. */
3628 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3631 if (next_arg
== tmp
|| *next_arg
== NULL
)
3633 gdbserver_usage (stderr
);
3637 /* Consume the "--". */
3640 else if (strcmp (*next_arg
, "--debug") == 0)
3642 else if (startswith (*next_arg
, "--debug-format="))
3644 std::string error_msg
3645 = parse_debug_format_options ((*next_arg
)
3646 + sizeof ("--debug-format=") - 1, 0);
3648 if (!error_msg
.empty ())
3650 fprintf (stderr
, "%s", error_msg
.c_str ());
3654 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3656 else if (startswith (*next_arg
, "--debug-file="))
3657 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
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 (const gdb_exception_error
&exception
)
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");
3951 /* Main function. */
3954 main (int argc
, char *argv
[])
3959 captured_main (argc
, argv
);
3961 catch (const gdb_exception
&exception
)
3963 if (exception
.reason
== RETURN_ERROR
)
3966 fprintf (stderr
, "%s\n", exception
.what ());
3967 fprintf (stderr
, "Exiting\n");
3974 gdb_assert_not_reached ("captured_main should never return");
3977 /* Process options coming from Z packets for a breakpoint. PACKET is
3978 the packet buffer. *PACKET is updated to point to the first char
3979 after the last processed option. */
3982 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3984 const char *dataptr
= *packet
;
3987 /* Check if data has the correct format. */
3988 if (*dataptr
!= ';')
3995 if (*dataptr
== ';')
3998 if (*dataptr
== 'X')
4000 /* Conditional expression. */
4002 debug_printf ("Found breakpoint condition.\n");
4003 if (!add_breakpoint_condition (bp
, &dataptr
))
4004 dataptr
= strchrnul (dataptr
, ';');
4006 else if (startswith (dataptr
, "cmds:"))
4008 dataptr
+= strlen ("cmds:");
4010 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4011 persist
= (*dataptr
== '1');
4013 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4014 dataptr
= strchrnul (dataptr
, ';');
4018 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4020 /* Skip tokens until we find one that we recognize. */
4021 dataptr
= strchrnul (dataptr
, ';');
4027 /* Event loop callback that handles a serial event. The first byte in
4028 the serial buffer gets us here. We expect characters to arrive at
4029 a brisk pace, so we read the rest of the packet with a blocking
4033 process_serial_event (void)
4035 client_state
&cs
= get_client_state ();
4041 int new_packet_len
= -1;
4043 disable_async_io ();
4045 response_needed
= 0;
4046 packet_len
= getpkt (cs
.own_buf
);
4047 if (packet_len
<= 0)
4050 /* Force an event loop break. */
4053 response_needed
= 1;
4055 char ch
= cs
.own_buf
[0];
4059 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4062 handle_general_set (cs
.own_buf
);
4065 handle_detach (cs
.own_buf
);
4068 extended_protocol
= 1;
4069 write_ok (cs
.own_buf
);
4072 handle_status (cs
.own_buf
);
4075 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4077 require_running_or_break (cs
.own_buf
);
4079 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4081 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4082 thread_id
= null_ptid
;
4083 else if (thread_id
.is_pid ())
4085 /* The ptid represents a pid. */
4086 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4090 write_enn (cs
.own_buf
);
4094 thread_id
= thread
->id
;
4098 /* The ptid represents a lwp/tid. */
4099 if (find_thread_ptid (thread_id
) == NULL
)
4101 write_enn (cs
.own_buf
);
4106 if (cs
.own_buf
[1] == 'g')
4108 if (thread_id
== null_ptid
)
4110 /* GDB is telling us to choose any thread. Check if
4111 the currently selected thread is still valid. If
4112 it is not, select the first available. */
4113 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4115 thread
= get_first_thread ();
4116 thread_id
= thread
->id
;
4119 cs
.general_thread
= thread_id
;
4120 set_desired_thread ();
4121 gdb_assert (current_thread
!= NULL
);
4123 else if (cs
.own_buf
[1] == 'c')
4124 cs
.cont_thread
= thread_id
;
4126 write_ok (cs
.own_buf
);
4130 /* Silently ignore it so that gdb can extend the protocol
4131 without compatibility headaches. */
4132 cs
.own_buf
[0] = '\0';
4136 require_running_or_break (cs
.own_buf
);
4137 if (cs
.current_traceframe
>= 0)
4139 struct regcache
*regcache
4140 = new_register_cache (current_target_desc ());
4142 if (fetch_traceframe_registers (cs
.current_traceframe
,
4144 registers_to_string (regcache
, cs
.own_buf
);
4146 write_enn (cs
.own_buf
);
4147 free_register_cache (regcache
);
4151 struct regcache
*regcache
;
4153 if (!set_desired_thread ())
4154 write_enn (cs
.own_buf
);
4157 regcache
= get_thread_regcache (current_thread
, 1);
4158 registers_to_string (regcache
, cs
.own_buf
);
4163 require_running_or_break (cs
.own_buf
);
4164 if (cs
.current_traceframe
>= 0)
4165 write_enn (cs
.own_buf
);
4168 struct regcache
*regcache
;
4170 if (!set_desired_thread ())
4171 write_enn (cs
.own_buf
);
4174 regcache
= get_thread_regcache (current_thread
, 1);
4175 registers_from_string (regcache
, &cs
.own_buf
[1]);
4176 write_ok (cs
.own_buf
);
4182 require_running_or_break (cs
.own_buf
);
4183 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4184 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4186 write_enn (cs
.own_buf
);
4188 bin2hex (mem_buf
, cs
.own_buf
, res
);
4192 require_running_or_break (cs
.own_buf
);
4193 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4194 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4195 write_ok (cs
.own_buf
);
4197 write_enn (cs
.own_buf
);
4200 require_running_or_break (cs
.own_buf
);
4201 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4202 &mem_addr
, &len
, &mem_buf
) < 0
4203 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4204 write_enn (cs
.own_buf
);
4206 write_ok (cs
.own_buf
);
4209 require_running_or_break (cs
.own_buf
);
4210 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4211 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4212 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4215 myresume (cs
.own_buf
, 0, signal
);
4218 require_running_or_break (cs
.own_buf
);
4219 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4220 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4221 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4224 myresume (cs
.own_buf
, 1, signal
);
4227 require_running_or_break (cs
.own_buf
);
4229 myresume (cs
.own_buf
, 0, signal
);
4232 require_running_or_break (cs
.own_buf
);
4234 myresume (cs
.own_buf
, 1, signal
);
4236 case 'Z': /* insert_ ... */
4238 case 'z': /* remove_ ... */
4243 char type
= cs
.own_buf
[1];
4245 const int insert
= ch
== 'Z';
4246 const char *p
= &cs
.own_buf
[3];
4248 p
= unpack_varlen_hex (p
, &addr
);
4249 kind
= strtol (p
+ 1, &dataptr
, 16);
4253 struct gdb_breakpoint
*bp
;
4255 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4260 /* GDB may have sent us a list of *point parameters to
4261 be evaluated on the target's side. Read such list
4262 here. If we already have a list of parameters, GDB
4263 is telling us to drop that list and use this one
4265 clear_breakpoint_conditions_and_commands (bp
);
4266 const char *options
= dataptr
;
4267 process_point_options (bp
, &options
);
4271 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4274 write_ok (cs
.own_buf
);
4277 cs
.own_buf
[0] = '\0';
4279 write_enn (cs
.own_buf
);
4283 response_needed
= 0;
4284 if (!target_running ())
4285 /* The packet we received doesn't make sense - but we can't
4286 reply to it, either. */
4289 fprintf (stderr
, "Killing all inferiors\n");
4291 for_each_process (kill_inferior_callback
);
4293 /* When using the extended protocol, we wait with no program
4294 running. The traditional protocol will exit instead. */
4295 if (extended_protocol
)
4297 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4298 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4306 require_running_or_break (cs
.own_buf
);
4308 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4309 if (find_thread_ptid (thread_id
) == NULL
)
4311 write_enn (cs
.own_buf
);
4315 if (mythread_alive (thread_id
))
4316 write_ok (cs
.own_buf
);
4318 write_enn (cs
.own_buf
);
4322 response_needed
= 0;
4324 /* Restarting the inferior is only supported in the extended
4326 if (extended_protocol
)
4328 if (target_running ())
4329 for_each_process (kill_inferior_callback
);
4331 fprintf (stderr
, "GDBserver restarting\n");
4333 /* Wait till we are at 1st instruction in prog. */
4334 if (program_path
.get () != NULL
)
4336 create_inferior (program_path
.get (), program_args
);
4338 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4340 /* Stopped at the first instruction of the target
4342 cs
.general_thread
= cs
.last_ptid
;
4346 /* Something went wrong. */
4347 cs
.general_thread
= null_ptid
;
4352 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4353 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4359 /* It is a request we don't understand. Respond with an
4360 empty packet so that gdb knows that we don't support this
4362 cs
.own_buf
[0] = '\0';
4366 /* Extended (long) request. */
4367 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4371 /* It is a request we don't understand. Respond with an empty
4372 packet so that gdb knows that we don't support this
4374 cs
.own_buf
[0] = '\0';
4378 if (new_packet_len
!= -1)
4379 putpkt_binary (cs
.own_buf
, new_packet_len
);
4381 putpkt (cs
.own_buf
);
4383 response_needed
= 0;
4391 /* Event-loop callback for serial events. */
4394 handle_serial_event (int err
, gdb_client_data client_data
)
4397 debug_printf ("handling possible serial event\n");
4399 /* Really handle it. */
4400 if (process_serial_event () < 0)
4403 /* Be sure to not change the selected thread behind GDB's back.
4404 Important in the non-stop mode asynchronous protocol. */
4405 set_desired_thread ();
4410 /* Push a stop notification on the notification queue. */
4413 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4415 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4417 vstop_notif
->status
= *status
;
4418 vstop_notif
->ptid
= ptid
;
4419 /* Push Stop notification. */
4420 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4423 /* Event-loop callback for target events. */
4426 handle_target_event (int err
, gdb_client_data client_data
)
4428 client_state
&cs
= get_client_state ();
4430 debug_printf ("handling possible target event\n");
4432 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4435 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4437 if (gdb_connected () && report_no_resumed
)
4438 push_stop_notification (null_ptid
, &cs
.last_status
);
4440 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4442 int pid
= cs
.last_ptid
.pid ();
4443 struct process_info
*process
= find_process_pid (pid
);
4444 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4446 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4447 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4449 mark_breakpoints_out (process
);
4450 target_mourn_inferior (cs
.last_ptid
);
4452 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4456 /* We're reporting this thread as stopped. Update its
4457 "want-stopped" state to what the client wants, until it
4458 gets a new resume action. */
4459 current_thread
->last_resume_kind
= resume_stop
;
4460 current_thread
->last_status
= cs
.last_status
;
4465 if (!target_running ())
4467 /* The last process exited. We're done. */
4471 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4472 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4473 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4477 /* A thread stopped with a signal, but gdb isn't
4478 connected to handle it. Pass it down to the
4479 inferior, as if it wasn't being traced. */
4480 enum gdb_signal signal
;
4483 debug_printf ("GDB not connected; forwarding event %d for"
4485 (int) cs
.last_status
.kind
,
4486 target_pid_to_str (cs
.last_ptid
));
4488 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4489 signal
= cs
.last_status
.value
.sig
;
4491 signal
= GDB_SIGNAL_0
;
4492 target_continue (cs
.last_ptid
, signal
);
4496 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4499 /* Be sure to not change the selected thread behind GDB's back.
4500 Important in the non-stop mode asynchronous protocol. */
4501 set_desired_thread ();
4514 } // namespace selftests
4515 #endif /* GDB_SELF_TEST */