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 /* Process each feature being provided by GDB. The first
2058 feature will follow a ':', and latter features will follow
2062 char **qsupported
= NULL
;
2067 /* Two passes, to avoid nested strtok calls in
2068 target_process_qsupported. */
2069 for (p
= strtok (p
+ 1, ";");
2071 p
= strtok (NULL
, ";"))
2074 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2075 qsupported
[count
- 1] = xstrdup (p
);
2078 for (i
= 0; i
< count
; i
++)
2081 if (strcmp (p
, "multiprocess+") == 0)
2083 /* GDB supports and wants multi-process support if
2085 if (target_supports_multi_process ())
2088 else if (strcmp (p
, "qRelocInsn+") == 0)
2090 /* GDB supports relocate instruction requests. */
2091 gdb_supports_qRelocInsn
= 1;
2093 else if (strcmp (p
, "swbreak+") == 0)
2095 /* GDB wants us to report whether a trap is caused
2096 by a software breakpoint and for us to handle PC
2097 adjustment if necessary on this target. */
2098 if (target_supports_stopped_by_sw_breakpoint ())
2099 swbreak_feature
= 1;
2101 else if (strcmp (p
, "hwbreak+") == 0)
2103 /* GDB wants us to report whether a trap is caused
2104 by a hardware breakpoint. */
2105 if (target_supports_stopped_by_hw_breakpoint ())
2106 hwbreak_feature
= 1;
2108 else if (strcmp (p
, "fork-events+") == 0)
2110 /* GDB supports and wants fork events if possible. */
2111 if (target_supports_fork_events ())
2112 report_fork_events
= 1;
2114 else if (strcmp (p
, "vfork-events+") == 0)
2116 /* GDB supports and wants vfork events if possible. */
2117 if (target_supports_vfork_events ())
2118 report_vfork_events
= 1;
2120 else if (strcmp (p
, "exec-events+") == 0)
2122 /* GDB supports and wants exec events if possible. */
2123 if (target_supports_exec_events ())
2124 report_exec_events
= 1;
2126 else if (strcmp (p
, "vContSupported+") == 0)
2127 vCont_supported
= 1;
2130 /* Move the unknown features all together. */
2131 qsupported
[i
] = NULL
;
2132 qsupported
[unknown
] = p
;
2137 /* Give the target backend a chance to process the unknown
2139 target_process_qsupported (qsupported
, unknown
);
2141 for (i
= 0; i
< count
; i
++)
2142 free (qsupported
[i
]);
2147 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2150 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2151 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2152 ";augmented-libraries-svr4-read+");
2155 /* We do not have any hook to indicate whether the non-SVR4 target
2156 backend supports qXfer:libraries:read, so always report it. */
2157 strcat (own_buf
, ";qXfer:libraries:read+");
2160 if (the_target
->read_auxv
!= NULL
)
2161 strcat (own_buf
, ";qXfer:auxv:read+");
2163 if (the_target
->qxfer_spu
!= NULL
)
2164 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2166 if (the_target
->qxfer_siginfo
!= NULL
)
2167 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2169 if (the_target
->read_loadmap
!= NULL
)
2170 strcat (own_buf
, ";qXfer:fdpic:read+");
2172 /* We always report qXfer:features:read, as targets may
2173 install XML files on a subsequent call to arch_setup.
2174 If we reported to GDB on startup that we don't support
2175 qXfer:feature:read at all, we will never be re-queried. */
2176 strcat (own_buf
, ";qXfer:features:read+");
2178 if (transport_is_reliable
)
2179 strcat (own_buf
, ";QStartNoAckMode+");
2181 if (the_target
->qxfer_osdata
!= NULL
)
2182 strcat (own_buf
, ";qXfer:osdata:read+");
2184 if (target_supports_multi_process ())
2185 strcat (own_buf
, ";multiprocess+");
2187 if (target_supports_fork_events ())
2188 strcat (own_buf
, ";fork-events+");
2190 if (target_supports_vfork_events ())
2191 strcat (own_buf
, ";vfork-events+");
2193 if (target_supports_exec_events ())
2194 strcat (own_buf
, ";exec-events+");
2196 if (target_supports_non_stop ())
2197 strcat (own_buf
, ";QNonStop+");
2199 if (target_supports_disable_randomization ())
2200 strcat (own_buf
, ";QDisableRandomization+");
2202 strcat (own_buf
, ";qXfer:threads:read+");
2204 if (target_supports_tracepoints ())
2206 strcat (own_buf
, ";ConditionalTracepoints+");
2207 strcat (own_buf
, ";TraceStateVariables+");
2208 strcat (own_buf
, ";TracepointSource+");
2209 strcat (own_buf
, ";DisconnectedTracing+");
2210 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2211 strcat (own_buf
, ";FastTracepoints+");
2212 strcat (own_buf
, ";StaticTracepoints+");
2213 strcat (own_buf
, ";InstallInTrace+");
2214 strcat (own_buf
, ";qXfer:statictrace:read+");
2215 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2216 strcat (own_buf
, ";EnableDisableTracepoints+");
2217 strcat (own_buf
, ";QTBuffer:size+");
2218 strcat (own_buf
, ";tracenz+");
2221 if (target_supports_hardware_single_step ())
2223 /* Support target-side breakpoint conditions and commands.
2224 GDBserver needs to step over the breakpoint if the condition
2225 is false. GDBserver software single step is too simple, so
2226 disable conditional breakpoints if the target doesn't have
2227 hardware single step. */
2228 strcat (own_buf
, ";ConditionalBreakpoints+");
2230 strcat (own_buf
, ";BreakpointCommands+");
2232 if (target_supports_agent ())
2233 strcat (own_buf
, ";QAgent+");
2235 supported_btrace_packets (own_buf
);
2237 if (target_supports_stopped_by_sw_breakpoint ())
2238 strcat (own_buf
, ";swbreak+");
2240 if (target_supports_stopped_by_hw_breakpoint ())
2241 strcat (own_buf
, ";hwbreak+");
2243 if (the_target
->pid_to_exec_file
!= NULL
)
2244 strcat (own_buf
, ";qXfer:exec-file:read+");
2246 strcat (own_buf
, ";vContSupported+");
2248 /* Reinitialize components as needed for the new connection. */
2249 hostio_handle_new_gdb_connection ();
2250 target_handle_new_gdb_connection ();
2255 /* Thread-local storage support. */
2256 if (the_target
->get_tls_address
!= NULL
2257 && startswith (own_buf
, "qGetTLSAddr:"))
2259 char *p
= own_buf
+ 12;
2260 CORE_ADDR parts
[2], address
= 0;
2262 ptid_t ptid
= null_ptid
;
2264 require_running (own_buf
);
2266 for (i
= 0; i
< 3; i
++)
2274 p2
= strchr (p
, ',');
2287 ptid
= read_ptid (p
, NULL
);
2289 decode_address (&parts
[i
- 1], p
, len
);
2293 if (p
!= NULL
|| i
< 3)
2297 struct thread_info
*thread
= find_thread_ptid (ptid
);
2302 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2308 strcpy (own_buf
, paddress(address
));
2313 write_enn (own_buf
);
2317 /* Otherwise, pretend we do not understand this packet. */
2320 /* Windows OS Thread Information Block address support. */
2321 if (the_target
->get_tib_address
!= NULL
2322 && startswith (own_buf
, "qGetTIBAddr:"))
2327 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2329 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2332 strcpy (own_buf
, paddress(tlb
));
2337 write_enn (own_buf
);
2343 /* Handle "monitor" commands. */
2344 if (startswith (own_buf
, "qRcmd,"))
2346 char *mon
= (char *) malloc (PBUFSIZ
);
2347 int len
= strlen (own_buf
+ 6);
2351 write_enn (own_buf
);
2356 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2358 write_enn (own_buf
);
2362 mon
[len
/ 2] = '\0';
2366 if (the_target
->handle_monitor_command
== NULL
2367 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2368 /* Default processing. */
2369 handle_monitor_command (mon
, own_buf
);
2375 if (startswith (own_buf
, "qSearch:memory:"))
2377 require_running (own_buf
);
2378 handle_search_memory (own_buf
, packet_len
);
2382 if (strcmp (own_buf
, "qAttached") == 0
2383 || startswith (own_buf
, "qAttached:"))
2385 struct process_info
*process
;
2387 if (own_buf
[sizeof ("qAttached") - 1])
2389 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2390 process
= (struct process_info
*)
2391 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2395 require_running (own_buf
);
2396 process
= current_process ();
2399 if (process
== NULL
)
2401 write_enn (own_buf
);
2405 strcpy (own_buf
, process
->attached
? "1" : "0");
2409 if (startswith (own_buf
, "qCRC:"))
2411 /* CRC check (compare-section). */
2415 unsigned long long crc
;
2417 require_running (own_buf
);
2418 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2419 if (*comma
++ != ',')
2421 write_enn (own_buf
);
2424 len
= strtoul (comma
, NULL
, 16);
2425 crc
= crc32 (base
, len
, 0xffffffff);
2426 /* Check for memory failure. */
2427 if (crc
== (unsigned long long) -1)
2429 write_enn (own_buf
);
2432 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2436 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2439 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2442 /* Otherwise we didn't know what packet it was. Say we didn't
2447 static void gdb_wants_all_threads_stopped (void);
2448 static void resume (struct thread_resume
*actions
, size_t n
);
2450 /* The callback that is passed to visit_actioned_threads. */
2451 typedef int (visit_actioned_threads_callback_ftype
)
2452 (const struct thread_resume
*, struct thread_info
*);
2454 /* Struct to pass data to visit_actioned_threads. */
2456 struct visit_actioned_threads_data
2458 const struct thread_resume
*actions
;
2460 visit_actioned_threads_callback_ftype
*callback
;
2463 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2464 true if CALLBACK returns true. Returns false if no matching thread
2465 is found or CALLBACK results false.
2466 Note: This function is itself a callback for find_inferior. */
2469 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2471 struct visit_actioned_threads_data
*data
2472 = (struct visit_actioned_threads_data
*) datap
;
2473 const struct thread_resume
*actions
= data
->actions
;
2474 size_t num_actions
= data
->num_actions
;
2475 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2478 for (i
= 0; i
< num_actions
; i
++)
2480 const struct thread_resume
*action
= &actions
[i
];
2482 if (ptid_equal (action
->thread
, minus_one_ptid
)
2483 || ptid_equal (action
->thread
, entry
->id
)
2484 || ((ptid_get_pid (action
->thread
)
2485 == ptid_get_pid (entry
->id
))
2486 && ptid_get_lwp (action
->thread
) == -1))
2488 struct thread_info
*thread
= (struct thread_info
*) entry
;
2490 if ((*callback
) (action
, thread
))
2498 /* Callback for visit_actioned_threads. If the thread has a pending
2499 status to report, report it now. */
2502 handle_pending_status (const struct thread_resume
*resumption
,
2503 struct thread_info
*thread
)
2505 if (thread
->status_pending_p
)
2507 thread
->status_pending_p
= 0;
2509 last_status
= thread
->last_status
;
2510 last_ptid
= thread
->entry
.id
;
2511 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2517 /* Parse vCont packets. */
2519 handle_v_cont (char *own_buf
)
2523 struct thread_resume
*resume_info
;
2524 struct thread_resume default_action
= {{0}};
2526 /* Count the number of semicolons in the packet. There should be one
2527 for every action. */
2533 p
= strchr (p
, ';');
2536 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2537 if (resume_info
== NULL
)
2545 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2547 if (p
[0] == 's' || p
[0] == 'S')
2548 resume_info
[i
].kind
= resume_step
;
2549 else if (p
[0] == 'r')
2550 resume_info
[i
].kind
= resume_step
;
2551 else if (p
[0] == 'c' || p
[0] == 'C')
2552 resume_info
[i
].kind
= resume_continue
;
2553 else if (p
[0] == 't')
2554 resume_info
[i
].kind
= resume_stop
;
2558 if (p
[0] == 'S' || p
[0] == 'C')
2561 sig
= strtol (p
+ 1, &q
, 16);
2566 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2568 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2570 else if (p
[0] == 'r')
2574 p
= unpack_varlen_hex (p
+ 1, &addr
);
2575 resume_info
[i
].step_range_start
= addr
;
2580 p
= unpack_varlen_hex (p
+ 1, &addr
);
2581 resume_info
[i
].step_range_end
= addr
;
2590 resume_info
[i
].thread
= minus_one_ptid
;
2591 default_action
= resume_info
[i
];
2593 /* Note: we don't increment i here, we'll overwrite this entry
2594 the next time through. */
2596 else if (p
[0] == ':')
2598 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2603 if (p
[0] != ';' && p
[0] != 0)
2606 resume_info
[i
].thread
= ptid
;
2613 resume_info
[i
] = default_action
;
2615 resume (resume_info
, n
);
2620 write_enn (own_buf
);
2625 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2628 resume (struct thread_resume
*actions
, size_t num_actions
)
2632 /* Check if among the threads that GDB wants actioned, there's
2633 one with a pending status to report. If so, skip actually
2634 resuming/stopping and report the pending event
2636 struct visit_actioned_threads_data data
;
2638 data
.actions
= actions
;
2639 data
.num_actions
= num_actions
;
2640 data
.callback
= handle_pending_status
;
2641 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2647 (*the_target
->resume
) (actions
, num_actions
);
2653 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2655 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2657 /* No proper RSP support for this yet. At least return
2659 sprintf (own_buf
, "E.No unwaited-for children left.");
2660 disable_async_io ();
2664 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2665 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2666 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2667 current_thread
->last_status
= last_status
;
2669 /* From the client's perspective, all-stop mode always stops all
2670 threads implicitly (and the target backend has already done
2671 so by now). Tag all threads as "want-stopped", so we don't
2672 resume them implicitly without the client telling us to. */
2673 gdb_wants_all_threads_stopped ();
2674 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2675 disable_async_io ();
2677 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2678 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2679 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2683 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2685 handle_v_attach (char *own_buf
)
2689 pid
= strtol (own_buf
+ 8, NULL
, 16);
2690 if (pid
!= 0 && attach_inferior (pid
) == 0)
2692 /* Don't report shared library events after attaching, even if
2693 some libraries are preloaded. GDB will always poll the
2694 library list. Avoids the "stopped by shared library event"
2695 notice on the GDB side. */
2700 /* In non-stop, we don't send a resume reply. Stop events
2701 will follow up using the normal notification
2706 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2712 write_enn (own_buf
);
2717 /* Run a new program. Return 1 if successful, 0 if failure. */
2719 handle_v_run (char *own_buf
)
2721 char *p
, *next_p
, **new_argv
;
2725 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2731 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2732 if (new_argv
== NULL
)
2734 write_enn (own_buf
);
2739 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2741 next_p
= strchr (p
, ';');
2743 next_p
= p
+ strlen (p
);
2745 if (i
== 0 && p
== next_p
)
2749 /* FIXME: Fail request if out of memory instead of dying. */
2750 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2751 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2752 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2761 if (new_argv
[0] == NULL
)
2763 /* GDB didn't specify a program to run. Use the program from the
2764 last run with the new argument list. */
2766 if (program_argv
== NULL
)
2768 write_enn (own_buf
);
2769 freeargv (new_argv
);
2773 new_argv
[0] = strdup (program_argv
[0]);
2774 if (new_argv
[0] == NULL
)
2776 write_enn (own_buf
);
2777 freeargv (new_argv
);
2782 /* Free the old argv and install the new one. */
2783 freeargv (program_argv
);
2784 program_argv
= new_argv
;
2786 start_inferior (program_argv
);
2787 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2789 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2791 /* In non-stop, sending a resume reply doesn't set the general
2792 thread, but GDB assumes a vRun sets it (this is so GDB can
2793 query which is the main thread of the new inferior. */
2795 general_thread
= last_ptid
;
2801 write_enn (own_buf
);
2806 /* Kill process. Return 1 if successful, 0 if failure. */
2808 handle_v_kill (char *own_buf
)
2811 char *p
= &own_buf
[6];
2813 pid
= strtol (p
, NULL
, 16);
2816 if (pid
!= 0 && kill_inferior (pid
) == 0)
2818 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2819 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2820 last_ptid
= pid_to_ptid (pid
);
2821 discard_queued_stop_replies (last_ptid
);
2827 write_enn (own_buf
);
2832 /* Handle all of the extended 'v' packets. */
2834 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2836 if (!disable_packet_vCont
)
2838 if (startswith (own_buf
, "vCont;"))
2840 require_running (own_buf
);
2841 handle_v_cont (own_buf
);
2845 if (startswith (own_buf
, "vCont?"))
2847 strcpy (own_buf
, "vCont;c;C;t");
2849 if (target_supports_hardware_single_step () || !vCont_supported
)
2851 /* If target supports hardware single step, add actions s
2852 and S to the list of supported actions. On the other
2853 hand, if GDB doesn't request the supported vCont actions
2854 in qSupported packet, add s and S to the list too. */
2855 own_buf
= own_buf
+ strlen (own_buf
);
2856 strcpy (own_buf
, ";s;S");
2859 if (target_supports_range_stepping ())
2861 own_buf
= own_buf
+ strlen (own_buf
);
2862 strcpy (own_buf
, ";r");
2868 if (startswith (own_buf
, "vFile:")
2869 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2872 if (startswith (own_buf
, "vAttach;"))
2874 if ((!extended_protocol
|| !multi_process
) && target_running ())
2876 fprintf (stderr
, "Already debugging a process\n");
2877 write_enn (own_buf
);
2880 handle_v_attach (own_buf
);
2884 if (startswith (own_buf
, "vRun;"))
2886 if ((!extended_protocol
|| !multi_process
) && target_running ())
2888 fprintf (stderr
, "Already debugging a process\n");
2889 write_enn (own_buf
);
2892 handle_v_run (own_buf
);
2896 if (startswith (own_buf
, "vKill;"))
2898 if (!target_running ())
2900 fprintf (stderr
, "No process to kill\n");
2901 write_enn (own_buf
);
2904 handle_v_kill (own_buf
);
2908 if (handle_notif_ack (own_buf
, packet_len
))
2911 /* Otherwise we didn't know what packet it was. Say we didn't
2917 /* Resume thread and wait for another event. In non-stop mode,
2918 don't really wait here, but return immediatelly to the event
2921 myresume (char *own_buf
, int step
, int sig
)
2923 struct thread_resume resume_info
[2];
2925 int valid_cont_thread
;
2927 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2928 && !ptid_equal (cont_thread
, minus_one_ptid
));
2930 if (step
|| sig
|| valid_cont_thread
)
2932 resume_info
[0].thread
= current_ptid
;
2934 resume_info
[0].kind
= resume_step
;
2936 resume_info
[0].kind
= resume_continue
;
2937 resume_info
[0].sig
= sig
;
2941 if (!valid_cont_thread
)
2943 resume_info
[n
].thread
= minus_one_ptid
;
2944 resume_info
[n
].kind
= resume_continue
;
2945 resume_info
[n
].sig
= 0;
2949 resume (resume_info
, n
);
2952 /* Callback for for_each_inferior. Make a new stop reply for each
2956 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2958 struct thread_info
*thread
= (struct thread_info
*) entry
;
2960 /* For now, assume targets that don't have this callback also don't
2961 manage the thread's last_status field. */
2962 if (the_target
->thread_stopped
== NULL
)
2964 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
2966 new_notif
->ptid
= entry
->id
;
2967 new_notif
->status
= thread
->last_status
;
2968 /* Pass the last stop reply back to GDB, but don't notify
2970 notif_event_enque (¬if_stop
,
2971 (struct notif_event
*) new_notif
);
2975 if (thread_stopped (thread
))
2980 = target_waitstatus_to_string (&thread
->last_status
);
2982 debug_printf ("Reporting thread %s as already stopped with %s\n",
2983 target_pid_to_str (entry
->id
),
2986 xfree (status_string
);
2989 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2991 /* Pass the last stop reply back to GDB, but don't notify
2993 queue_stop_reply (entry
->id
, &thread
->last_status
);
3000 /* Set this inferior threads's state as "want-stopped". We won't
3001 resume this thread until the client gives us another action for
3005 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3007 struct thread_info
*thread
= (struct thread_info
*) entry
;
3009 thread
->last_resume_kind
= resume_stop
;
3011 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3013 /* Most threads are stopped implicitly (all-stop); tag that with
3015 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3016 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3020 /* Set all threads' states as "want-stopped". */
3023 gdb_wants_all_threads_stopped (void)
3025 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3028 /* Clear the gdb_detached flag of every process. */
3031 gdb_reattached_process (struct inferior_list_entry
*entry
)
3033 struct process_info
*process
= (struct process_info
*) entry
;
3035 process
->gdb_detached
= 0;
3038 /* Callback for for_each_inferior. Clear the thread's pending status
3042 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3044 struct thread_info
*thread
= (struct thread_info
*) entry
;
3046 thread
->status_pending_p
= 0;
3049 /* Callback for for_each_inferior. If the thread is stopped with an
3050 interesting event, mark it as having a pending event. */
3053 set_pending_status_callback (struct inferior_list_entry
*entry
)
3055 struct thread_info
*thread
= (struct thread_info
*) entry
;
3057 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3058 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3059 /* A breakpoint, watchpoint or finished step from a previous
3060 GDB run isn't considered interesting for a new GDB run.
3061 If we left those pending, the new GDB could consider them
3062 random SIGTRAPs. This leaves out real async traps. We'd
3063 have to peek into the (target-specific) siginfo to
3064 distinguish those. */
3065 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3066 thread
->status_pending_p
= 1;
3069 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3070 pending status to report to GDB. */
3073 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3075 struct thread_info
*thread
= (struct thread_info
*) entry
;
3077 return thread
->status_pending_p
;
3080 /* Status handler for the '?' packet. */
3083 handle_status (char *own_buf
)
3085 /* GDB is connected, don't forward events to the target anymore. */
3086 for_each_inferior (&all_processes
, gdb_reattached_process
);
3088 /* In non-stop mode, we must send a stop reply for each stopped
3089 thread. In all-stop mode, just send one for the first stopped
3094 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3096 /* The first is sent immediatly. OK is sent if there is no
3097 stopped thread, which is the same handling of the vStopped
3098 packet (by design). */
3099 notif_write_event (¬if_stop
, own_buf
);
3103 struct inferior_list_entry
*thread
= NULL
;
3106 stabilize_threads ();
3107 gdb_wants_all_threads_stopped ();
3109 /* We can only report one status, but we might be coming out of
3110 non-stop -- if more than one thread is stopped with
3111 interesting events, leave events for the threads we're not
3112 reporting now pending. They'll be reported the next time the
3113 threads are resumed. Start by marking all interesting events
3115 for_each_inferior (&all_threads
, set_pending_status_callback
);
3117 /* Prefer the last thread that reported an event to GDB (even if
3118 that was a GDB_SIGNAL_TRAP). */
3119 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3120 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3121 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3122 thread
= find_inferior_id (&all_threads
, last_ptid
);
3124 /* If the last event thread is not found for some reason, look
3125 for some other thread that might have an event to report. */
3127 thread
= find_inferior (&all_threads
,
3128 find_status_pending_thread_callback
, NULL
);
3130 /* If we're still out of luck, simply pick the first thread in
3133 thread
= get_first_inferior (&all_threads
);
3137 struct thread_info
*tp
= (struct thread_info
*) thread
;
3139 /* We're reporting this event, so it's no longer
3141 tp
->status_pending_p
= 0;
3143 /* GDB assumes the current thread is the thread we're
3144 reporting the status for. */
3145 general_thread
= thread
->id
;
3146 set_desired_thread (1);
3148 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3149 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3152 strcpy (own_buf
, "W00");
3157 gdbserver_version (void)
3159 printf ("GNU gdbserver %s%s\n"
3160 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3161 "gdbserver is free software, covered by the "
3162 "GNU General Public License.\n"
3163 "This gdbserver was configured as \"%s\"\n",
3164 PKGVERSION
, version
, host_name
);
3168 gdbserver_usage (FILE *stream
)
3170 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3171 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3172 "\tgdbserver [OPTIONS] --multi COMM\n"
3174 "COMM may either be a tty device (for serial debugging),\n"
3175 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3176 "stdin/stdout of gdbserver.\n"
3177 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3178 "PID is the process ID to attach to, when --attach is specified.\n"
3180 "Operating modes:\n"
3182 " --attach Attach to running process PID.\n"
3183 " --multi Start server without a specific program, and\n"
3184 " only quit when explicitly commanded.\n"
3185 " --once Exit after the first connection has closed.\n"
3186 " --help Print this message and then exit.\n"
3187 " --version Display version information and exit.\n"
3191 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3192 " --disable-randomization\n"
3193 " Run PROG with address space randomization disabled.\n"
3194 " --no-disable-randomization\n"
3195 " Don't disable address space randomization when\n"
3200 " --debug Enable general debugging output.\n"
3201 " --debug-format=opt1[,opt2,...]\n"
3202 " Specify extra content in debugging output.\n"
3207 " --remote-debug Enable remote protocol debugging output.\n"
3208 " --disable-packet=opt1[,opt2,...]\n"
3209 " Disable support for RSP packets or features.\n"
3211 " vCont, Tthread, qC, qfThreadInfo and \n"
3212 " threads (disable all threading packets).\n"
3214 "For more information, consult the GDB manual (available as on-line \n"
3215 "info or a printed manual).\n");
3216 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3217 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3221 gdbserver_show_disableable (FILE *stream
)
3223 fprintf (stream
, "Disableable packets:\n"
3224 " vCont \tAll vCont packets\n"
3225 " qC \tQuerying the current thread\n"
3226 " qfThreadInfo\tThread listing\n"
3227 " Tthread \tPassing the thread specifier in the "
3228 "T stop reply packet\n"
3229 " threads \tAll of the above\n");
3233 #undef require_running
3234 #define require_running(BUF) \
3235 if (!target_running ()) \
3242 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3244 int pid
= * (int *) args
;
3246 if (ptid_get_pid (entry
->id
) == pid
)
3253 kill_inferior_callback (struct inferior_list_entry
*entry
)
3255 struct process_info
*process
= (struct process_info
*) entry
;
3256 int pid
= ptid_get_pid (process
->entry
.id
);
3258 kill_inferior (pid
);
3259 discard_queued_stop_replies (pid_to_ptid (pid
));
3262 /* Callback for for_each_inferior to detach or kill the inferior,
3263 depending on whether we attached to it or not.
3264 We inform the user whether we're detaching or killing the process
3265 as this is only called when gdbserver is about to exit. */
3268 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3270 struct process_info
*process
= (struct process_info
*) entry
;
3271 int pid
= ptid_get_pid (process
->entry
.id
);
3273 if (process
->attached
)
3274 detach_inferior (pid
);
3276 kill_inferior (pid
);
3278 discard_queued_stop_replies (pid_to_ptid (pid
));
3281 /* for_each_inferior callback for detach_or_kill_for_exit to print
3282 the pids of started inferiors. */
3285 print_started_pid (struct inferior_list_entry
*entry
)
3287 struct process_info
*process
= (struct process_info
*) entry
;
3289 if (! process
->attached
)
3291 int pid
= ptid_get_pid (process
->entry
.id
);
3292 fprintf (stderr
, " %d", pid
);
3296 /* for_each_inferior callback for detach_or_kill_for_exit to print
3297 the pids of attached inferiors. */
3300 print_attached_pid (struct inferior_list_entry
*entry
)
3302 struct process_info
*process
= (struct process_info
*) entry
;
3304 if (process
->attached
)
3306 int pid
= ptid_get_pid (process
->entry
.id
);
3307 fprintf (stderr
, " %d", pid
);
3311 /* Call this when exiting gdbserver with possible inferiors that need
3312 to be killed or detached from. */
3315 detach_or_kill_for_exit (void)
3317 /* First print a list of the inferiors we will be killing/detaching.
3318 This is to assist the user, for example, in case the inferior unexpectedly
3319 dies after we exit: did we screw up or did the inferior exit on its own?
3320 Having this info will save some head-scratching. */
3322 if (have_started_inferiors_p ())
3324 fprintf (stderr
, "Killing process(es):");
3325 for_each_inferior (&all_processes
, print_started_pid
);
3326 fprintf (stderr
, "\n");
3328 if (have_attached_inferiors_p ())
3330 fprintf (stderr
, "Detaching process(es):");
3331 for_each_inferior (&all_processes
, print_attached_pid
);
3332 fprintf (stderr
, "\n");
3335 /* Now we can kill or detach the inferiors. */
3337 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3340 /* Value that will be passed to exit(3) when gdbserver exits. */
3341 static int exit_code
;
3343 /* Cleanup version of detach_or_kill_for_exit. */
3346 detach_or_kill_for_exit_cleanup (void *ignore
)
3351 detach_or_kill_for_exit ();
3354 CATCH (exception
, RETURN_MASK_ALL
)
3357 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3363 /* Main function. This is called by the real "main" function,
3364 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3366 static void ATTRIBUTE_NORETURN
3367 captured_main (int argc
, char *argv
[])
3371 char *arg_end
, *port
;
3372 char **next_arg
= &argv
[1];
3373 volatile int multi_mode
= 0;
3374 volatile int attach
= 0;
3377 while (*next_arg
!= NULL
&& **next_arg
== '-')
3379 if (strcmp (*next_arg
, "--version") == 0)
3381 gdbserver_version ();
3384 else if (strcmp (*next_arg
, "--help") == 0)
3386 gdbserver_usage (stdout
);
3389 else if (strcmp (*next_arg
, "--attach") == 0)
3391 else if (strcmp (*next_arg
, "--multi") == 0)
3393 else if (strcmp (*next_arg
, "--wrapper") == 0)
3397 wrapper_argv
= next_arg
;
3398 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3401 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3403 gdbserver_usage (stderr
);
3407 /* Consume the "--". */
3410 else if (strcmp (*next_arg
, "--debug") == 0)
3412 else if (startswith (*next_arg
, "--debug-format="))
3415 = parse_debug_format_options ((*next_arg
)
3416 + sizeof ("--debug-format=") - 1, 0);
3418 if (error_msg
!= NULL
)
3420 fprintf (stderr
, "%s", error_msg
);
3424 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3426 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3428 gdbserver_show_disableable (stdout
);
3431 else if (startswith (*next_arg
, "--disable-packet="))
3433 char *packets
, *tok
;
3435 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3436 for (tok
= strtok (packets
, ",");
3438 tok
= strtok (NULL
, ","))
3440 if (strcmp ("vCont", tok
) == 0)
3441 disable_packet_vCont
= 1;
3442 else if (strcmp ("Tthread", tok
) == 0)
3443 disable_packet_Tthread
= 1;
3444 else if (strcmp ("qC", tok
) == 0)
3445 disable_packet_qC
= 1;
3446 else if (strcmp ("qfThreadInfo", tok
) == 0)
3447 disable_packet_qfThreadInfo
= 1;
3448 else if (strcmp ("threads", tok
) == 0)
3450 disable_packet_vCont
= 1;
3451 disable_packet_Tthread
= 1;
3452 disable_packet_qC
= 1;
3453 disable_packet_qfThreadInfo
= 1;
3457 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3459 gdbserver_show_disableable (stderr
);
3464 else if (strcmp (*next_arg
, "-") == 0)
3466 /* "-" specifies a stdio connection and is a form of port
3468 *next_arg
= STDIO_CONNECTION_NAME
;
3471 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3472 disable_randomization
= 1;
3473 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3474 disable_randomization
= 0;
3475 else if (strcmp (*next_arg
, "--once") == 0)
3479 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3489 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3491 gdbserver_usage (stderr
);
3495 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3496 opened by remote_prepare. */
3499 /* We need to know whether the remote connection is stdio before
3500 starting the inferior. Inferiors created in this scenario have
3501 stdin,stdout redirected. So do this here before we call
3503 remote_prepare (port
);
3508 /* --attach used to come after PORT, so allow it there for
3510 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3517 && (*next_arg
== NULL
3518 || (*next_arg
)[0] == '\0'
3519 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3521 || next_arg
[1] != NULL
))
3526 gdbserver_usage (stderr
);
3530 initialize_async_io ();
3532 initialize_event_loop ();
3533 if (target_supports_tracepoints ())
3534 initialize_tracepoint ();
3535 initialize_notif ();
3537 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3538 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3540 if (pid
== 0 && *next_arg
!= NULL
)
3544 n
= argc
- (next_arg
- argv
);
3545 program_argv
= XNEWVEC (char *, n
+ 1);
3546 for (i
= 0; i
< n
; i
++)
3547 program_argv
[i
] = xstrdup (next_arg
[i
]);
3548 program_argv
[i
] = NULL
;
3550 /* Wait till we are at first instruction in program. */
3551 start_inferior (program_argv
);
3553 /* We are now (hopefully) stopped at the first instruction of
3554 the target process. This assumes that the target process was
3555 successfully created. */
3559 if (attach_inferior (pid
) == -1)
3560 error ("Attaching not supported on this target");
3562 /* Otherwise succeeded. */
3566 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3567 last_status
.value
.integer
= 0;
3568 last_ptid
= minus_one_ptid
;
3570 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3572 /* Don't report shared library events on the initial connection,
3573 even if some libraries are preloaded. Avoids the "stopped by
3574 shared library event" notice on gdb side. */
3577 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3578 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3583 if (!was_running
&& !multi_mode
)
3584 error ("No program to debug");
3591 report_fork_events
= 0;
3592 report_vfork_events
= 0;
3593 report_exec_events
= 0;
3594 /* Be sure we're out of tfind mode. */
3595 current_traceframe
= -1;
3596 cont_thread
= null_ptid
;
3597 swbreak_feature
= 0;
3598 hwbreak_feature
= 0;
3599 vCont_supported
= 0;
3605 /* Wait for events. This will return when all event sources
3606 are removed from the event loop. */
3607 start_event_loop ();
3609 /* If an exit was requested (using the "monitor exit"
3610 command), terminate now. The only other way to get
3611 here is for getpkt to fail; close the connection
3612 and reopen it at the top of the loop. */
3614 if (exit_requested
|| run_once
)
3615 throw_quit ("Quit");
3618 "Remote side has terminated connection. "
3619 "GDBserver will reopen the connection.\n");
3621 /* Get rid of any pending statuses. An eventual reconnection
3622 (by the same GDB instance or another) will refresh all its
3623 state from scratch. */
3624 discard_queued_stop_replies (minus_one_ptid
);
3625 for_each_inferior (&all_threads
,
3626 clear_pending_status_callback
);
3630 if (disconnected_tracing
)
3632 /* Try to enable non-stop/async mode, so we we can
3633 both wait for an async socket accept, and handle
3634 async target events simultaneously. There's also
3635 no point either in having the target always stop
3636 all threads, when we're going to pass signals
3637 down without informing GDB. */
3640 if (start_non_stop (1))
3643 /* Detaching implicitly resumes all threads;
3644 simply disconnecting does not. */
3650 "Disconnected tracing disabled; "
3651 "stopping trace run.\n");
3656 CATCH (exception
, RETURN_MASK_ERROR
)
3659 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3661 if (response_needed
)
3663 write_enn (own_buf
);
3668 throw_quit ("Quit");
3674 /* Main function. */
3677 main (int argc
, char *argv
[])
3682 captured_main (argc
, argv
);
3684 CATCH (exception
, RETURN_MASK_ALL
)
3686 if (exception
.reason
== RETURN_ERROR
)
3689 fprintf (stderr
, "%s\n", exception
.message
);
3690 fprintf (stderr
, "Exiting\n");
3698 gdb_assert_not_reached ("captured_main should never return");
3701 /* Skip PACKET until the next semi-colon (or end of string). */
3704 skip_to_semicolon (char **packet
)
3706 while (**packet
!= '\0' && **packet
!= ';')
3710 /* Process options coming from Z packets for a breakpoint. PACKET is
3711 the packet buffer. *PACKET is updated to point to the first char
3712 after the last processed option. */
3715 process_point_options (struct breakpoint
*bp
, char **packet
)
3717 char *dataptr
= *packet
;
3720 /* Check if data has the correct format. */
3721 if (*dataptr
!= ';')
3728 if (*dataptr
== ';')
3731 if (*dataptr
== 'X')
3733 /* Conditional expression. */
3735 debug_printf ("Found breakpoint condition.\n");
3736 if (!add_breakpoint_condition (bp
, &dataptr
))
3737 skip_to_semicolon (&dataptr
);
3739 else if (startswith (dataptr
, "cmds:"))
3741 dataptr
+= strlen ("cmds:");
3743 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3744 persist
= (*dataptr
== '1');
3746 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3747 skip_to_semicolon (&dataptr
);
3751 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3753 /* Skip tokens until we find one that we recognize. */
3754 skip_to_semicolon (&dataptr
);
3760 /* Event loop callback that handles a serial event. The first byte in
3761 the serial buffer gets us here. We expect characters to arrive at
3762 a brisk pace, so we read the rest of the packet with a blocking
3766 process_serial_event (void)
3777 int new_packet_len
= -1;
3779 /* Used to decide when gdbserver should exit in
3780 multi-mode/remote. */
3781 static int have_ran
= 0;
3784 have_ran
= target_running ();
3786 disable_async_io ();
3788 response_needed
= 0;
3789 packet_len
= getpkt (own_buf
);
3790 if (packet_len
<= 0)
3793 /* Force an event loop break. */
3796 response_needed
= 1;
3803 handle_query (own_buf
, packet_len
, &new_packet_len
);
3806 handle_general_set (own_buf
);
3809 require_running (own_buf
);
3814 pid
= strtol (&own_buf
[i
], NULL
, 16);
3817 pid
= ptid_get_pid (current_ptid
);
3819 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3821 struct thread_resume resume_info
;
3822 struct process_info
*process
= find_process_pid (pid
);
3824 if (process
== NULL
)
3826 write_enn (own_buf
);
3830 if (tracing
&& disconnected_tracing
)
3832 "Disconnected tracing in effect, "
3833 "leaving gdbserver attached to the process\n");
3835 if (any_persistent_commands ())
3837 "Persistent commands are present, "
3838 "leaving gdbserver attached to the process\n");
3840 /* Make sure we're in non-stop/async mode, so we we can both
3841 wait for an async socket accept, and handle async target
3842 events simultaneously. There's also no point either in
3843 having the target stop all threads, when we're going to
3844 pass signals down without informing GDB. */
3848 debug_printf ("Forcing non-stop mode\n");
3854 process
->gdb_detached
= 1;
3856 /* Detaching implicitly resumes all threads. */
3857 resume_info
.thread
= minus_one_ptid
;
3858 resume_info
.kind
= resume_continue
;
3859 resume_info
.sig
= 0;
3860 (*the_target
->resume
) (&resume_info
, 1);
3863 break; /* from switch/case */
3866 fprintf (stderr
, "Detaching from process %d\n", pid
);
3868 if (detach_inferior (pid
) != 0)
3869 write_enn (own_buf
);
3872 discard_queued_stop_replies (pid_to_ptid (pid
));
3875 if (extended_protocol
)
3877 /* Treat this like a normal program exit. */
3878 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3879 last_status
.value
.integer
= 0;
3880 last_ptid
= pid_to_ptid (pid
);
3882 current_thread
= NULL
;
3889 /* If we are attached, then we can exit. Otherwise, we
3890 need to hang around doing nothing, until the child is
3892 join_inferior (pid
);
3898 extended_protocol
= 1;
3902 handle_status (own_buf
);
3905 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3907 ptid_t gdb_id
, thread_id
;
3910 require_running (own_buf
);
3912 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3914 pid
= ptid_get_pid (gdb_id
);
3916 if (ptid_equal (gdb_id
, null_ptid
)
3917 || ptid_equal (gdb_id
, minus_one_ptid
))
3918 thread_id
= null_ptid
;
3920 && ptid_equal (pid_to_ptid (pid
),
3923 struct thread_info
*thread
=
3924 (struct thread_info
*) find_inferior (&all_threads
,
3929 write_enn (own_buf
);
3933 thread_id
= thread
->entry
.id
;
3937 thread_id
= gdb_id_to_thread_id (gdb_id
);
3938 if (ptid_equal (thread_id
, null_ptid
))
3940 write_enn (own_buf
);
3945 if (own_buf
[1] == 'g')
3947 if (ptid_equal (thread_id
, null_ptid
))
3949 /* GDB is telling us to choose any thread. Check if
3950 the currently selected thread is still valid. If
3951 it is not, select the first available. */
3952 struct thread_info
*thread
=
3953 (struct thread_info
*) find_inferior_id (&all_threads
,
3956 thread
= get_first_thread ();
3957 thread_id
= thread
->entry
.id
;
3960 general_thread
= thread_id
;
3961 set_desired_thread (1);
3962 gdb_assert (current_thread
!= NULL
);
3964 else if (own_buf
[1] == 'c')
3965 cont_thread
= thread_id
;
3971 /* Silently ignore it so that gdb can extend the protocol
3972 without compatibility headaches. */
3977 require_running (own_buf
);
3978 if (current_traceframe
>= 0)
3980 struct regcache
*regcache
3981 = new_register_cache (current_target_desc ());
3983 if (fetch_traceframe_registers (current_traceframe
,
3985 registers_to_string (regcache
, own_buf
);
3987 write_enn (own_buf
);
3988 free_register_cache (regcache
);
3992 struct regcache
*regcache
;
3994 if (!set_desired_thread (1))
3995 write_enn (own_buf
);
3998 regcache
= get_thread_regcache (current_thread
, 1);
3999 registers_to_string (regcache
, own_buf
);
4004 require_running (own_buf
);
4005 if (current_traceframe
>= 0)
4006 write_enn (own_buf
);
4009 struct regcache
*regcache
;
4011 if (!set_desired_thread (1))
4012 write_enn (own_buf
);
4015 regcache
= get_thread_regcache (current_thread
, 1);
4016 registers_from_string (regcache
, &own_buf
[1]);
4022 require_running (own_buf
);
4023 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4024 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4026 write_enn (own_buf
);
4028 bin2hex (mem_buf
, own_buf
, res
);
4031 require_running (own_buf
);
4032 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4033 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4036 write_enn (own_buf
);
4039 require_running (own_buf
);
4040 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4041 &mem_addr
, &len
, &mem_buf
) < 0
4042 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4043 write_enn (own_buf
);
4048 require_running (own_buf
);
4049 hex2bin (own_buf
+ 1, &sig
, 1);
4050 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4051 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4054 myresume (own_buf
, 0, signal
);
4057 require_running (own_buf
);
4058 hex2bin (own_buf
+ 1, &sig
, 1);
4059 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4060 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4063 myresume (own_buf
, 1, signal
);
4066 require_running (own_buf
);
4068 myresume (own_buf
, 0, signal
);
4071 require_running (own_buf
);
4073 myresume (own_buf
, 1, signal
);
4075 case 'Z': /* insert_ ... */
4077 case 'z': /* remove_ ... */
4082 char type
= own_buf
[1];
4084 const int insert
= ch
== 'Z';
4085 char *p
= &own_buf
[3];
4087 p
= unpack_varlen_hex (p
, &addr
);
4088 kind
= strtol (p
+ 1, &dataptr
, 16);
4092 struct breakpoint
*bp
;
4094 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4099 /* GDB may have sent us a list of *point parameters to
4100 be evaluated on the target's side. Read such list
4101 here. If we already have a list of parameters, GDB
4102 is telling us to drop that list and use this one
4104 clear_breakpoint_conditions_and_commands (bp
);
4105 process_point_options (bp
, &dataptr
);
4109 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4117 write_enn (own_buf
);
4121 response_needed
= 0;
4122 if (!target_running ())
4123 /* The packet we received doesn't make sense - but we can't
4124 reply to it, either. */
4127 fprintf (stderr
, "Killing all inferiors\n");
4128 for_each_inferior (&all_processes
, kill_inferior_callback
);
4130 /* When using the extended protocol, we wait with no program
4131 running. The traditional protocol will exit instead. */
4132 if (extended_protocol
)
4134 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4135 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4143 ptid_t gdb_id
, thread_id
;
4145 require_running (own_buf
);
4147 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4148 thread_id
= gdb_id_to_thread_id (gdb_id
);
4149 if (ptid_equal (thread_id
, null_ptid
))
4151 write_enn (own_buf
);
4155 if (mythread_alive (thread_id
))
4158 write_enn (own_buf
);
4162 response_needed
= 0;
4164 /* Restarting the inferior is only supported in the extended
4166 if (extended_protocol
)
4168 if (target_running ())
4169 for_each_inferior (&all_processes
,
4170 kill_inferior_callback
);
4171 fprintf (stderr
, "GDBserver restarting\n");
4173 /* Wait till we are at 1st instruction in prog. */
4174 if (program_argv
!= NULL
)
4176 start_inferior (program_argv
);
4177 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4179 /* Stopped at the first instruction of the target
4181 general_thread
= last_ptid
;
4185 /* Something went wrong. */
4186 general_thread
= null_ptid
;
4191 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4192 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4198 /* It is a request we don't understand. Respond with an
4199 empty packet so that gdb knows that we don't support this
4205 /* Extended (long) request. */
4206 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4210 /* It is a request we don't understand. Respond with an empty
4211 packet so that gdb knows that we don't support this
4217 if (new_packet_len
!= -1)
4218 putpkt_binary (own_buf
, new_packet_len
);
4222 response_needed
= 0;
4224 if (!extended_protocol
&& have_ran
&& !target_running ())
4226 /* In non-stop, defer exiting until GDB had a chance to query
4227 the whole vStopped list (until it gets an OK). */
4228 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4230 /* Be transparent when GDB is connected through stdio -- no
4231 need to spam GDB's console. */
4232 if (!remote_connection_is_stdio ())
4233 fprintf (stderr
, "GDBserver exiting\n");
4245 /* Event-loop callback for serial events. */
4248 handle_serial_event (int err
, gdb_client_data client_data
)
4251 debug_printf ("handling possible serial event\n");
4253 /* Really handle it. */
4254 if (process_serial_event () < 0)
4257 /* Be sure to not change the selected thread behind GDB's back.
4258 Important in the non-stop mode asynchronous protocol. */
4259 set_desired_thread (1);
4264 /* Event-loop callback for target events. */
4267 handle_target_event (int err
, gdb_client_data client_data
)
4270 debug_printf ("handling possible target event\n");
4272 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4275 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4277 /* No RSP support for this yet. */
4279 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4281 int pid
= ptid_get_pid (last_ptid
);
4282 struct process_info
*process
= find_process_pid (pid
);
4283 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4285 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4286 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4288 mark_breakpoints_out (process
);
4289 mourn_inferior (process
);
4293 /* We're reporting this thread as stopped. Update its
4294 "want-stopped" state to what the client wants, until it
4295 gets a new resume action. */
4296 current_thread
->last_resume_kind
= resume_stop
;
4297 current_thread
->last_status
= last_status
;
4302 if (!target_running ())
4304 /* The last process exited. We're done. */
4308 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4310 /* A thread stopped with a signal, but gdb isn't
4311 connected to handle it. Pass it down to the
4312 inferior, as if it wasn't being traced. */
4313 struct thread_resume resume_info
;
4316 debug_printf ("GDB not connected; forwarding event %d for"
4318 (int) last_status
.kind
,
4319 target_pid_to_str (last_ptid
));
4321 resume_info
.thread
= last_ptid
;
4322 resume_info
.kind
= resume_continue
;
4323 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4324 (*the_target
->resume
) (&resume_info
, 1);
4326 else if (debug_threads
)
4327 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4328 (int) last_status
.kind
,
4329 target_pid_to_str (last_ptid
));
4333 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4335 vstop_notif
->status
= last_status
;
4336 vstop_notif
->ptid
= last_ptid
;
4337 /* Push Stop notification. */
4338 notif_push (¬if_stop
,
4339 (struct notif_event
*) vstop_notif
);
4343 /* Be sure to not change the selected thread behind GDB's back.
4344 Important in the non-stop mode asynchronous protocol. */
4345 set_desired_thread (1);