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
;
288 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
294 attach_inferior (int pid
)
296 /* myattach should return -1 if attaching is unsupported,
297 0 if it succeeded, and call error() otherwise. */
299 if (myattach (pid
) != 0)
302 fprintf (stderr
, "Attached; pid = %d\n", pid
);
305 /* FIXME - It may be that we should get the SIGNAL_PID from the
306 attach function, so that it can be the main thread instead of
307 whichever we were told to attach to. */
312 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
314 /* GDB knows to ignore the first SIGSTOP after attaching to a running
315 process using the "attach" command, but this is different; it's
316 just using "target remote". Pretend it's just starting up. */
317 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
318 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
319 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
321 current_thread
->last_resume_kind
= resume_stop
;
322 current_thread
->last_status
= last_status
;
328 extern int remote_debug
;
330 /* Decode a qXfer read request. Return 0 if everything looks OK,
334 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
336 /* After the read marker and annex, qXfer looks like a
337 traditional 'm' packet. */
338 decode_m_packet (buf
, ofs
, len
);
344 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
346 /* Extract and NUL-terminate the object. */
348 while (*buf
&& *buf
!= ':')
354 /* Extract and NUL-terminate the read/write action. */
356 while (*buf
&& *buf
!= ':')
362 /* Extract and NUL-terminate the annex. */
364 while (*buf
&& *buf
!= ':')
374 /* Write the response to a successful qXfer read. Returns the
375 length of the (binary) data stored in BUF, corresponding
376 to as much of DATA/LEN as we could fit. IS_MORE controls
377 the first character of the response. */
379 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
388 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
392 /* Handle btrace enabling in BTS format. */
395 handle_btrace_enable_bts (struct thread_info
*thread
)
397 if (thread
->btrace
!= NULL
)
398 return "E.Btrace already enabled.";
400 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
401 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
402 ¤t_btrace_conf
);
403 if (thread
->btrace
== NULL
)
404 return "E.Could not enable btrace.";
409 /* Handle btrace disabling. */
412 handle_btrace_disable (struct thread_info
*thread
)
415 if (thread
->btrace
== NULL
)
416 return "E.Branch tracing not enabled.";
418 if (target_disable_btrace (thread
->btrace
) != 0)
419 return "E.Could not disable branch tracing.";
421 thread
->btrace
= NULL
;
425 /* Handle the "Qbtrace" packet. */
428 handle_btrace_general_set (char *own_buf
)
430 struct thread_info
*thread
;
434 if (!startswith (own_buf
, "Qbtrace:"))
437 op
= own_buf
+ strlen ("Qbtrace:");
439 if (ptid_equal (general_thread
, null_ptid
)
440 || ptid_equal (general_thread
, minus_one_ptid
))
442 strcpy (own_buf
, "E.Must select a single thread.");
446 thread
= find_thread_ptid (general_thread
);
449 strcpy (own_buf
, "E.No such thread.");
455 if (strcmp (op
, "bts") == 0)
456 err
= handle_btrace_enable_bts (thread
);
457 else if (strcmp (op
, "off") == 0)
458 err
= handle_btrace_disable (thread
);
460 err
= "E.Bad Qbtrace operation. Use bts or off.";
463 strcpy (own_buf
, err
);
470 /* Handle the "Qbtrace-conf" packet. */
473 handle_btrace_conf_general_set (char *own_buf
)
475 struct thread_info
*thread
;
478 if (!startswith (own_buf
, "Qbtrace-conf:"))
481 op
= own_buf
+ strlen ("Qbtrace-conf:");
483 if (ptid_equal (general_thread
, null_ptid
)
484 || ptid_equal (general_thread
, minus_one_ptid
))
486 strcpy (own_buf
, "E.Must select a single thread.");
490 thread
= find_thread_ptid (general_thread
);
493 strcpy (own_buf
, "E.No such thread.");
497 if (startswith (op
, "bts:size="))
503 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
504 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
506 strcpy (own_buf
, "E.Bad size value.");
510 current_btrace_conf
.bts
.size
= (unsigned int) size
;
514 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
522 /* Handle all of the extended 'Q' packets. */
525 handle_general_set (char *own_buf
)
527 if (startswith (own_buf
, "QPassSignals:"))
529 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
530 const char *p
= own_buf
+ strlen ("QPassSignals:");
533 p
= decode_address_to_semicolon (&cursig
, p
);
534 for (i
= 0; i
< numsigs
; i
++)
540 /* Keep looping, to clear the remaining signals. */
543 p
= decode_address_to_semicolon (&cursig
, p
);
548 strcpy (own_buf
, "OK");
552 if (startswith (own_buf
, "QProgramSignals:"))
554 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
555 const char *p
= own_buf
+ strlen ("QProgramSignals:");
558 program_signals_p
= 1;
560 p
= decode_address_to_semicolon (&cursig
, p
);
561 for (i
= 0; i
< numsigs
; i
++)
565 program_signals
[i
] = 1;
567 /* Keep looping, to clear the remaining signals. */
570 p
= decode_address_to_semicolon (&cursig
, p
);
573 program_signals
[i
] = 0;
575 strcpy (own_buf
, "OK");
579 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
583 fprintf (stderr
, "[noack mode enabled]\n");
592 if (startswith (own_buf
, "QNonStop:"))
594 char *mode
= own_buf
+ 9;
598 if (strcmp (mode
, "0") == 0)
600 else if (strcmp (mode
, "1") == 0)
604 /* We don't know what this mode is, so complain to
606 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
612 req_str
= req
? "non-stop" : "all-stop";
613 if (start_non_stop (req
) != 0)
615 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
623 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
629 if (startswith (own_buf
, "QDisableRandomization:"))
631 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
634 unpack_varlen_hex (packet
, &setting
);
635 disable_randomization
= setting
;
639 if (disable_randomization
)
640 fprintf (stderr
, "[address space randomization disabled]\n");
642 fprintf (stderr
, "[address space randomization enabled]\n");
649 if (target_supports_tracepoints ()
650 && handle_tracepoint_general_set (own_buf
))
653 if (startswith (own_buf
, "QAgent:"))
655 char *mode
= own_buf
+ strlen ("QAgent:");
658 if (strcmp (mode
, "0") == 0)
660 else if (strcmp (mode
, "1") == 0)
664 /* We don't know what this value is, so complain to GDB. */
665 sprintf (own_buf
, "E.Unknown QAgent value");
669 /* Update the flag. */
672 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
677 if (handle_btrace_general_set (own_buf
))
680 if (handle_btrace_conf_general_set (own_buf
))
683 /* Otherwise we didn't know what packet it was. Say we didn't
689 get_features_xml (const char *annex
)
691 const struct target_desc
*desc
= current_target_desc ();
693 /* `desc->xmltarget' defines what to return when looking for the
694 "target.xml" file. Its contents can either be verbatim XML code
695 (prefixed with a '@') or else the name of the actual XML file to
696 be used in place of "target.xml".
698 This variable is set up from the auto-generated
699 init_registers_... routine for the current target. */
701 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
703 if (*desc
->xmltarget
== '@')
704 return desc
->xmltarget
+ 1;
706 annex
= desc
->xmltarget
;
711 extern const char *const xml_builtin
[][2];
714 /* Look for the annex. */
715 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
716 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
719 if (xml_builtin
[i
][0] != NULL
)
720 return xml_builtin
[i
][1];
728 monitor_show_help (void)
730 monitor_output ("The following monitor commands are supported:\n");
731 monitor_output (" set debug <0|1>\n");
732 monitor_output (" Enable general debugging messages\n");
733 monitor_output (" set debug-hw-points <0|1>\n");
734 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
735 monitor_output (" set remote-debug <0|1>\n");
736 monitor_output (" Enable remote protocol debugging messages\n");
737 monitor_output (" set debug-format option1[,option2,...]\n");
738 monitor_output (" Add additional information to debugging messages\n");
739 monitor_output (" Options: all, none");
740 monitor_output (", timestamp");
741 monitor_output ("\n");
742 monitor_output (" exit\n");
743 monitor_output (" Quit GDBserver\n");
746 /* Read trace frame or inferior memory. Returns the number of bytes
747 actually read, zero when no further transfer is possible, and -1 on
748 error. Return of a positive value smaller than LEN does not
749 indicate there's no more to be read, only the end of the transfer.
750 E.g., when GDB reads memory from a traceframe, a first request may
751 be served from a memory block that does not cover the whole request
752 length. A following request gets the rest served from either
753 another block (of the same traceframe) or from the read-only
757 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
761 if (current_traceframe
>= 0)
764 ULONGEST length
= len
;
766 if (traceframe_read_mem (current_traceframe
,
767 memaddr
, myaddr
, len
, &nbytes
))
769 /* Data read from trace buffer, we're done. */
772 if (!in_readonly_region (memaddr
, length
))
774 /* Otherwise we have a valid readonly case, fall through. */
775 /* (assume no half-trace half-real blocks for now) */
778 res
= prepare_to_access_memory ();
781 res
= read_inferior_memory (memaddr
, myaddr
, len
);
782 done_accessing_memory ();
784 return res
== 0 ? len
: -1;
790 /* Write trace frame or inferior memory. Actually, writing to trace
791 frames is forbidden. */
794 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
796 if (current_traceframe
>= 0)
802 ret
= prepare_to_access_memory ();
805 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
806 done_accessing_memory ();
812 /* Subroutine of handle_search_memory to simplify it. */
815 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
816 gdb_byte
*pattern
, unsigned pattern_len
,
817 gdb_byte
*search_buf
,
818 unsigned chunk_size
, unsigned search_buf_size
,
819 CORE_ADDR
*found_addrp
)
821 /* Prime the search buffer. */
823 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
826 warning ("Unable to access %ld bytes of target "
827 "memory at 0x%lx, halting search.",
828 (long) search_buf_size
, (long) start_addr
);
832 /* Perform the search.
834 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
835 When we've scanned N bytes we copy the trailing bytes to the start and
836 read in another N bytes. */
838 while (search_space_len
>= pattern_len
)
841 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
845 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
847 if (found_ptr
!= NULL
)
849 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
850 *found_addrp
= found_addr
;
854 /* Not found in this chunk, skip to next chunk. */
856 /* Don't let search_space_len wrap here, it's unsigned. */
857 if (search_space_len
>= chunk_size
)
858 search_space_len
-= chunk_size
;
860 search_space_len
= 0;
862 if (search_space_len
>= pattern_len
)
864 unsigned keep_len
= search_buf_size
- chunk_size
;
865 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
868 /* Copy the trailing part of the previous iteration to the front
869 of the buffer for the next iteration. */
870 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
872 nr_to_read
= (search_space_len
- keep_len
< chunk_size
873 ? search_space_len
- keep_len
876 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
877 nr_to_read
) != search_buf_size
)
879 warning ("Unable to access %ld bytes of target memory "
880 "at 0x%lx, halting search.",
881 (long) nr_to_read
, (long) read_addr
);
885 start_addr
+= chunk_size
;
894 /* Handle qSearch:memory packets. */
897 handle_search_memory (char *own_buf
, int packet_len
)
899 CORE_ADDR start_addr
;
900 CORE_ADDR search_space_len
;
902 unsigned int pattern_len
;
903 /* NOTE: also defined in find.c testcase. */
904 #define SEARCH_CHUNK_SIZE 16000
905 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
906 /* Buffer to hold memory contents for searching. */
907 gdb_byte
*search_buf
;
908 unsigned search_buf_size
;
910 CORE_ADDR found_addr
;
911 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
913 pattern
= malloc (packet_len
);
916 error ("Unable to allocate memory to perform the search");
917 strcpy (own_buf
, "E00");
920 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
921 packet_len
- cmd_name_len
,
922 &start_addr
, &search_space_len
,
923 pattern
, &pattern_len
) < 0)
926 error ("Error in parsing qSearch:memory packet");
927 strcpy (own_buf
, "E00");
931 search_buf_size
= chunk_size
+ pattern_len
- 1;
933 /* No point in trying to allocate a buffer larger than the search space. */
934 if (search_space_len
< search_buf_size
)
935 search_buf_size
= search_space_len
;
937 search_buf
= malloc (search_buf_size
);
938 if (search_buf
== NULL
)
941 error ("Unable to allocate memory to perform the search");
942 strcpy (own_buf
, "E00");
946 found
= handle_search_memory_1 (start_addr
, search_space_len
,
947 pattern
, pattern_len
,
948 search_buf
, chunk_size
, search_buf_size
,
952 sprintf (own_buf
, "1,%lx", (long) found_addr
);
954 strcpy (own_buf
, "0");
956 strcpy (own_buf
, "E00");
962 #define require_running(BUF) \
963 if (!target_running ()) \
969 /* Parse options to --debug-format= and "monitor set debug-format".
970 ARG is the text after "--debug-format=" or "monitor set debug-format".
971 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
972 This triggers calls to monitor_output.
973 The result is NULL if all options were parsed ok, otherwise an error
974 message which the caller must free.
976 N.B. These commands affect all debug format settings, they are not
977 cumulative. If a format is not specified, it is turned off.
978 However, we don't go to extra trouble with things like
979 "monitor set debug-format all,none,timestamp".
980 Instead we just parse them one at a time, in order.
982 The syntax for "monitor set debug" we support here is not identical
983 to gdb's "set debug foo on|off" because we also use this function to
984 parse "--debug-format=foo,bar". */
987 parse_debug_format_options (const char *arg
, int is_monitor
)
989 VEC (char_ptr
) *options
;
993 /* First turn all debug format options off. */
996 /* First remove leading spaces, for "monitor set debug-format". */
997 while (isspace (*arg
))
1000 options
= delim_string_to_char_ptr_vec (arg
, ',');
1002 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1004 if (strcmp (option
, "all") == 0)
1006 debug_timestamp
= 1;
1008 monitor_output ("All extra debug format options enabled.\n");
1010 else if (strcmp (option
, "none") == 0)
1012 debug_timestamp
= 0;
1014 monitor_output ("All extra debug format options disabled.\n");
1016 else if (strcmp (option
, "timestamp") == 0)
1018 debug_timestamp
= 1;
1020 monitor_output ("Timestamps will be added to debug output.\n");
1022 else if (*option
== '\0')
1024 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1029 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1032 free_char_ptr_vec (options
);
1037 free_char_ptr_vec (options
);
1041 /* Handle monitor commands not handled by target-specific handlers. */
1044 handle_monitor_command (char *mon
, char *own_buf
)
1046 if (strcmp (mon
, "set debug 1") == 0)
1049 monitor_output ("Debug output enabled.\n");
1051 else if (strcmp (mon
, "set debug 0") == 0)
1054 monitor_output ("Debug output disabled.\n");
1056 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1058 show_debug_regs
= 1;
1059 monitor_output ("H/W point debugging output enabled.\n");
1061 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1063 show_debug_regs
= 0;
1064 monitor_output ("H/W point debugging output disabled.\n");
1066 else if (strcmp (mon
, "set remote-debug 1") == 0)
1069 monitor_output ("Protocol debug output enabled.\n");
1071 else if (strcmp (mon
, "set remote-debug 0") == 0)
1074 monitor_output ("Protocol debug output disabled.\n");
1076 else if (startswith (mon
, "set debug-format "))
1079 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1082 if (error_msg
!= NULL
)
1084 monitor_output (error_msg
);
1085 monitor_show_help ();
1086 write_enn (own_buf
);
1090 else if (strcmp (mon
, "help") == 0)
1091 monitor_show_help ();
1092 else if (strcmp (mon
, "exit") == 0)
1096 monitor_output ("Unknown monitor command.\n\n");
1097 monitor_show_help ();
1098 write_enn (own_buf
);
1102 /* Associates a callback with each supported qXfer'able object. */
1106 /* The object this handler handles. */
1109 /* Request that the target transfer up to LEN 8-bit bytes of the
1110 target's OBJECT. The OFFSET, for a seekable object, specifies
1111 the starting point. The ANNEX can be used to provide additional
1112 data-specific information to the target.
1114 Return the number of bytes actually transfered, zero when no
1115 further transfer is possible, -1 on error, -2 when the transfer
1116 is not supported, and -3 on a verbose error message that should
1117 be preserved. Return of a positive value smaller than LEN does
1118 not indicate the end of the object, only the end of the transfer.
1120 One, and only one, of readbuf or writebuf must be non-NULL. */
1121 int (*xfer
) (const char *annex
,
1122 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1123 ULONGEST offset
, LONGEST len
);
1126 /* Handle qXfer:auxv:read. */
1129 handle_qxfer_auxv (const char *annex
,
1130 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1131 ULONGEST offset
, LONGEST len
)
1133 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1136 if (annex
[0] != '\0' || !target_running ())
1139 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1142 /* Handle qXfer:exec-file:read. */
1145 handle_qxfer_exec_file (const char *const_annex
,
1146 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1147 ULONGEST offset
, LONGEST len
)
1153 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1156 if (const_annex
[0] == '\0')
1158 if (current_thread
== NULL
)
1161 pid
= pid_of (current_thread
);
1165 char *annex
= alloca (strlen (const_annex
) + 1);
1167 strcpy (annex
, const_annex
);
1168 annex
= unpack_varlen_hex (annex
, &pid
);
1170 if (annex
[0] != '\0')
1177 file
= (*the_target
->pid_to_exec_file
) (pid
);
1181 total_len
= strlen (file
);
1183 if (offset
> total_len
)
1186 if (offset
+ len
> total_len
)
1187 len
= total_len
- offset
;
1189 memcpy (readbuf
, file
+ offset
, len
);
1193 /* Handle qXfer:features:read. */
1196 handle_qxfer_features (const char *annex
,
1197 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1198 ULONGEST offset
, LONGEST len
)
1200 const char *document
;
1203 if (writebuf
!= NULL
)
1206 if (!target_running ())
1209 /* Grab the correct annex. */
1210 document
= get_features_xml (annex
);
1211 if (document
== NULL
)
1214 total_len
= strlen (document
);
1216 if (offset
> total_len
)
1219 if (offset
+ len
> total_len
)
1220 len
= total_len
- offset
;
1222 memcpy (readbuf
, document
+ offset
, len
);
1226 /* Worker routine for handle_qxfer_libraries.
1227 Add to the length pointed to by ARG a conservative estimate of the
1228 length needed to transmit the file name of INF. */
1231 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1233 struct dll_info
*dll
= (struct dll_info
*) inf
;
1234 unsigned int *total_len
= arg
;
1236 /* Over-estimate the necessary memory. Assume that every character
1237 in the library name must be escaped. */
1238 *total_len
+= 128 + 6 * strlen (dll
->name
);
1241 /* Worker routine for handle_qxfer_libraries.
1242 Emit the XML to describe the library in INF. */
1245 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1247 struct dll_info
*dll
= (struct dll_info
*) inf
;
1252 strcpy (p
, " <library name=\"");
1254 name
= xml_escape_text (dll
->name
);
1258 strcpy (p
, "\"><segment address=\"");
1260 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1262 strcpy (p
, "\"/></library>\n");
1268 /* Handle qXfer:libraries:read. */
1271 handle_qxfer_libraries (const char *annex
,
1272 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1273 ULONGEST offset
, LONGEST len
)
1275 unsigned int total_len
;
1278 if (writebuf
!= NULL
)
1281 if (annex
[0] != '\0' || !target_running ())
1285 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1288 document
= malloc (total_len
);
1289 if (document
== NULL
)
1292 strcpy (document
, "<library-list>\n");
1293 p
= document
+ strlen (document
);
1295 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1297 strcpy (p
, "</library-list>\n");
1299 total_len
= strlen (document
);
1301 if (offset
> total_len
)
1307 if (offset
+ len
> total_len
)
1308 len
= total_len
- offset
;
1310 memcpy (readbuf
, document
+ offset
, len
);
1315 /* Handle qXfer:libraries-svr4:read. */
1318 handle_qxfer_libraries_svr4 (const char *annex
,
1319 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1320 ULONGEST offset
, LONGEST len
)
1322 if (writebuf
!= NULL
)
1325 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1328 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1331 /* Handle qXfer:osadata:read. */
1334 handle_qxfer_osdata (const char *annex
,
1335 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1336 ULONGEST offset
, LONGEST len
)
1338 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1341 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1344 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1347 handle_qxfer_siginfo (const char *annex
,
1348 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1349 ULONGEST offset
, LONGEST len
)
1351 if (the_target
->qxfer_siginfo
== NULL
)
1354 if (annex
[0] != '\0' || !target_running ())
1357 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1360 /* Handle qXfer:spu:read and qXfer:spu:write. */
1363 handle_qxfer_spu (const char *annex
,
1364 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1365 ULONGEST offset
, LONGEST len
)
1367 if (the_target
->qxfer_spu
== NULL
)
1370 if (!target_running ())
1373 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1376 /* Handle qXfer:statictrace:read. */
1379 handle_qxfer_statictrace (const char *annex
,
1380 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1381 ULONGEST offset
, LONGEST len
)
1385 if (writebuf
!= NULL
)
1388 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1391 if (traceframe_read_sdata (current_traceframe
, offset
,
1392 readbuf
, len
, &nbytes
))
1397 /* Helper for handle_qxfer_threads_proper.
1398 Emit the XML to describe the thread of INF. */
1401 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1403 struct thread_info
*thread
= (struct thread_info
*) inf
;
1404 struct buffer
*buffer
= arg
;
1405 ptid_t ptid
= thread_to_gdb_id (thread
);
1407 int core
= target_core_of_thread (ptid
);
1410 write_ptid (ptid_s
, ptid
);
1414 sprintf (core_s
, "%d", core
);
1415 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1420 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1425 /* Helper for handle_qxfer_threads. */
1428 handle_qxfer_threads_proper (struct buffer
*buffer
)
1430 buffer_grow_str (buffer
, "<threads>\n");
1432 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1435 buffer_grow_str0 (buffer
, "</threads>\n");
1438 /* Handle qXfer:threads:read. */
1441 handle_qxfer_threads (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
)
1445 static char *result
= 0;
1446 static unsigned int result_length
= 0;
1448 if (writebuf
!= NULL
)
1451 if (!target_running () || annex
[0] != '\0')
1456 struct buffer buffer
;
1457 /* When asked for data at offset 0, generate everything and store into
1458 'result'. Successive reads will be served off 'result'. */
1462 buffer_init (&buffer
);
1464 handle_qxfer_threads_proper (&buffer
);
1466 result
= buffer_finish (&buffer
);
1467 result_length
= strlen (result
);
1468 buffer_free (&buffer
);
1471 if (offset
>= result_length
)
1473 /* We're out of data. */
1480 if (len
> result_length
- offset
)
1481 len
= result_length
- offset
;
1483 memcpy (readbuf
, result
+ offset
, len
);
1488 /* Handle qXfer:traceframe-info:read. */
1491 handle_qxfer_traceframe_info (const char *annex
,
1492 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1493 ULONGEST offset
, LONGEST len
)
1495 static char *result
= 0;
1496 static unsigned int result_length
= 0;
1498 if (writebuf
!= NULL
)
1501 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1506 struct buffer buffer
;
1508 /* When asked for data at offset 0, generate everything and
1509 store into 'result'. Successive reads will be served off
1513 buffer_init (&buffer
);
1515 traceframe_read_info (current_traceframe
, &buffer
);
1517 result
= buffer_finish (&buffer
);
1518 result_length
= strlen (result
);
1519 buffer_free (&buffer
);
1522 if (offset
>= result_length
)
1524 /* We're out of data. */
1531 if (len
> result_length
- offset
)
1532 len
= result_length
- offset
;
1534 memcpy (readbuf
, result
+ offset
, len
);
1538 /* Handle qXfer:fdpic:read. */
1541 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1542 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1544 if (the_target
->read_loadmap
== NULL
)
1547 if (!target_running ())
1550 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1553 /* Handle qXfer:btrace:read. */
1556 handle_qxfer_btrace (const char *annex
,
1557 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1558 ULONGEST offset
, LONGEST len
)
1560 static struct buffer cache
;
1561 struct thread_info
*thread
;
1564 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1567 if (!target_running ())
1570 if (ptid_equal (general_thread
, null_ptid
)
1571 || ptid_equal (general_thread
, minus_one_ptid
))
1573 strcpy (own_buf
, "E.Must select a single thread.");
1577 thread
= find_thread_ptid (general_thread
);
1580 strcpy (own_buf
, "E.No such thread.");
1584 if (thread
->btrace
== NULL
)
1586 strcpy (own_buf
, "E.Btrace not enabled.");
1590 if (strcmp (annex
, "all") == 0)
1591 type
= BTRACE_READ_ALL
;
1592 else if (strcmp (annex
, "new") == 0)
1593 type
= BTRACE_READ_NEW
;
1594 else if (strcmp (annex
, "delta") == 0)
1595 type
= BTRACE_READ_DELTA
;
1598 strcpy (own_buf
, "E.Bad annex.");
1604 buffer_free (&cache
);
1606 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1609 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1613 else if (offset
> cache
.used_size
)
1615 buffer_free (&cache
);
1619 if (len
> cache
.used_size
- offset
)
1620 len
= cache
.used_size
- offset
;
1622 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1627 /* Handle qXfer:btrace-conf:read. */
1630 handle_qxfer_btrace_conf (const char *annex
,
1631 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1632 ULONGEST offset
, LONGEST len
)
1634 static struct buffer cache
;
1635 struct thread_info
*thread
;
1638 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1641 if (annex
[0] != '\0' || !target_running ())
1644 if (ptid_equal (general_thread
, null_ptid
)
1645 || ptid_equal (general_thread
, minus_one_ptid
))
1647 strcpy (own_buf
, "E.Must select a single thread.");
1651 thread
= find_thread_ptid (general_thread
);
1654 strcpy (own_buf
, "E.No such thread.");
1658 if (thread
->btrace
== NULL
)
1660 strcpy (own_buf
, "E.Btrace not enabled.");
1666 buffer_free (&cache
);
1668 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1671 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1675 else if (offset
> cache
.used_size
)
1677 buffer_free (&cache
);
1681 if (len
> cache
.used_size
- offset
)
1682 len
= cache
.used_size
- offset
;
1684 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1689 static const struct qxfer qxfer_packets
[] =
1691 { "auxv", handle_qxfer_auxv
},
1692 { "btrace", handle_qxfer_btrace
},
1693 { "btrace-conf", handle_qxfer_btrace_conf
},
1694 { "exec-file", handle_qxfer_exec_file
},
1695 { "fdpic", handle_qxfer_fdpic
},
1696 { "features", handle_qxfer_features
},
1697 { "libraries", handle_qxfer_libraries
},
1698 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1699 { "osdata", handle_qxfer_osdata
},
1700 { "siginfo", handle_qxfer_siginfo
},
1701 { "spu", handle_qxfer_spu
},
1702 { "statictrace", handle_qxfer_statictrace
},
1703 { "threads", handle_qxfer_threads
},
1704 { "traceframe-info", handle_qxfer_traceframe_info
},
1708 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1716 if (!startswith (own_buf
, "qXfer:"))
1719 /* Grab the object, r/w and annex. */
1720 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1722 write_enn (own_buf
);
1727 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1730 const struct qxfer
*q
= &qxfer_packets
[i
];
1732 if (strcmp (object
, q
->object
) == 0)
1734 if (strcmp (rw
, "read") == 0)
1736 unsigned char *data
;
1741 /* Grab the offset and length. */
1742 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1744 write_enn (own_buf
);
1748 /* Read one extra byte, as an indicator of whether there is
1750 if (len
> PBUFSIZ
- 2)
1752 data
= malloc (len
+ 1);
1755 write_enn (own_buf
);
1758 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1766 /* Preserve error message. */
1769 write_enn (own_buf
);
1771 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1773 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1778 else if (strcmp (rw
, "write") == 0)
1783 unsigned char *data
;
1785 strcpy (own_buf
, "E00");
1786 data
= malloc (packet_len
- (offset
- own_buf
));
1789 write_enn (own_buf
);
1792 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1793 &ofs
, &len
, data
) < 0)
1796 write_enn (own_buf
);
1800 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1808 /* Preserve error message. */
1811 write_enn (own_buf
);
1813 sprintf (own_buf
, "%x", n
);
1826 /* Table used by the crc32 function to calcuate the checksum. */
1828 static unsigned int crc32_table
[256] =
1831 /* Compute 32 bit CRC from inferior memory.
1833 On success, return 32 bit CRC.
1834 On failure, return (unsigned long long) -1. */
1836 static unsigned long long
1837 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1839 if (!crc32_table
[1])
1841 /* Initialize the CRC table and the decoding table. */
1845 for (i
= 0; i
< 256; i
++)
1847 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1848 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1855 unsigned char byte
= 0;
1857 /* Return failure if memory read fails. */
1858 if (read_inferior_memory (base
, &byte
, 1) != 0)
1859 return (unsigned long long) -1;
1861 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1864 return (unsigned long long) crc
;
1867 /* Add supported btrace packets to BUF. */
1870 supported_btrace_packets (char *buf
)
1872 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1874 strcat (buf
, ";Qbtrace:bts+");
1875 strcat (buf
, ";Qbtrace-conf:bts:size+");
1880 strcat (buf
, ";Qbtrace:off+");
1881 strcat (buf
, ";qXfer:btrace:read+");
1882 strcat (buf
, ";qXfer:btrace-conf:read+");
1885 /* Handle all of the extended 'q' packets. */
1888 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1890 static struct inferior_list_entry
*thread_ptr
;
1892 /* Reply the current thread id. */
1893 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1896 require_running (own_buf
);
1898 if (!ptid_equal (general_thread
, null_ptid
)
1899 && !ptid_equal (general_thread
, minus_one_ptid
))
1900 gdb_id
= general_thread
;
1903 thread_ptr
= get_first_inferior (&all_threads
);
1904 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1907 sprintf (own_buf
, "QC");
1909 write_ptid (own_buf
, gdb_id
);
1913 if (strcmp ("qSymbol::", own_buf
) == 0)
1915 /* GDB is suggesting new symbols have been loaded. This may
1916 mean a new shared library has been detected as loaded, so
1917 take the opportunity to check if breakpoints we think are
1918 inserted, still are. Note that it isn't guaranteed that
1919 we'll see this when a shared library is loaded, and nor will
1920 we see this for unloads (although breakpoints in unloaded
1921 libraries shouldn't trigger), as GDB may not find symbols for
1922 the library at all. We also re-validate breakpoints when we
1923 see a second GDB breakpoint for the same address, and or when
1924 we access breakpoint shadows. */
1925 validate_breakpoints ();
1927 if (target_supports_tracepoints ())
1928 tracepoint_look_up_symbols ();
1930 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1931 (*the_target
->look_up_symbols
) ();
1933 strcpy (own_buf
, "OK");
1937 if (!disable_packet_qfThreadInfo
)
1939 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1943 require_running (own_buf
);
1944 thread_ptr
= get_first_inferior (&all_threads
);
1947 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1948 write_ptid (own_buf
, gdb_id
);
1949 thread_ptr
= thread_ptr
->next
;
1953 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1957 require_running (own_buf
);
1958 if (thread_ptr
!= NULL
)
1961 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1962 write_ptid (own_buf
, gdb_id
);
1963 thread_ptr
= thread_ptr
->next
;
1968 sprintf (own_buf
, "l");
1974 if (the_target
->read_offsets
!= NULL
1975 && strcmp ("qOffsets", own_buf
) == 0)
1977 CORE_ADDR text
, data
;
1979 require_running (own_buf
);
1980 if (the_target
->read_offsets (&text
, &data
))
1981 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1982 (long)text
, (long)data
, (long)data
);
1984 write_enn (own_buf
);
1989 /* Protocol features query. */
1990 if (startswith (own_buf
, "qSupported")
1991 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1993 char *p
= &own_buf
[10];
1994 int gdb_supports_qRelocInsn
= 0;
1996 /* Start processing qSupported packet. */
1997 target_process_qsupported (NULL
);
1999 /* Process each feature being provided by GDB. The first
2000 feature will follow a ':', and latter features will follow
2004 char **qsupported
= NULL
;
2008 /* Two passes, to avoid nested strtok calls in
2009 target_process_qsupported. */
2010 for (p
= strtok (p
+ 1, ";");
2012 p
= strtok (NULL
, ";"))
2015 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
2016 qsupported
[count
- 1] = xstrdup (p
);
2019 for (i
= 0; i
< count
; i
++)
2022 if (strcmp (p
, "multiprocess+") == 0)
2024 /* GDB supports and wants multi-process support if
2026 if (target_supports_multi_process ())
2029 else if (strcmp (p
, "qRelocInsn+") == 0)
2031 /* GDB supports relocate instruction requests. */
2032 gdb_supports_qRelocInsn
= 1;
2034 else if (strcmp (p
, "swbreak+") == 0)
2036 /* GDB wants us to report whether a trap is caused
2037 by a software breakpoint and for us to handle PC
2038 adjustment if necessary on this target. */
2039 if (target_supports_stopped_by_sw_breakpoint ())
2040 swbreak_feature
= 1;
2042 else if (strcmp (p
, "hwbreak+") == 0)
2044 /* GDB wants us to report whether a trap is caused
2045 by a hardware breakpoint. */
2046 if (target_supports_stopped_by_hw_breakpoint ())
2047 hwbreak_feature
= 1;
2050 target_process_qsupported (p
);
2059 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2062 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2063 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2064 ";augmented-libraries-svr4-read+");
2067 /* We do not have any hook to indicate whether the non-SVR4 target
2068 backend supports qXfer:libraries:read, so always report it. */
2069 strcat (own_buf
, ";qXfer:libraries:read+");
2072 if (the_target
->read_auxv
!= NULL
)
2073 strcat (own_buf
, ";qXfer:auxv:read+");
2075 if (the_target
->qxfer_spu
!= NULL
)
2076 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2078 if (the_target
->qxfer_siginfo
!= NULL
)
2079 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2081 if (the_target
->read_loadmap
!= NULL
)
2082 strcat (own_buf
, ";qXfer:fdpic:read+");
2084 /* We always report qXfer:features:read, as targets may
2085 install XML files on a subsequent call to arch_setup.
2086 If we reported to GDB on startup that we don't support
2087 qXfer:feature:read at all, we will never be re-queried. */
2088 strcat (own_buf
, ";qXfer:features:read+");
2090 if (transport_is_reliable
)
2091 strcat (own_buf
, ";QStartNoAckMode+");
2093 if (the_target
->qxfer_osdata
!= NULL
)
2094 strcat (own_buf
, ";qXfer:osdata:read+");
2096 if (target_supports_multi_process ())
2097 strcat (own_buf
, ";multiprocess+");
2099 if (target_supports_non_stop ())
2100 strcat (own_buf
, ";QNonStop+");
2102 if (target_supports_disable_randomization ())
2103 strcat (own_buf
, ";QDisableRandomization+");
2105 strcat (own_buf
, ";qXfer:threads:read+");
2107 if (target_supports_tracepoints ())
2109 strcat (own_buf
, ";ConditionalTracepoints+");
2110 strcat (own_buf
, ";TraceStateVariables+");
2111 strcat (own_buf
, ";TracepointSource+");
2112 strcat (own_buf
, ";DisconnectedTracing+");
2113 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2114 strcat (own_buf
, ";FastTracepoints+");
2115 strcat (own_buf
, ";StaticTracepoints+");
2116 strcat (own_buf
, ";InstallInTrace+");
2117 strcat (own_buf
, ";qXfer:statictrace:read+");
2118 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2119 strcat (own_buf
, ";EnableDisableTracepoints+");
2120 strcat (own_buf
, ";QTBuffer:size+");
2121 strcat (own_buf
, ";tracenz+");
2124 /* Support target-side breakpoint conditions and commands. */
2125 if (target_supports_conditional_breakpoints ())
2126 strcat (own_buf
, ";ConditionalBreakpoints+");
2127 strcat (own_buf
, ";BreakpointCommands+");
2129 if (target_supports_agent ())
2130 strcat (own_buf
, ";QAgent+");
2132 supported_btrace_packets (own_buf
);
2134 if (target_supports_stopped_by_sw_breakpoint ())
2135 strcat (own_buf
, ";swbreak+");
2137 if (target_supports_stopped_by_hw_breakpoint ())
2138 strcat (own_buf
, ";hwbreak+");
2140 if (the_target
->pid_to_exec_file
!= NULL
)
2141 strcat (own_buf
, ";qXfer:exec-file:read+");
2146 /* Thread-local storage support. */
2147 if (the_target
->get_tls_address
!= NULL
2148 && startswith (own_buf
, "qGetTLSAddr:"))
2150 char *p
= own_buf
+ 12;
2151 CORE_ADDR parts
[2], address
= 0;
2153 ptid_t ptid
= null_ptid
;
2155 require_running (own_buf
);
2157 for (i
= 0; i
< 3; i
++)
2165 p2
= strchr (p
, ',');
2178 ptid
= read_ptid (p
, NULL
);
2180 decode_address (&parts
[i
- 1], p
, len
);
2184 if (p
!= NULL
|| i
< 3)
2188 struct thread_info
*thread
= find_thread_ptid (ptid
);
2193 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2199 strcpy (own_buf
, paddress(address
));
2204 write_enn (own_buf
);
2208 /* Otherwise, pretend we do not understand this packet. */
2211 /* Windows OS Thread Information Block address support. */
2212 if (the_target
->get_tib_address
!= NULL
2213 && startswith (own_buf
, "qGetTIBAddr:"))
2218 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2220 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2223 strcpy (own_buf
, paddress(tlb
));
2228 write_enn (own_buf
);
2234 /* Handle "monitor" commands. */
2235 if (startswith (own_buf
, "qRcmd,"))
2237 char *mon
= malloc (PBUFSIZ
);
2238 int len
= strlen (own_buf
+ 6);
2242 write_enn (own_buf
);
2247 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2249 write_enn (own_buf
);
2253 mon
[len
/ 2] = '\0';
2257 if (the_target
->handle_monitor_command
== NULL
2258 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2259 /* Default processing. */
2260 handle_monitor_command (mon
, own_buf
);
2266 if (startswith (own_buf
, "qSearch:memory:"))
2268 require_running (own_buf
);
2269 handle_search_memory (own_buf
, packet_len
);
2273 if (strcmp (own_buf
, "qAttached") == 0
2274 || startswith (own_buf
, "qAttached:"))
2276 struct process_info
*process
;
2278 if (own_buf
[sizeof ("qAttached") - 1])
2280 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2281 process
= (struct process_info
*)
2282 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2286 require_running (own_buf
);
2287 process
= current_process ();
2290 if (process
== NULL
)
2292 write_enn (own_buf
);
2296 strcpy (own_buf
, process
->attached
? "1" : "0");
2300 if (startswith (own_buf
, "qCRC:"))
2302 /* CRC check (compare-section). */
2306 unsigned long long crc
;
2308 require_running (own_buf
);
2309 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2310 if (*comma
++ != ',')
2312 write_enn (own_buf
);
2315 len
= strtoul (comma
, NULL
, 16);
2316 crc
= crc32 (base
, len
, 0xffffffff);
2317 /* Check for memory failure. */
2318 if (crc
== (unsigned long long) -1)
2320 write_enn (own_buf
);
2323 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2327 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2330 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2333 /* Otherwise we didn't know what packet it was. Say we didn't
2338 static void gdb_wants_all_threads_stopped (void);
2339 static void resume (struct thread_resume
*actions
, size_t n
);
2341 /* The callback that is passed to visit_actioned_threads. */
2342 typedef int (visit_actioned_threads_callback_ftype
)
2343 (const struct thread_resume
*, struct thread_info
*);
2345 /* Struct to pass data to visit_actioned_threads. */
2347 struct visit_actioned_threads_data
2349 const struct thread_resume
*actions
;
2351 visit_actioned_threads_callback_ftype
*callback
;
2354 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2355 true if CALLBACK returns true. Returns false if no matching thread
2356 is found or CALLBACK results false.
2357 Note: This function is itself a callback for find_inferior. */
2360 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2362 struct visit_actioned_threads_data
*data
= datap
;
2363 const struct thread_resume
*actions
= data
->actions
;
2364 size_t num_actions
= data
->num_actions
;
2365 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2368 for (i
= 0; i
< num_actions
; i
++)
2370 const struct thread_resume
*action
= &actions
[i
];
2372 if (ptid_equal (action
->thread
, minus_one_ptid
)
2373 || ptid_equal (action
->thread
, entry
->id
)
2374 || ((ptid_get_pid (action
->thread
)
2375 == ptid_get_pid (entry
->id
))
2376 && ptid_get_lwp (action
->thread
) == -1))
2378 struct thread_info
*thread
= (struct thread_info
*) entry
;
2380 if ((*callback
) (action
, thread
))
2388 /* Callback for visit_actioned_threads. If the thread has a pending
2389 status to report, report it now. */
2392 handle_pending_status (const struct thread_resume
*resumption
,
2393 struct thread_info
*thread
)
2395 if (thread
->status_pending_p
)
2397 thread
->status_pending_p
= 0;
2399 last_status
= thread
->last_status
;
2400 last_ptid
= thread
->entry
.id
;
2401 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2407 /* Parse vCont packets. */
2409 handle_v_cont (char *own_buf
)
2413 struct thread_resume
*resume_info
;
2414 struct thread_resume default_action
= {{0}};
2416 /* Count the number of semicolons in the packet. There should be one
2417 for every action. */
2423 p
= strchr (p
, ';');
2426 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2427 if (resume_info
== NULL
)
2435 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2437 if (p
[0] == 's' || p
[0] == 'S')
2438 resume_info
[i
].kind
= resume_step
;
2439 else if (p
[0] == 'r')
2440 resume_info
[i
].kind
= resume_step
;
2441 else if (p
[0] == 'c' || p
[0] == 'C')
2442 resume_info
[i
].kind
= resume_continue
;
2443 else if (p
[0] == 't')
2444 resume_info
[i
].kind
= resume_stop
;
2448 if (p
[0] == 'S' || p
[0] == 'C')
2451 sig
= strtol (p
+ 1, &q
, 16);
2456 if (!gdb_signal_to_host_p (sig
))
2458 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2460 else if (p
[0] == 'r')
2464 p
= unpack_varlen_hex (p
+ 1, &addr
);
2465 resume_info
[i
].step_range_start
= addr
;
2470 p
= unpack_varlen_hex (p
+ 1, &addr
);
2471 resume_info
[i
].step_range_end
= addr
;
2480 resume_info
[i
].thread
= minus_one_ptid
;
2481 default_action
= resume_info
[i
];
2483 /* Note: we don't increment i here, we'll overwrite this entry
2484 the next time through. */
2486 else if (p
[0] == ':')
2488 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2493 if (p
[0] != ';' && p
[0] != 0)
2496 resume_info
[i
].thread
= ptid
;
2503 resume_info
[i
] = default_action
;
2505 set_desired_thread (0);
2507 resume (resume_info
, n
);
2512 write_enn (own_buf
);
2517 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2520 resume (struct thread_resume
*actions
, size_t num_actions
)
2524 /* Check if among the threads that GDB wants actioned, there's
2525 one with a pending status to report. If so, skip actually
2526 resuming/stopping and report the pending event
2528 struct visit_actioned_threads_data data
;
2530 data
.actions
= actions
;
2531 data
.num_actions
= num_actions
;
2532 data
.callback
= handle_pending_status
;
2533 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2539 (*the_target
->resume
) (actions
, num_actions
);
2545 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2547 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2549 /* No proper RSP support for this yet. At least return
2551 sprintf (own_buf
, "E.No unwaited-for children left.");
2552 disable_async_io ();
2556 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2557 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2558 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2559 current_thread
->last_status
= last_status
;
2561 /* From the client's perspective, all-stop mode always stops all
2562 threads implicitly (and the target backend has already done
2563 so by now). Tag all threads as "want-stopped", so we don't
2564 resume them implicitly without the client telling us to. */
2565 gdb_wants_all_threads_stopped ();
2566 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2567 disable_async_io ();
2569 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2570 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2571 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2575 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2577 handle_v_attach (char *own_buf
)
2581 pid
= strtol (own_buf
+ 8, NULL
, 16);
2582 if (pid
!= 0 && attach_inferior (pid
) == 0)
2584 /* Don't report shared library events after attaching, even if
2585 some libraries are preloaded. GDB will always poll the
2586 library list. Avoids the "stopped by shared library event"
2587 notice on the GDB side. */
2592 /* In non-stop, we don't send a resume reply. Stop events
2593 will follow up using the normal notification
2598 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2604 write_enn (own_buf
);
2609 /* Run a new program. Return 1 if successful, 0 if failure. */
2611 handle_v_run (char *own_buf
)
2613 char *p
, *next_p
, **new_argv
;
2617 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2623 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2624 if (new_argv
== NULL
)
2626 write_enn (own_buf
);
2631 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2633 next_p
= strchr (p
, ';');
2635 next_p
= p
+ strlen (p
);
2637 if (i
== 0 && p
== next_p
)
2641 /* FIXME: Fail request if out of memory instead of dying. */
2642 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2643 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2644 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2653 if (new_argv
[0] == NULL
)
2655 /* GDB didn't specify a program to run. Use the program from the
2656 last run with the new argument list. */
2658 if (program_argv
== NULL
)
2660 write_enn (own_buf
);
2661 freeargv (new_argv
);
2665 new_argv
[0] = strdup (program_argv
[0]);
2666 if (new_argv
[0] == NULL
)
2668 write_enn (own_buf
);
2669 freeargv (new_argv
);
2674 /* Free the old argv and install the new one. */
2675 freeargv (program_argv
);
2676 program_argv
= new_argv
;
2678 start_inferior (program_argv
);
2679 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2681 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2683 /* In non-stop, sending a resume reply doesn't set the general
2684 thread, but GDB assumes a vRun sets it (this is so GDB can
2685 query which is the main thread of the new inferior. */
2687 general_thread
= last_ptid
;
2693 write_enn (own_buf
);
2698 /* Kill process. Return 1 if successful, 0 if failure. */
2700 handle_v_kill (char *own_buf
)
2703 char *p
= &own_buf
[6];
2705 pid
= strtol (p
, NULL
, 16);
2708 if (pid
!= 0 && kill_inferior (pid
) == 0)
2710 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2711 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2712 last_ptid
= pid_to_ptid (pid
);
2713 discard_queued_stop_replies (pid
);
2719 write_enn (own_buf
);
2724 /* Handle all of the extended 'v' packets. */
2726 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2728 if (!disable_packet_vCont
)
2730 if (startswith (own_buf
, "vCont;"))
2732 require_running (own_buf
);
2733 handle_v_cont (own_buf
);
2737 if (startswith (own_buf
, "vCont?"))
2739 strcpy (own_buf
, "vCont;c;C;s;S;t");
2740 if (target_supports_range_stepping ())
2742 own_buf
= own_buf
+ strlen (own_buf
);
2743 strcpy (own_buf
, ";r");
2749 if (startswith (own_buf
, "vFile:")
2750 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2753 if (startswith (own_buf
, "vAttach;"))
2755 if ((!extended_protocol
|| !multi_process
) && target_running ())
2757 fprintf (stderr
, "Already debugging a process\n");
2758 write_enn (own_buf
);
2761 handle_v_attach (own_buf
);
2765 if (startswith (own_buf
, "vRun;"))
2767 if ((!extended_protocol
|| !multi_process
) && target_running ())
2769 fprintf (stderr
, "Already debugging a process\n");
2770 write_enn (own_buf
);
2773 handle_v_run (own_buf
);
2777 if (startswith (own_buf
, "vKill;"))
2779 if (!target_running ())
2781 fprintf (stderr
, "No process to kill\n");
2782 write_enn (own_buf
);
2785 handle_v_kill (own_buf
);
2789 if (handle_notif_ack (own_buf
, packet_len
))
2792 /* Otherwise we didn't know what packet it was. Say we didn't
2798 /* Resume thread and wait for another event. In non-stop mode,
2799 don't really wait here, but return immediatelly to the event
2802 myresume (char *own_buf
, int step
, int sig
)
2804 struct thread_resume resume_info
[2];
2806 int valid_cont_thread
;
2808 set_desired_thread (0);
2810 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2811 && !ptid_equal (cont_thread
, minus_one_ptid
));
2813 if (step
|| sig
|| valid_cont_thread
)
2815 resume_info
[0].thread
= current_ptid
;
2817 resume_info
[0].kind
= resume_step
;
2819 resume_info
[0].kind
= resume_continue
;
2820 resume_info
[0].sig
= sig
;
2824 if (!valid_cont_thread
)
2826 resume_info
[n
].thread
= minus_one_ptid
;
2827 resume_info
[n
].kind
= resume_continue
;
2828 resume_info
[n
].sig
= 0;
2832 resume (resume_info
, n
);
2835 /* Callback for for_each_inferior. Make a new stop reply for each
2839 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2841 struct thread_info
*thread
= (struct thread_info
*) entry
;
2843 /* For now, assume targets that don't have this callback also don't
2844 manage the thread's last_status field. */
2845 if (the_target
->thread_stopped
== NULL
)
2847 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2849 new_notif
->ptid
= entry
->id
;
2850 new_notif
->status
= thread
->last_status
;
2851 /* Pass the last stop reply back to GDB, but don't notify
2853 notif_event_enque (¬if_stop
,
2854 (struct notif_event
*) new_notif
);
2858 if (thread_stopped (thread
))
2863 = target_waitstatus_to_string (&thread
->last_status
);
2865 debug_printf ("Reporting thread %s as already stopped with %s\n",
2866 target_pid_to_str (entry
->id
),
2869 xfree (status_string
);
2872 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2874 /* Pass the last stop reply back to GDB, but don't notify
2876 queue_stop_reply (entry
->id
, &thread
->last_status
);
2883 /* Set this inferior threads's state as "want-stopped". We won't
2884 resume this thread until the client gives us another action for
2888 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2890 struct thread_info
*thread
= (struct thread_info
*) entry
;
2892 thread
->last_resume_kind
= resume_stop
;
2894 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2896 /* Most threads are stopped implicitly (all-stop); tag that with
2898 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2899 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2903 /* Set all threads' states as "want-stopped". */
2906 gdb_wants_all_threads_stopped (void)
2908 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2911 /* Clear the gdb_detached flag of every process. */
2914 gdb_reattached_process (struct inferior_list_entry
*entry
)
2916 struct process_info
*process
= (struct process_info
*) entry
;
2918 process
->gdb_detached
= 0;
2921 /* Callback for for_each_inferior. Clear the thread's pending status
2925 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2927 struct thread_info
*thread
= (struct thread_info
*) entry
;
2929 thread
->status_pending_p
= 0;
2932 /* Callback for for_each_inferior. If the thread is stopped with an
2933 interesting event, mark it as having a pending event. */
2936 set_pending_status_callback (struct inferior_list_entry
*entry
)
2938 struct thread_info
*thread
= (struct thread_info
*) entry
;
2940 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
2941 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
2942 /* A breakpoint, watchpoint or finished step from a previous
2943 GDB run isn't considered interesting for a new GDB run.
2944 If we left those pending, the new GDB could consider them
2945 random SIGTRAPs. This leaves out real async traps. We'd
2946 have to peek into the (target-specific) siginfo to
2947 distinguish those. */
2948 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
2949 thread
->status_pending_p
= 1;
2952 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
2953 pending status to report to GDB. */
2956 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
2958 struct thread_info
*thread
= (struct thread_info
*) entry
;
2960 return thread
->status_pending_p
;
2963 /* Status handler for the '?' packet. */
2966 handle_status (char *own_buf
)
2968 /* GDB is connected, don't forward events to the target anymore. */
2969 for_each_inferior (&all_processes
, gdb_reattached_process
);
2971 /* In non-stop mode, we must send a stop reply for each stopped
2972 thread. In all-stop mode, just send one for the first stopped
2977 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2979 /* The first is sent immediatly. OK is sent if there is no
2980 stopped thread, which is the same handling of the vStopped
2981 packet (by design). */
2982 notif_write_event (¬if_stop
, own_buf
);
2986 struct inferior_list_entry
*thread
= NULL
;
2989 stabilize_threads ();
2990 gdb_wants_all_threads_stopped ();
2992 /* We can only report one status, but we might be coming out of
2993 non-stop -- if more than one thread is stopped with
2994 interesting events, leave events for the threads we're not
2995 reporting now pending. They'll be reported the next time the
2996 threads are resumed. Start by marking all interesting events
2998 for_each_inferior (&all_threads
, set_pending_status_callback
);
3000 /* Prefer the last thread that reported an event to GDB (even if
3001 that was a GDB_SIGNAL_TRAP). */
3002 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3003 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3004 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3005 thread
= find_inferior_id (&all_threads
, last_ptid
);
3007 /* If the last event thread is not found for some reason, look
3008 for some other thread that might have an event to report. */
3010 thread
= find_inferior (&all_threads
,
3011 find_status_pending_thread_callback
, NULL
);
3013 /* If we're still out of luck, simply pick the first thread in
3016 thread
= get_first_inferior (&all_threads
);
3020 struct thread_info
*tp
= (struct thread_info
*) thread
;
3022 /* We're reporting this event, so it's no longer
3024 tp
->status_pending_p
= 0;
3026 /* GDB assumes the current thread is the thread we're
3027 reporting the status for. */
3028 general_thread
= thread
->id
;
3029 set_desired_thread (1);
3031 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3032 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3035 strcpy (own_buf
, "W00");
3040 gdbserver_version (void)
3042 printf ("GNU gdbserver %s%s\n"
3043 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3044 "gdbserver is free software, covered by the "
3045 "GNU General Public License.\n"
3046 "This gdbserver was configured as \"%s\"\n",
3047 PKGVERSION
, version
, host_name
);
3051 gdbserver_usage (FILE *stream
)
3053 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3054 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3055 "\tgdbserver [OPTIONS] --multi COMM\n"
3057 "COMM may either be a tty device (for serial debugging),\n"
3058 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3059 "stdin/stdout of gdbserver.\n"
3060 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3061 "PID is the process ID to attach to, when --attach is specified.\n"
3063 "Operating modes:\n"
3065 " --attach Attach to running process PID.\n"
3066 " --multi Start server without a specific program, and\n"
3067 " only quit when explicitly commanded.\n"
3068 " --once Exit after the first connection has closed.\n"
3069 " --help Print this message and then exit.\n"
3070 " --version Display version information and exit.\n"
3074 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3075 " --disable-randomization\n"
3076 " Run PROG with address space randomization disabled.\n"
3077 " --no-disable-randomization\n"
3078 " Don't disable address space randomization when\n"
3083 " --debug Enable general debugging output.\n"
3084 " --debug-format=opt1[,opt2,...]\n"
3085 " Specify extra content in debugging output.\n"
3090 " --remote-debug Enable remote protocol debugging output.\n"
3091 " --disable-packet=opt1[,opt2,...]\n"
3092 " Disable support for RSP packets or features.\n"
3094 " vCont, Tthread, qC, qfThreadInfo and \n"
3095 " threads (disable all threading packets).\n"
3097 "For more information, consult the GDB manual (available as on-line \n"
3098 "info or a printed manual).\n");
3099 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3100 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3104 gdbserver_show_disableable (FILE *stream
)
3106 fprintf (stream
, "Disableable packets:\n"
3107 " vCont \tAll vCont packets\n"
3108 " qC \tQuerying the current thread\n"
3109 " qfThreadInfo\tThread listing\n"
3110 " Tthread \tPassing the thread specifier in the "
3111 "T stop reply packet\n"
3112 " threads \tAll of the above\n");
3116 #undef require_running
3117 #define require_running(BUF) \
3118 if (!target_running ()) \
3125 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3127 int pid
= * (int *) args
;
3129 if (ptid_get_pid (entry
->id
) == pid
)
3136 kill_inferior_callback (struct inferior_list_entry
*entry
)
3138 struct process_info
*process
= (struct process_info
*) entry
;
3139 int pid
= ptid_get_pid (process
->entry
.id
);
3141 kill_inferior (pid
);
3142 discard_queued_stop_replies (pid
);
3145 /* Callback for for_each_inferior to detach or kill the inferior,
3146 depending on whether we attached to it or not.
3147 We inform the user whether we're detaching or killing the process
3148 as this is only called when gdbserver is about to exit. */
3151 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3153 struct process_info
*process
= (struct process_info
*) entry
;
3154 int pid
= ptid_get_pid (process
->entry
.id
);
3156 if (process
->attached
)
3157 detach_inferior (pid
);
3159 kill_inferior (pid
);
3161 discard_queued_stop_replies (pid
);
3164 /* for_each_inferior callback for detach_or_kill_for_exit to print
3165 the pids of started inferiors. */
3168 print_started_pid (struct inferior_list_entry
*entry
)
3170 struct process_info
*process
= (struct process_info
*) entry
;
3172 if (! process
->attached
)
3174 int pid
= ptid_get_pid (process
->entry
.id
);
3175 fprintf (stderr
, " %d", pid
);
3179 /* for_each_inferior callback for detach_or_kill_for_exit to print
3180 the pids of attached inferiors. */
3183 print_attached_pid (struct inferior_list_entry
*entry
)
3185 struct process_info
*process
= (struct process_info
*) entry
;
3187 if (process
->attached
)
3189 int pid
= ptid_get_pid (process
->entry
.id
);
3190 fprintf (stderr
, " %d", pid
);
3194 /* Call this when exiting gdbserver with possible inferiors that need
3195 to be killed or detached from. */
3198 detach_or_kill_for_exit (void)
3200 /* First print a list of the inferiors we will be killing/detaching.
3201 This is to assist the user, for example, in case the inferior unexpectedly
3202 dies after we exit: did we screw up or did the inferior exit on its own?
3203 Having this info will save some head-scratching. */
3205 if (have_started_inferiors_p ())
3207 fprintf (stderr
, "Killing process(es):");
3208 for_each_inferior (&all_processes
, print_started_pid
);
3209 fprintf (stderr
, "\n");
3211 if (have_attached_inferiors_p ())
3213 fprintf (stderr
, "Detaching process(es):");
3214 for_each_inferior (&all_processes
, print_attached_pid
);
3215 fprintf (stderr
, "\n");
3218 /* Now we can kill or detach the inferiors. */
3220 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3223 /* Value that will be passed to exit(3) when gdbserver exits. */
3224 static int exit_code
;
3226 /* Cleanup version of detach_or_kill_for_exit. */
3229 detach_or_kill_for_exit_cleanup (void *ignore
)
3234 detach_or_kill_for_exit ();
3237 CATCH (exception
, RETURN_MASK_ALL
)
3240 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3246 /* Main function. This is called by the real "main" function,
3247 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3249 static void ATTRIBUTE_NORETURN
3250 captured_main (int argc
, char *argv
[])
3254 char *arg_end
, *port
;
3255 char **next_arg
= &argv
[1];
3256 volatile int multi_mode
= 0;
3257 volatile int attach
= 0;
3260 while (*next_arg
!= NULL
&& **next_arg
== '-')
3262 if (strcmp (*next_arg
, "--version") == 0)
3264 gdbserver_version ();
3267 else if (strcmp (*next_arg
, "--help") == 0)
3269 gdbserver_usage (stdout
);
3272 else if (strcmp (*next_arg
, "--attach") == 0)
3274 else if (strcmp (*next_arg
, "--multi") == 0)
3276 else if (strcmp (*next_arg
, "--wrapper") == 0)
3280 wrapper_argv
= next_arg
;
3281 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3284 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3286 gdbserver_usage (stderr
);
3290 /* Consume the "--". */
3293 else if (strcmp (*next_arg
, "--debug") == 0)
3295 else if (startswith (*next_arg
, "--debug-format="))
3298 = parse_debug_format_options ((*next_arg
)
3299 + sizeof ("--debug-format=") - 1, 0);
3301 if (error_msg
!= NULL
)
3303 fprintf (stderr
, "%s", error_msg
);
3307 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3309 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3311 gdbserver_show_disableable (stdout
);
3314 else if (startswith (*next_arg
, "--disable-packet="))
3316 char *packets
, *tok
;
3318 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3319 for (tok
= strtok (packets
, ",");
3321 tok
= strtok (NULL
, ","))
3323 if (strcmp ("vCont", tok
) == 0)
3324 disable_packet_vCont
= 1;
3325 else if (strcmp ("Tthread", tok
) == 0)
3326 disable_packet_Tthread
= 1;
3327 else if (strcmp ("qC", tok
) == 0)
3328 disable_packet_qC
= 1;
3329 else if (strcmp ("qfThreadInfo", tok
) == 0)
3330 disable_packet_qfThreadInfo
= 1;
3331 else if (strcmp ("threads", tok
) == 0)
3333 disable_packet_vCont
= 1;
3334 disable_packet_Tthread
= 1;
3335 disable_packet_qC
= 1;
3336 disable_packet_qfThreadInfo
= 1;
3340 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3342 gdbserver_show_disableable (stderr
);
3347 else if (strcmp (*next_arg
, "-") == 0)
3349 /* "-" specifies a stdio connection and is a form of port
3351 *next_arg
= STDIO_CONNECTION_NAME
;
3354 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3355 disable_randomization
= 1;
3356 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3357 disable_randomization
= 0;
3358 else if (strcmp (*next_arg
, "--once") == 0)
3362 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3372 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3374 gdbserver_usage (stderr
);
3378 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3379 opened by remote_prepare. */
3382 /* We need to know whether the remote connection is stdio before
3383 starting the inferior. Inferiors created in this scenario have
3384 stdin,stdout redirected. So do this here before we call
3386 remote_prepare (port
);
3391 /* --attach used to come after PORT, so allow it there for
3393 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3400 && (*next_arg
== NULL
3401 || (*next_arg
)[0] == '\0'
3402 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3404 || next_arg
[1] != NULL
))
3409 gdbserver_usage (stderr
);
3413 initialize_async_io ();
3415 initialize_event_loop ();
3416 if (target_supports_tracepoints ())
3417 initialize_tracepoint ();
3419 own_buf
= xmalloc (PBUFSIZ
+ 1);
3420 mem_buf
= xmalloc (PBUFSIZ
);
3422 if (pid
== 0 && *next_arg
!= NULL
)
3426 n
= argc
- (next_arg
- argv
);
3427 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3428 for (i
= 0; i
< n
; i
++)
3429 program_argv
[i
] = xstrdup (next_arg
[i
]);
3430 program_argv
[i
] = NULL
;
3432 /* Wait till we are at first instruction in program. */
3433 start_inferior (program_argv
);
3435 /* We are now (hopefully) stopped at the first instruction of
3436 the target process. This assumes that the target process was
3437 successfully created. */
3441 if (attach_inferior (pid
) == -1)
3442 error ("Attaching not supported on this target");
3444 /* Otherwise succeeded. */
3448 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3449 last_status
.value
.integer
= 0;
3450 last_ptid
= minus_one_ptid
;
3452 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3454 initialize_notif ();
3456 /* Don't report shared library events on the initial connection,
3457 even if some libraries are preloaded. Avoids the "stopped by
3458 shared library event" notice on gdb side. */
3461 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3462 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3467 if (!was_running
&& !multi_mode
)
3468 error ("No program to debug");
3475 /* Be sure we're out of tfind mode. */
3476 current_traceframe
= -1;
3477 cont_thread
= null_ptid
;
3478 swbreak_feature
= 0;
3479 hwbreak_feature
= 0;
3485 /* Wait for events. This will return when all event sources
3486 are removed from the event loop. */
3487 start_event_loop ();
3489 /* If an exit was requested (using the "monitor exit"
3490 command), terminate now. The only other way to get
3491 here is for getpkt to fail; close the connection
3492 and reopen it at the top of the loop. */
3494 if (exit_requested
|| run_once
)
3495 throw_quit ("Quit");
3498 "Remote side has terminated connection. "
3499 "GDBserver will reopen the connection.\n");
3501 /* Get rid of any pending statuses. An eventual reconnection
3502 (by the same GDB instance or another) will refresh all its
3503 state from scratch. */
3504 discard_queued_stop_replies (-1);
3505 for_each_inferior (&all_threads
,
3506 clear_pending_status_callback
);
3510 if (disconnected_tracing
)
3512 /* Try to enable non-stop/async mode, so we we can
3513 both wait for an async socket accept, and handle
3514 async target events simultaneously. There's also
3515 no point either in having the target always stop
3516 all threads, when we're going to pass signals
3517 down without informing GDB. */
3520 if (start_non_stop (1))
3523 /* Detaching implicitly resumes all threads;
3524 simply disconnecting does not. */
3530 "Disconnected tracing disabled; "
3531 "stopping trace run.\n");
3536 CATCH (exception
, RETURN_MASK_ERROR
)
3538 if (response_needed
)
3540 write_enn (own_buf
);
3548 /* Main function. */
3551 main (int argc
, char *argv
[])
3556 captured_main (argc
, argv
);
3558 CATCH (exception
, RETURN_MASK_ALL
)
3560 if (exception
.reason
== RETURN_ERROR
)
3563 fprintf (stderr
, "%s\n", exception
.message
);
3564 fprintf (stderr
, "Exiting\n");
3572 gdb_assert_not_reached ("captured_main should never return");
3575 /* Skip PACKET until the next semi-colon (or end of string). */
3578 skip_to_semicolon (char **packet
)
3580 while (**packet
!= '\0' && **packet
!= ';')
3584 /* Process options coming from Z packets for a breakpoint. PACKET is
3585 the packet buffer. *PACKET is updated to point to the first char
3586 after the last processed option. */
3589 process_point_options (struct breakpoint
*bp
, char **packet
)
3591 char *dataptr
= *packet
;
3594 /* Check if data has the correct format. */
3595 if (*dataptr
!= ';')
3602 if (*dataptr
== ';')
3605 if (*dataptr
== 'X')
3607 /* Conditional expression. */
3609 debug_printf ("Found breakpoint condition.\n");
3610 if (!add_breakpoint_condition (bp
, &dataptr
))
3611 skip_to_semicolon (&dataptr
);
3613 else if (startswith (dataptr
, "cmds:"))
3615 dataptr
+= strlen ("cmds:");
3617 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3618 persist
= (*dataptr
== '1');
3620 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3621 skip_to_semicolon (&dataptr
);
3625 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3627 /* Skip tokens until we find one that we recognize. */
3628 skip_to_semicolon (&dataptr
);
3634 /* Event loop callback that handles a serial event. The first byte in
3635 the serial buffer gets us here. We expect characters to arrive at
3636 a brisk pace, so we read the rest of the packet with a blocking
3640 process_serial_event (void)
3651 int new_packet_len
= -1;
3653 /* Used to decide when gdbserver should exit in
3654 multi-mode/remote. */
3655 static int have_ran
= 0;
3658 have_ran
= target_running ();
3660 disable_async_io ();
3662 response_needed
= 0;
3663 packet_len
= getpkt (own_buf
);
3664 if (packet_len
<= 0)
3667 /* Force an event loop break. */
3670 response_needed
= 1;
3677 handle_query (own_buf
, packet_len
, &new_packet_len
);
3680 handle_general_set (own_buf
);
3683 require_running (own_buf
);
3688 pid
= strtol (&own_buf
[i
], NULL
, 16);
3691 pid
= ptid_get_pid (current_ptid
);
3693 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3695 struct thread_resume resume_info
;
3696 struct process_info
*process
= find_process_pid (pid
);
3698 if (process
== NULL
)
3700 write_enn (own_buf
);
3704 if (tracing
&& disconnected_tracing
)
3706 "Disconnected tracing in effect, "
3707 "leaving gdbserver attached to the process\n");
3709 if (any_persistent_commands ())
3711 "Persistent commands are present, "
3712 "leaving gdbserver attached to the process\n");
3714 /* Make sure we're in non-stop/async mode, so we we can both
3715 wait for an async socket accept, and handle async target
3716 events simultaneously. There's also no point either in
3717 having the target stop all threads, when we're going to
3718 pass signals down without informing GDB. */
3722 debug_printf ("Forcing non-stop mode\n");
3728 process
->gdb_detached
= 1;
3730 /* Detaching implicitly resumes all threads. */
3731 resume_info
.thread
= minus_one_ptid
;
3732 resume_info
.kind
= resume_continue
;
3733 resume_info
.sig
= 0;
3734 (*the_target
->resume
) (&resume_info
, 1);
3737 break; /* from switch/case */
3740 fprintf (stderr
, "Detaching from process %d\n", pid
);
3742 if (detach_inferior (pid
) != 0)
3743 write_enn (own_buf
);
3746 discard_queued_stop_replies (pid
);
3749 if (extended_protocol
)
3751 /* Treat this like a normal program exit. */
3752 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3753 last_status
.value
.integer
= 0;
3754 last_ptid
= pid_to_ptid (pid
);
3756 current_thread
= NULL
;
3763 /* If we are attached, then we can exit. Otherwise, we
3764 need to hang around doing nothing, until the child is
3766 join_inferior (pid
);
3772 extended_protocol
= 1;
3776 handle_status (own_buf
);
3779 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3781 ptid_t gdb_id
, thread_id
;
3784 require_running (own_buf
);
3786 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3788 pid
= ptid_get_pid (gdb_id
);
3790 if (ptid_equal (gdb_id
, null_ptid
)
3791 || ptid_equal (gdb_id
, minus_one_ptid
))
3792 thread_id
= null_ptid
;
3794 && ptid_equal (pid_to_ptid (pid
),
3797 struct thread_info
*thread
=
3798 (struct thread_info
*) find_inferior (&all_threads
,
3803 write_enn (own_buf
);
3807 thread_id
= thread
->entry
.id
;
3811 thread_id
= gdb_id_to_thread_id (gdb_id
);
3812 if (ptid_equal (thread_id
, null_ptid
))
3814 write_enn (own_buf
);
3819 if (own_buf
[1] == 'g')
3821 if (ptid_equal (thread_id
, null_ptid
))
3823 /* GDB is telling us to choose any thread. Check if
3824 the currently selected thread is still valid. If
3825 it is not, select the first available. */
3826 struct thread_info
*thread
=
3827 (struct thread_info
*) find_inferior_id (&all_threads
,
3831 thread
= get_first_thread ();
3832 thread_id
= thread
->entry
.id
;
3836 general_thread
= thread_id
;
3837 set_desired_thread (1);
3839 else if (own_buf
[1] == 'c')
3840 cont_thread
= thread_id
;
3846 /* Silently ignore it so that gdb can extend the protocol
3847 without compatibility headaches. */
3852 require_running (own_buf
);
3853 if (current_traceframe
>= 0)
3855 struct regcache
*regcache
3856 = new_register_cache (current_target_desc ());
3858 if (fetch_traceframe_registers (current_traceframe
,
3860 registers_to_string (regcache
, own_buf
);
3862 write_enn (own_buf
);
3863 free_register_cache (regcache
);
3867 struct regcache
*regcache
;
3869 set_desired_thread (1);
3870 regcache
= get_thread_regcache (current_thread
, 1);
3871 registers_to_string (regcache
, own_buf
);
3875 require_running (own_buf
);
3876 if (current_traceframe
>= 0)
3877 write_enn (own_buf
);
3880 struct regcache
*regcache
;
3882 set_desired_thread (1);
3883 regcache
= get_thread_regcache (current_thread
, 1);
3884 registers_from_string (regcache
, &own_buf
[1]);
3889 require_running (own_buf
);
3890 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3891 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3893 write_enn (own_buf
);
3895 bin2hex (mem_buf
, own_buf
, res
);
3898 require_running (own_buf
);
3899 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3900 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3903 write_enn (own_buf
);
3906 require_running (own_buf
);
3907 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3908 &mem_addr
, &len
, &mem_buf
) < 0
3909 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3910 write_enn (own_buf
);
3915 require_running (own_buf
);
3916 hex2bin (own_buf
+ 1, &sig
, 1);
3917 if (gdb_signal_to_host_p (sig
))
3918 signal
= gdb_signal_to_host (sig
);
3921 myresume (own_buf
, 0, signal
);
3924 require_running (own_buf
);
3925 hex2bin (own_buf
+ 1, &sig
, 1);
3926 if (gdb_signal_to_host_p (sig
))
3927 signal
= gdb_signal_to_host (sig
);
3930 myresume (own_buf
, 1, signal
);
3933 require_running (own_buf
);
3935 myresume (own_buf
, 0, signal
);
3938 require_running (own_buf
);
3940 myresume (own_buf
, 1, signal
);
3942 case 'Z': /* insert_ ... */
3944 case 'z': /* remove_ ... */
3949 char type
= own_buf
[1];
3951 const int insert
= ch
== 'Z';
3952 char *p
= &own_buf
[3];
3954 p
= unpack_varlen_hex (p
, &addr
);
3955 len
= strtol (p
+ 1, &dataptr
, 16);
3959 struct breakpoint
*bp
;
3961 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
3966 /* GDB may have sent us a list of *point parameters to
3967 be evaluated on the target's side. Read such list
3968 here. If we already have a list of parameters, GDB
3969 is telling us to drop that list and use this one
3971 clear_breakpoint_conditions_and_commands (bp
);
3972 process_point_options (bp
, &dataptr
);
3976 res
= delete_gdb_breakpoint (type
, addr
, len
);
3984 write_enn (own_buf
);
3988 response_needed
= 0;
3989 if (!target_running ())
3990 /* The packet we received doesn't make sense - but we can't
3991 reply to it, either. */
3994 fprintf (stderr
, "Killing all inferiors\n");
3995 for_each_inferior (&all_processes
, kill_inferior_callback
);
3997 /* When using the extended protocol, we wait with no program
3998 running. The traditional protocol will exit instead. */
3999 if (extended_protocol
)
4001 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4002 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4010 ptid_t gdb_id
, thread_id
;
4012 require_running (own_buf
);
4014 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4015 thread_id
= gdb_id_to_thread_id (gdb_id
);
4016 if (ptid_equal (thread_id
, null_ptid
))
4018 write_enn (own_buf
);
4022 if (mythread_alive (thread_id
))
4025 write_enn (own_buf
);
4029 response_needed
= 0;
4031 /* Restarting the inferior is only supported in the extended
4033 if (extended_protocol
)
4035 if (target_running ())
4036 for_each_inferior (&all_processes
,
4037 kill_inferior_callback
);
4038 fprintf (stderr
, "GDBserver restarting\n");
4040 /* Wait till we are at 1st instruction in prog. */
4041 if (program_argv
!= NULL
)
4042 start_inferior (program_argv
);
4045 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4046 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4052 /* It is a request we don't understand. Respond with an
4053 empty packet so that gdb knows that we don't support this
4059 /* Extended (long) request. */
4060 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4064 /* It is a request we don't understand. Respond with an empty
4065 packet so that gdb knows that we don't support this
4071 if (new_packet_len
!= -1)
4072 putpkt_binary (own_buf
, new_packet_len
);
4076 response_needed
= 0;
4078 if (!extended_protocol
&& have_ran
&& !target_running ())
4080 /* In non-stop, defer exiting until GDB had a chance to query
4081 the whole vStopped list (until it gets an OK). */
4082 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4084 /* Be transparent when GDB is connected through stdio -- no
4085 need to spam GDB's console. */
4086 if (!remote_connection_is_stdio ())
4087 fprintf (stderr
, "GDBserver exiting\n");
4099 /* Event-loop callback for serial events. */
4102 handle_serial_event (int err
, gdb_client_data client_data
)
4105 debug_printf ("handling possible serial event\n");
4107 /* Really handle it. */
4108 if (process_serial_event () < 0)
4111 /* Be sure to not change the selected thread behind GDB's back.
4112 Important in the non-stop mode asynchronous protocol. */
4113 set_desired_thread (1);
4118 /* Event-loop callback for target events. */
4121 handle_target_event (int err
, gdb_client_data client_data
)
4124 debug_printf ("handling possible target event\n");
4126 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4129 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4131 /* No RSP support for this yet. */
4133 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4135 int pid
= ptid_get_pid (last_ptid
);
4136 struct process_info
*process
= find_process_pid (pid
);
4137 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4139 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4140 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4142 mark_breakpoints_out (process
);
4143 mourn_inferior (process
);
4147 /* We're reporting this thread as stopped. Update its
4148 "want-stopped" state to what the client wants, until it
4149 gets a new resume action. */
4150 current_thread
->last_resume_kind
= resume_stop
;
4151 current_thread
->last_status
= last_status
;
4156 if (!target_running ())
4158 /* The last process exited. We're done. */
4162 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4164 /* A thread stopped with a signal, but gdb isn't
4165 connected to handle it. Pass it down to the
4166 inferior, as if it wasn't being traced. */
4167 struct thread_resume resume_info
;
4170 debug_printf ("GDB not connected; forwarding event %d for"
4172 (int) last_status
.kind
,
4173 target_pid_to_str (last_ptid
));
4175 resume_info
.thread
= last_ptid
;
4176 resume_info
.kind
= resume_continue
;
4177 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4178 (*the_target
->resume
) (&resume_info
, 1);
4180 else if (debug_threads
)
4181 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4182 (int) last_status
.kind
,
4183 target_pid_to_str (last_ptid
));
4187 struct vstop_notif
*vstop_notif
4188 = xmalloc (sizeof (struct vstop_notif
));
4190 vstop_notif
->status
= last_status
;
4191 vstop_notif
->ptid
= last_ptid
;
4192 /* Push Stop notification. */
4193 notif_push (¬if_stop
,
4194 (struct notif_event
*) vstop_notif
);
4198 /* Be sure to not change the selected thread behind GDB's back.
4199 Important in the non-stop mode asynchronous protocol. */
4200 set_desired_thread (1);