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 if (startswith (own_buf
, "QSetWorkingDir:"))
874 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
878 std::string path
= hex2str (p
);
880 set_inferior_cwd (path
.c_str ());
883 debug_printf (_("[Set the inferior's current directory to %s]\n"),
888 /* An empty argument means that we should clear out any
889 previously set cwd for the inferior. */
890 set_inferior_cwd (NULL
);
894 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
901 /* Otherwise we didn't know what packet it was. Say we didn't
907 get_features_xml (const char *annex
)
909 const struct target_desc
*desc
= current_target_desc ();
911 /* `desc->xmltarget' defines what to return when looking for the
912 "target.xml" file. Its contents can either be verbatim XML code
913 (prefixed with a '@') or else the name of the actual XML file to
914 be used in place of "target.xml".
916 This variable is set up from the auto-generated
917 init_registers_... routine for the current target. */
919 if (strcmp (annex
, "target.xml") == 0)
921 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
931 extern const char *const xml_builtin
[][2];
934 /* Look for the annex. */
935 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
936 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
939 if (xml_builtin
[i
][0] != NULL
)
940 return xml_builtin
[i
][1];
948 monitor_show_help (void)
950 monitor_output ("The following monitor commands are supported:\n");
951 monitor_output (" set debug <0|1>\n");
952 monitor_output (" Enable general debugging messages\n");
953 monitor_output (" set debug-hw-points <0|1>\n");
954 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
955 monitor_output (" set remote-debug <0|1>\n");
956 monitor_output (" Enable remote protocol debugging messages\n");
957 monitor_output (" set debug-format option1[,option2,...]\n");
958 monitor_output (" Add additional information to debugging messages\n");
959 monitor_output (" Options: all, none");
960 monitor_output (", timestamp");
961 monitor_output ("\n");
962 monitor_output (" exit\n");
963 monitor_output (" Quit GDBserver\n");
966 /* Read trace frame or inferior memory. Returns the number of bytes
967 actually read, zero when no further transfer is possible, and -1 on
968 error. Return of a positive value smaller than LEN does not
969 indicate there's no more to be read, only the end of the transfer.
970 E.g., when GDB reads memory from a traceframe, a first request may
971 be served from a memory block that does not cover the whole request
972 length. A following request gets the rest served from either
973 another block (of the same traceframe) or from the read-only
977 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
981 if (current_traceframe
>= 0)
984 ULONGEST length
= len
;
986 if (traceframe_read_mem (current_traceframe
,
987 memaddr
, myaddr
, len
, &nbytes
))
989 /* Data read from trace buffer, we're done. */
992 if (!in_readonly_region (memaddr
, length
))
994 /* Otherwise we have a valid readonly case, fall through. */
995 /* (assume no half-trace half-real blocks for now) */
998 res
= prepare_to_access_memory ();
1001 if (set_desired_thread ())
1002 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1005 done_accessing_memory ();
1007 return res
== 0 ? len
: -1;
1013 /* Write trace frame or inferior memory. Actually, writing to trace
1014 frames is forbidden. */
1017 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1019 if (current_traceframe
>= 0)
1025 ret
= prepare_to_access_memory ();
1028 if (set_desired_thread ())
1029 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1032 done_accessing_memory ();
1038 /* Subroutine of handle_search_memory to simplify it. */
1041 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1042 gdb_byte
*pattern
, unsigned pattern_len
,
1043 gdb_byte
*search_buf
,
1044 unsigned chunk_size
, unsigned search_buf_size
,
1045 CORE_ADDR
*found_addrp
)
1047 /* Prime the search buffer. */
1049 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1052 warning ("Unable to access %ld bytes of target "
1053 "memory at 0x%lx, halting search.",
1054 (long) search_buf_size
, (long) start_addr
);
1058 /* Perform the search.
1060 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1061 When we've scanned N bytes we copy the trailing bytes to the start and
1062 read in another N bytes. */
1064 while (search_space_len
>= pattern_len
)
1066 gdb_byte
*found_ptr
;
1067 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1071 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1074 if (found_ptr
!= NULL
)
1076 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1077 *found_addrp
= found_addr
;
1081 /* Not found in this chunk, skip to next chunk. */
1083 /* Don't let search_space_len wrap here, it's unsigned. */
1084 if (search_space_len
>= chunk_size
)
1085 search_space_len
-= chunk_size
;
1087 search_space_len
= 0;
1089 if (search_space_len
>= pattern_len
)
1091 unsigned keep_len
= search_buf_size
- chunk_size
;
1092 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1095 /* Copy the trailing part of the previous iteration to the front
1096 of the buffer for the next iteration. */
1097 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1099 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1100 ? search_space_len
- keep_len
1103 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1104 nr_to_read
) != search_buf_size
)
1106 warning ("Unable to access %ld bytes of target memory "
1107 "at 0x%lx, halting search.",
1108 (long) nr_to_read
, (long) read_addr
);
1112 start_addr
+= chunk_size
;
1121 /* Handle qSearch:memory packets. */
1124 handle_search_memory (char *own_buf
, int packet_len
)
1126 CORE_ADDR start_addr
;
1127 CORE_ADDR search_space_len
;
1129 unsigned int pattern_len
;
1130 /* NOTE: also defined in find.c testcase. */
1131 #define SEARCH_CHUNK_SIZE 16000
1132 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1133 /* Buffer to hold memory contents for searching. */
1134 gdb_byte
*search_buf
;
1135 unsigned search_buf_size
;
1137 CORE_ADDR found_addr
;
1138 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1140 pattern
= (gdb_byte
*) malloc (packet_len
);
1141 if (pattern
== NULL
)
1143 error ("Unable to allocate memory to perform the search");
1144 strcpy (own_buf
, "E00");
1147 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1148 packet_len
- cmd_name_len
,
1149 &start_addr
, &search_space_len
,
1150 pattern
, &pattern_len
) < 0)
1153 error ("Error in parsing qSearch:memory packet");
1154 strcpy (own_buf
, "E00");
1158 search_buf_size
= chunk_size
+ pattern_len
- 1;
1160 /* No point in trying to allocate a buffer larger than the search space. */
1161 if (search_space_len
< search_buf_size
)
1162 search_buf_size
= search_space_len
;
1164 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1165 if (search_buf
== NULL
)
1168 error ("Unable to allocate memory to perform the search");
1169 strcpy (own_buf
, "E00");
1173 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1174 pattern
, pattern_len
,
1175 search_buf
, chunk_size
, search_buf_size
,
1179 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1180 else if (found
== 0)
1181 strcpy (own_buf
, "0");
1183 strcpy (own_buf
, "E00");
1189 /* Handle the "D" packet. */
1192 handle_detach (char *own_buf
)
1194 require_running_or_return (own_buf
);
1201 pid
= strtol (&own_buf
[2], NULL
, 16);
1204 pid
= ptid_get_pid (current_ptid
);
1206 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1208 struct process_info
*process
= find_process_pid (pid
);
1210 if (process
== NULL
)
1212 write_enn (own_buf
);
1216 if (tracing
&& disconnected_tracing
)
1218 "Disconnected tracing in effect, "
1219 "leaving gdbserver attached to the process\n");
1221 if (any_persistent_commands ())
1223 "Persistent commands are present, "
1224 "leaving gdbserver attached to the process\n");
1226 /* Make sure we're in non-stop/async mode, so we we can both
1227 wait for an async socket accept, and handle async target
1228 events simultaneously. There's also no point either in
1229 having the target stop all threads, when we're going to
1230 pass signals down without informing GDB. */
1234 debug_printf ("Forcing non-stop mode\n");
1240 process
->gdb_detached
= 1;
1242 /* Detaching implicitly resumes all threads. */
1243 target_continue_no_signal (minus_one_ptid
);
1249 fprintf (stderr
, "Detaching from process %d\n", pid
);
1251 if (detach_inferior (pid
) != 0)
1252 write_enn (own_buf
);
1255 discard_queued_stop_replies (pid_to_ptid (pid
));
1258 if (extended_protocol
|| target_running ())
1260 /* There is still at least one inferior remaining or
1261 we are in extended mode, so don't terminate gdbserver,
1262 and instead treat this like a normal program exit. */
1263 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1264 last_status
.value
.integer
= 0;
1265 last_ptid
= pid_to_ptid (pid
);
1267 current_thread
= NULL
;
1274 /* If we are attached, then we can exit. Otherwise, we
1275 need to hang around doing nothing, until the child is
1277 join_inferior (pid
);
1283 /* Parse options to --debug-format= and "monitor set debug-format".
1284 ARG is the text after "--debug-format=" or "monitor set debug-format".
1285 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1286 This triggers calls to monitor_output.
1287 The result is NULL if all options were parsed ok, otherwise an error
1288 message which the caller must free.
1290 N.B. These commands affect all debug format settings, they are not
1291 cumulative. If a format is not specified, it is turned off.
1292 However, we don't go to extra trouble with things like
1293 "monitor set debug-format all,none,timestamp".
1294 Instead we just parse them one at a time, in order.
1296 The syntax for "monitor set debug" we support here is not identical
1297 to gdb's "set debug foo on|off" because we also use this function to
1298 parse "--debug-format=foo,bar". */
1301 parse_debug_format_options (const char *arg
, int is_monitor
)
1303 VEC (char_ptr
) *options
;
1307 /* First turn all debug format options off. */
1308 debug_timestamp
= 0;
1310 /* First remove leading spaces, for "monitor set debug-format". */
1311 while (isspace (*arg
))
1314 options
= delim_string_to_char_ptr_vec (arg
, ',');
1316 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1318 if (strcmp (option
, "all") == 0)
1320 debug_timestamp
= 1;
1322 monitor_output ("All extra debug format options enabled.\n");
1324 else if (strcmp (option
, "none") == 0)
1326 debug_timestamp
= 0;
1328 monitor_output ("All extra debug format options disabled.\n");
1330 else if (strcmp (option
, "timestamp") == 0)
1332 debug_timestamp
= 1;
1334 monitor_output ("Timestamps will be added to debug output.\n");
1336 else if (*option
== '\0')
1338 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1343 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1346 free_char_ptr_vec (options
);
1351 free_char_ptr_vec (options
);
1355 /* Handle monitor commands not handled by target-specific handlers. */
1358 handle_monitor_command (char *mon
, char *own_buf
)
1360 if (strcmp (mon
, "set debug 1") == 0)
1363 monitor_output ("Debug output enabled.\n");
1365 else if (strcmp (mon
, "set debug 0") == 0)
1368 monitor_output ("Debug output disabled.\n");
1370 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1372 show_debug_regs
= 1;
1373 monitor_output ("H/W point debugging output enabled.\n");
1375 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1377 show_debug_regs
= 0;
1378 monitor_output ("H/W point debugging output disabled.\n");
1380 else if (strcmp (mon
, "set remote-debug 1") == 0)
1383 monitor_output ("Protocol debug output enabled.\n");
1385 else if (strcmp (mon
, "set remote-debug 0") == 0)
1388 monitor_output ("Protocol debug output disabled.\n");
1390 else if (startswith (mon
, "set debug-format "))
1393 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1396 if (error_msg
!= NULL
)
1398 monitor_output (error_msg
);
1399 monitor_show_help ();
1400 write_enn (own_buf
);
1404 else if (strcmp (mon
, "help") == 0)
1405 monitor_show_help ();
1406 else if (strcmp (mon
, "exit") == 0)
1410 monitor_output ("Unknown monitor command.\n\n");
1411 monitor_show_help ();
1412 write_enn (own_buf
);
1416 /* Associates a callback with each supported qXfer'able object. */
1420 /* The object this handler handles. */
1423 /* Request that the target transfer up to LEN 8-bit bytes of the
1424 target's OBJECT. The OFFSET, for a seekable object, specifies
1425 the starting point. The ANNEX can be used to provide additional
1426 data-specific information to the target.
1428 Return the number of bytes actually transfered, zero when no
1429 further transfer is possible, -1 on error, -2 when the transfer
1430 is not supported, and -3 on a verbose error message that should
1431 be preserved. Return of a positive value smaller than LEN does
1432 not indicate the end of the object, only the end of the transfer.
1434 One, and only one, of readbuf or writebuf must be non-NULL. */
1435 int (*xfer
) (const char *annex
,
1436 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1437 ULONGEST offset
, LONGEST len
);
1440 /* Handle qXfer:auxv:read. */
1443 handle_qxfer_auxv (const char *annex
,
1444 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1445 ULONGEST offset
, LONGEST len
)
1447 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1450 if (annex
[0] != '\0' || current_thread
== NULL
)
1453 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1456 /* Handle qXfer:exec-file:read. */
1459 handle_qxfer_exec_file (const char *annex
,
1460 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1461 ULONGEST offset
, LONGEST len
)
1467 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1470 if (annex
[0] == '\0')
1472 if (current_thread
== NULL
)
1475 pid
= pid_of (current_thread
);
1479 annex
= unpack_varlen_hex (annex
, &pid
);
1480 if (annex
[0] != '\0')
1487 file
= (*the_target
->pid_to_exec_file
) (pid
);
1491 total_len
= strlen (file
);
1493 if (offset
> total_len
)
1496 if (offset
+ len
> total_len
)
1497 len
= total_len
- offset
;
1499 memcpy (readbuf
, file
+ offset
, len
);
1503 /* Handle qXfer:features:read. */
1506 handle_qxfer_features (const char *annex
,
1507 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1508 ULONGEST offset
, LONGEST len
)
1510 const char *document
;
1513 if (writebuf
!= NULL
)
1516 if (!target_running ())
1519 /* Grab the correct annex. */
1520 document
= get_features_xml (annex
);
1521 if (document
== NULL
)
1524 total_len
= strlen (document
);
1526 if (offset
> total_len
)
1529 if (offset
+ len
> total_len
)
1530 len
= total_len
- offset
;
1532 memcpy (readbuf
, document
+ offset
, len
);
1536 /* Worker routine for handle_qxfer_libraries.
1537 Emit the XML to describe the library in INF. */
1540 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1542 struct dll_info
*dll
= (struct dll_info
*) inf
;
1543 std::string
*document
= (std::string
*) arg
;
1544 std::string name
= xml_escape_text (dll
->name
);
1546 *document
+= string_printf
1547 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1548 name
.c_str (), (long) dll
->base_addr
);
1551 /* Handle qXfer:libraries:read. */
1554 handle_qxfer_libraries (const char *annex
,
1555 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1556 ULONGEST offset
, LONGEST len
)
1558 if (writebuf
!= NULL
)
1561 if (annex
[0] != '\0' || current_thread
== NULL
)
1564 std::string document
= "<library-list version=\"1.0\">\n";
1566 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &document
);
1568 document
+= "</library-list>\n";
1570 if (offset
> document
.length ())
1573 if (offset
+ len
> document
.length ())
1574 len
= document
.length () - offset
;
1576 memcpy (readbuf
, &document
[offset
], len
);
1581 /* Handle qXfer:libraries-svr4:read. */
1584 handle_qxfer_libraries_svr4 (const char *annex
,
1585 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1586 ULONGEST offset
, LONGEST len
)
1588 if (writebuf
!= NULL
)
1591 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1594 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1597 /* Handle qXfer:osadata:read. */
1600 handle_qxfer_osdata (const char *annex
,
1601 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1602 ULONGEST offset
, LONGEST len
)
1604 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1607 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1610 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1613 handle_qxfer_siginfo (const char *annex
,
1614 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1615 ULONGEST offset
, LONGEST len
)
1617 if (the_target
->qxfer_siginfo
== NULL
)
1620 if (annex
[0] != '\0' || current_thread
== NULL
)
1623 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1626 /* Handle qXfer:spu:read and qXfer:spu:write. */
1629 handle_qxfer_spu (const char *annex
,
1630 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1631 ULONGEST offset
, LONGEST len
)
1633 if (the_target
->qxfer_spu
== NULL
)
1636 if (current_thread
== NULL
)
1639 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1642 /* Handle qXfer:statictrace:read. */
1645 handle_qxfer_statictrace (const char *annex
,
1646 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1647 ULONGEST offset
, LONGEST len
)
1651 if (writebuf
!= NULL
)
1654 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1657 if (traceframe_read_sdata (current_traceframe
, offset
,
1658 readbuf
, len
, &nbytes
))
1663 /* Helper for handle_qxfer_threads_proper.
1664 Emit the XML to describe the thread of INF. */
1667 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1669 struct thread_info
*thread
= (struct thread_info
*) inf
;
1670 struct buffer
*buffer
= (struct buffer
*) arg
;
1671 ptid_t ptid
= ptid_of (thread
);
1673 int core
= target_core_of_thread (ptid
);
1675 const char *name
= target_thread_name (ptid
);
1678 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1680 write_ptid (ptid_s
, ptid
);
1682 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1686 sprintf (core_s
, "%d", core
);
1687 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1691 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1695 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1696 bin2hex (handle
, handle_s
, handle_len
);
1697 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1700 buffer_xml_printf (buffer
, "/>\n");
1703 /* Helper for handle_qxfer_threads. */
1706 handle_qxfer_threads_proper (struct buffer
*buffer
)
1708 buffer_grow_str (buffer
, "<threads>\n");
1710 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1713 buffer_grow_str0 (buffer
, "</threads>\n");
1716 /* Handle qXfer:threads:read. */
1719 handle_qxfer_threads (const char *annex
,
1720 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1721 ULONGEST offset
, LONGEST len
)
1723 static char *result
= 0;
1724 static unsigned int result_length
= 0;
1726 if (writebuf
!= NULL
)
1729 if (annex
[0] != '\0')
1734 struct buffer buffer
;
1735 /* When asked for data at offset 0, generate everything and store into
1736 'result'. Successive reads will be served off 'result'. */
1740 buffer_init (&buffer
);
1742 handle_qxfer_threads_proper (&buffer
);
1744 result
= buffer_finish (&buffer
);
1745 result_length
= strlen (result
);
1746 buffer_free (&buffer
);
1749 if (offset
>= result_length
)
1751 /* We're out of data. */
1758 if (len
> result_length
- offset
)
1759 len
= result_length
- offset
;
1761 memcpy (readbuf
, result
+ offset
, len
);
1766 /* Handle qXfer:traceframe-info:read. */
1769 handle_qxfer_traceframe_info (const char *annex
,
1770 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1771 ULONGEST offset
, LONGEST len
)
1773 static char *result
= 0;
1774 static unsigned int result_length
= 0;
1776 if (writebuf
!= NULL
)
1779 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1784 struct buffer buffer
;
1786 /* When asked for data at offset 0, generate everything and
1787 store into 'result'. Successive reads will be served off
1791 buffer_init (&buffer
);
1793 traceframe_read_info (current_traceframe
, &buffer
);
1795 result
= buffer_finish (&buffer
);
1796 result_length
= strlen (result
);
1797 buffer_free (&buffer
);
1800 if (offset
>= result_length
)
1802 /* We're out of data. */
1809 if (len
> result_length
- offset
)
1810 len
= result_length
- offset
;
1812 memcpy (readbuf
, result
+ offset
, len
);
1816 /* Handle qXfer:fdpic:read. */
1819 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1820 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1822 if (the_target
->read_loadmap
== NULL
)
1825 if (current_thread
== NULL
)
1828 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1831 /* Handle qXfer:btrace:read. */
1834 handle_qxfer_btrace (const char *annex
,
1835 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1836 ULONGEST offset
, LONGEST len
)
1838 static struct buffer cache
;
1839 struct thread_info
*thread
;
1840 enum btrace_read_type type
;
1843 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1846 if (ptid_equal (general_thread
, null_ptid
)
1847 || ptid_equal (general_thread
, minus_one_ptid
))
1849 strcpy (own_buf
, "E.Must select a single thread.");
1853 thread
= find_thread_ptid (general_thread
);
1856 strcpy (own_buf
, "E.No such thread.");
1860 if (thread
->btrace
== NULL
)
1862 strcpy (own_buf
, "E.Btrace not enabled.");
1866 if (strcmp (annex
, "all") == 0)
1867 type
= BTRACE_READ_ALL
;
1868 else if (strcmp (annex
, "new") == 0)
1869 type
= BTRACE_READ_NEW
;
1870 else if (strcmp (annex
, "delta") == 0)
1871 type
= BTRACE_READ_DELTA
;
1874 strcpy (own_buf
, "E.Bad annex.");
1880 buffer_free (&cache
);
1882 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1885 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1889 else if (offset
> cache
.used_size
)
1891 buffer_free (&cache
);
1895 if (len
> cache
.used_size
- offset
)
1896 len
= cache
.used_size
- offset
;
1898 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1903 /* Handle qXfer:btrace-conf:read. */
1906 handle_qxfer_btrace_conf (const char *annex
,
1907 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1908 ULONGEST offset
, LONGEST len
)
1910 static struct buffer cache
;
1911 struct thread_info
*thread
;
1914 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1917 if (annex
[0] != '\0')
1920 if (ptid_equal (general_thread
, null_ptid
)
1921 || ptid_equal (general_thread
, minus_one_ptid
))
1923 strcpy (own_buf
, "E.Must select a single thread.");
1927 thread
= find_thread_ptid (general_thread
);
1930 strcpy (own_buf
, "E.No such thread.");
1934 if (thread
->btrace
== NULL
)
1936 strcpy (own_buf
, "E.Btrace not enabled.");
1942 buffer_free (&cache
);
1944 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1947 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1951 else if (offset
> cache
.used_size
)
1953 buffer_free (&cache
);
1957 if (len
> cache
.used_size
- offset
)
1958 len
= cache
.used_size
- offset
;
1960 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1965 static const struct qxfer qxfer_packets
[] =
1967 { "auxv", handle_qxfer_auxv
},
1968 { "btrace", handle_qxfer_btrace
},
1969 { "btrace-conf", handle_qxfer_btrace_conf
},
1970 { "exec-file", handle_qxfer_exec_file
},
1971 { "fdpic", handle_qxfer_fdpic
},
1972 { "features", handle_qxfer_features
},
1973 { "libraries", handle_qxfer_libraries
},
1974 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1975 { "osdata", handle_qxfer_osdata
},
1976 { "siginfo", handle_qxfer_siginfo
},
1977 { "spu", handle_qxfer_spu
},
1978 { "statictrace", handle_qxfer_statictrace
},
1979 { "threads", handle_qxfer_threads
},
1980 { "traceframe-info", handle_qxfer_traceframe_info
},
1984 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1992 if (!startswith (own_buf
, "qXfer:"))
1995 /* Grab the object, r/w and annex. */
1996 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1998 write_enn (own_buf
);
2003 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2006 const struct qxfer
*q
= &qxfer_packets
[i
];
2008 if (strcmp (object
, q
->object
) == 0)
2010 if (strcmp (rw
, "read") == 0)
2012 unsigned char *data
;
2017 /* Grab the offset and length. */
2018 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2020 write_enn (own_buf
);
2024 /* Read one extra byte, as an indicator of whether there is
2026 if (len
> PBUFSIZ
- 2)
2028 data
= (unsigned char *) malloc (len
+ 1);
2031 write_enn (own_buf
);
2034 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2042 /* Preserve error message. */
2045 write_enn (own_buf
);
2047 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2049 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2054 else if (strcmp (rw
, "write") == 0)
2059 unsigned char *data
;
2061 strcpy (own_buf
, "E00");
2062 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2065 write_enn (own_buf
);
2068 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2069 &ofs
, &len
, data
) < 0)
2072 write_enn (own_buf
);
2076 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2084 /* Preserve error message. */
2087 write_enn (own_buf
);
2089 sprintf (own_buf
, "%x", n
);
2102 /* Compute 32 bit CRC from inferior memory.
2104 On success, return 32 bit CRC.
2105 On failure, return (unsigned long long) -1. */
2107 static unsigned long long
2108 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2112 unsigned char byte
= 0;
2114 /* Return failure if memory read fails. */
2115 if (read_inferior_memory (base
, &byte
, 1) != 0)
2116 return (unsigned long long) -1;
2118 crc
= xcrc32 (&byte
, 1, crc
);
2121 return (unsigned long long) crc
;
2124 /* Add supported btrace packets to BUF. */
2127 supported_btrace_packets (char *buf
)
2129 int btrace_supported
= 0;
2131 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2133 strcat (buf
, ";Qbtrace:bts+");
2134 strcat (buf
, ";Qbtrace-conf:bts:size+");
2136 btrace_supported
= 1;
2139 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2141 strcat (buf
, ";Qbtrace:pt+");
2142 strcat (buf
, ";Qbtrace-conf:pt:size+");
2144 btrace_supported
= 1;
2147 if (!btrace_supported
)
2150 strcat (buf
, ";Qbtrace:off+");
2151 strcat (buf
, ";qXfer:btrace:read+");
2152 strcat (buf
, ";qXfer:btrace-conf:read+");
2155 /* Handle all of the extended 'q' packets. */
2158 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2160 static struct inferior_list_entry
*thread_ptr
;
2162 /* Reply the current thread id. */
2163 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2166 require_running_or_return (own_buf
);
2168 if (general_thread
!= null_ptid
&& general_thread
!= minus_one_ptid
)
2169 ptid
= general_thread
;
2172 thread_ptr
= get_first_inferior (&all_threads
);
2173 ptid
= thread_ptr
->id
;
2176 sprintf (own_buf
, "QC");
2178 write_ptid (own_buf
, ptid
);
2182 if (strcmp ("qSymbol::", own_buf
) == 0)
2184 struct thread_info
*save_thread
= current_thread
;
2186 /* For qSymbol, GDB only changes the current thread if the
2187 previous current thread was of a different process. So if
2188 the previous thread is gone, we need to pick another one of
2189 the same process. This can happen e.g., if we followed an
2190 exec in a non-leader thread. */
2191 if (current_thread
== NULL
)
2194 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2196 /* Just in case, if we didn't find a thread, then bail out
2197 instead of crashing. */
2198 if (current_thread
== NULL
)
2200 write_enn (own_buf
);
2201 current_thread
= save_thread
;
2206 /* GDB is suggesting new symbols have been loaded. This may
2207 mean a new shared library has been detected as loaded, so
2208 take the opportunity to check if breakpoints we think are
2209 inserted, still are. Note that it isn't guaranteed that
2210 we'll see this when a shared library is loaded, and nor will
2211 we see this for unloads (although breakpoints in unloaded
2212 libraries shouldn't trigger), as GDB may not find symbols for
2213 the library at all. We also re-validate breakpoints when we
2214 see a second GDB breakpoint for the same address, and or when
2215 we access breakpoint shadows. */
2216 validate_breakpoints ();
2218 if (target_supports_tracepoints ())
2219 tracepoint_look_up_symbols ();
2221 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2222 (*the_target
->look_up_symbols
) ();
2224 current_thread
= save_thread
;
2226 strcpy (own_buf
, "OK");
2230 if (!disable_packet_qfThreadInfo
)
2232 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2234 require_running_or_return (own_buf
);
2235 thread_ptr
= get_first_inferior (&all_threads
);
2238 write_ptid (own_buf
, thread_ptr
->id
);
2239 thread_ptr
= thread_ptr
->next
;
2243 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2245 require_running_or_return (own_buf
);
2246 if (thread_ptr
!= NULL
)
2249 write_ptid (own_buf
, thread_ptr
->id
);
2250 thread_ptr
= thread_ptr
->next
;
2255 sprintf (own_buf
, "l");
2261 if (the_target
->read_offsets
!= NULL
2262 && strcmp ("qOffsets", own_buf
) == 0)
2264 CORE_ADDR text
, data
;
2266 require_running_or_return (own_buf
);
2267 if (the_target
->read_offsets (&text
, &data
))
2268 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2269 (long)text
, (long)data
, (long)data
);
2271 write_enn (own_buf
);
2276 /* Protocol features query. */
2277 if (startswith (own_buf
, "qSupported")
2278 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2280 char *p
= &own_buf
[10];
2281 int gdb_supports_qRelocInsn
= 0;
2283 /* Process each feature being provided by GDB. The first
2284 feature will follow a ':', and latter features will follow
2288 char **qsupported
= NULL
;
2293 /* Two passes, to avoid nested strtok calls in
2294 target_process_qsupported. */
2295 for (p
= strtok (p
+ 1, ";");
2297 p
= strtok (NULL
, ";"))
2300 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2301 qsupported
[count
- 1] = xstrdup (p
);
2304 for (i
= 0; i
< count
; i
++)
2307 if (strcmp (p
, "multiprocess+") == 0)
2309 /* GDB supports and wants multi-process support if
2311 if (target_supports_multi_process ())
2314 else if (strcmp (p
, "qRelocInsn+") == 0)
2316 /* GDB supports relocate instruction requests. */
2317 gdb_supports_qRelocInsn
= 1;
2319 else if (strcmp (p
, "swbreak+") == 0)
2321 /* GDB wants us to report whether a trap is caused
2322 by a software breakpoint and for us to handle PC
2323 adjustment if necessary on this target. */
2324 if (target_supports_stopped_by_sw_breakpoint ())
2325 swbreak_feature
= 1;
2327 else if (strcmp (p
, "hwbreak+") == 0)
2329 /* GDB wants us to report whether a trap is caused
2330 by a hardware breakpoint. */
2331 if (target_supports_stopped_by_hw_breakpoint ())
2332 hwbreak_feature
= 1;
2334 else if (strcmp (p
, "fork-events+") == 0)
2336 /* GDB supports and wants fork events if possible. */
2337 if (target_supports_fork_events ())
2338 report_fork_events
= 1;
2340 else if (strcmp (p
, "vfork-events+") == 0)
2342 /* GDB supports and wants vfork events if possible. */
2343 if (target_supports_vfork_events ())
2344 report_vfork_events
= 1;
2346 else if (strcmp (p
, "exec-events+") == 0)
2348 /* GDB supports and wants exec events if possible. */
2349 if (target_supports_exec_events ())
2350 report_exec_events
= 1;
2352 else if (strcmp (p
, "vContSupported+") == 0)
2353 vCont_supported
= 1;
2354 else if (strcmp (p
, "QThreadEvents+") == 0)
2356 else if (strcmp (p
, "no-resumed+") == 0)
2358 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2360 report_no_resumed
= 1;
2364 /* Move the unknown features all together. */
2365 qsupported
[i
] = NULL
;
2366 qsupported
[unknown
] = p
;
2371 /* Give the target backend a chance to process the unknown
2373 target_process_qsupported (qsupported
, unknown
);
2375 for (i
= 0; i
< count
; i
++)
2376 free (qsupported
[i
]);
2381 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2382 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2383 "QEnvironmentReset+;QEnvironmentUnset+;"
2387 if (target_supports_catch_syscall ())
2388 strcat (own_buf
, ";QCatchSyscalls+");
2390 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2391 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2392 ";augmented-libraries-svr4-read+");
2395 /* We do not have any hook to indicate whether the non-SVR4 target
2396 backend supports qXfer:libraries:read, so always report it. */
2397 strcat (own_buf
, ";qXfer:libraries:read+");
2400 if (the_target
->read_auxv
!= NULL
)
2401 strcat (own_buf
, ";qXfer:auxv:read+");
2403 if (the_target
->qxfer_spu
!= NULL
)
2404 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2406 if (the_target
->qxfer_siginfo
!= NULL
)
2407 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2409 if (the_target
->read_loadmap
!= NULL
)
2410 strcat (own_buf
, ";qXfer:fdpic:read+");
2412 /* We always report qXfer:features:read, as targets may
2413 install XML files on a subsequent call to arch_setup.
2414 If we reported to GDB on startup that we don't support
2415 qXfer:feature:read at all, we will never be re-queried. */
2416 strcat (own_buf
, ";qXfer:features:read+");
2418 if (transport_is_reliable
)
2419 strcat (own_buf
, ";QStartNoAckMode+");
2421 if (the_target
->qxfer_osdata
!= NULL
)
2422 strcat (own_buf
, ";qXfer:osdata:read+");
2424 if (target_supports_multi_process ())
2425 strcat (own_buf
, ";multiprocess+");
2427 if (target_supports_fork_events ())
2428 strcat (own_buf
, ";fork-events+");
2430 if (target_supports_vfork_events ())
2431 strcat (own_buf
, ";vfork-events+");
2433 if (target_supports_exec_events ())
2434 strcat (own_buf
, ";exec-events+");
2436 if (target_supports_non_stop ())
2437 strcat (own_buf
, ";QNonStop+");
2439 if (target_supports_disable_randomization ())
2440 strcat (own_buf
, ";QDisableRandomization+");
2442 strcat (own_buf
, ";qXfer:threads:read+");
2444 if (target_supports_tracepoints ())
2446 strcat (own_buf
, ";ConditionalTracepoints+");
2447 strcat (own_buf
, ";TraceStateVariables+");
2448 strcat (own_buf
, ";TracepointSource+");
2449 strcat (own_buf
, ";DisconnectedTracing+");
2450 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2451 strcat (own_buf
, ";FastTracepoints+");
2452 strcat (own_buf
, ";StaticTracepoints+");
2453 strcat (own_buf
, ";InstallInTrace+");
2454 strcat (own_buf
, ";qXfer:statictrace:read+");
2455 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2456 strcat (own_buf
, ";EnableDisableTracepoints+");
2457 strcat (own_buf
, ";QTBuffer:size+");
2458 strcat (own_buf
, ";tracenz+");
2461 if (target_supports_hardware_single_step ()
2462 || target_supports_software_single_step () )
2464 strcat (own_buf
, ";ConditionalBreakpoints+");
2466 strcat (own_buf
, ";BreakpointCommands+");
2468 if (target_supports_agent ())
2469 strcat (own_buf
, ";QAgent+");
2471 supported_btrace_packets (own_buf
);
2473 if (target_supports_stopped_by_sw_breakpoint ())
2474 strcat (own_buf
, ";swbreak+");
2476 if (target_supports_stopped_by_hw_breakpoint ())
2477 strcat (own_buf
, ";hwbreak+");
2479 if (the_target
->pid_to_exec_file
!= NULL
)
2480 strcat (own_buf
, ";qXfer:exec-file:read+");
2482 strcat (own_buf
, ";vContSupported+");
2484 strcat (own_buf
, ";QThreadEvents+");
2486 strcat (own_buf
, ";no-resumed+");
2488 /* Reinitialize components as needed for the new connection. */
2489 hostio_handle_new_gdb_connection ();
2490 target_handle_new_gdb_connection ();
2495 /* Thread-local storage support. */
2496 if (the_target
->get_tls_address
!= NULL
2497 && startswith (own_buf
, "qGetTLSAddr:"))
2499 char *p
= own_buf
+ 12;
2500 CORE_ADDR parts
[2], address
= 0;
2502 ptid_t ptid
= null_ptid
;
2504 require_running_or_return (own_buf
);
2506 for (i
= 0; i
< 3; i
++)
2514 p2
= strchr (p
, ',');
2527 ptid
= read_ptid (p
, NULL
);
2529 decode_address (&parts
[i
- 1], p
, len
);
2533 if (p
!= NULL
|| i
< 3)
2537 struct thread_info
*thread
= find_thread_ptid (ptid
);
2542 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2548 strcpy (own_buf
, paddress(address
));
2553 write_enn (own_buf
);
2557 /* Otherwise, pretend we do not understand this packet. */
2560 /* Windows OS Thread Information Block address support. */
2561 if (the_target
->get_tib_address
!= NULL
2562 && startswith (own_buf
, "qGetTIBAddr:"))
2567 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2569 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2572 strcpy (own_buf
, paddress(tlb
));
2577 write_enn (own_buf
);
2583 /* Handle "monitor" commands. */
2584 if (startswith (own_buf
, "qRcmd,"))
2586 char *mon
= (char *) malloc (PBUFSIZ
);
2587 int len
= strlen (own_buf
+ 6);
2591 write_enn (own_buf
);
2596 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2598 write_enn (own_buf
);
2602 mon
[len
/ 2] = '\0';
2606 if (the_target
->handle_monitor_command
== NULL
2607 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2608 /* Default processing. */
2609 handle_monitor_command (mon
, own_buf
);
2615 if (startswith (own_buf
, "qSearch:memory:"))
2617 require_running_or_return (own_buf
);
2618 handle_search_memory (own_buf
, packet_len
);
2622 if (strcmp (own_buf
, "qAttached") == 0
2623 || startswith (own_buf
, "qAttached:"))
2625 struct process_info
*process
;
2627 if (own_buf
[sizeof ("qAttached") - 1])
2629 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2630 process
= (struct process_info
*)
2631 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2635 require_running_or_return (own_buf
);
2636 process
= current_process ();
2639 if (process
== NULL
)
2641 write_enn (own_buf
);
2645 strcpy (own_buf
, process
->attached
? "1" : "0");
2649 if (startswith (own_buf
, "qCRC:"))
2651 /* CRC check (compare-section). */
2655 unsigned long long crc
;
2657 require_running_or_return (own_buf
);
2658 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2659 if (*comma
++ != ',')
2661 write_enn (own_buf
);
2664 len
= strtoul (comma
, NULL
, 16);
2665 crc
= crc32 (base
, len
, 0xffffffff);
2666 /* Check for memory failure. */
2667 if (crc
== (unsigned long long) -1)
2669 write_enn (own_buf
);
2672 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2676 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2679 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2682 /* Otherwise we didn't know what packet it was. Say we didn't
2687 static void gdb_wants_all_threads_stopped (void);
2688 static void resume (struct thread_resume
*actions
, size_t n
);
2690 /* The callback that is passed to visit_actioned_threads. */
2691 typedef int (visit_actioned_threads_callback_ftype
)
2692 (const struct thread_resume
*, struct thread_info
*);
2694 /* Struct to pass data to visit_actioned_threads. */
2696 struct visit_actioned_threads_data
2698 const struct thread_resume
*actions
;
2700 visit_actioned_threads_callback_ftype
*callback
;
2703 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2704 true if CALLBACK returns true. Returns false if no matching thread
2705 is found or CALLBACK results false.
2706 Note: This function is itself a callback for find_inferior. */
2709 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2711 struct visit_actioned_threads_data
*data
2712 = (struct visit_actioned_threads_data
*) datap
;
2713 const struct thread_resume
*actions
= data
->actions
;
2714 size_t num_actions
= data
->num_actions
;
2715 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2718 for (i
= 0; i
< num_actions
; i
++)
2720 const struct thread_resume
*action
= &actions
[i
];
2722 if (ptid_equal (action
->thread
, minus_one_ptid
)
2723 || ptid_equal (action
->thread
, entry
->id
)
2724 || ((ptid_get_pid (action
->thread
)
2725 == ptid_get_pid (entry
->id
))
2726 && ptid_get_lwp (action
->thread
) == -1))
2728 struct thread_info
*thread
= (struct thread_info
*) entry
;
2730 if ((*callback
) (action
, thread
))
2738 /* Callback for visit_actioned_threads. If the thread has a pending
2739 status to report, report it now. */
2742 handle_pending_status (const struct thread_resume
*resumption
,
2743 struct thread_info
*thread
)
2745 if (thread
->status_pending_p
)
2747 thread
->status_pending_p
= 0;
2749 last_status
= thread
->last_status
;
2750 last_ptid
= thread
->entry
.id
;
2751 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2757 /* Parse vCont packets. */
2759 handle_v_cont (char *own_buf
)
2763 struct thread_resume
*resume_info
;
2764 struct thread_resume default_action
{ null_ptid
};
2766 /* Count the number of semicolons in the packet. There should be one
2767 for every action. */
2773 p
= strchr (p
, ';');
2776 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2777 if (resume_info
== NULL
)
2785 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2787 if (p
[0] == 's' || p
[0] == 'S')
2788 resume_info
[i
].kind
= resume_step
;
2789 else if (p
[0] == 'r')
2790 resume_info
[i
].kind
= resume_step
;
2791 else if (p
[0] == 'c' || p
[0] == 'C')
2792 resume_info
[i
].kind
= resume_continue
;
2793 else if (p
[0] == 't')
2794 resume_info
[i
].kind
= resume_stop
;
2798 if (p
[0] == 'S' || p
[0] == 'C')
2801 int sig
= strtol (p
+ 1, &q
, 16);
2806 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2808 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2810 else if (p
[0] == 'r')
2814 p
= unpack_varlen_hex (p
+ 1, &addr
);
2815 resume_info
[i
].step_range_start
= addr
;
2820 p
= unpack_varlen_hex (p
+ 1, &addr
);
2821 resume_info
[i
].step_range_end
= addr
;
2830 resume_info
[i
].thread
= minus_one_ptid
;
2831 default_action
= resume_info
[i
];
2833 /* Note: we don't increment i here, we'll overwrite this entry
2834 the next time through. */
2836 else if (p
[0] == ':')
2839 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2844 if (p
[0] != ';' && p
[0] != 0)
2847 resume_info
[i
].thread
= ptid
;
2854 resume_info
[i
] = default_action
;
2856 resume (resume_info
, n
);
2861 write_enn (own_buf
);
2866 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2869 resume (struct thread_resume
*actions
, size_t num_actions
)
2873 /* Check if among the threads that GDB wants actioned, there's
2874 one with a pending status to report. If so, skip actually
2875 resuming/stopping and report the pending event
2877 struct visit_actioned_threads_data data
;
2879 data
.actions
= actions
;
2880 data
.num_actions
= num_actions
;
2881 data
.callback
= handle_pending_status
;
2882 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2888 (*the_target
->resume
) (actions
, num_actions
);
2894 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2896 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2897 && !report_no_resumed
)
2899 /* The client does not support this stop reply. At least
2901 sprintf (own_buf
, "E.No unwaited-for children left.");
2902 disable_async_io ();
2906 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2907 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2908 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2909 current_thread
->last_status
= last_status
;
2911 /* From the client's perspective, all-stop mode always stops all
2912 threads implicitly (and the target backend has already done
2913 so by now). Tag all threads as "want-stopped", so we don't
2914 resume them implicitly without the client telling us to. */
2915 gdb_wants_all_threads_stopped ();
2916 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2917 disable_async_io ();
2919 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2920 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2921 target_mourn_inferior (last_ptid
);
2925 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2927 handle_v_attach (char *own_buf
)
2931 pid
= strtol (own_buf
+ 8, NULL
, 16);
2932 if (pid
!= 0 && attach_inferior (pid
) == 0)
2934 /* Don't report shared library events after attaching, even if
2935 some libraries are preloaded. GDB will always poll the
2936 library list. Avoids the "stopped by shared library event"
2937 notice on the GDB side. */
2942 /* In non-stop, we don't send a resume reply. Stop events
2943 will follow up using the normal notification
2948 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2954 write_enn (own_buf
);
2959 /* Run a new program. Return 1 if successful, 0 if failure. */
2961 handle_v_run (char *own_buf
)
2964 std::vector
<char *> new_argv
;
2965 char *new_program_name
= NULL
;
2969 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2975 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2977 next_p
= strchr (p
, ';');
2979 next_p
= p
+ strlen (p
);
2981 if (i
== 0 && p
== next_p
)
2983 /* No program specified. */
2984 new_program_name
= NULL
;
2986 else if (p
== next_p
)
2988 /* Empty argument. */
2989 new_argv
.push_back (xstrdup ("''"));
2993 size_t len
= (next_p
- p
) / 2;
2994 /* ARG is the unquoted argument received via the RSP. */
2995 char *arg
= (char *) xmalloc (len
+ 1);
2996 /* FULL_ARGS will contain the quoted version of ARG. */
2997 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2998 /* These are pointers used to navigate the strings above. */
2999 char *tmp_arg
= arg
;
3000 char *tmp_full_arg
= full_arg
;
3003 hex2bin (p
, (gdb_byte
*) arg
, len
);
3006 while (*tmp_arg
!= '\0')
3012 *tmp_full_arg
= '\'';
3018 /* Quote single quote. */
3019 *tmp_full_arg
= '\\';
3027 *tmp_full_arg
= *tmp_arg
;
3033 *tmp_full_arg
++ = '\'';
3035 /* Finish FULL_ARG and push it into the vector containing
3037 *tmp_full_arg
= '\0';
3039 new_program_name
= full_arg
;
3041 new_argv
.push_back (full_arg
);
3047 new_argv
.push_back (NULL
);
3049 if (new_program_name
== NULL
)
3051 /* GDB didn't specify a program to run. Use the program from the
3052 last run with the new argument list. */
3053 if (program_name
== NULL
)
3055 write_enn (own_buf
);
3056 free_vector_argv (new_argv
);
3062 xfree (program_name
);
3063 program_name
= new_program_name
;
3066 /* Free the old argv and install the new one. */
3067 free_vector_argv (program_args
);
3068 program_args
= new_argv
;
3070 create_inferior (program_name
, program_args
);
3072 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3074 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3076 /* In non-stop, sending a resume reply doesn't set the general
3077 thread, but GDB assumes a vRun sets it (this is so GDB can
3078 query which is the main thread of the new inferior. */
3080 general_thread
= last_ptid
;
3086 write_enn (own_buf
);
3091 /* Kill process. Return 1 if successful, 0 if failure. */
3093 handle_v_kill (char *own_buf
)
3096 char *p
= &own_buf
[6];
3098 pid
= strtol (p
, NULL
, 16);
3101 if (pid
!= 0 && kill_inferior (pid
) == 0)
3103 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3104 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3105 last_ptid
= pid_to_ptid (pid
);
3106 discard_queued_stop_replies (last_ptid
);
3112 write_enn (own_buf
);
3117 /* Handle all of the extended 'v' packets. */
3119 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3121 if (!disable_packet_vCont
)
3123 if (strcmp (own_buf
, "vCtrlC") == 0)
3125 (*the_target
->request_interrupt
) ();
3130 if (startswith (own_buf
, "vCont;"))
3132 handle_v_cont (own_buf
);
3136 if (startswith (own_buf
, "vCont?"))
3138 strcpy (own_buf
, "vCont;c;C;t");
3140 if (target_supports_hardware_single_step ()
3141 || target_supports_software_single_step ()
3142 || !vCont_supported
)
3144 /* If target supports single step either by hardware or by
3145 software, add actions s and S to the list of supported
3146 actions. On the other hand, if GDB doesn't request the
3147 supported vCont actions in qSupported packet, add s and
3148 S to the list too. */
3149 own_buf
= own_buf
+ strlen (own_buf
);
3150 strcpy (own_buf
, ";s;S");
3153 if (target_supports_range_stepping ())
3155 own_buf
= own_buf
+ strlen (own_buf
);
3156 strcpy (own_buf
, ";r");
3162 if (startswith (own_buf
, "vFile:")
3163 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3166 if (startswith (own_buf
, "vAttach;"))
3168 if ((!extended_protocol
|| !multi_process
) && target_running ())
3170 fprintf (stderr
, "Already debugging a process\n");
3171 write_enn (own_buf
);
3174 handle_v_attach (own_buf
);
3178 if (startswith (own_buf
, "vRun;"))
3180 if ((!extended_protocol
|| !multi_process
) && target_running ())
3182 fprintf (stderr
, "Already debugging a process\n");
3183 write_enn (own_buf
);
3186 handle_v_run (own_buf
);
3190 if (startswith (own_buf
, "vKill;"))
3192 if (!target_running ())
3194 fprintf (stderr
, "No process to kill\n");
3195 write_enn (own_buf
);
3198 handle_v_kill (own_buf
);
3202 if (handle_notif_ack (own_buf
, packet_len
))
3205 /* Otherwise we didn't know what packet it was. Say we didn't
3211 /* Resume thread and wait for another event. In non-stop mode,
3212 don't really wait here, but return immediatelly to the event
3215 myresume (char *own_buf
, int step
, int sig
)
3217 struct thread_resume resume_info
[2];
3219 int valid_cont_thread
;
3221 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3222 && !ptid_equal (cont_thread
, minus_one_ptid
));
3224 if (step
|| sig
|| valid_cont_thread
)
3226 resume_info
[0].thread
= current_ptid
;
3228 resume_info
[0].kind
= resume_step
;
3230 resume_info
[0].kind
= resume_continue
;
3231 resume_info
[0].sig
= sig
;
3235 if (!valid_cont_thread
)
3237 resume_info
[n
].thread
= minus_one_ptid
;
3238 resume_info
[n
].kind
= resume_continue
;
3239 resume_info
[n
].sig
= 0;
3243 resume (resume_info
, n
);
3246 /* Callback for for_each_inferior. Make a new stop reply for each
3250 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3252 struct thread_info
*thread
= (struct thread_info
*) entry
;
3254 /* For now, assume targets that don't have this callback also don't
3255 manage the thread's last_status field. */
3256 if (the_target
->thread_stopped
== NULL
)
3258 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3260 new_notif
->ptid
= entry
->id
;
3261 new_notif
->status
= thread
->last_status
;
3262 /* Pass the last stop reply back to GDB, but don't notify
3264 notif_event_enque (¬if_stop
,
3265 (struct notif_event
*) new_notif
);
3269 if (thread_stopped (thread
))
3273 std::string status_string
3274 = target_waitstatus_to_string (&thread
->last_status
);
3276 debug_printf ("Reporting thread %s as already stopped with %s\n",
3277 target_pid_to_str (entry
->id
),
3278 status_string
.c_str ());
3281 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3283 /* Pass the last stop reply back to GDB, but don't notify
3285 queue_stop_reply (entry
->id
, &thread
->last_status
);
3292 /* Set this inferior threads's state as "want-stopped". We won't
3293 resume this thread until the client gives us another action for
3297 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3299 struct thread_info
*thread
= (struct thread_info
*) entry
;
3301 thread
->last_resume_kind
= resume_stop
;
3303 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3305 /* Most threads are stopped implicitly (all-stop); tag that with
3307 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3308 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3312 /* Set all threads' states as "want-stopped". */
3315 gdb_wants_all_threads_stopped (void)
3317 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3320 /* Clear the gdb_detached flag of every process. */
3323 gdb_reattached_process (struct inferior_list_entry
*entry
)
3325 struct process_info
*process
= (struct process_info
*) entry
;
3327 process
->gdb_detached
= 0;
3330 /* Callback for for_each_inferior. Clear the thread's pending status
3334 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3336 struct thread_info
*thread
= (struct thread_info
*) entry
;
3338 thread
->status_pending_p
= 0;
3341 /* Callback for for_each_inferior. If the thread is stopped with an
3342 interesting event, mark it as having a pending event. */
3345 set_pending_status_callback (struct inferior_list_entry
*entry
)
3347 struct thread_info
*thread
= (struct thread_info
*) entry
;
3349 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3350 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3351 /* A breakpoint, watchpoint or finished step from a previous
3352 GDB run isn't considered interesting for a new GDB run.
3353 If we left those pending, the new GDB could consider them
3354 random SIGTRAPs. This leaves out real async traps. We'd
3355 have to peek into the (target-specific) siginfo to
3356 distinguish those. */
3357 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3358 thread
->status_pending_p
= 1;
3361 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3362 pending status to report to GDB. */
3365 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3367 struct thread_info
*thread
= (struct thread_info
*) entry
;
3369 return thread
->status_pending_p
;
3372 /* Status handler for the '?' packet. */
3375 handle_status (char *own_buf
)
3377 /* GDB is connected, don't forward events to the target anymore. */
3378 for_each_inferior (&all_processes
, gdb_reattached_process
);
3380 /* In non-stop mode, we must send a stop reply for each stopped
3381 thread. In all-stop mode, just send one for the first stopped
3386 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3388 /* The first is sent immediatly. OK is sent if there is no
3389 stopped thread, which is the same handling of the vStopped
3390 packet (by design). */
3391 notif_write_event (¬if_stop
, own_buf
);
3395 struct inferior_list_entry
*thread
= NULL
;
3398 stabilize_threads ();
3399 gdb_wants_all_threads_stopped ();
3401 /* We can only report one status, but we might be coming out of
3402 non-stop -- if more than one thread is stopped with
3403 interesting events, leave events for the threads we're not
3404 reporting now pending. They'll be reported the next time the
3405 threads are resumed. Start by marking all interesting events
3407 for_each_inferior (&all_threads
, set_pending_status_callback
);
3409 /* Prefer the last thread that reported an event to GDB (even if
3410 that was a GDB_SIGNAL_TRAP). */
3411 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3412 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3413 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3414 thread
= find_inferior_id (&all_threads
, last_ptid
);
3416 /* If the last event thread is not found for some reason, look
3417 for some other thread that might have an event to report. */
3419 thread
= find_inferior (&all_threads
,
3420 find_status_pending_thread_callback
, NULL
);
3422 /* If we're still out of luck, simply pick the first thread in
3425 thread
= get_first_inferior (&all_threads
);
3429 struct thread_info
*tp
= (struct thread_info
*) thread
;
3431 /* We're reporting this event, so it's no longer
3433 tp
->status_pending_p
= 0;
3435 /* GDB assumes the current thread is the thread we're
3436 reporting the status for. */
3437 general_thread
= thread
->id
;
3438 set_desired_thread ();
3440 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3441 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3444 strcpy (own_buf
, "W00");
3449 gdbserver_version (void)
3451 printf ("GNU gdbserver %s%s\n"
3452 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3453 "gdbserver is free software, covered by the "
3454 "GNU General Public License.\n"
3455 "This gdbserver was configured as \"%s\"\n",
3456 PKGVERSION
, version
, host_name
);
3460 gdbserver_usage (FILE *stream
)
3462 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3463 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3464 "\tgdbserver [OPTIONS] --multi COMM\n"
3466 "COMM may either be a tty device (for serial debugging),\n"
3467 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3468 "stdin/stdout of gdbserver.\n"
3469 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3470 "PID is the process ID to attach to, when --attach is specified.\n"
3472 "Operating modes:\n"
3474 " --attach Attach to running process PID.\n"
3475 " --multi Start server without a specific program, and\n"
3476 " only quit when explicitly commanded.\n"
3477 " --once Exit after the first connection has closed.\n"
3478 " --help Print this message and then exit.\n"
3479 " --version Display version information and exit.\n"
3483 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3484 " --disable-randomization\n"
3485 " Run PROG with address space randomization disabled.\n"
3486 " --no-disable-randomization\n"
3487 " Don't disable address space randomization when\n"
3489 " --startup-with-shell\n"
3490 " Start PROG using a shell. I.e., execs a shell that\n"
3491 " then execs PROG. (default)\n"
3492 " --no-startup-with-shell\n"
3493 " Exec PROG directly instead of using a shell.\n"
3494 " Disables argument globbing and variable substitution\n"
3495 " on UNIX-like systems.\n"
3499 " --debug Enable general debugging output.\n"
3500 " --debug-format=opt1[,opt2,...]\n"
3501 " Specify extra content in debugging output.\n"
3506 " --remote-debug Enable remote protocol debugging output.\n"
3507 " --disable-packet=opt1[,opt2,...]\n"
3508 " Disable support for RSP packets or features.\n"
3510 " vCont, Tthread, qC, qfThreadInfo and \n"
3511 " threads (disable all threading packets).\n"
3513 "For more information, consult the GDB manual (available as on-line \n"
3514 "info or a printed manual).\n");
3515 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3516 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3520 gdbserver_show_disableable (FILE *stream
)
3522 fprintf (stream
, "Disableable packets:\n"
3523 " vCont \tAll vCont packets\n"
3524 " qC \tQuerying the current thread\n"
3525 " qfThreadInfo\tThread listing\n"
3526 " Tthread \tPassing the thread specifier in the "
3527 "T stop reply packet\n"
3528 " threads \tAll of the above\n");
3532 kill_inferior_callback (struct inferior_list_entry
*entry
)
3534 struct process_info
*process
= (struct process_info
*) entry
;
3535 int pid
= ptid_get_pid (process
->entry
.id
);
3537 kill_inferior (pid
);
3538 discard_queued_stop_replies (pid_to_ptid (pid
));
3541 /* Callback for for_each_inferior to detach or kill the inferior,
3542 depending on whether we attached to it or not.
3543 We inform the user whether we're detaching or killing the process
3544 as this is only called when gdbserver is about to exit. */
3547 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3549 struct process_info
*process
= (struct process_info
*) entry
;
3550 int pid
= ptid_get_pid (process
->entry
.id
);
3552 if (process
->attached
)
3553 detach_inferior (pid
);
3555 kill_inferior (pid
);
3557 discard_queued_stop_replies (pid_to_ptid (pid
));
3560 /* for_each_inferior callback for detach_or_kill_for_exit to print
3561 the pids of started inferiors. */
3564 print_started_pid (struct inferior_list_entry
*entry
)
3566 struct process_info
*process
= (struct process_info
*) entry
;
3568 if (! process
->attached
)
3570 int pid
= ptid_get_pid (process
->entry
.id
);
3571 fprintf (stderr
, " %d", pid
);
3575 /* for_each_inferior callback for detach_or_kill_for_exit to print
3576 the pids of attached inferiors. */
3579 print_attached_pid (struct inferior_list_entry
*entry
)
3581 struct process_info
*process
= (struct process_info
*) entry
;
3583 if (process
->attached
)
3585 int pid
= ptid_get_pid (process
->entry
.id
);
3586 fprintf (stderr
, " %d", pid
);
3590 /* Call this when exiting gdbserver with possible inferiors that need
3591 to be killed or detached from. */
3594 detach_or_kill_for_exit (void)
3596 /* First print a list of the inferiors we will be killing/detaching.
3597 This is to assist the user, for example, in case the inferior unexpectedly
3598 dies after we exit: did we screw up or did the inferior exit on its own?
3599 Having this info will save some head-scratching. */
3601 if (have_started_inferiors_p ())
3603 fprintf (stderr
, "Killing process(es):");
3604 for_each_inferior (&all_processes
, print_started_pid
);
3605 fprintf (stderr
, "\n");
3607 if (have_attached_inferiors_p ())
3609 fprintf (stderr
, "Detaching process(es):");
3610 for_each_inferior (&all_processes
, print_attached_pid
);
3611 fprintf (stderr
, "\n");
3614 /* Now we can kill or detach the inferiors. */
3616 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3619 /* Value that will be passed to exit(3) when gdbserver exits. */
3620 static int exit_code
;
3622 /* Cleanup version of detach_or_kill_for_exit. */
3625 detach_or_kill_for_exit_cleanup (void *ignore
)
3630 detach_or_kill_for_exit ();
3633 CATCH (exception
, RETURN_MASK_ALL
)
3636 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3642 /* Main function. This is called by the real "main" function,
3643 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3645 static void ATTRIBUTE_NORETURN
3646 captured_main (int argc
, char *argv
[])
3651 const char *port
= NULL
;
3652 char **next_arg
= &argv
[1];
3653 volatile int multi_mode
= 0;
3654 volatile int attach
= 0;
3656 bool selftest
= false;
3657 const char *selftest_filter
= NULL
;
3659 while (*next_arg
!= NULL
&& **next_arg
== '-')
3661 if (strcmp (*next_arg
, "--version") == 0)
3663 gdbserver_version ();
3666 else if (strcmp (*next_arg
, "--help") == 0)
3668 gdbserver_usage (stdout
);
3671 else if (strcmp (*next_arg
, "--attach") == 0)
3673 else if (strcmp (*next_arg
, "--multi") == 0)
3675 else if (strcmp (*next_arg
, "--wrapper") == 0)
3682 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3684 wrapper_argv
+= *next_arg
;
3685 wrapper_argv
+= ' ';
3689 if (!wrapper_argv
.empty ())
3691 /* Erase the last whitespace. */
3692 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3695 if (next_arg
== tmp
|| *next_arg
== NULL
)
3697 gdbserver_usage (stderr
);
3701 /* Consume the "--". */
3704 else if (strcmp (*next_arg
, "--debug") == 0)
3706 else if (startswith (*next_arg
, "--debug-format="))
3709 = parse_debug_format_options ((*next_arg
)
3710 + sizeof ("--debug-format=") - 1, 0);
3712 if (error_msg
!= NULL
)
3714 fprintf (stderr
, "%s", error_msg
);
3718 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3720 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3722 gdbserver_show_disableable (stdout
);
3725 else if (startswith (*next_arg
, "--disable-packet="))
3727 char *packets
, *tok
;
3729 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3730 for (tok
= strtok (packets
, ",");
3732 tok
= strtok (NULL
, ","))
3734 if (strcmp ("vCont", tok
) == 0)
3735 disable_packet_vCont
= 1;
3736 else if (strcmp ("Tthread", tok
) == 0)
3737 disable_packet_Tthread
= 1;
3738 else if (strcmp ("qC", tok
) == 0)
3739 disable_packet_qC
= 1;
3740 else if (strcmp ("qfThreadInfo", tok
) == 0)
3741 disable_packet_qfThreadInfo
= 1;
3742 else if (strcmp ("threads", tok
) == 0)
3744 disable_packet_vCont
= 1;
3745 disable_packet_Tthread
= 1;
3746 disable_packet_qC
= 1;
3747 disable_packet_qfThreadInfo
= 1;
3751 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3753 gdbserver_show_disableable (stderr
);
3758 else if (strcmp (*next_arg
, "-") == 0)
3760 /* "-" specifies a stdio connection and is a form of port
3762 port
= STDIO_CONNECTION_NAME
;
3766 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3767 disable_randomization
= 1;
3768 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3769 disable_randomization
= 0;
3770 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3771 startup_with_shell
= true;
3772 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3773 startup_with_shell
= false;
3774 else if (strcmp (*next_arg
, "--once") == 0)
3776 else if (strcmp (*next_arg
, "--selftest") == 0)
3778 else if (startswith (*next_arg
, "--selftest="))
3781 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3785 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3798 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3801 gdbserver_usage (stderr
);
3805 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3806 opened by remote_prepare. */
3809 save_original_signals_state ();
3811 /* We need to know whether the remote connection is stdio before
3812 starting the inferior. Inferiors created in this scenario have
3813 stdin,stdout redirected. So do this here before we call
3816 remote_prepare (port
);
3821 /* --attach used to come after PORT, so allow it there for
3823 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3830 && (*next_arg
== NULL
3831 || (*next_arg
)[0] == '\0'
3832 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3834 || next_arg
[1] != NULL
))
3839 gdbserver_usage (stderr
);
3843 /* Gather information about the environment. */
3844 our_environ
= gdb_environ::from_host_environ ();
3846 initialize_async_io ();
3848 have_job_control ();
3849 initialize_event_loop ();
3850 if (target_supports_tracepoints ())
3851 initialize_tracepoint ();
3852 initialize_notif ();
3854 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3855 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3859 selftests::run_tests (selftest_filter
);
3860 throw_quit ("Quit");
3863 if (pid
== 0 && *next_arg
!= NULL
)
3867 n
= argc
- (next_arg
- argv
);
3868 program_name
= xstrdup (next_arg
[0]);
3869 for (i
= 1; i
< n
; i
++)
3870 program_args
.push_back (xstrdup (next_arg
[i
]));
3871 program_args
.push_back (NULL
);
3873 /* Wait till we are at first instruction in program. */
3874 create_inferior (program_name
, program_args
);
3876 /* We are now (hopefully) stopped at the first instruction of
3877 the target process. This assumes that the target process was
3878 successfully created. */
3882 if (attach_inferior (pid
) == -1)
3883 error ("Attaching not supported on this target");
3885 /* Otherwise succeeded. */
3889 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3890 last_status
.value
.integer
= 0;
3891 last_ptid
= minus_one_ptid
;
3893 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3895 /* Don't report shared library events on the initial connection,
3896 even if some libraries are preloaded. Avoids the "stopped by
3897 shared library event" notice on gdb side. */
3900 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3901 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3906 if (!was_running
&& !multi_mode
)
3907 error ("No program to debug");
3914 report_fork_events
= 0;
3915 report_vfork_events
= 0;
3916 report_exec_events
= 0;
3917 /* Be sure we're out of tfind mode. */
3918 current_traceframe
= -1;
3919 cont_thread
= null_ptid
;
3920 swbreak_feature
= 0;
3921 hwbreak_feature
= 0;
3922 vCont_supported
= 0;
3928 /* Wait for events. This will return when all event sources
3929 are removed from the event loop. */
3930 start_event_loop ();
3932 /* If an exit was requested (using the "monitor exit"
3933 command), terminate now. */
3935 throw_quit ("Quit");
3937 /* The only other way to get here is for getpkt to fail:
3939 - If --once was specified, we're done.
3941 - If not in extended-remote mode, and we're no longer
3942 debugging anything, simply exit: GDB has disconnected
3943 after processing the last process exit.
3945 - Otherwise, close the connection and reopen it at the
3947 if (run_once
|| (!extended_protocol
&& !target_running ()))
3948 throw_quit ("Quit");
3951 "Remote side has terminated connection. "
3952 "GDBserver will reopen the connection.\n");
3954 /* Get rid of any pending statuses. An eventual reconnection
3955 (by the same GDB instance or another) will refresh all its
3956 state from scratch. */
3957 discard_queued_stop_replies (minus_one_ptid
);
3958 for_each_inferior (&all_threads
,
3959 clear_pending_status_callback
);
3963 if (disconnected_tracing
)
3965 /* Try to enable non-stop/async mode, so we we can
3966 both wait for an async socket accept, and handle
3967 async target events simultaneously. There's also
3968 no point either in having the target always stop
3969 all threads, when we're going to pass signals
3970 down without informing GDB. */
3973 if (start_non_stop (1))
3976 /* Detaching implicitly resumes all threads;
3977 simply disconnecting does not. */
3983 "Disconnected tracing disabled; "
3984 "stopping trace run.\n");
3989 CATCH (exception
, RETURN_MASK_ERROR
)
3992 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3994 if (response_needed
)
3996 write_enn (own_buf
);
4001 throw_quit ("Quit");
4007 /* Main function. */
4010 main (int argc
, char *argv
[])
4015 captured_main (argc
, argv
);
4017 CATCH (exception
, RETURN_MASK_ALL
)
4019 if (exception
.reason
== RETURN_ERROR
)
4022 fprintf (stderr
, "%s\n", exception
.message
);
4023 fprintf (stderr
, "Exiting\n");
4031 gdb_assert_not_reached ("captured_main should never return");
4034 /* Process options coming from Z packets for a breakpoint. PACKET is
4035 the packet buffer. *PACKET is updated to point to the first char
4036 after the last processed option. */
4039 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
4041 const char *dataptr
= *packet
;
4044 /* Check if data has the correct format. */
4045 if (*dataptr
!= ';')
4052 if (*dataptr
== ';')
4055 if (*dataptr
== 'X')
4057 /* Conditional expression. */
4059 debug_printf ("Found breakpoint condition.\n");
4060 if (!add_breakpoint_condition (bp
, &dataptr
))
4061 dataptr
= strchrnul (dataptr
, ';');
4063 else if (startswith (dataptr
, "cmds:"))
4065 dataptr
+= strlen ("cmds:");
4067 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4068 persist
= (*dataptr
== '1');
4070 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4071 dataptr
= strchrnul (dataptr
, ';');
4075 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4077 /* Skip tokens until we find one that we recognize. */
4078 dataptr
= strchrnul (dataptr
, ';');
4084 /* Event loop callback that handles a serial event. The first byte in
4085 the serial buffer gets us here. We expect characters to arrive at
4086 a brisk pace, so we read the rest of the packet with a blocking
4090 process_serial_event (void)
4098 int new_packet_len
= -1;
4100 disable_async_io ();
4102 response_needed
= 0;
4103 packet_len
= getpkt (own_buf
);
4104 if (packet_len
<= 0)
4107 /* Force an event loop break. */
4110 response_needed
= 1;
4112 char ch
= own_buf
[0];
4116 handle_query (own_buf
, packet_len
, &new_packet_len
);
4119 handle_general_set (own_buf
);
4122 handle_detach (own_buf
);
4125 extended_protocol
= 1;
4129 handle_status (own_buf
);
4132 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4134 require_running_or_break (own_buf
);
4136 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4138 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4139 thread_id
= null_ptid
;
4140 else if (thread_id
.is_pid ())
4142 /* The ptid represents a pid. */
4143 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4147 write_enn (own_buf
);
4151 thread_id
= thread
->entry
.id
;
4155 /* The ptid represents a lwp/tid. */
4156 if (find_thread_ptid (thread_id
) == NULL
)
4158 write_enn (own_buf
);
4163 if (own_buf
[1] == 'g')
4165 if (ptid_equal (thread_id
, null_ptid
))
4167 /* GDB is telling us to choose any thread. Check if
4168 the currently selected thread is still valid. If
4169 it is not, select the first available. */
4170 struct thread_info
*thread
=
4171 (struct thread_info
*) find_inferior_id (&all_threads
,
4174 thread
= get_first_thread ();
4175 thread_id
= thread
->entry
.id
;
4178 general_thread
= thread_id
;
4179 set_desired_thread ();
4180 gdb_assert (current_thread
!= NULL
);
4182 else if (own_buf
[1] == 'c')
4183 cont_thread
= thread_id
;
4189 /* Silently ignore it so that gdb can extend the protocol
4190 without compatibility headaches. */
4195 require_running_or_break (own_buf
);
4196 if (current_traceframe
>= 0)
4198 struct regcache
*regcache
4199 = new_register_cache (current_target_desc ());
4201 if (fetch_traceframe_registers (current_traceframe
,
4203 registers_to_string (regcache
, own_buf
);
4205 write_enn (own_buf
);
4206 free_register_cache (regcache
);
4210 struct regcache
*regcache
;
4212 if (!set_desired_thread ())
4213 write_enn (own_buf
);
4216 regcache
= get_thread_regcache (current_thread
, 1);
4217 registers_to_string (regcache
, own_buf
);
4222 require_running_or_break (own_buf
);
4223 if (current_traceframe
>= 0)
4224 write_enn (own_buf
);
4227 struct regcache
*regcache
;
4229 if (!set_desired_thread ())
4230 write_enn (own_buf
);
4233 regcache
= get_thread_regcache (current_thread
, 1);
4234 registers_from_string (regcache
, &own_buf
[1]);
4240 require_running_or_break (own_buf
);
4241 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4242 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4244 write_enn (own_buf
);
4246 bin2hex (mem_buf
, own_buf
, res
);
4249 require_running_or_break (own_buf
);
4250 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4251 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4254 write_enn (own_buf
);
4257 require_running_or_break (own_buf
);
4258 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4259 &mem_addr
, &len
, &mem_buf
) < 0
4260 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4261 write_enn (own_buf
);
4266 require_running_or_break (own_buf
);
4267 hex2bin (own_buf
+ 1, &sig
, 1);
4268 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4269 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4272 myresume (own_buf
, 0, signal
);
4275 require_running_or_break (own_buf
);
4276 hex2bin (own_buf
+ 1, &sig
, 1);
4277 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4278 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4281 myresume (own_buf
, 1, signal
);
4284 require_running_or_break (own_buf
);
4286 myresume (own_buf
, 0, signal
);
4289 require_running_or_break (own_buf
);
4291 myresume (own_buf
, 1, signal
);
4293 case 'Z': /* insert_ ... */
4295 case 'z': /* remove_ ... */
4300 char type
= own_buf
[1];
4302 const int insert
= ch
== 'Z';
4303 const char *p
= &own_buf
[3];
4305 p
= unpack_varlen_hex (p
, &addr
);
4306 kind
= strtol (p
+ 1, &dataptr
, 16);
4310 struct gdb_breakpoint
*bp
;
4312 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4317 /* GDB may have sent us a list of *point parameters to
4318 be evaluated on the target's side. Read such list
4319 here. If we already have a list of parameters, GDB
4320 is telling us to drop that list and use this one
4322 clear_breakpoint_conditions_and_commands (bp
);
4323 const char *options
= dataptr
;
4324 process_point_options (bp
, &options
);
4328 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4336 write_enn (own_buf
);
4340 response_needed
= 0;
4341 if (!target_running ())
4342 /* The packet we received doesn't make sense - but we can't
4343 reply to it, either. */
4346 fprintf (stderr
, "Killing all inferiors\n");
4347 for_each_inferior (&all_processes
, kill_inferior_callback
);
4349 /* When using the extended protocol, we wait with no program
4350 running. The traditional protocol will exit instead. */
4351 if (extended_protocol
)
4353 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4354 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4362 require_running_or_break (own_buf
);
4364 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4365 if (find_thread_ptid (thread_id
) == NULL
)
4367 write_enn (own_buf
);
4371 if (mythread_alive (thread_id
))
4374 write_enn (own_buf
);
4378 response_needed
= 0;
4380 /* Restarting the inferior is only supported in the extended
4382 if (extended_protocol
)
4384 if (target_running ())
4385 for_each_inferior (&all_processes
,
4386 kill_inferior_callback
);
4387 fprintf (stderr
, "GDBserver restarting\n");
4389 /* Wait till we are at 1st instruction in prog. */
4390 if (program_name
!= NULL
)
4392 create_inferior (program_name
, program_args
);
4394 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4396 /* Stopped at the first instruction of the target
4398 general_thread
= last_ptid
;
4402 /* Something went wrong. */
4403 general_thread
= null_ptid
;
4408 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4409 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4415 /* It is a request we don't understand. Respond with an
4416 empty packet so that gdb knows that we don't support this
4422 /* Extended (long) request. */
4423 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4427 /* It is a request we don't understand. Respond with an empty
4428 packet so that gdb knows that we don't support this
4434 if (new_packet_len
!= -1)
4435 putpkt_binary (own_buf
, new_packet_len
);
4439 response_needed
= 0;
4447 /* Event-loop callback for serial events. */
4450 handle_serial_event (int err
, gdb_client_data client_data
)
4453 debug_printf ("handling possible serial event\n");
4455 /* Really handle it. */
4456 if (process_serial_event () < 0)
4459 /* Be sure to not change the selected thread behind GDB's back.
4460 Important in the non-stop mode asynchronous protocol. */
4461 set_desired_thread ();
4466 /* Push a stop notification on the notification queue. */
4469 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4471 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4473 vstop_notif
->status
= *status
;
4474 vstop_notif
->ptid
= ptid
;
4475 /* Push Stop notification. */
4476 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4479 /* Event-loop callback for target events. */
4482 handle_target_event (int err
, gdb_client_data client_data
)
4485 debug_printf ("handling possible target event\n");
4487 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4490 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4492 if (gdb_connected () && report_no_resumed
)
4493 push_stop_notification (null_ptid
, &last_status
);
4495 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4497 int pid
= ptid_get_pid (last_ptid
);
4498 struct process_info
*process
= find_process_pid (pid
);
4499 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4501 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4502 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4504 mark_breakpoints_out (process
);
4505 target_mourn_inferior (last_ptid
);
4507 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4511 /* We're reporting this thread as stopped. Update its
4512 "want-stopped" state to what the client wants, until it
4513 gets a new resume action. */
4514 current_thread
->last_resume_kind
= resume_stop
;
4515 current_thread
->last_status
= last_status
;
4520 if (!target_running ())
4522 /* The last process exited. We're done. */
4526 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4527 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4528 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4532 /* A thread stopped with a signal, but gdb isn't
4533 connected to handle it. Pass it down to the
4534 inferior, as if it wasn't being traced. */
4535 enum gdb_signal signal
;
4538 debug_printf ("GDB not connected; forwarding event %d for"
4540 (int) last_status
.kind
,
4541 target_pid_to_str (last_ptid
));
4543 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4544 signal
= last_status
.value
.sig
;
4546 signal
= GDB_SIGNAL_0
;
4547 target_continue (last_ptid
, signal
);
4551 push_stop_notification (last_ptid
, &last_status
);
4554 /* Be sure to not change the selected thread behind GDB's back.
4555 Important in the non-stop mode asynchronous protocol. */
4556 set_desired_thread ();
4569 } // namespace selftests
4570 #endif /* GDB_SELF_TEST */