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 an empty string if all options were parsed ok, otherwise an
1313 error 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 /* First turn all debug format options off. */
1329 debug_timestamp
= 0;
1331 /* First remove leading spaces, for "monitor set debug-format". */
1332 while (isspace (*arg
))
1335 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1336 = delim_string_to_char_ptr_vec (arg
, ',');
1338 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1340 if (strcmp (option
.get (), "all") == 0)
1342 debug_timestamp
= 1;
1344 monitor_output ("All extra debug format options enabled.\n");
1346 else if (strcmp (option
.get (), "none") == 0)
1348 debug_timestamp
= 0;
1350 monitor_output ("All extra debug format options disabled.\n");
1352 else if (strcmp (option
.get (), "timestamp") == 0)
1354 debug_timestamp
= 1;
1356 monitor_output ("Timestamps will be added to debug output.\n");
1358 else if (*option
== '\0')
1360 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1364 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1368 return std::string ();
1371 /* Handle monitor commands not handled by target-specific handlers. */
1374 handle_monitor_command (char *mon
, char *own_buf
)
1376 if (strcmp (mon
, "set debug 1") == 0)
1379 monitor_output ("Debug output enabled.\n");
1381 else if (strcmp (mon
, "set debug 0") == 0)
1384 monitor_output ("Debug output disabled.\n");
1386 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1388 show_debug_regs
= 1;
1389 monitor_output ("H/W point debugging output enabled.\n");
1391 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1393 show_debug_regs
= 0;
1394 monitor_output ("H/W point debugging output disabled.\n");
1396 else if (strcmp (mon
, "set remote-debug 1") == 0)
1399 monitor_output ("Protocol debug output enabled.\n");
1401 else if (strcmp (mon
, "set remote-debug 0") == 0)
1404 monitor_output ("Protocol debug output disabled.\n");
1406 else if (startswith (mon
, "set debug-format "))
1408 std::string error_msg
1409 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1412 if (!error_msg
.empty ())
1414 monitor_output (error_msg
.c_str ());
1415 monitor_show_help ();
1416 write_enn (own_buf
);
1419 else if (strcmp (mon
, "help") == 0)
1420 monitor_show_help ();
1421 else if (strcmp (mon
, "exit") == 0)
1425 monitor_output ("Unknown monitor command.\n\n");
1426 monitor_show_help ();
1427 write_enn (own_buf
);
1431 /* Associates a callback with each supported qXfer'able object. */
1435 /* The object this handler handles. */
1438 /* Request that the target transfer up to LEN 8-bit bytes of the
1439 target's OBJECT. The OFFSET, for a seekable object, specifies
1440 the starting point. The ANNEX can be used to provide additional
1441 data-specific information to the target.
1443 Return the number of bytes actually transfered, zero when no
1444 further transfer is possible, -1 on error, -2 when the transfer
1445 is not supported, and -3 on a verbose error message that should
1446 be preserved. Return of a positive value smaller than LEN does
1447 not indicate the end of the object, only the end of the transfer.
1449 One, and only one, of readbuf or writebuf must be non-NULL. */
1450 int (*xfer
) (const char *annex
,
1451 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1452 ULONGEST offset
, LONGEST len
);
1455 /* Handle qXfer:auxv:read. */
1458 handle_qxfer_auxv (const char *annex
,
1459 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1460 ULONGEST offset
, LONGEST len
)
1462 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1465 if (annex
[0] != '\0' || current_thread
== NULL
)
1468 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1471 /* Handle qXfer:exec-file:read. */
1474 handle_qxfer_exec_file (const char *annex
,
1475 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1476 ULONGEST offset
, LONGEST len
)
1482 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1485 if (annex
[0] == '\0')
1487 if (current_thread
== NULL
)
1490 pid
= pid_of (current_thread
);
1494 annex
= unpack_varlen_hex (annex
, &pid
);
1495 if (annex
[0] != '\0')
1502 file
= (*the_target
->pid_to_exec_file
) (pid
);
1506 total_len
= strlen (file
);
1508 if (offset
> total_len
)
1511 if (offset
+ len
> total_len
)
1512 len
= total_len
- offset
;
1514 memcpy (readbuf
, file
+ offset
, len
);
1518 /* Handle qXfer:features:read. */
1521 handle_qxfer_features (const char *annex
,
1522 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1523 ULONGEST offset
, LONGEST len
)
1525 const char *document
;
1528 if (writebuf
!= NULL
)
1531 if (!target_running ())
1534 /* Grab the correct annex. */
1535 document
= get_features_xml (annex
);
1536 if (document
== NULL
)
1539 total_len
= strlen (document
);
1541 if (offset
> total_len
)
1544 if (offset
+ len
> total_len
)
1545 len
= total_len
- offset
;
1547 memcpy (readbuf
, document
+ offset
, len
);
1551 /* Handle qXfer:libraries:read. */
1554 handle_qxfer_libraries (const char *annex
,
1555 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1556 ULONGEST offset
, LONGEST len
)
1558 if (writebuf
!= NULL
)
1561 if (annex
[0] != '\0' || current_thread
== NULL
)
1564 std::string document
= "<library-list version=\"1.0\">\n";
1566 for (const dll_info
&dll
: all_dlls
)
1567 document
+= string_printf
1568 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1569 dll
.name
.c_str (), (long) dll
.base_addr
);
1571 document
+= "</library-list>\n";
1573 if (offset
> document
.length ())
1576 if (offset
+ len
> document
.length ())
1577 len
= document
.length () - offset
;
1579 memcpy (readbuf
, &document
[offset
], len
);
1584 /* Handle qXfer:libraries-svr4:read. */
1587 handle_qxfer_libraries_svr4 (const char *annex
,
1588 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1589 ULONGEST offset
, LONGEST len
)
1591 if (writebuf
!= NULL
)
1594 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1597 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1600 /* Handle qXfer:osadata:read. */
1603 handle_qxfer_osdata (const char *annex
,
1604 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1605 ULONGEST offset
, LONGEST len
)
1607 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1610 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1613 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1616 handle_qxfer_siginfo (const char *annex
,
1617 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1618 ULONGEST offset
, LONGEST len
)
1620 if (the_target
->qxfer_siginfo
== NULL
)
1623 if (annex
[0] != '\0' || current_thread
== NULL
)
1626 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1629 /* Handle qXfer:spu:read and qXfer:spu:write. */
1632 handle_qxfer_spu (const char *annex
,
1633 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1634 ULONGEST offset
, LONGEST len
)
1636 if (the_target
->qxfer_spu
== NULL
)
1639 if (current_thread
== NULL
)
1642 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1645 /* Handle qXfer:statictrace:read. */
1648 handle_qxfer_statictrace (const char *annex
,
1649 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1650 ULONGEST offset
, LONGEST len
)
1654 if (writebuf
!= NULL
)
1657 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1660 if (traceframe_read_sdata (current_traceframe
, offset
,
1661 readbuf
, len
, &nbytes
))
1666 /* Helper for handle_qxfer_threads_proper.
1667 Emit the XML to describe the thread of INF. */
1670 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1672 ptid_t ptid
= ptid_of (thread
);
1674 int core
= target_core_of_thread (ptid
);
1676 const char *name
= target_thread_name (ptid
);
1679 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1681 write_ptid (ptid_s
, ptid
);
1683 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1687 sprintf (core_s
, "%d", core
);
1688 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1692 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1696 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1697 bin2hex (handle
, handle_s
, handle_len
);
1698 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1701 buffer_xml_printf (buffer
, "/>\n");
1704 /* Helper for handle_qxfer_threads. */
1707 handle_qxfer_threads_proper (struct buffer
*buffer
)
1709 buffer_grow_str (buffer
, "<threads>\n");
1711 for_each_thread ([&] (thread_info
*thread
)
1713 handle_qxfer_threads_worker (thread
, buffer
);
1716 buffer_grow_str0 (buffer
, "</threads>\n");
1719 /* Handle qXfer:threads:read. */
1722 handle_qxfer_threads (const char *annex
,
1723 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1724 ULONGEST offset
, LONGEST len
)
1726 static char *result
= 0;
1727 static unsigned int result_length
= 0;
1729 if (writebuf
!= NULL
)
1732 if (annex
[0] != '\0')
1737 struct buffer buffer
;
1738 /* When asked for data at offset 0, generate everything and store into
1739 'result'. Successive reads will be served off 'result'. */
1743 buffer_init (&buffer
);
1745 handle_qxfer_threads_proper (&buffer
);
1747 result
= buffer_finish (&buffer
);
1748 result_length
= strlen (result
);
1749 buffer_free (&buffer
);
1752 if (offset
>= result_length
)
1754 /* We're out of data. */
1761 if (len
> result_length
- offset
)
1762 len
= result_length
- offset
;
1764 memcpy (readbuf
, result
+ offset
, len
);
1769 /* Handle qXfer:traceframe-info:read. */
1772 handle_qxfer_traceframe_info (const char *annex
,
1773 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1774 ULONGEST offset
, LONGEST len
)
1776 static char *result
= 0;
1777 static unsigned int result_length
= 0;
1779 if (writebuf
!= NULL
)
1782 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1787 struct buffer buffer
;
1789 /* When asked for data at offset 0, generate everything and
1790 store into 'result'. Successive reads will be served off
1794 buffer_init (&buffer
);
1796 traceframe_read_info (current_traceframe
, &buffer
);
1798 result
= buffer_finish (&buffer
);
1799 result_length
= strlen (result
);
1800 buffer_free (&buffer
);
1803 if (offset
>= result_length
)
1805 /* We're out of data. */
1812 if (len
> result_length
- offset
)
1813 len
= result_length
- offset
;
1815 memcpy (readbuf
, result
+ offset
, len
);
1819 /* Handle qXfer:fdpic:read. */
1822 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1823 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1825 if (the_target
->read_loadmap
== NULL
)
1828 if (current_thread
== NULL
)
1831 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1834 /* Handle qXfer:btrace:read. */
1837 handle_qxfer_btrace (const char *annex
,
1838 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1839 ULONGEST offset
, LONGEST len
)
1841 static struct buffer cache
;
1842 struct thread_info
*thread
;
1843 enum btrace_read_type type
;
1846 if (writebuf
!= NULL
)
1849 if (ptid_equal (general_thread
, null_ptid
)
1850 || ptid_equal (general_thread
, minus_one_ptid
))
1852 strcpy (own_buf
, "E.Must select a single thread.");
1856 thread
= find_thread_ptid (general_thread
);
1859 strcpy (own_buf
, "E.No such thread.");
1863 if (thread
->btrace
== NULL
)
1865 strcpy (own_buf
, "E.Btrace not enabled.");
1869 if (strcmp (annex
, "all") == 0)
1870 type
= BTRACE_READ_ALL
;
1871 else if (strcmp (annex
, "new") == 0)
1872 type
= BTRACE_READ_NEW
;
1873 else if (strcmp (annex
, "delta") == 0)
1874 type
= BTRACE_READ_DELTA
;
1877 strcpy (own_buf
, "E.Bad annex.");
1883 buffer_free (&cache
);
1887 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1889 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1891 CATCH (exception
, RETURN_MASK_ERROR
)
1893 sprintf (own_buf
, "E.%s", exception
.message
);
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 (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
);
1958 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1960 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1962 CATCH (exception
, RETURN_MASK_ERROR
)
1964 sprintf (own_buf
, "E.%s", exception
.message
);
1972 else if (offset
> cache
.used_size
)
1974 buffer_free (&cache
);
1978 if (len
> cache
.used_size
- offset
)
1979 len
= cache
.used_size
- offset
;
1981 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1986 static const struct qxfer qxfer_packets
[] =
1988 { "auxv", handle_qxfer_auxv
},
1989 { "btrace", handle_qxfer_btrace
},
1990 { "btrace-conf", handle_qxfer_btrace_conf
},
1991 { "exec-file", handle_qxfer_exec_file
},
1992 { "fdpic", handle_qxfer_fdpic
},
1993 { "features", handle_qxfer_features
},
1994 { "libraries", handle_qxfer_libraries
},
1995 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1996 { "osdata", handle_qxfer_osdata
},
1997 { "siginfo", handle_qxfer_siginfo
},
1998 { "spu", handle_qxfer_spu
},
1999 { "statictrace", handle_qxfer_statictrace
},
2000 { "threads", handle_qxfer_threads
},
2001 { "traceframe-info", handle_qxfer_traceframe_info
},
2005 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2013 if (!startswith (own_buf
, "qXfer:"))
2016 /* Grab the object, r/w and annex. */
2017 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2019 write_enn (own_buf
);
2024 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2027 const struct qxfer
*q
= &qxfer_packets
[i
];
2029 if (strcmp (object
, q
->object
) == 0)
2031 if (strcmp (rw
, "read") == 0)
2033 unsigned char *data
;
2038 /* Grab the offset and length. */
2039 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2041 write_enn (own_buf
);
2045 /* Read one extra byte, as an indicator of whether there is
2047 if (len
> PBUFSIZ
- 2)
2049 data
= (unsigned char *) malloc (len
+ 1);
2052 write_enn (own_buf
);
2055 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2063 /* Preserve error message. */
2066 write_enn (own_buf
);
2068 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2070 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2075 else if (strcmp (rw
, "write") == 0)
2080 unsigned char *data
;
2082 strcpy (own_buf
, "E00");
2083 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2086 write_enn (own_buf
);
2089 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2090 &ofs
, &len
, data
) < 0)
2093 write_enn (own_buf
);
2097 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2105 /* Preserve error message. */
2108 write_enn (own_buf
);
2110 sprintf (own_buf
, "%x", n
);
2123 /* Compute 32 bit CRC from inferior memory.
2125 On success, return 32 bit CRC.
2126 On failure, return (unsigned long long) -1. */
2128 static unsigned long long
2129 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2133 unsigned char byte
= 0;
2135 /* Return failure if memory read fails. */
2136 if (read_inferior_memory (base
, &byte
, 1) != 0)
2137 return (unsigned long long) -1;
2139 crc
= xcrc32 (&byte
, 1, crc
);
2142 return (unsigned long long) crc
;
2145 /* Add supported btrace packets to BUF. */
2148 supported_btrace_packets (char *buf
)
2150 strcat (buf
, ";Qbtrace:bts+");
2151 strcat (buf
, ";Qbtrace-conf:bts:size+");
2152 strcat (buf
, ";Qbtrace:pt+");
2153 strcat (buf
, ";Qbtrace-conf:pt:size+");
2154 strcat (buf
, ";Qbtrace:off+");
2155 strcat (buf
, ";qXfer:btrace:read+");
2156 strcat (buf
, ";qXfer:btrace-conf:read+");
2159 /* Handle all of the extended 'q' packets. */
2162 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2164 static std::list
<thread_info
*>::const_iterator thread_iter
;
2166 /* Reply the current thread id. */
2167 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2170 require_running_or_return (own_buf
);
2172 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2173 ptid
= general_thread
;
2176 thread_iter
= all_threads
.begin ();
2177 ptid
= (*thread_iter
)->id
;
2180 sprintf (own_buf
, "QC");
2182 write_ptid (own_buf
, ptid
);
2186 if (strcmp ("qSymbol::", own_buf
) == 0)
2188 struct thread_info
*save_thread
= current_thread
;
2190 /* For qSymbol, GDB only changes the current thread if the
2191 previous current thread was of a different process. So if
2192 the previous thread is gone, we need to pick another one of
2193 the same process. This can happen e.g., if we followed an
2194 exec in a non-leader thread. */
2195 if (current_thread
== NULL
)
2198 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2200 /* Just in case, if we didn't find a thread, then bail out
2201 instead of crashing. */
2202 if (current_thread
== NULL
)
2204 write_enn (own_buf
);
2205 current_thread
= save_thread
;
2210 /* GDB is suggesting new symbols have been loaded. This may
2211 mean a new shared library has been detected as loaded, so
2212 take the opportunity to check if breakpoints we think are
2213 inserted, still are. Note that it isn't guaranteed that
2214 we'll see this when a shared library is loaded, and nor will
2215 we see this for unloads (although breakpoints in unloaded
2216 libraries shouldn't trigger), as GDB may not find symbols for
2217 the library at all. We also re-validate breakpoints when we
2218 see a second GDB breakpoint for the same address, and or when
2219 we access breakpoint shadows. */
2220 validate_breakpoints ();
2222 if (target_supports_tracepoints ())
2223 tracepoint_look_up_symbols ();
2225 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2226 (*the_target
->look_up_symbols
) ();
2228 current_thread
= save_thread
;
2230 strcpy (own_buf
, "OK");
2234 if (!disable_packet_qfThreadInfo
)
2236 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2238 require_running_or_return (own_buf
);
2239 thread_iter
= all_threads
.begin ();
2242 ptid_t ptid
= (*thread_iter
)->id
;
2243 write_ptid (own_buf
, ptid
);
2248 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2250 require_running_or_return (own_buf
);
2251 if (thread_iter
!= all_threads
.end ())
2254 ptid_t ptid
= (*thread_iter
)->id
;
2255 write_ptid (own_buf
, ptid
);
2261 sprintf (own_buf
, "l");
2267 if (the_target
->read_offsets
!= NULL
2268 && strcmp ("qOffsets", own_buf
) == 0)
2270 CORE_ADDR text
, data
;
2272 require_running_or_return (own_buf
);
2273 if (the_target
->read_offsets (&text
, &data
))
2274 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2275 (long)text
, (long)data
, (long)data
);
2277 write_enn (own_buf
);
2282 /* Protocol features query. */
2283 if (startswith (own_buf
, "qSupported")
2284 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2286 char *p
= &own_buf
[10];
2287 int gdb_supports_qRelocInsn
= 0;
2289 /* Process each feature being provided by GDB. The first
2290 feature will follow a ':', and latter features will follow
2294 char **qsupported
= NULL
;
2299 /* Two passes, to avoid nested strtok calls in
2300 target_process_qsupported. */
2301 for (p
= strtok (p
+ 1, ";");
2303 p
= strtok (NULL
, ";"))
2306 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2307 qsupported
[count
- 1] = xstrdup (p
);
2310 for (i
= 0; i
< count
; i
++)
2313 if (strcmp (p
, "multiprocess+") == 0)
2315 /* GDB supports and wants multi-process support if
2317 if (target_supports_multi_process ())
2320 else if (strcmp (p
, "qRelocInsn+") == 0)
2322 /* GDB supports relocate instruction requests. */
2323 gdb_supports_qRelocInsn
= 1;
2325 else if (strcmp (p
, "swbreak+") == 0)
2327 /* GDB wants us to report whether a trap is caused
2328 by a software breakpoint and for us to handle PC
2329 adjustment if necessary on this target. */
2330 if (target_supports_stopped_by_sw_breakpoint ())
2331 swbreak_feature
= 1;
2333 else if (strcmp (p
, "hwbreak+") == 0)
2335 /* GDB wants us to report whether a trap is caused
2336 by a hardware breakpoint. */
2337 if (target_supports_stopped_by_hw_breakpoint ())
2338 hwbreak_feature
= 1;
2340 else if (strcmp (p
, "fork-events+") == 0)
2342 /* GDB supports and wants fork events if possible. */
2343 if (target_supports_fork_events ())
2344 report_fork_events
= 1;
2346 else if (strcmp (p
, "vfork-events+") == 0)
2348 /* GDB supports and wants vfork events if possible. */
2349 if (target_supports_vfork_events ())
2350 report_vfork_events
= 1;
2352 else if (strcmp (p
, "exec-events+") == 0)
2354 /* GDB supports and wants exec events if possible. */
2355 if (target_supports_exec_events ())
2356 report_exec_events
= 1;
2358 else if (strcmp (p
, "vContSupported+") == 0)
2359 vCont_supported
= 1;
2360 else if (strcmp (p
, "QThreadEvents+") == 0)
2362 else if (strcmp (p
, "no-resumed+") == 0)
2364 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2366 report_no_resumed
= 1;
2370 /* Move the unknown features all together. */
2371 qsupported
[i
] = NULL
;
2372 qsupported
[unknown
] = p
;
2377 /* Give the target backend a chance to process the unknown
2379 target_process_qsupported (qsupported
, unknown
);
2381 for (i
= 0; i
< count
; i
++)
2382 free (qsupported
[i
]);
2387 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2388 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2389 "QEnvironmentReset+;QEnvironmentUnset+;"
2393 if (target_supports_catch_syscall ())
2394 strcat (own_buf
, ";QCatchSyscalls+");
2396 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2397 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2398 ";augmented-libraries-svr4-read+");
2401 /* We do not have any hook to indicate whether the non-SVR4 target
2402 backend supports qXfer:libraries:read, so always report it. */
2403 strcat (own_buf
, ";qXfer:libraries:read+");
2406 if (the_target
->read_auxv
!= NULL
)
2407 strcat (own_buf
, ";qXfer:auxv:read+");
2409 if (the_target
->qxfer_spu
!= NULL
)
2410 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2412 if (the_target
->qxfer_siginfo
!= NULL
)
2413 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2415 if (the_target
->read_loadmap
!= NULL
)
2416 strcat (own_buf
, ";qXfer:fdpic:read+");
2418 /* We always report qXfer:features:read, as targets may
2419 install XML files on a subsequent call to arch_setup.
2420 If we reported to GDB on startup that we don't support
2421 qXfer:feature:read at all, we will never be re-queried. */
2422 strcat (own_buf
, ";qXfer:features:read+");
2424 if (transport_is_reliable
)
2425 strcat (own_buf
, ";QStartNoAckMode+");
2427 if (the_target
->qxfer_osdata
!= NULL
)
2428 strcat (own_buf
, ";qXfer:osdata:read+");
2430 if (target_supports_multi_process ())
2431 strcat (own_buf
, ";multiprocess+");
2433 if (target_supports_fork_events ())
2434 strcat (own_buf
, ";fork-events+");
2436 if (target_supports_vfork_events ())
2437 strcat (own_buf
, ";vfork-events+");
2439 if (target_supports_exec_events ())
2440 strcat (own_buf
, ";exec-events+");
2442 if (target_supports_non_stop ())
2443 strcat (own_buf
, ";QNonStop+");
2445 if (target_supports_disable_randomization ())
2446 strcat (own_buf
, ";QDisableRandomization+");
2448 strcat (own_buf
, ";qXfer:threads:read+");
2450 if (target_supports_tracepoints ())
2452 strcat (own_buf
, ";ConditionalTracepoints+");
2453 strcat (own_buf
, ";TraceStateVariables+");
2454 strcat (own_buf
, ";TracepointSource+");
2455 strcat (own_buf
, ";DisconnectedTracing+");
2456 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2457 strcat (own_buf
, ";FastTracepoints+");
2458 strcat (own_buf
, ";StaticTracepoints+");
2459 strcat (own_buf
, ";InstallInTrace+");
2460 strcat (own_buf
, ";qXfer:statictrace:read+");
2461 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2462 strcat (own_buf
, ";EnableDisableTracepoints+");
2463 strcat (own_buf
, ";QTBuffer:size+");
2464 strcat (own_buf
, ";tracenz+");
2467 if (target_supports_hardware_single_step ()
2468 || target_supports_software_single_step () )
2470 strcat (own_buf
, ";ConditionalBreakpoints+");
2472 strcat (own_buf
, ";BreakpointCommands+");
2474 if (target_supports_agent ())
2475 strcat (own_buf
, ";QAgent+");
2477 supported_btrace_packets (own_buf
);
2479 if (target_supports_stopped_by_sw_breakpoint ())
2480 strcat (own_buf
, ";swbreak+");
2482 if (target_supports_stopped_by_hw_breakpoint ())
2483 strcat (own_buf
, ";hwbreak+");
2485 if (the_target
->pid_to_exec_file
!= NULL
)
2486 strcat (own_buf
, ";qXfer:exec-file:read+");
2488 strcat (own_buf
, ";vContSupported+");
2490 strcat (own_buf
, ";QThreadEvents+");
2492 strcat (own_buf
, ";no-resumed+");
2494 /* Reinitialize components as needed for the new connection. */
2495 hostio_handle_new_gdb_connection ();
2496 target_handle_new_gdb_connection ();
2501 /* Thread-local storage support. */
2502 if (the_target
->get_tls_address
!= NULL
2503 && startswith (own_buf
, "qGetTLSAddr:"))
2505 char *p
= own_buf
+ 12;
2506 CORE_ADDR parts
[2], address
= 0;
2508 ptid_t ptid
= null_ptid
;
2510 require_running_or_return (own_buf
);
2512 for (i
= 0; i
< 3; i
++)
2520 p2
= strchr (p
, ',');
2533 ptid
= read_ptid (p
, NULL
);
2535 decode_address (&parts
[i
- 1], p
, len
);
2539 if (p
!= NULL
|| i
< 3)
2543 struct thread_info
*thread
= find_thread_ptid (ptid
);
2548 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2554 strcpy (own_buf
, paddress(address
));
2559 write_enn (own_buf
);
2563 /* Otherwise, pretend we do not understand this packet. */
2566 /* Windows OS Thread Information Block address support. */
2567 if (the_target
->get_tib_address
!= NULL
2568 && startswith (own_buf
, "qGetTIBAddr:"))
2573 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2575 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2578 strcpy (own_buf
, paddress(tlb
));
2583 write_enn (own_buf
);
2589 /* Handle "monitor" commands. */
2590 if (startswith (own_buf
, "qRcmd,"))
2592 char *mon
= (char *) malloc (PBUFSIZ
);
2593 int len
= strlen (own_buf
+ 6);
2597 write_enn (own_buf
);
2602 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2604 write_enn (own_buf
);
2608 mon
[len
/ 2] = '\0';
2612 if (the_target
->handle_monitor_command
== NULL
2613 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2614 /* Default processing. */
2615 handle_monitor_command (mon
, own_buf
);
2621 if (startswith (own_buf
, "qSearch:memory:"))
2623 require_running_or_return (own_buf
);
2624 handle_search_memory (own_buf
, packet_len
);
2628 if (strcmp (own_buf
, "qAttached") == 0
2629 || startswith (own_buf
, "qAttached:"))
2631 struct process_info
*process
;
2633 if (own_buf
[sizeof ("qAttached") - 1])
2635 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2636 process
= find_process_pid (pid
);
2640 require_running_or_return (own_buf
);
2641 process
= current_process ();
2644 if (process
== NULL
)
2646 write_enn (own_buf
);
2650 strcpy (own_buf
, process
->attached
? "1" : "0");
2654 if (startswith (own_buf
, "qCRC:"))
2656 /* CRC check (compare-section). */
2660 unsigned long long crc
;
2662 require_running_or_return (own_buf
);
2663 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2664 if (*comma
++ != ',')
2666 write_enn (own_buf
);
2669 len
= strtoul (comma
, NULL
, 16);
2670 crc
= crc32 (base
, len
, 0xffffffff);
2671 /* Check for memory failure. */
2672 if (crc
== (unsigned long long) -1)
2674 write_enn (own_buf
);
2677 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2681 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2684 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2687 /* Otherwise we didn't know what packet it was. Say we didn't
2692 static void gdb_wants_all_threads_stopped (void);
2693 static void resume (struct thread_resume
*actions
, size_t n
);
2695 /* The callback that is passed to visit_actioned_threads. */
2696 typedef int (visit_actioned_threads_callback_ftype
)
2697 (const struct thread_resume
*, struct thread_info
*);
2699 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2700 true if CALLBACK returns true. Returns false if no matching thread
2701 is found or CALLBACK results false.
2702 Note: This function is itself a callback for find_thread. */
2705 visit_actioned_threads (thread_info
*thread
,
2706 const struct thread_resume
*actions
,
2708 visit_actioned_threads_callback_ftype
*callback
)
2710 for (size_t i
= 0; i
< num_actions
; i
++)
2712 const struct thread_resume
*action
= &actions
[i
];
2714 if (ptid_equal (action
->thread
, minus_one_ptid
)
2715 || ptid_equal (action
->thread
, thread
->id
)
2716 || ((ptid_get_pid (action
->thread
)
2717 == thread
->id
.pid ())
2718 && ptid_get_lwp (action
->thread
) == -1))
2720 if ((*callback
) (action
, thread
))
2728 /* Callback for visit_actioned_threads. If the thread has a pending
2729 status to report, report it now. */
2732 handle_pending_status (const struct thread_resume
*resumption
,
2733 struct thread_info
*thread
)
2735 if (thread
->status_pending_p
)
2737 thread
->status_pending_p
= 0;
2739 last_status
= thread
->last_status
;
2740 last_ptid
= thread
->id
;
2741 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2747 /* Parse vCont packets. */
2749 handle_v_cont (char *own_buf
)
2753 struct thread_resume
*resume_info
;
2754 struct thread_resume default_action
{ null_ptid
};
2756 /* Count the number of semicolons in the packet. There should be one
2757 for every action. */
2763 p
= strchr (p
, ';');
2766 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2767 if (resume_info
== NULL
)
2775 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2777 if (p
[0] == 's' || p
[0] == 'S')
2778 resume_info
[i
].kind
= resume_step
;
2779 else if (p
[0] == 'r')
2780 resume_info
[i
].kind
= resume_step
;
2781 else if (p
[0] == 'c' || p
[0] == 'C')
2782 resume_info
[i
].kind
= resume_continue
;
2783 else if (p
[0] == 't')
2784 resume_info
[i
].kind
= resume_stop
;
2788 if (p
[0] == 'S' || p
[0] == 'C')
2791 int sig
= strtol (p
+ 1, &q
, 16);
2796 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2798 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2800 else if (p
[0] == 'r')
2804 p
= unpack_varlen_hex (p
+ 1, &addr
);
2805 resume_info
[i
].step_range_start
= addr
;
2810 p
= unpack_varlen_hex (p
+ 1, &addr
);
2811 resume_info
[i
].step_range_end
= addr
;
2820 resume_info
[i
].thread
= minus_one_ptid
;
2821 default_action
= resume_info
[i
];
2823 /* Note: we don't increment i here, we'll overwrite this entry
2824 the next time through. */
2826 else if (p
[0] == ':')
2829 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2834 if (p
[0] != ';' && p
[0] != 0)
2837 resume_info
[i
].thread
= ptid
;
2844 resume_info
[i
] = default_action
;
2846 resume (resume_info
, n
);
2851 write_enn (own_buf
);
2856 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2859 resume (struct thread_resume
*actions
, size_t num_actions
)
2863 /* Check if among the threads that GDB wants actioned, there's
2864 one with a pending status to report. If so, skip actually
2865 resuming/stopping and report the pending event
2868 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2870 return visit_actioned_threads (thread
, actions
, num_actions
,
2871 handle_pending_status
);
2874 if (thread_with_status
!= NULL
)
2880 (*the_target
->resume
) (actions
, num_actions
);
2886 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2888 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2889 && !report_no_resumed
)
2891 /* The client does not support this stop reply. At least
2893 sprintf (own_buf
, "E.No unwaited-for children left.");
2894 disable_async_io ();
2898 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2899 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2900 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2901 current_thread
->last_status
= last_status
;
2903 /* From the client's perspective, all-stop mode always stops all
2904 threads implicitly (and the target backend has already done
2905 so by now). Tag all threads as "want-stopped", so we don't
2906 resume them implicitly without the client telling us to. */
2907 gdb_wants_all_threads_stopped ();
2908 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2909 disable_async_io ();
2911 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2912 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2913 target_mourn_inferior (last_ptid
);
2917 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2919 handle_v_attach (char *own_buf
)
2923 pid
= strtol (own_buf
+ 8, NULL
, 16);
2924 if (pid
!= 0 && attach_inferior (pid
) == 0)
2926 /* Don't report shared library events after attaching, even if
2927 some libraries are preloaded. GDB will always poll the
2928 library list. Avoids the "stopped by shared library event"
2929 notice on the GDB side. */
2934 /* In non-stop, we don't send a resume reply. Stop events
2935 will follow up using the normal notification
2940 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2946 write_enn (own_buf
);
2951 /* Run a new program. Return 1 if successful, 0 if failure. */
2953 handle_v_run (char *own_buf
)
2956 std::vector
<char *> new_argv
;
2957 char *new_program_name
= NULL
;
2961 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2967 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2969 next_p
= strchr (p
, ';');
2971 next_p
= p
+ strlen (p
);
2973 if (i
== 0 && p
== next_p
)
2975 /* No program specified. */
2976 new_program_name
= NULL
;
2978 else if (p
== next_p
)
2980 /* Empty argument. */
2981 new_argv
.push_back (xstrdup ("''"));
2985 size_t len
= (next_p
- p
) / 2;
2986 /* ARG is the unquoted argument received via the RSP. */
2987 char *arg
= (char *) xmalloc (len
+ 1);
2988 /* FULL_ARGS will contain the quoted version of ARG. */
2989 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2990 /* These are pointers used to navigate the strings above. */
2991 char *tmp_arg
= arg
;
2992 char *tmp_full_arg
= full_arg
;
2995 hex2bin (p
, (gdb_byte
*) arg
, len
);
2998 while (*tmp_arg
!= '\0')
3004 *tmp_full_arg
= '\'';
3010 /* Quote single quote. */
3011 *tmp_full_arg
= '\\';
3019 *tmp_full_arg
= *tmp_arg
;
3025 *tmp_full_arg
++ = '\'';
3027 /* Finish FULL_ARG and push it into the vector containing
3029 *tmp_full_arg
= '\0';
3031 new_program_name
= full_arg
;
3033 new_argv
.push_back (full_arg
);
3039 new_argv
.push_back (NULL
);
3041 if (new_program_name
== NULL
)
3043 /* GDB didn't specify a program to run. Use the program from the
3044 last run with the new argument list. */
3045 if (program_path
.get () == NULL
)
3047 write_enn (own_buf
);
3048 free_vector_argv (new_argv
);
3053 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3055 /* Free the old argv and install the new one. */
3056 free_vector_argv (program_args
);
3057 program_args
= new_argv
;
3059 create_inferior (program_path
.get (), program_args
);
3061 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3063 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3065 /* In non-stop, sending a resume reply doesn't set the general
3066 thread, but GDB assumes a vRun sets it (this is so GDB can
3067 query which is the main thread of the new inferior. */
3069 general_thread
= last_ptid
;
3075 write_enn (own_buf
);
3080 /* Kill process. Return 1 if successful, 0 if failure. */
3082 handle_v_kill (char *own_buf
)
3085 char *p
= &own_buf
[6];
3087 pid
= strtol (p
, NULL
, 16);
3090 if (pid
!= 0 && kill_inferior (pid
) == 0)
3092 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3093 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3094 last_ptid
= pid_to_ptid (pid
);
3095 discard_queued_stop_replies (last_ptid
);
3101 write_enn (own_buf
);
3106 /* Handle all of the extended 'v' packets. */
3108 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3110 if (!disable_packet_vCont
)
3112 if (strcmp (own_buf
, "vCtrlC") == 0)
3114 (*the_target
->request_interrupt
) ();
3119 if (startswith (own_buf
, "vCont;"))
3121 handle_v_cont (own_buf
);
3125 if (startswith (own_buf
, "vCont?"))
3127 strcpy (own_buf
, "vCont;c;C;t");
3129 if (target_supports_hardware_single_step ()
3130 || target_supports_software_single_step ()
3131 || !vCont_supported
)
3133 /* If target supports single step either by hardware or by
3134 software, add actions s and S to the list of supported
3135 actions. On the other hand, if GDB doesn't request the
3136 supported vCont actions in qSupported packet, add s and
3137 S to the list too. */
3138 own_buf
= own_buf
+ strlen (own_buf
);
3139 strcpy (own_buf
, ";s;S");
3142 if (target_supports_range_stepping ())
3144 own_buf
= own_buf
+ strlen (own_buf
);
3145 strcpy (own_buf
, ";r");
3151 if (startswith (own_buf
, "vFile:")
3152 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3155 if (startswith (own_buf
, "vAttach;"))
3157 if ((!extended_protocol
|| !multi_process
) && target_running ())
3159 fprintf (stderr
, "Already debugging a process\n");
3160 write_enn (own_buf
);
3163 handle_v_attach (own_buf
);
3167 if (startswith (own_buf
, "vRun;"))
3169 if ((!extended_protocol
|| !multi_process
) && target_running ())
3171 fprintf (stderr
, "Already debugging a process\n");
3172 write_enn (own_buf
);
3175 handle_v_run (own_buf
);
3179 if (startswith (own_buf
, "vKill;"))
3181 if (!target_running ())
3183 fprintf (stderr
, "No process to kill\n");
3184 write_enn (own_buf
);
3187 handle_v_kill (own_buf
);
3191 if (handle_notif_ack (own_buf
, packet_len
))
3194 /* Otherwise we didn't know what packet it was. Say we didn't
3200 /* Resume thread and wait for another event. In non-stop mode,
3201 don't really wait here, but return immediatelly to the event
3204 myresume (char *own_buf
, int step
, int sig
)
3206 struct thread_resume resume_info
[2];
3208 int valid_cont_thread
;
3210 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3211 && !ptid_equal (cont_thread
, minus_one_ptid
));
3213 if (step
|| sig
|| valid_cont_thread
)
3215 resume_info
[0].thread
= current_ptid
;
3217 resume_info
[0].kind
= resume_step
;
3219 resume_info
[0].kind
= resume_continue
;
3220 resume_info
[0].sig
= sig
;
3224 if (!valid_cont_thread
)
3226 resume_info
[n
].thread
= minus_one_ptid
;
3227 resume_info
[n
].kind
= resume_continue
;
3228 resume_info
[n
].sig
= 0;
3232 resume (resume_info
, n
);
3235 /* Callback for for_each_thread. Make a new stop reply for each
3239 queue_stop_reply_callback (thread_info
*thread
)
3241 /* For now, assume targets that don't have this callback also don't
3242 manage the thread's last_status field. */
3243 if (the_target
->thread_stopped
== NULL
)
3245 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3247 new_notif
->ptid
= thread
->id
;
3248 new_notif
->status
= thread
->last_status
;
3249 /* Pass the last stop reply back to GDB, but don't notify
3251 notif_event_enque (¬if_stop
,
3252 (struct notif_event
*) new_notif
);
3256 if (thread_stopped (thread
))
3260 std::string status_string
3261 = target_waitstatus_to_string (&thread
->last_status
);
3263 debug_printf ("Reporting thread %s as already stopped with %s\n",
3264 target_pid_to_str (thread
->id
),
3265 status_string
.c_str ());
3268 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3270 /* Pass the last stop reply back to GDB, but don't notify
3272 queue_stop_reply (thread
->id
, &thread
->last_status
);
3277 /* Set this inferior threads's state as "want-stopped". We won't
3278 resume this thread until the client gives us another action for
3282 gdb_wants_thread_stopped (thread_info
*thread
)
3284 thread
->last_resume_kind
= resume_stop
;
3286 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3288 /* Most threads are stopped implicitly (all-stop); tag that with
3290 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3291 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3295 /* Set all threads' states as "want-stopped". */
3298 gdb_wants_all_threads_stopped (void)
3300 for_each_thread (gdb_wants_thread_stopped
);
3303 /* Callback for for_each_thread. If the thread is stopped with an
3304 interesting event, mark it as having a pending event. */
3307 set_pending_status_callback (thread_info
*thread
)
3309 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3310 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3311 /* A breakpoint, watchpoint or finished step from a previous
3312 GDB run isn't considered interesting for a new GDB run.
3313 If we left those pending, the new GDB could consider them
3314 random SIGTRAPs. This leaves out real async traps. We'd
3315 have to peek into the (target-specific) siginfo to
3316 distinguish those. */
3317 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3318 thread
->status_pending_p
= 1;
3321 /* Status handler for the '?' packet. */
3324 handle_status (char *own_buf
)
3326 /* GDB is connected, don't forward events to the target anymore. */
3327 for_each_process ([] (process_info
*process
) {
3328 process
->gdb_detached
= 0;
3331 /* In non-stop mode, we must send a stop reply for each stopped
3332 thread. In all-stop mode, just send one for the first stopped
3337 for_each_thread (queue_stop_reply_callback
);
3339 /* The first is sent immediatly. OK is sent if there is no
3340 stopped thread, which is the same handling of the vStopped
3341 packet (by design). */
3342 notif_write_event (¬if_stop
, own_buf
);
3346 thread_info
*thread
= NULL
;
3349 stabilize_threads ();
3350 gdb_wants_all_threads_stopped ();
3352 /* We can only report one status, but we might be coming out of
3353 non-stop -- if more than one thread is stopped with
3354 interesting events, leave events for the threads we're not
3355 reporting now pending. They'll be reported the next time the
3356 threads are resumed. Start by marking all interesting events
3358 for_each_thread (set_pending_status_callback
);
3360 /* Prefer the last thread that reported an event to GDB (even if
3361 that was a GDB_SIGNAL_TRAP). */
3362 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3363 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3364 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3365 thread
= find_thread_ptid (last_ptid
);
3367 /* If the last event thread is not found for some reason, look
3368 for some other thread that might have an event to report. */
3370 thread
= find_thread ([] (thread_info
*thread
)
3372 return thread
->status_pending_p
;
3375 /* If we're still out of luck, simply pick the first thread in
3378 thread
= get_first_thread ();
3382 struct thread_info
*tp
= (struct thread_info
*) thread
;
3384 /* We're reporting this event, so it's no longer
3386 tp
->status_pending_p
= 0;
3388 /* GDB assumes the current thread is the thread we're
3389 reporting the status for. */
3390 general_thread
= thread
->id
;
3391 set_desired_thread ();
3393 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3394 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3397 strcpy (own_buf
, "W00");
3402 gdbserver_version (void)
3404 printf ("GNU gdbserver %s%s\n"
3405 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3406 "gdbserver is free software, covered by the "
3407 "GNU General Public License.\n"
3408 "This gdbserver was configured as \"%s\"\n",
3409 PKGVERSION
, version
, host_name
);
3413 gdbserver_usage (FILE *stream
)
3415 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3416 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3417 "\tgdbserver [OPTIONS] --multi COMM\n"
3419 "COMM may either be a tty device (for serial debugging),\n"
3420 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3421 "stdin/stdout of gdbserver.\n"
3422 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3423 "PID is the process ID to attach to, when --attach is specified.\n"
3425 "Operating modes:\n"
3427 " --attach Attach to running process PID.\n"
3428 " --multi Start server without a specific program, and\n"
3429 " only quit when explicitly commanded.\n"
3430 " --once Exit after the first connection has closed.\n"
3431 " --help Print this message and then exit.\n"
3432 " --version Display version information and exit.\n"
3436 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3437 " --disable-randomization\n"
3438 " Run PROG with address space randomization disabled.\n"
3439 " --no-disable-randomization\n"
3440 " Don't disable address space randomization when\n"
3442 " --startup-with-shell\n"
3443 " Start PROG using a shell. I.e., execs a shell that\n"
3444 " then execs PROG. (default)\n"
3445 " --no-startup-with-shell\n"
3446 " Exec PROG directly instead of using a shell.\n"
3447 " Disables argument globbing and variable substitution\n"
3448 " on UNIX-like systems.\n"
3452 " --debug Enable general debugging output.\n"
3453 " --debug-format=opt1[,opt2,...]\n"
3454 " Specify extra content in debugging output.\n"
3459 " --remote-debug Enable remote protocol debugging output.\n"
3460 " --disable-packet=opt1[,opt2,...]\n"
3461 " Disable support for RSP packets or features.\n"
3463 " vCont, Tthread, qC, qfThreadInfo and \n"
3464 " threads (disable all threading packets).\n"
3466 "For more information, consult the GDB manual (available as on-line \n"
3467 "info or a printed manual).\n");
3468 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3469 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3473 gdbserver_show_disableable (FILE *stream
)
3475 fprintf (stream
, "Disableable packets:\n"
3476 " vCont \tAll vCont packets\n"
3477 " qC \tQuerying the current thread\n"
3478 " qfThreadInfo\tThread listing\n"
3479 " Tthread \tPassing the thread specifier in the "
3480 "T stop reply packet\n"
3481 " threads \tAll of the above\n");
3485 kill_inferior_callback (process_info
*process
)
3487 int pid
= process
->pid
;
3489 kill_inferior (pid
);
3490 discard_queued_stop_replies (pid_to_ptid (pid
));
3493 /* Call this when exiting gdbserver with possible inferiors that need
3494 to be killed or detached from. */
3497 detach_or_kill_for_exit (void)
3499 /* First print a list of the inferiors we will be killing/detaching.
3500 This is to assist the user, for example, in case the inferior unexpectedly
3501 dies after we exit: did we screw up or did the inferior exit on its own?
3502 Having this info will save some head-scratching. */
3504 if (have_started_inferiors_p ())
3506 fprintf (stderr
, "Killing process(es):");
3508 for_each_process ([] (process_info
*process
) {
3509 if (!process
->attached
)
3510 fprintf (stderr
, " %d", process
->pid
);
3513 fprintf (stderr
, "\n");
3515 if (have_attached_inferiors_p ())
3517 fprintf (stderr
, "Detaching process(es):");
3519 for_each_process ([] (process_info
*process
) {
3520 if (process
->attached
)
3521 fprintf (stderr
, " %d", process
->pid
);
3524 fprintf (stderr
, "\n");
3527 /* Now we can kill or detach the inferiors. */
3528 for_each_process ([] (process_info
*process
) {
3529 int pid
= process
->pid
;
3531 if (process
->attached
)
3532 detach_inferior (pid
);
3534 kill_inferior (pid
);
3536 discard_queued_stop_replies (pid_to_ptid (pid
));
3540 /* Value that will be passed to exit(3) when gdbserver exits. */
3541 static int exit_code
;
3543 /* Cleanup version of detach_or_kill_for_exit. */
3546 detach_or_kill_for_exit_cleanup (void *ignore
)
3551 detach_or_kill_for_exit ();
3554 CATCH (exception
, RETURN_MASK_ALL
)
3557 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3563 /* Main function. This is called by the real "main" function,
3564 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3566 static void ATTRIBUTE_NORETURN
3567 captured_main (int argc
, char *argv
[])
3572 const char *port
= NULL
;
3573 char **next_arg
= &argv
[1];
3574 volatile int multi_mode
= 0;
3575 volatile int attach
= 0;
3577 bool selftest
= false;
3579 const char *selftest_filter
= NULL
;
3582 current_directory
= getcwd (NULL
, 0);
3583 if (current_directory
== NULL
)
3585 error (_("Could not find current working directory: %s"),
3586 safe_strerror (errno
));
3589 while (*next_arg
!= NULL
&& **next_arg
== '-')
3591 if (strcmp (*next_arg
, "--version") == 0)
3593 gdbserver_version ();
3596 else if (strcmp (*next_arg
, "--help") == 0)
3598 gdbserver_usage (stdout
);
3601 else if (strcmp (*next_arg
, "--attach") == 0)
3603 else if (strcmp (*next_arg
, "--multi") == 0)
3605 else if (strcmp (*next_arg
, "--wrapper") == 0)
3612 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3614 wrapper_argv
+= *next_arg
;
3615 wrapper_argv
+= ' ';
3619 if (!wrapper_argv
.empty ())
3621 /* Erase the last whitespace. */
3622 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3625 if (next_arg
== tmp
|| *next_arg
== NULL
)
3627 gdbserver_usage (stderr
);
3631 /* Consume the "--". */
3634 else if (strcmp (*next_arg
, "--debug") == 0)
3636 else if (startswith (*next_arg
, "--debug-format="))
3638 std::string error_msg
3639 = parse_debug_format_options ((*next_arg
)
3640 + sizeof ("--debug-format=") - 1, 0);
3642 if (!error_msg
.empty ())
3644 fprintf (stderr
, "%s", error_msg
.c_str ());
3648 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3650 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3652 gdbserver_show_disableable (stdout
);
3655 else if (startswith (*next_arg
, "--disable-packet="))
3657 char *packets
, *tok
;
3659 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3660 for (tok
= strtok (packets
, ",");
3662 tok
= strtok (NULL
, ","))
3664 if (strcmp ("vCont", tok
) == 0)
3665 disable_packet_vCont
= 1;
3666 else if (strcmp ("Tthread", tok
) == 0)
3667 disable_packet_Tthread
= 1;
3668 else if (strcmp ("qC", tok
) == 0)
3669 disable_packet_qC
= 1;
3670 else if (strcmp ("qfThreadInfo", tok
) == 0)
3671 disable_packet_qfThreadInfo
= 1;
3672 else if (strcmp ("threads", tok
) == 0)
3674 disable_packet_vCont
= 1;
3675 disable_packet_Tthread
= 1;
3676 disable_packet_qC
= 1;
3677 disable_packet_qfThreadInfo
= 1;
3681 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3683 gdbserver_show_disableable (stderr
);
3688 else if (strcmp (*next_arg
, "-") == 0)
3690 /* "-" specifies a stdio connection and is a form of port
3692 port
= STDIO_CONNECTION_NAME
;
3696 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3697 disable_randomization
= 1;
3698 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3699 disable_randomization
= 0;
3700 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3701 startup_with_shell
= true;
3702 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3703 startup_with_shell
= false;
3704 else if (strcmp (*next_arg
, "--once") == 0)
3706 else if (strcmp (*next_arg
, "--selftest") == 0)
3708 else if (startswith (*next_arg
, "--selftest="))
3712 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3717 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3730 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3733 gdbserver_usage (stderr
);
3737 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3738 opened by remote_prepare. */
3741 save_original_signals_state (false);
3743 /* We need to know whether the remote connection is stdio before
3744 starting the inferior. Inferiors created in this scenario have
3745 stdin,stdout redirected. So do this here before we call
3748 remote_prepare (port
);
3753 /* --attach used to come after PORT, so allow it there for
3755 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3762 && (*next_arg
== NULL
3763 || (*next_arg
)[0] == '\0'
3764 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3766 || next_arg
[1] != NULL
))
3771 gdbserver_usage (stderr
);
3775 /* Gather information about the environment. */
3776 our_environ
= gdb_environ::from_host_environ ();
3778 initialize_async_io ();
3780 have_job_control ();
3781 initialize_event_loop ();
3782 if (target_supports_tracepoints ())
3783 initialize_tracepoint ();
3784 initialize_notif ();
3786 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3787 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3792 selftests::run_tests (selftest_filter
);
3794 printf (_("Selftests are not available in a non-development build.\n"));
3796 throw_quit ("Quit");
3799 if (pid
== 0 && *next_arg
!= NULL
)
3803 n
= argc
- (next_arg
- argv
);
3804 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3805 for (i
= 1; i
< n
; i
++)
3806 program_args
.push_back (xstrdup (next_arg
[i
]));
3807 program_args
.push_back (NULL
);
3809 /* Wait till we are at first instruction in program. */
3810 create_inferior (program_path
.get (), program_args
);
3812 /* We are now (hopefully) stopped at the first instruction of
3813 the target process. This assumes that the target process was
3814 successfully created. */
3818 if (attach_inferior (pid
) == -1)
3819 error ("Attaching not supported on this target");
3821 /* Otherwise succeeded. */
3825 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3826 last_status
.value
.integer
= 0;
3827 last_ptid
= minus_one_ptid
;
3829 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3831 /* Don't report shared library events on the initial connection,
3832 even if some libraries are preloaded. Avoids the "stopped by
3833 shared library event" notice on gdb side. */
3836 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3837 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3842 if (!was_running
&& !multi_mode
)
3843 error ("No program to debug");
3850 report_fork_events
= 0;
3851 report_vfork_events
= 0;
3852 report_exec_events
= 0;
3853 /* Be sure we're out of tfind mode. */
3854 current_traceframe
= -1;
3855 cont_thread
= null_ptid
;
3856 swbreak_feature
= 0;
3857 hwbreak_feature
= 0;
3858 vCont_supported
= 0;
3864 /* Wait for events. This will return when all event sources
3865 are removed from the event loop. */
3866 start_event_loop ();
3868 /* If an exit was requested (using the "monitor exit"
3869 command), terminate now. */
3871 throw_quit ("Quit");
3873 /* The only other way to get here is for getpkt to fail:
3875 - If --once was specified, we're done.
3877 - If not in extended-remote mode, and we're no longer
3878 debugging anything, simply exit: GDB has disconnected
3879 after processing the last process exit.
3881 - Otherwise, close the connection and reopen it at the
3883 if (run_once
|| (!extended_protocol
&& !target_running ()))
3884 throw_quit ("Quit");
3887 "Remote side has terminated connection. "
3888 "GDBserver will reopen the connection.\n");
3890 /* Get rid of any pending statuses. An eventual reconnection
3891 (by the same GDB instance or another) will refresh all its
3892 state from scratch. */
3893 discard_queued_stop_replies (minus_one_ptid
);
3894 for_each_thread ([] (thread_info
*thread
)
3896 thread
->status_pending_p
= 0;
3901 if (disconnected_tracing
)
3903 /* Try to enable non-stop/async mode, so we we can
3904 both wait for an async socket accept, and handle
3905 async target events simultaneously. There's also
3906 no point either in having the target always stop
3907 all threads, when we're going to pass signals
3908 down without informing GDB. */
3911 if (start_non_stop (1))
3914 /* Detaching implicitly resumes all threads;
3915 simply disconnecting does not. */
3921 "Disconnected tracing disabled; "
3922 "stopping trace run.\n");
3927 CATCH (exception
, RETURN_MASK_ERROR
)
3930 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3932 if (response_needed
)
3934 write_enn (own_buf
);
3939 throw_quit ("Quit");
3945 /* Main function. */
3948 main (int argc
, char *argv
[])
3953 captured_main (argc
, argv
);
3955 CATCH (exception
, RETURN_MASK_ALL
)
3957 if (exception
.reason
== RETURN_ERROR
)
3960 fprintf (stderr
, "%s\n", exception
.message
);
3961 fprintf (stderr
, "Exiting\n");
3969 gdb_assert_not_reached ("captured_main should never return");
3972 /* Process options coming from Z packets for a breakpoint. PACKET is
3973 the packet buffer. *PACKET is updated to point to the first char
3974 after the last processed option. */
3977 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3979 const char *dataptr
= *packet
;
3982 /* Check if data has the correct format. */
3983 if (*dataptr
!= ';')
3990 if (*dataptr
== ';')
3993 if (*dataptr
== 'X')
3995 /* Conditional expression. */
3997 debug_printf ("Found breakpoint condition.\n");
3998 if (!add_breakpoint_condition (bp
, &dataptr
))
3999 dataptr
= strchrnul (dataptr
, ';');
4001 else if (startswith (dataptr
, "cmds:"))
4003 dataptr
+= strlen ("cmds:");
4005 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4006 persist
= (*dataptr
== '1');
4008 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4009 dataptr
= strchrnul (dataptr
, ';');
4013 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4015 /* Skip tokens until we find one that we recognize. */
4016 dataptr
= strchrnul (dataptr
, ';');
4022 /* Event loop callback that handles a serial event. The first byte in
4023 the serial buffer gets us here. We expect characters to arrive at
4024 a brisk pace, so we read the rest of the packet with a blocking
4028 process_serial_event (void)
4036 int new_packet_len
= -1;
4038 disable_async_io ();
4040 response_needed
= 0;
4041 packet_len
= getpkt (own_buf
);
4042 if (packet_len
<= 0)
4045 /* Force an event loop break. */
4048 response_needed
= 1;
4050 char ch
= own_buf
[0];
4054 handle_query (own_buf
, packet_len
, &new_packet_len
);
4057 handle_general_set (own_buf
);
4060 handle_detach (own_buf
);
4063 extended_protocol
= 1;
4067 handle_status (own_buf
);
4070 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4072 require_running_or_break (own_buf
);
4074 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4076 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4077 thread_id
= null_ptid
;
4078 else if (thread_id
.is_pid ())
4080 /* The ptid represents a pid. */
4081 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4085 write_enn (own_buf
);
4089 thread_id
= thread
->id
;
4093 /* The ptid represents a lwp/tid. */
4094 if (find_thread_ptid (thread_id
) == NULL
)
4096 write_enn (own_buf
);
4101 if (own_buf
[1] == 'g')
4103 if (ptid_equal (thread_id
, null_ptid
))
4105 /* GDB is telling us to choose any thread. Check if
4106 the currently selected thread is still valid. If
4107 it is not, select the first available. */
4108 thread_info
*thread
= find_thread_ptid (general_thread
);
4110 thread
= get_first_thread ();
4111 thread_id
= thread
->id
;
4114 general_thread
= thread_id
;
4115 set_desired_thread ();
4116 gdb_assert (current_thread
!= NULL
);
4118 else if (own_buf
[1] == 'c')
4119 cont_thread
= thread_id
;
4125 /* Silently ignore it so that gdb can extend the protocol
4126 without compatibility headaches. */
4131 require_running_or_break (own_buf
);
4132 if (current_traceframe
>= 0)
4134 struct regcache
*regcache
4135 = new_register_cache (current_target_desc ());
4137 if (fetch_traceframe_registers (current_traceframe
,
4139 registers_to_string (regcache
, own_buf
);
4141 write_enn (own_buf
);
4142 free_register_cache (regcache
);
4146 struct regcache
*regcache
;
4148 if (!set_desired_thread ())
4149 write_enn (own_buf
);
4152 regcache
= get_thread_regcache (current_thread
, 1);
4153 registers_to_string (regcache
, own_buf
);
4158 require_running_or_break (own_buf
);
4159 if (current_traceframe
>= 0)
4160 write_enn (own_buf
);
4163 struct regcache
*regcache
;
4165 if (!set_desired_thread ())
4166 write_enn (own_buf
);
4169 regcache
= get_thread_regcache (current_thread
, 1);
4170 registers_from_string (regcache
, &own_buf
[1]);
4176 require_running_or_break (own_buf
);
4177 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4178 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4180 write_enn (own_buf
);
4182 bin2hex (mem_buf
, own_buf
, res
);
4185 require_running_or_break (own_buf
);
4186 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4187 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4190 write_enn (own_buf
);
4193 require_running_or_break (own_buf
);
4194 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4195 &mem_addr
, &len
, &mem_buf
) < 0
4196 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4197 write_enn (own_buf
);
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
, 0, signal
);
4211 require_running_or_break (own_buf
);
4212 hex2bin (own_buf
+ 1, &sig
, 1);
4213 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4214 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4217 myresume (own_buf
, 1, signal
);
4220 require_running_or_break (own_buf
);
4222 myresume (own_buf
, 0, signal
);
4225 require_running_or_break (own_buf
);
4227 myresume (own_buf
, 1, signal
);
4229 case 'Z': /* insert_ ... */
4231 case 'z': /* remove_ ... */
4236 char type
= own_buf
[1];
4238 const int insert
= ch
== 'Z';
4239 const char *p
= &own_buf
[3];
4241 p
= unpack_varlen_hex (p
, &addr
);
4242 kind
= strtol (p
+ 1, &dataptr
, 16);
4246 struct gdb_breakpoint
*bp
;
4248 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4253 /* GDB may have sent us a list of *point parameters to
4254 be evaluated on the target's side. Read such list
4255 here. If we already have a list of parameters, GDB
4256 is telling us to drop that list and use this one
4258 clear_breakpoint_conditions_and_commands (bp
);
4259 const char *options
= dataptr
;
4260 process_point_options (bp
, &options
);
4264 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4272 write_enn (own_buf
);
4276 response_needed
= 0;
4277 if (!target_running ())
4278 /* The packet we received doesn't make sense - but we can't
4279 reply to it, either. */
4282 fprintf (stderr
, "Killing all inferiors\n");
4284 for_each_process (kill_inferior_callback
);
4286 /* When using the extended protocol, we wait with no program
4287 running. The traditional protocol will exit instead. */
4288 if (extended_protocol
)
4290 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4291 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4299 require_running_or_break (own_buf
);
4301 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4302 if (find_thread_ptid (thread_id
) == NULL
)
4304 write_enn (own_buf
);
4308 if (mythread_alive (thread_id
))
4311 write_enn (own_buf
);
4315 response_needed
= 0;
4317 /* Restarting the inferior is only supported in the extended
4319 if (extended_protocol
)
4321 if (target_running ())
4322 for_each_process (kill_inferior_callback
);
4324 fprintf (stderr
, "GDBserver restarting\n");
4326 /* Wait till we are at 1st instruction in prog. */
4327 if (program_path
.get () != NULL
)
4329 create_inferior (program_path
.get (), program_args
);
4331 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4333 /* Stopped at the first instruction of the target
4335 general_thread
= last_ptid
;
4339 /* Something went wrong. */
4340 general_thread
= null_ptid
;
4345 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4346 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4352 /* It is a request we don't understand. Respond with an
4353 empty packet so that gdb knows that we don't support this
4359 /* Extended (long) request. */
4360 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4364 /* It is a request we don't understand. Respond with an empty
4365 packet so that gdb knows that we don't support this
4371 if (new_packet_len
!= -1)
4372 putpkt_binary (own_buf
, new_packet_len
);
4376 response_needed
= 0;
4384 /* Event-loop callback for serial events. */
4387 handle_serial_event (int err
, gdb_client_data client_data
)
4390 debug_printf ("handling possible serial event\n");
4392 /* Really handle it. */
4393 if (process_serial_event () < 0)
4396 /* Be sure to not change the selected thread behind GDB's back.
4397 Important in the non-stop mode asynchronous protocol. */
4398 set_desired_thread ();
4403 /* Push a stop notification on the notification queue. */
4406 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4408 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4410 vstop_notif
->status
= *status
;
4411 vstop_notif
->ptid
= ptid
;
4412 /* Push Stop notification. */
4413 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4416 /* Event-loop callback for target events. */
4419 handle_target_event (int err
, gdb_client_data client_data
)
4422 debug_printf ("handling possible target event\n");
4424 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4427 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4429 if (gdb_connected () && report_no_resumed
)
4430 push_stop_notification (null_ptid
, &last_status
);
4432 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4434 int pid
= ptid_get_pid (last_ptid
);
4435 struct process_info
*process
= find_process_pid (pid
);
4436 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4438 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4439 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4441 mark_breakpoints_out (process
);
4442 target_mourn_inferior (last_ptid
);
4444 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4448 /* We're reporting this thread as stopped. Update its
4449 "want-stopped" state to what the client wants, until it
4450 gets a new resume action. */
4451 current_thread
->last_resume_kind
= resume_stop
;
4452 current_thread
->last_status
= last_status
;
4457 if (!target_running ())
4459 /* The last process exited. We're done. */
4463 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4464 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4465 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4469 /* A thread stopped with a signal, but gdb isn't
4470 connected to handle it. Pass it down to the
4471 inferior, as if it wasn't being traced. */
4472 enum gdb_signal signal
;
4475 debug_printf ("GDB not connected; forwarding event %d for"
4477 (int) last_status
.kind
,
4478 target_pid_to_str (last_ptid
));
4480 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4481 signal
= last_status
.value
.sig
;
4483 signal
= GDB_SIGNAL_0
;
4484 target_continue (last_ptid
, signal
);
4488 push_stop_notification (last_ptid
, &last_status
);
4491 /* Be sure to not change the selected thread behind GDB's back.
4492 Important in the non-stop mode asynchronous protocol. */
4493 set_desired_thread ();
4506 } // namespace selftests
4507 #endif /* GDB_SELF_TEST */