1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
43 #include "common/selftest.h"
45 #define require_running_or_return(BUF) \
46 if (!target_running ()) \
52 #define require_running_or_break(BUF) \
53 if (!target_running ()) \
59 /* The environment to pass to the inferior when creating it. */
61 static gdb_environ our_environ
;
63 /* Start the inferior using a shell. */
65 /* We always try to start the inferior using a shell. */
67 int startup_with_shell
= 1;
69 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
70 `vCont'. Note the multi-process extensions made `vCont' a
71 requirement, so `Hc pPID.TID' is pretty much undefined. So
72 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
73 resuming all threads of the process (again, `Hc' isn't used for
74 multi-process), or a specific thread ptid_t. */
77 /* The thread set with an `Hg' packet. */
78 ptid_t general_thread
;
82 static int extended_protocol
;
83 static int response_needed
;
84 static int exit_requested
;
86 /* --once: Exit after the first connection has closed. */
90 int report_fork_events
;
91 int report_vfork_events
;
92 int report_exec_events
;
93 int report_thread_events
;
95 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
96 static int report_no_resumed
;
102 /* True if the "vContSupported" feature is active. In that case, GDB
103 wants us to report whether single step is supported in the reply to
105 static int vCont_supported
;
107 /* Whether we should attempt to disable the operating system's address
108 space randomization feature before starting an inferior. */
109 int disable_randomization
= 1;
111 static char *program_name
= NULL
;
112 static std::vector
<char *> program_args
;
113 static std::string wrapper_argv
;
115 int pass_signals
[GDB_SIGNAL_LAST
];
116 int program_signals
[GDB_SIGNAL_LAST
];
117 int program_signals_p
;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid
;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 int disable_packet_vCont
;
130 int disable_packet_Tthread
;
131 int disable_packet_qC
;
132 int disable_packet_qfThreadInfo
;
134 /* Last status reported to GDB. */
135 struct target_waitstatus last_status
;
139 static unsigned char *mem_buf
;
141 /* A sub-class of 'struct notif_event' for stop, holding information
142 relative to a single stop reply. We keep a queue of these to
143 push to GDB in non-stop mode. */
147 struct notif_event base
;
149 /* Thread or process that got the event. */
153 struct target_waitstatus status
;
156 /* The current btrace configuration. This is gdbserver's mirror of GDB's
157 btrace configuration. */
158 static struct btrace_config current_btrace_conf
;
160 DEFINE_QUEUE_P (notif_event_p
);
162 /* Put a stop reply to the stop reply queue. */
165 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
167 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
169 new_notif
->ptid
= ptid
;
170 new_notif
->status
= *status
;
172 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
176 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
177 QUEUE_ITER (notif_event_p
) *iter
,
178 struct notif_event
*event
,
181 ptid_t filter_ptid
= *(ptid_t
*) data
;
182 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
184 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
186 if (q
->free_func
!= NULL
)
187 q
->free_func (event
);
189 QUEUE_remove_elem (notif_event_p
, q
, iter
);
198 discard_queued_stop_replies (ptid_t ptid
)
200 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
201 remove_all_on_match_ptid
, &ptid
);
205 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
207 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
209 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
212 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
215 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
216 QUEUE_ITER (notif_event_p
) *iter
,
217 struct notif_event
*event
,
220 ptid_t filter_ptid
= *(ptid_t
*) data
;
221 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
223 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
226 /* Don't resume fork children that GDB does not know about yet. */
227 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
228 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
229 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
238 in_queued_stop_replies (ptid_t ptid
)
240 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
241 in_queued_stop_replies_ptid
, &ptid
);
244 struct notif_server notif_stop
=
246 "vStopped", "Stop", NULL
, vstop_notif_reply
,
250 target_running (void)
252 return get_first_thread () != NULL
;
255 /* See common/common-inferior.h. */
260 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
263 /* See common/common-inferior.h. */
266 get_exec_file (int err
)
268 if (err
&& program_name
== NULL
)
269 error (_("No executable file specified."));
283 attach_inferior (int pid
)
285 /* myattach should return -1 if attaching is unsupported,
286 0 if it succeeded, and call error() otherwise. */
288 if (myattach (pid
) != 0)
291 fprintf (stderr
, "Attached; pid = %d\n", pid
);
294 /* FIXME - It may be that we should get the SIGNAL_PID from the
295 attach function, so that it can be the main thread instead of
296 whichever we were told to attach to. */
301 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
303 /* GDB knows to ignore the first SIGSTOP after attaching to a running
304 process using the "attach" command, but this is different; it's
305 just using "target remote". Pretend it's just starting up. */
306 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
307 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
308 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
310 current_thread
->last_resume_kind
= resume_stop
;
311 current_thread
->last_status
= last_status
;
317 extern int remote_debug
;
319 /* Decode a qXfer read request. Return 0 if everything looks OK,
323 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
325 /* After the read marker and annex, qXfer looks like a
326 traditional 'm' packet. */
327 decode_m_packet (buf
, ofs
, len
);
333 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
335 /* Extract and NUL-terminate the object. */
337 while (*buf
&& *buf
!= ':')
343 /* Extract and NUL-terminate the read/write action. */
345 while (*buf
&& *buf
!= ':')
351 /* Extract and NUL-terminate the annex. */
353 while (*buf
&& *buf
!= ':')
363 /* Write the response to a successful qXfer read. Returns the
364 length of the (binary) data stored in BUF, corresponding
365 to as much of DATA/LEN as we could fit. IS_MORE controls
366 the first character of the response. */
368 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
377 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
378 &out_len
, PBUFSIZ
- 2) + 1;
381 /* Handle btrace enabling in BTS format. */
384 handle_btrace_enable_bts (struct thread_info
*thread
)
386 if (thread
->btrace
!= NULL
)
387 return "E.Btrace already enabled.";
389 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
390 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
391 ¤t_btrace_conf
);
392 if (thread
->btrace
== NULL
)
393 return "E.Could not enable btrace.";
398 /* Handle btrace enabling in Intel Processor Trace format. */
401 handle_btrace_enable_pt (struct thread_info
*thread
)
403 if (thread
->btrace
!= NULL
)
404 return "E.Btrace already enabled.";
406 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
407 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
408 ¤t_btrace_conf
);
409 if (thread
->btrace
== NULL
)
410 return "E.Could not enable btrace.";
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 return "E.Branch tracing not enabled.";
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 return "E.Could not disable branch tracing.";
427 thread
->btrace
= NULL
;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf
)
436 struct thread_info
*thread
;
440 if (!startswith (own_buf
, "Qbtrace:"))
443 op
= own_buf
+ strlen ("Qbtrace:");
445 if (ptid_equal (general_thread
, null_ptid
)
446 || ptid_equal (general_thread
, minus_one_ptid
))
448 strcpy (own_buf
, "E.Must select a single thread.");
452 thread
= find_thread_ptid (general_thread
);
455 strcpy (own_buf
, "E.No such thread.");
461 if (strcmp (op
, "bts") == 0)
462 err
= handle_btrace_enable_bts (thread
);
463 else if (strcmp (op
, "pt") == 0)
464 err
= handle_btrace_enable_pt (thread
);
465 else if (strcmp (op
, "off") == 0)
466 err
= handle_btrace_disable (thread
);
468 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
471 strcpy (own_buf
, err
);
478 /* Handle the "Qbtrace-conf" packet. */
481 handle_btrace_conf_general_set (char *own_buf
)
483 struct thread_info
*thread
;
486 if (!startswith (own_buf
, "Qbtrace-conf:"))
489 op
= own_buf
+ strlen ("Qbtrace-conf:");
491 if (ptid_equal (general_thread
, null_ptid
)
492 || ptid_equal (general_thread
, minus_one_ptid
))
494 strcpy (own_buf
, "E.Must select a single thread.");
498 thread
= find_thread_ptid (general_thread
);
501 strcpy (own_buf
, "E.No such thread.");
505 if (startswith (op
, "bts:size="))
511 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
512 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
514 strcpy (own_buf
, "E.Bad size value.");
518 current_btrace_conf
.bts
.size
= (unsigned int) size
;
520 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
526 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
527 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
529 strcpy (own_buf
, "E.Bad size value.");
533 current_btrace_conf
.pt
.size
= (unsigned int) size
;
537 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
545 /* Handle all of the extended 'Q' packets. */
548 handle_general_set (char *own_buf
)
550 if (startswith (own_buf
, "QPassSignals:"))
552 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
553 const char *p
= own_buf
+ strlen ("QPassSignals:");
556 p
= decode_address_to_semicolon (&cursig
, p
);
557 for (i
= 0; i
< numsigs
; i
++)
563 /* Keep looping, to clear the remaining signals. */
566 p
= decode_address_to_semicolon (&cursig
, p
);
571 strcpy (own_buf
, "OK");
575 if (startswith (own_buf
, "QProgramSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QProgramSignals:");
581 program_signals_p
= 1;
583 p
= decode_address_to_semicolon (&cursig
, p
);
584 for (i
= 0; i
< numsigs
; i
++)
588 program_signals
[i
] = 1;
590 /* Keep looping, to clear the remaining signals. */
593 p
= decode_address_to_semicolon (&cursig
, p
);
596 program_signals
[i
] = 0;
598 strcpy (own_buf
, "OK");
602 if (startswith (own_buf
, "QCatchSyscalls:"))
604 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
607 struct process_info
*process
;
609 if (!target_running () || !target_supports_catch_syscall ())
615 if (strcmp (p
, "0") == 0)
617 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
621 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
627 process
= current_process ();
628 VEC_truncate (int, process
->syscalls_to_catch
, 0);
638 p
= decode_address_to_semicolon (&sysno
, p
);
639 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
643 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
650 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
652 our_environ
= gdb_environ::from_host_environ ();
658 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
660 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
661 /* The final form of the environment variable. FINAL_VAR will
662 hold the 'VAR=VALUE' format. */
663 std::string final_var
= hex2str (p
);
664 std::string var_name
, var_value
;
668 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
669 debug_printf (_("[Environment variable to be set: '%s']\n"),
674 size_t pos
= final_var
.find ('=');
675 if (pos
== std::string::npos
)
677 warning (_("Unexpected format for environment variable: '%s'"),
683 var_name
= final_var
.substr (0, pos
);
684 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
686 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
692 if (startswith (own_buf
, "QEnvironmentUnset:"))
694 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
695 std::string varname
= hex2str (p
);
699 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
700 debug_printf (_("[Environment variable to be unset: '%s']\n"),
705 our_environ
.unset (varname
.c_str ());
711 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
715 debug_printf ("[noack mode enabled]\n");
724 if (startswith (own_buf
, "QNonStop:"))
726 char *mode
= own_buf
+ 9;
730 if (strcmp (mode
, "0") == 0)
732 else if (strcmp (mode
, "1") == 0)
736 /* We don't know what this mode is, so complain to
738 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
744 req_str
= req
? "non-stop" : "all-stop";
745 if (start_non_stop (req
) != 0)
747 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
755 debug_printf ("[%s mode enabled]\n", req_str
);
761 if (startswith (own_buf
, "QDisableRandomization:"))
763 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
766 unpack_varlen_hex (packet
, &setting
);
767 disable_randomization
= setting
;
771 debug_printf (disable_randomization
772 ? "[address space randomization disabled]\n"
773 : "[address space randomization enabled]\n");
780 if (target_supports_tracepoints ()
781 && handle_tracepoint_general_set (own_buf
))
784 if (startswith (own_buf
, "QAgent:"))
786 char *mode
= own_buf
+ strlen ("QAgent:");
789 if (strcmp (mode
, "0") == 0)
791 else if (strcmp (mode
, "1") == 0)
795 /* We don't know what this value is, so complain to GDB. */
796 sprintf (own_buf
, "E.Unknown QAgent value");
800 /* Update the flag. */
803 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
808 if (handle_btrace_general_set (own_buf
))
811 if (handle_btrace_conf_general_set (own_buf
))
814 if (startswith (own_buf
, "QThreadEvents:"))
816 char *mode
= own_buf
+ strlen ("QThreadEvents:");
817 enum tribool req
= TRIBOOL_UNKNOWN
;
819 if (strcmp (mode
, "0") == 0)
821 else if (strcmp (mode
, "1") == 0)
825 char *mode_copy
= xstrdup (mode
);
827 /* We don't know what this mode is, so complain to GDB. */
828 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
834 report_thread_events
= (req
== TRIBOOL_TRUE
);
838 const char *req_str
= report_thread_events
? "enabled" : "disabled";
840 debug_printf ("[thread events are now %s]\n", req_str
);
847 if (startswith (own_buf
, "QStartupWithShell:"))
849 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
851 if (strcmp (value
, "1") == 0)
852 startup_with_shell
= true;
853 else if (strcmp (value
, "0") == 0)
854 startup_with_shell
= false;
858 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
865 debug_printf (_("[Inferior will %s started with shell]"),
866 startup_with_shell
? "be" : "not be");
872 /* Otherwise we didn't know what packet it was. Say we didn't
878 get_features_xml (const char *annex
)
880 const struct target_desc
*desc
= current_target_desc ();
882 /* `desc->xmltarget' defines what to return when looking for the
883 "target.xml" file. Its contents can either be verbatim XML code
884 (prefixed with a '@') or else the name of the actual XML file to
885 be used in place of "target.xml".
887 This variable is set up from the auto-generated
888 init_registers_... routine for the current target. */
890 if (strcmp (annex
, "target.xml") == 0)
892 const char *ret
= tdesc_get_features_xml ((target_desc
*) desc
);
902 extern const char *const xml_builtin
[][2];
905 /* Look for the annex. */
906 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
907 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
910 if (xml_builtin
[i
][0] != NULL
)
911 return xml_builtin
[i
][1];
919 monitor_show_help (void)
921 monitor_output ("The following monitor commands are supported:\n");
922 monitor_output (" set debug <0|1>\n");
923 monitor_output (" Enable general debugging messages\n");
924 monitor_output (" set debug-hw-points <0|1>\n");
925 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
926 monitor_output (" set remote-debug <0|1>\n");
927 monitor_output (" Enable remote protocol debugging messages\n");
928 monitor_output (" set debug-format option1[,option2,...]\n");
929 monitor_output (" Add additional information to debugging messages\n");
930 monitor_output (" Options: all, none");
931 monitor_output (", timestamp");
932 monitor_output ("\n");
933 monitor_output (" exit\n");
934 monitor_output (" Quit GDBserver\n");
937 /* Read trace frame or inferior memory. Returns the number of bytes
938 actually read, zero when no further transfer is possible, and -1 on
939 error. Return of a positive value smaller than LEN does not
940 indicate there's no more to be read, only the end of the transfer.
941 E.g., when GDB reads memory from a traceframe, a first request may
942 be served from a memory block that does not cover the whole request
943 length. A following request gets the rest served from either
944 another block (of the same traceframe) or from the read-only
948 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
952 if (current_traceframe
>= 0)
955 ULONGEST length
= len
;
957 if (traceframe_read_mem (current_traceframe
,
958 memaddr
, myaddr
, len
, &nbytes
))
960 /* Data read from trace buffer, we're done. */
963 if (!in_readonly_region (memaddr
, length
))
965 /* Otherwise we have a valid readonly case, fall through. */
966 /* (assume no half-trace half-real blocks for now) */
969 res
= prepare_to_access_memory ();
972 if (set_desired_thread (1))
973 res
= read_inferior_memory (memaddr
, myaddr
, len
);
976 done_accessing_memory ();
978 return res
== 0 ? len
: -1;
984 /* Write trace frame or inferior memory. Actually, writing to trace
985 frames is forbidden. */
988 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
990 if (current_traceframe
>= 0)
996 ret
= prepare_to_access_memory ();
999 if (set_desired_thread (1))
1000 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1003 done_accessing_memory ();
1009 /* Subroutine of handle_search_memory to simplify it. */
1012 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1013 gdb_byte
*pattern
, unsigned pattern_len
,
1014 gdb_byte
*search_buf
,
1015 unsigned chunk_size
, unsigned search_buf_size
,
1016 CORE_ADDR
*found_addrp
)
1018 /* Prime the search buffer. */
1020 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1023 warning ("Unable to access %ld bytes of target "
1024 "memory at 0x%lx, halting search.",
1025 (long) search_buf_size
, (long) start_addr
);
1029 /* Perform the search.
1031 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1032 When we've scanned N bytes we copy the trailing bytes to the start and
1033 read in another N bytes. */
1035 while (search_space_len
>= pattern_len
)
1037 gdb_byte
*found_ptr
;
1038 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1042 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1045 if (found_ptr
!= NULL
)
1047 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1048 *found_addrp
= found_addr
;
1052 /* Not found in this chunk, skip to next chunk. */
1054 /* Don't let search_space_len wrap here, it's unsigned. */
1055 if (search_space_len
>= chunk_size
)
1056 search_space_len
-= chunk_size
;
1058 search_space_len
= 0;
1060 if (search_space_len
>= pattern_len
)
1062 unsigned keep_len
= search_buf_size
- chunk_size
;
1063 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1066 /* Copy the trailing part of the previous iteration to the front
1067 of the buffer for the next iteration. */
1068 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1070 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1071 ? search_space_len
- keep_len
1074 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1075 nr_to_read
) != search_buf_size
)
1077 warning ("Unable to access %ld bytes of target memory "
1078 "at 0x%lx, halting search.",
1079 (long) nr_to_read
, (long) read_addr
);
1083 start_addr
+= chunk_size
;
1092 /* Handle qSearch:memory packets. */
1095 handle_search_memory (char *own_buf
, int packet_len
)
1097 CORE_ADDR start_addr
;
1098 CORE_ADDR search_space_len
;
1100 unsigned int pattern_len
;
1101 /* NOTE: also defined in find.c testcase. */
1102 #define SEARCH_CHUNK_SIZE 16000
1103 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1104 /* Buffer to hold memory contents for searching. */
1105 gdb_byte
*search_buf
;
1106 unsigned search_buf_size
;
1108 CORE_ADDR found_addr
;
1109 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1111 pattern
= (gdb_byte
*) malloc (packet_len
);
1112 if (pattern
== NULL
)
1114 error ("Unable to allocate memory to perform the search");
1115 strcpy (own_buf
, "E00");
1118 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1119 packet_len
- cmd_name_len
,
1120 &start_addr
, &search_space_len
,
1121 pattern
, &pattern_len
) < 0)
1124 error ("Error in parsing qSearch:memory packet");
1125 strcpy (own_buf
, "E00");
1129 search_buf_size
= chunk_size
+ pattern_len
- 1;
1131 /* No point in trying to allocate a buffer larger than the search space. */
1132 if (search_space_len
< search_buf_size
)
1133 search_buf_size
= search_space_len
;
1135 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1136 if (search_buf
== NULL
)
1139 error ("Unable to allocate memory to perform the search");
1140 strcpy (own_buf
, "E00");
1144 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1145 pattern
, pattern_len
,
1146 search_buf
, chunk_size
, search_buf_size
,
1150 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1151 else if (found
== 0)
1152 strcpy (own_buf
, "0");
1154 strcpy (own_buf
, "E00");
1160 /* Handle the "D" packet. */
1163 handle_detach (char *own_buf
)
1165 require_running_or_return (own_buf
);
1172 pid
= strtol (&own_buf
[2], NULL
, 16);
1175 pid
= ptid_get_pid (current_ptid
);
1177 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
1179 struct process_info
*process
= find_process_pid (pid
);
1181 if (process
== NULL
)
1183 write_enn (own_buf
);
1187 if (tracing
&& disconnected_tracing
)
1189 "Disconnected tracing in effect, "
1190 "leaving gdbserver attached to the process\n");
1192 if (any_persistent_commands ())
1194 "Persistent commands are present, "
1195 "leaving gdbserver attached to the process\n");
1197 /* Make sure we're in non-stop/async mode, so we we can both
1198 wait for an async socket accept, and handle async target
1199 events simultaneously. There's also no point either in
1200 having the target stop all threads, when we're going to
1201 pass signals down without informing GDB. */
1205 debug_printf ("Forcing non-stop mode\n");
1211 process
->gdb_detached
= 1;
1213 /* Detaching implicitly resumes all threads. */
1214 target_continue_no_signal (minus_one_ptid
);
1220 fprintf (stderr
, "Detaching from process %d\n", pid
);
1222 if (detach_inferior (pid
) != 0)
1223 write_enn (own_buf
);
1226 discard_queued_stop_replies (pid_to_ptid (pid
));
1229 if (extended_protocol
|| target_running ())
1231 /* There is still at least one inferior remaining or
1232 we are in extended mode, so don't terminate gdbserver,
1233 and instead treat this like a normal program exit. */
1234 last_status
.kind
= TARGET_WAITKIND_EXITED
;
1235 last_status
.value
.integer
= 0;
1236 last_ptid
= pid_to_ptid (pid
);
1238 current_thread
= NULL
;
1245 /* If we are attached, then we can exit. Otherwise, we
1246 need to hang around doing nothing, until the child is
1248 join_inferior (pid
);
1254 /* Parse options to --debug-format= and "monitor set debug-format".
1255 ARG is the text after "--debug-format=" or "monitor set debug-format".
1256 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1257 This triggers calls to monitor_output.
1258 The result is NULL if all options were parsed ok, otherwise an error
1259 message which the caller must free.
1261 N.B. These commands affect all debug format settings, they are not
1262 cumulative. If a format is not specified, it is turned off.
1263 However, we don't go to extra trouble with things like
1264 "monitor set debug-format all,none,timestamp".
1265 Instead we just parse them one at a time, in order.
1267 The syntax for "monitor set debug" we support here is not identical
1268 to gdb's "set debug foo on|off" because we also use this function to
1269 parse "--debug-format=foo,bar". */
1272 parse_debug_format_options (const char *arg
, int is_monitor
)
1274 VEC (char_ptr
) *options
;
1278 /* First turn all debug format options off. */
1279 debug_timestamp
= 0;
1281 /* First remove leading spaces, for "monitor set debug-format". */
1282 while (isspace (*arg
))
1285 options
= delim_string_to_char_ptr_vec (arg
, ',');
1287 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1289 if (strcmp (option
, "all") == 0)
1291 debug_timestamp
= 1;
1293 monitor_output ("All extra debug format options enabled.\n");
1295 else if (strcmp (option
, "none") == 0)
1297 debug_timestamp
= 0;
1299 monitor_output ("All extra debug format options disabled.\n");
1301 else if (strcmp (option
, "timestamp") == 0)
1303 debug_timestamp
= 1;
1305 monitor_output ("Timestamps will be added to debug output.\n");
1307 else if (*option
== '\0')
1309 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1314 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1317 free_char_ptr_vec (options
);
1322 free_char_ptr_vec (options
);
1326 /* Handle monitor commands not handled by target-specific handlers. */
1329 handle_monitor_command (char *mon
, char *own_buf
)
1331 if (strcmp (mon
, "set debug 1") == 0)
1334 monitor_output ("Debug output enabled.\n");
1336 else if (strcmp (mon
, "set debug 0") == 0)
1339 monitor_output ("Debug output disabled.\n");
1341 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1343 show_debug_regs
= 1;
1344 monitor_output ("H/W point debugging output enabled.\n");
1346 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1348 show_debug_regs
= 0;
1349 monitor_output ("H/W point debugging output disabled.\n");
1351 else if (strcmp (mon
, "set remote-debug 1") == 0)
1354 monitor_output ("Protocol debug output enabled.\n");
1356 else if (strcmp (mon
, "set remote-debug 0") == 0)
1359 monitor_output ("Protocol debug output disabled.\n");
1361 else if (startswith (mon
, "set debug-format "))
1364 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1367 if (error_msg
!= NULL
)
1369 monitor_output (error_msg
);
1370 monitor_show_help ();
1371 write_enn (own_buf
);
1375 else if (strcmp (mon
, "help") == 0)
1376 monitor_show_help ();
1377 else if (strcmp (mon
, "exit") == 0)
1381 monitor_output ("Unknown monitor command.\n\n");
1382 monitor_show_help ();
1383 write_enn (own_buf
);
1387 /* Associates a callback with each supported qXfer'able object. */
1391 /* The object this handler handles. */
1394 /* Request that the target transfer up to LEN 8-bit bytes of the
1395 target's OBJECT. The OFFSET, for a seekable object, specifies
1396 the starting point. The ANNEX can be used to provide additional
1397 data-specific information to the target.
1399 Return the number of bytes actually transfered, zero when no
1400 further transfer is possible, -1 on error, -2 when the transfer
1401 is not supported, and -3 on a verbose error message that should
1402 be preserved. Return of a positive value smaller than LEN does
1403 not indicate the end of the object, only the end of the transfer.
1405 One, and only one, of readbuf or writebuf must be non-NULL. */
1406 int (*xfer
) (const char *annex
,
1407 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1408 ULONGEST offset
, LONGEST len
);
1411 /* Handle qXfer:auxv:read. */
1414 handle_qxfer_auxv (const char *annex
,
1415 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1416 ULONGEST offset
, LONGEST len
)
1418 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1421 if (annex
[0] != '\0' || current_thread
== NULL
)
1424 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1427 /* Handle qXfer:exec-file:read. */
1430 handle_qxfer_exec_file (const char *const_annex
,
1431 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1432 ULONGEST offset
, LONGEST len
)
1438 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1441 if (const_annex
[0] == '\0')
1443 if (current_thread
== NULL
)
1446 pid
= pid_of (current_thread
);
1450 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1452 strcpy (annex
, const_annex
);
1453 annex
= unpack_varlen_hex (annex
, &pid
);
1455 if (annex
[0] != '\0')
1462 file
= (*the_target
->pid_to_exec_file
) (pid
);
1466 total_len
= strlen (file
);
1468 if (offset
> total_len
)
1471 if (offset
+ len
> total_len
)
1472 len
= total_len
- offset
;
1474 memcpy (readbuf
, file
+ offset
, len
);
1478 /* Handle qXfer:features:read. */
1481 handle_qxfer_features (const char *annex
,
1482 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1483 ULONGEST offset
, LONGEST len
)
1485 const char *document
;
1488 if (writebuf
!= NULL
)
1491 if (!target_running ())
1494 /* Grab the correct annex. */
1495 document
= get_features_xml (annex
);
1496 if (document
== NULL
)
1499 total_len
= strlen (document
);
1501 if (offset
> total_len
)
1504 if (offset
+ len
> total_len
)
1505 len
= total_len
- offset
;
1507 memcpy (readbuf
, document
+ offset
, len
);
1511 /* Worker routine for handle_qxfer_libraries.
1512 Add to the length pointed to by ARG a conservative estimate of the
1513 length needed to transmit the file name of INF. */
1516 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1518 struct dll_info
*dll
= (struct dll_info
*) inf
;
1519 unsigned int *total_len
= (unsigned int *) arg
;
1521 /* Over-estimate the necessary memory. Assume that every character
1522 in the library name must be escaped. */
1523 *total_len
+= 128 + 6 * strlen (dll
->name
);
1526 /* Worker routine for handle_qxfer_libraries.
1527 Emit the XML to describe the library in INF. */
1530 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1532 struct dll_info
*dll
= (struct dll_info
*) inf
;
1533 char **p_ptr
= (char **) arg
;
1537 strcpy (p
, " <library name=\"");
1539 name
= xml_escape_text (dll
->name
);
1543 strcpy (p
, "\"><segment address=\"");
1545 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1547 strcpy (p
, "\"/></library>\n");
1553 /* Handle qXfer:libraries:read. */
1556 handle_qxfer_libraries (const char *annex
,
1557 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1558 ULONGEST offset
, LONGEST len
)
1560 unsigned int total_len
;
1563 if (writebuf
!= NULL
)
1566 if (annex
[0] != '\0' || current_thread
== NULL
)
1570 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1573 document
= (char *) malloc (total_len
);
1574 if (document
== NULL
)
1577 strcpy (document
, "<library-list version=\"1.0\">\n");
1578 p
= document
+ strlen (document
);
1580 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1582 strcpy (p
, "</library-list>\n");
1584 total_len
= strlen (document
);
1586 if (offset
> total_len
)
1592 if (offset
+ len
> total_len
)
1593 len
= total_len
- offset
;
1595 memcpy (readbuf
, document
+ offset
, len
);
1600 /* Handle qXfer:libraries-svr4:read. */
1603 handle_qxfer_libraries_svr4 (const char *annex
,
1604 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1605 ULONGEST offset
, LONGEST len
)
1607 if (writebuf
!= NULL
)
1610 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1613 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1616 /* Handle qXfer:osadata:read. */
1619 handle_qxfer_osdata (const char *annex
,
1620 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1621 ULONGEST offset
, LONGEST len
)
1623 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1626 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1629 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1632 handle_qxfer_siginfo (const char *annex
,
1633 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1634 ULONGEST offset
, LONGEST len
)
1636 if (the_target
->qxfer_siginfo
== NULL
)
1639 if (annex
[0] != '\0' || current_thread
== NULL
)
1642 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1645 /* Handle qXfer:spu:read and qXfer:spu:write. */
1648 handle_qxfer_spu (const char *annex
,
1649 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1650 ULONGEST offset
, LONGEST len
)
1652 if (the_target
->qxfer_spu
== NULL
)
1655 if (current_thread
== NULL
)
1658 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1661 /* Handle qXfer:statictrace:read. */
1664 handle_qxfer_statictrace (const char *annex
,
1665 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1666 ULONGEST offset
, LONGEST len
)
1670 if (writebuf
!= NULL
)
1673 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1676 if (traceframe_read_sdata (current_traceframe
, offset
,
1677 readbuf
, len
, &nbytes
))
1682 /* Helper for handle_qxfer_threads_proper.
1683 Emit the XML to describe the thread of INF. */
1686 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1688 struct thread_info
*thread
= (struct thread_info
*) inf
;
1689 struct buffer
*buffer
= (struct buffer
*) arg
;
1690 ptid_t ptid
= thread_to_gdb_id (thread
);
1692 int core
= target_core_of_thread (ptid
);
1694 const char *name
= target_thread_name (ptid
);
1696 write_ptid (ptid_s
, ptid
);
1698 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1702 sprintf (core_s
, "%d", core
);
1703 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1707 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1709 buffer_xml_printf (buffer
, "/>\n");
1712 /* Helper for handle_qxfer_threads. */
1715 handle_qxfer_threads_proper (struct buffer
*buffer
)
1717 buffer_grow_str (buffer
, "<threads>\n");
1719 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1722 buffer_grow_str0 (buffer
, "</threads>\n");
1725 /* Handle qXfer:threads:read. */
1728 handle_qxfer_threads (const char *annex
,
1729 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1730 ULONGEST offset
, LONGEST len
)
1732 static char *result
= 0;
1733 static unsigned int result_length
= 0;
1735 if (writebuf
!= NULL
)
1738 if (annex
[0] != '\0')
1743 struct buffer buffer
;
1744 /* When asked for data at offset 0, generate everything and store into
1745 'result'. Successive reads will be served off 'result'. */
1749 buffer_init (&buffer
);
1751 handle_qxfer_threads_proper (&buffer
);
1753 result
= buffer_finish (&buffer
);
1754 result_length
= strlen (result
);
1755 buffer_free (&buffer
);
1758 if (offset
>= result_length
)
1760 /* We're out of data. */
1767 if (len
> result_length
- offset
)
1768 len
= result_length
- offset
;
1770 memcpy (readbuf
, result
+ offset
, len
);
1775 /* Handle qXfer:traceframe-info:read. */
1778 handle_qxfer_traceframe_info (const char *annex
,
1779 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1780 ULONGEST offset
, LONGEST len
)
1782 static char *result
= 0;
1783 static unsigned int result_length
= 0;
1785 if (writebuf
!= NULL
)
1788 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1793 struct buffer buffer
;
1795 /* When asked for data at offset 0, generate everything and
1796 store into 'result'. Successive reads will be served off
1800 buffer_init (&buffer
);
1802 traceframe_read_info (current_traceframe
, &buffer
);
1804 result
= buffer_finish (&buffer
);
1805 result_length
= strlen (result
);
1806 buffer_free (&buffer
);
1809 if (offset
>= result_length
)
1811 /* We're out of data. */
1818 if (len
> result_length
- offset
)
1819 len
= result_length
- offset
;
1821 memcpy (readbuf
, result
+ offset
, len
);
1825 /* Handle qXfer:fdpic:read. */
1828 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1829 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1831 if (the_target
->read_loadmap
== NULL
)
1834 if (current_thread
== NULL
)
1837 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1840 /* Handle qXfer:btrace:read. */
1843 handle_qxfer_btrace (const char *annex
,
1844 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1845 ULONGEST offset
, LONGEST len
)
1847 static struct buffer cache
;
1848 struct thread_info
*thread
;
1849 enum btrace_read_type type
;
1852 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1855 if (ptid_equal (general_thread
, null_ptid
)
1856 || ptid_equal (general_thread
, minus_one_ptid
))
1858 strcpy (own_buf
, "E.Must select a single thread.");
1862 thread
= find_thread_ptid (general_thread
);
1865 strcpy (own_buf
, "E.No such thread.");
1869 if (thread
->btrace
== NULL
)
1871 strcpy (own_buf
, "E.Btrace not enabled.");
1875 if (strcmp (annex
, "all") == 0)
1876 type
= BTRACE_READ_ALL
;
1877 else if (strcmp (annex
, "new") == 0)
1878 type
= BTRACE_READ_NEW
;
1879 else if (strcmp (annex
, "delta") == 0)
1880 type
= BTRACE_READ_DELTA
;
1883 strcpy (own_buf
, "E.Bad annex.");
1889 buffer_free (&cache
);
1891 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1894 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1898 else if (offset
> cache
.used_size
)
1900 buffer_free (&cache
);
1904 if (len
> cache
.used_size
- offset
)
1905 len
= cache
.used_size
- offset
;
1907 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1912 /* Handle qXfer:btrace-conf:read. */
1915 handle_qxfer_btrace_conf (const char *annex
,
1916 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1917 ULONGEST offset
, LONGEST len
)
1919 static struct buffer cache
;
1920 struct thread_info
*thread
;
1923 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1926 if (annex
[0] != '\0')
1929 if (ptid_equal (general_thread
, null_ptid
)
1930 || ptid_equal (general_thread
, minus_one_ptid
))
1932 strcpy (own_buf
, "E.Must select a single thread.");
1936 thread
= find_thread_ptid (general_thread
);
1939 strcpy (own_buf
, "E.No such thread.");
1943 if (thread
->btrace
== NULL
)
1945 strcpy (own_buf
, "E.Btrace not enabled.");
1951 buffer_free (&cache
);
1953 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1956 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1960 else if (offset
> cache
.used_size
)
1962 buffer_free (&cache
);
1966 if (len
> cache
.used_size
- offset
)
1967 len
= cache
.used_size
- offset
;
1969 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1974 static const struct qxfer qxfer_packets
[] =
1976 { "auxv", handle_qxfer_auxv
},
1977 { "btrace", handle_qxfer_btrace
},
1978 { "btrace-conf", handle_qxfer_btrace_conf
},
1979 { "exec-file", handle_qxfer_exec_file
},
1980 { "fdpic", handle_qxfer_fdpic
},
1981 { "features", handle_qxfer_features
},
1982 { "libraries", handle_qxfer_libraries
},
1983 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1984 { "osdata", handle_qxfer_osdata
},
1985 { "siginfo", handle_qxfer_siginfo
},
1986 { "spu", handle_qxfer_spu
},
1987 { "statictrace", handle_qxfer_statictrace
},
1988 { "threads", handle_qxfer_threads
},
1989 { "traceframe-info", handle_qxfer_traceframe_info
},
1993 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2001 if (!startswith (own_buf
, "qXfer:"))
2004 /* Grab the object, r/w and annex. */
2005 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2007 write_enn (own_buf
);
2012 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2015 const struct qxfer
*q
= &qxfer_packets
[i
];
2017 if (strcmp (object
, q
->object
) == 0)
2019 if (strcmp (rw
, "read") == 0)
2021 unsigned char *data
;
2026 /* Grab the offset and length. */
2027 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2029 write_enn (own_buf
);
2033 /* Read one extra byte, as an indicator of whether there is
2035 if (len
> PBUFSIZ
- 2)
2037 data
= (unsigned char *) malloc (len
+ 1);
2040 write_enn (own_buf
);
2043 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2051 /* Preserve error message. */
2054 write_enn (own_buf
);
2056 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2058 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2063 else if (strcmp (rw
, "write") == 0)
2068 unsigned char *data
;
2070 strcpy (own_buf
, "E00");
2071 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2074 write_enn (own_buf
);
2077 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2078 &ofs
, &len
, data
) < 0)
2081 write_enn (own_buf
);
2085 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2093 /* Preserve error message. */
2096 write_enn (own_buf
);
2098 sprintf (own_buf
, "%x", n
);
2111 /* Compute 32 bit CRC from inferior memory.
2113 On success, return 32 bit CRC.
2114 On failure, return (unsigned long long) -1. */
2116 static unsigned long long
2117 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2121 unsigned char byte
= 0;
2123 /* Return failure if memory read fails. */
2124 if (read_inferior_memory (base
, &byte
, 1) != 0)
2125 return (unsigned long long) -1;
2127 crc
= xcrc32 (&byte
, 1, crc
);
2130 return (unsigned long long) crc
;
2133 /* Add supported btrace packets to BUF. */
2136 supported_btrace_packets (char *buf
)
2138 int btrace_supported
= 0;
2140 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2142 strcat (buf
, ";Qbtrace:bts+");
2143 strcat (buf
, ";Qbtrace-conf:bts:size+");
2145 btrace_supported
= 1;
2148 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2150 strcat (buf
, ";Qbtrace:pt+");
2151 strcat (buf
, ";Qbtrace-conf:pt:size+");
2153 btrace_supported
= 1;
2156 if (!btrace_supported
)
2159 strcat (buf
, ";Qbtrace:off+");
2160 strcat (buf
, ";qXfer:btrace:read+");
2161 strcat (buf
, ";qXfer:btrace-conf:read+");
2164 /* Handle all of the extended 'q' packets. */
2167 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2169 static struct inferior_list_entry
*thread_ptr
;
2171 /* Reply the current thread id. */
2172 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2175 require_running_or_return (own_buf
);
2177 if (!ptid_equal (general_thread
, null_ptid
)
2178 && !ptid_equal (general_thread
, minus_one_ptid
))
2179 gdb_id
= general_thread
;
2182 thread_ptr
= get_first_inferior (&all_threads
);
2183 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2186 sprintf (own_buf
, "QC");
2188 write_ptid (own_buf
, gdb_id
);
2192 if (strcmp ("qSymbol::", own_buf
) == 0)
2194 struct thread_info
*save_thread
= current_thread
;
2196 /* For qSymbol, GDB only changes the current thread if the
2197 previous current thread was of a different process. So if
2198 the previous thread is gone, we need to pick another one of
2199 the same process. This can happen e.g., if we followed an
2200 exec in a non-leader thread. */
2201 if (current_thread
== NULL
)
2204 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2206 /* Just in case, if we didn't find a thread, then bail out
2207 instead of crashing. */
2208 if (current_thread
== NULL
)
2210 write_enn (own_buf
);
2211 current_thread
= save_thread
;
2216 /* GDB is suggesting new symbols have been loaded. This may
2217 mean a new shared library has been detected as loaded, so
2218 take the opportunity to check if breakpoints we think are
2219 inserted, still are. Note that it isn't guaranteed that
2220 we'll see this when a shared library is loaded, and nor will
2221 we see this for unloads (although breakpoints in unloaded
2222 libraries shouldn't trigger), as GDB may not find symbols for
2223 the library at all. We also re-validate breakpoints when we
2224 see a second GDB breakpoint for the same address, and or when
2225 we access breakpoint shadows. */
2226 validate_breakpoints ();
2228 if (target_supports_tracepoints ())
2229 tracepoint_look_up_symbols ();
2231 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2232 (*the_target
->look_up_symbols
) ();
2234 current_thread
= save_thread
;
2236 strcpy (own_buf
, "OK");
2240 if (!disable_packet_qfThreadInfo
)
2242 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2246 require_running_or_return (own_buf
);
2247 thread_ptr
= get_first_inferior (&all_threads
);
2250 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2251 write_ptid (own_buf
, gdb_id
);
2252 thread_ptr
= thread_ptr
->next
;
2256 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2260 require_running_or_return (own_buf
);
2261 if (thread_ptr
!= NULL
)
2264 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2265 write_ptid (own_buf
, gdb_id
);
2266 thread_ptr
= thread_ptr
->next
;
2271 sprintf (own_buf
, "l");
2277 if (the_target
->read_offsets
!= NULL
2278 && strcmp ("qOffsets", own_buf
) == 0)
2280 CORE_ADDR text
, data
;
2282 require_running_or_return (own_buf
);
2283 if (the_target
->read_offsets (&text
, &data
))
2284 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2285 (long)text
, (long)data
, (long)data
);
2287 write_enn (own_buf
);
2292 /* Protocol features query. */
2293 if (startswith (own_buf
, "qSupported")
2294 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2296 char *p
= &own_buf
[10];
2297 int gdb_supports_qRelocInsn
= 0;
2299 /* Process each feature being provided by GDB. The first
2300 feature will follow a ':', and latter features will follow
2304 char **qsupported
= NULL
;
2309 /* Two passes, to avoid nested strtok calls in
2310 target_process_qsupported. */
2311 for (p
= strtok (p
+ 1, ";");
2313 p
= strtok (NULL
, ";"))
2316 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2317 qsupported
[count
- 1] = xstrdup (p
);
2320 for (i
= 0; i
< count
; i
++)
2323 if (strcmp (p
, "multiprocess+") == 0)
2325 /* GDB supports and wants multi-process support if
2327 if (target_supports_multi_process ())
2330 else if (strcmp (p
, "qRelocInsn+") == 0)
2332 /* GDB supports relocate instruction requests. */
2333 gdb_supports_qRelocInsn
= 1;
2335 else if (strcmp (p
, "swbreak+") == 0)
2337 /* GDB wants us to report whether a trap is caused
2338 by a software breakpoint and for us to handle PC
2339 adjustment if necessary on this target. */
2340 if (target_supports_stopped_by_sw_breakpoint ())
2341 swbreak_feature
= 1;
2343 else if (strcmp (p
, "hwbreak+") == 0)
2345 /* GDB wants us to report whether a trap is caused
2346 by a hardware breakpoint. */
2347 if (target_supports_stopped_by_hw_breakpoint ())
2348 hwbreak_feature
= 1;
2350 else if (strcmp (p
, "fork-events+") == 0)
2352 /* GDB supports and wants fork events if possible. */
2353 if (target_supports_fork_events ())
2354 report_fork_events
= 1;
2356 else if (strcmp (p
, "vfork-events+") == 0)
2358 /* GDB supports and wants vfork events if possible. */
2359 if (target_supports_vfork_events ())
2360 report_vfork_events
= 1;
2362 else if (strcmp (p
, "exec-events+") == 0)
2364 /* GDB supports and wants exec events if possible. */
2365 if (target_supports_exec_events ())
2366 report_exec_events
= 1;
2368 else if (strcmp (p
, "vContSupported+") == 0)
2369 vCont_supported
= 1;
2370 else if (strcmp (p
, "QThreadEvents+") == 0)
2372 else if (strcmp (p
, "no-resumed+") == 0)
2374 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2376 report_no_resumed
= 1;
2380 /* Move the unknown features all together. */
2381 qsupported
[i
] = NULL
;
2382 qsupported
[unknown
] = p
;
2387 /* Give the target backend a chance to process the unknown
2389 target_process_qsupported (qsupported
, unknown
);
2391 for (i
= 0; i
< count
; i
++)
2392 free (qsupported
[i
]);
2397 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2398 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2399 "QEnvironmentReset+;QEnvironmentUnset+",
2402 if (target_supports_catch_syscall ())
2403 strcat (own_buf
, ";QCatchSyscalls+");
2405 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2406 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2407 ";augmented-libraries-svr4-read+");
2410 /* We do not have any hook to indicate whether the non-SVR4 target
2411 backend supports qXfer:libraries:read, so always report it. */
2412 strcat (own_buf
, ";qXfer:libraries:read+");
2415 if (the_target
->read_auxv
!= NULL
)
2416 strcat (own_buf
, ";qXfer:auxv:read+");
2418 if (the_target
->qxfer_spu
!= NULL
)
2419 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2421 if (the_target
->qxfer_siginfo
!= NULL
)
2422 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2424 if (the_target
->read_loadmap
!= NULL
)
2425 strcat (own_buf
, ";qXfer:fdpic:read+");
2427 /* We always report qXfer:features:read, as targets may
2428 install XML files on a subsequent call to arch_setup.
2429 If we reported to GDB on startup that we don't support
2430 qXfer:feature:read at all, we will never be re-queried. */
2431 strcat (own_buf
, ";qXfer:features:read+");
2433 if (transport_is_reliable
)
2434 strcat (own_buf
, ";QStartNoAckMode+");
2436 if (the_target
->qxfer_osdata
!= NULL
)
2437 strcat (own_buf
, ";qXfer:osdata:read+");
2439 if (target_supports_multi_process ())
2440 strcat (own_buf
, ";multiprocess+");
2442 if (target_supports_fork_events ())
2443 strcat (own_buf
, ";fork-events+");
2445 if (target_supports_vfork_events ())
2446 strcat (own_buf
, ";vfork-events+");
2448 if (target_supports_exec_events ())
2449 strcat (own_buf
, ";exec-events+");
2451 if (target_supports_non_stop ())
2452 strcat (own_buf
, ";QNonStop+");
2454 if (target_supports_disable_randomization ())
2455 strcat (own_buf
, ";QDisableRandomization+");
2457 strcat (own_buf
, ";qXfer:threads:read+");
2459 if (target_supports_tracepoints ())
2461 strcat (own_buf
, ";ConditionalTracepoints+");
2462 strcat (own_buf
, ";TraceStateVariables+");
2463 strcat (own_buf
, ";TracepointSource+");
2464 strcat (own_buf
, ";DisconnectedTracing+");
2465 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2466 strcat (own_buf
, ";FastTracepoints+");
2467 strcat (own_buf
, ";StaticTracepoints+");
2468 strcat (own_buf
, ";InstallInTrace+");
2469 strcat (own_buf
, ";qXfer:statictrace:read+");
2470 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2471 strcat (own_buf
, ";EnableDisableTracepoints+");
2472 strcat (own_buf
, ";QTBuffer:size+");
2473 strcat (own_buf
, ";tracenz+");
2476 if (target_supports_hardware_single_step ()
2477 || target_supports_software_single_step () )
2479 strcat (own_buf
, ";ConditionalBreakpoints+");
2481 strcat (own_buf
, ";BreakpointCommands+");
2483 if (target_supports_agent ())
2484 strcat (own_buf
, ";QAgent+");
2486 supported_btrace_packets (own_buf
);
2488 if (target_supports_stopped_by_sw_breakpoint ())
2489 strcat (own_buf
, ";swbreak+");
2491 if (target_supports_stopped_by_hw_breakpoint ())
2492 strcat (own_buf
, ";hwbreak+");
2494 if (the_target
->pid_to_exec_file
!= NULL
)
2495 strcat (own_buf
, ";qXfer:exec-file:read+");
2497 strcat (own_buf
, ";vContSupported+");
2499 strcat (own_buf
, ";QThreadEvents+");
2501 strcat (own_buf
, ";no-resumed+");
2503 /* Reinitialize components as needed for the new connection. */
2504 hostio_handle_new_gdb_connection ();
2505 target_handle_new_gdb_connection ();
2510 /* Thread-local storage support. */
2511 if (the_target
->get_tls_address
!= NULL
2512 && startswith (own_buf
, "qGetTLSAddr:"))
2514 char *p
= own_buf
+ 12;
2515 CORE_ADDR parts
[2], address
= 0;
2517 ptid_t ptid
= null_ptid
;
2519 require_running_or_return (own_buf
);
2521 for (i
= 0; i
< 3; i
++)
2529 p2
= strchr (p
, ',');
2542 ptid
= read_ptid (p
, NULL
);
2544 decode_address (&parts
[i
- 1], p
, len
);
2548 if (p
!= NULL
|| i
< 3)
2552 struct thread_info
*thread
= find_thread_ptid (ptid
);
2557 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2563 strcpy (own_buf
, paddress(address
));
2568 write_enn (own_buf
);
2572 /* Otherwise, pretend we do not understand this packet. */
2575 /* Windows OS Thread Information Block address support. */
2576 if (the_target
->get_tib_address
!= NULL
2577 && startswith (own_buf
, "qGetTIBAddr:"))
2582 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2584 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2587 strcpy (own_buf
, paddress(tlb
));
2592 write_enn (own_buf
);
2598 /* Handle "monitor" commands. */
2599 if (startswith (own_buf
, "qRcmd,"))
2601 char *mon
= (char *) malloc (PBUFSIZ
);
2602 int len
= strlen (own_buf
+ 6);
2606 write_enn (own_buf
);
2611 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2613 write_enn (own_buf
);
2617 mon
[len
/ 2] = '\0';
2621 if (the_target
->handle_monitor_command
== NULL
2622 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2623 /* Default processing. */
2624 handle_monitor_command (mon
, own_buf
);
2630 if (startswith (own_buf
, "qSearch:memory:"))
2632 require_running_or_return (own_buf
);
2633 handle_search_memory (own_buf
, packet_len
);
2637 if (strcmp (own_buf
, "qAttached") == 0
2638 || startswith (own_buf
, "qAttached:"))
2640 struct process_info
*process
;
2642 if (own_buf
[sizeof ("qAttached") - 1])
2644 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2645 process
= (struct process_info
*)
2646 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2650 require_running_or_return (own_buf
);
2651 process
= current_process ();
2654 if (process
== NULL
)
2656 write_enn (own_buf
);
2660 strcpy (own_buf
, process
->attached
? "1" : "0");
2664 if (startswith (own_buf
, "qCRC:"))
2666 /* CRC check (compare-section). */
2670 unsigned long long crc
;
2672 require_running_or_return (own_buf
);
2673 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2674 if (*comma
++ != ',')
2676 write_enn (own_buf
);
2679 len
= strtoul (comma
, NULL
, 16);
2680 crc
= crc32 (base
, len
, 0xffffffff);
2681 /* Check for memory failure. */
2682 if (crc
== (unsigned long long) -1)
2684 write_enn (own_buf
);
2687 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2691 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2694 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2697 /* Otherwise we didn't know what packet it was. Say we didn't
2702 static void gdb_wants_all_threads_stopped (void);
2703 static void resume (struct thread_resume
*actions
, size_t n
);
2705 /* The callback that is passed to visit_actioned_threads. */
2706 typedef int (visit_actioned_threads_callback_ftype
)
2707 (const struct thread_resume
*, struct thread_info
*);
2709 /* Struct to pass data to visit_actioned_threads. */
2711 struct visit_actioned_threads_data
2713 const struct thread_resume
*actions
;
2715 visit_actioned_threads_callback_ftype
*callback
;
2718 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2719 true if CALLBACK returns true. Returns false if no matching thread
2720 is found or CALLBACK results false.
2721 Note: This function is itself a callback for find_inferior. */
2724 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2726 struct visit_actioned_threads_data
*data
2727 = (struct visit_actioned_threads_data
*) datap
;
2728 const struct thread_resume
*actions
= data
->actions
;
2729 size_t num_actions
= data
->num_actions
;
2730 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2733 for (i
= 0; i
< num_actions
; i
++)
2735 const struct thread_resume
*action
= &actions
[i
];
2737 if (ptid_equal (action
->thread
, minus_one_ptid
)
2738 || ptid_equal (action
->thread
, entry
->id
)
2739 || ((ptid_get_pid (action
->thread
)
2740 == ptid_get_pid (entry
->id
))
2741 && ptid_get_lwp (action
->thread
) == -1))
2743 struct thread_info
*thread
= (struct thread_info
*) entry
;
2745 if ((*callback
) (action
, thread
))
2753 /* Callback for visit_actioned_threads. If the thread has a pending
2754 status to report, report it now. */
2757 handle_pending_status (const struct thread_resume
*resumption
,
2758 struct thread_info
*thread
)
2760 if (thread
->status_pending_p
)
2762 thread
->status_pending_p
= 0;
2764 last_status
= thread
->last_status
;
2765 last_ptid
= thread
->entry
.id
;
2766 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2772 /* Parse vCont packets. */
2774 handle_v_cont (char *own_buf
)
2778 struct thread_resume
*resume_info
;
2779 struct thread_resume default_action
{ null_ptid
};
2781 /* Count the number of semicolons in the packet. There should be one
2782 for every action. */
2788 p
= strchr (p
, ';');
2791 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2792 if (resume_info
== NULL
)
2800 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2802 if (p
[0] == 's' || p
[0] == 'S')
2803 resume_info
[i
].kind
= resume_step
;
2804 else if (p
[0] == 'r')
2805 resume_info
[i
].kind
= resume_step
;
2806 else if (p
[0] == 'c' || p
[0] == 'C')
2807 resume_info
[i
].kind
= resume_continue
;
2808 else if (p
[0] == 't')
2809 resume_info
[i
].kind
= resume_stop
;
2813 if (p
[0] == 'S' || p
[0] == 'C')
2816 sig
= strtol (p
+ 1, &q
, 16);
2821 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2823 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2825 else if (p
[0] == 'r')
2829 p
= unpack_varlen_hex (p
+ 1, &addr
);
2830 resume_info
[i
].step_range_start
= addr
;
2835 p
= unpack_varlen_hex (p
+ 1, &addr
);
2836 resume_info
[i
].step_range_end
= addr
;
2845 resume_info
[i
].thread
= minus_one_ptid
;
2846 default_action
= resume_info
[i
];
2848 /* Note: we don't increment i here, we'll overwrite this entry
2849 the next time through. */
2851 else if (p
[0] == ':')
2853 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2858 if (p
[0] != ';' && p
[0] != 0)
2861 resume_info
[i
].thread
= ptid
;
2868 resume_info
[i
] = default_action
;
2870 resume (resume_info
, n
);
2875 write_enn (own_buf
);
2880 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2883 resume (struct thread_resume
*actions
, size_t num_actions
)
2887 /* Check if among the threads that GDB wants actioned, there's
2888 one with a pending status to report. If so, skip actually
2889 resuming/stopping and report the pending event
2891 struct visit_actioned_threads_data data
;
2893 data
.actions
= actions
;
2894 data
.num_actions
= num_actions
;
2895 data
.callback
= handle_pending_status
;
2896 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2902 (*the_target
->resume
) (actions
, num_actions
);
2908 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2910 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2911 && !report_no_resumed
)
2913 /* The client does not support this stop reply. At least
2915 sprintf (own_buf
, "E.No unwaited-for children left.");
2916 disable_async_io ();
2920 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2921 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2922 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2923 current_thread
->last_status
= last_status
;
2925 /* From the client's perspective, all-stop mode always stops all
2926 threads implicitly (and the target backend has already done
2927 so by now). Tag all threads as "want-stopped", so we don't
2928 resume them implicitly without the client telling us to. */
2929 gdb_wants_all_threads_stopped ();
2930 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2931 disable_async_io ();
2933 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2934 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2935 target_mourn_inferior (last_ptid
);
2939 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2941 handle_v_attach (char *own_buf
)
2945 pid
= strtol (own_buf
+ 8, NULL
, 16);
2946 if (pid
!= 0 && attach_inferior (pid
) == 0)
2948 /* Don't report shared library events after attaching, even if
2949 some libraries are preloaded. GDB will always poll the
2950 library list. Avoids the "stopped by shared library event"
2951 notice on the GDB side. */
2956 /* In non-stop, we don't send a resume reply. Stop events
2957 will follow up using the normal notification
2962 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2968 write_enn (own_buf
);
2973 /* Run a new program. Return 1 if successful, 0 if failure. */
2975 handle_v_run (char *own_buf
)
2978 std::vector
<char *> new_argv
;
2979 char *new_program_name
= NULL
;
2983 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2989 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2991 next_p
= strchr (p
, ';');
2993 next_p
= p
+ strlen (p
);
2995 if (i
== 0 && p
== next_p
)
2997 /* No program specified. */
2998 new_program_name
= NULL
;
3000 else if (p
== next_p
)
3002 /* Empty argument. */
3003 new_argv
.push_back (xstrdup ("''"));
3007 size_t len
= (next_p
- p
) / 2;
3008 /* ARG is the unquoted argument received via the RSP. */
3009 char *arg
= (char *) xmalloc (len
+ 1);
3010 /* FULL_ARGS will contain the quoted version of ARG. */
3011 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
3012 /* These are pointers used to navigate the strings above. */
3013 char *tmp_arg
= arg
;
3014 char *tmp_full_arg
= full_arg
;
3017 hex2bin (p
, (gdb_byte
*) arg
, len
);
3020 while (*tmp_arg
!= '\0')
3026 *tmp_full_arg
= '\'';
3032 /* Quote single quote. */
3033 *tmp_full_arg
= '\\';
3041 *tmp_full_arg
= *tmp_arg
;
3047 *tmp_full_arg
++ = '\'';
3049 /* Finish FULL_ARG and push it into the vector containing
3051 *tmp_full_arg
= '\0';
3053 new_program_name
= full_arg
;
3055 new_argv
.push_back (full_arg
);
3061 new_argv
.push_back (NULL
);
3063 if (new_program_name
== NULL
)
3065 /* GDB didn't specify a program to run. Use the program from the
3066 last run with the new argument list. */
3067 if (program_name
== NULL
)
3069 write_enn (own_buf
);
3070 free_vector_argv (new_argv
);
3076 xfree (program_name
);
3077 program_name
= new_program_name
;
3080 /* Free the old argv and install the new one. */
3081 free_vector_argv (program_args
);
3082 program_args
= new_argv
;
3084 create_inferior (program_name
, program_args
);
3086 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3088 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
3090 /* In non-stop, sending a resume reply doesn't set the general
3091 thread, but GDB assumes a vRun sets it (this is so GDB can
3092 query which is the main thread of the new inferior. */
3094 general_thread
= last_ptid
;
3100 write_enn (own_buf
);
3105 /* Kill process. Return 1 if successful, 0 if failure. */
3107 handle_v_kill (char *own_buf
)
3110 char *p
= &own_buf
[6];
3112 pid
= strtol (p
, NULL
, 16);
3115 if (pid
!= 0 && kill_inferior (pid
) == 0)
3117 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3118 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3119 last_ptid
= pid_to_ptid (pid
);
3120 discard_queued_stop_replies (last_ptid
);
3126 write_enn (own_buf
);
3131 /* Handle all of the extended 'v' packets. */
3133 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3135 if (!disable_packet_vCont
)
3137 if (strcmp (own_buf
, "vCtrlC") == 0)
3139 (*the_target
->request_interrupt
) ();
3144 if (startswith (own_buf
, "vCont;"))
3146 handle_v_cont (own_buf
);
3150 if (startswith (own_buf
, "vCont?"))
3152 strcpy (own_buf
, "vCont;c;C;t");
3154 if (target_supports_hardware_single_step ()
3155 || target_supports_software_single_step ()
3156 || !vCont_supported
)
3158 /* If target supports single step either by hardware or by
3159 software, add actions s and S to the list of supported
3160 actions. On the other hand, if GDB doesn't request the
3161 supported vCont actions in qSupported packet, add s and
3162 S to the list too. */
3163 own_buf
= own_buf
+ strlen (own_buf
);
3164 strcpy (own_buf
, ";s;S");
3167 if (target_supports_range_stepping ())
3169 own_buf
= own_buf
+ strlen (own_buf
);
3170 strcpy (own_buf
, ";r");
3176 if (startswith (own_buf
, "vFile:")
3177 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3180 if (startswith (own_buf
, "vAttach;"))
3182 if ((!extended_protocol
|| !multi_process
) && target_running ())
3184 fprintf (stderr
, "Already debugging a process\n");
3185 write_enn (own_buf
);
3188 handle_v_attach (own_buf
);
3192 if (startswith (own_buf
, "vRun;"))
3194 if ((!extended_protocol
|| !multi_process
) && target_running ())
3196 fprintf (stderr
, "Already debugging a process\n");
3197 write_enn (own_buf
);
3200 handle_v_run (own_buf
);
3204 if (startswith (own_buf
, "vKill;"))
3206 if (!target_running ())
3208 fprintf (stderr
, "No process to kill\n");
3209 write_enn (own_buf
);
3212 handle_v_kill (own_buf
);
3216 if (handle_notif_ack (own_buf
, packet_len
))
3219 /* Otherwise we didn't know what packet it was. Say we didn't
3225 /* Resume thread and wait for another event. In non-stop mode,
3226 don't really wait here, but return immediatelly to the event
3229 myresume (char *own_buf
, int step
, int sig
)
3231 struct thread_resume resume_info
[2];
3233 int valid_cont_thread
;
3235 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3236 && !ptid_equal (cont_thread
, minus_one_ptid
));
3238 if (step
|| sig
|| valid_cont_thread
)
3240 resume_info
[0].thread
= current_ptid
;
3242 resume_info
[0].kind
= resume_step
;
3244 resume_info
[0].kind
= resume_continue
;
3245 resume_info
[0].sig
= sig
;
3249 if (!valid_cont_thread
)
3251 resume_info
[n
].thread
= minus_one_ptid
;
3252 resume_info
[n
].kind
= resume_continue
;
3253 resume_info
[n
].sig
= 0;
3257 resume (resume_info
, n
);
3260 /* Callback for for_each_inferior. Make a new stop reply for each
3264 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3266 struct thread_info
*thread
= (struct thread_info
*) entry
;
3268 /* For now, assume targets that don't have this callback also don't
3269 manage the thread's last_status field. */
3270 if (the_target
->thread_stopped
== NULL
)
3272 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3274 new_notif
->ptid
= entry
->id
;
3275 new_notif
->status
= thread
->last_status
;
3276 /* Pass the last stop reply back to GDB, but don't notify
3278 notif_event_enque (¬if_stop
,
3279 (struct notif_event
*) new_notif
);
3283 if (thread_stopped (thread
))
3287 std::string status_string
3288 = target_waitstatus_to_string (&thread
->last_status
);
3290 debug_printf ("Reporting thread %s as already stopped with %s\n",
3291 target_pid_to_str (entry
->id
),
3292 status_string
.c_str ());
3295 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3297 /* Pass the last stop reply back to GDB, but don't notify
3299 queue_stop_reply (entry
->id
, &thread
->last_status
);
3306 /* Set this inferior threads's state as "want-stopped". We won't
3307 resume this thread until the client gives us another action for
3311 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3313 struct thread_info
*thread
= (struct thread_info
*) entry
;
3315 thread
->last_resume_kind
= resume_stop
;
3317 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3319 /* Most threads are stopped implicitly (all-stop); tag that with
3321 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3322 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3326 /* Set all threads' states as "want-stopped". */
3329 gdb_wants_all_threads_stopped (void)
3331 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3334 /* Clear the gdb_detached flag of every process. */
3337 gdb_reattached_process (struct inferior_list_entry
*entry
)
3339 struct process_info
*process
= (struct process_info
*) entry
;
3341 process
->gdb_detached
= 0;
3344 /* Callback for for_each_inferior. Clear the thread's pending status
3348 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3350 struct thread_info
*thread
= (struct thread_info
*) entry
;
3352 thread
->status_pending_p
= 0;
3355 /* Callback for for_each_inferior. If the thread is stopped with an
3356 interesting event, mark it as having a pending event. */
3359 set_pending_status_callback (struct inferior_list_entry
*entry
)
3361 struct thread_info
*thread
= (struct thread_info
*) entry
;
3363 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3364 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3365 /* A breakpoint, watchpoint or finished step from a previous
3366 GDB run isn't considered interesting for a new GDB run.
3367 If we left those pending, the new GDB could consider them
3368 random SIGTRAPs. This leaves out real async traps. We'd
3369 have to peek into the (target-specific) siginfo to
3370 distinguish those. */
3371 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3372 thread
->status_pending_p
= 1;
3375 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3376 pending status to report to GDB. */
3379 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3381 struct thread_info
*thread
= (struct thread_info
*) entry
;
3383 return thread
->status_pending_p
;
3386 /* Status handler for the '?' packet. */
3389 handle_status (char *own_buf
)
3391 /* GDB is connected, don't forward events to the target anymore. */
3392 for_each_inferior (&all_processes
, gdb_reattached_process
);
3394 /* In non-stop mode, we must send a stop reply for each stopped
3395 thread. In all-stop mode, just send one for the first stopped
3400 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3402 /* The first is sent immediatly. OK is sent if there is no
3403 stopped thread, which is the same handling of the vStopped
3404 packet (by design). */
3405 notif_write_event (¬if_stop
, own_buf
);
3409 struct inferior_list_entry
*thread
= NULL
;
3412 stabilize_threads ();
3413 gdb_wants_all_threads_stopped ();
3415 /* We can only report one status, but we might be coming out of
3416 non-stop -- if more than one thread is stopped with
3417 interesting events, leave events for the threads we're not
3418 reporting now pending. They'll be reported the next time the
3419 threads are resumed. Start by marking all interesting events
3421 for_each_inferior (&all_threads
, set_pending_status_callback
);
3423 /* Prefer the last thread that reported an event to GDB (even if
3424 that was a GDB_SIGNAL_TRAP). */
3425 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3426 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3427 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3428 thread
= find_inferior_id (&all_threads
, last_ptid
);
3430 /* If the last event thread is not found for some reason, look
3431 for some other thread that might have an event to report. */
3433 thread
= find_inferior (&all_threads
,
3434 find_status_pending_thread_callback
, NULL
);
3436 /* If we're still out of luck, simply pick the first thread in
3439 thread
= get_first_inferior (&all_threads
);
3443 struct thread_info
*tp
= (struct thread_info
*) thread
;
3445 /* We're reporting this event, so it's no longer
3447 tp
->status_pending_p
= 0;
3449 /* GDB assumes the current thread is the thread we're
3450 reporting the status for. */
3451 general_thread
= thread
->id
;
3452 set_desired_thread (1);
3454 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3455 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3458 strcpy (own_buf
, "W00");
3463 gdbserver_version (void)
3465 printf ("GNU gdbserver %s%s\n"
3466 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3467 "gdbserver is free software, covered by the "
3468 "GNU General Public License.\n"
3469 "This gdbserver was configured as \"%s\"\n",
3470 PKGVERSION
, version
, host_name
);
3474 gdbserver_usage (FILE *stream
)
3476 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3477 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3478 "\tgdbserver [OPTIONS] --multi COMM\n"
3480 "COMM may either be a tty device (for serial debugging),\n"
3481 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3482 "stdin/stdout of gdbserver.\n"
3483 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3484 "PID is the process ID to attach to, when --attach is specified.\n"
3486 "Operating modes:\n"
3488 " --attach Attach to running process PID.\n"
3489 " --multi Start server without a specific program, and\n"
3490 " only quit when explicitly commanded.\n"
3491 " --once Exit after the first connection has closed.\n"
3492 " --help Print this message and then exit.\n"
3493 " --version Display version information and exit.\n"
3497 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3498 " --disable-randomization\n"
3499 " Run PROG with address space randomization disabled.\n"
3500 " --no-disable-randomization\n"
3501 " Don't disable address space randomization when\n"
3503 " --startup-with-shell\n"
3504 " Start PROG using a shell. I.e., execs a shell that\n"
3505 " then execs PROG. (default)\n"
3506 " --no-startup-with-shell\n"
3507 " Exec PROG directly instead of using a shell.\n"
3508 " Disables argument globbing and variable substitution\n"
3509 " on UNIX-like systems.\n"
3513 " --debug Enable general debugging output.\n"
3514 " --debug-format=opt1[,opt2,...]\n"
3515 " Specify extra content in debugging output.\n"
3520 " --remote-debug Enable remote protocol debugging output.\n"
3521 " --disable-packet=opt1[,opt2,...]\n"
3522 " Disable support for RSP packets or features.\n"
3524 " vCont, Tthread, qC, qfThreadInfo and \n"
3525 " threads (disable all threading packets).\n"
3527 "For more information, consult the GDB manual (available as on-line \n"
3528 "info or a printed manual).\n");
3529 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3530 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3534 gdbserver_show_disableable (FILE *stream
)
3536 fprintf (stream
, "Disableable packets:\n"
3537 " vCont \tAll vCont packets\n"
3538 " qC \tQuerying the current thread\n"
3539 " qfThreadInfo\tThread listing\n"
3540 " Tthread \tPassing the thread specifier in the "
3541 "T stop reply packet\n"
3542 " threads \tAll of the above\n");
3546 kill_inferior_callback (struct inferior_list_entry
*entry
)
3548 struct process_info
*process
= (struct process_info
*) entry
;
3549 int pid
= ptid_get_pid (process
->entry
.id
);
3551 kill_inferior (pid
);
3552 discard_queued_stop_replies (pid_to_ptid (pid
));
3555 /* Callback for for_each_inferior to detach or kill the inferior,
3556 depending on whether we attached to it or not.
3557 We inform the user whether we're detaching or killing the process
3558 as this is only called when gdbserver is about to exit. */
3561 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3563 struct process_info
*process
= (struct process_info
*) entry
;
3564 int pid
= ptid_get_pid (process
->entry
.id
);
3566 if (process
->attached
)
3567 detach_inferior (pid
);
3569 kill_inferior (pid
);
3571 discard_queued_stop_replies (pid_to_ptid (pid
));
3574 /* for_each_inferior callback for detach_or_kill_for_exit to print
3575 the pids of started inferiors. */
3578 print_started_pid (struct inferior_list_entry
*entry
)
3580 struct process_info
*process
= (struct process_info
*) entry
;
3582 if (! process
->attached
)
3584 int pid
= ptid_get_pid (process
->entry
.id
);
3585 fprintf (stderr
, " %d", pid
);
3589 /* for_each_inferior callback for detach_or_kill_for_exit to print
3590 the pids of attached inferiors. */
3593 print_attached_pid (struct inferior_list_entry
*entry
)
3595 struct process_info
*process
= (struct process_info
*) entry
;
3597 if (process
->attached
)
3599 int pid
= ptid_get_pid (process
->entry
.id
);
3600 fprintf (stderr
, " %d", pid
);
3604 /* Call this when exiting gdbserver with possible inferiors that need
3605 to be killed or detached from. */
3608 detach_or_kill_for_exit (void)
3610 /* First print a list of the inferiors we will be killing/detaching.
3611 This is to assist the user, for example, in case the inferior unexpectedly
3612 dies after we exit: did we screw up or did the inferior exit on its own?
3613 Having this info will save some head-scratching. */
3615 if (have_started_inferiors_p ())
3617 fprintf (stderr
, "Killing process(es):");
3618 for_each_inferior (&all_processes
, print_started_pid
);
3619 fprintf (stderr
, "\n");
3621 if (have_attached_inferiors_p ())
3623 fprintf (stderr
, "Detaching process(es):");
3624 for_each_inferior (&all_processes
, print_attached_pid
);
3625 fprintf (stderr
, "\n");
3628 /* Now we can kill or detach the inferiors. */
3630 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3633 /* Value that will be passed to exit(3) when gdbserver exits. */
3634 static int exit_code
;
3636 /* Cleanup version of detach_or_kill_for_exit. */
3639 detach_or_kill_for_exit_cleanup (void *ignore
)
3644 detach_or_kill_for_exit ();
3647 CATCH (exception
, RETURN_MASK_ALL
)
3650 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3656 /* Main function. This is called by the real "main" function,
3657 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3659 static void ATTRIBUTE_NORETURN
3660 captured_main (int argc
, char *argv
[])
3665 const char *port
= NULL
;
3666 char **next_arg
= &argv
[1];
3667 volatile int multi_mode
= 0;
3668 volatile int attach
= 0;
3670 bool selftest
= false;
3672 while (*next_arg
!= NULL
&& **next_arg
== '-')
3674 if (strcmp (*next_arg
, "--version") == 0)
3676 gdbserver_version ();
3679 else if (strcmp (*next_arg
, "--help") == 0)
3681 gdbserver_usage (stdout
);
3684 else if (strcmp (*next_arg
, "--attach") == 0)
3686 else if (strcmp (*next_arg
, "--multi") == 0)
3688 else if (strcmp (*next_arg
, "--wrapper") == 0)
3695 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3697 wrapper_argv
+= *next_arg
;
3698 wrapper_argv
+= ' ';
3702 if (!wrapper_argv
.empty ())
3704 /* Erase the last whitespace. */
3705 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3708 if (next_arg
== tmp
|| *next_arg
== NULL
)
3710 gdbserver_usage (stderr
);
3714 /* Consume the "--". */
3717 else if (strcmp (*next_arg
, "--debug") == 0)
3719 else if (startswith (*next_arg
, "--debug-format="))
3722 = parse_debug_format_options ((*next_arg
)
3723 + sizeof ("--debug-format=") - 1, 0);
3725 if (error_msg
!= NULL
)
3727 fprintf (stderr
, "%s", error_msg
);
3731 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3733 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3735 gdbserver_show_disableable (stdout
);
3738 else if (startswith (*next_arg
, "--disable-packet="))
3740 char *packets
, *tok
;
3742 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3743 for (tok
= strtok (packets
, ",");
3745 tok
= strtok (NULL
, ","))
3747 if (strcmp ("vCont", tok
) == 0)
3748 disable_packet_vCont
= 1;
3749 else if (strcmp ("Tthread", tok
) == 0)
3750 disable_packet_Tthread
= 1;
3751 else if (strcmp ("qC", tok
) == 0)
3752 disable_packet_qC
= 1;
3753 else if (strcmp ("qfThreadInfo", tok
) == 0)
3754 disable_packet_qfThreadInfo
= 1;
3755 else if (strcmp ("threads", tok
) == 0)
3757 disable_packet_vCont
= 1;
3758 disable_packet_Tthread
= 1;
3759 disable_packet_qC
= 1;
3760 disable_packet_qfThreadInfo
= 1;
3764 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3766 gdbserver_show_disableable (stderr
);
3771 else if (strcmp (*next_arg
, "-") == 0)
3773 /* "-" specifies a stdio connection and is a form of port
3775 port
= STDIO_CONNECTION_NAME
;
3779 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3780 disable_randomization
= 1;
3781 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3782 disable_randomization
= 0;
3783 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3784 startup_with_shell
= true;
3785 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3786 startup_with_shell
= false;
3787 else if (strcmp (*next_arg
, "--once") == 0)
3789 else if (strcmp (*next_arg
, "--selftest") == 0)
3793 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3806 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3809 gdbserver_usage (stderr
);
3813 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3814 opened by remote_prepare. */
3817 save_original_signals_state ();
3819 /* We need to know whether the remote connection is stdio before
3820 starting the inferior. Inferiors created in this scenario have
3821 stdin,stdout redirected. So do this here before we call
3824 remote_prepare (port
);
3829 /* --attach used to come after PORT, so allow it there for
3831 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3838 && (*next_arg
== NULL
3839 || (*next_arg
)[0] == '\0'
3840 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3842 || next_arg
[1] != NULL
))
3847 gdbserver_usage (stderr
);
3851 /* Gather information about the environment. */
3852 our_environ
= gdb_environ::from_host_environ ();
3854 initialize_async_io ();
3856 have_job_control ();
3857 initialize_event_loop ();
3858 if (target_supports_tracepoints ())
3859 initialize_tracepoint ();
3860 initialize_notif ();
3862 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3863 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3867 selftests::run_tests ();
3868 throw_quit ("Quit");
3871 if (pid
== 0 && *next_arg
!= NULL
)
3875 n
= argc
- (next_arg
- argv
);
3876 program_name
= xstrdup (next_arg
[0]);
3877 for (i
= 1; i
< n
; i
++)
3878 program_args
.push_back (xstrdup (next_arg
[i
]));
3879 program_args
.push_back (NULL
);
3881 /* Wait till we are at first instruction in program. */
3882 create_inferior (program_name
, program_args
);
3884 /* We are now (hopefully) stopped at the first instruction of
3885 the target process. This assumes that the target process was
3886 successfully created. */
3890 if (attach_inferior (pid
) == -1)
3891 error ("Attaching not supported on this target");
3893 /* Otherwise succeeded. */
3897 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3898 last_status
.value
.integer
= 0;
3899 last_ptid
= minus_one_ptid
;
3901 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3903 /* Don't report shared library events on the initial connection,
3904 even if some libraries are preloaded. Avoids the "stopped by
3905 shared library event" notice on gdb side. */
3908 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3909 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3914 if (!was_running
&& !multi_mode
)
3915 error ("No program to debug");
3922 report_fork_events
= 0;
3923 report_vfork_events
= 0;
3924 report_exec_events
= 0;
3925 /* Be sure we're out of tfind mode. */
3926 current_traceframe
= -1;
3927 cont_thread
= null_ptid
;
3928 swbreak_feature
= 0;
3929 hwbreak_feature
= 0;
3930 vCont_supported
= 0;
3936 /* Wait for events. This will return when all event sources
3937 are removed from the event loop. */
3938 start_event_loop ();
3940 /* If an exit was requested (using the "monitor exit"
3941 command), terminate now. */
3943 throw_quit ("Quit");
3945 /* The only other way to get here is for getpkt to fail:
3947 - If --once was specified, we're done.
3949 - If not in extended-remote mode, and we're no longer
3950 debugging anything, simply exit: GDB has disconnected
3951 after processing the last process exit.
3953 - Otherwise, close the connection and reopen it at the
3955 if (run_once
|| (!extended_protocol
&& !target_running ()))
3956 throw_quit ("Quit");
3959 "Remote side has terminated connection. "
3960 "GDBserver will reopen the connection.\n");
3962 /* Get rid of any pending statuses. An eventual reconnection
3963 (by the same GDB instance or another) will refresh all its
3964 state from scratch. */
3965 discard_queued_stop_replies (minus_one_ptid
);
3966 for_each_inferior (&all_threads
,
3967 clear_pending_status_callback
);
3971 if (disconnected_tracing
)
3973 /* Try to enable non-stop/async mode, so we we can
3974 both wait for an async socket accept, and handle
3975 async target events simultaneously. There's also
3976 no point either in having the target always stop
3977 all threads, when we're going to pass signals
3978 down without informing GDB. */
3981 if (start_non_stop (1))
3984 /* Detaching implicitly resumes all threads;
3985 simply disconnecting does not. */
3991 "Disconnected tracing disabled; "
3992 "stopping trace run.\n");
3997 CATCH (exception
, RETURN_MASK_ERROR
)
4000 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
4002 if (response_needed
)
4004 write_enn (own_buf
);
4009 throw_quit ("Quit");
4015 /* Main function. */
4018 main (int argc
, char *argv
[])
4023 captured_main (argc
, argv
);
4025 CATCH (exception
, RETURN_MASK_ALL
)
4027 if (exception
.reason
== RETURN_ERROR
)
4030 fprintf (stderr
, "%s\n", exception
.message
);
4031 fprintf (stderr
, "Exiting\n");
4039 gdb_assert_not_reached ("captured_main should never return");
4042 /* Process options coming from Z packets for a breakpoint. PACKET is
4043 the packet buffer. *PACKET is updated to point to the first char
4044 after the last processed option. */
4047 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
4049 char *dataptr
= *packet
;
4052 /* Check if data has the correct format. */
4053 if (*dataptr
!= ';')
4060 if (*dataptr
== ';')
4063 if (*dataptr
== 'X')
4065 /* Conditional expression. */
4067 debug_printf ("Found breakpoint condition.\n");
4068 if (!add_breakpoint_condition (bp
, &dataptr
))
4069 dataptr
= strchrnul (dataptr
, ';');
4071 else if (startswith (dataptr
, "cmds:"))
4073 dataptr
+= strlen ("cmds:");
4075 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4076 persist
= (*dataptr
== '1');
4078 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4079 dataptr
= strchrnul (dataptr
, ';');
4083 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4085 /* Skip tokens until we find one that we recognize. */
4086 dataptr
= strchrnul (dataptr
, ';');
4092 /* Event loop callback that handles a serial event. The first byte in
4093 the serial buffer gets us here. We expect characters to arrive at
4094 a brisk pace, so we read the rest of the packet with a blocking
4098 process_serial_event (void)
4106 int new_packet_len
= -1;
4108 disable_async_io ();
4110 response_needed
= 0;
4111 packet_len
= getpkt (own_buf
);
4112 if (packet_len
<= 0)
4115 /* Force an event loop break. */
4118 response_needed
= 1;
4120 char ch
= own_buf
[0];
4124 handle_query (own_buf
, packet_len
, &new_packet_len
);
4127 handle_general_set (own_buf
);
4130 handle_detach (own_buf
);
4133 extended_protocol
= 1;
4137 handle_status (own_buf
);
4140 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4142 require_running_or_break (own_buf
);
4144 ptid_t thread_id
= read_ptid (&own_buf
[2], NULL
);
4146 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4147 thread_id
= null_ptid
;
4148 else if (thread_id
.is_pid ())
4150 /* The ptid represents a pid. */
4151 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4155 write_enn (own_buf
);
4159 thread_id
= thread
->entry
.id
;
4163 /* The ptid represents a lwp/tid. */
4164 if (find_thread_ptid (thread_id
) == NULL
)
4166 write_enn (own_buf
);
4171 if (own_buf
[1] == 'g')
4173 if (ptid_equal (thread_id
, null_ptid
))
4175 /* GDB is telling us to choose any thread. Check if
4176 the currently selected thread is still valid. If
4177 it is not, select the first available. */
4178 struct thread_info
*thread
=
4179 (struct thread_info
*) find_inferior_id (&all_threads
,
4182 thread
= get_first_thread ();
4183 thread_id
= thread
->entry
.id
;
4186 general_thread
= thread_id
;
4187 set_desired_thread (1);
4188 gdb_assert (current_thread
!= NULL
);
4190 else if (own_buf
[1] == 'c')
4191 cont_thread
= thread_id
;
4197 /* Silently ignore it so that gdb can extend the protocol
4198 without compatibility headaches. */
4203 require_running_or_break (own_buf
);
4204 if (current_traceframe
>= 0)
4206 struct regcache
*regcache
4207 = new_register_cache (current_target_desc ());
4209 if (fetch_traceframe_registers (current_traceframe
,
4211 registers_to_string (regcache
, own_buf
);
4213 write_enn (own_buf
);
4214 free_register_cache (regcache
);
4218 struct regcache
*regcache
;
4220 if (!set_desired_thread (1))
4221 write_enn (own_buf
);
4224 regcache
= get_thread_regcache (current_thread
, 1);
4225 registers_to_string (regcache
, own_buf
);
4230 require_running_or_break (own_buf
);
4231 if (current_traceframe
>= 0)
4232 write_enn (own_buf
);
4235 struct regcache
*regcache
;
4237 if (!set_desired_thread (1))
4238 write_enn (own_buf
);
4241 regcache
= get_thread_regcache (current_thread
, 1);
4242 registers_from_string (regcache
, &own_buf
[1]);
4248 require_running_or_break (own_buf
);
4249 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4250 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4252 write_enn (own_buf
);
4254 bin2hex (mem_buf
, own_buf
, res
);
4257 require_running_or_break (own_buf
);
4258 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4259 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4262 write_enn (own_buf
);
4265 require_running_or_break (own_buf
);
4266 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4267 &mem_addr
, &len
, &mem_buf
) < 0
4268 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4269 write_enn (own_buf
);
4274 require_running_or_break (own_buf
);
4275 hex2bin (own_buf
+ 1, &sig
, 1);
4276 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4277 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4280 myresume (own_buf
, 0, signal
);
4283 require_running_or_break (own_buf
);
4284 hex2bin (own_buf
+ 1, &sig
, 1);
4285 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4286 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4289 myresume (own_buf
, 1, signal
);
4292 require_running_or_break (own_buf
);
4294 myresume (own_buf
, 0, signal
);
4297 require_running_or_break (own_buf
);
4299 myresume (own_buf
, 1, signal
);
4301 case 'Z': /* insert_ ... */
4303 case 'z': /* remove_ ... */
4308 char type
= own_buf
[1];
4310 const int insert
= ch
== 'Z';
4311 char *p
= &own_buf
[3];
4313 p
= unpack_varlen_hex (p
, &addr
);
4314 kind
= strtol (p
+ 1, &dataptr
, 16);
4318 struct gdb_breakpoint
*bp
;
4320 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4325 /* GDB may have sent us a list of *point parameters to
4326 be evaluated on the target's side. Read such list
4327 here. If we already have a list of parameters, GDB
4328 is telling us to drop that list and use this one
4330 clear_breakpoint_conditions_and_commands (bp
);
4331 process_point_options (bp
, &dataptr
);
4335 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4343 write_enn (own_buf
);
4347 response_needed
= 0;
4348 if (!target_running ())
4349 /* The packet we received doesn't make sense - but we can't
4350 reply to it, either. */
4353 fprintf (stderr
, "Killing all inferiors\n");
4354 for_each_inferior (&all_processes
, kill_inferior_callback
);
4356 /* When using the extended protocol, we wait with no program
4357 running. The traditional protocol will exit instead. */
4358 if (extended_protocol
)
4360 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4361 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4369 require_running_or_break (own_buf
);
4371 ptid_t thread_id
= read_ptid (&own_buf
[1], NULL
);
4372 if (find_thread_ptid (thread_id
) == NULL
)
4374 write_enn (own_buf
);
4378 if (mythread_alive (thread_id
))
4381 write_enn (own_buf
);
4385 response_needed
= 0;
4387 /* Restarting the inferior is only supported in the extended
4389 if (extended_protocol
)
4391 if (target_running ())
4392 for_each_inferior (&all_processes
,
4393 kill_inferior_callback
);
4394 fprintf (stderr
, "GDBserver restarting\n");
4396 /* Wait till we are at 1st instruction in prog. */
4397 if (program_name
!= NULL
)
4399 create_inferior (program_name
, program_args
);
4401 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4403 /* Stopped at the first instruction of the target
4405 general_thread
= last_ptid
;
4409 /* Something went wrong. */
4410 general_thread
= null_ptid
;
4415 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4416 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4422 /* It is a request we don't understand. Respond with an
4423 empty packet so that gdb knows that we don't support this
4429 /* Extended (long) request. */
4430 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4434 /* It is a request we don't understand. Respond with an empty
4435 packet so that gdb knows that we don't support this
4441 if (new_packet_len
!= -1)
4442 putpkt_binary (own_buf
, new_packet_len
);
4446 response_needed
= 0;
4454 /* Event-loop callback for serial events. */
4457 handle_serial_event (int err
, gdb_client_data client_data
)
4460 debug_printf ("handling possible serial event\n");
4462 /* Really handle it. */
4463 if (process_serial_event () < 0)
4466 /* Be sure to not change the selected thread behind GDB's back.
4467 Important in the non-stop mode asynchronous protocol. */
4468 set_desired_thread (1);
4473 /* Push a stop notification on the notification queue. */
4476 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4478 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4480 vstop_notif
->status
= *status
;
4481 vstop_notif
->ptid
= ptid
;
4482 /* Push Stop notification. */
4483 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4486 /* Event-loop callback for target events. */
4489 handle_target_event (int err
, gdb_client_data client_data
)
4492 debug_printf ("handling possible target event\n");
4494 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4497 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4499 if (gdb_connected () && report_no_resumed
)
4500 push_stop_notification (null_ptid
, &last_status
);
4502 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4504 int pid
= ptid_get_pid (last_ptid
);
4505 struct process_info
*process
= find_process_pid (pid
);
4506 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4508 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4509 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4511 mark_breakpoints_out (process
);
4512 target_mourn_inferior (last_ptid
);
4514 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4518 /* We're reporting this thread as stopped. Update its
4519 "want-stopped" state to what the client wants, until it
4520 gets a new resume action. */
4521 current_thread
->last_resume_kind
= resume_stop
;
4522 current_thread
->last_status
= last_status
;
4527 if (!target_running ())
4529 /* The last process exited. We're done. */
4533 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4534 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4535 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4539 /* A thread stopped with a signal, but gdb isn't
4540 connected to handle it. Pass it down to the
4541 inferior, as if it wasn't being traced. */
4542 enum gdb_signal signal
;
4545 debug_printf ("GDB not connected; forwarding event %d for"
4547 (int) last_status
.kind
,
4548 target_pid_to_str (last_ptid
));
4550 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4551 signal
= last_status
.value
.sig
;
4553 signal
= GDB_SIGNAL_0
;
4554 target_continue (last_ptid
, signal
);
4558 push_stop_notification (last_ptid
, &last_status
);
4561 /* Be sure to not change the selected thread behind GDB's back.
4562 Important in the non-stop mode asynchronous protocol. */
4563 set_desired_thread (1);
4576 } // namespace selftests
4577 #endif /* GDB_SELF_TEST */