1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2015 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"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
44 multi-process), or a specific thread ptid_t. */
47 /* The thread set with an `Hg' packet. */
48 ptid_t general_thread
;
52 static int extended_protocol
;
53 static int response_needed
;
54 static int exit_requested
;
56 /* --once: Exit after the first connection has closed. */
64 /* Whether we should attempt to disable the operating system's address
65 space randomization feature before starting an inferior. */
66 int disable_randomization
= 1;
68 static char **program_argv
, **wrapper_argv
;
70 int pass_signals
[GDB_SIGNAL_LAST
];
71 int program_signals
[GDB_SIGNAL_LAST
];
72 int program_signals_p
;
74 /* The PID of the originally created or attached inferior. Used to
75 send signals to the process when GDB sends us an asynchronous interrupt
76 (user hitting Control-C in the client), and to wait for the child to exit
77 when no longer debugging it. */
79 unsigned long signal_pid
;
82 /* A file descriptor for the controlling terminal. */
85 /* TERMINAL_FD's original foreground group. */
86 pid_t old_foreground_pgrp
;
88 /* Hand back terminal ownership to the original foreground group. */
91 restore_old_foreground_pgrp (void)
93 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
97 /* Set if you want to disable optional thread related packets support
98 in gdbserver, for the sake of testing GDB against stubs that don't
100 int disable_packet_vCont
;
101 int disable_packet_Tthread
;
102 int disable_packet_qC
;
103 int disable_packet_qfThreadInfo
;
105 /* Last status reported to GDB. */
106 static struct target_waitstatus last_status
;
107 static ptid_t last_ptid
;
109 static char *own_buf
;
110 static unsigned char *mem_buf
;
112 /* A sub-class of 'struct notif_event' for stop, holding information
113 relative to a single stop reply. We keep a queue of these to
114 push to GDB in non-stop mode. */
118 struct notif_event base
;
120 /* Thread or process that got the event. */
124 struct target_waitstatus status
;
127 /* The current btrace configuration. This is gdbserver's mirror of GDB's
128 btrace configuration. */
129 static struct btrace_config current_btrace_conf
;
131 DEFINE_QUEUE_P (notif_event_p
);
133 /* Put a stop reply to the stop reply queue. */
136 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
138 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
140 new_notif
->ptid
= ptid
;
141 new_notif
->status
= *status
;
143 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
147 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
148 QUEUE_ITER (notif_event_p
) *iter
,
149 struct notif_event
*event
,
155 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
157 if (q
->free_func
!= NULL
)
158 q
->free_func (event
);
160 QUEUE_remove_elem (notif_event_p
, q
, iter
);
166 /* Get rid of the currently pending stop replies for PID. If PID is
167 -1, then apply to all processes. */
170 discard_queued_stop_replies (int pid
)
172 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
173 remove_all_on_match_pid
, &pid
);
177 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
179 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
181 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
184 struct notif_server notif_stop
=
186 "vStopped", "Stop", NULL
, vstop_notif_reply
,
190 target_running (void)
192 return get_first_thread () != NULL
;
196 start_inferior (char **argv
)
198 char **new_argv
= argv
;
200 if (wrapper_argv
!= NULL
)
204 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
206 for (i
= 0; argv
[i
] != NULL
; i
++)
208 new_argv
= alloca (sizeof (char *) * count
);
210 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
211 new_argv
[count
++] = wrapper_argv
[i
];
212 for (i
= 0; argv
[i
] != NULL
; i
++)
213 new_argv
[count
++] = argv
[i
];
214 new_argv
[count
] = NULL
;
220 for (i
= 0; new_argv
[i
]; ++i
)
221 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
226 signal (SIGTTOU
, SIG_DFL
);
227 signal (SIGTTIN
, SIG_DFL
);
230 signal_pid
= create_inferior (new_argv
[0], new_argv
);
232 /* FIXME: we don't actually know at this point that the create
233 actually succeeded. We won't know that until we wait. */
234 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
239 signal (SIGTTOU
, SIG_IGN
);
240 signal (SIGTTIN
, SIG_IGN
);
241 terminal_fd
= fileno (stderr
);
242 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
243 tcsetpgrp (terminal_fd
, signal_pid
);
244 atexit (restore_old_foreground_pgrp
);
247 if (wrapper_argv
!= NULL
)
249 struct thread_resume resume_info
;
251 memset (&resume_info
, 0, sizeof (resume_info
));
252 resume_info
.thread
= pid_to_ptid (signal_pid
);
253 resume_info
.kind
= resume_continue
;
256 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
258 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
263 (*the_target
->resume
) (&resume_info
, 1);
265 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
266 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
269 current_thread
->last_resume_kind
= resume_stop
;
270 current_thread
->last_status
= last_status
;
272 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
277 /* Wait till we are at 1st instruction in program, return new pid
278 (assuming success). */
279 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
281 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
282 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
284 current_thread
->last_resume_kind
= resume_stop
;
285 current_thread
->last_status
= last_status
;
292 attach_inferior (int pid
)
294 /* myattach should return -1 if attaching is unsupported,
295 0 if it succeeded, and call error() otherwise. */
297 if (myattach (pid
) != 0)
300 fprintf (stderr
, "Attached; pid = %d\n", pid
);
303 /* FIXME - It may be that we should get the SIGNAL_PID from the
304 attach function, so that it can be the main thread instead of
305 whichever we were told to attach to. */
310 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
312 /* GDB knows to ignore the first SIGSTOP after attaching to a running
313 process using the "attach" command, but this is different; it's
314 just using "target remote". Pretend it's just starting up. */
315 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
316 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
317 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
319 current_thread
->last_resume_kind
= resume_stop
;
320 current_thread
->last_status
= last_status
;
326 extern int remote_debug
;
328 /* Decode a qXfer read request. Return 0 if everything looks OK,
332 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
334 /* After the read marker and annex, qXfer looks like a
335 traditional 'm' packet. */
336 decode_m_packet (buf
, ofs
, len
);
342 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
344 /* Extract and NUL-terminate the object. */
346 while (*buf
&& *buf
!= ':')
352 /* Extract and NUL-terminate the read/write action. */
354 while (*buf
&& *buf
!= ':')
360 /* Extract and NUL-terminate the annex. */
362 while (*buf
&& *buf
!= ':')
372 /* Write the response to a successful qXfer read. Returns the
373 length of the (binary) data stored in BUF, corresponding
374 to as much of DATA/LEN as we could fit. IS_MORE controls
375 the first character of the response. */
377 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
386 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
390 /* Handle btrace enabling in BTS format. */
393 handle_btrace_enable_bts (struct thread_info
*thread
)
395 if (thread
->btrace
!= NULL
)
396 return "E.Btrace already enabled.";
398 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
399 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
400 ¤t_btrace_conf
);
401 if (thread
->btrace
== NULL
)
402 return "E.Could not enable btrace.";
407 /* Handle btrace disabling. */
410 handle_btrace_disable (struct thread_info
*thread
)
413 if (thread
->btrace
== NULL
)
414 return "E.Branch tracing not enabled.";
416 if (target_disable_btrace (thread
->btrace
) != 0)
417 return "E.Could not disable branch tracing.";
419 thread
->btrace
= NULL
;
423 /* Handle the "Qbtrace" packet. */
426 handle_btrace_general_set (char *own_buf
)
428 struct thread_info
*thread
;
432 if (!startswith (own_buf
, "Qbtrace:"))
435 op
= own_buf
+ strlen ("Qbtrace:");
437 if (ptid_equal (general_thread
, null_ptid
)
438 || ptid_equal (general_thread
, minus_one_ptid
))
440 strcpy (own_buf
, "E.Must select a single thread.");
444 thread
= find_thread_ptid (general_thread
);
447 strcpy (own_buf
, "E.No such thread.");
453 if (strcmp (op
, "bts") == 0)
454 err
= handle_btrace_enable_bts (thread
);
455 else if (strcmp (op
, "off") == 0)
456 err
= handle_btrace_disable (thread
);
458 err
= "E.Bad Qbtrace operation. Use bts or off.";
461 strcpy (own_buf
, err
);
468 /* Handle the "Qbtrace-conf" packet. */
471 handle_btrace_conf_general_set (char *own_buf
)
473 struct thread_info
*thread
;
476 if (!startswith (own_buf
, "Qbtrace-conf:"))
479 op
= own_buf
+ strlen ("Qbtrace-conf:");
481 if (ptid_equal (general_thread
, null_ptid
)
482 || ptid_equal (general_thread
, minus_one_ptid
))
484 strcpy (own_buf
, "E.Must select a single thread.");
488 thread
= find_thread_ptid (general_thread
);
491 strcpy (own_buf
, "E.No such thread.");
495 if (startswith (op
, "bts:size="))
501 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
502 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
504 strcpy (own_buf
, "E.Bad size value.");
508 current_btrace_conf
.bts
.size
= (unsigned int) size
;
512 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
520 /* Handle all of the extended 'Q' packets. */
523 handle_general_set (char *own_buf
)
525 if (startswith (own_buf
, "QPassSignals:"))
527 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
528 const char *p
= own_buf
+ strlen ("QPassSignals:");
531 p
= decode_address_to_semicolon (&cursig
, p
);
532 for (i
= 0; i
< numsigs
; i
++)
538 /* Keep looping, to clear the remaining signals. */
541 p
= decode_address_to_semicolon (&cursig
, p
);
546 strcpy (own_buf
, "OK");
550 if (startswith (own_buf
, "QProgramSignals:"))
552 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
553 const char *p
= own_buf
+ strlen ("QProgramSignals:");
556 program_signals_p
= 1;
558 p
= decode_address_to_semicolon (&cursig
, p
);
559 for (i
= 0; i
< numsigs
; i
++)
563 program_signals
[i
] = 1;
565 /* Keep looping, to clear the remaining signals. */
568 p
= decode_address_to_semicolon (&cursig
, p
);
571 program_signals
[i
] = 0;
573 strcpy (own_buf
, "OK");
577 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
581 fprintf (stderr
, "[noack mode enabled]\n");
590 if (startswith (own_buf
, "QNonStop:"))
592 char *mode
= own_buf
+ 9;
596 if (strcmp (mode
, "0") == 0)
598 else if (strcmp (mode
, "1") == 0)
602 /* We don't know what this mode is, so complain to
604 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
610 req_str
= req
? "non-stop" : "all-stop";
611 if (start_non_stop (req
) != 0)
613 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
621 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
627 if (startswith (own_buf
, "QDisableRandomization:"))
629 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
632 unpack_varlen_hex (packet
, &setting
);
633 disable_randomization
= setting
;
637 if (disable_randomization
)
638 fprintf (stderr
, "[address space randomization disabled]\n");
640 fprintf (stderr
, "[address space randomization enabled]\n");
647 if (target_supports_tracepoints ()
648 && handle_tracepoint_general_set (own_buf
))
651 if (startswith (own_buf
, "QAgent:"))
653 char *mode
= own_buf
+ strlen ("QAgent:");
656 if (strcmp (mode
, "0") == 0)
658 else if (strcmp (mode
, "1") == 0)
662 /* We don't know what this value is, so complain to GDB. */
663 sprintf (own_buf
, "E.Unknown QAgent value");
667 /* Update the flag. */
670 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
675 if (handle_btrace_general_set (own_buf
))
678 if (handle_btrace_conf_general_set (own_buf
))
681 /* Otherwise we didn't know what packet it was. Say we didn't
687 get_features_xml (const char *annex
)
689 const struct target_desc
*desc
= current_target_desc ();
691 /* `desc->xmltarget' defines what to return when looking for the
692 "target.xml" file. Its contents can either be verbatim XML code
693 (prefixed with a '@') or else the name of the actual XML file to
694 be used in place of "target.xml".
696 This variable is set up from the auto-generated
697 init_registers_... routine for the current target. */
699 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
701 if (*desc
->xmltarget
== '@')
702 return desc
->xmltarget
+ 1;
704 annex
= desc
->xmltarget
;
709 extern const char *const xml_builtin
[][2];
712 /* Look for the annex. */
713 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
714 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
717 if (xml_builtin
[i
][0] != NULL
)
718 return xml_builtin
[i
][1];
726 monitor_show_help (void)
728 monitor_output ("The following monitor commands are supported:\n");
729 monitor_output (" set debug <0|1>\n");
730 monitor_output (" Enable general debugging messages\n");
731 monitor_output (" set debug-hw-points <0|1>\n");
732 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
733 monitor_output (" set remote-debug <0|1>\n");
734 monitor_output (" Enable remote protocol debugging messages\n");
735 monitor_output (" set debug-format option1[,option2,...]\n");
736 monitor_output (" Add additional information to debugging messages\n");
737 monitor_output (" Options: all, none");
738 monitor_output (", timestamp");
739 monitor_output ("\n");
740 monitor_output (" exit\n");
741 monitor_output (" Quit GDBserver\n");
744 /* Read trace frame or inferior memory. Returns the number of bytes
745 actually read, zero when no further transfer is possible, and -1 on
746 error. Return of a positive value smaller than LEN does not
747 indicate there's no more to be read, only the end of the transfer.
748 E.g., when GDB reads memory from a traceframe, a first request may
749 be served from a memory block that does not cover the whole request
750 length. A following request gets the rest served from either
751 another block (of the same traceframe) or from the read-only
755 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
759 if (current_traceframe
>= 0)
762 ULONGEST length
= len
;
764 if (traceframe_read_mem (current_traceframe
,
765 memaddr
, myaddr
, len
, &nbytes
))
767 /* Data read from trace buffer, we're done. */
770 if (!in_readonly_region (memaddr
, length
))
772 /* Otherwise we have a valid readonly case, fall through. */
773 /* (assume no half-trace half-real blocks for now) */
776 res
= prepare_to_access_memory ();
779 res
= read_inferior_memory (memaddr
, myaddr
, len
);
780 done_accessing_memory ();
782 return res
== 0 ? len
: -1;
788 /* Write trace frame or inferior memory. Actually, writing to trace
789 frames is forbidden. */
792 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
794 if (current_traceframe
>= 0)
800 ret
= prepare_to_access_memory ();
803 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
804 done_accessing_memory ();
810 /* Subroutine of handle_search_memory to simplify it. */
813 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
814 gdb_byte
*pattern
, unsigned pattern_len
,
815 gdb_byte
*search_buf
,
816 unsigned chunk_size
, unsigned search_buf_size
,
817 CORE_ADDR
*found_addrp
)
819 /* Prime the search buffer. */
821 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
824 warning ("Unable to access %ld bytes of target "
825 "memory at 0x%lx, halting search.",
826 (long) search_buf_size
, (long) start_addr
);
830 /* Perform the search.
832 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
833 When we've scanned N bytes we copy the trailing bytes to the start and
834 read in another N bytes. */
836 while (search_space_len
>= pattern_len
)
839 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
843 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
845 if (found_ptr
!= NULL
)
847 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
848 *found_addrp
= found_addr
;
852 /* Not found in this chunk, skip to next chunk. */
854 /* Don't let search_space_len wrap here, it's unsigned. */
855 if (search_space_len
>= chunk_size
)
856 search_space_len
-= chunk_size
;
858 search_space_len
= 0;
860 if (search_space_len
>= pattern_len
)
862 unsigned keep_len
= search_buf_size
- chunk_size
;
863 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
866 /* Copy the trailing part of the previous iteration to the front
867 of the buffer for the next iteration. */
868 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
870 nr_to_read
= (search_space_len
- keep_len
< chunk_size
871 ? search_space_len
- keep_len
874 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
875 nr_to_read
) != search_buf_size
)
877 warning ("Unable to access %ld bytes of target memory "
878 "at 0x%lx, halting search.",
879 (long) nr_to_read
, (long) read_addr
);
883 start_addr
+= chunk_size
;
892 /* Handle qSearch:memory packets. */
895 handle_search_memory (char *own_buf
, int packet_len
)
897 CORE_ADDR start_addr
;
898 CORE_ADDR search_space_len
;
900 unsigned int pattern_len
;
901 /* NOTE: also defined in find.c testcase. */
902 #define SEARCH_CHUNK_SIZE 16000
903 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
904 /* Buffer to hold memory contents for searching. */
905 gdb_byte
*search_buf
;
906 unsigned search_buf_size
;
908 CORE_ADDR found_addr
;
909 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
911 pattern
= malloc (packet_len
);
914 error ("Unable to allocate memory to perform the search");
915 strcpy (own_buf
, "E00");
918 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
919 packet_len
- cmd_name_len
,
920 &start_addr
, &search_space_len
,
921 pattern
, &pattern_len
) < 0)
924 error ("Error in parsing qSearch:memory packet");
925 strcpy (own_buf
, "E00");
929 search_buf_size
= chunk_size
+ pattern_len
- 1;
931 /* No point in trying to allocate a buffer larger than the search space. */
932 if (search_space_len
< search_buf_size
)
933 search_buf_size
= search_space_len
;
935 search_buf
= malloc (search_buf_size
);
936 if (search_buf
== NULL
)
939 error ("Unable to allocate memory to perform the search");
940 strcpy (own_buf
, "E00");
944 found
= handle_search_memory_1 (start_addr
, search_space_len
,
945 pattern
, pattern_len
,
946 search_buf
, chunk_size
, search_buf_size
,
950 sprintf (own_buf
, "1,%lx", (long) found_addr
);
952 strcpy (own_buf
, "0");
954 strcpy (own_buf
, "E00");
960 #define require_running(BUF) \
961 if (!target_running ()) \
967 /* Parse options to --debug-format= and "monitor set debug-format".
968 ARG is the text after "--debug-format=" or "monitor set debug-format".
969 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
970 This triggers calls to monitor_output.
971 The result is NULL if all options were parsed ok, otherwise an error
972 message which the caller must free.
974 N.B. These commands affect all debug format settings, they are not
975 cumulative. If a format is not specified, it is turned off.
976 However, we don't go to extra trouble with things like
977 "monitor set debug-format all,none,timestamp".
978 Instead we just parse them one at a time, in order.
980 The syntax for "monitor set debug" we support here is not identical
981 to gdb's "set debug foo on|off" because we also use this function to
982 parse "--debug-format=foo,bar". */
985 parse_debug_format_options (const char *arg
, int is_monitor
)
987 VEC (char_ptr
) *options
;
991 /* First turn all debug format options off. */
994 /* First remove leading spaces, for "monitor set debug-format". */
995 while (isspace (*arg
))
998 options
= delim_string_to_char_ptr_vec (arg
, ',');
1000 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1002 if (strcmp (option
, "all") == 0)
1004 debug_timestamp
= 1;
1006 monitor_output ("All extra debug format options enabled.\n");
1008 else if (strcmp (option
, "none") == 0)
1010 debug_timestamp
= 0;
1012 monitor_output ("All extra debug format options disabled.\n");
1014 else if (strcmp (option
, "timestamp") == 0)
1016 debug_timestamp
= 1;
1018 monitor_output ("Timestamps will be added to debug output.\n");
1020 else if (*option
== '\0')
1022 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1027 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1030 free_char_ptr_vec (options
);
1035 free_char_ptr_vec (options
);
1039 /* Handle monitor commands not handled by target-specific handlers. */
1042 handle_monitor_command (char *mon
, char *own_buf
)
1044 if (strcmp (mon
, "set debug 1") == 0)
1047 monitor_output ("Debug output enabled.\n");
1049 else if (strcmp (mon
, "set debug 0") == 0)
1052 monitor_output ("Debug output disabled.\n");
1054 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1056 show_debug_regs
= 1;
1057 monitor_output ("H/W point debugging output enabled.\n");
1059 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1061 show_debug_regs
= 0;
1062 monitor_output ("H/W point debugging output disabled.\n");
1064 else if (strcmp (mon
, "set remote-debug 1") == 0)
1067 monitor_output ("Protocol debug output enabled.\n");
1069 else if (strcmp (mon
, "set remote-debug 0") == 0)
1072 monitor_output ("Protocol debug output disabled.\n");
1074 else if (startswith (mon
, "set debug-format "))
1077 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1080 if (error_msg
!= NULL
)
1082 monitor_output (error_msg
);
1083 monitor_show_help ();
1084 write_enn (own_buf
);
1088 else if (strcmp (mon
, "help") == 0)
1089 monitor_show_help ();
1090 else if (strcmp (mon
, "exit") == 0)
1094 monitor_output ("Unknown monitor command.\n\n");
1095 monitor_show_help ();
1096 write_enn (own_buf
);
1100 /* Associates a callback with each supported qXfer'able object. */
1104 /* The object this handler handles. */
1107 /* Request that the target transfer up to LEN 8-bit bytes of the
1108 target's OBJECT. The OFFSET, for a seekable object, specifies
1109 the starting point. The ANNEX can be used to provide additional
1110 data-specific information to the target.
1112 Return the number of bytes actually transfered, zero when no
1113 further transfer is possible, -1 on error, -2 when the transfer
1114 is not supported, and -3 on a verbose error message that should
1115 be preserved. Return of a positive value smaller than LEN does
1116 not indicate the end of the object, only the end of the transfer.
1118 One, and only one, of readbuf or writebuf must be non-NULL. */
1119 int (*xfer
) (const char *annex
,
1120 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1121 ULONGEST offset
, LONGEST len
);
1124 /* Handle qXfer:auxv:read. */
1127 handle_qxfer_auxv (const char *annex
,
1128 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1129 ULONGEST offset
, LONGEST len
)
1131 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1134 if (annex
[0] != '\0' || !target_running ())
1137 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1140 /* Handle qXfer:features:read. */
1143 handle_qxfer_features (const char *annex
,
1144 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1145 ULONGEST offset
, LONGEST len
)
1147 const char *document
;
1150 if (writebuf
!= NULL
)
1153 if (!target_running ())
1156 /* Grab the correct annex. */
1157 document
= get_features_xml (annex
);
1158 if (document
== NULL
)
1161 total_len
= strlen (document
);
1163 if (offset
> total_len
)
1166 if (offset
+ len
> total_len
)
1167 len
= total_len
- offset
;
1169 memcpy (readbuf
, document
+ offset
, len
);
1173 /* Worker routine for handle_qxfer_libraries.
1174 Add to the length pointed to by ARG a conservative estimate of the
1175 length needed to transmit the file name of INF. */
1178 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1180 struct dll_info
*dll
= (struct dll_info
*) inf
;
1181 unsigned int *total_len
= arg
;
1183 /* Over-estimate the necessary memory. Assume that every character
1184 in the library name must be escaped. */
1185 *total_len
+= 128 + 6 * strlen (dll
->name
);
1188 /* Worker routine for handle_qxfer_libraries.
1189 Emit the XML to describe the library in INF. */
1192 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1194 struct dll_info
*dll
= (struct dll_info
*) inf
;
1199 strcpy (p
, " <library name=\"");
1201 name
= xml_escape_text (dll
->name
);
1205 strcpy (p
, "\"><segment address=\"");
1207 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1209 strcpy (p
, "\"/></library>\n");
1215 /* Handle qXfer:libraries:read. */
1218 handle_qxfer_libraries (const char *annex
,
1219 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1220 ULONGEST offset
, LONGEST len
)
1222 unsigned int total_len
;
1225 if (writebuf
!= NULL
)
1228 if (annex
[0] != '\0' || !target_running ())
1232 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1235 document
= malloc (total_len
);
1236 if (document
== NULL
)
1239 strcpy (document
, "<library-list>\n");
1240 p
= document
+ strlen (document
);
1242 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1244 strcpy (p
, "</library-list>\n");
1246 total_len
= strlen (document
);
1248 if (offset
> total_len
)
1254 if (offset
+ len
> total_len
)
1255 len
= total_len
- offset
;
1257 memcpy (readbuf
, document
+ offset
, len
);
1262 /* Handle qXfer:libraries-svr4:read. */
1265 handle_qxfer_libraries_svr4 (const char *annex
,
1266 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1267 ULONGEST offset
, LONGEST len
)
1269 if (writebuf
!= NULL
)
1272 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1275 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1278 /* Handle qXfer:osadata:read. */
1281 handle_qxfer_osdata (const char *annex
,
1282 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1283 ULONGEST offset
, LONGEST len
)
1285 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1288 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1291 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1294 handle_qxfer_siginfo (const char *annex
,
1295 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1296 ULONGEST offset
, LONGEST len
)
1298 if (the_target
->qxfer_siginfo
== NULL
)
1301 if (annex
[0] != '\0' || !target_running ())
1304 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1307 /* Handle qXfer:spu:read and qXfer:spu:write. */
1310 handle_qxfer_spu (const char *annex
,
1311 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1312 ULONGEST offset
, LONGEST len
)
1314 if (the_target
->qxfer_spu
== NULL
)
1317 if (!target_running ())
1320 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1323 /* Handle qXfer:statictrace:read. */
1326 handle_qxfer_statictrace (const char *annex
,
1327 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1328 ULONGEST offset
, LONGEST len
)
1332 if (writebuf
!= NULL
)
1335 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1338 if (traceframe_read_sdata (current_traceframe
, offset
,
1339 readbuf
, len
, &nbytes
))
1344 /* Helper for handle_qxfer_threads_proper.
1345 Emit the XML to describe the thread of INF. */
1348 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1350 struct thread_info
*thread
= (struct thread_info
*) inf
;
1351 struct buffer
*buffer
= arg
;
1352 ptid_t ptid
= thread_to_gdb_id (thread
);
1354 int core
= target_core_of_thread (ptid
);
1357 write_ptid (ptid_s
, ptid
);
1361 sprintf (core_s
, "%d", core
);
1362 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1367 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1372 /* Helper for handle_qxfer_threads. */
1375 handle_qxfer_threads_proper (struct buffer
*buffer
)
1377 buffer_grow_str (buffer
, "<threads>\n");
1379 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1382 buffer_grow_str0 (buffer
, "</threads>\n");
1385 /* Handle qXfer:threads:read. */
1388 handle_qxfer_threads (const char *annex
,
1389 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1390 ULONGEST offset
, LONGEST len
)
1392 static char *result
= 0;
1393 static unsigned int result_length
= 0;
1395 if (writebuf
!= NULL
)
1398 if (!target_running () || annex
[0] != '\0')
1403 struct buffer buffer
;
1404 /* When asked for data at offset 0, generate everything and store into
1405 'result'. Successive reads will be served off 'result'. */
1409 buffer_init (&buffer
);
1411 handle_qxfer_threads_proper (&buffer
);
1413 result
= buffer_finish (&buffer
);
1414 result_length
= strlen (result
);
1415 buffer_free (&buffer
);
1418 if (offset
>= result_length
)
1420 /* We're out of data. */
1427 if (len
> result_length
- offset
)
1428 len
= result_length
- offset
;
1430 memcpy (readbuf
, result
+ offset
, len
);
1435 /* Handle qXfer:traceframe-info:read. */
1438 handle_qxfer_traceframe_info (const char *annex
,
1439 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1440 ULONGEST offset
, LONGEST len
)
1442 static char *result
= 0;
1443 static unsigned int result_length
= 0;
1445 if (writebuf
!= NULL
)
1448 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1453 struct buffer buffer
;
1455 /* When asked for data at offset 0, generate everything and
1456 store into 'result'. Successive reads will be served off
1460 buffer_init (&buffer
);
1462 traceframe_read_info (current_traceframe
, &buffer
);
1464 result
= buffer_finish (&buffer
);
1465 result_length
= strlen (result
);
1466 buffer_free (&buffer
);
1469 if (offset
>= result_length
)
1471 /* We're out of data. */
1478 if (len
> result_length
- offset
)
1479 len
= result_length
- offset
;
1481 memcpy (readbuf
, result
+ offset
, len
);
1485 /* Handle qXfer:fdpic:read. */
1488 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1489 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1491 if (the_target
->read_loadmap
== NULL
)
1494 if (!target_running ())
1497 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1500 /* Handle qXfer:btrace:read. */
1503 handle_qxfer_btrace (const char *annex
,
1504 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1505 ULONGEST offset
, LONGEST len
)
1507 static struct buffer cache
;
1508 struct thread_info
*thread
;
1511 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1514 if (!target_running ())
1517 if (ptid_equal (general_thread
, null_ptid
)
1518 || ptid_equal (general_thread
, minus_one_ptid
))
1520 strcpy (own_buf
, "E.Must select a single thread.");
1524 thread
= find_thread_ptid (general_thread
);
1527 strcpy (own_buf
, "E.No such thread.");
1531 if (thread
->btrace
== NULL
)
1533 strcpy (own_buf
, "E.Btrace not enabled.");
1537 if (strcmp (annex
, "all") == 0)
1538 type
= BTRACE_READ_ALL
;
1539 else if (strcmp (annex
, "new") == 0)
1540 type
= BTRACE_READ_NEW
;
1541 else if (strcmp (annex
, "delta") == 0)
1542 type
= BTRACE_READ_DELTA
;
1545 strcpy (own_buf
, "E.Bad annex.");
1551 buffer_free (&cache
);
1553 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1556 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1560 else if (offset
> cache
.used_size
)
1562 buffer_free (&cache
);
1566 if (len
> cache
.used_size
- offset
)
1567 len
= cache
.used_size
- offset
;
1569 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1574 /* Handle qXfer:btrace-conf:read. */
1577 handle_qxfer_btrace_conf (const char *annex
,
1578 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1579 ULONGEST offset
, LONGEST len
)
1581 static struct buffer cache
;
1582 struct thread_info
*thread
;
1585 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1588 if (annex
[0] != '\0' || !target_running ())
1591 if (ptid_equal (general_thread
, null_ptid
)
1592 || ptid_equal (general_thread
, minus_one_ptid
))
1594 strcpy (own_buf
, "E.Must select a single thread.");
1598 thread
= find_thread_ptid (general_thread
);
1601 strcpy (own_buf
, "E.No such thread.");
1605 if (thread
->btrace
== NULL
)
1607 strcpy (own_buf
, "E.Btrace not enabled.");
1613 buffer_free (&cache
);
1615 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1618 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1622 else if (offset
> cache
.used_size
)
1624 buffer_free (&cache
);
1628 if (len
> cache
.used_size
- offset
)
1629 len
= cache
.used_size
- offset
;
1631 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1636 static const struct qxfer qxfer_packets
[] =
1638 { "auxv", handle_qxfer_auxv
},
1639 { "btrace", handle_qxfer_btrace
},
1640 { "btrace-conf", handle_qxfer_btrace_conf
},
1641 { "fdpic", handle_qxfer_fdpic
},
1642 { "features", handle_qxfer_features
},
1643 { "libraries", handle_qxfer_libraries
},
1644 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1645 { "osdata", handle_qxfer_osdata
},
1646 { "siginfo", handle_qxfer_siginfo
},
1647 { "spu", handle_qxfer_spu
},
1648 { "statictrace", handle_qxfer_statictrace
},
1649 { "threads", handle_qxfer_threads
},
1650 { "traceframe-info", handle_qxfer_traceframe_info
},
1654 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1662 if (!startswith (own_buf
, "qXfer:"))
1665 /* Grab the object, r/w and annex. */
1666 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1668 write_enn (own_buf
);
1673 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1676 const struct qxfer
*q
= &qxfer_packets
[i
];
1678 if (strcmp (object
, q
->object
) == 0)
1680 if (strcmp (rw
, "read") == 0)
1682 unsigned char *data
;
1687 /* Grab the offset and length. */
1688 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1690 write_enn (own_buf
);
1694 /* Read one extra byte, as an indicator of whether there is
1696 if (len
> PBUFSIZ
- 2)
1698 data
= malloc (len
+ 1);
1701 write_enn (own_buf
);
1704 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1712 /* Preserve error message. */
1715 write_enn (own_buf
);
1717 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1719 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1724 else if (strcmp (rw
, "write") == 0)
1729 unsigned char *data
;
1731 strcpy (own_buf
, "E00");
1732 data
= malloc (packet_len
- (offset
- own_buf
));
1735 write_enn (own_buf
);
1738 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1739 &ofs
, &len
, data
) < 0)
1742 write_enn (own_buf
);
1746 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1754 /* Preserve error message. */
1757 write_enn (own_buf
);
1759 sprintf (own_buf
, "%x", n
);
1772 /* Table used by the crc32 function to calcuate the checksum. */
1774 static unsigned int crc32_table
[256] =
1777 /* Compute 32 bit CRC from inferior memory.
1779 On success, return 32 bit CRC.
1780 On failure, return (unsigned long long) -1. */
1782 static unsigned long long
1783 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1785 if (!crc32_table
[1])
1787 /* Initialize the CRC table and the decoding table. */
1791 for (i
= 0; i
< 256; i
++)
1793 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1794 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1801 unsigned char byte
= 0;
1803 /* Return failure if memory read fails. */
1804 if (read_inferior_memory (base
, &byte
, 1) != 0)
1805 return (unsigned long long) -1;
1807 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1810 return (unsigned long long) crc
;
1813 /* Add supported btrace packets to BUF. */
1816 supported_btrace_packets (char *buf
)
1818 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1820 strcat (buf
, ";Qbtrace:bts+");
1821 strcat (buf
, ";Qbtrace-conf:bts:size+");
1826 strcat (buf
, ";Qbtrace:off+");
1827 strcat (buf
, ";qXfer:btrace:read+");
1828 strcat (buf
, ";qXfer:btrace-conf:read+");
1831 /* Handle all of the extended 'q' packets. */
1834 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1836 static struct inferior_list_entry
*thread_ptr
;
1838 /* Reply the current thread id. */
1839 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1842 require_running (own_buf
);
1844 if (!ptid_equal (general_thread
, null_ptid
)
1845 && !ptid_equal (general_thread
, minus_one_ptid
))
1846 gdb_id
= general_thread
;
1849 thread_ptr
= get_first_inferior (&all_threads
);
1850 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1853 sprintf (own_buf
, "QC");
1855 write_ptid (own_buf
, gdb_id
);
1859 if (strcmp ("qSymbol::", own_buf
) == 0)
1861 /* GDB is suggesting new symbols have been loaded. This may
1862 mean a new shared library has been detected as loaded, so
1863 take the opportunity to check if breakpoints we think are
1864 inserted, still are. Note that it isn't guaranteed that
1865 we'll see this when a shared library is loaded, and nor will
1866 we see this for unloads (although breakpoints in unloaded
1867 libraries shouldn't trigger), as GDB may not find symbols for
1868 the library at all. We also re-validate breakpoints when we
1869 see a second GDB breakpoint for the same address, and or when
1870 we access breakpoint shadows. */
1871 validate_breakpoints ();
1873 if (target_supports_tracepoints ())
1874 tracepoint_look_up_symbols ();
1876 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1877 (*the_target
->look_up_symbols
) ();
1879 strcpy (own_buf
, "OK");
1883 if (!disable_packet_qfThreadInfo
)
1885 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1889 require_running (own_buf
);
1890 thread_ptr
= get_first_inferior (&all_threads
);
1893 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1894 write_ptid (own_buf
, gdb_id
);
1895 thread_ptr
= thread_ptr
->next
;
1899 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1903 require_running (own_buf
);
1904 if (thread_ptr
!= NULL
)
1907 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1908 write_ptid (own_buf
, gdb_id
);
1909 thread_ptr
= thread_ptr
->next
;
1914 sprintf (own_buf
, "l");
1920 if (the_target
->read_offsets
!= NULL
1921 && strcmp ("qOffsets", own_buf
) == 0)
1923 CORE_ADDR text
, data
;
1925 require_running (own_buf
);
1926 if (the_target
->read_offsets (&text
, &data
))
1927 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1928 (long)text
, (long)data
, (long)data
);
1930 write_enn (own_buf
);
1935 /* Protocol features query. */
1936 if (startswith (own_buf
, "qSupported")
1937 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1939 char *p
= &own_buf
[10];
1940 int gdb_supports_qRelocInsn
= 0;
1942 /* Start processing qSupported packet. */
1943 target_process_qsupported (NULL
);
1945 /* Process each feature being provided by GDB. The first
1946 feature will follow a ':', and latter features will follow
1950 char **qsupported
= NULL
;
1954 /* Two passes, to avoid nested strtok calls in
1955 target_process_qsupported. */
1956 for (p
= strtok (p
+ 1, ";");
1958 p
= strtok (NULL
, ";"))
1961 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1962 qsupported
[count
- 1] = xstrdup (p
);
1965 for (i
= 0; i
< count
; i
++)
1968 if (strcmp (p
, "multiprocess+") == 0)
1970 /* GDB supports and wants multi-process support if
1972 if (target_supports_multi_process ())
1975 else if (strcmp (p
, "qRelocInsn+") == 0)
1977 /* GDB supports relocate instruction requests. */
1978 gdb_supports_qRelocInsn
= 1;
1980 else if (strcmp (p
, "swbreak+") == 0)
1982 /* GDB wants us to report whether a trap is caused
1983 by a software breakpoint and for us to handle PC
1984 adjustment if necessary on this target. */
1985 if (target_supports_stopped_by_sw_breakpoint ())
1986 swbreak_feature
= 1;
1988 else if (strcmp (p
, "hwbreak+") == 0)
1990 /* GDB wants us to report whether a trap is caused
1991 by a hardware breakpoint. */
1992 if (target_supports_stopped_by_hw_breakpoint ())
1993 hwbreak_feature
= 1;
1996 target_process_qsupported (p
);
2005 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2008 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2009 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2010 ";augmented-libraries-svr4-read+");
2013 /* We do not have any hook to indicate whether the non-SVR4 target
2014 backend supports qXfer:libraries:read, so always report it. */
2015 strcat (own_buf
, ";qXfer:libraries:read+");
2018 if (the_target
->read_auxv
!= NULL
)
2019 strcat (own_buf
, ";qXfer:auxv:read+");
2021 if (the_target
->qxfer_spu
!= NULL
)
2022 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2024 if (the_target
->qxfer_siginfo
!= NULL
)
2025 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2027 if (the_target
->read_loadmap
!= NULL
)
2028 strcat (own_buf
, ";qXfer:fdpic:read+");
2030 /* We always report qXfer:features:read, as targets may
2031 install XML files on a subsequent call to arch_setup.
2032 If we reported to GDB on startup that we don't support
2033 qXfer:feature:read at all, we will never be re-queried. */
2034 strcat (own_buf
, ";qXfer:features:read+");
2036 if (transport_is_reliable
)
2037 strcat (own_buf
, ";QStartNoAckMode+");
2039 if (the_target
->qxfer_osdata
!= NULL
)
2040 strcat (own_buf
, ";qXfer:osdata:read+");
2042 if (target_supports_multi_process ())
2043 strcat (own_buf
, ";multiprocess+");
2045 if (target_supports_non_stop ())
2046 strcat (own_buf
, ";QNonStop+");
2048 if (target_supports_disable_randomization ())
2049 strcat (own_buf
, ";QDisableRandomization+");
2051 strcat (own_buf
, ";qXfer:threads:read+");
2053 if (target_supports_tracepoints ())
2055 strcat (own_buf
, ";ConditionalTracepoints+");
2056 strcat (own_buf
, ";TraceStateVariables+");
2057 strcat (own_buf
, ";TracepointSource+");
2058 strcat (own_buf
, ";DisconnectedTracing+");
2059 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2060 strcat (own_buf
, ";FastTracepoints+");
2061 strcat (own_buf
, ";StaticTracepoints+");
2062 strcat (own_buf
, ";InstallInTrace+");
2063 strcat (own_buf
, ";qXfer:statictrace:read+");
2064 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2065 strcat (own_buf
, ";EnableDisableTracepoints+");
2066 strcat (own_buf
, ";QTBuffer:size+");
2067 strcat (own_buf
, ";tracenz+");
2070 /* Support target-side breakpoint conditions and commands. */
2071 strcat (own_buf
, ";ConditionalBreakpoints+");
2072 strcat (own_buf
, ";BreakpointCommands+");
2074 if (target_supports_agent ())
2075 strcat (own_buf
, ";QAgent+");
2077 supported_btrace_packets (own_buf
);
2079 if (target_supports_stopped_by_sw_breakpoint ())
2080 strcat (own_buf
, ";swbreak+");
2082 if (target_supports_stopped_by_hw_breakpoint ())
2083 strcat (own_buf
, ";hwbreak+");
2088 /* Thread-local storage support. */
2089 if (the_target
->get_tls_address
!= NULL
2090 && startswith (own_buf
, "qGetTLSAddr:"))
2092 char *p
= own_buf
+ 12;
2093 CORE_ADDR parts
[2], address
= 0;
2095 ptid_t ptid
= null_ptid
;
2097 require_running (own_buf
);
2099 for (i
= 0; i
< 3; i
++)
2107 p2
= strchr (p
, ',');
2120 ptid
= read_ptid (p
, NULL
);
2122 decode_address (&parts
[i
- 1], p
, len
);
2126 if (p
!= NULL
|| i
< 3)
2130 struct thread_info
*thread
= find_thread_ptid (ptid
);
2135 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2141 strcpy (own_buf
, paddress(address
));
2146 write_enn (own_buf
);
2150 /* Otherwise, pretend we do not understand this packet. */
2153 /* Windows OS Thread Information Block address support. */
2154 if (the_target
->get_tib_address
!= NULL
2155 && startswith (own_buf
, "qGetTIBAddr:"))
2160 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2162 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2165 strcpy (own_buf
, paddress(tlb
));
2170 write_enn (own_buf
);
2176 /* Handle "monitor" commands. */
2177 if (startswith (own_buf
, "qRcmd,"))
2179 char *mon
= malloc (PBUFSIZ
);
2180 int len
= strlen (own_buf
+ 6);
2184 write_enn (own_buf
);
2189 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2191 write_enn (own_buf
);
2195 mon
[len
/ 2] = '\0';
2199 if (the_target
->handle_monitor_command
== NULL
2200 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2201 /* Default processing. */
2202 handle_monitor_command (mon
, own_buf
);
2208 if (startswith (own_buf
, "qSearch:memory:"))
2210 require_running (own_buf
);
2211 handle_search_memory (own_buf
, packet_len
);
2215 if (strcmp (own_buf
, "qAttached") == 0
2216 || startswith (own_buf
, "qAttached:"))
2218 struct process_info
*process
;
2220 if (own_buf
[sizeof ("qAttached") - 1])
2222 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2223 process
= (struct process_info
*)
2224 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2228 require_running (own_buf
);
2229 process
= current_process ();
2232 if (process
== NULL
)
2234 write_enn (own_buf
);
2238 strcpy (own_buf
, process
->attached
? "1" : "0");
2242 if (startswith (own_buf
, "qCRC:"))
2244 /* CRC check (compare-section). */
2248 unsigned long long crc
;
2250 require_running (own_buf
);
2251 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2252 if (*comma
++ != ',')
2254 write_enn (own_buf
);
2257 len
= strtoul (comma
, NULL
, 16);
2258 crc
= crc32 (base
, len
, 0xffffffff);
2259 /* Check for memory failure. */
2260 if (crc
== (unsigned long long) -1)
2262 write_enn (own_buf
);
2265 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2269 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2272 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2275 /* Otherwise we didn't know what packet it was. Say we didn't
2280 static void gdb_wants_all_threads_stopped (void);
2281 static void resume (struct thread_resume
*actions
, size_t n
);
2283 /* The callback that is passed to visit_actioned_threads. */
2284 typedef int (visit_actioned_threads_callback_ftype
)
2285 (const struct thread_resume
*, struct thread_info
*);
2287 /* Struct to pass data to visit_actioned_threads. */
2289 struct visit_actioned_threads_data
2291 const struct thread_resume
*actions
;
2293 visit_actioned_threads_callback_ftype
*callback
;
2296 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2297 true if CALLBACK returns true. Returns false if no matching thread
2298 is found or CALLBACK results false.
2299 Note: This function is itself a callback for find_inferior. */
2302 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2304 struct visit_actioned_threads_data
*data
= datap
;
2305 const struct thread_resume
*actions
= data
->actions
;
2306 size_t num_actions
= data
->num_actions
;
2307 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2310 for (i
= 0; i
< num_actions
; i
++)
2312 const struct thread_resume
*action
= &actions
[i
];
2314 if (ptid_equal (action
->thread
, minus_one_ptid
)
2315 || ptid_equal (action
->thread
, entry
->id
)
2316 || ((ptid_get_pid (action
->thread
)
2317 == ptid_get_pid (entry
->id
))
2318 && ptid_get_lwp (action
->thread
) == -1))
2320 struct thread_info
*thread
= (struct thread_info
*) entry
;
2322 if ((*callback
) (action
, thread
))
2330 /* Callback for visit_actioned_threads. If the thread has a pending
2331 status to report, report it now. */
2334 handle_pending_status (const struct thread_resume
*resumption
,
2335 struct thread_info
*thread
)
2337 if (thread
->status_pending_p
)
2339 thread
->status_pending_p
= 0;
2341 last_status
= thread
->last_status
;
2342 last_ptid
= thread
->entry
.id
;
2343 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2349 /* Parse vCont packets. */
2351 handle_v_cont (char *own_buf
)
2355 struct thread_resume
*resume_info
;
2356 struct thread_resume default_action
= {{0}};
2358 /* Count the number of semicolons in the packet. There should be one
2359 for every action. */
2365 p
= strchr (p
, ';');
2368 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2369 if (resume_info
== NULL
)
2377 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2379 if (p
[0] == 's' || p
[0] == 'S')
2380 resume_info
[i
].kind
= resume_step
;
2381 else if (p
[0] == 'r')
2382 resume_info
[i
].kind
= resume_step
;
2383 else if (p
[0] == 'c' || p
[0] == 'C')
2384 resume_info
[i
].kind
= resume_continue
;
2385 else if (p
[0] == 't')
2386 resume_info
[i
].kind
= resume_stop
;
2390 if (p
[0] == 'S' || p
[0] == 'C')
2393 sig
= strtol (p
+ 1, &q
, 16);
2398 if (!gdb_signal_to_host_p (sig
))
2400 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2402 else if (p
[0] == 'r')
2406 p
= unpack_varlen_hex (p
+ 1, &addr
);
2407 resume_info
[i
].step_range_start
= addr
;
2412 p
= unpack_varlen_hex (p
+ 1, &addr
);
2413 resume_info
[i
].step_range_end
= addr
;
2422 resume_info
[i
].thread
= minus_one_ptid
;
2423 default_action
= resume_info
[i
];
2425 /* Note: we don't increment i here, we'll overwrite this entry
2426 the next time through. */
2428 else if (p
[0] == ':')
2430 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2435 if (p
[0] != ';' && p
[0] != 0)
2438 resume_info
[i
].thread
= ptid
;
2445 resume_info
[i
] = default_action
;
2447 set_desired_thread (0);
2449 resume (resume_info
, n
);
2454 write_enn (own_buf
);
2459 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2462 resume (struct thread_resume
*actions
, size_t num_actions
)
2466 /* Check if among the threads that GDB wants actioned, there's
2467 one with a pending status to report. If so, skip actually
2468 resuming/stopping and report the pending event
2470 struct visit_actioned_threads_data data
;
2472 data
.actions
= actions
;
2473 data
.num_actions
= num_actions
;
2474 data
.callback
= handle_pending_status
;
2475 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2481 (*the_target
->resume
) (actions
, num_actions
);
2487 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2489 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2491 /* No proper RSP support for this yet. At least return
2493 sprintf (own_buf
, "E.No unwaited-for children left.");
2494 disable_async_io ();
2498 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2499 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2500 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2501 current_thread
->last_status
= last_status
;
2503 /* From the client's perspective, all-stop mode always stops all
2504 threads implicitly (and the target backend has already done
2505 so by now). Tag all threads as "want-stopped", so we don't
2506 resume them implicitly without the client telling us to. */
2507 gdb_wants_all_threads_stopped ();
2508 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2509 disable_async_io ();
2511 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2512 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2513 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2517 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2519 handle_v_attach (char *own_buf
)
2523 pid
= strtol (own_buf
+ 8, NULL
, 16);
2524 if (pid
!= 0 && attach_inferior (pid
) == 0)
2526 /* Don't report shared library events after attaching, even if
2527 some libraries are preloaded. GDB will always poll the
2528 library list. Avoids the "stopped by shared library event"
2529 notice on the GDB side. */
2534 /* In non-stop, we don't send a resume reply. Stop events
2535 will follow up using the normal notification
2540 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2546 write_enn (own_buf
);
2551 /* Run a new program. Return 1 if successful, 0 if failure. */
2553 handle_v_run (char *own_buf
)
2555 char *p
, *next_p
, **new_argv
;
2559 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2565 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2566 if (new_argv
== NULL
)
2568 write_enn (own_buf
);
2573 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2575 next_p
= strchr (p
, ';');
2577 next_p
= p
+ strlen (p
);
2579 if (i
== 0 && p
== next_p
)
2583 /* FIXME: Fail request if out of memory instead of dying. */
2584 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2585 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2586 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2595 if (new_argv
[0] == NULL
)
2597 /* GDB didn't specify a program to run. Use the program from the
2598 last run with the new argument list. */
2600 if (program_argv
== NULL
)
2602 write_enn (own_buf
);
2603 freeargv (new_argv
);
2607 new_argv
[0] = strdup (program_argv
[0]);
2608 if (new_argv
[0] == NULL
)
2610 write_enn (own_buf
);
2611 freeargv (new_argv
);
2616 /* Free the old argv and install the new one. */
2617 freeargv (program_argv
);
2618 program_argv
= new_argv
;
2620 start_inferior (program_argv
);
2621 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2623 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2625 /* In non-stop, sending a resume reply doesn't set the general
2626 thread, but GDB assumes a vRun sets it (this is so GDB can
2627 query which is the main thread of the new inferior. */
2629 general_thread
= last_ptid
;
2635 write_enn (own_buf
);
2640 /* Kill process. Return 1 if successful, 0 if failure. */
2642 handle_v_kill (char *own_buf
)
2645 char *p
= &own_buf
[6];
2647 pid
= strtol (p
, NULL
, 16);
2650 if (pid
!= 0 && kill_inferior (pid
) == 0)
2652 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2653 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2654 last_ptid
= pid_to_ptid (pid
);
2655 discard_queued_stop_replies (pid
);
2661 write_enn (own_buf
);
2666 /* Handle all of the extended 'v' packets. */
2668 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2670 if (!disable_packet_vCont
)
2672 if (startswith (own_buf
, "vCont;"))
2674 require_running (own_buf
);
2675 handle_v_cont (own_buf
);
2679 if (startswith (own_buf
, "vCont?"))
2681 strcpy (own_buf
, "vCont;c;C;s;S;t");
2682 if (target_supports_range_stepping ())
2684 own_buf
= own_buf
+ strlen (own_buf
);
2685 strcpy (own_buf
, ";r");
2691 if (startswith (own_buf
, "vFile:")
2692 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2695 if (startswith (own_buf
, "vAttach;"))
2697 if ((!extended_protocol
|| !multi_process
) && target_running ())
2699 fprintf (stderr
, "Already debugging a process\n");
2700 write_enn (own_buf
);
2703 handle_v_attach (own_buf
);
2707 if (startswith (own_buf
, "vRun;"))
2709 if ((!extended_protocol
|| !multi_process
) && target_running ())
2711 fprintf (stderr
, "Already debugging a process\n");
2712 write_enn (own_buf
);
2715 handle_v_run (own_buf
);
2719 if (startswith (own_buf
, "vKill;"))
2721 if (!target_running ())
2723 fprintf (stderr
, "No process to kill\n");
2724 write_enn (own_buf
);
2727 handle_v_kill (own_buf
);
2731 if (handle_notif_ack (own_buf
, packet_len
))
2734 /* Otherwise we didn't know what packet it was. Say we didn't
2740 /* Resume thread and wait for another event. In non-stop mode,
2741 don't really wait here, but return immediatelly to the event
2744 myresume (char *own_buf
, int step
, int sig
)
2746 struct thread_resume resume_info
[2];
2748 int valid_cont_thread
;
2750 set_desired_thread (0);
2752 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2753 && !ptid_equal (cont_thread
, minus_one_ptid
));
2755 if (step
|| sig
|| valid_cont_thread
)
2757 resume_info
[0].thread
= current_ptid
;
2759 resume_info
[0].kind
= resume_step
;
2761 resume_info
[0].kind
= resume_continue
;
2762 resume_info
[0].sig
= sig
;
2766 if (!valid_cont_thread
)
2768 resume_info
[n
].thread
= minus_one_ptid
;
2769 resume_info
[n
].kind
= resume_continue
;
2770 resume_info
[n
].sig
= 0;
2774 resume (resume_info
, n
);
2777 /* Callback for for_each_inferior. Make a new stop reply for each
2781 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2783 struct thread_info
*thread
= (struct thread_info
*) entry
;
2785 /* For now, assume targets that don't have this callback also don't
2786 manage the thread's last_status field. */
2787 if (the_target
->thread_stopped
== NULL
)
2789 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2791 new_notif
->ptid
= entry
->id
;
2792 new_notif
->status
= thread
->last_status
;
2793 /* Pass the last stop reply back to GDB, but don't notify
2795 notif_event_enque (¬if_stop
,
2796 (struct notif_event
*) new_notif
);
2800 if (thread_stopped (thread
))
2805 = target_waitstatus_to_string (&thread
->last_status
);
2807 debug_printf ("Reporting thread %s as already stopped with %s\n",
2808 target_pid_to_str (entry
->id
),
2811 xfree (status_string
);
2814 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2816 /* Pass the last stop reply back to GDB, but don't notify
2818 queue_stop_reply (entry
->id
, &thread
->last_status
);
2825 /* Set this inferior threads's state as "want-stopped". We won't
2826 resume this thread until the client gives us another action for
2830 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2832 struct thread_info
*thread
= (struct thread_info
*) entry
;
2834 thread
->last_resume_kind
= resume_stop
;
2836 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2838 /* Most threads are stopped implicitly (all-stop); tag that with
2840 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2841 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2845 /* Set all threads' states as "want-stopped". */
2848 gdb_wants_all_threads_stopped (void)
2850 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2853 /* Clear the gdb_detached flag of every process. */
2856 gdb_reattached_process (struct inferior_list_entry
*entry
)
2858 struct process_info
*process
= (struct process_info
*) entry
;
2860 process
->gdb_detached
= 0;
2863 /* Callback for for_each_inferior. Clear the thread's pending status
2867 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2869 struct thread_info
*thread
= (struct thread_info
*) entry
;
2871 thread
->status_pending_p
= 0;
2874 /* Callback for for_each_inferior. If the thread is stopped with an
2875 interesting event, mark it as having a pending event. */
2878 set_pending_status_callback (struct inferior_list_entry
*entry
)
2880 struct thread_info
*thread
= (struct thread_info
*) entry
;
2882 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
2883 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
2884 /* A breakpoint, watchpoint or finished step from a previous
2885 GDB run isn't considered interesting for a new GDB run.
2886 If we left those pending, the new GDB could consider them
2887 random SIGTRAPs. This leaves out real async traps. We'd
2888 have to peek into the (target-specific) siginfo to
2889 distinguish those. */
2890 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
2891 thread
->status_pending_p
= 1;
2894 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
2895 pending status to report to GDB. */
2898 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
2900 struct thread_info
*thread
= (struct thread_info
*) entry
;
2902 return thread
->status_pending_p
;
2905 /* Status handler for the '?' packet. */
2908 handle_status (char *own_buf
)
2910 /* GDB is connected, don't forward events to the target anymore. */
2911 for_each_inferior (&all_processes
, gdb_reattached_process
);
2913 /* In non-stop mode, we must send a stop reply for each stopped
2914 thread. In all-stop mode, just send one for the first stopped
2919 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2921 /* The first is sent immediatly. OK is sent if there is no
2922 stopped thread, which is the same handling of the vStopped
2923 packet (by design). */
2924 notif_write_event (¬if_stop
, own_buf
);
2928 struct inferior_list_entry
*thread
= NULL
;
2931 stabilize_threads ();
2932 gdb_wants_all_threads_stopped ();
2934 /* We can only report one status, but we might be coming out of
2935 non-stop -- if more than one thread is stopped with
2936 interesting events, leave events for the threads we're not
2937 reporting now pending. They'll be reported the next time the
2938 threads are resumed. Start by marking all interesting events
2940 for_each_inferior (&all_threads
, set_pending_status_callback
);
2942 /* Prefer the last thread that reported an event to GDB (even if
2943 that was a GDB_SIGNAL_TRAP). */
2944 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
2945 && last_status
.kind
!= TARGET_WAITKIND_EXITED
2946 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2947 thread
= find_inferior_id (&all_threads
, last_ptid
);
2949 /* If the last event thread is not found for some reason, look
2950 for some other thread that might have an event to report. */
2952 thread
= find_inferior (&all_threads
,
2953 find_status_pending_thread_callback
, NULL
);
2955 /* If we're still out of luck, simply pick the first thread in
2958 thread
= get_first_inferior (&all_threads
);
2962 struct thread_info
*tp
= (struct thread_info
*) thread
;
2964 /* We're reporting this event, so it's no longer
2966 tp
->status_pending_p
= 0;
2968 /* GDB assumes the current thread is the thread we're
2969 reporting the status for. */
2970 general_thread
= thread
->id
;
2971 set_desired_thread (1);
2973 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2974 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
2977 strcpy (own_buf
, "W00");
2982 gdbserver_version (void)
2984 printf ("GNU gdbserver %s%s\n"
2985 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
2986 "gdbserver is free software, covered by the "
2987 "GNU General Public License.\n"
2988 "This gdbserver was configured as \"%s\"\n",
2989 PKGVERSION
, version
, host_name
);
2993 gdbserver_usage (FILE *stream
)
2995 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2996 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2997 "\tgdbserver [OPTIONS] --multi COMM\n"
2999 "COMM may either be a tty device (for serial debugging),\n"
3000 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3001 "stdin/stdout of gdbserver.\n"
3002 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3003 "PID is the process ID to attach to, when --attach is specified.\n"
3005 "Operating modes:\n"
3007 " --attach Attach to running process PID.\n"
3008 " --multi Start server without a specific program, and\n"
3009 " only quit when explicitly commanded.\n"
3010 " --once Exit after the first connection has closed.\n"
3011 " --help Print this message and then exit.\n"
3012 " --version Display version information and exit.\n"
3016 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3017 " --disable-randomization\n"
3018 " Run PROG with address space randomization disabled.\n"
3019 " --no-disable-randomization\n"
3020 " Don't disable address space randomization when\n"
3025 " --debug Enable general debugging output.\n"
3026 " --debug-format=opt1[,opt2,...]\n"
3027 " Specify extra content in debugging output.\n"
3032 " --remote-debug Enable remote protocol debugging output.\n"
3033 " --disable-packet=opt1[,opt2,...]\n"
3034 " Disable support for RSP packets or features.\n"
3036 " vCont, Tthread, qC, qfThreadInfo and \n"
3037 " threads (disable all threading packets).\n"
3039 "For more information, consult the GDB manual (available as on-line \n"
3040 "info or a printed manual).\n");
3041 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3042 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3046 gdbserver_show_disableable (FILE *stream
)
3048 fprintf (stream
, "Disableable packets:\n"
3049 " vCont \tAll vCont packets\n"
3050 " qC \tQuerying the current thread\n"
3051 " qfThreadInfo\tThread listing\n"
3052 " Tthread \tPassing the thread specifier in the "
3053 "T stop reply packet\n"
3054 " threads \tAll of the above\n");
3058 #undef require_running
3059 #define require_running(BUF) \
3060 if (!target_running ()) \
3067 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3069 int pid
= * (int *) args
;
3071 if (ptid_get_pid (entry
->id
) == pid
)
3078 kill_inferior_callback (struct inferior_list_entry
*entry
)
3080 struct process_info
*process
= (struct process_info
*) entry
;
3081 int pid
= ptid_get_pid (process
->entry
.id
);
3083 kill_inferior (pid
);
3084 discard_queued_stop_replies (pid
);
3087 /* Callback for for_each_inferior to detach or kill the inferior,
3088 depending on whether we attached to it or not.
3089 We inform the user whether we're detaching or killing the process
3090 as this is only called when gdbserver is about to exit. */
3093 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3095 struct process_info
*process
= (struct process_info
*) entry
;
3096 int pid
= ptid_get_pid (process
->entry
.id
);
3098 if (process
->attached
)
3099 detach_inferior (pid
);
3101 kill_inferior (pid
);
3103 discard_queued_stop_replies (pid
);
3106 /* for_each_inferior callback for detach_or_kill_for_exit to print
3107 the pids of started inferiors. */
3110 print_started_pid (struct inferior_list_entry
*entry
)
3112 struct process_info
*process
= (struct process_info
*) entry
;
3114 if (! process
->attached
)
3116 int pid
= ptid_get_pid (process
->entry
.id
);
3117 fprintf (stderr
, " %d", pid
);
3121 /* for_each_inferior callback for detach_or_kill_for_exit to print
3122 the pids of attached inferiors. */
3125 print_attached_pid (struct inferior_list_entry
*entry
)
3127 struct process_info
*process
= (struct process_info
*) entry
;
3129 if (process
->attached
)
3131 int pid
= ptid_get_pid (process
->entry
.id
);
3132 fprintf (stderr
, " %d", pid
);
3136 /* Call this when exiting gdbserver with possible inferiors that need
3137 to be killed or detached from. */
3140 detach_or_kill_for_exit (void)
3142 /* First print a list of the inferiors we will be killing/detaching.
3143 This is to assist the user, for example, in case the inferior unexpectedly
3144 dies after we exit: did we screw up or did the inferior exit on its own?
3145 Having this info will save some head-scratching. */
3147 if (have_started_inferiors_p ())
3149 fprintf (stderr
, "Killing process(es):");
3150 for_each_inferior (&all_processes
, print_started_pid
);
3151 fprintf (stderr
, "\n");
3153 if (have_attached_inferiors_p ())
3155 fprintf (stderr
, "Detaching process(es):");
3156 for_each_inferior (&all_processes
, print_attached_pid
);
3157 fprintf (stderr
, "\n");
3160 /* Now we can kill or detach the inferiors. */
3162 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3165 /* Value that will be passed to exit(3) when gdbserver exits. */
3166 static int exit_code
;
3168 /* Cleanup version of detach_or_kill_for_exit. */
3171 detach_or_kill_for_exit_cleanup (void *ignore
)
3176 detach_or_kill_for_exit ();
3179 CATCH (exception
, RETURN_MASK_ALL
)
3182 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3188 /* Main function. This is called by the real "main" function,
3189 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3191 static void ATTRIBUTE_NORETURN
3192 captured_main (int argc
, char *argv
[])
3196 char *arg_end
, *port
;
3197 char **next_arg
= &argv
[1];
3198 volatile int multi_mode
= 0;
3199 volatile int attach
= 0;
3202 while (*next_arg
!= NULL
&& **next_arg
== '-')
3204 if (strcmp (*next_arg
, "--version") == 0)
3206 gdbserver_version ();
3209 else if (strcmp (*next_arg
, "--help") == 0)
3211 gdbserver_usage (stdout
);
3214 else if (strcmp (*next_arg
, "--attach") == 0)
3216 else if (strcmp (*next_arg
, "--multi") == 0)
3218 else if (strcmp (*next_arg
, "--wrapper") == 0)
3222 wrapper_argv
= next_arg
;
3223 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3226 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3228 gdbserver_usage (stderr
);
3232 /* Consume the "--". */
3235 else if (strcmp (*next_arg
, "--debug") == 0)
3237 else if (startswith (*next_arg
, "--debug-format="))
3240 = parse_debug_format_options ((*next_arg
)
3241 + sizeof ("--debug-format=") - 1, 0);
3243 if (error_msg
!= NULL
)
3245 fprintf (stderr
, "%s", error_msg
);
3249 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3251 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3253 gdbserver_show_disableable (stdout
);
3256 else if (startswith (*next_arg
, "--disable-packet="))
3258 char *packets
, *tok
;
3260 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3261 for (tok
= strtok (packets
, ",");
3263 tok
= strtok (NULL
, ","))
3265 if (strcmp ("vCont", tok
) == 0)
3266 disable_packet_vCont
= 1;
3267 else if (strcmp ("Tthread", tok
) == 0)
3268 disable_packet_Tthread
= 1;
3269 else if (strcmp ("qC", tok
) == 0)
3270 disable_packet_qC
= 1;
3271 else if (strcmp ("qfThreadInfo", tok
) == 0)
3272 disable_packet_qfThreadInfo
= 1;
3273 else if (strcmp ("threads", tok
) == 0)
3275 disable_packet_vCont
= 1;
3276 disable_packet_Tthread
= 1;
3277 disable_packet_qC
= 1;
3278 disable_packet_qfThreadInfo
= 1;
3282 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3284 gdbserver_show_disableable (stderr
);
3289 else if (strcmp (*next_arg
, "-") == 0)
3291 /* "-" specifies a stdio connection and is a form of port
3293 *next_arg
= STDIO_CONNECTION_NAME
;
3296 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3297 disable_randomization
= 1;
3298 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3299 disable_randomization
= 0;
3300 else if (strcmp (*next_arg
, "--once") == 0)
3304 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3314 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3316 gdbserver_usage (stderr
);
3320 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3321 opened by remote_prepare. */
3324 /* We need to know whether the remote connection is stdio before
3325 starting the inferior. Inferiors created in this scenario have
3326 stdin,stdout redirected. So do this here before we call
3328 remote_prepare (port
);
3333 /* --attach used to come after PORT, so allow it there for
3335 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3342 && (*next_arg
== NULL
3343 || (*next_arg
)[0] == '\0'
3344 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3346 || next_arg
[1] != NULL
))
3351 gdbserver_usage (stderr
);
3355 initialize_async_io ();
3357 initialize_event_loop ();
3358 if (target_supports_tracepoints ())
3359 initialize_tracepoint ();
3361 own_buf
= xmalloc (PBUFSIZ
+ 1);
3362 mem_buf
= xmalloc (PBUFSIZ
);
3364 if (pid
== 0 && *next_arg
!= NULL
)
3368 n
= argc
- (next_arg
- argv
);
3369 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3370 for (i
= 0; i
< n
; i
++)
3371 program_argv
[i
] = xstrdup (next_arg
[i
]);
3372 program_argv
[i
] = NULL
;
3374 /* Wait till we are at first instruction in program. */
3375 start_inferior (program_argv
);
3377 /* We are now (hopefully) stopped at the first instruction of
3378 the target process. This assumes that the target process was
3379 successfully created. */
3383 if (attach_inferior (pid
) == -1)
3384 error ("Attaching not supported on this target");
3386 /* Otherwise succeeded. */
3390 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3391 last_status
.value
.integer
= 0;
3392 last_ptid
= minus_one_ptid
;
3394 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3396 initialize_notif ();
3398 /* Don't report shared library events on the initial connection,
3399 even if some libraries are preloaded. Avoids the "stopped by
3400 shared library event" notice on gdb side. */
3403 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3404 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3409 if (!was_running
&& !multi_mode
)
3410 error ("No program to debug");
3417 /* Be sure we're out of tfind mode. */
3418 current_traceframe
= -1;
3419 cont_thread
= null_ptid
;
3420 swbreak_feature
= 0;
3421 hwbreak_feature
= 0;
3427 /* Wait for events. This will return when all event sources
3428 are removed from the event loop. */
3429 start_event_loop ();
3431 /* If an exit was requested (using the "monitor exit"
3432 command), terminate now. The only other way to get
3433 here is for getpkt to fail; close the connection
3434 and reopen it at the top of the loop. */
3436 if (exit_requested
|| run_once
)
3437 throw_quit ("Quit");
3440 "Remote side has terminated connection. "
3441 "GDBserver will reopen the connection.\n");
3443 /* Get rid of any pending statuses. An eventual reconnection
3444 (by the same GDB instance or another) will refresh all its
3445 state from scratch. */
3446 discard_queued_stop_replies (-1);
3447 for_each_inferior (&all_threads
,
3448 clear_pending_status_callback
);
3452 if (disconnected_tracing
)
3454 /* Try to enable non-stop/async mode, so we we can
3455 both wait for an async socket accept, and handle
3456 async target events simultaneously. There's also
3457 no point either in having the target always stop
3458 all threads, when we're going to pass signals
3459 down without informing GDB. */
3462 if (start_non_stop (1))
3465 /* Detaching implicitly resumes all threads;
3466 simply disconnecting does not. */
3472 "Disconnected tracing disabled; "
3473 "stopping trace run.\n");
3478 CATCH (exception
, RETURN_MASK_ERROR
)
3480 if (response_needed
)
3482 write_enn (own_buf
);
3490 /* Main function. */
3493 main (int argc
, char *argv
[])
3498 captured_main (argc
, argv
);
3500 CATCH (exception
, RETURN_MASK_ALL
)
3502 if (exception
.reason
== RETURN_ERROR
)
3505 fprintf (stderr
, "%s\n", exception
.message
);
3506 fprintf (stderr
, "Exiting\n");
3514 gdb_assert_not_reached ("captured_main should never return");
3517 /* Skip PACKET until the next semi-colon (or end of string). */
3520 skip_to_semicolon (char **packet
)
3522 while (**packet
!= '\0' && **packet
!= ';')
3526 /* Process options coming from Z packets for a breakpoint. PACKET is
3527 the packet buffer. *PACKET is updated to point to the first char
3528 after the last processed option. */
3531 process_point_options (struct breakpoint
*bp
, char **packet
)
3533 char *dataptr
= *packet
;
3536 /* Check if data has the correct format. */
3537 if (*dataptr
!= ';')
3544 if (*dataptr
== ';')
3547 if (*dataptr
== 'X')
3549 /* Conditional expression. */
3551 debug_printf ("Found breakpoint condition.\n");
3552 if (!add_breakpoint_condition (bp
, &dataptr
))
3553 skip_to_semicolon (&dataptr
);
3555 else if (startswith (dataptr
, "cmds:"))
3557 dataptr
+= strlen ("cmds:");
3559 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3560 persist
= (*dataptr
== '1');
3562 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3563 skip_to_semicolon (&dataptr
);
3567 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3569 /* Skip tokens until we find one that we recognize. */
3570 skip_to_semicolon (&dataptr
);
3576 /* Event loop callback that handles a serial event. The first byte in
3577 the serial buffer gets us here. We expect characters to arrive at
3578 a brisk pace, so we read the rest of the packet with a blocking
3582 process_serial_event (void)
3593 int new_packet_len
= -1;
3595 /* Used to decide when gdbserver should exit in
3596 multi-mode/remote. */
3597 static int have_ran
= 0;
3600 have_ran
= target_running ();
3602 disable_async_io ();
3604 response_needed
= 0;
3605 packet_len
= getpkt (own_buf
);
3606 if (packet_len
<= 0)
3609 /* Force an event loop break. */
3612 response_needed
= 1;
3619 handle_query (own_buf
, packet_len
, &new_packet_len
);
3622 handle_general_set (own_buf
);
3625 require_running (own_buf
);
3630 pid
= strtol (&own_buf
[i
], NULL
, 16);
3633 pid
= ptid_get_pid (current_ptid
);
3635 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3637 struct thread_resume resume_info
;
3638 struct process_info
*process
= find_process_pid (pid
);
3640 if (process
== NULL
)
3642 write_enn (own_buf
);
3646 if (tracing
&& disconnected_tracing
)
3648 "Disconnected tracing in effect, "
3649 "leaving gdbserver attached to the process\n");
3651 if (any_persistent_commands ())
3653 "Persistent commands are present, "
3654 "leaving gdbserver attached to the process\n");
3656 /* Make sure we're in non-stop/async mode, so we we can both
3657 wait for an async socket accept, and handle async target
3658 events simultaneously. There's also no point either in
3659 having the target stop all threads, when we're going to
3660 pass signals down without informing GDB. */
3664 debug_printf ("Forcing non-stop mode\n");
3670 process
->gdb_detached
= 1;
3672 /* Detaching implicitly resumes all threads. */
3673 resume_info
.thread
= minus_one_ptid
;
3674 resume_info
.kind
= resume_continue
;
3675 resume_info
.sig
= 0;
3676 (*the_target
->resume
) (&resume_info
, 1);
3679 break; /* from switch/case */
3682 fprintf (stderr
, "Detaching from process %d\n", pid
);
3684 if (detach_inferior (pid
) != 0)
3685 write_enn (own_buf
);
3688 discard_queued_stop_replies (pid
);
3691 if (extended_protocol
)
3693 /* Treat this like a normal program exit. */
3694 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3695 last_status
.value
.integer
= 0;
3696 last_ptid
= pid_to_ptid (pid
);
3698 current_thread
= NULL
;
3705 /* If we are attached, then we can exit. Otherwise, we
3706 need to hang around doing nothing, until the child is
3708 join_inferior (pid
);
3714 extended_protocol
= 1;
3718 handle_status (own_buf
);
3721 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3723 ptid_t gdb_id
, thread_id
;
3726 require_running (own_buf
);
3728 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3730 pid
= ptid_get_pid (gdb_id
);
3732 if (ptid_equal (gdb_id
, null_ptid
)
3733 || ptid_equal (gdb_id
, minus_one_ptid
))
3734 thread_id
= null_ptid
;
3736 && ptid_equal (pid_to_ptid (pid
),
3739 struct thread_info
*thread
=
3740 (struct thread_info
*) find_inferior (&all_threads
,
3745 write_enn (own_buf
);
3749 thread_id
= thread
->entry
.id
;
3753 thread_id
= gdb_id_to_thread_id (gdb_id
);
3754 if (ptid_equal (thread_id
, null_ptid
))
3756 write_enn (own_buf
);
3761 if (own_buf
[1] == 'g')
3763 if (ptid_equal (thread_id
, null_ptid
))
3765 /* GDB is telling us to choose any thread. Check if
3766 the currently selected thread is still valid. If
3767 it is not, select the first available. */
3768 struct thread_info
*thread
=
3769 (struct thread_info
*) find_inferior_id (&all_threads
,
3773 thread
= get_first_thread ();
3774 thread_id
= thread
->entry
.id
;
3778 general_thread
= thread_id
;
3779 set_desired_thread (1);
3781 else if (own_buf
[1] == 'c')
3782 cont_thread
= thread_id
;
3788 /* Silently ignore it so that gdb can extend the protocol
3789 without compatibility headaches. */
3794 require_running (own_buf
);
3795 if (current_traceframe
>= 0)
3797 struct regcache
*regcache
3798 = new_register_cache (current_target_desc ());
3800 if (fetch_traceframe_registers (current_traceframe
,
3802 registers_to_string (regcache
, own_buf
);
3804 write_enn (own_buf
);
3805 free_register_cache (regcache
);
3809 struct regcache
*regcache
;
3811 set_desired_thread (1);
3812 regcache
= get_thread_regcache (current_thread
, 1);
3813 registers_to_string (regcache
, own_buf
);
3817 require_running (own_buf
);
3818 if (current_traceframe
>= 0)
3819 write_enn (own_buf
);
3822 struct regcache
*regcache
;
3824 set_desired_thread (1);
3825 regcache
= get_thread_regcache (current_thread
, 1);
3826 registers_from_string (regcache
, &own_buf
[1]);
3831 require_running (own_buf
);
3832 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3833 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3835 write_enn (own_buf
);
3837 bin2hex (mem_buf
, own_buf
, res
);
3840 require_running (own_buf
);
3841 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3842 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3845 write_enn (own_buf
);
3848 require_running (own_buf
);
3849 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3850 &mem_addr
, &len
, &mem_buf
) < 0
3851 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3852 write_enn (own_buf
);
3857 require_running (own_buf
);
3858 hex2bin (own_buf
+ 1, &sig
, 1);
3859 if (gdb_signal_to_host_p (sig
))
3860 signal
= gdb_signal_to_host (sig
);
3863 myresume (own_buf
, 0, signal
);
3866 require_running (own_buf
);
3867 hex2bin (own_buf
+ 1, &sig
, 1);
3868 if (gdb_signal_to_host_p (sig
))
3869 signal
= gdb_signal_to_host (sig
);
3872 myresume (own_buf
, 1, signal
);
3875 require_running (own_buf
);
3877 myresume (own_buf
, 0, signal
);
3880 require_running (own_buf
);
3882 myresume (own_buf
, 1, signal
);
3884 case 'Z': /* insert_ ... */
3886 case 'z': /* remove_ ... */
3891 char type
= own_buf
[1];
3893 const int insert
= ch
== 'Z';
3894 char *p
= &own_buf
[3];
3896 p
= unpack_varlen_hex (p
, &addr
);
3897 len
= strtol (p
+ 1, &dataptr
, 16);
3901 struct breakpoint
*bp
;
3903 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
3908 /* GDB may have sent us a list of *point parameters to
3909 be evaluated on the target's side. Read such list
3910 here. If we already have a list of parameters, GDB
3911 is telling us to drop that list and use this one
3913 clear_breakpoint_conditions_and_commands (bp
);
3914 process_point_options (bp
, &dataptr
);
3918 res
= delete_gdb_breakpoint (type
, addr
, len
);
3926 write_enn (own_buf
);
3930 response_needed
= 0;
3931 if (!target_running ())
3932 /* The packet we received doesn't make sense - but we can't
3933 reply to it, either. */
3936 fprintf (stderr
, "Killing all inferiors\n");
3937 for_each_inferior (&all_processes
, kill_inferior_callback
);
3939 /* When using the extended protocol, we wait with no program
3940 running. The traditional protocol will exit instead. */
3941 if (extended_protocol
)
3943 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3944 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3952 ptid_t gdb_id
, thread_id
;
3954 require_running (own_buf
);
3956 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3957 thread_id
= gdb_id_to_thread_id (gdb_id
);
3958 if (ptid_equal (thread_id
, null_ptid
))
3960 write_enn (own_buf
);
3964 if (mythread_alive (thread_id
))
3967 write_enn (own_buf
);
3971 response_needed
= 0;
3973 /* Restarting the inferior is only supported in the extended
3975 if (extended_protocol
)
3977 if (target_running ())
3978 for_each_inferior (&all_processes
,
3979 kill_inferior_callback
);
3980 fprintf (stderr
, "GDBserver restarting\n");
3982 /* Wait till we are at 1st instruction in prog. */
3983 if (program_argv
!= NULL
)
3984 start_inferior (program_argv
);
3987 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3988 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3994 /* It is a request we don't understand. Respond with an
3995 empty packet so that gdb knows that we don't support this
4001 /* Extended (long) request. */
4002 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4006 /* It is a request we don't understand. Respond with an empty
4007 packet so that gdb knows that we don't support this
4013 if (new_packet_len
!= -1)
4014 putpkt_binary (own_buf
, new_packet_len
);
4018 response_needed
= 0;
4020 if (!extended_protocol
&& have_ran
&& !target_running ())
4022 /* In non-stop, defer exiting until GDB had a chance to query
4023 the whole vStopped list (until it gets an OK). */
4024 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4026 /* Be transparent when GDB is connected through stdio -- no
4027 need to spam GDB's console. */
4028 if (!remote_connection_is_stdio ())
4029 fprintf (stderr
, "GDBserver exiting\n");
4041 /* Event-loop callback for serial events. */
4044 handle_serial_event (int err
, gdb_client_data client_data
)
4047 debug_printf ("handling possible serial event\n");
4049 /* Really handle it. */
4050 if (process_serial_event () < 0)
4053 /* Be sure to not change the selected thread behind GDB's back.
4054 Important in the non-stop mode asynchronous protocol. */
4055 set_desired_thread (1);
4060 /* Event-loop callback for target events. */
4063 handle_target_event (int err
, gdb_client_data client_data
)
4066 debug_printf ("handling possible target event\n");
4068 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4071 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4073 /* No RSP support for this yet. */
4075 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4077 int pid
= ptid_get_pid (last_ptid
);
4078 struct process_info
*process
= find_process_pid (pid
);
4079 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4081 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4082 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4084 mark_breakpoints_out (process
);
4085 mourn_inferior (process
);
4089 /* We're reporting this thread as stopped. Update its
4090 "want-stopped" state to what the client wants, until it
4091 gets a new resume action. */
4092 current_thread
->last_resume_kind
= resume_stop
;
4093 current_thread
->last_status
= last_status
;
4098 if (!target_running ())
4100 /* The last process exited. We're done. */
4104 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4106 /* A thread stopped with a signal, but gdb isn't
4107 connected to handle it. Pass it down to the
4108 inferior, as if it wasn't being traced. */
4109 struct thread_resume resume_info
;
4112 debug_printf ("GDB not connected; forwarding event %d for"
4114 (int) last_status
.kind
,
4115 target_pid_to_str (last_ptid
));
4117 resume_info
.thread
= last_ptid
;
4118 resume_info
.kind
= resume_continue
;
4119 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4120 (*the_target
->resume
) (&resume_info
, 1);
4122 else if (debug_threads
)
4123 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4124 (int) last_status
.kind
,
4125 target_pid_to_str (last_ptid
));
4129 struct vstop_notif
*vstop_notif
4130 = xmalloc (sizeof (struct vstop_notif
));
4132 vstop_notif
->status
= last_status
;
4133 vstop_notif
->ptid
= last_ptid
;
4134 /* Push Stop notification. */
4135 notif_push (¬if_stop
,
4136 (struct notif_event
*) vstop_notif
);
4140 /* Be sure to not change the selected thread behind GDB's back.
4141 Important in the non-stop mode asynchronous protocol. */
4142 set_desired_thread (1);