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
->entry
.id
,
391 ¤t_btrace_conf
);
392 if (thread
->btrace
== NULL
)
393 return "E.Could not enable btrace.";
398 /* Handle btrace enabling in Intel Processor Trace format. */
401 handle_btrace_enable_pt (struct thread_info
*thread
)
403 if (thread
->btrace
!= NULL
)
404 return "E.Btrace already enabled.";
406 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
407 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
408 ¤t_btrace_conf
);
409 if (thread
->btrace
== NULL
)
410 return "E.Could not enable btrace.";
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 return "E.Branch tracing not enabled.";
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 return "E.Could not disable branch tracing.";
427 thread
->btrace
= NULL
;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf
)
436 struct thread_info
*thread
;
440 if (!startswith (own_buf
, "Qbtrace:"))
443 op
= own_buf
+ strlen ("Qbtrace:");
445 if (ptid_equal (general_thread
, null_ptid
)
446 || ptid_equal (general_thread
, minus_one_ptid
))
448 strcpy (own_buf
, "E.Must select a single thread.");
452 thread
= find_thread_ptid (general_thread
);
455 strcpy (own_buf
, "E.No such thread.");
461 if (strcmp (op
, "bts") == 0)
462 err
= handle_btrace_enable_bts (thread
);
463 else if (strcmp (op
, "pt") == 0)
464 err
= handle_btrace_enable_pt (thread
);
465 else if (strcmp (op
, "off") == 0)
466 err
= handle_btrace_disable (thread
);
468 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
471 strcpy (own_buf
, err
);
478 /* Handle the "Qbtrace-conf" packet. */
481 handle_btrace_conf_general_set (char *own_buf
)
483 struct thread_info
*thread
;
486 if (!startswith (own_buf
, "Qbtrace-conf:"))
489 op
= own_buf
+ strlen ("Qbtrace-conf:");
491 if (ptid_equal (general_thread
, null_ptid
)
492 || ptid_equal (general_thread
, minus_one_ptid
))
494 strcpy (own_buf
, "E.Must select a single thread.");
498 thread
= find_thread_ptid (general_thread
);
501 strcpy (own_buf
, "E.No such thread.");
505 if (startswith (op
, "bts:size="))
511 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
512 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
514 strcpy (own_buf
, "E.Bad size value.");
518 current_btrace_conf
.bts
.size
= (unsigned int) size
;
520 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
526 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
527 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
529 strcpy (own_buf
, "E.Bad size value.");
533 current_btrace_conf
.pt
.size
= (unsigned int) size
;
537 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
545 /* Handle all of the extended 'Q' packets. */
548 handle_general_set (char *own_buf
)
550 if (startswith (own_buf
, "QPassSignals:"))
552 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
553 const char *p
= own_buf
+ strlen ("QPassSignals:");
556 p
= decode_address_to_semicolon (&cursig
, p
);
557 for (i
= 0; i
< numsigs
; i
++)
563 /* Keep looping, to clear the remaining signals. */
566 p
= decode_address_to_semicolon (&cursig
, p
);
571 strcpy (own_buf
, "OK");
575 if (startswith (own_buf
, "QProgramSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QProgramSignals:");
581 program_signals_p
= 1;
583 p
= decode_address_to_semicolon (&cursig
, p
);
584 for (i
= 0; i
< numsigs
; i
++)
588 program_signals
[i
] = 1;
590 /* Keep looping, to clear the remaining signals. */
593 p
= decode_address_to_semicolon (&cursig
, p
);
596 program_signals
[i
] = 0;
598 strcpy (own_buf
, "OK");
602 if (startswith (own_buf
, "QCatchSyscalls:"))
604 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
607 struct process_info
*process
;
609 if (!target_running () || !target_supports_catch_syscall ())
615 if (strcmp (p
, "0") == 0)
617 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
621 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
627 process
= current_process ();
628 VEC_truncate (int, process
->syscalls_to_catch
, 0);
638 p
= decode_address_to_semicolon (&sysno
, p
);
639 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
643 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
650 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
652 our_environ
= gdb_environ::from_host_environ ();
658 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
660 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
661 /* The final form of the environment variable. FINAL_VAR will
662 hold the 'VAR=VALUE' format. */
663 std::string final_var
= hex2str (p
);
664 std::string var_name
, var_value
;
668 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
669 debug_printf (_("[Environment variable to be set: '%s']\n"),
674 size_t pos
= final_var
.find ('=');
675 if (pos
== std::string::npos
)
677 warning (_("Unexpected format for environment variable: '%s'"),
683 var_name
= final_var
.substr (0, pos
);
684 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
686 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
692 if (startswith (own_buf
, "QEnvironmentUnset:"))
694 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
695 std::string varname
= hex2str (p
);
699 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
700 debug_printf (_("[Environment variable to be unset: '%s']\n"),
705 our_environ
.unset (varname
.c_str ());
711 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
715 debug_printf ("[noack mode enabled]\n");
724 if (startswith (own_buf
, "QNonStop:"))
726 char *mode
= own_buf
+ 9;
730 if (strcmp (mode
, "0") == 0)
732 else if (strcmp (mode
, "1") == 0)
736 /* We don't know what this mode is, so complain to
738 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
744 req_str
= req
? "non-stop" : "all-stop";
745 if (start_non_stop (req
) != 0)
747 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
755 debug_printf ("[%s mode enabled]\n", req_str
);
761 if (startswith (own_buf
, "QDisableRandomization:"))
763 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
766 unpack_varlen_hex (packet
, &setting
);
767 disable_randomization
= setting
;
771 debug_printf (disable_randomization
772 ? "[address space randomization disabled]\n"
773 : "[address space randomization enabled]\n");
780 if (target_supports_tracepoints ()
781 && handle_tracepoint_general_set (own_buf
))
784 if (startswith (own_buf
, "QAgent:"))
786 char *mode
= own_buf
+ strlen ("QAgent:");
789 if (strcmp (mode
, "0") == 0)
791 else if (strcmp (mode
, "1") == 0)
795 /* We don't know what this value is, so complain to GDB. */
796 sprintf (own_buf
, "E.Unknown QAgent value");
800 /* Update the flag. */
803 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
808 if (handle_btrace_general_set (own_buf
))
811 if (handle_btrace_conf_general_set (own_buf
))
814 if (startswith (own_buf
, "QThreadEvents:"))
816 char *mode
= own_buf
+ strlen ("QThreadEvents:");
817 enum tribool req
= TRIBOOL_UNKNOWN
;
819 if (strcmp (mode
, "0") == 0)
821 else if (strcmp (mode
, "1") == 0)
825 char *mode_copy
= xstrdup (mode
);
827 /* We don't know what this mode is, so complain to GDB. */
828 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
834 report_thread_events
= (req
== TRIBOOL_TRUE
);
838 const char *req_str
= report_thread_events
? "enabled" : "disabled";
840 debug_printf ("[thread events are now %s]\n", req_str
);
847 if (startswith (own_buf
, "QStartupWithShell:"))
849 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
851 if (strcmp (value
, "1") == 0)
852 startup_with_shell
= true;
853 else if (strcmp (value
, "0") == 0)
854 startup_with_shell
= false;
858 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
865 debug_printf (_("[Inferior will %s started with shell]"),
866 startup_with_shell
? "be" : "not be");
872 /* Otherwise we didn't know what packet it was. Say we didn't
878 get_features_xml (const char *annex
)
880 const struct target_desc
*desc
= current_target_desc ();
882 /* `desc->xmltarget' defines what to return when looking for the
883 "target.xml" file. Its contents can either be verbatim XML code
884 (prefixed with a '@') or else the name of the actual XML file to
885 be used in place of "target.xml".
887 This variable is set up from the auto-generated
888 init_registers_... routine for the current target. */
890 if (strcmp (annex
, "target.xml") == 0)
892 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
902 extern const char *const xml_builtin
[][2];
905 /* Look for the annex. */
906 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
907 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
910 if (xml_builtin
[i
][0] != NULL
)
911 return xml_builtin
[i
][1];
919 monitor_show_help (void)
921 monitor_output ("The following monitor commands are supported:\n");
922 monitor_output (" set debug <0|1>\n");
923 monitor_output (" Enable general debugging messages\n");
924 monitor_output (" set debug-hw-points <0|1>\n");
925 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
926 monitor_output (" set remote-debug <0|1>\n");
927 monitor_output (" Enable remote protocol debugging messages\n");
928 monitor_output (" set debug-format option1[,option2,...]\n");
929 monitor_output (" Add additional information to debugging messages\n");
930 monitor_output (" Options: all, none");
931 monitor_output (", timestamp");
932 monitor_output ("\n");
933 monitor_output (" exit\n");
934 monitor_output (" Quit GDBserver\n");
937 /* Read trace frame or inferior memory. Returns the number of bytes
938 actually read, zero when no further transfer is possible, and -1 on
939 error. Return of a positive value smaller than LEN does not
940 indicate there's no more to be read, only the end of the transfer.
941 E.g., when GDB reads memory from a traceframe, a first request may
942 be served from a memory block that does not cover the whole request
943 length. A following request gets the rest served from either
944 another block (of the same traceframe) or from the read-only
948 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
952 if (current_traceframe
>= 0)
955 ULONGEST length
= len
;
957 if (traceframe_read_mem (current_traceframe
,
958 memaddr
, myaddr
, len
, &nbytes
))
960 /* Data read from trace buffer, we're done. */
963 if (!in_readonly_region (memaddr
, length
))
965 /* Otherwise we have a valid readonly case, fall through. */
966 /* (assume no half-trace half-real blocks for now) */
969 res
= prepare_to_access_memory ();
972 if (set_desired_thread ())
973 res
= read_inferior_memory (memaddr
, myaddr
, len
);
976 done_accessing_memory ();
978 return res
== 0 ? len
: -1;
984 /* Write trace frame or inferior memory. Actually, writing to trace
985 frames is forbidden. */
988 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
990 if (current_traceframe
>= 0)
996 ret
= prepare_to_access_memory ();
999 if (set_desired_thread ())
1000 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1003 done_accessing_memory ();
1009 /* Subroutine of handle_search_memory to simplify it. */
1012 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1013 gdb_byte
*pattern
, unsigned pattern_len
,
1014 gdb_byte
*search_buf
,
1015 unsigned chunk_size
, unsigned search_buf_size
,
1016 CORE_ADDR
*found_addrp
)
1018 /* Prime the search buffer. */
1020 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1023 warning ("Unable to access %ld bytes of target "
1024 "memory at 0x%lx, halting search.",
1025 (long) search_buf_size
, (long) start_addr
);
1029 /* Perform the search.
1031 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1032 When we've scanned N bytes we copy the trailing bytes to the start and
1033 read in another N bytes. */
1035 while (search_space_len
>= pattern_len
)
1037 gdb_byte
*found_ptr
;
1038 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1042 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1045 if (found_ptr
!= NULL
)
1047 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1048 *found_addrp
= found_addr
;
1052 /* Not found in this chunk, skip to next chunk. */
1054 /* Don't let search_space_len wrap here, it's unsigned. */
1055 if (search_space_len
>= chunk_size
)
1056 search_space_len
-= chunk_size
;
1058 search_space_len
= 0;
1060 if (search_space_len
>= pattern_len
)
1062 unsigned keep_len
= search_buf_size
- chunk_size
;
1063 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1066 /* Copy the trailing part of the previous iteration to the front
1067 of the buffer for the next iteration. */
1068 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1070 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1071 ? search_space_len
- keep_len
1074 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1075 nr_to_read
) != search_buf_size
)
1077 warning ("Unable to access %ld bytes of target memory "
1078 "at 0x%lx, halting search.",
1079 (long) nr_to_read
, (long) read_addr
);
1083 start_addr
+= chunk_size
;
1092 /* Handle qSearch:memory packets. */
1095 handle_search_memory (char *own_buf
, int packet_len
)
1097 CORE_ADDR start_addr
;
1098 CORE_ADDR search_space_len
;
1100 unsigned int pattern_len
;
1101 /* NOTE: also defined in find.c testcase. */
1102 #define SEARCH_CHUNK_SIZE 16000
1103 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1104 /* Buffer to hold memory contents for searching. */
1105 gdb_byte
*search_buf
;
1106 unsigned search_buf_size
;
1108 CORE_ADDR found_addr
;
1109 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1111 pattern
= (gdb_byte
*) malloc (packet_len
);
1112 if (pattern
== NULL
)
1114 error ("Unable to allocate memory to perform the search");
1115 strcpy (own_buf
, "E00");
1118 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1119 packet_len
- cmd_name_len
,
1120 &start_addr
, &search_space_len
,
1121 pattern
, &pattern_len
) < 0)
1124 error ("Error in parsing qSearch:memory packet");
1125 strcpy (own_buf
, "E00");
1129 search_buf_size
= chunk_size
+ pattern_len
- 1;
1131 /* No point in trying to allocate a buffer larger than the search space. */
1132 if (search_space_len
< search_buf_size
)
1133 search_buf_size
= search_space_len
;
1135 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1136 if (search_buf
== NULL
)
1139 error ("Unable to allocate memory to perform the search");
1140 strcpy (own_buf
, "E00");
1144 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1145 pattern
, pattern_len
,
1146 search_buf
, chunk_size
, search_buf_size
,
1150 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1151 else if (found
== 0)
1152 strcpy (own_buf
, "0");
1154 strcpy (own_buf
, "E00");
1160 /* Handle the "D" packet. */
1163 handle_detach (char *own_buf
)
1165 require_running_or_return (own_buf
);
1172 pid
= strtol (&own_buf
[2], NULL
, 16);
1175 pid
= ptid_get_pid (current_ptid
);
1177 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1179 struct process_info
*process
= find_process_pid (pid
);
1181 if (process
== NULL
)
1183 write_enn (own_buf
);
1187 if (tracing
&& disconnected_tracing
)
1189 "Disconnected tracing in effect, "
1190 "leaving gdbserver attached to the process\n");
1192 if (any_persistent_commands ())
1194 "Persistent commands are present, "
1195 "leaving gdbserver attached to the process\n");
1197 /* Make sure we're in non-stop/async mode, so we we can both
1198 wait for an async socket accept, and handle async target
1199 events simultaneously. There's also no point either in
1200 having the target stop all threads, when we're going to
1201 pass signals down without informing GDB. */
1205 debug_printf ("Forcing non-stop mode\n");
1211 process
->gdb_detached
= 1;
1213 /* Detaching implicitly resumes all threads. */
1214 target_continue_no_signal (minus_one_ptid
);
1220 fprintf (stderr
, "Detaching from process %d\n", pid
);
1222 if (detach_inferior (pid
) != 0)
1223 write_enn (own_buf
);
1226 discard_queued_stop_replies (pid_to_ptid (pid
));
1229 if (extended_protocol
|| target_running ())
1231 /* There is still at least one inferior remaining or
1232 we are in extended mode, so don't terminate gdbserver,
1233 and instead treat this like a normal program exit. */
1234 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1235 last_status
.value
.integer
= 0;
1236 last_ptid
= pid_to_ptid (pid
);
1238 current_thread
= NULL
;
1245 /* If we are attached, then we can exit. Otherwise, we
1246 need to hang around doing nothing, until the child is
1248 join_inferior (pid
);
1254 /* Parse options to --debug-format= and "monitor set debug-format".
1255 ARG is the text after "--debug-format=" or "monitor set debug-format".
1256 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1257 This triggers calls to monitor_output.
1258 The result is NULL if all options were parsed ok, otherwise an error
1259 message which the caller must free.
1261 N.B. These commands affect all debug format settings, they are not
1262 cumulative. If a format is not specified, it is turned off.
1263 However, we don't go to extra trouble with things like
1264 "monitor set debug-format all,none,timestamp".
1265 Instead we just parse them one at a time, in order.
1267 The syntax for "monitor set debug" we support here is not identical
1268 to gdb's "set debug foo on|off" because we also use this function to
1269 parse "--debug-format=foo,bar". */
1272 parse_debug_format_options (const char *arg
, int is_monitor
)
1274 VEC (char_ptr
) *options
;
1278 /* First turn all debug format options off. */
1279 debug_timestamp
= 0;
1281 /* First remove leading spaces, for "monitor set debug-format". */
1282 while (isspace (*arg
))
1285 options
= delim_string_to_char_ptr_vec (arg
, ',');
1287 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1289 if (strcmp (option
, "all") == 0)
1291 debug_timestamp
= 1;
1293 monitor_output ("All extra debug format options enabled.\n");
1295 else if (strcmp (option
, "none") == 0)
1297 debug_timestamp
= 0;
1299 monitor_output ("All extra debug format options disabled.\n");
1301 else if (strcmp (option
, "timestamp") == 0)
1303 debug_timestamp
= 1;
1305 monitor_output ("Timestamps will be added to debug output.\n");
1307 else if (*option
== '\0')
1309 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1314 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1317 free_char_ptr_vec (options
);
1322 free_char_ptr_vec (options
);
1326 /* Handle monitor commands not handled by target-specific handlers. */
1329 handle_monitor_command (char *mon
, char *own_buf
)
1331 if (strcmp (mon
, "set debug 1") == 0)
1334 monitor_output ("Debug output enabled.\n");
1336 else if (strcmp (mon
, "set debug 0") == 0)
1339 monitor_output ("Debug output disabled.\n");
1341 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1343 show_debug_regs
= 1;
1344 monitor_output ("H/W point debugging output enabled.\n");
1346 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1348 show_debug_regs
= 0;
1349 monitor_output ("H/W point debugging output disabled.\n");
1351 else if (strcmp (mon
, "set remote-debug 1") == 0)
1354 monitor_output ("Protocol debug output enabled.\n");
1356 else if (strcmp (mon
, "set remote-debug 0") == 0)
1359 monitor_output ("Protocol debug output disabled.\n");
1361 else if (startswith (mon
, "set debug-format "))
1364 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1367 if (error_msg
!= NULL
)
1369 monitor_output (error_msg
);
1370 monitor_show_help ();
1371 write_enn (own_buf
);
1375 else if (strcmp (mon
, "help") == 0)
1376 monitor_show_help ();
1377 else if (strcmp (mon
, "exit") == 0)
1381 monitor_output ("Unknown monitor command.\n\n");
1382 monitor_show_help ();
1383 write_enn (own_buf
);
1387 /* Associates a callback with each supported qXfer'able object. */
1391 /* The object this handler handles. */
1394 /* Request that the target transfer up to LEN 8-bit bytes of the
1395 target's OBJECT. The OFFSET, for a seekable object, specifies
1396 the starting point. The ANNEX can be used to provide additional
1397 data-specific information to the target.
1399 Return the number of bytes actually transfered, zero when no
1400 further transfer is possible, -1 on error, -2 when the transfer
1401 is not supported, and -3 on a verbose error message that should
1402 be preserved. Return of a positive value smaller than LEN does
1403 not indicate the end of the object, only the end of the transfer.
1405 One, and only one, of readbuf or writebuf must be non-NULL. */
1406 int (*xfer
) (const char *annex
,
1407 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1408 ULONGEST offset
, LONGEST len
);
1411 /* Handle qXfer:auxv:read. */
1414 handle_qxfer_auxv (const char *annex
,
1415 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1416 ULONGEST offset
, LONGEST len
)
1418 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1421 if (annex
[0] != '\0' || current_thread
== NULL
)
1424 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1427 /* Handle qXfer:exec-file:read. */
1430 handle_qxfer_exec_file (const char *annex
,
1431 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1432 ULONGEST offset
, LONGEST len
)
1438 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1441 if (annex
[0] == '\0')
1443 if (current_thread
== NULL
)
1446 pid
= pid_of (current_thread
);
1450 annex
= unpack_varlen_hex (annex
, &pid
);
1451 if (annex
[0] != '\0')
1458 file
= (*the_target
->pid_to_exec_file
) (pid
);
1462 total_len
= strlen (file
);
1464 if (offset
> total_len
)
1467 if (offset
+ len
> total_len
)
1468 len
= total_len
- offset
;
1470 memcpy (readbuf
, file
+ offset
, len
);
1474 /* Handle qXfer:features:read. */
1477 handle_qxfer_features (const char *annex
,
1478 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1479 ULONGEST offset
, LONGEST len
)
1481 const char *document
;
1484 if (writebuf
!= NULL
)
1487 if (!target_running ())
1490 /* Grab the correct annex. */
1491 document
= get_features_xml (annex
);
1492 if (document
== NULL
)
1495 total_len
= strlen (document
);
1497 if (offset
> total_len
)
1500 if (offset
+ len
> total_len
)
1501 len
= total_len
- offset
;
1503 memcpy (readbuf
, document
+ offset
, len
);
1507 /* Worker routine for handle_qxfer_libraries.
1508 Emit the XML to describe the library in INF. */
1511 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1513 struct dll_info
*dll
= (struct dll_info
*) inf
;
1514 std::string
*document
= (std::string
*) arg
;
1515 std::string name
= xml_escape_text (dll
->name
);
1517 *document
+= string_printf
1518 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1519 name
.c_str (), (long) dll
->base_addr
);
1522 /* Handle qXfer:libraries:read. */
1525 handle_qxfer_libraries (const char *annex
,
1526 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1527 ULONGEST offset
, LONGEST len
)
1529 if (writebuf
!= NULL
)
1532 if (annex
[0] != '\0' || current_thread
== NULL
)
1535 std::string document
= "<library-list version=\"1.0\">\n";
1537 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &document
);
1539 document
+= "</library-list>\n";
1541 if (offset
> document
.length ())
1544 if (offset
+ len
> document
.length ())
1545 len
= document
.length () - offset
;
1547 memcpy (readbuf
, &document
[offset
], len
);
1552 /* Handle qXfer:libraries-svr4:read. */
1555 handle_qxfer_libraries_svr4 (const char *annex
,
1556 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1557 ULONGEST offset
, LONGEST len
)
1559 if (writebuf
!= NULL
)
1562 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1565 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1568 /* Handle qXfer:osadata:read. */
1571 handle_qxfer_osdata (const char *annex
,
1572 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1573 ULONGEST offset
, LONGEST len
)
1575 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1578 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1581 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1584 handle_qxfer_siginfo (const char *annex
,
1585 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1586 ULONGEST offset
, LONGEST len
)
1588 if (the_target
->qxfer_siginfo
== NULL
)
1591 if (annex
[0] != '\0' || current_thread
== NULL
)
1594 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1597 /* Handle qXfer:spu:read and qXfer:spu:write. */
1600 handle_qxfer_spu (const char *annex
,
1601 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1602 ULONGEST offset
, LONGEST len
)
1604 if (the_target
->qxfer_spu
== NULL
)
1607 if (current_thread
== NULL
)
1610 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1613 /* Handle qXfer:statictrace:read. */
1616 handle_qxfer_statictrace (const char *annex
,
1617 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1618 ULONGEST offset
, LONGEST len
)
1622 if (writebuf
!= NULL
)
1625 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1628 if (traceframe_read_sdata (current_traceframe
, offset
,
1629 readbuf
, len
, &nbytes
))
1634 /* Helper for handle_qxfer_threads_proper.
1635 Emit the XML to describe the thread of INF. */
1638 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1640 struct thread_info
*thread
= (struct thread_info
*) inf
;
1641 struct buffer
*buffer
= (struct buffer
*) arg
;
1642 ptid_t ptid
= ptid_of (thread
);
1644 int core
= target_core_of_thread (ptid
);
1646 const char *name
= target_thread_name (ptid
);
1649 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1651 write_ptid (ptid_s
, ptid
);
1653 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1657 sprintf (core_s
, "%d", core
);
1658 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1662 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1666 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1667 bin2hex (handle
, handle_s
, handle_len
);
1668 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1671 buffer_xml_printf (buffer
, "/>\n");
1674 /* Helper for handle_qxfer_threads. */
1677 handle_qxfer_threads_proper (struct buffer
*buffer
)
1679 buffer_grow_str (buffer
, "<threads>\n");
1681 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1684 buffer_grow_str0 (buffer
, "</threads>\n");
1687 /* Handle qXfer:threads:read. */
1690 handle_qxfer_threads (const char *annex
,
1691 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1692 ULONGEST offset
, LONGEST len
)
1694 static char *result
= 0;
1695 static unsigned int result_length
= 0;
1697 if (writebuf
!= NULL
)
1700 if (annex
[0] != '\0')
1705 struct buffer buffer
;
1706 /* When asked for data at offset 0, generate everything and store into
1707 'result'. Successive reads will be served off 'result'. */
1711 buffer_init (&buffer
);
1713 handle_qxfer_threads_proper (&buffer
);
1715 result
= buffer_finish (&buffer
);
1716 result_length
= strlen (result
);
1717 buffer_free (&buffer
);
1720 if (offset
>= result_length
)
1722 /* We're out of data. */
1729 if (len
> result_length
- offset
)
1730 len
= result_length
- offset
;
1732 memcpy (readbuf
, result
+ offset
, len
);
1737 /* Handle qXfer:traceframe-info:read. */
1740 handle_qxfer_traceframe_info (const char *annex
,
1741 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1742 ULONGEST offset
, LONGEST len
)
1744 static char *result
= 0;
1745 static unsigned int result_length
= 0;
1747 if (writebuf
!= NULL
)
1750 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1755 struct buffer buffer
;
1757 /* When asked for data at offset 0, generate everything and
1758 store into 'result'. Successive reads will be served off
1762 buffer_init (&buffer
);
1764 traceframe_read_info (current_traceframe
, &buffer
);
1766 result
= buffer_finish (&buffer
);
1767 result_length
= strlen (result
);
1768 buffer_free (&buffer
);
1771 if (offset
>= result_length
)
1773 /* We're out of data. */
1780 if (len
> result_length
- offset
)
1781 len
= result_length
- offset
;
1783 memcpy (readbuf
, result
+ offset
, len
);
1787 /* Handle qXfer:fdpic:read. */
1790 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1791 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1793 if (the_target
->read_loadmap
== NULL
)
1796 if (current_thread
== NULL
)
1799 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1802 /* Handle qXfer:btrace:read. */
1805 handle_qxfer_btrace (const char *annex
,
1806 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1807 ULONGEST offset
, LONGEST len
)
1809 static struct buffer cache
;
1810 struct thread_info
*thread
;
1811 enum btrace_read_type type
;
1814 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1817 if (ptid_equal (general_thread
, null_ptid
)
1818 || ptid_equal (general_thread
, minus_one_ptid
))
1820 strcpy (own_buf
, "E.Must select a single thread.");
1824 thread
= find_thread_ptid (general_thread
);
1827 strcpy (own_buf
, "E.No such thread.");
1831 if (thread
->btrace
== NULL
)
1833 strcpy (own_buf
, "E.Btrace not enabled.");
1837 if (strcmp (annex
, "all") == 0)
1838 type
= BTRACE_READ_ALL
;
1839 else if (strcmp (annex
, "new") == 0)
1840 type
= BTRACE_READ_NEW
;
1841 else if (strcmp (annex
, "delta") == 0)
1842 type
= BTRACE_READ_DELTA
;
1845 strcpy (own_buf
, "E.Bad annex.");
1851 buffer_free (&cache
);
1853 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1856 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1860 else if (offset
> cache
.used_size
)
1862 buffer_free (&cache
);
1866 if (len
> cache
.used_size
- offset
)
1867 len
= cache
.used_size
- offset
;
1869 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1874 /* Handle qXfer:btrace-conf:read. */
1877 handle_qxfer_btrace_conf (const char *annex
,
1878 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1879 ULONGEST offset
, LONGEST len
)
1881 static struct buffer cache
;
1882 struct thread_info
*thread
;
1885 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1888 if (annex
[0] != '\0')
1891 if (ptid_equal (general_thread
, null_ptid
)
1892 || ptid_equal (general_thread
, minus_one_ptid
))
1894 strcpy (own_buf
, "E.Must select a single thread.");
1898 thread
= find_thread_ptid (general_thread
);
1901 strcpy (own_buf
, "E.No such thread.");
1905 if (thread
->btrace
== NULL
)
1907 strcpy (own_buf
, "E.Btrace not enabled.");
1913 buffer_free (&cache
);
1915 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1918 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1922 else if (offset
> cache
.used_size
)
1924 buffer_free (&cache
);
1928 if (len
> cache
.used_size
- offset
)
1929 len
= cache
.used_size
- offset
;
1931 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1936 static const struct qxfer qxfer_packets
[] =
1938 { "auxv", handle_qxfer_auxv
},
1939 { "btrace", handle_qxfer_btrace
},
1940 { "btrace-conf", handle_qxfer_btrace_conf
},
1941 { "exec-file", handle_qxfer_exec_file
},
1942 { "fdpic", handle_qxfer_fdpic
},
1943 { "features", handle_qxfer_features
},
1944 { "libraries", handle_qxfer_libraries
},
1945 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1946 { "osdata", handle_qxfer_osdata
},
1947 { "siginfo", handle_qxfer_siginfo
},
1948 { "spu", handle_qxfer_spu
},
1949 { "statictrace", handle_qxfer_statictrace
},
1950 { "threads", handle_qxfer_threads
},
1951 { "traceframe-info", handle_qxfer_traceframe_info
},
1955 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1963 if (!startswith (own_buf
, "qXfer:"))
1966 /* Grab the object, r/w and annex. */
1967 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1969 write_enn (own_buf
);
1974 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1977 const struct qxfer
*q
= &qxfer_packets
[i
];
1979 if (strcmp (object
, q
->object
) == 0)
1981 if (strcmp (rw
, "read") == 0)
1983 unsigned char *data
;
1988 /* Grab the offset and length. */
1989 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1991 write_enn (own_buf
);
1995 /* Read one extra byte, as an indicator of whether there is
1997 if (len
> PBUFSIZ
- 2)
1999 data
= (unsigned char *) malloc (len
+ 1);
2002 write_enn (own_buf
);
2005 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2013 /* Preserve error message. */
2016 write_enn (own_buf
);
2018 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2020 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2025 else if (strcmp (rw
, "write") == 0)
2030 unsigned char *data
;
2032 strcpy (own_buf
, "E00");
2033 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2036 write_enn (own_buf
);
2039 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2040 &ofs
, &len
, data
) < 0)
2043 write_enn (own_buf
);
2047 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2055 /* Preserve error message. */
2058 write_enn (own_buf
);
2060 sprintf (own_buf
, "%x", n
);
2073 /* Compute 32 bit CRC from inferior memory.
2075 On success, return 32 bit CRC.
2076 On failure, return (unsigned long long) -1. */
2078 static unsigned long long
2079 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2083 unsigned char byte
= 0;
2085 /* Return failure if memory read fails. */
2086 if (read_inferior_memory (base
, &byte
, 1) != 0)
2087 return (unsigned long long) -1;
2089 crc
= xcrc32 (&byte
, 1, crc
);
2092 return (unsigned long long) crc
;
2095 /* Add supported btrace packets to BUF. */
2098 supported_btrace_packets (char *buf
)
2100 int btrace_supported
= 0;
2102 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2104 strcat (buf
, ";Qbtrace:bts+");
2105 strcat (buf
, ";Qbtrace-conf:bts:size+");
2107 btrace_supported
= 1;
2110 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2112 strcat (buf
, ";Qbtrace:pt+");
2113 strcat (buf
, ";Qbtrace-conf:pt:size+");
2115 btrace_supported
= 1;
2118 if (!btrace_supported
)
2121 strcat (buf
, ";Qbtrace:off+");
2122 strcat (buf
, ";qXfer:btrace:read+");
2123 strcat (buf
, ";qXfer:btrace-conf:read+");
2126 /* Handle all of the extended 'q' packets. */
2129 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2131 static struct inferior_list_entry
*thread_ptr
;
2133 /* Reply the current thread id. */
2134 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2137 require_running_or_return (own_buf
);
2139 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2140 ptid
= general_thread
;
2143 thread_ptr
= get_first_inferior (&all_threads
);
2144 ptid
= thread_ptr
->id
;
2147 sprintf (own_buf
, "QC");
2149 write_ptid (own_buf
, ptid
);
2153 if (strcmp ("qSymbol::", own_buf
) == 0)
2155 struct thread_info
*save_thread
= current_thread
;
2157 /* For qSymbol, GDB only changes the current thread if the
2158 previous current thread was of a different process. So if
2159 the previous thread is gone, we need to pick another one of
2160 the same process. This can happen e.g., if we followed an
2161 exec in a non-leader thread. */
2162 if (current_thread
== NULL
)
2165 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2167 /* Just in case, if we didn't find a thread, then bail out
2168 instead of crashing. */
2169 if (current_thread
== NULL
)
2171 write_enn (own_buf
);
2172 current_thread
= save_thread
;
2177 /* GDB is suggesting new symbols have been loaded. This may
2178 mean a new shared library has been detected as loaded, so
2179 take the opportunity to check if breakpoints we think are
2180 inserted, still are. Note that it isn't guaranteed that
2181 we'll see this when a shared library is loaded, and nor will
2182 we see this for unloads (although breakpoints in unloaded
2183 libraries shouldn't trigger), as GDB may not find symbols for
2184 the library at all. We also re-validate breakpoints when we
2185 see a second GDB breakpoint for the same address, and or when
2186 we access breakpoint shadows. */
2187 validate_breakpoints ();
2189 if (target_supports_tracepoints ())
2190 tracepoint_look_up_symbols ();
2192 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2193 (*the_target
->look_up_symbols
) ();
2195 current_thread
= save_thread
;
2197 strcpy (own_buf
, "OK");
2201 if (!disable_packet_qfThreadInfo
)
2203 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2205 require_running_or_return (own_buf
);
2206 thread_ptr
= get_first_inferior (&all_threads
);
2209 write_ptid (own_buf
, thread_ptr
->id
);
2210 thread_ptr
= thread_ptr
->next
;
2214 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2216 require_running_or_return (own_buf
);
2217 if (thread_ptr
!= NULL
)
2220 write_ptid (own_buf
, thread_ptr
->id
);
2221 thread_ptr
= thread_ptr
->next
;
2226 sprintf (own_buf
, "l");
2232 if (the_target
->read_offsets
!= NULL
2233 && strcmp ("qOffsets", own_buf
) == 0)
2235 CORE_ADDR text
, data
;
2237 require_running_or_return (own_buf
);
2238 if (the_target
->read_offsets (&text
, &data
))
2239 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2240 (long)text
, (long)data
, (long)data
);
2242 write_enn (own_buf
);
2247 /* Protocol features query. */
2248 if (startswith (own_buf
, "qSupported")
2249 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2251 char *p
= &own_buf
[10];
2252 int gdb_supports_qRelocInsn
= 0;
2254 /* Process each feature being provided by GDB. The first
2255 feature will follow a ':', and latter features will follow
2259 char **qsupported
= NULL
;
2264 /* Two passes, to avoid nested strtok calls in
2265 target_process_qsupported. */
2266 for (p
= strtok (p
+ 1, ";");
2268 p
= strtok (NULL
, ";"))
2271 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2272 qsupported
[count
- 1] = xstrdup (p
);
2275 for (i
= 0; i
< count
; i
++)
2278 if (strcmp (p
, "multiprocess+") == 0)
2280 /* GDB supports and wants multi-process support if
2282 if (target_supports_multi_process ())
2285 else if (strcmp (p
, "qRelocInsn+") == 0)
2287 /* GDB supports relocate instruction requests. */
2288 gdb_supports_qRelocInsn
= 1;
2290 else if (strcmp (p
, "swbreak+") == 0)
2292 /* GDB wants us to report whether a trap is caused
2293 by a software breakpoint and for us to handle PC
2294 adjustment if necessary on this target. */
2295 if (target_supports_stopped_by_sw_breakpoint ())
2296 swbreak_feature
= 1;
2298 else if (strcmp (p
, "hwbreak+") == 0)
2300 /* GDB wants us to report whether a trap is caused
2301 by a hardware breakpoint. */
2302 if (target_supports_stopped_by_hw_breakpoint ())
2303 hwbreak_feature
= 1;
2305 else if (strcmp (p
, "fork-events+") == 0)
2307 /* GDB supports and wants fork events if possible. */
2308 if (target_supports_fork_events ())
2309 report_fork_events
= 1;
2311 else if (strcmp (p
, "vfork-events+") == 0)
2313 /* GDB supports and wants vfork events if possible. */
2314 if (target_supports_vfork_events ())
2315 report_vfork_events
= 1;
2317 else if (strcmp (p
, "exec-events+") == 0)
2319 /* GDB supports and wants exec events if possible. */
2320 if (target_supports_exec_events ())
2321 report_exec_events
= 1;
2323 else if (strcmp (p
, "vContSupported+") == 0)
2324 vCont_supported
= 1;
2325 else if (strcmp (p
, "QThreadEvents+") == 0)
2327 else if (strcmp (p
, "no-resumed+") == 0)
2329 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2331 report_no_resumed
= 1;
2335 /* Move the unknown features all together. */
2336 qsupported
[i
] = NULL
;
2337 qsupported
[unknown
] = p
;
2342 /* Give the target backend a chance to process the unknown
2344 target_process_qsupported (qsupported
, unknown
);
2346 for (i
= 0; i
< count
; i
++)
2347 free (qsupported
[i
]);
2352 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2353 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2354 "QEnvironmentReset+;QEnvironmentUnset+",
2357 if (target_supports_catch_syscall ())
2358 strcat (own_buf
, ";QCatchSyscalls+");
2360 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2361 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2362 ";augmented-libraries-svr4-read+");
2365 /* We do not have any hook to indicate whether the non-SVR4 target
2366 backend supports qXfer:libraries:read, so always report it. */
2367 strcat (own_buf
, ";qXfer:libraries:read+");
2370 if (the_target
->read_auxv
!= NULL
)
2371 strcat (own_buf
, ";qXfer:auxv:read+");
2373 if (the_target
->qxfer_spu
!= NULL
)
2374 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2376 if (the_target
->qxfer_siginfo
!= NULL
)
2377 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2379 if (the_target
->read_loadmap
!= NULL
)
2380 strcat (own_buf
, ";qXfer:fdpic:read+");
2382 /* We always report qXfer:features:read, as targets may
2383 install XML files on a subsequent call to arch_setup.
2384 If we reported to GDB on startup that we don't support
2385 qXfer:feature:read at all, we will never be re-queried. */
2386 strcat (own_buf
, ";qXfer:features:read+");
2388 if (transport_is_reliable
)
2389 strcat (own_buf
, ";QStartNoAckMode+");
2391 if (the_target
->qxfer_osdata
!= NULL
)
2392 strcat (own_buf
, ";qXfer:osdata:read+");
2394 if (target_supports_multi_process ())
2395 strcat (own_buf
, ";multiprocess+");
2397 if (target_supports_fork_events ())
2398 strcat (own_buf
, ";fork-events+");
2400 if (target_supports_vfork_events ())
2401 strcat (own_buf
, ";vfork-events+");
2403 if (target_supports_exec_events ())
2404 strcat (own_buf
, ";exec-events+");
2406 if (target_supports_non_stop ())
2407 strcat (own_buf
, ";QNonStop+");
2409 if (target_supports_disable_randomization ())
2410 strcat (own_buf
, ";QDisableRandomization+");
2412 strcat (own_buf
, ";qXfer:threads:read+");
2414 if (target_supports_tracepoints ())
2416 strcat (own_buf
, ";ConditionalTracepoints+");
2417 strcat (own_buf
, ";TraceStateVariables+");
2418 strcat (own_buf
, ";TracepointSource+");
2419 strcat (own_buf
, ";DisconnectedTracing+");
2420 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2421 strcat (own_buf
, ";FastTracepoints+");
2422 strcat (own_buf
, ";StaticTracepoints+");
2423 strcat (own_buf
, ";InstallInTrace+");
2424 strcat (own_buf
, ";qXfer:statictrace:read+");
2425 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2426 strcat (own_buf
, ";EnableDisableTracepoints+");
2427 strcat (own_buf
, ";QTBuffer:size+");
2428 strcat (own_buf
, ";tracenz+");
2431 if (target_supports_hardware_single_step ()
2432 || target_supports_software_single_step () )
2434 strcat (own_buf
, ";ConditionalBreakpoints+");
2436 strcat (own_buf
, ";BreakpointCommands+");
2438 if (target_supports_agent ())
2439 strcat (own_buf
, ";QAgent+");
2441 supported_btrace_packets (own_buf
);
2443 if (target_supports_stopped_by_sw_breakpoint ())
2444 strcat (own_buf
, ";swbreak+");
2446 if (target_supports_stopped_by_hw_breakpoint ())
2447 strcat (own_buf
, ";hwbreak+");
2449 if (the_target
->pid_to_exec_file
!= NULL
)
2450 strcat (own_buf
, ";qXfer:exec-file:read+");
2452 strcat (own_buf
, ";vContSupported+");
2454 strcat (own_buf
, ";QThreadEvents+");
2456 strcat (own_buf
, ";no-resumed+");
2458 /* Reinitialize components as needed for the new connection. */
2459 hostio_handle_new_gdb_connection ();
2460 target_handle_new_gdb_connection ();
2465 /* Thread-local storage support. */
2466 if (the_target
->get_tls_address
!= NULL
2467 && startswith (own_buf
, "qGetTLSAddr:"))
2469 char *p
= own_buf
+ 12;
2470 CORE_ADDR parts
[2], address
= 0;
2472 ptid_t ptid
= null_ptid
;
2474 require_running_or_return (own_buf
);
2476 for (i
= 0; i
< 3; i
++)
2484 p2
= strchr (p
, ',');
2497 ptid
= read_ptid (p
, NULL
);
2499 decode_address (&parts
[i
- 1], p
, len
);
2503 if (p
!= NULL
|| i
< 3)
2507 struct thread_info
*thread
= find_thread_ptid (ptid
);
2512 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2518 strcpy (own_buf
, paddress(address
));
2523 write_enn (own_buf
);
2527 /* Otherwise, pretend we do not understand this packet. */
2530 /* Windows OS Thread Information Block address support. */
2531 if (the_target
->get_tib_address
!= NULL
2532 && startswith (own_buf
, "qGetTIBAddr:"))
2537 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2539 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2542 strcpy (own_buf
, paddress(tlb
));
2547 write_enn (own_buf
);
2553 /* Handle "monitor" commands. */
2554 if (startswith (own_buf
, "qRcmd,"))
2556 char *mon
= (char *) malloc (PBUFSIZ
);
2557 int len
= strlen (own_buf
+ 6);
2561 write_enn (own_buf
);
2566 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2568 write_enn (own_buf
);
2572 mon
[len
/ 2] = '\0';
2576 if (the_target
->handle_monitor_command
== NULL
2577 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2578 /* Default processing. */
2579 handle_monitor_command (mon
, own_buf
);
2585 if (startswith (own_buf
, "qSearch:memory:"))
2587 require_running_or_return (own_buf
);
2588 handle_search_memory (own_buf
, packet_len
);
2592 if (strcmp (own_buf
, "qAttached") == 0
2593 || startswith (own_buf
, "qAttached:"))
2595 struct process_info
*process
;
2597 if (own_buf
[sizeof ("qAttached") - 1])
2599 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2600 process
= (struct process_info
*)
2601 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2605 require_running_or_return (own_buf
);
2606 process
= current_process ();
2609 if (process
== NULL
)
2611 write_enn (own_buf
);
2615 strcpy (own_buf
, process
->attached
? "1" : "0");
2619 if (startswith (own_buf
, "qCRC:"))
2621 /* CRC check (compare-section). */
2625 unsigned long long crc
;
2627 require_running_or_return (own_buf
);
2628 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2629 if (*comma
++ != ',')
2631 write_enn (own_buf
);
2634 len
= strtoul (comma
, NULL
, 16);
2635 crc
= crc32 (base
, len
, 0xffffffff);
2636 /* Check for memory failure. */
2637 if (crc
== (unsigned long long) -1)
2639 write_enn (own_buf
);
2642 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2646 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2649 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2652 /* Otherwise we didn't know what packet it was. Say we didn't
2657 static void gdb_wants_all_threads_stopped (void);
2658 static void resume (struct thread_resume
*actions
, size_t n
);
2660 /* The callback that is passed to visit_actioned_threads. */
2661 typedef int (visit_actioned_threads_callback_ftype
)
2662 (const struct thread_resume
*, struct thread_info
*);
2664 /* Struct to pass data to visit_actioned_threads. */
2666 struct visit_actioned_threads_data
2668 const struct thread_resume
*actions
;
2670 visit_actioned_threads_callback_ftype
*callback
;
2673 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2674 true if CALLBACK returns true. Returns false if no matching thread
2675 is found or CALLBACK results false.
2676 Note: This function is itself a callback for find_inferior. */
2679 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2681 struct visit_actioned_threads_data
*data
2682 = (struct visit_actioned_threads_data
*) datap
;
2683 const struct thread_resume
*actions
= data
->actions
;
2684 size_t num_actions
= data
->num_actions
;
2685 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2688 for (i
= 0; i
< num_actions
; i
++)
2690 const struct thread_resume
*action
= &actions
[i
];
2692 if (ptid_equal (action
->thread
, minus_one_ptid
)
2693 || ptid_equal (action
->thread
, entry
->id
)
2694 || ((ptid_get_pid (action
->thread
)
2695 == ptid_get_pid (entry
->id
))
2696 && ptid_get_lwp (action
->thread
) == -1))
2698 struct thread_info
*thread
= (struct thread_info
*) entry
;
2700 if ((*callback
) (action
, thread
))
2708 /* Callback for visit_actioned_threads. If the thread has a pending
2709 status to report, report it now. */
2712 handle_pending_status (const struct thread_resume
*resumption
,
2713 struct thread_info
*thread
)
2715 if (thread
->status_pending_p
)
2717 thread
->status_pending_p
= 0;
2719 last_status
= thread
->last_status
;
2720 last_ptid
= thread
->entry
.id
;
2721 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2727 /* Parse vCont packets. */
2729 handle_v_cont (char *own_buf
)
2733 struct thread_resume
*resume_info
;
2734 struct thread_resume default_action
{ null_ptid
};
2736 /* Count the number of semicolons in the packet. There should be one
2737 for every action. */
2743 p
= strchr (p
, ';');
2746 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2747 if (resume_info
== NULL
)
2755 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2757 if (p
[0] == 's' || p
[0] == 'S')
2758 resume_info
[i
].kind
= resume_step
;
2759 else if (p
[0] == 'r')
2760 resume_info
[i
].kind
= resume_step
;
2761 else if (p
[0] == 'c' || p
[0] == 'C')
2762 resume_info
[i
].kind
= resume_continue
;
2763 else if (p
[0] == 't')
2764 resume_info
[i
].kind
= resume_stop
;
2768 if (p
[0] == 'S' || p
[0] == 'C')
2771 int sig
= strtol (p
+ 1, &q
, 16);
2776 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2778 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2780 else if (p
[0] == 'r')
2784 p
= unpack_varlen_hex (p
+ 1, &addr
);
2785 resume_info
[i
].step_range_start
= addr
;
2790 p
= unpack_varlen_hex (p
+ 1, &addr
);
2791 resume_info
[i
].step_range_end
= addr
;
2800 resume_info
[i
].thread
= minus_one_ptid
;
2801 default_action
= resume_info
[i
];
2803 /* Note: we don't increment i here, we'll overwrite this entry
2804 the next time through. */
2806 else if (p
[0] == ':')
2809 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2814 if (p
[0] != ';' && p
[0] != 0)
2817 resume_info
[i
].thread
= ptid
;
2824 resume_info
[i
] = default_action
;
2826 resume (resume_info
, n
);
2831 write_enn (own_buf
);
2836 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2839 resume (struct thread_resume
*actions
, size_t num_actions
)
2843 /* Check if among the threads that GDB wants actioned, there's
2844 one with a pending status to report. If so, skip actually
2845 resuming/stopping and report the pending event
2847 struct visit_actioned_threads_data data
;
2849 data
.actions
= actions
;
2850 data
.num_actions
= num_actions
;
2851 data
.callback
= handle_pending_status
;
2852 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2858 (*the_target
->resume
) (actions
, num_actions
);
2864 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2866 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2867 && !report_no_resumed
)
2869 /* The client does not support this stop reply. At least
2871 sprintf (own_buf
, "E.No unwaited-for children left.");
2872 disable_async_io ();
2876 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2877 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2878 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2879 current_thread
->last_status
= last_status
;
2881 /* From the client's perspective, all-stop mode always stops all
2882 threads implicitly (and the target backend has already done
2883 so by now). Tag all threads as "want-stopped", so we don't
2884 resume them implicitly without the client telling us to. */
2885 gdb_wants_all_threads_stopped ();
2886 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2887 disable_async_io ();
2889 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2890 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2891 target_mourn_inferior (last_ptid
);
2895 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2897 handle_v_attach (char *own_buf
)
2901 pid
= strtol (own_buf
+ 8, NULL
, 16);
2902 if (pid
!= 0 && attach_inferior (pid
) == 0)
2904 /* Don't report shared library events after attaching, even if
2905 some libraries are preloaded. GDB will always poll the
2906 library list. Avoids the "stopped by shared library event"
2907 notice on the GDB side. */
2912 /* In non-stop, we don't send a resume reply. Stop events
2913 will follow up using the normal notification
2918 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2924 write_enn (own_buf
);
2929 /* Run a new program. Return 1 if successful, 0 if failure. */
2931 handle_v_run (char *own_buf
)
2934 std::vector
<char *> new_argv
;
2935 char *new_program_name
= NULL
;
2939 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2945 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2947 next_p
= strchr (p
, ';');
2949 next_p
= p
+ strlen (p
);
2951 if (i
== 0 && p
== next_p
)
2953 /* No program specified. */
2954 new_program_name
= NULL
;
2956 else if (p
== next_p
)
2958 /* Empty argument. */
2959 new_argv
.push_back (xstrdup ("''"));
2963 size_t len
= (next_p
- p
) / 2;
2964 /* ARG is the unquoted argument received via the RSP. */
2965 char *arg
= (char *) xmalloc (len
+ 1);
2966 /* FULL_ARGS will contain the quoted version of ARG. */
2967 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2968 /* These are pointers used to navigate the strings above. */
2969 char *tmp_arg
= arg
;
2970 char *tmp_full_arg
= full_arg
;
2973 hex2bin (p
, (gdb_byte
*) arg
, len
);
2976 while (*tmp_arg
!= '\0')
2982 *tmp_full_arg
= '\'';
2988 /* Quote single quote. */
2989 *tmp_full_arg
= '\\';
2997 *tmp_full_arg
= *tmp_arg
;
3003 *tmp_full_arg
++ = '\'';
3005 /* Finish FULL_ARG and push it into the vector containing
3007 *tmp_full_arg
= '\0';
3009 new_program_name
= full_arg
;
3011 new_argv
.push_back (full_arg
);
3017 new_argv
.push_back (NULL
);
3019 if (new_program_name
== NULL
)
3021 /* GDB didn't specify a program to run. Use the program from the
3022 last run with the new argument list. */
3023 if (program_name
== NULL
)
3025 write_enn (own_buf
);
3026 free_vector_argv (new_argv
);
3032 xfree (program_name
);
3033 program_name
= new_program_name
;
3036 /* Free the old argv and install the new one. */
3037 free_vector_argv (program_args
);
3038 program_args
= new_argv
;
3040 create_inferior (program_name
, program_args
);
3042 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3044 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3046 /* In non-stop, sending a resume reply doesn't set the general
3047 thread, but GDB assumes a vRun sets it (this is so GDB can
3048 query which is the main thread of the new inferior. */
3050 general_thread
= last_ptid
;
3056 write_enn (own_buf
);
3061 /* Kill process. Return 1 if successful, 0 if failure. */
3063 handle_v_kill (char *own_buf
)
3066 char *p
= &own_buf
[6];
3068 pid
= strtol (p
, NULL
, 16);
3071 if (pid
!= 0 && kill_inferior (pid
) == 0)
3073 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3074 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3075 last_ptid
= pid_to_ptid (pid
);
3076 discard_queued_stop_replies (last_ptid
);
3082 write_enn (own_buf
);
3087 /* Handle all of the extended 'v' packets. */
3089 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3091 if (!disable_packet_vCont
)
3093 if (strcmp (own_buf
, "vCtrlC") == 0)
3095 (*the_target
->request_interrupt
) ();
3100 if (startswith (own_buf
, "vCont;"))
3102 handle_v_cont (own_buf
);
3106 if (startswith (own_buf
, "vCont?"))
3108 strcpy (own_buf
, "vCont;c;C;t");
3110 if (target_supports_hardware_single_step ()
3111 || target_supports_software_single_step ()
3112 || !vCont_supported
)
3114 /* If target supports single step either by hardware or by
3115 software, add actions s and S to the list of supported
3116 actions. On the other hand, if GDB doesn't request the
3117 supported vCont actions in qSupported packet, add s and
3118 S to the list too. */
3119 own_buf
= own_buf
+ strlen (own_buf
);
3120 strcpy (own_buf
, ";s;S");
3123 if (target_supports_range_stepping ())
3125 own_buf
= own_buf
+ strlen (own_buf
);
3126 strcpy (own_buf
, ";r");
3132 if (startswith (own_buf
, "vFile:")
3133 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3136 if (startswith (own_buf
, "vAttach;"))
3138 if ((!extended_protocol
|| !multi_process
) && target_running ())
3140 fprintf (stderr
, "Already debugging a process\n");
3141 write_enn (own_buf
);
3144 handle_v_attach (own_buf
);
3148 if (startswith (own_buf
, "vRun;"))
3150 if ((!extended_protocol
|| !multi_process
) && target_running ())
3152 fprintf (stderr
, "Already debugging a process\n");
3153 write_enn (own_buf
);
3156 handle_v_run (own_buf
);
3160 if (startswith (own_buf
, "vKill;"))
3162 if (!target_running ())
3164 fprintf (stderr
, "No process to kill\n");
3165 write_enn (own_buf
);
3168 handle_v_kill (own_buf
);
3172 if (handle_notif_ack (own_buf
, packet_len
))
3175 /* Otherwise we didn't know what packet it was. Say we didn't
3181 /* Resume thread and wait for another event. In non-stop mode,
3182 don't really wait here, but return immediatelly to the event
3185 myresume (char *own_buf
, int step
, int sig
)
3187 struct thread_resume resume_info
[2];
3189 int valid_cont_thread
;
3191 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3192 && !ptid_equal (cont_thread
, minus_one_ptid
));
3194 if (step
|| sig
|| valid_cont_thread
)
3196 resume_info
[0].thread
= current_ptid
;
3198 resume_info
[0].kind
= resume_step
;
3200 resume_info
[0].kind
= resume_continue
;
3201 resume_info
[0].sig
= sig
;
3205 if (!valid_cont_thread
)
3207 resume_info
[n
].thread
= minus_one_ptid
;
3208 resume_info
[n
].kind
= resume_continue
;
3209 resume_info
[n
].sig
= 0;
3213 resume (resume_info
, n
);
3216 /* Callback for for_each_inferior. Make a new stop reply for each
3220 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3222 struct thread_info
*thread
= (struct thread_info
*) entry
;
3224 /* For now, assume targets that don't have this callback also don't
3225 manage the thread's last_status field. */
3226 if (the_target
->thread_stopped
== NULL
)
3228 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3230 new_notif
->ptid
= entry
->id
;
3231 new_notif
->status
= thread
->last_status
;
3232 /* Pass the last stop reply back to GDB, but don't notify
3234 notif_event_enque (¬if_stop
,
3235 (struct notif_event
*) new_notif
);
3239 if (thread_stopped (thread
))
3243 std::string status_string
3244 = target_waitstatus_to_string (&thread
->last_status
);
3246 debug_printf ("Reporting thread %s as already stopped with %s\n",
3247 target_pid_to_str (entry
->id
),
3248 status_string
.c_str ());
3251 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3253 /* Pass the last stop reply back to GDB, but don't notify
3255 queue_stop_reply (entry
->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 (struct inferior_list_entry
*entry
)
3269 struct thread_info
*thread
= (struct thread_info
*) entry
;
3271 thread
->last_resume_kind
= resume_stop
;
3273 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3275 /* Most threads are stopped implicitly (all-stop); tag that with
3277 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3278 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3282 /* Set all threads' states as "want-stopped". */
3285 gdb_wants_all_threads_stopped (void)
3287 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3290 /* Clear the gdb_detached flag of every process. */
3293 gdb_reattached_process (struct inferior_list_entry
*entry
)
3295 struct process_info
*process
= (struct process_info
*) entry
;
3297 process
->gdb_detached
= 0;
3300 /* Callback for for_each_inferior. Clear the thread's pending status
3304 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3306 struct thread_info
*thread
= (struct thread_info
*) entry
;
3308 thread
->status_pending_p
= 0;
3311 /* Callback for for_each_inferior. If the thread is stopped with an
3312 interesting event, mark it as having a pending event. */
3315 set_pending_status_callback (struct inferior_list_entry
*entry
)
3317 struct thread_info
*thread
= (struct thread_info
*) entry
;
3319 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3320 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3321 /* A breakpoint, watchpoint or finished step from a previous
3322 GDB run isn't considered interesting for a new GDB run.
3323 If we left those pending, the new GDB could consider them
3324 random SIGTRAPs. This leaves out real async traps. We'd
3325 have to peek into the (target-specific) siginfo to
3326 distinguish those. */
3327 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3328 thread
->status_pending_p
= 1;
3331 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3332 pending status to report to GDB. */
3335 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3337 struct thread_info
*thread
= (struct thread_info
*) entry
;
3339 return thread
->status_pending_p
;
3342 /* Status handler for the '?' packet. */
3345 handle_status (char *own_buf
)
3347 /* GDB is connected, don't forward events to the target anymore. */
3348 for_each_inferior (&all_processes
, gdb_reattached_process
);
3350 /* In non-stop mode, we must send a stop reply for each stopped
3351 thread. In all-stop mode, just send one for the first stopped
3356 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3358 /* The first is sent immediatly. OK is sent if there is no
3359 stopped thread, which is the same handling of the vStopped
3360 packet (by design). */
3361 notif_write_event (¬if_stop
, own_buf
);
3365 struct inferior_list_entry
*thread
= NULL
;
3368 stabilize_threads ();
3369 gdb_wants_all_threads_stopped ();
3371 /* We can only report one status, but we might be coming out of
3372 non-stop -- if more than one thread is stopped with
3373 interesting events, leave events for the threads we're not
3374 reporting now pending. They'll be reported the next time the
3375 threads are resumed. Start by marking all interesting events
3377 for_each_inferior (&all_threads
, set_pending_status_callback
);
3379 /* Prefer the last thread that reported an event to GDB (even if
3380 that was a GDB_SIGNAL_TRAP). */
3381 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3382 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3383 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3384 thread
= find_inferior_id (&all_threads
, last_ptid
);
3386 /* If the last event thread is not found for some reason, look
3387 for some other thread that might have an event to report. */
3389 thread
= find_inferior (&all_threads
,
3390 find_status_pending_thread_callback
, NULL
);
3392 /* If we're still out of luck, simply pick the first thread in
3395 thread
= get_first_inferior (&all_threads
);
3399 struct thread_info
*tp
= (struct thread_info
*) thread
;
3401 /* We're reporting this event, so it's no longer
3403 tp
->status_pending_p
= 0;
3405 /* GDB assumes the current thread is the thread we're
3406 reporting the status for. */
3407 general_thread
= thread
->id
;
3408 set_desired_thread ();
3410 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3411 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3414 strcpy (own_buf
, "W00");
3419 gdbserver_version (void)
3421 printf ("GNU gdbserver %s%s\n"
3422 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3423 "gdbserver is free software, covered by the "
3424 "GNU General Public License.\n"
3425 "This gdbserver was configured as \"%s\"\n",
3426 PKGVERSION
, version
, host_name
);
3430 gdbserver_usage (FILE *stream
)
3432 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3433 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3434 "\tgdbserver [OPTIONS] --multi COMM\n"
3436 "COMM may either be a tty device (for serial debugging),\n"
3437 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3438 "stdin/stdout of gdbserver.\n"
3439 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3440 "PID is the process ID to attach to, when --attach is specified.\n"
3442 "Operating modes:\n"
3444 " --attach Attach to running process PID.\n"
3445 " --multi Start server without a specific program, and\n"
3446 " only quit when explicitly commanded.\n"
3447 " --once Exit after the first connection has closed.\n"
3448 " --help Print this message and then exit.\n"
3449 " --version Display version information and exit.\n"
3453 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3454 " --disable-randomization\n"
3455 " Run PROG with address space randomization disabled.\n"
3456 " --no-disable-randomization\n"
3457 " Don't disable address space randomization when\n"
3459 " --startup-with-shell\n"
3460 " Start PROG using a shell. I.e., execs a shell that\n"
3461 " then execs PROG. (default)\n"
3462 " --no-startup-with-shell\n"
3463 " Exec PROG directly instead of using a shell.\n"
3464 " Disables argument globbing and variable substitution\n"
3465 " on UNIX-like systems.\n"
3469 " --debug Enable general debugging output.\n"
3470 " --debug-format=opt1[,opt2,...]\n"
3471 " Specify extra content in debugging output.\n"
3476 " --remote-debug Enable remote protocol debugging output.\n"
3477 " --disable-packet=opt1[,opt2,...]\n"
3478 " Disable support for RSP packets or features.\n"
3480 " vCont, Tthread, qC, qfThreadInfo and \n"
3481 " threads (disable all threading packets).\n"
3483 "For more information, consult the GDB manual (available as on-line \n"
3484 "info or a printed manual).\n");
3485 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3486 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3490 gdbserver_show_disableable (FILE *stream
)
3492 fprintf (stream
, "Disableable packets:\n"
3493 " vCont \tAll vCont packets\n"
3494 " qC \tQuerying the current thread\n"
3495 " qfThreadInfo\tThread listing\n"
3496 " Tthread \tPassing the thread specifier in the "
3497 "T stop reply packet\n"
3498 " threads \tAll of the above\n");
3502 kill_inferior_callback (struct inferior_list_entry
*entry
)
3504 struct process_info
*process
= (struct process_info
*) entry
;
3505 int pid
= ptid_get_pid (process
->entry
.id
);
3507 kill_inferior (pid
);
3508 discard_queued_stop_replies (pid_to_ptid (pid
));
3511 /* Callback for for_each_inferior to detach or kill the inferior,
3512 depending on whether we attached to it or not.
3513 We inform the user whether we're detaching or killing the process
3514 as this is only called when gdbserver is about to exit. */
3517 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3519 struct process_info
*process
= (struct process_info
*) entry
;
3520 int pid
= ptid_get_pid (process
->entry
.id
);
3522 if (process
->attached
)
3523 detach_inferior (pid
);
3525 kill_inferior (pid
);
3527 discard_queued_stop_replies (pid_to_ptid (pid
));
3530 /* for_each_inferior callback for detach_or_kill_for_exit to print
3531 the pids of started inferiors. */
3534 print_started_pid (struct inferior_list_entry
*entry
)
3536 struct process_info
*process
= (struct process_info
*) entry
;
3538 if (! process
->attached
)
3540 int pid
= ptid_get_pid (process
->entry
.id
);
3541 fprintf (stderr
, " %d", pid
);
3545 /* for_each_inferior callback for detach_or_kill_for_exit to print
3546 the pids of attached inferiors. */
3549 print_attached_pid (struct inferior_list_entry
*entry
)
3551 struct process_info
*process
= (struct process_info
*) entry
;
3553 if (process
->attached
)
3555 int pid
= ptid_get_pid (process
->entry
.id
);
3556 fprintf (stderr
, " %d", pid
);
3560 /* Call this when exiting gdbserver with possible inferiors that need
3561 to be killed or detached from. */
3564 detach_or_kill_for_exit (void)
3566 /* First print a list of the inferiors we will be killing/detaching.
3567 This is to assist the user, for example, in case the inferior unexpectedly
3568 dies after we exit: did we screw up or did the inferior exit on its own?
3569 Having this info will save some head-scratching. */
3571 if (have_started_inferiors_p ())
3573 fprintf (stderr
, "Killing process(es):");
3574 for_each_inferior (&all_processes
, print_started_pid
);
3575 fprintf (stderr
, "\n");
3577 if (have_attached_inferiors_p ())
3579 fprintf (stderr
, "Detaching process(es):");
3580 for_each_inferior (&all_processes
, print_attached_pid
);
3581 fprintf (stderr
, "\n");
3584 /* Now we can kill or detach the inferiors. */
3586 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3589 /* Value that will be passed to exit(3) when gdbserver exits. */
3590 static int exit_code
;
3592 /* Cleanup version of detach_or_kill_for_exit. */
3595 detach_or_kill_for_exit_cleanup (void *ignore
)
3600 detach_or_kill_for_exit ();
3603 CATCH (exception
, RETURN_MASK_ALL
)
3606 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3612 /* Main function. This is called by the real "main" function,
3613 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3615 static void ATTRIBUTE_NORETURN
3616 captured_main (int argc
, char *argv
[])
3621 const char *port
= NULL
;
3622 char **next_arg
= &argv
[1];
3623 volatile int multi_mode
= 0;
3624 volatile int attach
= 0;
3626 bool selftest
= false;
3627 const char *selftest_filter
= NULL
;
3629 while (*next_arg
!= NULL
&& **next_arg
== '-')
3631 if (strcmp (*next_arg
, "--version") == 0)
3633 gdbserver_version ();
3636 else if (strcmp (*next_arg
, "--help") == 0)
3638 gdbserver_usage (stdout
);
3641 else if (strcmp (*next_arg
, "--attach") == 0)
3643 else if (strcmp (*next_arg
, "--multi") == 0)
3645 else if (strcmp (*next_arg
, "--wrapper") == 0)
3652 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3654 wrapper_argv
+= *next_arg
;
3655 wrapper_argv
+= ' ';
3659 if (!wrapper_argv
.empty ())
3661 /* Erase the last whitespace. */
3662 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3665 if (next_arg
== tmp
|| *next_arg
== NULL
)
3667 gdbserver_usage (stderr
);
3671 /* Consume the "--". */
3674 else if (strcmp (*next_arg
, "--debug") == 0)
3676 else if (startswith (*next_arg
, "--debug-format="))
3679 = parse_debug_format_options ((*next_arg
)
3680 + sizeof ("--debug-format=") - 1, 0);
3682 if (error_msg
!= NULL
)
3684 fprintf (stderr
, "%s", error_msg
);
3688 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3690 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3692 gdbserver_show_disableable (stdout
);
3695 else if (startswith (*next_arg
, "--disable-packet="))
3697 char *packets
, *tok
;
3699 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3700 for (tok
= strtok (packets
, ",");
3702 tok
= strtok (NULL
, ","))
3704 if (strcmp ("vCont", tok
) == 0)
3705 disable_packet_vCont
= 1;
3706 else if (strcmp ("Tthread", tok
) == 0)
3707 disable_packet_Tthread
= 1;
3708 else if (strcmp ("qC", tok
) == 0)
3709 disable_packet_qC
= 1;
3710 else if (strcmp ("qfThreadInfo", tok
) == 0)
3711 disable_packet_qfThreadInfo
= 1;
3712 else if (strcmp ("threads", tok
) == 0)
3714 disable_packet_vCont
= 1;
3715 disable_packet_Tthread
= 1;
3716 disable_packet_qC
= 1;
3717 disable_packet_qfThreadInfo
= 1;
3721 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3723 gdbserver_show_disableable (stderr
);
3728 else if (strcmp (*next_arg
, "-") == 0)
3730 /* "-" specifies a stdio connection and is a form of port
3732 port
= STDIO_CONNECTION_NAME
;
3736 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3737 disable_randomization
= 1;
3738 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3739 disable_randomization
= 0;
3740 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3741 startup_with_shell
= true;
3742 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3743 startup_with_shell
= false;
3744 else if (strcmp (*next_arg
, "--once") == 0)
3746 else if (strcmp (*next_arg
, "--selftest") == 0)
3748 else if (startswith (*next_arg
, "--selftest="))
3751 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3755 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3768 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3771 gdbserver_usage (stderr
);
3775 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3776 opened by remote_prepare. */
3779 save_original_signals_state ();
3781 /* We need to know whether the remote connection is stdio before
3782 starting the inferior. Inferiors created in this scenario have
3783 stdin,stdout redirected. So do this here before we call
3786 remote_prepare (port
);
3791 /* --attach used to come after PORT, so allow it there for
3793 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3800 && (*next_arg
== NULL
3801 || (*next_arg
)[0] == '\0'
3802 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3804 || next_arg
[1] != NULL
))
3809 gdbserver_usage (stderr
);
3813 /* Gather information about the environment. */
3814 our_environ
= gdb_environ::from_host_environ ();
3816 initialize_async_io ();
3818 have_job_control ();
3819 initialize_event_loop ();
3820 if (target_supports_tracepoints ())
3821 initialize_tracepoint ();
3822 initialize_notif ();
3824 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3825 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3829 selftests::run_tests (selftest_filter
);
3830 throw_quit ("Quit");
3833 if (pid
== 0 && *next_arg
!= NULL
)
3837 n
= argc
- (next_arg
- argv
);
3838 program_name
= xstrdup (next_arg
[0]);
3839 for (i
= 1; i
< n
; i
++)
3840 program_args
.push_back (xstrdup (next_arg
[i
]));
3841 program_args
.push_back (NULL
);
3843 /* Wait till we are at first instruction in program. */
3844 create_inferior (program_name
, program_args
);
3846 /* We are now (hopefully) stopped at the first instruction of
3847 the target process. This assumes that the target process was
3848 successfully created. */
3852 if (attach_inferior (pid
) == -1)
3853 error ("Attaching not supported on this target");
3855 /* Otherwise succeeded. */
3859 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3860 last_status
.value
.integer
= 0;
3861 last_ptid
= minus_one_ptid
;
3863 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3865 /* Don't report shared library events on the initial connection,
3866 even if some libraries are preloaded. Avoids the "stopped by
3867 shared library event" notice on gdb side. */
3870 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3871 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3876 if (!was_running
&& !multi_mode
)
3877 error ("No program to debug");
3884 report_fork_events
= 0;
3885 report_vfork_events
= 0;
3886 report_exec_events
= 0;
3887 /* Be sure we're out of tfind mode. */
3888 current_traceframe
= -1;
3889 cont_thread
= null_ptid
;
3890 swbreak_feature
= 0;
3891 hwbreak_feature
= 0;
3892 vCont_supported
= 0;
3898 /* Wait for events. This will return when all event sources
3899 are removed from the event loop. */
3900 start_event_loop ();
3902 /* If an exit was requested (using the "monitor exit"
3903 command), terminate now. */
3905 throw_quit ("Quit");
3907 /* The only other way to get here is for getpkt to fail:
3909 - If --once was specified, we're done.
3911 - If not in extended-remote mode, and we're no longer
3912 debugging anything, simply exit: GDB has disconnected
3913 after processing the last process exit.
3915 - Otherwise, close the connection and reopen it at the
3917 if (run_once
|| (!extended_protocol
&& !target_running ()))
3918 throw_quit ("Quit");
3921 "Remote side has terminated connection. "
3922 "GDBserver will reopen the connection.\n");
3924 /* Get rid of any pending statuses. An eventual reconnection
3925 (by the same GDB instance or another) will refresh all its
3926 state from scratch. */
3927 discard_queued_stop_replies (minus_one_ptid
);
3928 for_each_inferior (&all_threads
,
3929 clear_pending_status_callback
);
3933 if (disconnected_tracing
)
3935 /* Try to enable non-stop/async mode, so we we can
3936 both wait for an async socket accept, and handle
3937 async target events simultaneously. There's also
3938 no point either in having the target always stop
3939 all threads, when we're going to pass signals
3940 down without informing GDB. */
3943 if (start_non_stop (1))
3946 /* Detaching implicitly resumes all threads;
3947 simply disconnecting does not. */
3953 "Disconnected tracing disabled; "
3954 "stopping trace run.\n");
3959 CATCH (exception
, RETURN_MASK_ERROR
)
3962 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3964 if (response_needed
)
3966 write_enn (own_buf
);
3971 throw_quit ("Quit");
3977 /* Main function. */
3980 main (int argc
, char *argv
[])
3985 captured_main (argc
, argv
);
3987 CATCH (exception
, RETURN_MASK_ALL
)
3989 if (exception
.reason
== RETURN_ERROR
)
3992 fprintf (stderr
, "%s\n", exception
.message
);
3993 fprintf (stderr
, "Exiting\n");
4001 gdb_assert_not_reached ("captured_main should never return");
4004 /* Process options coming from Z packets for a breakpoint. PACKET is
4005 the packet buffer. *PACKET is updated to point to the first char
4006 after the last processed option. */
4009 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4011 const char *dataptr
= *packet
;
4014 /* Check if data has the correct format. */
4015 if (*dataptr
!= ';')
4022 if (*dataptr
== ';')
4025 if (*dataptr
== 'X')
4027 /* Conditional expression. */
4029 debug_printf ("Found breakpoint condition.\n");
4030 if (!add_breakpoint_condition (bp
, &dataptr
))
4031 dataptr
= strchrnul (dataptr
, ';');
4033 else if (startswith (dataptr
, "cmds:"))
4035 dataptr
+= strlen ("cmds:");
4037 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4038 persist
= (*dataptr
== '1');
4040 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4041 dataptr
= strchrnul (dataptr
, ';');
4045 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4047 /* Skip tokens until we find one that we recognize. */
4048 dataptr
= strchrnul (dataptr
, ';');
4054 /* Event loop callback that handles a serial event. The first byte in
4055 the serial buffer gets us here. We expect characters to arrive at
4056 a brisk pace, so we read the rest of the packet with a blocking
4060 process_serial_event (void)
4068 int new_packet_len
= -1;
4070 disable_async_io ();
4072 response_needed
= 0;
4073 packet_len
= getpkt (own_buf
);
4074 if (packet_len
<= 0)
4077 /* Force an event loop break. */
4080 response_needed
= 1;
4082 char ch
= own_buf
[0];
4086 handle_query (own_buf
, packet_len
, &new_packet_len
);
4089 handle_general_set (own_buf
);
4092 handle_detach (own_buf
);
4095 extended_protocol
= 1;
4099 handle_status (own_buf
);
4102 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4104 require_running_or_break (own_buf
);
4106 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4108 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4109 thread_id
= null_ptid
;
4110 else if (thread_id
.is_pid ())
4112 /* The ptid represents a pid. */
4113 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4117 write_enn (own_buf
);
4121 thread_id
= thread
->entry
.id
;
4125 /* The ptid represents a lwp/tid. */
4126 if (find_thread_ptid (thread_id
) == NULL
)
4128 write_enn (own_buf
);
4133 if (own_buf
[1] == 'g')
4135 if (ptid_equal (thread_id
, null_ptid
))
4137 /* GDB is telling us to choose any thread. Check if
4138 the currently selected thread is still valid. If
4139 it is not, select the first available. */
4140 struct thread_info
*thread
=
4141 (struct thread_info
*) find_inferior_id (&all_threads
,
4144 thread
= get_first_thread ();
4145 thread_id
= thread
->entry
.id
;
4148 general_thread
= thread_id
;
4149 set_desired_thread ();
4150 gdb_assert (current_thread
!= NULL
);
4152 else if (own_buf
[1] == 'c')
4153 cont_thread
= thread_id
;
4159 /* Silently ignore it so that gdb can extend the protocol
4160 without compatibility headaches. */
4165 require_running_or_break (own_buf
);
4166 if (current_traceframe
>= 0)
4168 struct regcache
*regcache
4169 = new_register_cache (current_target_desc ());
4171 if (fetch_traceframe_registers (current_traceframe
,
4173 registers_to_string (regcache
, own_buf
);
4175 write_enn (own_buf
);
4176 free_register_cache (regcache
);
4180 struct regcache
*regcache
;
4182 if (!set_desired_thread ())
4183 write_enn (own_buf
);
4186 regcache
= get_thread_regcache (current_thread
, 1);
4187 registers_to_string (regcache
, own_buf
);
4192 require_running_or_break (own_buf
);
4193 if (current_traceframe
>= 0)
4194 write_enn (own_buf
);
4197 struct regcache
*regcache
;
4199 if (!set_desired_thread ())
4200 write_enn (own_buf
);
4203 regcache
= get_thread_regcache (current_thread
, 1);
4204 registers_from_string (regcache
, &own_buf
[1]);
4210 require_running_or_break (own_buf
);
4211 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4212 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4214 write_enn (own_buf
);
4216 bin2hex (mem_buf
, own_buf
, res
);
4219 require_running_or_break (own_buf
);
4220 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4221 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4224 write_enn (own_buf
);
4227 require_running_or_break (own_buf
);
4228 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4229 &mem_addr
, &len
, &mem_buf
) < 0
4230 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4231 write_enn (own_buf
);
4236 require_running_or_break (own_buf
);
4237 hex2bin (own_buf
+ 1, &sig
, 1);
4238 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4239 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4242 myresume (own_buf
, 0, signal
);
4245 require_running_or_break (own_buf
);
4246 hex2bin (own_buf
+ 1, &sig
, 1);
4247 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4248 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4251 myresume (own_buf
, 1, signal
);
4254 require_running_or_break (own_buf
);
4256 myresume (own_buf
, 0, signal
);
4259 require_running_or_break (own_buf
);
4261 myresume (own_buf
, 1, signal
);
4263 case 'Z': /* insert_ ... */
4265 case 'z': /* remove_ ... */
4270 char type
= own_buf
[1];
4272 const int insert
= ch
== 'Z';
4273 const char *p
= &own_buf
[3];
4275 p
= unpack_varlen_hex (p
, &addr
);
4276 kind
= strtol (p
+ 1, &dataptr
, 16);
4280 struct gdb_breakpoint
*bp
;
4282 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4287 /* GDB may have sent us a list of *point parameters to
4288 be evaluated on the target's side. Read such list
4289 here. If we already have a list of parameters, GDB
4290 is telling us to drop that list and use this one
4292 clear_breakpoint_conditions_and_commands (bp
);
4293 const char *options
= dataptr
;
4294 process_point_options (bp
, &options
);
4298 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4306 write_enn (own_buf
);
4310 response_needed
= 0;
4311 if (!target_running ())
4312 /* The packet we received doesn't make sense - but we can't
4313 reply to it, either. */
4316 fprintf (stderr
, "Killing all inferiors\n");
4317 for_each_inferior (&all_processes
, kill_inferior_callback
);
4319 /* When using the extended protocol, we wait with no program
4320 running. The traditional protocol will exit instead. */
4321 if (extended_protocol
)
4323 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4324 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4332 require_running_or_break (own_buf
);
4334 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4335 if (find_thread_ptid (thread_id
) == NULL
)
4337 write_enn (own_buf
);
4341 if (mythread_alive (thread_id
))
4344 write_enn (own_buf
);
4348 response_needed
= 0;
4350 /* Restarting the inferior is only supported in the extended
4352 if (extended_protocol
)
4354 if (target_running ())
4355 for_each_inferior (&all_processes
,
4356 kill_inferior_callback
);
4357 fprintf (stderr
, "GDBserver restarting\n");
4359 /* Wait till we are at 1st instruction in prog. */
4360 if (program_name
!= NULL
)
4362 create_inferior (program_name
, program_args
);
4364 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4366 /* Stopped at the first instruction of the target
4368 general_thread
= last_ptid
;
4372 /* Something went wrong. */
4373 general_thread
= null_ptid
;
4378 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4379 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4385 /* It is a request we don't understand. Respond with an
4386 empty packet so that gdb knows that we don't support this
4392 /* Extended (long) request. */
4393 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4397 /* It is a request we don't understand. Respond with an empty
4398 packet so that gdb knows that we don't support this
4404 if (new_packet_len
!= -1)
4405 putpkt_binary (own_buf
, new_packet_len
);
4409 response_needed
= 0;
4417 /* Event-loop callback for serial events. */
4420 handle_serial_event (int err
, gdb_client_data client_data
)
4423 debug_printf ("handling possible serial event\n");
4425 /* Really handle it. */
4426 if (process_serial_event () < 0)
4429 /* Be sure to not change the selected thread behind GDB's back.
4430 Important in the non-stop mode asynchronous protocol. */
4431 set_desired_thread ();
4436 /* Push a stop notification on the notification queue. */
4439 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4441 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4443 vstop_notif
->status
= *status
;
4444 vstop_notif
->ptid
= ptid
;
4445 /* Push Stop notification. */
4446 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4449 /* Event-loop callback for target events. */
4452 handle_target_event (int err
, gdb_client_data client_data
)
4455 debug_printf ("handling possible target event\n");
4457 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4460 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4462 if (gdb_connected () && report_no_resumed
)
4463 push_stop_notification (null_ptid
, &last_status
);
4465 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4467 int pid
= ptid_get_pid (last_ptid
);
4468 struct process_info
*process
= find_process_pid (pid
);
4469 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4471 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4472 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4474 mark_breakpoints_out (process
);
4475 target_mourn_inferior (last_ptid
);
4477 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4481 /* We're reporting this thread as stopped. Update its
4482 "want-stopped" state to what the client wants, until it
4483 gets a new resume action. */
4484 current_thread
->last_resume_kind
= resume_stop
;
4485 current_thread
->last_status
= last_status
;
4490 if (!target_running ())
4492 /* The last process exited. We're done. */
4496 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4497 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4498 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4502 /* A thread stopped with a signal, but gdb isn't
4503 connected to handle it. Pass it down to the
4504 inferior, as if it wasn't being traced. */
4505 enum gdb_signal signal
;
4508 debug_printf ("GDB not connected; forwarding event %d for"
4510 (int) last_status
.kind
,
4511 target_pid_to_str (last_ptid
));
4513 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4514 signal
= last_status
.value
.sig
;
4516 signal
= GDB_SIGNAL_0
;
4517 target_continue (last_ptid
, signal
);
4521 push_stop_notification (last_ptid
, &last_status
);
4524 /* Be sure to not change the selected thread behind GDB's back.
4525 Important in the non-stop mode asynchronous protocol. */
4526 set_desired_thread ();
4539 } // namespace selftests
4540 #endif /* GDB_SELF_TEST */