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"
43 #include "common/selftest.h"
45 #define require_running_or_return(BUF) \
46 if (!target_running ()) \
52 #define require_running_or_break(BUF) \
53 if (!target_running ()) \
59 /* String containing the current directory (what getwd would return). */
61 char *current_directory
;
63 /* The environment to pass to the inferior when creating it. */
65 static gdb_environ our_environ
;
67 /* Start the inferior using a shell. */
69 /* We always try to start the inferior using a shell. */
71 int startup_with_shell
= 1;
73 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
74 `vCont'. Note the multi-process extensions made `vCont' a
75 requirement, so `Hc pPID.TID' is pretty much undefined. So
76 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
77 resuming all threads of the process (again, `Hc' isn't used for
78 multi-process), or a specific thread ptid_t. */
81 /* The thread set with an `Hg' packet. */
82 ptid_t general_thread
;
86 static int extended_protocol
;
87 static int response_needed
;
88 static int exit_requested
;
90 /* --once: Exit after the first connection has closed. */
94 int report_fork_events
;
95 int report_vfork_events
;
96 int report_exec_events
;
97 int report_thread_events
;
99 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
100 static int report_no_resumed
;
106 /* True if the "vContSupported" feature is active. In that case, GDB
107 wants us to report whether single step is supported in the reply to
109 static int vCont_supported
;
111 /* Whether we should attempt to disable the operating system's address
112 space randomization feature before starting an inferior. */
113 int disable_randomization
= 1;
115 static char *program_name
= NULL
;
116 static std::vector
<char *> program_args
;
117 static std::string wrapper_argv
;
119 int pass_signals
[GDB_SIGNAL_LAST
];
120 int program_signals
[GDB_SIGNAL_LAST
];
121 int program_signals_p
;
123 /* The PID of the originally created or attached inferior. Used to
124 send signals to the process when GDB sends us an asynchronous interrupt
125 (user hitting Control-C in the client), and to wait for the child to exit
126 when no longer debugging it. */
128 unsigned long signal_pid
;
130 /* Set if you want to disable optional thread related packets support
131 in gdbserver, for the sake of testing GDB against stubs that don't
133 int disable_packet_vCont
;
134 int disable_packet_Tthread
;
135 int disable_packet_qC
;
136 int disable_packet_qfThreadInfo
;
138 /* Last status reported to GDB. */
139 struct target_waitstatus last_status
;
143 static unsigned char *mem_buf
;
145 /* A sub-class of 'struct notif_event' for stop, holding information
146 relative to a single stop reply. We keep a queue of these to
147 push to GDB in non-stop mode. */
151 struct notif_event base
;
153 /* Thread or process that got the event. */
157 struct target_waitstatus status
;
160 /* The current btrace configuration. This is gdbserver's mirror of GDB's
161 btrace configuration. */
162 static struct btrace_config current_btrace_conf
;
164 DEFINE_QUEUE_P (notif_event_p
);
166 /* Put a stop reply to the stop reply queue. */
169 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
171 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
173 new_notif
->ptid
= ptid
;
174 new_notif
->status
= *status
;
176 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
180 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
181 QUEUE_ITER (notif_event_p
) *iter
,
182 struct notif_event
*event
,
185 ptid_t filter_ptid
= *(ptid_t
*) data
;
186 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
188 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
190 if (q
->free_func
!= NULL
)
191 q
->free_func (event
);
193 QUEUE_remove_elem (notif_event_p
, q
, iter
);
202 discard_queued_stop_replies (ptid_t ptid
)
204 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
205 remove_all_on_match_ptid
, &ptid
);
209 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
211 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
213 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
216 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
219 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
220 QUEUE_ITER (notif_event_p
) *iter
,
221 struct notif_event
*event
,
224 ptid_t filter_ptid
= *(ptid_t
*) data
;
225 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
227 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
230 /* Don't resume fork children that GDB does not know about yet. */
231 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
232 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
233 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
242 in_queued_stop_replies (ptid_t ptid
)
244 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
245 in_queued_stop_replies_ptid
, &ptid
);
248 struct notif_server notif_stop
=
250 "vStopped", "Stop", NULL
, vstop_notif_reply
,
254 target_running (void)
256 return get_first_thread () != NULL
;
259 /* See common/common-inferior.h. */
264 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
267 /* See common/common-inferior.h. */
270 get_exec_file (int err
)
272 if (err
&& program_name
== NULL
)
273 error (_("No executable file specified."));
287 attach_inferior (int pid
)
289 /* myattach should return -1 if attaching is unsupported,
290 0 if it succeeded, and call error() otherwise. */
292 if (myattach (pid
) != 0)
295 fprintf (stderr
, "Attached; pid = %d\n", pid
);
298 /* FIXME - It may be that we should get the SIGNAL_PID from the
299 attach function, so that it can be the main thread instead of
300 whichever we were told to attach to. */
305 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
307 /* GDB knows to ignore the first SIGSTOP after attaching to a running
308 process using the "attach" command, but this is different; it's
309 just using "target remote". Pretend it's just starting up. */
310 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
311 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
312 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
314 current_thread
->last_resume_kind
= resume_stop
;
315 current_thread
->last_status
= last_status
;
321 extern int remote_debug
;
323 /* Decode a qXfer read request. Return 0 if everything looks OK,
327 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
329 /* After the read marker and annex, qXfer looks like a
330 traditional 'm' packet. */
331 decode_m_packet (buf
, ofs
, len
);
337 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
339 /* Extract and NUL-terminate the object. */
341 while (*buf
&& *buf
!= ':')
347 /* Extract and NUL-terminate the read/write action. */
349 while (*buf
&& *buf
!= ':')
355 /* Extract and NUL-terminate the annex. */
357 while (*buf
&& *buf
!= ':')
367 /* Write the response to a successful qXfer read. Returns the
368 length of the (binary) data stored in BUF, corresponding
369 to as much of DATA/LEN as we could fit. IS_MORE controls
370 the first character of the response. */
372 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
381 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
382 &out_len
, PBUFSIZ
- 2) + 1;
385 /* Handle btrace enabling in BTS format. */
388 handle_btrace_enable_bts (struct thread_info
*thread
)
390 if (thread
->btrace
!= NULL
)
391 error (_("Btrace already enabled."));
393 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
394 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
397 /* Handle btrace enabling in Intel Processor Trace format. */
400 handle_btrace_enable_pt (struct thread_info
*thread
)
402 if (thread
->btrace
!= NULL
)
403 error (_("Btrace already enabled."));
405 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
406 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
409 /* Handle btrace disabling. */
412 handle_btrace_disable (struct thread_info
*thread
)
415 if (thread
->btrace
== NULL
)
416 error (_("Branch tracing not enabled."));
418 if (target_disable_btrace (thread
->btrace
) != 0)
419 error (_("Could not disable branch tracing."));
421 thread
->btrace
= NULL
;
424 /* Handle the "Qbtrace" packet. */
427 handle_btrace_general_set (char *own_buf
)
429 struct thread_info
*thread
;
432 if (!startswith (own_buf
, "Qbtrace:"))
435 op
= own_buf
+ strlen ("Qbtrace:");
437 if (ptid_equal (general_thread
, null_ptid
)
438 || ptid_equal (general_thread
, minus_one_ptid
))
440 strcpy (own_buf
, "E.Must select a single thread.");
444 thread
= find_thread_ptid (general_thread
);
447 strcpy (own_buf
, "E.No such thread.");
453 if (strcmp (op
, "bts") == 0)
454 handle_btrace_enable_bts (thread
);
455 else if (strcmp (op
, "pt") == 0)
456 handle_btrace_enable_pt (thread
);
457 else if (strcmp (op
, "off") == 0)
458 handle_btrace_disable (thread
);
460 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
464 CATCH (exception
, RETURN_MASK_ERROR
)
466 sprintf (own_buf
, "E.%s", exception
.message
);
473 /* Handle the "Qbtrace-conf" packet. */
476 handle_btrace_conf_general_set (char *own_buf
)
478 struct thread_info
*thread
;
481 if (!startswith (own_buf
, "Qbtrace-conf:"))
484 op
= own_buf
+ strlen ("Qbtrace-conf:");
486 if (ptid_equal (general_thread
, null_ptid
)
487 || ptid_equal (general_thread
, minus_one_ptid
))
489 strcpy (own_buf
, "E.Must select a single thread.");
493 thread
= find_thread_ptid (general_thread
);
496 strcpy (own_buf
, "E.No such thread.");
500 if (startswith (op
, "bts:size="))
506 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
507 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
509 strcpy (own_buf
, "E.Bad size value.");
513 current_btrace_conf
.bts
.size
= (unsigned int) size
;
515 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
521 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
522 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
524 strcpy (own_buf
, "E.Bad size value.");
528 current_btrace_conf
.pt
.size
= (unsigned int) size
;
532 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
540 /* Handle all of the extended 'Q' packets. */
543 handle_general_set (char *own_buf
)
545 if (startswith (own_buf
, "QPassSignals:"))
547 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
548 const char *p
= own_buf
+ strlen ("QPassSignals:");
551 p
= decode_address_to_semicolon (&cursig
, p
);
552 for (i
= 0; i
< numsigs
; i
++)
558 /* Keep looping, to clear the remaining signals. */
561 p
= decode_address_to_semicolon (&cursig
, p
);
566 strcpy (own_buf
, "OK");
570 if (startswith (own_buf
, "QProgramSignals:"))
572 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
573 const char *p
= own_buf
+ strlen ("QProgramSignals:");
576 program_signals_p
= 1;
578 p
= decode_address_to_semicolon (&cursig
, p
);
579 for (i
= 0; i
< numsigs
; i
++)
583 program_signals
[i
] = 1;
585 /* Keep looping, to clear the remaining signals. */
588 p
= decode_address_to_semicolon (&cursig
, p
);
591 program_signals
[i
] = 0;
593 strcpy (own_buf
, "OK");
597 if (startswith (own_buf
, "QCatchSyscalls:"))
599 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
602 struct process_info
*process
;
604 if (!target_running () || !target_supports_catch_syscall ())
610 if (strcmp (p
, "0") == 0)
612 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
616 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
622 process
= current_process ();
623 process
->syscalls_to_catch
.clear ();
633 p
= decode_address_to_semicolon (&sysno
, p
);
634 process
->syscalls_to_catch
.push_back (sysno
);
638 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
645 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
647 our_environ
= gdb_environ::from_host_environ ();
653 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
655 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
656 /* The final form of the environment variable. FINAL_VAR will
657 hold the 'VAR=VALUE' format. */
658 std::string final_var
= hex2str (p
);
659 std::string var_name
, var_value
;
663 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
664 debug_printf (_("[Environment variable to be set: '%s']\n"),
669 size_t pos
= final_var
.find ('=');
670 if (pos
== std::string::npos
)
672 warning (_("Unexpected format for environment variable: '%s'"),
678 var_name
= final_var
.substr (0, pos
);
679 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
681 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
687 if (startswith (own_buf
, "QEnvironmentUnset:"))
689 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
690 std::string varname
= hex2str (p
);
694 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
695 debug_printf (_("[Environment variable to be unset: '%s']\n"),
700 our_environ
.unset (varname
.c_str ());
706 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
710 debug_printf ("[noack mode enabled]\n");
719 if (startswith (own_buf
, "QNonStop:"))
721 char *mode
= own_buf
+ 9;
725 if (strcmp (mode
, "0") == 0)
727 else if (strcmp (mode
, "1") == 0)
731 /* We don't know what this mode is, so complain to
733 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
739 req_str
= req
? "non-stop" : "all-stop";
740 if (start_non_stop (req
) != 0)
742 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
750 debug_printf ("[%s mode enabled]\n", req_str
);
756 if (startswith (own_buf
, "QDisableRandomization:"))
758 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
761 unpack_varlen_hex (packet
, &setting
);
762 disable_randomization
= setting
;
766 debug_printf (disable_randomization
767 ? "[address space randomization disabled]\n"
768 : "[address space randomization enabled]\n");
775 if (target_supports_tracepoints ()
776 && handle_tracepoint_general_set (own_buf
))
779 if (startswith (own_buf
, "QAgent:"))
781 char *mode
= own_buf
+ strlen ("QAgent:");
784 if (strcmp (mode
, "0") == 0)
786 else if (strcmp (mode
, "1") == 0)
790 /* We don't know what this value is, so complain to GDB. */
791 sprintf (own_buf
, "E.Unknown QAgent value");
795 /* Update the flag. */
798 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
803 if (handle_btrace_general_set (own_buf
))
806 if (handle_btrace_conf_general_set (own_buf
))
809 if (startswith (own_buf
, "QThreadEvents:"))
811 char *mode
= own_buf
+ strlen ("QThreadEvents:");
812 enum tribool req
= TRIBOOL_UNKNOWN
;
814 if (strcmp (mode
, "0") == 0)
816 else if (strcmp (mode
, "1") == 0)
820 char *mode_copy
= xstrdup (mode
);
822 /* We don't know what this mode is, so complain to GDB. */
823 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
829 report_thread_events
= (req
== TRIBOOL_TRUE
);
833 const char *req_str
= report_thread_events
? "enabled" : "disabled";
835 debug_printf ("[thread events are now %s]\n", req_str
);
842 if (startswith (own_buf
, "QStartupWithShell:"))
844 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
846 if (strcmp (value
, "1") == 0)
847 startup_with_shell
= true;
848 else if (strcmp (value
, "0") == 0)
849 startup_with_shell
= false;
853 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
860 debug_printf (_("[Inferior will %s started with shell]"),
861 startup_with_shell
? "be" : "not be");
867 if (startswith (own_buf
, "QSetWorkingDir:"))
869 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
873 std::string path
= hex2str (p
);
875 set_inferior_cwd (path
.c_str ());
878 debug_printf (_("[Set the inferior's current directory to %s]\n"),
883 /* An empty argument means that we should clear out any
884 previously set cwd for the inferior. */
885 set_inferior_cwd (NULL
);
889 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
896 /* Otherwise we didn't know what packet it was. Say we didn't
902 get_features_xml (const char *annex
)
904 const struct target_desc
*desc
= current_target_desc ();
906 /* `desc->xmltarget' defines what to return when looking for the
907 "target.xml" file. Its contents can either be verbatim XML code
908 (prefixed with a '@') or else the name of the actual XML file to
909 be used in place of "target.xml".
911 This variable is set up from the auto-generated
912 init_registers_... routine for the current target. */
914 if (strcmp (annex
, "target.xml") == 0)
916 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
926 extern const char *const xml_builtin
[][2];
929 /* Look for the annex. */
930 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
931 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
934 if (xml_builtin
[i
][0] != NULL
)
935 return xml_builtin
[i
][1];
943 monitor_show_help (void)
945 monitor_output ("The following monitor commands are supported:\n");
946 monitor_output (" set debug <0|1>\n");
947 monitor_output (" Enable general debugging messages\n");
948 monitor_output (" set debug-hw-points <0|1>\n");
949 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
950 monitor_output (" set remote-debug <0|1>\n");
951 monitor_output (" Enable remote protocol debugging messages\n");
952 monitor_output (" set debug-format option1[,option2,...]\n");
953 monitor_output (" Add additional information to debugging messages\n");
954 monitor_output (" Options: all, none");
955 monitor_output (", timestamp");
956 monitor_output ("\n");
957 monitor_output (" exit\n");
958 monitor_output (" Quit GDBserver\n");
961 /* Read trace frame or inferior memory. Returns the number of bytes
962 actually read, zero when no further transfer is possible, and -1 on
963 error. Return of a positive value smaller than LEN does not
964 indicate there's no more to be read, only the end of the transfer.
965 E.g., when GDB reads memory from a traceframe, a first request may
966 be served from a memory block that does not cover the whole request
967 length. A following request gets the rest served from either
968 another block (of the same traceframe) or from the read-only
972 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
976 if (current_traceframe
>= 0)
979 ULONGEST length
= len
;
981 if (traceframe_read_mem (current_traceframe
,
982 memaddr
, myaddr
, len
, &nbytes
))
984 /* Data read from trace buffer, we're done. */
987 if (!in_readonly_region (memaddr
, length
))
989 /* Otherwise we have a valid readonly case, fall through. */
990 /* (assume no half-trace half-real blocks for now) */
993 res
= prepare_to_access_memory ();
996 if (set_desired_thread ())
997 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1000 done_accessing_memory ();
1002 return res
== 0 ? len
: -1;
1008 /* Write trace frame or inferior memory. Actually, writing to trace
1009 frames is forbidden. */
1012 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1014 if (current_traceframe
>= 0)
1020 ret
= prepare_to_access_memory ();
1023 if (set_desired_thread ())
1024 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1027 done_accessing_memory ();
1033 /* Subroutine of handle_search_memory to simplify it. */
1036 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1037 gdb_byte
*pattern
, unsigned pattern_len
,
1038 gdb_byte
*search_buf
,
1039 unsigned chunk_size
, unsigned search_buf_size
,
1040 CORE_ADDR
*found_addrp
)
1042 /* Prime the search buffer. */
1044 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1047 warning ("Unable to access %ld bytes of target "
1048 "memory at 0x%lx, halting search.",
1049 (long) search_buf_size
, (long) start_addr
);
1053 /* Perform the search.
1055 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1056 When we've scanned N bytes we copy the trailing bytes to the start and
1057 read in another N bytes. */
1059 while (search_space_len
>= pattern_len
)
1061 gdb_byte
*found_ptr
;
1062 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1066 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1069 if (found_ptr
!= NULL
)
1071 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1072 *found_addrp
= found_addr
;
1076 /* Not found in this chunk, skip to next chunk. */
1078 /* Don't let search_space_len wrap here, it's unsigned. */
1079 if (search_space_len
>= chunk_size
)
1080 search_space_len
-= chunk_size
;
1082 search_space_len
= 0;
1084 if (search_space_len
>= pattern_len
)
1086 unsigned keep_len
= search_buf_size
- chunk_size
;
1087 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1090 /* Copy the trailing part of the previous iteration to the front
1091 of the buffer for the next iteration. */
1092 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1094 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1095 ? search_space_len
- keep_len
1098 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1099 nr_to_read
) != search_buf_size
)
1101 warning ("Unable to access %ld bytes of target memory "
1102 "at 0x%lx, halting search.",
1103 (long) nr_to_read
, (long) read_addr
);
1107 start_addr
+= chunk_size
;
1116 /* Handle qSearch:memory packets. */
1119 handle_search_memory (char *own_buf
, int packet_len
)
1121 CORE_ADDR start_addr
;
1122 CORE_ADDR search_space_len
;
1124 unsigned int pattern_len
;
1125 /* NOTE: also defined in find.c testcase. */
1126 #define SEARCH_CHUNK_SIZE 16000
1127 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1128 /* Buffer to hold memory contents for searching. */
1129 gdb_byte
*search_buf
;
1130 unsigned search_buf_size
;
1132 CORE_ADDR found_addr
;
1133 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1135 pattern
= (gdb_byte
*) malloc (packet_len
);
1136 if (pattern
== NULL
)
1138 error ("Unable to allocate memory to perform the search");
1139 strcpy (own_buf
, "E00");
1142 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1143 packet_len
- cmd_name_len
,
1144 &start_addr
, &search_space_len
,
1145 pattern
, &pattern_len
) < 0)
1148 error ("Error in parsing qSearch:memory packet");
1149 strcpy (own_buf
, "E00");
1153 search_buf_size
= chunk_size
+ pattern_len
- 1;
1155 /* No point in trying to allocate a buffer larger than the search space. */
1156 if (search_space_len
< search_buf_size
)
1157 search_buf_size
= search_space_len
;
1159 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1160 if (search_buf
== NULL
)
1163 error ("Unable to allocate memory to perform the search");
1164 strcpy (own_buf
, "E00");
1168 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1169 pattern
, pattern_len
,
1170 search_buf
, chunk_size
, search_buf_size
,
1174 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1175 else if (found
== 0)
1176 strcpy (own_buf
, "0");
1178 strcpy (own_buf
, "E00");
1184 /* Handle the "D" packet. */
1187 handle_detach (char *own_buf
)
1189 require_running_or_return (own_buf
);
1196 pid
= strtol (&own_buf
[2], NULL
, 16);
1199 pid
= ptid_get_pid (current_ptid
);
1201 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1203 struct process_info
*process
= find_process_pid (pid
);
1205 if (process
== NULL
)
1207 write_enn (own_buf
);
1211 if (tracing
&& disconnected_tracing
)
1213 "Disconnected tracing in effect, "
1214 "leaving gdbserver attached to the process\n");
1216 if (any_persistent_commands ())
1218 "Persistent commands are present, "
1219 "leaving gdbserver attached to the process\n");
1221 /* Make sure we're in non-stop/async mode, so we we can both
1222 wait for an async socket accept, and handle async target
1223 events simultaneously. There's also no point either in
1224 having the target stop all threads, when we're going to
1225 pass signals down without informing GDB. */
1229 debug_printf ("Forcing non-stop mode\n");
1235 process
->gdb_detached
= 1;
1237 /* Detaching implicitly resumes all threads. */
1238 target_continue_no_signal (minus_one_ptid
);
1244 fprintf (stderr
, "Detaching from process %d\n", pid
);
1246 if (detach_inferior (pid
) != 0)
1247 write_enn (own_buf
);
1250 discard_queued_stop_replies (pid_to_ptid (pid
));
1253 if (extended_protocol
|| target_running ())
1255 /* There is still at least one inferior remaining or
1256 we are in extended mode, so don't terminate gdbserver,
1257 and instead treat this like a normal program exit. */
1258 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1259 last_status
.value
.integer
= 0;
1260 last_ptid
= pid_to_ptid (pid
);
1262 current_thread
= NULL
;
1269 /* If we are attached, then we can exit. Otherwise, we
1270 need to hang around doing nothing, until the child is
1272 join_inferior (pid
);
1278 /* Parse options to --debug-format= and "monitor set debug-format".
1279 ARG is the text after "--debug-format=" or "monitor set debug-format".
1280 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1281 This triggers calls to monitor_output.
1282 The result is NULL if all options were parsed ok, otherwise an error
1283 message which the caller must free.
1285 N.B. These commands affect all debug format settings, they are not
1286 cumulative. If a format is not specified, it is turned off.
1287 However, we don't go to extra trouble with things like
1288 "monitor set debug-format all,none,timestamp".
1289 Instead we just parse them one at a time, in order.
1291 The syntax for "monitor set debug" we support here is not identical
1292 to gdb's "set debug foo on|off" because we also use this function to
1293 parse "--debug-format=foo,bar". */
1296 parse_debug_format_options (const char *arg
, int is_monitor
)
1298 VEC (char_ptr
) *options
;
1302 /* First turn all debug format options off. */
1303 debug_timestamp
= 0;
1305 /* First remove leading spaces, for "monitor set debug-format". */
1306 while (isspace (*arg
))
1309 options
= delim_string_to_char_ptr_vec (arg
, ',');
1311 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1313 if (strcmp (option
, "all") == 0)
1315 debug_timestamp
= 1;
1317 monitor_output ("All extra debug format options enabled.\n");
1319 else if (strcmp (option
, "none") == 0)
1321 debug_timestamp
= 0;
1323 monitor_output ("All extra debug format options disabled.\n");
1325 else if (strcmp (option
, "timestamp") == 0)
1327 debug_timestamp
= 1;
1329 monitor_output ("Timestamps will be added to debug output.\n");
1331 else if (*option
== '\0')
1333 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1339 = string_printf ("Unknown debug-format argument: \"%s\"\n", option
);
1341 free_char_ptr_vec (options
);
1346 free_char_ptr_vec (options
);
1347 return std::string ();
1350 /* Handle monitor commands not handled by target-specific handlers. */
1353 handle_monitor_command (char *mon
, char *own_buf
)
1355 if (strcmp (mon
, "set debug 1") == 0)
1358 monitor_output ("Debug output enabled.\n");
1360 else if (strcmp (mon
, "set debug 0") == 0)
1363 monitor_output ("Debug output disabled.\n");
1365 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1367 show_debug_regs
= 1;
1368 monitor_output ("H/W point debugging output enabled.\n");
1370 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1372 show_debug_regs
= 0;
1373 monitor_output ("H/W point debugging output disabled.\n");
1375 else if (strcmp (mon
, "set remote-debug 1") == 0)
1378 monitor_output ("Protocol debug output enabled.\n");
1380 else if (strcmp (mon
, "set remote-debug 0") == 0)
1383 monitor_output ("Protocol debug output disabled.\n");
1385 else if (startswith (mon
, "set debug-format "))
1387 std::string error_msg
1388 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1391 if (!error_msg
.empty ())
1393 monitor_output (error_msg
.c_str ());
1394 monitor_show_help ();
1395 write_enn (own_buf
);
1398 else if (strcmp (mon
, "help") == 0)
1399 monitor_show_help ();
1400 else if (strcmp (mon
, "exit") == 0)
1404 monitor_output ("Unknown monitor command.\n\n");
1405 monitor_show_help ();
1406 write_enn (own_buf
);
1410 /* Associates a callback with each supported qXfer'able object. */
1414 /* The object this handler handles. */
1417 /* Request that the target transfer up to LEN 8-bit bytes of the
1418 target's OBJECT. The OFFSET, for a seekable object, specifies
1419 the starting point. The ANNEX can be used to provide additional
1420 data-specific information to the target.
1422 Return the number of bytes actually transfered, zero when no
1423 further transfer is possible, -1 on error, -2 when the transfer
1424 is not supported, and -3 on a verbose error message that should
1425 be preserved. Return of a positive value smaller than LEN does
1426 not indicate the end of the object, only the end of the transfer.
1428 One, and only one, of readbuf or writebuf must be non-NULL. */
1429 int (*xfer
) (const char *annex
,
1430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1431 ULONGEST offset
, LONGEST len
);
1434 /* Handle qXfer:auxv:read. */
1437 handle_qxfer_auxv (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
)
1441 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1444 if (annex
[0] != '\0' || current_thread
== NULL
)
1447 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1450 /* Handle qXfer:exec-file:read. */
1453 handle_qxfer_exec_file (const char *annex
,
1454 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1455 ULONGEST offset
, LONGEST len
)
1461 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1464 if (annex
[0] == '\0')
1466 if (current_thread
== NULL
)
1469 pid
= pid_of (current_thread
);
1473 annex
= unpack_varlen_hex (annex
, &pid
);
1474 if (annex
[0] != '\0')
1481 file
= (*the_target
->pid_to_exec_file
) (pid
);
1485 total_len
= strlen (file
);
1487 if (offset
> total_len
)
1490 if (offset
+ len
> total_len
)
1491 len
= total_len
- offset
;
1493 memcpy (readbuf
, file
+ offset
, len
);
1497 /* Handle qXfer:features:read. */
1500 handle_qxfer_features (const char *annex
,
1501 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1502 ULONGEST offset
, LONGEST len
)
1504 const char *document
;
1507 if (writebuf
!= NULL
)
1510 if (!target_running ())
1513 /* Grab the correct annex. */
1514 document
= get_features_xml (annex
);
1515 if (document
== NULL
)
1518 total_len
= strlen (document
);
1520 if (offset
> total_len
)
1523 if (offset
+ len
> total_len
)
1524 len
= total_len
- offset
;
1526 memcpy (readbuf
, document
+ offset
, len
);
1530 /* Handle qXfer:libraries:read. */
1533 handle_qxfer_libraries (const char *annex
,
1534 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1535 ULONGEST offset
, LONGEST len
)
1537 if (writebuf
!= NULL
)
1540 if (annex
[0] != '\0' || current_thread
== NULL
)
1543 std::string document
= "<library-list version=\"1.0\">\n";
1545 for (const dll_info
&dll
: all_dlls
)
1546 document
+= string_printf
1547 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1548 dll
.name
.c_str (), (long) dll
.base_addr
);
1550 document
+= "</library-list>\n";
1552 if (offset
> document
.length ())
1555 if (offset
+ len
> document
.length ())
1556 len
= document
.length () - offset
;
1558 memcpy (readbuf
, &document
[offset
], len
);
1563 /* Handle qXfer:libraries-svr4:read. */
1566 handle_qxfer_libraries_svr4 (const char *annex
,
1567 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1568 ULONGEST offset
, LONGEST len
)
1570 if (writebuf
!= NULL
)
1573 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1576 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1579 /* Handle qXfer:osadata:read. */
1582 handle_qxfer_osdata (const char *annex
,
1583 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1584 ULONGEST offset
, LONGEST len
)
1586 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1589 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1592 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1595 handle_qxfer_siginfo (const char *annex
,
1596 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1597 ULONGEST offset
, LONGEST len
)
1599 if (the_target
->qxfer_siginfo
== NULL
)
1602 if (annex
[0] != '\0' || current_thread
== NULL
)
1605 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1608 /* Handle qXfer:spu:read and qXfer:spu:write. */
1611 handle_qxfer_spu (const char *annex
,
1612 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1613 ULONGEST offset
, LONGEST len
)
1615 if (the_target
->qxfer_spu
== NULL
)
1618 if (current_thread
== NULL
)
1621 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1624 /* Handle qXfer:statictrace:read. */
1627 handle_qxfer_statictrace (const char *annex
,
1628 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1629 ULONGEST offset
, LONGEST len
)
1633 if (writebuf
!= NULL
)
1636 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1639 if (traceframe_read_sdata (current_traceframe
, offset
,
1640 readbuf
, len
, &nbytes
))
1645 /* Helper for handle_qxfer_threads_proper.
1646 Emit the XML to describe the thread of INF. */
1649 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1651 ptid_t ptid
= ptid_of (thread
);
1653 int core
= target_core_of_thread (ptid
);
1655 const char *name
= target_thread_name (ptid
);
1658 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1660 write_ptid (ptid_s
, ptid
);
1662 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1666 sprintf (core_s
, "%d", core
);
1667 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1671 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1675 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1676 bin2hex (handle
, handle_s
, handle_len
);
1677 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1680 buffer_xml_printf (buffer
, "/>\n");
1683 /* Helper for handle_qxfer_threads. */
1686 handle_qxfer_threads_proper (struct buffer
*buffer
)
1688 buffer_grow_str (buffer
, "<threads>\n");
1690 for_each_thread ([&] (thread_info
*thread
)
1692 handle_qxfer_threads_worker (thread
, buffer
);
1695 buffer_grow_str0 (buffer
, "</threads>\n");
1698 /* Handle qXfer:threads:read. */
1701 handle_qxfer_threads (const char *annex
,
1702 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1703 ULONGEST offset
, LONGEST len
)
1705 static char *result
= 0;
1706 static unsigned int result_length
= 0;
1708 if (writebuf
!= NULL
)
1711 if (annex
[0] != '\0')
1716 struct buffer buffer
;
1717 /* When asked for data at offset 0, generate everything and store into
1718 'result'. Successive reads will be served off 'result'. */
1722 buffer_init (&buffer
);
1724 handle_qxfer_threads_proper (&buffer
);
1726 result
= buffer_finish (&buffer
);
1727 result_length
= strlen (result
);
1728 buffer_free (&buffer
);
1731 if (offset
>= result_length
)
1733 /* We're out of data. */
1740 if (len
> result_length
- offset
)
1741 len
= result_length
- offset
;
1743 memcpy (readbuf
, result
+ offset
, len
);
1748 /* Handle qXfer:traceframe-info:read. */
1751 handle_qxfer_traceframe_info (const char *annex
,
1752 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1753 ULONGEST offset
, LONGEST len
)
1755 static char *result
= 0;
1756 static unsigned int result_length
= 0;
1758 if (writebuf
!= NULL
)
1761 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1766 struct buffer buffer
;
1768 /* When asked for data at offset 0, generate everything and
1769 store into 'result'. Successive reads will be served off
1773 buffer_init (&buffer
);
1775 traceframe_read_info (current_traceframe
, &buffer
);
1777 result
= buffer_finish (&buffer
);
1778 result_length
= strlen (result
);
1779 buffer_free (&buffer
);
1782 if (offset
>= result_length
)
1784 /* We're out of data. */
1791 if (len
> result_length
- offset
)
1792 len
= result_length
- offset
;
1794 memcpy (readbuf
, result
+ offset
, len
);
1798 /* Handle qXfer:fdpic:read. */
1801 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1802 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1804 if (the_target
->read_loadmap
== NULL
)
1807 if (current_thread
== NULL
)
1810 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1813 /* Handle qXfer:btrace:read. */
1816 handle_qxfer_btrace (const char *annex
,
1817 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1818 ULONGEST offset
, LONGEST len
)
1820 static struct buffer cache
;
1821 struct thread_info
*thread
;
1822 enum btrace_read_type type
;
1825 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1828 if (ptid_equal (general_thread
, null_ptid
)
1829 || ptid_equal (general_thread
, minus_one_ptid
))
1831 strcpy (own_buf
, "E.Must select a single thread.");
1835 thread
= find_thread_ptid (general_thread
);
1838 strcpy (own_buf
, "E.No such thread.");
1842 if (thread
->btrace
== NULL
)
1844 strcpy (own_buf
, "E.Btrace not enabled.");
1848 if (strcmp (annex
, "all") == 0)
1849 type
= BTRACE_READ_ALL
;
1850 else if (strcmp (annex
, "new") == 0)
1851 type
= BTRACE_READ_NEW
;
1852 else if (strcmp (annex
, "delta") == 0)
1853 type
= BTRACE_READ_DELTA
;
1856 strcpy (own_buf
, "E.Bad annex.");
1862 buffer_free (&cache
);
1864 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1867 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1871 else if (offset
> cache
.used_size
)
1873 buffer_free (&cache
);
1877 if (len
> cache
.used_size
- offset
)
1878 len
= cache
.used_size
- offset
;
1880 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1885 /* Handle qXfer:btrace-conf:read. */
1888 handle_qxfer_btrace_conf (const char *annex
,
1889 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1890 ULONGEST offset
, LONGEST len
)
1892 static struct buffer cache
;
1893 struct thread_info
*thread
;
1896 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1899 if (annex
[0] != '\0')
1902 if (ptid_equal (general_thread
, null_ptid
)
1903 || ptid_equal (general_thread
, minus_one_ptid
))
1905 strcpy (own_buf
, "E.Must select a single thread.");
1909 thread
= find_thread_ptid (general_thread
);
1912 strcpy (own_buf
, "E.No such thread.");
1916 if (thread
->btrace
== NULL
)
1918 strcpy (own_buf
, "E.Btrace not enabled.");
1924 buffer_free (&cache
);
1926 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1929 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1933 else if (offset
> cache
.used_size
)
1935 buffer_free (&cache
);
1939 if (len
> cache
.used_size
- offset
)
1940 len
= cache
.used_size
- offset
;
1942 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1947 static const struct qxfer qxfer_packets
[] =
1949 { "auxv", handle_qxfer_auxv
},
1950 { "btrace", handle_qxfer_btrace
},
1951 { "btrace-conf", handle_qxfer_btrace_conf
},
1952 { "exec-file", handle_qxfer_exec_file
},
1953 { "fdpic", handle_qxfer_fdpic
},
1954 { "features", handle_qxfer_features
},
1955 { "libraries", handle_qxfer_libraries
},
1956 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1957 { "osdata", handle_qxfer_osdata
},
1958 { "siginfo", handle_qxfer_siginfo
},
1959 { "spu", handle_qxfer_spu
},
1960 { "statictrace", handle_qxfer_statictrace
},
1961 { "threads", handle_qxfer_threads
},
1962 { "traceframe-info", handle_qxfer_traceframe_info
},
1966 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1974 if (!startswith (own_buf
, "qXfer:"))
1977 /* Grab the object, r/w and annex. */
1978 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1980 write_enn (own_buf
);
1985 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1988 const struct qxfer
*q
= &qxfer_packets
[i
];
1990 if (strcmp (object
, q
->object
) == 0)
1992 if (strcmp (rw
, "read") == 0)
1994 unsigned char *data
;
1999 /* Grab the offset and length. */
2000 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2002 write_enn (own_buf
);
2006 /* Read one extra byte, as an indicator of whether there is
2008 if (len
> PBUFSIZ
- 2)
2010 data
= (unsigned char *) malloc (len
+ 1);
2013 write_enn (own_buf
);
2016 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2024 /* Preserve error message. */
2027 write_enn (own_buf
);
2029 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2031 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2036 else if (strcmp (rw
, "write") == 0)
2041 unsigned char *data
;
2043 strcpy (own_buf
, "E00");
2044 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2047 write_enn (own_buf
);
2050 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2051 &ofs
, &len
, data
) < 0)
2054 write_enn (own_buf
);
2058 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2066 /* Preserve error message. */
2069 write_enn (own_buf
);
2071 sprintf (own_buf
, "%x", n
);
2084 /* Compute 32 bit CRC from inferior memory.
2086 On success, return 32 bit CRC.
2087 On failure, return (unsigned long long) -1. */
2089 static unsigned long long
2090 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2094 unsigned char byte
= 0;
2096 /* Return failure if memory read fails. */
2097 if (read_inferior_memory (base
, &byte
, 1) != 0)
2098 return (unsigned long long) -1;
2100 crc
= xcrc32 (&byte
, 1, crc
);
2103 return (unsigned long long) crc
;
2106 /* Add supported btrace packets to BUF. */
2109 supported_btrace_packets (char *buf
)
2111 strcat (buf
, ";Qbtrace:bts+");
2112 strcat (buf
, ";Qbtrace-conf:bts:size+");
2113 strcat (buf
, ";Qbtrace:pt+");
2114 strcat (buf
, ";Qbtrace-conf:pt:size+");
2115 strcat (buf
, ";Qbtrace:off+");
2116 strcat (buf
, ";qXfer:btrace:read+");
2117 strcat (buf
, ";qXfer:btrace-conf:read+");
2120 /* Handle all of the extended 'q' packets. */
2123 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2125 static std::list
<thread_info
*>::const_iterator thread_iter
;
2127 /* Reply the current thread id. */
2128 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2131 require_running_or_return (own_buf
);
2133 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2134 ptid
= general_thread
;
2137 thread_iter
= all_threads
.begin ();
2138 ptid
= (*thread_iter
)->id
;
2141 sprintf (own_buf
, "QC");
2143 write_ptid (own_buf
, ptid
);
2147 if (strcmp ("qSymbol::", own_buf
) == 0)
2149 struct thread_info
*save_thread
= current_thread
;
2151 /* For qSymbol, GDB only changes the current thread if the
2152 previous current thread was of a different process. So if
2153 the previous thread is gone, we need to pick another one of
2154 the same process. This can happen e.g., if we followed an
2155 exec in a non-leader thread. */
2156 if (current_thread
== NULL
)
2159 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2161 /* Just in case, if we didn't find a thread, then bail out
2162 instead of crashing. */
2163 if (current_thread
== NULL
)
2165 write_enn (own_buf
);
2166 current_thread
= save_thread
;
2171 /* GDB is suggesting new symbols have been loaded. This may
2172 mean a new shared library has been detected as loaded, so
2173 take the opportunity to check if breakpoints we think are
2174 inserted, still are. Note that it isn't guaranteed that
2175 we'll see this when a shared library is loaded, and nor will
2176 we see this for unloads (although breakpoints in unloaded
2177 libraries shouldn't trigger), as GDB may not find symbols for
2178 the library at all. We also re-validate breakpoints when we
2179 see a second GDB breakpoint for the same address, and or when
2180 we access breakpoint shadows. */
2181 validate_breakpoints ();
2183 if (target_supports_tracepoints ())
2184 tracepoint_look_up_symbols ();
2186 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2187 (*the_target
->look_up_symbols
) ();
2189 current_thread
= save_thread
;
2191 strcpy (own_buf
, "OK");
2195 if (!disable_packet_qfThreadInfo
)
2197 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2199 require_running_or_return (own_buf
);
2200 thread_iter
= all_threads
.begin ();
2203 ptid_t ptid
= (*thread_iter
)->id
;
2204 write_ptid (own_buf
, ptid
);
2209 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2211 require_running_or_return (own_buf
);
2212 if (thread_iter
!= all_threads
.end ())
2215 ptid_t ptid
= (*thread_iter
)->id
;
2216 write_ptid (own_buf
, ptid
);
2222 sprintf (own_buf
, "l");
2228 if (the_target
->read_offsets
!= NULL
2229 && strcmp ("qOffsets", own_buf
) == 0)
2231 CORE_ADDR text
, data
;
2233 require_running_or_return (own_buf
);
2234 if (the_target
->read_offsets (&text
, &data
))
2235 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2236 (long)text
, (long)data
, (long)data
);
2238 write_enn (own_buf
);
2243 /* Protocol features query. */
2244 if (startswith (own_buf
, "qSupported")
2245 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2247 char *p
= &own_buf
[10];
2248 int gdb_supports_qRelocInsn
= 0;
2250 /* Process each feature being provided by GDB. The first
2251 feature will follow a ':', and latter features will follow
2255 char **qsupported
= NULL
;
2260 /* Two passes, to avoid nested strtok calls in
2261 target_process_qsupported. */
2262 for (p
= strtok (p
+ 1, ";");
2264 p
= strtok (NULL
, ";"))
2267 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2268 qsupported
[count
- 1] = xstrdup (p
);
2271 for (i
= 0; i
< count
; i
++)
2274 if (strcmp (p
, "multiprocess+") == 0)
2276 /* GDB supports and wants multi-process support if
2278 if (target_supports_multi_process ())
2281 else if (strcmp (p
, "qRelocInsn+") == 0)
2283 /* GDB supports relocate instruction requests. */
2284 gdb_supports_qRelocInsn
= 1;
2286 else if (strcmp (p
, "swbreak+") == 0)
2288 /* GDB wants us to report whether a trap is caused
2289 by a software breakpoint and for us to handle PC
2290 adjustment if necessary on this target. */
2291 if (target_supports_stopped_by_sw_breakpoint ())
2292 swbreak_feature
= 1;
2294 else if (strcmp (p
, "hwbreak+") == 0)
2296 /* GDB wants us to report whether a trap is caused
2297 by a hardware breakpoint. */
2298 if (target_supports_stopped_by_hw_breakpoint ())
2299 hwbreak_feature
= 1;
2301 else if (strcmp (p
, "fork-events+") == 0)
2303 /* GDB supports and wants fork events if possible. */
2304 if (target_supports_fork_events ())
2305 report_fork_events
= 1;
2307 else if (strcmp (p
, "vfork-events+") == 0)
2309 /* GDB supports and wants vfork events if possible. */
2310 if (target_supports_vfork_events ())
2311 report_vfork_events
= 1;
2313 else if (strcmp (p
, "exec-events+") == 0)
2315 /* GDB supports and wants exec events if possible. */
2316 if (target_supports_exec_events ())
2317 report_exec_events
= 1;
2319 else if (strcmp (p
, "vContSupported+") == 0)
2320 vCont_supported
= 1;
2321 else if (strcmp (p
, "QThreadEvents+") == 0)
2323 else if (strcmp (p
, "no-resumed+") == 0)
2325 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2327 report_no_resumed
= 1;
2331 /* Move the unknown features all together. */
2332 qsupported
[i
] = NULL
;
2333 qsupported
[unknown
] = p
;
2338 /* Give the target backend a chance to process the unknown
2340 target_process_qsupported (qsupported
, unknown
);
2342 for (i
= 0; i
< count
; i
++)
2343 free (qsupported
[i
]);
2348 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2349 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2350 "QEnvironmentReset+;QEnvironmentUnset+;"
2354 if (target_supports_catch_syscall ())
2355 strcat (own_buf
, ";QCatchSyscalls+");
2357 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2358 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2359 ";augmented-libraries-svr4-read+");
2362 /* We do not have any hook to indicate whether the non-SVR4 target
2363 backend supports qXfer:libraries:read, so always report it. */
2364 strcat (own_buf
, ";qXfer:libraries:read+");
2367 if (the_target
->read_auxv
!= NULL
)
2368 strcat (own_buf
, ";qXfer:auxv:read+");
2370 if (the_target
->qxfer_spu
!= NULL
)
2371 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2373 if (the_target
->qxfer_siginfo
!= NULL
)
2374 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2376 if (the_target
->read_loadmap
!= NULL
)
2377 strcat (own_buf
, ";qXfer:fdpic:read+");
2379 /* We always report qXfer:features:read, as targets may
2380 install XML files on a subsequent call to arch_setup.
2381 If we reported to GDB on startup that we don't support
2382 qXfer:feature:read at all, we will never be re-queried. */
2383 strcat (own_buf
, ";qXfer:features:read+");
2385 if (transport_is_reliable
)
2386 strcat (own_buf
, ";QStartNoAckMode+");
2388 if (the_target
->qxfer_osdata
!= NULL
)
2389 strcat (own_buf
, ";qXfer:osdata:read+");
2391 if (target_supports_multi_process ())
2392 strcat (own_buf
, ";multiprocess+");
2394 if (target_supports_fork_events ())
2395 strcat (own_buf
, ";fork-events+");
2397 if (target_supports_vfork_events ())
2398 strcat (own_buf
, ";vfork-events+");
2400 if (target_supports_exec_events ())
2401 strcat (own_buf
, ";exec-events+");
2403 if (target_supports_non_stop ())
2404 strcat (own_buf
, ";QNonStop+");
2406 if (target_supports_disable_randomization ())
2407 strcat (own_buf
, ";QDisableRandomization+");
2409 strcat (own_buf
, ";qXfer:threads:read+");
2411 if (target_supports_tracepoints ())
2413 strcat (own_buf
, ";ConditionalTracepoints+");
2414 strcat (own_buf
, ";TraceStateVariables+");
2415 strcat (own_buf
, ";TracepointSource+");
2416 strcat (own_buf
, ";DisconnectedTracing+");
2417 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2418 strcat (own_buf
, ";FastTracepoints+");
2419 strcat (own_buf
, ";StaticTracepoints+");
2420 strcat (own_buf
, ";InstallInTrace+");
2421 strcat (own_buf
, ";qXfer:statictrace:read+");
2422 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2423 strcat (own_buf
, ";EnableDisableTracepoints+");
2424 strcat (own_buf
, ";QTBuffer:size+");
2425 strcat (own_buf
, ";tracenz+");
2428 if (target_supports_hardware_single_step ()
2429 || target_supports_software_single_step () )
2431 strcat (own_buf
, ";ConditionalBreakpoints+");
2433 strcat (own_buf
, ";BreakpointCommands+");
2435 if (target_supports_agent ())
2436 strcat (own_buf
, ";QAgent+");
2438 supported_btrace_packets (own_buf
);
2440 if (target_supports_stopped_by_sw_breakpoint ())
2441 strcat (own_buf
, ";swbreak+");
2443 if (target_supports_stopped_by_hw_breakpoint ())
2444 strcat (own_buf
, ";hwbreak+");
2446 if (the_target
->pid_to_exec_file
!= NULL
)
2447 strcat (own_buf
, ";qXfer:exec-file:read+");
2449 strcat (own_buf
, ";vContSupported+");
2451 strcat (own_buf
, ";QThreadEvents+");
2453 strcat (own_buf
, ";no-resumed+");
2455 /* Reinitialize components as needed for the new connection. */
2456 hostio_handle_new_gdb_connection ();
2457 target_handle_new_gdb_connection ();
2462 /* Thread-local storage support. */
2463 if (the_target
->get_tls_address
!= NULL
2464 && startswith (own_buf
, "qGetTLSAddr:"))
2466 char *p
= own_buf
+ 12;
2467 CORE_ADDR parts
[2], address
= 0;
2469 ptid_t ptid
= null_ptid
;
2471 require_running_or_return (own_buf
);
2473 for (i
= 0; i
< 3; i
++)
2481 p2
= strchr (p
, ',');
2494 ptid
= read_ptid (p
, NULL
);
2496 decode_address (&parts
[i
- 1], p
, len
);
2500 if (p
!= NULL
|| i
< 3)
2504 struct thread_info
*thread
= find_thread_ptid (ptid
);
2509 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2515 strcpy (own_buf
, paddress(address
));
2520 write_enn (own_buf
);
2524 /* Otherwise, pretend we do not understand this packet. */
2527 /* Windows OS Thread Information Block address support. */
2528 if (the_target
->get_tib_address
!= NULL
2529 && startswith (own_buf
, "qGetTIBAddr:"))
2534 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2536 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2539 strcpy (own_buf
, paddress(tlb
));
2544 write_enn (own_buf
);
2550 /* Handle "monitor" commands. */
2551 if (startswith (own_buf
, "qRcmd,"))
2553 char *mon
= (char *) malloc (PBUFSIZ
);
2554 int len
= strlen (own_buf
+ 6);
2558 write_enn (own_buf
);
2563 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2565 write_enn (own_buf
);
2569 mon
[len
/ 2] = '\0';
2573 if (the_target
->handle_monitor_command
== NULL
2574 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2575 /* Default processing. */
2576 handle_monitor_command (mon
, own_buf
);
2582 if (startswith (own_buf
, "qSearch:memory:"))
2584 require_running_or_return (own_buf
);
2585 handle_search_memory (own_buf
, packet_len
);
2589 if (strcmp (own_buf
, "qAttached") == 0
2590 || startswith (own_buf
, "qAttached:"))
2592 struct process_info
*process
;
2594 if (own_buf
[sizeof ("qAttached") - 1])
2596 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2597 process
= find_process_pid (pid
);
2601 require_running_or_return (own_buf
);
2602 process
= current_process ();
2605 if (process
== NULL
)
2607 write_enn (own_buf
);
2611 strcpy (own_buf
, process
->attached
? "1" : "0");
2615 if (startswith (own_buf
, "qCRC:"))
2617 /* CRC check (compare-section). */
2621 unsigned long long crc
;
2623 require_running_or_return (own_buf
);
2624 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2625 if (*comma
++ != ',')
2627 write_enn (own_buf
);
2630 len
= strtoul (comma
, NULL
, 16);
2631 crc
= crc32 (base
, len
, 0xffffffff);
2632 /* Check for memory failure. */
2633 if (crc
== (unsigned long long) -1)
2635 write_enn (own_buf
);
2638 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2642 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2645 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2648 /* Otherwise we didn't know what packet it was. Say we didn't
2653 static void gdb_wants_all_threads_stopped (void);
2654 static void resume (struct thread_resume
*actions
, size_t n
);
2656 /* The callback that is passed to visit_actioned_threads. */
2657 typedef int (visit_actioned_threads_callback_ftype
)
2658 (const struct thread_resume
*, struct thread_info
*);
2660 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2661 true if CALLBACK returns true. Returns false if no matching thread
2662 is found or CALLBACK results false.
2663 Note: This function is itself a callback for find_thread. */
2666 visit_actioned_threads (thread_info
*thread
,
2667 const struct thread_resume
*actions
,
2669 visit_actioned_threads_callback_ftype
*callback
)
2671 for (size_t i
= 0; i
< num_actions
; i
++)
2673 const struct thread_resume
*action
= &actions
[i
];
2675 if (ptid_equal (action
->thread
, minus_one_ptid
)
2676 || ptid_equal (action
->thread
, thread
->id
)
2677 || ((ptid_get_pid (action
->thread
)
2678 == thread
->id
.pid ())
2679 && ptid_get_lwp (action
->thread
) == -1))
2681 if ((*callback
) (action
, thread
))
2689 /* Callback for visit_actioned_threads. If the thread has a pending
2690 status to report, report it now. */
2693 handle_pending_status (const struct thread_resume
*resumption
,
2694 struct thread_info
*thread
)
2696 if (thread
->status_pending_p
)
2698 thread
->status_pending_p
= 0;
2700 last_status
= thread
->last_status
;
2701 last_ptid
= thread
->id
;
2702 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2708 /* Parse vCont packets. */
2710 handle_v_cont (char *own_buf
)
2714 struct thread_resume
*resume_info
;
2715 struct thread_resume default_action
{ null_ptid
};
2717 /* Count the number of semicolons in the packet. There should be one
2718 for every action. */
2724 p
= strchr (p
, ';');
2727 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2728 if (resume_info
== NULL
)
2736 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2738 if (p
[0] == 's' || p
[0] == 'S')
2739 resume_info
[i
].kind
= resume_step
;
2740 else if (p
[0] == 'r')
2741 resume_info
[i
].kind
= resume_step
;
2742 else if (p
[0] == 'c' || p
[0] == 'C')
2743 resume_info
[i
].kind
= resume_continue
;
2744 else if (p
[0] == 't')
2745 resume_info
[i
].kind
= resume_stop
;
2749 if (p
[0] == 'S' || p
[0] == 'C')
2752 int sig
= strtol (p
+ 1, &q
, 16);
2757 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2759 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2761 else if (p
[0] == 'r')
2765 p
= unpack_varlen_hex (p
+ 1, &addr
);
2766 resume_info
[i
].step_range_start
= addr
;
2771 p
= unpack_varlen_hex (p
+ 1, &addr
);
2772 resume_info
[i
].step_range_end
= addr
;
2781 resume_info
[i
].thread
= minus_one_ptid
;
2782 default_action
= resume_info
[i
];
2784 /* Note: we don't increment i here, we'll overwrite this entry
2785 the next time through. */
2787 else if (p
[0] == ':')
2790 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2795 if (p
[0] != ';' && p
[0] != 0)
2798 resume_info
[i
].thread
= ptid
;
2805 resume_info
[i
] = default_action
;
2807 resume (resume_info
, n
);
2812 write_enn (own_buf
);
2817 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2820 resume (struct thread_resume
*actions
, size_t num_actions
)
2824 /* Check if among the threads that GDB wants actioned, there's
2825 one with a pending status to report. If so, skip actually
2826 resuming/stopping and report the pending event
2829 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2831 return visit_actioned_threads (thread
, actions
, num_actions
,
2832 handle_pending_status
);
2835 if (thread_with_status
!= NULL
)
2841 (*the_target
->resume
) (actions
, num_actions
);
2847 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2849 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2850 && !report_no_resumed
)
2852 /* The client does not support this stop reply. At least
2854 sprintf (own_buf
, "E.No unwaited-for children left.");
2855 disable_async_io ();
2859 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2860 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2861 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2862 current_thread
->last_status
= last_status
;
2864 /* From the client's perspective, all-stop mode always stops all
2865 threads implicitly (and the target backend has already done
2866 so by now). Tag all threads as "want-stopped", so we don't
2867 resume them implicitly without the client telling us to. */
2868 gdb_wants_all_threads_stopped ();
2869 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2870 disable_async_io ();
2872 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2873 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2874 target_mourn_inferior (last_ptid
);
2878 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2880 handle_v_attach (char *own_buf
)
2884 pid
= strtol (own_buf
+ 8, NULL
, 16);
2885 if (pid
!= 0 && attach_inferior (pid
) == 0)
2887 /* Don't report shared library events after attaching, even if
2888 some libraries are preloaded. GDB will always poll the
2889 library list. Avoids the "stopped by shared library event"
2890 notice on the GDB side. */
2895 /* In non-stop, we don't send a resume reply. Stop events
2896 will follow up using the normal notification
2901 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2907 write_enn (own_buf
);
2912 /* Run a new program. Return 1 if successful, 0 if failure. */
2914 handle_v_run (char *own_buf
)
2917 std::vector
<char *> new_argv
;
2918 char *new_program_name
= NULL
;
2922 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2928 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2930 next_p
= strchr (p
, ';');
2932 next_p
= p
+ strlen (p
);
2934 if (i
== 0 && p
== next_p
)
2936 /* No program specified. */
2937 new_program_name
= NULL
;
2939 else if (p
== next_p
)
2941 /* Empty argument. */
2942 new_argv
.push_back (xstrdup ("''"));
2946 size_t len
= (next_p
- p
) / 2;
2947 /* ARG is the unquoted argument received via the RSP. */
2948 char *arg
= (char *) xmalloc (len
+ 1);
2949 /* FULL_ARGS will contain the quoted version of ARG. */
2950 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2951 /* These are pointers used to navigate the strings above. */
2952 char *tmp_arg
= arg
;
2953 char *tmp_full_arg
= full_arg
;
2956 hex2bin (p
, (gdb_byte
*) arg
, len
);
2959 while (*tmp_arg
!= '\0')
2965 *tmp_full_arg
= '\'';
2971 /* Quote single quote. */
2972 *tmp_full_arg
= '\\';
2980 *tmp_full_arg
= *tmp_arg
;
2986 *tmp_full_arg
++ = '\'';
2988 /* Finish FULL_ARG and push it into the vector containing
2990 *tmp_full_arg
= '\0';
2992 new_program_name
= full_arg
;
2994 new_argv
.push_back (full_arg
);
3000 new_argv
.push_back (NULL
);
3002 if (new_program_name
== NULL
)
3004 /* GDB didn't specify a program to run. Use the program from the
3005 last run with the new argument list. */
3006 if (program_name
== NULL
)
3008 write_enn (own_buf
);
3009 free_vector_argv (new_argv
);
3015 xfree (program_name
);
3016 program_name
= new_program_name
;
3019 /* Free the old argv and install the new one. */
3020 free_vector_argv (program_args
);
3021 program_args
= new_argv
;
3023 create_inferior (program_name
, program_args
);
3025 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3027 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3029 /* In non-stop, sending a resume reply doesn't set the general
3030 thread, but GDB assumes a vRun sets it (this is so GDB can
3031 query which is the main thread of the new inferior. */
3033 general_thread
= last_ptid
;
3039 write_enn (own_buf
);
3044 /* Kill process. Return 1 if successful, 0 if failure. */
3046 handle_v_kill (char *own_buf
)
3049 char *p
= &own_buf
[6];
3051 pid
= strtol (p
, NULL
, 16);
3054 if (pid
!= 0 && kill_inferior (pid
) == 0)
3056 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3057 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3058 last_ptid
= pid_to_ptid (pid
);
3059 discard_queued_stop_replies (last_ptid
);
3065 write_enn (own_buf
);
3070 /* Handle all of the extended 'v' packets. */
3072 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3074 if (!disable_packet_vCont
)
3076 if (strcmp (own_buf
, "vCtrlC") == 0)
3078 (*the_target
->request_interrupt
) ();
3083 if (startswith (own_buf
, "vCont;"))
3085 handle_v_cont (own_buf
);
3089 if (startswith (own_buf
, "vCont?"))
3091 strcpy (own_buf
, "vCont;c;C;t");
3093 if (target_supports_hardware_single_step ()
3094 || target_supports_software_single_step ()
3095 || !vCont_supported
)
3097 /* If target supports single step either by hardware or by
3098 software, add actions s and S to the list of supported
3099 actions. On the other hand, if GDB doesn't request the
3100 supported vCont actions in qSupported packet, add s and
3101 S to the list too. */
3102 own_buf
= own_buf
+ strlen (own_buf
);
3103 strcpy (own_buf
, ";s;S");
3106 if (target_supports_range_stepping ())
3108 own_buf
= own_buf
+ strlen (own_buf
);
3109 strcpy (own_buf
, ";r");
3115 if (startswith (own_buf
, "vFile:")
3116 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3119 if (startswith (own_buf
, "vAttach;"))
3121 if ((!extended_protocol
|| !multi_process
) && target_running ())
3123 fprintf (stderr
, "Already debugging a process\n");
3124 write_enn (own_buf
);
3127 handle_v_attach (own_buf
);
3131 if (startswith (own_buf
, "vRun;"))
3133 if ((!extended_protocol
|| !multi_process
) && target_running ())
3135 fprintf (stderr
, "Already debugging a process\n");
3136 write_enn (own_buf
);
3139 handle_v_run (own_buf
);
3143 if (startswith (own_buf
, "vKill;"))
3145 if (!target_running ())
3147 fprintf (stderr
, "No process to kill\n");
3148 write_enn (own_buf
);
3151 handle_v_kill (own_buf
);
3155 if (handle_notif_ack (own_buf
, packet_len
))
3158 /* Otherwise we didn't know what packet it was. Say we didn't
3164 /* Resume thread and wait for another event. In non-stop mode,
3165 don't really wait here, but return immediatelly to the event
3168 myresume (char *own_buf
, int step
, int sig
)
3170 struct thread_resume resume_info
[2];
3172 int valid_cont_thread
;
3174 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3175 && !ptid_equal (cont_thread
, minus_one_ptid
));
3177 if (step
|| sig
|| valid_cont_thread
)
3179 resume_info
[0].thread
= current_ptid
;
3181 resume_info
[0].kind
= resume_step
;
3183 resume_info
[0].kind
= resume_continue
;
3184 resume_info
[0].sig
= sig
;
3188 if (!valid_cont_thread
)
3190 resume_info
[n
].thread
= minus_one_ptid
;
3191 resume_info
[n
].kind
= resume_continue
;
3192 resume_info
[n
].sig
= 0;
3196 resume (resume_info
, n
);
3199 /* Callback for for_each_thread. Make a new stop reply for each
3203 queue_stop_reply_callback (thread_info
*thread
)
3205 /* For now, assume targets that don't have this callback also don't
3206 manage the thread's last_status field. */
3207 if (the_target
->thread_stopped
== NULL
)
3209 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3211 new_notif
->ptid
= thread
->id
;
3212 new_notif
->status
= thread
->last_status
;
3213 /* Pass the last stop reply back to GDB, but don't notify
3215 notif_event_enque (¬if_stop
,
3216 (struct notif_event
*) new_notif
);
3220 if (thread_stopped (thread
))
3224 std::string status_string
3225 = target_waitstatus_to_string (&thread
->last_status
);
3227 debug_printf ("Reporting thread %s as already stopped with %s\n",
3228 target_pid_to_str (thread
->id
),
3229 status_string
.c_str ());
3232 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3234 /* Pass the last stop reply back to GDB, but don't notify
3236 queue_stop_reply (thread
->id
, &thread
->last_status
);
3241 /* Set this inferior threads's state as "want-stopped". We won't
3242 resume this thread until the client gives us another action for
3246 gdb_wants_thread_stopped (thread_info
*thread
)
3248 thread
->last_resume_kind
= resume_stop
;
3250 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3252 /* Most threads are stopped implicitly (all-stop); tag that with
3254 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3255 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3259 /* Set all threads' states as "want-stopped". */
3262 gdb_wants_all_threads_stopped (void)
3264 for_each_thread (gdb_wants_thread_stopped
);
3267 /* Callback for for_each_thread. If the thread is stopped with an
3268 interesting event, mark it as having a pending event. */
3271 set_pending_status_callback (thread_info
*thread
)
3273 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3274 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3275 /* A breakpoint, watchpoint or finished step from a previous
3276 GDB run isn't considered interesting for a new GDB run.
3277 If we left those pending, the new GDB could consider them
3278 random SIGTRAPs. This leaves out real async traps. We'd
3279 have to peek into the (target-specific) siginfo to
3280 distinguish those. */
3281 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3282 thread
->status_pending_p
= 1;
3285 /* Status handler for the '?' packet. */
3288 handle_status (char *own_buf
)
3290 /* GDB is connected, don't forward events to the target anymore. */
3291 for_each_process ([] (process_info
*process
) {
3292 process
->gdb_detached
= 0;
3295 /* In non-stop mode, we must send a stop reply for each stopped
3296 thread. In all-stop mode, just send one for the first stopped
3301 for_each_thread (queue_stop_reply_callback
);
3303 /* The first is sent immediatly. OK is sent if there is no
3304 stopped thread, which is the same handling of the vStopped
3305 packet (by design). */
3306 notif_write_event (¬if_stop
, own_buf
);
3310 thread_info
*thread
= NULL
;
3313 stabilize_threads ();
3314 gdb_wants_all_threads_stopped ();
3316 /* We can only report one status, but we might be coming out of
3317 non-stop -- if more than one thread is stopped with
3318 interesting events, leave events for the threads we're not
3319 reporting now pending. They'll be reported the next time the
3320 threads are resumed. Start by marking all interesting events
3322 for_each_thread (set_pending_status_callback
);
3324 /* Prefer the last thread that reported an event to GDB (even if
3325 that was a GDB_SIGNAL_TRAP). */
3326 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3327 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3328 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3329 thread
= find_thread_ptid (last_ptid
);
3331 /* If the last event thread is not found for some reason, look
3332 for some other thread that might have an event to report. */
3334 thread
= find_thread ([] (thread_info
*thread
)
3336 return thread
->status_pending_p
;
3339 /* If we're still out of luck, simply pick the first thread in
3342 thread
= get_first_thread ();
3346 struct thread_info
*tp
= (struct thread_info
*) thread
;
3348 /* We're reporting this event, so it's no longer
3350 tp
->status_pending_p
= 0;
3352 /* GDB assumes the current thread is the thread we're
3353 reporting the status for. */
3354 general_thread
= thread
->id
;
3355 set_desired_thread ();
3357 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3358 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3361 strcpy (own_buf
, "W00");
3366 gdbserver_version (void)
3368 printf ("GNU gdbserver %s%s\n"
3369 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3370 "gdbserver is free software, covered by the "
3371 "GNU General Public License.\n"
3372 "This gdbserver was configured as \"%s\"\n",
3373 PKGVERSION
, version
, host_name
);
3377 gdbserver_usage (FILE *stream
)
3379 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3380 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3381 "\tgdbserver [OPTIONS] --multi COMM\n"
3383 "COMM may either be a tty device (for serial debugging),\n"
3384 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3385 "stdin/stdout of gdbserver.\n"
3386 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3387 "PID is the process ID to attach to, when --attach is specified.\n"
3389 "Operating modes:\n"
3391 " --attach Attach to running process PID.\n"
3392 " --multi Start server without a specific program, and\n"
3393 " only quit when explicitly commanded.\n"
3394 " --once Exit after the first connection has closed.\n"
3395 " --help Print this message and then exit.\n"
3396 " --version Display version information and exit.\n"
3400 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3401 " --disable-randomization\n"
3402 " Run PROG with address space randomization disabled.\n"
3403 " --no-disable-randomization\n"
3404 " Don't disable address space randomization when\n"
3406 " --startup-with-shell\n"
3407 " Start PROG using a shell. I.e., execs a shell that\n"
3408 " then execs PROG. (default)\n"
3409 " --no-startup-with-shell\n"
3410 " Exec PROG directly instead of using a shell.\n"
3411 " Disables argument globbing and variable substitution\n"
3412 " on UNIX-like systems.\n"
3416 " --debug Enable general debugging output.\n"
3417 " --debug-format=opt1[,opt2,...]\n"
3418 " Specify extra content in debugging output.\n"
3423 " --remote-debug Enable remote protocol debugging output.\n"
3424 " --disable-packet=opt1[,opt2,...]\n"
3425 " Disable support for RSP packets or features.\n"
3427 " vCont, Tthread, qC, qfThreadInfo and \n"
3428 " threads (disable all threading packets).\n"
3430 "For more information, consult the GDB manual (available as on-line \n"
3431 "info or a printed manual).\n");
3432 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3433 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3437 gdbserver_show_disableable (FILE *stream
)
3439 fprintf (stream
, "Disableable packets:\n"
3440 " vCont \tAll vCont packets\n"
3441 " qC \tQuerying the current thread\n"
3442 " qfThreadInfo\tThread listing\n"
3443 " Tthread \tPassing the thread specifier in the "
3444 "T stop reply packet\n"
3445 " threads \tAll of the above\n");
3449 kill_inferior_callback (process_info
*process
)
3451 int pid
= process
->pid
;
3453 kill_inferior (pid
);
3454 discard_queued_stop_replies (pid_to_ptid (pid
));
3457 /* Call this when exiting gdbserver with possible inferiors that need
3458 to be killed or detached from. */
3461 detach_or_kill_for_exit (void)
3463 /* First print a list of the inferiors we will be killing/detaching.
3464 This is to assist the user, for example, in case the inferior unexpectedly
3465 dies after we exit: did we screw up or did the inferior exit on its own?
3466 Having this info will save some head-scratching. */
3468 if (have_started_inferiors_p ())
3470 fprintf (stderr
, "Killing process(es):");
3472 for_each_process ([] (process_info
*process
) {
3473 if (!process
->attached
)
3474 fprintf (stderr
, " %d", process
->pid
);
3477 fprintf (stderr
, "\n");
3479 if (have_attached_inferiors_p ())
3481 fprintf (stderr
, "Detaching process(es):");
3483 for_each_process ([] (process_info
*process
) {
3484 if (process
->attached
)
3485 fprintf (stderr
, " %d", process
->pid
);
3488 fprintf (stderr
, "\n");
3491 /* Now we can kill or detach the inferiors. */
3492 for_each_process ([] (process_info
*process
) {
3493 int pid
= process
->pid
;
3495 if (process
->attached
)
3496 detach_inferior (pid
);
3498 kill_inferior (pid
);
3500 discard_queued_stop_replies (pid_to_ptid (pid
));
3504 /* Value that will be passed to exit(3) when gdbserver exits. */
3505 static int exit_code
;
3507 /* Cleanup version of detach_or_kill_for_exit. */
3510 detach_or_kill_for_exit_cleanup (void *ignore
)
3515 detach_or_kill_for_exit ();
3518 CATCH (exception
, RETURN_MASK_ALL
)
3521 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3527 /* Main function. This is called by the real "main" function,
3528 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3530 static void ATTRIBUTE_NORETURN
3531 captured_main (int argc
, char *argv
[])
3536 const char *port
= NULL
;
3537 char **next_arg
= &argv
[1];
3538 volatile int multi_mode
= 0;
3539 volatile int attach
= 0;
3541 bool selftest
= false;
3543 const char *selftest_filter
= NULL
;
3546 current_directory
= getcwd (NULL
, 0);
3547 if (current_directory
== NULL
)
3549 error (_("%s: error finding working directory"),
3550 safe_strerror (errno
));
3553 while (*next_arg
!= NULL
&& **next_arg
== '-')
3555 if (strcmp (*next_arg
, "--version") == 0)
3557 gdbserver_version ();
3560 else if (strcmp (*next_arg
, "--help") == 0)
3562 gdbserver_usage (stdout
);
3565 else if (strcmp (*next_arg
, "--attach") == 0)
3567 else if (strcmp (*next_arg
, "--multi") == 0)
3569 else if (strcmp (*next_arg
, "--wrapper") == 0)
3576 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3578 wrapper_argv
+= *next_arg
;
3579 wrapper_argv
+= ' ';
3583 if (!wrapper_argv
.empty ())
3585 /* Erase the last whitespace. */
3586 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3589 if (next_arg
== tmp
|| *next_arg
== NULL
)
3591 gdbserver_usage (stderr
);
3595 /* Consume the "--". */
3598 else if (strcmp (*next_arg
, "--debug") == 0)
3600 else if (startswith (*next_arg
, "--debug-format="))
3602 std::string error_msg
3603 = parse_debug_format_options ((*next_arg
)
3604 + sizeof ("--debug-format=") - 1, 0);
3606 if (!error_msg
.empty ())
3608 fprintf (stderr
, "%s", error_msg
.c_str ());
3612 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3614 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3616 gdbserver_show_disableable (stdout
);
3619 else if (startswith (*next_arg
, "--disable-packet="))
3621 char *packets
, *tok
;
3623 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3624 for (tok
= strtok (packets
, ",");
3626 tok
= strtok (NULL
, ","))
3628 if (strcmp ("vCont", tok
) == 0)
3629 disable_packet_vCont
= 1;
3630 else if (strcmp ("Tthread", tok
) == 0)
3631 disable_packet_Tthread
= 1;
3632 else if (strcmp ("qC", tok
) == 0)
3633 disable_packet_qC
= 1;
3634 else if (strcmp ("qfThreadInfo", tok
) == 0)
3635 disable_packet_qfThreadInfo
= 1;
3636 else if (strcmp ("threads", tok
) == 0)
3638 disable_packet_vCont
= 1;
3639 disable_packet_Tthread
= 1;
3640 disable_packet_qC
= 1;
3641 disable_packet_qfThreadInfo
= 1;
3645 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3647 gdbserver_show_disableable (stderr
);
3652 else if (strcmp (*next_arg
, "-") == 0)
3654 /* "-" specifies a stdio connection and is a form of port
3656 port
= STDIO_CONNECTION_NAME
;
3660 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3661 disable_randomization
= 1;
3662 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3663 disable_randomization
= 0;
3664 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3665 startup_with_shell
= true;
3666 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3667 startup_with_shell
= false;
3668 else if (strcmp (*next_arg
, "--once") == 0)
3670 else if (strcmp (*next_arg
, "--selftest") == 0)
3672 else if (startswith (*next_arg
, "--selftest="))
3676 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3681 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3694 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3697 gdbserver_usage (stderr
);
3701 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3702 opened by remote_prepare. */
3705 save_original_signals_state (false);
3707 /* We need to know whether the remote connection is stdio before
3708 starting the inferior. Inferiors created in this scenario have
3709 stdin,stdout redirected. So do this here before we call
3712 remote_prepare (port
);
3717 /* --attach used to come after PORT, so allow it there for
3719 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3726 && (*next_arg
== NULL
3727 || (*next_arg
)[0] == '\0'
3728 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3730 || next_arg
[1] != NULL
))
3735 gdbserver_usage (stderr
);
3739 /* Gather information about the environment. */
3740 our_environ
= gdb_environ::from_host_environ ();
3742 initialize_async_io ();
3744 have_job_control ();
3745 initialize_event_loop ();
3746 if (target_supports_tracepoints ())
3747 initialize_tracepoint ();
3748 initialize_notif ();
3750 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3751 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3756 selftests::run_tests (selftest_filter
);
3758 printf (_("Selftests are not available in a non-development build.\n"));
3760 throw_quit ("Quit");
3763 if (pid
== 0 && *next_arg
!= NULL
)
3767 n
= argc
- (next_arg
- argv
);
3768 program_name
= xstrdup (next_arg
[0]);
3769 for (i
= 1; i
< n
; i
++)
3770 program_args
.push_back (xstrdup (next_arg
[i
]));
3771 program_args
.push_back (NULL
);
3773 /* Wait till we are at first instruction in program. */
3774 create_inferior (program_name
, program_args
);
3776 /* We are now (hopefully) stopped at the first instruction of
3777 the target process. This assumes that the target process was
3778 successfully created. */
3782 if (attach_inferior (pid
) == -1)
3783 error ("Attaching not supported on this target");
3785 /* Otherwise succeeded. */
3789 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3790 last_status
.value
.integer
= 0;
3791 last_ptid
= minus_one_ptid
;
3793 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3795 /* Don't report shared library events on the initial connection,
3796 even if some libraries are preloaded. Avoids the "stopped by
3797 shared library event" notice on gdb side. */
3800 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3801 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3806 if (!was_running
&& !multi_mode
)
3807 error ("No program to debug");
3814 report_fork_events
= 0;
3815 report_vfork_events
= 0;
3816 report_exec_events
= 0;
3817 /* Be sure we're out of tfind mode. */
3818 current_traceframe
= -1;
3819 cont_thread
= null_ptid
;
3820 swbreak_feature
= 0;
3821 hwbreak_feature
= 0;
3822 vCont_supported
= 0;
3828 /* Wait for events. This will return when all event sources
3829 are removed from the event loop. */
3830 start_event_loop ();
3832 /* If an exit was requested (using the "monitor exit"
3833 command), terminate now. */
3835 throw_quit ("Quit");
3837 /* The only other way to get here is for getpkt to fail:
3839 - If --once was specified, we're done.
3841 - If not in extended-remote mode, and we're no longer
3842 debugging anything, simply exit: GDB has disconnected
3843 after processing the last process exit.
3845 - Otherwise, close the connection and reopen it at the
3847 if (run_once
|| (!extended_protocol
&& !target_running ()))
3848 throw_quit ("Quit");
3851 "Remote side has terminated connection. "
3852 "GDBserver will reopen the connection.\n");
3854 /* Get rid of any pending statuses. An eventual reconnection
3855 (by the same GDB instance or another) will refresh all its
3856 state from scratch. */
3857 discard_queued_stop_replies (minus_one_ptid
);
3858 for_each_thread ([] (thread_info
*thread
)
3860 thread
->status_pending_p
= 0;
3865 if (disconnected_tracing
)
3867 /* Try to enable non-stop/async mode, so we we can
3868 both wait for an async socket accept, and handle
3869 async target events simultaneously. There's also
3870 no point either in having the target always stop
3871 all threads, when we're going to pass signals
3872 down without informing GDB. */
3875 if (start_non_stop (1))
3878 /* Detaching implicitly resumes all threads;
3879 simply disconnecting does not. */
3885 "Disconnected tracing disabled; "
3886 "stopping trace run.\n");
3891 CATCH (exception
, RETURN_MASK_ERROR
)
3894 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3896 if (response_needed
)
3898 write_enn (own_buf
);
3903 throw_quit ("Quit");
3909 /* Main function. */
3912 main (int argc
, char *argv
[])
3917 captured_main (argc
, argv
);
3919 CATCH (exception
, RETURN_MASK_ALL
)
3921 if (exception
.reason
== RETURN_ERROR
)
3924 fprintf (stderr
, "%s\n", exception
.message
);
3925 fprintf (stderr
, "Exiting\n");
3933 gdb_assert_not_reached ("captured_main should never return");
3936 /* Process options coming from Z packets for a breakpoint. PACKET is
3937 the packet buffer. *PACKET is updated to point to the first char
3938 after the last processed option. */
3941 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3943 const char *dataptr
= *packet
;
3946 /* Check if data has the correct format. */
3947 if (*dataptr
!= ';')
3954 if (*dataptr
== ';')
3957 if (*dataptr
== 'X')
3959 /* Conditional expression. */
3961 debug_printf ("Found breakpoint condition.\n");
3962 if (!add_breakpoint_condition (bp
, &dataptr
))
3963 dataptr
= strchrnul (dataptr
, ';');
3965 else if (startswith (dataptr
, "cmds:"))
3967 dataptr
+= strlen ("cmds:");
3969 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3970 persist
= (*dataptr
== '1');
3972 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3973 dataptr
= strchrnul (dataptr
, ';');
3977 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3979 /* Skip tokens until we find one that we recognize. */
3980 dataptr
= strchrnul (dataptr
, ';');
3986 /* Event loop callback that handles a serial event. The first byte in
3987 the serial buffer gets us here. We expect characters to arrive at
3988 a brisk pace, so we read the rest of the packet with a blocking
3992 process_serial_event (void)
4000 int new_packet_len
= -1;
4002 disable_async_io ();
4004 response_needed
= 0;
4005 packet_len
= getpkt (own_buf
);
4006 if (packet_len
<= 0)
4009 /* Force an event loop break. */
4012 response_needed
= 1;
4014 char ch
= own_buf
[0];
4018 handle_query (own_buf
, packet_len
, &new_packet_len
);
4021 handle_general_set (own_buf
);
4024 handle_detach (own_buf
);
4027 extended_protocol
= 1;
4031 handle_status (own_buf
);
4034 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4036 require_running_or_break (own_buf
);
4038 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4040 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4041 thread_id
= null_ptid
;
4042 else if (thread_id
.is_pid ())
4044 /* The ptid represents a pid. */
4045 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4049 write_enn (own_buf
);
4053 thread_id
= thread
->id
;
4057 /* The ptid represents a lwp/tid. */
4058 if (find_thread_ptid (thread_id
) == NULL
)
4060 write_enn (own_buf
);
4065 if (own_buf
[1] == 'g')
4067 if (ptid_equal (thread_id
, null_ptid
))
4069 /* GDB is telling us to choose any thread. Check if
4070 the currently selected thread is still valid. If
4071 it is not, select the first available. */
4072 thread_info
*thread
= find_thread_ptid (general_thread
);
4074 thread
= get_first_thread ();
4075 thread_id
= thread
->id
;
4078 general_thread
= thread_id
;
4079 set_desired_thread ();
4080 gdb_assert (current_thread
!= NULL
);
4082 else if (own_buf
[1] == 'c')
4083 cont_thread
= thread_id
;
4089 /* Silently ignore it so that gdb can extend the protocol
4090 without compatibility headaches. */
4095 require_running_or_break (own_buf
);
4096 if (current_traceframe
>= 0)
4098 struct regcache
*regcache
4099 = new_register_cache (current_target_desc ());
4101 if (fetch_traceframe_registers (current_traceframe
,
4103 registers_to_string (regcache
, own_buf
);
4105 write_enn (own_buf
);
4106 free_register_cache (regcache
);
4110 struct regcache
*regcache
;
4112 if (!set_desired_thread ())
4113 write_enn (own_buf
);
4116 regcache
= get_thread_regcache (current_thread
, 1);
4117 registers_to_string (regcache
, own_buf
);
4122 require_running_or_break (own_buf
);
4123 if (current_traceframe
>= 0)
4124 write_enn (own_buf
);
4127 struct regcache
*regcache
;
4129 if (!set_desired_thread ())
4130 write_enn (own_buf
);
4133 regcache
= get_thread_regcache (current_thread
, 1);
4134 registers_from_string (regcache
, &own_buf
[1]);
4140 require_running_or_break (own_buf
);
4141 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4142 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4144 write_enn (own_buf
);
4146 bin2hex (mem_buf
, own_buf
, res
);
4149 require_running_or_break (own_buf
);
4150 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4151 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4154 write_enn (own_buf
);
4157 require_running_or_break (own_buf
);
4158 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4159 &mem_addr
, &len
, &mem_buf
) < 0
4160 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4161 write_enn (own_buf
);
4166 require_running_or_break (own_buf
);
4167 hex2bin (own_buf
+ 1, &sig
, 1);
4168 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4169 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4172 myresume (own_buf
, 0, signal
);
4175 require_running_or_break (own_buf
);
4176 hex2bin (own_buf
+ 1, &sig
, 1);
4177 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4178 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4181 myresume (own_buf
, 1, signal
);
4184 require_running_or_break (own_buf
);
4186 myresume (own_buf
, 0, signal
);
4189 require_running_or_break (own_buf
);
4191 myresume (own_buf
, 1, signal
);
4193 case 'Z': /* insert_ ... */
4195 case 'z': /* remove_ ... */
4200 char type
= own_buf
[1];
4202 const int insert
= ch
== 'Z';
4203 const char *p
= &own_buf
[3];
4205 p
= unpack_varlen_hex (p
, &addr
);
4206 kind
= strtol (p
+ 1, &dataptr
, 16);
4210 struct gdb_breakpoint
*bp
;
4212 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4217 /* GDB may have sent us a list of *point parameters to
4218 be evaluated on the target's side. Read such list
4219 here. If we already have a list of parameters, GDB
4220 is telling us to drop that list and use this one
4222 clear_breakpoint_conditions_and_commands (bp
);
4223 const char *options
= dataptr
;
4224 process_point_options (bp
, &options
);
4228 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4236 write_enn (own_buf
);
4240 response_needed
= 0;
4241 if (!target_running ())
4242 /* The packet we received doesn't make sense - but we can't
4243 reply to it, either. */
4246 fprintf (stderr
, "Killing all inferiors\n");
4248 for_each_process (kill_inferior_callback
);
4250 /* When using the extended protocol, we wait with no program
4251 running. The traditional protocol will exit instead. */
4252 if (extended_protocol
)
4254 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4255 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4263 require_running_or_break (own_buf
);
4265 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4266 if (find_thread_ptid (thread_id
) == NULL
)
4268 write_enn (own_buf
);
4272 if (mythread_alive (thread_id
))
4275 write_enn (own_buf
);
4279 response_needed
= 0;
4281 /* Restarting the inferior is only supported in the extended
4283 if (extended_protocol
)
4285 if (target_running ())
4286 for_each_process (kill_inferior_callback
);
4288 fprintf (stderr
, "GDBserver restarting\n");
4290 /* Wait till we are at 1st instruction in prog. */
4291 if (program_name
!= NULL
)
4293 create_inferior (program_name
, program_args
);
4295 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4297 /* Stopped at the first instruction of the target
4299 general_thread
= last_ptid
;
4303 /* Something went wrong. */
4304 general_thread
= null_ptid
;
4309 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4310 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4316 /* It is a request we don't understand. Respond with an
4317 empty packet so that gdb knows that we don't support this
4323 /* Extended (long) request. */
4324 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4328 /* It is a request we don't understand. Respond with an empty
4329 packet so that gdb knows that we don't support this
4335 if (new_packet_len
!= -1)
4336 putpkt_binary (own_buf
, new_packet_len
);
4340 response_needed
= 0;
4348 /* Event-loop callback for serial events. */
4351 handle_serial_event (int err
, gdb_client_data client_data
)
4354 debug_printf ("handling possible serial event\n");
4356 /* Really handle it. */
4357 if (process_serial_event () < 0)
4360 /* Be sure to not change the selected thread behind GDB's back.
4361 Important in the non-stop mode asynchronous protocol. */
4362 set_desired_thread ();
4367 /* Push a stop notification on the notification queue. */
4370 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4372 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4374 vstop_notif
->status
= *status
;
4375 vstop_notif
->ptid
= ptid
;
4376 /* Push Stop notification. */
4377 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4380 /* Event-loop callback for target events. */
4383 handle_target_event (int err
, gdb_client_data client_data
)
4386 debug_printf ("handling possible target event\n");
4388 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4391 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4393 if (gdb_connected () && report_no_resumed
)
4394 push_stop_notification (null_ptid
, &last_status
);
4396 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4398 int pid
= ptid_get_pid (last_ptid
);
4399 struct process_info
*process
= find_process_pid (pid
);
4400 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4402 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4403 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4405 mark_breakpoints_out (process
);
4406 target_mourn_inferior (last_ptid
);
4408 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4412 /* We're reporting this thread as stopped. Update its
4413 "want-stopped" state to what the client wants, until it
4414 gets a new resume action. */
4415 current_thread
->last_resume_kind
= resume_stop
;
4416 current_thread
->last_status
= last_status
;
4421 if (!target_running ())
4423 /* The last process exited. We're done. */
4427 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4428 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4429 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4433 /* A thread stopped with a signal, but gdb isn't
4434 connected to handle it. Pass it down to the
4435 inferior, as if it wasn't being traced. */
4436 enum gdb_signal signal
;
4439 debug_printf ("GDB not connected; forwarding event %d for"
4441 (int) last_status
.kind
,
4442 target_pid_to_str (last_ptid
));
4444 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4445 signal
= last_status
.value
.sig
;
4447 signal
= GDB_SIGNAL_0
;
4448 target_continue (last_ptid
, signal
);
4452 push_stop_notification (last_ptid
, &last_status
);
4455 /* Be sure to not change the selected thread behind GDB's back.
4456 Important in the non-stop mode asynchronous protocol. */
4457 set_desired_thread ();
4470 } // namespace selftests
4471 #endif /* GDB_SELF_TEST */