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 *const_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 (const_annex
[0] == '\0')
1443 if (current_thread
== NULL
)
1446 pid
= pid_of (current_thread
);
1450 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1452 strcpy (annex
, const_annex
);
1453 annex
= unpack_varlen_hex (annex
, &pid
);
1455 if (annex
[0] != '\0')
1462 file
= (*the_target
->pid_to_exec_file
) (pid
);
1466 total_len
= strlen (file
);
1468 if (offset
> total_len
)
1471 if (offset
+ len
> total_len
)
1472 len
= total_len
- offset
;
1474 memcpy (readbuf
, file
+ offset
, len
);
1478 /* Handle qXfer:features:read. */
1481 handle_qxfer_features (const char *annex
,
1482 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1483 ULONGEST offset
, LONGEST len
)
1485 const char *document
;
1488 if (writebuf
!= NULL
)
1491 if (!target_running ())
1494 /* Grab the correct annex. */
1495 document
= get_features_xml (annex
);
1496 if (document
== NULL
)
1499 total_len
= strlen (document
);
1501 if (offset
> total_len
)
1504 if (offset
+ len
> total_len
)
1505 len
= total_len
- offset
;
1507 memcpy (readbuf
, document
+ offset
, len
);
1511 /* Worker routine for handle_qxfer_libraries.
1512 Emit the XML to describe the library in INF. */
1515 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1517 struct dll_info
*dll
= (struct dll_info
*) inf
;
1518 std::string
*document
= (std::string
*) arg
;
1519 std::string name
= xml_escape_text (dll
->name
);
1521 *document
+= string_printf
1522 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1523 name
.c_str (), (long) dll
->base_addr
);
1526 /* Handle qXfer:libraries:read. */
1529 handle_qxfer_libraries (const char *annex
,
1530 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1531 ULONGEST offset
, LONGEST len
)
1533 if (writebuf
!= NULL
)
1536 if (annex
[0] != '\0' || current_thread
== NULL
)
1539 std::string document
= "<library-list version=\"1.0\">\n";
1541 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &document
);
1543 document
+= "</library-list>\n";
1545 if (offset
> document
.length ())
1548 if (offset
+ len
> document
.length ())
1549 len
= document
.length () - offset
;
1551 memcpy (readbuf
, &document
[offset
], len
);
1556 /* Handle qXfer:libraries-svr4:read. */
1559 handle_qxfer_libraries_svr4 (const char *annex
,
1560 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1561 ULONGEST offset
, LONGEST len
)
1563 if (writebuf
!= NULL
)
1566 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1569 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1572 /* Handle qXfer:osadata:read. */
1575 handle_qxfer_osdata (const char *annex
,
1576 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1577 ULONGEST offset
, LONGEST len
)
1579 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1582 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1585 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1588 handle_qxfer_siginfo (const char *annex
,
1589 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1590 ULONGEST offset
, LONGEST len
)
1592 if (the_target
->qxfer_siginfo
== NULL
)
1595 if (annex
[0] != '\0' || current_thread
== NULL
)
1598 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1601 /* Handle qXfer:spu:read and qXfer:spu:write. */
1604 handle_qxfer_spu (const char *annex
,
1605 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1606 ULONGEST offset
, LONGEST len
)
1608 if (the_target
->qxfer_spu
== NULL
)
1611 if (current_thread
== NULL
)
1614 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1617 /* Handle qXfer:statictrace:read. */
1620 handle_qxfer_statictrace (const char *annex
,
1621 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1622 ULONGEST offset
, LONGEST len
)
1626 if (writebuf
!= NULL
)
1629 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1632 if (traceframe_read_sdata (current_traceframe
, offset
,
1633 readbuf
, len
, &nbytes
))
1638 /* Helper for handle_qxfer_threads_proper.
1639 Emit the XML to describe the thread of INF. */
1642 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1644 struct thread_info
*thread
= (struct thread_info
*) inf
;
1645 struct buffer
*buffer
= (struct buffer
*) arg
;
1646 ptid_t ptid
= ptid_of (thread
);
1648 int core
= target_core_of_thread (ptid
);
1650 const char *name
= target_thread_name (ptid
);
1653 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1655 write_ptid (ptid_s
, ptid
);
1657 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1661 sprintf (core_s
, "%d", core
);
1662 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1666 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1670 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1671 bin2hex (handle
, handle_s
, handle_len
);
1672 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1675 buffer_xml_printf (buffer
, "/>\n");
1678 /* Helper for handle_qxfer_threads. */
1681 handle_qxfer_threads_proper (struct buffer
*buffer
)
1683 buffer_grow_str (buffer
, "<threads>\n");
1685 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1688 buffer_grow_str0 (buffer
, "</threads>\n");
1691 /* Handle qXfer:threads:read. */
1694 handle_qxfer_threads (const char *annex
,
1695 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1696 ULONGEST offset
, LONGEST len
)
1698 static char *result
= 0;
1699 static unsigned int result_length
= 0;
1701 if (writebuf
!= NULL
)
1704 if (annex
[0] != '\0')
1709 struct buffer buffer
;
1710 /* When asked for data at offset 0, generate everything and store into
1711 'result'. Successive reads will be served off 'result'. */
1715 buffer_init (&buffer
);
1717 handle_qxfer_threads_proper (&buffer
);
1719 result
= buffer_finish (&buffer
);
1720 result_length
= strlen (result
);
1721 buffer_free (&buffer
);
1724 if (offset
>= result_length
)
1726 /* We're out of data. */
1733 if (len
> result_length
- offset
)
1734 len
= result_length
- offset
;
1736 memcpy (readbuf
, result
+ offset
, len
);
1741 /* Handle qXfer:traceframe-info:read. */
1744 handle_qxfer_traceframe_info (const char *annex
,
1745 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1746 ULONGEST offset
, LONGEST len
)
1748 static char *result
= 0;
1749 static unsigned int result_length
= 0;
1751 if (writebuf
!= NULL
)
1754 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1759 struct buffer buffer
;
1761 /* When asked for data at offset 0, generate everything and
1762 store into 'result'. Successive reads will be served off
1766 buffer_init (&buffer
);
1768 traceframe_read_info (current_traceframe
, &buffer
);
1770 result
= buffer_finish (&buffer
);
1771 result_length
= strlen (result
);
1772 buffer_free (&buffer
);
1775 if (offset
>= result_length
)
1777 /* We're out of data. */
1784 if (len
> result_length
- offset
)
1785 len
= result_length
- offset
;
1787 memcpy (readbuf
, result
+ offset
, len
);
1791 /* Handle qXfer:fdpic:read. */
1794 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1795 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1797 if (the_target
->read_loadmap
== NULL
)
1800 if (current_thread
== NULL
)
1803 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1806 /* Handle qXfer:btrace:read. */
1809 handle_qxfer_btrace (const char *annex
,
1810 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1811 ULONGEST offset
, LONGEST len
)
1813 static struct buffer cache
;
1814 struct thread_info
*thread
;
1815 enum btrace_read_type type
;
1818 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1821 if (ptid_equal (general_thread
, null_ptid
)
1822 || ptid_equal (general_thread
, minus_one_ptid
))
1824 strcpy (own_buf
, "E.Must select a single thread.");
1828 thread
= find_thread_ptid (general_thread
);
1831 strcpy (own_buf
, "E.No such thread.");
1835 if (thread
->btrace
== NULL
)
1837 strcpy (own_buf
, "E.Btrace not enabled.");
1841 if (strcmp (annex
, "all") == 0)
1842 type
= BTRACE_READ_ALL
;
1843 else if (strcmp (annex
, "new") == 0)
1844 type
= BTRACE_READ_NEW
;
1845 else if (strcmp (annex
, "delta") == 0)
1846 type
= BTRACE_READ_DELTA
;
1849 strcpy (own_buf
, "E.Bad annex.");
1855 buffer_free (&cache
);
1857 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1860 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1864 else if (offset
> cache
.used_size
)
1866 buffer_free (&cache
);
1870 if (len
> cache
.used_size
- offset
)
1871 len
= cache
.used_size
- offset
;
1873 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1878 /* Handle qXfer:btrace-conf:read. */
1881 handle_qxfer_btrace_conf (const char *annex
,
1882 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1883 ULONGEST offset
, LONGEST len
)
1885 static struct buffer cache
;
1886 struct thread_info
*thread
;
1889 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1892 if (annex
[0] != '\0')
1895 if (ptid_equal (general_thread
, null_ptid
)
1896 || ptid_equal (general_thread
, minus_one_ptid
))
1898 strcpy (own_buf
, "E.Must select a single thread.");
1902 thread
= find_thread_ptid (general_thread
);
1905 strcpy (own_buf
, "E.No such thread.");
1909 if (thread
->btrace
== NULL
)
1911 strcpy (own_buf
, "E.Btrace not enabled.");
1917 buffer_free (&cache
);
1919 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1922 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1926 else if (offset
> cache
.used_size
)
1928 buffer_free (&cache
);
1932 if (len
> cache
.used_size
- offset
)
1933 len
= cache
.used_size
- offset
;
1935 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1940 static const struct qxfer qxfer_packets
[] =
1942 { "auxv", handle_qxfer_auxv
},
1943 { "btrace", handle_qxfer_btrace
},
1944 { "btrace-conf", handle_qxfer_btrace_conf
},
1945 { "exec-file", handle_qxfer_exec_file
},
1946 { "fdpic", handle_qxfer_fdpic
},
1947 { "features", handle_qxfer_features
},
1948 { "libraries", handle_qxfer_libraries
},
1949 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1950 { "osdata", handle_qxfer_osdata
},
1951 { "siginfo", handle_qxfer_siginfo
},
1952 { "spu", handle_qxfer_spu
},
1953 { "statictrace", handle_qxfer_statictrace
},
1954 { "threads", handle_qxfer_threads
},
1955 { "traceframe-info", handle_qxfer_traceframe_info
},
1959 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1967 if (!startswith (own_buf
, "qXfer:"))
1970 /* Grab the object, r/w and annex. */
1971 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1973 write_enn (own_buf
);
1978 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1981 const struct qxfer
*q
= &qxfer_packets
[i
];
1983 if (strcmp (object
, q
->object
) == 0)
1985 if (strcmp (rw
, "read") == 0)
1987 unsigned char *data
;
1992 /* Grab the offset and length. */
1993 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1995 write_enn (own_buf
);
1999 /* Read one extra byte, as an indicator of whether there is
2001 if (len
> PBUFSIZ
- 2)
2003 data
= (unsigned char *) malloc (len
+ 1);
2006 write_enn (own_buf
);
2009 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2017 /* Preserve error message. */
2020 write_enn (own_buf
);
2022 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2024 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2029 else if (strcmp (rw
, "write") == 0)
2034 unsigned char *data
;
2036 strcpy (own_buf
, "E00");
2037 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2040 write_enn (own_buf
);
2043 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2044 &ofs
, &len
, data
) < 0)
2047 write_enn (own_buf
);
2051 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2059 /* Preserve error message. */
2062 write_enn (own_buf
);
2064 sprintf (own_buf
, "%x", n
);
2077 /* Compute 32 bit CRC from inferior memory.
2079 On success, return 32 bit CRC.
2080 On failure, return (unsigned long long) -1. */
2082 static unsigned long long
2083 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2087 unsigned char byte
= 0;
2089 /* Return failure if memory read fails. */
2090 if (read_inferior_memory (base
, &byte
, 1) != 0)
2091 return (unsigned long long) -1;
2093 crc
= xcrc32 (&byte
, 1, crc
);
2096 return (unsigned long long) crc
;
2099 /* Add supported btrace packets to BUF. */
2102 supported_btrace_packets (char *buf
)
2104 int btrace_supported
= 0;
2106 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2108 strcat (buf
, ";Qbtrace:bts+");
2109 strcat (buf
, ";Qbtrace-conf:bts:size+");
2111 btrace_supported
= 1;
2114 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2116 strcat (buf
, ";Qbtrace:pt+");
2117 strcat (buf
, ";Qbtrace-conf:pt:size+");
2119 btrace_supported
= 1;
2122 if (!btrace_supported
)
2125 strcat (buf
, ";Qbtrace:off+");
2126 strcat (buf
, ";qXfer:btrace:read+");
2127 strcat (buf
, ";qXfer:btrace-conf:read+");
2130 /* Handle all of the extended 'q' packets. */
2133 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2135 static struct inferior_list_entry
*thread_ptr
;
2137 /* Reply the current thread id. */
2138 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2141 require_running_or_return (own_buf
);
2143 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2144 ptid
= general_thread
;
2147 thread_ptr
= get_first_inferior (&all_threads
);
2148 ptid
= thread_ptr
->id
;
2151 sprintf (own_buf
, "QC");
2153 write_ptid (own_buf
, ptid
);
2157 if (strcmp ("qSymbol::", own_buf
) == 0)
2159 struct thread_info
*save_thread
= current_thread
;
2161 /* For qSymbol, GDB only changes the current thread if the
2162 previous current thread was of a different process. So if
2163 the previous thread is gone, we need to pick another one of
2164 the same process. This can happen e.g., if we followed an
2165 exec in a non-leader thread. */
2166 if (current_thread
== NULL
)
2169 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2171 /* Just in case, if we didn't find a thread, then bail out
2172 instead of crashing. */
2173 if (current_thread
== NULL
)
2175 write_enn (own_buf
);
2176 current_thread
= save_thread
;
2181 /* GDB is suggesting new symbols have been loaded. This may
2182 mean a new shared library has been detected as loaded, so
2183 take the opportunity to check if breakpoints we think are
2184 inserted, still are. Note that it isn't guaranteed that
2185 we'll see this when a shared library is loaded, and nor will
2186 we see this for unloads (although breakpoints in unloaded
2187 libraries shouldn't trigger), as GDB may not find symbols for
2188 the library at all. We also re-validate breakpoints when we
2189 see a second GDB breakpoint for the same address, and or when
2190 we access breakpoint shadows. */
2191 validate_breakpoints ();
2193 if (target_supports_tracepoints ())
2194 tracepoint_look_up_symbols ();
2196 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2197 (*the_target
->look_up_symbols
) ();
2199 current_thread
= save_thread
;
2201 strcpy (own_buf
, "OK");
2205 if (!disable_packet_qfThreadInfo
)
2207 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2209 require_running_or_return (own_buf
);
2210 thread_ptr
= get_first_inferior (&all_threads
);
2213 write_ptid (own_buf
, thread_ptr
->id
);
2214 thread_ptr
= thread_ptr
->next
;
2218 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2220 require_running_or_return (own_buf
);
2221 if (thread_ptr
!= NULL
)
2224 write_ptid (own_buf
, thread_ptr
->id
);
2225 thread_ptr
= thread_ptr
->next
;
2230 sprintf (own_buf
, "l");
2236 if (the_target
->read_offsets
!= NULL
2237 && strcmp ("qOffsets", own_buf
) == 0)
2239 CORE_ADDR text
, data
;
2241 require_running_or_return (own_buf
);
2242 if (the_target
->read_offsets (&text
, &data
))
2243 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2244 (long)text
, (long)data
, (long)data
);
2246 write_enn (own_buf
);
2251 /* Protocol features query. */
2252 if (startswith (own_buf
, "qSupported")
2253 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2255 char *p
= &own_buf
[10];
2256 int gdb_supports_qRelocInsn
= 0;
2258 /* Process each feature being provided by GDB. The first
2259 feature will follow a ':', and latter features will follow
2263 char **qsupported
= NULL
;
2268 /* Two passes, to avoid nested strtok calls in
2269 target_process_qsupported. */
2270 for (p
= strtok (p
+ 1, ";");
2272 p
= strtok (NULL
, ";"))
2275 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2276 qsupported
[count
- 1] = xstrdup (p
);
2279 for (i
= 0; i
< count
; i
++)
2282 if (strcmp (p
, "multiprocess+") == 0)
2284 /* GDB supports and wants multi-process support if
2286 if (target_supports_multi_process ())
2289 else if (strcmp (p
, "qRelocInsn+") == 0)
2291 /* GDB supports relocate instruction requests. */
2292 gdb_supports_qRelocInsn
= 1;
2294 else if (strcmp (p
, "swbreak+") == 0)
2296 /* GDB wants us to report whether a trap is caused
2297 by a software breakpoint and for us to handle PC
2298 adjustment if necessary on this target. */
2299 if (target_supports_stopped_by_sw_breakpoint ())
2300 swbreak_feature
= 1;
2302 else if (strcmp (p
, "hwbreak+") == 0)
2304 /* GDB wants us to report whether a trap is caused
2305 by a hardware breakpoint. */
2306 if (target_supports_stopped_by_hw_breakpoint ())
2307 hwbreak_feature
= 1;
2309 else if (strcmp (p
, "fork-events+") == 0)
2311 /* GDB supports and wants fork events if possible. */
2312 if (target_supports_fork_events ())
2313 report_fork_events
= 1;
2315 else if (strcmp (p
, "vfork-events+") == 0)
2317 /* GDB supports and wants vfork events if possible. */
2318 if (target_supports_vfork_events ())
2319 report_vfork_events
= 1;
2321 else if (strcmp (p
, "exec-events+") == 0)
2323 /* GDB supports and wants exec events if possible. */
2324 if (target_supports_exec_events ())
2325 report_exec_events
= 1;
2327 else if (strcmp (p
, "vContSupported+") == 0)
2328 vCont_supported
= 1;
2329 else if (strcmp (p
, "QThreadEvents+") == 0)
2331 else if (strcmp (p
, "no-resumed+") == 0)
2333 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2335 report_no_resumed
= 1;
2339 /* Move the unknown features all together. */
2340 qsupported
[i
] = NULL
;
2341 qsupported
[unknown
] = p
;
2346 /* Give the target backend a chance to process the unknown
2348 target_process_qsupported (qsupported
, unknown
);
2350 for (i
= 0; i
< count
; i
++)
2351 free (qsupported
[i
]);
2356 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2357 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2358 "QEnvironmentReset+;QEnvironmentUnset+",
2361 if (target_supports_catch_syscall ())
2362 strcat (own_buf
, ";QCatchSyscalls+");
2364 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2365 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2366 ";augmented-libraries-svr4-read+");
2369 /* We do not have any hook to indicate whether the non-SVR4 target
2370 backend supports qXfer:libraries:read, so always report it. */
2371 strcat (own_buf
, ";qXfer:libraries:read+");
2374 if (the_target
->read_auxv
!= NULL
)
2375 strcat (own_buf
, ";qXfer:auxv:read+");
2377 if (the_target
->qxfer_spu
!= NULL
)
2378 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2380 if (the_target
->qxfer_siginfo
!= NULL
)
2381 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2383 if (the_target
->read_loadmap
!= NULL
)
2384 strcat (own_buf
, ";qXfer:fdpic:read+");
2386 /* We always report qXfer:features:read, as targets may
2387 install XML files on a subsequent call to arch_setup.
2388 If we reported to GDB on startup that we don't support
2389 qXfer:feature:read at all, we will never be re-queried. */
2390 strcat (own_buf
, ";qXfer:features:read+");
2392 if (transport_is_reliable
)
2393 strcat (own_buf
, ";QStartNoAckMode+");
2395 if (the_target
->qxfer_osdata
!= NULL
)
2396 strcat (own_buf
, ";qXfer:osdata:read+");
2398 if (target_supports_multi_process ())
2399 strcat (own_buf
, ";multiprocess+");
2401 if (target_supports_fork_events ())
2402 strcat (own_buf
, ";fork-events+");
2404 if (target_supports_vfork_events ())
2405 strcat (own_buf
, ";vfork-events+");
2407 if (target_supports_exec_events ())
2408 strcat (own_buf
, ";exec-events+");
2410 if (target_supports_non_stop ())
2411 strcat (own_buf
, ";QNonStop+");
2413 if (target_supports_disable_randomization ())
2414 strcat (own_buf
, ";QDisableRandomization+");
2416 strcat (own_buf
, ";qXfer:threads:read+");
2418 if (target_supports_tracepoints ())
2420 strcat (own_buf
, ";ConditionalTracepoints+");
2421 strcat (own_buf
, ";TraceStateVariables+");
2422 strcat (own_buf
, ";TracepointSource+");
2423 strcat (own_buf
, ";DisconnectedTracing+");
2424 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2425 strcat (own_buf
, ";FastTracepoints+");
2426 strcat (own_buf
, ";StaticTracepoints+");
2427 strcat (own_buf
, ";InstallInTrace+");
2428 strcat (own_buf
, ";qXfer:statictrace:read+");
2429 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2430 strcat (own_buf
, ";EnableDisableTracepoints+");
2431 strcat (own_buf
, ";QTBuffer:size+");
2432 strcat (own_buf
, ";tracenz+");
2435 if (target_supports_hardware_single_step ()
2436 || target_supports_software_single_step () )
2438 strcat (own_buf
, ";ConditionalBreakpoints+");
2440 strcat (own_buf
, ";BreakpointCommands+");
2442 if (target_supports_agent ())
2443 strcat (own_buf
, ";QAgent+");
2445 supported_btrace_packets (own_buf
);
2447 if (target_supports_stopped_by_sw_breakpoint ())
2448 strcat (own_buf
, ";swbreak+");
2450 if (target_supports_stopped_by_hw_breakpoint ())
2451 strcat (own_buf
, ";hwbreak+");
2453 if (the_target
->pid_to_exec_file
!= NULL
)
2454 strcat (own_buf
, ";qXfer:exec-file:read+");
2456 strcat (own_buf
, ";vContSupported+");
2458 strcat (own_buf
, ";QThreadEvents+");
2460 strcat (own_buf
, ";no-resumed+");
2462 /* Reinitialize components as needed for the new connection. */
2463 hostio_handle_new_gdb_connection ();
2464 target_handle_new_gdb_connection ();
2469 /* Thread-local storage support. */
2470 if (the_target
->get_tls_address
!= NULL
2471 && startswith (own_buf
, "qGetTLSAddr:"))
2473 char *p
= own_buf
+ 12;
2474 CORE_ADDR parts
[2], address
= 0;
2476 ptid_t ptid
= null_ptid
;
2478 require_running_or_return (own_buf
);
2480 for (i
= 0; i
< 3; i
++)
2488 p2
= strchr (p
, ',');
2501 ptid
= read_ptid (p
, NULL
);
2503 decode_address (&parts
[i
- 1], p
, len
);
2507 if (p
!= NULL
|| i
< 3)
2511 struct thread_info
*thread
= find_thread_ptid (ptid
);
2516 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2522 strcpy (own_buf
, paddress(address
));
2527 write_enn (own_buf
);
2531 /* Otherwise, pretend we do not understand this packet. */
2534 /* Windows OS Thread Information Block address support. */
2535 if (the_target
->get_tib_address
!= NULL
2536 && startswith (own_buf
, "qGetTIBAddr:"))
2541 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2543 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2546 strcpy (own_buf
, paddress(tlb
));
2551 write_enn (own_buf
);
2557 /* Handle "monitor" commands. */
2558 if (startswith (own_buf
, "qRcmd,"))
2560 char *mon
= (char *) malloc (PBUFSIZ
);
2561 int len
= strlen (own_buf
+ 6);
2565 write_enn (own_buf
);
2570 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2572 write_enn (own_buf
);
2576 mon
[len
/ 2] = '\0';
2580 if (the_target
->handle_monitor_command
== NULL
2581 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2582 /* Default processing. */
2583 handle_monitor_command (mon
, own_buf
);
2589 if (startswith (own_buf
, "qSearch:memory:"))
2591 require_running_or_return (own_buf
);
2592 handle_search_memory (own_buf
, packet_len
);
2596 if (strcmp (own_buf
, "qAttached") == 0
2597 || startswith (own_buf
, "qAttached:"))
2599 struct process_info
*process
;
2601 if (own_buf
[sizeof ("qAttached") - 1])
2603 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2604 process
= (struct process_info
*)
2605 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2609 require_running_or_return (own_buf
);
2610 process
= current_process ();
2613 if (process
== NULL
)
2615 write_enn (own_buf
);
2619 strcpy (own_buf
, process
->attached
? "1" : "0");
2623 if (startswith (own_buf
, "qCRC:"))
2625 /* CRC check (compare-section). */
2629 unsigned long long crc
;
2631 require_running_or_return (own_buf
);
2632 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2633 if (*comma
++ != ',')
2635 write_enn (own_buf
);
2638 len
= strtoul (comma
, NULL
, 16);
2639 crc
= crc32 (base
, len
, 0xffffffff);
2640 /* Check for memory failure. */
2641 if (crc
== (unsigned long long) -1)
2643 write_enn (own_buf
);
2646 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2650 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2653 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2656 /* Otherwise we didn't know what packet it was. Say we didn't
2661 static void gdb_wants_all_threads_stopped (void);
2662 static void resume (struct thread_resume
*actions
, size_t n
);
2664 /* The callback that is passed to visit_actioned_threads. */
2665 typedef int (visit_actioned_threads_callback_ftype
)
2666 (const struct thread_resume
*, struct thread_info
*);
2668 /* Struct to pass data to visit_actioned_threads. */
2670 struct visit_actioned_threads_data
2672 const struct thread_resume
*actions
;
2674 visit_actioned_threads_callback_ftype
*callback
;
2677 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2678 true if CALLBACK returns true. Returns false if no matching thread
2679 is found or CALLBACK results false.
2680 Note: This function is itself a callback for find_inferior. */
2683 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2685 struct visit_actioned_threads_data
*data
2686 = (struct visit_actioned_threads_data
*) datap
;
2687 const struct thread_resume
*actions
= data
->actions
;
2688 size_t num_actions
= data
->num_actions
;
2689 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2692 for (i
= 0; i
< num_actions
; i
++)
2694 const struct thread_resume
*action
= &actions
[i
];
2696 if (ptid_equal (action
->thread
, minus_one_ptid
)
2697 || ptid_equal (action
->thread
, entry
->id
)
2698 || ((ptid_get_pid (action
->thread
)
2699 == ptid_get_pid (entry
->id
))
2700 && ptid_get_lwp (action
->thread
) == -1))
2702 struct thread_info
*thread
= (struct thread_info
*) entry
;
2704 if ((*callback
) (action
, thread
))
2712 /* Callback for visit_actioned_threads. If the thread has a pending
2713 status to report, report it now. */
2716 handle_pending_status (const struct thread_resume
*resumption
,
2717 struct thread_info
*thread
)
2719 if (thread
->status_pending_p
)
2721 thread
->status_pending_p
= 0;
2723 last_status
= thread
->last_status
;
2724 last_ptid
= thread
->entry
.id
;
2725 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2731 /* Parse vCont packets. */
2733 handle_v_cont (char *own_buf
)
2737 struct thread_resume
*resume_info
;
2738 struct thread_resume default_action
{ null_ptid
};
2740 /* Count the number of semicolons in the packet. There should be one
2741 for every action. */
2747 p
= strchr (p
, ';');
2750 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2751 if (resume_info
== NULL
)
2759 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2761 if (p
[0] == 's' || p
[0] == 'S')
2762 resume_info
[i
].kind
= resume_step
;
2763 else if (p
[0] == 'r')
2764 resume_info
[i
].kind
= resume_step
;
2765 else if (p
[0] == 'c' || p
[0] == 'C')
2766 resume_info
[i
].kind
= resume_continue
;
2767 else if (p
[0] == 't')
2768 resume_info
[i
].kind
= resume_stop
;
2772 if (p
[0] == 'S' || p
[0] == 'C')
2775 sig
= strtol (p
+ 1, &q
, 16);
2780 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2782 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2784 else if (p
[0] == 'r')
2788 p
= unpack_varlen_hex (p
+ 1, &addr
);
2789 resume_info
[i
].step_range_start
= addr
;
2794 p
= unpack_varlen_hex (p
+ 1, &addr
);
2795 resume_info
[i
].step_range_end
= addr
;
2804 resume_info
[i
].thread
= minus_one_ptid
;
2805 default_action
= resume_info
[i
];
2807 /* Note: we don't increment i here, we'll overwrite this entry
2808 the next time through. */
2810 else if (p
[0] == ':')
2812 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2817 if (p
[0] != ';' && p
[0] != 0)
2820 resume_info
[i
].thread
= ptid
;
2827 resume_info
[i
] = default_action
;
2829 resume (resume_info
, n
);
2834 write_enn (own_buf
);
2839 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2842 resume (struct thread_resume
*actions
, size_t num_actions
)
2846 /* Check if among the threads that GDB wants actioned, there's
2847 one with a pending status to report. If so, skip actually
2848 resuming/stopping and report the pending event
2850 struct visit_actioned_threads_data data
;
2852 data
.actions
= actions
;
2853 data
.num_actions
= num_actions
;
2854 data
.callback
= handle_pending_status
;
2855 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2861 (*the_target
->resume
) (actions
, num_actions
);
2867 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2869 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2870 && !report_no_resumed
)
2872 /* The client does not support this stop reply. At least
2874 sprintf (own_buf
, "E.No unwaited-for children left.");
2875 disable_async_io ();
2879 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2880 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2881 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2882 current_thread
->last_status
= last_status
;
2884 /* From the client's perspective, all-stop mode always stops all
2885 threads implicitly (and the target backend has already done
2886 so by now). Tag all threads as "want-stopped", so we don't
2887 resume them implicitly without the client telling us to. */
2888 gdb_wants_all_threads_stopped ();
2889 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2890 disable_async_io ();
2892 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2893 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2894 target_mourn_inferior (last_ptid
);
2898 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2900 handle_v_attach (char *own_buf
)
2904 pid
= strtol (own_buf
+ 8, NULL
, 16);
2905 if (pid
!= 0 && attach_inferior (pid
) == 0)
2907 /* Don't report shared library events after attaching, even if
2908 some libraries are preloaded. GDB will always poll the
2909 library list. Avoids the "stopped by shared library event"
2910 notice on the GDB side. */
2915 /* In non-stop, we don't send a resume reply. Stop events
2916 will follow up using the normal notification
2921 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2927 write_enn (own_buf
);
2932 /* Run a new program. Return 1 if successful, 0 if failure. */
2934 handle_v_run (char *own_buf
)
2937 std::vector
<char *> new_argv
;
2938 char *new_program_name
= NULL
;
2942 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2948 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2950 next_p
= strchr (p
, ';');
2952 next_p
= p
+ strlen (p
);
2954 if (i
== 0 && p
== next_p
)
2956 /* No program specified. */
2957 new_program_name
= NULL
;
2959 else if (p
== next_p
)
2961 /* Empty argument. */
2962 new_argv
.push_back (xstrdup ("''"));
2966 size_t len
= (next_p
- p
) / 2;
2967 /* ARG is the unquoted argument received via the RSP. */
2968 char *arg
= (char *) xmalloc (len
+ 1);
2969 /* FULL_ARGS will contain the quoted version of ARG. */
2970 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2971 /* These are pointers used to navigate the strings above. */
2972 char *tmp_arg
= arg
;
2973 char *tmp_full_arg
= full_arg
;
2976 hex2bin (p
, (gdb_byte
*) arg
, len
);
2979 while (*tmp_arg
!= '\0')
2985 *tmp_full_arg
= '\'';
2991 /* Quote single quote. */
2992 *tmp_full_arg
= '\\';
3000 *tmp_full_arg
= *tmp_arg
;
3006 *tmp_full_arg
++ = '\'';
3008 /* Finish FULL_ARG and push it into the vector containing
3010 *tmp_full_arg
= '\0';
3012 new_program_name
= full_arg
;
3014 new_argv
.push_back (full_arg
);
3020 new_argv
.push_back (NULL
);
3022 if (new_program_name
== NULL
)
3024 /* GDB didn't specify a program to run. Use the program from the
3025 last run with the new argument list. */
3026 if (program_name
== NULL
)
3028 write_enn (own_buf
);
3029 free_vector_argv (new_argv
);
3035 xfree (program_name
);
3036 program_name
= new_program_name
;
3039 /* Free the old argv and install the new one. */
3040 free_vector_argv (program_args
);
3041 program_args
= new_argv
;
3043 create_inferior (program_name
, program_args
);
3045 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3047 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3049 /* In non-stop, sending a resume reply doesn't set the general
3050 thread, but GDB assumes a vRun sets it (this is so GDB can
3051 query which is the main thread of the new inferior. */
3053 general_thread
= last_ptid
;
3059 write_enn (own_buf
);
3064 /* Kill process. Return 1 if successful, 0 if failure. */
3066 handle_v_kill (char *own_buf
)
3069 char *p
= &own_buf
[6];
3071 pid
= strtol (p
, NULL
, 16);
3074 if (pid
!= 0 && kill_inferior (pid
) == 0)
3076 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3077 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3078 last_ptid
= pid_to_ptid (pid
);
3079 discard_queued_stop_replies (last_ptid
);
3085 write_enn (own_buf
);
3090 /* Handle all of the extended 'v' packets. */
3092 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3094 if (!disable_packet_vCont
)
3096 if (strcmp (own_buf
, "vCtrlC") == 0)
3098 (*the_target
->request_interrupt
) ();
3103 if (startswith (own_buf
, "vCont;"))
3105 handle_v_cont (own_buf
);
3109 if (startswith (own_buf
, "vCont?"))
3111 strcpy (own_buf
, "vCont;c;C;t");
3113 if (target_supports_hardware_single_step ()
3114 || target_supports_software_single_step ()
3115 || !vCont_supported
)
3117 /* If target supports single step either by hardware or by
3118 software, add actions s and S to the list of supported
3119 actions. On the other hand, if GDB doesn't request the
3120 supported vCont actions in qSupported packet, add s and
3121 S to the list too. */
3122 own_buf
= own_buf
+ strlen (own_buf
);
3123 strcpy (own_buf
, ";s;S");
3126 if (target_supports_range_stepping ())
3128 own_buf
= own_buf
+ strlen (own_buf
);
3129 strcpy (own_buf
, ";r");
3135 if (startswith (own_buf
, "vFile:")
3136 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3139 if (startswith (own_buf
, "vAttach;"))
3141 if ((!extended_protocol
|| !multi_process
) && target_running ())
3143 fprintf (stderr
, "Already debugging a process\n");
3144 write_enn (own_buf
);
3147 handle_v_attach (own_buf
);
3151 if (startswith (own_buf
, "vRun;"))
3153 if ((!extended_protocol
|| !multi_process
) && target_running ())
3155 fprintf (stderr
, "Already debugging a process\n");
3156 write_enn (own_buf
);
3159 handle_v_run (own_buf
);
3163 if (startswith (own_buf
, "vKill;"))
3165 if (!target_running ())
3167 fprintf (stderr
, "No process to kill\n");
3168 write_enn (own_buf
);
3171 handle_v_kill (own_buf
);
3175 if (handle_notif_ack (own_buf
, packet_len
))
3178 /* Otherwise we didn't know what packet it was. Say we didn't
3184 /* Resume thread and wait for another event. In non-stop mode,
3185 don't really wait here, but return immediatelly to the event
3188 myresume (char *own_buf
, int step
, int sig
)
3190 struct thread_resume resume_info
[2];
3192 int valid_cont_thread
;
3194 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3195 && !ptid_equal (cont_thread
, minus_one_ptid
));
3197 if (step
|| sig
|| valid_cont_thread
)
3199 resume_info
[0].thread
= current_ptid
;
3201 resume_info
[0].kind
= resume_step
;
3203 resume_info
[0].kind
= resume_continue
;
3204 resume_info
[0].sig
= sig
;
3208 if (!valid_cont_thread
)
3210 resume_info
[n
].thread
= minus_one_ptid
;
3211 resume_info
[n
].kind
= resume_continue
;
3212 resume_info
[n
].sig
= 0;
3216 resume (resume_info
, n
);
3219 /* Callback for for_each_inferior. Make a new stop reply for each
3223 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3225 struct thread_info
*thread
= (struct thread_info
*) entry
;
3227 /* For now, assume targets that don't have this callback also don't
3228 manage the thread's last_status field. */
3229 if (the_target
->thread_stopped
== NULL
)
3231 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3233 new_notif
->ptid
= entry
->id
;
3234 new_notif
->status
= thread
->last_status
;
3235 /* Pass the last stop reply back to GDB, but don't notify
3237 notif_event_enque (¬if_stop
,
3238 (struct notif_event
*) new_notif
);
3242 if (thread_stopped (thread
))
3246 std::string status_string
3247 = target_waitstatus_to_string (&thread
->last_status
);
3249 debug_printf ("Reporting thread %s as already stopped with %s\n",
3250 target_pid_to_str (entry
->id
),
3251 status_string
.c_str ());
3254 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3256 /* Pass the last stop reply back to GDB, but don't notify
3258 queue_stop_reply (entry
->id
, &thread
->last_status
);
3265 /* Set this inferior threads's state as "want-stopped". We won't
3266 resume this thread until the client gives us another action for
3270 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3272 struct thread_info
*thread
= (struct thread_info
*) entry
;
3274 thread
->last_resume_kind
= resume_stop
;
3276 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3278 /* Most threads are stopped implicitly (all-stop); tag that with
3280 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3281 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3285 /* Set all threads' states as "want-stopped". */
3288 gdb_wants_all_threads_stopped (void)
3290 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3293 /* Clear the gdb_detached flag of every process. */
3296 gdb_reattached_process (struct inferior_list_entry
*entry
)
3298 struct process_info
*process
= (struct process_info
*) entry
;
3300 process
->gdb_detached
= 0;
3303 /* Callback for for_each_inferior. Clear the thread's pending status
3307 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3309 struct thread_info
*thread
= (struct thread_info
*) entry
;
3311 thread
->status_pending_p
= 0;
3314 /* Callback for for_each_inferior. If the thread is stopped with an
3315 interesting event, mark it as having a pending event. */
3318 set_pending_status_callback (struct inferior_list_entry
*entry
)
3320 struct thread_info
*thread
= (struct thread_info
*) entry
;
3322 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3323 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3324 /* A breakpoint, watchpoint or finished step from a previous
3325 GDB run isn't considered interesting for a new GDB run.
3326 If we left those pending, the new GDB could consider them
3327 random SIGTRAPs. This leaves out real async traps. We'd
3328 have to peek into the (target-specific) siginfo to
3329 distinguish those. */
3330 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3331 thread
->status_pending_p
= 1;
3334 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3335 pending status to report to GDB. */
3338 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3340 struct thread_info
*thread
= (struct thread_info
*) entry
;
3342 return thread
->status_pending_p
;
3345 /* Status handler for the '?' packet. */
3348 handle_status (char *own_buf
)
3350 /* GDB is connected, don't forward events to the target anymore. */
3351 for_each_inferior (&all_processes
, gdb_reattached_process
);
3353 /* In non-stop mode, we must send a stop reply for each stopped
3354 thread. In all-stop mode, just send one for the first stopped
3359 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3361 /* The first is sent immediatly. OK is sent if there is no
3362 stopped thread, which is the same handling of the vStopped
3363 packet (by design). */
3364 notif_write_event (¬if_stop
, own_buf
);
3368 struct inferior_list_entry
*thread
= NULL
;
3371 stabilize_threads ();
3372 gdb_wants_all_threads_stopped ();
3374 /* We can only report one status, but we might be coming out of
3375 non-stop -- if more than one thread is stopped with
3376 interesting events, leave events for the threads we're not
3377 reporting now pending. They'll be reported the next time the
3378 threads are resumed. Start by marking all interesting events
3380 for_each_inferior (&all_threads
, set_pending_status_callback
);
3382 /* Prefer the last thread that reported an event to GDB (even if
3383 that was a GDB_SIGNAL_TRAP). */
3384 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3385 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3386 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3387 thread
= find_inferior_id (&all_threads
, last_ptid
);
3389 /* If the last event thread is not found for some reason, look
3390 for some other thread that might have an event to report. */
3392 thread
= find_inferior (&all_threads
,
3393 find_status_pending_thread_callback
, NULL
);
3395 /* If we're still out of luck, simply pick the first thread in
3398 thread
= get_first_inferior (&all_threads
);
3402 struct thread_info
*tp
= (struct thread_info
*) thread
;
3404 /* We're reporting this event, so it's no longer
3406 tp
->status_pending_p
= 0;
3408 /* GDB assumes the current thread is the thread we're
3409 reporting the status for. */
3410 general_thread
= thread
->id
;
3411 set_desired_thread ();
3413 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3414 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3417 strcpy (own_buf
, "W00");
3422 gdbserver_version (void)
3424 printf ("GNU gdbserver %s%s\n"
3425 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3426 "gdbserver is free software, covered by the "
3427 "GNU General Public License.\n"
3428 "This gdbserver was configured as \"%s\"\n",
3429 PKGVERSION
, version
, host_name
);
3433 gdbserver_usage (FILE *stream
)
3435 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3436 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3437 "\tgdbserver [OPTIONS] --multi COMM\n"
3439 "COMM may either be a tty device (for serial debugging),\n"
3440 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3441 "stdin/stdout of gdbserver.\n"
3442 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3443 "PID is the process ID to attach to, when --attach is specified.\n"
3445 "Operating modes:\n"
3447 " --attach Attach to running process PID.\n"
3448 " --multi Start server without a specific program, and\n"
3449 " only quit when explicitly commanded.\n"
3450 " --once Exit after the first connection has closed.\n"
3451 " --help Print this message and then exit.\n"
3452 " --version Display version information and exit.\n"
3456 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3457 " --disable-randomization\n"
3458 " Run PROG with address space randomization disabled.\n"
3459 " --no-disable-randomization\n"
3460 " Don't disable address space randomization when\n"
3462 " --startup-with-shell\n"
3463 " Start PROG using a shell. I.e., execs a shell that\n"
3464 " then execs PROG. (default)\n"
3465 " --no-startup-with-shell\n"
3466 " Exec PROG directly instead of using a shell.\n"
3467 " Disables argument globbing and variable substitution\n"
3468 " on UNIX-like systems.\n"
3472 " --debug Enable general debugging output.\n"
3473 " --debug-format=opt1[,opt2,...]\n"
3474 " Specify extra content in debugging output.\n"
3479 " --remote-debug Enable remote protocol debugging output.\n"
3480 " --disable-packet=opt1[,opt2,...]\n"
3481 " Disable support for RSP packets or features.\n"
3483 " vCont, Tthread, qC, qfThreadInfo and \n"
3484 " threads (disable all threading packets).\n"
3486 "For more information, consult the GDB manual (available as on-line \n"
3487 "info or a printed manual).\n");
3488 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3489 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3493 gdbserver_show_disableable (FILE *stream
)
3495 fprintf (stream
, "Disableable packets:\n"
3496 " vCont \tAll vCont packets\n"
3497 " qC \tQuerying the current thread\n"
3498 " qfThreadInfo\tThread listing\n"
3499 " Tthread \tPassing the thread specifier in the "
3500 "T stop reply packet\n"
3501 " threads \tAll of the above\n");
3505 kill_inferior_callback (struct inferior_list_entry
*entry
)
3507 struct process_info
*process
= (struct process_info
*) entry
;
3508 int pid
= ptid_get_pid (process
->entry
.id
);
3510 kill_inferior (pid
);
3511 discard_queued_stop_replies (pid_to_ptid (pid
));
3514 /* Callback for for_each_inferior to detach or kill the inferior,
3515 depending on whether we attached to it or not.
3516 We inform the user whether we're detaching or killing the process
3517 as this is only called when gdbserver is about to exit. */
3520 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3522 struct process_info
*process
= (struct process_info
*) entry
;
3523 int pid
= ptid_get_pid (process
->entry
.id
);
3525 if (process
->attached
)
3526 detach_inferior (pid
);
3528 kill_inferior (pid
);
3530 discard_queued_stop_replies (pid_to_ptid (pid
));
3533 /* for_each_inferior callback for detach_or_kill_for_exit to print
3534 the pids of started inferiors. */
3537 print_started_pid (struct inferior_list_entry
*entry
)
3539 struct process_info
*process
= (struct process_info
*) entry
;
3541 if (! process
->attached
)
3543 int pid
= ptid_get_pid (process
->entry
.id
);
3544 fprintf (stderr
, " %d", pid
);
3548 /* for_each_inferior callback for detach_or_kill_for_exit to print
3549 the pids of attached inferiors. */
3552 print_attached_pid (struct inferior_list_entry
*entry
)
3554 struct process_info
*process
= (struct process_info
*) entry
;
3556 if (process
->attached
)
3558 int pid
= ptid_get_pid (process
->entry
.id
);
3559 fprintf (stderr
, " %d", pid
);
3563 /* Call this when exiting gdbserver with possible inferiors that need
3564 to be killed or detached from. */
3567 detach_or_kill_for_exit (void)
3569 /* First print a list of the inferiors we will be killing/detaching.
3570 This is to assist the user, for example, in case the inferior unexpectedly
3571 dies after we exit: did we screw up or did the inferior exit on its own?
3572 Having this info will save some head-scratching. */
3574 if (have_started_inferiors_p ())
3576 fprintf (stderr
, "Killing process(es):");
3577 for_each_inferior (&all_processes
, print_started_pid
);
3578 fprintf (stderr
, "\n");
3580 if (have_attached_inferiors_p ())
3582 fprintf (stderr
, "Detaching process(es):");
3583 for_each_inferior (&all_processes
, print_attached_pid
);
3584 fprintf (stderr
, "\n");
3587 /* Now we can kill or detach the inferiors. */
3589 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3592 /* Value that will be passed to exit(3) when gdbserver exits. */
3593 static int exit_code
;
3595 /* Cleanup version of detach_or_kill_for_exit. */
3598 detach_or_kill_for_exit_cleanup (void *ignore
)
3603 detach_or_kill_for_exit ();
3606 CATCH (exception
, RETURN_MASK_ALL
)
3609 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3615 /* Main function. This is called by the real "main" function,
3616 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3618 static void ATTRIBUTE_NORETURN
3619 captured_main (int argc
, char *argv
[])
3624 const char *port
= NULL
;
3625 char **next_arg
= &argv
[1];
3626 volatile int multi_mode
= 0;
3627 volatile int attach
= 0;
3629 bool selftest
= false;
3630 const char *selftest_filter
= NULL
;
3632 while (*next_arg
!= NULL
&& **next_arg
== '-')
3634 if (strcmp (*next_arg
, "--version") == 0)
3636 gdbserver_version ();
3639 else if (strcmp (*next_arg
, "--help") == 0)
3641 gdbserver_usage (stdout
);
3644 else if (strcmp (*next_arg
, "--attach") == 0)
3646 else if (strcmp (*next_arg
, "--multi") == 0)
3648 else if (strcmp (*next_arg
, "--wrapper") == 0)
3655 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3657 wrapper_argv
+= *next_arg
;
3658 wrapper_argv
+= ' ';
3662 if (!wrapper_argv
.empty ())
3664 /* Erase the last whitespace. */
3665 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3668 if (next_arg
== tmp
|| *next_arg
== NULL
)
3670 gdbserver_usage (stderr
);
3674 /* Consume the "--". */
3677 else if (strcmp (*next_arg
, "--debug") == 0)
3679 else if (startswith (*next_arg
, "--debug-format="))
3682 = parse_debug_format_options ((*next_arg
)
3683 + sizeof ("--debug-format=") - 1, 0);
3685 if (error_msg
!= NULL
)
3687 fprintf (stderr
, "%s", error_msg
);
3691 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3693 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3695 gdbserver_show_disableable (stdout
);
3698 else if (startswith (*next_arg
, "--disable-packet="))
3700 char *packets
, *tok
;
3702 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3703 for (tok
= strtok (packets
, ",");
3705 tok
= strtok (NULL
, ","))
3707 if (strcmp ("vCont", tok
) == 0)
3708 disable_packet_vCont
= 1;
3709 else if (strcmp ("Tthread", tok
) == 0)
3710 disable_packet_Tthread
= 1;
3711 else if (strcmp ("qC", tok
) == 0)
3712 disable_packet_qC
= 1;
3713 else if (strcmp ("qfThreadInfo", tok
) == 0)
3714 disable_packet_qfThreadInfo
= 1;
3715 else if (strcmp ("threads", tok
) == 0)
3717 disable_packet_vCont
= 1;
3718 disable_packet_Tthread
= 1;
3719 disable_packet_qC
= 1;
3720 disable_packet_qfThreadInfo
= 1;
3724 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3726 gdbserver_show_disableable (stderr
);
3731 else if (strcmp (*next_arg
, "-") == 0)
3733 /* "-" specifies a stdio connection and is a form of port
3735 port
= STDIO_CONNECTION_NAME
;
3739 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3740 disable_randomization
= 1;
3741 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3742 disable_randomization
= 0;
3743 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3744 startup_with_shell
= true;
3745 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3746 startup_with_shell
= false;
3747 else if (strcmp (*next_arg
, "--once") == 0)
3749 else if (strcmp (*next_arg
, "--selftest") == 0)
3751 else if (startswith (*next_arg
, "--selftest="))
3754 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3758 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3771 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3774 gdbserver_usage (stderr
);
3778 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3779 opened by remote_prepare. */
3782 save_original_signals_state ();
3784 /* We need to know whether the remote connection is stdio before
3785 starting the inferior. Inferiors created in this scenario have
3786 stdin,stdout redirected. So do this here before we call
3789 remote_prepare (port
);
3794 /* --attach used to come after PORT, so allow it there for
3796 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3803 && (*next_arg
== NULL
3804 || (*next_arg
)[0] == '\0'
3805 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3807 || next_arg
[1] != NULL
))
3812 gdbserver_usage (stderr
);
3816 /* Gather information about the environment. */
3817 our_environ
= gdb_environ::from_host_environ ();
3819 initialize_async_io ();
3821 have_job_control ();
3822 initialize_event_loop ();
3823 if (target_supports_tracepoints ())
3824 initialize_tracepoint ();
3825 initialize_notif ();
3827 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3828 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3832 selftests::run_tests (selftest_filter
);
3833 throw_quit ("Quit");
3836 if (pid
== 0 && *next_arg
!= NULL
)
3840 n
= argc
- (next_arg
- argv
);
3841 program_name
= xstrdup (next_arg
[0]);
3842 for (i
= 1; i
< n
; i
++)
3843 program_args
.push_back (xstrdup (next_arg
[i
]));
3844 program_args
.push_back (NULL
);
3846 /* Wait till we are at first instruction in program. */
3847 create_inferior (program_name
, program_args
);
3849 /* We are now (hopefully) stopped at the first instruction of
3850 the target process. This assumes that the target process was
3851 successfully created. */
3855 if (attach_inferior (pid
) == -1)
3856 error ("Attaching not supported on this target");
3858 /* Otherwise succeeded. */
3862 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3863 last_status
.value
.integer
= 0;
3864 last_ptid
= minus_one_ptid
;
3866 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3868 /* Don't report shared library events on the initial connection,
3869 even if some libraries are preloaded. Avoids the "stopped by
3870 shared library event" notice on gdb side. */
3873 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3874 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3879 if (!was_running
&& !multi_mode
)
3880 error ("No program to debug");
3887 report_fork_events
= 0;
3888 report_vfork_events
= 0;
3889 report_exec_events
= 0;
3890 /* Be sure we're out of tfind mode. */
3891 current_traceframe
= -1;
3892 cont_thread
= null_ptid
;
3893 swbreak_feature
= 0;
3894 hwbreak_feature
= 0;
3895 vCont_supported
= 0;
3901 /* Wait for events. This will return when all event sources
3902 are removed from the event loop. */
3903 start_event_loop ();
3905 /* If an exit was requested (using the "monitor exit"
3906 command), terminate now. */
3908 throw_quit ("Quit");
3910 /* The only other way to get here is for getpkt to fail:
3912 - If --once was specified, we're done.
3914 - If not in extended-remote mode, and we're no longer
3915 debugging anything, simply exit: GDB has disconnected
3916 after processing the last process exit.
3918 - Otherwise, close the connection and reopen it at the
3920 if (run_once
|| (!extended_protocol
&& !target_running ()))
3921 throw_quit ("Quit");
3924 "Remote side has terminated connection. "
3925 "GDBserver will reopen the connection.\n");
3927 /* Get rid of any pending statuses. An eventual reconnection
3928 (by the same GDB instance or another) will refresh all its
3929 state from scratch. */
3930 discard_queued_stop_replies (minus_one_ptid
);
3931 for_each_inferior (&all_threads
,
3932 clear_pending_status_callback
);
3936 if (disconnected_tracing
)
3938 /* Try to enable non-stop/async mode, so we we can
3939 both wait for an async socket accept, and handle
3940 async target events simultaneously. There's also
3941 no point either in having the target always stop
3942 all threads, when we're going to pass signals
3943 down without informing GDB. */
3946 if (start_non_stop (1))
3949 /* Detaching implicitly resumes all threads;
3950 simply disconnecting does not. */
3956 "Disconnected tracing disabled; "
3957 "stopping trace run.\n");
3962 CATCH (exception
, RETURN_MASK_ERROR
)
3965 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3967 if (response_needed
)
3969 write_enn (own_buf
);
3974 throw_quit ("Quit");
3980 /* Main function. */
3983 main (int argc
, char *argv
[])
3988 captured_main (argc
, argv
);
3990 CATCH (exception
, RETURN_MASK_ALL
)
3992 if (exception
.reason
== RETURN_ERROR
)
3995 fprintf (stderr
, "%s\n", exception
.message
);
3996 fprintf (stderr
, "Exiting\n");
4004 gdb_assert_not_reached ("captured_main should never return");
4007 /* Process options coming from Z packets for a breakpoint. PACKET is
4008 the packet buffer. *PACKET is updated to point to the first char
4009 after the last processed option. */
4012 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
4014 char *dataptr
= *packet
;
4017 /* Check if data has the correct format. */
4018 if (*dataptr
!= ';')
4025 if (*dataptr
== ';')
4028 if (*dataptr
== 'X')
4030 /* Conditional expression. */
4032 debug_printf ("Found breakpoint condition.\n");
4033 if (!add_breakpoint_condition (bp
, &dataptr
))
4034 dataptr
= strchrnul (dataptr
, ';');
4036 else if (startswith (dataptr
, "cmds:"))
4038 dataptr
+= strlen ("cmds:");
4040 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4041 persist
= (*dataptr
== '1');
4043 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4044 dataptr
= strchrnul (dataptr
, ';');
4048 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4050 /* Skip tokens until we find one that we recognize. */
4051 dataptr
= strchrnul (dataptr
, ';');
4057 /* Event loop callback that handles a serial event. The first byte in
4058 the serial buffer gets us here. We expect characters to arrive at
4059 a brisk pace, so we read the rest of the packet with a blocking
4063 process_serial_event (void)
4071 int new_packet_len
= -1;
4073 disable_async_io ();
4075 response_needed
= 0;
4076 packet_len
= getpkt (own_buf
);
4077 if (packet_len
<= 0)
4080 /* Force an event loop break. */
4083 response_needed
= 1;
4085 char ch
= own_buf
[0];
4089 handle_query (own_buf
, packet_len
, &new_packet_len
);
4092 handle_general_set (own_buf
);
4095 handle_detach (own_buf
);
4098 extended_protocol
= 1;
4102 handle_status (own_buf
);
4105 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4107 require_running_or_break (own_buf
);
4109 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4111 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4112 thread_id
= null_ptid
;
4113 else if (thread_id
.is_pid ())
4115 /* The ptid represents a pid. */
4116 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4120 write_enn (own_buf
);
4124 thread_id
= thread
->entry
.id
;
4128 /* The ptid represents a lwp/tid. */
4129 if (find_thread_ptid (thread_id
) == NULL
)
4131 write_enn (own_buf
);
4136 if (own_buf
[1] == 'g')
4138 if (ptid_equal (thread_id
, null_ptid
))
4140 /* GDB is telling us to choose any thread. Check if
4141 the currently selected thread is still valid. If
4142 it is not, select the first available. */
4143 struct thread_info
*thread
=
4144 (struct thread_info
*) find_inferior_id (&all_threads
,
4147 thread
= get_first_thread ();
4148 thread_id
= thread
->entry
.id
;
4151 general_thread
= thread_id
;
4152 set_desired_thread ();
4153 gdb_assert (current_thread
!= NULL
);
4155 else if (own_buf
[1] == 'c')
4156 cont_thread
= thread_id
;
4162 /* Silently ignore it so that gdb can extend the protocol
4163 without compatibility headaches. */
4168 require_running_or_break (own_buf
);
4169 if (current_traceframe
>= 0)
4171 struct regcache
*regcache
4172 = new_register_cache (current_target_desc ());
4174 if (fetch_traceframe_registers (current_traceframe
,
4176 registers_to_string (regcache
, own_buf
);
4178 write_enn (own_buf
);
4179 free_register_cache (regcache
);
4183 struct regcache
*regcache
;
4185 if (!set_desired_thread ())
4186 write_enn (own_buf
);
4189 regcache
= get_thread_regcache (current_thread
, 1);
4190 registers_to_string (regcache
, own_buf
);
4195 require_running_or_break (own_buf
);
4196 if (current_traceframe
>= 0)
4197 write_enn (own_buf
);
4200 struct regcache
*regcache
;
4202 if (!set_desired_thread ())
4203 write_enn (own_buf
);
4206 regcache
= get_thread_regcache (current_thread
, 1);
4207 registers_from_string (regcache
, &own_buf
[1]);
4213 require_running_or_break (own_buf
);
4214 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4215 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4217 write_enn (own_buf
);
4219 bin2hex (mem_buf
, own_buf
, res
);
4222 require_running_or_break (own_buf
);
4223 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4224 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4227 write_enn (own_buf
);
4230 require_running_or_break (own_buf
);
4231 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4232 &mem_addr
, &len
, &mem_buf
) < 0
4233 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4234 write_enn (own_buf
);
4239 require_running_or_break (own_buf
);
4240 hex2bin (own_buf
+ 1, &sig
, 1);
4241 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4242 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4245 myresume (own_buf
, 0, signal
);
4248 require_running_or_break (own_buf
);
4249 hex2bin (own_buf
+ 1, &sig
, 1);
4250 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4251 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4254 myresume (own_buf
, 1, signal
);
4257 require_running_or_break (own_buf
);
4259 myresume (own_buf
, 0, signal
);
4262 require_running_or_break (own_buf
);
4264 myresume (own_buf
, 1, signal
);
4266 case 'Z': /* insert_ ... */
4268 case 'z': /* remove_ ... */
4273 char type
= own_buf
[1];
4275 const int insert
= ch
== 'Z';
4276 char *p
= &own_buf
[3];
4278 p
= unpack_varlen_hex (p
, &addr
);
4279 kind
= strtol (p
+ 1, &dataptr
, 16);
4283 struct gdb_breakpoint
*bp
;
4285 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4290 /* GDB may have sent us a list of *point parameters to
4291 be evaluated on the target's side. Read such list
4292 here. If we already have a list of parameters, GDB
4293 is telling us to drop that list and use this one
4295 clear_breakpoint_conditions_and_commands (bp
);
4296 process_point_options (bp
, &dataptr
);
4300 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4308 write_enn (own_buf
);
4312 response_needed
= 0;
4313 if (!target_running ())
4314 /* The packet we received doesn't make sense - but we can't
4315 reply to it, either. */
4318 fprintf (stderr
, "Killing all inferiors\n");
4319 for_each_inferior (&all_processes
, kill_inferior_callback
);
4321 /* When using the extended protocol, we wait with no program
4322 running. The traditional protocol will exit instead. */
4323 if (extended_protocol
)
4325 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4326 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4334 require_running_or_break (own_buf
);
4336 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4337 if (find_thread_ptid (thread_id
) == NULL
)
4339 write_enn (own_buf
);
4343 if (mythread_alive (thread_id
))
4346 write_enn (own_buf
);
4350 response_needed
= 0;
4352 /* Restarting the inferior is only supported in the extended
4354 if (extended_protocol
)
4356 if (target_running ())
4357 for_each_inferior (&all_processes
,
4358 kill_inferior_callback
);
4359 fprintf (stderr
, "GDBserver restarting\n");
4361 /* Wait till we are at 1st instruction in prog. */
4362 if (program_name
!= NULL
)
4364 create_inferior (program_name
, program_args
);
4366 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4368 /* Stopped at the first instruction of the target
4370 general_thread
= last_ptid
;
4374 /* Something went wrong. */
4375 general_thread
= null_ptid
;
4380 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4381 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4387 /* It is a request we don't understand. Respond with an
4388 empty packet so that gdb knows that we don't support this
4394 /* Extended (long) request. */
4395 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4399 /* It is a request we don't understand. Respond with an empty
4400 packet so that gdb knows that we don't support this
4406 if (new_packet_len
!= -1)
4407 putpkt_binary (own_buf
, new_packet_len
);
4411 response_needed
= 0;
4419 /* Event-loop callback for serial events. */
4422 handle_serial_event (int err
, gdb_client_data client_data
)
4425 debug_printf ("handling possible serial event\n");
4427 /* Really handle it. */
4428 if (process_serial_event () < 0)
4431 /* Be sure to not change the selected thread behind GDB's back.
4432 Important in the non-stop mode asynchronous protocol. */
4433 set_desired_thread ();
4438 /* Push a stop notification on the notification queue. */
4441 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4443 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4445 vstop_notif
->status
= *status
;
4446 vstop_notif
->ptid
= ptid
;
4447 /* Push Stop notification. */
4448 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4451 /* Event-loop callback for target events. */
4454 handle_target_event (int err
, gdb_client_data client_data
)
4457 debug_printf ("handling possible target event\n");
4459 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4462 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4464 if (gdb_connected () && report_no_resumed
)
4465 push_stop_notification (null_ptid
, &last_status
);
4467 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4469 int pid
= ptid_get_pid (last_ptid
);
4470 struct process_info
*process
= find_process_pid (pid
);
4471 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4473 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4474 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4476 mark_breakpoints_out (process
);
4477 target_mourn_inferior (last_ptid
);
4479 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4483 /* We're reporting this thread as stopped. Update its
4484 "want-stopped" state to what the client wants, until it
4485 gets a new resume action. */
4486 current_thread
->last_resume_kind
= resume_stop
;
4487 current_thread
->last_status
= last_status
;
4492 if (!target_running ())
4494 /* The last process exited. We're done. */
4498 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4499 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4500 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4504 /* A thread stopped with a signal, but gdb isn't
4505 connected to handle it. Pass it down to the
4506 inferior, as if it wasn't being traced. */
4507 enum gdb_signal signal
;
4510 debug_printf ("GDB not connected; forwarding event %d for"
4512 (int) last_status
.kind
,
4513 target_pid_to_str (last_ptid
));
4515 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4516 signal
= last_status
.value
.sig
;
4518 signal
= GDB_SIGNAL_0
;
4519 target_continue (last_ptid
, signal
);
4523 push_stop_notification (last_ptid
, &last_status
);
4526 /* Be sure to not change the selected thread behind GDB's back.
4527 Important in the non-stop mode asynchronous protocol. */
4528 set_desired_thread ();
4541 } // namespace selftests
4542 #endif /* GDB_SELF_TEST */