1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2018 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
42 #include "filenames.h"
43 #include "pathstuff.h"
45 #include "common/selftest.h"
47 #define require_running_or_return(BUF) \
48 if (!target_running ()) \
54 #define require_running_or_break(BUF) \
55 if (!target_running ()) \
61 /* String containing the current directory (what getwd would return). */
63 char *current_directory
;
65 /* The environment to pass to the inferior when creating it. */
67 static gdb_environ our_environ
;
69 /* Start the inferior using a shell. */
71 /* We always try to start the inferior using a shell. */
73 int startup_with_shell
= 1;
75 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
76 `vCont'. Note the multi-process extensions made `vCont' a
77 requirement, so `Hc pPID.TID' is pretty much undefined. So
78 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
79 resuming all threads of the process (again, `Hc' isn't used for
80 multi-process), or a specific thread ptid_t. */
83 /* The thread set with an `Hg' packet. */
84 ptid_t general_thread
;
88 static int extended_protocol
;
89 static int response_needed
;
90 static int exit_requested
;
92 /* --once: Exit after the first connection has closed. */
96 int report_fork_events
;
97 int report_vfork_events
;
98 int report_exec_events
;
99 int report_thread_events
;
101 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
102 static int report_no_resumed
;
108 /* True if the "vContSupported" feature is active. In that case, GDB
109 wants us to report whether single step is supported in the reply to
111 static int vCont_supported
;
113 /* Whether we should attempt to disable the operating system's address
114 space randomization feature before starting an inferior. */
115 int disable_randomization
= 1;
118 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
120 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
122 m_path
= std::move (path
);
124 /* Make sure we're using the absolute path of the inferior when
126 if (!contains_dir_separator (m_path
.get ()))
130 /* Check if the file is in our CWD. If it is, then we prefix
131 its name with CURRENT_DIRECTORY. Otherwise, we leave the
132 name as-is because we'll try searching for it in $PATH. */
133 if (is_regular_file (m_path
.get (), ®_file_errno
))
134 m_path
= gdb_abspath (m_path
.get ());
138 /* Return the PROGRAM_PATH. */
140 { return m_path
.get (); }
143 /* The program name, adjusted if needed. */
144 gdb::unique_xmalloc_ptr
<char> m_path
;
146 static std::vector
<char *> program_args
;
147 static std::string wrapper_argv
;
149 int pass_signals
[GDB_SIGNAL_LAST
];
150 int program_signals
[GDB_SIGNAL_LAST
];
151 int program_signals_p
;
153 /* The PID of the originally created or attached inferior. Used to
154 send signals to the process when GDB sends us an asynchronous interrupt
155 (user hitting Control-C in the client), and to wait for the child to exit
156 when no longer debugging it. */
158 unsigned long signal_pid
;
160 /* Set if you want to disable optional thread related packets support
161 in gdbserver, for the sake of testing GDB against stubs that don't
163 int disable_packet_vCont
;
164 int disable_packet_Tthread
;
165 int disable_packet_qC
;
166 int disable_packet_qfThreadInfo
;
168 /* Last status reported to GDB. */
169 struct target_waitstatus last_status
;
173 static unsigned char *mem_buf
;
175 /* A sub-class of 'struct notif_event' for stop, holding information
176 relative to a single stop reply. We keep a queue of these to
177 push to GDB in non-stop mode. */
181 struct notif_event base
;
183 /* Thread or process that got the event. */
187 struct target_waitstatus status
;
190 /* The current btrace configuration. This is gdbserver's mirror of GDB's
191 btrace configuration. */
192 static struct btrace_config current_btrace_conf
;
194 DEFINE_QUEUE_P (notif_event_p
);
196 /* Put a stop reply to the stop reply queue. */
199 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
201 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
203 new_notif
->ptid
= ptid
;
204 new_notif
->status
= *status
;
206 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
210 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
211 QUEUE_ITER (notif_event_p
) *iter
,
212 struct notif_event
*event
,
215 ptid_t filter_ptid
= *(ptid_t
*) data
;
216 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
218 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
220 if (q
->free_func
!= NULL
)
221 q
->free_func (event
);
223 QUEUE_remove_elem (notif_event_p
, q
, iter
);
232 discard_queued_stop_replies (ptid_t ptid
)
234 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
235 remove_all_on_match_ptid
, &ptid
);
239 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
241 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
243 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
246 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
249 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
250 QUEUE_ITER (notif_event_p
) *iter
,
251 struct notif_event
*event
,
254 ptid_t filter_ptid
= *(ptid_t
*) data
;
255 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
257 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
260 /* Don't resume fork children that GDB does not know about yet. */
261 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
262 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
263 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
272 in_queued_stop_replies (ptid_t ptid
)
274 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
275 in_queued_stop_replies_ptid
, &ptid
);
278 struct notif_server notif_stop
=
280 "vStopped", "Stop", NULL
, vstop_notif_reply
,
284 target_running (void)
286 return get_first_thread () != NULL
;
289 /* See common/common-inferior.h. */
294 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
297 /* See common/common-inferior.h. */
300 get_exec_file (int err
)
302 if (err
&& program_path
.get () == NULL
)
303 error (_("No executable file specified."));
305 return program_path
.get ();
317 attach_inferior (int pid
)
319 /* myattach should return -1 if attaching is unsupported,
320 0 if it succeeded, and call error() otherwise. */
322 if (myattach (pid
) != 0)
325 fprintf (stderr
, "Attached; pid = %d\n", pid
);
328 /* FIXME - It may be that we should get the SIGNAL_PID from the
329 attach function, so that it can be the main thread instead of
330 whichever we were told to attach to. */
335 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
337 /* GDB knows to ignore the first SIGSTOP after attaching to a running
338 process using the "attach" command, but this is different; it's
339 just using "target remote". Pretend it's just starting up. */
340 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
341 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
342 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
344 current_thread
->last_resume_kind
= resume_stop
;
345 current_thread
->last_status
= last_status
;
351 extern int remote_debug
;
353 /* Decode a qXfer read request. Return 0 if everything looks OK,
357 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
359 /* After the read marker and annex, qXfer looks like a
360 traditional 'm' packet. */
361 decode_m_packet (buf
, ofs
, len
);
367 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
369 /* Extract and NUL-terminate the object. */
371 while (*buf
&& *buf
!= ':')
377 /* Extract and NUL-terminate the read/write action. */
379 while (*buf
&& *buf
!= ':')
385 /* Extract and NUL-terminate the annex. */
387 while (*buf
&& *buf
!= ':')
397 /* Write the response to a successful qXfer read. Returns the
398 length of the (binary) data stored in BUF, corresponding
399 to as much of DATA/LEN as we could fit. IS_MORE controls
400 the first character of the response. */
402 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
411 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
412 &out_len
, PBUFSIZ
- 2) + 1;
415 /* Handle btrace enabling in BTS format. */
418 handle_btrace_enable_bts (struct thread_info
*thread
)
420 if (thread
->btrace
!= NULL
)
421 error (_("Btrace already enabled."));
423 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
424 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
427 /* Handle btrace enabling in Intel Processor Trace format. */
430 handle_btrace_enable_pt (struct thread_info
*thread
)
432 if (thread
->btrace
!= NULL
)
433 error (_("Btrace already enabled."));
435 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
436 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
439 /* Handle btrace disabling. */
442 handle_btrace_disable (struct thread_info
*thread
)
445 if (thread
->btrace
== NULL
)
446 error (_("Branch tracing not enabled."));
448 if (target_disable_btrace (thread
->btrace
) != 0)
449 error (_("Could not disable branch tracing."));
451 thread
->btrace
= NULL
;
454 /* Handle the "Qbtrace" packet. */
457 handle_btrace_general_set (char *own_buf
)
459 struct thread_info
*thread
;
462 if (!startswith (own_buf
, "Qbtrace:"))
465 op
= own_buf
+ strlen ("Qbtrace:");
467 if (ptid_equal (general_thread
, null_ptid
)
468 || ptid_equal (general_thread
, minus_one_ptid
))
470 strcpy (own_buf
, "E.Must select a single thread.");
474 thread
= find_thread_ptid (general_thread
);
477 strcpy (own_buf
, "E.No such thread.");
483 if (strcmp (op
, "bts") == 0)
484 handle_btrace_enable_bts (thread
);
485 else if (strcmp (op
, "pt") == 0)
486 handle_btrace_enable_pt (thread
);
487 else if (strcmp (op
, "off") == 0)
488 handle_btrace_disable (thread
);
490 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
494 CATCH (exception
, RETURN_MASK_ERROR
)
496 sprintf (own_buf
, "E.%s", exception
.message
);
503 /* Handle the "Qbtrace-conf" packet. */
506 handle_btrace_conf_general_set (char *own_buf
)
508 struct thread_info
*thread
;
511 if (!startswith (own_buf
, "Qbtrace-conf:"))
514 op
= own_buf
+ strlen ("Qbtrace-conf:");
516 if (ptid_equal (general_thread
, null_ptid
)
517 || ptid_equal (general_thread
, minus_one_ptid
))
519 strcpy (own_buf
, "E.Must select a single thread.");
523 thread
= find_thread_ptid (general_thread
);
526 strcpy (own_buf
, "E.No such thread.");
530 if (startswith (op
, "bts:size="))
536 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
537 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
539 strcpy (own_buf
, "E.Bad size value.");
543 current_btrace_conf
.bts
.size
= (unsigned int) size
;
545 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
551 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
552 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
554 strcpy (own_buf
, "E.Bad size value.");
558 current_btrace_conf
.pt
.size
= (unsigned int) size
;
562 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
570 /* Handle all of the extended 'Q' packets. */
573 handle_general_set (char *own_buf
)
575 if (startswith (own_buf
, "QPassSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QPassSignals:");
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QProgramSignals:"))
602 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
603 const char *p
= own_buf
+ strlen ("QProgramSignals:");
606 program_signals_p
= 1;
608 p
= decode_address_to_semicolon (&cursig
, p
);
609 for (i
= 0; i
< numsigs
; i
++)
613 program_signals
[i
] = 1;
615 /* Keep looping, to clear the remaining signals. */
618 p
= decode_address_to_semicolon (&cursig
, p
);
621 program_signals
[i
] = 0;
623 strcpy (own_buf
, "OK");
627 if (startswith (own_buf
, "QCatchSyscalls:"))
629 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
632 struct process_info
*process
;
634 if (!target_running () || !target_supports_catch_syscall ())
640 if (strcmp (p
, "0") == 0)
642 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
646 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
652 process
= current_process ();
653 process
->syscalls_to_catch
.clear ();
663 p
= decode_address_to_semicolon (&sysno
, p
);
664 process
->syscalls_to_catch
.push_back (sysno
);
668 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
675 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
677 our_environ
= gdb_environ::from_host_environ ();
683 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
685 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
686 /* The final form of the environment variable. FINAL_VAR will
687 hold the 'VAR=VALUE' format. */
688 std::string final_var
= hex2str (p
);
689 std::string var_name
, var_value
;
693 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
694 debug_printf (_("[Environment variable to be set: '%s']\n"),
699 size_t pos
= final_var
.find ('=');
700 if (pos
== std::string::npos
)
702 warning (_("Unexpected format for environment variable: '%s'"),
708 var_name
= final_var
.substr (0, pos
);
709 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
711 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
717 if (startswith (own_buf
, "QEnvironmentUnset:"))
719 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
720 std::string varname
= hex2str (p
);
724 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
725 debug_printf (_("[Environment variable to be unset: '%s']\n"),
730 our_environ
.unset (varname
.c_str ());
736 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
740 debug_printf ("[noack mode enabled]\n");
749 if (startswith (own_buf
, "QNonStop:"))
751 char *mode
= own_buf
+ 9;
755 if (strcmp (mode
, "0") == 0)
757 else if (strcmp (mode
, "1") == 0)
761 /* We don't know what this mode is, so complain to
763 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
769 req_str
= req
? "non-stop" : "all-stop";
770 if (start_non_stop (req
) != 0)
772 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
780 debug_printf ("[%s mode enabled]\n", req_str
);
786 if (startswith (own_buf
, "QDisableRandomization:"))
788 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
791 unpack_varlen_hex (packet
, &setting
);
792 disable_randomization
= setting
;
796 debug_printf (disable_randomization
797 ? "[address space randomization disabled]\n"
798 : "[address space randomization enabled]\n");
805 if (target_supports_tracepoints ()
806 && handle_tracepoint_general_set (own_buf
))
809 if (startswith (own_buf
, "QAgent:"))
811 char *mode
= own_buf
+ strlen ("QAgent:");
814 if (strcmp (mode
, "0") == 0)
816 else if (strcmp (mode
, "1") == 0)
820 /* We don't know what this value is, so complain to GDB. */
821 sprintf (own_buf
, "E.Unknown QAgent value");
825 /* Update the flag. */
828 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
833 if (handle_btrace_general_set (own_buf
))
836 if (handle_btrace_conf_general_set (own_buf
))
839 if (startswith (own_buf
, "QThreadEvents:"))
841 char *mode
= own_buf
+ strlen ("QThreadEvents:");
842 enum tribool req
= TRIBOOL_UNKNOWN
;
844 if (strcmp (mode
, "0") == 0)
846 else if (strcmp (mode
, "1") == 0)
850 char *mode_copy
= xstrdup (mode
);
852 /* We don't know what this mode is, so complain to GDB. */
853 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
859 report_thread_events
= (req
== TRIBOOL_TRUE
);
863 const char *req_str
= report_thread_events
? "enabled" : "disabled";
865 debug_printf ("[thread events are now %s]\n", req_str
);
872 if (startswith (own_buf
, "QStartupWithShell:"))
874 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
876 if (strcmp (value
, "1") == 0)
877 startup_with_shell
= true;
878 else if (strcmp (value
, "0") == 0)
879 startup_with_shell
= false;
883 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
890 debug_printf (_("[Inferior will %s started with shell]"),
891 startup_with_shell
? "be" : "not be");
897 if (startswith (own_buf
, "QSetWorkingDir:"))
899 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
903 std::string path
= hex2str (p
);
905 set_inferior_cwd (path
.c_str ());
908 debug_printf (_("[Set the inferior's current directory to %s]\n"),
913 /* An empty argument means that we should clear out any
914 previously set cwd for the inferior. */
915 set_inferior_cwd (NULL
);
919 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
926 /* Otherwise we didn't know what packet it was. Say we didn't
932 get_features_xml (const char *annex
)
934 const struct target_desc
*desc
= current_target_desc ();
936 /* `desc->xmltarget' defines what to return when looking for the
937 "target.xml" file. Its contents can either be verbatim XML code
938 (prefixed with a '@') or else the name of the actual XML file to
939 be used in place of "target.xml".
941 This variable is set up from the auto-generated
942 init_registers_... routine for the current target. */
944 if (strcmp (annex
, "target.xml") == 0)
946 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
956 extern const char *const xml_builtin
[][2];
959 /* Look for the annex. */
960 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
961 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
964 if (xml_builtin
[i
][0] != NULL
)
965 return xml_builtin
[i
][1];
973 monitor_show_help (void)
975 monitor_output ("The following monitor commands are supported:\n");
976 monitor_output (" set debug <0|1>\n");
977 monitor_output (" Enable general debugging messages\n");
978 monitor_output (" set debug-hw-points <0|1>\n");
979 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
980 monitor_output (" set remote-debug <0|1>\n");
981 monitor_output (" Enable remote protocol debugging messages\n");
982 monitor_output (" set debug-format option1[,option2,...]\n");
983 monitor_output (" Add additional information to debugging messages\n");
984 monitor_output (" Options: all, none");
985 monitor_output (", timestamp");
986 monitor_output ("\n");
987 monitor_output (" exit\n");
988 monitor_output (" Quit GDBserver\n");
991 /* Read trace frame or inferior memory. Returns the number of bytes
992 actually read, zero when no further transfer is possible, and -1 on
993 error. Return of a positive value smaller than LEN does not
994 indicate there's no more to be read, only the end of the transfer.
995 E.g., when GDB reads memory from a traceframe, a first request may
996 be served from a memory block that does not cover the whole request
997 length. A following request gets the rest served from either
998 another block (of the same traceframe) or from the read-only
1002 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1006 if (current_traceframe
>= 0)
1009 ULONGEST length
= len
;
1011 if (traceframe_read_mem (current_traceframe
,
1012 memaddr
, myaddr
, len
, &nbytes
))
1014 /* Data read from trace buffer, we're done. */
1017 if (!in_readonly_region (memaddr
, length
))
1019 /* Otherwise we have a valid readonly case, fall through. */
1020 /* (assume no half-trace half-real blocks for now) */
1023 res
= prepare_to_access_memory ();
1026 if (set_desired_thread ())
1027 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1030 done_accessing_memory ();
1032 return res
== 0 ? len
: -1;
1038 /* Write trace frame or inferior memory. Actually, writing to trace
1039 frames is forbidden. */
1042 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1044 if (current_traceframe
>= 0)
1050 ret
= prepare_to_access_memory ();
1053 if (set_desired_thread ())
1054 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1057 done_accessing_memory ();
1063 /* Subroutine of handle_search_memory to simplify it. */
1066 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1067 gdb_byte
*pattern
, unsigned pattern_len
,
1068 gdb_byte
*search_buf
,
1069 unsigned chunk_size
, unsigned search_buf_size
,
1070 CORE_ADDR
*found_addrp
)
1072 /* Prime the search buffer. */
1074 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1077 warning ("Unable to access %ld bytes of target "
1078 "memory at 0x%lx, halting search.",
1079 (long) search_buf_size
, (long) start_addr
);
1083 /* Perform the search.
1085 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1086 When we've scanned N bytes we copy the trailing bytes to the start and
1087 read in another N bytes. */
1089 while (search_space_len
>= pattern_len
)
1091 gdb_byte
*found_ptr
;
1092 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1096 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1099 if (found_ptr
!= NULL
)
1101 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1102 *found_addrp
= found_addr
;
1106 /* Not found in this chunk, skip to next chunk. */
1108 /* Don't let search_space_len wrap here, it's unsigned. */
1109 if (search_space_len
>= chunk_size
)
1110 search_space_len
-= chunk_size
;
1112 search_space_len
= 0;
1114 if (search_space_len
>= pattern_len
)
1116 unsigned keep_len
= search_buf_size
- chunk_size
;
1117 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1120 /* Copy the trailing part of the previous iteration to the front
1121 of the buffer for the next iteration. */
1122 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1124 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1125 ? search_space_len
- keep_len
1128 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1129 nr_to_read
) != search_buf_size
)
1131 warning ("Unable to access %ld bytes of target memory "
1132 "at 0x%lx, halting search.",
1133 (long) nr_to_read
, (long) read_addr
);
1137 start_addr
+= chunk_size
;
1146 /* Handle qSearch:memory packets. */
1149 handle_search_memory (char *own_buf
, int packet_len
)
1151 CORE_ADDR start_addr
;
1152 CORE_ADDR search_space_len
;
1154 unsigned int pattern_len
;
1155 /* NOTE: also defined in find.c testcase. */
1156 #define SEARCH_CHUNK_SIZE 16000
1157 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1158 /* Buffer to hold memory contents for searching. */
1159 gdb_byte
*search_buf
;
1160 unsigned search_buf_size
;
1162 CORE_ADDR found_addr
;
1163 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1165 pattern
= (gdb_byte
*) malloc (packet_len
);
1166 if (pattern
== NULL
)
1168 error ("Unable to allocate memory to perform the search");
1169 strcpy (own_buf
, "E00");
1172 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1173 packet_len
- cmd_name_len
,
1174 &start_addr
, &search_space_len
,
1175 pattern
, &pattern_len
) < 0)
1178 error ("Error in parsing qSearch:memory packet");
1179 strcpy (own_buf
, "E00");
1183 search_buf_size
= chunk_size
+ pattern_len
- 1;
1185 /* No point in trying to allocate a buffer larger than the search space. */
1186 if (search_space_len
< search_buf_size
)
1187 search_buf_size
= search_space_len
;
1189 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1190 if (search_buf
== NULL
)
1193 error ("Unable to allocate memory to perform the search");
1194 strcpy (own_buf
, "E00");
1198 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1199 pattern
, pattern_len
,
1200 search_buf
, chunk_size
, search_buf_size
,
1204 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1205 else if (found
== 0)
1206 strcpy (own_buf
, "0");
1208 strcpy (own_buf
, "E00");
1214 /* Handle the "D" packet. */
1217 handle_detach (char *own_buf
)
1219 require_running_or_return (own_buf
);
1226 pid
= strtol (&own_buf
[2], NULL
, 16);
1229 pid
= ptid_get_pid (current_ptid
);
1231 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1233 struct process_info
*process
= find_process_pid (pid
);
1235 if (process
== NULL
)
1237 write_enn (own_buf
);
1241 if (tracing
&& disconnected_tracing
)
1243 "Disconnected tracing in effect, "
1244 "leaving gdbserver attached to the process\n");
1246 if (any_persistent_commands ())
1248 "Persistent commands are present, "
1249 "leaving gdbserver attached to the process\n");
1251 /* Make sure we're in non-stop/async mode, so we we can both
1252 wait for an async socket accept, and handle async target
1253 events simultaneously. There's also no point either in
1254 having the target stop all threads, when we're going to
1255 pass signals down without informing GDB. */
1259 debug_printf ("Forcing non-stop mode\n");
1265 process
->gdb_detached
= 1;
1267 /* Detaching implicitly resumes all threads. */
1268 target_continue_no_signal (minus_one_ptid
);
1274 fprintf (stderr
, "Detaching from process %d\n", pid
);
1276 if (detach_inferior (pid
) != 0)
1277 write_enn (own_buf
);
1280 discard_queued_stop_replies (pid_to_ptid (pid
));
1283 if (extended_protocol
|| target_running ())
1285 /* There is still at least one inferior remaining or
1286 we are in extended mode, so don't terminate gdbserver,
1287 and instead treat this like a normal program exit. */
1288 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1289 last_status
.value
.integer
= 0;
1290 last_ptid
= pid_to_ptid (pid
);
1292 current_thread
= NULL
;
1299 /* If we are attached, then we can exit. Otherwise, we
1300 need to hang around doing nothing, until the child is
1302 join_inferior (pid
);
1308 /* Parse options to --debug-format= and "monitor set debug-format".
1309 ARG is the text after "--debug-format=" or "monitor set debug-format".
1310 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1311 This triggers calls to monitor_output.
1312 The result is NULL if all options were parsed ok, otherwise an error
1313 message which the caller must free.
1315 N.B. These commands affect all debug format settings, they are not
1316 cumulative. If a format is not specified, it is turned off.
1317 However, we don't go to extra trouble with things like
1318 "monitor set debug-format all,none,timestamp".
1319 Instead we just parse them one at a time, in order.
1321 The syntax for "monitor set debug" we support here is not identical
1322 to gdb's "set debug foo on|off" because we also use this function to
1323 parse "--debug-format=foo,bar". */
1326 parse_debug_format_options (const char *arg
, int is_monitor
)
1328 VEC (char_ptr
) *options
;
1332 /* First turn all debug format options off. */
1333 debug_timestamp
= 0;
1335 /* First remove leading spaces, for "monitor set debug-format". */
1336 while (isspace (*arg
))
1339 options
= delim_string_to_char_ptr_vec (arg
, ',');
1341 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1343 if (strcmp (option
, "all") == 0)
1345 debug_timestamp
= 1;
1347 monitor_output ("All extra debug format options enabled.\n");
1349 else if (strcmp (option
, "none") == 0)
1351 debug_timestamp
= 0;
1353 monitor_output ("All extra debug format options disabled.\n");
1355 else if (strcmp (option
, "timestamp") == 0)
1357 debug_timestamp
= 1;
1359 monitor_output ("Timestamps will be added to debug output.\n");
1361 else if (*option
== '\0')
1363 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1369 = string_printf ("Unknown debug-format argument: \"%s\"\n", option
);
1371 free_char_ptr_vec (options
);
1376 free_char_ptr_vec (options
);
1377 return std::string ();
1380 /* Handle monitor commands not handled by target-specific handlers. */
1383 handle_monitor_command (char *mon
, char *own_buf
)
1385 if (strcmp (mon
, "set debug 1") == 0)
1388 monitor_output ("Debug output enabled.\n");
1390 else if (strcmp (mon
, "set debug 0") == 0)
1393 monitor_output ("Debug output disabled.\n");
1395 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1397 show_debug_regs
= 1;
1398 monitor_output ("H/W point debugging output enabled.\n");
1400 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1402 show_debug_regs
= 0;
1403 monitor_output ("H/W point debugging output disabled.\n");
1405 else if (strcmp (mon
, "set remote-debug 1") == 0)
1408 monitor_output ("Protocol debug output enabled.\n");
1410 else if (strcmp (mon
, "set remote-debug 0") == 0)
1413 monitor_output ("Protocol debug output disabled.\n");
1415 else if (startswith (mon
, "set debug-format "))
1417 std::string error_msg
1418 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1421 if (!error_msg
.empty ())
1423 monitor_output (error_msg
.c_str ());
1424 monitor_show_help ();
1425 write_enn (own_buf
);
1428 else if (strcmp (mon
, "help") == 0)
1429 monitor_show_help ();
1430 else if (strcmp (mon
, "exit") == 0)
1434 monitor_output ("Unknown monitor command.\n\n");
1435 monitor_show_help ();
1436 write_enn (own_buf
);
1440 /* Associates a callback with each supported qXfer'able object. */
1444 /* The object this handler handles. */
1447 /* Request that the target transfer up to LEN 8-bit bytes of the
1448 target's OBJECT. The OFFSET, for a seekable object, specifies
1449 the starting point. The ANNEX can be used to provide additional
1450 data-specific information to the target.
1452 Return the number of bytes actually transfered, zero when no
1453 further transfer is possible, -1 on error, -2 when the transfer
1454 is not supported, and -3 on a verbose error message that should
1455 be preserved. Return of a positive value smaller than LEN does
1456 not indicate the end of the object, only the end of the transfer.
1458 One, and only one, of readbuf or writebuf must be non-NULL. */
1459 int (*xfer
) (const char *annex
,
1460 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1461 ULONGEST offset
, LONGEST len
);
1464 /* Handle qXfer:auxv:read. */
1467 handle_qxfer_auxv (const char *annex
,
1468 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1469 ULONGEST offset
, LONGEST len
)
1471 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1474 if (annex
[0] != '\0' || current_thread
== NULL
)
1477 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1480 /* Handle qXfer:exec-file:read. */
1483 handle_qxfer_exec_file (const char *annex
,
1484 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1485 ULONGEST offset
, LONGEST len
)
1491 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1494 if (annex
[0] == '\0')
1496 if (current_thread
== NULL
)
1499 pid
= pid_of (current_thread
);
1503 annex
= unpack_varlen_hex (annex
, &pid
);
1504 if (annex
[0] != '\0')
1511 file
= (*the_target
->pid_to_exec_file
) (pid
);
1515 total_len
= strlen (file
);
1517 if (offset
> total_len
)
1520 if (offset
+ len
> total_len
)
1521 len
= total_len
- offset
;
1523 memcpy (readbuf
, file
+ offset
, len
);
1527 /* Handle qXfer:features:read. */
1530 handle_qxfer_features (const char *annex
,
1531 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1532 ULONGEST offset
, LONGEST len
)
1534 const char *document
;
1537 if (writebuf
!= NULL
)
1540 if (!target_running ())
1543 /* Grab the correct annex. */
1544 document
= get_features_xml (annex
);
1545 if (document
== NULL
)
1548 total_len
= strlen (document
);
1550 if (offset
> total_len
)
1553 if (offset
+ len
> total_len
)
1554 len
= total_len
- offset
;
1556 memcpy (readbuf
, document
+ offset
, len
);
1560 /* Handle qXfer:libraries:read. */
1563 handle_qxfer_libraries (const char *annex
,
1564 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1565 ULONGEST offset
, LONGEST len
)
1567 if (writebuf
!= NULL
)
1570 if (annex
[0] != '\0' || current_thread
== NULL
)
1573 std::string document
= "<library-list version=\"1.0\">\n";
1575 for (const dll_info
&dll
: all_dlls
)
1576 document
+= string_printf
1577 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1578 dll
.name
.c_str (), (long) dll
.base_addr
);
1580 document
+= "</library-list>\n";
1582 if (offset
> document
.length ())
1585 if (offset
+ len
> document
.length ())
1586 len
= document
.length () - offset
;
1588 memcpy (readbuf
, &document
[offset
], len
);
1593 /* Handle qXfer:libraries-svr4:read. */
1596 handle_qxfer_libraries_svr4 (const char *annex
,
1597 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1598 ULONGEST offset
, LONGEST len
)
1600 if (writebuf
!= NULL
)
1603 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1606 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1609 /* Handle qXfer:osadata:read. */
1612 handle_qxfer_osdata (const char *annex
,
1613 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1614 ULONGEST offset
, LONGEST len
)
1616 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1619 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1622 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1625 handle_qxfer_siginfo (const char *annex
,
1626 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1627 ULONGEST offset
, LONGEST len
)
1629 if (the_target
->qxfer_siginfo
== NULL
)
1632 if (annex
[0] != '\0' || current_thread
== NULL
)
1635 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1638 /* Handle qXfer:spu:read and qXfer:spu:write. */
1641 handle_qxfer_spu (const char *annex
,
1642 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1643 ULONGEST offset
, LONGEST len
)
1645 if (the_target
->qxfer_spu
== NULL
)
1648 if (current_thread
== NULL
)
1651 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1654 /* Handle qXfer:statictrace:read. */
1657 handle_qxfer_statictrace (const char *annex
,
1658 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1659 ULONGEST offset
, LONGEST len
)
1663 if (writebuf
!= NULL
)
1666 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1669 if (traceframe_read_sdata (current_traceframe
, offset
,
1670 readbuf
, len
, &nbytes
))
1675 /* Helper for handle_qxfer_threads_proper.
1676 Emit the XML to describe the thread of INF. */
1679 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1681 ptid_t ptid
= ptid_of (thread
);
1683 int core
= target_core_of_thread (ptid
);
1685 const char *name
= target_thread_name (ptid
);
1688 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1690 write_ptid (ptid_s
, ptid
);
1692 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1696 sprintf (core_s
, "%d", core
);
1697 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1701 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1705 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1706 bin2hex (handle
, handle_s
, handle_len
);
1707 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1710 buffer_xml_printf (buffer
, "/>\n");
1713 /* Helper for handle_qxfer_threads. */
1716 handle_qxfer_threads_proper (struct buffer
*buffer
)
1718 buffer_grow_str (buffer
, "<threads>\n");
1720 for_each_thread ([&] (thread_info
*thread
)
1722 handle_qxfer_threads_worker (thread
, buffer
);
1725 buffer_grow_str0 (buffer
, "</threads>\n");
1728 /* Handle qXfer:threads:read. */
1731 handle_qxfer_threads (const char *annex
,
1732 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1733 ULONGEST offset
, LONGEST len
)
1735 static char *result
= 0;
1736 static unsigned int result_length
= 0;
1738 if (writebuf
!= NULL
)
1741 if (annex
[0] != '\0')
1746 struct buffer buffer
;
1747 /* When asked for data at offset 0, generate everything and store into
1748 'result'. Successive reads will be served off 'result'. */
1752 buffer_init (&buffer
);
1754 handle_qxfer_threads_proper (&buffer
);
1756 result
= buffer_finish (&buffer
);
1757 result_length
= strlen (result
);
1758 buffer_free (&buffer
);
1761 if (offset
>= result_length
)
1763 /* We're out of data. */
1770 if (len
> result_length
- offset
)
1771 len
= result_length
- offset
;
1773 memcpy (readbuf
, result
+ offset
, len
);
1778 /* Handle qXfer:traceframe-info:read. */
1781 handle_qxfer_traceframe_info (const char *annex
,
1782 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1783 ULONGEST offset
, LONGEST len
)
1785 static char *result
= 0;
1786 static unsigned int result_length
= 0;
1788 if (writebuf
!= NULL
)
1791 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1796 struct buffer buffer
;
1798 /* When asked for data at offset 0, generate everything and
1799 store into 'result'. Successive reads will be served off
1803 buffer_init (&buffer
);
1805 traceframe_read_info (current_traceframe
, &buffer
);
1807 result
= buffer_finish (&buffer
);
1808 result_length
= strlen (result
);
1809 buffer_free (&buffer
);
1812 if (offset
>= result_length
)
1814 /* We're out of data. */
1821 if (len
> result_length
- offset
)
1822 len
= result_length
- offset
;
1824 memcpy (readbuf
, result
+ offset
, len
);
1828 /* Handle qXfer:fdpic:read. */
1831 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1832 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1834 if (the_target
->read_loadmap
== NULL
)
1837 if (current_thread
== NULL
)
1840 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1843 /* Handle qXfer:btrace:read. */
1846 handle_qxfer_btrace (const char *annex
,
1847 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1848 ULONGEST offset
, LONGEST len
)
1850 static struct buffer cache
;
1851 struct thread_info
*thread
;
1852 enum btrace_read_type type
;
1855 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1858 if (ptid_equal (general_thread
, null_ptid
)
1859 || ptid_equal (general_thread
, minus_one_ptid
))
1861 strcpy (own_buf
, "E.Must select a single thread.");
1865 thread
= find_thread_ptid (general_thread
);
1868 strcpy (own_buf
, "E.No such thread.");
1872 if (thread
->btrace
== NULL
)
1874 strcpy (own_buf
, "E.Btrace not enabled.");
1878 if (strcmp (annex
, "all") == 0)
1879 type
= BTRACE_READ_ALL
;
1880 else if (strcmp (annex
, "new") == 0)
1881 type
= BTRACE_READ_NEW
;
1882 else if (strcmp (annex
, "delta") == 0)
1883 type
= BTRACE_READ_DELTA
;
1886 strcpy (own_buf
, "E.Bad annex.");
1892 buffer_free (&cache
);
1894 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1897 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1901 else if (offset
> cache
.used_size
)
1903 buffer_free (&cache
);
1907 if (len
> cache
.used_size
- offset
)
1908 len
= cache
.used_size
- offset
;
1910 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1915 /* Handle qXfer:btrace-conf:read. */
1918 handle_qxfer_btrace_conf (const char *annex
,
1919 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1920 ULONGEST offset
, LONGEST len
)
1922 static struct buffer cache
;
1923 struct thread_info
*thread
;
1926 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1929 if (annex
[0] != '\0')
1932 if (ptid_equal (general_thread
, null_ptid
)
1933 || ptid_equal (general_thread
, minus_one_ptid
))
1935 strcpy (own_buf
, "E.Must select a single thread.");
1939 thread
= find_thread_ptid (general_thread
);
1942 strcpy (own_buf
, "E.No such thread.");
1946 if (thread
->btrace
== NULL
)
1948 strcpy (own_buf
, "E.Btrace not enabled.");
1954 buffer_free (&cache
);
1956 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1959 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
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 static std::list
<thread_info
*>::const_iterator thread_iter
;
2157 /* Reply the current thread id. */
2158 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2161 require_running_or_return (own_buf
);
2163 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2164 ptid
= general_thread
;
2167 thread_iter
= all_threads
.begin ();
2168 ptid
= (*thread_iter
)->id
;
2171 sprintf (own_buf
, "QC");
2173 write_ptid (own_buf
, ptid
);
2177 if (strcmp ("qSymbol::", own_buf
) == 0)
2179 struct thread_info
*save_thread
= current_thread
;
2181 /* For qSymbol, GDB only changes the current thread if the
2182 previous current thread was of a different process. So if
2183 the previous thread is gone, we need to pick another one of
2184 the same process. This can happen e.g., if we followed an
2185 exec in a non-leader thread. */
2186 if (current_thread
== NULL
)
2189 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2191 /* Just in case, if we didn't find a thread, then bail out
2192 instead of crashing. */
2193 if (current_thread
== NULL
)
2195 write_enn (own_buf
);
2196 current_thread
= save_thread
;
2201 /* GDB is suggesting new symbols have been loaded. This may
2202 mean a new shared library has been detected as loaded, so
2203 take the opportunity to check if breakpoints we think are
2204 inserted, still are. Note that it isn't guaranteed that
2205 we'll see this when a shared library is loaded, and nor will
2206 we see this for unloads (although breakpoints in unloaded
2207 libraries shouldn't trigger), as GDB may not find symbols for
2208 the library at all. We also re-validate breakpoints when we
2209 see a second GDB breakpoint for the same address, and or when
2210 we access breakpoint shadows. */
2211 validate_breakpoints ();
2213 if (target_supports_tracepoints ())
2214 tracepoint_look_up_symbols ();
2216 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2217 (*the_target
->look_up_symbols
) ();
2219 current_thread
= save_thread
;
2221 strcpy (own_buf
, "OK");
2225 if (!disable_packet_qfThreadInfo
)
2227 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2229 require_running_or_return (own_buf
);
2230 thread_iter
= all_threads
.begin ();
2233 ptid_t ptid
= (*thread_iter
)->id
;
2234 write_ptid (own_buf
, ptid
);
2239 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2241 require_running_or_return (own_buf
);
2242 if (thread_iter
!= all_threads
.end ())
2245 ptid_t ptid
= (*thread_iter
)->id
;
2246 write_ptid (own_buf
, ptid
);
2252 sprintf (own_buf
, "l");
2258 if (the_target
->read_offsets
!= NULL
2259 && strcmp ("qOffsets", own_buf
) == 0)
2261 CORE_ADDR text
, data
;
2263 require_running_or_return (own_buf
);
2264 if (the_target
->read_offsets (&text
, &data
))
2265 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2266 (long)text
, (long)data
, (long)data
);
2268 write_enn (own_buf
);
2273 /* Protocol features query. */
2274 if (startswith (own_buf
, "qSupported")
2275 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2277 char *p
= &own_buf
[10];
2278 int gdb_supports_qRelocInsn
= 0;
2280 /* Process each feature being provided by GDB. The first
2281 feature will follow a ':', and latter features will follow
2285 char **qsupported
= NULL
;
2290 /* Two passes, to avoid nested strtok calls in
2291 target_process_qsupported. */
2292 for (p
= strtok (p
+ 1, ";");
2294 p
= strtok (NULL
, ";"))
2297 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2298 qsupported
[count
- 1] = xstrdup (p
);
2301 for (i
= 0; i
< count
; i
++)
2304 if (strcmp (p
, "multiprocess+") == 0)
2306 /* GDB supports and wants multi-process support if
2308 if (target_supports_multi_process ())
2311 else if (strcmp (p
, "qRelocInsn+") == 0)
2313 /* GDB supports relocate instruction requests. */
2314 gdb_supports_qRelocInsn
= 1;
2316 else if (strcmp (p
, "swbreak+") == 0)
2318 /* GDB wants us to report whether a trap is caused
2319 by a software breakpoint and for us to handle PC
2320 adjustment if necessary on this target. */
2321 if (target_supports_stopped_by_sw_breakpoint ())
2322 swbreak_feature
= 1;
2324 else if (strcmp (p
, "hwbreak+") == 0)
2326 /* GDB wants us to report whether a trap is caused
2327 by a hardware breakpoint. */
2328 if (target_supports_stopped_by_hw_breakpoint ())
2329 hwbreak_feature
= 1;
2331 else if (strcmp (p
, "fork-events+") == 0)
2333 /* GDB supports and wants fork events if possible. */
2334 if (target_supports_fork_events ())
2335 report_fork_events
= 1;
2337 else if (strcmp (p
, "vfork-events+") == 0)
2339 /* GDB supports and wants vfork events if possible. */
2340 if (target_supports_vfork_events ())
2341 report_vfork_events
= 1;
2343 else if (strcmp (p
, "exec-events+") == 0)
2345 /* GDB supports and wants exec events if possible. */
2346 if (target_supports_exec_events ())
2347 report_exec_events
= 1;
2349 else if (strcmp (p
, "vContSupported+") == 0)
2350 vCont_supported
= 1;
2351 else if (strcmp (p
, "QThreadEvents+") == 0)
2353 else if (strcmp (p
, "no-resumed+") == 0)
2355 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2357 report_no_resumed
= 1;
2361 /* Move the unknown features all together. */
2362 qsupported
[i
] = NULL
;
2363 qsupported
[unknown
] = p
;
2368 /* Give the target backend a chance to process the unknown
2370 target_process_qsupported (qsupported
, unknown
);
2372 for (i
= 0; i
< count
; i
++)
2373 free (qsupported
[i
]);
2378 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2379 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2380 "QEnvironmentReset+;QEnvironmentUnset+;"
2384 if (target_supports_catch_syscall ())
2385 strcat (own_buf
, ";QCatchSyscalls+");
2387 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2388 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2389 ";augmented-libraries-svr4-read+");
2392 /* We do not have any hook to indicate whether the non-SVR4 target
2393 backend supports qXfer:libraries:read, so always report it. */
2394 strcat (own_buf
, ";qXfer:libraries:read+");
2397 if (the_target
->read_auxv
!= NULL
)
2398 strcat (own_buf
, ";qXfer:auxv:read+");
2400 if (the_target
->qxfer_spu
!= NULL
)
2401 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2403 if (the_target
->qxfer_siginfo
!= NULL
)
2404 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2406 if (the_target
->read_loadmap
!= NULL
)
2407 strcat (own_buf
, ";qXfer:fdpic:read+");
2409 /* We always report qXfer:features:read, as targets may
2410 install XML files on a subsequent call to arch_setup.
2411 If we reported to GDB on startup that we don't support
2412 qXfer:feature:read at all, we will never be re-queried. */
2413 strcat (own_buf
, ";qXfer:features:read+");
2415 if (transport_is_reliable
)
2416 strcat (own_buf
, ";QStartNoAckMode+");
2418 if (the_target
->qxfer_osdata
!= NULL
)
2419 strcat (own_buf
, ";qXfer:osdata:read+");
2421 if (target_supports_multi_process ())
2422 strcat (own_buf
, ";multiprocess+");
2424 if (target_supports_fork_events ())
2425 strcat (own_buf
, ";fork-events+");
2427 if (target_supports_vfork_events ())
2428 strcat (own_buf
, ";vfork-events+");
2430 if (target_supports_exec_events ())
2431 strcat (own_buf
, ";exec-events+");
2433 if (target_supports_non_stop ())
2434 strcat (own_buf
, ";QNonStop+");
2436 if (target_supports_disable_randomization ())
2437 strcat (own_buf
, ";QDisableRandomization+");
2439 strcat (own_buf
, ";qXfer:threads:read+");
2441 if (target_supports_tracepoints ())
2443 strcat (own_buf
, ";ConditionalTracepoints+");
2444 strcat (own_buf
, ";TraceStateVariables+");
2445 strcat (own_buf
, ";TracepointSource+");
2446 strcat (own_buf
, ";DisconnectedTracing+");
2447 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2448 strcat (own_buf
, ";FastTracepoints+");
2449 strcat (own_buf
, ";StaticTracepoints+");
2450 strcat (own_buf
, ";InstallInTrace+");
2451 strcat (own_buf
, ";qXfer:statictrace:read+");
2452 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2453 strcat (own_buf
, ";EnableDisableTracepoints+");
2454 strcat (own_buf
, ";QTBuffer:size+");
2455 strcat (own_buf
, ";tracenz+");
2458 if (target_supports_hardware_single_step ()
2459 || target_supports_software_single_step () )
2461 strcat (own_buf
, ";ConditionalBreakpoints+");
2463 strcat (own_buf
, ";BreakpointCommands+");
2465 if (target_supports_agent ())
2466 strcat (own_buf
, ";QAgent+");
2468 supported_btrace_packets (own_buf
);
2470 if (target_supports_stopped_by_sw_breakpoint ())
2471 strcat (own_buf
, ";swbreak+");
2473 if (target_supports_stopped_by_hw_breakpoint ())
2474 strcat (own_buf
, ";hwbreak+");
2476 if (the_target
->pid_to_exec_file
!= NULL
)
2477 strcat (own_buf
, ";qXfer:exec-file:read+");
2479 strcat (own_buf
, ";vContSupported+");
2481 strcat (own_buf
, ";QThreadEvents+");
2483 strcat (own_buf
, ";no-resumed+");
2485 /* Reinitialize components as needed for the new connection. */
2486 hostio_handle_new_gdb_connection ();
2487 target_handle_new_gdb_connection ();
2492 /* Thread-local storage support. */
2493 if (the_target
->get_tls_address
!= NULL
2494 && startswith (own_buf
, "qGetTLSAddr:"))
2496 char *p
= own_buf
+ 12;
2497 CORE_ADDR parts
[2], address
= 0;
2499 ptid_t ptid
= null_ptid
;
2501 require_running_or_return (own_buf
);
2503 for (i
= 0; i
< 3; i
++)
2511 p2
= strchr (p
, ',');
2524 ptid
= read_ptid (p
, NULL
);
2526 decode_address (&parts
[i
- 1], p
, len
);
2530 if (p
!= NULL
|| i
< 3)
2534 struct thread_info
*thread
= find_thread_ptid (ptid
);
2539 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2545 strcpy (own_buf
, paddress(address
));
2550 write_enn (own_buf
);
2554 /* Otherwise, pretend we do not understand this packet. */
2557 /* Windows OS Thread Information Block address support. */
2558 if (the_target
->get_tib_address
!= NULL
2559 && startswith (own_buf
, "qGetTIBAddr:"))
2564 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2566 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2569 strcpy (own_buf
, paddress(tlb
));
2574 write_enn (own_buf
);
2580 /* Handle "monitor" commands. */
2581 if (startswith (own_buf
, "qRcmd,"))
2583 char *mon
= (char *) malloc (PBUFSIZ
);
2584 int len
= strlen (own_buf
+ 6);
2588 write_enn (own_buf
);
2593 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2595 write_enn (own_buf
);
2599 mon
[len
/ 2] = '\0';
2603 if (the_target
->handle_monitor_command
== NULL
2604 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2605 /* Default processing. */
2606 handle_monitor_command (mon
, own_buf
);
2612 if (startswith (own_buf
, "qSearch:memory:"))
2614 require_running_or_return (own_buf
);
2615 handle_search_memory (own_buf
, packet_len
);
2619 if (strcmp (own_buf
, "qAttached") == 0
2620 || startswith (own_buf
, "qAttached:"))
2622 struct process_info
*process
;
2624 if (own_buf
[sizeof ("qAttached") - 1])
2626 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2627 process
= find_process_pid (pid
);
2631 require_running_or_return (own_buf
);
2632 process
= current_process ();
2635 if (process
== NULL
)
2637 write_enn (own_buf
);
2641 strcpy (own_buf
, process
->attached
? "1" : "0");
2645 if (startswith (own_buf
, "qCRC:"))
2647 /* CRC check (compare-section). */
2651 unsigned long long crc
;
2653 require_running_or_return (own_buf
);
2654 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2655 if (*comma
++ != ',')
2657 write_enn (own_buf
);
2660 len
= strtoul (comma
, NULL
, 16);
2661 crc
= crc32 (base
, len
, 0xffffffff);
2662 /* Check for memory failure. */
2663 if (crc
== (unsigned long long) -1)
2665 write_enn (own_buf
);
2668 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2672 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2675 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2678 /* Otherwise we didn't know what packet it was. Say we didn't
2683 static void gdb_wants_all_threads_stopped (void);
2684 static void resume (struct thread_resume
*actions
, size_t n
);
2686 /* The callback that is passed to visit_actioned_threads. */
2687 typedef int (visit_actioned_threads_callback_ftype
)
2688 (const struct thread_resume
*, struct thread_info
*);
2690 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2691 true if CALLBACK returns true. Returns false if no matching thread
2692 is found or CALLBACK results false.
2693 Note: This function is itself a callback for find_thread. */
2696 visit_actioned_threads (thread_info
*thread
,
2697 const struct thread_resume
*actions
,
2699 visit_actioned_threads_callback_ftype
*callback
)
2701 for (size_t i
= 0; i
< num_actions
; i
++)
2703 const struct thread_resume
*action
= &actions
[i
];
2705 if (ptid_equal (action
->thread
, minus_one_ptid
)
2706 || ptid_equal (action
->thread
, thread
->id
)
2707 || ((ptid_get_pid (action
->thread
)
2708 == thread
->id
.pid ())
2709 && ptid_get_lwp (action
->thread
) == -1))
2711 if ((*callback
) (action
, thread
))
2719 /* Callback for visit_actioned_threads. If the thread has a pending
2720 status to report, report it now. */
2723 handle_pending_status (const struct thread_resume
*resumption
,
2724 struct thread_info
*thread
)
2726 if (thread
->status_pending_p
)
2728 thread
->status_pending_p
= 0;
2730 last_status
= thread
->last_status
;
2731 last_ptid
= thread
->id
;
2732 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2738 /* Parse vCont packets. */
2740 handle_v_cont (char *own_buf
)
2744 struct thread_resume
*resume_info
;
2745 struct thread_resume default_action
{ null_ptid
};
2747 /* Count the number of semicolons in the packet. There should be one
2748 for every action. */
2754 p
= strchr (p
, ';');
2757 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2758 if (resume_info
== NULL
)
2766 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2768 if (p
[0] == 's' || p
[0] == 'S')
2769 resume_info
[i
].kind
= resume_step
;
2770 else if (p
[0] == 'r')
2771 resume_info
[i
].kind
= resume_step
;
2772 else if (p
[0] == 'c' || p
[0] == 'C')
2773 resume_info
[i
].kind
= resume_continue
;
2774 else if (p
[0] == 't')
2775 resume_info
[i
].kind
= resume_stop
;
2779 if (p
[0] == 'S' || p
[0] == 'C')
2782 int sig
= strtol (p
+ 1, &q
, 16);
2787 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2789 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2791 else if (p
[0] == 'r')
2795 p
= unpack_varlen_hex (p
+ 1, &addr
);
2796 resume_info
[i
].step_range_start
= addr
;
2801 p
= unpack_varlen_hex (p
+ 1, &addr
);
2802 resume_info
[i
].step_range_end
= addr
;
2811 resume_info
[i
].thread
= minus_one_ptid
;
2812 default_action
= resume_info
[i
];
2814 /* Note: we don't increment i here, we'll overwrite this entry
2815 the next time through. */
2817 else if (p
[0] == ':')
2820 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2825 if (p
[0] != ';' && p
[0] != 0)
2828 resume_info
[i
].thread
= ptid
;
2835 resume_info
[i
] = default_action
;
2837 resume (resume_info
, n
);
2842 write_enn (own_buf
);
2847 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2850 resume (struct thread_resume
*actions
, size_t num_actions
)
2854 /* Check if among the threads that GDB wants actioned, there's
2855 one with a pending status to report. If so, skip actually
2856 resuming/stopping and report the pending event
2859 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2861 return visit_actioned_threads (thread
, actions
, num_actions
,
2862 handle_pending_status
);
2865 if (thread_with_status
!= NULL
)
2871 (*the_target
->resume
) (actions
, num_actions
);
2877 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2879 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2880 && !report_no_resumed
)
2882 /* The client does not support this stop reply. At least
2884 sprintf (own_buf
, "E.No unwaited-for children left.");
2885 disable_async_io ();
2889 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2890 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2891 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2892 current_thread
->last_status
= last_status
;
2894 /* From the client's perspective, all-stop mode always stops all
2895 threads implicitly (and the target backend has already done
2896 so by now). Tag all threads as "want-stopped", so we don't
2897 resume them implicitly without the client telling us to. */
2898 gdb_wants_all_threads_stopped ();
2899 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2900 disable_async_io ();
2902 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2903 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2904 target_mourn_inferior (last_ptid
);
2908 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2910 handle_v_attach (char *own_buf
)
2914 pid
= strtol (own_buf
+ 8, NULL
, 16);
2915 if (pid
!= 0 && attach_inferior (pid
) == 0)
2917 /* Don't report shared library events after attaching, even if
2918 some libraries are preloaded. GDB will always poll the
2919 library list. Avoids the "stopped by shared library event"
2920 notice on the GDB side. */
2925 /* In non-stop, we don't send a resume reply. Stop events
2926 will follow up using the normal notification
2931 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2937 write_enn (own_buf
);
2942 /* Run a new program. Return 1 if successful, 0 if failure. */
2944 handle_v_run (char *own_buf
)
2947 std::vector
<char *> new_argv
;
2948 char *new_program_name
= NULL
;
2952 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2958 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2960 next_p
= strchr (p
, ';');
2962 next_p
= p
+ strlen (p
);
2964 if (i
== 0 && p
== next_p
)
2966 /* No program specified. */
2967 new_program_name
= NULL
;
2969 else if (p
== next_p
)
2971 /* Empty argument. */
2972 new_argv
.push_back (xstrdup ("''"));
2976 size_t len
= (next_p
- p
) / 2;
2977 /* ARG is the unquoted argument received via the RSP. */
2978 char *arg
= (char *) xmalloc (len
+ 1);
2979 /* FULL_ARGS will contain the quoted version of ARG. */
2980 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2981 /* These are pointers used to navigate the strings above. */
2982 char *tmp_arg
= arg
;
2983 char *tmp_full_arg
= full_arg
;
2986 hex2bin (p
, (gdb_byte
*) arg
, len
);
2989 while (*tmp_arg
!= '\0')
2995 *tmp_full_arg
= '\'';
3001 /* Quote single quote. */
3002 *tmp_full_arg
= '\\';
3010 *tmp_full_arg
= *tmp_arg
;
3016 *tmp_full_arg
++ = '\'';
3018 /* Finish FULL_ARG and push it into the vector containing
3020 *tmp_full_arg
= '\0';
3022 new_program_name
= full_arg
;
3024 new_argv
.push_back (full_arg
);
3030 new_argv
.push_back (NULL
);
3032 if (new_program_name
== NULL
)
3034 /* GDB didn't specify a program to run. Use the program from the
3035 last run with the new argument list. */
3036 if (program_path
.get () == NULL
)
3038 write_enn (own_buf
);
3039 free_vector_argv (new_argv
);
3044 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3046 /* Free the old argv and install the new one. */
3047 free_vector_argv (program_args
);
3048 program_args
= new_argv
;
3050 create_inferior (program_path
.get (), program_args
);
3052 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3054 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3056 /* In non-stop, sending a resume reply doesn't set the general
3057 thread, but GDB assumes a vRun sets it (this is so GDB can
3058 query which is the main thread of the new inferior. */
3060 general_thread
= last_ptid
;
3066 write_enn (own_buf
);
3071 /* Kill process. Return 1 if successful, 0 if failure. */
3073 handle_v_kill (char *own_buf
)
3076 char *p
= &own_buf
[6];
3078 pid
= strtol (p
, NULL
, 16);
3081 if (pid
!= 0 && kill_inferior (pid
) == 0)
3083 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3084 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3085 last_ptid
= pid_to_ptid (pid
);
3086 discard_queued_stop_replies (last_ptid
);
3092 write_enn (own_buf
);
3097 /* Handle all of the extended 'v' packets. */
3099 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3101 if (!disable_packet_vCont
)
3103 if (strcmp (own_buf
, "vCtrlC") == 0)
3105 (*the_target
->request_interrupt
) ();
3110 if (startswith (own_buf
, "vCont;"))
3112 handle_v_cont (own_buf
);
3116 if (startswith (own_buf
, "vCont?"))
3118 strcpy (own_buf
, "vCont;c;C;t");
3120 if (target_supports_hardware_single_step ()
3121 || target_supports_software_single_step ()
3122 || !vCont_supported
)
3124 /* If target supports single step either by hardware or by
3125 software, add actions s and S to the list of supported
3126 actions. On the other hand, if GDB doesn't request the
3127 supported vCont actions in qSupported packet, add s and
3128 S to the list too. */
3129 own_buf
= own_buf
+ strlen (own_buf
);
3130 strcpy (own_buf
, ";s;S");
3133 if (target_supports_range_stepping ())
3135 own_buf
= own_buf
+ strlen (own_buf
);
3136 strcpy (own_buf
, ";r");
3142 if (startswith (own_buf
, "vFile:")
3143 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3146 if (startswith (own_buf
, "vAttach;"))
3148 if ((!extended_protocol
|| !multi_process
) && target_running ())
3150 fprintf (stderr
, "Already debugging a process\n");
3151 write_enn (own_buf
);
3154 handle_v_attach (own_buf
);
3158 if (startswith (own_buf
, "vRun;"))
3160 if ((!extended_protocol
|| !multi_process
) && target_running ())
3162 fprintf (stderr
, "Already debugging a process\n");
3163 write_enn (own_buf
);
3166 handle_v_run (own_buf
);
3170 if (startswith (own_buf
, "vKill;"))
3172 if (!target_running ())
3174 fprintf (stderr
, "No process to kill\n");
3175 write_enn (own_buf
);
3178 handle_v_kill (own_buf
);
3182 if (handle_notif_ack (own_buf
, packet_len
))
3185 /* Otherwise we didn't know what packet it was. Say we didn't
3191 /* Resume thread and wait for another event. In non-stop mode,
3192 don't really wait here, but return immediatelly to the event
3195 myresume (char *own_buf
, int step
, int sig
)
3197 struct thread_resume resume_info
[2];
3199 int valid_cont_thread
;
3201 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3202 && !ptid_equal (cont_thread
, minus_one_ptid
));
3204 if (step
|| sig
|| valid_cont_thread
)
3206 resume_info
[0].thread
= current_ptid
;
3208 resume_info
[0].kind
= resume_step
;
3210 resume_info
[0].kind
= resume_continue
;
3211 resume_info
[0].sig
= sig
;
3215 if (!valid_cont_thread
)
3217 resume_info
[n
].thread
= minus_one_ptid
;
3218 resume_info
[n
].kind
= resume_continue
;
3219 resume_info
[n
].sig
= 0;
3223 resume (resume_info
, n
);
3226 /* Callback for for_each_thread. Make a new stop reply for each
3230 queue_stop_reply_callback (thread_info
*thread
)
3232 /* For now, assume targets that don't have this callback also don't
3233 manage the thread's last_status field. */
3234 if (the_target
->thread_stopped
== NULL
)
3236 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3238 new_notif
->ptid
= thread
->id
;
3239 new_notif
->status
= thread
->last_status
;
3240 /* Pass the last stop reply back to GDB, but don't notify
3242 notif_event_enque (¬if_stop
,
3243 (struct notif_event
*) new_notif
);
3247 if (thread_stopped (thread
))
3251 std::string status_string
3252 = target_waitstatus_to_string (&thread
->last_status
);
3254 debug_printf ("Reporting thread %s as already stopped with %s\n",
3255 target_pid_to_str (thread
->id
),
3256 status_string
.c_str ());
3259 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3261 /* Pass the last stop reply back to GDB, but don't notify
3263 queue_stop_reply (thread
->id
, &thread
->last_status
);
3268 /* Set this inferior threads's state as "want-stopped". We won't
3269 resume this thread until the client gives us another action for
3273 gdb_wants_thread_stopped (thread_info
*thread
)
3275 thread
->last_resume_kind
= resume_stop
;
3277 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3279 /* Most threads are stopped implicitly (all-stop); tag that with
3281 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3282 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3286 /* Set all threads' states as "want-stopped". */
3289 gdb_wants_all_threads_stopped (void)
3291 for_each_thread (gdb_wants_thread_stopped
);
3294 /* Callback for for_each_thread. If the thread is stopped with an
3295 interesting event, mark it as having a pending event. */
3298 set_pending_status_callback (thread_info
*thread
)
3300 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3301 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3302 /* A breakpoint, watchpoint or finished step from a previous
3303 GDB run isn't considered interesting for a new GDB run.
3304 If we left those pending, the new GDB could consider them
3305 random SIGTRAPs. This leaves out real async traps. We'd
3306 have to peek into the (target-specific) siginfo to
3307 distinguish those. */
3308 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3309 thread
->status_pending_p
= 1;
3312 /* Status handler for the '?' packet. */
3315 handle_status (char *own_buf
)
3317 /* GDB is connected, don't forward events to the target anymore. */
3318 for_each_process ([] (process_info
*process
) {
3319 process
->gdb_detached
= 0;
3322 /* In non-stop mode, we must send a stop reply for each stopped
3323 thread. In all-stop mode, just send one for the first stopped
3328 for_each_thread (queue_stop_reply_callback
);
3330 /* The first is sent immediatly. OK is sent if there is no
3331 stopped thread, which is the same handling of the vStopped
3332 packet (by design). */
3333 notif_write_event (¬if_stop
, own_buf
);
3337 thread_info
*thread
= NULL
;
3340 stabilize_threads ();
3341 gdb_wants_all_threads_stopped ();
3343 /* We can only report one status, but we might be coming out of
3344 non-stop -- if more than one thread is stopped with
3345 interesting events, leave events for the threads we're not
3346 reporting now pending. They'll be reported the next time the
3347 threads are resumed. Start by marking all interesting events
3349 for_each_thread (set_pending_status_callback
);
3351 /* Prefer the last thread that reported an event to GDB (even if
3352 that was a GDB_SIGNAL_TRAP). */
3353 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3354 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3355 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3356 thread
= find_thread_ptid (last_ptid
);
3358 /* If the last event thread is not found for some reason, look
3359 for some other thread that might have an event to report. */
3361 thread
= find_thread ([] (thread_info
*thread
)
3363 return thread
->status_pending_p
;
3366 /* If we're still out of luck, simply pick the first thread in
3369 thread
= get_first_thread ();
3373 struct thread_info
*tp
= (struct thread_info
*) thread
;
3375 /* We're reporting this event, so it's no longer
3377 tp
->status_pending_p
= 0;
3379 /* GDB assumes the current thread is the thread we're
3380 reporting the status for. */
3381 general_thread
= thread
->id
;
3382 set_desired_thread ();
3384 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3385 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3388 strcpy (own_buf
, "W00");
3393 gdbserver_version (void)
3395 printf ("GNU gdbserver %s%s\n"
3396 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3397 "gdbserver is free software, covered by the "
3398 "GNU General Public License.\n"
3399 "This gdbserver was configured as \"%s\"\n",
3400 PKGVERSION
, version
, host_name
);
3404 gdbserver_usage (FILE *stream
)
3406 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3407 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3408 "\tgdbserver [OPTIONS] --multi COMM\n"
3410 "COMM may either be a tty device (for serial debugging),\n"
3411 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3412 "stdin/stdout of gdbserver.\n"
3413 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3414 "PID is the process ID to attach to, when --attach is specified.\n"
3416 "Operating modes:\n"
3418 " --attach Attach to running process PID.\n"
3419 " --multi Start server without a specific program, and\n"
3420 " only quit when explicitly commanded.\n"
3421 " --once Exit after the first connection has closed.\n"
3422 " --help Print this message and then exit.\n"
3423 " --version Display version information and exit.\n"
3427 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3428 " --disable-randomization\n"
3429 " Run PROG with address space randomization disabled.\n"
3430 " --no-disable-randomization\n"
3431 " Don't disable address space randomization when\n"
3433 " --startup-with-shell\n"
3434 " Start PROG using a shell. I.e., execs a shell that\n"
3435 " then execs PROG. (default)\n"
3436 " --no-startup-with-shell\n"
3437 " Exec PROG directly instead of using a shell.\n"
3438 " Disables argument globbing and variable substitution\n"
3439 " on UNIX-like systems.\n"
3443 " --debug Enable general debugging output.\n"
3444 " --debug-format=opt1[,opt2,...]\n"
3445 " Specify extra content in debugging output.\n"
3450 " --remote-debug Enable remote protocol debugging output.\n"
3451 " --disable-packet=opt1[,opt2,...]\n"
3452 " Disable support for RSP packets or features.\n"
3454 " vCont, Tthread, qC, qfThreadInfo and \n"
3455 " threads (disable all threading packets).\n"
3457 "For more information, consult the GDB manual (available as on-line \n"
3458 "info or a printed manual).\n");
3459 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3460 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3464 gdbserver_show_disableable (FILE *stream
)
3466 fprintf (stream
, "Disableable packets:\n"
3467 " vCont \tAll vCont packets\n"
3468 " qC \tQuerying the current thread\n"
3469 " qfThreadInfo\tThread listing\n"
3470 " Tthread \tPassing the thread specifier in the "
3471 "T stop reply packet\n"
3472 " threads \tAll of the above\n");
3476 kill_inferior_callback (process_info
*process
)
3478 int pid
= process
->pid
;
3480 kill_inferior (pid
);
3481 discard_queued_stop_replies (pid_to_ptid (pid
));
3484 /* Call this when exiting gdbserver with possible inferiors that need
3485 to be killed or detached from. */
3488 detach_or_kill_for_exit (void)
3490 /* First print a list of the inferiors we will be killing/detaching.
3491 This is to assist the user, for example, in case the inferior unexpectedly
3492 dies after we exit: did we screw up or did the inferior exit on its own?
3493 Having this info will save some head-scratching. */
3495 if (have_started_inferiors_p ())
3497 fprintf (stderr
, "Killing process(es):");
3499 for_each_process ([] (process_info
*process
) {
3500 if (!process
->attached
)
3501 fprintf (stderr
, " %d", process
->pid
);
3504 fprintf (stderr
, "\n");
3506 if (have_attached_inferiors_p ())
3508 fprintf (stderr
, "Detaching process(es):");
3510 for_each_process ([] (process_info
*process
) {
3511 if (process
->attached
)
3512 fprintf (stderr
, " %d", process
->pid
);
3515 fprintf (stderr
, "\n");
3518 /* Now we can kill or detach the inferiors. */
3519 for_each_process ([] (process_info
*process
) {
3520 int pid
= process
->pid
;
3522 if (process
->attached
)
3523 detach_inferior (pid
);
3525 kill_inferior (pid
);
3527 discard_queued_stop_replies (pid_to_ptid (pid
));
3531 /* Value that will be passed to exit(3) when gdbserver exits. */
3532 static int exit_code
;
3534 /* Cleanup version of detach_or_kill_for_exit. */
3537 detach_or_kill_for_exit_cleanup (void *ignore
)
3542 detach_or_kill_for_exit ();
3545 CATCH (exception
, RETURN_MASK_ALL
)
3548 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3554 /* Main function. This is called by the real "main" function,
3555 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3557 static void ATTRIBUTE_NORETURN
3558 captured_main (int argc
, char *argv
[])
3563 const char *port
= NULL
;
3564 char **next_arg
= &argv
[1];
3565 volatile int multi_mode
= 0;
3566 volatile int attach
= 0;
3568 bool selftest
= false;
3570 const char *selftest_filter
= NULL
;
3573 current_directory
= getcwd (NULL
, 0);
3574 if (current_directory
== NULL
)
3576 error (_("%s: error finding working directory"),
3577 safe_strerror (errno
));
3580 while (*next_arg
!= NULL
&& **next_arg
== '-')
3582 if (strcmp (*next_arg
, "--version") == 0)
3584 gdbserver_version ();
3587 else if (strcmp (*next_arg
, "--help") == 0)
3589 gdbserver_usage (stdout
);
3592 else if (strcmp (*next_arg
, "--attach") == 0)
3594 else if (strcmp (*next_arg
, "--multi") == 0)
3596 else if (strcmp (*next_arg
, "--wrapper") == 0)
3603 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3605 wrapper_argv
+= *next_arg
;
3606 wrapper_argv
+= ' ';
3610 if (!wrapper_argv
.empty ())
3612 /* Erase the last whitespace. */
3613 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3616 if (next_arg
== tmp
|| *next_arg
== NULL
)
3618 gdbserver_usage (stderr
);
3622 /* Consume the "--". */
3625 else if (strcmp (*next_arg
, "--debug") == 0)
3627 else if (startswith (*next_arg
, "--debug-format="))
3629 std::string error_msg
3630 = parse_debug_format_options ((*next_arg
)
3631 + sizeof ("--debug-format=") - 1, 0);
3633 if (!error_msg
.empty ())
3635 fprintf (stderr
, "%s", error_msg
.c_str ());
3639 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3641 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3643 gdbserver_show_disableable (stdout
);
3646 else if (startswith (*next_arg
, "--disable-packet="))
3648 char *packets
, *tok
;
3650 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3651 for (tok
= strtok (packets
, ",");
3653 tok
= strtok (NULL
, ","))
3655 if (strcmp ("vCont", tok
) == 0)
3656 disable_packet_vCont
= 1;
3657 else if (strcmp ("Tthread", tok
) == 0)
3658 disable_packet_Tthread
= 1;
3659 else if (strcmp ("qC", tok
) == 0)
3660 disable_packet_qC
= 1;
3661 else if (strcmp ("qfThreadInfo", tok
) == 0)
3662 disable_packet_qfThreadInfo
= 1;
3663 else if (strcmp ("threads", tok
) == 0)
3665 disable_packet_vCont
= 1;
3666 disable_packet_Tthread
= 1;
3667 disable_packet_qC
= 1;
3668 disable_packet_qfThreadInfo
= 1;
3672 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3674 gdbserver_show_disableable (stderr
);
3679 else if (strcmp (*next_arg
, "-") == 0)
3681 /* "-" specifies a stdio connection and is a form of port
3683 port
= STDIO_CONNECTION_NAME
;
3687 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3688 disable_randomization
= 1;
3689 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3690 disable_randomization
= 0;
3691 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3692 startup_with_shell
= true;
3693 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3694 startup_with_shell
= false;
3695 else if (strcmp (*next_arg
, "--once") == 0)
3697 else if (strcmp (*next_arg
, "--selftest") == 0)
3699 else if (startswith (*next_arg
, "--selftest="))
3703 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3708 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3721 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3724 gdbserver_usage (stderr
);
3728 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3729 opened by remote_prepare. */
3732 save_original_signals_state (false);
3734 /* We need to know whether the remote connection is stdio before
3735 starting the inferior. Inferiors created in this scenario have
3736 stdin,stdout redirected. So do this here before we call
3739 remote_prepare (port
);
3744 /* --attach used to come after PORT, so allow it there for
3746 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3753 && (*next_arg
== NULL
3754 || (*next_arg
)[0] == '\0'
3755 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3757 || next_arg
[1] != NULL
))
3762 gdbserver_usage (stderr
);
3766 /* Gather information about the environment. */
3767 our_environ
= gdb_environ::from_host_environ ();
3769 initialize_async_io ();
3771 have_job_control ();
3772 initialize_event_loop ();
3773 if (target_supports_tracepoints ())
3774 initialize_tracepoint ();
3775 initialize_notif ();
3777 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3778 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3783 selftests::run_tests (selftest_filter
);
3785 printf (_("Selftests are not available in a non-development build.\n"));
3787 throw_quit ("Quit");
3790 if (pid
== 0 && *next_arg
!= NULL
)
3794 n
= argc
- (next_arg
- argv
);
3795 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3796 for (i
= 1; i
< n
; i
++)
3797 program_args
.push_back (xstrdup (next_arg
[i
]));
3798 program_args
.push_back (NULL
);
3800 /* Wait till we are at first instruction in program. */
3801 create_inferior (program_path
.get (), program_args
);
3803 /* We are now (hopefully) stopped at the first instruction of
3804 the target process. This assumes that the target process was
3805 successfully created. */
3809 if (attach_inferior (pid
) == -1)
3810 error ("Attaching not supported on this target");
3812 /* Otherwise succeeded. */
3816 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3817 last_status
.value
.integer
= 0;
3818 last_ptid
= minus_one_ptid
;
3820 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3822 /* Don't report shared library events on the initial connection,
3823 even if some libraries are preloaded. Avoids the "stopped by
3824 shared library event" notice on gdb side. */
3827 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3828 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3833 if (!was_running
&& !multi_mode
)
3834 error ("No program to debug");
3841 report_fork_events
= 0;
3842 report_vfork_events
= 0;
3843 report_exec_events
= 0;
3844 /* Be sure we're out of tfind mode. */
3845 current_traceframe
= -1;
3846 cont_thread
= null_ptid
;
3847 swbreak_feature
= 0;
3848 hwbreak_feature
= 0;
3849 vCont_supported
= 0;
3855 /* Wait for events. This will return when all event sources
3856 are removed from the event loop. */
3857 start_event_loop ();
3859 /* If an exit was requested (using the "monitor exit"
3860 command), terminate now. */
3862 throw_quit ("Quit");
3864 /* The only other way to get here is for getpkt to fail:
3866 - If --once was specified, we're done.
3868 - If not in extended-remote mode, and we're no longer
3869 debugging anything, simply exit: GDB has disconnected
3870 after processing the last process exit.
3872 - Otherwise, close the connection and reopen it at the
3874 if (run_once
|| (!extended_protocol
&& !target_running ()))
3875 throw_quit ("Quit");
3878 "Remote side has terminated connection. "
3879 "GDBserver will reopen the connection.\n");
3881 /* Get rid of any pending statuses. An eventual reconnection
3882 (by the same GDB instance or another) will refresh all its
3883 state from scratch. */
3884 discard_queued_stop_replies (minus_one_ptid
);
3885 for_each_thread ([] (thread_info
*thread
)
3887 thread
->status_pending_p
= 0;
3892 if (disconnected_tracing
)
3894 /* Try to enable non-stop/async mode, so we we can
3895 both wait for an async socket accept, and handle
3896 async target events simultaneously. There's also
3897 no point either in having the target always stop
3898 all threads, when we're going to pass signals
3899 down without informing GDB. */
3902 if (start_non_stop (1))
3905 /* Detaching implicitly resumes all threads;
3906 simply disconnecting does not. */
3912 "Disconnected tracing disabled; "
3913 "stopping trace run.\n");
3918 CATCH (exception
, RETURN_MASK_ERROR
)
3921 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3923 if (response_needed
)
3925 write_enn (own_buf
);
3930 throw_quit ("Quit");
3936 /* Main function. */
3939 main (int argc
, char *argv
[])
3944 captured_main (argc
, argv
);
3946 CATCH (exception
, RETURN_MASK_ALL
)
3948 if (exception
.reason
== RETURN_ERROR
)
3951 fprintf (stderr
, "%s\n", exception
.message
);
3952 fprintf (stderr
, "Exiting\n");
3960 gdb_assert_not_reached ("captured_main should never return");
3963 /* Process options coming from Z packets for a breakpoint. PACKET is
3964 the packet buffer. *PACKET is updated to point to the first char
3965 after the last processed option. */
3968 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3970 const char *dataptr
= *packet
;
3973 /* Check if data has the correct format. */
3974 if (*dataptr
!= ';')
3981 if (*dataptr
== ';')
3984 if (*dataptr
== 'X')
3986 /* Conditional expression. */
3988 debug_printf ("Found breakpoint condition.\n");
3989 if (!add_breakpoint_condition (bp
, &dataptr
))
3990 dataptr
= strchrnul (dataptr
, ';');
3992 else if (startswith (dataptr
, "cmds:"))
3994 dataptr
+= strlen ("cmds:");
3996 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3997 persist
= (*dataptr
== '1');
3999 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4000 dataptr
= strchrnul (dataptr
, ';');
4004 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4006 /* Skip tokens until we find one that we recognize. */
4007 dataptr
= strchrnul (dataptr
, ';');
4013 /* Event loop callback that handles a serial event. The first byte in
4014 the serial buffer gets us here. We expect characters to arrive at
4015 a brisk pace, so we read the rest of the packet with a blocking
4019 process_serial_event (void)
4027 int new_packet_len
= -1;
4029 disable_async_io ();
4031 response_needed
= 0;
4032 packet_len
= getpkt (own_buf
);
4033 if (packet_len
<= 0)
4036 /* Force an event loop break. */
4039 response_needed
= 1;
4041 char ch
= own_buf
[0];
4045 handle_query (own_buf
, packet_len
, &new_packet_len
);
4048 handle_general_set (own_buf
);
4051 handle_detach (own_buf
);
4054 extended_protocol
= 1;
4058 handle_status (own_buf
);
4061 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4063 require_running_or_break (own_buf
);
4065 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4067 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4068 thread_id
= null_ptid
;
4069 else if (thread_id
.is_pid ())
4071 /* The ptid represents a pid. */
4072 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4076 write_enn (own_buf
);
4080 thread_id
= thread
->id
;
4084 /* The ptid represents a lwp/tid. */
4085 if (find_thread_ptid (thread_id
) == NULL
)
4087 write_enn (own_buf
);
4092 if (own_buf
[1] == 'g')
4094 if (ptid_equal (thread_id
, null_ptid
))
4096 /* GDB is telling us to choose any thread. Check if
4097 the currently selected thread is still valid. If
4098 it is not, select the first available. */
4099 thread_info
*thread
= find_thread_ptid (general_thread
);
4101 thread
= get_first_thread ();
4102 thread_id
= thread
->id
;
4105 general_thread
= thread_id
;
4106 set_desired_thread ();
4107 gdb_assert (current_thread
!= NULL
);
4109 else if (own_buf
[1] == 'c')
4110 cont_thread
= thread_id
;
4116 /* Silently ignore it so that gdb can extend the protocol
4117 without compatibility headaches. */
4122 require_running_or_break (own_buf
);
4123 if (current_traceframe
>= 0)
4125 struct regcache
*regcache
4126 = new_register_cache (current_target_desc ());
4128 if (fetch_traceframe_registers (current_traceframe
,
4130 registers_to_string (regcache
, own_buf
);
4132 write_enn (own_buf
);
4133 free_register_cache (regcache
);
4137 struct regcache
*regcache
;
4139 if (!set_desired_thread ())
4140 write_enn (own_buf
);
4143 regcache
= get_thread_regcache (current_thread
, 1);
4144 registers_to_string (regcache
, own_buf
);
4149 require_running_or_break (own_buf
);
4150 if (current_traceframe
>= 0)
4151 write_enn (own_buf
);
4154 struct regcache
*regcache
;
4156 if (!set_desired_thread ())
4157 write_enn (own_buf
);
4160 regcache
= get_thread_regcache (current_thread
, 1);
4161 registers_from_string (regcache
, &own_buf
[1]);
4167 require_running_or_break (own_buf
);
4168 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4169 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4171 write_enn (own_buf
);
4173 bin2hex (mem_buf
, own_buf
, res
);
4176 require_running_or_break (own_buf
);
4177 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4178 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4181 write_enn (own_buf
);
4184 require_running_or_break (own_buf
);
4185 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4186 &mem_addr
, &len
, &mem_buf
) < 0
4187 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4188 write_enn (own_buf
);
4193 require_running_or_break (own_buf
);
4194 hex2bin (own_buf
+ 1, &sig
, 1);
4195 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4196 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4199 myresume (own_buf
, 0, signal
);
4202 require_running_or_break (own_buf
);
4203 hex2bin (own_buf
+ 1, &sig
, 1);
4204 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4205 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4208 myresume (own_buf
, 1, signal
);
4211 require_running_or_break (own_buf
);
4213 myresume (own_buf
, 0, signal
);
4216 require_running_or_break (own_buf
);
4218 myresume (own_buf
, 1, signal
);
4220 case 'Z': /* insert_ ... */
4222 case 'z': /* remove_ ... */
4227 char type
= own_buf
[1];
4229 const int insert
= ch
== 'Z';
4230 const char *p
= &own_buf
[3];
4232 p
= unpack_varlen_hex (p
, &addr
);
4233 kind
= strtol (p
+ 1, &dataptr
, 16);
4237 struct gdb_breakpoint
*bp
;
4239 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4244 /* GDB may have sent us a list of *point parameters to
4245 be evaluated on the target's side. Read such list
4246 here. If we already have a list of parameters, GDB
4247 is telling us to drop that list and use this one
4249 clear_breakpoint_conditions_and_commands (bp
);
4250 const char *options
= dataptr
;
4251 process_point_options (bp
, &options
);
4255 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4263 write_enn (own_buf
);
4267 response_needed
= 0;
4268 if (!target_running ())
4269 /* The packet we received doesn't make sense - but we can't
4270 reply to it, either. */
4273 fprintf (stderr
, "Killing all inferiors\n");
4275 for_each_process (kill_inferior_callback
);
4277 /* When using the extended protocol, we wait with no program
4278 running. The traditional protocol will exit instead. */
4279 if (extended_protocol
)
4281 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4282 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4290 require_running_or_break (own_buf
);
4292 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4293 if (find_thread_ptid (thread_id
) == NULL
)
4295 write_enn (own_buf
);
4299 if (mythread_alive (thread_id
))
4302 write_enn (own_buf
);
4306 response_needed
= 0;
4308 /* Restarting the inferior is only supported in the extended
4310 if (extended_protocol
)
4312 if (target_running ())
4313 for_each_process (kill_inferior_callback
);
4315 fprintf (stderr
, "GDBserver restarting\n");
4317 /* Wait till we are at 1st instruction in prog. */
4318 if (program_path
.get () != NULL
)
4320 create_inferior (program_path
.get (), program_args
);
4322 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4324 /* Stopped at the first instruction of the target
4326 general_thread
= last_ptid
;
4330 /* Something went wrong. */
4331 general_thread
= null_ptid
;
4336 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4337 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4343 /* It is a request we don't understand. Respond with an
4344 empty packet so that gdb knows that we don't support this
4350 /* Extended (long) request. */
4351 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4355 /* It is a request we don't understand. Respond with an empty
4356 packet so that gdb knows that we don't support this
4362 if (new_packet_len
!= -1)
4363 putpkt_binary (own_buf
, new_packet_len
);
4367 response_needed
= 0;
4375 /* Event-loop callback for serial events. */
4378 handle_serial_event (int err
, gdb_client_data client_data
)
4381 debug_printf ("handling possible serial event\n");
4383 /* Really handle it. */
4384 if (process_serial_event () < 0)
4387 /* Be sure to not change the selected thread behind GDB's back.
4388 Important in the non-stop mode asynchronous protocol. */
4389 set_desired_thread ();
4394 /* Push a stop notification on the notification queue. */
4397 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4399 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4401 vstop_notif
->status
= *status
;
4402 vstop_notif
->ptid
= ptid
;
4403 /* Push Stop notification. */
4404 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4407 /* Event-loop callback for target events. */
4410 handle_target_event (int err
, gdb_client_data client_data
)
4413 debug_printf ("handling possible target event\n");
4415 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4418 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4420 if (gdb_connected () && report_no_resumed
)
4421 push_stop_notification (null_ptid
, &last_status
);
4423 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4425 int pid
= ptid_get_pid (last_ptid
);
4426 struct process_info
*process
= find_process_pid (pid
);
4427 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4429 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4430 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4432 mark_breakpoints_out (process
);
4433 target_mourn_inferior (last_ptid
);
4435 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4439 /* We're reporting this thread as stopped. Update its
4440 "want-stopped" state to what the client wants, until it
4441 gets a new resume action. */
4442 current_thread
->last_resume_kind
= resume_stop
;
4443 current_thread
->last_status
= last_status
;
4448 if (!target_running ())
4450 /* The last process exited. We're done. */
4454 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4455 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4456 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4460 /* A thread stopped with a signal, but gdb isn't
4461 connected to handle it. Pass it down to the
4462 inferior, as if it wasn't being traced. */
4463 enum gdb_signal signal
;
4466 debug_printf ("GDB not connected; forwarding event %d for"
4468 (int) last_status
.kind
,
4469 target_pid_to_str (last_ptid
));
4471 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4472 signal
= last_status
.value
.sig
;
4474 signal
= GDB_SIGNAL_0
;
4475 target_continue (last_ptid
, signal
);
4479 push_stop_notification (last_ptid
, &last_status
);
4482 /* Be sure to not change the selected thread behind GDB's back.
4483 Important in the non-stop mode asynchronous protocol. */
4484 set_desired_thread ();
4497 } // namespace selftests
4498 #endif /* GDB_SELF_TEST */