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 int extended_protocol
;
53 static int response_needed
;
54 static int exit_requested
;
56 /* --once: Exit after the first connection has closed. */
60 int report_fork_events
;
61 int report_vfork_events
;
66 /* Whether we should attempt to disable the operating system's address
67 space randomization feature before starting an inferior. */
68 int disable_randomization
= 1;
70 static char **program_argv
, **wrapper_argv
;
72 int pass_signals
[GDB_SIGNAL_LAST
];
73 int program_signals
[GDB_SIGNAL_LAST
];
74 int program_signals_p
;
76 /* The PID of the originally created or attached inferior. Used to
77 send signals to the process when GDB sends us an asynchronous interrupt
78 (user hitting Control-C in the client), and to wait for the child to exit
79 when no longer debugging it. */
81 unsigned long signal_pid
;
84 /* A file descriptor for the controlling terminal. */
87 /* TERMINAL_FD's original foreground group. */
88 pid_t old_foreground_pgrp
;
90 /* Hand back terminal ownership to the original foreground group. */
93 restore_old_foreground_pgrp (void)
95 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
99 /* Set if you want to disable optional thread related packets support
100 in gdbserver, for the sake of testing GDB against stubs that don't
102 int disable_packet_vCont
;
103 int disable_packet_Tthread
;
104 int disable_packet_qC
;
105 int disable_packet_qfThreadInfo
;
107 /* Last status reported to GDB. */
108 static struct target_waitstatus last_status
;
109 static ptid_t last_ptid
;
111 static char *own_buf
;
112 static unsigned char *mem_buf
;
114 /* A sub-class of 'struct notif_event' for stop, holding information
115 relative to a single stop reply. We keep a queue of these to
116 push to GDB in non-stop mode. */
120 struct notif_event base
;
122 /* Thread or process that got the event. */
126 struct target_waitstatus status
;
129 /* The current btrace configuration. This is gdbserver's mirror of GDB's
130 btrace configuration. */
131 static struct btrace_config current_btrace_conf
;
133 DEFINE_QUEUE_P (notif_event_p
);
135 /* Put a stop reply to the stop reply queue. */
138 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
140 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
142 new_notif
->ptid
= ptid
;
143 new_notif
->status
= *status
;
145 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
149 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
150 QUEUE_ITER (notif_event_p
) *iter
,
151 struct notif_event
*event
,
154 ptid_t filter_ptid
= *(ptid_t
*) data
;
155 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
157 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
159 if (q
->free_func
!= NULL
)
160 q
->free_func (event
);
162 QUEUE_remove_elem (notif_event_p
, q
, iter
);
171 discard_queued_stop_replies (ptid_t ptid
)
173 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
174 remove_all_on_match_ptid
, &ptid
);
178 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
180 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
182 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
185 struct notif_server notif_stop
=
187 "vStopped", "Stop", NULL
, vstop_notif_reply
,
191 target_running (void)
193 return get_first_thread () != NULL
;
197 start_inferior (char **argv
)
199 char **new_argv
= argv
;
201 if (wrapper_argv
!= NULL
)
205 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
207 for (i
= 0; argv
[i
] != NULL
; i
++)
209 new_argv
= XALLOCAVEC (char *, count
);
211 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
212 new_argv
[count
++] = wrapper_argv
[i
];
213 for (i
= 0; argv
[i
] != NULL
; i
++)
214 new_argv
[count
++] = argv
[i
];
215 new_argv
[count
] = NULL
;
221 for (i
= 0; new_argv
[i
]; ++i
)
222 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
227 signal (SIGTTOU
, SIG_DFL
);
228 signal (SIGTTIN
, SIG_DFL
);
231 signal_pid
= create_inferior (new_argv
[0], new_argv
);
233 /* FIXME: we don't actually know at this point that the create
234 actually succeeded. We won't know that until we wait. */
235 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
240 signal (SIGTTOU
, SIG_IGN
);
241 signal (SIGTTIN
, SIG_IGN
);
242 terminal_fd
= fileno (stderr
);
243 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
244 tcsetpgrp (terminal_fd
, signal_pid
);
245 atexit (restore_old_foreground_pgrp
);
248 if (wrapper_argv
!= NULL
)
250 struct thread_resume resume_info
;
252 memset (&resume_info
, 0, sizeof (resume_info
));
253 resume_info
.thread
= pid_to_ptid (signal_pid
);
254 resume_info
.kind
= resume_continue
;
257 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
259 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
);
274 target_arch_setup ();
278 /* Wait till we are at 1st instruction in program, return new pid
279 (assuming success). */
280 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
282 target_arch_setup ();
284 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
285 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
287 current_thread
->last_resume_kind
= resume_stop
;
288 current_thread
->last_status
= last_status
;
291 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
297 attach_inferior (int pid
)
299 /* myattach should return -1 if attaching is unsupported,
300 0 if it succeeded, and call error() otherwise. */
302 if (myattach (pid
) != 0)
305 fprintf (stderr
, "Attached; pid = %d\n", pid
);
308 /* FIXME - It may be that we should get the SIGNAL_PID from the
309 attach function, so that it can be the main thread instead of
310 whichever we were told to attach to. */
315 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
317 /* GDB knows to ignore the first SIGSTOP after attaching to a running
318 process using the "attach" command, but this is different; it's
319 just using "target remote". Pretend it's just starting up. */
320 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
321 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
322 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
324 current_thread
->last_resume_kind
= resume_stop
;
325 current_thread
->last_status
= last_status
;
331 extern int remote_debug
;
333 /* Decode a qXfer read request. Return 0 if everything looks OK,
337 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
339 /* After the read marker and annex, qXfer looks like a
340 traditional 'm' packet. */
341 decode_m_packet (buf
, ofs
, len
);
347 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
349 /* Extract and NUL-terminate the object. */
351 while (*buf
&& *buf
!= ':')
357 /* Extract and NUL-terminate the read/write action. */
359 while (*buf
&& *buf
!= ':')
365 /* Extract and NUL-terminate the annex. */
367 while (*buf
&& *buf
!= ':')
377 /* Write the response to a successful qXfer read. Returns the
378 length of the (binary) data stored in BUF, corresponding
379 to as much of DATA/LEN as we could fit. IS_MORE controls
380 the first character of the response. */
382 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
391 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
392 &out_len
, PBUFSIZ
- 2) + 1;
395 /* Handle btrace enabling in BTS format. */
398 handle_btrace_enable_bts (struct thread_info
*thread
)
400 if (thread
->btrace
!= NULL
)
401 return "E.Btrace already enabled.";
403 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
404 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
405 ¤t_btrace_conf
);
406 if (thread
->btrace
== NULL
)
407 return "E.Could not enable btrace.";
412 /* Handle btrace enabling in Intel(R) Processor Trace format. */
415 handle_btrace_enable_pt (struct thread_info
*thread
)
417 if (thread
->btrace
!= NULL
)
418 return "E.Btrace already enabled.";
420 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
421 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
422 ¤t_btrace_conf
);
423 if (thread
->btrace
== NULL
)
424 return "E.Could not enable btrace.";
429 /* Handle btrace disabling. */
432 handle_btrace_disable (struct thread_info
*thread
)
435 if (thread
->btrace
== NULL
)
436 return "E.Branch tracing not enabled.";
438 if (target_disable_btrace (thread
->btrace
) != 0)
439 return "E.Could not disable branch tracing.";
441 thread
->btrace
= NULL
;
445 /* Handle the "Qbtrace" packet. */
448 handle_btrace_general_set (char *own_buf
)
450 struct thread_info
*thread
;
454 if (!startswith (own_buf
, "Qbtrace:"))
457 op
= own_buf
+ strlen ("Qbtrace:");
459 if (ptid_equal (general_thread
, null_ptid
)
460 || ptid_equal (general_thread
, minus_one_ptid
))
462 strcpy (own_buf
, "E.Must select a single thread.");
466 thread
= find_thread_ptid (general_thread
);
469 strcpy (own_buf
, "E.No such thread.");
475 if (strcmp (op
, "bts") == 0)
476 err
= handle_btrace_enable_bts (thread
);
477 else if (strcmp (op
, "pt") == 0)
478 err
= handle_btrace_enable_pt (thread
);
479 else if (strcmp (op
, "off") == 0)
480 err
= handle_btrace_disable (thread
);
482 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
485 strcpy (own_buf
, err
);
492 /* Handle the "Qbtrace-conf" packet. */
495 handle_btrace_conf_general_set (char *own_buf
)
497 struct thread_info
*thread
;
500 if (!startswith (own_buf
, "Qbtrace-conf:"))
503 op
= own_buf
+ strlen ("Qbtrace-conf:");
505 if (ptid_equal (general_thread
, null_ptid
)
506 || ptid_equal (general_thread
, minus_one_ptid
))
508 strcpy (own_buf
, "E.Must select a single thread.");
512 thread
= find_thread_ptid (general_thread
);
515 strcpy (own_buf
, "E.No such thread.");
519 if (startswith (op
, "bts:size="))
525 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
526 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
528 strcpy (own_buf
, "E.Bad size value.");
532 current_btrace_conf
.bts
.size
= (unsigned int) size
;
534 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
540 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
541 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
543 strcpy (own_buf
, "E.Bad size value.");
547 current_btrace_conf
.pt
.size
= (unsigned int) size
;
551 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
559 /* Handle all of the extended 'Q' packets. */
562 handle_general_set (char *own_buf
)
564 if (startswith (own_buf
, "QPassSignals:"))
566 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
567 const char *p
= own_buf
+ strlen ("QPassSignals:");
570 p
= decode_address_to_semicolon (&cursig
, p
);
571 for (i
= 0; i
< numsigs
; i
++)
577 /* Keep looping, to clear the remaining signals. */
580 p
= decode_address_to_semicolon (&cursig
, p
);
585 strcpy (own_buf
, "OK");
589 if (startswith (own_buf
, "QProgramSignals:"))
591 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
592 const char *p
= own_buf
+ strlen ("QProgramSignals:");
595 program_signals_p
= 1;
597 p
= decode_address_to_semicolon (&cursig
, p
);
598 for (i
= 0; i
< numsigs
; i
++)
602 program_signals
[i
] = 1;
604 /* Keep looping, to clear the remaining signals. */
607 p
= decode_address_to_semicolon (&cursig
, p
);
610 program_signals
[i
] = 0;
612 strcpy (own_buf
, "OK");
616 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
620 fprintf (stderr
, "[noack mode enabled]\n");
629 if (startswith (own_buf
, "QNonStop:"))
631 char *mode
= own_buf
+ 9;
635 if (strcmp (mode
, "0") == 0)
637 else if (strcmp (mode
, "1") == 0)
641 /* We don't know what this mode is, so complain to
643 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
649 req_str
= req
? "non-stop" : "all-stop";
650 if (start_non_stop (req
) != 0)
652 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
660 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
666 if (startswith (own_buf
, "QDisableRandomization:"))
668 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
671 unpack_varlen_hex (packet
, &setting
);
672 disable_randomization
= setting
;
676 if (disable_randomization
)
677 fprintf (stderr
, "[address space randomization disabled]\n");
679 fprintf (stderr
, "[address space randomization enabled]\n");
686 if (target_supports_tracepoints ()
687 && handle_tracepoint_general_set (own_buf
))
690 if (startswith (own_buf
, "QAgent:"))
692 char *mode
= own_buf
+ strlen ("QAgent:");
695 if (strcmp (mode
, "0") == 0)
697 else if (strcmp (mode
, "1") == 0)
701 /* We don't know what this value is, so complain to GDB. */
702 sprintf (own_buf
, "E.Unknown QAgent value");
706 /* Update the flag. */
709 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
714 if (handle_btrace_general_set (own_buf
))
717 if (handle_btrace_conf_general_set (own_buf
))
720 /* Otherwise we didn't know what packet it was. Say we didn't
726 get_features_xml (const char *annex
)
728 const struct target_desc
*desc
= current_target_desc ();
730 /* `desc->xmltarget' defines what to return when looking for the
731 "target.xml" file. Its contents can either be verbatim XML code
732 (prefixed with a '@') or else the name of the actual XML file to
733 be used in place of "target.xml".
735 This variable is set up from the auto-generated
736 init_registers_... routine for the current target. */
738 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
740 if (*desc
->xmltarget
== '@')
741 return desc
->xmltarget
+ 1;
743 annex
= desc
->xmltarget
;
748 extern const char *const xml_builtin
[][2];
751 /* Look for the annex. */
752 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
753 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
756 if (xml_builtin
[i
][0] != NULL
)
757 return xml_builtin
[i
][1];
765 monitor_show_help (void)
767 monitor_output ("The following monitor commands are supported:\n");
768 monitor_output (" set debug <0|1>\n");
769 monitor_output (" Enable general debugging messages\n");
770 monitor_output (" set debug-hw-points <0|1>\n");
771 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
772 monitor_output (" set remote-debug <0|1>\n");
773 monitor_output (" Enable remote protocol debugging messages\n");
774 monitor_output (" set debug-format option1[,option2,...]\n");
775 monitor_output (" Add additional information to debugging messages\n");
776 monitor_output (" Options: all, none");
777 monitor_output (", timestamp");
778 monitor_output ("\n");
779 monitor_output (" exit\n");
780 monitor_output (" Quit GDBserver\n");
783 /* Read trace frame or inferior memory. Returns the number of bytes
784 actually read, zero when no further transfer is possible, and -1 on
785 error. Return of a positive value smaller than LEN does not
786 indicate there's no more to be read, only the end of the transfer.
787 E.g., when GDB reads memory from a traceframe, a first request may
788 be served from a memory block that does not cover the whole request
789 length. A following request gets the rest served from either
790 another block (of the same traceframe) or from the read-only
794 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
798 if (current_traceframe
>= 0)
801 ULONGEST length
= len
;
803 if (traceframe_read_mem (current_traceframe
,
804 memaddr
, myaddr
, len
, &nbytes
))
806 /* Data read from trace buffer, we're done. */
809 if (!in_readonly_region (memaddr
, length
))
811 /* Otherwise we have a valid readonly case, fall through. */
812 /* (assume no half-trace half-real blocks for now) */
815 res
= prepare_to_access_memory ();
818 if (set_desired_thread (1))
819 res
= read_inferior_memory (memaddr
, myaddr
, len
);
822 done_accessing_memory ();
824 return res
== 0 ? len
: -1;
830 /* Write trace frame or inferior memory. Actually, writing to trace
831 frames is forbidden. */
834 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
836 if (current_traceframe
>= 0)
842 ret
= prepare_to_access_memory ();
845 if (set_desired_thread (1))
846 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
849 done_accessing_memory ();
855 /* Subroutine of handle_search_memory to simplify it. */
858 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
859 gdb_byte
*pattern
, unsigned pattern_len
,
860 gdb_byte
*search_buf
,
861 unsigned chunk_size
, unsigned search_buf_size
,
862 CORE_ADDR
*found_addrp
)
864 /* Prime the search buffer. */
866 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
869 warning ("Unable to access %ld bytes of target "
870 "memory at 0x%lx, halting search.",
871 (long) search_buf_size
, (long) start_addr
);
875 /* Perform the search.
877 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
878 When we've scanned N bytes we copy the trailing bytes to the start and
879 read in another N bytes. */
881 while (search_space_len
>= pattern_len
)
884 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
888 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
890 if (found_ptr
!= NULL
)
892 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
893 *found_addrp
= found_addr
;
897 /* Not found in this chunk, skip to next chunk. */
899 /* Don't let search_space_len wrap here, it's unsigned. */
900 if (search_space_len
>= chunk_size
)
901 search_space_len
-= chunk_size
;
903 search_space_len
= 0;
905 if (search_space_len
>= pattern_len
)
907 unsigned keep_len
= search_buf_size
- chunk_size
;
908 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
911 /* Copy the trailing part of the previous iteration to the front
912 of the buffer for the next iteration. */
913 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
915 nr_to_read
= (search_space_len
- keep_len
< chunk_size
916 ? search_space_len
- keep_len
919 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
920 nr_to_read
) != search_buf_size
)
922 warning ("Unable to access %ld bytes of target memory "
923 "at 0x%lx, halting search.",
924 (long) nr_to_read
, (long) read_addr
);
928 start_addr
+= chunk_size
;
937 /* Handle qSearch:memory packets. */
940 handle_search_memory (char *own_buf
, int packet_len
)
942 CORE_ADDR start_addr
;
943 CORE_ADDR search_space_len
;
945 unsigned int pattern_len
;
946 /* NOTE: also defined in find.c testcase. */
947 #define SEARCH_CHUNK_SIZE 16000
948 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
949 /* Buffer to hold memory contents for searching. */
950 gdb_byte
*search_buf
;
951 unsigned search_buf_size
;
953 CORE_ADDR found_addr
;
954 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
956 pattern
= malloc (packet_len
);
959 error ("Unable to allocate memory to perform the search");
960 strcpy (own_buf
, "E00");
963 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
964 packet_len
- cmd_name_len
,
965 &start_addr
, &search_space_len
,
966 pattern
, &pattern_len
) < 0)
969 error ("Error in parsing qSearch:memory packet");
970 strcpy (own_buf
, "E00");
974 search_buf_size
= chunk_size
+ pattern_len
- 1;
976 /* No point in trying to allocate a buffer larger than the search space. */
977 if (search_space_len
< search_buf_size
)
978 search_buf_size
= search_space_len
;
980 search_buf
= malloc (search_buf_size
);
981 if (search_buf
== NULL
)
984 error ("Unable to allocate memory to perform the search");
985 strcpy (own_buf
, "E00");
989 found
= handle_search_memory_1 (start_addr
, search_space_len
,
990 pattern
, pattern_len
,
991 search_buf
, chunk_size
, search_buf_size
,
995 sprintf (own_buf
, "1,%lx", (long) found_addr
);
997 strcpy (own_buf
, "0");
999 strcpy (own_buf
, "E00");
1005 #define require_running(BUF) \
1006 if (!target_running ()) \
1012 /* Parse options to --debug-format= and "monitor set debug-format".
1013 ARG is the text after "--debug-format=" or "monitor set debug-format".
1014 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1015 This triggers calls to monitor_output.
1016 The result is NULL if all options were parsed ok, otherwise an error
1017 message which the caller must free.
1019 N.B. These commands affect all debug format settings, they are not
1020 cumulative. If a format is not specified, it is turned off.
1021 However, we don't go to extra trouble with things like
1022 "monitor set debug-format all,none,timestamp".
1023 Instead we just parse them one at a time, in order.
1025 The syntax for "monitor set debug" we support here is not identical
1026 to gdb's "set debug foo on|off" because we also use this function to
1027 parse "--debug-format=foo,bar". */
1030 parse_debug_format_options (const char *arg
, int is_monitor
)
1032 VEC (char_ptr
) *options
;
1036 /* First turn all debug format options off. */
1037 debug_timestamp
= 0;
1039 /* First remove leading spaces, for "monitor set debug-format". */
1040 while (isspace (*arg
))
1043 options
= delim_string_to_char_ptr_vec (arg
, ',');
1045 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1047 if (strcmp (option
, "all") == 0)
1049 debug_timestamp
= 1;
1051 monitor_output ("All extra debug format options enabled.\n");
1053 else if (strcmp (option
, "none") == 0)
1055 debug_timestamp
= 0;
1057 monitor_output ("All extra debug format options disabled.\n");
1059 else if (strcmp (option
, "timestamp") == 0)
1061 debug_timestamp
= 1;
1063 monitor_output ("Timestamps will be added to debug output.\n");
1065 else if (*option
== '\0')
1067 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1072 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1075 free_char_ptr_vec (options
);
1080 free_char_ptr_vec (options
);
1084 /* Handle monitor commands not handled by target-specific handlers. */
1087 handle_monitor_command (char *mon
, char *own_buf
)
1089 if (strcmp (mon
, "set debug 1") == 0)
1092 monitor_output ("Debug output enabled.\n");
1094 else if (strcmp (mon
, "set debug 0") == 0)
1097 monitor_output ("Debug output disabled.\n");
1099 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1101 show_debug_regs
= 1;
1102 monitor_output ("H/W point debugging output enabled.\n");
1104 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1106 show_debug_regs
= 0;
1107 monitor_output ("H/W point debugging output disabled.\n");
1109 else if (strcmp (mon
, "set remote-debug 1") == 0)
1112 monitor_output ("Protocol debug output enabled.\n");
1114 else if (strcmp (mon
, "set remote-debug 0") == 0)
1117 monitor_output ("Protocol debug output disabled.\n");
1119 else if (startswith (mon
, "set debug-format "))
1122 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1125 if (error_msg
!= NULL
)
1127 monitor_output (error_msg
);
1128 monitor_show_help ();
1129 write_enn (own_buf
);
1133 else if (strcmp (mon
, "help") == 0)
1134 monitor_show_help ();
1135 else if (strcmp (mon
, "exit") == 0)
1139 monitor_output ("Unknown monitor command.\n\n");
1140 monitor_show_help ();
1141 write_enn (own_buf
);
1145 /* Associates a callback with each supported qXfer'able object. */
1149 /* The object this handler handles. */
1152 /* Request that the target transfer up to LEN 8-bit bytes of the
1153 target's OBJECT. The OFFSET, for a seekable object, specifies
1154 the starting point. The ANNEX can be used to provide additional
1155 data-specific information to the target.
1157 Return the number of bytes actually transfered, zero when no
1158 further transfer is possible, -1 on error, -2 when the transfer
1159 is not supported, and -3 on a verbose error message that should
1160 be preserved. Return of a positive value smaller than LEN does
1161 not indicate the end of the object, only the end of the transfer.
1163 One, and only one, of readbuf or writebuf must be non-NULL. */
1164 int (*xfer
) (const char *annex
,
1165 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1166 ULONGEST offset
, LONGEST len
);
1169 /* Handle qXfer:auxv:read. */
1172 handle_qxfer_auxv (const char *annex
,
1173 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1174 ULONGEST offset
, LONGEST len
)
1176 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1179 if (annex
[0] != '\0' || current_thread
== NULL
)
1182 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1185 /* Handle qXfer:exec-file:read. */
1188 handle_qxfer_exec_file (const char *const_annex
,
1189 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1190 ULONGEST offset
, LONGEST len
)
1196 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1199 if (const_annex
[0] == '\0')
1201 if (current_thread
== NULL
)
1204 pid
= pid_of (current_thread
);
1208 char *annex
= alloca (strlen (const_annex
) + 1);
1210 strcpy (annex
, const_annex
);
1211 annex
= unpack_varlen_hex (annex
, &pid
);
1213 if (annex
[0] != '\0')
1220 file
= (*the_target
->pid_to_exec_file
) (pid
);
1224 total_len
= strlen (file
);
1226 if (offset
> total_len
)
1229 if (offset
+ len
> total_len
)
1230 len
= total_len
- offset
;
1232 memcpy (readbuf
, file
+ offset
, len
);
1236 /* Handle qXfer:features:read. */
1239 handle_qxfer_features (const char *annex
,
1240 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1241 ULONGEST offset
, LONGEST len
)
1243 const char *document
;
1246 if (writebuf
!= NULL
)
1249 if (!target_running ())
1252 /* Grab the correct annex. */
1253 document
= get_features_xml (annex
);
1254 if (document
== NULL
)
1257 total_len
= strlen (document
);
1259 if (offset
> total_len
)
1262 if (offset
+ len
> total_len
)
1263 len
= total_len
- offset
;
1265 memcpy (readbuf
, document
+ offset
, len
);
1269 /* Worker routine for handle_qxfer_libraries.
1270 Add to the length pointed to by ARG a conservative estimate of the
1271 length needed to transmit the file name of INF. */
1274 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1276 struct dll_info
*dll
= (struct dll_info
*) inf
;
1277 unsigned int *total_len
= arg
;
1279 /* Over-estimate the necessary memory. Assume that every character
1280 in the library name must be escaped. */
1281 *total_len
+= 128 + 6 * strlen (dll
->name
);
1284 /* Worker routine for handle_qxfer_libraries.
1285 Emit the XML to describe the library in INF. */
1288 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1290 struct dll_info
*dll
= (struct dll_info
*) inf
;
1295 strcpy (p
, " <library name=\"");
1297 name
= xml_escape_text (dll
->name
);
1301 strcpy (p
, "\"><segment address=\"");
1303 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1305 strcpy (p
, "\"/></library>\n");
1311 /* Handle qXfer:libraries:read. */
1314 handle_qxfer_libraries (const char *annex
,
1315 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1316 ULONGEST offset
, LONGEST len
)
1318 unsigned int total_len
;
1321 if (writebuf
!= NULL
)
1324 if (annex
[0] != '\0' || current_thread
== NULL
)
1328 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1331 document
= malloc (total_len
);
1332 if (document
== NULL
)
1335 strcpy (document
, "<library-list version=\"1.0\">\n");
1336 p
= document
+ strlen (document
);
1338 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1340 strcpy (p
, "</library-list>\n");
1342 total_len
= strlen (document
);
1344 if (offset
> total_len
)
1350 if (offset
+ len
> total_len
)
1351 len
= total_len
- offset
;
1353 memcpy (readbuf
, document
+ offset
, len
);
1358 /* Handle qXfer:libraries-svr4:read. */
1361 handle_qxfer_libraries_svr4 (const char *annex
,
1362 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1363 ULONGEST offset
, LONGEST len
)
1365 if (writebuf
!= NULL
)
1368 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1371 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1374 /* Handle qXfer:osadata:read. */
1377 handle_qxfer_osdata (const char *annex
,
1378 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1379 ULONGEST offset
, LONGEST len
)
1381 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1384 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1387 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1390 handle_qxfer_siginfo (const char *annex
,
1391 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1392 ULONGEST offset
, LONGEST len
)
1394 if (the_target
->qxfer_siginfo
== NULL
)
1397 if (annex
[0] != '\0' || current_thread
== NULL
)
1400 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1403 /* Handle qXfer:spu:read and qXfer:spu:write. */
1406 handle_qxfer_spu (const char *annex
,
1407 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1408 ULONGEST offset
, LONGEST len
)
1410 if (the_target
->qxfer_spu
== NULL
)
1413 if (current_thread
== NULL
)
1416 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1419 /* Handle qXfer:statictrace:read. */
1422 handle_qxfer_statictrace (const char *annex
,
1423 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1424 ULONGEST offset
, LONGEST len
)
1428 if (writebuf
!= NULL
)
1431 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1434 if (traceframe_read_sdata (current_traceframe
, offset
,
1435 readbuf
, len
, &nbytes
))
1440 /* Helper for handle_qxfer_threads_proper.
1441 Emit the XML to describe the thread of INF. */
1444 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1446 struct thread_info
*thread
= (struct thread_info
*) inf
;
1447 struct buffer
*buffer
= arg
;
1448 ptid_t ptid
= thread_to_gdb_id (thread
);
1450 int core
= target_core_of_thread (ptid
);
1453 write_ptid (ptid_s
, ptid
);
1457 sprintf (core_s
, "%d", core
);
1458 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1463 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1468 /* Helper for handle_qxfer_threads. */
1471 handle_qxfer_threads_proper (struct buffer
*buffer
)
1473 buffer_grow_str (buffer
, "<threads>\n");
1475 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1478 buffer_grow_str0 (buffer
, "</threads>\n");
1481 /* Handle qXfer:threads:read. */
1484 handle_qxfer_threads (const char *annex
,
1485 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1486 ULONGEST offset
, LONGEST len
)
1488 static char *result
= 0;
1489 static unsigned int result_length
= 0;
1491 if (writebuf
!= NULL
)
1494 if (annex
[0] != '\0')
1499 struct buffer buffer
;
1500 /* When asked for data at offset 0, generate everything and store into
1501 'result'. Successive reads will be served off 'result'. */
1505 buffer_init (&buffer
);
1507 handle_qxfer_threads_proper (&buffer
);
1509 result
= buffer_finish (&buffer
);
1510 result_length
= strlen (result
);
1511 buffer_free (&buffer
);
1514 if (offset
>= result_length
)
1516 /* We're out of data. */
1523 if (len
> result_length
- offset
)
1524 len
= result_length
- offset
;
1526 memcpy (readbuf
, result
+ offset
, len
);
1531 /* Handle qXfer:traceframe-info:read. */
1534 handle_qxfer_traceframe_info (const char *annex
,
1535 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1536 ULONGEST offset
, LONGEST len
)
1538 static char *result
= 0;
1539 static unsigned int result_length
= 0;
1541 if (writebuf
!= NULL
)
1544 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1549 struct buffer buffer
;
1551 /* When asked for data at offset 0, generate everything and
1552 store into 'result'. Successive reads will be served off
1556 buffer_init (&buffer
);
1558 traceframe_read_info (current_traceframe
, &buffer
);
1560 result
= buffer_finish (&buffer
);
1561 result_length
= strlen (result
);
1562 buffer_free (&buffer
);
1565 if (offset
>= result_length
)
1567 /* We're out of data. */
1574 if (len
> result_length
- offset
)
1575 len
= result_length
- offset
;
1577 memcpy (readbuf
, result
+ offset
, len
);
1581 /* Handle qXfer:fdpic:read. */
1584 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1585 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1587 if (the_target
->read_loadmap
== NULL
)
1590 if (current_thread
== NULL
)
1593 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1596 /* Handle qXfer:btrace:read. */
1599 handle_qxfer_btrace (const char *annex
,
1600 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1601 ULONGEST offset
, LONGEST len
)
1603 static struct buffer cache
;
1604 struct thread_info
*thread
;
1607 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1610 if (ptid_equal (general_thread
, null_ptid
)
1611 || ptid_equal (general_thread
, minus_one_ptid
))
1613 strcpy (own_buf
, "E.Must select a single thread.");
1617 thread
= find_thread_ptid (general_thread
);
1620 strcpy (own_buf
, "E.No such thread.");
1624 if (thread
->btrace
== NULL
)
1626 strcpy (own_buf
, "E.Btrace not enabled.");
1630 if (strcmp (annex
, "all") == 0)
1631 type
= BTRACE_READ_ALL
;
1632 else if (strcmp (annex
, "new") == 0)
1633 type
= BTRACE_READ_NEW
;
1634 else if (strcmp (annex
, "delta") == 0)
1635 type
= BTRACE_READ_DELTA
;
1638 strcpy (own_buf
, "E.Bad annex.");
1644 buffer_free (&cache
);
1646 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1649 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1653 else if (offset
> cache
.used_size
)
1655 buffer_free (&cache
);
1659 if (len
> cache
.used_size
- offset
)
1660 len
= cache
.used_size
- offset
;
1662 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1667 /* Handle qXfer:btrace-conf:read. */
1670 handle_qxfer_btrace_conf (const char *annex
,
1671 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1672 ULONGEST offset
, LONGEST len
)
1674 static struct buffer cache
;
1675 struct thread_info
*thread
;
1678 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1681 if (annex
[0] != '\0')
1684 if (ptid_equal (general_thread
, null_ptid
)
1685 || ptid_equal (general_thread
, minus_one_ptid
))
1687 strcpy (own_buf
, "E.Must select a single thread.");
1691 thread
= find_thread_ptid (general_thread
);
1694 strcpy (own_buf
, "E.No such thread.");
1698 if (thread
->btrace
== NULL
)
1700 strcpy (own_buf
, "E.Btrace not enabled.");
1706 buffer_free (&cache
);
1708 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1711 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1715 else if (offset
> cache
.used_size
)
1717 buffer_free (&cache
);
1721 if (len
> cache
.used_size
- offset
)
1722 len
= cache
.used_size
- offset
;
1724 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1729 static const struct qxfer qxfer_packets
[] =
1731 { "auxv", handle_qxfer_auxv
},
1732 { "btrace", handle_qxfer_btrace
},
1733 { "btrace-conf", handle_qxfer_btrace_conf
},
1734 { "exec-file", handle_qxfer_exec_file
},
1735 { "fdpic", handle_qxfer_fdpic
},
1736 { "features", handle_qxfer_features
},
1737 { "libraries", handle_qxfer_libraries
},
1738 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1739 { "osdata", handle_qxfer_osdata
},
1740 { "siginfo", handle_qxfer_siginfo
},
1741 { "spu", handle_qxfer_spu
},
1742 { "statictrace", handle_qxfer_statictrace
},
1743 { "threads", handle_qxfer_threads
},
1744 { "traceframe-info", handle_qxfer_traceframe_info
},
1748 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1756 if (!startswith (own_buf
, "qXfer:"))
1759 /* Grab the object, r/w and annex. */
1760 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1762 write_enn (own_buf
);
1767 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1770 const struct qxfer
*q
= &qxfer_packets
[i
];
1772 if (strcmp (object
, q
->object
) == 0)
1774 if (strcmp (rw
, "read") == 0)
1776 unsigned char *data
;
1781 /* Grab the offset and length. */
1782 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1784 write_enn (own_buf
);
1788 /* Read one extra byte, as an indicator of whether there is
1790 if (len
> PBUFSIZ
- 2)
1792 data
= malloc (len
+ 1);
1795 write_enn (own_buf
);
1798 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1806 /* Preserve error message. */
1809 write_enn (own_buf
);
1811 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1813 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1818 else if (strcmp (rw
, "write") == 0)
1823 unsigned char *data
;
1825 strcpy (own_buf
, "E00");
1826 data
= malloc (packet_len
- (offset
- own_buf
));
1829 write_enn (own_buf
);
1832 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1833 &ofs
, &len
, data
) < 0)
1836 write_enn (own_buf
);
1840 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1848 /* Preserve error message. */
1851 write_enn (own_buf
);
1853 sprintf (own_buf
, "%x", n
);
1866 /* Table used by the crc32 function to calcuate the checksum. */
1868 static unsigned int crc32_table
[256] =
1871 /* Compute 32 bit CRC from inferior memory.
1873 On success, return 32 bit CRC.
1874 On failure, return (unsigned long long) -1. */
1876 static unsigned long long
1877 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1879 if (!crc32_table
[1])
1881 /* Initialize the CRC table and the decoding table. */
1885 for (i
= 0; i
< 256; i
++)
1887 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1888 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1895 unsigned char byte
= 0;
1897 /* Return failure if memory read fails. */
1898 if (read_inferior_memory (base
, &byte
, 1) != 0)
1899 return (unsigned long long) -1;
1901 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1904 return (unsigned long long) crc
;
1907 /* Add supported btrace packets to BUF. */
1910 supported_btrace_packets (char *buf
)
1912 int btrace_supported
= 0;
1914 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1916 strcat (buf
, ";Qbtrace:bts+");
1917 strcat (buf
, ";Qbtrace-conf:bts:size+");
1919 btrace_supported
= 1;
1922 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1924 strcat (buf
, ";Qbtrace:pt+");
1925 strcat (buf
, ";Qbtrace-conf:pt:size+");
1927 btrace_supported
= 1;
1930 if (!btrace_supported
)
1933 strcat (buf
, ";Qbtrace:off+");
1934 strcat (buf
, ";qXfer:btrace:read+");
1935 strcat (buf
, ";qXfer:btrace-conf:read+");
1938 /* Handle all of the extended 'q' packets. */
1941 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1943 static struct inferior_list_entry
*thread_ptr
;
1945 /* Reply the current thread id. */
1946 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1949 require_running (own_buf
);
1951 if (!ptid_equal (general_thread
, null_ptid
)
1952 && !ptid_equal (general_thread
, minus_one_ptid
))
1953 gdb_id
= general_thread
;
1956 thread_ptr
= get_first_inferior (&all_threads
);
1957 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1960 sprintf (own_buf
, "QC");
1962 write_ptid (own_buf
, gdb_id
);
1966 if (strcmp ("qSymbol::", own_buf
) == 0)
1968 /* GDB is suggesting new symbols have been loaded. This may
1969 mean a new shared library has been detected as loaded, so
1970 take the opportunity to check if breakpoints we think are
1971 inserted, still are. Note that it isn't guaranteed that
1972 we'll see this when a shared library is loaded, and nor will
1973 we see this for unloads (although breakpoints in unloaded
1974 libraries shouldn't trigger), as GDB may not find symbols for
1975 the library at all. We also re-validate breakpoints when we
1976 see a second GDB breakpoint for the same address, and or when
1977 we access breakpoint shadows. */
1978 validate_breakpoints ();
1980 if (target_supports_tracepoints ())
1981 tracepoint_look_up_symbols ();
1983 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
1984 (*the_target
->look_up_symbols
) ();
1986 strcpy (own_buf
, "OK");
1990 if (!disable_packet_qfThreadInfo
)
1992 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1996 require_running (own_buf
);
1997 thread_ptr
= get_first_inferior (&all_threads
);
2000 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2001 write_ptid (own_buf
, gdb_id
);
2002 thread_ptr
= thread_ptr
->next
;
2006 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2010 require_running (own_buf
);
2011 if (thread_ptr
!= NULL
)
2014 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2015 write_ptid (own_buf
, gdb_id
);
2016 thread_ptr
= thread_ptr
->next
;
2021 sprintf (own_buf
, "l");
2027 if (the_target
->read_offsets
!= NULL
2028 && strcmp ("qOffsets", own_buf
) == 0)
2030 CORE_ADDR text
, data
;
2032 require_running (own_buf
);
2033 if (the_target
->read_offsets (&text
, &data
))
2034 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2035 (long)text
, (long)data
, (long)data
);
2037 write_enn (own_buf
);
2042 /* Protocol features query. */
2043 if (startswith (own_buf
, "qSupported")
2044 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2046 char *p
= &own_buf
[10];
2047 int gdb_supports_qRelocInsn
= 0;
2049 /* Start processing qSupported packet. */
2050 target_process_qsupported (NULL
);
2052 /* Process each feature being provided by GDB. The first
2053 feature will follow a ':', and latter features will follow
2057 char **qsupported
= NULL
;
2061 /* Two passes, to avoid nested strtok calls in
2062 target_process_qsupported. */
2063 for (p
= strtok (p
+ 1, ";");
2065 p
= strtok (NULL
, ";"))
2068 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
2069 qsupported
[count
- 1] = xstrdup (p
);
2072 for (i
= 0; i
< count
; i
++)
2075 if (strcmp (p
, "multiprocess+") == 0)
2077 /* GDB supports and wants multi-process support if
2079 if (target_supports_multi_process ())
2082 else if (strcmp (p
, "qRelocInsn+") == 0)
2084 /* GDB supports relocate instruction requests. */
2085 gdb_supports_qRelocInsn
= 1;
2087 else if (strcmp (p
, "swbreak+") == 0)
2089 /* GDB wants us to report whether a trap is caused
2090 by a software breakpoint and for us to handle PC
2091 adjustment if necessary on this target. */
2092 if (target_supports_stopped_by_sw_breakpoint ())
2093 swbreak_feature
= 1;
2095 else if (strcmp (p
, "hwbreak+") == 0)
2097 /* GDB wants us to report whether a trap is caused
2098 by a hardware breakpoint. */
2099 if (target_supports_stopped_by_hw_breakpoint ())
2100 hwbreak_feature
= 1;
2102 else if (strcmp (p
, "fork-events+") == 0)
2104 /* GDB supports and wants fork events if possible. */
2105 if (target_supports_fork_events ())
2106 report_fork_events
= 1;
2108 else if (strcmp (p
, "vfork-events+") == 0)
2110 /* GDB supports and wants vfork events if possible. */
2111 if (target_supports_vfork_events ())
2112 report_vfork_events
= 1;
2115 target_process_qsupported (p
);
2124 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2127 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2128 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2129 ";augmented-libraries-svr4-read+");
2132 /* We do not have any hook to indicate whether the non-SVR4 target
2133 backend supports qXfer:libraries:read, so always report it. */
2134 strcat (own_buf
, ";qXfer:libraries:read+");
2137 if (the_target
->read_auxv
!= NULL
)
2138 strcat (own_buf
, ";qXfer:auxv:read+");
2140 if (the_target
->qxfer_spu
!= NULL
)
2141 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2143 if (the_target
->qxfer_siginfo
!= NULL
)
2144 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2146 if (the_target
->read_loadmap
!= NULL
)
2147 strcat (own_buf
, ";qXfer:fdpic:read+");
2149 /* We always report qXfer:features:read, as targets may
2150 install XML files on a subsequent call to arch_setup.
2151 If we reported to GDB on startup that we don't support
2152 qXfer:feature:read at all, we will never be re-queried. */
2153 strcat (own_buf
, ";qXfer:features:read+");
2155 if (transport_is_reliable
)
2156 strcat (own_buf
, ";QStartNoAckMode+");
2158 if (the_target
->qxfer_osdata
!= NULL
)
2159 strcat (own_buf
, ";qXfer:osdata:read+");
2161 if (target_supports_multi_process ())
2162 strcat (own_buf
, ";multiprocess+");
2164 if (target_supports_fork_events ())
2165 strcat (own_buf
, ";fork-events+");
2167 if (target_supports_vfork_events ())
2168 strcat (own_buf
, ";vfork-events+");
2170 if (target_supports_non_stop ())
2171 strcat (own_buf
, ";QNonStop+");
2173 if (target_supports_disable_randomization ())
2174 strcat (own_buf
, ";QDisableRandomization+");
2176 strcat (own_buf
, ";qXfer:threads:read+");
2178 if (target_supports_tracepoints ())
2180 strcat (own_buf
, ";ConditionalTracepoints+");
2181 strcat (own_buf
, ";TraceStateVariables+");
2182 strcat (own_buf
, ";TracepointSource+");
2183 strcat (own_buf
, ";DisconnectedTracing+");
2184 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2185 strcat (own_buf
, ";FastTracepoints+");
2186 strcat (own_buf
, ";StaticTracepoints+");
2187 strcat (own_buf
, ";InstallInTrace+");
2188 strcat (own_buf
, ";qXfer:statictrace:read+");
2189 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2190 strcat (own_buf
, ";EnableDisableTracepoints+");
2191 strcat (own_buf
, ";QTBuffer:size+");
2192 strcat (own_buf
, ";tracenz+");
2195 /* Support target-side breakpoint conditions and commands. */
2196 if (target_supports_conditional_breakpoints ())
2197 strcat (own_buf
, ";ConditionalBreakpoints+");
2198 strcat (own_buf
, ";BreakpointCommands+");
2200 if (target_supports_agent ())
2201 strcat (own_buf
, ";QAgent+");
2203 supported_btrace_packets (own_buf
);
2205 if (target_supports_stopped_by_sw_breakpoint ())
2206 strcat (own_buf
, ";swbreak+");
2208 if (target_supports_stopped_by_hw_breakpoint ())
2209 strcat (own_buf
, ";hwbreak+");
2211 if (the_target
->pid_to_exec_file
!= NULL
)
2212 strcat (own_buf
, ";qXfer:exec-file:read+");
2214 /* Reinitialize components as needed for the new connection. */
2215 hostio_handle_new_gdb_connection ();
2216 target_handle_new_gdb_connection ();
2221 /* Thread-local storage support. */
2222 if (the_target
->get_tls_address
!= NULL
2223 && startswith (own_buf
, "qGetTLSAddr:"))
2225 char *p
= own_buf
+ 12;
2226 CORE_ADDR parts
[2], address
= 0;
2228 ptid_t ptid
= null_ptid
;
2230 require_running (own_buf
);
2232 for (i
= 0; i
< 3; i
++)
2240 p2
= strchr (p
, ',');
2253 ptid
= read_ptid (p
, NULL
);
2255 decode_address (&parts
[i
- 1], p
, len
);
2259 if (p
!= NULL
|| i
< 3)
2263 struct thread_info
*thread
= find_thread_ptid (ptid
);
2268 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2274 strcpy (own_buf
, paddress(address
));
2279 write_enn (own_buf
);
2283 /* Otherwise, pretend we do not understand this packet. */
2286 /* Windows OS Thread Information Block address support. */
2287 if (the_target
->get_tib_address
!= NULL
2288 && startswith (own_buf
, "qGetTIBAddr:"))
2293 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2295 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2298 strcpy (own_buf
, paddress(tlb
));
2303 write_enn (own_buf
);
2309 /* Handle "monitor" commands. */
2310 if (startswith (own_buf
, "qRcmd,"))
2312 char *mon
= malloc (PBUFSIZ
);
2313 int len
= strlen (own_buf
+ 6);
2317 write_enn (own_buf
);
2322 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2324 write_enn (own_buf
);
2328 mon
[len
/ 2] = '\0';
2332 if (the_target
->handle_monitor_command
== NULL
2333 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2334 /* Default processing. */
2335 handle_monitor_command (mon
, own_buf
);
2341 if (startswith (own_buf
, "qSearch:memory:"))
2343 require_running (own_buf
);
2344 handle_search_memory (own_buf
, packet_len
);
2348 if (strcmp (own_buf
, "qAttached") == 0
2349 || startswith (own_buf
, "qAttached:"))
2351 struct process_info
*process
;
2353 if (own_buf
[sizeof ("qAttached") - 1])
2355 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2356 process
= (struct process_info
*)
2357 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2361 require_running (own_buf
);
2362 process
= current_process ();
2365 if (process
== NULL
)
2367 write_enn (own_buf
);
2371 strcpy (own_buf
, process
->attached
? "1" : "0");
2375 if (startswith (own_buf
, "qCRC:"))
2377 /* CRC check (compare-section). */
2381 unsigned long long crc
;
2383 require_running (own_buf
);
2384 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2385 if (*comma
++ != ',')
2387 write_enn (own_buf
);
2390 len
= strtoul (comma
, NULL
, 16);
2391 crc
= crc32 (base
, len
, 0xffffffff);
2392 /* Check for memory failure. */
2393 if (crc
== (unsigned long long) -1)
2395 write_enn (own_buf
);
2398 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2402 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2405 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2408 /* Otherwise we didn't know what packet it was. Say we didn't
2413 static void gdb_wants_all_threads_stopped (void);
2414 static void resume (struct thread_resume
*actions
, size_t n
);
2416 /* The callback that is passed to visit_actioned_threads. */
2417 typedef int (visit_actioned_threads_callback_ftype
)
2418 (const struct thread_resume
*, struct thread_info
*);
2420 /* Struct to pass data to visit_actioned_threads. */
2422 struct visit_actioned_threads_data
2424 const struct thread_resume
*actions
;
2426 visit_actioned_threads_callback_ftype
*callback
;
2429 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2430 true if CALLBACK returns true. Returns false if no matching thread
2431 is found or CALLBACK results false.
2432 Note: This function is itself a callback for find_inferior. */
2435 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2437 struct visit_actioned_threads_data
*data
= datap
;
2438 const struct thread_resume
*actions
= data
->actions
;
2439 size_t num_actions
= data
->num_actions
;
2440 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2443 for (i
= 0; i
< num_actions
; i
++)
2445 const struct thread_resume
*action
= &actions
[i
];
2447 if (ptid_equal (action
->thread
, minus_one_ptid
)
2448 || ptid_equal (action
->thread
, entry
->id
)
2449 || ((ptid_get_pid (action
->thread
)
2450 == ptid_get_pid (entry
->id
))
2451 && ptid_get_lwp (action
->thread
) == -1))
2453 struct thread_info
*thread
= (struct thread_info
*) entry
;
2455 if ((*callback
) (action
, thread
))
2463 /* Callback for visit_actioned_threads. If the thread has a pending
2464 status to report, report it now. */
2467 handle_pending_status (const struct thread_resume
*resumption
,
2468 struct thread_info
*thread
)
2470 if (thread
->status_pending_p
)
2472 thread
->status_pending_p
= 0;
2474 last_status
= thread
->last_status
;
2475 last_ptid
= thread
->entry
.id
;
2476 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2482 /* Parse vCont packets. */
2484 handle_v_cont (char *own_buf
)
2488 struct thread_resume
*resume_info
;
2489 struct thread_resume default_action
= {{0}};
2491 /* Count the number of semicolons in the packet. There should be one
2492 for every action. */
2498 p
= strchr (p
, ';');
2501 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2502 if (resume_info
== NULL
)
2510 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2512 if (p
[0] == 's' || p
[0] == 'S')
2513 resume_info
[i
].kind
= resume_step
;
2514 else if (p
[0] == 'r')
2515 resume_info
[i
].kind
= resume_step
;
2516 else if (p
[0] == 'c' || p
[0] == 'C')
2517 resume_info
[i
].kind
= resume_continue
;
2518 else if (p
[0] == 't')
2519 resume_info
[i
].kind
= resume_stop
;
2523 if (p
[0] == 'S' || p
[0] == 'C')
2526 sig
= strtol (p
+ 1, &q
, 16);
2531 if (!gdb_signal_to_host_p (sig
))
2533 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2535 else if (p
[0] == 'r')
2539 p
= unpack_varlen_hex (p
+ 1, &addr
);
2540 resume_info
[i
].step_range_start
= addr
;
2545 p
= unpack_varlen_hex (p
+ 1, &addr
);
2546 resume_info
[i
].step_range_end
= addr
;
2555 resume_info
[i
].thread
= minus_one_ptid
;
2556 default_action
= resume_info
[i
];
2558 /* Note: we don't increment i here, we'll overwrite this entry
2559 the next time through. */
2561 else if (p
[0] == ':')
2563 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2568 if (p
[0] != ';' && p
[0] != 0)
2571 resume_info
[i
].thread
= ptid
;
2578 resume_info
[i
] = default_action
;
2580 resume (resume_info
, n
);
2585 write_enn (own_buf
);
2590 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2593 resume (struct thread_resume
*actions
, size_t num_actions
)
2597 /* Check if among the threads that GDB wants actioned, there's
2598 one with a pending status to report. If so, skip actually
2599 resuming/stopping and report the pending event
2601 struct visit_actioned_threads_data data
;
2603 data
.actions
= actions
;
2604 data
.num_actions
= num_actions
;
2605 data
.callback
= handle_pending_status
;
2606 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2612 (*the_target
->resume
) (actions
, num_actions
);
2618 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2620 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2622 /* No proper RSP support for this yet. At least return
2624 sprintf (own_buf
, "E.No unwaited-for children left.");
2625 disable_async_io ();
2629 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2630 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2631 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2632 current_thread
->last_status
= last_status
;
2634 /* From the client's perspective, all-stop mode always stops all
2635 threads implicitly (and the target backend has already done
2636 so by now). Tag all threads as "want-stopped", so we don't
2637 resume them implicitly without the client telling us to. */
2638 gdb_wants_all_threads_stopped ();
2639 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2640 disable_async_io ();
2642 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2643 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2644 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2648 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2650 handle_v_attach (char *own_buf
)
2654 pid
= strtol (own_buf
+ 8, NULL
, 16);
2655 if (pid
!= 0 && attach_inferior (pid
) == 0)
2657 /* Don't report shared library events after attaching, even if
2658 some libraries are preloaded. GDB will always poll the
2659 library list. Avoids the "stopped by shared library event"
2660 notice on the GDB side. */
2665 /* In non-stop, we don't send a resume reply. Stop events
2666 will follow up using the normal notification
2671 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2677 write_enn (own_buf
);
2682 /* Run a new program. Return 1 if successful, 0 if failure. */
2684 handle_v_run (char *own_buf
)
2686 char *p
, *next_p
, **new_argv
;
2690 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2696 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2697 if (new_argv
== NULL
)
2699 write_enn (own_buf
);
2704 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2706 next_p
= strchr (p
, ';');
2708 next_p
= p
+ strlen (p
);
2710 if (i
== 0 && p
== next_p
)
2714 /* FIXME: Fail request if out of memory instead of dying. */
2715 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2716 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2717 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2726 if (new_argv
[0] == NULL
)
2728 /* GDB didn't specify a program to run. Use the program from the
2729 last run with the new argument list. */
2731 if (program_argv
== NULL
)
2733 write_enn (own_buf
);
2734 freeargv (new_argv
);
2738 new_argv
[0] = strdup (program_argv
[0]);
2739 if (new_argv
[0] == NULL
)
2741 write_enn (own_buf
);
2742 freeargv (new_argv
);
2747 /* Free the old argv and install the new one. */
2748 freeargv (program_argv
);
2749 program_argv
= new_argv
;
2751 start_inferior (program_argv
);
2752 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2754 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2756 /* In non-stop, sending a resume reply doesn't set the general
2757 thread, but GDB assumes a vRun sets it (this is so GDB can
2758 query which is the main thread of the new inferior. */
2760 general_thread
= last_ptid
;
2766 write_enn (own_buf
);
2771 /* Kill process. Return 1 if successful, 0 if failure. */
2773 handle_v_kill (char *own_buf
)
2776 char *p
= &own_buf
[6];
2778 pid
= strtol (p
, NULL
, 16);
2781 if (pid
!= 0 && kill_inferior (pid
) == 0)
2783 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2784 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2785 last_ptid
= pid_to_ptid (pid
);
2786 discard_queued_stop_replies (last_ptid
);
2792 write_enn (own_buf
);
2797 /* Handle all of the extended 'v' packets. */
2799 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2801 if (!disable_packet_vCont
)
2803 if (startswith (own_buf
, "vCont;"))
2805 require_running (own_buf
);
2806 handle_v_cont (own_buf
);
2810 if (startswith (own_buf
, "vCont?"))
2812 strcpy (own_buf
, "vCont;c;C;s;S;t");
2813 if (target_supports_range_stepping ())
2815 own_buf
= own_buf
+ strlen (own_buf
);
2816 strcpy (own_buf
, ";r");
2822 if (startswith (own_buf
, "vFile:")
2823 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2826 if (startswith (own_buf
, "vAttach;"))
2828 if ((!extended_protocol
|| !multi_process
) && target_running ())
2830 fprintf (stderr
, "Already debugging a process\n");
2831 write_enn (own_buf
);
2834 handle_v_attach (own_buf
);
2838 if (startswith (own_buf
, "vRun;"))
2840 if ((!extended_protocol
|| !multi_process
) && target_running ())
2842 fprintf (stderr
, "Already debugging a process\n");
2843 write_enn (own_buf
);
2846 handle_v_run (own_buf
);
2850 if (startswith (own_buf
, "vKill;"))
2852 if (!target_running ())
2854 fprintf (stderr
, "No process to kill\n");
2855 write_enn (own_buf
);
2858 handle_v_kill (own_buf
);
2862 if (handle_notif_ack (own_buf
, packet_len
))
2865 /* Otherwise we didn't know what packet it was. Say we didn't
2871 /* Resume thread and wait for another event. In non-stop mode,
2872 don't really wait here, but return immediatelly to the event
2875 myresume (char *own_buf
, int step
, int sig
)
2877 struct thread_resume resume_info
[2];
2879 int valid_cont_thread
;
2881 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2882 && !ptid_equal (cont_thread
, minus_one_ptid
));
2884 if (step
|| sig
|| valid_cont_thread
)
2886 resume_info
[0].thread
= current_ptid
;
2888 resume_info
[0].kind
= resume_step
;
2890 resume_info
[0].kind
= resume_continue
;
2891 resume_info
[0].sig
= sig
;
2895 if (!valid_cont_thread
)
2897 resume_info
[n
].thread
= minus_one_ptid
;
2898 resume_info
[n
].kind
= resume_continue
;
2899 resume_info
[n
].sig
= 0;
2903 resume (resume_info
, n
);
2906 /* Callback for for_each_inferior. Make a new stop reply for each
2910 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2912 struct thread_info
*thread
= (struct thread_info
*) entry
;
2914 /* For now, assume targets that don't have this callback also don't
2915 manage the thread's last_status field. */
2916 if (the_target
->thread_stopped
== NULL
)
2918 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
2920 new_notif
->ptid
= entry
->id
;
2921 new_notif
->status
= thread
->last_status
;
2922 /* Pass the last stop reply back to GDB, but don't notify
2924 notif_event_enque (¬if_stop
,
2925 (struct notif_event
*) new_notif
);
2929 if (thread_stopped (thread
))
2934 = target_waitstatus_to_string (&thread
->last_status
);
2936 debug_printf ("Reporting thread %s as already stopped with %s\n",
2937 target_pid_to_str (entry
->id
),
2940 xfree (status_string
);
2943 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2945 /* Pass the last stop reply back to GDB, but don't notify
2947 queue_stop_reply (entry
->id
, &thread
->last_status
);
2954 /* Set this inferior threads's state as "want-stopped". We won't
2955 resume this thread until the client gives us another action for
2959 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2961 struct thread_info
*thread
= (struct thread_info
*) entry
;
2963 thread
->last_resume_kind
= resume_stop
;
2965 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2967 /* Most threads are stopped implicitly (all-stop); tag that with
2969 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2970 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2974 /* Set all threads' states as "want-stopped". */
2977 gdb_wants_all_threads_stopped (void)
2979 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2982 /* Clear the gdb_detached flag of every process. */
2985 gdb_reattached_process (struct inferior_list_entry
*entry
)
2987 struct process_info
*process
= (struct process_info
*) entry
;
2989 process
->gdb_detached
= 0;
2992 /* Callback for for_each_inferior. Clear the thread's pending status
2996 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2998 struct thread_info
*thread
= (struct thread_info
*) entry
;
3000 thread
->status_pending_p
= 0;
3003 /* Callback for for_each_inferior. If the thread is stopped with an
3004 interesting event, mark it as having a pending event. */
3007 set_pending_status_callback (struct inferior_list_entry
*entry
)
3009 struct thread_info
*thread
= (struct thread_info
*) entry
;
3011 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3012 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3013 /* A breakpoint, watchpoint or finished step from a previous
3014 GDB run isn't considered interesting for a new GDB run.
3015 If we left those pending, the new GDB could consider them
3016 random SIGTRAPs. This leaves out real async traps. We'd
3017 have to peek into the (target-specific) siginfo to
3018 distinguish those. */
3019 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3020 thread
->status_pending_p
= 1;
3023 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3024 pending status to report to GDB. */
3027 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3029 struct thread_info
*thread
= (struct thread_info
*) entry
;
3031 return thread
->status_pending_p
;
3034 /* Status handler for the '?' packet. */
3037 handle_status (char *own_buf
)
3039 /* GDB is connected, don't forward events to the target anymore. */
3040 for_each_inferior (&all_processes
, gdb_reattached_process
);
3042 /* In non-stop mode, we must send a stop reply for each stopped
3043 thread. In all-stop mode, just send one for the first stopped
3048 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3050 /* The first is sent immediatly. OK is sent if there is no
3051 stopped thread, which is the same handling of the vStopped
3052 packet (by design). */
3053 notif_write_event (¬if_stop
, own_buf
);
3057 struct inferior_list_entry
*thread
= NULL
;
3060 stabilize_threads ();
3061 gdb_wants_all_threads_stopped ();
3063 /* We can only report one status, but we might be coming out of
3064 non-stop -- if more than one thread is stopped with
3065 interesting events, leave events for the threads we're not
3066 reporting now pending. They'll be reported the next time the
3067 threads are resumed. Start by marking all interesting events
3069 for_each_inferior (&all_threads
, set_pending_status_callback
);
3071 /* Prefer the last thread that reported an event to GDB (even if
3072 that was a GDB_SIGNAL_TRAP). */
3073 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3074 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3075 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3076 thread
= find_inferior_id (&all_threads
, last_ptid
);
3078 /* If the last event thread is not found for some reason, look
3079 for some other thread that might have an event to report. */
3081 thread
= find_inferior (&all_threads
,
3082 find_status_pending_thread_callback
, NULL
);
3084 /* If we're still out of luck, simply pick the first thread in
3087 thread
= get_first_inferior (&all_threads
);
3091 struct thread_info
*tp
= (struct thread_info
*) thread
;
3093 /* We're reporting this event, so it's no longer
3095 tp
->status_pending_p
= 0;
3097 /* GDB assumes the current thread is the thread we're
3098 reporting the status for. */
3099 general_thread
= thread
->id
;
3100 set_desired_thread (1);
3102 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3103 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3106 strcpy (own_buf
, "W00");
3111 gdbserver_version (void)
3113 printf ("GNU gdbserver %s%s\n"
3114 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3115 "gdbserver is free software, covered by the "
3116 "GNU General Public License.\n"
3117 "This gdbserver was configured as \"%s\"\n",
3118 PKGVERSION
, version
, host_name
);
3122 gdbserver_usage (FILE *stream
)
3124 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3125 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3126 "\tgdbserver [OPTIONS] --multi COMM\n"
3128 "COMM may either be a tty device (for serial debugging),\n"
3129 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3130 "stdin/stdout of gdbserver.\n"
3131 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3132 "PID is the process ID to attach to, when --attach is specified.\n"
3134 "Operating modes:\n"
3136 " --attach Attach to running process PID.\n"
3137 " --multi Start server without a specific program, and\n"
3138 " only quit when explicitly commanded.\n"
3139 " --once Exit after the first connection has closed.\n"
3140 " --help Print this message and then exit.\n"
3141 " --version Display version information and exit.\n"
3145 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3146 " --disable-randomization\n"
3147 " Run PROG with address space randomization disabled.\n"
3148 " --no-disable-randomization\n"
3149 " Don't disable address space randomization when\n"
3154 " --debug Enable general debugging output.\n"
3155 " --debug-format=opt1[,opt2,...]\n"
3156 " Specify extra content in debugging output.\n"
3161 " --remote-debug Enable remote protocol debugging output.\n"
3162 " --disable-packet=opt1[,opt2,...]\n"
3163 " Disable support for RSP packets or features.\n"
3165 " vCont, Tthread, qC, qfThreadInfo and \n"
3166 " threads (disable all threading packets).\n"
3168 "For more information, consult the GDB manual (available as on-line \n"
3169 "info or a printed manual).\n");
3170 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3171 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3175 gdbserver_show_disableable (FILE *stream
)
3177 fprintf (stream
, "Disableable packets:\n"
3178 " vCont \tAll vCont packets\n"
3179 " qC \tQuerying the current thread\n"
3180 " qfThreadInfo\tThread listing\n"
3181 " Tthread \tPassing the thread specifier in the "
3182 "T stop reply packet\n"
3183 " threads \tAll of the above\n");
3187 #undef require_running
3188 #define require_running(BUF) \
3189 if (!target_running ()) \
3196 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3198 int pid
= * (int *) args
;
3200 if (ptid_get_pid (entry
->id
) == pid
)
3207 kill_inferior_callback (struct inferior_list_entry
*entry
)
3209 struct process_info
*process
= (struct process_info
*) entry
;
3210 int pid
= ptid_get_pid (process
->entry
.id
);
3212 kill_inferior (pid
);
3213 discard_queued_stop_replies (pid_to_ptid (pid
));
3216 /* Callback for for_each_inferior to detach or kill the inferior,
3217 depending on whether we attached to it or not.
3218 We inform the user whether we're detaching or killing the process
3219 as this is only called when gdbserver is about to exit. */
3222 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3224 struct process_info
*process
= (struct process_info
*) entry
;
3225 int pid
= ptid_get_pid (process
->entry
.id
);
3227 if (process
->attached
)
3228 detach_inferior (pid
);
3230 kill_inferior (pid
);
3232 discard_queued_stop_replies (pid_to_ptid (pid
));
3235 /* for_each_inferior callback for detach_or_kill_for_exit to print
3236 the pids of started inferiors. */
3239 print_started_pid (struct inferior_list_entry
*entry
)
3241 struct process_info
*process
= (struct process_info
*) entry
;
3243 if (! process
->attached
)
3245 int pid
= ptid_get_pid (process
->entry
.id
);
3246 fprintf (stderr
, " %d", pid
);
3250 /* for_each_inferior callback for detach_or_kill_for_exit to print
3251 the pids of attached inferiors. */
3254 print_attached_pid (struct inferior_list_entry
*entry
)
3256 struct process_info
*process
= (struct process_info
*) entry
;
3258 if (process
->attached
)
3260 int pid
= ptid_get_pid (process
->entry
.id
);
3261 fprintf (stderr
, " %d", pid
);
3265 /* Call this when exiting gdbserver with possible inferiors that need
3266 to be killed or detached from. */
3269 detach_or_kill_for_exit (void)
3271 /* First print a list of the inferiors we will be killing/detaching.
3272 This is to assist the user, for example, in case the inferior unexpectedly
3273 dies after we exit: did we screw up or did the inferior exit on its own?
3274 Having this info will save some head-scratching. */
3276 if (have_started_inferiors_p ())
3278 fprintf (stderr
, "Killing process(es):");
3279 for_each_inferior (&all_processes
, print_started_pid
);
3280 fprintf (stderr
, "\n");
3282 if (have_attached_inferiors_p ())
3284 fprintf (stderr
, "Detaching process(es):");
3285 for_each_inferior (&all_processes
, print_attached_pid
);
3286 fprintf (stderr
, "\n");
3289 /* Now we can kill or detach the inferiors. */
3291 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3294 /* Value that will be passed to exit(3) when gdbserver exits. */
3295 static int exit_code
;
3297 /* Cleanup version of detach_or_kill_for_exit. */
3300 detach_or_kill_for_exit_cleanup (void *ignore
)
3305 detach_or_kill_for_exit ();
3308 CATCH (exception
, RETURN_MASK_ALL
)
3311 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3317 /* Main function. This is called by the real "main" function,
3318 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3320 static void ATTRIBUTE_NORETURN
3321 captured_main (int argc
, char *argv
[])
3325 char *arg_end
, *port
;
3326 char **next_arg
= &argv
[1];
3327 volatile int multi_mode
= 0;
3328 volatile int attach
= 0;
3331 while (*next_arg
!= NULL
&& **next_arg
== '-')
3333 if (strcmp (*next_arg
, "--version") == 0)
3335 gdbserver_version ();
3338 else if (strcmp (*next_arg
, "--help") == 0)
3340 gdbserver_usage (stdout
);
3343 else if (strcmp (*next_arg
, "--attach") == 0)
3345 else if (strcmp (*next_arg
, "--multi") == 0)
3347 else if (strcmp (*next_arg
, "--wrapper") == 0)
3351 wrapper_argv
= next_arg
;
3352 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3355 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3357 gdbserver_usage (stderr
);
3361 /* Consume the "--". */
3364 else if (strcmp (*next_arg
, "--debug") == 0)
3366 else if (startswith (*next_arg
, "--debug-format="))
3369 = parse_debug_format_options ((*next_arg
)
3370 + sizeof ("--debug-format=") - 1, 0);
3372 if (error_msg
!= NULL
)
3374 fprintf (stderr
, "%s", error_msg
);
3378 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3380 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3382 gdbserver_show_disableable (stdout
);
3385 else if (startswith (*next_arg
, "--disable-packet="))
3387 char *packets
, *tok
;
3389 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3390 for (tok
= strtok (packets
, ",");
3392 tok
= strtok (NULL
, ","))
3394 if (strcmp ("vCont", tok
) == 0)
3395 disable_packet_vCont
= 1;
3396 else if (strcmp ("Tthread", tok
) == 0)
3397 disable_packet_Tthread
= 1;
3398 else if (strcmp ("qC", tok
) == 0)
3399 disable_packet_qC
= 1;
3400 else if (strcmp ("qfThreadInfo", tok
) == 0)
3401 disable_packet_qfThreadInfo
= 1;
3402 else if (strcmp ("threads", tok
) == 0)
3404 disable_packet_vCont
= 1;
3405 disable_packet_Tthread
= 1;
3406 disable_packet_qC
= 1;
3407 disable_packet_qfThreadInfo
= 1;
3411 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3413 gdbserver_show_disableable (stderr
);
3418 else if (strcmp (*next_arg
, "-") == 0)
3420 /* "-" specifies a stdio connection and is a form of port
3422 *next_arg
= STDIO_CONNECTION_NAME
;
3425 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3426 disable_randomization
= 1;
3427 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3428 disable_randomization
= 0;
3429 else if (strcmp (*next_arg
, "--once") == 0)
3433 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3443 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3445 gdbserver_usage (stderr
);
3449 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3450 opened by remote_prepare. */
3453 /* We need to know whether the remote connection is stdio before
3454 starting the inferior. Inferiors created in this scenario have
3455 stdin,stdout redirected. So do this here before we call
3457 remote_prepare (port
);
3462 /* --attach used to come after PORT, so allow it there for
3464 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3471 && (*next_arg
== NULL
3472 || (*next_arg
)[0] == '\0'
3473 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3475 || next_arg
[1] != NULL
))
3480 gdbserver_usage (stderr
);
3484 initialize_async_io ();
3486 initialize_event_loop ();
3487 if (target_supports_tracepoints ())
3488 initialize_tracepoint ();
3489 initialize_notif ();
3491 own_buf
= xmalloc (PBUFSIZ
+ 1);
3492 mem_buf
= xmalloc (PBUFSIZ
);
3494 if (pid
== 0 && *next_arg
!= NULL
)
3498 n
= argc
- (next_arg
- argv
);
3499 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3500 for (i
= 0; i
< n
; i
++)
3501 program_argv
[i
] = xstrdup (next_arg
[i
]);
3502 program_argv
[i
] = NULL
;
3504 /* Wait till we are at first instruction in program. */
3505 start_inferior (program_argv
);
3507 /* We are now (hopefully) stopped at the first instruction of
3508 the target process. This assumes that the target process was
3509 successfully created. */
3513 if (attach_inferior (pid
) == -1)
3514 error ("Attaching not supported on this target");
3516 /* Otherwise succeeded. */
3520 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3521 last_status
.value
.integer
= 0;
3522 last_ptid
= minus_one_ptid
;
3524 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3526 /* Don't report shared library events on the initial connection,
3527 even if some libraries are preloaded. Avoids the "stopped by
3528 shared library event" notice on gdb side. */
3531 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3532 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3537 if (!was_running
&& !multi_mode
)
3538 error ("No program to debug");
3545 report_fork_events
= 0;
3546 report_vfork_events
= 0;
3547 /* Be sure we're out of tfind mode. */
3548 current_traceframe
= -1;
3549 cont_thread
= null_ptid
;
3550 swbreak_feature
= 0;
3551 hwbreak_feature
= 0;
3557 /* Wait for events. This will return when all event sources
3558 are removed from the event loop. */
3559 start_event_loop ();
3561 /* If an exit was requested (using the "monitor exit"
3562 command), terminate now. The only other way to get
3563 here is for getpkt to fail; close the connection
3564 and reopen it at the top of the loop. */
3566 if (exit_requested
|| run_once
)
3567 throw_quit ("Quit");
3570 "Remote side has terminated connection. "
3571 "GDBserver will reopen the connection.\n");
3573 /* Get rid of any pending statuses. An eventual reconnection
3574 (by the same GDB instance or another) will refresh all its
3575 state from scratch. */
3576 discard_queued_stop_replies (minus_one_ptid
);
3577 for_each_inferior (&all_threads
,
3578 clear_pending_status_callback
);
3582 if (disconnected_tracing
)
3584 /* Try to enable non-stop/async mode, so we we can
3585 both wait for an async socket accept, and handle
3586 async target events simultaneously. There's also
3587 no point either in having the target always stop
3588 all threads, when we're going to pass signals
3589 down without informing GDB. */
3592 if (start_non_stop (1))
3595 /* Detaching implicitly resumes all threads;
3596 simply disconnecting does not. */
3602 "Disconnected tracing disabled; "
3603 "stopping trace run.\n");
3608 CATCH (exception
, RETURN_MASK_ERROR
)
3611 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3613 if (response_needed
)
3615 write_enn (own_buf
);
3620 throw_quit ("Quit");
3626 /* Main function. */
3629 main (int argc
, char *argv
[])
3634 captured_main (argc
, argv
);
3636 CATCH (exception
, RETURN_MASK_ALL
)
3638 if (exception
.reason
== RETURN_ERROR
)
3641 fprintf (stderr
, "%s\n", exception
.message
);
3642 fprintf (stderr
, "Exiting\n");
3650 gdb_assert_not_reached ("captured_main should never return");
3653 /* Skip PACKET until the next semi-colon (or end of string). */
3656 skip_to_semicolon (char **packet
)
3658 while (**packet
!= '\0' && **packet
!= ';')
3662 /* Process options coming from Z packets for a breakpoint. PACKET is
3663 the packet buffer. *PACKET is updated to point to the first char
3664 after the last processed option. */
3667 process_point_options (struct breakpoint
*bp
, char **packet
)
3669 char *dataptr
= *packet
;
3672 /* Check if data has the correct format. */
3673 if (*dataptr
!= ';')
3680 if (*dataptr
== ';')
3683 if (*dataptr
== 'X')
3685 /* Conditional expression. */
3687 debug_printf ("Found breakpoint condition.\n");
3688 if (!add_breakpoint_condition (bp
, &dataptr
))
3689 skip_to_semicolon (&dataptr
);
3691 else if (startswith (dataptr
, "cmds:"))
3693 dataptr
+= strlen ("cmds:");
3695 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3696 persist
= (*dataptr
== '1');
3698 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3699 skip_to_semicolon (&dataptr
);
3703 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3705 /* Skip tokens until we find one that we recognize. */
3706 skip_to_semicolon (&dataptr
);
3712 /* Event loop callback that handles a serial event. The first byte in
3713 the serial buffer gets us here. We expect characters to arrive at
3714 a brisk pace, so we read the rest of the packet with a blocking
3718 process_serial_event (void)
3729 int new_packet_len
= -1;
3731 /* Used to decide when gdbserver should exit in
3732 multi-mode/remote. */
3733 static int have_ran
= 0;
3736 have_ran
= target_running ();
3738 disable_async_io ();
3740 response_needed
= 0;
3741 packet_len
= getpkt (own_buf
);
3742 if (packet_len
<= 0)
3745 /* Force an event loop break. */
3748 response_needed
= 1;
3755 handle_query (own_buf
, packet_len
, &new_packet_len
);
3758 handle_general_set (own_buf
);
3761 require_running (own_buf
);
3766 pid
= strtol (&own_buf
[i
], NULL
, 16);
3769 pid
= ptid_get_pid (current_ptid
);
3771 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3773 struct thread_resume resume_info
;
3774 struct process_info
*process
= find_process_pid (pid
);
3776 if (process
== NULL
)
3778 write_enn (own_buf
);
3782 if (tracing
&& disconnected_tracing
)
3784 "Disconnected tracing in effect, "
3785 "leaving gdbserver attached to the process\n");
3787 if (any_persistent_commands ())
3789 "Persistent commands are present, "
3790 "leaving gdbserver attached to the process\n");
3792 /* Make sure we're in non-stop/async mode, so we we can both
3793 wait for an async socket accept, and handle async target
3794 events simultaneously. There's also no point either in
3795 having the target stop all threads, when we're going to
3796 pass signals down without informing GDB. */
3800 debug_printf ("Forcing non-stop mode\n");
3806 process
->gdb_detached
= 1;
3808 /* Detaching implicitly resumes all threads. */
3809 resume_info
.thread
= minus_one_ptid
;
3810 resume_info
.kind
= resume_continue
;
3811 resume_info
.sig
= 0;
3812 (*the_target
->resume
) (&resume_info
, 1);
3815 break; /* from switch/case */
3818 fprintf (stderr
, "Detaching from process %d\n", pid
);
3820 if (detach_inferior (pid
) != 0)
3821 write_enn (own_buf
);
3824 discard_queued_stop_replies (pid_to_ptid (pid
));
3827 if (extended_protocol
)
3829 /* Treat this like a normal program exit. */
3830 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3831 last_status
.value
.integer
= 0;
3832 last_ptid
= pid_to_ptid (pid
);
3834 current_thread
= NULL
;
3841 /* If we are attached, then we can exit. Otherwise, we
3842 need to hang around doing nothing, until the child is
3844 join_inferior (pid
);
3850 extended_protocol
= 1;
3854 handle_status (own_buf
);
3857 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3859 ptid_t gdb_id
, thread_id
;
3862 require_running (own_buf
);
3864 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3866 pid
= ptid_get_pid (gdb_id
);
3868 if (ptid_equal (gdb_id
, null_ptid
)
3869 || ptid_equal (gdb_id
, minus_one_ptid
))
3870 thread_id
= null_ptid
;
3872 && ptid_equal (pid_to_ptid (pid
),
3875 struct thread_info
*thread
=
3876 (struct thread_info
*) find_inferior (&all_threads
,
3881 write_enn (own_buf
);
3885 thread_id
= thread
->entry
.id
;
3889 thread_id
= gdb_id_to_thread_id (gdb_id
);
3890 if (ptid_equal (thread_id
, null_ptid
))
3892 write_enn (own_buf
);
3897 if (own_buf
[1] == 'g')
3899 if (ptid_equal (thread_id
, null_ptid
))
3901 /* GDB is telling us to choose any thread. Check if
3902 the currently selected thread is still valid. If
3903 it is not, select the first available. */
3904 struct thread_info
*thread
=
3905 (struct thread_info
*) find_inferior_id (&all_threads
,
3908 thread
= get_first_thread ();
3909 thread_id
= thread
->entry
.id
;
3912 general_thread
= thread_id
;
3913 set_desired_thread (1);
3914 gdb_assert (current_thread
!= NULL
);
3916 else if (own_buf
[1] == 'c')
3917 cont_thread
= thread_id
;
3923 /* Silently ignore it so that gdb can extend the protocol
3924 without compatibility headaches. */
3929 require_running (own_buf
);
3930 if (current_traceframe
>= 0)
3932 struct regcache
*regcache
3933 = new_register_cache (current_target_desc ());
3935 if (fetch_traceframe_registers (current_traceframe
,
3937 registers_to_string (regcache
, own_buf
);
3939 write_enn (own_buf
);
3940 free_register_cache (regcache
);
3944 struct regcache
*regcache
;
3946 if (!set_desired_thread (1))
3947 write_enn (own_buf
);
3950 regcache
= get_thread_regcache (current_thread
, 1);
3951 registers_to_string (regcache
, own_buf
);
3956 require_running (own_buf
);
3957 if (current_traceframe
>= 0)
3958 write_enn (own_buf
);
3961 struct regcache
*regcache
;
3963 if (!set_desired_thread (1))
3964 write_enn (own_buf
);
3967 regcache
= get_thread_regcache (current_thread
, 1);
3968 registers_from_string (regcache
, &own_buf
[1]);
3974 require_running (own_buf
);
3975 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3976 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3978 write_enn (own_buf
);
3980 bin2hex (mem_buf
, own_buf
, res
);
3983 require_running (own_buf
);
3984 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3985 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3988 write_enn (own_buf
);
3991 require_running (own_buf
);
3992 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3993 &mem_addr
, &len
, &mem_buf
) < 0
3994 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3995 write_enn (own_buf
);
4000 require_running (own_buf
);
4001 hex2bin (own_buf
+ 1, &sig
, 1);
4002 if (gdb_signal_to_host_p (sig
))
4003 signal
= gdb_signal_to_host (sig
);
4006 myresume (own_buf
, 0, signal
);
4009 require_running (own_buf
);
4010 hex2bin (own_buf
+ 1, &sig
, 1);
4011 if (gdb_signal_to_host_p (sig
))
4012 signal
= gdb_signal_to_host (sig
);
4015 myresume (own_buf
, 1, signal
);
4018 require_running (own_buf
);
4020 myresume (own_buf
, 0, signal
);
4023 require_running (own_buf
);
4025 myresume (own_buf
, 1, signal
);
4027 case 'Z': /* insert_ ... */
4029 case 'z': /* remove_ ... */
4034 char type
= own_buf
[1];
4036 const int insert
= ch
== 'Z';
4037 char *p
= &own_buf
[3];
4039 p
= unpack_varlen_hex (p
, &addr
);
4040 len
= strtol (p
+ 1, &dataptr
, 16);
4044 struct breakpoint
*bp
;
4046 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
4051 /* GDB may have sent us a list of *point parameters to
4052 be evaluated on the target's side. Read such list
4053 here. If we already have a list of parameters, GDB
4054 is telling us to drop that list and use this one
4056 clear_breakpoint_conditions_and_commands (bp
);
4057 process_point_options (bp
, &dataptr
);
4061 res
= delete_gdb_breakpoint (type
, addr
, len
);
4069 write_enn (own_buf
);
4073 response_needed
= 0;
4074 if (!target_running ())
4075 /* The packet we received doesn't make sense - but we can't
4076 reply to it, either. */
4079 fprintf (stderr
, "Killing all inferiors\n");
4080 for_each_inferior (&all_processes
, kill_inferior_callback
);
4082 /* When using the extended protocol, we wait with no program
4083 running. The traditional protocol will exit instead. */
4084 if (extended_protocol
)
4086 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4087 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4095 ptid_t gdb_id
, thread_id
;
4097 require_running (own_buf
);
4099 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4100 thread_id
= gdb_id_to_thread_id (gdb_id
);
4101 if (ptid_equal (thread_id
, null_ptid
))
4103 write_enn (own_buf
);
4107 if (mythread_alive (thread_id
))
4110 write_enn (own_buf
);
4114 response_needed
= 0;
4116 /* Restarting the inferior is only supported in the extended
4118 if (extended_protocol
)
4120 if (target_running ())
4121 for_each_inferior (&all_processes
,
4122 kill_inferior_callback
);
4123 fprintf (stderr
, "GDBserver restarting\n");
4125 /* Wait till we are at 1st instruction in prog. */
4126 if (program_argv
!= NULL
)
4128 start_inferior (program_argv
);
4129 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4131 /* Stopped at the first instruction of the target
4133 general_thread
= last_ptid
;
4137 /* Something went wrong. */
4138 general_thread
= null_ptid
;
4143 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4144 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4150 /* It is a request we don't understand. Respond with an
4151 empty packet so that gdb knows that we don't support this
4157 /* Extended (long) request. */
4158 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4162 /* It is a request we don't understand. Respond with an empty
4163 packet so that gdb knows that we don't support this
4169 if (new_packet_len
!= -1)
4170 putpkt_binary (own_buf
, new_packet_len
);
4174 response_needed
= 0;
4176 if (!extended_protocol
&& have_ran
&& !target_running ())
4178 /* In non-stop, defer exiting until GDB had a chance to query
4179 the whole vStopped list (until it gets an OK). */
4180 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4182 /* Be transparent when GDB is connected through stdio -- no
4183 need to spam GDB's console. */
4184 if (!remote_connection_is_stdio ())
4185 fprintf (stderr
, "GDBserver exiting\n");
4197 /* Event-loop callback for serial events. */
4200 handle_serial_event (int err
, gdb_client_data client_data
)
4203 debug_printf ("handling possible serial event\n");
4205 /* Really handle it. */
4206 if (process_serial_event () < 0)
4209 /* Be sure to not change the selected thread behind GDB's back.
4210 Important in the non-stop mode asynchronous protocol. */
4211 set_desired_thread (1);
4216 /* Event-loop callback for target events. */
4219 handle_target_event (int err
, gdb_client_data client_data
)
4222 debug_printf ("handling possible target event\n");
4224 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4227 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4229 /* No RSP support for this yet. */
4231 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4233 int pid
= ptid_get_pid (last_ptid
);
4234 struct process_info
*process
= find_process_pid (pid
);
4235 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4237 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4238 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4240 mark_breakpoints_out (process
);
4241 mourn_inferior (process
);
4245 /* We're reporting this thread as stopped. Update its
4246 "want-stopped" state to what the client wants, until it
4247 gets a new resume action. */
4248 current_thread
->last_resume_kind
= resume_stop
;
4249 current_thread
->last_status
= last_status
;
4254 if (!target_running ())
4256 /* The last process exited. We're done. */
4260 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4262 /* A thread stopped with a signal, but gdb isn't
4263 connected to handle it. Pass it down to the
4264 inferior, as if it wasn't being traced. */
4265 struct thread_resume resume_info
;
4268 debug_printf ("GDB not connected; forwarding event %d for"
4270 (int) last_status
.kind
,
4271 target_pid_to_str (last_ptid
));
4273 resume_info
.thread
= last_ptid
;
4274 resume_info
.kind
= resume_continue
;
4275 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4276 (*the_target
->resume
) (&resume_info
, 1);
4278 else if (debug_threads
)
4279 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4280 (int) last_status
.kind
,
4281 target_pid_to_str (last_ptid
));
4285 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4287 vstop_notif
->status
= last_status
;
4288 vstop_notif
->ptid
= last_ptid
;
4289 /* Push Stop notification. */
4290 notif_push (¬if_stop
,
4291 (struct notif_event
*) vstop_notif
);
4295 /* Be sure to not change the selected thread behind GDB's back.
4296 Important in the non-stop mode asynchronous protocol. */
4297 set_desired_thread (1);