1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2019 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
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 (vstop_event
->ptid
.matches (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 (vstop_event
->ptid
.matches (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 && vstop_event
->status
.value
.related_pid
.matches (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 (cs
.general_thread
== null_ptid
445 || 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 (cs
.general_thread
== null_ptid
495 || cs
.general_thread
== minus_one_ptid
)
497 strcpy (own_buf
, "E.Must select a single thread.");
501 thread
= find_thread_ptid (cs
.general_thread
);
504 strcpy (own_buf
, "E.No such thread.");
508 if (startswith (op
, "bts:size="))
514 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
515 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
517 strcpy (own_buf
, "E.Bad size value.");
521 current_btrace_conf
.bts
.size
= (unsigned int) size
;
523 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
529 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
530 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
532 strcpy (own_buf
, "E.Bad size value.");
536 current_btrace_conf
.pt
.size
= (unsigned int) size
;
540 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
548 /* Handle all of the extended 'Q' packets. */
551 handle_general_set (char *own_buf
)
553 client_state
&cs
= get_client_state ();
554 if (startswith (own_buf
, "QPassSignals:"))
556 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
557 const char *p
= own_buf
+ strlen ("QPassSignals:");
560 p
= decode_address_to_semicolon (&cursig
, p
);
561 for (i
= 0; i
< numsigs
; i
++)
565 cs
.pass_signals
[i
] = 1;
567 /* Keep looping, to clear the remaining signals. */
570 p
= decode_address_to_semicolon (&cursig
, p
);
573 cs
.pass_signals
[i
] = 0;
575 strcpy (own_buf
, "OK");
579 if (startswith (own_buf
, "QProgramSignals:"))
581 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
582 const char *p
= own_buf
+ strlen ("QProgramSignals:");
585 cs
.program_signals_p
= 1;
587 p
= decode_address_to_semicolon (&cursig
, p
);
588 for (i
= 0; i
< numsigs
; i
++)
592 cs
.program_signals
[i
] = 1;
594 /* Keep looping, to clear the remaining signals. */
597 p
= decode_address_to_semicolon (&cursig
, p
);
600 cs
.program_signals
[i
] = 0;
602 strcpy (own_buf
, "OK");
606 if (startswith (own_buf
, "QCatchSyscalls:"))
608 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
611 struct process_info
*process
;
613 if (!target_running () || !target_supports_catch_syscall ())
619 if (strcmp (p
, "0") == 0)
621 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
625 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
631 process
= current_process ();
632 process
->syscalls_to_catch
.clear ();
642 p
= decode_address_to_semicolon (&sysno
, p
);
643 process
->syscalls_to_catch
.push_back (sysno
);
647 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
654 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
656 our_environ
= gdb_environ::from_host_environ ();
662 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
664 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
665 /* The final form of the environment variable. FINAL_VAR will
666 hold the 'VAR=VALUE' format. */
667 std::string final_var
= hex2str (p
);
668 std::string var_name
, var_value
;
672 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
673 debug_printf (_("[Environment variable to be set: '%s']\n"),
678 size_t pos
= final_var
.find ('=');
679 if (pos
== std::string::npos
)
681 warning (_("Unexpected format for environment variable: '%s'"),
687 var_name
= final_var
.substr (0, pos
);
688 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
690 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
696 if (startswith (own_buf
, "QEnvironmentUnset:"))
698 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
699 std::string varname
= hex2str (p
);
703 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
704 debug_printf (_("[Environment variable to be unset: '%s']\n"),
709 our_environ
.unset (varname
.c_str ());
715 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
719 debug_printf ("[noack mode enabled]\n");
728 if (startswith (own_buf
, "QNonStop:"))
730 char *mode
= own_buf
+ 9;
734 if (strcmp (mode
, "0") == 0)
736 else if (strcmp (mode
, "1") == 0)
740 /* We don't know what this mode is, so complain to
742 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
748 req_str
= req
? "non-stop" : "all-stop";
749 if (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 ();
1199 process_info
*process
;
1201 if (cs
.multi_process
)
1204 int pid
= strtol (&own_buf
[2], NULL
, 16);
1206 process
= find_process_pid (pid
);
1210 process
= (current_thread
!= nullptr
1211 ? get_thread_process (current_thread
)
1215 if (process
== NULL
)
1217 write_enn (own_buf
);
1221 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1223 if (tracing
&& disconnected_tracing
)
1225 "Disconnected tracing in effect, "
1226 "leaving gdbserver attached to the process\n");
1228 if (any_persistent_commands (process
))
1230 "Persistent commands are present, "
1231 "leaving gdbserver attached to the process\n");
1233 /* Make sure we're in non-stop/async mode, so we we can both
1234 wait for an async socket accept, and handle async target
1235 events simultaneously. There's also no point either in
1236 having the target stop all threads, when we're going to
1237 pass signals down without informing GDB. */
1241 debug_printf ("Forcing non-stop mode\n");
1247 process
->gdb_detached
= 1;
1249 /* Detaching implicitly resumes all threads. */
1250 target_continue_no_signal (minus_one_ptid
);
1256 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1259 /* We'll need this after PROCESS has been destroyed. */
1260 int pid
= process
->pid
;
1262 if (detach_inferior (process
) != 0)
1263 write_enn (own_buf
);
1266 discard_queued_stop_replies (ptid_t (pid
));
1269 if (extended_protocol
|| target_running ())
1271 /* There is still at least one inferior remaining or
1272 we are in extended mode, so don't terminate gdbserver,
1273 and instead treat this like a normal program exit. */
1274 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1275 cs
.last_status
.value
.integer
= 0;
1276 cs
.last_ptid
= ptid_t (pid
);
1278 current_thread
= NULL
;
1285 /* If we are attached, then we can exit. Otherwise, we
1286 need to hang around doing nothing, until the child is
1288 join_inferior (pid
);
1294 /* Parse options to --debug-format= and "monitor set debug-format".
1295 ARG is the text after "--debug-format=" or "monitor set debug-format".
1296 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1297 This triggers calls to monitor_output.
1298 The result is an empty string if all options were parsed ok, otherwise an
1299 error message which the caller must free.
1301 N.B. These commands affect all debug format settings, they are not
1302 cumulative. If a format is not specified, it is turned off.
1303 However, we don't go to extra trouble with things like
1304 "monitor set debug-format all,none,timestamp".
1305 Instead we just parse them one at a time, in order.
1307 The syntax for "monitor set debug" we support here is not identical
1308 to gdb's "set debug foo on|off" because we also use this function to
1309 parse "--debug-format=foo,bar". */
1312 parse_debug_format_options (const char *arg
, int is_monitor
)
1314 /* First turn all debug format options off. */
1315 debug_timestamp
= 0;
1317 /* First remove leading spaces, for "monitor set debug-format". */
1318 while (isspace (*arg
))
1321 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1322 = delim_string_to_char_ptr_vec (arg
, ',');
1324 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1326 if (strcmp (option
.get (), "all") == 0)
1328 debug_timestamp
= 1;
1330 monitor_output ("All extra debug format options enabled.\n");
1332 else if (strcmp (option
.get (), "none") == 0)
1334 debug_timestamp
= 0;
1336 monitor_output ("All extra debug format options disabled.\n");
1338 else if (strcmp (option
.get (), "timestamp") == 0)
1340 debug_timestamp
= 1;
1342 monitor_output ("Timestamps will be added to debug output.\n");
1344 else if (*option
== '\0')
1346 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1350 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1354 return std::string ();
1357 /* Handle monitor commands not handled by target-specific handlers. */
1360 handle_monitor_command (char *mon
, char *own_buf
)
1362 if (strcmp (mon
, "set debug 1") == 0)
1365 monitor_output ("Debug output enabled.\n");
1367 else if (strcmp (mon
, "set debug 0") == 0)
1370 monitor_output ("Debug output disabled.\n");
1372 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1374 show_debug_regs
= 1;
1375 monitor_output ("H/W point debugging output enabled.\n");
1377 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1379 show_debug_regs
= 0;
1380 monitor_output ("H/W point debugging output disabled.\n");
1382 else if (strcmp (mon
, "set remote-debug 1") == 0)
1385 monitor_output ("Protocol debug output enabled.\n");
1387 else if (strcmp (mon
, "set remote-debug 0") == 0)
1390 monitor_output ("Protocol debug output disabled.\n");
1392 else if (startswith (mon
, "set debug-format "))
1394 std::string error_msg
1395 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1398 if (!error_msg
.empty ())
1400 monitor_output (error_msg
.c_str ());
1401 monitor_show_help ();
1402 write_enn (own_buf
);
1405 else if (strcmp (mon
, "help") == 0)
1406 monitor_show_help ();
1407 else if (strcmp (mon
, "exit") == 0)
1411 monitor_output ("Unknown monitor command.\n\n");
1412 monitor_show_help ();
1413 write_enn (own_buf
);
1417 /* Associates a callback with each supported qXfer'able object. */
1421 /* The object this handler handles. */
1424 /* Request that the target transfer up to LEN 8-bit bytes of the
1425 target's OBJECT. The OFFSET, for a seekable object, specifies
1426 the starting point. The ANNEX can be used to provide additional
1427 data-specific information to the target.
1429 Return the number of bytes actually transfered, zero when no
1430 further transfer is possible, -1 on error, -2 when the transfer
1431 is not supported, and -3 on a verbose error message that should
1432 be preserved. Return of a positive value smaller than LEN does
1433 not indicate the end of the object, only the end of the transfer.
1435 One, and only one, of readbuf or writebuf must be non-NULL. */
1436 int (*xfer
) (const char *annex
,
1437 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1438 ULONGEST offset
, LONGEST len
);
1441 /* Handle qXfer:auxv:read. */
1444 handle_qxfer_auxv (const char *annex
,
1445 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1446 ULONGEST offset
, LONGEST len
)
1448 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1451 if (annex
[0] != '\0' || current_thread
== NULL
)
1454 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1457 /* Handle qXfer:exec-file:read. */
1460 handle_qxfer_exec_file (const char *annex
,
1461 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1462 ULONGEST offset
, LONGEST len
)
1468 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1471 if (annex
[0] == '\0')
1473 if (current_thread
== NULL
)
1476 pid
= pid_of (current_thread
);
1480 annex
= unpack_varlen_hex (annex
, &pid
);
1481 if (annex
[0] != '\0')
1488 file
= (*the_target
->pid_to_exec_file
) (pid
);
1492 total_len
= strlen (file
);
1494 if (offset
> total_len
)
1497 if (offset
+ len
> total_len
)
1498 len
= total_len
- offset
;
1500 memcpy (readbuf
, file
+ offset
, len
);
1504 /* Handle qXfer:features:read. */
1507 handle_qxfer_features (const char *annex
,
1508 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1509 ULONGEST offset
, LONGEST len
)
1511 const char *document
;
1514 if (writebuf
!= NULL
)
1517 if (!target_running ())
1520 /* Grab the correct annex. */
1521 document
= get_features_xml (annex
);
1522 if (document
== NULL
)
1525 total_len
= strlen (document
);
1527 if (offset
> total_len
)
1530 if (offset
+ len
> total_len
)
1531 len
= total_len
- offset
;
1533 memcpy (readbuf
, document
+ offset
, len
);
1537 /* Handle qXfer:libraries:read. */
1540 handle_qxfer_libraries (const char *annex
,
1541 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1542 ULONGEST offset
, LONGEST len
)
1544 if (writebuf
!= NULL
)
1547 if (annex
[0] != '\0' || current_thread
== NULL
)
1550 std::string document
= "<library-list version=\"1.0\">\n";
1552 for (const dll_info
&dll
: all_dlls
)
1553 document
+= string_printf
1554 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1555 dll
.name
.c_str (), (long) dll
.base_addr
);
1557 document
+= "</library-list>\n";
1559 if (offset
> document
.length ())
1562 if (offset
+ len
> document
.length ())
1563 len
= document
.length () - offset
;
1565 memcpy (readbuf
, &document
[offset
], len
);
1570 /* Handle qXfer:libraries-svr4:read. */
1573 handle_qxfer_libraries_svr4 (const char *annex
,
1574 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1575 ULONGEST offset
, LONGEST len
)
1577 if (writebuf
!= NULL
)
1580 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1583 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1586 /* Handle qXfer:osadata:read. */
1589 handle_qxfer_osdata (const char *annex
,
1590 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1591 ULONGEST offset
, LONGEST len
)
1593 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1596 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1599 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1602 handle_qxfer_siginfo (const char *annex
,
1603 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1604 ULONGEST offset
, LONGEST len
)
1606 if (the_target
->qxfer_siginfo
== NULL
)
1609 if (annex
[0] != '\0' || current_thread
== NULL
)
1612 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1615 /* Handle qXfer:spu:read and qXfer:spu:write. */
1618 handle_qxfer_spu (const char *annex
,
1619 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1620 ULONGEST offset
, LONGEST len
)
1622 if (the_target
->qxfer_spu
== NULL
)
1625 if (current_thread
== NULL
)
1628 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1631 /* Handle qXfer:statictrace:read. */
1634 handle_qxfer_statictrace (const char *annex
,
1635 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1636 ULONGEST offset
, LONGEST len
)
1638 client_state
&cs
= get_client_state ();
1641 if (writebuf
!= NULL
)
1644 if (annex
[0] != '\0' || current_thread
== NULL
1645 || cs
.current_traceframe
== -1)
1648 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1649 readbuf
, len
, &nbytes
))
1654 /* Helper for handle_qxfer_threads_proper.
1655 Emit the XML to describe the thread of INF. */
1658 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1660 ptid_t ptid
= ptid_of (thread
);
1662 int core
= target_core_of_thread (ptid
);
1664 const char *name
= target_thread_name (ptid
);
1667 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1669 write_ptid (ptid_s
, ptid
);
1671 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1675 sprintf (core_s
, "%d", core
);
1676 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1680 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1684 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1685 bin2hex (handle
, handle_s
, handle_len
);
1686 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1689 buffer_xml_printf (buffer
, "/>\n");
1692 /* Helper for handle_qxfer_threads. */
1695 handle_qxfer_threads_proper (struct buffer
*buffer
)
1697 buffer_grow_str (buffer
, "<threads>\n");
1699 for_each_thread ([&] (thread_info
*thread
)
1701 handle_qxfer_threads_worker (thread
, buffer
);
1704 buffer_grow_str0 (buffer
, "</threads>\n");
1707 /* Handle qXfer:threads:read. */
1710 handle_qxfer_threads (const char *annex
,
1711 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1712 ULONGEST offset
, LONGEST len
)
1714 static char *result
= 0;
1715 static unsigned int result_length
= 0;
1717 if (writebuf
!= NULL
)
1720 if (annex
[0] != '\0')
1725 struct buffer buffer
;
1726 /* When asked for data at offset 0, generate everything and store into
1727 'result'. Successive reads will be served off 'result'. */
1731 buffer_init (&buffer
);
1733 handle_qxfer_threads_proper (&buffer
);
1735 result
= buffer_finish (&buffer
);
1736 result_length
= strlen (result
);
1737 buffer_free (&buffer
);
1740 if (offset
>= result_length
)
1742 /* We're out of data. */
1749 if (len
> result_length
- offset
)
1750 len
= result_length
- offset
;
1752 memcpy (readbuf
, result
+ offset
, len
);
1757 /* Handle qXfer:traceframe-info:read. */
1760 handle_qxfer_traceframe_info (const char *annex
,
1761 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1762 ULONGEST offset
, LONGEST len
)
1764 client_state
&cs
= get_client_state ();
1765 static char *result
= 0;
1766 static unsigned int result_length
= 0;
1768 if (writebuf
!= NULL
)
1771 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1776 struct buffer buffer
;
1778 /* When asked for data at offset 0, generate everything and
1779 store into 'result'. Successive reads will be served off
1783 buffer_init (&buffer
);
1785 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1787 result
= buffer_finish (&buffer
);
1788 result_length
= strlen (result
);
1789 buffer_free (&buffer
);
1792 if (offset
>= result_length
)
1794 /* We're out of data. */
1801 if (len
> result_length
- offset
)
1802 len
= result_length
- offset
;
1804 memcpy (readbuf
, result
+ offset
, len
);
1808 /* Handle qXfer:fdpic:read. */
1811 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1812 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1814 if (the_target
->read_loadmap
== NULL
)
1817 if (current_thread
== NULL
)
1820 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1823 /* Handle qXfer:btrace:read. */
1826 handle_qxfer_btrace (const char *annex
,
1827 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1828 ULONGEST offset
, LONGEST len
)
1830 client_state
&cs
= get_client_state ();
1831 static struct buffer cache
;
1832 struct thread_info
*thread
;
1833 enum btrace_read_type type
;
1836 if (writebuf
!= NULL
)
1839 if (cs
.general_thread
== null_ptid
1840 || cs
.general_thread
== minus_one_ptid
)
1842 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1846 thread
= find_thread_ptid (cs
.general_thread
);
1849 strcpy (cs
.own_buf
, "E.No such thread.");
1853 if (thread
->btrace
== NULL
)
1855 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1859 if (strcmp (annex
, "all") == 0)
1860 type
= BTRACE_READ_ALL
;
1861 else if (strcmp (annex
, "new") == 0)
1862 type
= BTRACE_READ_NEW
;
1863 else if (strcmp (annex
, "delta") == 0)
1864 type
= BTRACE_READ_DELTA
;
1867 strcpy (cs
.own_buf
, "E.Bad annex.");
1873 buffer_free (&cache
);
1877 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1879 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1881 CATCH (exception
, RETURN_MASK_ERROR
)
1883 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1891 else if (offset
> cache
.used_size
)
1893 buffer_free (&cache
);
1897 if (len
> cache
.used_size
- offset
)
1898 len
= cache
.used_size
- offset
;
1900 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1905 /* Handle qXfer:btrace-conf:read. */
1908 handle_qxfer_btrace_conf (const char *annex
,
1909 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1910 ULONGEST offset
, LONGEST len
)
1912 client_state
&cs
= get_client_state ();
1913 static struct buffer cache
;
1914 struct thread_info
*thread
;
1917 if (writebuf
!= NULL
)
1920 if (annex
[0] != '\0')
1923 if (cs
.general_thread
== null_ptid
1924 || cs
.general_thread
== minus_one_ptid
)
1926 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1930 thread
= find_thread_ptid (cs
.general_thread
);
1933 strcpy (cs
.own_buf
, "E.No such thread.");
1937 if (thread
->btrace
== NULL
)
1939 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1945 buffer_free (&cache
);
1949 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1951 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1953 CATCH (exception
, RETURN_MASK_ERROR
)
1955 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1963 else if (offset
> cache
.used_size
)
1965 buffer_free (&cache
);
1969 if (len
> cache
.used_size
- offset
)
1970 len
= cache
.used_size
- offset
;
1972 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1977 static const struct qxfer qxfer_packets
[] =
1979 { "auxv", handle_qxfer_auxv
},
1980 { "btrace", handle_qxfer_btrace
},
1981 { "btrace-conf", handle_qxfer_btrace_conf
},
1982 { "exec-file", handle_qxfer_exec_file
},
1983 { "fdpic", handle_qxfer_fdpic
},
1984 { "features", handle_qxfer_features
},
1985 { "libraries", handle_qxfer_libraries
},
1986 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1987 { "osdata", handle_qxfer_osdata
},
1988 { "siginfo", handle_qxfer_siginfo
},
1989 { "spu", handle_qxfer_spu
},
1990 { "statictrace", handle_qxfer_statictrace
},
1991 { "threads", handle_qxfer_threads
},
1992 { "traceframe-info", handle_qxfer_traceframe_info
},
1996 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2004 if (!startswith (own_buf
, "qXfer:"))
2007 /* Grab the object, r/w and annex. */
2008 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2010 write_enn (own_buf
);
2015 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2018 const struct qxfer
*q
= &qxfer_packets
[i
];
2020 if (strcmp (object
, q
->object
) == 0)
2022 if (strcmp (rw
, "read") == 0)
2024 unsigned char *data
;
2029 /* Grab the offset and length. */
2030 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2032 write_enn (own_buf
);
2036 /* Read one extra byte, as an indicator of whether there is
2038 if (len
> PBUFSIZ
- 2)
2040 data
= (unsigned char *) malloc (len
+ 1);
2043 write_enn (own_buf
);
2046 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2054 /* Preserve error message. */
2057 write_enn (own_buf
);
2059 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2061 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2066 else if (strcmp (rw
, "write") == 0)
2071 unsigned char *data
;
2073 strcpy (own_buf
, "E00");
2074 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2077 write_enn (own_buf
);
2080 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2081 &ofs
, &len
, data
) < 0)
2084 write_enn (own_buf
);
2088 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2096 /* Preserve error message. */
2099 write_enn (own_buf
);
2101 sprintf (own_buf
, "%x", n
);
2114 /* Compute 32 bit CRC from inferior memory.
2116 On success, return 32 bit CRC.
2117 On failure, return (unsigned long long) -1. */
2119 static unsigned long long
2120 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2124 unsigned char byte
= 0;
2126 /* Return failure if memory read fails. */
2127 if (read_inferior_memory (base
, &byte
, 1) != 0)
2128 return (unsigned long long) -1;
2130 crc
= xcrc32 (&byte
, 1, crc
);
2133 return (unsigned long long) crc
;
2136 /* Add supported btrace packets to BUF. */
2139 supported_btrace_packets (char *buf
)
2141 strcat (buf
, ";Qbtrace:bts+");
2142 strcat (buf
, ";Qbtrace-conf:bts:size+");
2143 strcat (buf
, ";Qbtrace:pt+");
2144 strcat (buf
, ";Qbtrace-conf:pt:size+");
2145 strcat (buf
, ";Qbtrace:off+");
2146 strcat (buf
, ";qXfer:btrace:read+");
2147 strcat (buf
, ";qXfer:btrace-conf:read+");
2150 /* Handle all of the extended 'q' packets. */
2153 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2155 client_state
&cs
= get_client_state ();
2156 static std::list
<thread_info
*>::const_iterator thread_iter
;
2158 /* Reply the current thread id. */
2159 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2162 require_running_or_return (own_buf
);
2164 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2165 ptid
= cs
.general_thread
;
2168 thread_iter
= all_threads
.begin ();
2169 ptid
= (*thread_iter
)->id
;
2172 sprintf (own_buf
, "QC");
2174 write_ptid (own_buf
, ptid
);
2178 if (strcmp ("qSymbol::", own_buf
) == 0)
2180 struct thread_info
*save_thread
= current_thread
;
2182 /* For qSymbol, GDB only changes the current thread if the
2183 previous current thread was of a different process. So if
2184 the previous thread is gone, we need to pick another one of
2185 the same process. This can happen e.g., if we followed an
2186 exec in a non-leader thread. */
2187 if (current_thread
== NULL
)
2190 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2192 /* Just in case, if we didn't find a thread, then bail out
2193 instead of crashing. */
2194 if (current_thread
== NULL
)
2196 write_enn (own_buf
);
2197 current_thread
= save_thread
;
2202 /* GDB is suggesting new symbols have been loaded. This may
2203 mean a new shared library has been detected as loaded, so
2204 take the opportunity to check if breakpoints we think are
2205 inserted, still are. Note that it isn't guaranteed that
2206 we'll see this when a shared library is loaded, and nor will
2207 we see this for unloads (although breakpoints in unloaded
2208 libraries shouldn't trigger), as GDB may not find symbols for
2209 the library at all. We also re-validate breakpoints when we
2210 see a second GDB breakpoint for the same address, and or when
2211 we access breakpoint shadows. */
2212 validate_breakpoints ();
2214 if (target_supports_tracepoints ())
2215 tracepoint_look_up_symbols ();
2217 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2218 (*the_target
->look_up_symbols
) ();
2220 current_thread
= save_thread
;
2222 strcpy (own_buf
, "OK");
2226 if (!disable_packet_qfThreadInfo
)
2228 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2230 require_running_or_return (own_buf
);
2231 thread_iter
= all_threads
.begin ();
2234 ptid_t ptid
= (*thread_iter
)->id
;
2235 write_ptid (own_buf
, ptid
);
2240 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2242 require_running_or_return (own_buf
);
2243 if (thread_iter
!= all_threads
.end ())
2246 ptid_t ptid
= (*thread_iter
)->id
;
2247 write_ptid (own_buf
, ptid
);
2253 sprintf (own_buf
, "l");
2259 if (the_target
->read_offsets
!= NULL
2260 && strcmp ("qOffsets", own_buf
) == 0)
2262 CORE_ADDR text
, data
;
2264 require_running_or_return (own_buf
);
2265 if (the_target
->read_offsets (&text
, &data
))
2266 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2267 (long)text
, (long)data
, (long)data
);
2269 write_enn (own_buf
);
2274 /* Protocol features query. */
2275 if (startswith (own_buf
, "qSupported")
2276 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2278 char *p
= &own_buf
[10];
2279 int gdb_supports_qRelocInsn
= 0;
2281 /* Process each feature being provided by GDB. The first
2282 feature will follow a ':', and latter features will follow
2286 char **qsupported
= NULL
;
2291 /* Two passes, to avoid nested strtok calls in
2292 target_process_qsupported. */
2293 for (p
= strtok (p
+ 1, ";");
2295 p
= strtok (NULL
, ";"))
2298 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2299 qsupported
[count
- 1] = xstrdup (p
);
2302 for (i
= 0; i
< count
; i
++)
2305 if (strcmp (p
, "multiprocess+") == 0)
2307 /* GDB supports and wants multi-process support if
2309 if (target_supports_multi_process ())
2310 cs
.multi_process
= 1;
2312 else if (strcmp (p
, "qRelocInsn+") == 0)
2314 /* GDB supports relocate instruction requests. */
2315 gdb_supports_qRelocInsn
= 1;
2317 else if (strcmp (p
, "swbreak+") == 0)
2319 /* GDB wants us to report whether a trap is caused
2320 by a software breakpoint and for us to handle PC
2321 adjustment if necessary on this target. */
2322 if (target_supports_stopped_by_sw_breakpoint ())
2323 cs
.swbreak_feature
= 1;
2325 else if (strcmp (p
, "hwbreak+") == 0)
2327 /* GDB wants us to report whether a trap is caused
2328 by a hardware breakpoint. */
2329 if (target_supports_stopped_by_hw_breakpoint ())
2330 cs
.hwbreak_feature
= 1;
2332 else if (strcmp (p
, "fork-events+") == 0)
2334 /* GDB supports and wants fork events if possible. */
2335 if (target_supports_fork_events ())
2336 cs
.report_fork_events
= 1;
2338 else if (strcmp (p
, "vfork-events+") == 0)
2340 /* GDB supports and wants vfork events if possible. */
2341 if (target_supports_vfork_events ())
2342 cs
.report_vfork_events
= 1;
2344 else if (strcmp (p
, "exec-events+") == 0)
2346 /* GDB supports and wants exec events if possible. */
2347 if (target_supports_exec_events ())
2348 cs
.report_exec_events
= 1;
2350 else if (strcmp (p
, "vContSupported+") == 0)
2351 cs
.vCont_supported
= 1;
2352 else if (strcmp (p
, "QThreadEvents+") == 0)
2354 else if (strcmp (p
, "no-resumed+") == 0)
2356 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2358 report_no_resumed
= 1;
2362 /* Move the unknown features all together. */
2363 qsupported
[i
] = NULL
;
2364 qsupported
[unknown
] = p
;
2369 /* Give the target backend a chance to process the unknown
2371 target_process_qsupported (qsupported
, unknown
);
2373 for (i
= 0; i
< count
; i
++)
2374 free (qsupported
[i
]);
2379 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2380 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2381 "QEnvironmentReset+;QEnvironmentUnset+;"
2385 if (target_supports_catch_syscall ())
2386 strcat (own_buf
, ";QCatchSyscalls+");
2388 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2389 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2390 ";augmented-libraries-svr4-read+");
2393 /* We do not have any hook to indicate whether the non-SVR4 target
2394 backend supports qXfer:libraries:read, so always report it. */
2395 strcat (own_buf
, ";qXfer:libraries:read+");
2398 if (the_target
->read_auxv
!= NULL
)
2399 strcat (own_buf
, ";qXfer:auxv:read+");
2401 if (the_target
->qxfer_spu
!= NULL
)
2402 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2404 if (the_target
->qxfer_siginfo
!= NULL
)
2405 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2407 if (the_target
->read_loadmap
!= NULL
)
2408 strcat (own_buf
, ";qXfer:fdpic:read+");
2410 /* We always report qXfer:features:read, as targets may
2411 install XML files on a subsequent call to arch_setup.
2412 If we reported to GDB on startup that we don't support
2413 qXfer:feature:read at all, we will never be re-queried. */
2414 strcat (own_buf
, ";qXfer:features:read+");
2416 if (cs
.transport_is_reliable
)
2417 strcat (own_buf
, ";QStartNoAckMode+");
2419 if (the_target
->qxfer_osdata
!= NULL
)
2420 strcat (own_buf
, ";qXfer:osdata:read+");
2422 if (target_supports_multi_process ())
2423 strcat (own_buf
, ";multiprocess+");
2425 if (target_supports_fork_events ())
2426 strcat (own_buf
, ";fork-events+");
2428 if (target_supports_vfork_events ())
2429 strcat (own_buf
, ";vfork-events+");
2431 if (target_supports_exec_events ())
2432 strcat (own_buf
, ";exec-events+");
2434 if (target_supports_non_stop ())
2435 strcat (own_buf
, ";QNonStop+");
2437 if (target_supports_disable_randomization ())
2438 strcat (own_buf
, ";QDisableRandomization+");
2440 strcat (own_buf
, ";qXfer:threads:read+");
2442 if (target_supports_tracepoints ())
2444 strcat (own_buf
, ";ConditionalTracepoints+");
2445 strcat (own_buf
, ";TraceStateVariables+");
2446 strcat (own_buf
, ";TracepointSource+");
2447 strcat (own_buf
, ";DisconnectedTracing+");
2448 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2449 strcat (own_buf
, ";FastTracepoints+");
2450 strcat (own_buf
, ";StaticTracepoints+");
2451 strcat (own_buf
, ";InstallInTrace+");
2452 strcat (own_buf
, ";qXfer:statictrace:read+");
2453 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2454 strcat (own_buf
, ";EnableDisableTracepoints+");
2455 strcat (own_buf
, ";QTBuffer:size+");
2456 strcat (own_buf
, ";tracenz+");
2459 if (target_supports_hardware_single_step ()
2460 || target_supports_software_single_step () )
2462 strcat (own_buf
, ";ConditionalBreakpoints+");
2464 strcat (own_buf
, ";BreakpointCommands+");
2466 if (target_supports_agent ())
2467 strcat (own_buf
, ";QAgent+");
2469 supported_btrace_packets (own_buf
);
2471 if (target_supports_stopped_by_sw_breakpoint ())
2472 strcat (own_buf
, ";swbreak+");
2474 if (target_supports_stopped_by_hw_breakpoint ())
2475 strcat (own_buf
, ";hwbreak+");
2477 if (the_target
->pid_to_exec_file
!= NULL
)
2478 strcat (own_buf
, ";qXfer:exec-file:read+");
2480 strcat (own_buf
, ";vContSupported+");
2482 strcat (own_buf
, ";QThreadEvents+");
2484 strcat (own_buf
, ";no-resumed+");
2486 /* Reinitialize components as needed for the new connection. */
2487 hostio_handle_new_gdb_connection ();
2488 target_handle_new_gdb_connection ();
2493 /* Thread-local storage support. */
2494 if (the_target
->get_tls_address
!= NULL
2495 && startswith (own_buf
, "qGetTLSAddr:"))
2497 char *p
= own_buf
+ 12;
2498 CORE_ADDR parts
[2], address
= 0;
2500 ptid_t ptid
= null_ptid
;
2502 require_running_or_return (own_buf
);
2504 for (i
= 0; i
< 3; i
++)
2512 p2
= strchr (p
, ',');
2525 ptid
= read_ptid (p
, NULL
);
2527 decode_address (&parts
[i
- 1], p
, len
);
2531 if (p
!= NULL
|| i
< 3)
2535 struct thread_info
*thread
= find_thread_ptid (ptid
);
2540 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2546 strcpy (own_buf
, paddress(address
));
2551 write_enn (own_buf
);
2555 /* Otherwise, pretend we do not understand this packet. */
2558 /* Windows OS Thread Information Block address support. */
2559 if (the_target
->get_tib_address
!= NULL
2560 && startswith (own_buf
, "qGetTIBAddr:"))
2565 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2567 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2570 strcpy (own_buf
, paddress(tlb
));
2575 write_enn (own_buf
);
2581 /* Handle "monitor" commands. */
2582 if (startswith (own_buf
, "qRcmd,"))
2584 char *mon
= (char *) malloc (PBUFSIZ
);
2585 int len
= strlen (own_buf
+ 6);
2589 write_enn (own_buf
);
2594 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2596 write_enn (own_buf
);
2600 mon
[len
/ 2] = '\0';
2604 if (the_target
->handle_monitor_command
== NULL
2605 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2606 /* Default processing. */
2607 handle_monitor_command (mon
, own_buf
);
2613 if (startswith (own_buf
, "qSearch:memory:"))
2615 require_running_or_return (own_buf
);
2616 handle_search_memory (own_buf
, packet_len
);
2620 if (strcmp (own_buf
, "qAttached") == 0
2621 || startswith (own_buf
, "qAttached:"))
2623 struct process_info
*process
;
2625 if (own_buf
[sizeof ("qAttached") - 1])
2627 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2628 process
= find_process_pid (pid
);
2632 require_running_or_return (own_buf
);
2633 process
= current_process ();
2636 if (process
== NULL
)
2638 write_enn (own_buf
);
2642 strcpy (own_buf
, process
->attached
? "1" : "0");
2646 if (startswith (own_buf
, "qCRC:"))
2648 /* CRC check (compare-section). */
2652 unsigned long long crc
;
2654 require_running_or_return (own_buf
);
2655 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2656 if (*comma
++ != ',')
2658 write_enn (own_buf
);
2661 len
= strtoul (comma
, NULL
, 16);
2662 crc
= crc32 (base
, len
, 0xffffffff);
2663 /* Check for memory failure. */
2664 if (crc
== (unsigned long long) -1)
2666 write_enn (own_buf
);
2669 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2673 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2676 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2679 /* Otherwise we didn't know what packet it was. Say we didn't
2684 static void gdb_wants_all_threads_stopped (void);
2685 static void resume (struct thread_resume
*actions
, size_t n
);
2687 /* The callback that is passed to visit_actioned_threads. */
2688 typedef int (visit_actioned_threads_callback_ftype
)
2689 (const struct thread_resume
*, struct thread_info
*);
2691 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2692 true if CALLBACK returns true. Returns false if no matching thread
2693 is found or CALLBACK results false.
2694 Note: This function is itself a callback for find_thread. */
2697 visit_actioned_threads (thread_info
*thread
,
2698 const struct thread_resume
*actions
,
2700 visit_actioned_threads_callback_ftype
*callback
)
2702 for (size_t i
= 0; i
< num_actions
; i
++)
2704 const struct thread_resume
*action
= &actions
[i
];
2706 if (action
->thread
== minus_one_ptid
2707 || action
->thread
== thread
->id
2708 || ((action
->thread
.pid ()
2709 == thread
->id
.pid ())
2710 && action
->thread
.lwp () == -1))
2712 if ((*callback
) (action
, thread
))
2720 /* Callback for visit_actioned_threads. If the thread has a pending
2721 status to report, report it now. */
2724 handle_pending_status (const struct thread_resume
*resumption
,
2725 struct thread_info
*thread
)
2727 client_state
&cs
= get_client_state ();
2728 if (thread
->status_pending_p
)
2730 thread
->status_pending_p
= 0;
2732 cs
.last_status
= thread
->last_status
;
2733 cs
.last_ptid
= thread
->id
;
2734 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2740 /* Parse vCont packets. */
2742 handle_v_cont (char *own_buf
)
2746 struct thread_resume
*resume_info
;
2747 struct thread_resume default_action
{ null_ptid
};
2749 /* Count the number of semicolons in the packet. There should be one
2750 for every action. */
2756 p
= strchr (p
, ';');
2759 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2760 if (resume_info
== NULL
)
2768 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2770 if (p
[0] == 's' || p
[0] == 'S')
2771 resume_info
[i
].kind
= resume_step
;
2772 else if (p
[0] == 'r')
2773 resume_info
[i
].kind
= resume_step
;
2774 else if (p
[0] == 'c' || p
[0] == 'C')
2775 resume_info
[i
].kind
= resume_continue
;
2776 else if (p
[0] == 't')
2777 resume_info
[i
].kind
= resume_stop
;
2781 if (p
[0] == 'S' || p
[0] == 'C')
2784 int sig
= strtol (p
+ 1, &q
, 16);
2789 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2791 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2793 else if (p
[0] == 'r')
2797 p
= unpack_varlen_hex (p
+ 1, &addr
);
2798 resume_info
[i
].step_range_start
= addr
;
2803 p
= unpack_varlen_hex (p
+ 1, &addr
);
2804 resume_info
[i
].step_range_end
= addr
;
2813 resume_info
[i
].thread
= minus_one_ptid
;
2814 default_action
= resume_info
[i
];
2816 /* Note: we don't increment i here, we'll overwrite this entry
2817 the next time through. */
2819 else if (p
[0] == ':')
2822 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2827 if (p
[0] != ';' && p
[0] != 0)
2830 resume_info
[i
].thread
= ptid
;
2837 resume_info
[i
] = default_action
;
2839 resume (resume_info
, n
);
2844 write_enn (own_buf
);
2849 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2852 resume (struct thread_resume
*actions
, size_t num_actions
)
2854 client_state
&cs
= get_client_state ();
2857 /* Check if among the threads that GDB wants actioned, there's
2858 one with a pending status to report. If so, skip actually
2859 resuming/stopping and report the pending event
2862 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2864 return visit_actioned_threads (thread
, actions
, num_actions
,
2865 handle_pending_status
);
2868 if (thread_with_status
!= NULL
)
2874 (*the_target
->resume
) (actions
, num_actions
);
2877 write_ok (cs
.own_buf
);
2880 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2882 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2883 && !report_no_resumed
)
2885 /* The client does not support this stop reply. At least
2887 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2888 disable_async_io ();
2892 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2893 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2894 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2895 current_thread
->last_status
= cs
.last_status
;
2897 /* From the client's perspective, all-stop mode always stops all
2898 threads implicitly (and the target backend has already done
2899 so by now). Tag all threads as "want-stopped", so we don't
2900 resume them implicitly without the client telling us to. */
2901 gdb_wants_all_threads_stopped ();
2902 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2903 disable_async_io ();
2905 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2906 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2907 target_mourn_inferior (cs
.last_ptid
);
2911 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2913 handle_v_attach (char *own_buf
)
2915 client_state
&cs
= get_client_state ();
2918 pid
= strtol (own_buf
+ 8, NULL
, 16);
2919 if (pid
!= 0 && attach_inferior (pid
) == 0)
2921 /* Don't report shared library events after attaching, even if
2922 some libraries are preloaded. GDB will always poll the
2923 library list. Avoids the "stopped by shared library event"
2924 notice on the GDB side. */
2929 /* In non-stop, we don't send a resume reply. Stop events
2930 will follow up using the normal notification
2935 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2941 write_enn (own_buf
);
2946 /* Run a new program. Return 1 if successful, 0 if failure. */
2948 handle_v_run (char *own_buf
)
2950 client_state
&cs
= get_client_state ();
2952 std::vector
<char *> new_argv
;
2953 char *new_program_name
= NULL
;
2957 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2963 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2965 next_p
= strchr (p
, ';');
2967 next_p
= p
+ strlen (p
);
2969 if (i
== 0 && p
== next_p
)
2971 /* No program specified. */
2972 new_program_name
= NULL
;
2974 else if (p
== next_p
)
2976 /* Empty argument. */
2977 new_argv
.push_back (xstrdup ("''"));
2981 size_t len
= (next_p
- p
) / 2;
2982 /* ARG is the unquoted argument received via the RSP. */
2983 char *arg
= (char *) xmalloc (len
+ 1);
2984 /* FULL_ARGS will contain the quoted version of ARG. */
2985 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2986 /* These are pointers used to navigate the strings above. */
2987 char *tmp_arg
= arg
;
2988 char *tmp_full_arg
= full_arg
;
2991 hex2bin (p
, (gdb_byte
*) arg
, len
);
2994 while (*tmp_arg
!= '\0')
3000 *tmp_full_arg
= '\'';
3006 /* Quote single quote. */
3007 *tmp_full_arg
= '\\';
3015 *tmp_full_arg
= *tmp_arg
;
3021 *tmp_full_arg
++ = '\'';
3023 /* Finish FULL_ARG and push it into the vector containing
3025 *tmp_full_arg
= '\0';
3027 new_program_name
= full_arg
;
3029 new_argv
.push_back (full_arg
);
3035 new_argv
.push_back (NULL
);
3037 if (new_program_name
== NULL
)
3039 /* GDB didn't specify a program to run. Use the program from the
3040 last run with the new argument list. */
3041 if (program_path
.get () == NULL
)
3043 write_enn (own_buf
);
3044 free_vector_argv (new_argv
);
3049 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3051 /* Free the old argv and install the new one. */
3052 free_vector_argv (program_args
);
3053 program_args
= new_argv
;
3055 create_inferior (program_path
.get (), program_args
);
3057 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3059 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3061 /* In non-stop, sending a resume reply doesn't set the general
3062 thread, but GDB assumes a vRun sets it (this is so GDB can
3063 query which is the main thread of the new inferior. */
3065 cs
.general_thread
= cs
.last_ptid
;
3071 write_enn (own_buf
);
3076 /* Kill process. Return 1 if successful, 0 if failure. */
3078 handle_v_kill (char *own_buf
)
3080 client_state
&cs
= get_client_state ();
3082 char *p
= &own_buf
[6];
3083 if (cs
.multi_process
)
3084 pid
= strtol (p
, NULL
, 16);
3088 process_info
*proc
= find_process_pid (pid
);
3090 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3092 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3093 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3094 cs
.last_ptid
= ptid_t (pid
);
3095 discard_queued_stop_replies (cs
.last_ptid
);
3101 write_enn (own_buf
);
3106 /* Handle all of the extended 'v' packets. */
3108 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3110 client_state
&cs
= get_client_state ();
3111 if (!disable_packet_vCont
)
3113 if (strcmp (own_buf
, "vCtrlC") == 0)
3115 (*the_target
->request_interrupt
) ();
3120 if (startswith (own_buf
, "vCont;"))
3122 handle_v_cont (own_buf
);
3126 if (startswith (own_buf
, "vCont?"))
3128 strcpy (own_buf
, "vCont;c;C;t");
3130 if (target_supports_hardware_single_step ()
3131 || target_supports_software_single_step ()
3132 || !cs
.vCont_supported
)
3134 /* If target supports single step either by hardware or by
3135 software, add actions s and S to the list of supported
3136 actions. On the other hand, if GDB doesn't request the
3137 supported vCont actions in qSupported packet, add s and
3138 S to the list too. */
3139 own_buf
= own_buf
+ strlen (own_buf
);
3140 strcpy (own_buf
, ";s;S");
3143 if (target_supports_range_stepping ())
3145 own_buf
= own_buf
+ strlen (own_buf
);
3146 strcpy (own_buf
, ";r");
3152 if (startswith (own_buf
, "vFile:")
3153 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3156 if (startswith (own_buf
, "vAttach;"))
3158 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3160 fprintf (stderr
, "Already debugging a process\n");
3161 write_enn (own_buf
);
3164 handle_v_attach (own_buf
);
3168 if (startswith (own_buf
, "vRun;"))
3170 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3172 fprintf (stderr
, "Already debugging a process\n");
3173 write_enn (own_buf
);
3176 handle_v_run (own_buf
);
3180 if (startswith (own_buf
, "vKill;"))
3182 if (!target_running ())
3184 fprintf (stderr
, "No process to kill\n");
3185 write_enn (own_buf
);
3188 handle_v_kill (own_buf
);
3192 if (handle_notif_ack (own_buf
, packet_len
))
3195 /* Otherwise we didn't know what packet it was. Say we didn't
3201 /* Resume thread and wait for another event. In non-stop mode,
3202 don't really wait here, but return immediatelly to the event
3205 myresume (char *own_buf
, int step
, int sig
)
3207 client_state
&cs
= get_client_state ();
3208 struct thread_resume resume_info
[2];
3210 int valid_cont_thread
;
3212 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3213 && cs
.cont_thread
!= minus_one_ptid
);
3215 if (step
|| sig
|| valid_cont_thread
)
3217 resume_info
[0].thread
= current_ptid
;
3219 resume_info
[0].kind
= resume_step
;
3221 resume_info
[0].kind
= resume_continue
;
3222 resume_info
[0].sig
= sig
;
3226 if (!valid_cont_thread
)
3228 resume_info
[n
].thread
= minus_one_ptid
;
3229 resume_info
[n
].kind
= resume_continue
;
3230 resume_info
[n
].sig
= 0;
3234 resume (resume_info
, n
);
3237 /* Callback for for_each_thread. Make a new stop reply for each
3241 queue_stop_reply_callback (thread_info
*thread
)
3243 /* For now, assume targets that don't have this callback also don't
3244 manage the thread's last_status field. */
3245 if (the_target
->thread_stopped
== NULL
)
3247 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3249 new_notif
->ptid
= thread
->id
;
3250 new_notif
->status
= thread
->last_status
;
3251 /* Pass the last stop reply back to GDB, but don't notify
3253 notif_event_enque (¬if_stop
,
3254 (struct notif_event
*) new_notif
);
3258 if (thread_stopped (thread
))
3262 std::string status_string
3263 = target_waitstatus_to_string (&thread
->last_status
);
3265 debug_printf ("Reporting thread %s as already stopped with %s\n",
3266 target_pid_to_str (thread
->id
),
3267 status_string
.c_str ());
3270 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3272 /* Pass the last stop reply back to GDB, but don't notify
3274 queue_stop_reply (thread
->id
, &thread
->last_status
);
3279 /* Set this inferior threads's state as "want-stopped". We won't
3280 resume this thread until the client gives us another action for
3284 gdb_wants_thread_stopped (thread_info
*thread
)
3286 thread
->last_resume_kind
= resume_stop
;
3288 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3290 /* Most threads are stopped implicitly (all-stop); tag that with
3292 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3293 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3297 /* Set all threads' states as "want-stopped". */
3300 gdb_wants_all_threads_stopped (void)
3302 for_each_thread (gdb_wants_thread_stopped
);
3305 /* Callback for for_each_thread. If the thread is stopped with an
3306 interesting event, mark it as having a pending event. */
3309 set_pending_status_callback (thread_info
*thread
)
3311 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3312 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3313 /* A breakpoint, watchpoint or finished step from a previous
3314 GDB run isn't considered interesting for a new GDB run.
3315 If we left those pending, the new GDB could consider them
3316 random SIGTRAPs. This leaves out real async traps. We'd
3317 have to peek into the (target-specific) siginfo to
3318 distinguish those. */
3319 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3320 thread
->status_pending_p
= 1;
3323 /* Status handler for the '?' packet. */
3326 handle_status (char *own_buf
)
3328 client_state
&cs
= get_client_state ();
3330 /* GDB is connected, don't forward events to the target anymore. */
3331 for_each_process ([] (process_info
*process
) {
3332 process
->gdb_detached
= 0;
3335 /* In non-stop mode, we must send a stop reply for each stopped
3336 thread. In all-stop mode, just send one for the first stopped
3341 for_each_thread (queue_stop_reply_callback
);
3343 /* The first is sent immediatly. OK is sent if there is no
3344 stopped thread, which is the same handling of the vStopped
3345 packet (by design). */
3346 notif_write_event (¬if_stop
, cs
.own_buf
);
3350 thread_info
*thread
= NULL
;
3353 stabilize_threads ();
3354 gdb_wants_all_threads_stopped ();
3356 /* We can only report one status, but we might be coming out of
3357 non-stop -- if more than one thread is stopped with
3358 interesting events, leave events for the threads we're not
3359 reporting now pending. They'll be reported the next time the
3360 threads are resumed. Start by marking all interesting events
3362 for_each_thread (set_pending_status_callback
);
3364 /* Prefer the last thread that reported an event to GDB (even if
3365 that was a GDB_SIGNAL_TRAP). */
3366 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3367 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3368 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3369 thread
= find_thread_ptid (cs
.last_ptid
);
3371 /* If the last event thread is not found for some reason, look
3372 for some other thread that might have an event to report. */
3374 thread
= find_thread ([] (thread_info
*thr_arg
)
3376 return thr_arg
->status_pending_p
;
3379 /* If we're still out of luck, simply pick the first thread in
3382 thread
= get_first_thread ();
3386 struct thread_info
*tp
= (struct thread_info
*) thread
;
3388 /* We're reporting this event, so it's no longer
3390 tp
->status_pending_p
= 0;
3392 /* GDB assumes the current thread is the thread we're
3393 reporting the status for. */
3394 cs
.general_thread
= thread
->id
;
3395 set_desired_thread ();
3397 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3398 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3401 strcpy (own_buf
, "W00");
3406 gdbserver_version (void)
3408 printf ("GNU gdbserver %s%s\n"
3409 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3410 "gdbserver is free software, covered by the "
3411 "GNU General Public License.\n"
3412 "This gdbserver was configured as \"%s\"\n",
3413 PKGVERSION
, version
, host_name
);
3417 gdbserver_usage (FILE *stream
)
3419 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3420 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3421 "\tgdbserver [OPTIONS] --multi COMM\n"
3423 "COMM may either be a tty device (for serial debugging),\n"
3424 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3425 "stdin/stdout of gdbserver.\n"
3426 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3427 "PID is the process ID to attach to, when --attach is specified.\n"
3429 "Operating modes:\n"
3431 " --attach Attach to running process PID.\n"
3432 " --multi Start server without a specific program, and\n"
3433 " only quit when explicitly commanded.\n"
3434 " --once Exit after the first connection has closed.\n"
3435 " --help Print this message and then exit.\n"
3436 " --version Display version information and exit.\n"
3440 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3441 " --disable-randomization\n"
3442 " Run PROG with address space randomization disabled.\n"
3443 " --no-disable-randomization\n"
3444 " Don't disable address space randomization when\n"
3446 " --startup-with-shell\n"
3447 " Start PROG using a shell. I.e., execs a shell that\n"
3448 " then execs PROG. (default)\n"
3449 " --no-startup-with-shell\n"
3450 " Exec PROG directly instead of using a shell.\n"
3451 " Disables argument globbing and variable substitution\n"
3452 " on UNIX-like systems.\n"
3456 " --debug Enable general debugging output.\n"
3457 " --debug-format=opt1[,opt2,...]\n"
3458 " Specify extra content in debugging output.\n"
3463 " --remote-debug Enable remote protocol debugging output.\n"
3464 " --disable-packet=opt1[,opt2,...]\n"
3465 " Disable support for RSP packets or features.\n"
3467 " vCont, Tthread, qC, qfThreadInfo and \n"
3468 " threads (disable all threading packets).\n"
3470 "For more information, consult the GDB manual (available as on-line \n"
3471 "info or a printed manual).\n");
3472 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3473 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3477 gdbserver_show_disableable (FILE *stream
)
3479 fprintf (stream
, "Disableable packets:\n"
3480 " vCont \tAll vCont packets\n"
3481 " qC \tQuerying the current thread\n"
3482 " qfThreadInfo\tThread listing\n"
3483 " Tthread \tPassing the thread specifier in the "
3484 "T stop reply packet\n"
3485 " threads \tAll of the above\n");
3489 kill_inferior_callback (process_info
*process
)
3491 kill_inferior (process
);
3492 discard_queued_stop_replies (ptid_t (process
->pid
));
3495 /* Call this when exiting gdbserver with possible inferiors that need
3496 to be killed or detached from. */
3499 detach_or_kill_for_exit (void)
3501 /* First print a list of the inferiors we will be killing/detaching.
3502 This is to assist the user, for example, in case the inferior unexpectedly
3503 dies after we exit: did we screw up or did the inferior exit on its own?
3504 Having this info will save some head-scratching. */
3506 if (have_started_inferiors_p ())
3508 fprintf (stderr
, "Killing process(es):");
3510 for_each_process ([] (process_info
*process
) {
3511 if (!process
->attached
)
3512 fprintf (stderr
, " %d", process
->pid
);
3515 fprintf (stderr
, "\n");
3517 if (have_attached_inferiors_p ())
3519 fprintf (stderr
, "Detaching process(es):");
3521 for_each_process ([] (process_info
*process
) {
3522 if (process
->attached
)
3523 fprintf (stderr
, " %d", process
->pid
);
3526 fprintf (stderr
, "\n");
3529 /* Now we can kill or detach the inferiors. */
3530 for_each_process ([] (process_info
*process
) {
3531 int pid
= process
->pid
;
3533 if (process
->attached
)
3534 detach_inferior (process
);
3536 kill_inferior (process
);
3538 discard_queued_stop_replies (ptid_t (pid
));
3542 /* Value that will be passed to exit(3) when gdbserver exits. */
3543 static int exit_code
;
3545 /* Cleanup version of detach_or_kill_for_exit. */
3548 detach_or_kill_for_exit_cleanup (void *ignore
)
3553 detach_or_kill_for_exit ();
3556 CATCH (exception
, RETURN_MASK_ALL
)
3559 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3565 /* Main function. This is called by the real "main" function,
3566 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3568 static void ATTRIBUTE_NORETURN
3569 captured_main (int argc
, char *argv
[])
3574 const char *port
= NULL
;
3575 char **next_arg
= &argv
[1];
3576 volatile int multi_mode
= 0;
3577 volatile int attach
= 0;
3579 bool selftest
= false;
3581 const char *selftest_filter
= NULL
;
3584 current_directory
= getcwd (NULL
, 0);
3585 client_state
&cs
= get_client_state ();
3587 if (current_directory
== NULL
)
3589 error (_("Could not find current working directory: %s"),
3590 safe_strerror (errno
));
3593 while (*next_arg
!= NULL
&& **next_arg
== '-')
3595 if (strcmp (*next_arg
, "--version") == 0)
3597 gdbserver_version ();
3600 else if (strcmp (*next_arg
, "--help") == 0)
3602 gdbserver_usage (stdout
);
3605 else if (strcmp (*next_arg
, "--attach") == 0)
3607 else if (strcmp (*next_arg
, "--multi") == 0)
3609 else if (strcmp (*next_arg
, "--wrapper") == 0)
3616 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3618 wrapper_argv
+= *next_arg
;
3619 wrapper_argv
+= ' ';
3623 if (!wrapper_argv
.empty ())
3625 /* Erase the last whitespace. */
3626 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3629 if (next_arg
== tmp
|| *next_arg
== NULL
)
3631 gdbserver_usage (stderr
);
3635 /* Consume the "--". */
3638 else if (strcmp (*next_arg
, "--debug") == 0)
3640 else if (startswith (*next_arg
, "--debug-format="))
3642 std::string error_msg
3643 = parse_debug_format_options ((*next_arg
)
3644 + sizeof ("--debug-format=") - 1, 0);
3646 if (!error_msg
.empty ())
3648 fprintf (stderr
, "%s", error_msg
.c_str ());
3652 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3654 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3656 gdbserver_show_disableable (stdout
);
3659 else if (startswith (*next_arg
, "--disable-packet="))
3661 char *packets
, *tok
;
3663 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3664 for (tok
= strtok (packets
, ",");
3666 tok
= strtok (NULL
, ","))
3668 if (strcmp ("vCont", tok
) == 0)
3669 disable_packet_vCont
= 1;
3670 else if (strcmp ("Tthread", tok
) == 0)
3671 disable_packet_Tthread
= 1;
3672 else if (strcmp ("qC", tok
) == 0)
3673 disable_packet_qC
= 1;
3674 else if (strcmp ("qfThreadInfo", tok
) == 0)
3675 disable_packet_qfThreadInfo
= 1;
3676 else if (strcmp ("threads", tok
) == 0)
3678 disable_packet_vCont
= 1;
3679 disable_packet_Tthread
= 1;
3680 disable_packet_qC
= 1;
3681 disable_packet_qfThreadInfo
= 1;
3685 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3687 gdbserver_show_disableable (stderr
);
3692 else if (strcmp (*next_arg
, "-") == 0)
3694 /* "-" specifies a stdio connection and is a form of port
3696 port
= STDIO_CONNECTION_NAME
;
3700 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3701 cs
.disable_randomization
= 1;
3702 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3703 cs
.disable_randomization
= 0;
3704 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3705 startup_with_shell
= true;
3706 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3707 startup_with_shell
= false;
3708 else if (strcmp (*next_arg
, "--once") == 0)
3710 else if (strcmp (*next_arg
, "--selftest") == 0)
3712 else if (startswith (*next_arg
, "--selftest="))
3716 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3721 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3734 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3737 gdbserver_usage (stderr
);
3741 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3742 opened by remote_prepare. */
3745 save_original_signals_state (false);
3747 /* We need to know whether the remote connection is stdio before
3748 starting the inferior. Inferiors created in this scenario have
3749 stdin,stdout redirected. So do this here before we call
3752 remote_prepare (port
);
3757 /* --attach used to come after PORT, so allow it there for
3759 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3766 && (*next_arg
== NULL
3767 || (*next_arg
)[0] == '\0'
3768 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3770 || next_arg
[1] != NULL
))
3775 gdbserver_usage (stderr
);
3779 /* Gather information about the environment. */
3780 our_environ
= gdb_environ::from_host_environ ();
3782 initialize_async_io ();
3784 have_job_control ();
3785 initialize_event_loop ();
3786 if (target_supports_tracepoints ())
3787 initialize_tracepoint ();
3788 initialize_notif ();
3790 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3795 selftests::run_tests (selftest_filter
);
3797 printf (_("Selftests have been disabled for this build.\n"));
3799 throw_quit ("Quit");
3802 if (pid
== 0 && *next_arg
!= NULL
)
3806 n
= argc
- (next_arg
- argv
);
3807 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3808 for (i
= 1; i
< n
; i
++)
3809 program_args
.push_back (xstrdup (next_arg
[i
]));
3810 program_args
.push_back (NULL
);
3812 /* Wait till we are at first instruction in program. */
3813 create_inferior (program_path
.get (), program_args
);
3815 /* We are now (hopefully) stopped at the first instruction of
3816 the target process. This assumes that the target process was
3817 successfully created. */
3821 if (attach_inferior (pid
) == -1)
3822 error ("Attaching not supported on this target");
3824 /* Otherwise succeeded. */
3828 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3829 cs
.last_status
.value
.integer
= 0;
3830 cs
.last_ptid
= minus_one_ptid
;
3832 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3834 /* Don't report shared library events on the initial connection,
3835 even if some libraries are preloaded. Avoids the "stopped by
3836 shared library event" notice on gdb side. */
3839 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3840 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3845 if (!was_running
&& !multi_mode
)
3846 error ("No program to debug");
3851 cs
.multi_process
= 0;
3852 cs
.report_fork_events
= 0;
3853 cs
.report_vfork_events
= 0;
3854 cs
.report_exec_events
= 0;
3855 /* Be sure we're out of tfind mode. */
3856 cs
.current_traceframe
= -1;
3857 cs
.cont_thread
= null_ptid
;
3858 cs
.swbreak_feature
= 0;
3859 cs
.hwbreak_feature
= 0;
3860 cs
.vCont_supported
= 0;
3866 /* Wait for events. This will return when all event sources
3867 are removed from the event loop. */
3868 start_event_loop ();
3870 /* If an exit was requested (using the "monitor exit"
3871 command), terminate now. */
3873 throw_quit ("Quit");
3875 /* The only other way to get here is for getpkt to fail:
3877 - If --once was specified, we're done.
3879 - If not in extended-remote mode, and we're no longer
3880 debugging anything, simply exit: GDB has disconnected
3881 after processing the last process exit.
3883 - Otherwise, close the connection and reopen it at the
3885 if (run_once
|| (!extended_protocol
&& !target_running ()))
3886 throw_quit ("Quit");
3889 "Remote side has terminated connection. "
3890 "GDBserver will reopen the connection.\n");
3892 /* Get rid of any pending statuses. An eventual reconnection
3893 (by the same GDB instance or another) will refresh all its
3894 state from scratch. */
3895 discard_queued_stop_replies (minus_one_ptid
);
3896 for_each_thread ([] (thread_info
*thread
)
3898 thread
->status_pending_p
= 0;
3903 if (disconnected_tracing
)
3905 /* Try to enable non-stop/async mode, so we we can
3906 both wait for an async socket accept, and handle
3907 async target events simultaneously. There's also
3908 no point either in having the target always stop
3909 all threads, when we're going to pass signals
3910 down without informing GDB. */
3913 if (start_non_stop (1))
3916 /* Detaching implicitly resumes all threads;
3917 simply disconnecting does not. */
3923 "Disconnected tracing disabled; "
3924 "stopping trace run.\n");
3929 CATCH (exception
, RETURN_MASK_ERROR
)
3932 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3934 if (response_needed
)
3936 write_enn (cs
.own_buf
);
3937 putpkt (cs
.own_buf
);
3941 throw_quit ("Quit");
3947 /* Main function. */
3950 main (int argc
, char *argv
[])
3955 captured_main (argc
, argv
);
3957 CATCH (exception
, RETURN_MASK_ALL
)
3959 if (exception
.reason
== RETURN_ERROR
)
3962 fprintf (stderr
, "%s\n", exception
.message
);
3963 fprintf (stderr
, "Exiting\n");
3971 gdb_assert_not_reached ("captured_main should never return");
3974 /* Process options coming from Z packets for a breakpoint. PACKET is
3975 the packet buffer. *PACKET is updated to point to the first char
3976 after the last processed option. */
3979 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3981 const char *dataptr
= *packet
;
3984 /* Check if data has the correct format. */
3985 if (*dataptr
!= ';')
3992 if (*dataptr
== ';')
3995 if (*dataptr
== 'X')
3997 /* Conditional expression. */
3999 debug_printf ("Found breakpoint condition.\n");
4000 if (!add_breakpoint_condition (bp
, &dataptr
))
4001 dataptr
= strchrnul (dataptr
, ';');
4003 else if (startswith (dataptr
, "cmds:"))
4005 dataptr
+= strlen ("cmds:");
4007 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4008 persist
= (*dataptr
== '1');
4010 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4011 dataptr
= strchrnul (dataptr
, ';');
4015 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4017 /* Skip tokens until we find one that we recognize. */
4018 dataptr
= strchrnul (dataptr
, ';');
4024 /* Event loop callback that handles a serial event. The first byte in
4025 the serial buffer gets us here. We expect characters to arrive at
4026 a brisk pace, so we read the rest of the packet with a blocking
4030 process_serial_event (void)
4032 client_state
&cs
= get_client_state ();
4038 int new_packet_len
= -1;
4040 disable_async_io ();
4042 response_needed
= 0;
4043 packet_len
= getpkt (cs
.own_buf
);
4044 if (packet_len
<= 0)
4047 /* Force an event loop break. */
4050 response_needed
= 1;
4052 char ch
= cs
.own_buf
[0];
4056 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4059 handle_general_set (cs
.own_buf
);
4062 handle_detach (cs
.own_buf
);
4065 extended_protocol
= 1;
4066 write_ok (cs
.own_buf
);
4069 handle_status (cs
.own_buf
);
4072 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4074 require_running_or_break (cs
.own_buf
);
4076 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4078 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4079 thread_id
= null_ptid
;
4080 else if (thread_id
.is_pid ())
4082 /* The ptid represents a pid. */
4083 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4087 write_enn (cs
.own_buf
);
4091 thread_id
= thread
->id
;
4095 /* The ptid represents a lwp/tid. */
4096 if (find_thread_ptid (thread_id
) == NULL
)
4098 write_enn (cs
.own_buf
);
4103 if (cs
.own_buf
[1] == 'g')
4105 if (thread_id
== null_ptid
)
4107 /* GDB is telling us to choose any thread. Check if
4108 the currently selected thread is still valid. If
4109 it is not, select the first available. */
4110 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4112 thread
= get_first_thread ();
4113 thread_id
= thread
->id
;
4116 cs
.general_thread
= thread_id
;
4117 set_desired_thread ();
4118 gdb_assert (current_thread
!= NULL
);
4120 else if (cs
.own_buf
[1] == 'c')
4121 cs
.cont_thread
= thread_id
;
4123 write_ok (cs
.own_buf
);
4127 /* Silently ignore it so that gdb can extend the protocol
4128 without compatibility headaches. */
4129 cs
.own_buf
[0] = '\0';
4133 require_running_or_break (cs
.own_buf
);
4134 if (cs
.current_traceframe
>= 0)
4136 struct regcache
*regcache
4137 = new_register_cache (current_target_desc ());
4139 if (fetch_traceframe_registers (cs
.current_traceframe
,
4141 registers_to_string (regcache
, cs
.own_buf
);
4143 write_enn (cs
.own_buf
);
4144 free_register_cache (regcache
);
4148 struct regcache
*regcache
;
4150 if (!set_desired_thread ())
4151 write_enn (cs
.own_buf
);
4154 regcache
= get_thread_regcache (current_thread
, 1);
4155 registers_to_string (regcache
, cs
.own_buf
);
4160 require_running_or_break (cs
.own_buf
);
4161 if (cs
.current_traceframe
>= 0)
4162 write_enn (cs
.own_buf
);
4165 struct regcache
*regcache
;
4167 if (!set_desired_thread ())
4168 write_enn (cs
.own_buf
);
4171 regcache
= get_thread_regcache (current_thread
, 1);
4172 registers_from_string (regcache
, &cs
.own_buf
[1]);
4173 write_ok (cs
.own_buf
);
4179 require_running_or_break (cs
.own_buf
);
4180 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4181 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4183 write_enn (cs
.own_buf
);
4185 bin2hex (mem_buf
, cs
.own_buf
, res
);
4189 require_running_or_break (cs
.own_buf
);
4190 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4191 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4192 write_ok (cs
.own_buf
);
4194 write_enn (cs
.own_buf
);
4197 require_running_or_break (cs
.own_buf
);
4198 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4199 &mem_addr
, &len
, &mem_buf
) < 0
4200 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4201 write_enn (cs
.own_buf
);
4203 write_ok (cs
.own_buf
);
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
, 0, signal
);
4215 require_running_or_break (cs
.own_buf
);
4216 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4217 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4218 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4221 myresume (cs
.own_buf
, 1, signal
);
4224 require_running_or_break (cs
.own_buf
);
4226 myresume (cs
.own_buf
, 0, signal
);
4229 require_running_or_break (cs
.own_buf
);
4231 myresume (cs
.own_buf
, 1, signal
);
4233 case 'Z': /* insert_ ... */
4235 case 'z': /* remove_ ... */
4240 char type
= cs
.own_buf
[1];
4242 const int insert
= ch
== 'Z';
4243 const char *p
= &cs
.own_buf
[3];
4245 p
= unpack_varlen_hex (p
, &addr
);
4246 kind
= strtol (p
+ 1, &dataptr
, 16);
4250 struct gdb_breakpoint
*bp
;
4252 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4257 /* GDB may have sent us a list of *point parameters to
4258 be evaluated on the target's side. Read such list
4259 here. If we already have a list of parameters, GDB
4260 is telling us to drop that list and use this one
4262 clear_breakpoint_conditions_and_commands (bp
);
4263 const char *options
= dataptr
;
4264 process_point_options (bp
, &options
);
4268 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4271 write_ok (cs
.own_buf
);
4274 cs
.own_buf
[0] = '\0';
4276 write_enn (cs
.own_buf
);
4280 response_needed
= 0;
4281 if (!target_running ())
4282 /* The packet we received doesn't make sense - but we can't
4283 reply to it, either. */
4286 fprintf (stderr
, "Killing all inferiors\n");
4288 for_each_process (kill_inferior_callback
);
4290 /* When using the extended protocol, we wait with no program
4291 running. The traditional protocol will exit instead. */
4292 if (extended_protocol
)
4294 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4295 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4303 require_running_or_break (cs
.own_buf
);
4305 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4306 if (find_thread_ptid (thread_id
) == NULL
)
4308 write_enn (cs
.own_buf
);
4312 if (mythread_alive (thread_id
))
4313 write_ok (cs
.own_buf
);
4315 write_enn (cs
.own_buf
);
4319 response_needed
= 0;
4321 /* Restarting the inferior is only supported in the extended
4323 if (extended_protocol
)
4325 if (target_running ())
4326 for_each_process (kill_inferior_callback
);
4328 fprintf (stderr
, "GDBserver restarting\n");
4330 /* Wait till we are at 1st instruction in prog. */
4331 if (program_path
.get () != NULL
)
4333 create_inferior (program_path
.get (), program_args
);
4335 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4337 /* Stopped at the first instruction of the target
4339 cs
.general_thread
= cs
.last_ptid
;
4343 /* Something went wrong. */
4344 cs
.general_thread
= null_ptid
;
4349 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4350 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4356 /* It is a request we don't understand. Respond with an
4357 empty packet so that gdb knows that we don't support this
4359 cs
.own_buf
[0] = '\0';
4363 /* Extended (long) request. */
4364 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4368 /* It is a request we don't understand. Respond with an empty
4369 packet so that gdb knows that we don't support this
4371 cs
.own_buf
[0] = '\0';
4375 if (new_packet_len
!= -1)
4376 putpkt_binary (cs
.own_buf
, new_packet_len
);
4378 putpkt (cs
.own_buf
);
4380 response_needed
= 0;
4388 /* Event-loop callback for serial events. */
4391 handle_serial_event (int err
, gdb_client_data client_data
)
4394 debug_printf ("handling possible serial event\n");
4396 /* Really handle it. */
4397 if (process_serial_event () < 0)
4400 /* Be sure to not change the selected thread behind GDB's back.
4401 Important in the non-stop mode asynchronous protocol. */
4402 set_desired_thread ();
4407 /* Push a stop notification on the notification queue. */
4410 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4412 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4414 vstop_notif
->status
= *status
;
4415 vstop_notif
->ptid
= ptid
;
4416 /* Push Stop notification. */
4417 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4420 /* Event-loop callback for target events. */
4423 handle_target_event (int err
, gdb_client_data client_data
)
4425 client_state
&cs
= get_client_state ();
4427 debug_printf ("handling possible target event\n");
4429 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4432 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4434 if (gdb_connected () && report_no_resumed
)
4435 push_stop_notification (null_ptid
, &cs
.last_status
);
4437 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4439 int pid
= cs
.last_ptid
.pid ();
4440 struct process_info
*process
= find_process_pid (pid
);
4441 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4443 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4444 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4446 mark_breakpoints_out (process
);
4447 target_mourn_inferior (cs
.last_ptid
);
4449 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4453 /* We're reporting this thread as stopped. Update its
4454 "want-stopped" state to what the client wants, until it
4455 gets a new resume action. */
4456 current_thread
->last_resume_kind
= resume_stop
;
4457 current_thread
->last_status
= cs
.last_status
;
4462 if (!target_running ())
4464 /* The last process exited. We're done. */
4468 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4469 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4470 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4474 /* A thread stopped with a signal, but gdb isn't
4475 connected to handle it. Pass it down to the
4476 inferior, as if it wasn't being traced. */
4477 enum gdb_signal signal
;
4480 debug_printf ("GDB not connected; forwarding event %d for"
4482 (int) cs
.last_status
.kind
,
4483 target_pid_to_str (cs
.last_ptid
));
4485 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4486 signal
= cs
.last_status
.value
.sig
;
4488 signal
= GDB_SIGNAL_0
;
4489 target_continue (cs
.last_ptid
, signal
);
4493 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4496 /* Be sure to not change the selected thread behind GDB's back.
4497 Important in the non-stop mode asynchronous protocol. */
4498 set_desired_thread ();
4511 } // namespace selftests
4512 #endif /* GDB_SELF_TEST */