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), or \n"
3000 "HOST:PORT to listen for a TCP connection.\n"
3003 " --debug Enable general debugging output.\n"
3004 " --debug-format=opt1[,opt2,...]\n"
3005 " Specify extra content in debugging output.\n"
3010 " --remote-debug Enable remote protocol debugging output.\n"
3011 " --version Display version information and exit.\n"
3012 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3013 " --once Exit after the first connection has "
3015 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3016 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3020 gdbserver_show_disableable (FILE *stream
)
3022 fprintf (stream
, "Disableable packets:\n"
3023 " vCont \tAll vCont packets\n"
3024 " qC \tQuerying the current thread\n"
3025 " qfThreadInfo\tThread listing\n"
3026 " Tthread \tPassing the thread specifier in the "
3027 "T stop reply packet\n"
3028 " threads \tAll of the above\n");
3032 #undef require_running
3033 #define require_running(BUF) \
3034 if (!target_running ()) \
3041 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3043 int pid
= * (int *) args
;
3045 if (ptid_get_pid (entry
->id
) == pid
)
3052 kill_inferior_callback (struct inferior_list_entry
*entry
)
3054 struct process_info
*process
= (struct process_info
*) entry
;
3055 int pid
= ptid_get_pid (process
->entry
.id
);
3057 kill_inferior (pid
);
3058 discard_queued_stop_replies (pid
);
3061 /* Callback for for_each_inferior to detach or kill the inferior,
3062 depending on whether we attached to it or not.
3063 We inform the user whether we're detaching or killing the process
3064 as this is only called when gdbserver is about to exit. */
3067 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3069 struct process_info
*process
= (struct process_info
*) entry
;
3070 int pid
= ptid_get_pid (process
->entry
.id
);
3072 if (process
->attached
)
3073 detach_inferior (pid
);
3075 kill_inferior (pid
);
3077 discard_queued_stop_replies (pid
);
3080 /* for_each_inferior callback for detach_or_kill_for_exit to print
3081 the pids of started inferiors. */
3084 print_started_pid (struct inferior_list_entry
*entry
)
3086 struct process_info
*process
= (struct process_info
*) entry
;
3088 if (! process
->attached
)
3090 int pid
= ptid_get_pid (process
->entry
.id
);
3091 fprintf (stderr
, " %d", pid
);
3095 /* for_each_inferior callback for detach_or_kill_for_exit to print
3096 the pids of attached inferiors. */
3099 print_attached_pid (struct inferior_list_entry
*entry
)
3101 struct process_info
*process
= (struct process_info
*) entry
;
3103 if (process
->attached
)
3105 int pid
= ptid_get_pid (process
->entry
.id
);
3106 fprintf (stderr
, " %d", pid
);
3110 /* Call this when exiting gdbserver with possible inferiors that need
3111 to be killed or detached from. */
3114 detach_or_kill_for_exit (void)
3116 /* First print a list of the inferiors we will be killing/detaching.
3117 This is to assist the user, for example, in case the inferior unexpectedly
3118 dies after we exit: did we screw up or did the inferior exit on its own?
3119 Having this info will save some head-scratching. */
3121 if (have_started_inferiors_p ())
3123 fprintf (stderr
, "Killing process(es):");
3124 for_each_inferior (&all_processes
, print_started_pid
);
3125 fprintf (stderr
, "\n");
3127 if (have_attached_inferiors_p ())
3129 fprintf (stderr
, "Detaching process(es):");
3130 for_each_inferior (&all_processes
, print_attached_pid
);
3131 fprintf (stderr
, "\n");
3134 /* Now we can kill or detach the inferiors. */
3136 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3139 /* Value that will be passed to exit(3) when gdbserver exits. */
3140 static int exit_code
;
3142 /* Cleanup version of detach_or_kill_for_exit. */
3145 detach_or_kill_for_exit_cleanup (void *ignore
)
3150 detach_or_kill_for_exit ();
3153 CATCH (exception
, RETURN_MASK_ALL
)
3156 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3162 /* Main function. This is called by the real "main" function,
3163 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3165 static void ATTRIBUTE_NORETURN
3166 captured_main (int argc
, char *argv
[])
3170 char *arg_end
, *port
;
3171 char **next_arg
= &argv
[1];
3172 volatile int multi_mode
= 0;
3173 volatile int attach
= 0;
3176 while (*next_arg
!= NULL
&& **next_arg
== '-')
3178 if (strcmp (*next_arg
, "--version") == 0)
3180 gdbserver_version ();
3183 else if (strcmp (*next_arg
, "--help") == 0)
3185 gdbserver_usage (stdout
);
3188 else if (strcmp (*next_arg
, "--attach") == 0)
3190 else if (strcmp (*next_arg
, "--multi") == 0)
3192 else if (strcmp (*next_arg
, "--wrapper") == 0)
3196 wrapper_argv
= next_arg
;
3197 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3200 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3202 gdbserver_usage (stderr
);
3206 /* Consume the "--". */
3209 else if (strcmp (*next_arg
, "--debug") == 0)
3211 else if (startswith (*next_arg
, "--debug-format="))
3214 = parse_debug_format_options ((*next_arg
)
3215 + sizeof ("--debug-format=") - 1, 0);
3217 if (error_msg
!= NULL
)
3219 fprintf (stderr
, "%s", error_msg
);
3223 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3225 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3227 gdbserver_show_disableable (stdout
);
3230 else if (startswith (*next_arg
, "--disable-packet="))
3232 char *packets
, *tok
;
3234 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3235 for (tok
= strtok (packets
, ",");
3237 tok
= strtok (NULL
, ","))
3239 if (strcmp ("vCont", tok
) == 0)
3240 disable_packet_vCont
= 1;
3241 else if (strcmp ("Tthread", tok
) == 0)
3242 disable_packet_Tthread
= 1;
3243 else if (strcmp ("qC", tok
) == 0)
3244 disable_packet_qC
= 1;
3245 else if (strcmp ("qfThreadInfo", tok
) == 0)
3246 disable_packet_qfThreadInfo
= 1;
3247 else if (strcmp ("threads", tok
) == 0)
3249 disable_packet_vCont
= 1;
3250 disable_packet_Tthread
= 1;
3251 disable_packet_qC
= 1;
3252 disable_packet_qfThreadInfo
= 1;
3256 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3258 gdbserver_show_disableable (stderr
);
3263 else if (strcmp (*next_arg
, "-") == 0)
3265 /* "-" specifies a stdio connection and is a form of port
3267 *next_arg
= STDIO_CONNECTION_NAME
;
3270 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3271 disable_randomization
= 1;
3272 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3273 disable_randomization
= 0;
3274 else if (strcmp (*next_arg
, "--once") == 0)
3278 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3288 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3290 gdbserver_usage (stderr
);
3294 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3295 opened by remote_prepare. */
3298 /* We need to know whether the remote connection is stdio before
3299 starting the inferior. Inferiors created in this scenario have
3300 stdin,stdout redirected. So do this here before we call
3302 remote_prepare (port
);
3307 /* --attach used to come after PORT, so allow it there for
3309 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3316 && (*next_arg
== NULL
3317 || (*next_arg
)[0] == '\0'
3318 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3320 || next_arg
[1] != NULL
))
3325 gdbserver_usage (stderr
);
3329 initialize_async_io ();
3331 initialize_event_loop ();
3332 if (target_supports_tracepoints ())
3333 initialize_tracepoint ();
3335 own_buf
= xmalloc (PBUFSIZ
+ 1);
3336 mem_buf
= xmalloc (PBUFSIZ
);
3338 if (pid
== 0 && *next_arg
!= NULL
)
3342 n
= argc
- (next_arg
- argv
);
3343 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3344 for (i
= 0; i
< n
; i
++)
3345 program_argv
[i
] = xstrdup (next_arg
[i
]);
3346 program_argv
[i
] = NULL
;
3348 /* Wait till we are at first instruction in program. */
3349 start_inferior (program_argv
);
3351 /* We are now (hopefully) stopped at the first instruction of
3352 the target process. This assumes that the target process was
3353 successfully created. */
3357 if (attach_inferior (pid
) == -1)
3358 error ("Attaching not supported on this target");
3360 /* Otherwise succeeded. */
3364 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3365 last_status
.value
.integer
= 0;
3366 last_ptid
= minus_one_ptid
;
3368 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3370 initialize_notif ();
3372 /* Don't report shared library events on the initial connection,
3373 even if some libraries are preloaded. Avoids the "stopped by
3374 shared library event" notice on gdb side. */
3377 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3378 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3383 if (!was_running
&& !multi_mode
)
3384 error ("No program to debug");
3391 /* Be sure we're out of tfind mode. */
3392 current_traceframe
= -1;
3393 cont_thread
= null_ptid
;
3394 swbreak_feature
= 0;
3395 hwbreak_feature
= 0;
3401 /* Wait for events. This will return when all event sources
3402 are removed from the event loop. */
3403 start_event_loop ();
3405 /* If an exit was requested (using the "monitor exit"
3406 command), terminate now. The only other way to get
3407 here is for getpkt to fail; close the connection
3408 and reopen it at the top of the loop. */
3410 if (exit_requested
|| run_once
)
3411 throw_quit ("Quit");
3414 "Remote side has terminated connection. "
3415 "GDBserver will reopen the connection.\n");
3417 /* Get rid of any pending statuses. An eventual reconnection
3418 (by the same GDB instance or another) will refresh all its
3419 state from scratch. */
3420 discard_queued_stop_replies (-1);
3421 for_each_inferior (&all_threads
,
3422 clear_pending_status_callback
);
3426 if (disconnected_tracing
)
3428 /* Try to enable non-stop/async mode, so we we can
3429 both wait for an async socket accept, and handle
3430 async target events simultaneously. There's also
3431 no point either in having the target always stop
3432 all threads, when we're going to pass signals
3433 down without informing GDB. */
3436 if (start_non_stop (1))
3439 /* Detaching implicitly resumes all threads;
3440 simply disconnecting does not. */
3446 "Disconnected tracing disabled; "
3447 "stopping trace run.\n");
3452 CATCH (exception
, RETURN_MASK_ERROR
)
3454 if (response_needed
)
3456 write_enn (own_buf
);
3464 /* Main function. */
3467 main (int argc
, char *argv
[])
3472 captured_main (argc
, argv
);
3474 CATCH (exception
, RETURN_MASK_ALL
)
3476 if (exception
.reason
== RETURN_ERROR
)
3479 fprintf (stderr
, "%s\n", exception
.message
);
3480 fprintf (stderr
, "Exiting\n");
3488 gdb_assert_not_reached ("captured_main should never return");
3491 /* Skip PACKET until the next semi-colon (or end of string). */
3494 skip_to_semicolon (char **packet
)
3496 while (**packet
!= '\0' && **packet
!= ';')
3500 /* Process options coming from Z packets for a breakpoint. PACKET is
3501 the packet buffer. *PACKET is updated to point to the first char
3502 after the last processed option. */
3505 process_point_options (struct breakpoint
*bp
, char **packet
)
3507 char *dataptr
= *packet
;
3510 /* Check if data has the correct format. */
3511 if (*dataptr
!= ';')
3518 if (*dataptr
== ';')
3521 if (*dataptr
== 'X')
3523 /* Conditional expression. */
3525 debug_printf ("Found breakpoint condition.\n");
3526 if (!add_breakpoint_condition (bp
, &dataptr
))
3527 skip_to_semicolon (&dataptr
);
3529 else if (startswith (dataptr
, "cmds:"))
3531 dataptr
+= strlen ("cmds:");
3533 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3534 persist
= (*dataptr
== '1');
3536 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3537 skip_to_semicolon (&dataptr
);
3541 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3543 /* Skip tokens until we find one that we recognize. */
3544 skip_to_semicolon (&dataptr
);
3550 /* Event loop callback that handles a serial event. The first byte in
3551 the serial buffer gets us here. We expect characters to arrive at
3552 a brisk pace, so we read the rest of the packet with a blocking
3556 process_serial_event (void)
3567 int new_packet_len
= -1;
3569 /* Used to decide when gdbserver should exit in
3570 multi-mode/remote. */
3571 static int have_ran
= 0;
3574 have_ran
= target_running ();
3576 disable_async_io ();
3578 response_needed
= 0;
3579 packet_len
= getpkt (own_buf
);
3580 if (packet_len
<= 0)
3583 /* Force an event loop break. */
3586 response_needed
= 1;
3593 handle_query (own_buf
, packet_len
, &new_packet_len
);
3596 handle_general_set (own_buf
);
3599 require_running (own_buf
);
3604 pid
= strtol (&own_buf
[i
], NULL
, 16);
3607 pid
= ptid_get_pid (current_ptid
);
3609 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3611 struct thread_resume resume_info
;
3612 struct process_info
*process
= find_process_pid (pid
);
3614 if (process
== NULL
)
3616 write_enn (own_buf
);
3620 if (tracing
&& disconnected_tracing
)
3622 "Disconnected tracing in effect, "
3623 "leaving gdbserver attached to the process\n");
3625 if (any_persistent_commands ())
3627 "Persistent commands are present, "
3628 "leaving gdbserver attached to the process\n");
3630 /* Make sure we're in non-stop/async mode, so we we can both
3631 wait for an async socket accept, and handle async target
3632 events simultaneously. There's also no point either in
3633 having the target stop all threads, when we're going to
3634 pass signals down without informing GDB. */
3638 debug_printf ("Forcing non-stop mode\n");
3644 process
->gdb_detached
= 1;
3646 /* Detaching implicitly resumes all threads. */
3647 resume_info
.thread
= minus_one_ptid
;
3648 resume_info
.kind
= resume_continue
;
3649 resume_info
.sig
= 0;
3650 (*the_target
->resume
) (&resume_info
, 1);
3653 break; /* from switch/case */
3656 fprintf (stderr
, "Detaching from process %d\n", pid
);
3658 if (detach_inferior (pid
) != 0)
3659 write_enn (own_buf
);
3662 discard_queued_stop_replies (pid
);
3665 if (extended_protocol
)
3667 /* Treat this like a normal program exit. */
3668 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3669 last_status
.value
.integer
= 0;
3670 last_ptid
= pid_to_ptid (pid
);
3672 current_thread
= NULL
;
3679 /* If we are attached, then we can exit. Otherwise, we
3680 need to hang around doing nothing, until the child is
3682 join_inferior (pid
);
3688 extended_protocol
= 1;
3692 handle_status (own_buf
);
3695 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3697 ptid_t gdb_id
, thread_id
;
3700 require_running (own_buf
);
3702 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3704 pid
= ptid_get_pid (gdb_id
);
3706 if (ptid_equal (gdb_id
, null_ptid
)
3707 || ptid_equal (gdb_id
, minus_one_ptid
))
3708 thread_id
= null_ptid
;
3710 && ptid_equal (pid_to_ptid (pid
),
3713 struct thread_info
*thread
=
3714 (struct thread_info
*) find_inferior (&all_threads
,
3719 write_enn (own_buf
);
3723 thread_id
= thread
->entry
.id
;
3727 thread_id
= gdb_id_to_thread_id (gdb_id
);
3728 if (ptid_equal (thread_id
, null_ptid
))
3730 write_enn (own_buf
);
3735 if (own_buf
[1] == 'g')
3737 if (ptid_equal (thread_id
, null_ptid
))
3739 /* GDB is telling us to choose any thread. Check if
3740 the currently selected thread is still valid. If
3741 it is not, select the first available. */
3742 struct thread_info
*thread
=
3743 (struct thread_info
*) find_inferior_id (&all_threads
,
3747 thread
= get_first_thread ();
3748 thread_id
= thread
->entry
.id
;
3752 general_thread
= thread_id
;
3753 set_desired_thread (1);
3755 else if (own_buf
[1] == 'c')
3756 cont_thread
= thread_id
;
3762 /* Silently ignore it so that gdb can extend the protocol
3763 without compatibility headaches. */
3768 require_running (own_buf
);
3769 if (current_traceframe
>= 0)
3771 struct regcache
*regcache
3772 = new_register_cache (current_target_desc ());
3774 if (fetch_traceframe_registers (current_traceframe
,
3776 registers_to_string (regcache
, own_buf
);
3778 write_enn (own_buf
);
3779 free_register_cache (regcache
);
3783 struct regcache
*regcache
;
3785 set_desired_thread (1);
3786 regcache
= get_thread_regcache (current_thread
, 1);
3787 registers_to_string (regcache
, own_buf
);
3791 require_running (own_buf
);
3792 if (current_traceframe
>= 0)
3793 write_enn (own_buf
);
3796 struct regcache
*regcache
;
3798 set_desired_thread (1);
3799 regcache
= get_thread_regcache (current_thread
, 1);
3800 registers_from_string (regcache
, &own_buf
[1]);
3805 require_running (own_buf
);
3806 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3807 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3809 write_enn (own_buf
);
3811 bin2hex (mem_buf
, own_buf
, res
);
3814 require_running (own_buf
);
3815 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3816 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3819 write_enn (own_buf
);
3822 require_running (own_buf
);
3823 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3824 &mem_addr
, &len
, &mem_buf
) < 0
3825 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3826 write_enn (own_buf
);
3831 require_running (own_buf
);
3832 hex2bin (own_buf
+ 1, &sig
, 1);
3833 if (gdb_signal_to_host_p (sig
))
3834 signal
= gdb_signal_to_host (sig
);
3837 myresume (own_buf
, 0, signal
);
3840 require_running (own_buf
);
3841 hex2bin (own_buf
+ 1, &sig
, 1);
3842 if (gdb_signal_to_host_p (sig
))
3843 signal
= gdb_signal_to_host (sig
);
3846 myresume (own_buf
, 1, signal
);
3849 require_running (own_buf
);
3851 myresume (own_buf
, 0, signal
);
3854 require_running (own_buf
);
3856 myresume (own_buf
, 1, signal
);
3858 case 'Z': /* insert_ ... */
3860 case 'z': /* remove_ ... */
3865 char type
= own_buf
[1];
3867 const int insert
= ch
== 'Z';
3868 char *p
= &own_buf
[3];
3870 p
= unpack_varlen_hex (p
, &addr
);
3871 len
= strtol (p
+ 1, &dataptr
, 16);
3875 struct breakpoint
*bp
;
3877 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
3882 /* GDB may have sent us a list of *point parameters to
3883 be evaluated on the target's side. Read such list
3884 here. If we already have a list of parameters, GDB
3885 is telling us to drop that list and use this one
3887 clear_breakpoint_conditions_and_commands (bp
);
3888 process_point_options (bp
, &dataptr
);
3892 res
= delete_gdb_breakpoint (type
, addr
, len
);
3900 write_enn (own_buf
);
3904 response_needed
= 0;
3905 if (!target_running ())
3906 /* The packet we received doesn't make sense - but we can't
3907 reply to it, either. */
3910 fprintf (stderr
, "Killing all inferiors\n");
3911 for_each_inferior (&all_processes
, kill_inferior_callback
);
3913 /* When using the extended protocol, we wait with no program
3914 running. The traditional protocol will exit instead. */
3915 if (extended_protocol
)
3917 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3918 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3926 ptid_t gdb_id
, thread_id
;
3928 require_running (own_buf
);
3930 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3931 thread_id
= gdb_id_to_thread_id (gdb_id
);
3932 if (ptid_equal (thread_id
, null_ptid
))
3934 write_enn (own_buf
);
3938 if (mythread_alive (thread_id
))
3941 write_enn (own_buf
);
3945 response_needed
= 0;
3947 /* Restarting the inferior is only supported in the extended
3949 if (extended_protocol
)
3951 if (target_running ())
3952 for_each_inferior (&all_processes
,
3953 kill_inferior_callback
);
3954 fprintf (stderr
, "GDBserver restarting\n");
3956 /* Wait till we are at 1st instruction in prog. */
3957 if (program_argv
!= NULL
)
3958 start_inferior (program_argv
);
3961 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3962 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3968 /* It is a request we don't understand. Respond with an
3969 empty packet so that gdb knows that we don't support this
3975 /* Extended (long) request. */
3976 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3980 /* It is a request we don't understand. Respond with an empty
3981 packet so that gdb knows that we don't support this
3987 if (new_packet_len
!= -1)
3988 putpkt_binary (own_buf
, new_packet_len
);
3992 response_needed
= 0;
3994 if (!extended_protocol
&& have_ran
&& !target_running ())
3996 /* In non-stop, defer exiting until GDB had a chance to query
3997 the whole vStopped list (until it gets an OK). */
3998 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4000 /* Be transparent when GDB is connected through stdio -- no
4001 need to spam GDB's console. */
4002 if (!remote_connection_is_stdio ())
4003 fprintf (stderr
, "GDBserver exiting\n");
4015 /* Event-loop callback for serial events. */
4018 handle_serial_event (int err
, gdb_client_data client_data
)
4021 debug_printf ("handling possible serial event\n");
4023 /* Really handle it. */
4024 if (process_serial_event () < 0)
4027 /* Be sure to not change the selected thread behind GDB's back.
4028 Important in the non-stop mode asynchronous protocol. */
4029 set_desired_thread (1);
4034 /* Event-loop callback for target events. */
4037 handle_target_event (int err
, gdb_client_data client_data
)
4040 debug_printf ("handling possible target event\n");
4042 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4045 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4047 /* No RSP support for this yet. */
4049 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4051 int pid
= ptid_get_pid (last_ptid
);
4052 struct process_info
*process
= find_process_pid (pid
);
4053 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4055 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4056 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4058 mark_breakpoints_out (process
);
4059 mourn_inferior (process
);
4063 /* We're reporting this thread as stopped. Update its
4064 "want-stopped" state to what the client wants, until it
4065 gets a new resume action. */
4066 current_thread
->last_resume_kind
= resume_stop
;
4067 current_thread
->last_status
= last_status
;
4072 if (!target_running ())
4074 /* The last process exited. We're done. */
4078 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4080 /* A thread stopped with a signal, but gdb isn't
4081 connected to handle it. Pass it down to the
4082 inferior, as if it wasn't being traced. */
4083 struct thread_resume resume_info
;
4086 debug_printf ("GDB not connected; forwarding event %d for"
4088 (int) last_status
.kind
,
4089 target_pid_to_str (last_ptid
));
4091 resume_info
.thread
= last_ptid
;
4092 resume_info
.kind
= resume_continue
;
4093 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4094 (*the_target
->resume
) (&resume_info
, 1);
4096 else if (debug_threads
)
4097 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4098 (int) last_status
.kind
,
4099 target_pid_to_str (last_ptid
));
4103 struct vstop_notif
*vstop_notif
4104 = xmalloc (sizeof (struct vstop_notif
));
4106 vstop_notif
->status
= last_status
;
4107 vstop_notif
->ptid
= last_ptid
;
4108 /* Push Stop notification. */
4109 notif_push (¬if_stop
,
4110 (struct notif_event
*) vstop_notif
);
4114 /* Be sure to not change the selected thread behind GDB's back.
4115 Important in the non-stop mode asynchronous protocol. */
4116 set_desired_thread (1);