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
, "help") == 0)
1407 monitor_show_help ();
1408 else if (strcmp (mon
, "exit") == 0)
1412 monitor_output ("Unknown monitor command.\n\n");
1413 monitor_show_help ();
1414 write_enn (own_buf
);
1418 /* Associates a callback with each supported qXfer'able object. */
1422 /* The object this handler handles. */
1425 /* Request that the target transfer up to LEN 8-bit bytes of the
1426 target's OBJECT. The OFFSET, for a seekable object, specifies
1427 the starting point. The ANNEX can be used to provide additional
1428 data-specific information to the target.
1430 Return the number of bytes actually transfered, zero when no
1431 further transfer is possible, -1 on error, -2 when the transfer
1432 is not supported, and -3 on a verbose error message that should
1433 be preserved. Return of a positive value smaller than LEN does
1434 not indicate the end of the object, only the end of the transfer.
1436 One, and only one, of readbuf or writebuf must be non-NULL. */
1437 int (*xfer
) (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
);
1442 /* Handle qXfer:auxv:read. */
1445 handle_qxfer_auxv (const char *annex
,
1446 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1447 ULONGEST offset
, LONGEST len
)
1449 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1452 if (annex
[0] != '\0' || current_thread
== NULL
)
1455 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1458 /* Handle qXfer:exec-file:read. */
1461 handle_qxfer_exec_file (const char *annex
,
1462 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1463 ULONGEST offset
, LONGEST len
)
1469 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1472 if (annex
[0] == '\0')
1474 if (current_thread
== NULL
)
1477 pid
= pid_of (current_thread
);
1481 annex
= unpack_varlen_hex (annex
, &pid
);
1482 if (annex
[0] != '\0')
1489 file
= (*the_target
->pid_to_exec_file
) (pid
);
1493 total_len
= strlen (file
);
1495 if (offset
> total_len
)
1498 if (offset
+ len
> total_len
)
1499 len
= total_len
- offset
;
1501 memcpy (readbuf
, file
+ offset
, len
);
1505 /* Handle qXfer:features:read. */
1508 handle_qxfer_features (const char *annex
,
1509 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1510 ULONGEST offset
, LONGEST len
)
1512 const char *document
;
1515 if (writebuf
!= NULL
)
1518 if (!target_running ())
1521 /* Grab the correct annex. */
1522 document
= get_features_xml (annex
);
1523 if (document
== NULL
)
1526 total_len
= strlen (document
);
1528 if (offset
> total_len
)
1531 if (offset
+ len
> total_len
)
1532 len
= total_len
- offset
;
1534 memcpy (readbuf
, document
+ offset
, len
);
1538 /* Handle qXfer:libraries:read. */
1541 handle_qxfer_libraries (const char *annex
,
1542 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1543 ULONGEST offset
, LONGEST len
)
1545 if (writebuf
!= NULL
)
1548 if (annex
[0] != '\0' || current_thread
== NULL
)
1551 std::string document
= "<library-list version=\"1.0\">\n";
1553 for (const dll_info
&dll
: all_dlls
)
1554 document
+= string_printf
1555 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1556 dll
.name
.c_str (), (long) dll
.base_addr
);
1558 document
+= "</library-list>\n";
1560 if (offset
> document
.length ())
1563 if (offset
+ len
> document
.length ())
1564 len
= document
.length () - offset
;
1566 memcpy (readbuf
, &document
[offset
], len
);
1571 /* Handle qXfer:libraries-svr4:read. */
1574 handle_qxfer_libraries_svr4 (const char *annex
,
1575 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1576 ULONGEST offset
, LONGEST len
)
1578 if (writebuf
!= NULL
)
1581 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1584 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1587 /* Handle qXfer:osadata:read. */
1590 handle_qxfer_osdata (const char *annex
,
1591 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1592 ULONGEST offset
, LONGEST len
)
1594 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1597 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1600 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1603 handle_qxfer_siginfo (const char *annex
,
1604 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1605 ULONGEST offset
, LONGEST len
)
1607 if (the_target
->qxfer_siginfo
== NULL
)
1610 if (annex
[0] != '\0' || current_thread
== NULL
)
1613 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1616 /* Handle qXfer:spu:read and qXfer:spu:write. */
1619 handle_qxfer_spu (const char *annex
,
1620 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1621 ULONGEST offset
, LONGEST len
)
1623 if (the_target
->qxfer_spu
== NULL
)
1626 if (current_thread
== NULL
)
1629 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1632 /* Handle qXfer:statictrace:read. */
1635 handle_qxfer_statictrace (const char *annex
,
1636 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1637 ULONGEST offset
, LONGEST len
)
1639 client_state
&cs
= get_client_state ();
1642 if (writebuf
!= NULL
)
1645 if (annex
[0] != '\0' || current_thread
== NULL
1646 || cs
.current_traceframe
== -1)
1649 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1650 readbuf
, len
, &nbytes
))
1655 /* Helper for handle_qxfer_threads_proper.
1656 Emit the XML to describe the thread of INF. */
1659 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1661 ptid_t ptid
= ptid_of (thread
);
1663 int core
= target_core_of_thread (ptid
);
1665 const char *name
= target_thread_name (ptid
);
1668 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1670 write_ptid (ptid_s
, ptid
);
1672 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1676 sprintf (core_s
, "%d", core
);
1677 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1681 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1685 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1686 bin2hex (handle
, handle_s
, handle_len
);
1687 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1690 buffer_xml_printf (buffer
, "/>\n");
1693 /* Helper for handle_qxfer_threads. */
1696 handle_qxfer_threads_proper (struct buffer
*buffer
)
1698 buffer_grow_str (buffer
, "<threads>\n");
1700 for_each_thread ([&] (thread_info
*thread
)
1702 handle_qxfer_threads_worker (thread
, buffer
);
1705 buffer_grow_str0 (buffer
, "</threads>\n");
1708 /* Handle qXfer:threads:read. */
1711 handle_qxfer_threads (const char *annex
,
1712 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1713 ULONGEST offset
, LONGEST len
)
1715 static char *result
= 0;
1716 static unsigned int result_length
= 0;
1718 if (writebuf
!= NULL
)
1721 if (annex
[0] != '\0')
1726 struct buffer buffer
;
1727 /* When asked for data at offset 0, generate everything and store into
1728 'result'. Successive reads will be served off 'result'. */
1732 buffer_init (&buffer
);
1734 handle_qxfer_threads_proper (&buffer
);
1736 result
= buffer_finish (&buffer
);
1737 result_length
= strlen (result
);
1738 buffer_free (&buffer
);
1741 if (offset
>= result_length
)
1743 /* We're out of data. */
1750 if (len
> result_length
- offset
)
1751 len
= result_length
- offset
;
1753 memcpy (readbuf
, result
+ offset
, len
);
1758 /* Handle qXfer:traceframe-info:read. */
1761 handle_qxfer_traceframe_info (const char *annex
,
1762 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1763 ULONGEST offset
, LONGEST len
)
1765 client_state
&cs
= get_client_state ();
1766 static char *result
= 0;
1767 static unsigned int result_length
= 0;
1769 if (writebuf
!= NULL
)
1772 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1777 struct buffer buffer
;
1779 /* When asked for data at offset 0, generate everything and
1780 store into 'result'. Successive reads will be served off
1784 buffer_init (&buffer
);
1786 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1788 result
= buffer_finish (&buffer
);
1789 result_length
= strlen (result
);
1790 buffer_free (&buffer
);
1793 if (offset
>= result_length
)
1795 /* We're out of data. */
1802 if (len
> result_length
- offset
)
1803 len
= result_length
- offset
;
1805 memcpy (readbuf
, result
+ offset
, len
);
1809 /* Handle qXfer:fdpic:read. */
1812 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1813 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1815 if (the_target
->read_loadmap
== NULL
)
1818 if (current_thread
== NULL
)
1821 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1824 /* Handle qXfer:btrace:read. */
1827 handle_qxfer_btrace (const char *annex
,
1828 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1829 ULONGEST offset
, LONGEST len
)
1831 client_state
&cs
= get_client_state ();
1832 static struct buffer cache
;
1833 struct thread_info
*thread
;
1834 enum btrace_read_type type
;
1837 if (writebuf
!= NULL
)
1840 if (cs
.general_thread
== null_ptid
1841 || cs
.general_thread
== minus_one_ptid
)
1843 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1847 thread
= find_thread_ptid (cs
.general_thread
);
1850 strcpy (cs
.own_buf
, "E.No such thread.");
1854 if (thread
->btrace
== NULL
)
1856 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1860 if (strcmp (annex
, "all") == 0)
1861 type
= BTRACE_READ_ALL
;
1862 else if (strcmp (annex
, "new") == 0)
1863 type
= BTRACE_READ_NEW
;
1864 else if (strcmp (annex
, "delta") == 0)
1865 type
= BTRACE_READ_DELTA
;
1868 strcpy (cs
.own_buf
, "E.Bad annex.");
1874 buffer_free (&cache
);
1878 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1880 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1882 catch (const gdb_exception_error
&exception
)
1884 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1891 else if (offset
> cache
.used_size
)
1893 buffer_free (&cache
);
1897 if (len
> cache
.used_size
- offset
)
1898 len
= cache
.used_size
- offset
;
1900 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1905 /* Handle qXfer:btrace-conf:read. */
1908 handle_qxfer_btrace_conf (const char *annex
,
1909 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1910 ULONGEST offset
, LONGEST len
)
1912 client_state
&cs
= get_client_state ();
1913 static struct buffer cache
;
1914 struct thread_info
*thread
;
1917 if (writebuf
!= NULL
)
1920 if (annex
[0] != '\0')
1923 if (cs
.general_thread
== null_ptid
1924 || cs
.general_thread
== minus_one_ptid
)
1926 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1930 thread
= find_thread_ptid (cs
.general_thread
);
1933 strcpy (cs
.own_buf
, "E.No such thread.");
1937 if (thread
->btrace
== NULL
)
1939 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1945 buffer_free (&cache
);
1949 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1951 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1953 catch (const gdb_exception_error
&exception
)
1955 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1962 else if (offset
> cache
.used_size
)
1964 buffer_free (&cache
);
1968 if (len
> cache
.used_size
- offset
)
1969 len
= cache
.used_size
- offset
;
1971 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1976 static const struct qxfer qxfer_packets
[] =
1978 { "auxv", handle_qxfer_auxv
},
1979 { "btrace", handle_qxfer_btrace
},
1980 { "btrace-conf", handle_qxfer_btrace_conf
},
1981 { "exec-file", handle_qxfer_exec_file
},
1982 { "fdpic", handle_qxfer_fdpic
},
1983 { "features", handle_qxfer_features
},
1984 { "libraries", handle_qxfer_libraries
},
1985 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1986 { "osdata", handle_qxfer_osdata
},
1987 { "siginfo", handle_qxfer_siginfo
},
1988 { "spu", handle_qxfer_spu
},
1989 { "statictrace", handle_qxfer_statictrace
},
1990 { "threads", handle_qxfer_threads
},
1991 { "traceframe-info", handle_qxfer_traceframe_info
},
1995 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2003 if (!startswith (own_buf
, "qXfer:"))
2006 /* Grab the object, r/w and annex. */
2007 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2009 write_enn (own_buf
);
2014 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2017 const struct qxfer
*q
= &qxfer_packets
[i
];
2019 if (strcmp (object
, q
->object
) == 0)
2021 if (strcmp (rw
, "read") == 0)
2023 unsigned char *data
;
2028 /* Grab the offset and length. */
2029 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2031 write_enn (own_buf
);
2035 /* Read one extra byte, as an indicator of whether there is
2037 if (len
> PBUFSIZ
- 2)
2039 data
= (unsigned char *) malloc (len
+ 1);
2042 write_enn (own_buf
);
2045 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2053 /* Preserve error message. */
2056 write_enn (own_buf
);
2058 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2060 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2065 else if (strcmp (rw
, "write") == 0)
2070 unsigned char *data
;
2072 strcpy (own_buf
, "E00");
2073 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2076 write_enn (own_buf
);
2079 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2080 &ofs
, &len
, data
) < 0)
2083 write_enn (own_buf
);
2087 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2095 /* Preserve error message. */
2098 write_enn (own_buf
);
2100 sprintf (own_buf
, "%x", n
);
2113 /* Compute 32 bit CRC from inferior memory.
2115 On success, return 32 bit CRC.
2116 On failure, return (unsigned long long) -1. */
2118 static unsigned long long
2119 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2123 unsigned char byte
= 0;
2125 /* Return failure if memory read fails. */
2126 if (read_inferior_memory (base
, &byte
, 1) != 0)
2127 return (unsigned long long) -1;
2129 crc
= xcrc32 (&byte
, 1, crc
);
2132 return (unsigned long long) crc
;
2135 /* Add supported btrace packets to BUF. */
2138 supported_btrace_packets (char *buf
)
2140 strcat (buf
, ";Qbtrace:bts+");
2141 strcat (buf
, ";Qbtrace-conf:bts:size+");
2142 strcat (buf
, ";Qbtrace:pt+");
2143 strcat (buf
, ";Qbtrace-conf:pt:size+");
2144 strcat (buf
, ";Qbtrace:off+");
2145 strcat (buf
, ";qXfer:btrace:read+");
2146 strcat (buf
, ";qXfer:btrace-conf:read+");
2149 /* Handle all of the extended 'q' packets. */
2152 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2154 client_state
&cs
= get_client_state ();
2155 static std::list
<thread_info
*>::const_iterator thread_iter
;
2157 /* Reply the current thread id. */
2158 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2161 require_running_or_return (own_buf
);
2163 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2164 ptid
= cs
.general_thread
;
2167 thread_iter
= all_threads
.begin ();
2168 ptid
= (*thread_iter
)->id
;
2171 sprintf (own_buf
, "QC");
2173 write_ptid (own_buf
, ptid
);
2177 if (strcmp ("qSymbol::", own_buf
) == 0)
2179 struct thread_info
*save_thread
= current_thread
;
2181 /* For qSymbol, GDB only changes the current thread if the
2182 previous current thread was of a different process. So if
2183 the previous thread is gone, we need to pick another one of
2184 the same process. This can happen e.g., if we followed an
2185 exec in a non-leader thread. */
2186 if (current_thread
== NULL
)
2189 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2191 /* Just in case, if we didn't find a thread, then bail out
2192 instead of crashing. */
2193 if (current_thread
== NULL
)
2195 write_enn (own_buf
);
2196 current_thread
= save_thread
;
2201 /* GDB is suggesting new symbols have been loaded. This may
2202 mean a new shared library has been detected as loaded, so
2203 take the opportunity to check if breakpoints we think are
2204 inserted, still are. Note that it isn't guaranteed that
2205 we'll see this when a shared library is loaded, and nor will
2206 we see this for unloads (although breakpoints in unloaded
2207 libraries shouldn't trigger), as GDB may not find symbols for
2208 the library at all. We also re-validate breakpoints when we
2209 see a second GDB breakpoint for the same address, and or when
2210 we access breakpoint shadows. */
2211 validate_breakpoints ();
2213 if (target_supports_tracepoints ())
2214 tracepoint_look_up_symbols ();
2216 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2217 (*the_target
->look_up_symbols
) ();
2219 current_thread
= save_thread
;
2221 strcpy (own_buf
, "OK");
2225 if (!disable_packet_qfThreadInfo
)
2227 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2229 require_running_or_return (own_buf
);
2230 thread_iter
= all_threads
.begin ();
2233 ptid_t ptid
= (*thread_iter
)->id
;
2234 write_ptid (own_buf
, ptid
);
2239 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2241 require_running_or_return (own_buf
);
2242 if (thread_iter
!= all_threads
.end ())
2245 ptid_t ptid
= (*thread_iter
)->id
;
2246 write_ptid (own_buf
, ptid
);
2252 sprintf (own_buf
, "l");
2258 if (the_target
->read_offsets
!= NULL
2259 && strcmp ("qOffsets", own_buf
) == 0)
2261 CORE_ADDR text
, data
;
2263 require_running_or_return (own_buf
);
2264 if (the_target
->read_offsets (&text
, &data
))
2265 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2266 (long)text
, (long)data
, (long)data
);
2268 write_enn (own_buf
);
2273 /* Protocol features query. */
2274 if (startswith (own_buf
, "qSupported")
2275 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2277 char *p
= &own_buf
[10];
2278 int gdb_supports_qRelocInsn
= 0;
2280 /* Process each feature being provided by GDB. The first
2281 feature will follow a ':', and latter features will follow
2285 char **qsupported
= NULL
;
2290 /* Two passes, to avoid nested strtok calls in
2291 target_process_qsupported. */
2292 for (p
= strtok (p
+ 1, ";");
2294 p
= strtok (NULL
, ";"))
2297 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2298 qsupported
[count
- 1] = xstrdup (p
);
2301 for (i
= 0; i
< count
; i
++)
2304 if (strcmp (p
, "multiprocess+") == 0)
2306 /* GDB supports and wants multi-process support if
2308 if (target_supports_multi_process ())
2309 cs
.multi_process
= 1;
2311 else if (strcmp (p
, "qRelocInsn+") == 0)
2313 /* GDB supports relocate instruction requests. */
2314 gdb_supports_qRelocInsn
= 1;
2316 else if (strcmp (p
, "swbreak+") == 0)
2318 /* GDB wants us to report whether a trap is caused
2319 by a software breakpoint and for us to handle PC
2320 adjustment if necessary on this target. */
2321 if (target_supports_stopped_by_sw_breakpoint ())
2322 cs
.swbreak_feature
= 1;
2324 else if (strcmp (p
, "hwbreak+") == 0)
2326 /* GDB wants us to report whether a trap is caused
2327 by a hardware breakpoint. */
2328 if (target_supports_stopped_by_hw_breakpoint ())
2329 cs
.hwbreak_feature
= 1;
2331 else if (strcmp (p
, "fork-events+") == 0)
2333 /* GDB supports and wants fork events if possible. */
2334 if (target_supports_fork_events ())
2335 cs
.report_fork_events
= 1;
2337 else if (strcmp (p
, "vfork-events+") == 0)
2339 /* GDB supports and wants vfork events if possible. */
2340 if (target_supports_vfork_events ())
2341 cs
.report_vfork_events
= 1;
2343 else if (strcmp (p
, "exec-events+") == 0)
2345 /* GDB supports and wants exec events if possible. */
2346 if (target_supports_exec_events ())
2347 cs
.report_exec_events
= 1;
2349 else if (strcmp (p
, "vContSupported+") == 0)
2350 cs
.vCont_supported
= 1;
2351 else if (strcmp (p
, "QThreadEvents+") == 0)
2353 else if (strcmp (p
, "no-resumed+") == 0)
2355 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2357 report_no_resumed
= 1;
2361 /* Move the unknown features all together. */
2362 qsupported
[i
] = NULL
;
2363 qsupported
[unknown
] = p
;
2368 /* Give the target backend a chance to process the unknown
2370 target_process_qsupported (qsupported
, unknown
);
2372 for (i
= 0; i
< count
; i
++)
2373 free (qsupported
[i
]);
2378 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2379 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2380 "QEnvironmentReset+;QEnvironmentUnset+;"
2384 if (target_supports_catch_syscall ())
2385 strcat (own_buf
, ";QCatchSyscalls+");
2387 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2388 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2389 ";augmented-libraries-svr4-read+");
2392 /* We do not have any hook to indicate whether the non-SVR4 target
2393 backend supports qXfer:libraries:read, so always report it. */
2394 strcat (own_buf
, ";qXfer:libraries:read+");
2397 if (the_target
->read_auxv
!= NULL
)
2398 strcat (own_buf
, ";qXfer:auxv:read+");
2400 if (the_target
->qxfer_spu
!= NULL
)
2401 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2403 if (the_target
->qxfer_siginfo
!= NULL
)
2404 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2406 if (the_target
->read_loadmap
!= NULL
)
2407 strcat (own_buf
, ";qXfer:fdpic:read+");
2409 /* We always report qXfer:features:read, as targets may
2410 install XML files on a subsequent call to arch_setup.
2411 If we reported to GDB on startup that we don't support
2412 qXfer:feature:read at all, we will never be re-queried. */
2413 strcat (own_buf
, ";qXfer:features:read+");
2415 if (cs
.transport_is_reliable
)
2416 strcat (own_buf
, ";QStartNoAckMode+");
2418 if (the_target
->qxfer_osdata
!= NULL
)
2419 strcat (own_buf
, ";qXfer:osdata:read+");
2421 if (target_supports_multi_process ())
2422 strcat (own_buf
, ";multiprocess+");
2424 if (target_supports_fork_events ())
2425 strcat (own_buf
, ";fork-events+");
2427 if (target_supports_vfork_events ())
2428 strcat (own_buf
, ";vfork-events+");
2430 if (target_supports_exec_events ())
2431 strcat (own_buf
, ";exec-events+");
2433 if (target_supports_non_stop ())
2434 strcat (own_buf
, ";QNonStop+");
2436 if (target_supports_disable_randomization ())
2437 strcat (own_buf
, ";QDisableRandomization+");
2439 strcat (own_buf
, ";qXfer:threads:read+");
2441 if (target_supports_tracepoints ())
2443 strcat (own_buf
, ";ConditionalTracepoints+");
2444 strcat (own_buf
, ";TraceStateVariables+");
2445 strcat (own_buf
, ";TracepointSource+");
2446 strcat (own_buf
, ";DisconnectedTracing+");
2447 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2448 strcat (own_buf
, ";FastTracepoints+");
2449 strcat (own_buf
, ";StaticTracepoints+");
2450 strcat (own_buf
, ";InstallInTrace+");
2451 strcat (own_buf
, ";qXfer:statictrace:read+");
2452 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2453 strcat (own_buf
, ";EnableDisableTracepoints+");
2454 strcat (own_buf
, ";QTBuffer:size+");
2455 strcat (own_buf
, ";tracenz+");
2458 if (target_supports_hardware_single_step ()
2459 || target_supports_software_single_step () )
2461 strcat (own_buf
, ";ConditionalBreakpoints+");
2463 strcat (own_buf
, ";BreakpointCommands+");
2465 if (target_supports_agent ())
2466 strcat (own_buf
, ";QAgent+");
2468 supported_btrace_packets (own_buf
);
2470 if (target_supports_stopped_by_sw_breakpoint ())
2471 strcat (own_buf
, ";swbreak+");
2473 if (target_supports_stopped_by_hw_breakpoint ())
2474 strcat (own_buf
, ";hwbreak+");
2476 if (the_target
->pid_to_exec_file
!= NULL
)
2477 strcat (own_buf
, ";qXfer:exec-file:read+");
2479 strcat (own_buf
, ";vContSupported+");
2481 strcat (own_buf
, ";QThreadEvents+");
2483 strcat (own_buf
, ";no-resumed+");
2485 /* Reinitialize components as needed for the new connection. */
2486 hostio_handle_new_gdb_connection ();
2487 target_handle_new_gdb_connection ();
2492 /* Thread-local storage support. */
2493 if (the_target
->get_tls_address
!= NULL
2494 && startswith (own_buf
, "qGetTLSAddr:"))
2496 char *p
= own_buf
+ 12;
2497 CORE_ADDR parts
[2], address
= 0;
2499 ptid_t ptid
= null_ptid
;
2501 require_running_or_return (own_buf
);
2503 for (i
= 0; i
< 3; i
++)
2511 p2
= strchr (p
, ',');
2524 ptid
= read_ptid (p
, NULL
);
2526 decode_address (&parts
[i
- 1], p
, len
);
2530 if (p
!= NULL
|| i
< 3)
2534 struct thread_info
*thread
= find_thread_ptid (ptid
);
2539 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2545 strcpy (own_buf
, paddress(address
));
2550 write_enn (own_buf
);
2554 /* Otherwise, pretend we do not understand this packet. */
2557 /* Windows OS Thread Information Block address support. */
2558 if (the_target
->get_tib_address
!= NULL
2559 && startswith (own_buf
, "qGetTIBAddr:"))
2564 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2566 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2569 strcpy (own_buf
, paddress(tlb
));
2574 write_enn (own_buf
);
2580 /* Handle "monitor" commands. */
2581 if (startswith (own_buf
, "qRcmd,"))
2583 char *mon
= (char *) malloc (PBUFSIZ
);
2584 int len
= strlen (own_buf
+ 6);
2588 write_enn (own_buf
);
2593 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2595 write_enn (own_buf
);
2599 mon
[len
/ 2] = '\0';
2603 if (the_target
->handle_monitor_command
== NULL
2604 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2605 /* Default processing. */
2606 handle_monitor_command (mon
, own_buf
);
2612 if (startswith (own_buf
, "qSearch:memory:"))
2614 require_running_or_return (own_buf
);
2615 handle_search_memory (own_buf
, packet_len
);
2619 if (strcmp (own_buf
, "qAttached") == 0
2620 || startswith (own_buf
, "qAttached:"))
2622 struct process_info
*process
;
2624 if (own_buf
[sizeof ("qAttached") - 1])
2626 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2627 process
= find_process_pid (pid
);
2631 require_running_or_return (own_buf
);
2632 process
= current_process ();
2635 if (process
== NULL
)
2637 write_enn (own_buf
);
2641 strcpy (own_buf
, process
->attached
? "1" : "0");
2645 if (startswith (own_buf
, "qCRC:"))
2647 /* CRC check (compare-section). */
2651 unsigned long long crc
;
2653 require_running_or_return (own_buf
);
2654 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2655 if (*comma
++ != ',')
2657 write_enn (own_buf
);
2660 len
= strtoul (comma
, NULL
, 16);
2661 crc
= crc32 (base
, len
, 0xffffffff);
2662 /* Check for memory failure. */
2663 if (crc
== (unsigned long long) -1)
2665 write_enn (own_buf
);
2668 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2672 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2675 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2678 /* Otherwise we didn't know what packet it was. Say we didn't
2683 static void gdb_wants_all_threads_stopped (void);
2684 static void resume (struct thread_resume
*actions
, size_t n
);
2686 /* The callback that is passed to visit_actioned_threads. */
2687 typedef int (visit_actioned_threads_callback_ftype
)
2688 (const struct thread_resume
*, struct thread_info
*);
2690 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2691 true if CALLBACK returns true. Returns false if no matching thread
2692 is found or CALLBACK results false.
2693 Note: This function is itself a callback for find_thread. */
2696 visit_actioned_threads (thread_info
*thread
,
2697 const struct thread_resume
*actions
,
2699 visit_actioned_threads_callback_ftype
*callback
)
2701 for (size_t i
= 0; i
< num_actions
; i
++)
2703 const struct thread_resume
*action
= &actions
[i
];
2705 if (action
->thread
== minus_one_ptid
2706 || action
->thread
== thread
->id
2707 || ((action
->thread
.pid ()
2708 == thread
->id
.pid ())
2709 && action
->thread
.lwp () == -1))
2711 if ((*callback
) (action
, thread
))
2719 /* Callback for visit_actioned_threads. If the thread has a pending
2720 status to report, report it now. */
2723 handle_pending_status (const struct thread_resume
*resumption
,
2724 struct thread_info
*thread
)
2726 client_state
&cs
= get_client_state ();
2727 if (thread
->status_pending_p
)
2729 thread
->status_pending_p
= 0;
2731 cs
.last_status
= thread
->last_status
;
2732 cs
.last_ptid
= thread
->id
;
2733 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2739 /* Parse vCont packets. */
2741 handle_v_cont (char *own_buf
)
2745 struct thread_resume
*resume_info
;
2746 struct thread_resume default_action
{ null_ptid
};
2748 /* Count the number of semicolons in the packet. There should be one
2749 for every action. */
2755 p
= strchr (p
, ';');
2758 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2759 if (resume_info
== NULL
)
2767 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2769 if (p
[0] == 's' || p
[0] == 'S')
2770 resume_info
[i
].kind
= resume_step
;
2771 else if (p
[0] == 'r')
2772 resume_info
[i
].kind
= resume_step
;
2773 else if (p
[0] == 'c' || p
[0] == 'C')
2774 resume_info
[i
].kind
= resume_continue
;
2775 else if (p
[0] == 't')
2776 resume_info
[i
].kind
= resume_stop
;
2780 if (p
[0] == 'S' || p
[0] == 'C')
2783 int sig
= strtol (p
+ 1, &q
, 16);
2788 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2790 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2792 else if (p
[0] == 'r')
2796 p
= unpack_varlen_hex (p
+ 1, &addr
);
2797 resume_info
[i
].step_range_start
= addr
;
2802 p
= unpack_varlen_hex (p
+ 1, &addr
);
2803 resume_info
[i
].step_range_end
= addr
;
2812 resume_info
[i
].thread
= minus_one_ptid
;
2813 default_action
= resume_info
[i
];
2815 /* Note: we don't increment i here, we'll overwrite this entry
2816 the next time through. */
2818 else if (p
[0] == ':')
2821 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2826 if (p
[0] != ';' && p
[0] != 0)
2829 resume_info
[i
].thread
= ptid
;
2836 resume_info
[i
] = default_action
;
2838 resume (resume_info
, n
);
2843 write_enn (own_buf
);
2848 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2851 resume (struct thread_resume
*actions
, size_t num_actions
)
2853 client_state
&cs
= get_client_state ();
2856 /* Check if among the threads that GDB wants actioned, there's
2857 one with a pending status to report. If so, skip actually
2858 resuming/stopping and report the pending event
2861 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2863 return visit_actioned_threads (thread
, actions
, num_actions
,
2864 handle_pending_status
);
2867 if (thread_with_status
!= NULL
)
2873 (*the_target
->resume
) (actions
, num_actions
);
2876 write_ok (cs
.own_buf
);
2879 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2881 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2882 && !report_no_resumed
)
2884 /* The client does not support this stop reply. At least
2886 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2887 disable_async_io ();
2891 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2892 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2893 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2894 current_thread
->last_status
= cs
.last_status
;
2896 /* From the client's perspective, all-stop mode always stops all
2897 threads implicitly (and the target backend has already done
2898 so by now). Tag all threads as "want-stopped", so we don't
2899 resume them implicitly without the client telling us to. */
2900 gdb_wants_all_threads_stopped ();
2901 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2902 disable_async_io ();
2904 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2905 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2906 target_mourn_inferior (cs
.last_ptid
);
2910 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2912 handle_v_attach (char *own_buf
)
2914 client_state
&cs
= get_client_state ();
2917 pid
= strtol (own_buf
+ 8, NULL
, 16);
2918 if (pid
!= 0 && attach_inferior (pid
) == 0)
2920 /* Don't report shared library events after attaching, even if
2921 some libraries are preloaded. GDB will always poll the
2922 library list. Avoids the "stopped by shared library event"
2923 notice on the GDB side. */
2928 /* In non-stop, we don't send a resume reply. Stop events
2929 will follow up using the normal notification
2934 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2940 write_enn (own_buf
);
2945 /* Run a new program. Return 1 if successful, 0 if failure. */
2947 handle_v_run (char *own_buf
)
2949 client_state
&cs
= get_client_state ();
2951 std::vector
<char *> new_argv
;
2952 char *new_program_name
= NULL
;
2956 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2962 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2964 next_p
= strchr (p
, ';');
2966 next_p
= p
+ strlen (p
);
2968 if (i
== 0 && p
== next_p
)
2970 /* No program specified. */
2971 new_program_name
= NULL
;
2973 else if (p
== next_p
)
2975 /* Empty argument. */
2976 new_argv
.push_back (xstrdup ("''"));
2980 size_t len
= (next_p
- p
) / 2;
2981 /* ARG is the unquoted argument received via the RSP. */
2982 char *arg
= (char *) xmalloc (len
+ 1);
2983 /* FULL_ARGS will contain the quoted version of ARG. */
2984 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2985 /* These are pointers used to navigate the strings above. */
2986 char *tmp_arg
= arg
;
2987 char *tmp_full_arg
= full_arg
;
2990 hex2bin (p
, (gdb_byte
*) arg
, len
);
2993 while (*tmp_arg
!= '\0')
2999 *tmp_full_arg
= '\'';
3005 /* Quote single quote. */
3006 *tmp_full_arg
= '\\';
3014 *tmp_full_arg
= *tmp_arg
;
3020 *tmp_full_arg
++ = '\'';
3022 /* Finish FULL_ARG and push it into the vector containing
3024 *tmp_full_arg
= '\0';
3026 new_program_name
= full_arg
;
3028 new_argv
.push_back (full_arg
);
3034 new_argv
.push_back (NULL
);
3036 if (new_program_name
== NULL
)
3038 /* GDB didn't specify a program to run. Use the program from the
3039 last run with the new argument list. */
3040 if (program_path
.get () == NULL
)
3042 write_enn (own_buf
);
3043 free_vector_argv (new_argv
);
3048 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3050 /* Free the old argv and install the new one. */
3051 free_vector_argv (program_args
);
3052 program_args
= new_argv
;
3054 create_inferior (program_path
.get (), program_args
);
3056 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3058 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3060 /* In non-stop, sending a resume reply doesn't set the general
3061 thread, but GDB assumes a vRun sets it (this is so GDB can
3062 query which is the main thread of the new inferior. */
3064 cs
.general_thread
= cs
.last_ptid
;
3070 write_enn (own_buf
);
3075 /* Kill process. Return 1 if successful, 0 if failure. */
3077 handle_v_kill (char *own_buf
)
3079 client_state
&cs
= get_client_state ();
3081 char *p
= &own_buf
[6];
3082 if (cs
.multi_process
)
3083 pid
= strtol (p
, NULL
, 16);
3087 process_info
*proc
= find_process_pid (pid
);
3089 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3091 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3092 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3093 cs
.last_ptid
= ptid_t (pid
);
3094 discard_queued_stop_replies (cs
.last_ptid
);
3100 write_enn (own_buf
);
3105 /* Handle all of the extended 'v' packets. */
3107 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3109 client_state
&cs
= get_client_state ();
3110 if (!disable_packet_vCont
)
3112 if (strcmp (own_buf
, "vCtrlC") == 0)
3114 (*the_target
->request_interrupt
) ();
3119 if (startswith (own_buf
, "vCont;"))
3121 handle_v_cont (own_buf
);
3125 if (startswith (own_buf
, "vCont?"))
3127 strcpy (own_buf
, "vCont;c;C;t");
3129 if (target_supports_hardware_single_step ()
3130 || target_supports_software_single_step ()
3131 || !cs
.vCont_supported
)
3133 /* If target supports single step either by hardware or by
3134 software, add actions s and S to the list of supported
3135 actions. On the other hand, if GDB doesn't request the
3136 supported vCont actions in qSupported packet, add s and
3137 S to the list too. */
3138 own_buf
= own_buf
+ strlen (own_buf
);
3139 strcpy (own_buf
, ";s;S");
3142 if (target_supports_range_stepping ())
3144 own_buf
= own_buf
+ strlen (own_buf
);
3145 strcpy (own_buf
, ";r");
3151 if (startswith (own_buf
, "vFile:")
3152 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3155 if (startswith (own_buf
, "vAttach;"))
3157 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3159 fprintf (stderr
, "Already debugging a process\n");
3160 write_enn (own_buf
);
3163 handle_v_attach (own_buf
);
3167 if (startswith (own_buf
, "vRun;"))
3169 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3171 fprintf (stderr
, "Already debugging a process\n");
3172 write_enn (own_buf
);
3175 handle_v_run (own_buf
);
3179 if (startswith (own_buf
, "vKill;"))
3181 if (!target_running ())
3183 fprintf (stderr
, "No process to kill\n");
3184 write_enn (own_buf
);
3187 handle_v_kill (own_buf
);
3191 if (handle_notif_ack (own_buf
, packet_len
))
3194 /* Otherwise we didn't know what packet it was. Say we didn't
3200 /* Resume thread and wait for another event. In non-stop mode,
3201 don't really wait here, but return immediatelly to the event
3204 myresume (char *own_buf
, int step
, int sig
)
3206 client_state
&cs
= get_client_state ();
3207 struct thread_resume resume_info
[2];
3209 int valid_cont_thread
;
3211 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3212 && cs
.cont_thread
!= minus_one_ptid
);
3214 if (step
|| sig
|| valid_cont_thread
)
3216 resume_info
[0].thread
= current_ptid
;
3218 resume_info
[0].kind
= resume_step
;
3220 resume_info
[0].kind
= resume_continue
;
3221 resume_info
[0].sig
= sig
;
3225 if (!valid_cont_thread
)
3227 resume_info
[n
].thread
= minus_one_ptid
;
3228 resume_info
[n
].kind
= resume_continue
;
3229 resume_info
[n
].sig
= 0;
3233 resume (resume_info
, n
);
3236 /* Callback for for_each_thread. Make a new stop reply for each
3240 queue_stop_reply_callback (thread_info
*thread
)
3242 /* For now, assume targets that don't have this callback also don't
3243 manage the thread's last_status field. */
3244 if (the_target
->thread_stopped
== NULL
)
3246 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3248 new_notif
->ptid
= thread
->id
;
3249 new_notif
->status
= thread
->last_status
;
3250 /* Pass the last stop reply back to GDB, but don't notify
3252 notif_event_enque (¬if_stop
,
3253 (struct notif_event
*) new_notif
);
3257 if (thread_stopped (thread
))
3261 std::string status_string
3262 = target_waitstatus_to_string (&thread
->last_status
);
3264 debug_printf ("Reporting thread %s as already stopped with %s\n",
3265 target_pid_to_str (thread
->id
),
3266 status_string
.c_str ());
3269 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3271 /* Pass the last stop reply back to GDB, but don't notify
3273 queue_stop_reply (thread
->id
, &thread
->last_status
);
3278 /* Set this inferior threads's state as "want-stopped". We won't
3279 resume this thread until the client gives us another action for
3283 gdb_wants_thread_stopped (thread_info
*thread
)
3285 thread
->last_resume_kind
= resume_stop
;
3287 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3289 /* Most threads are stopped implicitly (all-stop); tag that with
3291 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3292 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3296 /* Set all threads' states as "want-stopped". */
3299 gdb_wants_all_threads_stopped (void)
3301 for_each_thread (gdb_wants_thread_stopped
);
3304 /* Callback for for_each_thread. If the thread is stopped with an
3305 interesting event, mark it as having a pending event. */
3308 set_pending_status_callback (thread_info
*thread
)
3310 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3311 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3312 /* A breakpoint, watchpoint or finished step from a previous
3313 GDB run isn't considered interesting for a new GDB run.
3314 If we left those pending, the new GDB could consider them
3315 random SIGTRAPs. This leaves out real async traps. We'd
3316 have to peek into the (target-specific) siginfo to
3317 distinguish those. */
3318 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3319 thread
->status_pending_p
= 1;
3322 /* Status handler for the '?' packet. */
3325 handle_status (char *own_buf
)
3327 client_state
&cs
= get_client_state ();
3329 /* GDB is connected, don't forward events to the target anymore. */
3330 for_each_process ([] (process_info
*process
) {
3331 process
->gdb_detached
= 0;
3334 /* In non-stop mode, we must send a stop reply for each stopped
3335 thread. In all-stop mode, just send one for the first stopped
3340 for_each_thread (queue_stop_reply_callback
);
3342 /* The first is sent immediatly. OK is sent if there is no
3343 stopped thread, which is the same handling of the vStopped
3344 packet (by design). */
3345 notif_write_event (¬if_stop
, cs
.own_buf
);
3349 thread_info
*thread
= NULL
;
3352 stabilize_threads ();
3353 gdb_wants_all_threads_stopped ();
3355 /* We can only report one status, but we might be coming out of
3356 non-stop -- if more than one thread is stopped with
3357 interesting events, leave events for the threads we're not
3358 reporting now pending. They'll be reported the next time the
3359 threads are resumed. Start by marking all interesting events
3361 for_each_thread (set_pending_status_callback
);
3363 /* Prefer the last thread that reported an event to GDB (even if
3364 that was a GDB_SIGNAL_TRAP). */
3365 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3366 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3367 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3368 thread
= find_thread_ptid (cs
.last_ptid
);
3370 /* If the last event thread is not found for some reason, look
3371 for some other thread that might have an event to report. */
3373 thread
= find_thread ([] (thread_info
*thr_arg
)
3375 return thr_arg
->status_pending_p
;
3378 /* If we're still out of luck, simply pick the first thread in
3381 thread
= get_first_thread ();
3385 struct thread_info
*tp
= (struct thread_info
*) thread
;
3387 /* We're reporting this event, so it's no longer
3389 tp
->status_pending_p
= 0;
3391 /* GDB assumes the current thread is the thread we're
3392 reporting the status for. */
3393 cs
.general_thread
= thread
->id
;
3394 set_desired_thread ();
3396 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3397 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3400 strcpy (own_buf
, "W00");
3405 gdbserver_version (void)
3407 printf ("GNU gdbserver %s%s\n"
3408 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3409 "gdbserver is free software, covered by the "
3410 "GNU General Public License.\n"
3411 "This gdbserver was configured as \"%s\"\n",
3412 PKGVERSION
, version
, host_name
);
3416 gdbserver_usage (FILE *stream
)
3418 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3419 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3420 "\tgdbserver [OPTIONS] --multi COMM\n"
3422 "COMM may either be a tty device (for serial debugging),\n"
3423 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3424 "stdin/stdout of gdbserver.\n"
3425 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3426 "PID is the process ID to attach to, when --attach is specified.\n"
3428 "Operating modes:\n"
3430 " --attach Attach to running process PID.\n"
3431 " --multi Start server without a specific program, and\n"
3432 " only quit when explicitly commanded.\n"
3433 " --once Exit after the first connection has closed.\n"
3434 " --help Print this message and then exit.\n"
3435 " --version Display version information and exit.\n"
3439 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3440 " --disable-randomization\n"
3441 " Run PROG with address space randomization disabled.\n"
3442 " --no-disable-randomization\n"
3443 " Don't disable address space randomization when\n"
3445 " --startup-with-shell\n"
3446 " Start PROG using a shell. I.e., execs a shell that\n"
3447 " then execs PROG. (default)\n"
3448 " --no-startup-with-shell\n"
3449 " Exec PROG directly instead of using a shell.\n"
3450 " Disables argument globbing and variable substitution\n"
3451 " on UNIX-like systems.\n"
3455 " --debug Enable general debugging output.\n"
3456 " --debug-format=OPT1[,OPT2,...]\n"
3457 " Specify extra content in debugging output.\n"
3462 " --remote-debug Enable remote protocol debugging output.\n"
3463 " --disable-packet=OPT1[,OPT2,...]\n"
3464 " Disable support for RSP packets or features.\n"
3466 " vCont, Tthread, qC, qfThreadInfo and \n"
3467 " threads (disable all threading packets).\n"
3469 "For more information, consult the GDB manual (available as on-line \n"
3470 "info or a printed manual).\n");
3471 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3472 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3476 gdbserver_show_disableable (FILE *stream
)
3478 fprintf (stream
, "Disableable packets:\n"
3479 " vCont \tAll vCont packets\n"
3480 " qC \tQuerying the current thread\n"
3481 " qfThreadInfo\tThread listing\n"
3482 " Tthread \tPassing the thread specifier in the "
3483 "T stop reply packet\n"
3484 " threads \tAll of the above\n");
3488 kill_inferior_callback (process_info
*process
)
3490 kill_inferior (process
);
3491 discard_queued_stop_replies (ptid_t (process
->pid
));
3494 /* Call this when exiting gdbserver with possible inferiors that need
3495 to be killed or detached from. */
3498 detach_or_kill_for_exit (void)
3500 /* First print a list of the inferiors we will be killing/detaching.
3501 This is to assist the user, for example, in case the inferior unexpectedly
3502 dies after we exit: did we screw up or did the inferior exit on its own?
3503 Having this info will save some head-scratching. */
3505 if (have_started_inferiors_p ())
3507 fprintf (stderr
, "Killing process(es):");
3509 for_each_process ([] (process_info
*process
) {
3510 if (!process
->attached
)
3511 fprintf (stderr
, " %d", process
->pid
);
3514 fprintf (stderr
, "\n");
3516 if (have_attached_inferiors_p ())
3518 fprintf (stderr
, "Detaching process(es):");
3520 for_each_process ([] (process_info
*process
) {
3521 if (process
->attached
)
3522 fprintf (stderr
, " %d", process
->pid
);
3525 fprintf (stderr
, "\n");
3528 /* Now we can kill or detach the inferiors. */
3529 for_each_process ([] (process_info
*process
) {
3530 int pid
= process
->pid
;
3532 if (process
->attached
)
3533 detach_inferior (process
);
3535 kill_inferior (process
);
3537 discard_queued_stop_replies (ptid_t (pid
));
3541 /* Value that will be passed to exit(3) when gdbserver exits. */
3542 static int exit_code
;
3544 /* Wrapper for detach_or_kill_for_exit that catches and prints
3548 detach_or_kill_for_exit_cleanup ()
3552 detach_or_kill_for_exit ();
3554 catch (const gdb_exception
&exception
)
3557 fprintf (stderr
, "Detach or kill failed: %s\n",
3563 /* Main function. This is called by the real "main" function,
3564 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3566 static void ATTRIBUTE_NORETURN
3567 captured_main (int argc
, char *argv
[])
3572 const char *port
= NULL
;
3573 char **next_arg
= &argv
[1];
3574 volatile int multi_mode
= 0;
3575 volatile int attach
= 0;
3577 bool selftest
= false;
3579 const char *selftest_filter
= NULL
;
3582 current_directory
= getcwd (NULL
, 0);
3583 client_state
&cs
= get_client_state ();
3585 if (current_directory
== NULL
)
3587 error (_("Could not find current working directory: %s"),
3588 safe_strerror (errno
));
3591 while (*next_arg
!= NULL
&& **next_arg
== '-')
3593 if (strcmp (*next_arg
, "--version") == 0)
3595 gdbserver_version ();
3598 else if (strcmp (*next_arg
, "--help") == 0)
3600 gdbserver_usage (stdout
);
3603 else if (strcmp (*next_arg
, "--attach") == 0)
3605 else if (strcmp (*next_arg
, "--multi") == 0)
3607 else if (strcmp (*next_arg
, "--wrapper") == 0)
3614 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3616 wrapper_argv
+= *next_arg
;
3617 wrapper_argv
+= ' ';
3621 if (!wrapper_argv
.empty ())
3623 /* Erase the last whitespace. */
3624 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3627 if (next_arg
== tmp
|| *next_arg
== NULL
)
3629 gdbserver_usage (stderr
);
3633 /* Consume the "--". */
3636 else if (strcmp (*next_arg
, "--debug") == 0)
3638 else if (startswith (*next_arg
, "--debug-format="))
3640 std::string error_msg
3641 = parse_debug_format_options ((*next_arg
)
3642 + sizeof ("--debug-format=") - 1, 0);
3644 if (!error_msg
.empty ())
3646 fprintf (stderr
, "%s", error_msg
.c_str ());
3650 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3652 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3654 gdbserver_show_disableable (stdout
);
3657 else if (startswith (*next_arg
, "--disable-packet="))
3659 char *packets
, *tok
;
3661 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3662 for (tok
= strtok (packets
, ",");
3664 tok
= strtok (NULL
, ","))
3666 if (strcmp ("vCont", tok
) == 0)
3667 disable_packet_vCont
= 1;
3668 else if (strcmp ("Tthread", tok
) == 0)
3669 disable_packet_Tthread
= 1;
3670 else if (strcmp ("qC", tok
) == 0)
3671 disable_packet_qC
= 1;
3672 else if (strcmp ("qfThreadInfo", tok
) == 0)
3673 disable_packet_qfThreadInfo
= 1;
3674 else if (strcmp ("threads", tok
) == 0)
3676 disable_packet_vCont
= 1;
3677 disable_packet_Tthread
= 1;
3678 disable_packet_qC
= 1;
3679 disable_packet_qfThreadInfo
= 1;
3683 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3685 gdbserver_show_disableable (stderr
);
3690 else if (strcmp (*next_arg
, "-") == 0)
3692 /* "-" specifies a stdio connection and is a form of port
3694 port
= STDIO_CONNECTION_NAME
;
3698 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3699 cs
.disable_randomization
= 1;
3700 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3701 cs
.disable_randomization
= 0;
3702 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3703 startup_with_shell
= true;
3704 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3705 startup_with_shell
= false;
3706 else if (strcmp (*next_arg
, "--once") == 0)
3708 else if (strcmp (*next_arg
, "--selftest") == 0)
3710 else if (startswith (*next_arg
, "--selftest="))
3714 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3719 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3732 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3735 gdbserver_usage (stderr
);
3739 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3740 opened by remote_prepare. */
3743 save_original_signals_state (false);
3745 /* We need to know whether the remote connection is stdio before
3746 starting the inferior. Inferiors created in this scenario have
3747 stdin,stdout redirected. So do this here before we call
3750 remote_prepare (port
);
3755 /* --attach used to come after PORT, so allow it there for
3757 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3764 && (*next_arg
== NULL
3765 || (*next_arg
)[0] == '\0'
3766 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3768 || next_arg
[1] != NULL
))
3773 gdbserver_usage (stderr
);
3777 /* Gather information about the environment. */
3778 our_environ
= gdb_environ::from_host_environ ();
3780 initialize_async_io ();
3782 have_job_control ();
3783 initialize_event_loop ();
3784 if (target_supports_tracepoints ())
3785 initialize_tracepoint ();
3786 initialize_notif ();
3788 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3793 selftests::run_tests (selftest_filter
);
3795 printf (_("Selftests have been disabled for this build.\n"));
3797 throw_quit ("Quit");
3800 if (pid
== 0 && *next_arg
!= NULL
)
3804 n
= argc
- (next_arg
- argv
);
3805 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3806 for (i
= 1; i
< n
; i
++)
3807 program_args
.push_back (xstrdup (next_arg
[i
]));
3808 program_args
.push_back (NULL
);
3810 /* Wait till we are at first instruction in program. */
3811 create_inferior (program_path
.get (), program_args
);
3813 /* We are now (hopefully) stopped at the first instruction of
3814 the target process. This assumes that the target process was
3815 successfully created. */
3819 if (attach_inferior (pid
) == -1)
3820 error ("Attaching not supported on this target");
3822 /* Otherwise succeeded. */
3826 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3827 cs
.last_status
.value
.integer
= 0;
3828 cs
.last_ptid
= minus_one_ptid
;
3831 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3833 /* Don't report shared library events on the initial connection,
3834 even if some libraries are preloaded. Avoids the "stopped by
3835 shared library event" notice on gdb side. */
3838 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3839 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3844 if (!was_running
&& !multi_mode
)
3845 error ("No program to debug");
3850 cs
.multi_process
= 0;
3851 cs
.report_fork_events
= 0;
3852 cs
.report_vfork_events
= 0;
3853 cs
.report_exec_events
= 0;
3854 /* Be sure we're out of tfind mode. */
3855 cs
.current_traceframe
= -1;
3856 cs
.cont_thread
= null_ptid
;
3857 cs
.swbreak_feature
= 0;
3858 cs
.hwbreak_feature
= 0;
3859 cs
.vCont_supported
= 0;
3865 /* Wait for events. This will return when all event sources
3866 are removed from the event loop. */
3867 start_event_loop ();
3869 /* If an exit was requested (using the "monitor exit"
3870 command), terminate now. */
3872 throw_quit ("Quit");
3874 /* The only other way to get here is for getpkt to fail:
3876 - If --once was specified, we're done.
3878 - If not in extended-remote mode, and we're no longer
3879 debugging anything, simply exit: GDB has disconnected
3880 after processing the last process exit.
3882 - Otherwise, close the connection and reopen it at the
3884 if (run_once
|| (!extended_protocol
&& !target_running ()))
3885 throw_quit ("Quit");
3888 "Remote side has terminated connection. "
3889 "GDBserver will reopen the connection.\n");
3891 /* Get rid of any pending statuses. An eventual reconnection
3892 (by the same GDB instance or another) will refresh all its
3893 state from scratch. */
3894 discard_queued_stop_replies (minus_one_ptid
);
3895 for_each_thread ([] (thread_info
*thread
)
3897 thread
->status_pending_p
= 0;
3902 if (disconnected_tracing
)
3904 /* Try to enable non-stop/async mode, so we we can
3905 both wait for an async socket accept, and handle
3906 async target events simultaneously. There's also
3907 no point either in having the target always stop
3908 all threads, when we're going to pass signals
3909 down without informing GDB. */
3912 if (start_non_stop (1))
3915 /* Detaching implicitly resumes all threads;
3916 simply disconnecting does not. */
3922 "Disconnected tracing disabled; "
3923 "stopping trace run.\n");
3928 catch (const gdb_exception_error
&exception
)
3931 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3933 if (response_needed
)
3935 write_enn (cs
.own_buf
);
3936 putpkt (cs
.own_buf
);
3940 throw_quit ("Quit");
3945 /* Main function. */
3948 main (int argc
, char *argv
[])
3953 captured_main (argc
, argv
);
3955 catch (const gdb_exception
&exception
)
3957 if (exception
.reason
== RETURN_ERROR
)
3960 fprintf (stderr
, "%s\n", exception
.what ());
3961 fprintf (stderr
, "Exiting\n");
3968 gdb_assert_not_reached ("captured_main should never return");
3971 /* Process options coming from Z packets for a breakpoint. PACKET is
3972 the packet buffer. *PACKET is updated to point to the first char
3973 after the last processed option. */
3976 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3978 const char *dataptr
= *packet
;
3981 /* Check if data has the correct format. */
3982 if (*dataptr
!= ';')
3989 if (*dataptr
== ';')
3992 if (*dataptr
== 'X')
3994 /* Conditional expression. */
3996 debug_printf ("Found breakpoint condition.\n");
3997 if (!add_breakpoint_condition (bp
, &dataptr
))
3998 dataptr
= strchrnul (dataptr
, ';');
4000 else if (startswith (dataptr
, "cmds:"))
4002 dataptr
+= strlen ("cmds:");
4004 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4005 persist
= (*dataptr
== '1');
4007 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4008 dataptr
= strchrnul (dataptr
, ';');
4012 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4014 /* Skip tokens until we find one that we recognize. */
4015 dataptr
= strchrnul (dataptr
, ';');
4021 /* Event loop callback that handles a serial event. The first byte in
4022 the serial buffer gets us here. We expect characters to arrive at
4023 a brisk pace, so we read the rest of the packet with a blocking
4027 process_serial_event (void)
4029 client_state
&cs
= get_client_state ();
4035 int new_packet_len
= -1;
4037 disable_async_io ();
4039 response_needed
= 0;
4040 packet_len
= getpkt (cs
.own_buf
);
4041 if (packet_len
<= 0)
4044 /* Force an event loop break. */
4047 response_needed
= 1;
4049 char ch
= cs
.own_buf
[0];
4053 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4056 handle_general_set (cs
.own_buf
);
4059 handle_detach (cs
.own_buf
);
4062 extended_protocol
= 1;
4063 write_ok (cs
.own_buf
);
4066 handle_status (cs
.own_buf
);
4069 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4071 require_running_or_break (cs
.own_buf
);
4073 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4075 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4076 thread_id
= null_ptid
;
4077 else if (thread_id
.is_pid ())
4079 /* The ptid represents a pid. */
4080 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4084 write_enn (cs
.own_buf
);
4088 thread_id
= thread
->id
;
4092 /* The ptid represents a lwp/tid. */
4093 if (find_thread_ptid (thread_id
) == NULL
)
4095 write_enn (cs
.own_buf
);
4100 if (cs
.own_buf
[1] == 'g')
4102 if (thread_id
== null_ptid
)
4104 /* GDB is telling us to choose any thread. Check if
4105 the currently selected thread is still valid. If
4106 it is not, select the first available. */
4107 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4109 thread
= get_first_thread ();
4110 thread_id
= thread
->id
;
4113 cs
.general_thread
= thread_id
;
4114 set_desired_thread ();
4115 gdb_assert (current_thread
!= NULL
);
4117 else if (cs
.own_buf
[1] == 'c')
4118 cs
.cont_thread
= thread_id
;
4120 write_ok (cs
.own_buf
);
4124 /* Silently ignore it so that gdb can extend the protocol
4125 without compatibility headaches. */
4126 cs
.own_buf
[0] = '\0';
4130 require_running_or_break (cs
.own_buf
);
4131 if (cs
.current_traceframe
>= 0)
4133 struct regcache
*regcache
4134 = new_register_cache (current_target_desc ());
4136 if (fetch_traceframe_registers (cs
.current_traceframe
,
4138 registers_to_string (regcache
, cs
.own_buf
);
4140 write_enn (cs
.own_buf
);
4141 free_register_cache (regcache
);
4145 struct regcache
*regcache
;
4147 if (!set_desired_thread ())
4148 write_enn (cs
.own_buf
);
4151 regcache
= get_thread_regcache (current_thread
, 1);
4152 registers_to_string (regcache
, cs
.own_buf
);
4157 require_running_or_break (cs
.own_buf
);
4158 if (cs
.current_traceframe
>= 0)
4159 write_enn (cs
.own_buf
);
4162 struct regcache
*regcache
;
4164 if (!set_desired_thread ())
4165 write_enn (cs
.own_buf
);
4168 regcache
= get_thread_regcache (current_thread
, 1);
4169 registers_from_string (regcache
, &cs
.own_buf
[1]);
4170 write_ok (cs
.own_buf
);
4176 require_running_or_break (cs
.own_buf
);
4177 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4178 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4180 write_enn (cs
.own_buf
);
4182 bin2hex (mem_buf
, cs
.own_buf
, res
);
4186 require_running_or_break (cs
.own_buf
);
4187 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4188 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4189 write_ok (cs
.own_buf
);
4191 write_enn (cs
.own_buf
);
4194 require_running_or_break (cs
.own_buf
);
4195 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4196 &mem_addr
, &len
, &mem_buf
) < 0
4197 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4198 write_enn (cs
.own_buf
);
4200 write_ok (cs
.own_buf
);
4203 require_running_or_break (cs
.own_buf
);
4204 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4205 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4206 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4209 myresume (cs
.own_buf
, 0, signal
);
4212 require_running_or_break (cs
.own_buf
);
4213 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4214 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4215 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4218 myresume (cs
.own_buf
, 1, signal
);
4221 require_running_or_break (cs
.own_buf
);
4223 myresume (cs
.own_buf
, 0, signal
);
4226 require_running_or_break (cs
.own_buf
);
4228 myresume (cs
.own_buf
, 1, signal
);
4230 case 'Z': /* insert_ ... */
4232 case 'z': /* remove_ ... */
4237 char type
= cs
.own_buf
[1];
4239 const int insert
= ch
== 'Z';
4240 const char *p
= &cs
.own_buf
[3];
4242 p
= unpack_varlen_hex (p
, &addr
);
4243 kind
= strtol (p
+ 1, &dataptr
, 16);
4247 struct gdb_breakpoint
*bp
;
4249 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4254 /* GDB may have sent us a list of *point parameters to
4255 be evaluated on the target's side. Read such list
4256 here. If we already have a list of parameters, GDB
4257 is telling us to drop that list and use this one
4259 clear_breakpoint_conditions_and_commands (bp
);
4260 const char *options
= dataptr
;
4261 process_point_options (bp
, &options
);
4265 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4268 write_ok (cs
.own_buf
);
4271 cs
.own_buf
[0] = '\0';
4273 write_enn (cs
.own_buf
);
4277 response_needed
= 0;
4278 if (!target_running ())
4279 /* The packet we received doesn't make sense - but we can't
4280 reply to it, either. */
4283 fprintf (stderr
, "Killing all inferiors\n");
4285 for_each_process (kill_inferior_callback
);
4287 /* When using the extended protocol, we wait with no program
4288 running. The traditional protocol will exit instead. */
4289 if (extended_protocol
)
4291 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4292 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4300 require_running_or_break (cs
.own_buf
);
4302 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4303 if (find_thread_ptid (thread_id
) == NULL
)
4305 write_enn (cs
.own_buf
);
4309 if (mythread_alive (thread_id
))
4310 write_ok (cs
.own_buf
);
4312 write_enn (cs
.own_buf
);
4316 response_needed
= 0;
4318 /* Restarting the inferior is only supported in the extended
4320 if (extended_protocol
)
4322 if (target_running ())
4323 for_each_process (kill_inferior_callback
);
4325 fprintf (stderr
, "GDBserver restarting\n");
4327 /* Wait till we are at 1st instruction in prog. */
4328 if (program_path
.get () != NULL
)
4330 create_inferior (program_path
.get (), program_args
);
4332 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4334 /* Stopped at the first instruction of the target
4336 cs
.general_thread
= cs
.last_ptid
;
4340 /* Something went wrong. */
4341 cs
.general_thread
= null_ptid
;
4346 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4347 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4353 /* It is a request we don't understand. Respond with an
4354 empty packet so that gdb knows that we don't support this
4356 cs
.own_buf
[0] = '\0';
4360 /* Extended (long) request. */
4361 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4365 /* It is a request we don't understand. Respond with an empty
4366 packet so that gdb knows that we don't support this
4368 cs
.own_buf
[0] = '\0';
4372 if (new_packet_len
!= -1)
4373 putpkt_binary (cs
.own_buf
, new_packet_len
);
4375 putpkt (cs
.own_buf
);
4377 response_needed
= 0;
4385 /* Event-loop callback for serial events. */
4388 handle_serial_event (int err
, gdb_client_data client_data
)
4391 debug_printf ("handling possible serial event\n");
4393 /* Really handle it. */
4394 if (process_serial_event () < 0)
4397 /* Be sure to not change the selected thread behind GDB's back.
4398 Important in the non-stop mode asynchronous protocol. */
4399 set_desired_thread ();
4404 /* Push a stop notification on the notification queue. */
4407 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4409 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4411 vstop_notif
->status
= *status
;
4412 vstop_notif
->ptid
= ptid
;
4413 /* Push Stop notification. */
4414 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4417 /* Event-loop callback for target events. */
4420 handle_target_event (int err
, gdb_client_data client_data
)
4422 client_state
&cs
= get_client_state ();
4424 debug_printf ("handling possible target event\n");
4426 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4429 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4431 if (gdb_connected () && report_no_resumed
)
4432 push_stop_notification (null_ptid
, &cs
.last_status
);
4434 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4436 int pid
= cs
.last_ptid
.pid ();
4437 struct process_info
*process
= find_process_pid (pid
);
4438 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4440 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4441 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4443 mark_breakpoints_out (process
);
4444 target_mourn_inferior (cs
.last_ptid
);
4446 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4450 /* We're reporting this thread as stopped. Update its
4451 "want-stopped" state to what the client wants, until it
4452 gets a new resume action. */
4453 current_thread
->last_resume_kind
= resume_stop
;
4454 current_thread
->last_status
= cs
.last_status
;
4459 if (!target_running ())
4461 /* The last process exited. We're done. */
4465 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4466 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4467 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4471 /* A thread stopped with a signal, but gdb isn't
4472 connected to handle it. Pass it down to the
4473 inferior, as if it wasn't being traced. */
4474 enum gdb_signal signal
;
4477 debug_printf ("GDB not connected; forwarding event %d for"
4479 (int) cs
.last_status
.kind
,
4480 target_pid_to_str (cs
.last_ptid
));
4482 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4483 signal
= cs
.last_status
.value
.sig
;
4485 signal
= GDB_SIGNAL_0
;
4486 target_continue (cs
.last_ptid
, signal
);
4490 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4493 /* Be sure to not change the selected thread behind GDB's back.
4494 Important in the non-stop mode asynchronous protocol. */
4495 set_desired_thread ();
4508 } // namespace selftests
4509 #endif /* GDB_SELF_TEST */