1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2019 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
21 #include "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 "gdbsupport/selftest.h"
46 #include "gdbsupport/scope-exit.h"
48 #define require_running_or_return(BUF) \
49 if (!target_running ()) \
55 #define require_running_or_break(BUF) \
56 if (!target_running ()) \
62 /* String containing the current directory (what getwd would return). */
64 char *current_directory
;
66 /* The environment to pass to the inferior when creating it. */
68 static gdb_environ our_environ
;
70 /* Start the inferior using a shell. */
72 /* We always try to start the inferior using a shell. */
74 int startup_with_shell
= 1;
78 static int extended_protocol
;
79 static int response_needed
;
80 static int exit_requested
;
82 /* --once: Exit after the first connection has closed. */
85 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
86 static int report_no_resumed
;
91 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
93 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
95 m_path
= std::move (path
);
97 /* Make sure we're using the absolute path of the inferior when
99 if (!contains_dir_separator (m_path
.get ()))
103 /* Check if the file is in our CWD. If it is, then we prefix
104 its name with CURRENT_DIRECTORY. Otherwise, we leave the
105 name as-is because we'll try searching for it in $PATH. */
106 if (is_regular_file (m_path
.get (), ®_file_errno
))
107 m_path
= gdb_abspath (m_path
.get ());
111 /* Return the PROGRAM_PATH. */
113 { return m_path
.get (); }
116 /* The program name, adjusted if needed. */
117 gdb::unique_xmalloc_ptr
<char> m_path
;
119 static std::vector
<char *> program_args
;
120 static std::string wrapper_argv
;
122 /* The PID of the originally created or attached inferior. Used to
123 send signals to the process when GDB sends us an asynchronous interrupt
124 (user hitting Control-C in the client), and to wait for the child to exit
125 when no longer debugging it. */
127 unsigned long signal_pid
;
129 /* Set if you want to disable optional thread related packets support
130 in gdbserver, for the sake of testing GDB against stubs that don't
132 int disable_packet_vCont
;
133 int disable_packet_Tthread
;
134 int disable_packet_qC
;
135 int disable_packet_qfThreadInfo
;
137 static unsigned char *mem_buf
;
139 /* A sub-class of 'struct notif_event' for stop, holding information
140 relative to a single stop reply. We keep a queue of these to
141 push to GDB in non-stop mode. */
143 struct vstop_notif
: public notif_event
145 /* Thread or process that got the event. */
149 struct target_waitstatus status
;
152 /* The current btrace configuration. This is gdbserver's mirror of GDB's
153 btrace configuration. */
154 static struct btrace_config current_btrace_conf
;
156 /* The client remote protocol state. */
158 static client_state g_client_state
;
163 client_state
&cs
= g_client_state
;
168 /* Put a stop reply to the stop reply queue. */
171 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
173 struct vstop_notif
*new_notif
= new struct vstop_notif
;
175 new_notif
->ptid
= ptid
;
176 new_notif
->status
= *status
;
178 notif_event_enque (¬if_stop
, new_notif
);
182 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
184 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
186 return vstop_event
->ptid
.matches (filter_ptid
);
192 discard_queued_stop_replies (ptid_t ptid
)
194 std::list
<notif_event
*>::iterator iter
, next
, end
;
195 end
= notif_stop
.queue
.end ();
196 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
201 if (remove_all_on_match_ptid (*iter
, ptid
))
204 notif_stop
.queue
.erase (iter
);
210 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
212 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
214 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
217 /* Helper for in_queued_stop_replies. */
220 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
222 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
224 if (vstop_event
->ptid
.matches (filter_ptid
))
227 /* Don't resume fork children that GDB does not know about yet. */
228 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
229 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
230 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
239 in_queued_stop_replies (ptid_t ptid
)
241 for (notif_event
*event
: notif_stop
.queue
)
243 if (in_queued_stop_replies_ptid (event
, ptid
))
250 struct notif_server notif_stop
=
252 "vStopped", "Stop", {}, vstop_notif_reply
,
256 target_running (void)
258 return get_first_thread () != NULL
;
261 /* See gdbsupport/common-inferior.h. */
266 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
269 /* See gdbsupport/common-inferior.h. */
272 get_exec_file (int err
)
274 if (err
&& program_path
.get () == NULL
)
275 error (_("No executable file specified."));
277 return program_path
.get ();
289 attach_inferior (int pid
)
291 client_state
&cs
= get_client_state ();
292 /* myattach should return -1 if attaching is unsupported,
293 0 if it succeeded, and call error() otherwise. */
295 if (find_process_pid (pid
) != nullptr)
296 error ("Already attached to process %d\n", pid
);
298 if (myattach (pid
) != 0)
301 fprintf (stderr
, "Attached; pid = %d\n", pid
);
304 /* FIXME - It may be that we should get the SIGNAL_PID from the
305 attach function, so that it can be the main thread instead of
306 whichever we were told to attach to. */
311 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
313 /* GDB knows to ignore the first SIGSTOP after attaching to a running
314 process using the "attach" command, but this is different; it's
315 just using "target remote". Pretend it's just starting up. */
316 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
317 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
318 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
320 current_thread
->last_resume_kind
= resume_stop
;
321 current_thread
->last_status
= cs
.last_status
;
327 /* Decode a qXfer read request. Return 0 if everything looks OK,
331 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
333 /* After the read marker and annex, qXfer looks like a
334 traditional 'm' packet. */
335 decode_m_packet (buf
, ofs
, len
);
341 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
343 /* Extract and NUL-terminate the object. */
345 while (*buf
&& *buf
!= ':')
351 /* Extract and NUL-terminate the read/write action. */
353 while (*buf
&& *buf
!= ':')
359 /* Extract and NUL-terminate the annex. */
361 while (*buf
&& *buf
!= ':')
371 /* Write the response to a successful qXfer read. Returns the
372 length of the (binary) data stored in BUF, corresponding
373 to as much of DATA/LEN as we could fit. IS_MORE controls
374 the first character of the response. */
376 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
385 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
386 &out_len
, PBUFSIZ
- 2) + 1;
389 /* Handle btrace enabling in BTS format. */
392 handle_btrace_enable_bts (struct thread_info
*thread
)
394 if (thread
->btrace
!= NULL
)
395 error (_("Btrace already enabled."));
397 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
398 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
401 /* Handle btrace enabling in Intel Processor Trace format. */
404 handle_btrace_enable_pt (struct thread_info
*thread
)
406 if (thread
->btrace
!= NULL
)
407 error (_("Btrace already enabled."));
409 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
410 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
413 /* Handle btrace disabling. */
416 handle_btrace_disable (struct thread_info
*thread
)
419 if (thread
->btrace
== NULL
)
420 error (_("Branch tracing not enabled."));
422 if (target_disable_btrace (thread
->btrace
) != 0)
423 error (_("Could not disable branch tracing."));
425 thread
->btrace
= NULL
;
428 /* Handle the "Qbtrace" packet. */
431 handle_btrace_general_set (char *own_buf
)
433 client_state
&cs
= get_client_state ();
434 struct thread_info
*thread
;
437 if (!startswith (own_buf
, "Qbtrace:"))
440 op
= own_buf
+ strlen ("Qbtrace:");
442 if (cs
.general_thread
== null_ptid
443 || cs
.general_thread
== minus_one_ptid
)
445 strcpy (own_buf
, "E.Must select a single thread.");
449 thread
= find_thread_ptid (cs
.general_thread
);
452 strcpy (own_buf
, "E.No such thread.");
458 if (strcmp (op
, "bts") == 0)
459 handle_btrace_enable_bts (thread
);
460 else if (strcmp (op
, "pt") == 0)
461 handle_btrace_enable_pt (thread
);
462 else if (strcmp (op
, "off") == 0)
463 handle_btrace_disable (thread
);
465 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
469 catch (const gdb_exception_error
&exception
)
471 sprintf (own_buf
, "E.%s", exception
.what ());
477 /* Handle the "Qbtrace-conf" packet. */
480 handle_btrace_conf_general_set (char *own_buf
)
482 client_state
&cs
= get_client_state ();
483 struct thread_info
*thread
;
486 if (!startswith (own_buf
, "Qbtrace-conf:"))
489 op
= own_buf
+ strlen ("Qbtrace-conf:");
491 if (cs
.general_thread
== null_ptid
492 || cs
.general_thread
== minus_one_ptid
)
494 strcpy (own_buf
, "E.Must select a single thread.");
498 thread
= find_thread_ptid (cs
.general_thread
);
501 strcpy (own_buf
, "E.No such thread.");
505 if (startswith (op
, "bts:size="))
511 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
512 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
514 strcpy (own_buf
, "E.Bad size value.");
518 current_btrace_conf
.bts
.size
= (unsigned int) size
;
520 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
526 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
527 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
529 strcpy (own_buf
, "E.Bad size value.");
533 current_btrace_conf
.pt
.size
= (unsigned int) size
;
537 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
545 /* Handle all of the extended 'Q' packets. */
548 handle_general_set (char *own_buf
)
550 client_state
&cs
= get_client_state ();
551 if (startswith (own_buf
, "QPassSignals:"))
553 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
554 const char *p
= own_buf
+ strlen ("QPassSignals:");
557 p
= decode_address_to_semicolon (&cursig
, p
);
558 for (i
= 0; i
< numsigs
; i
++)
562 cs
.pass_signals
[i
] = 1;
564 /* Keep looping, to clear the remaining signals. */
567 p
= decode_address_to_semicolon (&cursig
, p
);
570 cs
.pass_signals
[i
] = 0;
572 strcpy (own_buf
, "OK");
576 if (startswith (own_buf
, "QProgramSignals:"))
578 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
579 const char *p
= own_buf
+ strlen ("QProgramSignals:");
582 cs
.program_signals_p
= 1;
584 p
= decode_address_to_semicolon (&cursig
, p
);
585 for (i
= 0; i
< numsigs
; i
++)
589 cs
.program_signals
[i
] = 1;
591 /* Keep looping, to clear the remaining signals. */
594 p
= decode_address_to_semicolon (&cursig
, p
);
597 cs
.program_signals
[i
] = 0;
599 strcpy (own_buf
, "OK");
603 if (startswith (own_buf
, "QCatchSyscalls:"))
605 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
608 struct process_info
*process
;
610 if (!target_running () || !target_supports_catch_syscall ())
616 if (strcmp (p
, "0") == 0)
618 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
622 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
628 process
= current_process ();
629 process
->syscalls_to_catch
.clear ();
639 p
= decode_address_to_semicolon (&sysno
, p
);
640 process
->syscalls_to_catch
.push_back (sysno
);
644 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
651 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
653 our_environ
= gdb_environ::from_host_environ ();
659 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
661 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
662 /* The final form of the environment variable. FINAL_VAR will
663 hold the 'VAR=VALUE' format. */
664 std::string final_var
= hex2str (p
);
665 std::string var_name
, var_value
;
669 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
670 debug_printf (_("[Environment variable to be set: '%s']\n"),
675 size_t pos
= final_var
.find ('=');
676 if (pos
== std::string::npos
)
678 warning (_("Unexpected format for environment variable: '%s'"),
684 var_name
= final_var
.substr (0, pos
);
685 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
687 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
693 if (startswith (own_buf
, "QEnvironmentUnset:"))
695 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
696 std::string varname
= hex2str (p
);
700 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
701 debug_printf (_("[Environment variable to be unset: '%s']\n"),
706 our_environ
.unset (varname
.c_str ());
712 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
716 debug_printf ("[noack mode enabled]\n");
725 if (startswith (own_buf
, "QNonStop:"))
727 char *mode
= own_buf
+ 9;
731 if (strcmp (mode
, "0") == 0)
733 else if (strcmp (mode
, "1") == 0)
737 /* We don't know what this mode is, so complain to
739 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
745 req_str
= req
? "non-stop" : "all-stop";
746 if (start_non_stop (req
) != 0)
748 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
756 debug_printf ("[%s mode enabled]\n", req_str
);
762 if (startswith (own_buf
, "QDisableRandomization:"))
764 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
767 unpack_varlen_hex (packet
, &setting
);
768 cs
.disable_randomization
= setting
;
772 debug_printf (cs
.disable_randomization
773 ? "[address space randomization disabled]\n"
774 : "[address space randomization enabled]\n");
781 if (target_supports_tracepoints ()
782 && handle_tracepoint_general_set (own_buf
))
785 if (startswith (own_buf
, "QAgent:"))
787 char *mode
= own_buf
+ strlen ("QAgent:");
790 if (strcmp (mode
, "0") == 0)
792 else if (strcmp (mode
, "1") == 0)
796 /* We don't know what this value is, so complain to GDB. */
797 sprintf (own_buf
, "E.Unknown QAgent value");
801 /* Update the flag. */
804 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
809 if (handle_btrace_general_set (own_buf
))
812 if (handle_btrace_conf_general_set (own_buf
))
815 if (startswith (own_buf
, "QThreadEvents:"))
817 char *mode
= own_buf
+ strlen ("QThreadEvents:");
818 enum tribool req
= TRIBOOL_UNKNOWN
;
820 if (strcmp (mode
, "0") == 0)
822 else if (strcmp (mode
, "1") == 0)
826 /* We don't know what this mode is, so complain to GDB. */
827 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
832 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
836 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
838 debug_printf ("[thread events are now %s]\n", req_str
);
845 if (startswith (own_buf
, "QStartupWithShell:"))
847 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
849 if (strcmp (value
, "1") == 0)
850 startup_with_shell
= true;
851 else if (strcmp (value
, "0") == 0)
852 startup_with_shell
= false;
856 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
863 debug_printf (_("[Inferior will %s started with shell]"),
864 startup_with_shell
? "be" : "not be");
870 if (startswith (own_buf
, "QSetWorkingDir:"))
872 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
876 std::string path
= hex2str (p
);
878 set_inferior_cwd (path
.c_str ());
881 debug_printf (_("[Set the inferior's current directory to %s]\n"),
886 /* An empty argument means that we should clear out any
887 previously set cwd for the inferior. */
888 set_inferior_cwd (NULL
);
892 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
899 /* Otherwise we didn't know what packet it was. Say we didn't
905 get_features_xml (const char *annex
)
907 const struct target_desc
*desc
= current_target_desc ();
909 /* `desc->xmltarget' defines what to return when looking for the
910 "target.xml" file. Its contents can either be verbatim XML code
911 (prefixed with a '@') or else the name of the actual XML file to
912 be used in place of "target.xml".
914 This variable is set up from the auto-generated
915 init_registers_... routine for the current target. */
917 if (strcmp (annex
, "target.xml") == 0)
919 const char *ret
= tdesc_get_features_xml (desc
);
929 extern const char *const xml_builtin
[][2];
932 /* Look for the annex. */
933 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
934 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
937 if (xml_builtin
[i
][0] != NULL
)
938 return xml_builtin
[i
][1];
946 monitor_show_help (void)
948 monitor_output ("The following monitor commands are supported:\n");
949 monitor_output (" set debug <0|1>\n");
950 monitor_output (" Enable general debugging messages\n");
951 monitor_output (" set debug-hw-points <0|1>\n");
952 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
953 monitor_output (" set remote-debug <0|1>\n");
954 monitor_output (" Enable remote protocol debugging messages\n");
955 monitor_output (" set debug-format option1[,option2,...]\n");
956 monitor_output (" Add additional information to debugging messages\n");
957 monitor_output (" Options: all, none");
958 monitor_output (", timestamp");
959 monitor_output ("\n");
960 monitor_output (" exit\n");
961 monitor_output (" Quit GDBserver\n");
964 /* Read trace frame or inferior memory. Returns the number of bytes
965 actually read, zero when no further transfer is possible, and -1 on
966 error. Return of a positive value smaller than LEN does not
967 indicate there's no more to be read, only the end of the transfer.
968 E.g., when GDB reads memory from a traceframe, a first request may
969 be served from a memory block that does not cover the whole request
970 length. A following request gets the rest served from either
971 another block (of the same traceframe) or from the read-only
975 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
977 client_state
&cs
= get_client_state ();
980 if (cs
.current_traceframe
>= 0)
983 ULONGEST length
= len
;
985 if (traceframe_read_mem (cs
.current_traceframe
,
986 memaddr
, myaddr
, len
, &nbytes
))
988 /* Data read from trace buffer, we're done. */
991 if (!in_readonly_region (memaddr
, length
))
993 /* Otherwise we have a valid readonly case, fall through. */
994 /* (assume no half-trace half-real blocks for now) */
997 res
= prepare_to_access_memory ();
1000 if (set_desired_thread ())
1001 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1004 done_accessing_memory ();
1006 return res
== 0 ? len
: -1;
1012 /* Write trace frame or inferior memory. Actually, writing to trace
1013 frames is forbidden. */
1016 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1018 client_state
&cs
= get_client_state ();
1019 if (cs
.current_traceframe
>= 0)
1025 ret
= prepare_to_access_memory ();
1028 if (set_desired_thread ())
1029 ret
= target_write_memory (memaddr
, myaddr
, len
);
1032 done_accessing_memory ();
1038 /* Subroutine of handle_search_memory to simplify it. */
1041 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1042 gdb_byte
*pattern
, unsigned pattern_len
,
1043 gdb_byte
*search_buf
,
1044 unsigned chunk_size
, unsigned search_buf_size
,
1045 CORE_ADDR
*found_addrp
)
1047 /* Prime the search buffer. */
1049 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1052 warning ("Unable to access %ld bytes of target "
1053 "memory at 0x%lx, halting search.",
1054 (long) search_buf_size
, (long) start_addr
);
1058 /* Perform the search.
1060 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1061 When we've scanned N bytes we copy the trailing bytes to the start and
1062 read in another N bytes. */
1064 while (search_space_len
>= pattern_len
)
1066 gdb_byte
*found_ptr
;
1067 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1071 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1074 if (found_ptr
!= NULL
)
1076 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1077 *found_addrp
= found_addr
;
1081 /* Not found in this chunk, skip to next chunk. */
1083 /* Don't let search_space_len wrap here, it's unsigned. */
1084 if (search_space_len
>= chunk_size
)
1085 search_space_len
-= chunk_size
;
1087 search_space_len
= 0;
1089 if (search_space_len
>= pattern_len
)
1091 unsigned keep_len
= search_buf_size
- chunk_size
;
1092 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1095 /* Copy the trailing part of the previous iteration to the front
1096 of the buffer for the next iteration. */
1097 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1099 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1100 ? search_space_len
- keep_len
1103 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1104 nr_to_read
) != search_buf_size
)
1106 warning ("Unable to access %ld bytes of target memory "
1107 "at 0x%lx, halting search.",
1108 (long) nr_to_read
, (long) read_addr
);
1112 start_addr
+= chunk_size
;
1121 /* Handle qSearch:memory packets. */
1124 handle_search_memory (char *own_buf
, int packet_len
)
1126 CORE_ADDR start_addr
;
1127 CORE_ADDR search_space_len
;
1129 unsigned int pattern_len
;
1130 /* NOTE: also defined in find.c testcase. */
1131 #define SEARCH_CHUNK_SIZE 16000
1132 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1133 /* Buffer to hold memory contents for searching. */
1134 gdb_byte
*search_buf
;
1135 unsigned search_buf_size
;
1137 CORE_ADDR found_addr
;
1138 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1140 pattern
= (gdb_byte
*) malloc (packet_len
);
1141 if (pattern
== NULL
)
1143 error ("Unable to allocate memory to perform the search");
1144 strcpy (own_buf
, "E00");
1147 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1148 packet_len
- cmd_name_len
,
1149 &start_addr
, &search_space_len
,
1150 pattern
, &pattern_len
) < 0)
1153 error ("Error in parsing qSearch:memory packet");
1154 strcpy (own_buf
, "E00");
1158 search_buf_size
= chunk_size
+ pattern_len
- 1;
1160 /* No point in trying to allocate a buffer larger than the search space. */
1161 if (search_space_len
< search_buf_size
)
1162 search_buf_size
= search_space_len
;
1164 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1165 if (search_buf
== NULL
)
1168 error ("Unable to allocate memory to perform the search");
1169 strcpy (own_buf
, "E00");
1173 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1174 pattern
, pattern_len
,
1175 search_buf
, chunk_size
, search_buf_size
,
1179 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1180 else if (found
== 0)
1181 strcpy (own_buf
, "0");
1183 strcpy (own_buf
, "E00");
1189 /* Handle the "D" packet. */
1192 handle_detach (char *own_buf
)
1194 client_state
&cs
= get_client_state ();
1196 process_info
*process
;
1198 if (cs
.multi_process
)
1201 int pid
= strtol (&own_buf
[2], NULL
, 16);
1203 process
= find_process_pid (pid
);
1207 process
= (current_thread
!= nullptr
1208 ? get_thread_process (current_thread
)
1212 if (process
== NULL
)
1214 write_enn (own_buf
);
1218 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1220 if (tracing
&& disconnected_tracing
)
1222 "Disconnected tracing in effect, "
1223 "leaving gdbserver attached to the process\n");
1225 if (any_persistent_commands (process
))
1227 "Persistent commands are present, "
1228 "leaving gdbserver attached to the process\n");
1230 /* Make sure we're in non-stop/async mode, so we we can both
1231 wait for an async socket accept, and handle async target
1232 events simultaneously. There's also no point either in
1233 having the target stop all threads, when we're going to
1234 pass signals down without informing GDB. */
1238 debug_printf ("Forcing non-stop mode\n");
1244 process
->gdb_detached
= 1;
1246 /* Detaching implicitly resumes all threads. */
1247 target_continue_no_signal (minus_one_ptid
);
1253 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1256 /* We'll need this after PROCESS has been destroyed. */
1257 int pid
= process
->pid
;
1259 if (detach_inferior (process
) != 0)
1260 write_enn (own_buf
);
1263 discard_queued_stop_replies (ptid_t (pid
));
1266 if (extended_protocol
|| target_running ())
1268 /* There is still at least one inferior remaining or
1269 we are in extended mode, so don't terminate gdbserver,
1270 and instead treat this like a normal program exit. */
1271 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1272 cs
.last_status
.value
.integer
= 0;
1273 cs
.last_ptid
= ptid_t (pid
);
1275 current_thread
= NULL
;
1282 /* If we are attached, then we can exit. Otherwise, we
1283 need to hang around doing nothing, until the child is
1285 join_inferior (pid
);
1291 /* Parse options to --debug-format= and "monitor set debug-format".
1292 ARG is the text after "--debug-format=" or "monitor set debug-format".
1293 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1294 This triggers calls to monitor_output.
1295 The result is an empty string if all options were parsed ok, otherwise an
1296 error message which the caller must free.
1298 N.B. These commands affect all debug format settings, they are not
1299 cumulative. If a format is not specified, it is turned off.
1300 However, we don't go to extra trouble with things like
1301 "monitor set debug-format all,none,timestamp".
1302 Instead we just parse them one at a time, in order.
1304 The syntax for "monitor set debug" we support here is not identical
1305 to gdb's "set debug foo on|off" because we also use this function to
1306 parse "--debug-format=foo,bar". */
1309 parse_debug_format_options (const char *arg
, int is_monitor
)
1311 /* First turn all debug format options off. */
1312 debug_timestamp
= 0;
1314 /* First remove leading spaces, for "monitor set debug-format". */
1315 while (isspace (*arg
))
1318 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1319 = delim_string_to_char_ptr_vec (arg
, ',');
1321 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1323 if (strcmp (option
.get (), "all") == 0)
1325 debug_timestamp
= 1;
1327 monitor_output ("All extra debug format options enabled.\n");
1329 else if (strcmp (option
.get (), "none") == 0)
1331 debug_timestamp
= 0;
1333 monitor_output ("All extra debug format options disabled.\n");
1335 else if (strcmp (option
.get (), "timestamp") == 0)
1337 debug_timestamp
= 1;
1339 monitor_output ("Timestamps will be added to debug output.\n");
1341 else if (*option
== '\0')
1343 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1347 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1351 return std::string ();
1354 /* Handle monitor commands not handled by target-specific handlers. */
1357 handle_monitor_command (char *mon
, char *own_buf
)
1359 if (strcmp (mon
, "set debug 1") == 0)
1362 monitor_output ("Debug output enabled.\n");
1364 else if (strcmp (mon
, "set debug 0") == 0)
1367 monitor_output ("Debug output disabled.\n");
1369 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1371 show_debug_regs
= 1;
1372 monitor_output ("H/W point debugging output enabled.\n");
1374 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1376 show_debug_regs
= 0;
1377 monitor_output ("H/W point debugging output disabled.\n");
1379 else if (strcmp (mon
, "set remote-debug 1") == 0)
1382 monitor_output ("Protocol debug output enabled.\n");
1384 else if (strcmp (mon
, "set remote-debug 0") == 0)
1387 monitor_output ("Protocol debug output disabled.\n");
1389 else if (startswith (mon
, "set debug-format "))
1391 std::string error_msg
1392 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1395 if (!error_msg
.empty ())
1397 monitor_output (error_msg
.c_str ());
1398 monitor_show_help ();
1399 write_enn (own_buf
);
1402 else if (strcmp (mon
, "set debug-file") == 0)
1403 debug_set_output (nullptr);
1404 else if (startswith (mon
, "set debug-file "))
1405 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1406 else if (strcmp (mon
, "help") == 0)
1407 monitor_show_help ();
1408 else if (strcmp (mon
, "exit") == 0)
1412 monitor_output ("Unknown monitor command.\n\n");
1413 monitor_show_help ();
1414 write_enn (own_buf
);
1418 /* Associates a callback with each supported qXfer'able object. */
1422 /* The object this handler handles. */
1425 /* Request that the target transfer up to LEN 8-bit bytes of the
1426 target's OBJECT. The OFFSET, for a seekable object, specifies
1427 the starting point. The ANNEX can be used to provide additional
1428 data-specific information to the target.
1430 Return the number of bytes actually transfered, zero when no
1431 further transfer is possible, -1 on error, -2 when the transfer
1432 is not supported, and -3 on a verbose error message that should
1433 be preserved. Return of a positive value smaller than LEN does
1434 not indicate the end of the object, only the end of the transfer.
1436 One, and only one, of readbuf or writebuf must be non-NULL. */
1437 int (*xfer
) (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
);
1442 /* Handle qXfer:auxv:read. */
1445 handle_qxfer_auxv (const char *annex
,
1446 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1447 ULONGEST offset
, LONGEST len
)
1449 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1452 if (annex
[0] != '\0' || current_thread
== NULL
)
1455 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1458 /* Handle qXfer:exec-file:read. */
1461 handle_qxfer_exec_file (const char *annex
,
1462 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1463 ULONGEST offset
, LONGEST len
)
1469 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1472 if (annex
[0] == '\0')
1474 if (current_thread
== NULL
)
1477 pid
= pid_of (current_thread
);
1481 annex
= unpack_varlen_hex (annex
, &pid
);
1482 if (annex
[0] != '\0')
1489 file
= (*the_target
->pid_to_exec_file
) (pid
);
1493 total_len
= strlen (file
);
1495 if (offset
> total_len
)
1498 if (offset
+ len
> total_len
)
1499 len
= total_len
- offset
;
1501 memcpy (readbuf
, file
+ offset
, len
);
1505 /* Handle qXfer:features:read. */
1508 handle_qxfer_features (const char *annex
,
1509 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1510 ULONGEST offset
, LONGEST len
)
1512 const char *document
;
1515 if (writebuf
!= NULL
)
1518 if (!target_running ())
1521 /* Grab the correct annex. */
1522 document
= get_features_xml (annex
);
1523 if (document
== NULL
)
1526 total_len
= strlen (document
);
1528 if (offset
> total_len
)
1531 if (offset
+ len
> total_len
)
1532 len
= total_len
- offset
;
1534 memcpy (readbuf
, document
+ offset
, len
);
1538 /* Handle qXfer:libraries:read. */
1541 handle_qxfer_libraries (const char *annex
,
1542 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1543 ULONGEST offset
, LONGEST len
)
1545 if (writebuf
!= NULL
)
1548 if (annex
[0] != '\0' || current_thread
== NULL
)
1551 std::string document
= "<library-list version=\"1.0\">\n";
1553 for (const dll_info
&dll
: all_dlls
)
1554 document
+= string_printf
1555 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1556 dll
.name
.c_str (), (long) dll
.base_addr
);
1558 document
+= "</library-list>\n";
1560 if (offset
> document
.length ())
1563 if (offset
+ len
> document
.length ())
1564 len
= document
.length () - offset
;
1566 memcpy (readbuf
, &document
[offset
], len
);
1571 /* Handle qXfer:libraries-svr4:read. */
1574 handle_qxfer_libraries_svr4 (const char *annex
,
1575 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1576 ULONGEST offset
, LONGEST len
)
1578 if (writebuf
!= NULL
)
1581 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1584 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1587 /* Handle qXfer:osadata:read. */
1590 handle_qxfer_osdata (const char *annex
,
1591 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1592 ULONGEST offset
, LONGEST len
)
1594 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1597 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1600 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1603 handle_qxfer_siginfo (const char *annex
,
1604 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1605 ULONGEST offset
, LONGEST len
)
1607 if (the_target
->qxfer_siginfo
== NULL
)
1610 if (annex
[0] != '\0' || current_thread
== NULL
)
1613 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1616 /* Handle qXfer:spu:read and qXfer:spu:write. */
1619 handle_qxfer_spu (const char *annex
,
1620 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1621 ULONGEST offset
, LONGEST len
)
1623 if (the_target
->qxfer_spu
== NULL
)
1626 if (current_thread
== NULL
)
1629 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1632 /* Handle qXfer:statictrace:read. */
1635 handle_qxfer_statictrace (const char *annex
,
1636 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1637 ULONGEST offset
, LONGEST len
)
1639 client_state
&cs
= get_client_state ();
1642 if (writebuf
!= NULL
)
1645 if (annex
[0] != '\0' || current_thread
== NULL
1646 || cs
.current_traceframe
== -1)
1649 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1650 readbuf
, len
, &nbytes
))
1655 /* Helper for handle_qxfer_threads_proper.
1656 Emit the XML to describe the thread of INF. */
1659 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1661 ptid_t ptid
= ptid_of (thread
);
1663 int core
= target_core_of_thread (ptid
);
1665 const char *name
= target_thread_name (ptid
);
1668 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1670 write_ptid (ptid_s
, ptid
);
1672 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1676 sprintf (core_s
, "%d", core
);
1677 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1681 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1685 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1686 bin2hex (handle
, handle_s
, handle_len
);
1687 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1690 buffer_xml_printf (buffer
, "/>\n");
1693 /* Helper for handle_qxfer_threads. */
1696 handle_qxfer_threads_proper (struct buffer
*buffer
)
1698 buffer_grow_str (buffer
, "<threads>\n");
1700 for_each_thread ([&] (thread_info
*thread
)
1702 handle_qxfer_threads_worker (thread
, buffer
);
1705 buffer_grow_str0 (buffer
, "</threads>\n");
1708 /* Handle qXfer:threads:read. */
1711 handle_qxfer_threads (const char *annex
,
1712 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1713 ULONGEST offset
, LONGEST len
)
1715 static char *result
= 0;
1716 static unsigned int result_length
= 0;
1718 if (writebuf
!= NULL
)
1721 if (annex
[0] != '\0')
1726 struct buffer buffer
;
1727 /* When asked for data at offset 0, generate everything and store into
1728 'result'. Successive reads will be served off 'result'. */
1732 buffer_init (&buffer
);
1734 handle_qxfer_threads_proper (&buffer
);
1736 result
= buffer_finish (&buffer
);
1737 result_length
= strlen (result
);
1738 buffer_free (&buffer
);
1741 if (offset
>= result_length
)
1743 /* We're out of data. */
1750 if (len
> result_length
- offset
)
1751 len
= result_length
- offset
;
1753 memcpy (readbuf
, result
+ offset
, len
);
1758 /* Handle qXfer:traceframe-info:read. */
1761 handle_qxfer_traceframe_info (const char *annex
,
1762 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1763 ULONGEST offset
, LONGEST len
)
1765 client_state
&cs
= get_client_state ();
1766 static char *result
= 0;
1767 static unsigned int result_length
= 0;
1769 if (writebuf
!= NULL
)
1772 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1777 struct buffer buffer
;
1779 /* When asked for data at offset 0, generate everything and
1780 store into 'result'. Successive reads will be served off
1784 buffer_init (&buffer
);
1786 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1788 result
= buffer_finish (&buffer
);
1789 result_length
= strlen (result
);
1790 buffer_free (&buffer
);
1793 if (offset
>= result_length
)
1795 /* We're out of data. */
1802 if (len
> result_length
- offset
)
1803 len
= result_length
- offset
;
1805 memcpy (readbuf
, result
+ offset
, len
);
1809 /* Handle qXfer:fdpic:read. */
1812 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1813 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1815 if (the_target
->read_loadmap
== NULL
)
1818 if (current_thread
== NULL
)
1821 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1824 /* Handle qXfer:btrace:read. */
1827 handle_qxfer_btrace (const char *annex
,
1828 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1829 ULONGEST offset
, LONGEST len
)
1831 client_state
&cs
= get_client_state ();
1832 static struct buffer cache
;
1833 struct thread_info
*thread
;
1834 enum btrace_read_type type
;
1837 if (writebuf
!= NULL
)
1840 if (cs
.general_thread
== null_ptid
1841 || cs
.general_thread
== minus_one_ptid
)
1843 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1847 thread
= find_thread_ptid (cs
.general_thread
);
1850 strcpy (cs
.own_buf
, "E.No such thread.");
1854 if (thread
->btrace
== NULL
)
1856 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1860 if (strcmp (annex
, "all") == 0)
1861 type
= BTRACE_READ_ALL
;
1862 else if (strcmp (annex
, "new") == 0)
1863 type
= BTRACE_READ_NEW
;
1864 else if (strcmp (annex
, "delta") == 0)
1865 type
= BTRACE_READ_DELTA
;
1868 strcpy (cs
.own_buf
, "E.Bad annex.");
1874 buffer_free (&cache
);
1878 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1880 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1882 catch (const gdb_exception_error
&exception
)
1884 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1891 else if (offset
> cache
.used_size
)
1893 buffer_free (&cache
);
1897 if (len
> cache
.used_size
- offset
)
1898 len
= cache
.used_size
- offset
;
1900 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1905 /* Handle qXfer:btrace-conf:read. */
1908 handle_qxfer_btrace_conf (const char *annex
,
1909 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1910 ULONGEST offset
, LONGEST len
)
1912 client_state
&cs
= get_client_state ();
1913 static struct buffer cache
;
1914 struct thread_info
*thread
;
1917 if (writebuf
!= NULL
)
1920 if (annex
[0] != '\0')
1923 if (cs
.general_thread
== null_ptid
1924 || cs
.general_thread
== minus_one_ptid
)
1926 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1930 thread
= find_thread_ptid (cs
.general_thread
);
1933 strcpy (cs
.own_buf
, "E.No such thread.");
1937 if (thread
->btrace
== NULL
)
1939 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1945 buffer_free (&cache
);
1949 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1951 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1953 catch (const gdb_exception_error
&exception
)
1955 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1962 else if (offset
> cache
.used_size
)
1964 buffer_free (&cache
);
1968 if (len
> cache
.used_size
- offset
)
1969 len
= cache
.used_size
- offset
;
1971 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1976 static const struct qxfer qxfer_packets
[] =
1978 { "auxv", handle_qxfer_auxv
},
1979 { "btrace", handle_qxfer_btrace
},
1980 { "btrace-conf", handle_qxfer_btrace_conf
},
1981 { "exec-file", handle_qxfer_exec_file
},
1982 { "fdpic", handle_qxfer_fdpic
},
1983 { "features", handle_qxfer_features
},
1984 { "libraries", handle_qxfer_libraries
},
1985 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1986 { "osdata", handle_qxfer_osdata
},
1987 { "siginfo", handle_qxfer_siginfo
},
1988 { "spu", handle_qxfer_spu
},
1989 { "statictrace", handle_qxfer_statictrace
},
1990 { "threads", handle_qxfer_threads
},
1991 { "traceframe-info", handle_qxfer_traceframe_info
},
1995 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2003 if (!startswith (own_buf
, "qXfer:"))
2006 /* Grab the object, r/w and annex. */
2007 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2009 write_enn (own_buf
);
2014 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2017 const struct qxfer
*q
= &qxfer_packets
[i
];
2019 if (strcmp (object
, q
->object
) == 0)
2021 if (strcmp (rw
, "read") == 0)
2023 unsigned char *data
;
2028 /* Grab the offset and length. */
2029 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2031 write_enn (own_buf
);
2035 /* Read one extra byte, as an indicator of whether there is
2037 if (len
> PBUFSIZ
- 2)
2039 data
= (unsigned char *) malloc (len
+ 1);
2042 write_enn (own_buf
);
2045 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2053 /* Preserve error message. */
2056 write_enn (own_buf
);
2058 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2060 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2065 else if (strcmp (rw
, "write") == 0)
2070 unsigned char *data
;
2072 strcpy (own_buf
, "E00");
2073 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2076 write_enn (own_buf
);
2079 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2080 &ofs
, &len
, data
) < 0)
2083 write_enn (own_buf
);
2087 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2095 /* Preserve error message. */
2098 write_enn (own_buf
);
2100 sprintf (own_buf
, "%x", n
);
2113 /* Compute 32 bit CRC from inferior memory.
2115 On success, return 32 bit CRC.
2116 On failure, return (unsigned long long) -1. */
2118 static unsigned long long
2119 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2123 unsigned char byte
= 0;
2125 /* Return failure if memory read fails. */
2126 if (read_inferior_memory (base
, &byte
, 1) != 0)
2127 return (unsigned long long) -1;
2129 crc
= xcrc32 (&byte
, 1, crc
);
2132 return (unsigned long long) crc
;
2135 /* Add supported btrace packets to BUF. */
2138 supported_btrace_packets (char *buf
)
2140 strcat (buf
, ";Qbtrace:bts+");
2141 strcat (buf
, ";Qbtrace-conf:bts:size+");
2142 strcat (buf
, ";Qbtrace:pt+");
2143 strcat (buf
, ";Qbtrace-conf:pt:size+");
2144 strcat (buf
, ";Qbtrace:off+");
2145 strcat (buf
, ";qXfer:btrace:read+");
2146 strcat (buf
, ";qXfer:btrace-conf:read+");
2149 /* Handle all of the extended 'q' packets. */
2152 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2154 client_state
&cs
= get_client_state ();
2155 static std::list
<thread_info
*>::const_iterator thread_iter
;
2157 /* Reply the current thread id. */
2158 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2161 require_running_or_return (own_buf
);
2163 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2164 ptid
= cs
.general_thread
;
2167 thread_iter
= all_threads
.begin ();
2168 ptid
= (*thread_iter
)->id
;
2171 sprintf (own_buf
, "QC");
2173 write_ptid (own_buf
, ptid
);
2177 if (strcmp ("qSymbol::", own_buf
) == 0)
2179 struct thread_info
*save_thread
= current_thread
;
2181 /* For qSymbol, GDB only changes the current thread if the
2182 previous current thread was of a different process. So if
2183 the previous thread is gone, we need to pick another one of
2184 the same process. This can happen e.g., if we followed an
2185 exec in a non-leader thread. */
2186 if (current_thread
== NULL
)
2189 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2191 /* Just in case, if we didn't find a thread, then bail out
2192 instead of crashing. */
2193 if (current_thread
== NULL
)
2195 write_enn (own_buf
);
2196 current_thread
= save_thread
;
2201 /* GDB is suggesting new symbols have been loaded. This may
2202 mean a new shared library has been detected as loaded, so
2203 take the opportunity to check if breakpoints we think are
2204 inserted, still are. Note that it isn't guaranteed that
2205 we'll see this when a shared library is loaded, and nor will
2206 we see this for unloads (although breakpoints in unloaded
2207 libraries shouldn't trigger), as GDB may not find symbols for
2208 the library at all. We also re-validate breakpoints when we
2209 see a second GDB breakpoint for the same address, and or when
2210 we access breakpoint shadows. */
2211 validate_breakpoints ();
2213 if (target_supports_tracepoints ())
2214 tracepoint_look_up_symbols ();
2216 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2217 (*the_target
->look_up_symbols
) ();
2219 current_thread
= save_thread
;
2221 strcpy (own_buf
, "OK");
2225 if (!disable_packet_qfThreadInfo
)
2227 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2229 require_running_or_return (own_buf
);
2230 thread_iter
= all_threads
.begin ();
2233 ptid_t ptid
= (*thread_iter
)->id
;
2234 write_ptid (own_buf
, ptid
);
2239 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2241 require_running_or_return (own_buf
);
2242 if (thread_iter
!= all_threads
.end ())
2245 ptid_t ptid
= (*thread_iter
)->id
;
2246 write_ptid (own_buf
, ptid
);
2252 sprintf (own_buf
, "l");
2258 if (the_target
->read_offsets
!= NULL
2259 && strcmp ("qOffsets", own_buf
) == 0)
2261 CORE_ADDR text
, data
;
2263 require_running_or_return (own_buf
);
2264 if (the_target
->read_offsets (&text
, &data
))
2265 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2266 (long)text
, (long)data
, (long)data
);
2268 write_enn (own_buf
);
2273 /* Protocol features query. */
2274 if (startswith (own_buf
, "qSupported")
2275 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2277 char *p
= &own_buf
[10];
2278 int gdb_supports_qRelocInsn
= 0;
2280 /* Process each feature being provided by GDB. The first
2281 feature will follow a ':', and latter features will follow
2285 char **qsupported
= NULL
;
2290 /* Two passes, to avoid nested strtok calls in
2291 target_process_qsupported. */
2292 for (p
= strtok (p
+ 1, ";");
2294 p
= strtok (NULL
, ";"))
2297 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2298 qsupported
[count
- 1] = xstrdup (p
);
2301 for (i
= 0; i
< count
; i
++)
2304 if (strcmp (p
, "multiprocess+") == 0)
2306 /* GDB supports and wants multi-process support if
2308 if (target_supports_multi_process ())
2309 cs
.multi_process
= 1;
2311 else if (strcmp (p
, "qRelocInsn+") == 0)
2313 /* GDB supports relocate instruction requests. */
2314 gdb_supports_qRelocInsn
= 1;
2316 else if (strcmp (p
, "swbreak+") == 0)
2318 /* GDB wants us to report whether a trap is caused
2319 by a software breakpoint and for us to handle PC
2320 adjustment if necessary on this target. */
2321 if (target_supports_stopped_by_sw_breakpoint ())
2322 cs
.swbreak_feature
= 1;
2324 else if (strcmp (p
, "hwbreak+") == 0)
2326 /* GDB wants us to report whether a trap is caused
2327 by a hardware breakpoint. */
2328 if (target_supports_stopped_by_hw_breakpoint ())
2329 cs
.hwbreak_feature
= 1;
2331 else if (strcmp (p
, "fork-events+") == 0)
2333 /* GDB supports and wants fork events if possible. */
2334 if (target_supports_fork_events ())
2335 cs
.report_fork_events
= 1;
2337 else if (strcmp (p
, "vfork-events+") == 0)
2339 /* GDB supports and wants vfork events if possible. */
2340 if (target_supports_vfork_events ())
2341 cs
.report_vfork_events
= 1;
2343 else if (strcmp (p
, "exec-events+") == 0)
2345 /* GDB supports and wants exec events if possible. */
2346 if (target_supports_exec_events ())
2347 cs
.report_exec_events
= 1;
2349 else if (strcmp (p
, "vContSupported+") == 0)
2350 cs
.vCont_supported
= 1;
2351 else if (strcmp (p
, "QThreadEvents+") == 0)
2353 else if (strcmp (p
, "no-resumed+") == 0)
2355 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2357 report_no_resumed
= 1;
2361 /* Move the unknown features all together. */
2362 qsupported
[i
] = NULL
;
2363 qsupported
[unknown
] = p
;
2368 /* Give the target backend a chance to process the unknown
2370 target_process_qsupported (qsupported
, unknown
);
2372 for (i
= 0; i
< count
; i
++)
2373 free (qsupported
[i
]);
2378 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2379 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2380 "QEnvironmentReset+;QEnvironmentUnset+;"
2384 if (target_supports_catch_syscall ())
2385 strcat (own_buf
, ";QCatchSyscalls+");
2387 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2388 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2389 ";augmented-libraries-svr4-read+");
2392 /* We do not have any hook to indicate whether the non-SVR4 target
2393 backend supports qXfer:libraries:read, so always report it. */
2394 strcat (own_buf
, ";qXfer:libraries:read+");
2397 if (the_target
->read_auxv
!= NULL
)
2398 strcat (own_buf
, ";qXfer:auxv:read+");
2400 if (the_target
->qxfer_spu
!= NULL
)
2401 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2403 if (the_target
->qxfer_siginfo
!= NULL
)
2404 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2406 if (the_target
->read_loadmap
!= NULL
)
2407 strcat (own_buf
, ";qXfer:fdpic:read+");
2409 /* We always report qXfer:features:read, as targets may
2410 install XML files on a subsequent call to arch_setup.
2411 If we reported to GDB on startup that we don't support
2412 qXfer:feature:read at all, we will never be re-queried. */
2413 strcat (own_buf
, ";qXfer:features:read+");
2415 if (cs
.transport_is_reliable
)
2416 strcat (own_buf
, ";QStartNoAckMode+");
2418 if (the_target
->qxfer_osdata
!= NULL
)
2419 strcat (own_buf
, ";qXfer:osdata:read+");
2421 if (target_supports_multi_process ())
2422 strcat (own_buf
, ";multiprocess+");
2424 if (target_supports_fork_events ())
2425 strcat (own_buf
, ";fork-events+");
2427 if (target_supports_vfork_events ())
2428 strcat (own_buf
, ";vfork-events+");
2430 if (target_supports_exec_events ())
2431 strcat (own_buf
, ";exec-events+");
2433 if (target_supports_non_stop ())
2434 strcat (own_buf
, ";QNonStop+");
2436 if (target_supports_disable_randomization ())
2437 strcat (own_buf
, ";QDisableRandomization+");
2439 strcat (own_buf
, ";qXfer:threads:read+");
2441 if (target_supports_tracepoints ())
2443 strcat (own_buf
, ";ConditionalTracepoints+");
2444 strcat (own_buf
, ";TraceStateVariables+");
2445 strcat (own_buf
, ";TracepointSource+");
2446 strcat (own_buf
, ";DisconnectedTracing+");
2447 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2448 strcat (own_buf
, ";FastTracepoints+");
2449 strcat (own_buf
, ";StaticTracepoints+");
2450 strcat (own_buf
, ";InstallInTrace+");
2451 strcat (own_buf
, ";qXfer:statictrace:read+");
2452 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2453 strcat (own_buf
, ";EnableDisableTracepoints+");
2454 strcat (own_buf
, ";QTBuffer:size+");
2455 strcat (own_buf
, ";tracenz+");
2458 if (target_supports_hardware_single_step ()
2459 || target_supports_software_single_step () )
2461 strcat (own_buf
, ";ConditionalBreakpoints+");
2463 strcat (own_buf
, ";BreakpointCommands+");
2465 if (target_supports_agent ())
2466 strcat (own_buf
, ";QAgent+");
2468 supported_btrace_packets (own_buf
);
2470 if (target_supports_stopped_by_sw_breakpoint ())
2471 strcat (own_buf
, ";swbreak+");
2473 if (target_supports_stopped_by_hw_breakpoint ())
2474 strcat (own_buf
, ";hwbreak+");
2476 if (the_target
->pid_to_exec_file
!= NULL
)
2477 strcat (own_buf
, ";qXfer:exec-file:read+");
2479 strcat (own_buf
, ";vContSupported+");
2481 strcat (own_buf
, ";QThreadEvents+");
2483 strcat (own_buf
, ";no-resumed+");
2485 /* Reinitialize components as needed for the new connection. */
2486 hostio_handle_new_gdb_connection ();
2487 target_handle_new_gdb_connection ();
2492 /* Thread-local storage support. */
2493 if (the_target
->get_tls_address
!= NULL
2494 && startswith (own_buf
, "qGetTLSAddr:"))
2496 char *p
= own_buf
+ 12;
2497 CORE_ADDR parts
[2], address
= 0;
2499 ptid_t ptid
= null_ptid
;
2501 require_running_or_return (own_buf
);
2503 for (i
= 0; i
< 3; i
++)
2511 p2
= strchr (p
, ',');
2524 ptid
= read_ptid (p
, NULL
);
2526 decode_address (&parts
[i
- 1], p
, len
);
2530 if (p
!= NULL
|| i
< 3)
2534 struct thread_info
*thread
= find_thread_ptid (ptid
);
2539 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2545 strcpy (own_buf
, paddress(address
));
2550 write_enn (own_buf
);
2554 /* Otherwise, pretend we do not understand this packet. */
2557 /* Windows OS Thread Information Block address support. */
2558 if (the_target
->get_tib_address
!= NULL
2559 && startswith (own_buf
, "qGetTIBAddr:"))
2564 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2566 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2569 strcpy (own_buf
, paddress(tlb
));
2574 write_enn (own_buf
);
2580 /* Handle "monitor" commands. */
2581 if (startswith (own_buf
, "qRcmd,"))
2583 char *mon
= (char *) malloc (PBUFSIZ
);
2584 int len
= strlen (own_buf
+ 6);
2588 write_enn (own_buf
);
2593 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2595 write_enn (own_buf
);
2599 mon
[len
/ 2] = '\0';
2603 if (the_target
->handle_monitor_command
== NULL
2604 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2605 /* Default processing. */
2606 handle_monitor_command (mon
, own_buf
);
2612 if (startswith (own_buf
, "qSearch:memory:"))
2614 require_running_or_return (own_buf
);
2615 handle_search_memory (own_buf
, packet_len
);
2619 if (strcmp (own_buf
, "qAttached") == 0
2620 || startswith (own_buf
, "qAttached:"))
2622 struct process_info
*process
;
2624 if (own_buf
[sizeof ("qAttached") - 1])
2626 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2627 process
= find_process_pid (pid
);
2631 require_running_or_return (own_buf
);
2632 process
= current_process ();
2635 if (process
== NULL
)
2637 write_enn (own_buf
);
2641 strcpy (own_buf
, process
->attached
? "1" : "0");
2645 if (startswith (own_buf
, "qCRC:"))
2647 /* CRC check (compare-section). */
2651 unsigned long long crc
;
2653 require_running_or_return (own_buf
);
2654 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2655 if (*comma
++ != ',')
2657 write_enn (own_buf
);
2660 len
= strtoul (comma
, NULL
, 16);
2661 crc
= crc32 (base
, len
, 0xffffffff);
2662 /* Check for memory failure. */
2663 if (crc
== (unsigned long long) -1)
2665 write_enn (own_buf
);
2668 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2672 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2675 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2678 /* Otherwise we didn't know what packet it was. Say we didn't
2683 static void gdb_wants_all_threads_stopped (void);
2684 static void resume (struct thread_resume
*actions
, size_t n
);
2686 /* The callback that is passed to visit_actioned_threads. */
2687 typedef int (visit_actioned_threads_callback_ftype
)
2688 (const struct thread_resume
*, struct thread_info
*);
2690 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2691 true if CALLBACK returns true. Returns false if no matching thread
2692 is found or CALLBACK results false.
2693 Note: This function is itself a callback for find_thread. */
2696 visit_actioned_threads (thread_info
*thread
,
2697 const struct thread_resume
*actions
,
2699 visit_actioned_threads_callback_ftype
*callback
)
2701 for (size_t i
= 0; i
< num_actions
; i
++)
2703 const struct thread_resume
*action
= &actions
[i
];
2705 if (action
->thread
== minus_one_ptid
2706 || action
->thread
== thread
->id
2707 || ((action
->thread
.pid ()
2708 == thread
->id
.pid ())
2709 && action
->thread
.lwp () == -1))
2711 if ((*callback
) (action
, thread
))
2719 /* Callback for visit_actioned_threads. If the thread has a pending
2720 status to report, report it now. */
2723 handle_pending_status (const struct thread_resume
*resumption
,
2724 struct thread_info
*thread
)
2726 client_state
&cs
= get_client_state ();
2727 if (thread
->status_pending_p
)
2729 thread
->status_pending_p
= 0;
2731 cs
.last_status
= thread
->last_status
;
2732 cs
.last_ptid
= thread
->id
;
2733 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2739 /* Parse vCont packets. */
2741 handle_v_cont (char *own_buf
)
2745 struct thread_resume
*resume_info
;
2746 struct thread_resume default_action
{ null_ptid
};
2748 /* Count the number of semicolons in the packet. There should be one
2749 for every action. */
2755 p
= strchr (p
, ';');
2758 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2759 if (resume_info
== NULL
)
2767 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2769 if (p
[0] == 's' || p
[0] == 'S')
2770 resume_info
[i
].kind
= resume_step
;
2771 else if (p
[0] == 'r')
2772 resume_info
[i
].kind
= resume_step
;
2773 else if (p
[0] == 'c' || p
[0] == 'C')
2774 resume_info
[i
].kind
= resume_continue
;
2775 else if (p
[0] == 't')
2776 resume_info
[i
].kind
= resume_stop
;
2780 if (p
[0] == 'S' || p
[0] == 'C')
2783 int sig
= strtol (p
+ 1, &q
, 16);
2788 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2790 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2792 else if (p
[0] == 'r')
2796 p
= unpack_varlen_hex (p
+ 1, &addr
);
2797 resume_info
[i
].step_range_start
= addr
;
2802 p
= unpack_varlen_hex (p
+ 1, &addr
);
2803 resume_info
[i
].step_range_end
= addr
;
2812 resume_info
[i
].thread
= minus_one_ptid
;
2813 default_action
= resume_info
[i
];
2815 /* Note: we don't increment i here, we'll overwrite this entry
2816 the next time through. */
2818 else if (p
[0] == ':')
2821 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2826 if (p
[0] != ';' && p
[0] != 0)
2829 resume_info
[i
].thread
= ptid
;
2836 resume_info
[i
] = default_action
;
2838 resume (resume_info
, n
);
2843 write_enn (own_buf
);
2848 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2851 resume (struct thread_resume
*actions
, size_t num_actions
)
2853 client_state
&cs
= get_client_state ();
2856 /* Check if among the threads that GDB wants actioned, there's
2857 one with a pending status to report. If so, skip actually
2858 resuming/stopping and report the pending event
2861 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2863 return visit_actioned_threads (thread
, actions
, num_actions
,
2864 handle_pending_status
);
2867 if (thread_with_status
!= NULL
)
2873 (*the_target
->resume
) (actions
, num_actions
);
2876 write_ok (cs
.own_buf
);
2879 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2881 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2882 && !report_no_resumed
)
2884 /* The client does not support this stop reply. At least
2886 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2887 disable_async_io ();
2891 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2892 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2893 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2894 current_thread
->last_status
= cs
.last_status
;
2896 /* From the client's perspective, all-stop mode always stops all
2897 threads implicitly (and the target backend has already done
2898 so by now). Tag all threads as "want-stopped", so we don't
2899 resume them implicitly without the client telling us to. */
2900 gdb_wants_all_threads_stopped ();
2901 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2902 disable_async_io ();
2904 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2905 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2906 target_mourn_inferior (cs
.last_ptid
);
2910 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2912 handle_v_attach (char *own_buf
)
2914 client_state
&cs
= get_client_state ();
2917 pid
= strtol (own_buf
+ 8, NULL
, 16);
2918 if (pid
!= 0 && attach_inferior (pid
) == 0)
2920 /* Don't report shared library events after attaching, even if
2921 some libraries are preloaded. GDB will always poll the
2922 library list. Avoids the "stopped by shared library event"
2923 notice on the GDB side. */
2928 /* In non-stop, we don't send a resume reply. Stop events
2929 will follow up using the normal notification
2934 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2940 write_enn (own_buf
);
2945 /* Run a new program. Return 1 if successful, 0 if failure. */
2947 handle_v_run (char *own_buf
)
2949 client_state
&cs
= get_client_state ();
2951 std::vector
<char *> new_argv
;
2952 char *new_program_name
= NULL
;
2956 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2962 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2964 next_p
= strchr (p
, ';');
2966 next_p
= p
+ strlen (p
);
2968 if (i
== 0 && p
== next_p
)
2970 /* No program specified. */
2971 new_program_name
= NULL
;
2973 else if (p
== next_p
)
2975 /* Empty argument. */
2976 new_argv
.push_back (xstrdup ("''"));
2980 size_t len
= (next_p
- p
) / 2;
2981 /* ARG is the unquoted argument received via the RSP. */
2982 char *arg
= (char *) xmalloc (len
+ 1);
2983 /* FULL_ARGS will contain the quoted version of ARG. */
2984 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2985 /* These are pointers used to navigate the strings above. */
2986 char *tmp_arg
= arg
;
2987 char *tmp_full_arg
= full_arg
;
2990 hex2bin (p
, (gdb_byte
*) arg
, len
);
2993 while (*tmp_arg
!= '\0')
2999 *tmp_full_arg
= '\'';
3005 /* Quote single quote. */
3006 *tmp_full_arg
= '\\';
3014 *tmp_full_arg
= *tmp_arg
;
3020 *tmp_full_arg
++ = '\'';
3022 /* Finish FULL_ARG and push it into the vector containing
3024 *tmp_full_arg
= '\0';
3026 new_program_name
= full_arg
;
3028 new_argv
.push_back (full_arg
);
3034 new_argv
.push_back (NULL
);
3036 if (new_program_name
== NULL
)
3038 /* GDB didn't specify a program to run. Use the program from the
3039 last run with the new argument list. */
3040 if (program_path
.get () == NULL
)
3042 write_enn (own_buf
);
3043 free_vector_argv (new_argv
);
3048 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3050 /* Free the old argv and install the new one. */
3051 free_vector_argv (program_args
);
3052 program_args
= new_argv
;
3054 create_inferior (program_path
.get (), program_args
);
3056 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3058 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3060 /* In non-stop, sending a resume reply doesn't set the general
3061 thread, but GDB assumes a vRun sets it (this is so GDB can
3062 query which is the main thread of the new inferior. */
3064 cs
.general_thread
= cs
.last_ptid
;
3070 write_enn (own_buf
);
3075 /* Kill process. Return 1 if successful, 0 if failure. */
3077 handle_v_kill (char *own_buf
)
3079 client_state
&cs
= get_client_state ();
3081 char *p
= &own_buf
[6];
3082 if (cs
.multi_process
)
3083 pid
= strtol (p
, NULL
, 16);
3087 process_info
*proc
= find_process_pid (pid
);
3089 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3091 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3092 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3093 cs
.last_ptid
= ptid_t (pid
);
3094 discard_queued_stop_replies (cs
.last_ptid
);
3100 write_enn (own_buf
);
3105 /* Handle all of the extended 'v' packets. */
3107 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3109 client_state
&cs
= get_client_state ();
3110 if (!disable_packet_vCont
)
3112 if (strcmp (own_buf
, "vCtrlC") == 0)
3114 (*the_target
->request_interrupt
) ();
3119 if (startswith (own_buf
, "vCont;"))
3121 handle_v_cont (own_buf
);
3125 if (startswith (own_buf
, "vCont?"))
3127 strcpy (own_buf
, "vCont;c;C;t");
3129 if (target_supports_hardware_single_step ()
3130 || target_supports_software_single_step ()
3131 || !cs
.vCont_supported
)
3133 /* If target supports single step either by hardware or by
3134 software, add actions s and S to the list of supported
3135 actions. On the other hand, if GDB doesn't request the
3136 supported vCont actions in qSupported packet, add s and
3137 S to the list too. */
3138 own_buf
= own_buf
+ strlen (own_buf
);
3139 strcpy (own_buf
, ";s;S");
3142 if (target_supports_range_stepping ())
3144 own_buf
= own_buf
+ strlen (own_buf
);
3145 strcpy (own_buf
, ";r");
3151 if (startswith (own_buf
, "vFile:")
3152 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3155 if (startswith (own_buf
, "vAttach;"))
3157 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3159 fprintf (stderr
, "Already debugging a process\n");
3160 write_enn (own_buf
);
3163 handle_v_attach (own_buf
);
3167 if (startswith (own_buf
, "vRun;"))
3169 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3171 fprintf (stderr
, "Already debugging a process\n");
3172 write_enn (own_buf
);
3175 handle_v_run (own_buf
);
3179 if (startswith (own_buf
, "vKill;"))
3181 if (!target_running ())
3183 fprintf (stderr
, "No process to kill\n");
3184 write_enn (own_buf
);
3187 handle_v_kill (own_buf
);
3191 if (handle_notif_ack (own_buf
, packet_len
))
3194 /* Otherwise we didn't know what packet it was. Say we didn't
3200 /* Resume thread and wait for another event. In non-stop mode,
3201 don't really wait here, but return immediatelly to the event
3204 myresume (char *own_buf
, int step
, int sig
)
3206 client_state
&cs
= get_client_state ();
3207 struct thread_resume resume_info
[2];
3209 int valid_cont_thread
;
3211 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3212 && cs
.cont_thread
!= minus_one_ptid
);
3214 if (step
|| sig
|| valid_cont_thread
)
3216 resume_info
[0].thread
= current_ptid
;
3218 resume_info
[0].kind
= resume_step
;
3220 resume_info
[0].kind
= resume_continue
;
3221 resume_info
[0].sig
= sig
;
3225 if (!valid_cont_thread
)
3227 resume_info
[n
].thread
= minus_one_ptid
;
3228 resume_info
[n
].kind
= resume_continue
;
3229 resume_info
[n
].sig
= 0;
3233 resume (resume_info
, n
);
3236 /* Callback for for_each_thread. Make a new stop reply for each
3240 queue_stop_reply_callback (thread_info
*thread
)
3242 /* For now, assume targets that don't have this callback also don't
3243 manage the thread's last_status field. */
3244 if (the_target
->thread_stopped
== NULL
)
3246 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3248 new_notif
->ptid
= thread
->id
;
3249 new_notif
->status
= thread
->last_status
;
3250 /* Pass the last stop reply back to GDB, but don't notify
3252 notif_event_enque (¬if_stop
, new_notif
);
3256 if (thread_stopped (thread
))
3260 std::string status_string
3261 = target_waitstatus_to_string (&thread
->last_status
);
3263 debug_printf ("Reporting thread %s as already stopped with %s\n",
3264 target_pid_to_str (thread
->id
),
3265 status_string
.c_str ());
3268 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3270 /* Pass the last stop reply back to GDB, but don't notify
3272 queue_stop_reply (thread
->id
, &thread
->last_status
);
3277 /* Set this inferior threads's state as "want-stopped". We won't
3278 resume this thread until the client gives us another action for
3282 gdb_wants_thread_stopped (thread_info
*thread
)
3284 thread
->last_resume_kind
= resume_stop
;
3286 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3288 /* Most threads are stopped implicitly (all-stop); tag that with
3290 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3291 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3295 /* Set all threads' states as "want-stopped". */
3298 gdb_wants_all_threads_stopped (void)
3300 for_each_thread (gdb_wants_thread_stopped
);
3303 /* Callback for for_each_thread. If the thread is stopped with an
3304 interesting event, mark it as having a pending event. */
3307 set_pending_status_callback (thread_info
*thread
)
3309 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3310 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3311 /* A breakpoint, watchpoint or finished step from a previous
3312 GDB run isn't considered interesting for a new GDB run.
3313 If we left those pending, the new GDB could consider them
3314 random SIGTRAPs. This leaves out real async traps. We'd
3315 have to peek into the (target-specific) siginfo to
3316 distinguish those. */
3317 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3318 thread
->status_pending_p
= 1;
3321 /* Status handler for the '?' packet. */
3324 handle_status (char *own_buf
)
3326 client_state
&cs
= get_client_state ();
3328 /* GDB is connected, don't forward events to the target anymore. */
3329 for_each_process ([] (process_info
*process
) {
3330 process
->gdb_detached
= 0;
3333 /* In non-stop mode, we must send a stop reply for each stopped
3334 thread. In all-stop mode, just send one for the first stopped
3339 for_each_thread (queue_stop_reply_callback
);
3341 /* The first is sent immediatly. OK is sent if there is no
3342 stopped thread, which is the same handling of the vStopped
3343 packet (by design). */
3344 notif_write_event (¬if_stop
, cs
.own_buf
);
3348 thread_info
*thread
= NULL
;
3351 stabilize_threads ();
3352 gdb_wants_all_threads_stopped ();
3354 /* We can only report one status, but we might be coming out of
3355 non-stop -- if more than one thread is stopped with
3356 interesting events, leave events for the threads we're not
3357 reporting now pending. They'll be reported the next time the
3358 threads are resumed. Start by marking all interesting events
3360 for_each_thread (set_pending_status_callback
);
3362 /* Prefer the last thread that reported an event to GDB (even if
3363 that was a GDB_SIGNAL_TRAP). */
3364 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3365 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3366 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3367 thread
= find_thread_ptid (cs
.last_ptid
);
3369 /* If the last event thread is not found for some reason, look
3370 for some other thread that might have an event to report. */
3372 thread
= find_thread ([] (thread_info
*thr_arg
)
3374 return thr_arg
->status_pending_p
;
3377 /* If we're still out of luck, simply pick the first thread in
3380 thread
= get_first_thread ();
3384 struct thread_info
*tp
= (struct thread_info
*) thread
;
3386 /* We're reporting this event, so it's no longer
3388 tp
->status_pending_p
= 0;
3390 /* GDB assumes the current thread is the thread we're
3391 reporting the status for. */
3392 cs
.general_thread
= thread
->id
;
3393 set_desired_thread ();
3395 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3396 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3399 strcpy (own_buf
, "W00");
3404 gdbserver_version (void)
3406 printf ("GNU gdbserver %s%s\n"
3407 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3408 "gdbserver is free software, covered by the "
3409 "GNU General Public License.\n"
3410 "This gdbserver was configured as \"%s\"\n",
3411 PKGVERSION
, version
, host_name
);
3415 gdbserver_usage (FILE *stream
)
3417 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3418 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3419 "\tgdbserver [OPTIONS] --multi COMM\n"
3421 "COMM may either be a tty device (for serial debugging),\n"
3422 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3423 "stdin/stdout of gdbserver.\n"
3424 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3425 "PID is the process ID to attach to, when --attach is specified.\n"
3427 "Operating modes:\n"
3429 " --attach Attach to running process PID.\n"
3430 " --multi Start server without a specific program, and\n"
3431 " only quit when explicitly commanded.\n"
3432 " --once Exit after the first connection has closed.\n"
3433 " --help Print this message and then exit.\n"
3434 " --version Display version information and exit.\n"
3438 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3439 " --disable-randomization\n"
3440 " Run PROG with address space randomization disabled.\n"
3441 " --no-disable-randomization\n"
3442 " Don't disable address space randomization when\n"
3444 " --startup-with-shell\n"
3445 " Start PROG using a shell. I.e., execs a shell that\n"
3446 " then execs PROG. (default)\n"
3447 " --no-startup-with-shell\n"
3448 " Exec PROG directly instead of using a shell.\n"
3449 " Disables argument globbing and variable substitution\n"
3450 " on UNIX-like systems.\n"
3454 " --debug Enable general debugging output.\n"
3455 " --debug-format=OPT1[,OPT2,...]\n"
3456 " Specify extra content in debugging output.\n"
3461 " --remote-debug Enable remote protocol debugging output.\n"
3462 " --disable-packet=OPT1[,OPT2,...]\n"
3463 " Disable support for RSP packets or features.\n"
3465 " vCont, Tthread, qC, qfThreadInfo and \n"
3466 " threads (disable all threading packets).\n"
3468 "For more information, consult the GDB manual (available as on-line \n"
3469 "info or a printed manual).\n");
3470 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3471 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3475 gdbserver_show_disableable (FILE *stream
)
3477 fprintf (stream
, "Disableable packets:\n"
3478 " vCont \tAll vCont packets\n"
3479 " qC \tQuerying the current thread\n"
3480 " qfThreadInfo\tThread listing\n"
3481 " Tthread \tPassing the thread specifier in the "
3482 "T stop reply packet\n"
3483 " threads \tAll of the above\n");
3487 kill_inferior_callback (process_info
*process
)
3489 kill_inferior (process
);
3490 discard_queued_stop_replies (ptid_t (process
->pid
));
3493 /* Call this when exiting gdbserver with possible inferiors that need
3494 to be killed or detached from. */
3497 detach_or_kill_for_exit (void)
3499 /* First print a list of the inferiors we will be killing/detaching.
3500 This is to assist the user, for example, in case the inferior unexpectedly
3501 dies after we exit: did we screw up or did the inferior exit on its own?
3502 Having this info will save some head-scratching. */
3504 if (have_started_inferiors_p ())
3506 fprintf (stderr
, "Killing process(es):");
3508 for_each_process ([] (process_info
*process
) {
3509 if (!process
->attached
)
3510 fprintf (stderr
, " %d", process
->pid
);
3513 fprintf (stderr
, "\n");
3515 if (have_attached_inferiors_p ())
3517 fprintf (stderr
, "Detaching process(es):");
3519 for_each_process ([] (process_info
*process
) {
3520 if (process
->attached
)
3521 fprintf (stderr
, " %d", process
->pid
);
3524 fprintf (stderr
, "\n");
3527 /* Now we can kill or detach the inferiors. */
3528 for_each_process ([] (process_info
*process
) {
3529 int pid
= process
->pid
;
3531 if (process
->attached
)
3532 detach_inferior (process
);
3534 kill_inferior (process
);
3536 discard_queued_stop_replies (ptid_t (pid
));
3540 /* Value that will be passed to exit(3) when gdbserver exits. */
3541 static int exit_code
;
3543 /* Wrapper for detach_or_kill_for_exit that catches and prints
3547 detach_or_kill_for_exit_cleanup ()
3551 detach_or_kill_for_exit ();
3553 catch (const gdb_exception
&exception
)
3556 fprintf (stderr
, "Detach or kill failed: %s\n",
3562 /* Main function. This is called by the real "main" function,
3563 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3565 static void ATTRIBUTE_NORETURN
3566 captured_main (int argc
, char *argv
[])
3571 const char *port
= NULL
;
3572 char **next_arg
= &argv
[1];
3573 volatile int multi_mode
= 0;
3574 volatile int attach
= 0;
3576 bool selftest
= false;
3578 const char *selftest_filter
= NULL
;
3581 current_directory
= getcwd (NULL
, 0);
3582 client_state
&cs
= get_client_state ();
3584 if (current_directory
== NULL
)
3586 error (_("Could not find current working directory: %s"),
3587 safe_strerror (errno
));
3590 while (*next_arg
!= NULL
&& **next_arg
== '-')
3592 if (strcmp (*next_arg
, "--version") == 0)
3594 gdbserver_version ();
3597 else if (strcmp (*next_arg
, "--help") == 0)
3599 gdbserver_usage (stdout
);
3602 else if (strcmp (*next_arg
, "--attach") == 0)
3604 else if (strcmp (*next_arg
, "--multi") == 0)
3606 else if (strcmp (*next_arg
, "--wrapper") == 0)
3613 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3615 wrapper_argv
+= *next_arg
;
3616 wrapper_argv
+= ' ';
3620 if (!wrapper_argv
.empty ())
3622 /* Erase the last whitespace. */
3623 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3626 if (next_arg
== tmp
|| *next_arg
== NULL
)
3628 gdbserver_usage (stderr
);
3632 /* Consume the "--". */
3635 else if (strcmp (*next_arg
, "--debug") == 0)
3637 else if (startswith (*next_arg
, "--debug-format="))
3639 std::string error_msg
3640 = parse_debug_format_options ((*next_arg
)
3641 + sizeof ("--debug-format=") - 1, 0);
3643 if (!error_msg
.empty ())
3645 fprintf (stderr
, "%s", error_msg
.c_str ());
3649 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3651 else if (startswith (*next_arg
, "--debug-file="))
3652 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3653 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3655 gdbserver_show_disableable (stdout
);
3658 else if (startswith (*next_arg
, "--disable-packet="))
3660 char *packets
, *tok
;
3662 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3663 for (tok
= strtok (packets
, ",");
3665 tok
= strtok (NULL
, ","))
3667 if (strcmp ("vCont", tok
) == 0)
3668 disable_packet_vCont
= 1;
3669 else if (strcmp ("Tthread", tok
) == 0)
3670 disable_packet_Tthread
= 1;
3671 else if (strcmp ("qC", tok
) == 0)
3672 disable_packet_qC
= 1;
3673 else if (strcmp ("qfThreadInfo", tok
) == 0)
3674 disable_packet_qfThreadInfo
= 1;
3675 else if (strcmp ("threads", tok
) == 0)
3677 disable_packet_vCont
= 1;
3678 disable_packet_Tthread
= 1;
3679 disable_packet_qC
= 1;
3680 disable_packet_qfThreadInfo
= 1;
3684 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3686 gdbserver_show_disableable (stderr
);
3691 else if (strcmp (*next_arg
, "-") == 0)
3693 /* "-" specifies a stdio connection and is a form of port
3695 port
= STDIO_CONNECTION_NAME
;
3699 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3700 cs
.disable_randomization
= 1;
3701 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3702 cs
.disable_randomization
= 0;
3703 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3704 startup_with_shell
= true;
3705 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3706 startup_with_shell
= false;
3707 else if (strcmp (*next_arg
, "--once") == 0)
3709 else if (strcmp (*next_arg
, "--selftest") == 0)
3711 else if (startswith (*next_arg
, "--selftest="))
3715 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3720 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3733 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3736 gdbserver_usage (stderr
);
3740 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3741 opened by remote_prepare. */
3744 save_original_signals_state (false);
3746 /* We need to know whether the remote connection is stdio before
3747 starting the inferior. Inferiors created in this scenario have
3748 stdin,stdout redirected. So do this here before we call
3751 remote_prepare (port
);
3756 /* --attach used to come after PORT, so allow it there for
3758 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3765 && (*next_arg
== NULL
3766 || (*next_arg
)[0] == '\0'
3767 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3769 || next_arg
[1] != NULL
))
3774 gdbserver_usage (stderr
);
3778 /* Gather information about the environment. */
3779 our_environ
= gdb_environ::from_host_environ ();
3781 initialize_async_io ();
3783 have_job_control ();
3784 initialize_event_loop ();
3785 if (target_supports_tracepoints ())
3786 initialize_tracepoint ();
3788 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3793 selftests::run_tests (selftest_filter
);
3795 printf (_("Selftests have been disabled for this build.\n"));
3797 throw_quit ("Quit");
3800 if (pid
== 0 && *next_arg
!= NULL
)
3804 n
= argc
- (next_arg
- argv
);
3805 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3806 for (i
= 1; i
< n
; i
++)
3807 program_args
.push_back (xstrdup (next_arg
[i
]));
3808 program_args
.push_back (NULL
);
3810 /* Wait till we are at first instruction in program. */
3811 create_inferior (program_path
.get (), program_args
);
3813 /* We are now (hopefully) stopped at the first instruction of
3814 the target process. This assumes that the target process was
3815 successfully created. */
3819 if (attach_inferior (pid
) == -1)
3820 error ("Attaching not supported on this target");
3822 /* Otherwise succeeded. */
3826 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3827 cs
.last_status
.value
.integer
= 0;
3828 cs
.last_ptid
= minus_one_ptid
;
3831 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3833 /* Don't report shared library events on the initial connection,
3834 even if some libraries are preloaded. Avoids the "stopped by
3835 shared library event" notice on gdb side. */
3838 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3839 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3844 if (!was_running
&& !multi_mode
)
3845 error ("No program to debug");
3850 cs
.multi_process
= 0;
3851 cs
.report_fork_events
= 0;
3852 cs
.report_vfork_events
= 0;
3853 cs
.report_exec_events
= 0;
3854 /* Be sure we're out of tfind mode. */
3855 cs
.current_traceframe
= -1;
3856 cs
.cont_thread
= null_ptid
;
3857 cs
.swbreak_feature
= 0;
3858 cs
.hwbreak_feature
= 0;
3859 cs
.vCont_supported
= 0;
3865 /* Wait for events. This will return when all event sources
3866 are removed from the event loop. */
3867 start_event_loop ();
3869 /* If an exit was requested (using the "monitor exit"
3870 command), terminate now. */
3872 throw_quit ("Quit");
3874 /* The only other way to get here is for getpkt to fail:
3876 - If --once was specified, we're done.
3878 - If not in extended-remote mode, and we're no longer
3879 debugging anything, simply exit: GDB has disconnected
3880 after processing the last process exit.
3882 - Otherwise, close the connection and reopen it at the
3884 if (run_once
|| (!extended_protocol
&& !target_running ()))
3885 throw_quit ("Quit");
3888 "Remote side has terminated connection. "
3889 "GDBserver will reopen the connection.\n");
3891 /* Get rid of any pending statuses. An eventual reconnection
3892 (by the same GDB instance or another) will refresh all its
3893 state from scratch. */
3894 discard_queued_stop_replies (minus_one_ptid
);
3895 for_each_thread ([] (thread_info
*thread
)
3897 thread
->status_pending_p
= 0;
3902 if (disconnected_tracing
)
3904 /* Try to enable non-stop/async mode, so we we can
3905 both wait for an async socket accept, and handle
3906 async target events simultaneously. There's also
3907 no point either in having the target always stop
3908 all threads, when we're going to pass signals
3909 down without informing GDB. */
3912 if (start_non_stop (1))
3915 /* Detaching implicitly resumes all threads;
3916 simply disconnecting does not. */
3922 "Disconnected tracing disabled; "
3923 "stopping trace run.\n");
3928 catch (const gdb_exception_error
&exception
)
3931 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3933 if (response_needed
)
3935 write_enn (cs
.own_buf
);
3936 putpkt (cs
.own_buf
);
3940 throw_quit ("Quit");
3945 /* Main function. */
3948 main (int argc
, char *argv
[])
3953 captured_main (argc
, argv
);
3955 catch (const gdb_exception
&exception
)
3957 if (exception
.reason
== RETURN_ERROR
)
3960 fprintf (stderr
, "%s\n", exception
.what ());
3961 fprintf (stderr
, "Exiting\n");
3968 gdb_assert_not_reached ("captured_main should never return");
3971 /* Process options coming from Z packets for a breakpoint. PACKET is
3972 the packet buffer. *PACKET is updated to point to the first char
3973 after the last processed option. */
3976 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3978 const char *dataptr
= *packet
;
3981 /* Check if data has the correct format. */
3982 if (*dataptr
!= ';')
3989 if (*dataptr
== ';')
3992 if (*dataptr
== 'X')
3994 /* Conditional expression. */
3996 debug_printf ("Found breakpoint condition.\n");
3997 if (!add_breakpoint_condition (bp
, &dataptr
))
3998 dataptr
= strchrnul (dataptr
, ';');
4000 else if (startswith (dataptr
, "cmds:"))
4002 dataptr
+= strlen ("cmds:");
4004 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4005 persist
= (*dataptr
== '1');
4007 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4008 dataptr
= strchrnul (dataptr
, ';');
4012 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4014 /* Skip tokens until we find one that we recognize. */
4015 dataptr
= strchrnul (dataptr
, ';');
4021 /* Event loop callback that handles a serial event. The first byte in
4022 the serial buffer gets us here. We expect characters to arrive at
4023 a brisk pace, so we read the rest of the packet with a blocking
4027 process_serial_event (void)
4029 client_state
&cs
= get_client_state ();
4035 int new_packet_len
= -1;
4037 disable_async_io ();
4039 response_needed
= 0;
4040 packet_len
= getpkt (cs
.own_buf
);
4041 if (packet_len
<= 0)
4044 /* Force an event loop break. */
4047 response_needed
= 1;
4049 char ch
= cs
.own_buf
[0];
4053 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4056 handle_general_set (cs
.own_buf
);
4059 handle_detach (cs
.own_buf
);
4062 extended_protocol
= 1;
4063 write_ok (cs
.own_buf
);
4066 handle_status (cs
.own_buf
);
4069 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4071 require_running_or_break (cs
.own_buf
);
4073 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4075 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4076 thread_id
= null_ptid
;
4077 else if (thread_id
.is_pid ())
4079 /* The ptid represents a pid. */
4080 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4084 write_enn (cs
.own_buf
);
4088 thread_id
= thread
->id
;
4092 /* The ptid represents a lwp/tid. */
4093 if (find_thread_ptid (thread_id
) == NULL
)
4095 write_enn (cs
.own_buf
);
4100 if (cs
.own_buf
[1] == 'g')
4102 if (thread_id
== null_ptid
)
4104 /* GDB is telling us to choose any thread. Check if
4105 the currently selected thread is still valid. If
4106 it is not, select the first available. */
4107 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4109 thread
= get_first_thread ();
4110 thread_id
= thread
->id
;
4113 cs
.general_thread
= thread_id
;
4114 set_desired_thread ();
4115 gdb_assert (current_thread
!= NULL
);
4117 else if (cs
.own_buf
[1] == 'c')
4118 cs
.cont_thread
= thread_id
;
4120 write_ok (cs
.own_buf
);
4124 /* Silently ignore it so that gdb can extend the protocol
4125 without compatibility headaches. */
4126 cs
.own_buf
[0] = '\0';
4130 require_running_or_break (cs
.own_buf
);
4131 if (cs
.current_traceframe
>= 0)
4133 struct regcache
*regcache
4134 = new_register_cache (current_target_desc ());
4136 if (fetch_traceframe_registers (cs
.current_traceframe
,
4138 registers_to_string (regcache
, cs
.own_buf
);
4140 write_enn (cs
.own_buf
);
4141 free_register_cache (regcache
);
4145 struct regcache
*regcache
;
4147 if (!set_desired_thread ())
4148 write_enn (cs
.own_buf
);
4151 regcache
= get_thread_regcache (current_thread
, 1);
4152 registers_to_string (regcache
, cs
.own_buf
);
4157 require_running_or_break (cs
.own_buf
);
4158 if (cs
.current_traceframe
>= 0)
4159 write_enn (cs
.own_buf
);
4162 struct regcache
*regcache
;
4164 if (!set_desired_thread ())
4165 write_enn (cs
.own_buf
);
4168 regcache
= get_thread_regcache (current_thread
, 1);
4169 registers_from_string (regcache
, &cs
.own_buf
[1]);
4170 write_ok (cs
.own_buf
);
4176 require_running_or_break (cs
.own_buf
);
4177 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4178 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4180 write_enn (cs
.own_buf
);
4182 bin2hex (mem_buf
, cs
.own_buf
, res
);
4186 require_running_or_break (cs
.own_buf
);
4187 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4188 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4189 write_ok (cs
.own_buf
);
4191 write_enn (cs
.own_buf
);
4194 require_running_or_break (cs
.own_buf
);
4195 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4196 &mem_addr
, &len
, &mem_buf
) < 0
4197 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4198 write_enn (cs
.own_buf
);
4200 write_ok (cs
.own_buf
);
4203 require_running_or_break (cs
.own_buf
);
4204 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4205 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4206 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4209 myresume (cs
.own_buf
, 0, signal
);
4212 require_running_or_break (cs
.own_buf
);
4213 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4214 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4215 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4218 myresume (cs
.own_buf
, 1, signal
);
4221 require_running_or_break (cs
.own_buf
);
4223 myresume (cs
.own_buf
, 0, signal
);
4226 require_running_or_break (cs
.own_buf
);
4228 myresume (cs
.own_buf
, 1, signal
);
4230 case 'Z': /* insert_ ... */
4232 case 'z': /* remove_ ... */
4237 char type
= cs
.own_buf
[1];
4239 const int insert
= ch
== 'Z';
4240 const char *p
= &cs
.own_buf
[3];
4242 p
= unpack_varlen_hex (p
, &addr
);
4243 kind
= strtol (p
+ 1, &dataptr
, 16);
4247 struct gdb_breakpoint
*bp
;
4249 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4254 /* GDB may have sent us a list of *point parameters to
4255 be evaluated on the target's side. Read such list
4256 here. If we already have a list of parameters, GDB
4257 is telling us to drop that list and use this one
4259 clear_breakpoint_conditions_and_commands (bp
);
4260 const char *options
= dataptr
;
4261 process_point_options (bp
, &options
);
4265 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4268 write_ok (cs
.own_buf
);
4271 cs
.own_buf
[0] = '\0';
4273 write_enn (cs
.own_buf
);
4277 response_needed
= 0;
4278 if (!target_running ())
4279 /* The packet we received doesn't make sense - but we can't
4280 reply to it, either. */
4283 fprintf (stderr
, "Killing all inferiors\n");
4285 for_each_process (kill_inferior_callback
);
4287 /* When using the extended protocol, we wait with no program
4288 running. The traditional protocol will exit instead. */
4289 if (extended_protocol
)
4291 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4292 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4300 require_running_or_break (cs
.own_buf
);
4302 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4303 if (find_thread_ptid (thread_id
) == NULL
)
4305 write_enn (cs
.own_buf
);
4309 if (mythread_alive (thread_id
))
4310 write_ok (cs
.own_buf
);
4312 write_enn (cs
.own_buf
);
4316 response_needed
= 0;
4318 /* Restarting the inferior is only supported in the extended
4320 if (extended_protocol
)
4322 if (target_running ())
4323 for_each_process (kill_inferior_callback
);
4325 fprintf (stderr
, "GDBserver restarting\n");
4327 /* Wait till we are at 1st instruction in prog. */
4328 if (program_path
.get () != NULL
)
4330 create_inferior (program_path
.get (), program_args
);
4332 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4334 /* Stopped at the first instruction of the target
4336 cs
.general_thread
= cs
.last_ptid
;
4340 /* Something went wrong. */
4341 cs
.general_thread
= null_ptid
;
4346 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4347 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4353 /* It is a request we don't understand. Respond with an
4354 empty packet so that gdb knows that we don't support this
4356 cs
.own_buf
[0] = '\0';
4360 /* Extended (long) request. */
4361 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4365 /* It is a request we don't understand. Respond with an empty
4366 packet so that gdb knows that we don't support this
4368 cs
.own_buf
[0] = '\0';
4372 if (new_packet_len
!= -1)
4373 putpkt_binary (cs
.own_buf
, new_packet_len
);
4375 putpkt (cs
.own_buf
);
4377 response_needed
= 0;
4385 /* Event-loop callback for serial events. */
4388 handle_serial_event (int err
, gdb_client_data client_data
)
4391 debug_printf ("handling possible serial event\n");
4393 /* Really handle it. */
4394 if (process_serial_event () < 0)
4397 /* Be sure to not change the selected thread behind GDB's back.
4398 Important in the non-stop mode asynchronous protocol. */
4399 set_desired_thread ();
4404 /* Push a stop notification on the notification queue. */
4407 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4409 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4411 vstop_notif
->status
= *status
;
4412 vstop_notif
->ptid
= ptid
;
4413 /* Push Stop notification. */
4414 notif_push (¬if_stop
, vstop_notif
);
4417 /* Event-loop callback for target events. */
4420 handle_target_event (int err
, gdb_client_data client_data
)
4422 client_state
&cs
= get_client_state ();
4424 debug_printf ("handling possible target event\n");
4426 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4429 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4431 if (gdb_connected () && report_no_resumed
)
4432 push_stop_notification (null_ptid
, &cs
.last_status
);
4434 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4436 int pid
= cs
.last_ptid
.pid ();
4437 struct process_info
*process
= find_process_pid (pid
);
4438 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4440 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4441 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4443 mark_breakpoints_out (process
);
4444 target_mourn_inferior (cs
.last_ptid
);
4446 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4450 /* We're reporting this thread as stopped. Update its
4451 "want-stopped" state to what the client wants, until it
4452 gets a new resume action. */
4453 current_thread
->last_resume_kind
= resume_stop
;
4454 current_thread
->last_status
= cs
.last_status
;
4459 if (!target_running ())
4461 /* The last process exited. We're done. */
4465 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4466 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4467 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4471 /* A thread stopped with a signal, but gdb isn't
4472 connected to handle it. Pass it down to the
4473 inferior, as if it wasn't being traced. */
4474 enum gdb_signal signal
;
4477 debug_printf ("GDB not connected; forwarding event %d for"
4479 (int) cs
.last_status
.kind
,
4480 target_pid_to_str (cs
.last_ptid
));
4482 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4483 signal
= cs
.last_status
.value
.sig
;
4485 signal
= GDB_SIGNAL_0
;
4486 target_continue (cs
.last_ptid
, signal
);
4490 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4493 /* Be sure to not change the selected thread behind GDB's back.
4494 Important in the non-stop mode asynchronous protocol. */
4495 set_desired_thread ();
4508 } // namespace selftests
4509 #endif /* GDB_SELF_TEST */