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
;
62 int report_exec_events
;
67 /* True if the "vContSupported" feature is active. In that case, GDB
68 wants us to report whether single step is supported in the reply to
70 static int vCont_supported
;
72 /* Whether we should attempt to disable the operating system's address
73 space randomization feature before starting an inferior. */
74 int disable_randomization
= 1;
76 static char **program_argv
, **wrapper_argv
;
78 int pass_signals
[GDB_SIGNAL_LAST
];
79 int program_signals
[GDB_SIGNAL_LAST
];
80 int program_signals_p
;
82 /* The PID of the originally created or attached inferior. Used to
83 send signals to the process when GDB sends us an asynchronous interrupt
84 (user hitting Control-C in the client), and to wait for the child to exit
85 when no longer debugging it. */
87 unsigned long signal_pid
;
90 /* A file descriptor for the controlling terminal. */
93 /* TERMINAL_FD's original foreground group. */
94 pid_t old_foreground_pgrp
;
96 /* Hand back terminal ownership to the original foreground group. */
99 restore_old_foreground_pgrp (void)
101 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
105 /* Set if you want to disable optional thread related packets support
106 in gdbserver, for the sake of testing GDB against stubs that don't
108 int disable_packet_vCont
;
109 int disable_packet_Tthread
;
110 int disable_packet_qC
;
111 int disable_packet_qfThreadInfo
;
113 /* Last status reported to GDB. */
114 static struct target_waitstatus last_status
;
115 static ptid_t last_ptid
;
117 static char *own_buf
;
118 static unsigned char *mem_buf
;
120 /* A sub-class of 'struct notif_event' for stop, holding information
121 relative to a single stop reply. We keep a queue of these to
122 push to GDB in non-stop mode. */
126 struct notif_event base
;
128 /* Thread or process that got the event. */
132 struct target_waitstatus status
;
135 /* The current btrace configuration. This is gdbserver's mirror of GDB's
136 btrace configuration. */
137 static struct btrace_config current_btrace_conf
;
139 DEFINE_QUEUE_P (notif_event_p
);
141 /* Put a stop reply to the stop reply queue. */
144 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
146 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
148 new_notif
->ptid
= ptid
;
149 new_notif
->status
= *status
;
151 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
155 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
156 QUEUE_ITER (notif_event_p
) *iter
,
157 struct notif_event
*event
,
160 ptid_t filter_ptid
= *(ptid_t
*) data
;
161 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
163 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
165 if (q
->free_func
!= NULL
)
166 q
->free_func (event
);
168 QUEUE_remove_elem (notif_event_p
, q
, iter
);
177 discard_queued_stop_replies (ptid_t ptid
)
179 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
180 remove_all_on_match_ptid
, &ptid
);
184 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
186 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
188 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
191 struct notif_server notif_stop
=
193 "vStopped", "Stop", NULL
, vstop_notif_reply
,
197 target_running (void)
199 return get_first_thread () != NULL
;
203 start_inferior (char **argv
)
205 char **new_argv
= argv
;
207 if (wrapper_argv
!= NULL
)
211 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
213 for (i
= 0; argv
[i
] != NULL
; i
++)
215 new_argv
= XALLOCAVEC (char *, count
);
217 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
218 new_argv
[count
++] = wrapper_argv
[i
];
219 for (i
= 0; argv
[i
] != NULL
; i
++)
220 new_argv
[count
++] = argv
[i
];
221 new_argv
[count
] = NULL
;
227 for (i
= 0; new_argv
[i
]; ++i
)
228 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
233 signal (SIGTTOU
, SIG_DFL
);
234 signal (SIGTTIN
, SIG_DFL
);
237 signal_pid
= create_inferior (new_argv
[0], new_argv
);
239 /* FIXME: we don't actually know at this point that the create
240 actually succeeded. We won't know that until we wait. */
241 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
246 signal (SIGTTOU
, SIG_IGN
);
247 signal (SIGTTIN
, SIG_IGN
);
248 terminal_fd
= fileno (stderr
);
249 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
250 tcsetpgrp (terminal_fd
, signal_pid
);
251 atexit (restore_old_foreground_pgrp
);
254 if (wrapper_argv
!= NULL
)
256 struct thread_resume resume_info
;
258 memset (&resume_info
, 0, sizeof (resume_info
));
259 resume_info
.thread
= pid_to_ptid (signal_pid
);
260 resume_info
.kind
= resume_continue
;
263 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
265 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
269 (*the_target
->resume
) (&resume_info
, 1);
271 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
272 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
275 current_thread
->last_resume_kind
= resume_stop
;
276 current_thread
->last_status
= last_status
;
278 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
280 target_arch_setup ();
284 /* Wait till we are at 1st instruction in program, return new pid
285 (assuming success). */
286 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
288 target_arch_setup ();
290 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
291 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
293 current_thread
->last_resume_kind
= resume_stop
;
294 current_thread
->last_status
= last_status
;
297 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
303 attach_inferior (int pid
)
305 /* myattach should return -1 if attaching is unsupported,
306 0 if it succeeded, and call error() otherwise. */
308 if (myattach (pid
) != 0)
311 fprintf (stderr
, "Attached; pid = %d\n", pid
);
314 /* FIXME - It may be that we should get the SIGNAL_PID from the
315 attach function, so that it can be the main thread instead of
316 whichever we were told to attach to. */
321 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
323 /* GDB knows to ignore the first SIGSTOP after attaching to a running
324 process using the "attach" command, but this is different; it's
325 just using "target remote". Pretend it's just starting up. */
326 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
327 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
328 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
330 current_thread
->last_resume_kind
= resume_stop
;
331 current_thread
->last_status
= last_status
;
337 extern int remote_debug
;
339 /* Decode a qXfer read request. Return 0 if everything looks OK,
343 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
345 /* After the read marker and annex, qXfer looks like a
346 traditional 'm' packet. */
347 decode_m_packet (buf
, ofs
, len
);
353 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
355 /* Extract and NUL-terminate the object. */
357 while (*buf
&& *buf
!= ':')
363 /* Extract and NUL-terminate the read/write action. */
365 while (*buf
&& *buf
!= ':')
371 /* Extract and NUL-terminate the annex. */
373 while (*buf
&& *buf
!= ':')
383 /* Write the response to a successful qXfer read. Returns the
384 length of the (binary) data stored in BUF, corresponding
385 to as much of DATA/LEN as we could fit. IS_MORE controls
386 the first character of the response. */
388 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
397 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
398 &out_len
, PBUFSIZ
- 2) + 1;
401 /* Handle btrace enabling in BTS format. */
404 handle_btrace_enable_bts (struct thread_info
*thread
)
406 if (thread
->btrace
!= NULL
)
407 return "E.Btrace already enabled.";
409 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
410 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
411 ¤t_btrace_conf
);
412 if (thread
->btrace
== NULL
)
413 return "E.Could not enable btrace.";
418 /* Handle btrace enabling in Intel(R) Processor Trace format. */
421 handle_btrace_enable_pt (struct thread_info
*thread
)
423 if (thread
->btrace
!= NULL
)
424 return "E.Btrace already enabled.";
426 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
427 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
428 ¤t_btrace_conf
);
429 if (thread
->btrace
== NULL
)
430 return "E.Could not enable btrace.";
435 /* Handle btrace disabling. */
438 handle_btrace_disable (struct thread_info
*thread
)
441 if (thread
->btrace
== NULL
)
442 return "E.Branch tracing not enabled.";
444 if (target_disable_btrace (thread
->btrace
) != 0)
445 return "E.Could not disable branch tracing.";
447 thread
->btrace
= NULL
;
451 /* Handle the "Qbtrace" packet. */
454 handle_btrace_general_set (char *own_buf
)
456 struct thread_info
*thread
;
460 if (!startswith (own_buf
, "Qbtrace:"))
463 op
= own_buf
+ strlen ("Qbtrace:");
465 if (ptid_equal (general_thread
, null_ptid
)
466 || ptid_equal (general_thread
, minus_one_ptid
))
468 strcpy (own_buf
, "E.Must select a single thread.");
472 thread
= find_thread_ptid (general_thread
);
475 strcpy (own_buf
, "E.No such thread.");
481 if (strcmp (op
, "bts") == 0)
482 err
= handle_btrace_enable_bts (thread
);
483 else if (strcmp (op
, "pt") == 0)
484 err
= handle_btrace_enable_pt (thread
);
485 else if (strcmp (op
, "off") == 0)
486 err
= handle_btrace_disable (thread
);
488 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
491 strcpy (own_buf
, err
);
498 /* Handle the "Qbtrace-conf" packet. */
501 handle_btrace_conf_general_set (char *own_buf
)
503 struct thread_info
*thread
;
506 if (!startswith (own_buf
, "Qbtrace-conf:"))
509 op
= own_buf
+ strlen ("Qbtrace-conf:");
511 if (ptid_equal (general_thread
, null_ptid
)
512 || ptid_equal (general_thread
, minus_one_ptid
))
514 strcpy (own_buf
, "E.Must select a single thread.");
518 thread
= find_thread_ptid (general_thread
);
521 strcpy (own_buf
, "E.No such thread.");
525 if (startswith (op
, "bts:size="))
531 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
532 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
534 strcpy (own_buf
, "E.Bad size value.");
538 current_btrace_conf
.bts
.size
= (unsigned int) size
;
540 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
546 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
547 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
549 strcpy (own_buf
, "E.Bad size value.");
553 current_btrace_conf
.pt
.size
= (unsigned int) size
;
557 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
565 /* Handle all of the extended 'Q' packets. */
568 handle_general_set (char *own_buf
)
570 if (startswith (own_buf
, "QPassSignals:"))
572 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
573 const char *p
= own_buf
+ strlen ("QPassSignals:");
576 p
= decode_address_to_semicolon (&cursig
, p
);
577 for (i
= 0; i
< numsigs
; i
++)
583 /* Keep looping, to clear the remaining signals. */
586 p
= decode_address_to_semicolon (&cursig
, p
);
591 strcpy (own_buf
, "OK");
595 if (startswith (own_buf
, "QProgramSignals:"))
597 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
598 const char *p
= own_buf
+ strlen ("QProgramSignals:");
601 program_signals_p
= 1;
603 p
= decode_address_to_semicolon (&cursig
, p
);
604 for (i
= 0; i
< numsigs
; i
++)
608 program_signals
[i
] = 1;
610 /* Keep looping, to clear the remaining signals. */
613 p
= decode_address_to_semicolon (&cursig
, p
);
616 program_signals
[i
] = 0;
618 strcpy (own_buf
, "OK");
622 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
626 fprintf (stderr
, "[noack mode enabled]\n");
635 if (startswith (own_buf
, "QNonStop:"))
637 char *mode
= own_buf
+ 9;
641 if (strcmp (mode
, "0") == 0)
643 else if (strcmp (mode
, "1") == 0)
647 /* We don't know what this mode is, so complain to
649 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
655 req_str
= req
? "non-stop" : "all-stop";
656 if (start_non_stop (req
) != 0)
658 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
666 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
672 if (startswith (own_buf
, "QDisableRandomization:"))
674 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
677 unpack_varlen_hex (packet
, &setting
);
678 disable_randomization
= setting
;
682 if (disable_randomization
)
683 fprintf (stderr
, "[address space randomization disabled]\n");
685 fprintf (stderr
, "[address space randomization enabled]\n");
692 if (target_supports_tracepoints ()
693 && handle_tracepoint_general_set (own_buf
))
696 if (startswith (own_buf
, "QAgent:"))
698 char *mode
= own_buf
+ strlen ("QAgent:");
701 if (strcmp (mode
, "0") == 0)
703 else if (strcmp (mode
, "1") == 0)
707 /* We don't know what this value is, so complain to GDB. */
708 sprintf (own_buf
, "E.Unknown QAgent value");
712 /* Update the flag. */
715 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
720 if (handle_btrace_general_set (own_buf
))
723 if (handle_btrace_conf_general_set (own_buf
))
726 /* Otherwise we didn't know what packet it was. Say we didn't
732 get_features_xml (const char *annex
)
734 const struct target_desc
*desc
= current_target_desc ();
736 /* `desc->xmltarget' defines what to return when looking for the
737 "target.xml" file. Its contents can either be verbatim XML code
738 (prefixed with a '@') or else the name of the actual XML file to
739 be used in place of "target.xml".
741 This variable is set up from the auto-generated
742 init_registers_... routine for the current target. */
744 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
746 if (*desc
->xmltarget
== '@')
747 return desc
->xmltarget
+ 1;
749 annex
= desc
->xmltarget
;
754 extern const char *const xml_builtin
[][2];
757 /* Look for the annex. */
758 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
759 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
762 if (xml_builtin
[i
][0] != NULL
)
763 return xml_builtin
[i
][1];
771 monitor_show_help (void)
773 monitor_output ("The following monitor commands are supported:\n");
774 monitor_output (" set debug <0|1>\n");
775 monitor_output (" Enable general debugging messages\n");
776 monitor_output (" set debug-hw-points <0|1>\n");
777 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
778 monitor_output (" set remote-debug <0|1>\n");
779 monitor_output (" Enable remote protocol debugging messages\n");
780 monitor_output (" set debug-format option1[,option2,...]\n");
781 monitor_output (" Add additional information to debugging messages\n");
782 monitor_output (" Options: all, none");
783 monitor_output (", timestamp");
784 monitor_output ("\n");
785 monitor_output (" exit\n");
786 monitor_output (" Quit GDBserver\n");
789 /* Read trace frame or inferior memory. Returns the number of bytes
790 actually read, zero when no further transfer is possible, and -1 on
791 error. Return of a positive value smaller than LEN does not
792 indicate there's no more to be read, only the end of the transfer.
793 E.g., when GDB reads memory from a traceframe, a first request may
794 be served from a memory block that does not cover the whole request
795 length. A following request gets the rest served from either
796 another block (of the same traceframe) or from the read-only
800 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
804 if (current_traceframe
>= 0)
807 ULONGEST length
= len
;
809 if (traceframe_read_mem (current_traceframe
,
810 memaddr
, myaddr
, len
, &nbytes
))
812 /* Data read from trace buffer, we're done. */
815 if (!in_readonly_region (memaddr
, length
))
817 /* Otherwise we have a valid readonly case, fall through. */
818 /* (assume no half-trace half-real blocks for now) */
821 res
= prepare_to_access_memory ();
824 if (set_desired_thread (1))
825 res
= read_inferior_memory (memaddr
, myaddr
, len
);
828 done_accessing_memory ();
830 return res
== 0 ? len
: -1;
836 /* Write trace frame or inferior memory. Actually, writing to trace
837 frames is forbidden. */
840 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
842 if (current_traceframe
>= 0)
848 ret
= prepare_to_access_memory ();
851 if (set_desired_thread (1))
852 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
855 done_accessing_memory ();
861 /* Subroutine of handle_search_memory to simplify it. */
864 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
865 gdb_byte
*pattern
, unsigned pattern_len
,
866 gdb_byte
*search_buf
,
867 unsigned chunk_size
, unsigned search_buf_size
,
868 CORE_ADDR
*found_addrp
)
870 /* Prime the search buffer. */
872 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
875 warning ("Unable to access %ld bytes of target "
876 "memory at 0x%lx, halting search.",
877 (long) search_buf_size
, (long) start_addr
);
881 /* Perform the search.
883 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
884 When we've scanned N bytes we copy the trailing bytes to the start and
885 read in another N bytes. */
887 while (search_space_len
>= pattern_len
)
890 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
894 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
897 if (found_ptr
!= NULL
)
899 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
900 *found_addrp
= found_addr
;
904 /* Not found in this chunk, skip to next chunk. */
906 /* Don't let search_space_len wrap here, it's unsigned. */
907 if (search_space_len
>= chunk_size
)
908 search_space_len
-= chunk_size
;
910 search_space_len
= 0;
912 if (search_space_len
>= pattern_len
)
914 unsigned keep_len
= search_buf_size
- chunk_size
;
915 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
918 /* Copy the trailing part of the previous iteration to the front
919 of the buffer for the next iteration. */
920 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
922 nr_to_read
= (search_space_len
- keep_len
< chunk_size
923 ? search_space_len
- keep_len
926 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
927 nr_to_read
) != search_buf_size
)
929 warning ("Unable to access %ld bytes of target memory "
930 "at 0x%lx, halting search.",
931 (long) nr_to_read
, (long) read_addr
);
935 start_addr
+= chunk_size
;
944 /* Handle qSearch:memory packets. */
947 handle_search_memory (char *own_buf
, int packet_len
)
949 CORE_ADDR start_addr
;
950 CORE_ADDR search_space_len
;
952 unsigned int pattern_len
;
953 /* NOTE: also defined in find.c testcase. */
954 #define SEARCH_CHUNK_SIZE 16000
955 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
956 /* Buffer to hold memory contents for searching. */
957 gdb_byte
*search_buf
;
958 unsigned search_buf_size
;
960 CORE_ADDR found_addr
;
961 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
963 pattern
= (gdb_byte
*) malloc (packet_len
);
966 error ("Unable to allocate memory to perform the search");
967 strcpy (own_buf
, "E00");
970 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
971 packet_len
- cmd_name_len
,
972 &start_addr
, &search_space_len
,
973 pattern
, &pattern_len
) < 0)
976 error ("Error in parsing qSearch:memory packet");
977 strcpy (own_buf
, "E00");
981 search_buf_size
= chunk_size
+ pattern_len
- 1;
983 /* No point in trying to allocate a buffer larger than the search space. */
984 if (search_space_len
< search_buf_size
)
985 search_buf_size
= search_space_len
;
987 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
988 if (search_buf
== NULL
)
991 error ("Unable to allocate memory to perform the search");
992 strcpy (own_buf
, "E00");
996 found
= handle_search_memory_1 (start_addr
, search_space_len
,
997 pattern
, pattern_len
,
998 search_buf
, chunk_size
, search_buf_size
,
1002 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1003 else if (found
== 0)
1004 strcpy (own_buf
, "0");
1006 strcpy (own_buf
, "E00");
1012 #define require_running(BUF) \
1013 if (!target_running ()) \
1019 /* Parse options to --debug-format= and "monitor set debug-format".
1020 ARG is the text after "--debug-format=" or "monitor set debug-format".
1021 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1022 This triggers calls to monitor_output.
1023 The result is NULL if all options were parsed ok, otherwise an error
1024 message which the caller must free.
1026 N.B. These commands affect all debug format settings, they are not
1027 cumulative. If a format is not specified, it is turned off.
1028 However, we don't go to extra trouble with things like
1029 "monitor set debug-format all,none,timestamp".
1030 Instead we just parse them one at a time, in order.
1032 The syntax for "monitor set debug" we support here is not identical
1033 to gdb's "set debug foo on|off" because we also use this function to
1034 parse "--debug-format=foo,bar". */
1037 parse_debug_format_options (const char *arg
, int is_monitor
)
1039 VEC (char_ptr
) *options
;
1043 /* First turn all debug format options off. */
1044 debug_timestamp
= 0;
1046 /* First remove leading spaces, for "monitor set debug-format". */
1047 while (isspace (*arg
))
1050 options
= delim_string_to_char_ptr_vec (arg
, ',');
1052 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1054 if (strcmp (option
, "all") == 0)
1056 debug_timestamp
= 1;
1058 monitor_output ("All extra debug format options enabled.\n");
1060 else if (strcmp (option
, "none") == 0)
1062 debug_timestamp
= 0;
1064 monitor_output ("All extra debug format options disabled.\n");
1066 else if (strcmp (option
, "timestamp") == 0)
1068 debug_timestamp
= 1;
1070 monitor_output ("Timestamps will be added to debug output.\n");
1072 else if (*option
== '\0')
1074 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1079 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1082 free_char_ptr_vec (options
);
1087 free_char_ptr_vec (options
);
1091 /* Handle monitor commands not handled by target-specific handlers. */
1094 handle_monitor_command (char *mon
, char *own_buf
)
1096 if (strcmp (mon
, "set debug 1") == 0)
1099 monitor_output ("Debug output enabled.\n");
1101 else if (strcmp (mon
, "set debug 0") == 0)
1104 monitor_output ("Debug output disabled.\n");
1106 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1108 show_debug_regs
= 1;
1109 monitor_output ("H/W point debugging output enabled.\n");
1111 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1113 show_debug_regs
= 0;
1114 monitor_output ("H/W point debugging output disabled.\n");
1116 else if (strcmp (mon
, "set remote-debug 1") == 0)
1119 monitor_output ("Protocol debug output enabled.\n");
1121 else if (strcmp (mon
, "set remote-debug 0") == 0)
1124 monitor_output ("Protocol debug output disabled.\n");
1126 else if (startswith (mon
, "set debug-format "))
1129 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1132 if (error_msg
!= NULL
)
1134 monitor_output (error_msg
);
1135 monitor_show_help ();
1136 write_enn (own_buf
);
1140 else if (strcmp (mon
, "help") == 0)
1141 monitor_show_help ();
1142 else if (strcmp (mon
, "exit") == 0)
1146 monitor_output ("Unknown monitor command.\n\n");
1147 monitor_show_help ();
1148 write_enn (own_buf
);
1152 /* Associates a callback with each supported qXfer'able object. */
1156 /* The object this handler handles. */
1159 /* Request that the target transfer up to LEN 8-bit bytes of the
1160 target's OBJECT. The OFFSET, for a seekable object, specifies
1161 the starting point. The ANNEX can be used to provide additional
1162 data-specific information to the target.
1164 Return the number of bytes actually transfered, zero when no
1165 further transfer is possible, -1 on error, -2 when the transfer
1166 is not supported, and -3 on a verbose error message that should
1167 be preserved. Return of a positive value smaller than LEN does
1168 not indicate the end of the object, only the end of the transfer.
1170 One, and only one, of readbuf or writebuf must be non-NULL. */
1171 int (*xfer
) (const char *annex
,
1172 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1173 ULONGEST offset
, LONGEST len
);
1176 /* Handle qXfer:auxv:read. */
1179 handle_qxfer_auxv (const char *annex
,
1180 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1181 ULONGEST offset
, LONGEST len
)
1183 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1186 if (annex
[0] != '\0' || current_thread
== NULL
)
1189 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1192 /* Handle qXfer:exec-file:read. */
1195 handle_qxfer_exec_file (const char *const_annex
,
1196 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1197 ULONGEST offset
, LONGEST len
)
1203 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1206 if (const_annex
[0] == '\0')
1208 if (current_thread
== NULL
)
1211 pid
= pid_of (current_thread
);
1215 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1217 strcpy (annex
, const_annex
);
1218 annex
= unpack_varlen_hex (annex
, &pid
);
1220 if (annex
[0] != '\0')
1227 file
= (*the_target
->pid_to_exec_file
) (pid
);
1231 total_len
= strlen (file
);
1233 if (offset
> total_len
)
1236 if (offset
+ len
> total_len
)
1237 len
= total_len
- offset
;
1239 memcpy (readbuf
, file
+ offset
, len
);
1243 /* Handle qXfer:features:read. */
1246 handle_qxfer_features (const char *annex
,
1247 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1248 ULONGEST offset
, LONGEST len
)
1250 const char *document
;
1253 if (writebuf
!= NULL
)
1256 if (!target_running ())
1259 /* Grab the correct annex. */
1260 document
= get_features_xml (annex
);
1261 if (document
== NULL
)
1264 total_len
= strlen (document
);
1266 if (offset
> total_len
)
1269 if (offset
+ len
> total_len
)
1270 len
= total_len
- offset
;
1272 memcpy (readbuf
, document
+ offset
, len
);
1276 /* Worker routine for handle_qxfer_libraries.
1277 Add to the length pointed to by ARG a conservative estimate of the
1278 length needed to transmit the file name of INF. */
1281 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1283 struct dll_info
*dll
= (struct dll_info
*) inf
;
1284 unsigned int *total_len
= (unsigned int *) arg
;
1286 /* Over-estimate the necessary memory. Assume that every character
1287 in the library name must be escaped. */
1288 *total_len
+= 128 + 6 * strlen (dll
->name
);
1291 /* Worker routine for handle_qxfer_libraries.
1292 Emit the XML to describe the library in INF. */
1295 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1297 struct dll_info
*dll
= (struct dll_info
*) inf
;
1298 char **p_ptr
= (char **) arg
;
1302 strcpy (p
, " <library name=\"");
1304 name
= xml_escape_text (dll
->name
);
1308 strcpy (p
, "\"><segment address=\"");
1310 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1312 strcpy (p
, "\"/></library>\n");
1318 /* Handle qXfer:libraries:read. */
1321 handle_qxfer_libraries (const char *annex
,
1322 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1323 ULONGEST offset
, LONGEST len
)
1325 unsigned int total_len
;
1328 if (writebuf
!= NULL
)
1331 if (annex
[0] != '\0' || current_thread
== NULL
)
1335 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1338 document
= (char *) malloc (total_len
);
1339 if (document
== NULL
)
1342 strcpy (document
, "<library-list version=\"1.0\">\n");
1343 p
= document
+ strlen (document
);
1345 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1347 strcpy (p
, "</library-list>\n");
1349 total_len
= strlen (document
);
1351 if (offset
> total_len
)
1357 if (offset
+ len
> total_len
)
1358 len
= total_len
- offset
;
1360 memcpy (readbuf
, document
+ offset
, len
);
1365 /* Handle qXfer:libraries-svr4:read. */
1368 handle_qxfer_libraries_svr4 (const char *annex
,
1369 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1370 ULONGEST offset
, LONGEST len
)
1372 if (writebuf
!= NULL
)
1375 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1378 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1381 /* Handle qXfer:osadata:read. */
1384 handle_qxfer_osdata (const char *annex
,
1385 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1386 ULONGEST offset
, LONGEST len
)
1388 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1391 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1394 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1397 handle_qxfer_siginfo (const char *annex
,
1398 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1399 ULONGEST offset
, LONGEST len
)
1401 if (the_target
->qxfer_siginfo
== NULL
)
1404 if (annex
[0] != '\0' || current_thread
== NULL
)
1407 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1410 /* Handle qXfer:spu:read and qXfer:spu:write. */
1413 handle_qxfer_spu (const char *annex
,
1414 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1415 ULONGEST offset
, LONGEST len
)
1417 if (the_target
->qxfer_spu
== NULL
)
1420 if (current_thread
== NULL
)
1423 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1426 /* Handle qXfer:statictrace:read. */
1429 handle_qxfer_statictrace (const char *annex
,
1430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1431 ULONGEST offset
, LONGEST len
)
1435 if (writebuf
!= NULL
)
1438 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1441 if (traceframe_read_sdata (current_traceframe
, offset
,
1442 readbuf
, len
, &nbytes
))
1447 /* Helper for handle_qxfer_threads_proper.
1448 Emit the XML to describe the thread of INF. */
1451 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1453 struct thread_info
*thread
= (struct thread_info
*) inf
;
1454 struct buffer
*buffer
= (struct buffer
*) arg
;
1455 ptid_t ptid
= thread_to_gdb_id (thread
);
1457 int core
= target_core_of_thread (ptid
);
1460 write_ptid (ptid_s
, ptid
);
1464 sprintf (core_s
, "%d", core
);
1465 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1470 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1475 /* Helper for handle_qxfer_threads. */
1478 handle_qxfer_threads_proper (struct buffer
*buffer
)
1480 buffer_grow_str (buffer
, "<threads>\n");
1482 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1485 buffer_grow_str0 (buffer
, "</threads>\n");
1488 /* Handle qXfer:threads:read. */
1491 handle_qxfer_threads (const char *annex
,
1492 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1493 ULONGEST offset
, LONGEST len
)
1495 static char *result
= 0;
1496 static unsigned int result_length
= 0;
1498 if (writebuf
!= NULL
)
1501 if (annex
[0] != '\0')
1506 struct buffer buffer
;
1507 /* When asked for data at offset 0, generate everything and store into
1508 'result'. Successive reads will be served off 'result'. */
1512 buffer_init (&buffer
);
1514 handle_qxfer_threads_proper (&buffer
);
1516 result
= buffer_finish (&buffer
);
1517 result_length
= strlen (result
);
1518 buffer_free (&buffer
);
1521 if (offset
>= result_length
)
1523 /* We're out of data. */
1530 if (len
> result_length
- offset
)
1531 len
= result_length
- offset
;
1533 memcpy (readbuf
, result
+ offset
, len
);
1538 /* Handle qXfer:traceframe-info:read. */
1541 handle_qxfer_traceframe_info (const char *annex
,
1542 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1543 ULONGEST offset
, LONGEST len
)
1545 static char *result
= 0;
1546 static unsigned int result_length
= 0;
1548 if (writebuf
!= NULL
)
1551 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1556 struct buffer buffer
;
1558 /* When asked for data at offset 0, generate everything and
1559 store into 'result'. Successive reads will be served off
1563 buffer_init (&buffer
);
1565 traceframe_read_info (current_traceframe
, &buffer
);
1567 result
= buffer_finish (&buffer
);
1568 result_length
= strlen (result
);
1569 buffer_free (&buffer
);
1572 if (offset
>= result_length
)
1574 /* We're out of data. */
1581 if (len
> result_length
- offset
)
1582 len
= result_length
- offset
;
1584 memcpy (readbuf
, result
+ offset
, len
);
1588 /* Handle qXfer:fdpic:read. */
1591 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1592 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1594 if (the_target
->read_loadmap
== NULL
)
1597 if (current_thread
== NULL
)
1600 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1603 /* Handle qXfer:btrace:read. */
1606 handle_qxfer_btrace (const char *annex
,
1607 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1608 ULONGEST offset
, LONGEST len
)
1610 static struct buffer cache
;
1611 struct thread_info
*thread
;
1612 enum btrace_read_type type
;
1615 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1618 if (ptid_equal (general_thread
, null_ptid
)
1619 || ptid_equal (general_thread
, minus_one_ptid
))
1621 strcpy (own_buf
, "E.Must select a single thread.");
1625 thread
= find_thread_ptid (general_thread
);
1628 strcpy (own_buf
, "E.No such thread.");
1632 if (thread
->btrace
== NULL
)
1634 strcpy (own_buf
, "E.Btrace not enabled.");
1638 if (strcmp (annex
, "all") == 0)
1639 type
= BTRACE_READ_ALL
;
1640 else if (strcmp (annex
, "new") == 0)
1641 type
= BTRACE_READ_NEW
;
1642 else if (strcmp (annex
, "delta") == 0)
1643 type
= BTRACE_READ_DELTA
;
1646 strcpy (own_buf
, "E.Bad annex.");
1652 buffer_free (&cache
);
1654 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1657 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1661 else if (offset
> cache
.used_size
)
1663 buffer_free (&cache
);
1667 if (len
> cache
.used_size
- offset
)
1668 len
= cache
.used_size
- offset
;
1670 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1675 /* Handle qXfer:btrace-conf:read. */
1678 handle_qxfer_btrace_conf (const char *annex
,
1679 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1680 ULONGEST offset
, LONGEST len
)
1682 static struct buffer cache
;
1683 struct thread_info
*thread
;
1686 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1689 if (annex
[0] != '\0')
1692 if (ptid_equal (general_thread
, null_ptid
)
1693 || ptid_equal (general_thread
, minus_one_ptid
))
1695 strcpy (own_buf
, "E.Must select a single thread.");
1699 thread
= find_thread_ptid (general_thread
);
1702 strcpy (own_buf
, "E.No such thread.");
1706 if (thread
->btrace
== NULL
)
1708 strcpy (own_buf
, "E.Btrace not enabled.");
1714 buffer_free (&cache
);
1716 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1719 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1723 else if (offset
> cache
.used_size
)
1725 buffer_free (&cache
);
1729 if (len
> cache
.used_size
- offset
)
1730 len
= cache
.used_size
- offset
;
1732 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1737 static const struct qxfer qxfer_packets
[] =
1739 { "auxv", handle_qxfer_auxv
},
1740 { "btrace", handle_qxfer_btrace
},
1741 { "btrace-conf", handle_qxfer_btrace_conf
},
1742 { "exec-file", handle_qxfer_exec_file
},
1743 { "fdpic", handle_qxfer_fdpic
},
1744 { "features", handle_qxfer_features
},
1745 { "libraries", handle_qxfer_libraries
},
1746 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1747 { "osdata", handle_qxfer_osdata
},
1748 { "siginfo", handle_qxfer_siginfo
},
1749 { "spu", handle_qxfer_spu
},
1750 { "statictrace", handle_qxfer_statictrace
},
1751 { "threads", handle_qxfer_threads
},
1752 { "traceframe-info", handle_qxfer_traceframe_info
},
1756 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1764 if (!startswith (own_buf
, "qXfer:"))
1767 /* Grab the object, r/w and annex. */
1768 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1770 write_enn (own_buf
);
1775 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1778 const struct qxfer
*q
= &qxfer_packets
[i
];
1780 if (strcmp (object
, q
->object
) == 0)
1782 if (strcmp (rw
, "read") == 0)
1784 unsigned char *data
;
1789 /* Grab the offset and length. */
1790 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1792 write_enn (own_buf
);
1796 /* Read one extra byte, as an indicator of whether there is
1798 if (len
> PBUFSIZ
- 2)
1800 data
= (unsigned char *) malloc (len
+ 1);
1803 write_enn (own_buf
);
1806 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1814 /* Preserve error message. */
1817 write_enn (own_buf
);
1819 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1821 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1826 else if (strcmp (rw
, "write") == 0)
1831 unsigned char *data
;
1833 strcpy (own_buf
, "E00");
1834 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1837 write_enn (own_buf
);
1840 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1841 &ofs
, &len
, data
) < 0)
1844 write_enn (own_buf
);
1848 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1856 /* Preserve error message. */
1859 write_enn (own_buf
);
1861 sprintf (own_buf
, "%x", n
);
1874 /* Table used by the crc32 function to calcuate the checksum. */
1876 static unsigned int crc32_table
[256] =
1879 /* Compute 32 bit CRC from inferior memory.
1881 On success, return 32 bit CRC.
1882 On failure, return (unsigned long long) -1. */
1884 static unsigned long long
1885 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1887 if (!crc32_table
[1])
1889 /* Initialize the CRC table and the decoding table. */
1893 for (i
= 0; i
< 256; i
++)
1895 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1896 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1903 unsigned char byte
= 0;
1905 /* Return failure if memory read fails. */
1906 if (read_inferior_memory (base
, &byte
, 1) != 0)
1907 return (unsigned long long) -1;
1909 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1912 return (unsigned long long) crc
;
1915 /* Add supported btrace packets to BUF. */
1918 supported_btrace_packets (char *buf
)
1920 int btrace_supported
= 0;
1922 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1924 strcat (buf
, ";Qbtrace:bts+");
1925 strcat (buf
, ";Qbtrace-conf:bts:size+");
1927 btrace_supported
= 1;
1930 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1932 strcat (buf
, ";Qbtrace:pt+");
1933 strcat (buf
, ";Qbtrace-conf:pt:size+");
1935 btrace_supported
= 1;
1938 if (!btrace_supported
)
1941 strcat (buf
, ";Qbtrace:off+");
1942 strcat (buf
, ";qXfer:btrace:read+");
1943 strcat (buf
, ";qXfer:btrace-conf:read+");
1946 /* Handle all of the extended 'q' packets. */
1949 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1951 static struct inferior_list_entry
*thread_ptr
;
1953 /* Reply the current thread id. */
1954 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1957 require_running (own_buf
);
1959 if (!ptid_equal (general_thread
, null_ptid
)
1960 && !ptid_equal (general_thread
, minus_one_ptid
))
1961 gdb_id
= general_thread
;
1964 thread_ptr
= get_first_inferior (&all_threads
);
1965 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1968 sprintf (own_buf
, "QC");
1970 write_ptid (own_buf
, gdb_id
);
1974 if (strcmp ("qSymbol::", own_buf
) == 0)
1976 /* GDB is suggesting new symbols have been loaded. This may
1977 mean a new shared library has been detected as loaded, so
1978 take the opportunity to check if breakpoints we think are
1979 inserted, still are. Note that it isn't guaranteed that
1980 we'll see this when a shared library is loaded, and nor will
1981 we see this for unloads (although breakpoints in unloaded
1982 libraries shouldn't trigger), as GDB may not find symbols for
1983 the library at all. We also re-validate breakpoints when we
1984 see a second GDB breakpoint for the same address, and or when
1985 we access breakpoint shadows. */
1986 validate_breakpoints ();
1988 if (target_supports_tracepoints ())
1989 tracepoint_look_up_symbols ();
1991 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
1992 (*the_target
->look_up_symbols
) ();
1994 strcpy (own_buf
, "OK");
1998 if (!disable_packet_qfThreadInfo
)
2000 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2004 require_running (own_buf
);
2005 thread_ptr
= get_first_inferior (&all_threads
);
2008 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2009 write_ptid (own_buf
, gdb_id
);
2010 thread_ptr
= thread_ptr
->next
;
2014 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2018 require_running (own_buf
);
2019 if (thread_ptr
!= NULL
)
2022 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2023 write_ptid (own_buf
, gdb_id
);
2024 thread_ptr
= thread_ptr
->next
;
2029 sprintf (own_buf
, "l");
2035 if (the_target
->read_offsets
!= NULL
2036 && strcmp ("qOffsets", own_buf
) == 0)
2038 CORE_ADDR text
, data
;
2040 require_running (own_buf
);
2041 if (the_target
->read_offsets (&text
, &data
))
2042 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2043 (long)text
, (long)data
, (long)data
);
2045 write_enn (own_buf
);
2050 /* Protocol features query. */
2051 if (startswith (own_buf
, "qSupported")
2052 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2054 char *p
= &own_buf
[10];
2055 int gdb_supports_qRelocInsn
= 0;
2057 /* Start processing qSupported packet. */
2058 target_process_qsupported (NULL
);
2060 /* Process each feature being provided by GDB. The first
2061 feature will follow a ':', and latter features will follow
2065 char **qsupported
= NULL
;
2069 /* Two passes, to avoid nested strtok calls in
2070 target_process_qsupported. */
2071 for (p
= strtok (p
+ 1, ";");
2073 p
= strtok (NULL
, ";"))
2076 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2077 qsupported
[count
- 1] = xstrdup (p
);
2080 for (i
= 0; i
< count
; i
++)
2083 if (strcmp (p
, "multiprocess+") == 0)
2085 /* GDB supports and wants multi-process support if
2087 if (target_supports_multi_process ())
2090 else if (strcmp (p
, "qRelocInsn+") == 0)
2092 /* GDB supports relocate instruction requests. */
2093 gdb_supports_qRelocInsn
= 1;
2095 else if (strcmp (p
, "swbreak+") == 0)
2097 /* GDB wants us to report whether a trap is caused
2098 by a software breakpoint and for us to handle PC
2099 adjustment if necessary on this target. */
2100 if (target_supports_stopped_by_sw_breakpoint ())
2101 swbreak_feature
= 1;
2103 else if (strcmp (p
, "hwbreak+") == 0)
2105 /* GDB wants us to report whether a trap is caused
2106 by a hardware breakpoint. */
2107 if (target_supports_stopped_by_hw_breakpoint ())
2108 hwbreak_feature
= 1;
2110 else if (strcmp (p
, "fork-events+") == 0)
2112 /* GDB supports and wants fork events if possible. */
2113 if (target_supports_fork_events ())
2114 report_fork_events
= 1;
2116 else if (strcmp (p
, "vfork-events+") == 0)
2118 /* GDB supports and wants vfork events if possible. */
2119 if (target_supports_vfork_events ())
2120 report_vfork_events
= 1;
2122 else if (strcmp (p
, "exec-events+") == 0)
2124 /* GDB supports and wants exec events if possible. */
2125 if (target_supports_exec_events ())
2126 report_exec_events
= 1;
2128 else if (strcmp (p
, "vContSupported+") == 0)
2129 vCont_supported
= 1;
2131 target_process_qsupported (p
);
2140 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2143 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2144 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2145 ";augmented-libraries-svr4-read+");
2148 /* We do not have any hook to indicate whether the non-SVR4 target
2149 backend supports qXfer:libraries:read, so always report it. */
2150 strcat (own_buf
, ";qXfer:libraries:read+");
2153 if (the_target
->read_auxv
!= NULL
)
2154 strcat (own_buf
, ";qXfer:auxv:read+");
2156 if (the_target
->qxfer_spu
!= NULL
)
2157 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2159 if (the_target
->qxfer_siginfo
!= NULL
)
2160 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2162 if (the_target
->read_loadmap
!= NULL
)
2163 strcat (own_buf
, ";qXfer:fdpic:read+");
2165 /* We always report qXfer:features:read, as targets may
2166 install XML files on a subsequent call to arch_setup.
2167 If we reported to GDB on startup that we don't support
2168 qXfer:feature:read at all, we will never be re-queried. */
2169 strcat (own_buf
, ";qXfer:features:read+");
2171 if (transport_is_reliable
)
2172 strcat (own_buf
, ";QStartNoAckMode+");
2174 if (the_target
->qxfer_osdata
!= NULL
)
2175 strcat (own_buf
, ";qXfer:osdata:read+");
2177 if (target_supports_multi_process ())
2178 strcat (own_buf
, ";multiprocess+");
2180 if (target_supports_fork_events ())
2181 strcat (own_buf
, ";fork-events+");
2183 if (target_supports_vfork_events ())
2184 strcat (own_buf
, ";vfork-events+");
2186 if (target_supports_exec_events ())
2187 strcat (own_buf
, ";exec-events+");
2189 if (target_supports_non_stop ())
2190 strcat (own_buf
, ";QNonStop+");
2192 if (target_supports_disable_randomization ())
2193 strcat (own_buf
, ";QDisableRandomization+");
2195 strcat (own_buf
, ";qXfer:threads:read+");
2197 if (target_supports_tracepoints ())
2199 strcat (own_buf
, ";ConditionalTracepoints+");
2200 strcat (own_buf
, ";TraceStateVariables+");
2201 strcat (own_buf
, ";TracepointSource+");
2202 strcat (own_buf
, ";DisconnectedTracing+");
2203 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2204 strcat (own_buf
, ";FastTracepoints+");
2205 strcat (own_buf
, ";StaticTracepoints+");
2206 strcat (own_buf
, ";InstallInTrace+");
2207 strcat (own_buf
, ";qXfer:statictrace:read+");
2208 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2209 strcat (own_buf
, ";EnableDisableTracepoints+");
2210 strcat (own_buf
, ";QTBuffer:size+");
2211 strcat (own_buf
, ";tracenz+");
2214 if (target_supports_hardware_single_step ())
2216 /* Support target-side breakpoint conditions and commands.
2217 GDBserver needs to step over the breakpoint if the condition
2218 is false. GDBserver software single step is too simple, so
2219 disable conditional breakpoints if the target doesn't have
2220 hardware single step. */
2221 strcat (own_buf
, ";ConditionalBreakpoints+");
2223 strcat (own_buf
, ";BreakpointCommands+");
2225 if (target_supports_agent ())
2226 strcat (own_buf
, ";QAgent+");
2228 supported_btrace_packets (own_buf
);
2230 if (target_supports_stopped_by_sw_breakpoint ())
2231 strcat (own_buf
, ";swbreak+");
2233 if (target_supports_stopped_by_hw_breakpoint ())
2234 strcat (own_buf
, ";hwbreak+");
2236 if (the_target
->pid_to_exec_file
!= NULL
)
2237 strcat (own_buf
, ";qXfer:exec-file:read+");
2239 strcat (own_buf
, ";vContSupported+");
2241 /* Reinitialize components as needed for the new connection. */
2242 hostio_handle_new_gdb_connection ();
2243 target_handle_new_gdb_connection ();
2248 /* Thread-local storage support. */
2249 if (the_target
->get_tls_address
!= NULL
2250 && startswith (own_buf
, "qGetTLSAddr:"))
2252 char *p
= own_buf
+ 12;
2253 CORE_ADDR parts
[2], address
= 0;
2255 ptid_t ptid
= null_ptid
;
2257 require_running (own_buf
);
2259 for (i
= 0; i
< 3; i
++)
2267 p2
= strchr (p
, ',');
2280 ptid
= read_ptid (p
, NULL
);
2282 decode_address (&parts
[i
- 1], p
, len
);
2286 if (p
!= NULL
|| i
< 3)
2290 struct thread_info
*thread
= find_thread_ptid (ptid
);
2295 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2301 strcpy (own_buf
, paddress(address
));
2306 write_enn (own_buf
);
2310 /* Otherwise, pretend we do not understand this packet. */
2313 /* Windows OS Thread Information Block address support. */
2314 if (the_target
->get_tib_address
!= NULL
2315 && startswith (own_buf
, "qGetTIBAddr:"))
2320 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2322 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2325 strcpy (own_buf
, paddress(tlb
));
2330 write_enn (own_buf
);
2336 /* Handle "monitor" commands. */
2337 if (startswith (own_buf
, "qRcmd,"))
2339 char *mon
= (char *) malloc (PBUFSIZ
);
2340 int len
= strlen (own_buf
+ 6);
2344 write_enn (own_buf
);
2349 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2351 write_enn (own_buf
);
2355 mon
[len
/ 2] = '\0';
2359 if (the_target
->handle_monitor_command
== NULL
2360 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2361 /* Default processing. */
2362 handle_monitor_command (mon
, own_buf
);
2368 if (startswith (own_buf
, "qSearch:memory:"))
2370 require_running (own_buf
);
2371 handle_search_memory (own_buf
, packet_len
);
2375 if (strcmp (own_buf
, "qAttached") == 0
2376 || startswith (own_buf
, "qAttached:"))
2378 struct process_info
*process
;
2380 if (own_buf
[sizeof ("qAttached") - 1])
2382 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2383 process
= (struct process_info
*)
2384 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2388 require_running (own_buf
);
2389 process
= current_process ();
2392 if (process
== NULL
)
2394 write_enn (own_buf
);
2398 strcpy (own_buf
, process
->attached
? "1" : "0");
2402 if (startswith (own_buf
, "qCRC:"))
2404 /* CRC check (compare-section). */
2408 unsigned long long crc
;
2410 require_running (own_buf
);
2411 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2412 if (*comma
++ != ',')
2414 write_enn (own_buf
);
2417 len
= strtoul (comma
, NULL
, 16);
2418 crc
= crc32 (base
, len
, 0xffffffff);
2419 /* Check for memory failure. */
2420 if (crc
== (unsigned long long) -1)
2422 write_enn (own_buf
);
2425 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2429 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2432 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2435 /* Otherwise we didn't know what packet it was. Say we didn't
2440 static void gdb_wants_all_threads_stopped (void);
2441 static void resume (struct thread_resume
*actions
, size_t n
);
2443 /* The callback that is passed to visit_actioned_threads. */
2444 typedef int (visit_actioned_threads_callback_ftype
)
2445 (const struct thread_resume
*, struct thread_info
*);
2447 /* Struct to pass data to visit_actioned_threads. */
2449 struct visit_actioned_threads_data
2451 const struct thread_resume
*actions
;
2453 visit_actioned_threads_callback_ftype
*callback
;
2456 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2457 true if CALLBACK returns true. Returns false if no matching thread
2458 is found or CALLBACK results false.
2459 Note: This function is itself a callback for find_inferior. */
2462 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2464 struct visit_actioned_threads_data
*data
2465 = (struct visit_actioned_threads_data
*) datap
;
2466 const struct thread_resume
*actions
= data
->actions
;
2467 size_t num_actions
= data
->num_actions
;
2468 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2471 for (i
= 0; i
< num_actions
; i
++)
2473 const struct thread_resume
*action
= &actions
[i
];
2475 if (ptid_equal (action
->thread
, minus_one_ptid
)
2476 || ptid_equal (action
->thread
, entry
->id
)
2477 || ((ptid_get_pid (action
->thread
)
2478 == ptid_get_pid (entry
->id
))
2479 && ptid_get_lwp (action
->thread
) == -1))
2481 struct thread_info
*thread
= (struct thread_info
*) entry
;
2483 if ((*callback
) (action
, thread
))
2491 /* Callback for visit_actioned_threads. If the thread has a pending
2492 status to report, report it now. */
2495 handle_pending_status (const struct thread_resume
*resumption
,
2496 struct thread_info
*thread
)
2498 if (thread
->status_pending_p
)
2500 thread
->status_pending_p
= 0;
2502 last_status
= thread
->last_status
;
2503 last_ptid
= thread
->entry
.id
;
2504 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2510 /* Parse vCont packets. */
2512 handle_v_cont (char *own_buf
)
2516 struct thread_resume
*resume_info
;
2517 struct thread_resume default_action
= {{0}};
2519 /* Count the number of semicolons in the packet. There should be one
2520 for every action. */
2526 p
= strchr (p
, ';');
2529 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2530 if (resume_info
== NULL
)
2538 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2540 if (p
[0] == 's' || p
[0] == 'S')
2541 resume_info
[i
].kind
= resume_step
;
2542 else if (p
[0] == 'r')
2543 resume_info
[i
].kind
= resume_step
;
2544 else if (p
[0] == 'c' || p
[0] == 'C')
2545 resume_info
[i
].kind
= resume_continue
;
2546 else if (p
[0] == 't')
2547 resume_info
[i
].kind
= resume_stop
;
2551 if (p
[0] == 'S' || p
[0] == 'C')
2554 sig
= strtol (p
+ 1, &q
, 16);
2559 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2561 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2563 else if (p
[0] == 'r')
2567 p
= unpack_varlen_hex (p
+ 1, &addr
);
2568 resume_info
[i
].step_range_start
= addr
;
2573 p
= unpack_varlen_hex (p
+ 1, &addr
);
2574 resume_info
[i
].step_range_end
= addr
;
2583 resume_info
[i
].thread
= minus_one_ptid
;
2584 default_action
= resume_info
[i
];
2586 /* Note: we don't increment i here, we'll overwrite this entry
2587 the next time through. */
2589 else if (p
[0] == ':')
2591 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2596 if (p
[0] != ';' && p
[0] != 0)
2599 resume_info
[i
].thread
= ptid
;
2606 resume_info
[i
] = default_action
;
2608 resume (resume_info
, n
);
2613 write_enn (own_buf
);
2618 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2621 resume (struct thread_resume
*actions
, size_t num_actions
)
2625 /* Check if among the threads that GDB wants actioned, there's
2626 one with a pending status to report. If so, skip actually
2627 resuming/stopping and report the pending event
2629 struct visit_actioned_threads_data data
;
2631 data
.actions
= actions
;
2632 data
.num_actions
= num_actions
;
2633 data
.callback
= handle_pending_status
;
2634 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2640 (*the_target
->resume
) (actions
, num_actions
);
2646 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2648 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2650 /* No proper RSP support for this yet. At least return
2652 sprintf (own_buf
, "E.No unwaited-for children left.");
2653 disable_async_io ();
2657 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2658 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2659 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2660 current_thread
->last_status
= last_status
;
2662 /* From the client's perspective, all-stop mode always stops all
2663 threads implicitly (and the target backend has already done
2664 so by now). Tag all threads as "want-stopped", so we don't
2665 resume them implicitly without the client telling us to. */
2666 gdb_wants_all_threads_stopped ();
2667 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2668 disable_async_io ();
2670 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2671 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2672 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2676 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2678 handle_v_attach (char *own_buf
)
2682 pid
= strtol (own_buf
+ 8, NULL
, 16);
2683 if (pid
!= 0 && attach_inferior (pid
) == 0)
2685 /* Don't report shared library events after attaching, even if
2686 some libraries are preloaded. GDB will always poll the
2687 library list. Avoids the "stopped by shared library event"
2688 notice on the GDB side. */
2693 /* In non-stop, we don't send a resume reply. Stop events
2694 will follow up using the normal notification
2699 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2705 write_enn (own_buf
);
2710 /* Run a new program. Return 1 if successful, 0 if failure. */
2712 handle_v_run (char *own_buf
)
2714 char *p
, *next_p
, **new_argv
;
2718 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2724 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2725 if (new_argv
== NULL
)
2727 write_enn (own_buf
);
2732 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2734 next_p
= strchr (p
, ';');
2736 next_p
= p
+ strlen (p
);
2738 if (i
== 0 && p
== next_p
)
2742 /* FIXME: Fail request if out of memory instead of dying. */
2743 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2744 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2745 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2754 if (new_argv
[0] == NULL
)
2756 /* GDB didn't specify a program to run. Use the program from the
2757 last run with the new argument list. */
2759 if (program_argv
== NULL
)
2761 write_enn (own_buf
);
2762 freeargv (new_argv
);
2766 new_argv
[0] = strdup (program_argv
[0]);
2767 if (new_argv
[0] == NULL
)
2769 write_enn (own_buf
);
2770 freeargv (new_argv
);
2775 /* Free the old argv and install the new one. */
2776 freeargv (program_argv
);
2777 program_argv
= new_argv
;
2779 start_inferior (program_argv
);
2780 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2782 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2784 /* In non-stop, sending a resume reply doesn't set the general
2785 thread, but GDB assumes a vRun sets it (this is so GDB can
2786 query which is the main thread of the new inferior. */
2788 general_thread
= last_ptid
;
2794 write_enn (own_buf
);
2799 /* Kill process. Return 1 if successful, 0 if failure. */
2801 handle_v_kill (char *own_buf
)
2804 char *p
= &own_buf
[6];
2806 pid
= strtol (p
, NULL
, 16);
2809 if (pid
!= 0 && kill_inferior (pid
) == 0)
2811 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2812 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2813 last_ptid
= pid_to_ptid (pid
);
2814 discard_queued_stop_replies (last_ptid
);
2820 write_enn (own_buf
);
2825 /* Handle all of the extended 'v' packets. */
2827 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2829 if (!disable_packet_vCont
)
2831 if (startswith (own_buf
, "vCont;"))
2833 require_running (own_buf
);
2834 handle_v_cont (own_buf
);
2838 if (startswith (own_buf
, "vCont?"))
2840 strcpy (own_buf
, "vCont;c;C;t");
2842 if (target_supports_hardware_single_step () || !vCont_supported
)
2844 /* If target supports hardware single step, add actions s
2845 and S to the list of supported actions. On the other
2846 hand, if GDB doesn't request the supported vCont actions
2847 in qSupported packet, add s and S to the list too. */
2848 own_buf
= own_buf
+ strlen (own_buf
);
2849 strcpy (own_buf
, ";s;S");
2852 if (target_supports_range_stepping ())
2854 own_buf
= own_buf
+ strlen (own_buf
);
2855 strcpy (own_buf
, ";r");
2861 if (startswith (own_buf
, "vFile:")
2862 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2865 if (startswith (own_buf
, "vAttach;"))
2867 if ((!extended_protocol
|| !multi_process
) && target_running ())
2869 fprintf (stderr
, "Already debugging a process\n");
2870 write_enn (own_buf
);
2873 handle_v_attach (own_buf
);
2877 if (startswith (own_buf
, "vRun;"))
2879 if ((!extended_protocol
|| !multi_process
) && target_running ())
2881 fprintf (stderr
, "Already debugging a process\n");
2882 write_enn (own_buf
);
2885 handle_v_run (own_buf
);
2889 if (startswith (own_buf
, "vKill;"))
2891 if (!target_running ())
2893 fprintf (stderr
, "No process to kill\n");
2894 write_enn (own_buf
);
2897 handle_v_kill (own_buf
);
2901 if (handle_notif_ack (own_buf
, packet_len
))
2904 /* Otherwise we didn't know what packet it was. Say we didn't
2910 /* Resume thread and wait for another event. In non-stop mode,
2911 don't really wait here, but return immediatelly to the event
2914 myresume (char *own_buf
, int step
, int sig
)
2916 struct thread_resume resume_info
[2];
2918 int valid_cont_thread
;
2920 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2921 && !ptid_equal (cont_thread
, minus_one_ptid
));
2923 if (step
|| sig
|| valid_cont_thread
)
2925 resume_info
[0].thread
= current_ptid
;
2927 resume_info
[0].kind
= resume_step
;
2929 resume_info
[0].kind
= resume_continue
;
2930 resume_info
[0].sig
= sig
;
2934 if (!valid_cont_thread
)
2936 resume_info
[n
].thread
= minus_one_ptid
;
2937 resume_info
[n
].kind
= resume_continue
;
2938 resume_info
[n
].sig
= 0;
2942 resume (resume_info
, n
);
2945 /* Callback for for_each_inferior. Make a new stop reply for each
2949 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2951 struct thread_info
*thread
= (struct thread_info
*) entry
;
2953 /* For now, assume targets that don't have this callback also don't
2954 manage the thread's last_status field. */
2955 if (the_target
->thread_stopped
== NULL
)
2957 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
2959 new_notif
->ptid
= entry
->id
;
2960 new_notif
->status
= thread
->last_status
;
2961 /* Pass the last stop reply back to GDB, but don't notify
2963 notif_event_enque (¬if_stop
,
2964 (struct notif_event
*) new_notif
);
2968 if (thread_stopped (thread
))
2973 = target_waitstatus_to_string (&thread
->last_status
);
2975 debug_printf ("Reporting thread %s as already stopped with %s\n",
2976 target_pid_to_str (entry
->id
),
2979 xfree (status_string
);
2982 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2984 /* Pass the last stop reply back to GDB, but don't notify
2986 queue_stop_reply (entry
->id
, &thread
->last_status
);
2993 /* Set this inferior threads's state as "want-stopped". We won't
2994 resume this thread until the client gives us another action for
2998 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3000 struct thread_info
*thread
= (struct thread_info
*) entry
;
3002 thread
->last_resume_kind
= resume_stop
;
3004 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3006 /* Most threads are stopped implicitly (all-stop); tag that with
3008 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3009 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3013 /* Set all threads' states as "want-stopped". */
3016 gdb_wants_all_threads_stopped (void)
3018 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3021 /* Clear the gdb_detached flag of every process. */
3024 gdb_reattached_process (struct inferior_list_entry
*entry
)
3026 struct process_info
*process
= (struct process_info
*) entry
;
3028 process
->gdb_detached
= 0;
3031 /* Callback for for_each_inferior. Clear the thread's pending status
3035 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3037 struct thread_info
*thread
= (struct thread_info
*) entry
;
3039 thread
->status_pending_p
= 0;
3042 /* Callback for for_each_inferior. If the thread is stopped with an
3043 interesting event, mark it as having a pending event. */
3046 set_pending_status_callback (struct inferior_list_entry
*entry
)
3048 struct thread_info
*thread
= (struct thread_info
*) entry
;
3050 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3051 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3052 /* A breakpoint, watchpoint or finished step from a previous
3053 GDB run isn't considered interesting for a new GDB run.
3054 If we left those pending, the new GDB could consider them
3055 random SIGTRAPs. This leaves out real async traps. We'd
3056 have to peek into the (target-specific) siginfo to
3057 distinguish those. */
3058 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3059 thread
->status_pending_p
= 1;
3062 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3063 pending status to report to GDB. */
3066 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3068 struct thread_info
*thread
= (struct thread_info
*) entry
;
3070 return thread
->status_pending_p
;
3073 /* Status handler for the '?' packet. */
3076 handle_status (char *own_buf
)
3078 /* GDB is connected, don't forward events to the target anymore. */
3079 for_each_inferior (&all_processes
, gdb_reattached_process
);
3081 /* In non-stop mode, we must send a stop reply for each stopped
3082 thread. In all-stop mode, just send one for the first stopped
3087 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3089 /* The first is sent immediatly. OK is sent if there is no
3090 stopped thread, which is the same handling of the vStopped
3091 packet (by design). */
3092 notif_write_event (¬if_stop
, own_buf
);
3096 struct inferior_list_entry
*thread
= NULL
;
3099 stabilize_threads ();
3100 gdb_wants_all_threads_stopped ();
3102 /* We can only report one status, but we might be coming out of
3103 non-stop -- if more than one thread is stopped with
3104 interesting events, leave events for the threads we're not
3105 reporting now pending. They'll be reported the next time the
3106 threads are resumed. Start by marking all interesting events
3108 for_each_inferior (&all_threads
, set_pending_status_callback
);
3110 /* Prefer the last thread that reported an event to GDB (even if
3111 that was a GDB_SIGNAL_TRAP). */
3112 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3113 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3114 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3115 thread
= find_inferior_id (&all_threads
, last_ptid
);
3117 /* If the last event thread is not found for some reason, look
3118 for some other thread that might have an event to report. */
3120 thread
= find_inferior (&all_threads
,
3121 find_status_pending_thread_callback
, NULL
);
3123 /* If we're still out of luck, simply pick the first thread in
3126 thread
= get_first_inferior (&all_threads
);
3130 struct thread_info
*tp
= (struct thread_info
*) thread
;
3132 /* We're reporting this event, so it's no longer
3134 tp
->status_pending_p
= 0;
3136 /* GDB assumes the current thread is the thread we're
3137 reporting the status for. */
3138 general_thread
= thread
->id
;
3139 set_desired_thread (1);
3141 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3142 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3145 strcpy (own_buf
, "W00");
3150 gdbserver_version (void)
3152 printf ("GNU gdbserver %s%s\n"
3153 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3154 "gdbserver is free software, covered by the "
3155 "GNU General Public License.\n"
3156 "This gdbserver was configured as \"%s\"\n",
3157 PKGVERSION
, version
, host_name
);
3161 gdbserver_usage (FILE *stream
)
3163 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3164 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3165 "\tgdbserver [OPTIONS] --multi COMM\n"
3167 "COMM may either be a tty device (for serial debugging),\n"
3168 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3169 "stdin/stdout of gdbserver.\n"
3170 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3171 "PID is the process ID to attach to, when --attach is specified.\n"
3173 "Operating modes:\n"
3175 " --attach Attach to running process PID.\n"
3176 " --multi Start server without a specific program, and\n"
3177 " only quit when explicitly commanded.\n"
3178 " --once Exit after the first connection has closed.\n"
3179 " --help Print this message and then exit.\n"
3180 " --version Display version information and exit.\n"
3184 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3185 " --disable-randomization\n"
3186 " Run PROG with address space randomization disabled.\n"
3187 " --no-disable-randomization\n"
3188 " Don't disable address space randomization when\n"
3193 " --debug Enable general debugging output.\n"
3194 " --debug-format=opt1[,opt2,...]\n"
3195 " Specify extra content in debugging output.\n"
3200 " --remote-debug Enable remote protocol debugging output.\n"
3201 " --disable-packet=opt1[,opt2,...]\n"
3202 " Disable support for RSP packets or features.\n"
3204 " vCont, Tthread, qC, qfThreadInfo and \n"
3205 " threads (disable all threading packets).\n"
3207 "For more information, consult the GDB manual (available as on-line \n"
3208 "info or a printed manual).\n");
3209 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3210 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3214 gdbserver_show_disableable (FILE *stream
)
3216 fprintf (stream
, "Disableable packets:\n"
3217 " vCont \tAll vCont packets\n"
3218 " qC \tQuerying the current thread\n"
3219 " qfThreadInfo\tThread listing\n"
3220 " Tthread \tPassing the thread specifier in the "
3221 "T stop reply packet\n"
3222 " threads \tAll of the above\n");
3226 #undef require_running
3227 #define require_running(BUF) \
3228 if (!target_running ()) \
3235 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3237 int pid
= * (int *) args
;
3239 if (ptid_get_pid (entry
->id
) == pid
)
3246 kill_inferior_callback (struct inferior_list_entry
*entry
)
3248 struct process_info
*process
= (struct process_info
*) entry
;
3249 int pid
= ptid_get_pid (process
->entry
.id
);
3251 kill_inferior (pid
);
3252 discard_queued_stop_replies (pid_to_ptid (pid
));
3255 /* Callback for for_each_inferior to detach or kill the inferior,
3256 depending on whether we attached to it or not.
3257 We inform the user whether we're detaching or killing the process
3258 as this is only called when gdbserver is about to exit. */
3261 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3263 struct process_info
*process
= (struct process_info
*) entry
;
3264 int pid
= ptid_get_pid (process
->entry
.id
);
3266 if (process
->attached
)
3267 detach_inferior (pid
);
3269 kill_inferior (pid
);
3271 discard_queued_stop_replies (pid_to_ptid (pid
));
3274 /* for_each_inferior callback for detach_or_kill_for_exit to print
3275 the pids of started inferiors. */
3278 print_started_pid (struct inferior_list_entry
*entry
)
3280 struct process_info
*process
= (struct process_info
*) entry
;
3282 if (! process
->attached
)
3284 int pid
= ptid_get_pid (process
->entry
.id
);
3285 fprintf (stderr
, " %d", pid
);
3289 /* for_each_inferior callback for detach_or_kill_for_exit to print
3290 the pids of attached inferiors. */
3293 print_attached_pid (struct inferior_list_entry
*entry
)
3295 struct process_info
*process
= (struct process_info
*) entry
;
3297 if (process
->attached
)
3299 int pid
= ptid_get_pid (process
->entry
.id
);
3300 fprintf (stderr
, " %d", pid
);
3304 /* Call this when exiting gdbserver with possible inferiors that need
3305 to be killed or detached from. */
3308 detach_or_kill_for_exit (void)
3310 /* First print a list of the inferiors we will be killing/detaching.
3311 This is to assist the user, for example, in case the inferior unexpectedly
3312 dies after we exit: did we screw up or did the inferior exit on its own?
3313 Having this info will save some head-scratching. */
3315 if (have_started_inferiors_p ())
3317 fprintf (stderr
, "Killing process(es):");
3318 for_each_inferior (&all_processes
, print_started_pid
);
3319 fprintf (stderr
, "\n");
3321 if (have_attached_inferiors_p ())
3323 fprintf (stderr
, "Detaching process(es):");
3324 for_each_inferior (&all_processes
, print_attached_pid
);
3325 fprintf (stderr
, "\n");
3328 /* Now we can kill or detach the inferiors. */
3330 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3333 /* Value that will be passed to exit(3) when gdbserver exits. */
3334 static int exit_code
;
3336 /* Cleanup version of detach_or_kill_for_exit. */
3339 detach_or_kill_for_exit_cleanup (void *ignore
)
3344 detach_or_kill_for_exit ();
3347 CATCH (exception
, RETURN_MASK_ALL
)
3350 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3356 /* Main function. This is called by the real "main" function,
3357 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3359 static void ATTRIBUTE_NORETURN
3360 captured_main (int argc
, char *argv
[])
3364 char *arg_end
, *port
;
3365 char **next_arg
= &argv
[1];
3366 volatile int multi_mode
= 0;
3367 volatile int attach
= 0;
3370 while (*next_arg
!= NULL
&& **next_arg
== '-')
3372 if (strcmp (*next_arg
, "--version") == 0)
3374 gdbserver_version ();
3377 else if (strcmp (*next_arg
, "--help") == 0)
3379 gdbserver_usage (stdout
);
3382 else if (strcmp (*next_arg
, "--attach") == 0)
3384 else if (strcmp (*next_arg
, "--multi") == 0)
3386 else if (strcmp (*next_arg
, "--wrapper") == 0)
3390 wrapper_argv
= next_arg
;
3391 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3394 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3396 gdbserver_usage (stderr
);
3400 /* Consume the "--". */
3403 else if (strcmp (*next_arg
, "--debug") == 0)
3405 else if (startswith (*next_arg
, "--debug-format="))
3408 = parse_debug_format_options ((*next_arg
)
3409 + sizeof ("--debug-format=") - 1, 0);
3411 if (error_msg
!= NULL
)
3413 fprintf (stderr
, "%s", error_msg
);
3417 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3419 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3421 gdbserver_show_disableable (stdout
);
3424 else if (startswith (*next_arg
, "--disable-packet="))
3426 char *packets
, *tok
;
3428 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3429 for (tok
= strtok (packets
, ",");
3431 tok
= strtok (NULL
, ","))
3433 if (strcmp ("vCont", tok
) == 0)
3434 disable_packet_vCont
= 1;
3435 else if (strcmp ("Tthread", tok
) == 0)
3436 disable_packet_Tthread
= 1;
3437 else if (strcmp ("qC", tok
) == 0)
3438 disable_packet_qC
= 1;
3439 else if (strcmp ("qfThreadInfo", tok
) == 0)
3440 disable_packet_qfThreadInfo
= 1;
3441 else if (strcmp ("threads", tok
) == 0)
3443 disable_packet_vCont
= 1;
3444 disable_packet_Tthread
= 1;
3445 disable_packet_qC
= 1;
3446 disable_packet_qfThreadInfo
= 1;
3450 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3452 gdbserver_show_disableable (stderr
);
3457 else if (strcmp (*next_arg
, "-") == 0)
3459 /* "-" specifies a stdio connection and is a form of port
3461 *next_arg
= STDIO_CONNECTION_NAME
;
3464 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3465 disable_randomization
= 1;
3466 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3467 disable_randomization
= 0;
3468 else if (strcmp (*next_arg
, "--once") == 0)
3472 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3482 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3484 gdbserver_usage (stderr
);
3488 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3489 opened by remote_prepare. */
3492 /* We need to know whether the remote connection is stdio before
3493 starting the inferior. Inferiors created in this scenario have
3494 stdin,stdout redirected. So do this here before we call
3496 remote_prepare (port
);
3501 /* --attach used to come after PORT, so allow it there for
3503 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3510 && (*next_arg
== NULL
3511 || (*next_arg
)[0] == '\0'
3512 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3514 || next_arg
[1] != NULL
))
3519 gdbserver_usage (stderr
);
3523 initialize_async_io ();
3525 initialize_event_loop ();
3526 if (target_supports_tracepoints ())
3527 initialize_tracepoint ();
3528 initialize_notif ();
3530 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3531 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3533 if (pid
== 0 && *next_arg
!= NULL
)
3537 n
= argc
- (next_arg
- argv
);
3538 program_argv
= XNEWVEC (char *, n
+ 1);
3539 for (i
= 0; i
< n
; i
++)
3540 program_argv
[i
] = xstrdup (next_arg
[i
]);
3541 program_argv
[i
] = NULL
;
3543 /* Wait till we are at first instruction in program. */
3544 start_inferior (program_argv
);
3546 /* We are now (hopefully) stopped at the first instruction of
3547 the target process. This assumes that the target process was
3548 successfully created. */
3552 if (attach_inferior (pid
) == -1)
3553 error ("Attaching not supported on this target");
3555 /* Otherwise succeeded. */
3559 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3560 last_status
.value
.integer
= 0;
3561 last_ptid
= minus_one_ptid
;
3563 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3565 /* Don't report shared library events on the initial connection,
3566 even if some libraries are preloaded. Avoids the "stopped by
3567 shared library event" notice on gdb side. */
3570 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3571 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3576 if (!was_running
&& !multi_mode
)
3577 error ("No program to debug");
3584 report_fork_events
= 0;
3585 report_vfork_events
= 0;
3586 report_exec_events
= 0;
3587 /* Be sure we're out of tfind mode. */
3588 current_traceframe
= -1;
3589 cont_thread
= null_ptid
;
3590 swbreak_feature
= 0;
3591 hwbreak_feature
= 0;
3592 vCont_supported
= 0;
3598 /* Wait for events. This will return when all event sources
3599 are removed from the event loop. */
3600 start_event_loop ();
3602 /* If an exit was requested (using the "monitor exit"
3603 command), terminate now. The only other way to get
3604 here is for getpkt to fail; close the connection
3605 and reopen it at the top of the loop. */
3607 if (exit_requested
|| run_once
)
3608 throw_quit ("Quit");
3611 "Remote side has terminated connection. "
3612 "GDBserver will reopen the connection.\n");
3614 /* Get rid of any pending statuses. An eventual reconnection
3615 (by the same GDB instance or another) will refresh all its
3616 state from scratch. */
3617 discard_queued_stop_replies (minus_one_ptid
);
3618 for_each_inferior (&all_threads
,
3619 clear_pending_status_callback
);
3623 if (disconnected_tracing
)
3625 /* Try to enable non-stop/async mode, so we we can
3626 both wait for an async socket accept, and handle
3627 async target events simultaneously. There's also
3628 no point either in having the target always stop
3629 all threads, when we're going to pass signals
3630 down without informing GDB. */
3633 if (start_non_stop (1))
3636 /* Detaching implicitly resumes all threads;
3637 simply disconnecting does not. */
3643 "Disconnected tracing disabled; "
3644 "stopping trace run.\n");
3649 CATCH (exception
, RETURN_MASK_ERROR
)
3652 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3654 if (response_needed
)
3656 write_enn (own_buf
);
3661 throw_quit ("Quit");
3667 /* Main function. */
3670 main (int argc
, char *argv
[])
3675 captured_main (argc
, argv
);
3677 CATCH (exception
, RETURN_MASK_ALL
)
3679 if (exception
.reason
== RETURN_ERROR
)
3682 fprintf (stderr
, "%s\n", exception
.message
);
3683 fprintf (stderr
, "Exiting\n");
3691 gdb_assert_not_reached ("captured_main should never return");
3694 /* Skip PACKET until the next semi-colon (or end of string). */
3697 skip_to_semicolon (char **packet
)
3699 while (**packet
!= '\0' && **packet
!= ';')
3703 /* Process options coming from Z packets for a breakpoint. PACKET is
3704 the packet buffer. *PACKET is updated to point to the first char
3705 after the last processed option. */
3708 process_point_options (struct breakpoint
*bp
, char **packet
)
3710 char *dataptr
= *packet
;
3713 /* Check if data has the correct format. */
3714 if (*dataptr
!= ';')
3721 if (*dataptr
== ';')
3724 if (*dataptr
== 'X')
3726 /* Conditional expression. */
3728 debug_printf ("Found breakpoint condition.\n");
3729 if (!add_breakpoint_condition (bp
, &dataptr
))
3730 skip_to_semicolon (&dataptr
);
3732 else if (startswith (dataptr
, "cmds:"))
3734 dataptr
+= strlen ("cmds:");
3736 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3737 persist
= (*dataptr
== '1');
3739 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3740 skip_to_semicolon (&dataptr
);
3744 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3746 /* Skip tokens until we find one that we recognize. */
3747 skip_to_semicolon (&dataptr
);
3753 /* Event loop callback that handles a serial event. The first byte in
3754 the serial buffer gets us here. We expect characters to arrive at
3755 a brisk pace, so we read the rest of the packet with a blocking
3759 process_serial_event (void)
3770 int new_packet_len
= -1;
3772 /* Used to decide when gdbserver should exit in
3773 multi-mode/remote. */
3774 static int have_ran
= 0;
3777 have_ran
= target_running ();
3779 disable_async_io ();
3781 response_needed
= 0;
3782 packet_len
= getpkt (own_buf
);
3783 if (packet_len
<= 0)
3786 /* Force an event loop break. */
3789 response_needed
= 1;
3796 handle_query (own_buf
, packet_len
, &new_packet_len
);
3799 handle_general_set (own_buf
);
3802 require_running (own_buf
);
3807 pid
= strtol (&own_buf
[i
], NULL
, 16);
3810 pid
= ptid_get_pid (current_ptid
);
3812 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3814 struct thread_resume resume_info
;
3815 struct process_info
*process
= find_process_pid (pid
);
3817 if (process
== NULL
)
3819 write_enn (own_buf
);
3823 if (tracing
&& disconnected_tracing
)
3825 "Disconnected tracing in effect, "
3826 "leaving gdbserver attached to the process\n");
3828 if (any_persistent_commands ())
3830 "Persistent commands are present, "
3831 "leaving gdbserver attached to the process\n");
3833 /* Make sure we're in non-stop/async mode, so we we can both
3834 wait for an async socket accept, and handle async target
3835 events simultaneously. There's also no point either in
3836 having the target stop all threads, when we're going to
3837 pass signals down without informing GDB. */
3841 debug_printf ("Forcing non-stop mode\n");
3847 process
->gdb_detached
= 1;
3849 /* Detaching implicitly resumes all threads. */
3850 resume_info
.thread
= minus_one_ptid
;
3851 resume_info
.kind
= resume_continue
;
3852 resume_info
.sig
= 0;
3853 (*the_target
->resume
) (&resume_info
, 1);
3856 break; /* from switch/case */
3859 fprintf (stderr
, "Detaching from process %d\n", pid
);
3861 if (detach_inferior (pid
) != 0)
3862 write_enn (own_buf
);
3865 discard_queued_stop_replies (pid_to_ptid (pid
));
3868 if (extended_protocol
)
3870 /* Treat this like a normal program exit. */
3871 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3872 last_status
.value
.integer
= 0;
3873 last_ptid
= pid_to_ptid (pid
);
3875 current_thread
= NULL
;
3882 /* If we are attached, then we can exit. Otherwise, we
3883 need to hang around doing nothing, until the child is
3885 join_inferior (pid
);
3891 extended_protocol
= 1;
3895 handle_status (own_buf
);
3898 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3900 ptid_t gdb_id
, thread_id
;
3903 require_running (own_buf
);
3905 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3907 pid
= ptid_get_pid (gdb_id
);
3909 if (ptid_equal (gdb_id
, null_ptid
)
3910 || ptid_equal (gdb_id
, minus_one_ptid
))
3911 thread_id
= null_ptid
;
3913 && ptid_equal (pid_to_ptid (pid
),
3916 struct thread_info
*thread
=
3917 (struct thread_info
*) find_inferior (&all_threads
,
3922 write_enn (own_buf
);
3926 thread_id
= thread
->entry
.id
;
3930 thread_id
= gdb_id_to_thread_id (gdb_id
);
3931 if (ptid_equal (thread_id
, null_ptid
))
3933 write_enn (own_buf
);
3938 if (own_buf
[1] == 'g')
3940 if (ptid_equal (thread_id
, null_ptid
))
3942 /* GDB is telling us to choose any thread. Check if
3943 the currently selected thread is still valid. If
3944 it is not, select the first available. */
3945 struct thread_info
*thread
=
3946 (struct thread_info
*) find_inferior_id (&all_threads
,
3949 thread
= get_first_thread ();
3950 thread_id
= thread
->entry
.id
;
3953 general_thread
= thread_id
;
3954 set_desired_thread (1);
3955 gdb_assert (current_thread
!= NULL
);
3957 else if (own_buf
[1] == 'c')
3958 cont_thread
= thread_id
;
3964 /* Silently ignore it so that gdb can extend the protocol
3965 without compatibility headaches. */
3970 require_running (own_buf
);
3971 if (current_traceframe
>= 0)
3973 struct regcache
*regcache
3974 = new_register_cache (current_target_desc ());
3976 if (fetch_traceframe_registers (current_traceframe
,
3978 registers_to_string (regcache
, own_buf
);
3980 write_enn (own_buf
);
3981 free_register_cache (regcache
);
3985 struct regcache
*regcache
;
3987 if (!set_desired_thread (1))
3988 write_enn (own_buf
);
3991 regcache
= get_thread_regcache (current_thread
, 1);
3992 registers_to_string (regcache
, own_buf
);
3997 require_running (own_buf
);
3998 if (current_traceframe
>= 0)
3999 write_enn (own_buf
);
4002 struct regcache
*regcache
;
4004 if (!set_desired_thread (1))
4005 write_enn (own_buf
);
4008 regcache
= get_thread_regcache (current_thread
, 1);
4009 registers_from_string (regcache
, &own_buf
[1]);
4015 require_running (own_buf
);
4016 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4017 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4019 write_enn (own_buf
);
4021 bin2hex (mem_buf
, own_buf
, res
);
4024 require_running (own_buf
);
4025 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4026 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4029 write_enn (own_buf
);
4032 require_running (own_buf
);
4033 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4034 &mem_addr
, &len
, &mem_buf
) < 0
4035 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4036 write_enn (own_buf
);
4041 require_running (own_buf
);
4042 hex2bin (own_buf
+ 1, &sig
, 1);
4043 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4044 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4047 myresume (own_buf
, 0, signal
);
4050 require_running (own_buf
);
4051 hex2bin (own_buf
+ 1, &sig
, 1);
4052 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4053 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4056 myresume (own_buf
, 1, signal
);
4059 require_running (own_buf
);
4061 myresume (own_buf
, 0, signal
);
4064 require_running (own_buf
);
4066 myresume (own_buf
, 1, signal
);
4068 case 'Z': /* insert_ ... */
4070 case 'z': /* remove_ ... */
4075 char type
= own_buf
[1];
4077 const int insert
= ch
== 'Z';
4078 char *p
= &own_buf
[3];
4080 p
= unpack_varlen_hex (p
, &addr
);
4081 kind
= strtol (p
+ 1, &dataptr
, 16);
4085 struct breakpoint
*bp
;
4087 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4092 /* GDB may have sent us a list of *point parameters to
4093 be evaluated on the target's side. Read such list
4094 here. If we already have a list of parameters, GDB
4095 is telling us to drop that list and use this one
4097 clear_breakpoint_conditions_and_commands (bp
);
4098 process_point_options (bp
, &dataptr
);
4102 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4110 write_enn (own_buf
);
4114 response_needed
= 0;
4115 if (!target_running ())
4116 /* The packet we received doesn't make sense - but we can't
4117 reply to it, either. */
4120 fprintf (stderr
, "Killing all inferiors\n");
4121 for_each_inferior (&all_processes
, kill_inferior_callback
);
4123 /* When using the extended protocol, we wait with no program
4124 running. The traditional protocol will exit instead. */
4125 if (extended_protocol
)
4127 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4128 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4136 ptid_t gdb_id
, thread_id
;
4138 require_running (own_buf
);
4140 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4141 thread_id
= gdb_id_to_thread_id (gdb_id
);
4142 if (ptid_equal (thread_id
, null_ptid
))
4144 write_enn (own_buf
);
4148 if (mythread_alive (thread_id
))
4151 write_enn (own_buf
);
4155 response_needed
= 0;
4157 /* Restarting the inferior is only supported in the extended
4159 if (extended_protocol
)
4161 if (target_running ())
4162 for_each_inferior (&all_processes
,
4163 kill_inferior_callback
);
4164 fprintf (stderr
, "GDBserver restarting\n");
4166 /* Wait till we are at 1st instruction in prog. */
4167 if (program_argv
!= NULL
)
4169 start_inferior (program_argv
);
4170 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4172 /* Stopped at the first instruction of the target
4174 general_thread
= last_ptid
;
4178 /* Something went wrong. */
4179 general_thread
= null_ptid
;
4184 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4185 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4191 /* It is a request we don't understand. Respond with an
4192 empty packet so that gdb knows that we don't support this
4198 /* Extended (long) request. */
4199 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4203 /* It is a request we don't understand. Respond with an empty
4204 packet so that gdb knows that we don't support this
4210 if (new_packet_len
!= -1)
4211 putpkt_binary (own_buf
, new_packet_len
);
4215 response_needed
= 0;
4217 if (!extended_protocol
&& have_ran
&& !target_running ())
4219 /* In non-stop, defer exiting until GDB had a chance to query
4220 the whole vStopped list (until it gets an OK). */
4221 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4223 /* Be transparent when GDB is connected through stdio -- no
4224 need to spam GDB's console. */
4225 if (!remote_connection_is_stdio ())
4226 fprintf (stderr
, "GDBserver exiting\n");
4238 /* Event-loop callback for serial events. */
4241 handle_serial_event (int err
, gdb_client_data client_data
)
4244 debug_printf ("handling possible serial event\n");
4246 /* Really handle it. */
4247 if (process_serial_event () < 0)
4250 /* Be sure to not change the selected thread behind GDB's back.
4251 Important in the non-stop mode asynchronous protocol. */
4252 set_desired_thread (1);
4257 /* Event-loop callback for target events. */
4260 handle_target_event (int err
, gdb_client_data client_data
)
4263 debug_printf ("handling possible target event\n");
4265 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4268 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4270 /* No RSP support for this yet. */
4272 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4274 int pid
= ptid_get_pid (last_ptid
);
4275 struct process_info
*process
= find_process_pid (pid
);
4276 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4278 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4279 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4281 mark_breakpoints_out (process
);
4282 mourn_inferior (process
);
4286 /* We're reporting this thread as stopped. Update its
4287 "want-stopped" state to what the client wants, until it
4288 gets a new resume action. */
4289 current_thread
->last_resume_kind
= resume_stop
;
4290 current_thread
->last_status
= last_status
;
4295 if (!target_running ())
4297 /* The last process exited. We're done. */
4301 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4303 /* A thread stopped with a signal, but gdb isn't
4304 connected to handle it. Pass it down to the
4305 inferior, as if it wasn't being traced. */
4306 struct thread_resume resume_info
;
4309 debug_printf ("GDB not connected; forwarding event %d for"
4311 (int) last_status
.kind
,
4312 target_pid_to_str (last_ptid
));
4314 resume_info
.thread
= last_ptid
;
4315 resume_info
.kind
= resume_continue
;
4316 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4317 (*the_target
->resume
) (&resume_info
, 1);
4319 else if (debug_threads
)
4320 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4321 (int) last_status
.kind
,
4322 target_pid_to_str (last_ptid
));
4326 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4328 vstop_notif
->status
= last_status
;
4329 vstop_notif
->ptid
= last_ptid
;
4330 /* Push Stop notification. */
4331 notif_push (¬if_stop
,
4332 (struct notif_event
*) vstop_notif
);
4336 /* Be sure to not change the selected thread behind GDB's back.
4337 Important in the non-stop mode asynchronous protocol. */
4338 set_desired_thread (1);