1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2018 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"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
42 #include "filenames.h"
43 #include "pathstuff.h"
45 #include "common/selftest.h"
47 #define require_running_or_return(BUF) \
48 if (!target_running ()) \
54 #define require_running_or_break(BUF) \
55 if (!target_running ()) \
61 /* String containing the current directory (what getwd would return). */
63 char *current_directory
;
65 /* The environment to pass to the inferior when creating it. */
67 static gdb_environ our_environ
;
69 /* Start the inferior using a shell. */
71 /* We always try to start the inferior using a shell. */
73 int startup_with_shell
= 1;
77 static int extended_protocol
;
78 static int response_needed
;
79 static int exit_requested
;
81 /* --once: Exit after the first connection has closed. */
84 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
85 static int report_no_resumed
;
90 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
92 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
94 m_path
= std::move (path
);
96 /* Make sure we're using the absolute path of the inferior when
98 if (!contains_dir_separator (m_path
.get ()))
102 /* Check if the file is in our CWD. If it is, then we prefix
103 its name with CURRENT_DIRECTORY. Otherwise, we leave the
104 name as-is because we'll try searching for it in $PATH. */
105 if (is_regular_file (m_path
.get (), ®_file_errno
))
106 m_path
= gdb_abspath (m_path
.get ());
110 /* Return the PROGRAM_PATH. */
112 { return m_path
.get (); }
115 /* The program name, adjusted if needed. */
116 gdb::unique_xmalloc_ptr
<char> m_path
;
118 static std::vector
<char *> program_args
;
119 static std::string wrapper_argv
;
121 /* The PID of the originally created or attached inferior. Used to
122 send signals to the process when GDB sends us an asynchronous interrupt
123 (user hitting Control-C in the client), and to wait for the child to exit
124 when no longer debugging it. */
126 unsigned long signal_pid
;
128 /* Set if you want to disable optional thread related packets support
129 in gdbserver, for the sake of testing GDB against stubs that don't
131 int disable_packet_vCont
;
132 int disable_packet_Tthread
;
133 int disable_packet_qC
;
134 int disable_packet_qfThreadInfo
;
136 static unsigned char *mem_buf
;
138 /* A sub-class of 'struct notif_event' for stop, holding information
139 relative to a single stop reply. We keep a queue of these to
140 push to GDB in non-stop mode. */
144 struct notif_event base
;
146 /* Thread or process that got the event. */
150 struct target_waitstatus status
;
153 /* The current btrace configuration. This is gdbserver's mirror of GDB's
154 btrace configuration. */
155 static struct btrace_config current_btrace_conf
;
157 DEFINE_QUEUE_P (notif_event_p
);
159 /* The client remote protocol state. */
161 static client_state g_client_state
;
166 client_state
&cs
= g_client_state
;
171 /* Put a stop reply to the stop reply queue. */
174 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
176 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
178 new_notif
->ptid
= ptid
;
179 new_notif
->status
= *status
;
181 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
185 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
186 QUEUE_ITER (notif_event_p
) *iter
,
187 struct notif_event
*event
,
190 ptid_t filter_ptid
= *(ptid_t
*) data
;
191 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
193 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
195 if (q
->free_func
!= NULL
)
196 q
->free_func (event
);
198 QUEUE_remove_elem (notif_event_p
, q
, iter
);
207 discard_queued_stop_replies (ptid_t ptid
)
209 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
210 remove_all_on_match_ptid
, &ptid
);
214 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
216 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
218 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
221 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
224 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
225 QUEUE_ITER (notif_event_p
) *iter
,
226 struct notif_event
*event
,
229 ptid_t filter_ptid
= *(ptid_t
*) data
;
230 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
232 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
235 /* Don't resume fork children that GDB does not know about yet. */
236 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
237 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
238 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
247 in_queued_stop_replies (ptid_t ptid
)
249 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
250 in_queued_stop_replies_ptid
, &ptid
);
253 struct notif_server notif_stop
=
255 "vStopped", "Stop", NULL
, vstop_notif_reply
,
259 target_running (void)
261 return get_first_thread () != NULL
;
264 /* See common/common-inferior.h. */
269 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
272 /* See common/common-inferior.h. */
275 get_exec_file (int err
)
277 if (err
&& program_path
.get () == NULL
)
278 error (_("No executable file specified."));
280 return program_path
.get ();
292 attach_inferior (int pid
)
294 client_state
&cs
= get_client_state ();
295 /* myattach should return -1 if attaching is unsupported,
296 0 if it succeeded, and call error() otherwise. */
298 if (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 extern int remote_debug
;
329 /* Decode a qXfer read request. Return 0 if everything looks OK,
333 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
335 /* After the read marker and annex, qXfer looks like a
336 traditional 'm' packet. */
337 decode_m_packet (buf
, ofs
, len
);
343 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
345 /* Extract and NUL-terminate the object. */
347 while (*buf
&& *buf
!= ':')
353 /* Extract and NUL-terminate the read/write action. */
355 while (*buf
&& *buf
!= ':')
361 /* Extract and NUL-terminate the annex. */
363 while (*buf
&& *buf
!= ':')
373 /* Write the response to a successful qXfer read. Returns the
374 length of the (binary) data stored in BUF, corresponding
375 to as much of DATA/LEN as we could fit. IS_MORE controls
376 the first character of the response. */
378 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
387 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
388 &out_len
, PBUFSIZ
- 2) + 1;
391 /* Handle btrace enabling in BTS format. */
394 handle_btrace_enable_bts (struct thread_info
*thread
)
396 if (thread
->btrace
!= NULL
)
397 error (_("Btrace already enabled."));
399 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
400 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
403 /* Handle btrace enabling in Intel Processor Trace format. */
406 handle_btrace_enable_pt (struct thread_info
*thread
)
408 if (thread
->btrace
!= NULL
)
409 error (_("Btrace already enabled."));
411 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
412 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 error (_("Branch tracing not enabled."));
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 error (_("Could not disable branch tracing."));
427 thread
->btrace
= NULL
;
430 /* Handle the "Qbtrace" packet. */
433 handle_btrace_general_set (char *own_buf
)
435 client_state
&cs
= get_client_state ();
436 struct thread_info
*thread
;
439 if (!startswith (own_buf
, "Qbtrace:"))
442 op
= own_buf
+ strlen ("Qbtrace:");
444 if (ptid_equal (cs
.general_thread
, null_ptid
)
445 || ptid_equal (cs
.general_thread
, minus_one_ptid
))
447 strcpy (own_buf
, "E.Must select a single thread.");
451 thread
= find_thread_ptid (cs
.general_thread
);
454 strcpy (own_buf
, "E.No such thread.");
460 if (strcmp (op
, "bts") == 0)
461 handle_btrace_enable_bts (thread
);
462 else if (strcmp (op
, "pt") == 0)
463 handle_btrace_enable_pt (thread
);
464 else if (strcmp (op
, "off") == 0)
465 handle_btrace_disable (thread
);
467 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
471 CATCH (exception
, RETURN_MASK_ERROR
)
473 sprintf (own_buf
, "E.%s", exception
.message
);
480 /* Handle the "Qbtrace-conf" packet. */
483 handle_btrace_conf_general_set (char *own_buf
)
485 client_state
&cs
= get_client_state ();
486 struct thread_info
*thread
;
489 if (!startswith (own_buf
, "Qbtrace-conf:"))
492 op
= own_buf
+ strlen ("Qbtrace-conf:");
494 if (ptid_equal (cs
.general_thread
, null_ptid
)
495 || ptid_equal (cs
.general_thread
, minus_one_ptid
))
497 strcpy (own_buf
, "E.Must select a single thread.");
501 thread
= find_thread_ptid (cs
.general_thread
);
504 strcpy (own_buf
, "E.No such thread.");
508 if (startswith (op
, "bts:size="))
514 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
515 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
517 strcpy (own_buf
, "E.Bad size value.");
521 current_btrace_conf
.bts
.size
= (unsigned int) size
;
523 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
529 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
530 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
532 strcpy (own_buf
, "E.Bad size value.");
536 current_btrace_conf
.pt
.size
= (unsigned int) size
;
540 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
548 /* Handle all of the extended 'Q' packets. */
551 handle_general_set (char *own_buf
)
553 client_state
&cs
= get_client_state ();
554 if (startswith (own_buf
, "QPassSignals:"))
556 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
557 const char *p
= own_buf
+ strlen ("QPassSignals:");
560 p
= decode_address_to_semicolon (&cursig
, p
);
561 for (i
= 0; i
< numsigs
; i
++)
565 cs
.pass_signals
[i
] = 1;
567 /* Keep looping, to clear the remaining signals. */
570 p
= decode_address_to_semicolon (&cursig
, p
);
573 cs
.pass_signals
[i
] = 0;
575 strcpy (own_buf
, "OK");
579 if (startswith (own_buf
, "QProgramSignals:"))
581 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
582 const char *p
= own_buf
+ strlen ("QProgramSignals:");
585 cs
.program_signals_p
= 1;
587 p
= decode_address_to_semicolon (&cursig
, p
);
588 for (i
= 0; i
< numsigs
; i
++)
592 cs
.program_signals
[i
] = 1;
594 /* Keep looping, to clear the remaining signals. */
597 p
= decode_address_to_semicolon (&cursig
, p
);
600 cs
.program_signals
[i
] = 0;
602 strcpy (own_buf
, "OK");
606 if (startswith (own_buf
, "QCatchSyscalls:"))
608 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
611 struct process_info
*process
;
613 if (!target_running () || !target_supports_catch_syscall ())
619 if (strcmp (p
, "0") == 0)
621 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
625 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
631 process
= current_process ();
632 process
->syscalls_to_catch
.clear ();
642 p
= decode_address_to_semicolon (&sysno
, p
);
643 process
->syscalls_to_catch
.push_back (sysno
);
647 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
654 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
656 our_environ
= gdb_environ::from_host_environ ();
662 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
664 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
665 /* The final form of the environment variable. FINAL_VAR will
666 hold the 'VAR=VALUE' format. */
667 std::string final_var
= hex2str (p
);
668 std::string var_name
, var_value
;
672 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
673 debug_printf (_("[Environment variable to be set: '%s']\n"),
678 size_t pos
= final_var
.find ('=');
679 if (pos
== std::string::npos
)
681 warning (_("Unexpected format for environment variable: '%s'"),
687 var_name
= final_var
.substr (0, pos
);
688 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
690 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
696 if (startswith (own_buf
, "QEnvironmentUnset:"))
698 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
699 std::string varname
= hex2str (p
);
703 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
704 debug_printf (_("[Environment variable to be unset: '%s']\n"),
709 our_environ
.unset (varname
.c_str ());
715 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
719 debug_printf ("[noack mode enabled]\n");
728 if (startswith (own_buf
, "QNonStop:"))
730 char *mode
= own_buf
+ 9;
734 if (strcmp (mode
, "0") == 0)
736 else if (strcmp (mode
, "1") == 0)
740 /* We don't know what this mode is, so complain to
742 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
748 req_str
= req
? "non-stop" : "all-stop";
749 if (start_non_stop (req
) != 0)
751 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
759 debug_printf ("[%s mode enabled]\n", req_str
);
765 if (startswith (own_buf
, "QDisableRandomization:"))
767 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
770 unpack_varlen_hex (packet
, &setting
);
771 cs
.disable_randomization
= setting
;
775 debug_printf (cs
.disable_randomization
776 ? "[address space randomization disabled]\n"
777 : "[address space randomization enabled]\n");
784 if (target_supports_tracepoints ()
785 && handle_tracepoint_general_set (own_buf
))
788 if (startswith (own_buf
, "QAgent:"))
790 char *mode
= own_buf
+ strlen ("QAgent:");
793 if (strcmp (mode
, "0") == 0)
795 else if (strcmp (mode
, "1") == 0)
799 /* We don't know what this value is, so complain to GDB. */
800 sprintf (own_buf
, "E.Unknown QAgent value");
804 /* Update the flag. */
807 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
812 if (handle_btrace_general_set (own_buf
))
815 if (handle_btrace_conf_general_set (own_buf
))
818 if (startswith (own_buf
, "QThreadEvents:"))
820 char *mode
= own_buf
+ strlen ("QThreadEvents:");
821 enum tribool req
= TRIBOOL_UNKNOWN
;
823 if (strcmp (mode
, "0") == 0)
825 else if (strcmp (mode
, "1") == 0)
829 /* We don't know what this mode is, so complain to GDB. */
830 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
835 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
839 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
841 debug_printf ("[thread events are now %s]\n", req_str
);
848 if (startswith (own_buf
, "QStartupWithShell:"))
850 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
852 if (strcmp (value
, "1") == 0)
853 startup_with_shell
= true;
854 else if (strcmp (value
, "0") == 0)
855 startup_with_shell
= false;
859 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
866 debug_printf (_("[Inferior will %s started with shell]"),
867 startup_with_shell
? "be" : "not be");
873 if (startswith (own_buf
, "QSetWorkingDir:"))
875 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
879 std::string path
= hex2str (p
);
881 set_inferior_cwd (path
.c_str ());
884 debug_printf (_("[Set the inferior's current directory to %s]\n"),
889 /* An empty argument means that we should clear out any
890 previously set cwd for the inferior. */
891 set_inferior_cwd (NULL
);
895 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
902 /* Otherwise we didn't know what packet it was. Say we didn't
908 get_features_xml (const char *annex
)
910 const struct target_desc
*desc
= current_target_desc ();
912 /* `desc->xmltarget' defines what to return when looking for the
913 "target.xml" file. Its contents can either be verbatim XML code
914 (prefixed with a '@') or else the name of the actual XML file to
915 be used in place of "target.xml".
917 This variable is set up from the auto-generated
918 init_registers_... routine for the current target. */
920 if (strcmp (annex
, "target.xml") == 0)
922 const char *ret
= tdesc_get_features_xml (desc
);
932 extern const char *const xml_builtin
[][2];
935 /* Look for the annex. */
936 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
937 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
940 if (xml_builtin
[i
][0] != NULL
)
941 return xml_builtin
[i
][1];
949 monitor_show_help (void)
951 monitor_output ("The following monitor commands are supported:\n");
952 monitor_output (" set debug <0|1>\n");
953 monitor_output (" Enable general debugging messages\n");
954 monitor_output (" set debug-hw-points <0|1>\n");
955 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
956 monitor_output (" set remote-debug <0|1>\n");
957 monitor_output (" Enable remote protocol debugging messages\n");
958 monitor_output (" set debug-format option1[,option2,...]\n");
959 monitor_output (" Add additional information to debugging messages\n");
960 monitor_output (" Options: all, none");
961 monitor_output (", timestamp");
962 monitor_output ("\n");
963 monitor_output (" exit\n");
964 monitor_output (" Quit GDBserver\n");
967 /* Read trace frame or inferior memory. Returns the number of bytes
968 actually read, zero when no further transfer is possible, and -1 on
969 error. Return of a positive value smaller than LEN does not
970 indicate there's no more to be read, only the end of the transfer.
971 E.g., when GDB reads memory from a traceframe, a first request may
972 be served from a memory block that does not cover the whole request
973 length. A following request gets the rest served from either
974 another block (of the same traceframe) or from the read-only
978 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
980 client_state
&cs
= get_client_state ();
983 if (cs
.current_traceframe
>= 0)
986 ULONGEST length
= len
;
988 if (traceframe_read_mem (cs
.current_traceframe
,
989 memaddr
, myaddr
, len
, &nbytes
))
991 /* Data read from trace buffer, we're done. */
994 if (!in_readonly_region (memaddr
, length
))
996 /* Otherwise we have a valid readonly case, fall through. */
997 /* (assume no half-trace half-real blocks for now) */
1000 res
= prepare_to_access_memory ();
1003 if (set_desired_thread ())
1004 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1007 done_accessing_memory ();
1009 return res
== 0 ? len
: -1;
1015 /* Write trace frame or inferior memory. Actually, writing to trace
1016 frames is forbidden. */
1019 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1021 client_state
&cs
= get_client_state ();
1022 if (cs
.current_traceframe
>= 0)
1028 ret
= prepare_to_access_memory ();
1031 if (set_desired_thread ())
1032 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1035 done_accessing_memory ();
1041 /* Subroutine of handle_search_memory to simplify it. */
1044 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1045 gdb_byte
*pattern
, unsigned pattern_len
,
1046 gdb_byte
*search_buf
,
1047 unsigned chunk_size
, unsigned search_buf_size
,
1048 CORE_ADDR
*found_addrp
)
1050 /* Prime the search buffer. */
1052 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1055 warning ("Unable to access %ld bytes of target "
1056 "memory at 0x%lx, halting search.",
1057 (long) search_buf_size
, (long) start_addr
);
1061 /* Perform the search.
1063 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1064 When we've scanned N bytes we copy the trailing bytes to the start and
1065 read in another N bytes. */
1067 while (search_space_len
>= pattern_len
)
1069 gdb_byte
*found_ptr
;
1070 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1074 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1077 if (found_ptr
!= NULL
)
1079 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1080 *found_addrp
= found_addr
;
1084 /* Not found in this chunk, skip to next chunk. */
1086 /* Don't let search_space_len wrap here, it's unsigned. */
1087 if (search_space_len
>= chunk_size
)
1088 search_space_len
-= chunk_size
;
1090 search_space_len
= 0;
1092 if (search_space_len
>= pattern_len
)
1094 unsigned keep_len
= search_buf_size
- chunk_size
;
1095 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1098 /* Copy the trailing part of the previous iteration to the front
1099 of the buffer for the next iteration. */
1100 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1102 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1103 ? search_space_len
- keep_len
1106 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1107 nr_to_read
) != search_buf_size
)
1109 warning ("Unable to access %ld bytes of target memory "
1110 "at 0x%lx, halting search.",
1111 (long) nr_to_read
, (long) read_addr
);
1115 start_addr
+= chunk_size
;
1124 /* Handle qSearch:memory packets. */
1127 handle_search_memory (char *own_buf
, int packet_len
)
1129 CORE_ADDR start_addr
;
1130 CORE_ADDR search_space_len
;
1132 unsigned int pattern_len
;
1133 /* NOTE: also defined in find.c testcase. */
1134 #define SEARCH_CHUNK_SIZE 16000
1135 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1136 /* Buffer to hold memory contents for searching. */
1137 gdb_byte
*search_buf
;
1138 unsigned search_buf_size
;
1140 CORE_ADDR found_addr
;
1141 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1143 pattern
= (gdb_byte
*) malloc (packet_len
);
1144 if (pattern
== NULL
)
1146 error ("Unable to allocate memory to perform the search");
1147 strcpy (own_buf
, "E00");
1150 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1151 packet_len
- cmd_name_len
,
1152 &start_addr
, &search_space_len
,
1153 pattern
, &pattern_len
) < 0)
1156 error ("Error in parsing qSearch:memory packet");
1157 strcpy (own_buf
, "E00");
1161 search_buf_size
= chunk_size
+ pattern_len
- 1;
1163 /* No point in trying to allocate a buffer larger than the search space. */
1164 if (search_space_len
< search_buf_size
)
1165 search_buf_size
= search_space_len
;
1167 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1168 if (search_buf
== NULL
)
1171 error ("Unable to allocate memory to perform the search");
1172 strcpy (own_buf
, "E00");
1176 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1177 pattern
, pattern_len
,
1178 search_buf
, chunk_size
, search_buf_size
,
1182 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1183 else if (found
== 0)
1184 strcpy (own_buf
, "0");
1186 strcpy (own_buf
, "E00");
1192 /* Handle the "D" packet. */
1195 handle_detach (char *own_buf
)
1197 client_state
&cs
= get_client_state ();
1198 require_running_or_return (own_buf
);
1202 if (cs
.multi_process
)
1205 pid
= strtol (&own_buf
[2], NULL
, 16);
1208 pid
= current_ptid
.pid ();
1210 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1212 struct process_info
*process
= find_process_pid (pid
);
1214 if (process
== NULL
)
1216 write_enn (own_buf
);
1220 if (tracing
&& disconnected_tracing
)
1222 "Disconnected tracing in effect, "
1223 "leaving gdbserver attached to the process\n");
1225 if (any_persistent_commands ())
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", pid
);
1255 if (detach_inferior (pid
) != 0)
1256 write_enn (own_buf
);
1259 discard_queued_stop_replies (ptid_t (pid
));
1262 if (extended_protocol
|| target_running ())
1264 /* There is still at least one inferior remaining or
1265 we are in extended mode, so don't terminate gdbserver,
1266 and instead treat this like a normal program exit. */
1267 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1268 cs
.last_status
.value
.integer
= 0;
1269 cs
.last_ptid
= ptid_t (pid
);
1271 current_thread
= NULL
;
1278 /* If we are attached, then we can exit. Otherwise, we
1279 need to hang around doing nothing, until the child is
1281 join_inferior (pid
);
1287 /* Parse options to --debug-format= and "monitor set debug-format".
1288 ARG is the text after "--debug-format=" or "monitor set debug-format".
1289 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1290 This triggers calls to monitor_output.
1291 The result is an empty string if all options were parsed ok, otherwise an
1292 error message which the caller must free.
1294 N.B. These commands affect all debug format settings, they are not
1295 cumulative. If a format is not specified, it is turned off.
1296 However, we don't go to extra trouble with things like
1297 "monitor set debug-format all,none,timestamp".
1298 Instead we just parse them one at a time, in order.
1300 The syntax for "monitor set debug" we support here is not identical
1301 to gdb's "set debug foo on|off" because we also use this function to
1302 parse "--debug-format=foo,bar". */
1305 parse_debug_format_options (const char *arg
, int is_monitor
)
1307 /* First turn all debug format options off. */
1308 debug_timestamp
= 0;
1310 /* First remove leading spaces, for "monitor set debug-format". */
1311 while (isspace (*arg
))
1314 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1315 = delim_string_to_char_ptr_vec (arg
, ',');
1317 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1319 if (strcmp (option
.get (), "all") == 0)
1321 debug_timestamp
= 1;
1323 monitor_output ("All extra debug format options enabled.\n");
1325 else if (strcmp (option
.get (), "none") == 0)
1327 debug_timestamp
= 0;
1329 monitor_output ("All extra debug format options disabled.\n");
1331 else if (strcmp (option
.get (), "timestamp") == 0)
1333 debug_timestamp
= 1;
1335 monitor_output ("Timestamps will be added to debug output.\n");
1337 else if (*option
== '\0')
1339 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1343 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1347 return std::string ();
1350 /* Handle monitor commands not handled by target-specific handlers. */
1353 handle_monitor_command (char *mon
, char *own_buf
)
1355 if (strcmp (mon
, "set debug 1") == 0)
1358 monitor_output ("Debug output enabled.\n");
1360 else if (strcmp (mon
, "set debug 0") == 0)
1363 monitor_output ("Debug output disabled.\n");
1365 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1367 show_debug_regs
= 1;
1368 monitor_output ("H/W point debugging output enabled.\n");
1370 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1372 show_debug_regs
= 0;
1373 monitor_output ("H/W point debugging output disabled.\n");
1375 else if (strcmp (mon
, "set remote-debug 1") == 0)
1378 monitor_output ("Protocol debug output enabled.\n");
1380 else if (strcmp (mon
, "set remote-debug 0") == 0)
1383 monitor_output ("Protocol debug output disabled.\n");
1385 else if (startswith (mon
, "set debug-format "))
1387 std::string error_msg
1388 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1391 if (!error_msg
.empty ())
1393 monitor_output (error_msg
.c_str ());
1394 monitor_show_help ();
1395 write_enn (own_buf
);
1398 else if (strcmp (mon
, "help") == 0)
1399 monitor_show_help ();
1400 else if (strcmp (mon
, "exit") == 0)
1404 monitor_output ("Unknown monitor command.\n\n");
1405 monitor_show_help ();
1406 write_enn (own_buf
);
1410 /* Associates a callback with each supported qXfer'able object. */
1414 /* The object this handler handles. */
1417 /* Request that the target transfer up to LEN 8-bit bytes of the
1418 target's OBJECT. The OFFSET, for a seekable object, specifies
1419 the starting point. The ANNEX can be used to provide additional
1420 data-specific information to the target.
1422 Return the number of bytes actually transfered, zero when no
1423 further transfer is possible, -1 on error, -2 when the transfer
1424 is not supported, and -3 on a verbose error message that should
1425 be preserved. Return of a positive value smaller than LEN does
1426 not indicate the end of the object, only the end of the transfer.
1428 One, and only one, of readbuf or writebuf must be non-NULL. */
1429 int (*xfer
) (const char *annex
,
1430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1431 ULONGEST offset
, LONGEST len
);
1434 /* Handle qXfer:auxv:read. */
1437 handle_qxfer_auxv (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
)
1441 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1444 if (annex
[0] != '\0' || current_thread
== NULL
)
1447 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1450 /* Handle qXfer:exec-file:read. */
1453 handle_qxfer_exec_file (const char *annex
,
1454 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1455 ULONGEST offset
, LONGEST len
)
1461 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1464 if (annex
[0] == '\0')
1466 if (current_thread
== NULL
)
1469 pid
= pid_of (current_thread
);
1473 annex
= unpack_varlen_hex (annex
, &pid
);
1474 if (annex
[0] != '\0')
1481 file
= (*the_target
->pid_to_exec_file
) (pid
);
1485 total_len
= strlen (file
);
1487 if (offset
> total_len
)
1490 if (offset
+ len
> total_len
)
1491 len
= total_len
- offset
;
1493 memcpy (readbuf
, file
+ offset
, len
);
1497 /* Handle qXfer:features:read. */
1500 handle_qxfer_features (const char *annex
,
1501 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1502 ULONGEST offset
, LONGEST len
)
1504 const char *document
;
1507 if (writebuf
!= NULL
)
1510 if (!target_running ())
1513 /* Grab the correct annex. */
1514 document
= get_features_xml (annex
);
1515 if (document
== NULL
)
1518 total_len
= strlen (document
);
1520 if (offset
> total_len
)
1523 if (offset
+ len
> total_len
)
1524 len
= total_len
- offset
;
1526 memcpy (readbuf
, document
+ offset
, len
);
1530 /* Handle qXfer:libraries:read. */
1533 handle_qxfer_libraries (const char *annex
,
1534 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1535 ULONGEST offset
, LONGEST len
)
1537 if (writebuf
!= NULL
)
1540 if (annex
[0] != '\0' || current_thread
== NULL
)
1543 std::string document
= "<library-list version=\"1.0\">\n";
1545 for (const dll_info
&dll
: all_dlls
)
1546 document
+= string_printf
1547 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1548 dll
.name
.c_str (), (long) dll
.base_addr
);
1550 document
+= "</library-list>\n";
1552 if (offset
> document
.length ())
1555 if (offset
+ len
> document
.length ())
1556 len
= document
.length () - offset
;
1558 memcpy (readbuf
, &document
[offset
], len
);
1563 /* Handle qXfer:libraries-svr4:read. */
1566 handle_qxfer_libraries_svr4 (const char *annex
,
1567 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1568 ULONGEST offset
, LONGEST len
)
1570 if (writebuf
!= NULL
)
1573 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1576 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1579 /* Handle qXfer:osadata:read. */
1582 handle_qxfer_osdata (const char *annex
,
1583 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1584 ULONGEST offset
, LONGEST len
)
1586 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1589 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1592 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1595 handle_qxfer_siginfo (const char *annex
,
1596 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1597 ULONGEST offset
, LONGEST len
)
1599 if (the_target
->qxfer_siginfo
== NULL
)
1602 if (annex
[0] != '\0' || current_thread
== NULL
)
1605 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1608 /* Handle qXfer:spu:read and qXfer:spu:write. */
1611 handle_qxfer_spu (const char *annex
,
1612 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1613 ULONGEST offset
, LONGEST len
)
1615 if (the_target
->qxfer_spu
== NULL
)
1618 if (current_thread
== NULL
)
1621 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1624 /* Handle qXfer:statictrace:read. */
1627 handle_qxfer_statictrace (const char *annex
,
1628 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1629 ULONGEST offset
, LONGEST len
)
1631 client_state
&cs
= get_client_state ();
1634 if (writebuf
!= NULL
)
1637 if (annex
[0] != '\0' || current_thread
== NULL
1638 || cs
.current_traceframe
== -1)
1641 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1642 readbuf
, len
, &nbytes
))
1647 /* Helper for handle_qxfer_threads_proper.
1648 Emit the XML to describe the thread of INF. */
1651 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1653 ptid_t ptid
= ptid_of (thread
);
1655 int core
= target_core_of_thread (ptid
);
1657 const char *name
= target_thread_name (ptid
);
1660 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1662 write_ptid (ptid_s
, ptid
);
1664 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1668 sprintf (core_s
, "%d", core
);
1669 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1673 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1677 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1678 bin2hex (handle
, handle_s
, handle_len
);
1679 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1682 buffer_xml_printf (buffer
, "/>\n");
1685 /* Helper for handle_qxfer_threads. */
1688 handle_qxfer_threads_proper (struct buffer
*buffer
)
1690 buffer_grow_str (buffer
, "<threads>\n");
1692 for_each_thread ([&] (thread_info
*thread
)
1694 handle_qxfer_threads_worker (thread
, buffer
);
1697 buffer_grow_str0 (buffer
, "</threads>\n");
1700 /* Handle qXfer:threads:read. */
1703 handle_qxfer_threads (const char *annex
,
1704 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1705 ULONGEST offset
, LONGEST len
)
1707 static char *result
= 0;
1708 static unsigned int result_length
= 0;
1710 if (writebuf
!= NULL
)
1713 if (annex
[0] != '\0')
1718 struct buffer buffer
;
1719 /* When asked for data at offset 0, generate everything and store into
1720 'result'. Successive reads will be served off 'result'. */
1724 buffer_init (&buffer
);
1726 handle_qxfer_threads_proper (&buffer
);
1728 result
= buffer_finish (&buffer
);
1729 result_length
= strlen (result
);
1730 buffer_free (&buffer
);
1733 if (offset
>= result_length
)
1735 /* We're out of data. */
1742 if (len
> result_length
- offset
)
1743 len
= result_length
- offset
;
1745 memcpy (readbuf
, result
+ offset
, len
);
1750 /* Handle qXfer:traceframe-info:read. */
1753 handle_qxfer_traceframe_info (const char *annex
,
1754 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1755 ULONGEST offset
, LONGEST len
)
1757 client_state
&cs
= get_client_state ();
1758 static char *result
= 0;
1759 static unsigned int result_length
= 0;
1761 if (writebuf
!= NULL
)
1764 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1769 struct buffer buffer
;
1771 /* When asked for data at offset 0, generate everything and
1772 store into 'result'. Successive reads will be served off
1776 buffer_init (&buffer
);
1778 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1780 result
= buffer_finish (&buffer
);
1781 result_length
= strlen (result
);
1782 buffer_free (&buffer
);
1785 if (offset
>= result_length
)
1787 /* We're out of data. */
1794 if (len
> result_length
- offset
)
1795 len
= result_length
- offset
;
1797 memcpy (readbuf
, result
+ offset
, len
);
1801 /* Handle qXfer:fdpic:read. */
1804 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1805 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1807 if (the_target
->read_loadmap
== NULL
)
1810 if (current_thread
== NULL
)
1813 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1816 /* Handle qXfer:btrace:read. */
1819 handle_qxfer_btrace (const char *annex
,
1820 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1821 ULONGEST offset
, LONGEST len
)
1823 client_state
&cs
= get_client_state ();
1824 static struct buffer cache
;
1825 struct thread_info
*thread
;
1826 enum btrace_read_type type
;
1829 if (writebuf
!= NULL
)
1832 if (ptid_equal (cs
.general_thread
, null_ptid
)
1833 || ptid_equal (cs
.general_thread
, minus_one_ptid
))
1835 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1839 thread
= find_thread_ptid (cs
.general_thread
);
1842 strcpy (cs
.own_buf
, "E.No such thread.");
1846 if (thread
->btrace
== NULL
)
1848 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1852 if (strcmp (annex
, "all") == 0)
1853 type
= BTRACE_READ_ALL
;
1854 else if (strcmp (annex
, "new") == 0)
1855 type
= BTRACE_READ_NEW
;
1856 else if (strcmp (annex
, "delta") == 0)
1857 type
= BTRACE_READ_DELTA
;
1860 strcpy (cs
.own_buf
, "E.Bad annex.");
1866 buffer_free (&cache
);
1870 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1872 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1874 CATCH (exception
, RETURN_MASK_ERROR
)
1876 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1884 else if (offset
> cache
.used_size
)
1886 buffer_free (&cache
);
1890 if (len
> cache
.used_size
- offset
)
1891 len
= cache
.used_size
- offset
;
1893 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1898 /* Handle qXfer:btrace-conf:read. */
1901 handle_qxfer_btrace_conf (const char *annex
,
1902 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1903 ULONGEST offset
, LONGEST len
)
1905 client_state
&cs
= get_client_state ();
1906 static struct buffer cache
;
1907 struct thread_info
*thread
;
1910 if (writebuf
!= NULL
)
1913 if (annex
[0] != '\0')
1916 if (ptid_equal (cs
.general_thread
, null_ptid
)
1917 || ptid_equal (cs
.general_thread
, minus_one_ptid
))
1919 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1923 thread
= find_thread_ptid (cs
.general_thread
);
1926 strcpy (cs
.own_buf
, "E.No such thread.");
1930 if (thread
->btrace
== NULL
)
1932 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1938 buffer_free (&cache
);
1942 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1944 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1946 CATCH (exception
, RETURN_MASK_ERROR
)
1948 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1956 else if (offset
> cache
.used_size
)
1958 buffer_free (&cache
);
1962 if (len
> cache
.used_size
- offset
)
1963 len
= cache
.used_size
- offset
;
1965 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1970 static const struct qxfer qxfer_packets
[] =
1972 { "auxv", handle_qxfer_auxv
},
1973 { "btrace", handle_qxfer_btrace
},
1974 { "btrace-conf", handle_qxfer_btrace_conf
},
1975 { "exec-file", handle_qxfer_exec_file
},
1976 { "fdpic", handle_qxfer_fdpic
},
1977 { "features", handle_qxfer_features
},
1978 { "libraries", handle_qxfer_libraries
},
1979 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1980 { "osdata", handle_qxfer_osdata
},
1981 { "siginfo", handle_qxfer_siginfo
},
1982 { "spu", handle_qxfer_spu
},
1983 { "statictrace", handle_qxfer_statictrace
},
1984 { "threads", handle_qxfer_threads
},
1985 { "traceframe-info", handle_qxfer_traceframe_info
},
1989 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1997 if (!startswith (own_buf
, "qXfer:"))
2000 /* Grab the object, r/w and annex. */
2001 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2003 write_enn (own_buf
);
2008 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2011 const struct qxfer
*q
= &qxfer_packets
[i
];
2013 if (strcmp (object
, q
->object
) == 0)
2015 if (strcmp (rw
, "read") == 0)
2017 unsigned char *data
;
2022 /* Grab the offset and length. */
2023 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2025 write_enn (own_buf
);
2029 /* Read one extra byte, as an indicator of whether there is
2031 if (len
> PBUFSIZ
- 2)
2033 data
= (unsigned char *) malloc (len
+ 1);
2036 write_enn (own_buf
);
2039 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2047 /* Preserve error message. */
2050 write_enn (own_buf
);
2052 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2054 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2059 else if (strcmp (rw
, "write") == 0)
2064 unsigned char *data
;
2066 strcpy (own_buf
, "E00");
2067 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2070 write_enn (own_buf
);
2073 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2074 &ofs
, &len
, data
) < 0)
2077 write_enn (own_buf
);
2081 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2089 /* Preserve error message. */
2092 write_enn (own_buf
);
2094 sprintf (own_buf
, "%x", n
);
2107 /* Compute 32 bit CRC from inferior memory.
2109 On success, return 32 bit CRC.
2110 On failure, return (unsigned long long) -1. */
2112 static unsigned long long
2113 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2117 unsigned char byte
= 0;
2119 /* Return failure if memory read fails. */
2120 if (read_inferior_memory (base
, &byte
, 1) != 0)
2121 return (unsigned long long) -1;
2123 crc
= xcrc32 (&byte
, 1, crc
);
2126 return (unsigned long long) crc
;
2129 /* Add supported btrace packets to BUF. */
2132 supported_btrace_packets (char *buf
)
2134 strcat (buf
, ";Qbtrace:bts+");
2135 strcat (buf
, ";Qbtrace-conf:bts:size+");
2136 strcat (buf
, ";Qbtrace:pt+");
2137 strcat (buf
, ";Qbtrace-conf:pt:size+");
2138 strcat (buf
, ";Qbtrace:off+");
2139 strcat (buf
, ";qXfer:btrace:read+");
2140 strcat (buf
, ";qXfer:btrace-conf:read+");
2143 /* Handle all of the extended 'q' packets. */
2146 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2148 client_state
&cs
= get_client_state ();
2149 static std::list
<thread_info
*>::const_iterator thread_iter
;
2151 /* Reply the current thread id. */
2152 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2155 require_running_or_return (own_buf
);
2157 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2158 ptid
= cs
.general_thread
;
2161 thread_iter
= all_threads
.begin ();
2162 ptid
= (*thread_iter
)->id
;
2165 sprintf (own_buf
, "QC");
2167 write_ptid (own_buf
, ptid
);
2171 if (strcmp ("qSymbol::", own_buf
) == 0)
2173 struct thread_info
*save_thread
= current_thread
;
2175 /* For qSymbol, GDB only changes the current thread if the
2176 previous current thread was of a different process. So if
2177 the previous thread is gone, we need to pick another one of
2178 the same process. This can happen e.g., if we followed an
2179 exec in a non-leader thread. */
2180 if (current_thread
== NULL
)
2183 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2185 /* Just in case, if we didn't find a thread, then bail out
2186 instead of crashing. */
2187 if (current_thread
== NULL
)
2189 write_enn (own_buf
);
2190 current_thread
= save_thread
;
2195 /* GDB is suggesting new symbols have been loaded. This may
2196 mean a new shared library has been detected as loaded, so
2197 take the opportunity to check if breakpoints we think are
2198 inserted, still are. Note that it isn't guaranteed that
2199 we'll see this when a shared library is loaded, and nor will
2200 we see this for unloads (although breakpoints in unloaded
2201 libraries shouldn't trigger), as GDB may not find symbols for
2202 the library at all. We also re-validate breakpoints when we
2203 see a second GDB breakpoint for the same address, and or when
2204 we access breakpoint shadows. */
2205 validate_breakpoints ();
2207 if (target_supports_tracepoints ())
2208 tracepoint_look_up_symbols ();
2210 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2211 (*the_target
->look_up_symbols
) ();
2213 current_thread
= save_thread
;
2215 strcpy (own_buf
, "OK");
2219 if (!disable_packet_qfThreadInfo
)
2221 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2223 require_running_or_return (own_buf
);
2224 thread_iter
= all_threads
.begin ();
2227 ptid_t ptid
= (*thread_iter
)->id
;
2228 write_ptid (own_buf
, ptid
);
2233 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2235 require_running_or_return (own_buf
);
2236 if (thread_iter
!= all_threads
.end ())
2239 ptid_t ptid
= (*thread_iter
)->id
;
2240 write_ptid (own_buf
, ptid
);
2246 sprintf (own_buf
, "l");
2252 if (the_target
->read_offsets
!= NULL
2253 && strcmp ("qOffsets", own_buf
) == 0)
2255 CORE_ADDR text
, data
;
2257 require_running_or_return (own_buf
);
2258 if (the_target
->read_offsets (&text
, &data
))
2259 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2260 (long)text
, (long)data
, (long)data
);
2262 write_enn (own_buf
);
2267 /* Protocol features query. */
2268 if (startswith (own_buf
, "qSupported")
2269 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2271 char *p
= &own_buf
[10];
2272 int gdb_supports_qRelocInsn
= 0;
2274 /* Process each feature being provided by GDB. The first
2275 feature will follow a ':', and latter features will follow
2279 char **qsupported
= NULL
;
2284 /* Two passes, to avoid nested strtok calls in
2285 target_process_qsupported. */
2286 for (p
= strtok (p
+ 1, ";");
2288 p
= strtok (NULL
, ";"))
2291 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2292 qsupported
[count
- 1] = xstrdup (p
);
2295 for (i
= 0; i
< count
; i
++)
2298 if (strcmp (p
, "multiprocess+") == 0)
2300 /* GDB supports and wants multi-process support if
2302 if (target_supports_multi_process ())
2303 cs
.multi_process
= 1;
2305 else if (strcmp (p
, "qRelocInsn+") == 0)
2307 /* GDB supports relocate instruction requests. */
2308 gdb_supports_qRelocInsn
= 1;
2310 else if (strcmp (p
, "swbreak+") == 0)
2312 /* GDB wants us to report whether a trap is caused
2313 by a software breakpoint and for us to handle PC
2314 adjustment if necessary on this target. */
2315 if (target_supports_stopped_by_sw_breakpoint ())
2316 cs
.swbreak_feature
= 1;
2318 else if (strcmp (p
, "hwbreak+") == 0)
2320 /* GDB wants us to report whether a trap is caused
2321 by a hardware breakpoint. */
2322 if (target_supports_stopped_by_hw_breakpoint ())
2323 cs
.hwbreak_feature
= 1;
2325 else if (strcmp (p
, "fork-events+") == 0)
2327 /* GDB supports and wants fork events if possible. */
2328 if (target_supports_fork_events ())
2329 cs
.report_fork_events
= 1;
2331 else if (strcmp (p
, "vfork-events+") == 0)
2333 /* GDB supports and wants vfork events if possible. */
2334 if (target_supports_vfork_events ())
2335 cs
.report_vfork_events
= 1;
2337 else if (strcmp (p
, "exec-events+") == 0)
2339 /* GDB supports and wants exec events if possible. */
2340 if (target_supports_exec_events ())
2341 cs
.report_exec_events
= 1;
2343 else if (strcmp (p
, "vContSupported+") == 0)
2344 cs
.vCont_supported
= 1;
2345 else if (strcmp (p
, "QThreadEvents+") == 0)
2347 else if (strcmp (p
, "no-resumed+") == 0)
2349 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2351 report_no_resumed
= 1;
2355 /* Move the unknown features all together. */
2356 qsupported
[i
] = NULL
;
2357 qsupported
[unknown
] = p
;
2362 /* Give the target backend a chance to process the unknown
2364 target_process_qsupported (qsupported
, unknown
);
2366 for (i
= 0; i
< count
; i
++)
2367 free (qsupported
[i
]);
2372 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2373 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2374 "QEnvironmentReset+;QEnvironmentUnset+;"
2378 if (target_supports_catch_syscall ())
2379 strcat (own_buf
, ";QCatchSyscalls+");
2381 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2382 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2383 ";augmented-libraries-svr4-read+");
2386 /* We do not have any hook to indicate whether the non-SVR4 target
2387 backend supports qXfer:libraries:read, so always report it. */
2388 strcat (own_buf
, ";qXfer:libraries:read+");
2391 if (the_target
->read_auxv
!= NULL
)
2392 strcat (own_buf
, ";qXfer:auxv:read+");
2394 if (the_target
->qxfer_spu
!= NULL
)
2395 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2397 if (the_target
->qxfer_siginfo
!= NULL
)
2398 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2400 if (the_target
->read_loadmap
!= NULL
)
2401 strcat (own_buf
, ";qXfer:fdpic:read+");
2403 /* We always report qXfer:features:read, as targets may
2404 install XML files on a subsequent call to arch_setup.
2405 If we reported to GDB on startup that we don't support
2406 qXfer:feature:read at all, we will never be re-queried. */
2407 strcat (own_buf
, ";qXfer:features:read+");
2409 if (cs
.transport_is_reliable
)
2410 strcat (own_buf
, ";QStartNoAckMode+");
2412 if (the_target
->qxfer_osdata
!= NULL
)
2413 strcat (own_buf
, ";qXfer:osdata:read+");
2415 if (target_supports_multi_process ())
2416 strcat (own_buf
, ";multiprocess+");
2418 if (target_supports_fork_events ())
2419 strcat (own_buf
, ";fork-events+");
2421 if (target_supports_vfork_events ())
2422 strcat (own_buf
, ";vfork-events+");
2424 if (target_supports_exec_events ())
2425 strcat (own_buf
, ";exec-events+");
2427 if (target_supports_non_stop ())
2428 strcat (own_buf
, ";QNonStop+");
2430 if (target_supports_disable_randomization ())
2431 strcat (own_buf
, ";QDisableRandomization+");
2433 strcat (own_buf
, ";qXfer:threads:read+");
2435 if (target_supports_tracepoints ())
2437 strcat (own_buf
, ";ConditionalTracepoints+");
2438 strcat (own_buf
, ";TraceStateVariables+");
2439 strcat (own_buf
, ";TracepointSource+");
2440 strcat (own_buf
, ";DisconnectedTracing+");
2441 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2442 strcat (own_buf
, ";FastTracepoints+");
2443 strcat (own_buf
, ";StaticTracepoints+");
2444 strcat (own_buf
, ";InstallInTrace+");
2445 strcat (own_buf
, ";qXfer:statictrace:read+");
2446 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2447 strcat (own_buf
, ";EnableDisableTracepoints+");
2448 strcat (own_buf
, ";QTBuffer:size+");
2449 strcat (own_buf
, ";tracenz+");
2452 if (target_supports_hardware_single_step ()
2453 || target_supports_software_single_step () )
2455 strcat (own_buf
, ";ConditionalBreakpoints+");
2457 strcat (own_buf
, ";BreakpointCommands+");
2459 if (target_supports_agent ())
2460 strcat (own_buf
, ";QAgent+");
2462 supported_btrace_packets (own_buf
);
2464 if (target_supports_stopped_by_sw_breakpoint ())
2465 strcat (own_buf
, ";swbreak+");
2467 if (target_supports_stopped_by_hw_breakpoint ())
2468 strcat (own_buf
, ";hwbreak+");
2470 if (the_target
->pid_to_exec_file
!= NULL
)
2471 strcat (own_buf
, ";qXfer:exec-file:read+");
2473 strcat (own_buf
, ";vContSupported+");
2475 strcat (own_buf
, ";QThreadEvents+");
2477 strcat (own_buf
, ";no-resumed+");
2479 /* Reinitialize components as needed for the new connection. */
2480 hostio_handle_new_gdb_connection ();
2481 target_handle_new_gdb_connection ();
2486 /* Thread-local storage support. */
2487 if (the_target
->get_tls_address
!= NULL
2488 && startswith (own_buf
, "qGetTLSAddr:"))
2490 char *p
= own_buf
+ 12;
2491 CORE_ADDR parts
[2], address
= 0;
2493 ptid_t ptid
= null_ptid
;
2495 require_running_or_return (own_buf
);
2497 for (i
= 0; i
< 3; i
++)
2505 p2
= strchr (p
, ',');
2518 ptid
= read_ptid (p
, NULL
);
2520 decode_address (&parts
[i
- 1], p
, len
);
2524 if (p
!= NULL
|| i
< 3)
2528 struct thread_info
*thread
= find_thread_ptid (ptid
);
2533 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2539 strcpy (own_buf
, paddress(address
));
2544 write_enn (own_buf
);
2548 /* Otherwise, pretend we do not understand this packet. */
2551 /* Windows OS Thread Information Block address support. */
2552 if (the_target
->get_tib_address
!= NULL
2553 && startswith (own_buf
, "qGetTIBAddr:"))
2558 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2560 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2563 strcpy (own_buf
, paddress(tlb
));
2568 write_enn (own_buf
);
2574 /* Handle "monitor" commands. */
2575 if (startswith (own_buf
, "qRcmd,"))
2577 char *mon
= (char *) malloc (PBUFSIZ
);
2578 int len
= strlen (own_buf
+ 6);
2582 write_enn (own_buf
);
2587 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2589 write_enn (own_buf
);
2593 mon
[len
/ 2] = '\0';
2597 if (the_target
->handle_monitor_command
== NULL
2598 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2599 /* Default processing. */
2600 handle_monitor_command (mon
, own_buf
);
2606 if (startswith (own_buf
, "qSearch:memory:"))
2608 require_running_or_return (own_buf
);
2609 handle_search_memory (own_buf
, packet_len
);
2613 if (strcmp (own_buf
, "qAttached") == 0
2614 || startswith (own_buf
, "qAttached:"))
2616 struct process_info
*process
;
2618 if (own_buf
[sizeof ("qAttached") - 1])
2620 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2621 process
= find_process_pid (pid
);
2625 require_running_or_return (own_buf
);
2626 process
= current_process ();
2629 if (process
== NULL
)
2631 write_enn (own_buf
);
2635 strcpy (own_buf
, process
->attached
? "1" : "0");
2639 if (startswith (own_buf
, "qCRC:"))
2641 /* CRC check (compare-section). */
2645 unsigned long long crc
;
2647 require_running_or_return (own_buf
);
2648 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2649 if (*comma
++ != ',')
2651 write_enn (own_buf
);
2654 len
= strtoul (comma
, NULL
, 16);
2655 crc
= crc32 (base
, len
, 0xffffffff);
2656 /* Check for memory failure. */
2657 if (crc
== (unsigned long long) -1)
2659 write_enn (own_buf
);
2662 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2666 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2669 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2672 /* Otherwise we didn't know what packet it was. Say we didn't
2677 static void gdb_wants_all_threads_stopped (void);
2678 static void resume (struct thread_resume
*actions
, size_t n
);
2680 /* The callback that is passed to visit_actioned_threads. */
2681 typedef int (visit_actioned_threads_callback_ftype
)
2682 (const struct thread_resume
*, struct thread_info
*);
2684 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2685 true if CALLBACK returns true. Returns false if no matching thread
2686 is found or CALLBACK results false.
2687 Note: This function is itself a callback for find_thread. */
2690 visit_actioned_threads (thread_info
*thread
,
2691 const struct thread_resume
*actions
,
2693 visit_actioned_threads_callback_ftype
*callback
)
2695 for (size_t i
= 0; i
< num_actions
; i
++)
2697 const struct thread_resume
*action
= &actions
[i
];
2699 if (ptid_equal (action
->thread
, minus_one_ptid
)
2700 || ptid_equal (action
->thread
, thread
->id
)
2701 || ((action
->thread
.pid ()
2702 == thread
->id
.pid ())
2703 && ptid_get_lwp (action
->thread
) == -1))
2705 if ((*callback
) (action
, thread
))
2713 /* Callback for visit_actioned_threads. If the thread has a pending
2714 status to report, report it now. */
2717 handle_pending_status (const struct thread_resume
*resumption
,
2718 struct thread_info
*thread
)
2720 client_state
&cs
= get_client_state ();
2721 if (thread
->status_pending_p
)
2723 thread
->status_pending_p
= 0;
2725 cs
.last_status
= thread
->last_status
;
2726 cs
.last_ptid
= thread
->id
;
2727 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2733 /* Parse vCont packets. */
2735 handle_v_cont (char *own_buf
)
2739 struct thread_resume
*resume_info
;
2740 struct thread_resume default_action
{ null_ptid
};
2742 /* Count the number of semicolons in the packet. There should be one
2743 for every action. */
2749 p
= strchr (p
, ';');
2752 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2753 if (resume_info
== NULL
)
2761 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2763 if (p
[0] == 's' || p
[0] == 'S')
2764 resume_info
[i
].kind
= resume_step
;
2765 else if (p
[0] == 'r')
2766 resume_info
[i
].kind
= resume_step
;
2767 else if (p
[0] == 'c' || p
[0] == 'C')
2768 resume_info
[i
].kind
= resume_continue
;
2769 else if (p
[0] == 't')
2770 resume_info
[i
].kind
= resume_stop
;
2774 if (p
[0] == 'S' || p
[0] == 'C')
2777 int sig
= strtol (p
+ 1, &q
, 16);
2782 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2784 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2786 else if (p
[0] == 'r')
2790 p
= unpack_varlen_hex (p
+ 1, &addr
);
2791 resume_info
[i
].step_range_start
= addr
;
2796 p
= unpack_varlen_hex (p
+ 1, &addr
);
2797 resume_info
[i
].step_range_end
= addr
;
2806 resume_info
[i
].thread
= minus_one_ptid
;
2807 default_action
= resume_info
[i
];
2809 /* Note: we don't increment i here, we'll overwrite this entry
2810 the next time through. */
2812 else if (p
[0] == ':')
2815 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2820 if (p
[0] != ';' && p
[0] != 0)
2823 resume_info
[i
].thread
= ptid
;
2830 resume_info
[i
] = default_action
;
2832 resume (resume_info
, n
);
2837 write_enn (own_buf
);
2842 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2845 resume (struct thread_resume
*actions
, size_t num_actions
)
2847 client_state
&cs
= get_client_state ();
2850 /* Check if among the threads that GDB wants actioned, there's
2851 one with a pending status to report. If so, skip actually
2852 resuming/stopping and report the pending event
2855 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2857 return visit_actioned_threads (thread
, actions
, num_actions
,
2858 handle_pending_status
);
2861 if (thread_with_status
!= NULL
)
2867 (*the_target
->resume
) (actions
, num_actions
);
2870 write_ok (cs
.own_buf
);
2873 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2875 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2876 && !report_no_resumed
)
2878 /* The client does not support this stop reply. At least
2880 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2881 disable_async_io ();
2885 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2886 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2887 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2888 current_thread
->last_status
= cs
.last_status
;
2890 /* From the client's perspective, all-stop mode always stops all
2891 threads implicitly (and the target backend has already done
2892 so by now). Tag all threads as "want-stopped", so we don't
2893 resume them implicitly without the client telling us to. */
2894 gdb_wants_all_threads_stopped ();
2895 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2896 disable_async_io ();
2898 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2899 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2900 target_mourn_inferior (cs
.last_ptid
);
2904 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2906 handle_v_attach (char *own_buf
)
2908 client_state
&cs
= get_client_state ();
2911 pid
= strtol (own_buf
+ 8, NULL
, 16);
2912 if (pid
!= 0 && attach_inferior (pid
) == 0)
2914 /* Don't report shared library events after attaching, even if
2915 some libraries are preloaded. GDB will always poll the
2916 library list. Avoids the "stopped by shared library event"
2917 notice on the GDB side. */
2922 /* In non-stop, we don't send a resume reply. Stop events
2923 will follow up using the normal notification
2928 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2934 write_enn (own_buf
);
2939 /* Run a new program. Return 1 if successful, 0 if failure. */
2941 handle_v_run (char *own_buf
)
2943 client_state
&cs
= get_client_state ();
2945 std::vector
<char *> new_argv
;
2946 char *new_program_name
= NULL
;
2950 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2956 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2958 next_p
= strchr (p
, ';');
2960 next_p
= p
+ strlen (p
);
2962 if (i
== 0 && p
== next_p
)
2964 /* No program specified. */
2965 new_program_name
= NULL
;
2967 else if (p
== next_p
)
2969 /* Empty argument. */
2970 new_argv
.push_back (xstrdup ("''"));
2974 size_t len
= (next_p
- p
) / 2;
2975 /* ARG is the unquoted argument received via the RSP. */
2976 char *arg
= (char *) xmalloc (len
+ 1);
2977 /* FULL_ARGS will contain the quoted version of ARG. */
2978 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2979 /* These are pointers used to navigate the strings above. */
2980 char *tmp_arg
= arg
;
2981 char *tmp_full_arg
= full_arg
;
2984 hex2bin (p
, (gdb_byte
*) arg
, len
);
2987 while (*tmp_arg
!= '\0')
2993 *tmp_full_arg
= '\'';
2999 /* Quote single quote. */
3000 *tmp_full_arg
= '\\';
3008 *tmp_full_arg
= *tmp_arg
;
3014 *tmp_full_arg
++ = '\'';
3016 /* Finish FULL_ARG and push it into the vector containing
3018 *tmp_full_arg
= '\0';
3020 new_program_name
= full_arg
;
3022 new_argv
.push_back (full_arg
);
3028 new_argv
.push_back (NULL
);
3030 if (new_program_name
== NULL
)
3032 /* GDB didn't specify a program to run. Use the program from the
3033 last run with the new argument list. */
3034 if (program_path
.get () == NULL
)
3036 write_enn (own_buf
);
3037 free_vector_argv (new_argv
);
3042 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3044 /* Free the old argv and install the new one. */
3045 free_vector_argv (program_args
);
3046 program_args
= new_argv
;
3048 create_inferior (program_path
.get (), program_args
);
3050 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3052 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3054 /* In non-stop, sending a resume reply doesn't set the general
3055 thread, but GDB assumes a vRun sets it (this is so GDB can
3056 query which is the main thread of the new inferior. */
3058 cs
.general_thread
= cs
.last_ptid
;
3064 write_enn (own_buf
);
3069 /* Kill process. Return 1 if successful, 0 if failure. */
3071 handle_v_kill (char *own_buf
)
3073 client_state
&cs
= get_client_state ();
3075 char *p
= &own_buf
[6];
3076 if (cs
.multi_process
)
3077 pid
= strtol (p
, NULL
, 16);
3080 if (pid
!= 0 && kill_inferior (pid
) == 0)
3082 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3083 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3084 cs
.last_ptid
= ptid_t (pid
);
3085 discard_queued_stop_replies (cs
.last_ptid
);
3091 write_enn (own_buf
);
3096 /* Handle all of the extended 'v' packets. */
3098 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3100 client_state
&cs
= get_client_state ();
3101 if (!disable_packet_vCont
)
3103 if (strcmp (own_buf
, "vCtrlC") == 0)
3105 (*the_target
->request_interrupt
) ();
3110 if (startswith (own_buf
, "vCont;"))
3112 handle_v_cont (own_buf
);
3116 if (startswith (own_buf
, "vCont?"))
3118 strcpy (own_buf
, "vCont;c;C;t");
3120 if (target_supports_hardware_single_step ()
3121 || target_supports_software_single_step ()
3122 || !cs
.vCont_supported
)
3124 /* If target supports single step either by hardware or by
3125 software, add actions s and S to the list of supported
3126 actions. On the other hand, if GDB doesn't request the
3127 supported vCont actions in qSupported packet, add s and
3128 S to the list too. */
3129 own_buf
= own_buf
+ strlen (own_buf
);
3130 strcpy (own_buf
, ";s;S");
3133 if (target_supports_range_stepping ())
3135 own_buf
= own_buf
+ strlen (own_buf
);
3136 strcpy (own_buf
, ";r");
3142 if (startswith (own_buf
, "vFile:")
3143 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3146 if (startswith (own_buf
, "vAttach;"))
3148 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3150 fprintf (stderr
, "Already debugging a process\n");
3151 write_enn (own_buf
);
3154 handle_v_attach (own_buf
);
3158 if (startswith (own_buf
, "vRun;"))
3160 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3162 fprintf (stderr
, "Already debugging a process\n");
3163 write_enn (own_buf
);
3166 handle_v_run (own_buf
);
3170 if (startswith (own_buf
, "vKill;"))
3172 if (!target_running ())
3174 fprintf (stderr
, "No process to kill\n");
3175 write_enn (own_buf
);
3178 handle_v_kill (own_buf
);
3182 if (handle_notif_ack (own_buf
, packet_len
))
3185 /* Otherwise we didn't know what packet it was. Say we didn't
3191 /* Resume thread and wait for another event. In non-stop mode,
3192 don't really wait here, but return immediatelly to the event
3195 myresume (char *own_buf
, int step
, int sig
)
3197 client_state
&cs
= get_client_state ();
3198 struct thread_resume resume_info
[2];
3200 int valid_cont_thread
;
3202 valid_cont_thread
= (!ptid_equal (cs
.cont_thread
, null_ptid
)
3203 && !ptid_equal (cs
.cont_thread
, minus_one_ptid
));
3205 if (step
|| sig
|| valid_cont_thread
)
3207 resume_info
[0].thread
= current_ptid
;
3209 resume_info
[0].kind
= resume_step
;
3211 resume_info
[0].kind
= resume_continue
;
3212 resume_info
[0].sig
= sig
;
3216 if (!valid_cont_thread
)
3218 resume_info
[n
].thread
= minus_one_ptid
;
3219 resume_info
[n
].kind
= resume_continue
;
3220 resume_info
[n
].sig
= 0;
3224 resume (resume_info
, n
);
3227 /* Callback for for_each_thread. Make a new stop reply for each
3231 queue_stop_reply_callback (thread_info
*thread
)
3233 /* For now, assume targets that don't have this callback also don't
3234 manage the thread's last_status field. */
3235 if (the_target
->thread_stopped
== NULL
)
3237 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3239 new_notif
->ptid
= thread
->id
;
3240 new_notif
->status
= thread
->last_status
;
3241 /* Pass the last stop reply back to GDB, but don't notify
3243 notif_event_enque (¬if_stop
,
3244 (struct notif_event
*) 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
*thread
)
3366 return thread
->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) 2018 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 int pid
= process
->pid
;
3483 kill_inferior (pid
);
3484 discard_queued_stop_replies (ptid_t (pid
));
3487 /* Call this when exiting gdbserver with possible inferiors that need
3488 to be killed or detached from. */
3491 detach_or_kill_for_exit (void)
3493 /* First print a list of the inferiors we will be killing/detaching.
3494 This is to assist the user, for example, in case the inferior unexpectedly
3495 dies after we exit: did we screw up or did the inferior exit on its own?
3496 Having this info will save some head-scratching. */
3498 if (have_started_inferiors_p ())
3500 fprintf (stderr
, "Killing process(es):");
3502 for_each_process ([] (process_info
*process
) {
3503 if (!process
->attached
)
3504 fprintf (stderr
, " %d", process
->pid
);
3507 fprintf (stderr
, "\n");
3509 if (have_attached_inferiors_p ())
3511 fprintf (stderr
, "Detaching process(es):");
3513 for_each_process ([] (process_info
*process
) {
3514 if (process
->attached
)
3515 fprintf (stderr
, " %d", process
->pid
);
3518 fprintf (stderr
, "\n");
3521 /* Now we can kill or detach the inferiors. */
3522 for_each_process ([] (process_info
*process
) {
3523 int pid
= process
->pid
;
3525 if (process
->attached
)
3526 detach_inferior (pid
);
3528 kill_inferior (pid
);
3530 discard_queued_stop_replies (ptid_t (pid
));
3534 /* Value that will be passed to exit(3) when gdbserver exits. */
3535 static int exit_code
;
3537 /* Cleanup version of detach_or_kill_for_exit. */
3540 detach_or_kill_for_exit_cleanup (void *ignore
)
3545 detach_or_kill_for_exit ();
3548 CATCH (exception
, RETURN_MASK_ALL
)
3551 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3557 /* Main function. This is called by the real "main" function,
3558 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3560 static void ATTRIBUTE_NORETURN
3561 captured_main (int argc
, char *argv
[])
3566 const char *port
= NULL
;
3567 char **next_arg
= &argv
[1];
3568 volatile int multi_mode
= 0;
3569 volatile int attach
= 0;
3571 bool selftest
= false;
3573 const char *selftest_filter
= NULL
;
3576 current_directory
= getcwd (NULL
, 0);
3577 client_state
&cs
= get_client_state ();
3579 if (current_directory
== NULL
)
3581 error (_("Could not find current working directory: %s"),
3582 safe_strerror (errno
));
3585 while (*next_arg
!= NULL
&& **next_arg
== '-')
3587 if (strcmp (*next_arg
, "--version") == 0)
3589 gdbserver_version ();
3592 else if (strcmp (*next_arg
, "--help") == 0)
3594 gdbserver_usage (stdout
);
3597 else if (strcmp (*next_arg
, "--attach") == 0)
3599 else if (strcmp (*next_arg
, "--multi") == 0)
3601 else if (strcmp (*next_arg
, "--wrapper") == 0)
3608 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3610 wrapper_argv
+= *next_arg
;
3611 wrapper_argv
+= ' ';
3615 if (!wrapper_argv
.empty ())
3617 /* Erase the last whitespace. */
3618 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3621 if (next_arg
== tmp
|| *next_arg
== NULL
)
3623 gdbserver_usage (stderr
);
3627 /* Consume the "--". */
3630 else if (strcmp (*next_arg
, "--debug") == 0)
3632 else if (startswith (*next_arg
, "--debug-format="))
3634 std::string error_msg
3635 = parse_debug_format_options ((*next_arg
)
3636 + sizeof ("--debug-format=") - 1, 0);
3638 if (!error_msg
.empty ())
3640 fprintf (stderr
, "%s", error_msg
.c_str ());
3644 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3646 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3648 gdbserver_show_disableable (stdout
);
3651 else if (startswith (*next_arg
, "--disable-packet="))
3653 char *packets
, *tok
;
3655 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3656 for (tok
= strtok (packets
, ",");
3658 tok
= strtok (NULL
, ","))
3660 if (strcmp ("vCont", tok
) == 0)
3661 disable_packet_vCont
= 1;
3662 else if (strcmp ("Tthread", tok
) == 0)
3663 disable_packet_Tthread
= 1;
3664 else if (strcmp ("qC", tok
) == 0)
3665 disable_packet_qC
= 1;
3666 else if (strcmp ("qfThreadInfo", tok
) == 0)
3667 disable_packet_qfThreadInfo
= 1;
3668 else if (strcmp ("threads", tok
) == 0)
3670 disable_packet_vCont
= 1;
3671 disable_packet_Tthread
= 1;
3672 disable_packet_qC
= 1;
3673 disable_packet_qfThreadInfo
= 1;
3677 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3679 gdbserver_show_disableable (stderr
);
3684 else if (strcmp (*next_arg
, "-") == 0)
3686 /* "-" specifies a stdio connection and is a form of port
3688 port
= STDIO_CONNECTION_NAME
;
3692 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3693 cs
.disable_randomization
= 1;
3694 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3695 cs
.disable_randomization
= 0;
3696 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3697 startup_with_shell
= true;
3698 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3699 startup_with_shell
= false;
3700 else if (strcmp (*next_arg
, "--once") == 0)
3702 else if (strcmp (*next_arg
, "--selftest") == 0)
3704 else if (startswith (*next_arg
, "--selftest="))
3708 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3713 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3726 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3729 gdbserver_usage (stderr
);
3733 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3734 opened by remote_prepare. */
3737 save_original_signals_state (false);
3739 /* We need to know whether the remote connection is stdio before
3740 starting the inferior. Inferiors created in this scenario have
3741 stdin,stdout redirected. So do this here before we call
3744 remote_prepare (port
);
3749 /* --attach used to come after PORT, so allow it there for
3751 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3758 && (*next_arg
== NULL
3759 || (*next_arg
)[0] == '\0'
3760 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3762 || next_arg
[1] != NULL
))
3767 gdbserver_usage (stderr
);
3771 /* Gather information about the environment. */
3772 our_environ
= gdb_environ::from_host_environ ();
3774 initialize_async_io ();
3776 have_job_control ();
3777 initialize_event_loop ();
3778 if (target_supports_tracepoints ())
3779 initialize_tracepoint ();
3780 initialize_notif ();
3782 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3787 selftests::run_tests (selftest_filter
);
3789 printf (_("Selftests are not available in a non-development build.\n"));
3791 throw_quit ("Quit");
3794 if (pid
== 0 && *next_arg
!= NULL
)
3798 n
= argc
- (next_arg
- argv
);
3799 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3800 for (i
= 1; i
< n
; i
++)
3801 program_args
.push_back (xstrdup (next_arg
[i
]));
3802 program_args
.push_back (NULL
);
3804 /* Wait till we are at first instruction in program. */
3805 create_inferior (program_path
.get (), program_args
);
3807 /* We are now (hopefully) stopped at the first instruction of
3808 the target process. This assumes that the target process was
3809 successfully created. */
3813 if (attach_inferior (pid
) == -1)
3814 error ("Attaching not supported on this target");
3816 /* Otherwise succeeded. */
3820 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3821 cs
.last_status
.value
.integer
= 0;
3822 cs
.last_ptid
= minus_one_ptid
;
3824 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3826 /* Don't report shared library events on the initial connection,
3827 even if some libraries are preloaded. Avoids the "stopped by
3828 shared library event" notice on gdb side. */
3831 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3832 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3837 if (!was_running
&& !multi_mode
)
3838 error ("No program to debug");
3843 cs
.multi_process
= 0;
3844 cs
.report_fork_events
= 0;
3845 cs
.report_vfork_events
= 0;
3846 cs
.report_exec_events
= 0;
3847 /* Be sure we're out of tfind mode. */
3848 cs
.current_traceframe
= -1;
3849 cs
.cont_thread
= null_ptid
;
3850 cs
.swbreak_feature
= 0;
3851 cs
.hwbreak_feature
= 0;
3852 cs
.vCont_supported
= 0;
3858 /* Wait for events. This will return when all event sources
3859 are removed from the event loop. */
3860 start_event_loop ();
3862 /* If an exit was requested (using the "monitor exit"
3863 command), terminate now. */
3865 throw_quit ("Quit");
3867 /* The only other way to get here is for getpkt to fail:
3869 - If --once was specified, we're done.
3871 - If not in extended-remote mode, and we're no longer
3872 debugging anything, simply exit: GDB has disconnected
3873 after processing the last process exit.
3875 - Otherwise, close the connection and reopen it at the
3877 if (run_once
|| (!extended_protocol
&& !target_running ()))
3878 throw_quit ("Quit");
3881 "Remote side has terminated connection. "
3882 "GDBserver will reopen the connection.\n");
3884 /* Get rid of any pending statuses. An eventual reconnection
3885 (by the same GDB instance or another) will refresh all its
3886 state from scratch. */
3887 discard_queued_stop_replies (minus_one_ptid
);
3888 for_each_thread ([] (thread_info
*thread
)
3890 thread
->status_pending_p
= 0;
3895 if (disconnected_tracing
)
3897 /* Try to enable non-stop/async mode, so we we can
3898 both wait for an async socket accept, and handle
3899 async target events simultaneously. There's also
3900 no point either in having the target always stop
3901 all threads, when we're going to pass signals
3902 down without informing GDB. */
3905 if (start_non_stop (1))
3908 /* Detaching implicitly resumes all threads;
3909 simply disconnecting does not. */
3915 "Disconnected tracing disabled; "
3916 "stopping trace run.\n");
3921 CATCH (exception
, RETURN_MASK_ERROR
)
3924 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3926 if (response_needed
)
3928 write_enn (cs
.own_buf
);
3929 putpkt (cs
.own_buf
);
3933 throw_quit ("Quit");
3939 /* Main function. */
3942 main (int argc
, char *argv
[])
3947 captured_main (argc
, argv
);
3949 CATCH (exception
, RETURN_MASK_ALL
)
3951 if (exception
.reason
== RETURN_ERROR
)
3954 fprintf (stderr
, "%s\n", exception
.message
);
3955 fprintf (stderr
, "Exiting\n");
3963 gdb_assert_not_reached ("captured_main should never return");
3966 /* Process options coming from Z packets for a breakpoint. PACKET is
3967 the packet buffer. *PACKET is updated to point to the first char
3968 after the last processed option. */
3971 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3973 const char *dataptr
= *packet
;
3976 /* Check if data has the correct format. */
3977 if (*dataptr
!= ';')
3984 if (*dataptr
== ';')
3987 if (*dataptr
== 'X')
3989 /* Conditional expression. */
3991 debug_printf ("Found breakpoint condition.\n");
3992 if (!add_breakpoint_condition (bp
, &dataptr
))
3993 dataptr
= strchrnul (dataptr
, ';');
3995 else if (startswith (dataptr
, "cmds:"))
3997 dataptr
+= strlen ("cmds:");
3999 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4000 persist
= (*dataptr
== '1');
4002 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4003 dataptr
= strchrnul (dataptr
, ';');
4007 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4009 /* Skip tokens until we find one that we recognize. */
4010 dataptr
= strchrnul (dataptr
, ';');
4016 /* Event loop callback that handles a serial event. The first byte in
4017 the serial buffer gets us here. We expect characters to arrive at
4018 a brisk pace, so we read the rest of the packet with a blocking
4022 process_serial_event (void)
4024 client_state
&cs
= get_client_state ();
4031 int new_packet_len
= -1;
4033 disable_async_io ();
4035 response_needed
= 0;
4036 packet_len
= getpkt (cs
.own_buf
);
4037 if (packet_len
<= 0)
4040 /* Force an event loop break. */
4043 response_needed
= 1;
4045 char ch
= cs
.own_buf
[0];
4049 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4052 handle_general_set (cs
.own_buf
);
4055 handle_detach (cs
.own_buf
);
4058 extended_protocol
= 1;
4059 write_ok (cs
.own_buf
);
4062 handle_status (cs
.own_buf
);
4065 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4067 require_running_or_break (cs
.own_buf
);
4069 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4071 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4072 thread_id
= null_ptid
;
4073 else if (thread_id
.is_pid ())
4075 /* The ptid represents a pid. */
4076 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4080 write_enn (cs
.own_buf
);
4084 thread_id
= thread
->id
;
4088 /* The ptid represents a lwp/tid. */
4089 if (find_thread_ptid (thread_id
) == NULL
)
4091 write_enn (cs
.own_buf
);
4096 if (cs
.own_buf
[1] == 'g')
4098 if (ptid_equal (thread_id
, null_ptid
))
4100 /* GDB is telling us to choose any thread. Check if
4101 the currently selected thread is still valid. If
4102 it is not, select the first available. */
4103 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4105 thread
= get_first_thread ();
4106 thread_id
= thread
->id
;
4109 cs
.general_thread
= thread_id
;
4110 set_desired_thread ();
4111 gdb_assert (current_thread
!= NULL
);
4113 else if (cs
.own_buf
[1] == 'c')
4114 cs
.cont_thread
= thread_id
;
4116 write_ok (cs
.own_buf
);
4120 /* Silently ignore it so that gdb can extend the protocol
4121 without compatibility headaches. */
4122 cs
.own_buf
[0] = '\0';
4126 require_running_or_break (cs
.own_buf
);
4127 if (cs
.current_traceframe
>= 0)
4129 struct regcache
*regcache
4130 = new_register_cache (current_target_desc ());
4132 if (fetch_traceframe_registers (cs
.current_traceframe
,
4134 registers_to_string (regcache
, cs
.own_buf
);
4136 write_enn (cs
.own_buf
);
4137 free_register_cache (regcache
);
4141 struct regcache
*regcache
;
4143 if (!set_desired_thread ())
4144 write_enn (cs
.own_buf
);
4147 regcache
= get_thread_regcache (current_thread
, 1);
4148 registers_to_string (regcache
, cs
.own_buf
);
4153 require_running_or_break (cs
.own_buf
);
4154 if (cs
.current_traceframe
>= 0)
4155 write_enn (cs
.own_buf
);
4158 struct regcache
*regcache
;
4160 if (!set_desired_thread ())
4161 write_enn (cs
.own_buf
);
4164 regcache
= get_thread_regcache (current_thread
, 1);
4165 registers_from_string (regcache
, &cs
.own_buf
[1]);
4166 write_ok (cs
.own_buf
);
4171 require_running_or_break (cs
.own_buf
);
4172 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4173 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4175 write_enn (cs
.own_buf
);
4177 bin2hex (mem_buf
, cs
.own_buf
, res
);
4180 require_running_or_break (cs
.own_buf
);
4181 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4182 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4183 write_ok (cs
.own_buf
);
4185 write_enn (cs
.own_buf
);
4188 require_running_or_break (cs
.own_buf
);
4189 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4190 &mem_addr
, &len
, &mem_buf
) < 0
4191 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4192 write_enn (cs
.own_buf
);
4194 write_ok (cs
.own_buf
);
4197 require_running_or_break (cs
.own_buf
);
4198 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4199 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4200 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4203 myresume (cs
.own_buf
, 0, signal
);
4206 require_running_or_break (cs
.own_buf
);
4207 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4208 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4209 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4212 myresume (cs
.own_buf
, 1, signal
);
4215 require_running_or_break (cs
.own_buf
);
4217 myresume (cs
.own_buf
, 0, signal
);
4220 require_running_or_break (cs
.own_buf
);
4222 myresume (cs
.own_buf
, 1, signal
);
4224 case 'Z': /* insert_ ... */
4226 case 'z': /* remove_ ... */
4231 char type
= cs
.own_buf
[1];
4233 const int insert
= ch
== 'Z';
4234 const char *p
= &cs
.own_buf
[3];
4236 p
= unpack_varlen_hex (p
, &addr
);
4237 kind
= strtol (p
+ 1, &dataptr
, 16);
4241 struct gdb_breakpoint
*bp
;
4243 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4248 /* GDB may have sent us a list of *point parameters to
4249 be evaluated on the target's side. Read such list
4250 here. If we already have a list of parameters, GDB
4251 is telling us to drop that list and use this one
4253 clear_breakpoint_conditions_and_commands (bp
);
4254 const char *options
= dataptr
;
4255 process_point_options (bp
, &options
);
4259 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4262 write_ok (cs
.own_buf
);
4265 cs
.own_buf
[0] = '\0';
4267 write_enn (cs
.own_buf
);
4271 response_needed
= 0;
4272 if (!target_running ())
4273 /* The packet we received doesn't make sense - but we can't
4274 reply to it, either. */
4277 fprintf (stderr
, "Killing all inferiors\n");
4279 for_each_process (kill_inferior_callback
);
4281 /* When using the extended protocol, we wait with no program
4282 running. The traditional protocol will exit instead. */
4283 if (extended_protocol
)
4285 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4286 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4294 require_running_or_break (cs
.own_buf
);
4296 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4297 if (find_thread_ptid (thread_id
) == NULL
)
4299 write_enn (cs
.own_buf
);
4303 if (mythread_alive (thread_id
))
4304 write_ok (cs
.own_buf
);
4306 write_enn (cs
.own_buf
);
4310 response_needed
= 0;
4312 /* Restarting the inferior is only supported in the extended
4314 if (extended_protocol
)
4316 if (target_running ())
4317 for_each_process (kill_inferior_callback
);
4319 fprintf (stderr
, "GDBserver restarting\n");
4321 /* Wait till we are at 1st instruction in prog. */
4322 if (program_path
.get () != NULL
)
4324 create_inferior (program_path
.get (), program_args
);
4326 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4328 /* Stopped at the first instruction of the target
4330 cs
.general_thread
= cs
.last_ptid
;
4334 /* Something went wrong. */
4335 cs
.general_thread
= null_ptid
;
4340 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4341 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4347 /* It is a request we don't understand. Respond with an
4348 empty packet so that gdb knows that we don't support this
4350 cs
.own_buf
[0] = '\0';
4354 /* Extended (long) request. */
4355 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4359 /* It is a request we don't understand. Respond with an empty
4360 packet so that gdb knows that we don't support this
4362 cs
.own_buf
[0] = '\0';
4366 if (new_packet_len
!= -1)
4367 putpkt_binary (cs
.own_buf
, new_packet_len
);
4369 putpkt (cs
.own_buf
);
4371 response_needed
= 0;
4379 /* Event-loop callback for serial events. */
4382 handle_serial_event (int err
, gdb_client_data client_data
)
4385 debug_printf ("handling possible serial event\n");
4387 /* Really handle it. */
4388 if (process_serial_event () < 0)
4391 /* Be sure to not change the selected thread behind GDB's back.
4392 Important in the non-stop mode asynchronous protocol. */
4393 set_desired_thread ();
4398 /* Push a stop notification on the notification queue. */
4401 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4403 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4405 vstop_notif
->status
= *status
;
4406 vstop_notif
->ptid
= ptid
;
4407 /* Push Stop notification. */
4408 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4411 /* Event-loop callback for target events. */
4414 handle_target_event (int err
, gdb_client_data client_data
)
4416 client_state
&cs
= get_client_state ();
4418 debug_printf ("handling possible target event\n");
4420 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4423 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4425 if (gdb_connected () && report_no_resumed
)
4426 push_stop_notification (null_ptid
, &cs
.last_status
);
4428 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4430 int pid
= cs
.last_ptid
.pid ();
4431 struct process_info
*process
= find_process_pid (pid
);
4432 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4434 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4435 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4437 mark_breakpoints_out (process
);
4438 target_mourn_inferior (cs
.last_ptid
);
4440 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4444 /* We're reporting this thread as stopped. Update its
4445 "want-stopped" state to what the client wants, until it
4446 gets a new resume action. */
4447 current_thread
->last_resume_kind
= resume_stop
;
4448 current_thread
->last_status
= cs
.last_status
;
4453 if (!target_running ())
4455 /* The last process exited. We're done. */
4459 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4460 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4461 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4465 /* A thread stopped with a signal, but gdb isn't
4466 connected to handle it. Pass it down to the
4467 inferior, as if it wasn't being traced. */
4468 enum gdb_signal signal
;
4471 debug_printf ("GDB not connected; forwarding event %d for"
4473 (int) cs
.last_status
.kind
,
4474 target_pid_to_str (cs
.last_ptid
));
4476 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4477 signal
= cs
.last_status
.value
.sig
;
4479 signal
= GDB_SIGNAL_0
;
4480 target_continue (cs
.last_ptid
, signal
);
4484 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4487 /* Be sure to not change the selected thread behind GDB's back.
4488 Important in the non-stop mode asynchronous protocol. */
4489 set_desired_thread ();
4502 } // namespace selftests
4503 #endif /* GDB_SELF_TEST */