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:statictrace:read. */
1619 handle_qxfer_statictrace (const char *annex
,
1620 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1621 ULONGEST offset
, LONGEST len
)
1623 client_state
&cs
= get_client_state ();
1626 if (writebuf
!= NULL
)
1629 if (annex
[0] != '\0' || current_thread
== NULL
1630 || cs
.current_traceframe
== -1)
1633 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1634 readbuf
, len
, &nbytes
))
1639 /* Helper for handle_qxfer_threads_proper.
1640 Emit the XML to describe the thread of INF. */
1643 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1645 ptid_t ptid
= ptid_of (thread
);
1647 int core
= target_core_of_thread (ptid
);
1649 const char *name
= target_thread_name (ptid
);
1652 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1654 write_ptid (ptid_s
, ptid
);
1656 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1660 sprintf (core_s
, "%d", core
);
1661 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1665 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1669 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1670 bin2hex (handle
, handle_s
, handle_len
);
1671 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1674 buffer_xml_printf (buffer
, "/>\n");
1677 /* Helper for handle_qxfer_threads. */
1680 handle_qxfer_threads_proper (struct buffer
*buffer
)
1682 buffer_grow_str (buffer
, "<threads>\n");
1684 for_each_thread ([&] (thread_info
*thread
)
1686 handle_qxfer_threads_worker (thread
, buffer
);
1689 buffer_grow_str0 (buffer
, "</threads>\n");
1692 /* Handle qXfer:threads:read. */
1695 handle_qxfer_threads (const char *annex
,
1696 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1697 ULONGEST offset
, LONGEST len
)
1699 static char *result
= 0;
1700 static unsigned int result_length
= 0;
1702 if (writebuf
!= NULL
)
1705 if (annex
[0] != '\0')
1710 struct buffer buffer
;
1711 /* When asked for data at offset 0, generate everything and store into
1712 'result'. Successive reads will be served off 'result'. */
1716 buffer_init (&buffer
);
1718 handle_qxfer_threads_proper (&buffer
);
1720 result
= buffer_finish (&buffer
);
1721 result_length
= strlen (result
);
1722 buffer_free (&buffer
);
1725 if (offset
>= result_length
)
1727 /* We're out of data. */
1734 if (len
> result_length
- offset
)
1735 len
= result_length
- offset
;
1737 memcpy (readbuf
, result
+ offset
, len
);
1742 /* Handle qXfer:traceframe-info:read. */
1745 handle_qxfer_traceframe_info (const char *annex
,
1746 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1747 ULONGEST offset
, LONGEST len
)
1749 client_state
&cs
= get_client_state ();
1750 static char *result
= 0;
1751 static unsigned int result_length
= 0;
1753 if (writebuf
!= NULL
)
1756 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1761 struct buffer buffer
;
1763 /* When asked for data at offset 0, generate everything and
1764 store into 'result'. Successive reads will be served off
1768 buffer_init (&buffer
);
1770 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1772 result
= buffer_finish (&buffer
);
1773 result_length
= strlen (result
);
1774 buffer_free (&buffer
);
1777 if (offset
>= result_length
)
1779 /* We're out of data. */
1786 if (len
> result_length
- offset
)
1787 len
= result_length
- offset
;
1789 memcpy (readbuf
, result
+ offset
, len
);
1793 /* Handle qXfer:fdpic:read. */
1796 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1797 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1799 if (the_target
->read_loadmap
== NULL
)
1802 if (current_thread
== NULL
)
1805 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1808 /* Handle qXfer:btrace:read. */
1811 handle_qxfer_btrace (const char *annex
,
1812 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1813 ULONGEST offset
, LONGEST len
)
1815 client_state
&cs
= get_client_state ();
1816 static struct buffer cache
;
1817 struct thread_info
*thread
;
1818 enum btrace_read_type type
;
1821 if (writebuf
!= NULL
)
1824 if (cs
.general_thread
== null_ptid
1825 || cs
.general_thread
== minus_one_ptid
)
1827 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1831 thread
= find_thread_ptid (cs
.general_thread
);
1834 strcpy (cs
.own_buf
, "E.No such thread.");
1838 if (thread
->btrace
== NULL
)
1840 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1844 if (strcmp (annex
, "all") == 0)
1845 type
= BTRACE_READ_ALL
;
1846 else if (strcmp (annex
, "new") == 0)
1847 type
= BTRACE_READ_NEW
;
1848 else if (strcmp (annex
, "delta") == 0)
1849 type
= BTRACE_READ_DELTA
;
1852 strcpy (cs
.own_buf
, "E.Bad annex.");
1858 buffer_free (&cache
);
1862 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1864 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1866 catch (const gdb_exception_error
&exception
)
1868 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1875 else if (offset
> cache
.used_size
)
1877 buffer_free (&cache
);
1881 if (len
> cache
.used_size
- offset
)
1882 len
= cache
.used_size
- offset
;
1884 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1889 /* Handle qXfer:btrace-conf:read. */
1892 handle_qxfer_btrace_conf (const char *annex
,
1893 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1894 ULONGEST offset
, LONGEST len
)
1896 client_state
&cs
= get_client_state ();
1897 static struct buffer cache
;
1898 struct thread_info
*thread
;
1901 if (writebuf
!= NULL
)
1904 if (annex
[0] != '\0')
1907 if (cs
.general_thread
== null_ptid
1908 || cs
.general_thread
== minus_one_ptid
)
1910 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1914 thread
= find_thread_ptid (cs
.general_thread
);
1917 strcpy (cs
.own_buf
, "E.No such thread.");
1921 if (thread
->btrace
== NULL
)
1923 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1929 buffer_free (&cache
);
1933 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1935 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1937 catch (const gdb_exception_error
&exception
)
1939 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1946 else if (offset
> cache
.used_size
)
1948 buffer_free (&cache
);
1952 if (len
> cache
.used_size
- offset
)
1953 len
= cache
.used_size
- offset
;
1955 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1960 static const struct qxfer qxfer_packets
[] =
1962 { "auxv", handle_qxfer_auxv
},
1963 { "btrace", handle_qxfer_btrace
},
1964 { "btrace-conf", handle_qxfer_btrace_conf
},
1965 { "exec-file", handle_qxfer_exec_file
},
1966 { "fdpic", handle_qxfer_fdpic
},
1967 { "features", handle_qxfer_features
},
1968 { "libraries", handle_qxfer_libraries
},
1969 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1970 { "osdata", handle_qxfer_osdata
},
1971 { "siginfo", handle_qxfer_siginfo
},
1972 { "statictrace", handle_qxfer_statictrace
},
1973 { "threads", handle_qxfer_threads
},
1974 { "traceframe-info", handle_qxfer_traceframe_info
},
1978 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1986 if (!startswith (own_buf
, "qXfer:"))
1989 /* Grab the object, r/w and annex. */
1990 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1992 write_enn (own_buf
);
1997 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2000 const struct qxfer
*q
= &qxfer_packets
[i
];
2002 if (strcmp (object
, q
->object
) == 0)
2004 if (strcmp (rw
, "read") == 0)
2006 unsigned char *data
;
2011 /* Grab the offset and length. */
2012 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2014 write_enn (own_buf
);
2018 /* Read one extra byte, as an indicator of whether there is
2020 if (len
> PBUFSIZ
- 2)
2022 data
= (unsigned char *) malloc (len
+ 1);
2025 write_enn (own_buf
);
2028 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2036 /* Preserve error message. */
2039 write_enn (own_buf
);
2041 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2043 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2048 else if (strcmp (rw
, "write") == 0)
2053 unsigned char *data
;
2055 strcpy (own_buf
, "E00");
2056 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2059 write_enn (own_buf
);
2062 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2063 &ofs
, &len
, data
) < 0)
2066 write_enn (own_buf
);
2070 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2078 /* Preserve error message. */
2081 write_enn (own_buf
);
2083 sprintf (own_buf
, "%x", n
);
2096 /* Compute 32 bit CRC from inferior memory.
2098 On success, return 32 bit CRC.
2099 On failure, return (unsigned long long) -1. */
2101 static unsigned long long
2102 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2106 unsigned char byte
= 0;
2108 /* Return failure if memory read fails. */
2109 if (read_inferior_memory (base
, &byte
, 1) != 0)
2110 return (unsigned long long) -1;
2112 crc
= xcrc32 (&byte
, 1, crc
);
2115 return (unsigned long long) crc
;
2118 /* Add supported btrace packets to BUF. */
2121 supported_btrace_packets (char *buf
)
2123 strcat (buf
, ";Qbtrace:bts+");
2124 strcat (buf
, ";Qbtrace-conf:bts:size+");
2125 strcat (buf
, ";Qbtrace:pt+");
2126 strcat (buf
, ";Qbtrace-conf:pt:size+");
2127 strcat (buf
, ";Qbtrace:off+");
2128 strcat (buf
, ";qXfer:btrace:read+");
2129 strcat (buf
, ";qXfer:btrace-conf:read+");
2132 /* Handle all of the extended 'q' packets. */
2135 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2137 client_state
&cs
= get_client_state ();
2138 static std::list
<thread_info
*>::const_iterator thread_iter
;
2140 /* Reply the current thread id. */
2141 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2144 require_running_or_return (own_buf
);
2146 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2147 ptid
= cs
.general_thread
;
2150 thread_iter
= all_threads
.begin ();
2151 ptid
= (*thread_iter
)->id
;
2154 sprintf (own_buf
, "QC");
2156 write_ptid (own_buf
, ptid
);
2160 if (strcmp ("qSymbol::", own_buf
) == 0)
2162 struct thread_info
*save_thread
= current_thread
;
2164 /* For qSymbol, GDB only changes the current thread if the
2165 previous current thread was of a different process. So if
2166 the previous thread is gone, we need to pick another one of
2167 the same process. This can happen e.g., if we followed an
2168 exec in a non-leader thread. */
2169 if (current_thread
== NULL
)
2172 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2174 /* Just in case, if we didn't find a thread, then bail out
2175 instead of crashing. */
2176 if (current_thread
== NULL
)
2178 write_enn (own_buf
);
2179 current_thread
= save_thread
;
2184 /* GDB is suggesting new symbols have been loaded. This may
2185 mean a new shared library has been detected as loaded, so
2186 take the opportunity to check if breakpoints we think are
2187 inserted, still are. Note that it isn't guaranteed that
2188 we'll see this when a shared library is loaded, and nor will
2189 we see this for unloads (although breakpoints in unloaded
2190 libraries shouldn't trigger), as GDB may not find symbols for
2191 the library at all. We also re-validate breakpoints when we
2192 see a second GDB breakpoint for the same address, and or when
2193 we access breakpoint shadows. */
2194 validate_breakpoints ();
2196 if (target_supports_tracepoints ())
2197 tracepoint_look_up_symbols ();
2199 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2200 (*the_target
->look_up_symbols
) ();
2202 current_thread
= save_thread
;
2204 strcpy (own_buf
, "OK");
2208 if (!disable_packet_qfThreadInfo
)
2210 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2212 require_running_or_return (own_buf
);
2213 thread_iter
= all_threads
.begin ();
2216 ptid_t ptid
= (*thread_iter
)->id
;
2217 write_ptid (own_buf
, ptid
);
2222 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2224 require_running_or_return (own_buf
);
2225 if (thread_iter
!= all_threads
.end ())
2228 ptid_t ptid
= (*thread_iter
)->id
;
2229 write_ptid (own_buf
, ptid
);
2235 sprintf (own_buf
, "l");
2241 if (the_target
->read_offsets
!= NULL
2242 && strcmp ("qOffsets", own_buf
) == 0)
2244 CORE_ADDR text
, data
;
2246 require_running_or_return (own_buf
);
2247 if (the_target
->read_offsets (&text
, &data
))
2248 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2249 (long)text
, (long)data
, (long)data
);
2251 write_enn (own_buf
);
2256 /* Protocol features query. */
2257 if (startswith (own_buf
, "qSupported")
2258 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2260 char *p
= &own_buf
[10];
2261 int gdb_supports_qRelocInsn
= 0;
2263 /* Process each feature being provided by GDB. The first
2264 feature will follow a ':', and latter features will follow
2268 char **qsupported
= NULL
;
2273 /* Two passes, to avoid nested strtok calls in
2274 target_process_qsupported. */
2275 for (p
= strtok (p
+ 1, ";");
2277 p
= strtok (NULL
, ";"))
2280 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2281 qsupported
[count
- 1] = xstrdup (p
);
2284 for (i
= 0; i
< count
; i
++)
2287 if (strcmp (p
, "multiprocess+") == 0)
2289 /* GDB supports and wants multi-process support if
2291 if (target_supports_multi_process ())
2292 cs
.multi_process
= 1;
2294 else if (strcmp (p
, "qRelocInsn+") == 0)
2296 /* GDB supports relocate instruction requests. */
2297 gdb_supports_qRelocInsn
= 1;
2299 else if (strcmp (p
, "swbreak+") == 0)
2301 /* GDB wants us to report whether a trap is caused
2302 by a software breakpoint and for us to handle PC
2303 adjustment if necessary on this target. */
2304 if (target_supports_stopped_by_sw_breakpoint ())
2305 cs
.swbreak_feature
= 1;
2307 else if (strcmp (p
, "hwbreak+") == 0)
2309 /* GDB wants us to report whether a trap is caused
2310 by a hardware breakpoint. */
2311 if (target_supports_stopped_by_hw_breakpoint ())
2312 cs
.hwbreak_feature
= 1;
2314 else if (strcmp (p
, "fork-events+") == 0)
2316 /* GDB supports and wants fork events if possible. */
2317 if (target_supports_fork_events ())
2318 cs
.report_fork_events
= 1;
2320 else if (strcmp (p
, "vfork-events+") == 0)
2322 /* GDB supports and wants vfork events if possible. */
2323 if (target_supports_vfork_events ())
2324 cs
.report_vfork_events
= 1;
2326 else if (strcmp (p
, "exec-events+") == 0)
2328 /* GDB supports and wants exec events if possible. */
2329 if (target_supports_exec_events ())
2330 cs
.report_exec_events
= 1;
2332 else if (strcmp (p
, "vContSupported+") == 0)
2333 cs
.vCont_supported
= 1;
2334 else if (strcmp (p
, "QThreadEvents+") == 0)
2336 else if (strcmp (p
, "no-resumed+") == 0)
2338 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2340 report_no_resumed
= 1;
2344 /* Move the unknown features all together. */
2345 qsupported
[i
] = NULL
;
2346 qsupported
[unknown
] = p
;
2351 /* Give the target backend a chance to process the unknown
2353 target_process_qsupported (qsupported
, unknown
);
2355 for (i
= 0; i
< count
; i
++)
2356 free (qsupported
[i
]);
2361 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2362 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2363 "QEnvironmentReset+;QEnvironmentUnset+;"
2367 if (target_supports_catch_syscall ())
2368 strcat (own_buf
, ";QCatchSyscalls+");
2370 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2371 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2372 ";augmented-libraries-svr4-read+");
2375 /* We do not have any hook to indicate whether the non-SVR4 target
2376 backend supports qXfer:libraries:read, so always report it. */
2377 strcat (own_buf
, ";qXfer:libraries:read+");
2380 if (the_target
->read_auxv
!= NULL
)
2381 strcat (own_buf
, ";qXfer:auxv:read+");
2383 if (the_target
->qxfer_siginfo
!= NULL
)
2384 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2386 if (the_target
->read_loadmap
!= NULL
)
2387 strcat (own_buf
, ";qXfer:fdpic:read+");
2389 /* We always report qXfer:features:read, as targets may
2390 install XML files on a subsequent call to arch_setup.
2391 If we reported to GDB on startup that we don't support
2392 qXfer:feature:read at all, we will never be re-queried. */
2393 strcat (own_buf
, ";qXfer:features:read+");
2395 if (cs
.transport_is_reliable
)
2396 strcat (own_buf
, ";QStartNoAckMode+");
2398 if (the_target
->qxfer_osdata
!= NULL
)
2399 strcat (own_buf
, ";qXfer:osdata:read+");
2401 if (target_supports_multi_process ())
2402 strcat (own_buf
, ";multiprocess+");
2404 if (target_supports_fork_events ())
2405 strcat (own_buf
, ";fork-events+");
2407 if (target_supports_vfork_events ())
2408 strcat (own_buf
, ";vfork-events+");
2410 if (target_supports_exec_events ())
2411 strcat (own_buf
, ";exec-events+");
2413 if (target_supports_non_stop ())
2414 strcat (own_buf
, ";QNonStop+");
2416 if (target_supports_disable_randomization ())
2417 strcat (own_buf
, ";QDisableRandomization+");
2419 strcat (own_buf
, ";qXfer:threads:read+");
2421 if (target_supports_tracepoints ())
2423 strcat (own_buf
, ";ConditionalTracepoints+");
2424 strcat (own_buf
, ";TraceStateVariables+");
2425 strcat (own_buf
, ";TracepointSource+");
2426 strcat (own_buf
, ";DisconnectedTracing+");
2427 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2428 strcat (own_buf
, ";FastTracepoints+");
2429 strcat (own_buf
, ";StaticTracepoints+");
2430 strcat (own_buf
, ";InstallInTrace+");
2431 strcat (own_buf
, ";qXfer:statictrace:read+");
2432 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2433 strcat (own_buf
, ";EnableDisableTracepoints+");
2434 strcat (own_buf
, ";QTBuffer:size+");
2435 strcat (own_buf
, ";tracenz+");
2438 if (target_supports_hardware_single_step ()
2439 || target_supports_software_single_step () )
2441 strcat (own_buf
, ";ConditionalBreakpoints+");
2443 strcat (own_buf
, ";BreakpointCommands+");
2445 if (target_supports_agent ())
2446 strcat (own_buf
, ";QAgent+");
2448 supported_btrace_packets (own_buf
);
2450 if (target_supports_stopped_by_sw_breakpoint ())
2451 strcat (own_buf
, ";swbreak+");
2453 if (target_supports_stopped_by_hw_breakpoint ())
2454 strcat (own_buf
, ";hwbreak+");
2456 if (the_target
->pid_to_exec_file
!= NULL
)
2457 strcat (own_buf
, ";qXfer:exec-file:read+");
2459 strcat (own_buf
, ";vContSupported+");
2461 strcat (own_buf
, ";QThreadEvents+");
2463 strcat (own_buf
, ";no-resumed+");
2465 /* Reinitialize components as needed for the new connection. */
2466 hostio_handle_new_gdb_connection ();
2467 target_handle_new_gdb_connection ();
2472 /* Thread-local storage support. */
2473 if (the_target
->get_tls_address
!= NULL
2474 && startswith (own_buf
, "qGetTLSAddr:"))
2476 char *p
= own_buf
+ 12;
2477 CORE_ADDR parts
[2], address
= 0;
2479 ptid_t ptid
= null_ptid
;
2481 require_running_or_return (own_buf
);
2483 for (i
= 0; i
< 3; i
++)
2491 p2
= strchr (p
, ',');
2504 ptid
= read_ptid (p
, NULL
);
2506 decode_address (&parts
[i
- 1], p
, len
);
2510 if (p
!= NULL
|| i
< 3)
2514 struct thread_info
*thread
= find_thread_ptid (ptid
);
2519 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2525 strcpy (own_buf
, paddress(address
));
2530 write_enn (own_buf
);
2534 /* Otherwise, pretend we do not understand this packet. */
2537 /* Windows OS Thread Information Block address support. */
2538 if (the_target
->get_tib_address
!= NULL
2539 && startswith (own_buf
, "qGetTIBAddr:"))
2544 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2546 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2549 strcpy (own_buf
, paddress(tlb
));
2554 write_enn (own_buf
);
2560 /* Handle "monitor" commands. */
2561 if (startswith (own_buf
, "qRcmd,"))
2563 char *mon
= (char *) malloc (PBUFSIZ
);
2564 int len
= strlen (own_buf
+ 6);
2568 write_enn (own_buf
);
2573 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2575 write_enn (own_buf
);
2579 mon
[len
/ 2] = '\0';
2583 if (the_target
->handle_monitor_command
== NULL
2584 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2585 /* Default processing. */
2586 handle_monitor_command (mon
, own_buf
);
2592 if (startswith (own_buf
, "qSearch:memory:"))
2594 require_running_or_return (own_buf
);
2595 handle_search_memory (own_buf
, packet_len
);
2599 if (strcmp (own_buf
, "qAttached") == 0
2600 || startswith (own_buf
, "qAttached:"))
2602 struct process_info
*process
;
2604 if (own_buf
[sizeof ("qAttached") - 1])
2606 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2607 process
= find_process_pid (pid
);
2611 require_running_or_return (own_buf
);
2612 process
= current_process ();
2615 if (process
== NULL
)
2617 write_enn (own_buf
);
2621 strcpy (own_buf
, process
->attached
? "1" : "0");
2625 if (startswith (own_buf
, "qCRC:"))
2627 /* CRC check (compare-section). */
2631 unsigned long long crc
;
2633 require_running_or_return (own_buf
);
2634 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2635 if (*comma
++ != ',')
2637 write_enn (own_buf
);
2640 len
= strtoul (comma
, NULL
, 16);
2641 crc
= crc32 (base
, len
, 0xffffffff);
2642 /* Check for memory failure. */
2643 if (crc
== (unsigned long long) -1)
2645 write_enn (own_buf
);
2648 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2652 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2655 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2658 /* Otherwise we didn't know what packet it was. Say we didn't
2663 static void gdb_wants_all_threads_stopped (void);
2664 static void resume (struct thread_resume
*actions
, size_t n
);
2666 /* The callback that is passed to visit_actioned_threads. */
2667 typedef int (visit_actioned_threads_callback_ftype
)
2668 (const struct thread_resume
*, struct thread_info
*);
2670 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2671 true if CALLBACK returns true. Returns false if no matching thread
2672 is found or CALLBACK results false.
2673 Note: This function is itself a callback for find_thread. */
2676 visit_actioned_threads (thread_info
*thread
,
2677 const struct thread_resume
*actions
,
2679 visit_actioned_threads_callback_ftype
*callback
)
2681 for (size_t i
= 0; i
< num_actions
; i
++)
2683 const struct thread_resume
*action
= &actions
[i
];
2685 if (action
->thread
== minus_one_ptid
2686 || action
->thread
== thread
->id
2687 || ((action
->thread
.pid ()
2688 == thread
->id
.pid ())
2689 && action
->thread
.lwp () == -1))
2691 if ((*callback
) (action
, thread
))
2699 /* Callback for visit_actioned_threads. If the thread has a pending
2700 status to report, report it now. */
2703 handle_pending_status (const struct thread_resume
*resumption
,
2704 struct thread_info
*thread
)
2706 client_state
&cs
= get_client_state ();
2707 if (thread
->status_pending_p
)
2709 thread
->status_pending_p
= 0;
2711 cs
.last_status
= thread
->last_status
;
2712 cs
.last_ptid
= thread
->id
;
2713 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2719 /* Parse vCont packets. */
2721 handle_v_cont (char *own_buf
)
2725 struct thread_resume
*resume_info
;
2726 struct thread_resume default_action
{ null_ptid
};
2728 /* Count the number of semicolons in the packet. There should be one
2729 for every action. */
2735 p
= strchr (p
, ';');
2738 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2739 if (resume_info
== NULL
)
2747 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2749 if (p
[0] == 's' || p
[0] == 'S')
2750 resume_info
[i
].kind
= resume_step
;
2751 else if (p
[0] == 'r')
2752 resume_info
[i
].kind
= resume_step
;
2753 else if (p
[0] == 'c' || p
[0] == 'C')
2754 resume_info
[i
].kind
= resume_continue
;
2755 else if (p
[0] == 't')
2756 resume_info
[i
].kind
= resume_stop
;
2760 if (p
[0] == 'S' || p
[0] == 'C')
2763 int sig
= strtol (p
+ 1, &q
, 16);
2768 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2770 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2772 else if (p
[0] == 'r')
2776 p
= unpack_varlen_hex (p
+ 1, &addr
);
2777 resume_info
[i
].step_range_start
= addr
;
2782 p
= unpack_varlen_hex (p
+ 1, &addr
);
2783 resume_info
[i
].step_range_end
= addr
;
2792 resume_info
[i
].thread
= minus_one_ptid
;
2793 default_action
= resume_info
[i
];
2795 /* Note: we don't increment i here, we'll overwrite this entry
2796 the next time through. */
2798 else if (p
[0] == ':')
2801 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2806 if (p
[0] != ';' && p
[0] != 0)
2809 resume_info
[i
].thread
= ptid
;
2816 resume_info
[i
] = default_action
;
2818 resume (resume_info
, n
);
2823 write_enn (own_buf
);
2828 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2831 resume (struct thread_resume
*actions
, size_t num_actions
)
2833 client_state
&cs
= get_client_state ();
2836 /* Check if among the threads that GDB wants actioned, there's
2837 one with a pending status to report. If so, skip actually
2838 resuming/stopping and report the pending event
2841 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2843 return visit_actioned_threads (thread
, actions
, num_actions
,
2844 handle_pending_status
);
2847 if (thread_with_status
!= NULL
)
2853 (*the_target
->resume
) (actions
, num_actions
);
2856 write_ok (cs
.own_buf
);
2859 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2861 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2862 && !report_no_resumed
)
2864 /* The client does not support this stop reply. At least
2866 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2867 disable_async_io ();
2871 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2872 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2873 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2874 current_thread
->last_status
= cs
.last_status
;
2876 /* From the client's perspective, all-stop mode always stops all
2877 threads implicitly (and the target backend has already done
2878 so by now). Tag all threads as "want-stopped", so we don't
2879 resume them implicitly without the client telling us to. */
2880 gdb_wants_all_threads_stopped ();
2881 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2882 disable_async_io ();
2884 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2885 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2886 target_mourn_inferior (cs
.last_ptid
);
2890 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2892 handle_v_attach (char *own_buf
)
2894 client_state
&cs
= get_client_state ();
2898 pid
= strtol (own_buf
+ 8, NULL
, 16);
2902 ret
= attach_inferior (pid
);
2904 catch (const gdb_exception_error
&e
)
2906 snprintf (own_buf
, PBUFSIZ
, "E.%s", e
.what ());
2910 if (pid
!= 0 && ret
== 0)
2912 /* Don't report shared library events after attaching, even if
2913 some libraries are preloaded. GDB will always poll the
2914 library list. Avoids the "stopped by shared library event"
2915 notice on the GDB side. */
2920 /* In non-stop, we don't send a resume reply. Stop events
2921 will follow up using the normal notification
2926 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2932 write_enn (own_buf
);
2937 /* Run a new program. Return 1 if successful, 0 if failure. */
2939 handle_v_run (char *own_buf
)
2941 client_state
&cs
= get_client_state ();
2943 std::vector
<char *> new_argv
;
2944 char *new_program_name
= NULL
;
2948 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2954 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2956 next_p
= strchr (p
, ';');
2958 next_p
= p
+ strlen (p
);
2960 if (i
== 0 && p
== next_p
)
2962 /* No program specified. */
2963 new_program_name
= NULL
;
2965 else if (p
== next_p
)
2967 /* Empty argument. */
2968 new_argv
.push_back (xstrdup ("''"));
2972 size_t len
= (next_p
- p
) / 2;
2973 /* ARG is the unquoted argument received via the RSP. */
2974 char *arg
= (char *) xmalloc (len
+ 1);
2975 /* FULL_ARGS will contain the quoted version of ARG. */
2976 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2977 /* These are pointers used to navigate the strings above. */
2978 char *tmp_arg
= arg
;
2979 char *tmp_full_arg
= full_arg
;
2982 hex2bin (p
, (gdb_byte
*) arg
, len
);
2985 while (*tmp_arg
!= '\0')
2991 *tmp_full_arg
= '\'';
2997 /* Quote single quote. */
2998 *tmp_full_arg
= '\\';
3006 *tmp_full_arg
= *tmp_arg
;
3012 *tmp_full_arg
++ = '\'';
3014 /* Finish FULL_ARG and push it into the vector containing
3016 *tmp_full_arg
= '\0';
3018 new_program_name
= full_arg
;
3020 new_argv
.push_back (full_arg
);
3026 new_argv
.push_back (NULL
);
3028 if (new_program_name
== NULL
)
3030 /* GDB didn't specify a program to run. Use the program from the
3031 last run with the new argument list. */
3032 if (program_path
.get () == NULL
)
3034 write_enn (own_buf
);
3035 free_vector_argv (new_argv
);
3040 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3042 /* Free the old argv and install the new one. */
3043 free_vector_argv (program_args
);
3044 program_args
= new_argv
;
3046 create_inferior (program_path
.get (), program_args
);
3048 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3050 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3052 /* In non-stop, sending a resume reply doesn't set the general
3053 thread, but GDB assumes a vRun sets it (this is so GDB can
3054 query which is the main thread of the new inferior. */
3056 cs
.general_thread
= cs
.last_ptid
;
3062 write_enn (own_buf
);
3067 /* Kill process. Return 1 if successful, 0 if failure. */
3069 handle_v_kill (char *own_buf
)
3071 client_state
&cs
= get_client_state ();
3073 char *p
= &own_buf
[6];
3074 if (cs
.multi_process
)
3075 pid
= strtol (p
, NULL
, 16);
3079 process_info
*proc
= find_process_pid (pid
);
3081 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3083 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3084 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3085 cs
.last_ptid
= ptid_t (pid
);
3086 discard_queued_stop_replies (cs
.last_ptid
);
3092 write_enn (own_buf
);
3097 /* Handle all of the extended 'v' packets. */
3099 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3101 client_state
&cs
= get_client_state ();
3102 if (!disable_packet_vCont
)
3104 if (strcmp (own_buf
, "vCtrlC") == 0)
3106 (*the_target
->request_interrupt
) ();
3111 if (startswith (own_buf
, "vCont;"))
3113 handle_v_cont (own_buf
);
3117 if (startswith (own_buf
, "vCont?"))
3119 strcpy (own_buf
, "vCont;c;C;t");
3121 if (target_supports_hardware_single_step ()
3122 || target_supports_software_single_step ()
3123 || !cs
.vCont_supported
)
3125 /* If target supports single step either by hardware or by
3126 software, add actions s and S to the list of supported
3127 actions. On the other hand, if GDB doesn't request the
3128 supported vCont actions in qSupported packet, add s and
3129 S to the list too. */
3130 own_buf
= own_buf
+ strlen (own_buf
);
3131 strcpy (own_buf
, ";s;S");
3134 if (target_supports_range_stepping ())
3136 own_buf
= own_buf
+ strlen (own_buf
);
3137 strcpy (own_buf
, ";r");
3143 if (startswith (own_buf
, "vFile:")
3144 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3147 if (startswith (own_buf
, "vAttach;"))
3149 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3151 fprintf (stderr
, "Already debugging a process\n");
3152 write_enn (own_buf
);
3155 handle_v_attach (own_buf
);
3159 if (startswith (own_buf
, "vRun;"))
3161 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3163 fprintf (stderr
, "Already debugging a process\n");
3164 write_enn (own_buf
);
3167 handle_v_run (own_buf
);
3171 if (startswith (own_buf
, "vKill;"))
3173 if (!target_running ())
3175 fprintf (stderr
, "No process to kill\n");
3176 write_enn (own_buf
);
3179 handle_v_kill (own_buf
);
3183 if (handle_notif_ack (own_buf
, packet_len
))
3186 /* Otherwise we didn't know what packet it was. Say we didn't
3192 /* Resume thread and wait for another event. In non-stop mode,
3193 don't really wait here, but return immediatelly to the event
3196 myresume (char *own_buf
, int step
, int sig
)
3198 client_state
&cs
= get_client_state ();
3199 struct thread_resume resume_info
[2];
3201 int valid_cont_thread
;
3203 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3204 && cs
.cont_thread
!= minus_one_ptid
);
3206 if (step
|| sig
|| valid_cont_thread
)
3208 resume_info
[0].thread
= current_ptid
;
3210 resume_info
[0].kind
= resume_step
;
3212 resume_info
[0].kind
= resume_continue
;
3213 resume_info
[0].sig
= sig
;
3217 if (!valid_cont_thread
)
3219 resume_info
[n
].thread
= minus_one_ptid
;
3220 resume_info
[n
].kind
= resume_continue
;
3221 resume_info
[n
].sig
= 0;
3225 resume (resume_info
, n
);
3228 /* Callback for for_each_thread. Make a new stop reply for each
3232 queue_stop_reply_callback (thread_info
*thread
)
3234 /* For now, assume targets that don't have this callback also don't
3235 manage the thread's last_status field. */
3236 if (the_target
->thread_stopped
== NULL
)
3238 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3240 new_notif
->ptid
= thread
->id
;
3241 new_notif
->status
= thread
->last_status
;
3242 /* Pass the last stop reply back to GDB, but don't notify
3244 notif_event_enque (¬if_stop
, new_notif
);
3248 if (thread_stopped (thread
))
3252 std::string status_string
3253 = target_waitstatus_to_string (&thread
->last_status
);
3255 debug_printf ("Reporting thread %s as already stopped with %s\n",
3256 target_pid_to_str (thread
->id
),
3257 status_string
.c_str ());
3260 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3262 /* Pass the last stop reply back to GDB, but don't notify
3264 queue_stop_reply (thread
->id
, &thread
->last_status
);
3269 /* Set this inferior threads's state as "want-stopped". We won't
3270 resume this thread until the client gives us another action for
3274 gdb_wants_thread_stopped (thread_info
*thread
)
3276 thread
->last_resume_kind
= resume_stop
;
3278 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3280 /* Most threads are stopped implicitly (all-stop); tag that with
3282 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3283 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3287 /* Set all threads' states as "want-stopped". */
3290 gdb_wants_all_threads_stopped (void)
3292 for_each_thread (gdb_wants_thread_stopped
);
3295 /* Callback for for_each_thread. If the thread is stopped with an
3296 interesting event, mark it as having a pending event. */
3299 set_pending_status_callback (thread_info
*thread
)
3301 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3302 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3303 /* A breakpoint, watchpoint or finished step from a previous
3304 GDB run isn't considered interesting for a new GDB run.
3305 If we left those pending, the new GDB could consider them
3306 random SIGTRAPs. This leaves out real async traps. We'd
3307 have to peek into the (target-specific) siginfo to
3308 distinguish those. */
3309 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3310 thread
->status_pending_p
= 1;
3313 /* Status handler for the '?' packet. */
3316 handle_status (char *own_buf
)
3318 client_state
&cs
= get_client_state ();
3320 /* GDB is connected, don't forward events to the target anymore. */
3321 for_each_process ([] (process_info
*process
) {
3322 process
->gdb_detached
= 0;
3325 /* In non-stop mode, we must send a stop reply for each stopped
3326 thread. In all-stop mode, just send one for the first stopped
3331 for_each_thread (queue_stop_reply_callback
);
3333 /* The first is sent immediatly. OK is sent if there is no
3334 stopped thread, which is the same handling of the vStopped
3335 packet (by design). */
3336 notif_write_event (¬if_stop
, cs
.own_buf
);
3340 thread_info
*thread
= NULL
;
3343 stabilize_threads ();
3344 gdb_wants_all_threads_stopped ();
3346 /* We can only report one status, but we might be coming out of
3347 non-stop -- if more than one thread is stopped with
3348 interesting events, leave events for the threads we're not
3349 reporting now pending. They'll be reported the next time the
3350 threads are resumed. Start by marking all interesting events
3352 for_each_thread (set_pending_status_callback
);
3354 /* Prefer the last thread that reported an event to GDB (even if
3355 that was a GDB_SIGNAL_TRAP). */
3356 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3357 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3358 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3359 thread
= find_thread_ptid (cs
.last_ptid
);
3361 /* If the last event thread is not found for some reason, look
3362 for some other thread that might have an event to report. */
3364 thread
= find_thread ([] (thread_info
*thr_arg
)
3366 return thr_arg
->status_pending_p
;
3369 /* If we're still out of luck, simply pick the first thread in
3372 thread
= get_first_thread ();
3376 struct thread_info
*tp
= (struct thread_info
*) thread
;
3378 /* We're reporting this event, so it's no longer
3380 tp
->status_pending_p
= 0;
3382 /* GDB assumes the current thread is the thread we're
3383 reporting the status for. */
3384 cs
.general_thread
= thread
->id
;
3385 set_desired_thread ();
3387 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3388 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3391 strcpy (own_buf
, "W00");
3396 gdbserver_version (void)
3398 printf ("GNU gdbserver %s%s\n"
3399 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3400 "gdbserver is free software, covered by the "
3401 "GNU General Public License.\n"
3402 "This gdbserver was configured as \"%s\"\n",
3403 PKGVERSION
, version
, host_name
);
3407 gdbserver_usage (FILE *stream
)
3409 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3410 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3411 "\tgdbserver [OPTIONS] --multi COMM\n"
3413 "COMM may either be a tty device (for serial debugging),\n"
3414 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3415 "stdin/stdout of gdbserver.\n"
3416 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3417 "PID is the process ID to attach to, when --attach is specified.\n"
3419 "Operating modes:\n"
3421 " --attach Attach to running process PID.\n"
3422 " --multi Start server without a specific program, and\n"
3423 " only quit when explicitly commanded.\n"
3424 " --once Exit after the first connection has closed.\n"
3425 " --help Print this message and then exit.\n"
3426 " --version Display version information and exit.\n"
3430 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3431 " --disable-randomization\n"
3432 " Run PROG with address space randomization disabled.\n"
3433 " --no-disable-randomization\n"
3434 " Don't disable address space randomization when\n"
3436 " --startup-with-shell\n"
3437 " Start PROG using a shell. I.e., execs a shell that\n"
3438 " then execs PROG. (default)\n"
3439 " --no-startup-with-shell\n"
3440 " Exec PROG directly instead of using a shell.\n"
3441 " Disables argument globbing and variable substitution\n"
3442 " on UNIX-like systems.\n"
3446 " --debug Enable general debugging output.\n"
3447 " --debug-format=OPT1[,OPT2,...]\n"
3448 " Specify extra content in debugging output.\n"
3453 " --remote-debug Enable remote protocol debugging output.\n"
3454 " --disable-packet=OPT1[,OPT2,...]\n"
3455 " Disable support for RSP packets or features.\n"
3457 " vCont, Tthread, qC, qfThreadInfo and \n"
3458 " threads (disable all threading packets).\n"
3460 "For more information, consult the GDB manual (available as on-line \n"
3461 "info or a printed manual).\n");
3462 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3463 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3467 gdbserver_show_disableable (FILE *stream
)
3469 fprintf (stream
, "Disableable packets:\n"
3470 " vCont \tAll vCont packets\n"
3471 " qC \tQuerying the current thread\n"
3472 " qfThreadInfo\tThread listing\n"
3473 " Tthread \tPassing the thread specifier in the "
3474 "T stop reply packet\n"
3475 " threads \tAll of the above\n");
3479 kill_inferior_callback (process_info
*process
)
3481 kill_inferior (process
);
3482 discard_queued_stop_replies (ptid_t (process
->pid
));
3485 /* Call this when exiting gdbserver with possible inferiors that need
3486 to be killed or detached from. */
3489 detach_or_kill_for_exit (void)
3491 /* First print a list of the inferiors we will be killing/detaching.
3492 This is to assist the user, for example, in case the inferior unexpectedly
3493 dies after we exit: did we screw up or did the inferior exit on its own?
3494 Having this info will save some head-scratching. */
3496 if (have_started_inferiors_p ())
3498 fprintf (stderr
, "Killing process(es):");
3500 for_each_process ([] (process_info
*process
) {
3501 if (!process
->attached
)
3502 fprintf (stderr
, " %d", process
->pid
);
3505 fprintf (stderr
, "\n");
3507 if (have_attached_inferiors_p ())
3509 fprintf (stderr
, "Detaching process(es):");
3511 for_each_process ([] (process_info
*process
) {
3512 if (process
->attached
)
3513 fprintf (stderr
, " %d", process
->pid
);
3516 fprintf (stderr
, "\n");
3519 /* Now we can kill or detach the inferiors. */
3520 for_each_process ([] (process_info
*process
) {
3521 int pid
= process
->pid
;
3523 if (process
->attached
)
3524 detach_inferior (process
);
3526 kill_inferior (process
);
3528 discard_queued_stop_replies (ptid_t (pid
));
3532 /* Value that will be passed to exit(3) when gdbserver exits. */
3533 static int exit_code
;
3535 /* Wrapper for detach_or_kill_for_exit that catches and prints
3539 detach_or_kill_for_exit_cleanup ()
3543 detach_or_kill_for_exit ();
3545 catch (const gdb_exception
&exception
)
3548 fprintf (stderr
, "Detach or kill failed: %s\n",
3554 /* Main function. This is called by the real "main" function,
3555 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3557 static void ATTRIBUTE_NORETURN
3558 captured_main (int argc
, char *argv
[])
3563 const char *port
= NULL
;
3564 char **next_arg
= &argv
[1];
3565 volatile int multi_mode
= 0;
3566 volatile int attach
= 0;
3568 bool selftest
= false;
3570 const char *selftest_filter
= NULL
;
3573 current_directory
= getcwd (NULL
, 0);
3574 client_state
&cs
= get_client_state ();
3576 if (current_directory
== NULL
)
3578 error (_("Could not find current working directory: %s"),
3579 safe_strerror (errno
));
3582 while (*next_arg
!= NULL
&& **next_arg
== '-')
3584 if (strcmp (*next_arg
, "--version") == 0)
3586 gdbserver_version ();
3589 else if (strcmp (*next_arg
, "--help") == 0)
3591 gdbserver_usage (stdout
);
3594 else if (strcmp (*next_arg
, "--attach") == 0)
3596 else if (strcmp (*next_arg
, "--multi") == 0)
3598 else if (strcmp (*next_arg
, "--wrapper") == 0)
3605 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3607 wrapper_argv
+= *next_arg
;
3608 wrapper_argv
+= ' ';
3612 if (!wrapper_argv
.empty ())
3614 /* Erase the last whitespace. */
3615 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3618 if (next_arg
== tmp
|| *next_arg
== NULL
)
3620 gdbserver_usage (stderr
);
3624 /* Consume the "--". */
3627 else if (strcmp (*next_arg
, "--debug") == 0)
3629 else if (startswith (*next_arg
, "--debug-format="))
3631 std::string error_msg
3632 = parse_debug_format_options ((*next_arg
)
3633 + sizeof ("--debug-format=") - 1, 0);
3635 if (!error_msg
.empty ())
3637 fprintf (stderr
, "%s", error_msg
.c_str ());
3641 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3643 else if (startswith (*next_arg
, "--debug-file="))
3644 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3645 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3647 gdbserver_show_disableable (stdout
);
3650 else if (startswith (*next_arg
, "--disable-packet="))
3652 char *packets
, *tok
;
3654 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3655 for (tok
= strtok (packets
, ",");
3657 tok
= strtok (NULL
, ","))
3659 if (strcmp ("vCont", tok
) == 0)
3660 disable_packet_vCont
= 1;
3661 else if (strcmp ("Tthread", tok
) == 0)
3662 disable_packet_Tthread
= 1;
3663 else if (strcmp ("qC", tok
) == 0)
3664 disable_packet_qC
= 1;
3665 else if (strcmp ("qfThreadInfo", tok
) == 0)
3666 disable_packet_qfThreadInfo
= 1;
3667 else if (strcmp ("threads", tok
) == 0)
3669 disable_packet_vCont
= 1;
3670 disable_packet_Tthread
= 1;
3671 disable_packet_qC
= 1;
3672 disable_packet_qfThreadInfo
= 1;
3676 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3678 gdbserver_show_disableable (stderr
);
3683 else if (strcmp (*next_arg
, "-") == 0)
3685 /* "-" specifies a stdio connection and is a form of port
3687 port
= STDIO_CONNECTION_NAME
;
3691 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3692 cs
.disable_randomization
= 1;
3693 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3694 cs
.disable_randomization
= 0;
3695 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3696 startup_with_shell
= true;
3697 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3698 startup_with_shell
= false;
3699 else if (strcmp (*next_arg
, "--once") == 0)
3701 else if (strcmp (*next_arg
, "--selftest") == 0)
3703 else if (startswith (*next_arg
, "--selftest="))
3707 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3712 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3725 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3728 gdbserver_usage (stderr
);
3732 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3733 opened by remote_prepare. */
3736 save_original_signals_state (false);
3738 /* We need to know whether the remote connection is stdio before
3739 starting the inferior. Inferiors created in this scenario have
3740 stdin,stdout redirected. So do this here before we call
3743 remote_prepare (port
);
3748 /* --attach used to come after PORT, so allow it there for
3750 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3757 && (*next_arg
== NULL
3758 || (*next_arg
)[0] == '\0'
3759 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3761 || next_arg
[1] != NULL
))
3766 gdbserver_usage (stderr
);
3770 /* Gather information about the environment. */
3771 our_environ
= gdb_environ::from_host_environ ();
3773 initialize_async_io ();
3775 have_job_control ();
3776 initialize_event_loop ();
3777 if (target_supports_tracepoints ())
3778 initialize_tracepoint ();
3780 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3785 selftests::run_tests (selftest_filter
);
3787 printf (_("Selftests have been disabled for this build.\n"));
3789 throw_quit ("Quit");
3792 if (pid
== 0 && *next_arg
!= NULL
)
3796 n
= argc
- (next_arg
- argv
);
3797 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3798 for (i
= 1; i
< n
; i
++)
3799 program_args
.push_back (xstrdup (next_arg
[i
]));
3800 program_args
.push_back (NULL
);
3802 /* Wait till we are at first instruction in program. */
3803 create_inferior (program_path
.get (), program_args
);
3805 /* We are now (hopefully) stopped at the first instruction of
3806 the target process. This assumes that the target process was
3807 successfully created. */
3811 if (attach_inferior (pid
) == -1)
3812 error ("Attaching not supported on this target");
3814 /* Otherwise succeeded. */
3818 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3819 cs
.last_status
.value
.integer
= 0;
3820 cs
.last_ptid
= minus_one_ptid
;
3823 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3825 /* Don't report shared library events on the initial connection,
3826 even if some libraries are preloaded. Avoids the "stopped by
3827 shared library event" notice on gdb side. */
3830 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3831 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3836 if (!was_running
&& !multi_mode
)
3837 error ("No program to debug");
3842 cs
.multi_process
= 0;
3843 cs
.report_fork_events
= 0;
3844 cs
.report_vfork_events
= 0;
3845 cs
.report_exec_events
= 0;
3846 /* Be sure we're out of tfind mode. */
3847 cs
.current_traceframe
= -1;
3848 cs
.cont_thread
= null_ptid
;
3849 cs
.swbreak_feature
= 0;
3850 cs
.hwbreak_feature
= 0;
3851 cs
.vCont_supported
= 0;
3857 /* Wait for events. This will return when all event sources
3858 are removed from the event loop. */
3859 start_event_loop ();
3861 /* If an exit was requested (using the "monitor exit"
3862 command), terminate now. */
3864 throw_quit ("Quit");
3866 /* The only other way to get here is for getpkt to fail:
3868 - If --once was specified, we're done.
3870 - If not in extended-remote mode, and we're no longer
3871 debugging anything, simply exit: GDB has disconnected
3872 after processing the last process exit.
3874 - Otherwise, close the connection and reopen it at the
3876 if (run_once
|| (!extended_protocol
&& !target_running ()))
3877 throw_quit ("Quit");
3880 "Remote side has terminated connection. "
3881 "GDBserver will reopen the connection.\n");
3883 /* Get rid of any pending statuses. An eventual reconnection
3884 (by the same GDB instance or another) will refresh all its
3885 state from scratch. */
3886 discard_queued_stop_replies (minus_one_ptid
);
3887 for_each_thread ([] (thread_info
*thread
)
3889 thread
->status_pending_p
= 0;
3894 if (disconnected_tracing
)
3896 /* Try to enable non-stop/async mode, so we we can
3897 both wait for an async socket accept, and handle
3898 async target events simultaneously. There's also
3899 no point either in having the target always stop
3900 all threads, when we're going to pass signals
3901 down without informing GDB. */
3904 if (start_non_stop (1))
3907 /* Detaching implicitly resumes all threads;
3908 simply disconnecting does not. */
3914 "Disconnected tracing disabled; "
3915 "stopping trace run.\n");
3920 catch (const gdb_exception_error
&exception
)
3923 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3925 if (response_needed
)
3927 write_enn (cs
.own_buf
);
3928 putpkt (cs
.own_buf
);
3932 throw_quit ("Quit");
3937 /* Main function. */
3940 main (int argc
, char *argv
[])
3945 captured_main (argc
, argv
);
3947 catch (const gdb_exception
&exception
)
3949 if (exception
.reason
== RETURN_ERROR
)
3952 fprintf (stderr
, "%s\n", exception
.what ());
3953 fprintf (stderr
, "Exiting\n");
3960 gdb_assert_not_reached ("captured_main should never return");
3963 /* Process options coming from Z packets for a breakpoint. PACKET is
3964 the packet buffer. *PACKET is updated to point to the first char
3965 after the last processed option. */
3968 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3970 const char *dataptr
= *packet
;
3973 /* Check if data has the correct format. */
3974 if (*dataptr
!= ';')
3981 if (*dataptr
== ';')
3984 if (*dataptr
== 'X')
3986 /* Conditional expression. */
3988 debug_printf ("Found breakpoint condition.\n");
3989 if (!add_breakpoint_condition (bp
, &dataptr
))
3990 dataptr
= strchrnul (dataptr
, ';');
3992 else if (startswith (dataptr
, "cmds:"))
3994 dataptr
+= strlen ("cmds:");
3996 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3997 persist
= (*dataptr
== '1');
3999 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4000 dataptr
= strchrnul (dataptr
, ';');
4004 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4006 /* Skip tokens until we find one that we recognize. */
4007 dataptr
= strchrnul (dataptr
, ';');
4013 /* Event loop callback that handles a serial event. The first byte in
4014 the serial buffer gets us here. We expect characters to arrive at
4015 a brisk pace, so we read the rest of the packet with a blocking
4019 process_serial_event (void)
4021 client_state
&cs
= get_client_state ();
4027 int new_packet_len
= -1;
4029 disable_async_io ();
4031 response_needed
= 0;
4032 packet_len
= getpkt (cs
.own_buf
);
4033 if (packet_len
<= 0)
4036 /* Force an event loop break. */
4039 response_needed
= 1;
4041 char ch
= cs
.own_buf
[0];
4045 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4048 handle_general_set (cs
.own_buf
);
4051 handle_detach (cs
.own_buf
);
4054 extended_protocol
= 1;
4055 write_ok (cs
.own_buf
);
4058 handle_status (cs
.own_buf
);
4061 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4063 require_running_or_break (cs
.own_buf
);
4065 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4067 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4068 thread_id
= null_ptid
;
4069 else if (thread_id
.is_pid ())
4071 /* The ptid represents a pid. */
4072 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4076 write_enn (cs
.own_buf
);
4080 thread_id
= thread
->id
;
4084 /* The ptid represents a lwp/tid. */
4085 if (find_thread_ptid (thread_id
) == NULL
)
4087 write_enn (cs
.own_buf
);
4092 if (cs
.own_buf
[1] == 'g')
4094 if (thread_id
== null_ptid
)
4096 /* GDB is telling us to choose any thread. Check if
4097 the currently selected thread is still valid. If
4098 it is not, select the first available. */
4099 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4101 thread
= get_first_thread ();
4102 thread_id
= thread
->id
;
4105 cs
.general_thread
= thread_id
;
4106 set_desired_thread ();
4107 gdb_assert (current_thread
!= NULL
);
4109 else if (cs
.own_buf
[1] == 'c')
4110 cs
.cont_thread
= thread_id
;
4112 write_ok (cs
.own_buf
);
4116 /* Silently ignore it so that gdb can extend the protocol
4117 without compatibility headaches. */
4118 cs
.own_buf
[0] = '\0';
4122 require_running_or_break (cs
.own_buf
);
4123 if (cs
.current_traceframe
>= 0)
4125 struct regcache
*regcache
4126 = new_register_cache (current_target_desc ());
4128 if (fetch_traceframe_registers (cs
.current_traceframe
,
4130 registers_to_string (regcache
, cs
.own_buf
);
4132 write_enn (cs
.own_buf
);
4133 free_register_cache (regcache
);
4137 struct regcache
*regcache
;
4139 if (!set_desired_thread ())
4140 write_enn (cs
.own_buf
);
4143 regcache
= get_thread_regcache (current_thread
, 1);
4144 registers_to_string (regcache
, cs
.own_buf
);
4149 require_running_or_break (cs
.own_buf
);
4150 if (cs
.current_traceframe
>= 0)
4151 write_enn (cs
.own_buf
);
4154 struct regcache
*regcache
;
4156 if (!set_desired_thread ())
4157 write_enn (cs
.own_buf
);
4160 regcache
= get_thread_regcache (current_thread
, 1);
4161 registers_from_string (regcache
, &cs
.own_buf
[1]);
4162 write_ok (cs
.own_buf
);
4168 require_running_or_break (cs
.own_buf
);
4169 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4170 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4172 write_enn (cs
.own_buf
);
4174 bin2hex (mem_buf
, cs
.own_buf
, res
);
4178 require_running_or_break (cs
.own_buf
);
4179 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4180 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4181 write_ok (cs
.own_buf
);
4183 write_enn (cs
.own_buf
);
4186 require_running_or_break (cs
.own_buf
);
4187 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4188 &mem_addr
, &len
, &mem_buf
) < 0
4189 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4190 write_enn (cs
.own_buf
);
4192 write_ok (cs
.own_buf
);
4195 require_running_or_break (cs
.own_buf
);
4196 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4197 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4198 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4201 myresume (cs
.own_buf
, 0, signal
);
4204 require_running_or_break (cs
.own_buf
);
4205 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4206 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4207 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4210 myresume (cs
.own_buf
, 1, signal
);
4213 require_running_or_break (cs
.own_buf
);
4215 myresume (cs
.own_buf
, 0, signal
);
4218 require_running_or_break (cs
.own_buf
);
4220 myresume (cs
.own_buf
, 1, signal
);
4222 case 'Z': /* insert_ ... */
4224 case 'z': /* remove_ ... */
4229 char type
= cs
.own_buf
[1];
4231 const int insert
= ch
== 'Z';
4232 const char *p
= &cs
.own_buf
[3];
4234 p
= unpack_varlen_hex (p
, &addr
);
4235 kind
= strtol (p
+ 1, &dataptr
, 16);
4239 struct gdb_breakpoint
*bp
;
4241 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4246 /* GDB may have sent us a list of *point parameters to
4247 be evaluated on the target's side. Read such list
4248 here. If we already have a list of parameters, GDB
4249 is telling us to drop that list and use this one
4251 clear_breakpoint_conditions_and_commands (bp
);
4252 const char *options
= dataptr
;
4253 process_point_options (bp
, &options
);
4257 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4260 write_ok (cs
.own_buf
);
4263 cs
.own_buf
[0] = '\0';
4265 write_enn (cs
.own_buf
);
4269 response_needed
= 0;
4270 if (!target_running ())
4271 /* The packet we received doesn't make sense - but we can't
4272 reply to it, either. */
4275 fprintf (stderr
, "Killing all inferiors\n");
4277 for_each_process (kill_inferior_callback
);
4279 /* When using the extended protocol, we wait with no program
4280 running. The traditional protocol will exit instead. */
4281 if (extended_protocol
)
4283 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4284 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4292 require_running_or_break (cs
.own_buf
);
4294 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4295 if (find_thread_ptid (thread_id
) == NULL
)
4297 write_enn (cs
.own_buf
);
4301 if (mythread_alive (thread_id
))
4302 write_ok (cs
.own_buf
);
4304 write_enn (cs
.own_buf
);
4308 response_needed
= 0;
4310 /* Restarting the inferior is only supported in the extended
4312 if (extended_protocol
)
4314 if (target_running ())
4315 for_each_process (kill_inferior_callback
);
4317 fprintf (stderr
, "GDBserver restarting\n");
4319 /* Wait till we are at 1st instruction in prog. */
4320 if (program_path
.get () != NULL
)
4322 create_inferior (program_path
.get (), program_args
);
4324 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4326 /* Stopped at the first instruction of the target
4328 cs
.general_thread
= cs
.last_ptid
;
4332 /* Something went wrong. */
4333 cs
.general_thread
= null_ptid
;
4338 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4339 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4345 /* It is a request we don't understand. Respond with an
4346 empty packet so that gdb knows that we don't support this
4348 cs
.own_buf
[0] = '\0';
4352 /* Extended (long) request. */
4353 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4357 /* It is a request we don't understand. Respond with an empty
4358 packet so that gdb knows that we don't support this
4360 cs
.own_buf
[0] = '\0';
4364 if (new_packet_len
!= -1)
4365 putpkt_binary (cs
.own_buf
, new_packet_len
);
4367 putpkt (cs
.own_buf
);
4369 response_needed
= 0;
4377 /* Event-loop callback for serial events. */
4380 handle_serial_event (int err
, gdb_client_data client_data
)
4383 debug_printf ("handling possible serial event\n");
4385 /* Really handle it. */
4386 if (process_serial_event () < 0)
4389 /* Be sure to not change the selected thread behind GDB's back.
4390 Important in the non-stop mode asynchronous protocol. */
4391 set_desired_thread ();
4396 /* Push a stop notification on the notification queue. */
4399 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4401 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4403 vstop_notif
->status
= *status
;
4404 vstop_notif
->ptid
= ptid
;
4405 /* Push Stop notification. */
4406 notif_push (¬if_stop
, vstop_notif
);
4409 /* Event-loop callback for target events. */
4412 handle_target_event (int err
, gdb_client_data client_data
)
4414 client_state
&cs
= get_client_state ();
4416 debug_printf ("handling possible target event\n");
4418 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4421 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4423 if (gdb_connected () && report_no_resumed
)
4424 push_stop_notification (null_ptid
, &cs
.last_status
);
4426 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4428 int pid
= cs
.last_ptid
.pid ();
4429 struct process_info
*process
= find_process_pid (pid
);
4430 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4432 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4433 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4435 mark_breakpoints_out (process
);
4436 target_mourn_inferior (cs
.last_ptid
);
4438 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4442 /* We're reporting this thread as stopped. Update its
4443 "want-stopped" state to what the client wants, until it
4444 gets a new resume action. */
4445 current_thread
->last_resume_kind
= resume_stop
;
4446 current_thread
->last_status
= cs
.last_status
;
4451 if (!target_running ())
4453 /* The last process exited. We're done. */
4457 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4458 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4459 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4463 /* A thread stopped with a signal, but gdb isn't
4464 connected to handle it. Pass it down to the
4465 inferior, as if it wasn't being traced. */
4466 enum gdb_signal signal
;
4469 debug_printf ("GDB not connected; forwarding event %d for"
4471 (int) cs
.last_status
.kind
,
4472 target_pid_to_str (cs
.last_ptid
));
4474 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4475 signal
= cs
.last_status
.value
.sig
;
4477 signal
= GDB_SIGNAL_0
;
4478 target_continue (cs
.last_ptid
, signal
);
4482 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4485 /* Be sure to not change the selected thread behind GDB's back.
4486 Important in the non-stop mode asynchronous protocol. */
4487 set_desired_thread ();
4500 } // namespace selftests
4501 #endif /* GDB_SELF_TEST */