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