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 /* The environment to pass to the inferior when creating it. */
45 struct gdb_environ
*our_environ
= NULL
;
47 /* Start the inferior using a shell. */
49 /* We always try to start the inferior using a shell. */
51 int startup_with_shell
= 1;
53 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
54 `vCont'. Note the multi-process extensions made `vCont' a
55 requirement, so `Hc pPID.TID' is pretty much undefined. So
56 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
57 resuming all threads of the process (again, `Hc' isn't used for
58 multi-process), or a specific thread ptid_t. */
61 /* The thread set with an `Hg' packet. */
62 ptid_t general_thread
;
66 static int extended_protocol
;
67 static int response_needed
;
68 static int exit_requested
;
70 /* --once: Exit after the first connection has closed. */
74 int report_fork_events
;
75 int report_vfork_events
;
76 int report_exec_events
;
77 int report_thread_events
;
79 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
80 static int report_no_resumed
;
86 /* True if the "vContSupported" feature is active. In that case, GDB
87 wants us to report whether single step is supported in the reply to
89 static int vCont_supported
;
91 /* Whether we should attempt to disable the operating system's address
92 space randomization feature before starting an inferior. */
93 int disable_randomization
= 1;
95 static char *program_name
= NULL
;
96 static std::vector
<char *> program_args
;
97 static std::string wrapper_argv
;
99 int pass_signals
[GDB_SIGNAL_LAST
];
100 int program_signals
[GDB_SIGNAL_LAST
];
101 int program_signals_p
;
103 /* The PID of the originally created or attached inferior. Used to
104 send signals to the process when GDB sends us an asynchronous interrupt
105 (user hitting Control-C in the client), and to wait for the child to exit
106 when no longer debugging it. */
108 unsigned long signal_pid
;
110 /* Set if you want to disable optional thread related packets support
111 in gdbserver, for the sake of testing GDB against stubs that don't
113 int disable_packet_vCont
;
114 int disable_packet_Tthread
;
115 int disable_packet_qC
;
116 int disable_packet_qfThreadInfo
;
118 /* Last status reported to GDB. */
119 struct target_waitstatus last_status
;
123 static unsigned char *mem_buf
;
125 /* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
131 struct notif_event base
;
133 /* Thread or process that got the event. */
137 struct target_waitstatus status
;
140 /* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142 static struct btrace_config current_btrace_conf
;
144 DEFINE_QUEUE_P (notif_event_p
);
146 /* Put a stop reply to the stop reply queue. */
149 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
151 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
153 new_notif
->ptid
= ptid
;
154 new_notif
->status
= *status
;
156 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
160 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
161 QUEUE_ITER (notif_event_p
) *iter
,
162 struct notif_event
*event
,
165 ptid_t filter_ptid
= *(ptid_t
*) data
;
166 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
168 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
170 if (q
->free_func
!= NULL
)
171 q
->free_func (event
);
173 QUEUE_remove_elem (notif_event_p
, q
, iter
);
182 discard_queued_stop_replies (ptid_t ptid
)
184 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
185 remove_all_on_match_ptid
, &ptid
);
189 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
191 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
193 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
196 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
199 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
200 QUEUE_ITER (notif_event_p
) *iter
,
201 struct notif_event
*event
,
204 ptid_t filter_ptid
= *(ptid_t
*) data
;
205 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
207 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
210 /* Don't resume fork children that GDB does not know about yet. */
211 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
212 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
213 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
222 in_queued_stop_replies (ptid_t ptid
)
224 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
225 in_queued_stop_replies_ptid
, &ptid
);
228 struct notif_server notif_stop
=
230 "vStopped", "Stop", NULL
, vstop_notif_reply
,
234 target_running (void)
236 return get_first_thread () != NULL
;
239 /* See common/common-inferior.h. */
244 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
247 /* See common/common-inferior.h. */
250 get_exec_file (int err
)
252 if (err
&& program_name
== NULL
)
253 error (_("No executable file specified."));
267 attach_inferior (int pid
)
269 /* myattach should return -1 if attaching is unsupported,
270 0 if it succeeded, and call error() otherwise. */
272 if (myattach (pid
) != 0)
275 fprintf (stderr
, "Attached; pid = %d\n", pid
);
278 /* FIXME - It may be that we should get the SIGNAL_PID from the
279 attach function, so that it can be the main thread instead of
280 whichever we were told to attach to. */
285 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
287 /* GDB knows to ignore the first SIGSTOP after attaching to a running
288 process using the "attach" command, but this is different; it's
289 just using "target remote". Pretend it's just starting up. */
290 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
291 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
292 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
294 current_thread
->last_resume_kind
= resume_stop
;
295 current_thread
->last_status
= last_status
;
301 extern int remote_debug
;
303 /* Decode a qXfer read request. Return 0 if everything looks OK,
307 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
309 /* After the read marker and annex, qXfer looks like a
310 traditional 'm' packet. */
311 decode_m_packet (buf
, ofs
, len
);
317 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
319 /* Extract and NUL-terminate the object. */
321 while (*buf
&& *buf
!= ':')
327 /* Extract and NUL-terminate the read/write action. */
329 while (*buf
&& *buf
!= ':')
335 /* Extract and NUL-terminate the annex. */
337 while (*buf
&& *buf
!= ':')
347 /* Write the response to a successful qXfer read. Returns the
348 length of the (binary) data stored in BUF, corresponding
349 to as much of DATA/LEN as we could fit. IS_MORE controls
350 the first character of the response. */
352 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
361 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
362 &out_len
, PBUFSIZ
- 2) + 1;
365 /* Handle btrace enabling in BTS format. */
368 handle_btrace_enable_bts (struct thread_info
*thread
)
370 if (thread
->btrace
!= NULL
)
371 return "E.Btrace already enabled.";
373 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
374 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
375 ¤t_btrace_conf
);
376 if (thread
->btrace
== NULL
)
377 return "E.Could not enable btrace.";
382 /* Handle btrace enabling in Intel Processor Trace format. */
385 handle_btrace_enable_pt (struct thread_info
*thread
)
387 if (thread
->btrace
!= NULL
)
388 return "E.Btrace already enabled.";
390 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
391 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
392 ¤t_btrace_conf
);
393 if (thread
->btrace
== NULL
)
394 return "E.Could not enable btrace.";
399 /* Handle btrace disabling. */
402 handle_btrace_disable (struct thread_info
*thread
)
405 if (thread
->btrace
== NULL
)
406 return "E.Branch tracing not enabled.";
408 if (target_disable_btrace (thread
->btrace
) != 0)
409 return "E.Could not disable branch tracing.";
411 thread
->btrace
= NULL
;
415 /* Handle the "Qbtrace" packet. */
418 handle_btrace_general_set (char *own_buf
)
420 struct thread_info
*thread
;
424 if (!startswith (own_buf
, "Qbtrace:"))
427 op
= own_buf
+ strlen ("Qbtrace:");
429 if (ptid_equal (general_thread
, null_ptid
)
430 || ptid_equal (general_thread
, minus_one_ptid
))
432 strcpy (own_buf
, "E.Must select a single thread.");
436 thread
= find_thread_ptid (general_thread
);
439 strcpy (own_buf
, "E.No such thread.");
445 if (strcmp (op
, "bts") == 0)
446 err
= handle_btrace_enable_bts (thread
);
447 else if (strcmp (op
, "pt") == 0)
448 err
= handle_btrace_enable_pt (thread
);
449 else if (strcmp (op
, "off") == 0)
450 err
= handle_btrace_disable (thread
);
452 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
455 strcpy (own_buf
, err
);
462 /* Handle the "Qbtrace-conf" packet. */
465 handle_btrace_conf_general_set (char *own_buf
)
467 struct thread_info
*thread
;
470 if (!startswith (own_buf
, "Qbtrace-conf:"))
473 op
= own_buf
+ strlen ("Qbtrace-conf:");
475 if (ptid_equal (general_thread
, null_ptid
)
476 || ptid_equal (general_thread
, minus_one_ptid
))
478 strcpy (own_buf
, "E.Must select a single thread.");
482 thread
= find_thread_ptid (general_thread
);
485 strcpy (own_buf
, "E.No such thread.");
489 if (startswith (op
, "bts:size="))
495 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
496 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
498 strcpy (own_buf
, "E.Bad size value.");
502 current_btrace_conf
.bts
.size
= (unsigned int) size
;
504 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
510 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
511 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
513 strcpy (own_buf
, "E.Bad size value.");
517 current_btrace_conf
.pt
.size
= (unsigned int) size
;
521 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
529 /* Handle all of the extended 'Q' packets. */
532 handle_general_set (char *own_buf
)
534 if (startswith (own_buf
, "QPassSignals:"))
536 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
537 const char *p
= own_buf
+ strlen ("QPassSignals:");
540 p
= decode_address_to_semicolon (&cursig
, p
);
541 for (i
= 0; i
< numsigs
; i
++)
547 /* Keep looping, to clear the remaining signals. */
550 p
= decode_address_to_semicolon (&cursig
, p
);
555 strcpy (own_buf
, "OK");
559 if (startswith (own_buf
, "QProgramSignals:"))
561 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
562 const char *p
= own_buf
+ strlen ("QProgramSignals:");
565 program_signals_p
= 1;
567 p
= decode_address_to_semicolon (&cursig
, p
);
568 for (i
= 0; i
< numsigs
; i
++)
572 program_signals
[i
] = 1;
574 /* Keep looping, to clear the remaining signals. */
577 p
= decode_address_to_semicolon (&cursig
, p
);
580 program_signals
[i
] = 0;
582 strcpy (own_buf
, "OK");
586 if (startswith (own_buf
, "QCatchSyscalls:"))
588 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
591 struct process_info
*process
;
593 if (!target_running () || !target_supports_catch_syscall ())
599 if (strcmp (p
, "0") == 0)
601 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
605 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
611 process
= current_process ();
612 VEC_truncate (int, process
->syscalls_to_catch
, 0);
622 p
= decode_address_to_semicolon (&sysno
, p
);
623 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
627 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
634 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
638 debug_printf ("[noack mode enabled]\n");
647 if (startswith (own_buf
, "QNonStop:"))
649 char *mode
= own_buf
+ 9;
653 if (strcmp (mode
, "0") == 0)
655 else if (strcmp (mode
, "1") == 0)
659 /* We don't know what this mode is, so complain to
661 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
667 req_str
= req
? "non-stop" : "all-stop";
668 if (start_non_stop (req
) != 0)
670 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
678 debug_printf ("[%s mode enabled]\n", req_str
);
684 if (startswith (own_buf
, "QDisableRandomization:"))
686 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
689 unpack_varlen_hex (packet
, &setting
);
690 disable_randomization
= setting
;
694 debug_printf (disable_randomization
695 ? "[address space randomization disabled]\n"
696 : "[address space randomization enabled]\n");
703 if (target_supports_tracepoints ()
704 && handle_tracepoint_general_set (own_buf
))
707 if (startswith (own_buf
, "QAgent:"))
709 char *mode
= own_buf
+ strlen ("QAgent:");
712 if (strcmp (mode
, "0") == 0)
714 else if (strcmp (mode
, "1") == 0)
718 /* We don't know what this value is, so complain to GDB. */
719 sprintf (own_buf
, "E.Unknown QAgent value");
723 /* Update the flag. */
726 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
731 if (handle_btrace_general_set (own_buf
))
734 if (handle_btrace_conf_general_set (own_buf
))
737 if (startswith (own_buf
, "QThreadEvents:"))
739 char *mode
= own_buf
+ strlen ("QThreadEvents:");
740 enum tribool req
= TRIBOOL_UNKNOWN
;
742 if (strcmp (mode
, "0") == 0)
744 else if (strcmp (mode
, "1") == 0)
748 char *mode_copy
= xstrdup (mode
);
750 /* We don't know what this mode is, so complain to GDB. */
751 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
757 report_thread_events
= (req
== TRIBOOL_TRUE
);
761 const char *req_str
= report_thread_events
? "enabled" : "disabled";
763 debug_printf ("[thread events are now %s]\n", req_str
);
770 /* Otherwise we didn't know what packet it was. Say we didn't
776 get_features_xml (const char *annex
)
778 const struct target_desc
*desc
= current_target_desc ();
780 /* `desc->xmltarget' defines what to return when looking for the
781 "target.xml" file. Its contents can either be verbatim XML code
782 (prefixed with a '@') or else the name of the actual XML file to
783 be used in place of "target.xml".
785 This variable is set up from the auto-generated
786 init_registers_... routine for the current target. */
788 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
790 if (*desc
->xmltarget
== '@')
791 return desc
->xmltarget
+ 1;
793 annex
= desc
->xmltarget
;
798 extern const char *const xml_builtin
[][2];
801 /* Look for the annex. */
802 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
803 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
806 if (xml_builtin
[i
][0] != NULL
)
807 return xml_builtin
[i
][1];
815 monitor_show_help (void)
817 monitor_output ("The following monitor commands are supported:\n");
818 monitor_output (" set debug <0|1>\n");
819 monitor_output (" Enable general debugging messages\n");
820 monitor_output (" set debug-hw-points <0|1>\n");
821 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
822 monitor_output (" set remote-debug <0|1>\n");
823 monitor_output (" Enable remote protocol debugging messages\n");
824 monitor_output (" set debug-format option1[,option2,...]\n");
825 monitor_output (" Add additional information to debugging messages\n");
826 monitor_output (" Options: all, none");
827 monitor_output (", timestamp");
828 monitor_output ("\n");
829 monitor_output (" exit\n");
830 monitor_output (" Quit GDBserver\n");
833 /* Read trace frame or inferior memory. Returns the number of bytes
834 actually read, zero when no further transfer is possible, and -1 on
835 error. Return of a positive value smaller than LEN does not
836 indicate there's no more to be read, only the end of the transfer.
837 E.g., when GDB reads memory from a traceframe, a first request may
838 be served from a memory block that does not cover the whole request
839 length. A following request gets the rest served from either
840 another block (of the same traceframe) or from the read-only
844 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
848 if (current_traceframe
>= 0)
851 ULONGEST length
= len
;
853 if (traceframe_read_mem (current_traceframe
,
854 memaddr
, myaddr
, len
, &nbytes
))
856 /* Data read from trace buffer, we're done. */
859 if (!in_readonly_region (memaddr
, length
))
861 /* Otherwise we have a valid readonly case, fall through. */
862 /* (assume no half-trace half-real blocks for now) */
865 res
= prepare_to_access_memory ();
868 if (set_desired_thread (1))
869 res
= read_inferior_memory (memaddr
, myaddr
, len
);
872 done_accessing_memory ();
874 return res
== 0 ? len
: -1;
880 /* Write trace frame or inferior memory. Actually, writing to trace
881 frames is forbidden. */
884 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
886 if (current_traceframe
>= 0)
892 ret
= prepare_to_access_memory ();
895 if (set_desired_thread (1))
896 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
899 done_accessing_memory ();
905 /* Subroutine of handle_search_memory to simplify it. */
908 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
909 gdb_byte
*pattern
, unsigned pattern_len
,
910 gdb_byte
*search_buf
,
911 unsigned chunk_size
, unsigned search_buf_size
,
912 CORE_ADDR
*found_addrp
)
914 /* Prime the search buffer. */
916 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
919 warning ("Unable to access %ld bytes of target "
920 "memory at 0x%lx, halting search.",
921 (long) search_buf_size
, (long) start_addr
);
925 /* Perform the search.
927 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
928 When we've scanned N bytes we copy the trailing bytes to the start and
929 read in another N bytes. */
931 while (search_space_len
>= pattern_len
)
934 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
938 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
941 if (found_ptr
!= NULL
)
943 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
944 *found_addrp
= found_addr
;
948 /* Not found in this chunk, skip to next chunk. */
950 /* Don't let search_space_len wrap here, it's unsigned. */
951 if (search_space_len
>= chunk_size
)
952 search_space_len
-= chunk_size
;
954 search_space_len
= 0;
956 if (search_space_len
>= pattern_len
)
958 unsigned keep_len
= search_buf_size
- chunk_size
;
959 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
962 /* Copy the trailing part of the previous iteration to the front
963 of the buffer for the next iteration. */
964 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
966 nr_to_read
= (search_space_len
- keep_len
< chunk_size
967 ? search_space_len
- keep_len
970 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
971 nr_to_read
) != search_buf_size
)
973 warning ("Unable to access %ld bytes of target memory "
974 "at 0x%lx, halting search.",
975 (long) nr_to_read
, (long) read_addr
);
979 start_addr
+= chunk_size
;
988 /* Handle qSearch:memory packets. */
991 handle_search_memory (char *own_buf
, int packet_len
)
993 CORE_ADDR start_addr
;
994 CORE_ADDR search_space_len
;
996 unsigned int pattern_len
;
997 /* NOTE: also defined in find.c testcase. */
998 #define SEARCH_CHUNK_SIZE 16000
999 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1000 /* Buffer to hold memory contents for searching. */
1001 gdb_byte
*search_buf
;
1002 unsigned search_buf_size
;
1004 CORE_ADDR found_addr
;
1005 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1007 pattern
= (gdb_byte
*) malloc (packet_len
);
1008 if (pattern
== NULL
)
1010 error ("Unable to allocate memory to perform the search");
1011 strcpy (own_buf
, "E00");
1014 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1015 packet_len
- cmd_name_len
,
1016 &start_addr
, &search_space_len
,
1017 pattern
, &pattern_len
) < 0)
1020 error ("Error in parsing qSearch:memory packet");
1021 strcpy (own_buf
, "E00");
1025 search_buf_size
= chunk_size
+ pattern_len
- 1;
1027 /* No point in trying to allocate a buffer larger than the search space. */
1028 if (search_space_len
< search_buf_size
)
1029 search_buf_size
= search_space_len
;
1031 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1032 if (search_buf
== NULL
)
1035 error ("Unable to allocate memory to perform the search");
1036 strcpy (own_buf
, "E00");
1040 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1041 pattern
, pattern_len
,
1042 search_buf
, chunk_size
, search_buf_size
,
1046 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1047 else if (found
== 0)
1048 strcpy (own_buf
, "0");
1050 strcpy (own_buf
, "E00");
1056 #define require_running(BUF) \
1057 if (!target_running ()) \
1063 /* Parse options to --debug-format= and "monitor set debug-format".
1064 ARG is the text after "--debug-format=" or "monitor set debug-format".
1065 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1066 This triggers calls to monitor_output.
1067 The result is NULL if all options were parsed ok, otherwise an error
1068 message which the caller must free.
1070 N.B. These commands affect all debug format settings, they are not
1071 cumulative. If a format is not specified, it is turned off.
1072 However, we don't go to extra trouble with things like
1073 "monitor set debug-format all,none,timestamp".
1074 Instead we just parse them one at a time, in order.
1076 The syntax for "monitor set debug" we support here is not identical
1077 to gdb's "set debug foo on|off" because we also use this function to
1078 parse "--debug-format=foo,bar". */
1081 parse_debug_format_options (const char *arg
, int is_monitor
)
1083 VEC (char_ptr
) *options
;
1087 /* First turn all debug format options off. */
1088 debug_timestamp
= 0;
1090 /* First remove leading spaces, for "monitor set debug-format". */
1091 while (isspace (*arg
))
1094 options
= delim_string_to_char_ptr_vec (arg
, ',');
1096 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1098 if (strcmp (option
, "all") == 0)
1100 debug_timestamp
= 1;
1102 monitor_output ("All extra debug format options enabled.\n");
1104 else if (strcmp (option
, "none") == 0)
1106 debug_timestamp
= 0;
1108 monitor_output ("All extra debug format options disabled.\n");
1110 else if (strcmp (option
, "timestamp") == 0)
1112 debug_timestamp
= 1;
1114 monitor_output ("Timestamps will be added to debug output.\n");
1116 else if (*option
== '\0')
1118 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1123 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1126 free_char_ptr_vec (options
);
1131 free_char_ptr_vec (options
);
1135 /* Handle monitor commands not handled by target-specific handlers. */
1138 handle_monitor_command (char *mon
, char *own_buf
)
1140 if (strcmp (mon
, "set debug 1") == 0)
1143 monitor_output ("Debug output enabled.\n");
1145 else if (strcmp (mon
, "set debug 0") == 0)
1148 monitor_output ("Debug output disabled.\n");
1150 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1152 show_debug_regs
= 1;
1153 monitor_output ("H/W point debugging output enabled.\n");
1155 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1157 show_debug_regs
= 0;
1158 monitor_output ("H/W point debugging output disabled.\n");
1160 else if (strcmp (mon
, "set remote-debug 1") == 0)
1163 monitor_output ("Protocol debug output enabled.\n");
1165 else if (strcmp (mon
, "set remote-debug 0") == 0)
1168 monitor_output ("Protocol debug output disabled.\n");
1170 else if (startswith (mon
, "set debug-format "))
1173 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1176 if (error_msg
!= NULL
)
1178 monitor_output (error_msg
);
1179 monitor_show_help ();
1180 write_enn (own_buf
);
1184 else if (strcmp (mon
, "help") == 0)
1185 monitor_show_help ();
1186 else if (strcmp (mon
, "exit") == 0)
1190 monitor_output ("Unknown monitor command.\n\n");
1191 monitor_show_help ();
1192 write_enn (own_buf
);
1196 /* Associates a callback with each supported qXfer'able object. */
1200 /* The object this handler handles. */
1203 /* Request that the target transfer up to LEN 8-bit bytes of the
1204 target's OBJECT. The OFFSET, for a seekable object, specifies
1205 the starting point. The ANNEX can be used to provide additional
1206 data-specific information to the target.
1208 Return the number of bytes actually transfered, zero when no
1209 further transfer is possible, -1 on error, -2 when the transfer
1210 is not supported, and -3 on a verbose error message that should
1211 be preserved. Return of a positive value smaller than LEN does
1212 not indicate the end of the object, only the end of the transfer.
1214 One, and only one, of readbuf or writebuf must be non-NULL. */
1215 int (*xfer
) (const char *annex
,
1216 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1217 ULONGEST offset
, LONGEST len
);
1220 /* Handle qXfer:auxv:read. */
1223 handle_qxfer_auxv (const char *annex
,
1224 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1225 ULONGEST offset
, LONGEST len
)
1227 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1230 if (annex
[0] != '\0' || current_thread
== NULL
)
1233 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1236 /* Handle qXfer:exec-file:read. */
1239 handle_qxfer_exec_file (const char *const_annex
,
1240 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1241 ULONGEST offset
, LONGEST len
)
1247 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1250 if (const_annex
[0] == '\0')
1252 if (current_thread
== NULL
)
1255 pid
= pid_of (current_thread
);
1259 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1261 strcpy (annex
, const_annex
);
1262 annex
= unpack_varlen_hex (annex
, &pid
);
1264 if (annex
[0] != '\0')
1271 file
= (*the_target
->pid_to_exec_file
) (pid
);
1275 total_len
= strlen (file
);
1277 if (offset
> total_len
)
1280 if (offset
+ len
> total_len
)
1281 len
= total_len
- offset
;
1283 memcpy (readbuf
, file
+ offset
, len
);
1287 /* Handle qXfer:features:read. */
1290 handle_qxfer_features (const char *annex
,
1291 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1292 ULONGEST offset
, LONGEST len
)
1294 const char *document
;
1297 if (writebuf
!= NULL
)
1300 if (!target_running ())
1303 /* Grab the correct annex. */
1304 document
= get_features_xml (annex
);
1305 if (document
== NULL
)
1308 total_len
= strlen (document
);
1310 if (offset
> total_len
)
1313 if (offset
+ len
> total_len
)
1314 len
= total_len
- offset
;
1316 memcpy (readbuf
, document
+ offset
, len
);
1320 /* Worker routine for handle_qxfer_libraries.
1321 Add to the length pointed to by ARG a conservative estimate of the
1322 length needed to transmit the file name of INF. */
1325 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1327 struct dll_info
*dll
= (struct dll_info
*) inf
;
1328 unsigned int *total_len
= (unsigned int *) arg
;
1330 /* Over-estimate the necessary memory. Assume that every character
1331 in the library name must be escaped. */
1332 *total_len
+= 128 + 6 * strlen (dll
->name
);
1335 /* Worker routine for handle_qxfer_libraries.
1336 Emit the XML to describe the library in INF. */
1339 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1341 struct dll_info
*dll
= (struct dll_info
*) inf
;
1342 char **p_ptr
= (char **) arg
;
1346 strcpy (p
, " <library name=\"");
1348 name
= xml_escape_text (dll
->name
);
1352 strcpy (p
, "\"><segment address=\"");
1354 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1356 strcpy (p
, "\"/></library>\n");
1362 /* Handle qXfer:libraries:read. */
1365 handle_qxfer_libraries (const char *annex
,
1366 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1367 ULONGEST offset
, LONGEST len
)
1369 unsigned int total_len
;
1372 if (writebuf
!= NULL
)
1375 if (annex
[0] != '\0' || current_thread
== NULL
)
1379 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1382 document
= (char *) malloc (total_len
);
1383 if (document
== NULL
)
1386 strcpy (document
, "<library-list version=\"1.0\">\n");
1387 p
= document
+ strlen (document
);
1389 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1391 strcpy (p
, "</library-list>\n");
1393 total_len
= strlen (document
);
1395 if (offset
> total_len
)
1401 if (offset
+ len
> total_len
)
1402 len
= total_len
- offset
;
1404 memcpy (readbuf
, document
+ offset
, len
);
1409 /* Handle qXfer:libraries-svr4:read. */
1412 handle_qxfer_libraries_svr4 (const char *annex
,
1413 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1414 ULONGEST offset
, LONGEST len
)
1416 if (writebuf
!= NULL
)
1419 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1422 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1425 /* Handle qXfer:osadata:read. */
1428 handle_qxfer_osdata (const char *annex
,
1429 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1430 ULONGEST offset
, LONGEST len
)
1432 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1435 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1438 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1441 handle_qxfer_siginfo (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
)
1445 if (the_target
->qxfer_siginfo
== NULL
)
1448 if (annex
[0] != '\0' || current_thread
== NULL
)
1451 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1454 /* Handle qXfer:spu:read and qXfer:spu:write. */
1457 handle_qxfer_spu (const char *annex
,
1458 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1459 ULONGEST offset
, LONGEST len
)
1461 if (the_target
->qxfer_spu
== NULL
)
1464 if (current_thread
== NULL
)
1467 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1470 /* Handle qXfer:statictrace:read. */
1473 handle_qxfer_statictrace (const char *annex
,
1474 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1475 ULONGEST offset
, LONGEST len
)
1479 if (writebuf
!= NULL
)
1482 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1485 if (traceframe_read_sdata (current_traceframe
, offset
,
1486 readbuf
, len
, &nbytes
))
1491 /* Helper for handle_qxfer_threads_proper.
1492 Emit the XML to describe the thread of INF. */
1495 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1497 struct thread_info
*thread
= (struct thread_info
*) inf
;
1498 struct buffer
*buffer
= (struct buffer
*) arg
;
1499 ptid_t ptid
= thread_to_gdb_id (thread
);
1501 int core
= target_core_of_thread (ptid
);
1503 const char *name
= target_thread_name (ptid
);
1505 write_ptid (ptid_s
, ptid
);
1507 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1511 sprintf (core_s
, "%d", core
);
1512 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1516 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1518 buffer_xml_printf (buffer
, "/>\n");
1521 /* Helper for handle_qxfer_threads. */
1524 handle_qxfer_threads_proper (struct buffer
*buffer
)
1526 buffer_grow_str (buffer
, "<threads>\n");
1528 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1531 buffer_grow_str0 (buffer
, "</threads>\n");
1534 /* Handle qXfer:threads:read. */
1537 handle_qxfer_threads (const char *annex
,
1538 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1539 ULONGEST offset
, LONGEST len
)
1541 static char *result
= 0;
1542 static unsigned int result_length
= 0;
1544 if (writebuf
!= NULL
)
1547 if (annex
[0] != '\0')
1552 struct buffer buffer
;
1553 /* When asked for data at offset 0, generate everything and store into
1554 'result'. Successive reads will be served off 'result'. */
1558 buffer_init (&buffer
);
1560 handle_qxfer_threads_proper (&buffer
);
1562 result
= buffer_finish (&buffer
);
1563 result_length
= strlen (result
);
1564 buffer_free (&buffer
);
1567 if (offset
>= result_length
)
1569 /* We're out of data. */
1576 if (len
> result_length
- offset
)
1577 len
= result_length
- offset
;
1579 memcpy (readbuf
, result
+ offset
, len
);
1584 /* Handle qXfer:traceframe-info:read. */
1587 handle_qxfer_traceframe_info (const char *annex
,
1588 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1589 ULONGEST offset
, LONGEST len
)
1591 static char *result
= 0;
1592 static unsigned int result_length
= 0;
1594 if (writebuf
!= NULL
)
1597 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1602 struct buffer buffer
;
1604 /* When asked for data at offset 0, generate everything and
1605 store into 'result'. Successive reads will be served off
1609 buffer_init (&buffer
);
1611 traceframe_read_info (current_traceframe
, &buffer
);
1613 result
= buffer_finish (&buffer
);
1614 result_length
= strlen (result
);
1615 buffer_free (&buffer
);
1618 if (offset
>= result_length
)
1620 /* We're out of data. */
1627 if (len
> result_length
- offset
)
1628 len
= result_length
- offset
;
1630 memcpy (readbuf
, result
+ offset
, len
);
1634 /* Handle qXfer:fdpic:read. */
1637 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1638 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1640 if (the_target
->read_loadmap
== NULL
)
1643 if (current_thread
== NULL
)
1646 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1649 /* Handle qXfer:btrace:read. */
1652 handle_qxfer_btrace (const char *annex
,
1653 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1654 ULONGEST offset
, LONGEST len
)
1656 static struct buffer cache
;
1657 struct thread_info
*thread
;
1658 enum btrace_read_type type
;
1661 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1664 if (ptid_equal (general_thread
, null_ptid
)
1665 || ptid_equal (general_thread
, minus_one_ptid
))
1667 strcpy (own_buf
, "E.Must select a single thread.");
1671 thread
= find_thread_ptid (general_thread
);
1674 strcpy (own_buf
, "E.No such thread.");
1678 if (thread
->btrace
== NULL
)
1680 strcpy (own_buf
, "E.Btrace not enabled.");
1684 if (strcmp (annex
, "all") == 0)
1685 type
= BTRACE_READ_ALL
;
1686 else if (strcmp (annex
, "new") == 0)
1687 type
= BTRACE_READ_NEW
;
1688 else if (strcmp (annex
, "delta") == 0)
1689 type
= BTRACE_READ_DELTA
;
1692 strcpy (own_buf
, "E.Bad annex.");
1698 buffer_free (&cache
);
1700 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1703 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1707 else if (offset
> cache
.used_size
)
1709 buffer_free (&cache
);
1713 if (len
> cache
.used_size
- offset
)
1714 len
= cache
.used_size
- offset
;
1716 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1721 /* Handle qXfer:btrace-conf:read. */
1724 handle_qxfer_btrace_conf (const char *annex
,
1725 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1726 ULONGEST offset
, LONGEST len
)
1728 static struct buffer cache
;
1729 struct thread_info
*thread
;
1732 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1735 if (annex
[0] != '\0')
1738 if (ptid_equal (general_thread
, null_ptid
)
1739 || ptid_equal (general_thread
, minus_one_ptid
))
1741 strcpy (own_buf
, "E.Must select a single thread.");
1745 thread
= find_thread_ptid (general_thread
);
1748 strcpy (own_buf
, "E.No such thread.");
1752 if (thread
->btrace
== NULL
)
1754 strcpy (own_buf
, "E.Btrace not enabled.");
1760 buffer_free (&cache
);
1762 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1765 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1769 else if (offset
> cache
.used_size
)
1771 buffer_free (&cache
);
1775 if (len
> cache
.used_size
- offset
)
1776 len
= cache
.used_size
- offset
;
1778 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1783 static const struct qxfer qxfer_packets
[] =
1785 { "auxv", handle_qxfer_auxv
},
1786 { "btrace", handle_qxfer_btrace
},
1787 { "btrace-conf", handle_qxfer_btrace_conf
},
1788 { "exec-file", handle_qxfer_exec_file
},
1789 { "fdpic", handle_qxfer_fdpic
},
1790 { "features", handle_qxfer_features
},
1791 { "libraries", handle_qxfer_libraries
},
1792 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1793 { "osdata", handle_qxfer_osdata
},
1794 { "siginfo", handle_qxfer_siginfo
},
1795 { "spu", handle_qxfer_spu
},
1796 { "statictrace", handle_qxfer_statictrace
},
1797 { "threads", handle_qxfer_threads
},
1798 { "traceframe-info", handle_qxfer_traceframe_info
},
1802 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1810 if (!startswith (own_buf
, "qXfer:"))
1813 /* Grab the object, r/w and annex. */
1814 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1816 write_enn (own_buf
);
1821 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1824 const struct qxfer
*q
= &qxfer_packets
[i
];
1826 if (strcmp (object
, q
->object
) == 0)
1828 if (strcmp (rw
, "read") == 0)
1830 unsigned char *data
;
1835 /* Grab the offset and length. */
1836 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1838 write_enn (own_buf
);
1842 /* Read one extra byte, as an indicator of whether there is
1844 if (len
> PBUFSIZ
- 2)
1846 data
= (unsigned char *) malloc (len
+ 1);
1849 write_enn (own_buf
);
1852 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1860 /* Preserve error message. */
1863 write_enn (own_buf
);
1865 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1867 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1872 else if (strcmp (rw
, "write") == 0)
1877 unsigned char *data
;
1879 strcpy (own_buf
, "E00");
1880 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1883 write_enn (own_buf
);
1886 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1887 &ofs
, &len
, data
) < 0)
1890 write_enn (own_buf
);
1894 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1902 /* Preserve error message. */
1905 write_enn (own_buf
);
1907 sprintf (own_buf
, "%x", n
);
1920 /* Compute 32 bit CRC from inferior memory.
1922 On success, return 32 bit CRC.
1923 On failure, return (unsigned long long) -1. */
1925 static unsigned long long
1926 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1930 unsigned char byte
= 0;
1932 /* Return failure if memory read fails. */
1933 if (read_inferior_memory (base
, &byte
, 1) != 0)
1934 return (unsigned long long) -1;
1936 crc
= xcrc32 (&byte
, 1, crc
);
1939 return (unsigned long long) crc
;
1942 /* Add supported btrace packets to BUF. */
1945 supported_btrace_packets (char *buf
)
1947 int btrace_supported
= 0;
1949 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1951 strcat (buf
, ";Qbtrace:bts+");
1952 strcat (buf
, ";Qbtrace-conf:bts:size+");
1954 btrace_supported
= 1;
1957 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1959 strcat (buf
, ";Qbtrace:pt+");
1960 strcat (buf
, ";Qbtrace-conf:pt:size+");
1962 btrace_supported
= 1;
1965 if (!btrace_supported
)
1968 strcat (buf
, ";Qbtrace:off+");
1969 strcat (buf
, ";qXfer:btrace:read+");
1970 strcat (buf
, ";qXfer:btrace-conf:read+");
1973 /* Handle all of the extended 'q' packets. */
1976 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1978 static struct inferior_list_entry
*thread_ptr
;
1980 /* Reply the current thread id. */
1981 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1984 require_running (own_buf
);
1986 if (!ptid_equal (general_thread
, null_ptid
)
1987 && !ptid_equal (general_thread
, minus_one_ptid
))
1988 gdb_id
= general_thread
;
1991 thread_ptr
= get_first_inferior (&all_threads
);
1992 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1995 sprintf (own_buf
, "QC");
1997 write_ptid (own_buf
, gdb_id
);
2001 if (strcmp ("qSymbol::", own_buf
) == 0)
2003 struct thread_info
*save_thread
= current_thread
;
2005 /* For qSymbol, GDB only changes the current thread if the
2006 previous current thread was of a different process. So if
2007 the previous thread is gone, we need to pick another one of
2008 the same process. This can happen e.g., if we followed an
2009 exec in a non-leader thread. */
2010 if (current_thread
== NULL
)
2013 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2015 /* Just in case, if we didn't find a thread, then bail out
2016 instead of crashing. */
2017 if (current_thread
== NULL
)
2019 write_enn (own_buf
);
2020 current_thread
= save_thread
;
2025 /* GDB is suggesting new symbols have been loaded. This may
2026 mean a new shared library has been detected as loaded, so
2027 take the opportunity to check if breakpoints we think are
2028 inserted, still are. Note that it isn't guaranteed that
2029 we'll see this when a shared library is loaded, and nor will
2030 we see this for unloads (although breakpoints in unloaded
2031 libraries shouldn't trigger), as GDB may not find symbols for
2032 the library at all. We also re-validate breakpoints when we
2033 see a second GDB breakpoint for the same address, and or when
2034 we access breakpoint shadows. */
2035 validate_breakpoints ();
2037 if (target_supports_tracepoints ())
2038 tracepoint_look_up_symbols ();
2040 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2041 (*the_target
->look_up_symbols
) ();
2043 current_thread
= save_thread
;
2045 strcpy (own_buf
, "OK");
2049 if (!disable_packet_qfThreadInfo
)
2051 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2055 require_running (own_buf
);
2056 thread_ptr
= get_first_inferior (&all_threads
);
2059 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2060 write_ptid (own_buf
, gdb_id
);
2061 thread_ptr
= thread_ptr
->next
;
2065 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2069 require_running (own_buf
);
2070 if (thread_ptr
!= NULL
)
2073 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2074 write_ptid (own_buf
, gdb_id
);
2075 thread_ptr
= thread_ptr
->next
;
2080 sprintf (own_buf
, "l");
2086 if (the_target
->read_offsets
!= NULL
2087 && strcmp ("qOffsets", own_buf
) == 0)
2089 CORE_ADDR text
, data
;
2091 require_running (own_buf
);
2092 if (the_target
->read_offsets (&text
, &data
))
2093 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2094 (long)text
, (long)data
, (long)data
);
2096 write_enn (own_buf
);
2101 /* Protocol features query. */
2102 if (startswith (own_buf
, "qSupported")
2103 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2105 char *p
= &own_buf
[10];
2106 int gdb_supports_qRelocInsn
= 0;
2108 /* Process each feature being provided by GDB. The first
2109 feature will follow a ':', and latter features will follow
2113 char **qsupported
= NULL
;
2118 /* Two passes, to avoid nested strtok calls in
2119 target_process_qsupported. */
2120 for (p
= strtok (p
+ 1, ";");
2122 p
= strtok (NULL
, ";"))
2125 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2126 qsupported
[count
- 1] = xstrdup (p
);
2129 for (i
= 0; i
< count
; i
++)
2132 if (strcmp (p
, "multiprocess+") == 0)
2134 /* GDB supports and wants multi-process support if
2136 if (target_supports_multi_process ())
2139 else if (strcmp (p
, "qRelocInsn+") == 0)
2141 /* GDB supports relocate instruction requests. */
2142 gdb_supports_qRelocInsn
= 1;
2144 else if (strcmp (p
, "swbreak+") == 0)
2146 /* GDB wants us to report whether a trap is caused
2147 by a software breakpoint and for us to handle PC
2148 adjustment if necessary on this target. */
2149 if (target_supports_stopped_by_sw_breakpoint ())
2150 swbreak_feature
= 1;
2152 else if (strcmp (p
, "hwbreak+") == 0)
2154 /* GDB wants us to report whether a trap is caused
2155 by a hardware breakpoint. */
2156 if (target_supports_stopped_by_hw_breakpoint ())
2157 hwbreak_feature
= 1;
2159 else if (strcmp (p
, "fork-events+") == 0)
2161 /* GDB supports and wants fork events if possible. */
2162 if (target_supports_fork_events ())
2163 report_fork_events
= 1;
2165 else if (strcmp (p
, "vfork-events+") == 0)
2167 /* GDB supports and wants vfork events if possible. */
2168 if (target_supports_vfork_events ())
2169 report_vfork_events
= 1;
2171 else if (strcmp (p
, "exec-events+") == 0)
2173 /* GDB supports and wants exec events if possible. */
2174 if (target_supports_exec_events ())
2175 report_exec_events
= 1;
2177 else if (strcmp (p
, "vContSupported+") == 0)
2178 vCont_supported
= 1;
2179 else if (strcmp (p
, "QThreadEvents+") == 0)
2181 else if (strcmp (p
, "no-resumed+") == 0)
2183 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2185 report_no_resumed
= 1;
2189 /* Move the unknown features all together. */
2190 qsupported
[i
] = NULL
;
2191 qsupported
[unknown
] = p
;
2196 /* Give the target backend a chance to process the unknown
2198 target_process_qsupported (qsupported
, unknown
);
2200 for (i
= 0; i
< count
; i
++)
2201 free (qsupported
[i
]);
2206 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2209 if (target_supports_catch_syscall ())
2210 strcat (own_buf
, ";QCatchSyscalls+");
2212 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2213 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2214 ";augmented-libraries-svr4-read+");
2217 /* We do not have any hook to indicate whether the non-SVR4 target
2218 backend supports qXfer:libraries:read, so always report it. */
2219 strcat (own_buf
, ";qXfer:libraries:read+");
2222 if (the_target
->read_auxv
!= NULL
)
2223 strcat (own_buf
, ";qXfer:auxv:read+");
2225 if (the_target
->qxfer_spu
!= NULL
)
2226 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2228 if (the_target
->qxfer_siginfo
!= NULL
)
2229 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2231 if (the_target
->read_loadmap
!= NULL
)
2232 strcat (own_buf
, ";qXfer:fdpic:read+");
2234 /* We always report qXfer:features:read, as targets may
2235 install XML files on a subsequent call to arch_setup.
2236 If we reported to GDB on startup that we don't support
2237 qXfer:feature:read at all, we will never be re-queried. */
2238 strcat (own_buf
, ";qXfer:features:read+");
2240 if (transport_is_reliable
)
2241 strcat (own_buf
, ";QStartNoAckMode+");
2243 if (the_target
->qxfer_osdata
!= NULL
)
2244 strcat (own_buf
, ";qXfer:osdata:read+");
2246 if (target_supports_multi_process ())
2247 strcat (own_buf
, ";multiprocess+");
2249 if (target_supports_fork_events ())
2250 strcat (own_buf
, ";fork-events+");
2252 if (target_supports_vfork_events ())
2253 strcat (own_buf
, ";vfork-events+");
2255 if (target_supports_exec_events ())
2256 strcat (own_buf
, ";exec-events+");
2258 if (target_supports_non_stop ())
2259 strcat (own_buf
, ";QNonStop+");
2261 if (target_supports_disable_randomization ())
2262 strcat (own_buf
, ";QDisableRandomization+");
2264 strcat (own_buf
, ";qXfer:threads:read+");
2266 if (target_supports_tracepoints ())
2268 strcat (own_buf
, ";ConditionalTracepoints+");
2269 strcat (own_buf
, ";TraceStateVariables+");
2270 strcat (own_buf
, ";TracepointSource+");
2271 strcat (own_buf
, ";DisconnectedTracing+");
2272 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2273 strcat (own_buf
, ";FastTracepoints+");
2274 strcat (own_buf
, ";StaticTracepoints+");
2275 strcat (own_buf
, ";InstallInTrace+");
2276 strcat (own_buf
, ";qXfer:statictrace:read+");
2277 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2278 strcat (own_buf
, ";EnableDisableTracepoints+");
2279 strcat (own_buf
, ";QTBuffer:size+");
2280 strcat (own_buf
, ";tracenz+");
2283 if (target_supports_hardware_single_step ()
2284 || target_supports_software_single_step () )
2286 strcat (own_buf
, ";ConditionalBreakpoints+");
2288 strcat (own_buf
, ";BreakpointCommands+");
2290 if (target_supports_agent ())
2291 strcat (own_buf
, ";QAgent+");
2293 supported_btrace_packets (own_buf
);
2295 if (target_supports_stopped_by_sw_breakpoint ())
2296 strcat (own_buf
, ";swbreak+");
2298 if (target_supports_stopped_by_hw_breakpoint ())
2299 strcat (own_buf
, ";hwbreak+");
2301 if (the_target
->pid_to_exec_file
!= NULL
)
2302 strcat (own_buf
, ";qXfer:exec-file:read+");
2304 strcat (own_buf
, ";vContSupported+");
2306 strcat (own_buf
, ";QThreadEvents+");
2308 strcat (own_buf
, ";no-resumed+");
2310 /* Reinitialize components as needed for the new connection. */
2311 hostio_handle_new_gdb_connection ();
2312 target_handle_new_gdb_connection ();
2317 /* Thread-local storage support. */
2318 if (the_target
->get_tls_address
!= NULL
2319 && startswith (own_buf
, "qGetTLSAddr:"))
2321 char *p
= own_buf
+ 12;
2322 CORE_ADDR parts
[2], address
= 0;
2324 ptid_t ptid
= null_ptid
;
2326 require_running (own_buf
);
2328 for (i
= 0; i
< 3; i
++)
2336 p2
= strchr (p
, ',');
2349 ptid
= read_ptid (p
, NULL
);
2351 decode_address (&parts
[i
- 1], p
, len
);
2355 if (p
!= NULL
|| i
< 3)
2359 struct thread_info
*thread
= find_thread_ptid (ptid
);
2364 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2370 strcpy (own_buf
, paddress(address
));
2375 write_enn (own_buf
);
2379 /* Otherwise, pretend we do not understand this packet. */
2382 /* Windows OS Thread Information Block address support. */
2383 if (the_target
->get_tib_address
!= NULL
2384 && startswith (own_buf
, "qGetTIBAddr:"))
2389 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2391 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2394 strcpy (own_buf
, paddress(tlb
));
2399 write_enn (own_buf
);
2405 /* Handle "monitor" commands. */
2406 if (startswith (own_buf
, "qRcmd,"))
2408 char *mon
= (char *) malloc (PBUFSIZ
);
2409 int len
= strlen (own_buf
+ 6);
2413 write_enn (own_buf
);
2418 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2420 write_enn (own_buf
);
2424 mon
[len
/ 2] = '\0';
2428 if (the_target
->handle_monitor_command
== NULL
2429 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2430 /* Default processing. */
2431 handle_monitor_command (mon
, own_buf
);
2437 if (startswith (own_buf
, "qSearch:memory:"))
2439 require_running (own_buf
);
2440 handle_search_memory (own_buf
, packet_len
);
2444 if (strcmp (own_buf
, "qAttached") == 0
2445 || startswith (own_buf
, "qAttached:"))
2447 struct process_info
*process
;
2449 if (own_buf
[sizeof ("qAttached") - 1])
2451 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2452 process
= (struct process_info
*)
2453 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2457 require_running (own_buf
);
2458 process
= current_process ();
2461 if (process
== NULL
)
2463 write_enn (own_buf
);
2467 strcpy (own_buf
, process
->attached
? "1" : "0");
2471 if (startswith (own_buf
, "qCRC:"))
2473 /* CRC check (compare-section). */
2477 unsigned long long crc
;
2479 require_running (own_buf
);
2480 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2481 if (*comma
++ != ',')
2483 write_enn (own_buf
);
2486 len
= strtoul (comma
, NULL
, 16);
2487 crc
= crc32 (base
, len
, 0xffffffff);
2488 /* Check for memory failure. */
2489 if (crc
== (unsigned long long) -1)
2491 write_enn (own_buf
);
2494 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2498 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2501 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2504 /* Otherwise we didn't know what packet it was. Say we didn't
2509 static void gdb_wants_all_threads_stopped (void);
2510 static void resume (struct thread_resume
*actions
, size_t n
);
2512 /* The callback that is passed to visit_actioned_threads. */
2513 typedef int (visit_actioned_threads_callback_ftype
)
2514 (const struct thread_resume
*, struct thread_info
*);
2516 /* Struct to pass data to visit_actioned_threads. */
2518 struct visit_actioned_threads_data
2520 const struct thread_resume
*actions
;
2522 visit_actioned_threads_callback_ftype
*callback
;
2525 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2526 true if CALLBACK returns true. Returns false if no matching thread
2527 is found or CALLBACK results false.
2528 Note: This function is itself a callback for find_inferior. */
2531 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2533 struct visit_actioned_threads_data
*data
2534 = (struct visit_actioned_threads_data
*) datap
;
2535 const struct thread_resume
*actions
= data
->actions
;
2536 size_t num_actions
= data
->num_actions
;
2537 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2540 for (i
= 0; i
< num_actions
; i
++)
2542 const struct thread_resume
*action
= &actions
[i
];
2544 if (ptid_equal (action
->thread
, minus_one_ptid
)
2545 || ptid_equal (action
->thread
, entry
->id
)
2546 || ((ptid_get_pid (action
->thread
)
2547 == ptid_get_pid (entry
->id
))
2548 && ptid_get_lwp (action
->thread
) == -1))
2550 struct thread_info
*thread
= (struct thread_info
*) entry
;
2552 if ((*callback
) (action
, thread
))
2560 /* Callback for visit_actioned_threads. If the thread has a pending
2561 status to report, report it now. */
2564 handle_pending_status (const struct thread_resume
*resumption
,
2565 struct thread_info
*thread
)
2567 if (thread
->status_pending_p
)
2569 thread
->status_pending_p
= 0;
2571 last_status
= thread
->last_status
;
2572 last_ptid
= thread
->entry
.id
;
2573 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2579 /* Parse vCont packets. */
2581 handle_v_cont (char *own_buf
)
2585 struct thread_resume
*resume_info
;
2586 struct thread_resume default_action
{ null_ptid
};
2588 /* Count the number of semicolons in the packet. There should be one
2589 for every action. */
2595 p
= strchr (p
, ';');
2598 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2599 if (resume_info
== NULL
)
2607 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2609 if (p
[0] == 's' || p
[0] == 'S')
2610 resume_info
[i
].kind
= resume_step
;
2611 else if (p
[0] == 'r')
2612 resume_info
[i
].kind
= resume_step
;
2613 else if (p
[0] == 'c' || p
[0] == 'C')
2614 resume_info
[i
].kind
= resume_continue
;
2615 else if (p
[0] == 't')
2616 resume_info
[i
].kind
= resume_stop
;
2620 if (p
[0] == 'S' || p
[0] == 'C')
2623 sig
= strtol (p
+ 1, &q
, 16);
2628 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2630 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2632 else if (p
[0] == 'r')
2636 p
= unpack_varlen_hex (p
+ 1, &addr
);
2637 resume_info
[i
].step_range_start
= addr
;
2642 p
= unpack_varlen_hex (p
+ 1, &addr
);
2643 resume_info
[i
].step_range_end
= addr
;
2652 resume_info
[i
].thread
= minus_one_ptid
;
2653 default_action
= resume_info
[i
];
2655 /* Note: we don't increment i here, we'll overwrite this entry
2656 the next time through. */
2658 else if (p
[0] == ':')
2660 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2665 if (p
[0] != ';' && p
[0] != 0)
2668 resume_info
[i
].thread
= ptid
;
2675 resume_info
[i
] = default_action
;
2677 resume (resume_info
, n
);
2682 write_enn (own_buf
);
2687 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2690 resume (struct thread_resume
*actions
, size_t num_actions
)
2694 /* Check if among the threads that GDB wants actioned, there's
2695 one with a pending status to report. If so, skip actually
2696 resuming/stopping and report the pending event
2698 struct visit_actioned_threads_data data
;
2700 data
.actions
= actions
;
2701 data
.num_actions
= num_actions
;
2702 data
.callback
= handle_pending_status
;
2703 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2709 (*the_target
->resume
) (actions
, num_actions
);
2715 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2717 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2718 && !report_no_resumed
)
2720 /* The client does not support this stop reply. At least
2722 sprintf (own_buf
, "E.No unwaited-for children left.");
2723 disable_async_io ();
2727 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2728 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2729 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2730 current_thread
->last_status
= last_status
;
2732 /* From the client's perspective, all-stop mode always stops all
2733 threads implicitly (and the target backend has already done
2734 so by now). Tag all threads as "want-stopped", so we don't
2735 resume them implicitly without the client telling us to. */
2736 gdb_wants_all_threads_stopped ();
2737 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2738 disable_async_io ();
2740 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2741 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2742 target_mourn_inferior (last_ptid
);
2746 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2748 handle_v_attach (char *own_buf
)
2752 pid
= strtol (own_buf
+ 8, NULL
, 16);
2753 if (pid
!= 0 && attach_inferior (pid
) == 0)
2755 /* Don't report shared library events after attaching, even if
2756 some libraries are preloaded. GDB will always poll the
2757 library list. Avoids the "stopped by shared library event"
2758 notice on the GDB side. */
2763 /* In non-stop, we don't send a resume reply. Stop events
2764 will follow up using the normal notification
2769 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2775 write_enn (own_buf
);
2780 /* Run a new program. Return 1 if successful, 0 if failure. */
2782 handle_v_run (char *own_buf
)
2785 std::vector
<char *> new_argv
;
2786 char *new_program_name
= NULL
;
2790 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2796 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2798 next_p
= strchr (p
, ';');
2800 next_p
= p
+ strlen (p
);
2802 if (i
== 0 && p
== next_p
)
2804 /* No program specified. */
2805 new_program_name
= NULL
;
2807 else if (p
== next_p
)
2809 /* Empty argument. */
2810 new_argv
.push_back (xstrdup ("''"));
2814 size_t len
= (next_p
- p
) / 2;
2815 /* ARG is the unquoted argument received via the RSP. */
2816 char *arg
= (char *) xmalloc (len
+ 1);
2817 /* FULL_ARGS will contain the quoted version of ARG. */
2818 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2819 /* These are pointers used to navigate the strings above. */
2820 char *tmp_arg
= arg
;
2821 char *tmp_full_arg
= full_arg
;
2824 hex2bin (p
, (gdb_byte
*) arg
, len
);
2827 while (*tmp_arg
!= '\0')
2833 *tmp_full_arg
= '\'';
2839 /* Quote single quote. */
2840 *tmp_full_arg
= '\\';
2848 *tmp_full_arg
= *tmp_arg
;
2854 *tmp_full_arg
++ = '\'';
2856 /* Finish FULL_ARG and push it into the vector containing
2858 *tmp_full_arg
= '\0';
2860 new_program_name
= full_arg
;
2862 new_argv
.push_back (full_arg
);
2868 new_argv
.push_back (NULL
);
2870 if (new_program_name
== NULL
)
2872 /* GDB didn't specify a program to run. Use the program from the
2873 last run with the new argument list. */
2874 if (program_name
== NULL
)
2876 write_enn (own_buf
);
2877 free_vector_argv (new_argv
);
2883 xfree (program_name
);
2884 program_name
= new_program_name
;
2887 /* Free the old argv and install the new one. */
2888 free_vector_argv (program_args
);
2889 program_args
= new_argv
;
2891 create_inferior (program_name
, program_args
);
2893 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2895 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2897 /* In non-stop, sending a resume reply doesn't set the general
2898 thread, but GDB assumes a vRun sets it (this is so GDB can
2899 query which is the main thread of the new inferior. */
2901 general_thread
= last_ptid
;
2907 write_enn (own_buf
);
2912 /* Kill process. Return 1 if successful, 0 if failure. */
2914 handle_v_kill (char *own_buf
)
2917 char *p
= &own_buf
[6];
2919 pid
= strtol (p
, NULL
, 16);
2922 if (pid
!= 0 && kill_inferior (pid
) == 0)
2924 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2925 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2926 last_ptid
= pid_to_ptid (pid
);
2927 discard_queued_stop_replies (last_ptid
);
2933 write_enn (own_buf
);
2938 /* Handle all of the extended 'v' packets. */
2940 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2942 if (!disable_packet_vCont
)
2944 if (strcmp (own_buf
, "vCtrlC") == 0)
2946 (*the_target
->request_interrupt
) ();
2951 if (startswith (own_buf
, "vCont;"))
2953 handle_v_cont (own_buf
);
2957 if (startswith (own_buf
, "vCont?"))
2959 strcpy (own_buf
, "vCont;c;C;t");
2961 if (target_supports_hardware_single_step ()
2962 || target_supports_software_single_step ()
2963 || !vCont_supported
)
2965 /* If target supports single step either by hardware or by
2966 software, add actions s and S to the list of supported
2967 actions. On the other hand, if GDB doesn't request the
2968 supported vCont actions in qSupported packet, add s and
2969 S to the list too. */
2970 own_buf
= own_buf
+ strlen (own_buf
);
2971 strcpy (own_buf
, ";s;S");
2974 if (target_supports_range_stepping ())
2976 own_buf
= own_buf
+ strlen (own_buf
);
2977 strcpy (own_buf
, ";r");
2983 if (startswith (own_buf
, "vFile:")
2984 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2987 if (startswith (own_buf
, "vAttach;"))
2989 if ((!extended_protocol
|| !multi_process
) && target_running ())
2991 fprintf (stderr
, "Already debugging a process\n");
2992 write_enn (own_buf
);
2995 handle_v_attach (own_buf
);
2999 if (startswith (own_buf
, "vRun;"))
3001 if ((!extended_protocol
|| !multi_process
) && target_running ())
3003 fprintf (stderr
, "Already debugging a process\n");
3004 write_enn (own_buf
);
3007 handle_v_run (own_buf
);
3011 if (startswith (own_buf
, "vKill;"))
3013 if (!target_running ())
3015 fprintf (stderr
, "No process to kill\n");
3016 write_enn (own_buf
);
3019 handle_v_kill (own_buf
);
3023 if (handle_notif_ack (own_buf
, packet_len
))
3026 /* Otherwise we didn't know what packet it was. Say we didn't
3032 /* Resume thread and wait for another event. In non-stop mode,
3033 don't really wait here, but return immediatelly to the event
3036 myresume (char *own_buf
, int step
, int sig
)
3038 struct thread_resume resume_info
[2];
3040 int valid_cont_thread
;
3042 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3043 && !ptid_equal (cont_thread
, minus_one_ptid
));
3045 if (step
|| sig
|| valid_cont_thread
)
3047 resume_info
[0].thread
= current_ptid
;
3049 resume_info
[0].kind
= resume_step
;
3051 resume_info
[0].kind
= resume_continue
;
3052 resume_info
[0].sig
= sig
;
3056 if (!valid_cont_thread
)
3058 resume_info
[n
].thread
= minus_one_ptid
;
3059 resume_info
[n
].kind
= resume_continue
;
3060 resume_info
[n
].sig
= 0;
3064 resume (resume_info
, n
);
3067 /* Callback for for_each_inferior. Make a new stop reply for each
3071 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3073 struct thread_info
*thread
= (struct thread_info
*) entry
;
3075 /* For now, assume targets that don't have this callback also don't
3076 manage the thread's last_status field. */
3077 if (the_target
->thread_stopped
== NULL
)
3079 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3081 new_notif
->ptid
= entry
->id
;
3082 new_notif
->status
= thread
->last_status
;
3083 /* Pass the last stop reply back to GDB, but don't notify
3085 notif_event_enque (¬if_stop
,
3086 (struct notif_event
*) new_notif
);
3090 if (thread_stopped (thread
))
3095 = target_waitstatus_to_string (&thread
->last_status
);
3097 debug_printf ("Reporting thread %s as already stopped with %s\n",
3098 target_pid_to_str (entry
->id
),
3101 xfree (status_string
);
3104 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3106 /* Pass the last stop reply back to GDB, but don't notify
3108 queue_stop_reply (entry
->id
, &thread
->last_status
);
3115 /* Set this inferior threads's state as "want-stopped". We won't
3116 resume this thread until the client gives us another action for
3120 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3122 struct thread_info
*thread
= (struct thread_info
*) entry
;
3124 thread
->last_resume_kind
= resume_stop
;
3126 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3128 /* Most threads are stopped implicitly (all-stop); tag that with
3130 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3131 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3135 /* Set all threads' states as "want-stopped". */
3138 gdb_wants_all_threads_stopped (void)
3140 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3143 /* Clear the gdb_detached flag of every process. */
3146 gdb_reattached_process (struct inferior_list_entry
*entry
)
3148 struct process_info
*process
= (struct process_info
*) entry
;
3150 process
->gdb_detached
= 0;
3153 /* Callback for for_each_inferior. Clear the thread's pending status
3157 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3159 struct thread_info
*thread
= (struct thread_info
*) entry
;
3161 thread
->status_pending_p
= 0;
3164 /* Callback for for_each_inferior. If the thread is stopped with an
3165 interesting event, mark it as having a pending event. */
3168 set_pending_status_callback (struct inferior_list_entry
*entry
)
3170 struct thread_info
*thread
= (struct thread_info
*) entry
;
3172 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3173 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3174 /* A breakpoint, watchpoint or finished step from a previous
3175 GDB run isn't considered interesting for a new GDB run.
3176 If we left those pending, the new GDB could consider them
3177 random SIGTRAPs. This leaves out real async traps. We'd
3178 have to peek into the (target-specific) siginfo to
3179 distinguish those. */
3180 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3181 thread
->status_pending_p
= 1;
3184 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3185 pending status to report to GDB. */
3188 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3190 struct thread_info
*thread
= (struct thread_info
*) entry
;
3192 return thread
->status_pending_p
;
3195 /* Status handler for the '?' packet. */
3198 handle_status (char *own_buf
)
3200 /* GDB is connected, don't forward events to the target anymore. */
3201 for_each_inferior (&all_processes
, gdb_reattached_process
);
3203 /* In non-stop mode, we must send a stop reply for each stopped
3204 thread. In all-stop mode, just send one for the first stopped
3209 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3211 /* The first is sent immediatly. OK is sent if there is no
3212 stopped thread, which is the same handling of the vStopped
3213 packet (by design). */
3214 notif_write_event (¬if_stop
, own_buf
);
3218 struct inferior_list_entry
*thread
= NULL
;
3221 stabilize_threads ();
3222 gdb_wants_all_threads_stopped ();
3224 /* We can only report one status, but we might be coming out of
3225 non-stop -- if more than one thread is stopped with
3226 interesting events, leave events for the threads we're not
3227 reporting now pending. They'll be reported the next time the
3228 threads are resumed. Start by marking all interesting events
3230 for_each_inferior (&all_threads
, set_pending_status_callback
);
3232 /* Prefer the last thread that reported an event to GDB (even if
3233 that was a GDB_SIGNAL_TRAP). */
3234 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3235 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3236 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3237 thread
= find_inferior_id (&all_threads
, last_ptid
);
3239 /* If the last event thread is not found for some reason, look
3240 for some other thread that might have an event to report. */
3242 thread
= find_inferior (&all_threads
,
3243 find_status_pending_thread_callback
, NULL
);
3245 /* If we're still out of luck, simply pick the first thread in
3248 thread
= get_first_inferior (&all_threads
);
3252 struct thread_info
*tp
= (struct thread_info
*) thread
;
3254 /* We're reporting this event, so it's no longer
3256 tp
->status_pending_p
= 0;
3258 /* GDB assumes the current thread is the thread we're
3259 reporting the status for. */
3260 general_thread
= thread
->id
;
3261 set_desired_thread (1);
3263 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3264 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3267 strcpy (own_buf
, "W00");
3272 gdbserver_version (void)
3274 printf ("GNU gdbserver %s%s\n"
3275 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3276 "gdbserver is free software, covered by the "
3277 "GNU General Public License.\n"
3278 "This gdbserver was configured as \"%s\"\n",
3279 PKGVERSION
, version
, host_name
);
3283 gdbserver_usage (FILE *stream
)
3285 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3286 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3287 "\tgdbserver [OPTIONS] --multi COMM\n"
3289 "COMM may either be a tty device (for serial debugging),\n"
3290 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3291 "stdin/stdout of gdbserver.\n"
3292 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3293 "PID is the process ID to attach to, when --attach is specified.\n"
3295 "Operating modes:\n"
3297 " --attach Attach to running process PID.\n"
3298 " --multi Start server without a specific program, and\n"
3299 " only quit when explicitly commanded.\n"
3300 " --once Exit after the first connection has closed.\n"
3301 " --help Print this message and then exit.\n"
3302 " --version Display version information and exit.\n"
3306 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3307 " --disable-randomization\n"
3308 " Run PROG with address space randomization disabled.\n"
3309 " --no-disable-randomization\n"
3310 " Don't disable address space randomization when\n"
3315 " --debug Enable general debugging output.\n"
3316 " --debug-format=opt1[,opt2,...]\n"
3317 " Specify extra content in debugging output.\n"
3322 " --remote-debug Enable remote protocol debugging output.\n"
3323 " --disable-packet=opt1[,opt2,...]\n"
3324 " Disable support for RSP packets or features.\n"
3326 " vCont, Tthread, qC, qfThreadInfo and \n"
3327 " threads (disable all threading packets).\n"
3329 "For more information, consult the GDB manual (available as on-line \n"
3330 "info or a printed manual).\n");
3331 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3332 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3336 gdbserver_show_disableable (FILE *stream
)
3338 fprintf (stream
, "Disableable packets:\n"
3339 " vCont \tAll vCont packets\n"
3340 " qC \tQuerying the current thread\n"
3341 " qfThreadInfo\tThread listing\n"
3342 " Tthread \tPassing the thread specifier in the "
3343 "T stop reply packet\n"
3344 " threads \tAll of the above\n");
3348 #undef require_running
3349 #define require_running(BUF) \
3350 if (!target_running ()) \
3357 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3359 int pid
= * (int *) args
;
3361 if (ptid_get_pid (entry
->id
) == pid
)
3368 kill_inferior_callback (struct inferior_list_entry
*entry
)
3370 struct process_info
*process
= (struct process_info
*) entry
;
3371 int pid
= ptid_get_pid (process
->entry
.id
);
3373 kill_inferior (pid
);
3374 discard_queued_stop_replies (pid_to_ptid (pid
));
3377 /* Callback for for_each_inferior to detach or kill the inferior,
3378 depending on whether we attached to it or not.
3379 We inform the user whether we're detaching or killing the process
3380 as this is only called when gdbserver is about to exit. */
3383 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3385 struct process_info
*process
= (struct process_info
*) entry
;
3386 int pid
= ptid_get_pid (process
->entry
.id
);
3388 if (process
->attached
)
3389 detach_inferior (pid
);
3391 kill_inferior (pid
);
3393 discard_queued_stop_replies (pid_to_ptid (pid
));
3396 /* for_each_inferior callback for detach_or_kill_for_exit to print
3397 the pids of started inferiors. */
3400 print_started_pid (struct inferior_list_entry
*entry
)
3402 struct process_info
*process
= (struct process_info
*) entry
;
3404 if (! process
->attached
)
3406 int pid
= ptid_get_pid (process
->entry
.id
);
3407 fprintf (stderr
, " %d", pid
);
3411 /* for_each_inferior callback for detach_or_kill_for_exit to print
3412 the pids of attached inferiors. */
3415 print_attached_pid (struct inferior_list_entry
*entry
)
3417 struct process_info
*process
= (struct process_info
*) entry
;
3419 if (process
->attached
)
3421 int pid
= ptid_get_pid (process
->entry
.id
);
3422 fprintf (stderr
, " %d", pid
);
3426 /* Call this when exiting gdbserver with possible inferiors that need
3427 to be killed or detached from. */
3430 detach_or_kill_for_exit (void)
3432 /* First print a list of the inferiors we will be killing/detaching.
3433 This is to assist the user, for example, in case the inferior unexpectedly
3434 dies after we exit: did we screw up or did the inferior exit on its own?
3435 Having this info will save some head-scratching. */
3437 if (have_started_inferiors_p ())
3439 fprintf (stderr
, "Killing process(es):");
3440 for_each_inferior (&all_processes
, print_started_pid
);
3441 fprintf (stderr
, "\n");
3443 if (have_attached_inferiors_p ())
3445 fprintf (stderr
, "Detaching process(es):");
3446 for_each_inferior (&all_processes
, print_attached_pid
);
3447 fprintf (stderr
, "\n");
3450 /* Now we can kill or detach the inferiors. */
3452 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3455 /* Value that will be passed to exit(3) when gdbserver exits. */
3456 static int exit_code
;
3458 /* Cleanup version of detach_or_kill_for_exit. */
3461 detach_or_kill_for_exit_cleanup (void *ignore
)
3466 detach_or_kill_for_exit ();
3469 CATCH (exception
, RETURN_MASK_ALL
)
3472 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3478 /* Main function. This is called by the real "main" function,
3479 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3481 static void ATTRIBUTE_NORETURN
3482 captured_main (int argc
, char *argv
[])
3487 const char *port
= NULL
;
3488 char **next_arg
= &argv
[1];
3489 volatile int multi_mode
= 0;
3490 volatile int attach
= 0;
3493 while (*next_arg
!= NULL
&& **next_arg
== '-')
3495 if (strcmp (*next_arg
, "--version") == 0)
3497 gdbserver_version ();
3500 else if (strcmp (*next_arg
, "--help") == 0)
3502 gdbserver_usage (stdout
);
3505 else if (strcmp (*next_arg
, "--attach") == 0)
3507 else if (strcmp (*next_arg
, "--multi") == 0)
3509 else if (strcmp (*next_arg
, "--wrapper") == 0)
3516 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3518 wrapper_argv
+= *next_arg
;
3519 wrapper_argv
+= ' ';
3523 if (!wrapper_argv
.empty ())
3525 /* Erase the last whitespace. */
3526 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3529 if (next_arg
== tmp
|| *next_arg
== NULL
)
3531 gdbserver_usage (stderr
);
3535 /* Consume the "--". */
3538 else if (strcmp (*next_arg
, "--debug") == 0)
3540 else if (startswith (*next_arg
, "--debug-format="))
3543 = parse_debug_format_options ((*next_arg
)
3544 + sizeof ("--debug-format=") - 1, 0);
3546 if (error_msg
!= NULL
)
3548 fprintf (stderr
, "%s", error_msg
);
3552 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3554 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3556 gdbserver_show_disableable (stdout
);
3559 else if (startswith (*next_arg
, "--disable-packet="))
3561 char *packets
, *tok
;
3563 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3564 for (tok
= strtok (packets
, ",");
3566 tok
= strtok (NULL
, ","))
3568 if (strcmp ("vCont", tok
) == 0)
3569 disable_packet_vCont
= 1;
3570 else if (strcmp ("Tthread", tok
) == 0)
3571 disable_packet_Tthread
= 1;
3572 else if (strcmp ("qC", tok
) == 0)
3573 disable_packet_qC
= 1;
3574 else if (strcmp ("qfThreadInfo", tok
) == 0)
3575 disable_packet_qfThreadInfo
= 1;
3576 else if (strcmp ("threads", tok
) == 0)
3578 disable_packet_vCont
= 1;
3579 disable_packet_Tthread
= 1;
3580 disable_packet_qC
= 1;
3581 disable_packet_qfThreadInfo
= 1;
3585 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3587 gdbserver_show_disableable (stderr
);
3592 else if (strcmp (*next_arg
, "-") == 0)
3594 /* "-" specifies a stdio connection and is a form of port
3596 port
= STDIO_CONNECTION_NAME
;
3600 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3601 disable_randomization
= 1;
3602 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3603 disable_randomization
= 0;
3604 else if (strcmp (*next_arg
, "--once") == 0)
3608 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3621 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3623 gdbserver_usage (stderr
);
3627 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3628 opened by remote_prepare. */
3631 save_original_signals_state ();
3633 /* We need to know whether the remote connection is stdio before
3634 starting the inferior. Inferiors created in this scenario have
3635 stdin,stdout redirected. So do this here before we call
3637 remote_prepare (port
);
3642 /* --attach used to come after PORT, so allow it there for
3644 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3651 && (*next_arg
== NULL
3652 || (*next_arg
)[0] == '\0'
3653 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3655 || next_arg
[1] != NULL
))
3660 gdbserver_usage (stderr
);
3664 /* Gather information about the environment. */
3665 our_environ
= make_environ ();
3666 init_environ (our_environ
);
3668 initialize_async_io ();
3670 have_job_control ();
3671 initialize_event_loop ();
3672 if (target_supports_tracepoints ())
3673 initialize_tracepoint ();
3674 initialize_notif ();
3676 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3677 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3679 if (pid
== 0 && *next_arg
!= NULL
)
3683 n
= argc
- (next_arg
- argv
);
3684 program_name
= xstrdup (next_arg
[0]);
3685 for (i
= 1; i
< n
; i
++)
3686 program_args
.push_back (xstrdup (next_arg
[i
]));
3687 program_args
.push_back (NULL
);
3689 /* Wait till we are at first instruction in program. */
3690 create_inferior (program_name
, program_args
);
3692 /* We are now (hopefully) stopped at the first instruction of
3693 the target process. This assumes that the target process was
3694 successfully created. */
3698 if (attach_inferior (pid
) == -1)
3699 error ("Attaching not supported on this target");
3701 /* Otherwise succeeded. */
3705 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3706 last_status
.value
.integer
= 0;
3707 last_ptid
= minus_one_ptid
;
3709 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3711 /* Don't report shared library events on the initial connection,
3712 even if some libraries are preloaded. Avoids the "stopped by
3713 shared library event" notice on gdb side. */
3716 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3717 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3722 if (!was_running
&& !multi_mode
)
3723 error ("No program to debug");
3730 report_fork_events
= 0;
3731 report_vfork_events
= 0;
3732 report_exec_events
= 0;
3733 /* Be sure we're out of tfind mode. */
3734 current_traceframe
= -1;
3735 cont_thread
= null_ptid
;
3736 swbreak_feature
= 0;
3737 hwbreak_feature
= 0;
3738 vCont_supported
= 0;
3744 /* Wait for events. This will return when all event sources
3745 are removed from the event loop. */
3746 start_event_loop ();
3748 /* If an exit was requested (using the "monitor exit"
3749 command), terminate now. */
3751 throw_quit ("Quit");
3753 /* The only other way to get here is for getpkt to fail:
3755 - If --once was specified, we're done.
3757 - If not in extended-remote mode, and we're no longer
3758 debugging anything, simply exit: GDB has disconnected
3759 after processing the last process exit.
3761 - Otherwise, close the connection and reopen it at the
3763 if (run_once
|| (!extended_protocol
&& !target_running ()))
3764 throw_quit ("Quit");
3767 "Remote side has terminated connection. "
3768 "GDBserver will reopen the connection.\n");
3770 /* Get rid of any pending statuses. An eventual reconnection
3771 (by the same GDB instance or another) will refresh all its
3772 state from scratch. */
3773 discard_queued_stop_replies (minus_one_ptid
);
3774 for_each_inferior (&all_threads
,
3775 clear_pending_status_callback
);
3779 if (disconnected_tracing
)
3781 /* Try to enable non-stop/async mode, so we we can
3782 both wait for an async socket accept, and handle
3783 async target events simultaneously. There's also
3784 no point either in having the target always stop
3785 all threads, when we're going to pass signals
3786 down without informing GDB. */
3789 if (start_non_stop (1))
3792 /* Detaching implicitly resumes all threads;
3793 simply disconnecting does not. */
3799 "Disconnected tracing disabled; "
3800 "stopping trace run.\n");
3805 CATCH (exception
, RETURN_MASK_ERROR
)
3808 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3810 if (response_needed
)
3812 write_enn (own_buf
);
3817 throw_quit ("Quit");
3823 /* Main function. */
3826 main (int argc
, char *argv
[])
3831 captured_main (argc
, argv
);
3833 CATCH (exception
, RETURN_MASK_ALL
)
3835 if (exception
.reason
== RETURN_ERROR
)
3838 fprintf (stderr
, "%s\n", exception
.message
);
3839 fprintf (stderr
, "Exiting\n");
3847 gdb_assert_not_reached ("captured_main should never return");
3850 /* Process options coming from Z packets for a breakpoint. PACKET is
3851 the packet buffer. *PACKET is updated to point to the first char
3852 after the last processed option. */
3855 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3857 char *dataptr
= *packet
;
3860 /* Check if data has the correct format. */
3861 if (*dataptr
!= ';')
3868 if (*dataptr
== ';')
3871 if (*dataptr
== 'X')
3873 /* Conditional expression. */
3875 debug_printf ("Found breakpoint condition.\n");
3876 if (!add_breakpoint_condition (bp
, &dataptr
))
3877 dataptr
= strchrnul (dataptr
, ';');
3879 else if (startswith (dataptr
, "cmds:"))
3881 dataptr
+= strlen ("cmds:");
3883 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3884 persist
= (*dataptr
== '1');
3886 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3887 dataptr
= strchrnul (dataptr
, ';');
3891 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3893 /* Skip tokens until we find one that we recognize. */
3894 dataptr
= strchrnul (dataptr
, ';');
3900 /* Event loop callback that handles a serial event. The first byte in
3901 the serial buffer gets us here. We expect characters to arrive at
3902 a brisk pace, so we read the rest of the packet with a blocking
3906 process_serial_event (void)
3917 int new_packet_len
= -1;
3919 disable_async_io ();
3921 response_needed
= 0;
3922 packet_len
= getpkt (own_buf
);
3923 if (packet_len
<= 0)
3926 /* Force an event loop break. */
3929 response_needed
= 1;
3936 handle_query (own_buf
, packet_len
, &new_packet_len
);
3939 handle_general_set (own_buf
);
3942 require_running (own_buf
);
3947 pid
= strtol (&own_buf
[i
], NULL
, 16);
3950 pid
= ptid_get_pid (current_ptid
);
3952 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3954 struct process_info
*process
= find_process_pid (pid
);
3956 if (process
== NULL
)
3958 write_enn (own_buf
);
3962 if (tracing
&& disconnected_tracing
)
3964 "Disconnected tracing in effect, "
3965 "leaving gdbserver attached to the process\n");
3967 if (any_persistent_commands ())
3969 "Persistent commands are present, "
3970 "leaving gdbserver attached to the process\n");
3972 /* Make sure we're in non-stop/async mode, so we we can both
3973 wait for an async socket accept, and handle async target
3974 events simultaneously. There's also no point either in
3975 having the target stop all threads, when we're going to
3976 pass signals down without informing GDB. */
3980 debug_printf ("Forcing non-stop mode\n");
3986 process
->gdb_detached
= 1;
3988 /* Detaching implicitly resumes all threads. */
3989 target_continue_no_signal (minus_one_ptid
);
3992 break; /* from switch/case */
3995 fprintf (stderr
, "Detaching from process %d\n", pid
);
3997 if (detach_inferior (pid
) != 0)
3998 write_enn (own_buf
);
4001 discard_queued_stop_replies (pid_to_ptid (pid
));
4004 if (extended_protocol
|| target_running ())
4006 /* There is still at least one inferior remaining or
4007 we are in extended mode, so don't terminate gdbserver,
4008 and instead treat this like a normal program exit. */
4009 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4010 last_status
.value
.integer
= 0;
4011 last_ptid
= pid_to_ptid (pid
);
4013 current_thread
= NULL
;
4020 /* If we are attached, then we can exit. Otherwise, we
4021 need to hang around doing nothing, until the child is
4023 join_inferior (pid
);
4029 extended_protocol
= 1;
4033 handle_status (own_buf
);
4036 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4038 ptid_t gdb_id
, thread_id
;
4041 require_running (own_buf
);
4043 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4045 pid
= ptid_get_pid (gdb_id
);
4047 if (ptid_equal (gdb_id
, null_ptid
)
4048 || ptid_equal (gdb_id
, minus_one_ptid
))
4049 thread_id
= null_ptid
;
4051 && ptid_equal (pid_to_ptid (pid
),
4054 struct thread_info
*thread
=
4055 (struct thread_info
*) find_inferior (&all_threads
,
4060 write_enn (own_buf
);
4064 thread_id
= thread
->entry
.id
;
4068 thread_id
= gdb_id_to_thread_id (gdb_id
);
4069 if (ptid_equal (thread_id
, null_ptid
))
4071 write_enn (own_buf
);
4076 if (own_buf
[1] == 'g')
4078 if (ptid_equal (thread_id
, null_ptid
))
4080 /* GDB is telling us to choose any thread. Check if
4081 the currently selected thread is still valid. If
4082 it is not, select the first available. */
4083 struct thread_info
*thread
=
4084 (struct thread_info
*) find_inferior_id (&all_threads
,
4087 thread
= get_first_thread ();
4088 thread_id
= thread
->entry
.id
;
4091 general_thread
= thread_id
;
4092 set_desired_thread (1);
4093 gdb_assert (current_thread
!= NULL
);
4095 else if (own_buf
[1] == 'c')
4096 cont_thread
= thread_id
;
4102 /* Silently ignore it so that gdb can extend the protocol
4103 without compatibility headaches. */
4108 require_running (own_buf
);
4109 if (current_traceframe
>= 0)
4111 struct regcache
*regcache
4112 = new_register_cache (current_target_desc ());
4114 if (fetch_traceframe_registers (current_traceframe
,
4116 registers_to_string (regcache
, own_buf
);
4118 write_enn (own_buf
);
4119 free_register_cache (regcache
);
4123 struct regcache
*regcache
;
4125 if (!set_desired_thread (1))
4126 write_enn (own_buf
);
4129 regcache
= get_thread_regcache (current_thread
, 1);
4130 registers_to_string (regcache
, own_buf
);
4135 require_running (own_buf
);
4136 if (current_traceframe
>= 0)
4137 write_enn (own_buf
);
4140 struct regcache
*regcache
;
4142 if (!set_desired_thread (1))
4143 write_enn (own_buf
);
4146 regcache
= get_thread_regcache (current_thread
, 1);
4147 registers_from_string (regcache
, &own_buf
[1]);
4153 require_running (own_buf
);
4154 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4155 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4157 write_enn (own_buf
);
4159 bin2hex (mem_buf
, own_buf
, res
);
4162 require_running (own_buf
);
4163 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4164 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4167 write_enn (own_buf
);
4170 require_running (own_buf
);
4171 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4172 &mem_addr
, &len
, &mem_buf
) < 0
4173 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4174 write_enn (own_buf
);
4179 require_running (own_buf
);
4180 hex2bin (own_buf
+ 1, &sig
, 1);
4181 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4182 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4185 myresume (own_buf
, 0, signal
);
4188 require_running (own_buf
);
4189 hex2bin (own_buf
+ 1, &sig
, 1);
4190 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4191 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4194 myresume (own_buf
, 1, signal
);
4197 require_running (own_buf
);
4199 myresume (own_buf
, 0, signal
);
4202 require_running (own_buf
);
4204 myresume (own_buf
, 1, signal
);
4206 case 'Z': /* insert_ ... */
4208 case 'z': /* remove_ ... */
4213 char type
= own_buf
[1];
4215 const int insert
= ch
== 'Z';
4216 char *p
= &own_buf
[3];
4218 p
= unpack_varlen_hex (p
, &addr
);
4219 kind
= strtol (p
+ 1, &dataptr
, 16);
4223 struct gdb_breakpoint
*bp
;
4225 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4230 /* GDB may have sent us a list of *point parameters to
4231 be evaluated on the target's side. Read such list
4232 here. If we already have a list of parameters, GDB
4233 is telling us to drop that list and use this one
4235 clear_breakpoint_conditions_and_commands (bp
);
4236 process_point_options (bp
, &dataptr
);
4240 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4248 write_enn (own_buf
);
4252 response_needed
= 0;
4253 if (!target_running ())
4254 /* The packet we received doesn't make sense - but we can't
4255 reply to it, either. */
4258 fprintf (stderr
, "Killing all inferiors\n");
4259 for_each_inferior (&all_processes
, kill_inferior_callback
);
4261 /* When using the extended protocol, we wait with no program
4262 running. The traditional protocol will exit instead. */
4263 if (extended_protocol
)
4265 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4266 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4274 ptid_t gdb_id
, thread_id
;
4276 require_running (own_buf
);
4278 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4279 thread_id
= gdb_id_to_thread_id (gdb_id
);
4280 if (ptid_equal (thread_id
, null_ptid
))
4282 write_enn (own_buf
);
4286 if (mythread_alive (thread_id
))
4289 write_enn (own_buf
);
4293 response_needed
= 0;
4295 /* Restarting the inferior is only supported in the extended
4297 if (extended_protocol
)
4299 if (target_running ())
4300 for_each_inferior (&all_processes
,
4301 kill_inferior_callback
);
4302 fprintf (stderr
, "GDBserver restarting\n");
4304 /* Wait till we are at 1st instruction in prog. */
4305 if (program_name
!= NULL
)
4307 create_inferior (program_name
, program_args
);
4309 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4311 /* Stopped at the first instruction of the target
4313 general_thread
= last_ptid
;
4317 /* Something went wrong. */
4318 general_thread
= null_ptid
;
4323 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4324 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4330 /* It is a request we don't understand. Respond with an
4331 empty packet so that gdb knows that we don't support this
4337 /* Extended (long) request. */
4338 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4342 /* It is a request we don't understand. Respond with an empty
4343 packet so that gdb knows that we don't support this
4349 if (new_packet_len
!= -1)
4350 putpkt_binary (own_buf
, new_packet_len
);
4354 response_needed
= 0;
4362 /* Event-loop callback for serial events. */
4365 handle_serial_event (int err
, gdb_client_data client_data
)
4368 debug_printf ("handling possible serial event\n");
4370 /* Really handle it. */
4371 if (process_serial_event () < 0)
4374 /* Be sure to not change the selected thread behind GDB's back.
4375 Important in the non-stop mode asynchronous protocol. */
4376 set_desired_thread (1);
4381 /* Push a stop notification on the notification queue. */
4384 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4386 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4388 vstop_notif
->status
= *status
;
4389 vstop_notif
->ptid
= ptid
;
4390 /* Push Stop notification. */
4391 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4394 /* Event-loop callback for target events. */
4397 handle_target_event (int err
, gdb_client_data client_data
)
4400 debug_printf ("handling possible target event\n");
4402 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4405 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4407 if (gdb_connected () && report_no_resumed
)
4408 push_stop_notification (null_ptid
, &last_status
);
4410 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4412 int pid
= ptid_get_pid (last_ptid
);
4413 struct process_info
*process
= find_process_pid (pid
);
4414 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4416 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4417 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4419 mark_breakpoints_out (process
);
4420 target_mourn_inferior (last_ptid
);
4422 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4426 /* We're reporting this thread as stopped. Update its
4427 "want-stopped" state to what the client wants, until it
4428 gets a new resume action. */
4429 current_thread
->last_resume_kind
= resume_stop
;
4430 current_thread
->last_status
= last_status
;
4435 if (!target_running ())
4437 /* The last process exited. We're done. */
4441 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4442 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4443 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4447 /* A thread stopped with a signal, but gdb isn't
4448 connected to handle it. Pass it down to the
4449 inferior, as if it wasn't being traced. */
4450 enum gdb_signal signal
;
4453 debug_printf ("GDB not connected; forwarding event %d for"
4455 (int) last_status
.kind
,
4456 target_pid_to_str (last_ptid
));
4458 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4459 signal
= last_status
.value
.sig
;
4461 signal
= GDB_SIGNAL_0
;
4462 target_continue (last_ptid
, signal
);
4466 push_stop_notification (last_ptid
, &last_status
);
4469 /* Be sure to not change the selected thread behind GDB's back.
4470 Important in the non-stop mode asynchronous protocol. */
4471 set_desired_thread (1);