1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 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. */
1341 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1344 free_char_ptr_vec (options
);
1349 free_char_ptr_vec (options
);
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 "))
1391 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1394 if (error_msg
!= NULL
)
1396 monitor_output (error_msg
);
1397 monitor_show_help ();
1398 write_enn (own_buf
);
1402 else if (strcmp (mon
, "help") == 0)
1403 monitor_show_help ();
1404 else if (strcmp (mon
, "exit") == 0)
1408 monitor_output ("Unknown monitor command.\n\n");
1409 monitor_show_help ();
1410 write_enn (own_buf
);
1414 /* Associates a callback with each supported qXfer'able object. */
1418 /* The object this handler handles. */
1421 /* Request that the target transfer up to LEN 8-bit bytes of the
1422 target's OBJECT. The OFFSET, for a seekable object, specifies
1423 the starting point. The ANNEX can be used to provide additional
1424 data-specific information to the target.
1426 Return the number of bytes actually transfered, zero when no
1427 further transfer is possible, -1 on error, -2 when the transfer
1428 is not supported, and -3 on a verbose error message that should
1429 be preserved. Return of a positive value smaller than LEN does
1430 not indicate the end of the object, only the end of the transfer.
1432 One, and only one, of readbuf or writebuf must be non-NULL. */
1433 int (*xfer
) (const char *annex
,
1434 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1435 ULONGEST offset
, LONGEST len
);
1438 /* Handle qXfer:auxv:read. */
1441 handle_qxfer_auxv (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
)
1445 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1448 if (annex
[0] != '\0' || current_thread
== NULL
)
1451 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1454 /* Handle qXfer:exec-file:read. */
1457 handle_qxfer_exec_file (const char *annex
,
1458 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1459 ULONGEST offset
, LONGEST len
)
1465 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1468 if (annex
[0] == '\0')
1470 if (current_thread
== NULL
)
1473 pid
= pid_of (current_thread
);
1477 annex
= unpack_varlen_hex (annex
, &pid
);
1478 if (annex
[0] != '\0')
1485 file
= (*the_target
->pid_to_exec_file
) (pid
);
1489 total_len
= strlen (file
);
1491 if (offset
> total_len
)
1494 if (offset
+ len
> total_len
)
1495 len
= total_len
- offset
;
1497 memcpy (readbuf
, file
+ offset
, len
);
1501 /* Handle qXfer:features:read. */
1504 handle_qxfer_features (const char *annex
,
1505 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1506 ULONGEST offset
, LONGEST len
)
1508 const char *document
;
1511 if (writebuf
!= NULL
)
1514 if (!target_running ())
1517 /* Grab the correct annex. */
1518 document
= get_features_xml (annex
);
1519 if (document
== NULL
)
1522 total_len
= strlen (document
);
1524 if (offset
> total_len
)
1527 if (offset
+ len
> total_len
)
1528 len
= total_len
- offset
;
1530 memcpy (readbuf
, document
+ offset
, len
);
1534 /* Handle qXfer:libraries:read. */
1537 handle_qxfer_libraries (const char *annex
,
1538 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1539 ULONGEST offset
, LONGEST len
)
1541 if (writebuf
!= NULL
)
1544 if (annex
[0] != '\0' || current_thread
== NULL
)
1547 std::string document
= "<library-list version=\"1.0\">\n";
1549 for (const dll_info
&dll
: all_dlls
)
1550 document
+= string_printf
1551 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1552 dll
.name
.c_str (), (long) dll
.base_addr
);
1554 document
+= "</library-list>\n";
1556 if (offset
> document
.length ())
1559 if (offset
+ len
> document
.length ())
1560 len
= document
.length () - offset
;
1562 memcpy (readbuf
, &document
[offset
], len
);
1567 /* Handle qXfer:libraries-svr4:read. */
1570 handle_qxfer_libraries_svr4 (const char *annex
,
1571 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1572 ULONGEST offset
, LONGEST len
)
1574 if (writebuf
!= NULL
)
1577 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1580 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1583 /* Handle qXfer:osadata:read. */
1586 handle_qxfer_osdata (const char *annex
,
1587 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1588 ULONGEST offset
, LONGEST len
)
1590 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1593 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1596 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1599 handle_qxfer_siginfo (const char *annex
,
1600 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1601 ULONGEST offset
, LONGEST len
)
1603 if (the_target
->qxfer_siginfo
== NULL
)
1606 if (annex
[0] != '\0' || current_thread
== NULL
)
1609 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1612 /* Handle qXfer:spu:read and qXfer:spu:write. */
1615 handle_qxfer_spu (const char *annex
,
1616 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1617 ULONGEST offset
, LONGEST len
)
1619 if (the_target
->qxfer_spu
== NULL
)
1622 if (current_thread
== NULL
)
1625 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1628 /* Handle qXfer:statictrace:read. */
1631 handle_qxfer_statictrace (const char *annex
,
1632 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1633 ULONGEST offset
, LONGEST len
)
1637 if (writebuf
!= NULL
)
1640 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1643 if (traceframe_read_sdata (current_traceframe
, offset
,
1644 readbuf
, len
, &nbytes
))
1649 /* Helper for handle_qxfer_threads_proper.
1650 Emit the XML to describe the thread of INF. */
1653 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1655 ptid_t ptid
= ptid_of (thread
);
1657 int core
= target_core_of_thread (ptid
);
1659 const char *name
= target_thread_name (ptid
);
1662 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1664 write_ptid (ptid_s
, ptid
);
1666 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1670 sprintf (core_s
, "%d", core
);
1671 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1675 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1679 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1680 bin2hex (handle
, handle_s
, handle_len
);
1681 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1684 buffer_xml_printf (buffer
, "/>\n");
1687 /* Helper for handle_qxfer_threads. */
1690 handle_qxfer_threads_proper (struct buffer
*buffer
)
1692 buffer_grow_str (buffer
, "<threads>\n");
1694 for_each_thread ([&] (thread_info
*thread
)
1696 handle_qxfer_threads_worker (thread
, buffer
);
1699 buffer_grow_str0 (buffer
, "</threads>\n");
1702 /* Handle qXfer:threads:read. */
1705 handle_qxfer_threads (const char *annex
,
1706 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1707 ULONGEST offset
, LONGEST len
)
1709 static char *result
= 0;
1710 static unsigned int result_length
= 0;
1712 if (writebuf
!= NULL
)
1715 if (annex
[0] != '\0')
1720 struct buffer buffer
;
1721 /* When asked for data at offset 0, generate everything and store into
1722 'result'. Successive reads will be served off 'result'. */
1726 buffer_init (&buffer
);
1728 handle_qxfer_threads_proper (&buffer
);
1730 result
= buffer_finish (&buffer
);
1731 result_length
= strlen (result
);
1732 buffer_free (&buffer
);
1735 if (offset
>= result_length
)
1737 /* We're out of data. */
1744 if (len
> result_length
- offset
)
1745 len
= result_length
- offset
;
1747 memcpy (readbuf
, result
+ offset
, len
);
1752 /* Handle qXfer:traceframe-info:read. */
1755 handle_qxfer_traceframe_info (const char *annex
,
1756 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1757 ULONGEST offset
, LONGEST len
)
1759 static char *result
= 0;
1760 static unsigned int result_length
= 0;
1762 if (writebuf
!= NULL
)
1765 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1770 struct buffer buffer
;
1772 /* When asked for data at offset 0, generate everything and
1773 store into 'result'. Successive reads will be served off
1777 buffer_init (&buffer
);
1779 traceframe_read_info (current_traceframe
, &buffer
);
1781 result
= buffer_finish (&buffer
);
1782 result_length
= strlen (result
);
1783 buffer_free (&buffer
);
1786 if (offset
>= result_length
)
1788 /* We're out of data. */
1795 if (len
> result_length
- offset
)
1796 len
= result_length
- offset
;
1798 memcpy (readbuf
, result
+ offset
, len
);
1802 /* Handle qXfer:fdpic:read. */
1805 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1806 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1808 if (the_target
->read_loadmap
== NULL
)
1811 if (current_thread
== NULL
)
1814 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1817 /* Handle qXfer:btrace:read. */
1820 handle_qxfer_btrace (const char *annex
,
1821 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1822 ULONGEST offset
, LONGEST len
)
1824 static struct buffer cache
;
1825 struct thread_info
*thread
;
1826 enum btrace_read_type type
;
1829 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1832 if (ptid_equal (general_thread
, null_ptid
)
1833 || ptid_equal (general_thread
, minus_one_ptid
))
1835 strcpy (own_buf
, "E.Must select a single thread.");
1839 thread
= find_thread_ptid (general_thread
);
1842 strcpy (own_buf
, "E.No such thread.");
1846 if (thread
->btrace
== NULL
)
1848 strcpy (own_buf
, "E.Btrace not enabled.");
1852 if (strcmp (annex
, "all") == 0)
1853 type
= BTRACE_READ_ALL
;
1854 else if (strcmp (annex
, "new") == 0)
1855 type
= BTRACE_READ_NEW
;
1856 else if (strcmp (annex
, "delta") == 0)
1857 type
= BTRACE_READ_DELTA
;
1860 strcpy (own_buf
, "E.Bad annex.");
1866 buffer_free (&cache
);
1868 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1871 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1875 else if (offset
> cache
.used_size
)
1877 buffer_free (&cache
);
1881 if (len
> cache
.used_size
- offset
)
1882 len
= cache
.used_size
- offset
;
1884 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1889 /* Handle qXfer:btrace-conf:read. */
1892 handle_qxfer_btrace_conf (const char *annex
,
1893 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1894 ULONGEST offset
, LONGEST len
)
1896 static struct buffer cache
;
1897 struct thread_info
*thread
;
1900 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1903 if (annex
[0] != '\0')
1906 if (ptid_equal (general_thread
, null_ptid
)
1907 || ptid_equal (general_thread
, minus_one_ptid
))
1909 strcpy (own_buf
, "E.Must select a single thread.");
1913 thread
= find_thread_ptid (general_thread
);
1916 strcpy (own_buf
, "E.No such thread.");
1920 if (thread
->btrace
== NULL
)
1922 strcpy (own_buf
, "E.Btrace not enabled.");
1928 buffer_free (&cache
);
1930 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1933 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1937 else if (offset
> cache
.used_size
)
1939 buffer_free (&cache
);
1943 if (len
> cache
.used_size
- offset
)
1944 len
= cache
.used_size
- offset
;
1946 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1951 static const struct qxfer qxfer_packets
[] =
1953 { "auxv", handle_qxfer_auxv
},
1954 { "btrace", handle_qxfer_btrace
},
1955 { "btrace-conf", handle_qxfer_btrace_conf
},
1956 { "exec-file", handle_qxfer_exec_file
},
1957 { "fdpic", handle_qxfer_fdpic
},
1958 { "features", handle_qxfer_features
},
1959 { "libraries", handle_qxfer_libraries
},
1960 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1961 { "osdata", handle_qxfer_osdata
},
1962 { "siginfo", handle_qxfer_siginfo
},
1963 { "spu", handle_qxfer_spu
},
1964 { "statictrace", handle_qxfer_statictrace
},
1965 { "threads", handle_qxfer_threads
},
1966 { "traceframe-info", handle_qxfer_traceframe_info
},
1970 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1978 if (!startswith (own_buf
, "qXfer:"))
1981 /* Grab the object, r/w and annex. */
1982 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1984 write_enn (own_buf
);
1989 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1992 const struct qxfer
*q
= &qxfer_packets
[i
];
1994 if (strcmp (object
, q
->object
) == 0)
1996 if (strcmp (rw
, "read") == 0)
1998 unsigned char *data
;
2003 /* Grab the offset and length. */
2004 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2006 write_enn (own_buf
);
2010 /* Read one extra byte, as an indicator of whether there is
2012 if (len
> PBUFSIZ
- 2)
2014 data
= (unsigned char *) malloc (len
+ 1);
2017 write_enn (own_buf
);
2020 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2028 /* Preserve error message. */
2031 write_enn (own_buf
);
2033 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2035 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2040 else if (strcmp (rw
, "write") == 0)
2045 unsigned char *data
;
2047 strcpy (own_buf
, "E00");
2048 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2051 write_enn (own_buf
);
2054 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2055 &ofs
, &len
, data
) < 0)
2058 write_enn (own_buf
);
2062 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2070 /* Preserve error message. */
2073 write_enn (own_buf
);
2075 sprintf (own_buf
, "%x", n
);
2088 /* Compute 32 bit CRC from inferior memory.
2090 On success, return 32 bit CRC.
2091 On failure, return (unsigned long long) -1. */
2093 static unsigned long long
2094 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2098 unsigned char byte
= 0;
2100 /* Return failure if memory read fails. */
2101 if (read_inferior_memory (base
, &byte
, 1) != 0)
2102 return (unsigned long long) -1;
2104 crc
= xcrc32 (&byte
, 1, crc
);
2107 return (unsigned long long) crc
;
2110 /* Add supported btrace packets to BUF. */
2113 supported_btrace_packets (char *buf
)
2115 int btrace_supported
= 0;
2117 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2119 strcat (buf
, ";Qbtrace:bts+");
2120 strcat (buf
, ";Qbtrace-conf:bts:size+");
2122 btrace_supported
= 1;
2125 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2127 strcat (buf
, ";Qbtrace:pt+");
2128 strcat (buf
, ";Qbtrace-conf:pt:size+");
2130 btrace_supported
= 1;
2133 if (!btrace_supported
)
2136 strcat (buf
, ";Qbtrace:off+");
2137 strcat (buf
, ";qXfer:btrace:read+");
2138 strcat (buf
, ";qXfer:btrace-conf:read+");
2141 /* Handle all of the extended 'q' packets. */
2144 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2146 static std::list
<thread_info
*>::const_iterator thread_iter
;
2148 /* Reply the current thread id. */
2149 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2152 require_running_or_return (own_buf
);
2154 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2155 ptid
= general_thread
;
2158 thread_iter
= all_threads
.begin ();
2159 ptid
= (*thread_iter
)->id
;
2162 sprintf (own_buf
, "QC");
2164 write_ptid (own_buf
, ptid
);
2168 if (strcmp ("qSymbol::", own_buf
) == 0)
2170 struct thread_info
*save_thread
= current_thread
;
2172 /* For qSymbol, GDB only changes the current thread if the
2173 previous current thread was of a different process. So if
2174 the previous thread is gone, we need to pick another one of
2175 the same process. This can happen e.g., if we followed an
2176 exec in a non-leader thread. */
2177 if (current_thread
== NULL
)
2180 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2182 /* Just in case, if we didn't find a thread, then bail out
2183 instead of crashing. */
2184 if (current_thread
== NULL
)
2186 write_enn (own_buf
);
2187 current_thread
= save_thread
;
2192 /* GDB is suggesting new symbols have been loaded. This may
2193 mean a new shared library has been detected as loaded, so
2194 take the opportunity to check if breakpoints we think are
2195 inserted, still are. Note that it isn't guaranteed that
2196 we'll see this when a shared library is loaded, and nor will
2197 we see this for unloads (although breakpoints in unloaded
2198 libraries shouldn't trigger), as GDB may not find symbols for
2199 the library at all. We also re-validate breakpoints when we
2200 see a second GDB breakpoint for the same address, and or when
2201 we access breakpoint shadows. */
2202 validate_breakpoints ();
2204 if (target_supports_tracepoints ())
2205 tracepoint_look_up_symbols ();
2207 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2208 (*the_target
->look_up_symbols
) ();
2210 current_thread
= save_thread
;
2212 strcpy (own_buf
, "OK");
2216 if (!disable_packet_qfThreadInfo
)
2218 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2220 require_running_or_return (own_buf
);
2221 thread_iter
= all_threads
.begin ();
2224 ptid_t ptid
= (*thread_iter
)->id
;
2225 write_ptid (own_buf
, ptid
);
2230 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2232 require_running_or_return (own_buf
);
2233 if (thread_iter
!= all_threads
.end ())
2236 ptid_t ptid
= (*thread_iter
)->id
;
2237 write_ptid (own_buf
, ptid
);
2243 sprintf (own_buf
, "l");
2249 if (the_target
->read_offsets
!= NULL
2250 && strcmp ("qOffsets", own_buf
) == 0)
2252 CORE_ADDR text
, data
;
2254 require_running_or_return (own_buf
);
2255 if (the_target
->read_offsets (&text
, &data
))
2256 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2257 (long)text
, (long)data
, (long)data
);
2259 write_enn (own_buf
);
2264 /* Protocol features query. */
2265 if (startswith (own_buf
, "qSupported")
2266 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2268 char *p
= &own_buf
[10];
2269 int gdb_supports_qRelocInsn
= 0;
2271 /* Process each feature being provided by GDB. The first
2272 feature will follow a ':', and latter features will follow
2276 char **qsupported
= NULL
;
2281 /* Two passes, to avoid nested strtok calls in
2282 target_process_qsupported. */
2283 for (p
= strtok (p
+ 1, ";");
2285 p
= strtok (NULL
, ";"))
2288 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2289 qsupported
[count
- 1] = xstrdup (p
);
2292 for (i
= 0; i
< count
; i
++)
2295 if (strcmp (p
, "multiprocess+") == 0)
2297 /* GDB supports and wants multi-process support if
2299 if (target_supports_multi_process ())
2302 else if (strcmp (p
, "qRelocInsn+") == 0)
2304 /* GDB supports relocate instruction requests. */
2305 gdb_supports_qRelocInsn
= 1;
2307 else if (strcmp (p
, "swbreak+") == 0)
2309 /* GDB wants us to report whether a trap is caused
2310 by a software breakpoint and for us to handle PC
2311 adjustment if necessary on this target. */
2312 if (target_supports_stopped_by_sw_breakpoint ())
2313 swbreak_feature
= 1;
2315 else if (strcmp (p
, "hwbreak+") == 0)
2317 /* GDB wants us to report whether a trap is caused
2318 by a hardware breakpoint. */
2319 if (target_supports_stopped_by_hw_breakpoint ())
2320 hwbreak_feature
= 1;
2322 else if (strcmp (p
, "fork-events+") == 0)
2324 /* GDB supports and wants fork events if possible. */
2325 if (target_supports_fork_events ())
2326 report_fork_events
= 1;
2328 else if (strcmp (p
, "vfork-events+") == 0)
2330 /* GDB supports and wants vfork events if possible. */
2331 if (target_supports_vfork_events ())
2332 report_vfork_events
= 1;
2334 else if (strcmp (p
, "exec-events+") == 0)
2336 /* GDB supports and wants exec events if possible. */
2337 if (target_supports_exec_events ())
2338 report_exec_events
= 1;
2340 else if (strcmp (p
, "vContSupported+") == 0)
2341 vCont_supported
= 1;
2342 else if (strcmp (p
, "QThreadEvents+") == 0)
2344 else if (strcmp (p
, "no-resumed+") == 0)
2346 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2348 report_no_resumed
= 1;
2352 /* Move the unknown features all together. */
2353 qsupported
[i
] = NULL
;
2354 qsupported
[unknown
] = p
;
2359 /* Give the target backend a chance to process the unknown
2361 target_process_qsupported (qsupported
, unknown
);
2363 for (i
= 0; i
< count
; i
++)
2364 free (qsupported
[i
]);
2369 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2370 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2371 "QEnvironmentReset+;QEnvironmentUnset+;"
2375 if (target_supports_catch_syscall ())
2376 strcat (own_buf
, ";QCatchSyscalls+");
2378 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2379 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2380 ";augmented-libraries-svr4-read+");
2383 /* We do not have any hook to indicate whether the non-SVR4 target
2384 backend supports qXfer:libraries:read, so always report it. */
2385 strcat (own_buf
, ";qXfer:libraries:read+");
2388 if (the_target
->read_auxv
!= NULL
)
2389 strcat (own_buf
, ";qXfer:auxv:read+");
2391 if (the_target
->qxfer_spu
!= NULL
)
2392 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2394 if (the_target
->qxfer_siginfo
!= NULL
)
2395 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2397 if (the_target
->read_loadmap
!= NULL
)
2398 strcat (own_buf
, ";qXfer:fdpic:read+");
2400 /* We always report qXfer:features:read, as targets may
2401 install XML files on a subsequent call to arch_setup.
2402 If we reported to GDB on startup that we don't support
2403 qXfer:feature:read at all, we will never be re-queried. */
2404 strcat (own_buf
, ";qXfer:features:read+");
2406 if (transport_is_reliable
)
2407 strcat (own_buf
, ";QStartNoAckMode+");
2409 if (the_target
->qxfer_osdata
!= NULL
)
2410 strcat (own_buf
, ";qXfer:osdata:read+");
2412 if (target_supports_multi_process ())
2413 strcat (own_buf
, ";multiprocess+");
2415 if (target_supports_fork_events ())
2416 strcat (own_buf
, ";fork-events+");
2418 if (target_supports_vfork_events ())
2419 strcat (own_buf
, ";vfork-events+");
2421 if (target_supports_exec_events ())
2422 strcat (own_buf
, ";exec-events+");
2424 if (target_supports_non_stop ())
2425 strcat (own_buf
, ";QNonStop+");
2427 if (target_supports_disable_randomization ())
2428 strcat (own_buf
, ";QDisableRandomization+");
2430 strcat (own_buf
, ";qXfer:threads:read+");
2432 if (target_supports_tracepoints ())
2434 strcat (own_buf
, ";ConditionalTracepoints+");
2435 strcat (own_buf
, ";TraceStateVariables+");
2436 strcat (own_buf
, ";TracepointSource+");
2437 strcat (own_buf
, ";DisconnectedTracing+");
2438 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2439 strcat (own_buf
, ";FastTracepoints+");
2440 strcat (own_buf
, ";StaticTracepoints+");
2441 strcat (own_buf
, ";InstallInTrace+");
2442 strcat (own_buf
, ";qXfer:statictrace:read+");
2443 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2444 strcat (own_buf
, ";EnableDisableTracepoints+");
2445 strcat (own_buf
, ";QTBuffer:size+");
2446 strcat (own_buf
, ";tracenz+");
2449 if (target_supports_hardware_single_step ()
2450 || target_supports_software_single_step () )
2452 strcat (own_buf
, ";ConditionalBreakpoints+");
2454 strcat (own_buf
, ";BreakpointCommands+");
2456 if (target_supports_agent ())
2457 strcat (own_buf
, ";QAgent+");
2459 supported_btrace_packets (own_buf
);
2461 if (target_supports_stopped_by_sw_breakpoint ())
2462 strcat (own_buf
, ";swbreak+");
2464 if (target_supports_stopped_by_hw_breakpoint ())
2465 strcat (own_buf
, ";hwbreak+");
2467 if (the_target
->pid_to_exec_file
!= NULL
)
2468 strcat (own_buf
, ";qXfer:exec-file:read+");
2470 strcat (own_buf
, ";vContSupported+");
2472 strcat (own_buf
, ";QThreadEvents+");
2474 strcat (own_buf
, ";no-resumed+");
2476 /* Reinitialize components as needed for the new connection. */
2477 hostio_handle_new_gdb_connection ();
2478 target_handle_new_gdb_connection ();
2483 /* Thread-local storage support. */
2484 if (the_target
->get_tls_address
!= NULL
2485 && startswith (own_buf
, "qGetTLSAddr:"))
2487 char *p
= own_buf
+ 12;
2488 CORE_ADDR parts
[2], address
= 0;
2490 ptid_t ptid
= null_ptid
;
2492 require_running_or_return (own_buf
);
2494 for (i
= 0; i
< 3; i
++)
2502 p2
= strchr (p
, ',');
2515 ptid
= read_ptid (p
, NULL
);
2517 decode_address (&parts
[i
- 1], p
, len
);
2521 if (p
!= NULL
|| i
< 3)
2525 struct thread_info
*thread
= find_thread_ptid (ptid
);
2530 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2536 strcpy (own_buf
, paddress(address
));
2541 write_enn (own_buf
);
2545 /* Otherwise, pretend we do not understand this packet. */
2548 /* Windows OS Thread Information Block address support. */
2549 if (the_target
->get_tib_address
!= NULL
2550 && startswith (own_buf
, "qGetTIBAddr:"))
2555 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2557 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2560 strcpy (own_buf
, paddress(tlb
));
2565 write_enn (own_buf
);
2571 /* Handle "monitor" commands. */
2572 if (startswith (own_buf
, "qRcmd,"))
2574 char *mon
= (char *) malloc (PBUFSIZ
);
2575 int len
= strlen (own_buf
+ 6);
2579 write_enn (own_buf
);
2584 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2586 write_enn (own_buf
);
2590 mon
[len
/ 2] = '\0';
2594 if (the_target
->handle_monitor_command
== NULL
2595 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2596 /* Default processing. */
2597 handle_monitor_command (mon
, own_buf
);
2603 if (startswith (own_buf
, "qSearch:memory:"))
2605 require_running_or_return (own_buf
);
2606 handle_search_memory (own_buf
, packet_len
);
2610 if (strcmp (own_buf
, "qAttached") == 0
2611 || startswith (own_buf
, "qAttached:"))
2613 struct process_info
*process
;
2615 if (own_buf
[sizeof ("qAttached") - 1])
2617 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2618 process
= find_process_pid (pid
);
2622 require_running_or_return (own_buf
);
2623 process
= current_process ();
2626 if (process
== NULL
)
2628 write_enn (own_buf
);
2632 strcpy (own_buf
, process
->attached
? "1" : "0");
2636 if (startswith (own_buf
, "qCRC:"))
2638 /* CRC check (compare-section). */
2642 unsigned long long crc
;
2644 require_running_or_return (own_buf
);
2645 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2646 if (*comma
++ != ',')
2648 write_enn (own_buf
);
2651 len
= strtoul (comma
, NULL
, 16);
2652 crc
= crc32 (base
, len
, 0xffffffff);
2653 /* Check for memory failure. */
2654 if (crc
== (unsigned long long) -1)
2656 write_enn (own_buf
);
2659 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2663 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2666 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2669 /* Otherwise we didn't know what packet it was. Say we didn't
2674 static void gdb_wants_all_threads_stopped (void);
2675 static void resume (struct thread_resume
*actions
, size_t n
);
2677 /* The callback that is passed to visit_actioned_threads. */
2678 typedef int (visit_actioned_threads_callback_ftype
)
2679 (const struct thread_resume
*, struct thread_info
*);
2681 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2682 true if CALLBACK returns true. Returns false if no matching thread
2683 is found or CALLBACK results false.
2684 Note: This function is itself a callback for find_thread. */
2687 visit_actioned_threads (thread_info
*thread
,
2688 const struct thread_resume
*actions
,
2690 visit_actioned_threads_callback_ftype
*callback
)
2692 for (size_t i
= 0; i
< num_actions
; i
++)
2694 const struct thread_resume
*action
= &actions
[i
];
2696 if (ptid_equal (action
->thread
, minus_one_ptid
)
2697 || ptid_equal (action
->thread
, thread
->id
)
2698 || ((ptid_get_pid (action
->thread
)
2699 == thread
->id
.pid ())
2700 && ptid_get_lwp (action
->thread
) == -1))
2702 if ((*callback
) (action
, thread
))
2710 /* Callback for visit_actioned_threads. If the thread has a pending
2711 status to report, report it now. */
2714 handle_pending_status (const struct thread_resume
*resumption
,
2715 struct thread_info
*thread
)
2717 if (thread
->status_pending_p
)
2719 thread
->status_pending_p
= 0;
2721 last_status
= thread
->last_status
;
2722 last_ptid
= thread
->id
;
2723 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2729 /* Parse vCont packets. */
2731 handle_v_cont (char *own_buf
)
2735 struct thread_resume
*resume_info
;
2736 struct thread_resume default_action
{ null_ptid
};
2738 /* Count the number of semicolons in the packet. There should be one
2739 for every action. */
2745 p
= strchr (p
, ';');
2748 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2749 if (resume_info
== NULL
)
2757 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2759 if (p
[0] == 's' || p
[0] == 'S')
2760 resume_info
[i
].kind
= resume_step
;
2761 else if (p
[0] == 'r')
2762 resume_info
[i
].kind
= resume_step
;
2763 else if (p
[0] == 'c' || p
[0] == 'C')
2764 resume_info
[i
].kind
= resume_continue
;
2765 else if (p
[0] == 't')
2766 resume_info
[i
].kind
= resume_stop
;
2770 if (p
[0] == 'S' || p
[0] == 'C')
2773 int sig
= strtol (p
+ 1, &q
, 16);
2778 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2780 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2782 else if (p
[0] == 'r')
2786 p
= unpack_varlen_hex (p
+ 1, &addr
);
2787 resume_info
[i
].step_range_start
= addr
;
2792 p
= unpack_varlen_hex (p
+ 1, &addr
);
2793 resume_info
[i
].step_range_end
= addr
;
2802 resume_info
[i
].thread
= minus_one_ptid
;
2803 default_action
= resume_info
[i
];
2805 /* Note: we don't increment i here, we'll overwrite this entry
2806 the next time through. */
2808 else if (p
[0] == ':')
2811 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2816 if (p
[0] != ';' && p
[0] != 0)
2819 resume_info
[i
].thread
= ptid
;
2826 resume_info
[i
] = default_action
;
2828 resume (resume_info
, n
);
2833 write_enn (own_buf
);
2838 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2841 resume (struct thread_resume
*actions
, size_t num_actions
)
2845 /* Check if among the threads that GDB wants actioned, there's
2846 one with a pending status to report. If so, skip actually
2847 resuming/stopping and report the pending event
2850 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2852 return visit_actioned_threads (thread
, actions
, num_actions
,
2853 handle_pending_status
);
2856 if (thread_with_status
!= NULL
)
2862 (*the_target
->resume
) (actions
, num_actions
);
2868 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2870 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2871 && !report_no_resumed
)
2873 /* The client does not support this stop reply. At least
2875 sprintf (own_buf
, "E.No unwaited-for children left.");
2876 disable_async_io ();
2880 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2881 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2882 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2883 current_thread
->last_status
= last_status
;
2885 /* From the client's perspective, all-stop mode always stops all
2886 threads implicitly (and the target backend has already done
2887 so by now). Tag all threads as "want-stopped", so we don't
2888 resume them implicitly without the client telling us to. */
2889 gdb_wants_all_threads_stopped ();
2890 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2891 disable_async_io ();
2893 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2894 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2895 target_mourn_inferior (last_ptid
);
2899 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2901 handle_v_attach (char *own_buf
)
2905 pid
= strtol (own_buf
+ 8, NULL
, 16);
2906 if (pid
!= 0 && attach_inferior (pid
) == 0)
2908 /* Don't report shared library events after attaching, even if
2909 some libraries are preloaded. GDB will always poll the
2910 library list. Avoids the "stopped by shared library event"
2911 notice on the GDB side. */
2916 /* In non-stop, we don't send a resume reply. Stop events
2917 will follow up using the normal notification
2922 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2928 write_enn (own_buf
);
2933 /* Run a new program. Return 1 if successful, 0 if failure. */
2935 handle_v_run (char *own_buf
)
2938 std::vector
<char *> new_argv
;
2939 char *new_program_name
= NULL
;
2943 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2949 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2951 next_p
= strchr (p
, ';');
2953 next_p
= p
+ strlen (p
);
2955 if (i
== 0 && p
== next_p
)
2957 /* No program specified. */
2958 new_program_name
= NULL
;
2960 else if (p
== next_p
)
2962 /* Empty argument. */
2963 new_argv
.push_back (xstrdup ("''"));
2967 size_t len
= (next_p
- p
) / 2;
2968 /* ARG is the unquoted argument received via the RSP. */
2969 char *arg
= (char *) xmalloc (len
+ 1);
2970 /* FULL_ARGS will contain the quoted version of ARG. */
2971 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2972 /* These are pointers used to navigate the strings above. */
2973 char *tmp_arg
= arg
;
2974 char *tmp_full_arg
= full_arg
;
2977 hex2bin (p
, (gdb_byte
*) arg
, len
);
2980 while (*tmp_arg
!= '\0')
2986 *tmp_full_arg
= '\'';
2992 /* Quote single quote. */
2993 *tmp_full_arg
= '\\';
3001 *tmp_full_arg
= *tmp_arg
;
3007 *tmp_full_arg
++ = '\'';
3009 /* Finish FULL_ARG and push it into the vector containing
3011 *tmp_full_arg
= '\0';
3013 new_program_name
= full_arg
;
3015 new_argv
.push_back (full_arg
);
3021 new_argv
.push_back (NULL
);
3023 if (new_program_name
== NULL
)
3025 /* GDB didn't specify a program to run. Use the program from the
3026 last run with the new argument list. */
3027 if (program_name
== NULL
)
3029 write_enn (own_buf
);
3030 free_vector_argv (new_argv
);
3036 xfree (program_name
);
3037 program_name
= new_program_name
;
3040 /* Free the old argv and install the new one. */
3041 free_vector_argv (program_args
);
3042 program_args
= new_argv
;
3044 create_inferior (program_name
, program_args
);
3046 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3048 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3050 /* In non-stop, sending a resume reply doesn't set the general
3051 thread, but GDB assumes a vRun sets it (this is so GDB can
3052 query which is the main thread of the new inferior. */
3054 general_thread
= last_ptid
;
3060 write_enn (own_buf
);
3065 /* Kill process. Return 1 if successful, 0 if failure. */
3067 handle_v_kill (char *own_buf
)
3070 char *p
= &own_buf
[6];
3072 pid
= strtol (p
, NULL
, 16);
3075 if (pid
!= 0 && kill_inferior (pid
) == 0)
3077 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3078 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3079 last_ptid
= pid_to_ptid (pid
);
3080 discard_queued_stop_replies (last_ptid
);
3086 write_enn (own_buf
);
3091 /* Handle all of the extended 'v' packets. */
3093 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3095 if (!disable_packet_vCont
)
3097 if (strcmp (own_buf
, "vCtrlC") == 0)
3099 (*the_target
->request_interrupt
) ();
3104 if (startswith (own_buf
, "vCont;"))
3106 handle_v_cont (own_buf
);
3110 if (startswith (own_buf
, "vCont?"))
3112 strcpy (own_buf
, "vCont;c;C;t");
3114 if (target_supports_hardware_single_step ()
3115 || target_supports_software_single_step ()
3116 || !vCont_supported
)
3118 /* If target supports single step either by hardware or by
3119 software, add actions s and S to the list of supported
3120 actions. On the other hand, if GDB doesn't request the
3121 supported vCont actions in qSupported packet, add s and
3122 S to the list too. */
3123 own_buf
= own_buf
+ strlen (own_buf
);
3124 strcpy (own_buf
, ";s;S");
3127 if (target_supports_range_stepping ())
3129 own_buf
= own_buf
+ strlen (own_buf
);
3130 strcpy (own_buf
, ";r");
3136 if (startswith (own_buf
, "vFile:")
3137 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3140 if (startswith (own_buf
, "vAttach;"))
3142 if ((!extended_protocol
|| !multi_process
) && target_running ())
3144 fprintf (stderr
, "Already debugging a process\n");
3145 write_enn (own_buf
);
3148 handle_v_attach (own_buf
);
3152 if (startswith (own_buf
, "vRun;"))
3154 if ((!extended_protocol
|| !multi_process
) && target_running ())
3156 fprintf (stderr
, "Already debugging a process\n");
3157 write_enn (own_buf
);
3160 handle_v_run (own_buf
);
3164 if (startswith (own_buf
, "vKill;"))
3166 if (!target_running ())
3168 fprintf (stderr
, "No process to kill\n");
3169 write_enn (own_buf
);
3172 handle_v_kill (own_buf
);
3176 if (handle_notif_ack (own_buf
, packet_len
))
3179 /* Otherwise we didn't know what packet it was. Say we didn't
3185 /* Resume thread and wait for another event. In non-stop mode,
3186 don't really wait here, but return immediatelly to the event
3189 myresume (char *own_buf
, int step
, int sig
)
3191 struct thread_resume resume_info
[2];
3193 int valid_cont_thread
;
3195 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3196 && !ptid_equal (cont_thread
, minus_one_ptid
));
3198 if (step
|| sig
|| valid_cont_thread
)
3200 resume_info
[0].thread
= current_ptid
;
3202 resume_info
[0].kind
= resume_step
;
3204 resume_info
[0].kind
= resume_continue
;
3205 resume_info
[0].sig
= sig
;
3209 if (!valid_cont_thread
)
3211 resume_info
[n
].thread
= minus_one_ptid
;
3212 resume_info
[n
].kind
= resume_continue
;
3213 resume_info
[n
].sig
= 0;
3217 resume (resume_info
, n
);
3220 /* Callback for for_each_thread. Make a new stop reply for each
3224 queue_stop_reply_callback (thread_info
*thread
)
3226 /* For now, assume targets that don't have this callback also don't
3227 manage the thread's last_status field. */
3228 if (the_target
->thread_stopped
== NULL
)
3230 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3232 new_notif
->ptid
= thread
->id
;
3233 new_notif
->status
= thread
->last_status
;
3234 /* Pass the last stop reply back to GDB, but don't notify
3236 notif_event_enque (¬if_stop
,
3237 (struct notif_event
*) new_notif
);
3241 if (thread_stopped (thread
))
3245 std::string status_string
3246 = target_waitstatus_to_string (&thread
->last_status
);
3248 debug_printf ("Reporting thread %s as already stopped with %s\n",
3249 target_pid_to_str (thread
->id
),
3250 status_string
.c_str ());
3253 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3255 /* Pass the last stop reply back to GDB, but don't notify
3257 queue_stop_reply (thread
->id
, &thread
->last_status
);
3262 /* Set this inferior threads's state as "want-stopped". We won't
3263 resume this thread until the client gives us another action for
3267 gdb_wants_thread_stopped (thread_info
*thread
)
3269 thread
->last_resume_kind
= resume_stop
;
3271 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3273 /* Most threads are stopped implicitly (all-stop); tag that with
3275 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3276 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3280 /* Set all threads' states as "want-stopped". */
3283 gdb_wants_all_threads_stopped (void)
3285 for_each_thread (gdb_wants_thread_stopped
);
3288 /* Callback for for_each_thread. If the thread is stopped with an
3289 interesting event, mark it as having a pending event. */
3292 set_pending_status_callback (thread_info
*thread
)
3294 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3295 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3296 /* A breakpoint, watchpoint or finished step from a previous
3297 GDB run isn't considered interesting for a new GDB run.
3298 If we left those pending, the new GDB could consider them
3299 random SIGTRAPs. This leaves out real async traps. We'd
3300 have to peek into the (target-specific) siginfo to
3301 distinguish those. */
3302 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3303 thread
->status_pending_p
= 1;
3306 /* Status handler for the '?' packet. */
3309 handle_status (char *own_buf
)
3311 /* GDB is connected, don't forward events to the target anymore. */
3312 for_each_process ([] (process_info
*process
) {
3313 process
->gdb_detached
= 0;
3316 /* In non-stop mode, we must send a stop reply for each stopped
3317 thread. In all-stop mode, just send one for the first stopped
3322 for_each_thread (queue_stop_reply_callback
);
3324 /* The first is sent immediatly. OK is sent if there is no
3325 stopped thread, which is the same handling of the vStopped
3326 packet (by design). */
3327 notif_write_event (¬if_stop
, own_buf
);
3331 thread_info
*thread
= NULL
;
3334 stabilize_threads ();
3335 gdb_wants_all_threads_stopped ();
3337 /* We can only report one status, but we might be coming out of
3338 non-stop -- if more than one thread is stopped with
3339 interesting events, leave events for the threads we're not
3340 reporting now pending. They'll be reported the next time the
3341 threads are resumed. Start by marking all interesting events
3343 for_each_thread (set_pending_status_callback
);
3345 /* Prefer the last thread that reported an event to GDB (even if
3346 that was a GDB_SIGNAL_TRAP). */
3347 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3348 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3349 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3350 thread
= find_thread_ptid (last_ptid
);
3352 /* If the last event thread is not found for some reason, look
3353 for some other thread that might have an event to report. */
3355 thread
= find_thread ([] (thread_info
*thread
)
3357 return thread
->status_pending_p
;
3360 /* If we're still out of luck, simply pick the first thread in
3363 thread
= get_first_thread ();
3367 struct thread_info
*tp
= (struct thread_info
*) thread
;
3369 /* We're reporting this event, so it's no longer
3371 tp
->status_pending_p
= 0;
3373 /* GDB assumes the current thread is the thread we're
3374 reporting the status for. */
3375 general_thread
= thread
->id
;
3376 set_desired_thread ();
3378 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3379 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3382 strcpy (own_buf
, "W00");
3387 gdbserver_version (void)
3389 printf ("GNU gdbserver %s%s\n"
3390 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3391 "gdbserver is free software, covered by the "
3392 "GNU General Public License.\n"
3393 "This gdbserver was configured as \"%s\"\n",
3394 PKGVERSION
, version
, host_name
);
3398 gdbserver_usage (FILE *stream
)
3400 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3401 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3402 "\tgdbserver [OPTIONS] --multi COMM\n"
3404 "COMM may either be a tty device (for serial debugging),\n"
3405 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3406 "stdin/stdout of gdbserver.\n"
3407 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3408 "PID is the process ID to attach to, when --attach is specified.\n"
3410 "Operating modes:\n"
3412 " --attach Attach to running process PID.\n"
3413 " --multi Start server without a specific program, and\n"
3414 " only quit when explicitly commanded.\n"
3415 " --once Exit after the first connection has closed.\n"
3416 " --help Print this message and then exit.\n"
3417 " --version Display version information and exit.\n"
3421 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3422 " --disable-randomization\n"
3423 " Run PROG with address space randomization disabled.\n"
3424 " --no-disable-randomization\n"
3425 " Don't disable address space randomization when\n"
3427 " --startup-with-shell\n"
3428 " Start PROG using a shell. I.e., execs a shell that\n"
3429 " then execs PROG. (default)\n"
3430 " --no-startup-with-shell\n"
3431 " Exec PROG directly instead of using a shell.\n"
3432 " Disables argument globbing and variable substitution\n"
3433 " on UNIX-like systems.\n"
3437 " --debug Enable general debugging output.\n"
3438 " --debug-format=opt1[,opt2,...]\n"
3439 " Specify extra content in debugging output.\n"
3444 " --remote-debug Enable remote protocol debugging output.\n"
3445 " --disable-packet=opt1[,opt2,...]\n"
3446 " Disable support for RSP packets or features.\n"
3448 " vCont, Tthread, qC, qfThreadInfo and \n"
3449 " threads (disable all threading packets).\n"
3451 "For more information, consult the GDB manual (available as on-line \n"
3452 "info or a printed manual).\n");
3453 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3454 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3458 gdbserver_show_disableable (FILE *stream
)
3460 fprintf (stream
, "Disableable packets:\n"
3461 " vCont \tAll vCont packets\n"
3462 " qC \tQuerying the current thread\n"
3463 " qfThreadInfo\tThread listing\n"
3464 " Tthread \tPassing the thread specifier in the "
3465 "T stop reply packet\n"
3466 " threads \tAll of the above\n");
3470 kill_inferior_callback (process_info
*process
)
3472 int pid
= process
->pid
;
3474 kill_inferior (pid
);
3475 discard_queued_stop_replies (pid_to_ptid (pid
));
3478 /* Call this when exiting gdbserver with possible inferiors that need
3479 to be killed or detached from. */
3482 detach_or_kill_for_exit (void)
3484 /* First print a list of the inferiors we will be killing/detaching.
3485 This is to assist the user, for example, in case the inferior unexpectedly
3486 dies after we exit: did we screw up or did the inferior exit on its own?
3487 Having this info will save some head-scratching. */
3489 if (have_started_inferiors_p ())
3491 fprintf (stderr
, "Killing process(es):");
3493 for_each_process ([] (process_info
*process
) {
3494 if (!process
->attached
)
3495 fprintf (stderr
, " %d", process
->pid
);
3498 fprintf (stderr
, "\n");
3500 if (have_attached_inferiors_p ())
3502 fprintf (stderr
, "Detaching process(es):");
3504 for_each_process ([] (process_info
*process
) {
3505 if (process
->attached
)
3506 fprintf (stderr
, " %d", process
->pid
);
3509 fprintf (stderr
, "\n");
3512 /* Now we can kill or detach the inferiors. */
3513 for_each_process ([] (process_info
*process
) {
3514 int pid
= process
->pid
;
3516 if (process
->attached
)
3517 detach_inferior (pid
);
3519 kill_inferior (pid
);
3521 discard_queued_stop_replies (pid_to_ptid (pid
));
3525 /* Value that will be passed to exit(3) when gdbserver exits. */
3526 static int exit_code
;
3528 /* Cleanup version of detach_or_kill_for_exit. */
3531 detach_or_kill_for_exit_cleanup (void *ignore
)
3536 detach_or_kill_for_exit ();
3539 CATCH (exception
, RETURN_MASK_ALL
)
3542 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3548 /* Main function. This is called by the real "main" function,
3549 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3551 static void ATTRIBUTE_NORETURN
3552 captured_main (int argc
, char *argv
[])
3557 const char *port
= NULL
;
3558 char **next_arg
= &argv
[1];
3559 volatile int multi_mode
= 0;
3560 volatile int attach
= 0;
3562 bool selftest
= false;
3563 const char *selftest_filter
= NULL
;
3565 while (*next_arg
!= NULL
&& **next_arg
== '-')
3567 if (strcmp (*next_arg
, "--version") == 0)
3569 gdbserver_version ();
3572 else if (strcmp (*next_arg
, "--help") == 0)
3574 gdbserver_usage (stdout
);
3577 else if (strcmp (*next_arg
, "--attach") == 0)
3579 else if (strcmp (*next_arg
, "--multi") == 0)
3581 else if (strcmp (*next_arg
, "--wrapper") == 0)
3588 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3590 wrapper_argv
+= *next_arg
;
3591 wrapper_argv
+= ' ';
3595 if (!wrapper_argv
.empty ())
3597 /* Erase the last whitespace. */
3598 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3601 if (next_arg
== tmp
|| *next_arg
== NULL
)
3603 gdbserver_usage (stderr
);
3607 /* Consume the "--". */
3610 else if (strcmp (*next_arg
, "--debug") == 0)
3612 else if (startswith (*next_arg
, "--debug-format="))
3615 = parse_debug_format_options ((*next_arg
)
3616 + sizeof ("--debug-format=") - 1, 0);
3618 if (error_msg
!= NULL
)
3620 fprintf (stderr
, "%s", error_msg
);
3624 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3626 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3628 gdbserver_show_disableable (stdout
);
3631 else if (startswith (*next_arg
, "--disable-packet="))
3633 char *packets
, *tok
;
3635 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3636 for (tok
= strtok (packets
, ",");
3638 tok
= strtok (NULL
, ","))
3640 if (strcmp ("vCont", tok
) == 0)
3641 disable_packet_vCont
= 1;
3642 else if (strcmp ("Tthread", tok
) == 0)
3643 disable_packet_Tthread
= 1;
3644 else if (strcmp ("qC", tok
) == 0)
3645 disable_packet_qC
= 1;
3646 else if (strcmp ("qfThreadInfo", tok
) == 0)
3647 disable_packet_qfThreadInfo
= 1;
3648 else if (strcmp ("threads", tok
) == 0)
3650 disable_packet_vCont
= 1;
3651 disable_packet_Tthread
= 1;
3652 disable_packet_qC
= 1;
3653 disable_packet_qfThreadInfo
= 1;
3657 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3659 gdbserver_show_disableable (stderr
);
3664 else if (strcmp (*next_arg
, "-") == 0)
3666 /* "-" specifies a stdio connection and is a form of port
3668 port
= STDIO_CONNECTION_NAME
;
3672 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3673 disable_randomization
= 1;
3674 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3675 disable_randomization
= 0;
3676 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3677 startup_with_shell
= true;
3678 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3679 startup_with_shell
= false;
3680 else if (strcmp (*next_arg
, "--once") == 0)
3682 else if (strcmp (*next_arg
, "--selftest") == 0)
3684 else if (startswith (*next_arg
, "--selftest="))
3687 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3691 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3704 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3707 gdbserver_usage (stderr
);
3711 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3712 opened by remote_prepare. */
3715 save_original_signals_state ();
3717 /* We need to know whether the remote connection is stdio before
3718 starting the inferior. Inferiors created in this scenario have
3719 stdin,stdout redirected. So do this here before we call
3722 remote_prepare (port
);
3727 /* --attach used to come after PORT, so allow it there for
3729 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3736 && (*next_arg
== NULL
3737 || (*next_arg
)[0] == '\0'
3738 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3740 || next_arg
[1] != NULL
))
3745 gdbserver_usage (stderr
);
3749 /* Gather information about the environment. */
3750 our_environ
= gdb_environ::from_host_environ ();
3752 initialize_async_io ();
3754 have_job_control ();
3755 initialize_event_loop ();
3756 if (target_supports_tracepoints ())
3757 initialize_tracepoint ();
3758 initialize_notif ();
3760 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3761 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3765 selftests::run_tests (selftest_filter
);
3766 throw_quit ("Quit");
3769 if (pid
== 0 && *next_arg
!= NULL
)
3773 n
= argc
- (next_arg
- argv
);
3774 program_name
= xstrdup (next_arg
[0]);
3775 for (i
= 1; i
< n
; i
++)
3776 program_args
.push_back (xstrdup (next_arg
[i
]));
3777 program_args
.push_back (NULL
);
3779 /* Wait till we are at first instruction in program. */
3780 create_inferior (program_name
, program_args
);
3782 /* We are now (hopefully) stopped at the first instruction of
3783 the target process. This assumes that the target process was
3784 successfully created. */
3788 if (attach_inferior (pid
) == -1)
3789 error ("Attaching not supported on this target");
3791 /* Otherwise succeeded. */
3795 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3796 last_status
.value
.integer
= 0;
3797 last_ptid
= minus_one_ptid
;
3799 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3801 /* Don't report shared library events on the initial connection,
3802 even if some libraries are preloaded. Avoids the "stopped by
3803 shared library event" notice on gdb side. */
3806 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3807 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3812 if (!was_running
&& !multi_mode
)
3813 error ("No program to debug");
3820 report_fork_events
= 0;
3821 report_vfork_events
= 0;
3822 report_exec_events
= 0;
3823 /* Be sure we're out of tfind mode. */
3824 current_traceframe
= -1;
3825 cont_thread
= null_ptid
;
3826 swbreak_feature
= 0;
3827 hwbreak_feature
= 0;
3828 vCont_supported
= 0;
3834 /* Wait for events. This will return when all event sources
3835 are removed from the event loop. */
3836 start_event_loop ();
3838 /* If an exit was requested (using the "monitor exit"
3839 command), terminate now. */
3841 throw_quit ("Quit");
3843 /* The only other way to get here is for getpkt to fail:
3845 - If --once was specified, we're done.
3847 - If not in extended-remote mode, and we're no longer
3848 debugging anything, simply exit: GDB has disconnected
3849 after processing the last process exit.
3851 - Otherwise, close the connection and reopen it at the
3853 if (run_once
|| (!extended_protocol
&& !target_running ()))
3854 throw_quit ("Quit");
3857 "Remote side has terminated connection. "
3858 "GDBserver will reopen the connection.\n");
3860 /* Get rid of any pending statuses. An eventual reconnection
3861 (by the same GDB instance or another) will refresh all its
3862 state from scratch. */
3863 discard_queued_stop_replies (minus_one_ptid
);
3864 for_each_thread ([] (thread_info
*thread
)
3866 thread
->status_pending_p
= 0;
3871 if (disconnected_tracing
)
3873 /* Try to enable non-stop/async mode, so we we can
3874 both wait for an async socket accept, and handle
3875 async target events simultaneously. There's also
3876 no point either in having the target always stop
3877 all threads, when we're going to pass signals
3878 down without informing GDB. */
3881 if (start_non_stop (1))
3884 /* Detaching implicitly resumes all threads;
3885 simply disconnecting does not. */
3891 "Disconnected tracing disabled; "
3892 "stopping trace run.\n");
3897 CATCH (exception
, RETURN_MASK_ERROR
)
3900 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3902 if (response_needed
)
3904 write_enn (own_buf
);
3909 throw_quit ("Quit");
3915 /* Main function. */
3918 main (int argc
, char *argv
[])
3923 captured_main (argc
, argv
);
3925 CATCH (exception
, RETURN_MASK_ALL
)
3927 if (exception
.reason
== RETURN_ERROR
)
3930 fprintf (stderr
, "%s\n", exception
.message
);
3931 fprintf (stderr
, "Exiting\n");
3939 gdb_assert_not_reached ("captured_main should never return");
3942 /* Process options coming from Z packets for a breakpoint. PACKET is
3943 the packet buffer. *PACKET is updated to point to the first char
3944 after the last processed option. */
3947 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3949 const char *dataptr
= *packet
;
3952 /* Check if data has the correct format. */
3953 if (*dataptr
!= ';')
3960 if (*dataptr
== ';')
3963 if (*dataptr
== 'X')
3965 /* Conditional expression. */
3967 debug_printf ("Found breakpoint condition.\n");
3968 if (!add_breakpoint_condition (bp
, &dataptr
))
3969 dataptr
= strchrnul (dataptr
, ';');
3971 else if (startswith (dataptr
, "cmds:"))
3973 dataptr
+= strlen ("cmds:");
3975 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3976 persist
= (*dataptr
== '1');
3978 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3979 dataptr
= strchrnul (dataptr
, ';');
3983 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3985 /* Skip tokens until we find one that we recognize. */
3986 dataptr
= strchrnul (dataptr
, ';');
3992 /* Event loop callback that handles a serial event. The first byte in
3993 the serial buffer gets us here. We expect characters to arrive at
3994 a brisk pace, so we read the rest of the packet with a blocking
3998 process_serial_event (void)
4006 int new_packet_len
= -1;
4008 disable_async_io ();
4010 response_needed
= 0;
4011 packet_len
= getpkt (own_buf
);
4012 if (packet_len
<= 0)
4015 /* Force an event loop break. */
4018 response_needed
= 1;
4020 char ch
= own_buf
[0];
4024 handle_query (own_buf
, packet_len
, &new_packet_len
);
4027 handle_general_set (own_buf
);
4030 handle_detach (own_buf
);
4033 extended_protocol
= 1;
4037 handle_status (own_buf
);
4040 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4042 require_running_or_break (own_buf
);
4044 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4046 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4047 thread_id
= null_ptid
;
4048 else if (thread_id
.is_pid ())
4050 /* The ptid represents a pid. */
4051 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4055 write_enn (own_buf
);
4059 thread_id
= thread
->id
;
4063 /* The ptid represents a lwp/tid. */
4064 if (find_thread_ptid (thread_id
) == NULL
)
4066 write_enn (own_buf
);
4071 if (own_buf
[1] == 'g')
4073 if (ptid_equal (thread_id
, null_ptid
))
4075 /* GDB is telling us to choose any thread. Check if
4076 the currently selected thread is still valid. If
4077 it is not, select the first available. */
4078 thread_info
*thread
= find_thread_ptid (general_thread
);
4080 thread
= get_first_thread ();
4081 thread_id
= thread
->id
;
4084 general_thread
= thread_id
;
4085 set_desired_thread ();
4086 gdb_assert (current_thread
!= NULL
);
4088 else if (own_buf
[1] == 'c')
4089 cont_thread
= thread_id
;
4095 /* Silently ignore it so that gdb can extend the protocol
4096 without compatibility headaches. */
4101 require_running_or_break (own_buf
);
4102 if (current_traceframe
>= 0)
4104 struct regcache
*regcache
4105 = new_register_cache (current_target_desc ());
4107 if (fetch_traceframe_registers (current_traceframe
,
4109 registers_to_string (regcache
, own_buf
);
4111 write_enn (own_buf
);
4112 free_register_cache (regcache
);
4116 struct regcache
*regcache
;
4118 if (!set_desired_thread ())
4119 write_enn (own_buf
);
4122 regcache
= get_thread_regcache (current_thread
, 1);
4123 registers_to_string (regcache
, own_buf
);
4128 require_running_or_break (own_buf
);
4129 if (current_traceframe
>= 0)
4130 write_enn (own_buf
);
4133 struct regcache
*regcache
;
4135 if (!set_desired_thread ())
4136 write_enn (own_buf
);
4139 regcache
= get_thread_regcache (current_thread
, 1);
4140 registers_from_string (regcache
, &own_buf
[1]);
4146 require_running_or_break (own_buf
);
4147 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4148 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4150 write_enn (own_buf
);
4152 bin2hex (mem_buf
, own_buf
, res
);
4155 require_running_or_break (own_buf
);
4156 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4157 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4160 write_enn (own_buf
);
4163 require_running_or_break (own_buf
);
4164 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4165 &mem_addr
, &len
, &mem_buf
) < 0
4166 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4167 write_enn (own_buf
);
4172 require_running_or_break (own_buf
);
4173 hex2bin (own_buf
+ 1, &sig
, 1);
4174 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4175 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4178 myresume (own_buf
, 0, signal
);
4181 require_running_or_break (own_buf
);
4182 hex2bin (own_buf
+ 1, &sig
, 1);
4183 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4184 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4187 myresume (own_buf
, 1, signal
);
4190 require_running_or_break (own_buf
);
4192 myresume (own_buf
, 0, signal
);
4195 require_running_or_break (own_buf
);
4197 myresume (own_buf
, 1, signal
);
4199 case 'Z': /* insert_ ... */
4201 case 'z': /* remove_ ... */
4206 char type
= own_buf
[1];
4208 const int insert
= ch
== 'Z';
4209 const char *p
= &own_buf
[3];
4211 p
= unpack_varlen_hex (p
, &addr
);
4212 kind
= strtol (p
+ 1, &dataptr
, 16);
4216 struct gdb_breakpoint
*bp
;
4218 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4223 /* GDB may have sent us a list of *point parameters to
4224 be evaluated on the target's side. Read such list
4225 here. If we already have a list of parameters, GDB
4226 is telling us to drop that list and use this one
4228 clear_breakpoint_conditions_and_commands (bp
);
4229 const char *options
= dataptr
;
4230 process_point_options (bp
, &options
);
4234 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4242 write_enn (own_buf
);
4246 response_needed
= 0;
4247 if (!target_running ())
4248 /* The packet we received doesn't make sense - but we can't
4249 reply to it, either. */
4252 fprintf (stderr
, "Killing all inferiors\n");
4254 for_each_process (kill_inferior_callback
);
4256 /* When using the extended protocol, we wait with no program
4257 running. The traditional protocol will exit instead. */
4258 if (extended_protocol
)
4260 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4261 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4269 require_running_or_break (own_buf
);
4271 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4272 if (find_thread_ptid (thread_id
) == NULL
)
4274 write_enn (own_buf
);
4278 if (mythread_alive (thread_id
))
4281 write_enn (own_buf
);
4285 response_needed
= 0;
4287 /* Restarting the inferior is only supported in the extended
4289 if (extended_protocol
)
4291 if (target_running ())
4292 for_each_process (kill_inferior_callback
);
4294 fprintf (stderr
, "GDBserver restarting\n");
4296 /* Wait till we are at 1st instruction in prog. */
4297 if (program_name
!= NULL
)
4299 create_inferior (program_name
, program_args
);
4301 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4303 /* Stopped at the first instruction of the target
4305 general_thread
= last_ptid
;
4309 /* Something went wrong. */
4310 general_thread
= null_ptid
;
4315 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4316 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4322 /* It is a request we don't understand. Respond with an
4323 empty packet so that gdb knows that we don't support this
4329 /* Extended (long) request. */
4330 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4334 /* It is a request we don't understand. Respond with an empty
4335 packet so that gdb knows that we don't support this
4341 if (new_packet_len
!= -1)
4342 putpkt_binary (own_buf
, new_packet_len
);
4346 response_needed
= 0;
4354 /* Event-loop callback for serial events. */
4357 handle_serial_event (int err
, gdb_client_data client_data
)
4360 debug_printf ("handling possible serial event\n");
4362 /* Really handle it. */
4363 if (process_serial_event () < 0)
4366 /* Be sure to not change the selected thread behind GDB's back.
4367 Important in the non-stop mode asynchronous protocol. */
4368 set_desired_thread ();
4373 /* Push a stop notification on the notification queue. */
4376 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4378 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4380 vstop_notif
->status
= *status
;
4381 vstop_notif
->ptid
= ptid
;
4382 /* Push Stop notification. */
4383 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4386 /* Event-loop callback for target events. */
4389 handle_target_event (int err
, gdb_client_data client_data
)
4392 debug_printf ("handling possible target event\n");
4394 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4397 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4399 if (gdb_connected () && report_no_resumed
)
4400 push_stop_notification (null_ptid
, &last_status
);
4402 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4404 int pid
= ptid_get_pid (last_ptid
);
4405 struct process_info
*process
= find_process_pid (pid
);
4406 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4408 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4409 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4411 mark_breakpoints_out (process
);
4412 target_mourn_inferior (last_ptid
);
4414 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4418 /* We're reporting this thread as stopped. Update its
4419 "want-stopped" state to what the client wants, until it
4420 gets a new resume action. */
4421 current_thread
->last_resume_kind
= resume_stop
;
4422 current_thread
->last_status
= last_status
;
4427 if (!target_running ())
4429 /* The last process exited. We're done. */
4433 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4434 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4435 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4439 /* A thread stopped with a signal, but gdb isn't
4440 connected to handle it. Pass it down to the
4441 inferior, as if it wasn't being traced. */
4442 enum gdb_signal signal
;
4445 debug_printf ("GDB not connected; forwarding event %d for"
4447 (int) last_status
.kind
,
4448 target_pid_to_str (last_ptid
));
4450 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4451 signal
= last_status
.value
.sig
;
4453 signal
= GDB_SIGNAL_0
;
4454 target_continue (last_ptid
, signal
);
4458 push_stop_notification (last_ptid
, &last_status
);
4461 /* Be sure to not change the selected thread behind GDB's back.
4462 Important in the non-stop mode asynchronous protocol. */
4463 set_desired_thread ();
4476 } // namespace selftests
4477 #endif /* GDB_SELF_TEST */