1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2013 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"
31 #include "btrace-common.h"
33 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
34 `vCont'. Note the multi-process extensions made `vCont' a
35 requirement, so `Hc pPID.TID' is pretty much undefined. So
36 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
37 resuming all threads of the process (again, `Hc' isn't used for
38 multi-process), or a specific thread ptid_t.
40 We also set this when handling a single-thread `vCont' resume, as
41 some places in the backends check it to know when (and for which
42 thread) single-thread scheduler-locking is in effect. */
45 /* The thread set with an `Hg' packet. */
46 ptid_t general_thread
;
50 static int extended_protocol
;
51 static int response_needed
;
52 static int exit_requested
;
54 /* --once: Exit after the first connection has closed. */
60 /* Whether we should attempt to disable the operating system's address
61 space randomization feature before starting an inferior. */
62 int disable_randomization
= 1;
64 static char **program_argv
, **wrapper_argv
;
66 /* Enable miscellaneous debugging output. The name is historical - it
67 was originally used to debug LinuxThreads support. */
70 /* Enable debugging of h/w breakpoint/watchpoint support. */
73 int pass_signals
[GDB_SIGNAL_LAST
];
74 int program_signals
[GDB_SIGNAL_LAST
];
75 int program_signals_p
;
79 const char *gdbserver_xmltarget
;
81 /* The PID of the originally created or attached inferior. Used to
82 send signals to the process when GDB sends us an asynchronous interrupt
83 (user hitting Control-C in the client), and to wait for the child to exit
84 when no longer debugging it. */
86 unsigned long signal_pid
;
89 /* A file descriptor for the controlling terminal. */
92 /* TERMINAL_FD's original foreground group. */
93 pid_t old_foreground_pgrp
;
95 /* Hand back terminal ownership to the original foreground group. */
98 restore_old_foreground_pgrp (void)
100 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
104 /* Set if you want to disable optional thread related packets support
105 in gdbserver, for the sake of testing GDB against stubs that don't
107 int disable_packet_vCont
;
108 int disable_packet_Tthread
;
109 int disable_packet_qC
;
110 int disable_packet_qfThreadInfo
;
112 /* Last status reported to GDB. */
113 static struct target_waitstatus last_status
;
114 static ptid_t last_ptid
;
116 static char *own_buf
;
117 static unsigned char *mem_buf
;
119 /* A sub-class of 'struct notif_event' for stop, holding information
120 relative to a single stop reply. We keep a queue of these to
121 push to GDB in non-stop mode. */
125 struct notif_event base
;
127 /* Thread or process that got the event. */
131 struct target_waitstatus status
;
134 DEFINE_QUEUE_P (notif_event_p
);
136 /* Put a stop reply to the stop reply queue. */
139 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
141 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
143 new_notif
->ptid
= ptid
;
144 new_notif
->status
= *status
;
146 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
150 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
151 QUEUE_ITER (notif_event_p
) *iter
,
152 struct notif_event
*event
,
158 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
160 if (q
->free_func
!= NULL
)
161 q
->free_func (event
);
163 QUEUE_remove_elem (notif_event_p
, q
, iter
);
169 /* Get rid of the currently pending stop replies for PID. If PID is
170 -1, then apply to all processes. */
173 discard_queued_stop_replies (int pid
)
175 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
176 remove_all_on_match_pid
, &pid
);
180 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
182 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
184 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
187 struct notif_server notif_stop
=
189 "vStopped", "Stop", NULL
, vstop_notif_reply
,
193 target_running (void)
195 return all_threads
.head
!= NULL
;
199 start_inferior (char **argv
)
201 char **new_argv
= argv
;
203 if (wrapper_argv
!= NULL
)
207 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
209 for (i
= 0; argv
[i
] != NULL
; i
++)
211 new_argv
= alloca (sizeof (char *) * count
);
213 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
214 new_argv
[count
++] = wrapper_argv
[i
];
215 for (i
= 0; argv
[i
] != NULL
; i
++)
216 new_argv
[count
++] = argv
[i
];
217 new_argv
[count
] = NULL
;
223 for (i
= 0; new_argv
[i
]; ++i
)
224 fprintf (stderr
, "new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
229 signal (SIGTTOU
, SIG_DFL
);
230 signal (SIGTTIN
, SIG_DFL
);
233 /* Clear this so the backend doesn't get confused, thinking
234 CONT_THREAD died, and it needs to resume all threads. */
235 cont_thread
= null_ptid
;
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 resume_info
.thread
= pid_to_ptid (signal_pid
);
259 resume_info
.kind
= resume_continue
;
262 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
264 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_inferior
->last_resume_kind
= resume_stop
;
276 current_inferior
->last_status
= last_status
;
278 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
283 /* Wait till we are at 1st instruction in program, return new pid
284 (assuming success). */
285 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
287 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
288 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
290 current_inferior
->last_resume_kind
= resume_stop
;
291 current_inferior
->last_status
= last_status
;
298 attach_inferior (int pid
)
300 /* myattach should return -1 if attaching is unsupported,
301 0 if it succeeded, and call error() otherwise. */
303 if (myattach (pid
) != 0)
306 fprintf (stderr
, "Attached; pid = %d\n", pid
);
309 /* FIXME - It may be that we should get the SIGNAL_PID from the
310 attach function, so that it can be the main thread instead of
311 whichever we were told to attach to. */
314 /* Clear this so the backend doesn't get confused, thinking
315 CONT_THREAD died, and it needs to resume all threads. */
316 cont_thread
= null_ptid
;
320 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
322 /* GDB knows to ignore the first SIGSTOP after attaching to a running
323 process using the "attach" command, but this is different; it's
324 just using "target remote". Pretend it's just starting up. */
325 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
326 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
327 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
329 current_inferior
->last_resume_kind
= resume_stop
;
330 current_inferior
->last_status
= last_status
;
336 extern int remote_debug
;
338 /* Decode a qXfer read request. Return 0 if everything looks OK,
342 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
344 /* After the read marker and annex, qXfer looks like a
345 traditional 'm' packet. */
346 decode_m_packet (buf
, ofs
, len
);
352 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
354 /* Extract and NUL-terminate the object. */
356 while (*buf
&& *buf
!= ':')
362 /* Extract and NUL-terminate the read/write action. */
364 while (*buf
&& *buf
!= ':')
370 /* Extract and NUL-terminate the annex. */
372 while (*buf
&& *buf
!= ':')
382 /* Write the response to a successful qXfer read. Returns the
383 length of the (binary) data stored in BUF, corresponding
384 to as much of DATA/LEN as we could fit. IS_MORE controls
385 the first character of the response. */
387 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
396 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
400 /* Handle btrace enabling. */
403 handle_btrace_enable (struct thread_info
*thread
)
405 if (thread
->btrace
!= NULL
)
406 return "E.Btrace already enabled.";
408 thread
->btrace
= target_enable_btrace (thread
->entry
.id
);
409 if (thread
->btrace
== NULL
)
410 return "E.Could not enable btrace.";
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 return "E.Branch tracing not enabled.";
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 return "E.Could not disable branch tracing.";
427 thread
->btrace
= NULL
;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf
)
436 struct thread_info
*thread
;
440 if (strncmp ("Qbtrace:", own_buf
, strlen ("Qbtrace:")) != 0)
443 op
= own_buf
+ strlen ("Qbtrace:");
445 if (!target_supports_btrace ())
447 strcpy (own_buf
, "E.Target does not support branch tracing.");
451 if (ptid_equal (general_thread
, null_ptid
)
452 || ptid_equal (general_thread
, minus_one_ptid
))
454 strcpy (own_buf
, "E.Must select a single thread.");
458 thread
= find_thread_ptid (general_thread
);
461 strcpy (own_buf
, "E.No such thread.");
467 if (strcmp (op
, "bts") == 0)
468 err
= handle_btrace_enable (thread
);
469 else if (strcmp (op
, "off") == 0)
470 err
= handle_btrace_disable (thread
);
472 err
= "E.Bad Qbtrace operation. Use bts or off.";
475 strcpy (own_buf
, err
);
482 /* Handle all of the extended 'Q' packets. */
485 handle_general_set (char *own_buf
)
487 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
489 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
490 const char *p
= own_buf
+ strlen ("QPassSignals:");
493 p
= decode_address_to_semicolon (&cursig
, p
);
494 for (i
= 0; i
< numsigs
; i
++)
500 /* Keep looping, to clear the remaining signals. */
503 p
= decode_address_to_semicolon (&cursig
, p
);
508 strcpy (own_buf
, "OK");
512 if (strncmp ("QProgramSignals:", own_buf
, strlen ("QProgramSignals:")) == 0)
514 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
515 const char *p
= own_buf
+ strlen ("QProgramSignals:");
518 program_signals_p
= 1;
520 p
= decode_address_to_semicolon (&cursig
, p
);
521 for (i
= 0; i
< numsigs
; i
++)
525 program_signals
[i
] = 1;
527 /* Keep looping, to clear the remaining signals. */
530 p
= decode_address_to_semicolon (&cursig
, p
);
533 program_signals
[i
] = 0;
535 strcpy (own_buf
, "OK");
539 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
543 fprintf (stderr
, "[noack mode enabled]\n");
552 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
554 char *mode
= own_buf
+ 9;
558 if (strcmp (mode
, "0") == 0)
560 else if (strcmp (mode
, "1") == 0)
564 /* We don't know what this mode is, so complain to
566 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
572 req_str
= req
? "non-stop" : "all-stop";
573 if (start_non_stop (req
) != 0)
575 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
583 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
589 if (strncmp ("QDisableRandomization:", own_buf
,
590 strlen ("QDisableRandomization:")) == 0)
592 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
595 unpack_varlen_hex (packet
, &setting
);
596 disable_randomization
= setting
;
600 if (disable_randomization
)
601 fprintf (stderr
, "[address space randomization disabled]\n");
603 fprintf (stderr
, "[address space randomization enabled]\n");
610 if (target_supports_tracepoints ()
611 && handle_tracepoint_general_set (own_buf
))
614 if (strncmp ("QAgent:", own_buf
, strlen ("QAgent:")) == 0)
616 char *mode
= own_buf
+ strlen ("QAgent:");
619 if (strcmp (mode
, "0") == 0)
621 else if (strcmp (mode
, "1") == 0)
625 /* We don't know what this value is, so complain to GDB. */
626 sprintf (own_buf
, "E.Unknown QAgent value");
630 /* Update the flag. */
633 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
638 if (handle_btrace_general_set (own_buf
))
641 /* Otherwise we didn't know what packet it was. Say we didn't
647 get_features_xml (const char *annex
)
649 /* gdbserver_xmltarget defines what to return when looking
650 for the "target.xml" file. Its contents can either be
651 verbatim XML code (prefixed with a '@') or else the name
652 of the actual XML file to be used in place of "target.xml".
654 This variable is set up from the auto-generated
655 init_registers_... routine for the current target. */
657 if (gdbserver_xmltarget
658 && strcmp (annex
, "target.xml") == 0)
660 if (*gdbserver_xmltarget
== '@')
661 return gdbserver_xmltarget
+ 1;
663 annex
= gdbserver_xmltarget
;
668 extern const char *const xml_builtin
[][2];
671 /* Look for the annex. */
672 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
673 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
676 if (xml_builtin
[i
][0] != NULL
)
677 return xml_builtin
[i
][1];
685 monitor_show_help (void)
687 monitor_output ("The following monitor commands are supported:\n");
688 monitor_output (" set debug <0|1>\n");
689 monitor_output (" Enable general debugging messages\n");
690 monitor_output (" set debug-hw-points <0|1>\n");
691 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
692 monitor_output (" set remote-debug <0|1>\n");
693 monitor_output (" Enable remote protocol debugging messages\n");
694 monitor_output (" exit\n");
695 monitor_output (" Quit GDBserver\n");
698 /* Read trace frame or inferior memory. Returns the number of bytes
699 actually read, zero when no further transfer is possible, and -1 on
700 error. Return of a positive value smaller than LEN does not
701 indicate there's no more to be read, only the end of the transfer.
702 E.g., when GDB reads memory from a traceframe, a first request may
703 be served from a memory block that does not cover the whole request
704 length. A following request gets the rest served from either
705 another block (of the same traceframe) or from the read-only
709 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
713 if (current_traceframe
>= 0)
716 ULONGEST length
= len
;
718 if (traceframe_read_mem (current_traceframe
,
719 memaddr
, myaddr
, len
, &nbytes
))
721 /* Data read from trace buffer, we're done. */
724 if (!in_readonly_region (memaddr
, length
))
726 /* Otherwise we have a valid readonly case, fall through. */
727 /* (assume no half-trace half-real blocks for now) */
730 res
= prepare_to_access_memory ();
733 res
= read_inferior_memory (memaddr
, myaddr
, len
);
734 done_accessing_memory ();
736 return res
== 0 ? len
: -1;
742 /* Write trace frame or inferior memory. Actually, writing to trace
743 frames is forbidden. */
746 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
748 if (current_traceframe
>= 0)
754 ret
= prepare_to_access_memory ();
757 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
758 done_accessing_memory ();
764 /* Subroutine of handle_search_memory to simplify it. */
767 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
768 gdb_byte
*pattern
, unsigned pattern_len
,
769 gdb_byte
*search_buf
,
770 unsigned chunk_size
, unsigned search_buf_size
,
771 CORE_ADDR
*found_addrp
)
773 /* Prime the search buffer. */
775 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
778 warning ("Unable to access %ld bytes of target "
779 "memory at 0x%lx, halting search.",
780 (long) search_buf_size
, (long) start_addr
);
784 /* Perform the search.
786 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
787 When we've scanned N bytes we copy the trailing bytes to the start and
788 read in another N bytes. */
790 while (search_space_len
>= pattern_len
)
793 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
797 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
799 if (found_ptr
!= NULL
)
801 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
802 *found_addrp
= found_addr
;
806 /* Not found in this chunk, skip to next chunk. */
808 /* Don't let search_space_len wrap here, it's unsigned. */
809 if (search_space_len
>= chunk_size
)
810 search_space_len
-= chunk_size
;
812 search_space_len
= 0;
814 if (search_space_len
>= pattern_len
)
816 unsigned keep_len
= search_buf_size
- chunk_size
;
817 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
820 /* Copy the trailing part of the previous iteration to the front
821 of the buffer for the next iteration. */
822 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
824 nr_to_read
= (search_space_len
- keep_len
< chunk_size
825 ? search_space_len
- keep_len
828 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
829 nr_to_read
) != search_buf_size
)
831 warning ("Unable to access %ld bytes of target memory "
832 "at 0x%lx, halting search.",
833 (long) nr_to_read
, (long) read_addr
);
837 start_addr
+= chunk_size
;
846 /* Handle qSearch:memory packets. */
849 handle_search_memory (char *own_buf
, int packet_len
)
851 CORE_ADDR start_addr
;
852 CORE_ADDR search_space_len
;
854 unsigned int pattern_len
;
855 /* NOTE: also defined in find.c testcase. */
856 #define SEARCH_CHUNK_SIZE 16000
857 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
858 /* Buffer to hold memory contents for searching. */
859 gdb_byte
*search_buf
;
860 unsigned search_buf_size
;
862 CORE_ADDR found_addr
;
863 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
865 pattern
= malloc (packet_len
);
868 error ("Unable to allocate memory to perform the search");
869 strcpy (own_buf
, "E00");
872 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
873 packet_len
- cmd_name_len
,
874 &start_addr
, &search_space_len
,
875 pattern
, &pattern_len
) < 0)
878 error ("Error in parsing qSearch:memory packet");
879 strcpy (own_buf
, "E00");
883 search_buf_size
= chunk_size
+ pattern_len
- 1;
885 /* No point in trying to allocate a buffer larger than the search space. */
886 if (search_space_len
< search_buf_size
)
887 search_buf_size
= search_space_len
;
889 search_buf
= malloc (search_buf_size
);
890 if (search_buf
== NULL
)
893 error ("Unable to allocate memory to perform the search");
894 strcpy (own_buf
, "E00");
898 found
= handle_search_memory_1 (start_addr
, search_space_len
,
899 pattern
, pattern_len
,
900 search_buf
, chunk_size
, search_buf_size
,
904 sprintf (own_buf
, "1,%lx", (long) found_addr
);
906 strcpy (own_buf
, "0");
908 strcpy (own_buf
, "E00");
914 #define require_running(BUF) \
915 if (!target_running ()) \
921 /* Handle monitor commands not handled by target-specific handlers. */
924 handle_monitor_command (char *mon
, char *own_buf
)
926 if (strcmp (mon
, "set debug 1") == 0)
929 monitor_output ("Debug output enabled.\n");
931 else if (strcmp (mon
, "set debug 0") == 0)
934 monitor_output ("Debug output disabled.\n");
936 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
939 monitor_output ("H/W point debugging output enabled.\n");
941 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
944 monitor_output ("H/W point debugging output disabled.\n");
946 else if (strcmp (mon
, "set remote-debug 1") == 0)
949 monitor_output ("Protocol debug output enabled.\n");
951 else if (strcmp (mon
, "set remote-debug 0") == 0)
954 monitor_output ("Protocol debug output disabled.\n");
956 else if (strcmp (mon
, "help") == 0)
957 monitor_show_help ();
958 else if (strcmp (mon
, "exit") == 0)
962 monitor_output ("Unknown monitor command.\n\n");
963 monitor_show_help ();
968 /* Associates a callback with each supported qXfer'able object. */
972 /* The object this handler handles. */
975 /* Request that the target transfer up to LEN 8-bit bytes of the
976 target's OBJECT. The OFFSET, for a seekable object, specifies
977 the starting point. The ANNEX can be used to provide additional
978 data-specific information to the target.
980 Return the number of bytes actually transfered, zero when no
981 further transfer is possible, -1 on error, -2 when the transfer
982 is not supported, and -3 on a verbose error message that should
983 be preserved. Return of a positive value smaller than LEN does
984 not indicate the end of the object, only the end of the transfer.
986 One, and only one, of readbuf or writebuf must be non-NULL. */
987 int (*xfer
) (const char *annex
,
988 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
989 ULONGEST offset
, LONGEST len
);
992 /* Handle qXfer:auxv:read. */
995 handle_qxfer_auxv (const char *annex
,
996 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
997 ULONGEST offset
, LONGEST len
)
999 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1002 if (annex
[0] != '\0' || !target_running ())
1005 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1008 /* Handle qXfer:features:read. */
1011 handle_qxfer_features (const char *annex
,
1012 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1013 ULONGEST offset
, LONGEST len
)
1015 const char *document
;
1018 if (writebuf
!= NULL
)
1021 if (!target_running ())
1024 /* Grab the correct annex. */
1025 document
= get_features_xml (annex
);
1026 if (document
== NULL
)
1029 total_len
= strlen (document
);
1031 if (offset
> total_len
)
1034 if (offset
+ len
> total_len
)
1035 len
= total_len
- offset
;
1037 memcpy (readbuf
, document
+ offset
, len
);
1041 /* Handle qXfer:libraries:read. */
1044 handle_qxfer_libraries (const char *annex
,
1045 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1046 ULONGEST offset
, LONGEST len
)
1048 unsigned int total_len
;
1050 struct inferior_list_entry
*dll_ptr
;
1052 if (writebuf
!= NULL
)
1055 if (annex
[0] != '\0' || !target_running ())
1058 /* Over-estimate the necessary memory. Assume that every character
1059 in the library name must be escaped. */
1061 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1062 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1064 document
= malloc (total_len
);
1065 if (document
== NULL
)
1068 strcpy (document
, "<library-list>\n");
1069 p
= document
+ strlen (document
);
1071 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1073 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1076 strcpy (p
, " <library name=\"");
1078 name
= xml_escape_text (dll
->name
);
1082 strcpy (p
, "\"><segment address=\"");
1084 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1086 strcpy (p
, "\"/></library>\n");
1090 strcpy (p
, "</library-list>\n");
1092 total_len
= strlen (document
);
1094 if (offset
> total_len
)
1100 if (offset
+ len
> total_len
)
1101 len
= total_len
- offset
;
1103 memcpy (readbuf
, document
+ offset
, len
);
1108 /* Handle qXfer:libraries-svr4:read. */
1111 handle_qxfer_libraries_svr4 (const char *annex
,
1112 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1113 ULONGEST offset
, LONGEST len
)
1115 if (writebuf
!= NULL
)
1118 if (annex
[0] != '\0' || !target_running ()
1119 || the_target
->qxfer_libraries_svr4
== NULL
)
1122 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1125 /* Handle qXfer:osadata:read. */
1128 handle_qxfer_osdata (const char *annex
,
1129 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1130 ULONGEST offset
, LONGEST len
)
1132 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1135 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1138 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1141 handle_qxfer_siginfo (const char *annex
,
1142 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1143 ULONGEST offset
, LONGEST len
)
1145 if (the_target
->qxfer_siginfo
== NULL
)
1148 if (annex
[0] != '\0' || !target_running ())
1151 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1154 /* Handle qXfer:spu:read and qXfer:spu:write. */
1157 handle_qxfer_spu (const char *annex
,
1158 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1159 ULONGEST offset
, LONGEST len
)
1161 if (the_target
->qxfer_spu
== NULL
)
1164 if (!target_running ())
1167 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1170 /* Handle qXfer:statictrace:read. */
1173 handle_qxfer_statictrace (const char *annex
,
1174 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1175 ULONGEST offset
, LONGEST len
)
1179 if (writebuf
!= NULL
)
1182 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1185 if (traceframe_read_sdata (current_traceframe
, offset
,
1186 readbuf
, len
, &nbytes
))
1191 /* Helper for handle_qxfer_threads. */
1194 handle_qxfer_threads_proper (struct buffer
*buffer
)
1196 struct inferior_list_entry
*thread
;
1198 buffer_grow_str (buffer
, "<threads>\n");
1200 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
1202 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
1204 int core
= target_core_of_thread (ptid
);
1207 write_ptid (ptid_s
, ptid
);
1211 sprintf (core_s
, "%d", core
);
1212 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1217 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1222 buffer_grow_str0 (buffer
, "</threads>\n");
1225 /* Handle qXfer:threads:read. */
1228 handle_qxfer_threads (const char *annex
,
1229 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1230 ULONGEST offset
, LONGEST len
)
1232 static char *result
= 0;
1233 static unsigned int result_length
= 0;
1235 if (writebuf
!= NULL
)
1238 if (!target_running () || annex
[0] != '\0')
1243 struct buffer buffer
;
1244 /* When asked for data at offset 0, generate everything and store into
1245 'result'. Successive reads will be served off 'result'. */
1249 buffer_init (&buffer
);
1251 handle_qxfer_threads_proper (&buffer
);
1253 result
= buffer_finish (&buffer
);
1254 result_length
= strlen (result
);
1255 buffer_free (&buffer
);
1258 if (offset
>= result_length
)
1260 /* We're out of data. */
1267 if (len
> result_length
- offset
)
1268 len
= result_length
- offset
;
1270 memcpy (readbuf
, result
+ offset
, len
);
1275 /* Handle qXfer:traceframe-info:read. */
1278 handle_qxfer_traceframe_info (const char *annex
,
1279 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1280 ULONGEST offset
, LONGEST len
)
1282 static char *result
= 0;
1283 static unsigned int result_length
= 0;
1285 if (writebuf
!= NULL
)
1288 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1293 struct buffer buffer
;
1295 /* When asked for data at offset 0, generate everything and
1296 store into 'result'. Successive reads will be served off
1300 buffer_init (&buffer
);
1302 traceframe_read_info (current_traceframe
, &buffer
);
1304 result
= buffer_finish (&buffer
);
1305 result_length
= strlen (result
);
1306 buffer_free (&buffer
);
1309 if (offset
>= result_length
)
1311 /* We're out of data. */
1318 if (len
> result_length
- offset
)
1319 len
= result_length
- offset
;
1321 memcpy (readbuf
, result
+ offset
, len
);
1325 /* Handle qXfer:fdpic:read. */
1328 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1329 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1331 if (the_target
->read_loadmap
== NULL
)
1334 if (!target_running ())
1337 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1340 /* Handle qXfer:btrace:read. */
1343 handle_qxfer_btrace (const char *annex
,
1344 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1345 ULONGEST offset
, LONGEST len
)
1347 static struct buffer cache
;
1348 struct thread_info
*thread
;
1351 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1354 if (!target_running ())
1357 if (ptid_equal (general_thread
, null_ptid
)
1358 || ptid_equal (general_thread
, minus_one_ptid
))
1360 strcpy (own_buf
, "E.Must select a single thread.");
1364 thread
= find_thread_ptid (general_thread
);
1367 strcpy (own_buf
, "E.No such thread.");
1371 if (thread
->btrace
== NULL
)
1373 strcpy (own_buf
, "E.Btrace not enabled.");
1377 if (strcmp (annex
, "all") == 0)
1378 type
= btrace_read_all
;
1379 else if (strcmp (annex
, "new") == 0)
1380 type
= btrace_read_new
;
1383 strcpy (own_buf
, "E.Bad annex.");
1389 buffer_free (&cache
);
1391 target_read_btrace (thread
->btrace
, &cache
, type
);
1393 else if (offset
> cache
.used_size
)
1395 buffer_free (&cache
);
1399 if (len
> cache
.used_size
- offset
)
1400 len
= cache
.used_size
- offset
;
1402 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1407 static const struct qxfer qxfer_packets
[] =
1409 { "auxv", handle_qxfer_auxv
},
1410 { "btrace", handle_qxfer_btrace
},
1411 { "fdpic", handle_qxfer_fdpic
},
1412 { "features", handle_qxfer_features
},
1413 { "libraries", handle_qxfer_libraries
},
1414 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1415 { "osdata", handle_qxfer_osdata
},
1416 { "siginfo", handle_qxfer_siginfo
},
1417 { "spu", handle_qxfer_spu
},
1418 { "statictrace", handle_qxfer_statictrace
},
1419 { "threads", handle_qxfer_threads
},
1420 { "traceframe-info", handle_qxfer_traceframe_info
},
1424 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1432 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1435 /* Grab the object, r/w and annex. */
1436 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1438 write_enn (own_buf
);
1443 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1446 const struct qxfer
*q
= &qxfer_packets
[i
];
1448 if (strcmp (object
, q
->object
) == 0)
1450 if (strcmp (rw
, "read") == 0)
1452 unsigned char *data
;
1457 /* Grab the offset and length. */
1458 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1460 write_enn (own_buf
);
1464 /* Read one extra byte, as an indicator of whether there is
1466 if (len
> PBUFSIZ
- 2)
1468 data
= malloc (len
+ 1);
1471 write_enn (own_buf
);
1474 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1482 /* Preserve error message. */
1485 write_enn (own_buf
);
1487 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1489 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1494 else if (strcmp (rw
, "write") == 0)
1499 unsigned char *data
;
1501 strcpy (own_buf
, "E00");
1502 data
= malloc (packet_len
- (offset
- own_buf
));
1505 write_enn (own_buf
);
1508 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1509 &ofs
, &len
, data
) < 0)
1512 write_enn (own_buf
);
1516 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1524 /* Preserve error message. */
1527 write_enn (own_buf
);
1529 sprintf (own_buf
, "%x", n
);
1542 /* Table used by the crc32 function to calcuate the checksum. */
1544 static unsigned int crc32_table
[256] =
1547 /* Compute 32 bit CRC from inferior memory.
1549 On success, return 32 bit CRC.
1550 On failure, return (unsigned long long) -1. */
1552 static unsigned long long
1553 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1555 if (!crc32_table
[1])
1557 /* Initialize the CRC table and the decoding table. */
1561 for (i
= 0; i
< 256; i
++)
1563 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1564 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1571 unsigned char byte
= 0;
1573 /* Return failure if memory read fails. */
1574 if (read_inferior_memory (base
, &byte
, 1) != 0)
1575 return (unsigned long long) -1;
1577 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1580 return (unsigned long long) crc
;
1583 /* Handle all of the extended 'q' packets. */
1586 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1588 static struct inferior_list_entry
*thread_ptr
;
1590 /* Reply the current thread id. */
1591 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1594 require_running (own_buf
);
1596 if (!ptid_equal (general_thread
, null_ptid
)
1597 && !ptid_equal (general_thread
, minus_one_ptid
))
1598 gdb_id
= general_thread
;
1601 thread_ptr
= all_threads
.head
;
1602 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1605 sprintf (own_buf
, "QC");
1607 write_ptid (own_buf
, gdb_id
);
1611 if (strcmp ("qSymbol::", own_buf
) == 0)
1613 /* GDB is suggesting new symbols have been loaded. This may
1614 mean a new shared library has been detected as loaded, so
1615 take the opportunity to check if breakpoints we think are
1616 inserted, still are. Note that it isn't guaranteed that
1617 we'll see this when a shared library is loaded, and nor will
1618 we see this for unloads (although breakpoints in unloaded
1619 libraries shouldn't trigger), as GDB may not find symbols for
1620 the library at all. We also re-validate breakpoints when we
1621 see a second GDB breakpoint for the same address, and or when
1622 we access breakpoint shadows. */
1623 validate_breakpoints ();
1625 if (target_supports_tracepoints ())
1626 tracepoint_look_up_symbols ();
1628 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1629 (*the_target
->look_up_symbols
) ();
1631 strcpy (own_buf
, "OK");
1635 if (!disable_packet_qfThreadInfo
)
1637 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1641 require_running (own_buf
);
1642 thread_ptr
= all_threads
.head
;
1645 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1646 write_ptid (own_buf
, gdb_id
);
1647 thread_ptr
= thread_ptr
->next
;
1651 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1655 require_running (own_buf
);
1656 if (thread_ptr
!= NULL
)
1659 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1660 write_ptid (own_buf
, gdb_id
);
1661 thread_ptr
= thread_ptr
->next
;
1666 sprintf (own_buf
, "l");
1672 if (the_target
->read_offsets
!= NULL
1673 && strcmp ("qOffsets", own_buf
) == 0)
1675 CORE_ADDR text
, data
;
1677 require_running (own_buf
);
1678 if (the_target
->read_offsets (&text
, &data
))
1679 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1680 (long)text
, (long)data
, (long)data
);
1682 write_enn (own_buf
);
1687 /* Protocol features query. */
1688 if (strncmp ("qSupported", own_buf
, 10) == 0
1689 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1691 char *p
= &own_buf
[10];
1692 int gdb_supports_qRelocInsn
= 0;
1694 /* Start processing qSupported packet. */
1695 target_process_qsupported (NULL
);
1697 /* Process each feature being provided by GDB. The first
1698 feature will follow a ':', and latter features will follow
1702 char **qsupported
= NULL
;
1706 /* Two passes, to avoid nested strtok calls in
1707 target_process_qsupported. */
1708 for (p
= strtok (p
+ 1, ";");
1710 p
= strtok (NULL
, ";"))
1713 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1714 qsupported
[count
- 1] = xstrdup (p
);
1717 for (i
= 0; i
< count
; i
++)
1720 if (strcmp (p
, "multiprocess+") == 0)
1722 /* GDB supports and wants multi-process support if
1724 if (target_supports_multi_process ())
1727 else if (strcmp (p
, "qRelocInsn+") == 0)
1729 /* GDB supports relocate instruction requests. */
1730 gdb_supports_qRelocInsn
= 1;
1733 target_process_qsupported (p
);
1742 "PacketSize=%x;QPassSignals+;QProgramSignals+",
1745 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1746 strcat (own_buf
, ";qXfer:libraries-svr4:read+");
1749 /* We do not have any hook to indicate whether the non-SVR4 target
1750 backend supports qXfer:libraries:read, so always report it. */
1751 strcat (own_buf
, ";qXfer:libraries:read+");
1754 if (the_target
->read_auxv
!= NULL
)
1755 strcat (own_buf
, ";qXfer:auxv:read+");
1757 if (the_target
->qxfer_spu
!= NULL
)
1758 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1760 if (the_target
->qxfer_siginfo
!= NULL
)
1761 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1763 if (the_target
->read_loadmap
!= NULL
)
1764 strcat (own_buf
, ";qXfer:fdpic:read+");
1766 /* We always report qXfer:features:read, as targets may
1767 install XML files on a subsequent call to arch_setup.
1768 If we reported to GDB on startup that we don't support
1769 qXfer:feature:read at all, we will never be re-queried. */
1770 strcat (own_buf
, ";qXfer:features:read+");
1772 if (transport_is_reliable
)
1773 strcat (own_buf
, ";QStartNoAckMode+");
1775 if (the_target
->qxfer_osdata
!= NULL
)
1776 strcat (own_buf
, ";qXfer:osdata:read+");
1778 if (target_supports_multi_process ())
1779 strcat (own_buf
, ";multiprocess+");
1781 if (target_supports_non_stop ())
1782 strcat (own_buf
, ";QNonStop+");
1784 if (target_supports_disable_randomization ())
1785 strcat (own_buf
, ";QDisableRandomization+");
1787 strcat (own_buf
, ";qXfer:threads:read+");
1789 if (target_supports_tracepoints ())
1791 strcat (own_buf
, ";ConditionalTracepoints+");
1792 strcat (own_buf
, ";TraceStateVariables+");
1793 strcat (own_buf
, ";TracepointSource+");
1794 strcat (own_buf
, ";DisconnectedTracing+");
1795 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1796 strcat (own_buf
, ";FastTracepoints+");
1797 strcat (own_buf
, ";StaticTracepoints+");
1798 strcat (own_buf
, ";InstallInTrace+");
1799 strcat (own_buf
, ";qXfer:statictrace:read+");
1800 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1801 strcat (own_buf
, ";EnableDisableTracepoints+");
1802 strcat (own_buf
, ";QTBuffer:size+");
1803 strcat (own_buf
, ";tracenz+");
1806 /* Support target-side breakpoint conditions and commands. */
1807 strcat (own_buf
, ";ConditionalBreakpoints+");
1808 strcat (own_buf
, ";BreakpointCommands+");
1810 if (target_supports_agent ())
1811 strcat (own_buf
, ";QAgent+");
1813 if (target_supports_btrace ())
1815 strcat (own_buf
, ";Qbtrace:bts+");
1816 strcat (own_buf
, ";Qbtrace:off+");
1817 strcat (own_buf
, ";qXfer:btrace:read+");
1823 /* Thread-local storage support. */
1824 if (the_target
->get_tls_address
!= NULL
1825 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1827 char *p
= own_buf
+ 12;
1828 CORE_ADDR parts
[2], address
= 0;
1830 ptid_t ptid
= null_ptid
;
1832 require_running (own_buf
);
1834 for (i
= 0; i
< 3; i
++)
1842 p2
= strchr (p
, ',');
1855 ptid
= read_ptid (p
, NULL
);
1857 decode_address (&parts
[i
- 1], p
, len
);
1861 if (p
!= NULL
|| i
< 3)
1865 struct thread_info
*thread
= find_thread_ptid (ptid
);
1870 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1876 strcpy (own_buf
, paddress(address
));
1881 write_enn (own_buf
);
1885 /* Otherwise, pretend we do not understand this packet. */
1888 /* Windows OS Thread Information Block address support. */
1889 if (the_target
->get_tib_address
!= NULL
1890 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1895 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1897 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1900 strcpy (own_buf
, paddress(tlb
));
1905 write_enn (own_buf
);
1911 /* Handle "monitor" commands. */
1912 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1914 char *mon
= malloc (PBUFSIZ
);
1915 int len
= strlen (own_buf
+ 6);
1919 write_enn (own_buf
);
1923 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1925 write_enn (own_buf
);
1929 mon
[len
/ 2] = '\0';
1933 if (the_target
->handle_monitor_command
== NULL
1934 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1935 /* Default processing. */
1936 handle_monitor_command (mon
, own_buf
);
1942 if (strncmp ("qSearch:memory:", own_buf
,
1943 sizeof ("qSearch:memory:") - 1) == 0)
1945 require_running (own_buf
);
1946 handle_search_memory (own_buf
, packet_len
);
1950 if (strcmp (own_buf
, "qAttached") == 0
1951 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1953 struct process_info
*process
;
1955 if (own_buf
[sizeof ("qAttached") - 1])
1957 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1958 process
= (struct process_info
*)
1959 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1963 require_running (own_buf
);
1964 process
= current_process ();
1967 if (process
== NULL
)
1969 write_enn (own_buf
);
1973 strcpy (own_buf
, process
->attached
? "1" : "0");
1977 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1979 /* CRC check (compare-section). */
1983 unsigned long long crc
;
1985 require_running (own_buf
);
1986 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
1987 if (*comma
++ != ',')
1989 write_enn (own_buf
);
1992 len
= strtoul (comma
, NULL
, 16);
1993 crc
= crc32 (base
, len
, 0xffffffff);
1994 /* Check for memory failure. */
1995 if (crc
== (unsigned long long) -1)
1997 write_enn (own_buf
);
2000 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2004 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2007 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2010 /* Otherwise we didn't know what packet it was. Say we didn't
2015 static void gdb_wants_all_threads_stopped (void);
2017 /* Parse vCont packets. */
2019 handle_v_cont (char *own_buf
)
2023 struct thread_resume
*resume_info
;
2024 struct thread_resume default_action
= {{0}};
2026 /* Count the number of semicolons in the packet. There should be one
2027 for every action. */
2033 p
= strchr (p
, ';');
2036 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2037 if (resume_info
== NULL
)
2045 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2047 if (p
[0] == 's' || p
[0] == 'S')
2048 resume_info
[i
].kind
= resume_step
;
2049 else if (p
[0] == 'r')
2050 resume_info
[i
].kind
= resume_step
;
2051 else if (p
[0] == 'c' || p
[0] == 'C')
2052 resume_info
[i
].kind
= resume_continue
;
2053 else if (p
[0] == 't')
2054 resume_info
[i
].kind
= resume_stop
;
2058 if (p
[0] == 'S' || p
[0] == 'C')
2061 sig
= strtol (p
+ 1, &q
, 16);
2066 if (!gdb_signal_to_host_p (sig
))
2068 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2070 else if (p
[0] == 'r')
2075 p1
= strchr (p
, ',');
2076 decode_address (&resume_info
[i
].step_range_start
, p
, p1
- p
);
2079 p1
= strchr (p
, ':');
2080 decode_address (&resume_info
[i
].step_range_end
, p
, p1
- p
);
2091 resume_info
[i
].thread
= minus_one_ptid
;
2092 default_action
= resume_info
[i
];
2094 /* Note: we don't increment i here, we'll overwrite this entry
2095 the next time through. */
2097 else if (p
[0] == ':')
2099 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2104 if (p
[0] != ';' && p
[0] != 0)
2107 resume_info
[i
].thread
= ptid
;
2114 resume_info
[i
] = default_action
;
2116 /* `cont_thread' is still used in occasional places in the backend,
2117 to implement single-thread scheduler-locking. Doesn't make sense
2118 to set it if we see a stop request, or a wildcard action (one
2119 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
2121 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
2122 || ptid_get_lwp (resume_info
[0].thread
) == -1)
2123 && resume_info
[0].kind
!= resume_stop
)
2124 cont_thread
= resume_info
[0].thread
;
2126 cont_thread
= minus_one_ptid
;
2127 set_desired_inferior (0);
2132 (*the_target
->resume
) (resume_info
, n
);
2140 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2142 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2143 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2144 current_inferior
->last_status
= last_status
;
2146 /* From the client's perspective, all-stop mode always stops all
2147 threads implicitly (and the target backend has already done
2148 so by now). Tag all threads as "want-stopped", so we don't
2149 resume them implicitly without the client telling us to. */
2150 gdb_wants_all_threads_stopped ();
2151 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2152 disable_async_io ();
2154 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2155 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2156 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2161 write_enn (own_buf
);
2166 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2168 handle_v_attach (char *own_buf
)
2172 pid
= strtol (own_buf
+ 8, NULL
, 16);
2173 if (pid
!= 0 && attach_inferior (pid
) == 0)
2175 /* Don't report shared library events after attaching, even if
2176 some libraries are preloaded. GDB will always poll the
2177 library list. Avoids the "stopped by shared library event"
2178 notice on the GDB side. */
2183 /* In non-stop, we don't send a resume reply. Stop events
2184 will follow up using the normal notification
2189 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2195 write_enn (own_buf
);
2200 /* Run a new program. Return 1 if successful, 0 if failure. */
2202 handle_v_run (char *own_buf
)
2204 char *p
, *next_p
, **new_argv
;
2208 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2214 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2215 if (new_argv
== NULL
)
2217 write_enn (own_buf
);
2222 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2224 next_p
= strchr (p
, ';');
2226 next_p
= p
+ strlen (p
);
2228 if (i
== 0 && p
== next_p
)
2232 /* FIXME: Fail request if out of memory instead of dying. */
2233 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2234 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2235 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2244 if (new_argv
[0] == NULL
)
2246 /* GDB didn't specify a program to run. Use the program from the
2247 last run with the new argument list. */
2249 if (program_argv
== NULL
)
2251 write_enn (own_buf
);
2252 freeargv (new_argv
);
2256 new_argv
[0] = strdup (program_argv
[0]);
2257 if (new_argv
[0] == NULL
)
2259 write_enn (own_buf
);
2260 freeargv (new_argv
);
2265 /* Free the old argv and install the new one. */
2266 freeargv (program_argv
);
2267 program_argv
= new_argv
;
2269 start_inferior (program_argv
);
2270 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2272 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2274 /* In non-stop, sending a resume reply doesn't set the general
2275 thread, but GDB assumes a vRun sets it (this is so GDB can
2276 query which is the main thread of the new inferior. */
2278 general_thread
= last_ptid
;
2284 write_enn (own_buf
);
2289 /* Kill process. Return 1 if successful, 0 if failure. */
2291 handle_v_kill (char *own_buf
)
2294 char *p
= &own_buf
[6];
2296 pid
= strtol (p
, NULL
, 16);
2299 if (pid
!= 0 && kill_inferior (pid
) == 0)
2301 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2302 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2303 last_ptid
= pid_to_ptid (pid
);
2304 discard_queued_stop_replies (pid
);
2310 write_enn (own_buf
);
2315 /* Handle all of the extended 'v' packets. */
2317 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2319 if (!disable_packet_vCont
)
2321 if (strncmp (own_buf
, "vCont;", 6) == 0)
2323 require_running (own_buf
);
2324 handle_v_cont (own_buf
);
2328 if (strncmp (own_buf
, "vCont?", 6) == 0)
2330 strcpy (own_buf
, "vCont;c;C;s;S;t");
2331 if (target_supports_range_stepping ())
2333 own_buf
= own_buf
+ strlen (own_buf
);
2334 strcpy (own_buf
, ";r");
2340 if (strncmp (own_buf
, "vFile:", 6) == 0
2341 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2344 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2346 if ((!extended_protocol
|| !multi_process
) && target_running ())
2348 fprintf (stderr
, "Already debugging a process\n");
2349 write_enn (own_buf
);
2352 handle_v_attach (own_buf
);
2356 if (strncmp (own_buf
, "vRun;", 5) == 0)
2358 if ((!extended_protocol
|| !multi_process
) && target_running ())
2360 fprintf (stderr
, "Already debugging a process\n");
2361 write_enn (own_buf
);
2364 handle_v_run (own_buf
);
2368 if (strncmp (own_buf
, "vKill;", 6) == 0)
2370 if (!target_running ())
2372 fprintf (stderr
, "No process to kill\n");
2373 write_enn (own_buf
);
2376 handle_v_kill (own_buf
);
2380 if (handle_notif_ack (own_buf
, packet_len
))
2383 /* Otherwise we didn't know what packet it was. Say we didn't
2389 /* Resume inferior and wait for another event. In non-stop mode,
2390 don't really wait here, but return immediatelly to the event
2393 myresume (char *own_buf
, int step
, int sig
)
2395 struct thread_resume resume_info
[2];
2397 int valid_cont_thread
;
2399 set_desired_inferior (0);
2401 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2402 && !ptid_equal (cont_thread
, minus_one_ptid
));
2404 if (step
|| sig
|| valid_cont_thread
)
2406 resume_info
[0].thread
= current_ptid
;
2408 resume_info
[0].kind
= resume_step
;
2410 resume_info
[0].kind
= resume_continue
;
2411 resume_info
[0].sig
= sig
;
2415 if (!valid_cont_thread
)
2417 resume_info
[n
].thread
= minus_one_ptid
;
2418 resume_info
[n
].kind
= resume_continue
;
2419 resume_info
[n
].sig
= 0;
2426 (*the_target
->resume
) (resume_info
, n
);
2432 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2434 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2435 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2437 current_inferior
->last_resume_kind
= resume_stop
;
2438 current_inferior
->last_status
= last_status
;
2441 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2442 disable_async_io ();
2444 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2445 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2446 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2450 /* Callback for for_each_inferior. Make a new stop reply for each
2454 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2456 struct thread_info
*thread
= (struct thread_info
*) entry
;
2458 /* For now, assume targets that don't have this callback also don't
2459 manage the thread's last_status field. */
2460 if (the_target
->thread_stopped
== NULL
)
2462 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2464 new_notif
->ptid
= entry
->id
;
2465 new_notif
->status
= thread
->last_status
;
2466 /* Pass the last stop reply back to GDB, but don't notify
2468 notif_event_enque (¬if_stop
,
2469 (struct notif_event
*) new_notif
);
2473 if (thread_stopped (thread
))
2477 "Reporting thread %s as already stopped with %s\n",
2478 target_pid_to_str (entry
->id
),
2479 target_waitstatus_to_string (&thread
->last_status
));
2481 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2483 /* Pass the last stop reply back to GDB, but don't notify
2485 queue_stop_reply (entry
->id
, &thread
->last_status
);
2492 /* Set this inferior threads's state as "want-stopped". We won't
2493 resume this thread until the client gives us another action for
2497 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2499 struct thread_info
*thread
= (struct thread_info
*) entry
;
2501 thread
->last_resume_kind
= resume_stop
;
2503 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2505 /* Most threads are stopped implicitly (all-stop); tag that with
2507 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2508 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2512 /* Set all threads' states as "want-stopped". */
2515 gdb_wants_all_threads_stopped (void)
2517 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2520 /* Clear the gdb_detached flag of every process. */
2523 gdb_reattached_process (struct inferior_list_entry
*entry
)
2525 struct process_info
*process
= (struct process_info
*) entry
;
2527 process
->gdb_detached
= 0;
2530 /* Status handler for the '?' packet. */
2533 handle_status (char *own_buf
)
2535 /* GDB is connected, don't forward events to the target anymore. */
2536 for_each_inferior (&all_processes
, gdb_reattached_process
);
2538 /* In non-stop mode, we must send a stop reply for each stopped
2539 thread. In all-stop mode, just send one for the first stopped
2544 discard_queued_stop_replies (-1);
2545 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2547 /* The first is sent immediatly. OK is sent if there is no
2548 stopped thread, which is the same handling of the vStopped
2549 packet (by design). */
2550 notif_write_event (¬if_stop
, own_buf
);
2555 stabilize_threads ();
2556 gdb_wants_all_threads_stopped ();
2558 if (all_threads
.head
)
2560 struct target_waitstatus status
;
2562 status
.kind
= TARGET_WAITKIND_STOPPED
;
2563 status
.value
.sig
= GDB_SIGNAL_TRAP
;
2564 prepare_resume_reply (own_buf
,
2565 all_threads
.head
->id
, &status
);
2568 strcpy (own_buf
, "W00");
2573 gdbserver_version (void)
2575 printf ("GNU gdbserver %s%s\n"
2576 "Copyright (C) 2013 Free Software Foundation, Inc.\n"
2577 "gdbserver is free software, covered by the "
2578 "GNU General Public License.\n"
2579 "This gdbserver was configured as \"%s\"\n",
2580 PKGVERSION
, version
, host_name
);
2584 gdbserver_usage (FILE *stream
)
2586 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2587 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2588 "\tgdbserver [OPTIONS] --multi COMM\n"
2590 "COMM may either be a tty device (for serial debugging), or \n"
2591 "HOST:PORT to listen for a TCP connection.\n"
2594 " --debug Enable general debugging output.\n"
2595 " --remote-debug Enable remote protocol debugging output.\n"
2596 " --version Display version information and exit.\n"
2597 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2598 " --once Exit after the first connection has "
2600 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2601 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2605 gdbserver_show_disableable (FILE *stream
)
2607 fprintf (stream
, "Disableable packets:\n"
2608 " vCont \tAll vCont packets\n"
2609 " qC \tQuerying the current thread\n"
2610 " qfThreadInfo\tThread listing\n"
2611 " Tthread \tPassing the thread specifier in the "
2612 "T stop reply packet\n"
2613 " threads \tAll of the above\n");
2617 #undef require_running
2618 #define require_running(BUF) \
2619 if (!target_running ()) \
2626 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2628 int pid
= * (int *) args
;
2630 if (ptid_get_pid (entry
->id
) == pid
)
2637 kill_inferior_callback (struct inferior_list_entry
*entry
)
2639 struct process_info
*process
= (struct process_info
*) entry
;
2640 int pid
= ptid_get_pid (process
->head
.id
);
2642 kill_inferior (pid
);
2643 discard_queued_stop_replies (pid
);
2646 /* Callback for for_each_inferior to detach or kill the inferior,
2647 depending on whether we attached to it or not.
2648 We inform the user whether we're detaching or killing the process
2649 as this is only called when gdbserver is about to exit. */
2652 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2654 struct process_info
*process
= (struct process_info
*) entry
;
2655 int pid
= ptid_get_pid (process
->head
.id
);
2657 if (process
->attached
)
2658 detach_inferior (pid
);
2660 kill_inferior (pid
);
2662 discard_queued_stop_replies (pid
);
2665 /* for_each_inferior callback for detach_or_kill_for_exit to print
2666 the pids of started inferiors. */
2669 print_started_pid (struct inferior_list_entry
*entry
)
2671 struct process_info
*process
= (struct process_info
*) entry
;
2673 if (! process
->attached
)
2675 int pid
= ptid_get_pid (process
->head
.id
);
2676 fprintf (stderr
, " %d", pid
);
2680 /* for_each_inferior callback for detach_or_kill_for_exit to print
2681 the pids of attached inferiors. */
2684 print_attached_pid (struct inferior_list_entry
*entry
)
2686 struct process_info
*process
= (struct process_info
*) entry
;
2688 if (process
->attached
)
2690 int pid
= ptid_get_pid (process
->head
.id
);
2691 fprintf (stderr
, " %d", pid
);
2695 /* Call this when exiting gdbserver with possible inferiors that need
2696 to be killed or detached from. */
2699 detach_or_kill_for_exit (void)
2701 /* First print a list of the inferiors we will be killing/detaching.
2702 This is to assist the user, for example, in case the inferior unexpectedly
2703 dies after we exit: did we screw up or did the inferior exit on its own?
2704 Having this info will save some head-scratching. */
2706 if (have_started_inferiors_p ())
2708 fprintf (stderr
, "Killing process(es):");
2709 for_each_inferior (&all_processes
, print_started_pid
);
2710 fprintf (stderr
, "\n");
2712 if (have_attached_inferiors_p ())
2714 fprintf (stderr
, "Detaching process(es):");
2715 for_each_inferior (&all_processes
, print_attached_pid
);
2716 fprintf (stderr
, "\n");
2719 /* Now we can kill or detach the inferiors. */
2721 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2725 main (int argc
, char *argv
[])
2729 char *arg_end
, *port
;
2730 char **next_arg
= &argv
[1];
2731 volatile int multi_mode
= 0;
2732 volatile int attach
= 0;
2735 while (*next_arg
!= NULL
&& **next_arg
== '-')
2737 if (strcmp (*next_arg
, "--version") == 0)
2739 gdbserver_version ();
2742 else if (strcmp (*next_arg
, "--help") == 0)
2744 gdbserver_usage (stdout
);
2747 else if (strcmp (*next_arg
, "--attach") == 0)
2749 else if (strcmp (*next_arg
, "--multi") == 0)
2751 else if (strcmp (*next_arg
, "--wrapper") == 0)
2755 wrapper_argv
= next_arg
;
2756 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2759 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2761 gdbserver_usage (stderr
);
2765 /* Consume the "--". */
2768 else if (strcmp (*next_arg
, "--debug") == 0)
2770 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2772 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2774 gdbserver_show_disableable (stdout
);
2777 else if (strncmp (*next_arg
,
2778 "--disable-packet=",
2779 sizeof ("--disable-packet=") - 1) == 0)
2781 char *packets
, *tok
;
2783 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2784 for (tok
= strtok (packets
, ",");
2786 tok
= strtok (NULL
, ","))
2788 if (strcmp ("vCont", tok
) == 0)
2789 disable_packet_vCont
= 1;
2790 else if (strcmp ("Tthread", tok
) == 0)
2791 disable_packet_Tthread
= 1;
2792 else if (strcmp ("qC", tok
) == 0)
2793 disable_packet_qC
= 1;
2794 else if (strcmp ("qfThreadInfo", tok
) == 0)
2795 disable_packet_qfThreadInfo
= 1;
2796 else if (strcmp ("threads", tok
) == 0)
2798 disable_packet_vCont
= 1;
2799 disable_packet_Tthread
= 1;
2800 disable_packet_qC
= 1;
2801 disable_packet_qfThreadInfo
= 1;
2805 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2807 gdbserver_show_disableable (stderr
);
2812 else if (strcmp (*next_arg
, "-") == 0)
2814 /* "-" specifies a stdio connection and is a form of port
2816 *next_arg
= STDIO_CONNECTION_NAME
;
2819 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2820 disable_randomization
= 1;
2821 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2822 disable_randomization
= 0;
2823 else if (strcmp (*next_arg
, "--once") == 0)
2827 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2835 if (setjmp (toplevel
))
2837 fprintf (stderr
, "Exiting\n");
2843 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2845 gdbserver_usage (stderr
);
2849 /* We need to know whether the remote connection is stdio before
2850 starting the inferior. Inferiors created in this scenario have
2851 stdin,stdout redirected. So do this here before we call
2853 remote_prepare (port
);
2858 /* --attach used to come after PORT, so allow it there for
2860 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2867 && (*next_arg
== NULL
2868 || (*next_arg
)[0] == '\0'
2869 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2871 || next_arg
[1] != NULL
))
2876 gdbserver_usage (stderr
);
2880 initialize_async_io ();
2882 initialize_event_loop ();
2883 if (target_supports_tracepoints ())
2884 initialize_tracepoint ();
2886 own_buf
= xmalloc (PBUFSIZ
+ 1);
2887 mem_buf
= xmalloc (PBUFSIZ
);
2889 if (pid
== 0 && *next_arg
!= NULL
)
2893 n
= argc
- (next_arg
- argv
);
2894 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2895 for (i
= 0; i
< n
; i
++)
2896 program_argv
[i
] = xstrdup (next_arg
[i
]);
2897 program_argv
[i
] = NULL
;
2899 /* Wait till we are at first instruction in program. */
2900 start_inferior (program_argv
);
2902 /* We are now (hopefully) stopped at the first instruction of
2903 the target process. This assumes that the target process was
2904 successfully created. */
2908 if (attach_inferior (pid
) == -1)
2909 error ("Attaching not supported on this target");
2911 /* Otherwise succeeded. */
2915 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2916 last_status
.value
.integer
= 0;
2917 last_ptid
= minus_one_ptid
;
2920 initialize_notif ();
2922 /* Don't report shared library events on the initial connection,
2923 even if some libraries are preloaded. Avoids the "stopped by
2924 shared library event" notice on gdb side. */
2927 if (setjmp (toplevel
))
2929 /* If something fails and longjmps while detaching or killing
2930 inferiors, we'd end up here again, stuck in an infinite loop
2931 trap. Be sure that if that happens, we exit immediately
2933 if (setjmp (toplevel
) == 0)
2934 detach_or_kill_for_exit ();
2936 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2940 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2941 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2946 if (!was_running
&& !multi_mode
)
2948 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2956 /* Be sure we're out of tfind mode. */
2957 current_traceframe
= -1;
2961 if (setjmp (toplevel
) != 0)
2963 /* An error occurred. */
2964 if (response_needed
)
2966 write_enn (own_buf
);
2971 /* Wait for events. This will return when all event sources are
2972 removed from the event loop. */
2973 start_event_loop ();
2975 /* If an exit was requested (using the "monitor exit" command),
2976 terminate now. The only other way to get here is for
2977 getpkt to fail; close the connection and reopen it at the
2980 if (exit_requested
|| run_once
)
2982 /* If something fails and longjmps while detaching or
2983 killing inferiors, we'd end up here again, stuck in an
2984 infinite loop trap. Be sure that if that happens, we
2985 exit immediately instead. */
2986 if (setjmp (toplevel
) == 0)
2988 detach_or_kill_for_exit ();
2993 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2999 "Remote side has terminated connection. "
3000 "GDBserver will reopen the connection.\n");
3004 if (disconnected_tracing
)
3006 /* Try to enable non-stop/async mode, so we we can both
3007 wait for an async socket accept, and handle async
3008 target events simultaneously. There's also no point
3009 either in having the target always stop all threads,
3010 when we're going to pass signals down without
3014 if (start_non_stop (1))
3017 /* Detaching implicitly resumes all threads; simply
3018 disconnecting does not. */
3024 "Disconnected tracing disabled; stopping trace run.\n");
3031 /* Process options coming from Z packets for *point at address
3032 POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
3033 to point to the first char after the last processed option. */
3036 process_point_options (CORE_ADDR point_addr
, char **packet
)
3038 char *dataptr
= *packet
;
3041 /* Check if data has the correct format. */
3042 if (*dataptr
!= ';')
3049 if (*dataptr
== ';')
3052 if (*dataptr
== 'X')
3054 /* Conditional expression. */
3056 fprintf (stderr
, "Found breakpoint condition.\n");
3057 add_breakpoint_condition (point_addr
, &dataptr
);
3059 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
3061 dataptr
+= strlen ("cmds:");
3063 fprintf (stderr
, "Found breakpoint commands %s.\n", dataptr
);
3064 persist
= (*dataptr
== '1');
3066 add_breakpoint_commands (point_addr
, &dataptr
, persist
);
3070 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3072 /* Skip tokens until we find one that we recognize. */
3073 while (*dataptr
&& *dataptr
!= ';')
3080 /* Event loop callback that handles a serial event. The first byte in
3081 the serial buffer gets us here. We expect characters to arrive at
3082 a brisk pace, so we read the rest of the packet with a blocking
3086 process_serial_event (void)
3097 int new_packet_len
= -1;
3099 /* Used to decide when gdbserver should exit in
3100 multi-mode/remote. */
3101 static int have_ran
= 0;
3104 have_ran
= target_running ();
3106 disable_async_io ();
3108 response_needed
= 0;
3109 packet_len
= getpkt (own_buf
);
3110 if (packet_len
<= 0)
3113 /* Force an event loop break. */
3116 response_needed
= 1;
3123 handle_query (own_buf
, packet_len
, &new_packet_len
);
3126 handle_general_set (own_buf
);
3129 require_running (own_buf
);
3134 pid
= strtol (&own_buf
[i
], NULL
, 16);
3137 pid
= ptid_get_pid (current_ptid
);
3139 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3141 struct thread_resume resume_info
;
3142 struct process_info
*process
= find_process_pid (pid
);
3144 if (process
== NULL
)
3146 write_enn (own_buf
);
3150 if (tracing
&& disconnected_tracing
)
3152 "Disconnected tracing in effect, "
3153 "leaving gdbserver attached to the process\n");
3155 if (any_persistent_commands ())
3157 "Persistent commands are present, "
3158 "leaving gdbserver attached to the process\n");
3160 /* Make sure we're in non-stop/async mode, so we we can both
3161 wait for an async socket accept, and handle async target
3162 events simultaneously. There's also no point either in
3163 having the target stop all threads, when we're going to
3164 pass signals down without informing GDB. */
3168 fprintf (stderr
, "Forcing non-stop mode\n");
3174 process
->gdb_detached
= 1;
3176 /* Detaching implicitly resumes all threads. */
3177 resume_info
.thread
= minus_one_ptid
;
3178 resume_info
.kind
= resume_continue
;
3179 resume_info
.sig
= 0;
3180 (*the_target
->resume
) (&resume_info
, 1);
3183 break; /* from switch/case */
3186 fprintf (stderr
, "Detaching from process %d\n", pid
);
3188 if (detach_inferior (pid
) != 0)
3189 write_enn (own_buf
);
3192 discard_queued_stop_replies (pid
);
3195 if (extended_protocol
)
3197 /* Treat this like a normal program exit. */
3198 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3199 last_status
.value
.integer
= 0;
3200 last_ptid
= pid_to_ptid (pid
);
3202 current_inferior
= NULL
;
3209 /* If we are attached, then we can exit. Otherwise, we
3210 need to hang around doing nothing, until the child is
3212 join_inferior (pid
);
3218 extended_protocol
= 1;
3222 handle_status (own_buf
);
3225 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3227 ptid_t gdb_id
, thread_id
;
3230 require_running (own_buf
);
3232 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3234 pid
= ptid_get_pid (gdb_id
);
3236 if (ptid_equal (gdb_id
, null_ptid
)
3237 || ptid_equal (gdb_id
, minus_one_ptid
))
3238 thread_id
= null_ptid
;
3240 && ptid_equal (pid_to_ptid (pid
),
3243 struct thread_info
*thread
=
3244 (struct thread_info
*) find_inferior (&all_threads
,
3249 write_enn (own_buf
);
3253 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
3257 thread_id
= gdb_id_to_thread_id (gdb_id
);
3258 if (ptid_equal (thread_id
, null_ptid
))
3260 write_enn (own_buf
);
3265 if (own_buf
[1] == 'g')
3267 if (ptid_equal (thread_id
, null_ptid
))
3269 /* GDB is telling us to choose any thread. Check if
3270 the currently selected thread is still valid. If
3271 it is not, select the first available. */
3272 struct thread_info
*thread
=
3273 (struct thread_info
*) find_inferior_id (&all_threads
,
3276 thread_id
= all_threads
.head
->id
;
3279 general_thread
= thread_id
;
3280 set_desired_inferior (1);
3282 else if (own_buf
[1] == 'c')
3283 cont_thread
= thread_id
;
3289 /* Silently ignore it so that gdb can extend the protocol
3290 without compatibility headaches. */
3295 require_running (own_buf
);
3296 if (current_traceframe
>= 0)
3298 struct regcache
*regcache
= new_register_cache ();
3300 if (fetch_traceframe_registers (current_traceframe
,
3302 registers_to_string (regcache
, own_buf
);
3304 write_enn (own_buf
);
3305 free_register_cache (regcache
);
3309 struct regcache
*regcache
;
3311 set_desired_inferior (1);
3312 regcache
= get_thread_regcache (current_inferior
, 1);
3313 registers_to_string (regcache
, own_buf
);
3317 require_running (own_buf
);
3318 if (current_traceframe
>= 0)
3319 write_enn (own_buf
);
3322 struct regcache
*regcache
;
3324 set_desired_inferior (1);
3325 regcache
= get_thread_regcache (current_inferior
, 1);
3326 registers_from_string (regcache
, &own_buf
[1]);
3331 require_running (own_buf
);
3332 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3333 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3335 write_enn (own_buf
);
3337 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3340 require_running (own_buf
);
3341 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3342 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3345 write_enn (own_buf
);
3348 require_running (own_buf
);
3349 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3350 &mem_addr
, &len
, &mem_buf
) < 0
3351 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3352 write_enn (own_buf
);
3357 require_running (own_buf
);
3358 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3359 if (gdb_signal_to_host_p (sig
))
3360 signal
= gdb_signal_to_host (sig
);
3363 myresume (own_buf
, 0, signal
);
3366 require_running (own_buf
);
3367 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3368 if (gdb_signal_to_host_p (sig
))
3369 signal
= gdb_signal_to_host (sig
);
3372 myresume (own_buf
, 1, signal
);
3375 require_running (own_buf
);
3377 myresume (own_buf
, 0, signal
);
3380 require_running (own_buf
);
3382 myresume (own_buf
, 1, signal
);
3384 case 'Z': /* insert_ ... */
3386 case 'z': /* remove_ ... */
3391 char type
= own_buf
[1];
3393 const int insert
= ch
== 'Z';
3394 char *p
= &own_buf
[3];
3396 p
= unpack_varlen_hex (p
, &addr
);
3397 len
= strtol (p
+ 1, &dataptr
, 16);
3399 /* Default to unrecognized/unsupported. */
3403 case '0': /* software-breakpoint */
3404 case '1': /* hardware-breakpoint */
3405 case '2': /* write watchpoint */
3406 case '3': /* read watchpoint */
3407 case '4': /* access watchpoint */
3408 require_running (own_buf
);
3409 if (insert
&& the_target
->insert_point
!= NULL
)
3411 /* Insert the breakpoint. If it is already inserted, nothing
3413 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3415 /* GDB may have sent us a list of *point parameters to be
3416 evaluated on the target's side. Read such list here. If we
3417 already have a list of parameters, GDB is telling us to drop
3418 that list and use this one instead. */
3419 if (!res
&& (type
== '0' || type
== '1'))
3421 /* Remove previous conditions. */
3422 clear_gdb_breakpoint_conditions (addr
);
3423 process_point_options (addr
, &dataptr
);
3426 else if (!insert
&& the_target
->remove_point
!= NULL
)
3427 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3439 write_enn (own_buf
);
3443 response_needed
= 0;
3444 if (!target_running ())
3445 /* The packet we received doesn't make sense - but we can't
3446 reply to it, either. */
3449 fprintf (stderr
, "Killing all inferiors\n");
3450 for_each_inferior (&all_processes
, kill_inferior_callback
);
3452 /* When using the extended protocol, we wait with no program
3453 running. The traditional protocol will exit instead. */
3454 if (extended_protocol
)
3456 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3457 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3465 ptid_t gdb_id
, thread_id
;
3467 require_running (own_buf
);
3469 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3470 thread_id
= gdb_id_to_thread_id (gdb_id
);
3471 if (ptid_equal (thread_id
, null_ptid
))
3473 write_enn (own_buf
);
3477 if (mythread_alive (thread_id
))
3480 write_enn (own_buf
);
3484 response_needed
= 0;
3486 /* Restarting the inferior is only supported in the extended
3488 if (extended_protocol
)
3490 if (target_running ())
3491 for_each_inferior (&all_processes
,
3492 kill_inferior_callback
);
3493 fprintf (stderr
, "GDBserver restarting\n");
3495 /* Wait till we are at 1st instruction in prog. */
3496 if (program_argv
!= NULL
)
3497 start_inferior (program_argv
);
3500 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3501 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3507 /* It is a request we don't understand. Respond with an
3508 empty packet so that gdb knows that we don't support this
3514 /* Extended (long) request. */
3515 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3519 /* It is a request we don't understand. Respond with an empty
3520 packet so that gdb knows that we don't support this
3526 if (new_packet_len
!= -1)
3527 putpkt_binary (own_buf
, new_packet_len
);
3531 response_needed
= 0;
3533 if (!extended_protocol
&& have_ran
&& !target_running ())
3535 /* In non-stop, defer exiting until GDB had a chance to query
3536 the whole vStopped list (until it gets an OK). */
3537 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3539 fprintf (stderr
, "GDBserver exiting\n");
3551 /* Event-loop callback for serial events. */
3554 handle_serial_event (int err
, gdb_client_data client_data
)
3557 fprintf (stderr
, "handling possible serial event\n");
3559 /* Really handle it. */
3560 if (process_serial_event () < 0)
3563 /* Be sure to not change the selected inferior behind GDB's back.
3564 Important in the non-stop mode asynchronous protocol. */
3565 set_desired_inferior (1);
3570 /* Event-loop callback for target events. */
3573 handle_target_event (int err
, gdb_client_data client_data
)
3576 fprintf (stderr
, "handling possible target event\n");
3578 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3581 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3583 int pid
= ptid_get_pid (last_ptid
);
3584 struct process_info
*process
= find_process_pid (pid
);
3585 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3587 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3588 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3590 mark_breakpoints_out (process
);
3591 mourn_inferior (process
);
3595 /* We're reporting this thread as stopped. Update its
3596 "want-stopped" state to what the client wants, until it
3597 gets a new resume action. */
3598 current_inferior
->last_resume_kind
= resume_stop
;
3599 current_inferior
->last_status
= last_status
;
3604 if (!target_running ())
3606 /* The last process exited. We're done. */
3610 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3612 /* A thread stopped with a signal, but gdb isn't
3613 connected to handle it. Pass it down to the
3614 inferior, as if it wasn't being traced. */
3615 struct thread_resume resume_info
;
3619 "GDB not connected; forwarding event %d for [%s]\n",
3620 (int) last_status
.kind
,
3621 target_pid_to_str (last_ptid
));
3623 resume_info
.thread
= last_ptid
;
3624 resume_info
.kind
= resume_continue
;
3625 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3626 (*the_target
->resume
) (&resume_info
, 1);
3628 else if (debug_threads
)
3629 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3630 (int) last_status
.kind
,
3631 target_pid_to_str (last_ptid
));
3635 struct vstop_notif
*vstop_notif
3636 = xmalloc (sizeof (struct vstop_notif
));
3638 vstop_notif
->status
= last_status
;
3639 vstop_notif
->ptid
= last_ptid
;
3640 /* Push Stop notification. */
3641 notif_push (¬if_stop
,
3642 (struct notif_event
*) vstop_notif
);
3646 /* Be sure to not change the selected inferior behind GDB's back.
3647 Important in the non-stop mode asynchronous protocol. */
3648 set_desired_inferior (1);