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 /* The environment to pass to the inferior when creating it. */
61 static gdb_environ our_environ
;
63 /* Start the inferior using a shell. */
65 /* We always try to start the inferior using a shell. */
67 int startup_with_shell
= 1;
69 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
70 `vCont'. Note the multi-process extensions made `vCont' a
71 requirement, so `Hc pPID.TID' is pretty much undefined. So
72 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
73 resuming all threads of the process (again, `Hc' isn't used for
74 multi-process), or a specific thread ptid_t. */
77 /* The thread set with an `Hg' packet. */
78 ptid_t general_thread
;
82 static int extended_protocol
;
83 static int response_needed
;
84 static int exit_requested
;
86 /* --once: Exit after the first connection has closed. */
90 int report_fork_events
;
91 int report_vfork_events
;
92 int report_exec_events
;
93 int report_thread_events
;
95 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
96 static int report_no_resumed
;
102 /* True if the "vContSupported" feature is active. In that case, GDB
103 wants us to report whether single step is supported in the reply to
105 static int vCont_supported
;
107 /* Whether we should attempt to disable the operating system's address
108 space randomization feature before starting an inferior. */
109 int disable_randomization
= 1;
111 static char *program_name
= NULL
;
112 static std::vector
<char *> program_args
;
113 static std::string wrapper_argv
;
115 int pass_signals
[GDB_SIGNAL_LAST
];
116 int program_signals
[GDB_SIGNAL_LAST
];
117 int program_signals_p
;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid
;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 int disable_packet_vCont
;
130 int disable_packet_Tthread
;
131 int disable_packet_qC
;
132 int disable_packet_qfThreadInfo
;
134 /* Last status reported to GDB. */
135 struct target_waitstatus last_status
;
139 static unsigned char *mem_buf
;
141 /* A sub-class of 'struct notif_event' for stop, holding information
142 relative to a single stop reply. We keep a queue of these to
143 push to GDB in non-stop mode. */
147 struct notif_event base
;
149 /* Thread or process that got the event. */
153 struct target_waitstatus status
;
156 /* The current btrace configuration. This is gdbserver's mirror of GDB's
157 btrace configuration. */
158 static struct btrace_config current_btrace_conf
;
160 DEFINE_QUEUE_P (notif_event_p
);
162 /* Put a stop reply to the stop reply queue. */
165 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
167 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
169 new_notif
->ptid
= ptid
;
170 new_notif
->status
= *status
;
172 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
176 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
177 QUEUE_ITER (notif_event_p
) *iter
,
178 struct notif_event
*event
,
181 ptid_t filter_ptid
= *(ptid_t
*) data
;
182 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
184 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
186 if (q
->free_func
!= NULL
)
187 q
->free_func (event
);
189 QUEUE_remove_elem (notif_event_p
, q
, iter
);
198 discard_queued_stop_replies (ptid_t ptid
)
200 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
201 remove_all_on_match_ptid
, &ptid
);
205 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
207 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
209 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
212 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
215 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
216 QUEUE_ITER (notif_event_p
) *iter
,
217 struct notif_event
*event
,
220 ptid_t filter_ptid
= *(ptid_t
*) data
;
221 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
223 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
226 /* Don't resume fork children that GDB does not know about yet. */
227 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
228 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
229 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
238 in_queued_stop_replies (ptid_t ptid
)
240 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
241 in_queued_stop_replies_ptid
, &ptid
);
244 struct notif_server notif_stop
=
246 "vStopped", "Stop", NULL
, vstop_notif_reply
,
250 target_running (void)
252 return get_first_thread () != NULL
;
255 /* See common/common-inferior.h. */
260 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
263 /* See common/common-inferior.h. */
266 get_exec_file (int err
)
268 if (err
&& program_name
== NULL
)
269 error (_("No executable file specified."));
283 attach_inferior (int pid
)
285 /* myattach should return -1 if attaching is unsupported,
286 0 if it succeeded, and call error() otherwise. */
288 if (myattach (pid
) != 0)
291 fprintf (stderr
, "Attached; pid = %d\n", pid
);
294 /* FIXME - It may be that we should get the SIGNAL_PID from the
295 attach function, so that it can be the main thread instead of
296 whichever we were told to attach to. */
301 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
303 /* GDB knows to ignore the first SIGSTOP after attaching to a running
304 process using the "attach" command, but this is different; it's
305 just using "target remote". Pretend it's just starting up. */
306 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
307 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
308 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
310 current_thread
->last_resume_kind
= resume_stop
;
311 current_thread
->last_status
= last_status
;
317 extern int remote_debug
;
319 /* Decode a qXfer read request. Return 0 if everything looks OK,
323 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
325 /* After the read marker and annex, qXfer looks like a
326 traditional 'm' packet. */
327 decode_m_packet (buf
, ofs
, len
);
333 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
335 /* Extract and NUL-terminate the object. */
337 while (*buf
&& *buf
!= ':')
343 /* Extract and NUL-terminate the read/write action. */
345 while (*buf
&& *buf
!= ':')
351 /* Extract and NUL-terminate the annex. */
353 while (*buf
&& *buf
!= ':')
363 /* Write the response to a successful qXfer read. Returns the
364 length of the (binary) data stored in BUF, corresponding
365 to as much of DATA/LEN as we could fit. IS_MORE controls
366 the first character of the response. */
368 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
377 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
378 &out_len
, PBUFSIZ
- 2) + 1;
381 /* Handle btrace enabling in BTS format. */
384 handle_btrace_enable_bts (struct thread_info
*thread
)
386 if (thread
->btrace
!= NULL
)
387 return "E.Btrace already enabled.";
389 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
390 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
391 if (thread
->btrace
== NULL
)
392 return "E.Could not enable btrace.";
397 /* Handle btrace enabling in Intel Processor Trace format. */
400 handle_btrace_enable_pt (struct thread_info
*thread
)
402 if (thread
->btrace
!= NULL
)
403 return "E.Btrace already enabled.";
405 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
406 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
407 if (thread
->btrace
== NULL
)
408 return "E.Could not enable btrace.";
413 /* Handle btrace disabling. */
416 handle_btrace_disable (struct thread_info
*thread
)
419 if (thread
->btrace
== NULL
)
420 return "E.Branch tracing not enabled.";
422 if (target_disable_btrace (thread
->btrace
) != 0)
423 return "E.Could not disable branch tracing.";
425 thread
->btrace
= NULL
;
429 /* Handle the "Qbtrace" packet. */
432 handle_btrace_general_set (char *own_buf
)
434 struct thread_info
*thread
;
438 if (!startswith (own_buf
, "Qbtrace:"))
441 op
= own_buf
+ strlen ("Qbtrace:");
443 if (ptid_equal (general_thread
, null_ptid
)
444 || ptid_equal (general_thread
, minus_one_ptid
))
446 strcpy (own_buf
, "E.Must select a single thread.");
450 thread
= find_thread_ptid (general_thread
);
453 strcpy (own_buf
, "E.No such thread.");
459 if (strcmp (op
, "bts") == 0)
460 err
= handle_btrace_enable_bts (thread
);
461 else if (strcmp (op
, "pt") == 0)
462 err
= handle_btrace_enable_pt (thread
);
463 else if (strcmp (op
, "off") == 0)
464 err
= handle_btrace_disable (thread
);
466 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
469 strcpy (own_buf
, err
);
476 /* Handle the "Qbtrace-conf" packet. */
479 handle_btrace_conf_general_set (char *own_buf
)
481 struct thread_info
*thread
;
484 if (!startswith (own_buf
, "Qbtrace-conf:"))
487 op
= own_buf
+ strlen ("Qbtrace-conf:");
489 if (ptid_equal (general_thread
, null_ptid
)
490 || ptid_equal (general_thread
, minus_one_ptid
))
492 strcpy (own_buf
, "E.Must select a single thread.");
496 thread
= find_thread_ptid (general_thread
);
499 strcpy (own_buf
, "E.No such thread.");
503 if (startswith (op
, "bts:size="))
509 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
510 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
512 strcpy (own_buf
, "E.Bad size value.");
516 current_btrace_conf
.bts
.size
= (unsigned int) size
;
518 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
524 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
525 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
527 strcpy (own_buf
, "E.Bad size value.");
531 current_btrace_conf
.pt
.size
= (unsigned int) size
;
535 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
543 /* Handle all of the extended 'Q' packets. */
546 handle_general_set (char *own_buf
)
548 if (startswith (own_buf
, "QPassSignals:"))
550 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
551 const char *p
= own_buf
+ strlen ("QPassSignals:");
554 p
= decode_address_to_semicolon (&cursig
, p
);
555 for (i
= 0; i
< numsigs
; i
++)
561 /* Keep looping, to clear the remaining signals. */
564 p
= decode_address_to_semicolon (&cursig
, p
);
569 strcpy (own_buf
, "OK");
573 if (startswith (own_buf
, "QProgramSignals:"))
575 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
576 const char *p
= own_buf
+ strlen ("QProgramSignals:");
579 program_signals_p
= 1;
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
586 program_signals
[i
] = 1;
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
594 program_signals
[i
] = 0;
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QCatchSyscalls:"))
602 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
605 struct process_info
*process
;
607 if (!target_running () || !target_supports_catch_syscall ())
613 if (strcmp (p
, "0") == 0)
615 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
619 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
625 process
= current_process ();
626 process
->syscalls_to_catch
.clear ();
636 p
= decode_address_to_semicolon (&sysno
, p
);
637 process
->syscalls_to_catch
.push_back (sysno
);
641 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
648 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
650 our_environ
= gdb_environ::from_host_environ ();
656 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
658 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
659 /* The final form of the environment variable. FINAL_VAR will
660 hold the 'VAR=VALUE' format. */
661 std::string final_var
= hex2str (p
);
662 std::string var_name
, var_value
;
666 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
667 debug_printf (_("[Environment variable to be set: '%s']\n"),
672 size_t pos
= final_var
.find ('=');
673 if (pos
== std::string::npos
)
675 warning (_("Unexpected format for environment variable: '%s'"),
681 var_name
= final_var
.substr (0, pos
);
682 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
684 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
690 if (startswith (own_buf
, "QEnvironmentUnset:"))
692 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
693 std::string varname
= hex2str (p
);
697 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
698 debug_printf (_("[Environment variable to be unset: '%s']\n"),
703 our_environ
.unset (varname
.c_str ());
709 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
713 debug_printf ("[noack mode enabled]\n");
722 if (startswith (own_buf
, "QNonStop:"))
724 char *mode
= own_buf
+ 9;
728 if (strcmp (mode
, "0") == 0)
730 else if (strcmp (mode
, "1") == 0)
734 /* We don't know what this mode is, so complain to
736 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
742 req_str
= req
? "non-stop" : "all-stop";
743 if (start_non_stop (req
) != 0)
745 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
753 debug_printf ("[%s mode enabled]\n", req_str
);
759 if (startswith (own_buf
, "QDisableRandomization:"))
761 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
764 unpack_varlen_hex (packet
, &setting
);
765 disable_randomization
= setting
;
769 debug_printf (disable_randomization
770 ? "[address space randomization disabled]\n"
771 : "[address space randomization enabled]\n");
778 if (target_supports_tracepoints ()
779 && handle_tracepoint_general_set (own_buf
))
782 if (startswith (own_buf
, "QAgent:"))
784 char *mode
= own_buf
+ strlen ("QAgent:");
787 if (strcmp (mode
, "0") == 0)
789 else if (strcmp (mode
, "1") == 0)
793 /* We don't know what this value is, so complain to GDB. */
794 sprintf (own_buf
, "E.Unknown QAgent value");
798 /* Update the flag. */
801 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
806 if (handle_btrace_general_set (own_buf
))
809 if (handle_btrace_conf_general_set (own_buf
))
812 if (startswith (own_buf
, "QThreadEvents:"))
814 char *mode
= own_buf
+ strlen ("QThreadEvents:");
815 enum tribool req
= TRIBOOL_UNKNOWN
;
817 if (strcmp (mode
, "0") == 0)
819 else if (strcmp (mode
, "1") == 0)
823 char *mode_copy
= xstrdup (mode
);
825 /* We don't know what this mode is, so complain to GDB. */
826 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
832 report_thread_events
= (req
== TRIBOOL_TRUE
);
836 const char *req_str
= report_thread_events
? "enabled" : "disabled";
838 debug_printf ("[thread events are now %s]\n", req_str
);
845 if (startswith (own_buf
, "QStartupWithShell:"))
847 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
849 if (strcmp (value
, "1") == 0)
850 startup_with_shell
= true;
851 else if (strcmp (value
, "0") == 0)
852 startup_with_shell
= false;
856 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
863 debug_printf (_("[Inferior will %s started with shell]"),
864 startup_with_shell
? "be" : "not be");
870 if (startswith (own_buf
, "QSetWorkingDir:"))
872 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
876 std::string path
= hex2str (p
);
878 set_inferior_cwd (path
.c_str ());
881 debug_printf (_("[Set the inferior's current directory to %s]\n"),
886 /* An empty argument means that we should clear out any
887 previously set cwd for the inferior. */
888 set_inferior_cwd (NULL
);
892 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
899 /* Otherwise we didn't know what packet it was. Say we didn't
905 get_features_xml (const char *annex
)
907 const struct target_desc
*desc
= current_target_desc ();
909 /* `desc->xmltarget' defines what to return when looking for the
910 "target.xml" file. Its contents can either be verbatim XML code
911 (prefixed with a '@') or else the name of the actual XML file to
912 be used in place of "target.xml".
914 This variable is set up from the auto-generated
915 init_registers_... routine for the current target. */
917 if (strcmp (annex
, "target.xml") == 0)
919 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
929 extern const char *const xml_builtin
[][2];
932 /* Look for the annex. */
933 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
934 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
937 if (xml_builtin
[i
][0] != NULL
)
938 return xml_builtin
[i
][1];
946 monitor_show_help (void)
948 monitor_output ("The following monitor commands are supported:\n");
949 monitor_output (" set debug <0|1>\n");
950 monitor_output (" Enable general debugging messages\n");
951 monitor_output (" set debug-hw-points <0|1>\n");
952 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
953 monitor_output (" set remote-debug <0|1>\n");
954 monitor_output (" Enable remote protocol debugging messages\n");
955 monitor_output (" set debug-format option1[,option2,...]\n");
956 monitor_output (" Add additional information to debugging messages\n");
957 monitor_output (" Options: all, none");
958 monitor_output (", timestamp");
959 monitor_output ("\n");
960 monitor_output (" exit\n");
961 monitor_output (" Quit GDBserver\n");
964 /* Read trace frame or inferior memory. Returns the number of bytes
965 actually read, zero when no further transfer is possible, and -1 on
966 error. Return of a positive value smaller than LEN does not
967 indicate there's no more to be read, only the end of the transfer.
968 E.g., when GDB reads memory from a traceframe, a first request may
969 be served from a memory block that does not cover the whole request
970 length. A following request gets the rest served from either
971 another block (of the same traceframe) or from the read-only
975 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
979 if (current_traceframe
>= 0)
982 ULONGEST length
= len
;
984 if (traceframe_read_mem (current_traceframe
,
985 memaddr
, myaddr
, len
, &nbytes
))
987 /* Data read from trace buffer, we're done. */
990 if (!in_readonly_region (memaddr
, length
))
992 /* Otherwise we have a valid readonly case, fall through. */
993 /* (assume no half-trace half-real blocks for now) */
996 res
= prepare_to_access_memory ();
999 if (set_desired_thread ())
1000 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1003 done_accessing_memory ();
1005 return res
== 0 ? len
: -1;
1011 /* Write trace frame or inferior memory. Actually, writing to trace
1012 frames is forbidden. */
1015 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1017 if (current_traceframe
>= 0)
1023 ret
= prepare_to_access_memory ();
1026 if (set_desired_thread ())
1027 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1030 done_accessing_memory ();
1036 /* Subroutine of handle_search_memory to simplify it. */
1039 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1040 gdb_byte
*pattern
, unsigned pattern_len
,
1041 gdb_byte
*search_buf
,
1042 unsigned chunk_size
, unsigned search_buf_size
,
1043 CORE_ADDR
*found_addrp
)
1045 /* Prime the search buffer. */
1047 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1050 warning ("Unable to access %ld bytes of target "
1051 "memory at 0x%lx, halting search.",
1052 (long) search_buf_size
, (long) start_addr
);
1056 /* Perform the search.
1058 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1059 When we've scanned N bytes we copy the trailing bytes to the start and
1060 read in another N bytes. */
1062 while (search_space_len
>= pattern_len
)
1064 gdb_byte
*found_ptr
;
1065 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1069 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1072 if (found_ptr
!= NULL
)
1074 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1075 *found_addrp
= found_addr
;
1079 /* Not found in this chunk, skip to next chunk. */
1081 /* Don't let search_space_len wrap here, it's unsigned. */
1082 if (search_space_len
>= chunk_size
)
1083 search_space_len
-= chunk_size
;
1085 search_space_len
= 0;
1087 if (search_space_len
>= pattern_len
)
1089 unsigned keep_len
= search_buf_size
- chunk_size
;
1090 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1093 /* Copy the trailing part of the previous iteration to the front
1094 of the buffer for the next iteration. */
1095 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1097 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1098 ? search_space_len
- keep_len
1101 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1102 nr_to_read
) != search_buf_size
)
1104 warning ("Unable to access %ld bytes of target memory "
1105 "at 0x%lx, halting search.",
1106 (long) nr_to_read
, (long) read_addr
);
1110 start_addr
+= chunk_size
;
1119 /* Handle qSearch:memory packets. */
1122 handle_search_memory (char *own_buf
, int packet_len
)
1124 CORE_ADDR start_addr
;
1125 CORE_ADDR search_space_len
;
1127 unsigned int pattern_len
;
1128 /* NOTE: also defined in find.c testcase. */
1129 #define SEARCH_CHUNK_SIZE 16000
1130 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1131 /* Buffer to hold memory contents for searching. */
1132 gdb_byte
*search_buf
;
1133 unsigned search_buf_size
;
1135 CORE_ADDR found_addr
;
1136 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1138 pattern
= (gdb_byte
*) malloc (packet_len
);
1139 if (pattern
== NULL
)
1141 error ("Unable to allocate memory to perform the search");
1142 strcpy (own_buf
, "E00");
1145 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1146 packet_len
- cmd_name_len
,
1147 &start_addr
, &search_space_len
,
1148 pattern
, &pattern_len
) < 0)
1151 error ("Error in parsing qSearch:memory packet");
1152 strcpy (own_buf
, "E00");
1156 search_buf_size
= chunk_size
+ pattern_len
- 1;
1158 /* No point in trying to allocate a buffer larger than the search space. */
1159 if (search_space_len
< search_buf_size
)
1160 search_buf_size
= search_space_len
;
1162 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1163 if (search_buf
== NULL
)
1166 error ("Unable to allocate memory to perform the search");
1167 strcpy (own_buf
, "E00");
1171 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1172 pattern
, pattern_len
,
1173 search_buf
, chunk_size
, search_buf_size
,
1177 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1178 else if (found
== 0)
1179 strcpy (own_buf
, "0");
1181 strcpy (own_buf
, "E00");
1187 /* Handle the "D" packet. */
1190 handle_detach (char *own_buf
)
1192 require_running_or_return (own_buf
);
1199 pid
= strtol (&own_buf
[2], NULL
, 16);
1202 pid
= ptid_get_pid (current_ptid
);
1204 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1206 struct process_info
*process
= find_process_pid (pid
);
1208 if (process
== NULL
)
1210 write_enn (own_buf
);
1214 if (tracing
&& disconnected_tracing
)
1216 "Disconnected tracing in effect, "
1217 "leaving gdbserver attached to the process\n");
1219 if (any_persistent_commands ())
1221 "Persistent commands are present, "
1222 "leaving gdbserver attached to the process\n");
1224 /* Make sure we're in non-stop/async mode, so we we can both
1225 wait for an async socket accept, and handle async target
1226 events simultaneously. There's also no point either in
1227 having the target stop all threads, when we're going to
1228 pass signals down without informing GDB. */
1232 debug_printf ("Forcing non-stop mode\n");
1238 process
->gdb_detached
= 1;
1240 /* Detaching implicitly resumes all threads. */
1241 target_continue_no_signal (minus_one_ptid
);
1247 fprintf (stderr
, "Detaching from process %d\n", pid
);
1249 if (detach_inferior (pid
) != 0)
1250 write_enn (own_buf
);
1253 discard_queued_stop_replies (pid_to_ptid (pid
));
1256 if (extended_protocol
|| target_running ())
1258 /* There is still at least one inferior remaining or
1259 we are in extended mode, so don't terminate gdbserver,
1260 and instead treat this like a normal program exit. */
1261 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1262 last_status
.value
.integer
= 0;
1263 last_ptid
= pid_to_ptid (pid
);
1265 current_thread
= NULL
;
1272 /* If we are attached, then we can exit. Otherwise, we
1273 need to hang around doing nothing, until the child is
1275 join_inferior (pid
);
1281 /* Parse options to --debug-format= and "monitor set debug-format".
1282 ARG is the text after "--debug-format=" or "monitor set debug-format".
1283 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1284 This triggers calls to monitor_output.
1285 The result is NULL if all options were parsed ok, otherwise an error
1286 message which the caller must free.
1288 N.B. These commands affect all debug format settings, they are not
1289 cumulative. If a format is not specified, it is turned off.
1290 However, we don't go to extra trouble with things like
1291 "monitor set debug-format all,none,timestamp".
1292 Instead we just parse them one at a time, in order.
1294 The syntax for "monitor set debug" we support here is not identical
1295 to gdb's "set debug foo on|off" because we also use this function to
1296 parse "--debug-format=foo,bar". */
1299 parse_debug_format_options (const char *arg
, int is_monitor
)
1301 VEC (char_ptr
) *options
;
1305 /* First turn all debug format options off. */
1306 debug_timestamp
= 0;
1308 /* First remove leading spaces, for "monitor set debug-format". */
1309 while (isspace (*arg
))
1312 options
= delim_string_to_char_ptr_vec (arg
, ',');
1314 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1316 if (strcmp (option
, "all") == 0)
1318 debug_timestamp
= 1;
1320 monitor_output ("All extra debug format options enabled.\n");
1322 else if (strcmp (option
, "none") == 0)
1324 debug_timestamp
= 0;
1326 monitor_output ("All extra debug format options disabled.\n");
1328 else if (strcmp (option
, "timestamp") == 0)
1330 debug_timestamp
= 1;
1332 monitor_output ("Timestamps will be added to debug output.\n");
1334 else if (*option
== '\0')
1336 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1342 = string_printf ("Unknown debug-format argument: \"%s\"\n", option
);
1344 free_char_ptr_vec (options
);
1349 free_char_ptr_vec (options
);
1350 return std::string ();
1353 /* Handle monitor commands not handled by target-specific handlers. */
1356 handle_monitor_command (char *mon
, char *own_buf
)
1358 if (strcmp (mon
, "set debug 1") == 0)
1361 monitor_output ("Debug output enabled.\n");
1363 else if (strcmp (mon
, "set debug 0") == 0)
1366 monitor_output ("Debug output disabled.\n");
1368 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1370 show_debug_regs
= 1;
1371 monitor_output ("H/W point debugging output enabled.\n");
1373 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1375 show_debug_regs
= 0;
1376 monitor_output ("H/W point debugging output disabled.\n");
1378 else if (strcmp (mon
, "set remote-debug 1") == 0)
1381 monitor_output ("Protocol debug output enabled.\n");
1383 else if (strcmp (mon
, "set remote-debug 0") == 0)
1386 monitor_output ("Protocol debug output disabled.\n");
1388 else if (startswith (mon
, "set debug-format "))
1390 std::string error_msg
1391 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1394 if (!error_msg
.empty ())
1396 monitor_output (error_msg
.c_str ());
1397 monitor_show_help ();
1398 write_enn (own_buf
);
1401 else if (strcmp (mon
, "help") == 0)
1402 monitor_show_help ();
1403 else if (strcmp (mon
, "exit") == 0)
1407 monitor_output ("Unknown monitor command.\n\n");
1408 monitor_show_help ();
1409 write_enn (own_buf
);
1413 /* Associates a callback with each supported qXfer'able object. */
1417 /* The object this handler handles. */
1420 /* Request that the target transfer up to LEN 8-bit bytes of the
1421 target's OBJECT. The OFFSET, for a seekable object, specifies
1422 the starting point. The ANNEX can be used to provide additional
1423 data-specific information to the target.
1425 Return the number of bytes actually transfered, zero when no
1426 further transfer is possible, -1 on error, -2 when the transfer
1427 is not supported, and -3 on a verbose error message that should
1428 be preserved. Return of a positive value smaller than LEN does
1429 not indicate the end of the object, only the end of the transfer.
1431 One, and only one, of readbuf or writebuf must be non-NULL. */
1432 int (*xfer
) (const char *annex
,
1433 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1434 ULONGEST offset
, LONGEST len
);
1437 /* Handle qXfer:auxv:read. */
1440 handle_qxfer_auxv (const char *annex
,
1441 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1442 ULONGEST offset
, LONGEST len
)
1444 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1447 if (annex
[0] != '\0' || current_thread
== NULL
)
1450 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1453 /* Handle qXfer:exec-file:read. */
1456 handle_qxfer_exec_file (const char *annex
,
1457 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1458 ULONGEST offset
, LONGEST len
)
1464 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1467 if (annex
[0] == '\0')
1469 if (current_thread
== NULL
)
1472 pid
= pid_of (current_thread
);
1476 annex
= unpack_varlen_hex (annex
, &pid
);
1477 if (annex
[0] != '\0')
1484 file
= (*the_target
->pid_to_exec_file
) (pid
);
1488 total_len
= strlen (file
);
1490 if (offset
> total_len
)
1493 if (offset
+ len
> total_len
)
1494 len
= total_len
- offset
;
1496 memcpy (readbuf
, file
+ offset
, len
);
1500 /* Handle qXfer:features:read. */
1503 handle_qxfer_features (const char *annex
,
1504 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1505 ULONGEST offset
, LONGEST len
)
1507 const char *document
;
1510 if (writebuf
!= NULL
)
1513 if (!target_running ())
1516 /* Grab the correct annex. */
1517 document
= get_features_xml (annex
);
1518 if (document
== NULL
)
1521 total_len
= strlen (document
);
1523 if (offset
> total_len
)
1526 if (offset
+ len
> total_len
)
1527 len
= total_len
- offset
;
1529 memcpy (readbuf
, document
+ offset
, len
);
1533 /* Handle qXfer:libraries:read. */
1536 handle_qxfer_libraries (const char *annex
,
1537 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1538 ULONGEST offset
, LONGEST len
)
1540 if (writebuf
!= NULL
)
1543 if (annex
[0] != '\0' || current_thread
== NULL
)
1546 std::string document
= "<library-list version=\"1.0\">\n";
1548 for (const dll_info
&dll
: all_dlls
)
1549 document
+= string_printf
1550 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1551 dll
.name
.c_str (), (long) dll
.base_addr
);
1553 document
+= "</library-list>\n";
1555 if (offset
> document
.length ())
1558 if (offset
+ len
> document
.length ())
1559 len
= document
.length () - offset
;
1561 memcpy (readbuf
, &document
[offset
], len
);
1566 /* Handle qXfer:libraries-svr4:read. */
1569 handle_qxfer_libraries_svr4 (const char *annex
,
1570 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1571 ULONGEST offset
, LONGEST len
)
1573 if (writebuf
!= NULL
)
1576 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1579 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1582 /* Handle qXfer:osadata:read. */
1585 handle_qxfer_osdata (const char *annex
,
1586 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1587 ULONGEST offset
, LONGEST len
)
1589 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1592 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1595 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1598 handle_qxfer_siginfo (const char *annex
,
1599 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1600 ULONGEST offset
, LONGEST len
)
1602 if (the_target
->qxfer_siginfo
== NULL
)
1605 if (annex
[0] != '\0' || current_thread
== NULL
)
1608 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1611 /* Handle qXfer:spu:read and qXfer:spu:write. */
1614 handle_qxfer_spu (const char *annex
,
1615 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1616 ULONGEST offset
, LONGEST len
)
1618 if (the_target
->qxfer_spu
== NULL
)
1621 if (current_thread
== NULL
)
1624 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1627 /* Handle qXfer:statictrace:read. */
1630 handle_qxfer_statictrace (const char *annex
,
1631 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1632 ULONGEST offset
, LONGEST len
)
1636 if (writebuf
!= NULL
)
1639 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1642 if (traceframe_read_sdata (current_traceframe
, offset
,
1643 readbuf
, len
, &nbytes
))
1648 /* Helper for handle_qxfer_threads_proper.
1649 Emit the XML to describe the thread of INF. */
1652 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1654 ptid_t ptid
= ptid_of (thread
);
1656 int core
= target_core_of_thread (ptid
);
1658 const char *name
= target_thread_name (ptid
);
1661 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1663 write_ptid (ptid_s
, ptid
);
1665 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1669 sprintf (core_s
, "%d", core
);
1670 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1674 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1678 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1679 bin2hex (handle
, handle_s
, handle_len
);
1680 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1683 buffer_xml_printf (buffer
, "/>\n");
1686 /* Helper for handle_qxfer_threads. */
1689 handle_qxfer_threads_proper (struct buffer
*buffer
)
1691 buffer_grow_str (buffer
, "<threads>\n");
1693 for_each_thread ([&] (thread_info
*thread
)
1695 handle_qxfer_threads_worker (thread
, buffer
);
1698 buffer_grow_str0 (buffer
, "</threads>\n");
1701 /* Handle qXfer:threads:read. */
1704 handle_qxfer_threads (const char *annex
,
1705 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1706 ULONGEST offset
, LONGEST len
)
1708 static char *result
= 0;
1709 static unsigned int result_length
= 0;
1711 if (writebuf
!= NULL
)
1714 if (annex
[0] != '\0')
1719 struct buffer buffer
;
1720 /* When asked for data at offset 0, generate everything and store into
1721 'result'. Successive reads will be served off 'result'. */
1725 buffer_init (&buffer
);
1727 handle_qxfer_threads_proper (&buffer
);
1729 result
= buffer_finish (&buffer
);
1730 result_length
= strlen (result
);
1731 buffer_free (&buffer
);
1734 if (offset
>= result_length
)
1736 /* We're out of data. */
1743 if (len
> result_length
- offset
)
1744 len
= result_length
- offset
;
1746 memcpy (readbuf
, result
+ offset
, len
);
1751 /* Handle qXfer:traceframe-info:read. */
1754 handle_qxfer_traceframe_info (const char *annex
,
1755 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1756 ULONGEST offset
, LONGEST len
)
1758 static char *result
= 0;
1759 static unsigned int result_length
= 0;
1761 if (writebuf
!= NULL
)
1764 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1769 struct buffer buffer
;
1771 /* When asked for data at offset 0, generate everything and
1772 store into 'result'. Successive reads will be served off
1776 buffer_init (&buffer
);
1778 traceframe_read_info (current_traceframe
, &buffer
);
1780 result
= buffer_finish (&buffer
);
1781 result_length
= strlen (result
);
1782 buffer_free (&buffer
);
1785 if (offset
>= result_length
)
1787 /* We're out of data. */
1794 if (len
> result_length
- offset
)
1795 len
= result_length
- offset
;
1797 memcpy (readbuf
, result
+ offset
, len
);
1801 /* Handle qXfer:fdpic:read. */
1804 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1805 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1807 if (the_target
->read_loadmap
== NULL
)
1810 if (current_thread
== NULL
)
1813 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1816 /* Handle qXfer:btrace:read. */
1819 handle_qxfer_btrace (const char *annex
,
1820 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1821 ULONGEST offset
, LONGEST len
)
1823 static struct buffer cache
;
1824 struct thread_info
*thread
;
1825 enum btrace_read_type type
;
1828 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1831 if (ptid_equal (general_thread
, null_ptid
)
1832 || ptid_equal (general_thread
, minus_one_ptid
))
1834 strcpy (own_buf
, "E.Must select a single thread.");
1838 thread
= find_thread_ptid (general_thread
);
1841 strcpy (own_buf
, "E.No such thread.");
1845 if (thread
->btrace
== NULL
)
1847 strcpy (own_buf
, "E.Btrace not enabled.");
1851 if (strcmp (annex
, "all") == 0)
1852 type
= BTRACE_READ_ALL
;
1853 else if (strcmp (annex
, "new") == 0)
1854 type
= BTRACE_READ_NEW
;
1855 else if (strcmp (annex
, "delta") == 0)
1856 type
= BTRACE_READ_DELTA
;
1859 strcpy (own_buf
, "E.Bad annex.");
1865 buffer_free (&cache
);
1867 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1870 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1874 else if (offset
> cache
.used_size
)
1876 buffer_free (&cache
);
1880 if (len
> cache
.used_size
- offset
)
1881 len
= cache
.used_size
- offset
;
1883 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1888 /* Handle qXfer:btrace-conf:read. */
1891 handle_qxfer_btrace_conf (const char *annex
,
1892 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1893 ULONGEST offset
, LONGEST len
)
1895 static struct buffer cache
;
1896 struct thread_info
*thread
;
1899 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1902 if (annex
[0] != '\0')
1905 if (ptid_equal (general_thread
, null_ptid
)
1906 || ptid_equal (general_thread
, minus_one_ptid
))
1908 strcpy (own_buf
, "E.Must select a single thread.");
1912 thread
= find_thread_ptid (general_thread
);
1915 strcpy (own_buf
, "E.No such thread.");
1919 if (thread
->btrace
== NULL
)
1921 strcpy (own_buf
, "E.Btrace not enabled.");
1927 buffer_free (&cache
);
1929 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1932 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1936 else if (offset
> cache
.used_size
)
1938 buffer_free (&cache
);
1942 if (len
> cache
.used_size
- offset
)
1943 len
= cache
.used_size
- offset
;
1945 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1950 static const struct qxfer qxfer_packets
[] =
1952 { "auxv", handle_qxfer_auxv
},
1953 { "btrace", handle_qxfer_btrace
},
1954 { "btrace-conf", handle_qxfer_btrace_conf
},
1955 { "exec-file", handle_qxfer_exec_file
},
1956 { "fdpic", handle_qxfer_fdpic
},
1957 { "features", handle_qxfer_features
},
1958 { "libraries", handle_qxfer_libraries
},
1959 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1960 { "osdata", handle_qxfer_osdata
},
1961 { "siginfo", handle_qxfer_siginfo
},
1962 { "spu", handle_qxfer_spu
},
1963 { "statictrace", handle_qxfer_statictrace
},
1964 { "threads", handle_qxfer_threads
},
1965 { "traceframe-info", handle_qxfer_traceframe_info
},
1969 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1977 if (!startswith (own_buf
, "qXfer:"))
1980 /* Grab the object, r/w and annex. */
1981 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1983 write_enn (own_buf
);
1988 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1991 const struct qxfer
*q
= &qxfer_packets
[i
];
1993 if (strcmp (object
, q
->object
) == 0)
1995 if (strcmp (rw
, "read") == 0)
1997 unsigned char *data
;
2002 /* Grab the offset and length. */
2003 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2005 write_enn (own_buf
);
2009 /* Read one extra byte, as an indicator of whether there is
2011 if (len
> PBUFSIZ
- 2)
2013 data
= (unsigned char *) malloc (len
+ 1);
2016 write_enn (own_buf
);
2019 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2027 /* Preserve error message. */
2030 write_enn (own_buf
);
2032 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2034 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2039 else if (strcmp (rw
, "write") == 0)
2044 unsigned char *data
;
2046 strcpy (own_buf
, "E00");
2047 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2050 write_enn (own_buf
);
2053 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2054 &ofs
, &len
, data
) < 0)
2057 write_enn (own_buf
);
2061 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2069 /* Preserve error message. */
2072 write_enn (own_buf
);
2074 sprintf (own_buf
, "%x", n
);
2087 /* Compute 32 bit CRC from inferior memory.
2089 On success, return 32 bit CRC.
2090 On failure, return (unsigned long long) -1. */
2092 static unsigned long long
2093 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2097 unsigned char byte
= 0;
2099 /* Return failure if memory read fails. */
2100 if (read_inferior_memory (base
, &byte
, 1) != 0)
2101 return (unsigned long long) -1;
2103 crc
= xcrc32 (&byte
, 1, crc
);
2106 return (unsigned long long) crc
;
2109 /* Add supported btrace packets to BUF. */
2112 supported_btrace_packets (char *buf
)
2114 int btrace_supported
= 0;
2116 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2118 strcat (buf
, ";Qbtrace:bts+");
2119 strcat (buf
, ";Qbtrace-conf:bts:size+");
2121 btrace_supported
= 1;
2124 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2126 strcat (buf
, ";Qbtrace:pt+");
2127 strcat (buf
, ";Qbtrace-conf:pt:size+");
2129 btrace_supported
= 1;
2132 if (!btrace_supported
)
2135 strcat (buf
, ";Qbtrace:off+");
2136 strcat (buf
, ";qXfer:btrace:read+");
2137 strcat (buf
, ";qXfer:btrace-conf:read+");
2140 /* Handle all of the extended 'q' packets. */
2143 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2145 static std::list
<thread_info
*>::const_iterator thread_iter
;
2147 /* Reply the current thread id. */
2148 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2151 require_running_or_return (own_buf
);
2153 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2154 ptid
= general_thread
;
2157 thread_iter
= all_threads
.begin ();
2158 ptid
= (*thread_iter
)->id
;
2161 sprintf (own_buf
, "QC");
2163 write_ptid (own_buf
, ptid
);
2167 if (strcmp ("qSymbol::", own_buf
) == 0)
2169 struct thread_info
*save_thread
= current_thread
;
2171 /* For qSymbol, GDB only changes the current thread if the
2172 previous current thread was of a different process. So if
2173 the previous thread is gone, we need to pick another one of
2174 the same process. This can happen e.g., if we followed an
2175 exec in a non-leader thread. */
2176 if (current_thread
== NULL
)
2179 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2181 /* Just in case, if we didn't find a thread, then bail out
2182 instead of crashing. */
2183 if (current_thread
== NULL
)
2185 write_enn (own_buf
);
2186 current_thread
= save_thread
;
2191 /* GDB is suggesting new symbols have been loaded. This may
2192 mean a new shared library has been detected as loaded, so
2193 take the opportunity to check if breakpoints we think are
2194 inserted, still are. Note that it isn't guaranteed that
2195 we'll see this when a shared library is loaded, and nor will
2196 we see this for unloads (although breakpoints in unloaded
2197 libraries shouldn't trigger), as GDB may not find symbols for
2198 the library at all. We also re-validate breakpoints when we
2199 see a second GDB breakpoint for the same address, and or when
2200 we access breakpoint shadows. */
2201 validate_breakpoints ();
2203 if (target_supports_tracepoints ())
2204 tracepoint_look_up_symbols ();
2206 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2207 (*the_target
->look_up_symbols
) ();
2209 current_thread
= save_thread
;
2211 strcpy (own_buf
, "OK");
2215 if (!disable_packet_qfThreadInfo
)
2217 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2219 require_running_or_return (own_buf
);
2220 thread_iter
= all_threads
.begin ();
2223 ptid_t ptid
= (*thread_iter
)->id
;
2224 write_ptid (own_buf
, ptid
);
2229 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2231 require_running_or_return (own_buf
);
2232 if (thread_iter
!= all_threads
.end ())
2235 ptid_t ptid
= (*thread_iter
)->id
;
2236 write_ptid (own_buf
, ptid
);
2242 sprintf (own_buf
, "l");
2248 if (the_target
->read_offsets
!= NULL
2249 && strcmp ("qOffsets", own_buf
) == 0)
2251 CORE_ADDR text
, data
;
2253 require_running_or_return (own_buf
);
2254 if (the_target
->read_offsets (&text
, &data
))
2255 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2256 (long)text
, (long)data
, (long)data
);
2258 write_enn (own_buf
);
2263 /* Protocol features query. */
2264 if (startswith (own_buf
, "qSupported")
2265 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2267 char *p
= &own_buf
[10];
2268 int gdb_supports_qRelocInsn
= 0;
2270 /* Process each feature being provided by GDB. The first
2271 feature will follow a ':', and latter features will follow
2275 char **qsupported
= NULL
;
2280 /* Two passes, to avoid nested strtok calls in
2281 target_process_qsupported. */
2282 for (p
= strtok (p
+ 1, ";");
2284 p
= strtok (NULL
, ";"))
2287 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2288 qsupported
[count
- 1] = xstrdup (p
);
2291 for (i
= 0; i
< count
; i
++)
2294 if (strcmp (p
, "multiprocess+") == 0)
2296 /* GDB supports and wants multi-process support if
2298 if (target_supports_multi_process ())
2301 else if (strcmp (p
, "qRelocInsn+") == 0)
2303 /* GDB supports relocate instruction requests. */
2304 gdb_supports_qRelocInsn
= 1;
2306 else if (strcmp (p
, "swbreak+") == 0)
2308 /* GDB wants us to report whether a trap is caused
2309 by a software breakpoint and for us to handle PC
2310 adjustment if necessary on this target. */
2311 if (target_supports_stopped_by_sw_breakpoint ())
2312 swbreak_feature
= 1;
2314 else if (strcmp (p
, "hwbreak+") == 0)
2316 /* GDB wants us to report whether a trap is caused
2317 by a hardware breakpoint. */
2318 if (target_supports_stopped_by_hw_breakpoint ())
2319 hwbreak_feature
= 1;
2321 else if (strcmp (p
, "fork-events+") == 0)
2323 /* GDB supports and wants fork events if possible. */
2324 if (target_supports_fork_events ())
2325 report_fork_events
= 1;
2327 else if (strcmp (p
, "vfork-events+") == 0)
2329 /* GDB supports and wants vfork events if possible. */
2330 if (target_supports_vfork_events ())
2331 report_vfork_events
= 1;
2333 else if (strcmp (p
, "exec-events+") == 0)
2335 /* GDB supports and wants exec events if possible. */
2336 if (target_supports_exec_events ())
2337 report_exec_events
= 1;
2339 else if (strcmp (p
, "vContSupported+") == 0)
2340 vCont_supported
= 1;
2341 else if (strcmp (p
, "QThreadEvents+") == 0)
2343 else if (strcmp (p
, "no-resumed+") == 0)
2345 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2347 report_no_resumed
= 1;
2351 /* Move the unknown features all together. */
2352 qsupported
[i
] = NULL
;
2353 qsupported
[unknown
] = p
;
2358 /* Give the target backend a chance to process the unknown
2360 target_process_qsupported (qsupported
, unknown
);
2362 for (i
= 0; i
< count
; i
++)
2363 free (qsupported
[i
]);
2368 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2369 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2370 "QEnvironmentReset+;QEnvironmentUnset+;"
2374 if (target_supports_catch_syscall ())
2375 strcat (own_buf
, ";QCatchSyscalls+");
2377 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2378 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2379 ";augmented-libraries-svr4-read+");
2382 /* We do not have any hook to indicate whether the non-SVR4 target
2383 backend supports qXfer:libraries:read, so always report it. */
2384 strcat (own_buf
, ";qXfer:libraries:read+");
2387 if (the_target
->read_auxv
!= NULL
)
2388 strcat (own_buf
, ";qXfer:auxv:read+");
2390 if (the_target
->qxfer_spu
!= NULL
)
2391 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2393 if (the_target
->qxfer_siginfo
!= NULL
)
2394 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2396 if (the_target
->read_loadmap
!= NULL
)
2397 strcat (own_buf
, ";qXfer:fdpic:read+");
2399 /* We always report qXfer:features:read, as targets may
2400 install XML files on a subsequent call to arch_setup.
2401 If we reported to GDB on startup that we don't support
2402 qXfer:feature:read at all, we will never be re-queried. */
2403 strcat (own_buf
, ";qXfer:features:read+");
2405 if (transport_is_reliable
)
2406 strcat (own_buf
, ";QStartNoAckMode+");
2408 if (the_target
->qxfer_osdata
!= NULL
)
2409 strcat (own_buf
, ";qXfer:osdata:read+");
2411 if (target_supports_multi_process ())
2412 strcat (own_buf
, ";multiprocess+");
2414 if (target_supports_fork_events ())
2415 strcat (own_buf
, ";fork-events+");
2417 if (target_supports_vfork_events ())
2418 strcat (own_buf
, ";vfork-events+");
2420 if (target_supports_exec_events ())
2421 strcat (own_buf
, ";exec-events+");
2423 if (target_supports_non_stop ())
2424 strcat (own_buf
, ";QNonStop+");
2426 if (target_supports_disable_randomization ())
2427 strcat (own_buf
, ";QDisableRandomization+");
2429 strcat (own_buf
, ";qXfer:threads:read+");
2431 if (target_supports_tracepoints ())
2433 strcat (own_buf
, ";ConditionalTracepoints+");
2434 strcat (own_buf
, ";TraceStateVariables+");
2435 strcat (own_buf
, ";TracepointSource+");
2436 strcat (own_buf
, ";DisconnectedTracing+");
2437 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2438 strcat (own_buf
, ";FastTracepoints+");
2439 strcat (own_buf
, ";StaticTracepoints+");
2440 strcat (own_buf
, ";InstallInTrace+");
2441 strcat (own_buf
, ";qXfer:statictrace:read+");
2442 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2443 strcat (own_buf
, ";EnableDisableTracepoints+");
2444 strcat (own_buf
, ";QTBuffer:size+");
2445 strcat (own_buf
, ";tracenz+");
2448 if (target_supports_hardware_single_step ()
2449 || target_supports_software_single_step () )
2451 strcat (own_buf
, ";ConditionalBreakpoints+");
2453 strcat (own_buf
, ";BreakpointCommands+");
2455 if (target_supports_agent ())
2456 strcat (own_buf
, ";QAgent+");
2458 supported_btrace_packets (own_buf
);
2460 if (target_supports_stopped_by_sw_breakpoint ())
2461 strcat (own_buf
, ";swbreak+");
2463 if (target_supports_stopped_by_hw_breakpoint ())
2464 strcat (own_buf
, ";hwbreak+");
2466 if (the_target
->pid_to_exec_file
!= NULL
)
2467 strcat (own_buf
, ";qXfer:exec-file:read+");
2469 strcat (own_buf
, ";vContSupported+");
2471 strcat (own_buf
, ";QThreadEvents+");
2473 strcat (own_buf
, ";no-resumed+");
2475 /* Reinitialize components as needed for the new connection. */
2476 hostio_handle_new_gdb_connection ();
2477 target_handle_new_gdb_connection ();
2482 /* Thread-local storage support. */
2483 if (the_target
->get_tls_address
!= NULL
2484 && startswith (own_buf
, "qGetTLSAddr:"))
2486 char *p
= own_buf
+ 12;
2487 CORE_ADDR parts
[2], address
= 0;
2489 ptid_t ptid
= null_ptid
;
2491 require_running_or_return (own_buf
);
2493 for (i
= 0; i
< 3; i
++)
2501 p2
= strchr (p
, ',');
2514 ptid
= read_ptid (p
, NULL
);
2516 decode_address (&parts
[i
- 1], p
, len
);
2520 if (p
!= NULL
|| i
< 3)
2524 struct thread_info
*thread
= find_thread_ptid (ptid
);
2529 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2535 strcpy (own_buf
, paddress(address
));
2540 write_enn (own_buf
);
2544 /* Otherwise, pretend we do not understand this packet. */
2547 /* Windows OS Thread Information Block address support. */
2548 if (the_target
->get_tib_address
!= NULL
2549 && startswith (own_buf
, "qGetTIBAddr:"))
2554 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2556 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2559 strcpy (own_buf
, paddress(tlb
));
2564 write_enn (own_buf
);
2570 /* Handle "monitor" commands. */
2571 if (startswith (own_buf
, "qRcmd,"))
2573 char *mon
= (char *) malloc (PBUFSIZ
);
2574 int len
= strlen (own_buf
+ 6);
2578 write_enn (own_buf
);
2583 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2585 write_enn (own_buf
);
2589 mon
[len
/ 2] = '\0';
2593 if (the_target
->handle_monitor_command
== NULL
2594 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2595 /* Default processing. */
2596 handle_monitor_command (mon
, own_buf
);
2602 if (startswith (own_buf
, "qSearch:memory:"))
2604 require_running_or_return (own_buf
);
2605 handle_search_memory (own_buf
, packet_len
);
2609 if (strcmp (own_buf
, "qAttached") == 0
2610 || startswith (own_buf
, "qAttached:"))
2612 struct process_info
*process
;
2614 if (own_buf
[sizeof ("qAttached") - 1])
2616 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2617 process
= find_process_pid (pid
);
2621 require_running_or_return (own_buf
);
2622 process
= current_process ();
2625 if (process
== NULL
)
2627 write_enn (own_buf
);
2631 strcpy (own_buf
, process
->attached
? "1" : "0");
2635 if (startswith (own_buf
, "qCRC:"))
2637 /* CRC check (compare-section). */
2641 unsigned long long crc
;
2643 require_running_or_return (own_buf
);
2644 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2645 if (*comma
++ != ',')
2647 write_enn (own_buf
);
2650 len
= strtoul (comma
, NULL
, 16);
2651 crc
= crc32 (base
, len
, 0xffffffff);
2652 /* Check for memory failure. */
2653 if (crc
== (unsigned long long) -1)
2655 write_enn (own_buf
);
2658 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2662 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2665 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2668 /* Otherwise we didn't know what packet it was. Say we didn't
2673 static void gdb_wants_all_threads_stopped (void);
2674 static void resume (struct thread_resume
*actions
, size_t n
);
2676 /* The callback that is passed to visit_actioned_threads. */
2677 typedef int (visit_actioned_threads_callback_ftype
)
2678 (const struct thread_resume
*, struct thread_info
*);
2680 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2681 true if CALLBACK returns true. Returns false if no matching thread
2682 is found or CALLBACK results false.
2683 Note: This function is itself a callback for find_thread. */
2686 visit_actioned_threads (thread_info
*thread
,
2687 const struct thread_resume
*actions
,
2689 visit_actioned_threads_callback_ftype
*callback
)
2691 for (size_t i
= 0; i
< num_actions
; i
++)
2693 const struct thread_resume
*action
= &actions
[i
];
2695 if (ptid_equal (action
->thread
, minus_one_ptid
)
2696 || ptid_equal (action
->thread
, thread
->id
)
2697 || ((ptid_get_pid (action
->thread
)
2698 == thread
->id
.pid ())
2699 && ptid_get_lwp (action
->thread
) == -1))
2701 if ((*callback
) (action
, thread
))
2709 /* Callback for visit_actioned_threads. If the thread has a pending
2710 status to report, report it now. */
2713 handle_pending_status (const struct thread_resume
*resumption
,
2714 struct thread_info
*thread
)
2716 if (thread
->status_pending_p
)
2718 thread
->status_pending_p
= 0;
2720 last_status
= thread
->last_status
;
2721 last_ptid
= thread
->id
;
2722 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2728 /* Parse vCont packets. */
2730 handle_v_cont (char *own_buf
)
2734 struct thread_resume
*resume_info
;
2735 struct thread_resume default_action
{ null_ptid
};
2737 /* Count the number of semicolons in the packet. There should be one
2738 for every action. */
2744 p
= strchr (p
, ';');
2747 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2748 if (resume_info
== NULL
)
2756 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2758 if (p
[0] == 's' || p
[0] == 'S')
2759 resume_info
[i
].kind
= resume_step
;
2760 else if (p
[0] == 'r')
2761 resume_info
[i
].kind
= resume_step
;
2762 else if (p
[0] == 'c' || p
[0] == 'C')
2763 resume_info
[i
].kind
= resume_continue
;
2764 else if (p
[0] == 't')
2765 resume_info
[i
].kind
= resume_stop
;
2769 if (p
[0] == 'S' || p
[0] == 'C')
2772 int sig
= strtol (p
+ 1, &q
, 16);
2777 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2779 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2781 else if (p
[0] == 'r')
2785 p
= unpack_varlen_hex (p
+ 1, &addr
);
2786 resume_info
[i
].step_range_start
= addr
;
2791 p
= unpack_varlen_hex (p
+ 1, &addr
);
2792 resume_info
[i
].step_range_end
= addr
;
2801 resume_info
[i
].thread
= minus_one_ptid
;
2802 default_action
= resume_info
[i
];
2804 /* Note: we don't increment i here, we'll overwrite this entry
2805 the next time through. */
2807 else if (p
[0] == ':')
2810 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2815 if (p
[0] != ';' && p
[0] != 0)
2818 resume_info
[i
].thread
= ptid
;
2825 resume_info
[i
] = default_action
;
2827 resume (resume_info
, n
);
2832 write_enn (own_buf
);
2837 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2840 resume (struct thread_resume
*actions
, size_t num_actions
)
2844 /* Check if among the threads that GDB wants actioned, there's
2845 one with a pending status to report. If so, skip actually
2846 resuming/stopping and report the pending event
2849 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2851 return visit_actioned_threads (thread
, actions
, num_actions
,
2852 handle_pending_status
);
2855 if (thread_with_status
!= NULL
)
2861 (*the_target
->resume
) (actions
, num_actions
);
2867 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2869 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2870 && !report_no_resumed
)
2872 /* The client does not support this stop reply. At least
2874 sprintf (own_buf
, "E.No unwaited-for children left.");
2875 disable_async_io ();
2879 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2880 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2881 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2882 current_thread
->last_status
= last_status
;
2884 /* From the client's perspective, all-stop mode always stops all
2885 threads implicitly (and the target backend has already done
2886 so by now). Tag all threads as "want-stopped", so we don't
2887 resume them implicitly without the client telling us to. */
2888 gdb_wants_all_threads_stopped ();
2889 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2890 disable_async_io ();
2892 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2893 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2894 target_mourn_inferior (last_ptid
);
2898 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2900 handle_v_attach (char *own_buf
)
2904 pid
= strtol (own_buf
+ 8, NULL
, 16);
2905 if (pid
!= 0 && attach_inferior (pid
) == 0)
2907 /* Don't report shared library events after attaching, even if
2908 some libraries are preloaded. GDB will always poll the
2909 library list. Avoids the "stopped by shared library event"
2910 notice on the GDB side. */
2915 /* In non-stop, we don't send a resume reply. Stop events
2916 will follow up using the normal notification
2921 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2927 write_enn (own_buf
);
2932 /* Run a new program. Return 1 if successful, 0 if failure. */
2934 handle_v_run (char *own_buf
)
2937 std::vector
<char *> new_argv
;
2938 char *new_program_name
= NULL
;
2942 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2948 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2950 next_p
= strchr (p
, ';');
2952 next_p
= p
+ strlen (p
);
2954 if (i
== 0 && p
== next_p
)
2956 /* No program specified. */
2957 new_program_name
= NULL
;
2959 else if (p
== next_p
)
2961 /* Empty argument. */
2962 new_argv
.push_back (xstrdup ("''"));
2966 size_t len
= (next_p
- p
) / 2;
2967 /* ARG is the unquoted argument received via the RSP. */
2968 char *arg
= (char *) xmalloc (len
+ 1);
2969 /* FULL_ARGS will contain the quoted version of ARG. */
2970 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2971 /* These are pointers used to navigate the strings above. */
2972 char *tmp_arg
= arg
;
2973 char *tmp_full_arg
= full_arg
;
2976 hex2bin (p
, (gdb_byte
*) arg
, len
);
2979 while (*tmp_arg
!= '\0')
2985 *tmp_full_arg
= '\'';
2991 /* Quote single quote. */
2992 *tmp_full_arg
= '\\';
3000 *tmp_full_arg
= *tmp_arg
;
3006 *tmp_full_arg
++ = '\'';
3008 /* Finish FULL_ARG and push it into the vector containing
3010 *tmp_full_arg
= '\0';
3012 new_program_name
= full_arg
;
3014 new_argv
.push_back (full_arg
);
3020 new_argv
.push_back (NULL
);
3022 if (new_program_name
== NULL
)
3024 /* GDB didn't specify a program to run. Use the program from the
3025 last run with the new argument list. */
3026 if (program_name
== NULL
)
3028 write_enn (own_buf
);
3029 free_vector_argv (new_argv
);
3035 xfree (program_name
);
3036 program_name
= new_program_name
;
3039 /* Free the old argv and install the new one. */
3040 free_vector_argv (program_args
);
3041 program_args
= new_argv
;
3043 create_inferior (program_name
, program_args
);
3045 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3047 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3049 /* In non-stop, sending a resume reply doesn't set the general
3050 thread, but GDB assumes a vRun sets it (this is so GDB can
3051 query which is the main thread of the new inferior. */
3053 general_thread
= last_ptid
;
3059 write_enn (own_buf
);
3064 /* Kill process. Return 1 if successful, 0 if failure. */
3066 handle_v_kill (char *own_buf
)
3069 char *p
= &own_buf
[6];
3071 pid
= strtol (p
, NULL
, 16);
3074 if (pid
!= 0 && kill_inferior (pid
) == 0)
3076 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3077 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3078 last_ptid
= pid_to_ptid (pid
);
3079 discard_queued_stop_replies (last_ptid
);
3085 write_enn (own_buf
);
3090 /* Handle all of the extended 'v' packets. */
3092 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3094 if (!disable_packet_vCont
)
3096 if (strcmp (own_buf
, "vCtrlC") == 0)
3098 (*the_target
->request_interrupt
) ();
3103 if (startswith (own_buf
, "vCont;"))
3105 handle_v_cont (own_buf
);
3109 if (startswith (own_buf
, "vCont?"))
3111 strcpy (own_buf
, "vCont;c;C;t");
3113 if (target_supports_hardware_single_step ()
3114 || target_supports_software_single_step ()
3115 || !vCont_supported
)
3117 /* If target supports single step either by hardware or by
3118 software, add actions s and S to the list of supported
3119 actions. On the other hand, if GDB doesn't request the
3120 supported vCont actions in qSupported packet, add s and
3121 S to the list too. */
3122 own_buf
= own_buf
+ strlen (own_buf
);
3123 strcpy (own_buf
, ";s;S");
3126 if (target_supports_range_stepping ())
3128 own_buf
= own_buf
+ strlen (own_buf
);
3129 strcpy (own_buf
, ";r");
3135 if (startswith (own_buf
, "vFile:")
3136 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3139 if (startswith (own_buf
, "vAttach;"))
3141 if ((!extended_protocol
|| !multi_process
) && target_running ())
3143 fprintf (stderr
, "Already debugging a process\n");
3144 write_enn (own_buf
);
3147 handle_v_attach (own_buf
);
3151 if (startswith (own_buf
, "vRun;"))
3153 if ((!extended_protocol
|| !multi_process
) && target_running ())
3155 fprintf (stderr
, "Already debugging a process\n");
3156 write_enn (own_buf
);
3159 handle_v_run (own_buf
);
3163 if (startswith (own_buf
, "vKill;"))
3165 if (!target_running ())
3167 fprintf (stderr
, "No process to kill\n");
3168 write_enn (own_buf
);
3171 handle_v_kill (own_buf
);
3175 if (handle_notif_ack (own_buf
, packet_len
))
3178 /* Otherwise we didn't know what packet it was. Say we didn't
3184 /* Resume thread and wait for another event. In non-stop mode,
3185 don't really wait here, but return immediatelly to the event
3188 myresume (char *own_buf
, int step
, int sig
)
3190 struct thread_resume resume_info
[2];
3192 int valid_cont_thread
;
3194 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3195 && !ptid_equal (cont_thread
, minus_one_ptid
));
3197 if (step
|| sig
|| valid_cont_thread
)
3199 resume_info
[0].thread
= current_ptid
;
3201 resume_info
[0].kind
= resume_step
;
3203 resume_info
[0].kind
= resume_continue
;
3204 resume_info
[0].sig
= sig
;
3208 if (!valid_cont_thread
)
3210 resume_info
[n
].thread
= minus_one_ptid
;
3211 resume_info
[n
].kind
= resume_continue
;
3212 resume_info
[n
].sig
= 0;
3216 resume (resume_info
, n
);
3219 /* Callback for for_each_thread. Make a new stop reply for each
3223 queue_stop_reply_callback (thread_info
*thread
)
3225 /* For now, assume targets that don't have this callback also don't
3226 manage the thread's last_status field. */
3227 if (the_target
->thread_stopped
== NULL
)
3229 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3231 new_notif
->ptid
= thread
->id
;
3232 new_notif
->status
= thread
->last_status
;
3233 /* Pass the last stop reply back to GDB, but don't notify
3235 notif_event_enque (¬if_stop
,
3236 (struct notif_event
*) new_notif
);
3240 if (thread_stopped (thread
))
3244 std::string status_string
3245 = target_waitstatus_to_string (&thread
->last_status
);
3247 debug_printf ("Reporting thread %s as already stopped with %s\n",
3248 target_pid_to_str (thread
->id
),
3249 status_string
.c_str ());
3252 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3254 /* Pass the last stop reply back to GDB, but don't notify
3256 queue_stop_reply (thread
->id
, &thread
->last_status
);
3261 /* Set this inferior threads's state as "want-stopped". We won't
3262 resume this thread until the client gives us another action for
3266 gdb_wants_thread_stopped (thread_info
*thread
)
3268 thread
->last_resume_kind
= resume_stop
;
3270 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3272 /* Most threads are stopped implicitly (all-stop); tag that with
3274 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3275 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3279 /* Set all threads' states as "want-stopped". */
3282 gdb_wants_all_threads_stopped (void)
3284 for_each_thread (gdb_wants_thread_stopped
);
3287 /* Callback for for_each_thread. If the thread is stopped with an
3288 interesting event, mark it as having a pending event. */
3291 set_pending_status_callback (thread_info
*thread
)
3293 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3294 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3295 /* A breakpoint, watchpoint or finished step from a previous
3296 GDB run isn't considered interesting for a new GDB run.
3297 If we left those pending, the new GDB could consider them
3298 random SIGTRAPs. This leaves out real async traps. We'd
3299 have to peek into the (target-specific) siginfo to
3300 distinguish those. */
3301 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3302 thread
->status_pending_p
= 1;
3305 /* Status handler for the '?' packet. */
3308 handle_status (char *own_buf
)
3310 /* GDB is connected, don't forward events to the target anymore. */
3311 for_each_process ([] (process_info
*process
) {
3312 process
->gdb_detached
= 0;
3315 /* In non-stop mode, we must send a stop reply for each stopped
3316 thread. In all-stop mode, just send one for the first stopped
3321 for_each_thread (queue_stop_reply_callback
);
3323 /* The first is sent immediatly. OK is sent if there is no
3324 stopped thread, which is the same handling of the vStopped
3325 packet (by design). */
3326 notif_write_event (¬if_stop
, own_buf
);
3330 thread_info
*thread
= NULL
;
3333 stabilize_threads ();
3334 gdb_wants_all_threads_stopped ();
3336 /* We can only report one status, but we might be coming out of
3337 non-stop -- if more than one thread is stopped with
3338 interesting events, leave events for the threads we're not
3339 reporting now pending. They'll be reported the next time the
3340 threads are resumed. Start by marking all interesting events
3342 for_each_thread (set_pending_status_callback
);
3344 /* Prefer the last thread that reported an event to GDB (even if
3345 that was a GDB_SIGNAL_TRAP). */
3346 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3347 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3348 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3349 thread
= find_thread_ptid (last_ptid
);
3351 /* If the last event thread is not found for some reason, look
3352 for some other thread that might have an event to report. */
3354 thread
= find_thread ([] (thread_info
*thread
)
3356 return thread
->status_pending_p
;
3359 /* If we're still out of luck, simply pick the first thread in
3362 thread
= get_first_thread ();
3366 struct thread_info
*tp
= (struct thread_info
*) thread
;
3368 /* We're reporting this event, so it's no longer
3370 tp
->status_pending_p
= 0;
3372 /* GDB assumes the current thread is the thread we're
3373 reporting the status for. */
3374 general_thread
= thread
->id
;
3375 set_desired_thread ();
3377 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3378 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3381 strcpy (own_buf
, "W00");
3386 gdbserver_version (void)
3388 printf ("GNU gdbserver %s%s\n"
3389 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3390 "gdbserver is free software, covered by the "
3391 "GNU General Public License.\n"
3392 "This gdbserver was configured as \"%s\"\n",
3393 PKGVERSION
, version
, host_name
);
3397 gdbserver_usage (FILE *stream
)
3399 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3400 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3401 "\tgdbserver [OPTIONS] --multi COMM\n"
3403 "COMM may either be a tty device (for serial debugging),\n"
3404 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3405 "stdin/stdout of gdbserver.\n"
3406 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3407 "PID is the process ID to attach to, when --attach is specified.\n"
3409 "Operating modes:\n"
3411 " --attach Attach to running process PID.\n"
3412 " --multi Start server without a specific program, and\n"
3413 " only quit when explicitly commanded.\n"
3414 " --once Exit after the first connection has closed.\n"
3415 " --help Print this message and then exit.\n"
3416 " --version Display version information and exit.\n"
3420 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3421 " --disable-randomization\n"
3422 " Run PROG with address space randomization disabled.\n"
3423 " --no-disable-randomization\n"
3424 " Don't disable address space randomization when\n"
3426 " --startup-with-shell\n"
3427 " Start PROG using a shell. I.e., execs a shell that\n"
3428 " then execs PROG. (default)\n"
3429 " --no-startup-with-shell\n"
3430 " Exec PROG directly instead of using a shell.\n"
3431 " Disables argument globbing and variable substitution\n"
3432 " on UNIX-like systems.\n"
3436 " --debug Enable general debugging output.\n"
3437 " --debug-format=opt1[,opt2,...]\n"
3438 " Specify extra content in debugging output.\n"
3443 " --remote-debug Enable remote protocol debugging output.\n"
3444 " --disable-packet=opt1[,opt2,...]\n"
3445 " Disable support for RSP packets or features.\n"
3447 " vCont, Tthread, qC, qfThreadInfo and \n"
3448 " threads (disable all threading packets).\n"
3450 "For more information, consult the GDB manual (available as on-line \n"
3451 "info or a printed manual).\n");
3452 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3453 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3457 gdbserver_show_disableable (FILE *stream
)
3459 fprintf (stream
, "Disableable packets:\n"
3460 " vCont \tAll vCont packets\n"
3461 " qC \tQuerying the current thread\n"
3462 " qfThreadInfo\tThread listing\n"
3463 " Tthread \tPassing the thread specifier in the "
3464 "T stop reply packet\n"
3465 " threads \tAll of the above\n");
3469 kill_inferior_callback (process_info
*process
)
3471 int pid
= process
->pid
;
3473 kill_inferior (pid
);
3474 discard_queued_stop_replies (pid_to_ptid (pid
));
3477 /* Call this when exiting gdbserver with possible inferiors that need
3478 to be killed or detached from. */
3481 detach_or_kill_for_exit (void)
3483 /* First print a list of the inferiors we will be killing/detaching.
3484 This is to assist the user, for example, in case the inferior unexpectedly
3485 dies after we exit: did we screw up or did the inferior exit on its own?
3486 Having this info will save some head-scratching. */
3488 if (have_started_inferiors_p ())
3490 fprintf (stderr
, "Killing process(es):");
3492 for_each_process ([] (process_info
*process
) {
3493 if (!process
->attached
)
3494 fprintf (stderr
, " %d", process
->pid
);
3497 fprintf (stderr
, "\n");
3499 if (have_attached_inferiors_p ())
3501 fprintf (stderr
, "Detaching process(es):");
3503 for_each_process ([] (process_info
*process
) {
3504 if (process
->attached
)
3505 fprintf (stderr
, " %d", process
->pid
);
3508 fprintf (stderr
, "\n");
3511 /* Now we can kill or detach the inferiors. */
3512 for_each_process ([] (process_info
*process
) {
3513 int pid
= process
->pid
;
3515 if (process
->attached
)
3516 detach_inferior (pid
);
3518 kill_inferior (pid
);
3520 discard_queued_stop_replies (pid_to_ptid (pid
));
3524 /* Value that will be passed to exit(3) when gdbserver exits. */
3525 static int exit_code
;
3527 /* Cleanup version of detach_or_kill_for_exit. */
3530 detach_or_kill_for_exit_cleanup (void *ignore
)
3535 detach_or_kill_for_exit ();
3538 CATCH (exception
, RETURN_MASK_ALL
)
3541 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3547 /* Main function. This is called by the real "main" function,
3548 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3550 static void ATTRIBUTE_NORETURN
3551 captured_main (int argc
, char *argv
[])
3556 const char *port
= NULL
;
3557 char **next_arg
= &argv
[1];
3558 volatile int multi_mode
= 0;
3559 volatile int attach
= 0;
3561 bool selftest
= false;
3563 const char *selftest_filter
= NULL
;
3566 while (*next_arg
!= NULL
&& **next_arg
== '-')
3568 if (strcmp (*next_arg
, "--version") == 0)
3570 gdbserver_version ();
3573 else if (strcmp (*next_arg
, "--help") == 0)
3575 gdbserver_usage (stdout
);
3578 else if (strcmp (*next_arg
, "--attach") == 0)
3580 else if (strcmp (*next_arg
, "--multi") == 0)
3582 else if (strcmp (*next_arg
, "--wrapper") == 0)
3589 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3591 wrapper_argv
+= *next_arg
;
3592 wrapper_argv
+= ' ';
3596 if (!wrapper_argv
.empty ())
3598 /* Erase the last whitespace. */
3599 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3602 if (next_arg
== tmp
|| *next_arg
== NULL
)
3604 gdbserver_usage (stderr
);
3608 /* Consume the "--". */
3611 else if (strcmp (*next_arg
, "--debug") == 0)
3613 else if (startswith (*next_arg
, "--debug-format="))
3615 std::string error_msg
3616 = parse_debug_format_options ((*next_arg
)
3617 + sizeof ("--debug-format=") - 1, 0);
3619 if (!error_msg
.empty ())
3621 fprintf (stderr
, "%s", error_msg
.c_str ());
3625 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3627 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3629 gdbserver_show_disableable (stdout
);
3632 else if (startswith (*next_arg
, "--disable-packet="))
3634 char *packets
, *tok
;
3636 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3637 for (tok
= strtok (packets
, ",");
3639 tok
= strtok (NULL
, ","))
3641 if (strcmp ("vCont", tok
) == 0)
3642 disable_packet_vCont
= 1;
3643 else if (strcmp ("Tthread", tok
) == 0)
3644 disable_packet_Tthread
= 1;
3645 else if (strcmp ("qC", tok
) == 0)
3646 disable_packet_qC
= 1;
3647 else if (strcmp ("qfThreadInfo", tok
) == 0)
3648 disable_packet_qfThreadInfo
= 1;
3649 else if (strcmp ("threads", tok
) == 0)
3651 disable_packet_vCont
= 1;
3652 disable_packet_Tthread
= 1;
3653 disable_packet_qC
= 1;
3654 disable_packet_qfThreadInfo
= 1;
3658 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3660 gdbserver_show_disableable (stderr
);
3665 else if (strcmp (*next_arg
, "-") == 0)
3667 /* "-" specifies a stdio connection and is a form of port
3669 port
= STDIO_CONNECTION_NAME
;
3673 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3674 disable_randomization
= 1;
3675 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3676 disable_randomization
= 0;
3677 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3678 startup_with_shell
= true;
3679 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3680 startup_with_shell
= false;
3681 else if (strcmp (*next_arg
, "--once") == 0)
3683 else if (strcmp (*next_arg
, "--selftest") == 0)
3685 else if (startswith (*next_arg
, "--selftest="))
3689 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3694 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3707 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3710 gdbserver_usage (stderr
);
3714 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3715 opened by remote_prepare. */
3718 save_original_signals_state (false);
3720 /* We need to know whether the remote connection is stdio before
3721 starting the inferior. Inferiors created in this scenario have
3722 stdin,stdout redirected. So do this here before we call
3725 remote_prepare (port
);
3730 /* --attach used to come after PORT, so allow it there for
3732 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3739 && (*next_arg
== NULL
3740 || (*next_arg
)[0] == '\0'
3741 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3743 || next_arg
[1] != NULL
))
3748 gdbserver_usage (stderr
);
3752 /* Gather information about the environment. */
3753 our_environ
= gdb_environ::from_host_environ ();
3755 initialize_async_io ();
3757 have_job_control ();
3758 initialize_event_loop ();
3759 if (target_supports_tracepoints ())
3760 initialize_tracepoint ();
3761 initialize_notif ();
3763 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3764 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3769 selftests::run_tests (selftest_filter
);
3771 printf (_("Selftests are not available in a non-development build.\n"));
3773 throw_quit ("Quit");
3776 if (pid
== 0 && *next_arg
!= NULL
)
3780 n
= argc
- (next_arg
- argv
);
3781 program_name
= xstrdup (next_arg
[0]);
3782 for (i
= 1; i
< n
; i
++)
3783 program_args
.push_back (xstrdup (next_arg
[i
]));
3784 program_args
.push_back (NULL
);
3786 /* Wait till we are at first instruction in program. */
3787 create_inferior (program_name
, program_args
);
3789 /* We are now (hopefully) stopped at the first instruction of
3790 the target process. This assumes that the target process was
3791 successfully created. */
3795 if (attach_inferior (pid
) == -1)
3796 error ("Attaching not supported on this target");
3798 /* Otherwise succeeded. */
3802 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3803 last_status
.value
.integer
= 0;
3804 last_ptid
= minus_one_ptid
;
3806 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3808 /* Don't report shared library events on the initial connection,
3809 even if some libraries are preloaded. Avoids the "stopped by
3810 shared library event" notice on gdb side. */
3813 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3814 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3819 if (!was_running
&& !multi_mode
)
3820 error ("No program to debug");
3827 report_fork_events
= 0;
3828 report_vfork_events
= 0;
3829 report_exec_events
= 0;
3830 /* Be sure we're out of tfind mode. */
3831 current_traceframe
= -1;
3832 cont_thread
= null_ptid
;
3833 swbreak_feature
= 0;
3834 hwbreak_feature
= 0;
3835 vCont_supported
= 0;
3841 /* Wait for events. This will return when all event sources
3842 are removed from the event loop. */
3843 start_event_loop ();
3845 /* If an exit was requested (using the "monitor exit"
3846 command), terminate now. */
3848 throw_quit ("Quit");
3850 /* The only other way to get here is for getpkt to fail:
3852 - If --once was specified, we're done.
3854 - If not in extended-remote mode, and we're no longer
3855 debugging anything, simply exit: GDB has disconnected
3856 after processing the last process exit.
3858 - Otherwise, close the connection and reopen it at the
3860 if (run_once
|| (!extended_protocol
&& !target_running ()))
3861 throw_quit ("Quit");
3864 "Remote side has terminated connection. "
3865 "GDBserver will reopen the connection.\n");
3867 /* Get rid of any pending statuses. An eventual reconnection
3868 (by the same GDB instance or another) will refresh all its
3869 state from scratch. */
3870 discard_queued_stop_replies (minus_one_ptid
);
3871 for_each_thread ([] (thread_info
*thread
)
3873 thread
->status_pending_p
= 0;
3878 if (disconnected_tracing
)
3880 /* Try to enable non-stop/async mode, so we we can
3881 both wait for an async socket accept, and handle
3882 async target events simultaneously. There's also
3883 no point either in having the target always stop
3884 all threads, when we're going to pass signals
3885 down without informing GDB. */
3888 if (start_non_stop (1))
3891 /* Detaching implicitly resumes all threads;
3892 simply disconnecting does not. */
3898 "Disconnected tracing disabled; "
3899 "stopping trace run.\n");
3904 CATCH (exception
, RETURN_MASK_ERROR
)
3907 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3909 if (response_needed
)
3911 write_enn (own_buf
);
3916 throw_quit ("Quit");
3922 /* Main function. */
3925 main (int argc
, char *argv
[])
3930 captured_main (argc
, argv
);
3932 CATCH (exception
, RETURN_MASK_ALL
)
3934 if (exception
.reason
== RETURN_ERROR
)
3937 fprintf (stderr
, "%s\n", exception
.message
);
3938 fprintf (stderr
, "Exiting\n");
3946 gdb_assert_not_reached ("captured_main should never return");
3949 /* Process options coming from Z packets for a breakpoint. PACKET is
3950 the packet buffer. *PACKET is updated to point to the first char
3951 after the last processed option. */
3954 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3956 const char *dataptr
= *packet
;
3959 /* Check if data has the correct format. */
3960 if (*dataptr
!= ';')
3967 if (*dataptr
== ';')
3970 if (*dataptr
== 'X')
3972 /* Conditional expression. */
3974 debug_printf ("Found breakpoint condition.\n");
3975 if (!add_breakpoint_condition (bp
, &dataptr
))
3976 dataptr
= strchrnul (dataptr
, ';');
3978 else if (startswith (dataptr
, "cmds:"))
3980 dataptr
+= strlen ("cmds:");
3982 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3983 persist
= (*dataptr
== '1');
3985 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3986 dataptr
= strchrnul (dataptr
, ';');
3990 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3992 /* Skip tokens until we find one that we recognize. */
3993 dataptr
= strchrnul (dataptr
, ';');
3999 /* Event loop callback that handles a serial event. The first byte in
4000 the serial buffer gets us here. We expect characters to arrive at
4001 a brisk pace, so we read the rest of the packet with a blocking
4005 process_serial_event (void)
4013 int new_packet_len
= -1;
4015 disable_async_io ();
4017 response_needed
= 0;
4018 packet_len
= getpkt (own_buf
);
4019 if (packet_len
<= 0)
4022 /* Force an event loop break. */
4025 response_needed
= 1;
4027 char ch
= own_buf
[0];
4031 handle_query (own_buf
, packet_len
, &new_packet_len
);
4034 handle_general_set (own_buf
);
4037 handle_detach (own_buf
);
4040 extended_protocol
= 1;
4044 handle_status (own_buf
);
4047 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4049 require_running_or_break (own_buf
);
4051 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4053 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4054 thread_id
= null_ptid
;
4055 else if (thread_id
.is_pid ())
4057 /* The ptid represents a pid. */
4058 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4062 write_enn (own_buf
);
4066 thread_id
= thread
->id
;
4070 /* The ptid represents a lwp/tid. */
4071 if (find_thread_ptid (thread_id
) == NULL
)
4073 write_enn (own_buf
);
4078 if (own_buf
[1] == 'g')
4080 if (ptid_equal (thread_id
, null_ptid
))
4082 /* GDB is telling us to choose any thread. Check if
4083 the currently selected thread is still valid. If
4084 it is not, select the first available. */
4085 thread_info
*thread
= find_thread_ptid (general_thread
);
4087 thread
= get_first_thread ();
4088 thread_id
= thread
->id
;
4091 general_thread
= thread_id
;
4092 set_desired_thread ();
4093 gdb_assert (current_thread
!= NULL
);
4095 else if (own_buf
[1] == 'c')
4096 cont_thread
= thread_id
;
4102 /* Silently ignore it so that gdb can extend the protocol
4103 without compatibility headaches. */
4108 require_running_or_break (own_buf
);
4109 if (current_traceframe
>= 0)
4111 struct regcache
*regcache
4112 = new_register_cache (current_target_desc ());
4114 if (fetch_traceframe_registers (current_traceframe
,
4116 registers_to_string (regcache
, own_buf
);
4118 write_enn (own_buf
);
4119 free_register_cache (regcache
);
4123 struct regcache
*regcache
;
4125 if (!set_desired_thread ())
4126 write_enn (own_buf
);
4129 regcache
= get_thread_regcache (current_thread
, 1);
4130 registers_to_string (regcache
, own_buf
);
4135 require_running_or_break (own_buf
);
4136 if (current_traceframe
>= 0)
4137 write_enn (own_buf
);
4140 struct regcache
*regcache
;
4142 if (!set_desired_thread ())
4143 write_enn (own_buf
);
4146 regcache
= get_thread_regcache (current_thread
, 1);
4147 registers_from_string (regcache
, &own_buf
[1]);
4153 require_running_or_break (own_buf
);
4154 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4155 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4157 write_enn (own_buf
);
4159 bin2hex (mem_buf
, own_buf
, res
);
4162 require_running_or_break (own_buf
);
4163 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4164 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4167 write_enn (own_buf
);
4170 require_running_or_break (own_buf
);
4171 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4172 &mem_addr
, &len
, &mem_buf
) < 0
4173 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4174 write_enn (own_buf
);
4179 require_running_or_break (own_buf
);
4180 hex2bin (own_buf
+ 1, &sig
, 1);
4181 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4182 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4185 myresume (own_buf
, 0, signal
);
4188 require_running_or_break (own_buf
);
4189 hex2bin (own_buf
+ 1, &sig
, 1);
4190 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4191 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4194 myresume (own_buf
, 1, signal
);
4197 require_running_or_break (own_buf
);
4199 myresume (own_buf
, 0, signal
);
4202 require_running_or_break (own_buf
);
4204 myresume (own_buf
, 1, signal
);
4206 case 'Z': /* insert_ ... */
4208 case 'z': /* remove_ ... */
4213 char type
= own_buf
[1];
4215 const int insert
= ch
== 'Z';
4216 const char *p
= &own_buf
[3];
4218 p
= unpack_varlen_hex (p
, &addr
);
4219 kind
= strtol (p
+ 1, &dataptr
, 16);
4223 struct gdb_breakpoint
*bp
;
4225 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4230 /* GDB may have sent us a list of *point parameters to
4231 be evaluated on the target's side. Read such list
4232 here. If we already have a list of parameters, GDB
4233 is telling us to drop that list and use this one
4235 clear_breakpoint_conditions_and_commands (bp
);
4236 const char *options
= dataptr
;
4237 process_point_options (bp
, &options
);
4241 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4249 write_enn (own_buf
);
4253 response_needed
= 0;
4254 if (!target_running ())
4255 /* The packet we received doesn't make sense - but we can't
4256 reply to it, either. */
4259 fprintf (stderr
, "Killing all inferiors\n");
4261 for_each_process (kill_inferior_callback
);
4263 /* When using the extended protocol, we wait with no program
4264 running. The traditional protocol will exit instead. */
4265 if (extended_protocol
)
4267 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4268 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4276 require_running_or_break (own_buf
);
4278 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4279 if (find_thread_ptid (thread_id
) == NULL
)
4281 write_enn (own_buf
);
4285 if (mythread_alive (thread_id
))
4288 write_enn (own_buf
);
4292 response_needed
= 0;
4294 /* Restarting the inferior is only supported in the extended
4296 if (extended_protocol
)
4298 if (target_running ())
4299 for_each_process (kill_inferior_callback
);
4301 fprintf (stderr
, "GDBserver restarting\n");
4303 /* Wait till we are at 1st instruction in prog. */
4304 if (program_name
!= NULL
)
4306 create_inferior (program_name
, program_args
);
4308 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4310 /* Stopped at the first instruction of the target
4312 general_thread
= last_ptid
;
4316 /* Something went wrong. */
4317 general_thread
= null_ptid
;
4322 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4323 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4329 /* It is a request we don't understand. Respond with an
4330 empty packet so that gdb knows that we don't support this
4336 /* Extended (long) request. */
4337 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4341 /* It is a request we don't understand. Respond with an empty
4342 packet so that gdb knows that we don't support this
4348 if (new_packet_len
!= -1)
4349 putpkt_binary (own_buf
, new_packet_len
);
4353 response_needed
= 0;
4361 /* Event-loop callback for serial events. */
4364 handle_serial_event (int err
, gdb_client_data client_data
)
4367 debug_printf ("handling possible serial event\n");
4369 /* Really handle it. */
4370 if (process_serial_event () < 0)
4373 /* Be sure to not change the selected thread behind GDB's back.
4374 Important in the non-stop mode asynchronous protocol. */
4375 set_desired_thread ();
4380 /* Push a stop notification on the notification queue. */
4383 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4385 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4387 vstop_notif
->status
= *status
;
4388 vstop_notif
->ptid
= ptid
;
4389 /* Push Stop notification. */
4390 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4393 /* Event-loop callback for target events. */
4396 handle_target_event (int err
, gdb_client_data client_data
)
4399 debug_printf ("handling possible target event\n");
4401 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4404 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4406 if (gdb_connected () && report_no_resumed
)
4407 push_stop_notification (null_ptid
, &last_status
);
4409 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4411 int pid
= ptid_get_pid (last_ptid
);
4412 struct process_info
*process
= find_process_pid (pid
);
4413 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4415 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4416 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4418 mark_breakpoints_out (process
);
4419 target_mourn_inferior (last_ptid
);
4421 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4425 /* We're reporting this thread as stopped. Update its
4426 "want-stopped" state to what the client wants, until it
4427 gets a new resume action. */
4428 current_thread
->last_resume_kind
= resume_stop
;
4429 current_thread
->last_status
= last_status
;
4434 if (!target_running ())
4436 /* The last process exited. We're done. */
4440 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4441 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4442 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4446 /* A thread stopped with a signal, but gdb isn't
4447 connected to handle it. Pass it down to the
4448 inferior, as if it wasn't being traced. */
4449 enum gdb_signal signal
;
4452 debug_printf ("GDB not connected; forwarding event %d for"
4454 (int) last_status
.kind
,
4455 target_pid_to_str (last_ptid
));
4457 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4458 signal
= last_status
.value
.sig
;
4460 signal
= GDB_SIGNAL_0
;
4461 target_continue (last_ptid
, signal
);
4465 push_stop_notification (last_ptid
, &last_status
);
4468 /* Be sure to not change the selected thread behind GDB's back.
4469 Important in the non-stop mode asynchronous protocol. */
4470 set_desired_thread ();
4483 } // namespace selftests
4484 #endif /* GDB_SELF_TEST */