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 annex
= alloca (strlen (const_annex
) + 1);
1157 strcpy (annex
, const_annex
);
1158 annex
= unpack_varlen_hex (annex
, &pid
);
1159 if (annex
[0] != '\0' || pid
== 0)
1162 file
= (*the_target
->pid_to_exec_file
) (pid
);
1166 total_len
= strlen (file
);
1168 if (offset
> total_len
)
1171 if (offset
+ len
> total_len
)
1172 len
= total_len
- offset
;
1174 memcpy (readbuf
, file
+ offset
, len
);
1178 /* Handle qXfer:features:read. */
1181 handle_qxfer_features (const char *annex
,
1182 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1183 ULONGEST offset
, LONGEST len
)
1185 const char *document
;
1188 if (writebuf
!= NULL
)
1191 if (!target_running ())
1194 /* Grab the correct annex. */
1195 document
= get_features_xml (annex
);
1196 if (document
== NULL
)
1199 total_len
= strlen (document
);
1201 if (offset
> total_len
)
1204 if (offset
+ len
> total_len
)
1205 len
= total_len
- offset
;
1207 memcpy (readbuf
, document
+ offset
, len
);
1211 /* Worker routine for handle_qxfer_libraries.
1212 Add to the length pointed to by ARG a conservative estimate of the
1213 length needed to transmit the file name of INF. */
1216 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1218 struct dll_info
*dll
= (struct dll_info
*) inf
;
1219 unsigned int *total_len
= arg
;
1221 /* Over-estimate the necessary memory. Assume that every character
1222 in the library name must be escaped. */
1223 *total_len
+= 128 + 6 * strlen (dll
->name
);
1226 /* Worker routine for handle_qxfer_libraries.
1227 Emit the XML to describe the library in INF. */
1230 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1232 struct dll_info
*dll
= (struct dll_info
*) inf
;
1237 strcpy (p
, " <library name=\"");
1239 name
= xml_escape_text (dll
->name
);
1243 strcpy (p
, "\"><segment address=\"");
1245 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1247 strcpy (p
, "\"/></library>\n");
1253 /* Handle qXfer:libraries:read. */
1256 handle_qxfer_libraries (const char *annex
,
1257 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1258 ULONGEST offset
, LONGEST len
)
1260 unsigned int total_len
;
1263 if (writebuf
!= NULL
)
1266 if (annex
[0] != '\0' || !target_running ())
1270 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1273 document
= malloc (total_len
);
1274 if (document
== NULL
)
1277 strcpy (document
, "<library-list>\n");
1278 p
= document
+ strlen (document
);
1280 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1282 strcpy (p
, "</library-list>\n");
1284 total_len
= strlen (document
);
1286 if (offset
> total_len
)
1292 if (offset
+ len
> total_len
)
1293 len
= total_len
- offset
;
1295 memcpy (readbuf
, document
+ offset
, len
);
1300 /* Handle qXfer:libraries-svr4:read. */
1303 handle_qxfer_libraries_svr4 (const char *annex
,
1304 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1305 ULONGEST offset
, LONGEST len
)
1307 if (writebuf
!= NULL
)
1310 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1313 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1316 /* Handle qXfer:osadata:read. */
1319 handle_qxfer_osdata (const char *annex
,
1320 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1321 ULONGEST offset
, LONGEST len
)
1323 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1326 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1329 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1332 handle_qxfer_siginfo (const char *annex
,
1333 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1334 ULONGEST offset
, LONGEST len
)
1336 if (the_target
->qxfer_siginfo
== NULL
)
1339 if (annex
[0] != '\0' || !target_running ())
1342 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1345 /* Handle qXfer:spu:read and qXfer:spu:write. */
1348 handle_qxfer_spu (const char *annex
,
1349 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1350 ULONGEST offset
, LONGEST len
)
1352 if (the_target
->qxfer_spu
== NULL
)
1355 if (!target_running ())
1358 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1361 /* Handle qXfer:statictrace:read. */
1364 handle_qxfer_statictrace (const char *annex
,
1365 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1366 ULONGEST offset
, LONGEST len
)
1370 if (writebuf
!= NULL
)
1373 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1376 if (traceframe_read_sdata (current_traceframe
, offset
,
1377 readbuf
, len
, &nbytes
))
1382 /* Helper for handle_qxfer_threads_proper.
1383 Emit the XML to describe the thread of INF. */
1386 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1388 struct thread_info
*thread
= (struct thread_info
*) inf
;
1389 struct buffer
*buffer
= arg
;
1390 ptid_t ptid
= thread_to_gdb_id (thread
);
1392 int core
= target_core_of_thread (ptid
);
1395 write_ptid (ptid_s
, ptid
);
1399 sprintf (core_s
, "%d", core
);
1400 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1405 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1410 /* Helper for handle_qxfer_threads. */
1413 handle_qxfer_threads_proper (struct buffer
*buffer
)
1415 buffer_grow_str (buffer
, "<threads>\n");
1417 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1420 buffer_grow_str0 (buffer
, "</threads>\n");
1423 /* Handle qXfer:threads:read. */
1426 handle_qxfer_threads (const char *annex
,
1427 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1428 ULONGEST offset
, LONGEST len
)
1430 static char *result
= 0;
1431 static unsigned int result_length
= 0;
1433 if (writebuf
!= NULL
)
1436 if (!target_running () || annex
[0] != '\0')
1441 struct buffer buffer
;
1442 /* When asked for data at offset 0, generate everything and store into
1443 'result'. Successive reads will be served off 'result'. */
1447 buffer_init (&buffer
);
1449 handle_qxfer_threads_proper (&buffer
);
1451 result
= buffer_finish (&buffer
);
1452 result_length
= strlen (result
);
1453 buffer_free (&buffer
);
1456 if (offset
>= result_length
)
1458 /* We're out of data. */
1465 if (len
> result_length
- offset
)
1466 len
= result_length
- offset
;
1468 memcpy (readbuf
, result
+ offset
, len
);
1473 /* Handle qXfer:traceframe-info:read. */
1476 handle_qxfer_traceframe_info (const char *annex
,
1477 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1478 ULONGEST offset
, LONGEST len
)
1480 static char *result
= 0;
1481 static unsigned int result_length
= 0;
1483 if (writebuf
!= NULL
)
1486 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1491 struct buffer buffer
;
1493 /* When asked for data at offset 0, generate everything and
1494 store into 'result'. Successive reads will be served off
1498 buffer_init (&buffer
);
1500 traceframe_read_info (current_traceframe
, &buffer
);
1502 result
= buffer_finish (&buffer
);
1503 result_length
= strlen (result
);
1504 buffer_free (&buffer
);
1507 if (offset
>= result_length
)
1509 /* We're out of data. */
1516 if (len
> result_length
- offset
)
1517 len
= result_length
- offset
;
1519 memcpy (readbuf
, result
+ offset
, len
);
1523 /* Handle qXfer:fdpic:read. */
1526 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1527 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1529 if (the_target
->read_loadmap
== NULL
)
1532 if (!target_running ())
1535 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1538 /* Handle qXfer:btrace:read. */
1541 handle_qxfer_btrace (const char *annex
,
1542 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1543 ULONGEST offset
, LONGEST len
)
1545 static struct buffer cache
;
1546 struct thread_info
*thread
;
1549 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1552 if (!target_running ())
1555 if (ptid_equal (general_thread
, null_ptid
)
1556 || ptid_equal (general_thread
, minus_one_ptid
))
1558 strcpy (own_buf
, "E.Must select a single thread.");
1562 thread
= find_thread_ptid (general_thread
);
1565 strcpy (own_buf
, "E.No such thread.");
1569 if (thread
->btrace
== NULL
)
1571 strcpy (own_buf
, "E.Btrace not enabled.");
1575 if (strcmp (annex
, "all") == 0)
1576 type
= BTRACE_READ_ALL
;
1577 else if (strcmp (annex
, "new") == 0)
1578 type
= BTRACE_READ_NEW
;
1579 else if (strcmp (annex
, "delta") == 0)
1580 type
= BTRACE_READ_DELTA
;
1583 strcpy (own_buf
, "E.Bad annex.");
1589 buffer_free (&cache
);
1591 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1594 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1598 else if (offset
> cache
.used_size
)
1600 buffer_free (&cache
);
1604 if (len
> cache
.used_size
- offset
)
1605 len
= cache
.used_size
- offset
;
1607 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1612 /* Handle qXfer:btrace-conf:read. */
1615 handle_qxfer_btrace_conf (const char *annex
,
1616 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1617 ULONGEST offset
, LONGEST len
)
1619 static struct buffer cache
;
1620 struct thread_info
*thread
;
1623 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1626 if (annex
[0] != '\0' || !target_running ())
1629 if (ptid_equal (general_thread
, null_ptid
)
1630 || ptid_equal (general_thread
, minus_one_ptid
))
1632 strcpy (own_buf
, "E.Must select a single thread.");
1636 thread
= find_thread_ptid (general_thread
);
1639 strcpy (own_buf
, "E.No such thread.");
1643 if (thread
->btrace
== NULL
)
1645 strcpy (own_buf
, "E.Btrace not enabled.");
1651 buffer_free (&cache
);
1653 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1656 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1660 else if (offset
> cache
.used_size
)
1662 buffer_free (&cache
);
1666 if (len
> cache
.used_size
- offset
)
1667 len
= cache
.used_size
- offset
;
1669 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1674 static const struct qxfer qxfer_packets
[] =
1676 { "auxv", handle_qxfer_auxv
},
1677 { "btrace", handle_qxfer_btrace
},
1678 { "btrace-conf", handle_qxfer_btrace_conf
},
1679 { "exec-file", handle_qxfer_exec_file
},
1680 { "fdpic", handle_qxfer_fdpic
},
1681 { "features", handle_qxfer_features
},
1682 { "libraries", handle_qxfer_libraries
},
1683 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1684 { "osdata", handle_qxfer_osdata
},
1685 { "siginfo", handle_qxfer_siginfo
},
1686 { "spu", handle_qxfer_spu
},
1687 { "statictrace", handle_qxfer_statictrace
},
1688 { "threads", handle_qxfer_threads
},
1689 { "traceframe-info", handle_qxfer_traceframe_info
},
1693 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1701 if (!startswith (own_buf
, "qXfer:"))
1704 /* Grab the object, r/w and annex. */
1705 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1707 write_enn (own_buf
);
1712 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1715 const struct qxfer
*q
= &qxfer_packets
[i
];
1717 if (strcmp (object
, q
->object
) == 0)
1719 if (strcmp (rw
, "read") == 0)
1721 unsigned char *data
;
1726 /* Grab the offset and length. */
1727 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1729 write_enn (own_buf
);
1733 /* Read one extra byte, as an indicator of whether there is
1735 if (len
> PBUFSIZ
- 2)
1737 data
= malloc (len
+ 1);
1740 write_enn (own_buf
);
1743 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1751 /* Preserve error message. */
1754 write_enn (own_buf
);
1756 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1758 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1763 else if (strcmp (rw
, "write") == 0)
1768 unsigned char *data
;
1770 strcpy (own_buf
, "E00");
1771 data
= malloc (packet_len
- (offset
- own_buf
));
1774 write_enn (own_buf
);
1777 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1778 &ofs
, &len
, data
) < 0)
1781 write_enn (own_buf
);
1785 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1793 /* Preserve error message. */
1796 write_enn (own_buf
);
1798 sprintf (own_buf
, "%x", n
);
1811 /* Table used by the crc32 function to calcuate the checksum. */
1813 static unsigned int crc32_table
[256] =
1816 /* Compute 32 bit CRC from inferior memory.
1818 On success, return 32 bit CRC.
1819 On failure, return (unsigned long long) -1. */
1821 static unsigned long long
1822 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1824 if (!crc32_table
[1])
1826 /* Initialize the CRC table and the decoding table. */
1830 for (i
= 0; i
< 256; i
++)
1832 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1833 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1840 unsigned char byte
= 0;
1842 /* Return failure if memory read fails. */
1843 if (read_inferior_memory (base
, &byte
, 1) != 0)
1844 return (unsigned long long) -1;
1846 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1849 return (unsigned long long) crc
;
1852 /* Add supported btrace packets to BUF. */
1855 supported_btrace_packets (char *buf
)
1857 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1859 strcat (buf
, ";Qbtrace:bts+");
1860 strcat (buf
, ";Qbtrace-conf:bts:size+");
1865 strcat (buf
, ";Qbtrace:off+");
1866 strcat (buf
, ";qXfer:btrace:read+");
1867 strcat (buf
, ";qXfer:btrace-conf:read+");
1870 /* Handle all of the extended 'q' packets. */
1873 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1875 static struct inferior_list_entry
*thread_ptr
;
1877 /* Reply the current thread id. */
1878 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1881 require_running (own_buf
);
1883 if (!ptid_equal (general_thread
, null_ptid
)
1884 && !ptid_equal (general_thread
, minus_one_ptid
))
1885 gdb_id
= general_thread
;
1888 thread_ptr
= get_first_inferior (&all_threads
);
1889 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1892 sprintf (own_buf
, "QC");
1894 write_ptid (own_buf
, gdb_id
);
1898 if (strcmp ("qSymbol::", own_buf
) == 0)
1900 /* GDB is suggesting new symbols have been loaded. This may
1901 mean a new shared library has been detected as loaded, so
1902 take the opportunity to check if breakpoints we think are
1903 inserted, still are. Note that it isn't guaranteed that
1904 we'll see this when a shared library is loaded, and nor will
1905 we see this for unloads (although breakpoints in unloaded
1906 libraries shouldn't trigger), as GDB may not find symbols for
1907 the library at all. We also re-validate breakpoints when we
1908 see a second GDB breakpoint for the same address, and or when
1909 we access breakpoint shadows. */
1910 validate_breakpoints ();
1912 if (target_supports_tracepoints ())
1913 tracepoint_look_up_symbols ();
1915 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1916 (*the_target
->look_up_symbols
) ();
1918 strcpy (own_buf
, "OK");
1922 if (!disable_packet_qfThreadInfo
)
1924 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1928 require_running (own_buf
);
1929 thread_ptr
= get_first_inferior (&all_threads
);
1932 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1933 write_ptid (own_buf
, gdb_id
);
1934 thread_ptr
= thread_ptr
->next
;
1938 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1942 require_running (own_buf
);
1943 if (thread_ptr
!= NULL
)
1946 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1947 write_ptid (own_buf
, gdb_id
);
1948 thread_ptr
= thread_ptr
->next
;
1953 sprintf (own_buf
, "l");
1959 if (the_target
->read_offsets
!= NULL
1960 && strcmp ("qOffsets", own_buf
) == 0)
1962 CORE_ADDR text
, data
;
1964 require_running (own_buf
);
1965 if (the_target
->read_offsets (&text
, &data
))
1966 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1967 (long)text
, (long)data
, (long)data
);
1969 write_enn (own_buf
);
1974 /* Protocol features query. */
1975 if (startswith (own_buf
, "qSupported")
1976 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1978 char *p
= &own_buf
[10];
1979 int gdb_supports_qRelocInsn
= 0;
1981 /* Start processing qSupported packet. */
1982 target_process_qsupported (NULL
);
1984 /* Process each feature being provided by GDB. The first
1985 feature will follow a ':', and latter features will follow
1989 char **qsupported
= NULL
;
1993 /* Two passes, to avoid nested strtok calls in
1994 target_process_qsupported. */
1995 for (p
= strtok (p
+ 1, ";");
1997 p
= strtok (NULL
, ";"))
2000 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
2001 qsupported
[count
- 1] = xstrdup (p
);
2004 for (i
= 0; i
< count
; i
++)
2007 if (strcmp (p
, "multiprocess+") == 0)
2009 /* GDB supports and wants multi-process support if
2011 if (target_supports_multi_process ())
2014 else if (strcmp (p
, "qRelocInsn+") == 0)
2016 /* GDB supports relocate instruction requests. */
2017 gdb_supports_qRelocInsn
= 1;
2019 else if (strcmp (p
, "swbreak+") == 0)
2021 /* GDB wants us to report whether a trap is caused
2022 by a software breakpoint and for us to handle PC
2023 adjustment if necessary on this target. */
2024 if (target_supports_stopped_by_sw_breakpoint ())
2025 swbreak_feature
= 1;
2027 else if (strcmp (p
, "hwbreak+") == 0)
2029 /* GDB wants us to report whether a trap is caused
2030 by a hardware breakpoint. */
2031 if (target_supports_stopped_by_hw_breakpoint ())
2032 hwbreak_feature
= 1;
2035 target_process_qsupported (p
);
2044 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2047 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2048 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2049 ";augmented-libraries-svr4-read+");
2052 /* We do not have any hook to indicate whether the non-SVR4 target
2053 backend supports qXfer:libraries:read, so always report it. */
2054 strcat (own_buf
, ";qXfer:libraries:read+");
2057 if (the_target
->read_auxv
!= NULL
)
2058 strcat (own_buf
, ";qXfer:auxv:read+");
2060 if (the_target
->qxfer_spu
!= NULL
)
2061 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2063 if (the_target
->qxfer_siginfo
!= NULL
)
2064 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2066 if (the_target
->read_loadmap
!= NULL
)
2067 strcat (own_buf
, ";qXfer:fdpic:read+");
2069 /* We always report qXfer:features:read, as targets may
2070 install XML files on a subsequent call to arch_setup.
2071 If we reported to GDB on startup that we don't support
2072 qXfer:feature:read at all, we will never be re-queried. */
2073 strcat (own_buf
, ";qXfer:features:read+");
2075 if (transport_is_reliable
)
2076 strcat (own_buf
, ";QStartNoAckMode+");
2078 if (the_target
->qxfer_osdata
!= NULL
)
2079 strcat (own_buf
, ";qXfer:osdata:read+");
2081 if (target_supports_multi_process ())
2082 strcat (own_buf
, ";multiprocess+");
2084 if (target_supports_non_stop ())
2085 strcat (own_buf
, ";QNonStop+");
2087 if (target_supports_disable_randomization ())
2088 strcat (own_buf
, ";QDisableRandomization+");
2090 strcat (own_buf
, ";qXfer:threads:read+");
2092 if (target_supports_tracepoints ())
2094 strcat (own_buf
, ";ConditionalTracepoints+");
2095 strcat (own_buf
, ";TraceStateVariables+");
2096 strcat (own_buf
, ";TracepointSource+");
2097 strcat (own_buf
, ";DisconnectedTracing+");
2098 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2099 strcat (own_buf
, ";FastTracepoints+");
2100 strcat (own_buf
, ";StaticTracepoints+");
2101 strcat (own_buf
, ";InstallInTrace+");
2102 strcat (own_buf
, ";qXfer:statictrace:read+");
2103 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2104 strcat (own_buf
, ";EnableDisableTracepoints+");
2105 strcat (own_buf
, ";QTBuffer:size+");
2106 strcat (own_buf
, ";tracenz+");
2109 /* Support target-side breakpoint conditions and commands. */
2110 if (target_supports_conditional_breakpoints ())
2111 strcat (own_buf
, ";ConditionalBreakpoints+");
2112 strcat (own_buf
, ";BreakpointCommands+");
2114 if (target_supports_agent ())
2115 strcat (own_buf
, ";QAgent+");
2117 supported_btrace_packets (own_buf
);
2119 if (target_supports_stopped_by_sw_breakpoint ())
2120 strcat (own_buf
, ";swbreak+");
2122 if (target_supports_stopped_by_hw_breakpoint ())
2123 strcat (own_buf
, ";hwbreak+");
2125 if (the_target
->pid_to_exec_file
!= NULL
)
2126 strcat (own_buf
, ";qXfer:exec-file:read+");
2131 /* Thread-local storage support. */
2132 if (the_target
->get_tls_address
!= NULL
2133 && startswith (own_buf
, "qGetTLSAddr:"))
2135 char *p
= own_buf
+ 12;
2136 CORE_ADDR parts
[2], address
= 0;
2138 ptid_t ptid
= null_ptid
;
2140 require_running (own_buf
);
2142 for (i
= 0; i
< 3; i
++)
2150 p2
= strchr (p
, ',');
2163 ptid
= read_ptid (p
, NULL
);
2165 decode_address (&parts
[i
- 1], p
, len
);
2169 if (p
!= NULL
|| i
< 3)
2173 struct thread_info
*thread
= find_thread_ptid (ptid
);
2178 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2184 strcpy (own_buf
, paddress(address
));
2189 write_enn (own_buf
);
2193 /* Otherwise, pretend we do not understand this packet. */
2196 /* Windows OS Thread Information Block address support. */
2197 if (the_target
->get_tib_address
!= NULL
2198 && startswith (own_buf
, "qGetTIBAddr:"))
2203 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2205 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2208 strcpy (own_buf
, paddress(tlb
));
2213 write_enn (own_buf
);
2219 /* Handle "monitor" commands. */
2220 if (startswith (own_buf
, "qRcmd,"))
2222 char *mon
= malloc (PBUFSIZ
);
2223 int len
= strlen (own_buf
+ 6);
2227 write_enn (own_buf
);
2232 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2234 write_enn (own_buf
);
2238 mon
[len
/ 2] = '\0';
2242 if (the_target
->handle_monitor_command
== NULL
2243 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2244 /* Default processing. */
2245 handle_monitor_command (mon
, own_buf
);
2251 if (startswith (own_buf
, "qSearch:memory:"))
2253 require_running (own_buf
);
2254 handle_search_memory (own_buf
, packet_len
);
2258 if (strcmp (own_buf
, "qAttached") == 0
2259 || startswith (own_buf
, "qAttached:"))
2261 struct process_info
*process
;
2263 if (own_buf
[sizeof ("qAttached") - 1])
2265 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2266 process
= (struct process_info
*)
2267 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2271 require_running (own_buf
);
2272 process
= current_process ();
2275 if (process
== NULL
)
2277 write_enn (own_buf
);
2281 strcpy (own_buf
, process
->attached
? "1" : "0");
2285 if (startswith (own_buf
, "qCRC:"))
2287 /* CRC check (compare-section). */
2291 unsigned long long crc
;
2293 require_running (own_buf
);
2294 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2295 if (*comma
++ != ',')
2297 write_enn (own_buf
);
2300 len
= strtoul (comma
, NULL
, 16);
2301 crc
= crc32 (base
, len
, 0xffffffff);
2302 /* Check for memory failure. */
2303 if (crc
== (unsigned long long) -1)
2305 write_enn (own_buf
);
2308 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2312 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2315 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2318 /* Otherwise we didn't know what packet it was. Say we didn't
2323 static void gdb_wants_all_threads_stopped (void);
2324 static void resume (struct thread_resume
*actions
, size_t n
);
2326 /* The callback that is passed to visit_actioned_threads. */
2327 typedef int (visit_actioned_threads_callback_ftype
)
2328 (const struct thread_resume
*, struct thread_info
*);
2330 /* Struct to pass data to visit_actioned_threads. */
2332 struct visit_actioned_threads_data
2334 const struct thread_resume
*actions
;
2336 visit_actioned_threads_callback_ftype
*callback
;
2339 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2340 true if CALLBACK returns true. Returns false if no matching thread
2341 is found or CALLBACK results false.
2342 Note: This function is itself a callback for find_inferior. */
2345 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2347 struct visit_actioned_threads_data
*data
= datap
;
2348 const struct thread_resume
*actions
= data
->actions
;
2349 size_t num_actions
= data
->num_actions
;
2350 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2353 for (i
= 0; i
< num_actions
; i
++)
2355 const struct thread_resume
*action
= &actions
[i
];
2357 if (ptid_equal (action
->thread
, minus_one_ptid
)
2358 || ptid_equal (action
->thread
, entry
->id
)
2359 || ((ptid_get_pid (action
->thread
)
2360 == ptid_get_pid (entry
->id
))
2361 && ptid_get_lwp (action
->thread
) == -1))
2363 struct thread_info
*thread
= (struct thread_info
*) entry
;
2365 if ((*callback
) (action
, thread
))
2373 /* Callback for visit_actioned_threads. If the thread has a pending
2374 status to report, report it now. */
2377 handle_pending_status (const struct thread_resume
*resumption
,
2378 struct thread_info
*thread
)
2380 if (thread
->status_pending_p
)
2382 thread
->status_pending_p
= 0;
2384 last_status
= thread
->last_status
;
2385 last_ptid
= thread
->entry
.id
;
2386 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2392 /* Parse vCont packets. */
2394 handle_v_cont (char *own_buf
)
2398 struct thread_resume
*resume_info
;
2399 struct thread_resume default_action
= {{0}};
2401 /* Count the number of semicolons in the packet. There should be one
2402 for every action. */
2408 p
= strchr (p
, ';');
2411 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2412 if (resume_info
== NULL
)
2420 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2422 if (p
[0] == 's' || p
[0] == 'S')
2423 resume_info
[i
].kind
= resume_step
;
2424 else if (p
[0] == 'r')
2425 resume_info
[i
].kind
= resume_step
;
2426 else if (p
[0] == 'c' || p
[0] == 'C')
2427 resume_info
[i
].kind
= resume_continue
;
2428 else if (p
[0] == 't')
2429 resume_info
[i
].kind
= resume_stop
;
2433 if (p
[0] == 'S' || p
[0] == 'C')
2436 sig
= strtol (p
+ 1, &q
, 16);
2441 if (!gdb_signal_to_host_p (sig
))
2443 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2445 else if (p
[0] == 'r')
2449 p
= unpack_varlen_hex (p
+ 1, &addr
);
2450 resume_info
[i
].step_range_start
= addr
;
2455 p
= unpack_varlen_hex (p
+ 1, &addr
);
2456 resume_info
[i
].step_range_end
= addr
;
2465 resume_info
[i
].thread
= minus_one_ptid
;
2466 default_action
= resume_info
[i
];
2468 /* Note: we don't increment i here, we'll overwrite this entry
2469 the next time through. */
2471 else if (p
[0] == ':')
2473 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2478 if (p
[0] != ';' && p
[0] != 0)
2481 resume_info
[i
].thread
= ptid
;
2488 resume_info
[i
] = default_action
;
2490 set_desired_thread (0);
2492 resume (resume_info
, n
);
2497 write_enn (own_buf
);
2502 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2505 resume (struct thread_resume
*actions
, size_t num_actions
)
2509 /* Check if among the threads that GDB wants actioned, there's
2510 one with a pending status to report. If so, skip actually
2511 resuming/stopping and report the pending event
2513 struct visit_actioned_threads_data data
;
2515 data
.actions
= actions
;
2516 data
.num_actions
= num_actions
;
2517 data
.callback
= handle_pending_status
;
2518 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2524 (*the_target
->resume
) (actions
, num_actions
);
2530 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2532 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2534 /* No proper RSP support for this yet. At least return
2536 sprintf (own_buf
, "E.No unwaited-for children left.");
2537 disable_async_io ();
2541 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2542 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2543 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2544 current_thread
->last_status
= last_status
;
2546 /* From the client's perspective, all-stop mode always stops all
2547 threads implicitly (and the target backend has already done
2548 so by now). Tag all threads as "want-stopped", so we don't
2549 resume them implicitly without the client telling us to. */
2550 gdb_wants_all_threads_stopped ();
2551 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2552 disable_async_io ();
2554 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2555 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2556 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2560 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2562 handle_v_attach (char *own_buf
)
2566 pid
= strtol (own_buf
+ 8, NULL
, 16);
2567 if (pid
!= 0 && attach_inferior (pid
) == 0)
2569 /* Don't report shared library events after attaching, even if
2570 some libraries are preloaded. GDB will always poll the
2571 library list. Avoids the "stopped by shared library event"
2572 notice on the GDB side. */
2577 /* In non-stop, we don't send a resume reply. Stop events
2578 will follow up using the normal notification
2583 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2589 write_enn (own_buf
);
2594 /* Run a new program. Return 1 if successful, 0 if failure. */
2596 handle_v_run (char *own_buf
)
2598 char *p
, *next_p
, **new_argv
;
2602 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2608 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2609 if (new_argv
== NULL
)
2611 write_enn (own_buf
);
2616 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2618 next_p
= strchr (p
, ';');
2620 next_p
= p
+ strlen (p
);
2622 if (i
== 0 && p
== next_p
)
2626 /* FIXME: Fail request if out of memory instead of dying. */
2627 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2628 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2629 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2638 if (new_argv
[0] == NULL
)
2640 /* GDB didn't specify a program to run. Use the program from the
2641 last run with the new argument list. */
2643 if (program_argv
== NULL
)
2645 write_enn (own_buf
);
2646 freeargv (new_argv
);
2650 new_argv
[0] = strdup (program_argv
[0]);
2651 if (new_argv
[0] == NULL
)
2653 write_enn (own_buf
);
2654 freeargv (new_argv
);
2659 /* Free the old argv and install the new one. */
2660 freeargv (program_argv
);
2661 program_argv
= new_argv
;
2663 start_inferior (program_argv
);
2664 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2666 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2668 /* In non-stop, sending a resume reply doesn't set the general
2669 thread, but GDB assumes a vRun sets it (this is so GDB can
2670 query which is the main thread of the new inferior. */
2672 general_thread
= last_ptid
;
2678 write_enn (own_buf
);
2683 /* Kill process. Return 1 if successful, 0 if failure. */
2685 handle_v_kill (char *own_buf
)
2688 char *p
= &own_buf
[6];
2690 pid
= strtol (p
, NULL
, 16);
2693 if (pid
!= 0 && kill_inferior (pid
) == 0)
2695 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2696 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2697 last_ptid
= pid_to_ptid (pid
);
2698 discard_queued_stop_replies (pid
);
2704 write_enn (own_buf
);
2709 /* Handle all of the extended 'v' packets. */
2711 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2713 if (!disable_packet_vCont
)
2715 if (startswith (own_buf
, "vCont;"))
2717 require_running (own_buf
);
2718 handle_v_cont (own_buf
);
2722 if (startswith (own_buf
, "vCont?"))
2724 strcpy (own_buf
, "vCont;c;C;s;S;t");
2725 if (target_supports_range_stepping ())
2727 own_buf
= own_buf
+ strlen (own_buf
);
2728 strcpy (own_buf
, ";r");
2734 if (startswith (own_buf
, "vFile:")
2735 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2738 if (startswith (own_buf
, "vAttach;"))
2740 if ((!extended_protocol
|| !multi_process
) && target_running ())
2742 fprintf (stderr
, "Already debugging a process\n");
2743 write_enn (own_buf
);
2746 handle_v_attach (own_buf
);
2750 if (startswith (own_buf
, "vRun;"))
2752 if ((!extended_protocol
|| !multi_process
) && target_running ())
2754 fprintf (stderr
, "Already debugging a process\n");
2755 write_enn (own_buf
);
2758 handle_v_run (own_buf
);
2762 if (startswith (own_buf
, "vKill;"))
2764 if (!target_running ())
2766 fprintf (stderr
, "No process to kill\n");
2767 write_enn (own_buf
);
2770 handle_v_kill (own_buf
);
2774 if (handle_notif_ack (own_buf
, packet_len
))
2777 /* Otherwise we didn't know what packet it was. Say we didn't
2783 /* Resume thread and wait for another event. In non-stop mode,
2784 don't really wait here, but return immediatelly to the event
2787 myresume (char *own_buf
, int step
, int sig
)
2789 struct thread_resume resume_info
[2];
2791 int valid_cont_thread
;
2793 set_desired_thread (0);
2795 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2796 && !ptid_equal (cont_thread
, minus_one_ptid
));
2798 if (step
|| sig
|| valid_cont_thread
)
2800 resume_info
[0].thread
= current_ptid
;
2802 resume_info
[0].kind
= resume_step
;
2804 resume_info
[0].kind
= resume_continue
;
2805 resume_info
[0].sig
= sig
;
2809 if (!valid_cont_thread
)
2811 resume_info
[n
].thread
= minus_one_ptid
;
2812 resume_info
[n
].kind
= resume_continue
;
2813 resume_info
[n
].sig
= 0;
2817 resume (resume_info
, n
);
2820 /* Callback for for_each_inferior. Make a new stop reply for each
2824 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2826 struct thread_info
*thread
= (struct thread_info
*) entry
;
2828 /* For now, assume targets that don't have this callback also don't
2829 manage the thread's last_status field. */
2830 if (the_target
->thread_stopped
== NULL
)
2832 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2834 new_notif
->ptid
= entry
->id
;
2835 new_notif
->status
= thread
->last_status
;
2836 /* Pass the last stop reply back to GDB, but don't notify
2838 notif_event_enque (¬if_stop
,
2839 (struct notif_event
*) new_notif
);
2843 if (thread_stopped (thread
))
2848 = target_waitstatus_to_string (&thread
->last_status
);
2850 debug_printf ("Reporting thread %s as already stopped with %s\n",
2851 target_pid_to_str (entry
->id
),
2854 xfree (status_string
);
2857 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2859 /* Pass the last stop reply back to GDB, but don't notify
2861 queue_stop_reply (entry
->id
, &thread
->last_status
);
2868 /* Set this inferior threads's state as "want-stopped". We won't
2869 resume this thread until the client gives us another action for
2873 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2875 struct thread_info
*thread
= (struct thread_info
*) entry
;
2877 thread
->last_resume_kind
= resume_stop
;
2879 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2881 /* Most threads are stopped implicitly (all-stop); tag that with
2883 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2884 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2888 /* Set all threads' states as "want-stopped". */
2891 gdb_wants_all_threads_stopped (void)
2893 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2896 /* Clear the gdb_detached flag of every process. */
2899 gdb_reattached_process (struct inferior_list_entry
*entry
)
2901 struct process_info
*process
= (struct process_info
*) entry
;
2903 process
->gdb_detached
= 0;
2906 /* Callback for for_each_inferior. Clear the thread's pending status
2910 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2912 struct thread_info
*thread
= (struct thread_info
*) entry
;
2914 thread
->status_pending_p
= 0;
2917 /* Callback for for_each_inferior. If the thread is stopped with an
2918 interesting event, mark it as having a pending event. */
2921 set_pending_status_callback (struct inferior_list_entry
*entry
)
2923 struct thread_info
*thread
= (struct thread_info
*) entry
;
2925 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
2926 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
2927 /* A breakpoint, watchpoint or finished step from a previous
2928 GDB run isn't considered interesting for a new GDB run.
2929 If we left those pending, the new GDB could consider them
2930 random SIGTRAPs. This leaves out real async traps. We'd
2931 have to peek into the (target-specific) siginfo to
2932 distinguish those. */
2933 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
2934 thread
->status_pending_p
= 1;
2937 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
2938 pending status to report to GDB. */
2941 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
2943 struct thread_info
*thread
= (struct thread_info
*) entry
;
2945 return thread
->status_pending_p
;
2948 /* Status handler for the '?' packet. */
2951 handle_status (char *own_buf
)
2953 /* GDB is connected, don't forward events to the target anymore. */
2954 for_each_inferior (&all_processes
, gdb_reattached_process
);
2956 /* In non-stop mode, we must send a stop reply for each stopped
2957 thread. In all-stop mode, just send one for the first stopped
2962 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2964 /* The first is sent immediatly. OK is sent if there is no
2965 stopped thread, which is the same handling of the vStopped
2966 packet (by design). */
2967 notif_write_event (¬if_stop
, own_buf
);
2971 struct inferior_list_entry
*thread
= NULL
;
2974 stabilize_threads ();
2975 gdb_wants_all_threads_stopped ();
2977 /* We can only report one status, but we might be coming out of
2978 non-stop -- if more than one thread is stopped with
2979 interesting events, leave events for the threads we're not
2980 reporting now pending. They'll be reported the next time the
2981 threads are resumed. Start by marking all interesting events
2983 for_each_inferior (&all_threads
, set_pending_status_callback
);
2985 /* Prefer the last thread that reported an event to GDB (even if
2986 that was a GDB_SIGNAL_TRAP). */
2987 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
2988 && last_status
.kind
!= TARGET_WAITKIND_EXITED
2989 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2990 thread
= find_inferior_id (&all_threads
, last_ptid
);
2992 /* If the last event thread is not found for some reason, look
2993 for some other thread that might have an event to report. */
2995 thread
= find_inferior (&all_threads
,
2996 find_status_pending_thread_callback
, NULL
);
2998 /* If we're still out of luck, simply pick the first thread in
3001 thread
= get_first_inferior (&all_threads
);
3005 struct thread_info
*tp
= (struct thread_info
*) thread
;
3007 /* We're reporting this event, so it's no longer
3009 tp
->status_pending_p
= 0;
3011 /* GDB assumes the current thread is the thread we're
3012 reporting the status for. */
3013 general_thread
= thread
->id
;
3014 set_desired_thread (1);
3016 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3017 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3020 strcpy (own_buf
, "W00");
3025 gdbserver_version (void)
3027 printf ("GNU gdbserver %s%s\n"
3028 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3029 "gdbserver is free software, covered by the "
3030 "GNU General Public License.\n"
3031 "This gdbserver was configured as \"%s\"\n",
3032 PKGVERSION
, version
, host_name
);
3036 gdbserver_usage (FILE *stream
)
3038 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3039 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3040 "\tgdbserver [OPTIONS] --multi COMM\n"
3042 "COMM may either be a tty device (for serial debugging),\n"
3043 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3044 "stdin/stdout of gdbserver.\n"
3045 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3046 "PID is the process ID to attach to, when --attach is specified.\n"
3048 "Operating modes:\n"
3050 " --attach Attach to running process PID.\n"
3051 " --multi Start server without a specific program, and\n"
3052 " only quit when explicitly commanded.\n"
3053 " --once Exit after the first connection has closed.\n"
3054 " --help Print this message and then exit.\n"
3055 " --version Display version information and exit.\n"
3059 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3060 " --disable-randomization\n"
3061 " Run PROG with address space randomization disabled.\n"
3062 " --no-disable-randomization\n"
3063 " Don't disable address space randomization when\n"
3068 " --debug Enable general debugging output.\n"
3069 " --debug-format=opt1[,opt2,...]\n"
3070 " Specify extra content in debugging output.\n"
3075 " --remote-debug Enable remote protocol debugging output.\n"
3076 " --disable-packet=opt1[,opt2,...]\n"
3077 " Disable support for RSP packets or features.\n"
3079 " vCont, Tthread, qC, qfThreadInfo and \n"
3080 " threads (disable all threading packets).\n"
3082 "For more information, consult the GDB manual (available as on-line \n"
3083 "info or a printed manual).\n");
3084 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3085 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3089 gdbserver_show_disableable (FILE *stream
)
3091 fprintf (stream
, "Disableable packets:\n"
3092 " vCont \tAll vCont packets\n"
3093 " qC \tQuerying the current thread\n"
3094 " qfThreadInfo\tThread listing\n"
3095 " Tthread \tPassing the thread specifier in the "
3096 "T stop reply packet\n"
3097 " threads \tAll of the above\n");
3101 #undef require_running
3102 #define require_running(BUF) \
3103 if (!target_running ()) \
3110 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3112 int pid
= * (int *) args
;
3114 if (ptid_get_pid (entry
->id
) == pid
)
3121 kill_inferior_callback (struct inferior_list_entry
*entry
)
3123 struct process_info
*process
= (struct process_info
*) entry
;
3124 int pid
= ptid_get_pid (process
->entry
.id
);
3126 kill_inferior (pid
);
3127 discard_queued_stop_replies (pid
);
3130 /* Callback for for_each_inferior to detach or kill the inferior,
3131 depending on whether we attached to it or not.
3132 We inform the user whether we're detaching or killing the process
3133 as this is only called when gdbserver is about to exit. */
3136 detach_or_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 if (process
->attached
)
3142 detach_inferior (pid
);
3144 kill_inferior (pid
);
3146 discard_queued_stop_replies (pid
);
3149 /* for_each_inferior callback for detach_or_kill_for_exit to print
3150 the pids of started inferiors. */
3153 print_started_pid (struct inferior_list_entry
*entry
)
3155 struct process_info
*process
= (struct process_info
*) entry
;
3157 if (! process
->attached
)
3159 int pid
= ptid_get_pid (process
->entry
.id
);
3160 fprintf (stderr
, " %d", pid
);
3164 /* for_each_inferior callback for detach_or_kill_for_exit to print
3165 the pids of attached inferiors. */
3168 print_attached_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 /* Call this when exiting gdbserver with possible inferiors that need
3180 to be killed or detached from. */
3183 detach_or_kill_for_exit (void)
3185 /* First print a list of the inferiors we will be killing/detaching.
3186 This is to assist the user, for example, in case the inferior unexpectedly
3187 dies after we exit: did we screw up or did the inferior exit on its own?
3188 Having this info will save some head-scratching. */
3190 if (have_started_inferiors_p ())
3192 fprintf (stderr
, "Killing process(es):");
3193 for_each_inferior (&all_processes
, print_started_pid
);
3194 fprintf (stderr
, "\n");
3196 if (have_attached_inferiors_p ())
3198 fprintf (stderr
, "Detaching process(es):");
3199 for_each_inferior (&all_processes
, print_attached_pid
);
3200 fprintf (stderr
, "\n");
3203 /* Now we can kill or detach the inferiors. */
3205 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3208 /* Value that will be passed to exit(3) when gdbserver exits. */
3209 static int exit_code
;
3211 /* Cleanup version of detach_or_kill_for_exit. */
3214 detach_or_kill_for_exit_cleanup (void *ignore
)
3219 detach_or_kill_for_exit ();
3222 CATCH (exception
, RETURN_MASK_ALL
)
3225 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3231 /* Main function. This is called by the real "main" function,
3232 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3234 static void ATTRIBUTE_NORETURN
3235 captured_main (int argc
, char *argv
[])
3239 char *arg_end
, *port
;
3240 char **next_arg
= &argv
[1];
3241 volatile int multi_mode
= 0;
3242 volatile int attach
= 0;
3245 while (*next_arg
!= NULL
&& **next_arg
== '-')
3247 if (strcmp (*next_arg
, "--version") == 0)
3249 gdbserver_version ();
3252 else if (strcmp (*next_arg
, "--help") == 0)
3254 gdbserver_usage (stdout
);
3257 else if (strcmp (*next_arg
, "--attach") == 0)
3259 else if (strcmp (*next_arg
, "--multi") == 0)
3261 else if (strcmp (*next_arg
, "--wrapper") == 0)
3265 wrapper_argv
= next_arg
;
3266 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3269 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3271 gdbserver_usage (stderr
);
3275 /* Consume the "--". */
3278 else if (strcmp (*next_arg
, "--debug") == 0)
3280 else if (startswith (*next_arg
, "--debug-format="))
3283 = parse_debug_format_options ((*next_arg
)
3284 + sizeof ("--debug-format=") - 1, 0);
3286 if (error_msg
!= NULL
)
3288 fprintf (stderr
, "%s", error_msg
);
3292 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3294 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3296 gdbserver_show_disableable (stdout
);
3299 else if (startswith (*next_arg
, "--disable-packet="))
3301 char *packets
, *tok
;
3303 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3304 for (tok
= strtok (packets
, ",");
3306 tok
= strtok (NULL
, ","))
3308 if (strcmp ("vCont", tok
) == 0)
3309 disable_packet_vCont
= 1;
3310 else if (strcmp ("Tthread", tok
) == 0)
3311 disable_packet_Tthread
= 1;
3312 else if (strcmp ("qC", tok
) == 0)
3313 disable_packet_qC
= 1;
3314 else if (strcmp ("qfThreadInfo", tok
) == 0)
3315 disable_packet_qfThreadInfo
= 1;
3316 else if (strcmp ("threads", tok
) == 0)
3318 disable_packet_vCont
= 1;
3319 disable_packet_Tthread
= 1;
3320 disable_packet_qC
= 1;
3321 disable_packet_qfThreadInfo
= 1;
3325 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3327 gdbserver_show_disableable (stderr
);
3332 else if (strcmp (*next_arg
, "-") == 0)
3334 /* "-" specifies a stdio connection and is a form of port
3336 *next_arg
= STDIO_CONNECTION_NAME
;
3339 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3340 disable_randomization
= 1;
3341 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3342 disable_randomization
= 0;
3343 else if (strcmp (*next_arg
, "--once") == 0)
3347 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3357 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3359 gdbserver_usage (stderr
);
3363 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3364 opened by remote_prepare. */
3367 /* We need to know whether the remote connection is stdio before
3368 starting the inferior. Inferiors created in this scenario have
3369 stdin,stdout redirected. So do this here before we call
3371 remote_prepare (port
);
3376 /* --attach used to come after PORT, so allow it there for
3378 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3385 && (*next_arg
== NULL
3386 || (*next_arg
)[0] == '\0'
3387 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3389 || next_arg
[1] != NULL
))
3394 gdbserver_usage (stderr
);
3398 initialize_async_io ();
3400 initialize_event_loop ();
3401 if (target_supports_tracepoints ())
3402 initialize_tracepoint ();
3404 own_buf
= xmalloc (PBUFSIZ
+ 1);
3405 mem_buf
= xmalloc (PBUFSIZ
);
3407 if (pid
== 0 && *next_arg
!= NULL
)
3411 n
= argc
- (next_arg
- argv
);
3412 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3413 for (i
= 0; i
< n
; i
++)
3414 program_argv
[i
] = xstrdup (next_arg
[i
]);
3415 program_argv
[i
] = NULL
;
3417 /* Wait till we are at first instruction in program. */
3418 start_inferior (program_argv
);
3420 /* We are now (hopefully) stopped at the first instruction of
3421 the target process. This assumes that the target process was
3422 successfully created. */
3426 if (attach_inferior (pid
) == -1)
3427 error ("Attaching not supported on this target");
3429 /* Otherwise succeeded. */
3433 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3434 last_status
.value
.integer
= 0;
3435 last_ptid
= minus_one_ptid
;
3437 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3439 initialize_notif ();
3441 /* Don't report shared library events on the initial connection,
3442 even if some libraries are preloaded. Avoids the "stopped by
3443 shared library event" notice on gdb side. */
3446 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3447 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3452 if (!was_running
&& !multi_mode
)
3453 error ("No program to debug");
3460 /* Be sure we're out of tfind mode. */
3461 current_traceframe
= -1;
3462 cont_thread
= null_ptid
;
3463 swbreak_feature
= 0;
3464 hwbreak_feature
= 0;
3470 /* Wait for events. This will return when all event sources
3471 are removed from the event loop. */
3472 start_event_loop ();
3474 /* If an exit was requested (using the "monitor exit"
3475 command), terminate now. The only other way to get
3476 here is for getpkt to fail; close the connection
3477 and reopen it at the top of the loop. */
3479 if (exit_requested
|| run_once
)
3480 throw_quit ("Quit");
3483 "Remote side has terminated connection. "
3484 "GDBserver will reopen the connection.\n");
3486 /* Get rid of any pending statuses. An eventual reconnection
3487 (by the same GDB instance or another) will refresh all its
3488 state from scratch. */
3489 discard_queued_stop_replies (-1);
3490 for_each_inferior (&all_threads
,
3491 clear_pending_status_callback
);
3495 if (disconnected_tracing
)
3497 /* Try to enable non-stop/async mode, so we we can
3498 both wait for an async socket accept, and handle
3499 async target events simultaneously. There's also
3500 no point either in having the target always stop
3501 all threads, when we're going to pass signals
3502 down without informing GDB. */
3505 if (start_non_stop (1))
3508 /* Detaching implicitly resumes all threads;
3509 simply disconnecting does not. */
3515 "Disconnected tracing disabled; "
3516 "stopping trace run.\n");
3521 CATCH (exception
, RETURN_MASK_ERROR
)
3523 if (response_needed
)
3525 write_enn (own_buf
);
3533 /* Main function. */
3536 main (int argc
, char *argv
[])
3541 captured_main (argc
, argv
);
3543 CATCH (exception
, RETURN_MASK_ALL
)
3545 if (exception
.reason
== RETURN_ERROR
)
3548 fprintf (stderr
, "%s\n", exception
.message
);
3549 fprintf (stderr
, "Exiting\n");
3557 gdb_assert_not_reached ("captured_main should never return");
3560 /* Skip PACKET until the next semi-colon (or end of string). */
3563 skip_to_semicolon (char **packet
)
3565 while (**packet
!= '\0' && **packet
!= ';')
3569 /* Process options coming from Z packets for a breakpoint. PACKET is
3570 the packet buffer. *PACKET is updated to point to the first char
3571 after the last processed option. */
3574 process_point_options (struct breakpoint
*bp
, char **packet
)
3576 char *dataptr
= *packet
;
3579 /* Check if data has the correct format. */
3580 if (*dataptr
!= ';')
3587 if (*dataptr
== ';')
3590 if (*dataptr
== 'X')
3592 /* Conditional expression. */
3594 debug_printf ("Found breakpoint condition.\n");
3595 if (!add_breakpoint_condition (bp
, &dataptr
))
3596 skip_to_semicolon (&dataptr
);
3598 else if (startswith (dataptr
, "cmds:"))
3600 dataptr
+= strlen ("cmds:");
3602 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3603 persist
= (*dataptr
== '1');
3605 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3606 skip_to_semicolon (&dataptr
);
3610 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3612 /* Skip tokens until we find one that we recognize. */
3613 skip_to_semicolon (&dataptr
);
3619 /* Event loop callback that handles a serial event. The first byte in
3620 the serial buffer gets us here. We expect characters to arrive at
3621 a brisk pace, so we read the rest of the packet with a blocking
3625 process_serial_event (void)
3636 int new_packet_len
= -1;
3638 /* Used to decide when gdbserver should exit in
3639 multi-mode/remote. */
3640 static int have_ran
= 0;
3643 have_ran
= target_running ();
3645 disable_async_io ();
3647 response_needed
= 0;
3648 packet_len
= getpkt (own_buf
);
3649 if (packet_len
<= 0)
3652 /* Force an event loop break. */
3655 response_needed
= 1;
3662 handle_query (own_buf
, packet_len
, &new_packet_len
);
3665 handle_general_set (own_buf
);
3668 require_running (own_buf
);
3673 pid
= strtol (&own_buf
[i
], NULL
, 16);
3676 pid
= ptid_get_pid (current_ptid
);
3678 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3680 struct thread_resume resume_info
;
3681 struct process_info
*process
= find_process_pid (pid
);
3683 if (process
== NULL
)
3685 write_enn (own_buf
);
3689 if (tracing
&& disconnected_tracing
)
3691 "Disconnected tracing in effect, "
3692 "leaving gdbserver attached to the process\n");
3694 if (any_persistent_commands ())
3696 "Persistent commands are present, "
3697 "leaving gdbserver attached to the process\n");
3699 /* Make sure we're in non-stop/async mode, so we we can both
3700 wait for an async socket accept, and handle async target
3701 events simultaneously. There's also no point either in
3702 having the target stop all threads, when we're going to
3703 pass signals down without informing GDB. */
3707 debug_printf ("Forcing non-stop mode\n");
3713 process
->gdb_detached
= 1;
3715 /* Detaching implicitly resumes all threads. */
3716 resume_info
.thread
= minus_one_ptid
;
3717 resume_info
.kind
= resume_continue
;
3718 resume_info
.sig
= 0;
3719 (*the_target
->resume
) (&resume_info
, 1);
3722 break; /* from switch/case */
3725 fprintf (stderr
, "Detaching from process %d\n", pid
);
3727 if (detach_inferior (pid
) != 0)
3728 write_enn (own_buf
);
3731 discard_queued_stop_replies (pid
);
3734 if (extended_protocol
)
3736 /* Treat this like a normal program exit. */
3737 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3738 last_status
.value
.integer
= 0;
3739 last_ptid
= pid_to_ptid (pid
);
3741 current_thread
= NULL
;
3748 /* If we are attached, then we can exit. Otherwise, we
3749 need to hang around doing nothing, until the child is
3751 join_inferior (pid
);
3757 extended_protocol
= 1;
3761 handle_status (own_buf
);
3764 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3766 ptid_t gdb_id
, thread_id
;
3769 require_running (own_buf
);
3771 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3773 pid
= ptid_get_pid (gdb_id
);
3775 if (ptid_equal (gdb_id
, null_ptid
)
3776 || ptid_equal (gdb_id
, minus_one_ptid
))
3777 thread_id
= null_ptid
;
3779 && ptid_equal (pid_to_ptid (pid
),
3782 struct thread_info
*thread
=
3783 (struct thread_info
*) find_inferior (&all_threads
,
3788 write_enn (own_buf
);
3792 thread_id
= thread
->entry
.id
;
3796 thread_id
= gdb_id_to_thread_id (gdb_id
);
3797 if (ptid_equal (thread_id
, null_ptid
))
3799 write_enn (own_buf
);
3804 if (own_buf
[1] == 'g')
3806 if (ptid_equal (thread_id
, null_ptid
))
3808 /* GDB is telling us to choose any thread. Check if
3809 the currently selected thread is still valid. If
3810 it is not, select the first available. */
3811 struct thread_info
*thread
=
3812 (struct thread_info
*) find_inferior_id (&all_threads
,
3816 thread
= get_first_thread ();
3817 thread_id
= thread
->entry
.id
;
3821 general_thread
= thread_id
;
3822 set_desired_thread (1);
3824 else if (own_buf
[1] == 'c')
3825 cont_thread
= thread_id
;
3831 /* Silently ignore it so that gdb can extend the protocol
3832 without compatibility headaches. */
3837 require_running (own_buf
);
3838 if (current_traceframe
>= 0)
3840 struct regcache
*regcache
3841 = new_register_cache (current_target_desc ());
3843 if (fetch_traceframe_registers (current_traceframe
,
3845 registers_to_string (regcache
, own_buf
);
3847 write_enn (own_buf
);
3848 free_register_cache (regcache
);
3852 struct regcache
*regcache
;
3854 set_desired_thread (1);
3855 regcache
= get_thread_regcache (current_thread
, 1);
3856 registers_to_string (regcache
, own_buf
);
3860 require_running (own_buf
);
3861 if (current_traceframe
>= 0)
3862 write_enn (own_buf
);
3865 struct regcache
*regcache
;
3867 set_desired_thread (1);
3868 regcache
= get_thread_regcache (current_thread
, 1);
3869 registers_from_string (regcache
, &own_buf
[1]);
3874 require_running (own_buf
);
3875 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3876 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3878 write_enn (own_buf
);
3880 bin2hex (mem_buf
, own_buf
, res
);
3883 require_running (own_buf
);
3884 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3885 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3888 write_enn (own_buf
);
3891 require_running (own_buf
);
3892 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3893 &mem_addr
, &len
, &mem_buf
) < 0
3894 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3895 write_enn (own_buf
);
3900 require_running (own_buf
);
3901 hex2bin (own_buf
+ 1, &sig
, 1);
3902 if (gdb_signal_to_host_p (sig
))
3903 signal
= gdb_signal_to_host (sig
);
3906 myresume (own_buf
, 0, signal
);
3909 require_running (own_buf
);
3910 hex2bin (own_buf
+ 1, &sig
, 1);
3911 if (gdb_signal_to_host_p (sig
))
3912 signal
= gdb_signal_to_host (sig
);
3915 myresume (own_buf
, 1, signal
);
3918 require_running (own_buf
);
3920 myresume (own_buf
, 0, signal
);
3923 require_running (own_buf
);
3925 myresume (own_buf
, 1, signal
);
3927 case 'Z': /* insert_ ... */
3929 case 'z': /* remove_ ... */
3934 char type
= own_buf
[1];
3936 const int insert
= ch
== 'Z';
3937 char *p
= &own_buf
[3];
3939 p
= unpack_varlen_hex (p
, &addr
);
3940 len
= strtol (p
+ 1, &dataptr
, 16);
3944 struct breakpoint
*bp
;
3946 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
3951 /* GDB may have sent us a list of *point parameters to
3952 be evaluated on the target's side. Read such list
3953 here. If we already have a list of parameters, GDB
3954 is telling us to drop that list and use this one
3956 clear_breakpoint_conditions_and_commands (bp
);
3957 process_point_options (bp
, &dataptr
);
3961 res
= delete_gdb_breakpoint (type
, addr
, len
);
3969 write_enn (own_buf
);
3973 response_needed
= 0;
3974 if (!target_running ())
3975 /* The packet we received doesn't make sense - but we can't
3976 reply to it, either. */
3979 fprintf (stderr
, "Killing all inferiors\n");
3980 for_each_inferior (&all_processes
, kill_inferior_callback
);
3982 /* When using the extended protocol, we wait with no program
3983 running. The traditional protocol will exit instead. */
3984 if (extended_protocol
)
3986 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3987 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3995 ptid_t gdb_id
, thread_id
;
3997 require_running (own_buf
);
3999 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4000 thread_id
= gdb_id_to_thread_id (gdb_id
);
4001 if (ptid_equal (thread_id
, null_ptid
))
4003 write_enn (own_buf
);
4007 if (mythread_alive (thread_id
))
4010 write_enn (own_buf
);
4014 response_needed
= 0;
4016 /* Restarting the inferior is only supported in the extended
4018 if (extended_protocol
)
4020 if (target_running ())
4021 for_each_inferior (&all_processes
,
4022 kill_inferior_callback
);
4023 fprintf (stderr
, "GDBserver restarting\n");
4025 /* Wait till we are at 1st instruction in prog. */
4026 if (program_argv
!= NULL
)
4027 start_inferior (program_argv
);
4030 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4031 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4037 /* It is a request we don't understand. Respond with an
4038 empty packet so that gdb knows that we don't support this
4044 /* Extended (long) request. */
4045 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4049 /* It is a request we don't understand. Respond with an empty
4050 packet so that gdb knows that we don't support this
4056 if (new_packet_len
!= -1)
4057 putpkt_binary (own_buf
, new_packet_len
);
4061 response_needed
= 0;
4063 if (!extended_protocol
&& have_ran
&& !target_running ())
4065 /* In non-stop, defer exiting until GDB had a chance to query
4066 the whole vStopped list (until it gets an OK). */
4067 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4069 /* Be transparent when GDB is connected through stdio -- no
4070 need to spam GDB's console. */
4071 if (!remote_connection_is_stdio ())
4072 fprintf (stderr
, "GDBserver exiting\n");
4084 /* Event-loop callback for serial events. */
4087 handle_serial_event (int err
, gdb_client_data client_data
)
4090 debug_printf ("handling possible serial event\n");
4092 /* Really handle it. */
4093 if (process_serial_event () < 0)
4096 /* Be sure to not change the selected thread behind GDB's back.
4097 Important in the non-stop mode asynchronous protocol. */
4098 set_desired_thread (1);
4103 /* Event-loop callback for target events. */
4106 handle_target_event (int err
, gdb_client_data client_data
)
4109 debug_printf ("handling possible target event\n");
4111 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4114 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4116 /* No RSP support for this yet. */
4118 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4120 int pid
= ptid_get_pid (last_ptid
);
4121 struct process_info
*process
= find_process_pid (pid
);
4122 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4124 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4125 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4127 mark_breakpoints_out (process
);
4128 mourn_inferior (process
);
4132 /* We're reporting this thread as stopped. Update its
4133 "want-stopped" state to what the client wants, until it
4134 gets a new resume action. */
4135 current_thread
->last_resume_kind
= resume_stop
;
4136 current_thread
->last_status
= last_status
;
4141 if (!target_running ())
4143 /* The last process exited. We're done. */
4147 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4149 /* A thread stopped with a signal, but gdb isn't
4150 connected to handle it. Pass it down to the
4151 inferior, as if it wasn't being traced. */
4152 struct thread_resume resume_info
;
4155 debug_printf ("GDB not connected; forwarding event %d for"
4157 (int) last_status
.kind
,
4158 target_pid_to_str (last_ptid
));
4160 resume_info
.thread
= last_ptid
;
4161 resume_info
.kind
= resume_continue
;
4162 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4163 (*the_target
->resume
) (&resume_info
, 1);
4165 else if (debug_threads
)
4166 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4167 (int) last_status
.kind
,
4168 target_pid_to_str (last_ptid
));
4172 struct vstop_notif
*vstop_notif
4173 = xmalloc (sizeof (struct vstop_notif
));
4175 vstop_notif
->status
= last_status
;
4176 vstop_notif
->ptid
= last_ptid
;
4177 /* Push Stop notification. */
4178 notif_push (¬if_stop
,
4179 (struct notif_event
*) vstop_notif
);
4183 /* Be sure to not change the selected thread behind GDB's back.
4184 Important in the non-stop mode asynchronous protocol. */
4185 set_desired_thread (1);