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 if (p
[0] == 's' || p
[0] == 'S')
2046 resume_info
[i
].kind
= resume_step
;
2047 else if (p
[0] == 'c' || p
[0] == 'C')
2048 resume_info
[i
].kind
= resume_continue
;
2049 else if (p
[0] == 't')
2050 resume_info
[i
].kind
= resume_stop
;
2054 if (p
[0] == 'S' || p
[0] == 'C')
2057 sig
= strtol (p
+ 1, &q
, 16);
2062 if (!gdb_signal_to_host_p (sig
))
2064 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2068 resume_info
[i
].sig
= 0;
2074 resume_info
[i
].thread
= minus_one_ptid
;
2075 default_action
= resume_info
[i
];
2077 /* Note: we don't increment i here, we'll overwrite this entry
2078 the next time through. */
2080 else if (p
[0] == ':')
2082 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2087 if (p
[0] != ';' && p
[0] != 0)
2090 resume_info
[i
].thread
= ptid
;
2097 resume_info
[i
] = default_action
;
2099 /* `cont_thread' is still used in occasional places in the backend,
2100 to implement single-thread scheduler-locking. Doesn't make sense
2101 to set it if we see a stop request, or a wildcard action (one
2102 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
2104 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
2105 || ptid_get_lwp (resume_info
[0].thread
) == -1)
2106 && resume_info
[0].kind
!= resume_stop
)
2107 cont_thread
= resume_info
[0].thread
;
2109 cont_thread
= minus_one_ptid
;
2110 set_desired_inferior (0);
2115 (*the_target
->resume
) (resume_info
, n
);
2123 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2125 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2126 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2127 current_inferior
->last_status
= last_status
;
2129 /* From the client's perspective, all-stop mode always stops all
2130 threads implicitly (and the target backend has already done
2131 so by now). Tag all threads as "want-stopped", so we don't
2132 resume them implicitly without the client telling us to. */
2133 gdb_wants_all_threads_stopped ();
2134 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2135 disable_async_io ();
2137 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2138 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2139 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2144 write_enn (own_buf
);
2149 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2151 handle_v_attach (char *own_buf
)
2155 pid
= strtol (own_buf
+ 8, NULL
, 16);
2156 if (pid
!= 0 && attach_inferior (pid
) == 0)
2158 /* Don't report shared library events after attaching, even if
2159 some libraries are preloaded. GDB will always poll the
2160 library list. Avoids the "stopped by shared library event"
2161 notice on the GDB side. */
2166 /* In non-stop, we don't send a resume reply. Stop events
2167 will follow up using the normal notification
2172 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2178 write_enn (own_buf
);
2183 /* Run a new program. Return 1 if successful, 0 if failure. */
2185 handle_v_run (char *own_buf
)
2187 char *p
, *next_p
, **new_argv
;
2191 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2197 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2198 if (new_argv
== NULL
)
2200 write_enn (own_buf
);
2205 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2207 next_p
= strchr (p
, ';');
2209 next_p
= p
+ strlen (p
);
2211 if (i
== 0 && p
== next_p
)
2215 /* FIXME: Fail request if out of memory instead of dying. */
2216 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2217 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2218 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2227 if (new_argv
[0] == NULL
)
2229 /* GDB didn't specify a program to run. Use the program from the
2230 last run with the new argument list. */
2232 if (program_argv
== NULL
)
2234 write_enn (own_buf
);
2235 freeargv (new_argv
);
2239 new_argv
[0] = strdup (program_argv
[0]);
2240 if (new_argv
[0] == NULL
)
2242 write_enn (own_buf
);
2243 freeargv (new_argv
);
2248 /* Free the old argv and install the new one. */
2249 freeargv (program_argv
);
2250 program_argv
= new_argv
;
2252 start_inferior (program_argv
);
2253 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2255 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2257 /* In non-stop, sending a resume reply doesn't set the general
2258 thread, but GDB assumes a vRun sets it (this is so GDB can
2259 query which is the main thread of the new inferior. */
2261 general_thread
= last_ptid
;
2267 write_enn (own_buf
);
2272 /* Kill process. Return 1 if successful, 0 if failure. */
2274 handle_v_kill (char *own_buf
)
2277 char *p
= &own_buf
[6];
2279 pid
= strtol (p
, NULL
, 16);
2282 if (pid
!= 0 && kill_inferior (pid
) == 0)
2284 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2285 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2286 last_ptid
= pid_to_ptid (pid
);
2287 discard_queued_stop_replies (pid
);
2293 write_enn (own_buf
);
2298 /* Handle all of the extended 'v' packets. */
2300 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2302 if (!disable_packet_vCont
)
2304 if (strncmp (own_buf
, "vCont;", 6) == 0)
2306 require_running (own_buf
);
2307 handle_v_cont (own_buf
);
2311 if (strncmp (own_buf
, "vCont?", 6) == 0)
2313 strcpy (own_buf
, "vCont;c;C;s;S;t");
2318 if (strncmp (own_buf
, "vFile:", 6) == 0
2319 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2322 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2324 if ((!extended_protocol
|| !multi_process
) && target_running ())
2326 fprintf (stderr
, "Already debugging a process\n");
2327 write_enn (own_buf
);
2330 handle_v_attach (own_buf
);
2334 if (strncmp (own_buf
, "vRun;", 5) == 0)
2336 if ((!extended_protocol
|| !multi_process
) && target_running ())
2338 fprintf (stderr
, "Already debugging a process\n");
2339 write_enn (own_buf
);
2342 handle_v_run (own_buf
);
2346 if (strncmp (own_buf
, "vKill;", 6) == 0)
2348 if (!target_running ())
2350 fprintf (stderr
, "No process to kill\n");
2351 write_enn (own_buf
);
2354 handle_v_kill (own_buf
);
2358 if (handle_notif_ack (own_buf
, packet_len
))
2361 /* Otherwise we didn't know what packet it was. Say we didn't
2367 /* Resume inferior and wait for another event. In non-stop mode,
2368 don't really wait here, but return immediatelly to the event
2371 myresume (char *own_buf
, int step
, int sig
)
2373 struct thread_resume resume_info
[2];
2375 int valid_cont_thread
;
2377 set_desired_inferior (0);
2379 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2380 && !ptid_equal (cont_thread
, minus_one_ptid
));
2382 if (step
|| sig
|| valid_cont_thread
)
2384 resume_info
[0].thread
= current_ptid
;
2386 resume_info
[0].kind
= resume_step
;
2388 resume_info
[0].kind
= resume_continue
;
2389 resume_info
[0].sig
= sig
;
2393 if (!valid_cont_thread
)
2395 resume_info
[n
].thread
= minus_one_ptid
;
2396 resume_info
[n
].kind
= resume_continue
;
2397 resume_info
[n
].sig
= 0;
2404 (*the_target
->resume
) (resume_info
, n
);
2410 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2412 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2413 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2415 current_inferior
->last_resume_kind
= resume_stop
;
2416 current_inferior
->last_status
= last_status
;
2419 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2420 disable_async_io ();
2422 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2423 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2424 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2428 /* Callback for for_each_inferior. Make a new stop reply for each
2432 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2434 struct thread_info
*thread
= (struct thread_info
*) entry
;
2436 /* For now, assume targets that don't have this callback also don't
2437 manage the thread's last_status field. */
2438 if (the_target
->thread_stopped
== NULL
)
2440 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2442 new_notif
->ptid
= entry
->id
;
2443 new_notif
->status
= thread
->last_status
;
2444 /* Pass the last stop reply back to GDB, but don't notify
2446 notif_event_enque (¬if_stop
,
2447 (struct notif_event
*) new_notif
);
2451 if (thread_stopped (thread
))
2455 "Reporting thread %s as already stopped with %s\n",
2456 target_pid_to_str (entry
->id
),
2457 target_waitstatus_to_string (&thread
->last_status
));
2459 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2461 /* Pass the last stop reply back to GDB, but don't notify
2463 queue_stop_reply (entry
->id
, &thread
->last_status
);
2470 /* Set this inferior threads's state as "want-stopped". We won't
2471 resume this thread until the client gives us another action for
2475 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2477 struct thread_info
*thread
= (struct thread_info
*) entry
;
2479 thread
->last_resume_kind
= resume_stop
;
2481 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2483 /* Most threads are stopped implicitly (all-stop); tag that with
2485 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2486 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2490 /* Set all threads' states as "want-stopped". */
2493 gdb_wants_all_threads_stopped (void)
2495 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2498 /* Clear the gdb_detached flag of every process. */
2501 gdb_reattached_process (struct inferior_list_entry
*entry
)
2503 struct process_info
*process
= (struct process_info
*) entry
;
2505 process
->gdb_detached
= 0;
2508 /* Status handler for the '?' packet. */
2511 handle_status (char *own_buf
)
2513 /* GDB is connected, don't forward events to the target anymore. */
2514 for_each_inferior (&all_processes
, gdb_reattached_process
);
2516 /* In non-stop mode, we must send a stop reply for each stopped
2517 thread. In all-stop mode, just send one for the first stopped
2522 discard_queued_stop_replies (-1);
2523 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2525 /* The first is sent immediatly. OK is sent if there is no
2526 stopped thread, which is the same handling of the vStopped
2527 packet (by design). */
2528 notif_write_event (¬if_stop
, own_buf
);
2533 stabilize_threads ();
2534 gdb_wants_all_threads_stopped ();
2536 if (all_threads
.head
)
2538 struct target_waitstatus status
;
2540 status
.kind
= TARGET_WAITKIND_STOPPED
;
2541 status
.value
.sig
= GDB_SIGNAL_TRAP
;
2542 prepare_resume_reply (own_buf
,
2543 all_threads
.head
->id
, &status
);
2546 strcpy (own_buf
, "W00");
2551 gdbserver_version (void)
2553 printf ("GNU gdbserver %s%s\n"
2554 "Copyright (C) 2013 Free Software Foundation, Inc.\n"
2555 "gdbserver is free software, covered by the "
2556 "GNU General Public License.\n"
2557 "This gdbserver was configured as \"%s\"\n",
2558 PKGVERSION
, version
, host_name
);
2562 gdbserver_usage (FILE *stream
)
2564 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2565 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2566 "\tgdbserver [OPTIONS] --multi COMM\n"
2568 "COMM may either be a tty device (for serial debugging), or \n"
2569 "HOST:PORT to listen for a TCP connection.\n"
2572 " --debug Enable general debugging output.\n"
2573 " --remote-debug Enable remote protocol debugging output.\n"
2574 " --version Display version information and exit.\n"
2575 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2576 " --once Exit after the first connection has "
2578 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2579 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2583 gdbserver_show_disableable (FILE *stream
)
2585 fprintf (stream
, "Disableable packets:\n"
2586 " vCont \tAll vCont packets\n"
2587 " qC \tQuerying the current thread\n"
2588 " qfThreadInfo\tThread listing\n"
2589 " Tthread \tPassing the thread specifier in the "
2590 "T stop reply packet\n"
2591 " threads \tAll of the above\n");
2595 #undef require_running
2596 #define require_running(BUF) \
2597 if (!target_running ()) \
2604 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2606 int pid
= * (int *) args
;
2608 if (ptid_get_pid (entry
->id
) == pid
)
2615 kill_inferior_callback (struct inferior_list_entry
*entry
)
2617 struct process_info
*process
= (struct process_info
*) entry
;
2618 int pid
= ptid_get_pid (process
->head
.id
);
2620 kill_inferior (pid
);
2621 discard_queued_stop_replies (pid
);
2624 /* Callback for for_each_inferior to detach or kill the inferior,
2625 depending on whether we attached to it or not.
2626 We inform the user whether we're detaching or killing the process
2627 as this is only called when gdbserver is about to exit. */
2630 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2632 struct process_info
*process
= (struct process_info
*) entry
;
2633 int pid
= ptid_get_pid (process
->head
.id
);
2635 if (process
->attached
)
2636 detach_inferior (pid
);
2638 kill_inferior (pid
);
2640 discard_queued_stop_replies (pid
);
2643 /* for_each_inferior callback for detach_or_kill_for_exit to print
2644 the pids of started inferiors. */
2647 print_started_pid (struct inferior_list_entry
*entry
)
2649 struct process_info
*process
= (struct process_info
*) entry
;
2651 if (! process
->attached
)
2653 int pid
= ptid_get_pid (process
->head
.id
);
2654 fprintf (stderr
, " %d", pid
);
2658 /* for_each_inferior callback for detach_or_kill_for_exit to print
2659 the pids of attached inferiors. */
2662 print_attached_pid (struct inferior_list_entry
*entry
)
2664 struct process_info
*process
= (struct process_info
*) entry
;
2666 if (process
->attached
)
2668 int pid
= ptid_get_pid (process
->head
.id
);
2669 fprintf (stderr
, " %d", pid
);
2673 /* Call this when exiting gdbserver with possible inferiors that need
2674 to be killed or detached from. */
2677 detach_or_kill_for_exit (void)
2679 /* First print a list of the inferiors we will be killing/detaching.
2680 This is to assist the user, for example, in case the inferior unexpectedly
2681 dies after we exit: did we screw up or did the inferior exit on its own?
2682 Having this info will save some head-scratching. */
2684 if (have_started_inferiors_p ())
2686 fprintf (stderr
, "Killing process(es):");
2687 for_each_inferior (&all_processes
, print_started_pid
);
2688 fprintf (stderr
, "\n");
2690 if (have_attached_inferiors_p ())
2692 fprintf (stderr
, "Detaching process(es):");
2693 for_each_inferior (&all_processes
, print_attached_pid
);
2694 fprintf (stderr
, "\n");
2697 /* Now we can kill or detach the inferiors. */
2699 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2703 main (int argc
, char *argv
[])
2707 char *arg_end
, *port
;
2708 char **next_arg
= &argv
[1];
2709 volatile int multi_mode
= 0;
2710 volatile int attach
= 0;
2713 while (*next_arg
!= NULL
&& **next_arg
== '-')
2715 if (strcmp (*next_arg
, "--version") == 0)
2717 gdbserver_version ();
2720 else if (strcmp (*next_arg
, "--help") == 0)
2722 gdbserver_usage (stdout
);
2725 else if (strcmp (*next_arg
, "--attach") == 0)
2727 else if (strcmp (*next_arg
, "--multi") == 0)
2729 else if (strcmp (*next_arg
, "--wrapper") == 0)
2733 wrapper_argv
= next_arg
;
2734 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2737 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2739 gdbserver_usage (stderr
);
2743 /* Consume the "--". */
2746 else if (strcmp (*next_arg
, "--debug") == 0)
2748 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2750 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2752 gdbserver_show_disableable (stdout
);
2755 else if (strncmp (*next_arg
,
2756 "--disable-packet=",
2757 sizeof ("--disable-packet=") - 1) == 0)
2759 char *packets
, *tok
;
2761 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2762 for (tok
= strtok (packets
, ",");
2764 tok
= strtok (NULL
, ","))
2766 if (strcmp ("vCont", tok
) == 0)
2767 disable_packet_vCont
= 1;
2768 else if (strcmp ("Tthread", tok
) == 0)
2769 disable_packet_Tthread
= 1;
2770 else if (strcmp ("qC", tok
) == 0)
2771 disable_packet_qC
= 1;
2772 else if (strcmp ("qfThreadInfo", tok
) == 0)
2773 disable_packet_qfThreadInfo
= 1;
2774 else if (strcmp ("threads", tok
) == 0)
2776 disable_packet_vCont
= 1;
2777 disable_packet_Tthread
= 1;
2778 disable_packet_qC
= 1;
2779 disable_packet_qfThreadInfo
= 1;
2783 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2785 gdbserver_show_disableable (stderr
);
2790 else if (strcmp (*next_arg
, "-") == 0)
2792 /* "-" specifies a stdio connection and is a form of port
2794 *next_arg
= STDIO_CONNECTION_NAME
;
2797 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2798 disable_randomization
= 1;
2799 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2800 disable_randomization
= 0;
2801 else if (strcmp (*next_arg
, "--once") == 0)
2805 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2813 if (setjmp (toplevel
))
2815 fprintf (stderr
, "Exiting\n");
2821 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2823 gdbserver_usage (stderr
);
2827 /* We need to know whether the remote connection is stdio before
2828 starting the inferior. Inferiors created in this scenario have
2829 stdin,stdout redirected. So do this here before we call
2831 remote_prepare (port
);
2836 /* --attach used to come after PORT, so allow it there for
2838 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2845 && (*next_arg
== NULL
2846 || (*next_arg
)[0] == '\0'
2847 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2849 || next_arg
[1] != NULL
))
2854 gdbserver_usage (stderr
);
2858 initialize_async_io ();
2860 initialize_event_loop ();
2861 if (target_supports_tracepoints ())
2862 initialize_tracepoint ();
2864 own_buf
= xmalloc (PBUFSIZ
+ 1);
2865 mem_buf
= xmalloc (PBUFSIZ
);
2867 if (pid
== 0 && *next_arg
!= NULL
)
2871 n
= argc
- (next_arg
- argv
);
2872 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2873 for (i
= 0; i
< n
; i
++)
2874 program_argv
[i
] = xstrdup (next_arg
[i
]);
2875 program_argv
[i
] = NULL
;
2877 /* Wait till we are at first instruction in program. */
2878 start_inferior (program_argv
);
2880 /* We are now (hopefully) stopped at the first instruction of
2881 the target process. This assumes that the target process was
2882 successfully created. */
2886 if (attach_inferior (pid
) == -1)
2887 error ("Attaching not supported on this target");
2889 /* Otherwise succeeded. */
2893 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2894 last_status
.value
.integer
= 0;
2895 last_ptid
= minus_one_ptid
;
2898 initialize_notif ();
2900 /* Don't report shared library events on the initial connection,
2901 even if some libraries are preloaded. Avoids the "stopped by
2902 shared library event" notice on gdb side. */
2905 if (setjmp (toplevel
))
2907 /* If something fails and longjmps while detaching or killing
2908 inferiors, we'd end up here again, stuck in an infinite loop
2909 trap. Be sure that if that happens, we exit immediately
2911 if (setjmp (toplevel
) == 0)
2912 detach_or_kill_for_exit ();
2914 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2918 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2919 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2924 if (!was_running
&& !multi_mode
)
2926 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2934 /* Be sure we're out of tfind mode. */
2935 current_traceframe
= -1;
2939 if (setjmp (toplevel
) != 0)
2941 /* An error occurred. */
2942 if (response_needed
)
2944 write_enn (own_buf
);
2949 /* Wait for events. This will return when all event sources are
2950 removed from the event loop. */
2951 start_event_loop ();
2953 /* If an exit was requested (using the "monitor exit" command),
2954 terminate now. The only other way to get here is for
2955 getpkt to fail; close the connection and reopen it at the
2958 if (exit_requested
|| run_once
)
2960 /* If something fails and longjmps while detaching or
2961 killing inferiors, we'd end up here again, stuck in an
2962 infinite loop trap. Be sure that if that happens, we
2963 exit immediately instead. */
2964 if (setjmp (toplevel
) == 0)
2966 detach_or_kill_for_exit ();
2971 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2977 "Remote side has terminated connection. "
2978 "GDBserver will reopen the connection.\n");
2982 if (disconnected_tracing
)
2984 /* Try to enable non-stop/async mode, so we we can both
2985 wait for an async socket accept, and handle async
2986 target events simultaneously. There's also no point
2987 either in having the target always stop all threads,
2988 when we're going to pass signals down without
2992 if (start_non_stop (1))
2995 /* Detaching implicitly resumes all threads; simply
2996 disconnecting does not. */
3002 "Disconnected tracing disabled; stopping trace run.\n");
3009 /* Process options coming from Z packets for *point at address
3010 POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
3011 to point to the first char after the last processed option. */
3014 process_point_options (CORE_ADDR point_addr
, char **packet
)
3016 char *dataptr
= *packet
;
3019 /* Check if data has the correct format. */
3020 if (*dataptr
!= ';')
3027 if (*dataptr
== ';')
3030 if (*dataptr
== 'X')
3032 /* Conditional expression. */
3034 fprintf (stderr
, "Found breakpoint condition.\n");
3035 add_breakpoint_condition (point_addr
, &dataptr
);
3037 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
3039 dataptr
+= strlen ("cmds:");
3041 fprintf (stderr
, "Found breakpoint commands %s.\n", dataptr
);
3042 persist
= (*dataptr
== '1');
3044 add_breakpoint_commands (point_addr
, &dataptr
, persist
);
3048 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3050 /* Skip tokens until we find one that we recognize. */
3051 while (*dataptr
&& *dataptr
!= ';')
3058 /* Event loop callback that handles a serial event. The first byte in
3059 the serial buffer gets us here. We expect characters to arrive at
3060 a brisk pace, so we read the rest of the packet with a blocking
3064 process_serial_event (void)
3075 int new_packet_len
= -1;
3077 /* Used to decide when gdbserver should exit in
3078 multi-mode/remote. */
3079 static int have_ran
= 0;
3082 have_ran
= target_running ();
3084 disable_async_io ();
3086 response_needed
= 0;
3087 packet_len
= getpkt (own_buf
);
3088 if (packet_len
<= 0)
3091 /* Force an event loop break. */
3094 response_needed
= 1;
3101 handle_query (own_buf
, packet_len
, &new_packet_len
);
3104 handle_general_set (own_buf
);
3107 require_running (own_buf
);
3112 pid
= strtol (&own_buf
[i
], NULL
, 16);
3115 pid
= ptid_get_pid (current_ptid
);
3117 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3119 struct thread_resume resume_info
;
3120 struct process_info
*process
= find_process_pid (pid
);
3122 if (process
== NULL
)
3124 write_enn (own_buf
);
3128 if (tracing
&& disconnected_tracing
)
3130 "Disconnected tracing in effect, "
3131 "leaving gdbserver attached to the process\n");
3133 if (any_persistent_commands ())
3135 "Persistent commands are present, "
3136 "leaving gdbserver attached to the process\n");
3138 /* Make sure we're in non-stop/async mode, so we we can both
3139 wait for an async socket accept, and handle async target
3140 events simultaneously. There's also no point either in
3141 having the target stop all threads, when we're going to
3142 pass signals down without informing GDB. */
3146 fprintf (stderr
, "Forcing non-stop mode\n");
3152 process
->gdb_detached
= 1;
3154 /* Detaching implicitly resumes all threads. */
3155 resume_info
.thread
= minus_one_ptid
;
3156 resume_info
.kind
= resume_continue
;
3157 resume_info
.sig
= 0;
3158 (*the_target
->resume
) (&resume_info
, 1);
3161 break; /* from switch/case */
3164 fprintf (stderr
, "Detaching from process %d\n", pid
);
3166 if (detach_inferior (pid
) != 0)
3167 write_enn (own_buf
);
3170 discard_queued_stop_replies (pid
);
3173 if (extended_protocol
)
3175 /* Treat this like a normal program exit. */
3176 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3177 last_status
.value
.integer
= 0;
3178 last_ptid
= pid_to_ptid (pid
);
3180 current_inferior
= NULL
;
3187 /* If we are attached, then we can exit. Otherwise, we
3188 need to hang around doing nothing, until the child is
3190 join_inferior (pid
);
3196 extended_protocol
= 1;
3200 handle_status (own_buf
);
3203 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3205 ptid_t gdb_id
, thread_id
;
3208 require_running (own_buf
);
3210 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3212 pid
= ptid_get_pid (gdb_id
);
3214 if (ptid_equal (gdb_id
, null_ptid
)
3215 || ptid_equal (gdb_id
, minus_one_ptid
))
3216 thread_id
= null_ptid
;
3218 && ptid_equal (pid_to_ptid (pid
),
3221 struct thread_info
*thread
=
3222 (struct thread_info
*) find_inferior (&all_threads
,
3227 write_enn (own_buf
);
3231 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
3235 thread_id
= gdb_id_to_thread_id (gdb_id
);
3236 if (ptid_equal (thread_id
, null_ptid
))
3238 write_enn (own_buf
);
3243 if (own_buf
[1] == 'g')
3245 if (ptid_equal (thread_id
, null_ptid
))
3247 /* GDB is telling us to choose any thread. Check if
3248 the currently selected thread is still valid. If
3249 it is not, select the first available. */
3250 struct thread_info
*thread
=
3251 (struct thread_info
*) find_inferior_id (&all_threads
,
3254 thread_id
= all_threads
.head
->id
;
3257 general_thread
= thread_id
;
3258 set_desired_inferior (1);
3260 else if (own_buf
[1] == 'c')
3261 cont_thread
= thread_id
;
3267 /* Silently ignore it so that gdb can extend the protocol
3268 without compatibility headaches. */
3273 require_running (own_buf
);
3274 if (current_traceframe
>= 0)
3276 struct regcache
*regcache
= new_register_cache ();
3278 if (fetch_traceframe_registers (current_traceframe
,
3280 registers_to_string (regcache
, own_buf
);
3282 write_enn (own_buf
);
3283 free_register_cache (regcache
);
3287 struct regcache
*regcache
;
3289 set_desired_inferior (1);
3290 regcache
= get_thread_regcache (current_inferior
, 1);
3291 registers_to_string (regcache
, own_buf
);
3295 require_running (own_buf
);
3296 if (current_traceframe
>= 0)
3297 write_enn (own_buf
);
3300 struct regcache
*regcache
;
3302 set_desired_inferior (1);
3303 regcache
= get_thread_regcache (current_inferior
, 1);
3304 registers_from_string (regcache
, &own_buf
[1]);
3309 require_running (own_buf
);
3310 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3311 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3313 write_enn (own_buf
);
3315 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3318 require_running (own_buf
);
3319 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3320 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3323 write_enn (own_buf
);
3326 require_running (own_buf
);
3327 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3328 &mem_addr
, &len
, &mem_buf
) < 0
3329 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3330 write_enn (own_buf
);
3335 require_running (own_buf
);
3336 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3337 if (gdb_signal_to_host_p (sig
))
3338 signal
= gdb_signal_to_host (sig
);
3341 myresume (own_buf
, 0, signal
);
3344 require_running (own_buf
);
3345 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3346 if (gdb_signal_to_host_p (sig
))
3347 signal
= gdb_signal_to_host (sig
);
3350 myresume (own_buf
, 1, signal
);
3353 require_running (own_buf
);
3355 myresume (own_buf
, 0, signal
);
3358 require_running (own_buf
);
3360 myresume (own_buf
, 1, signal
);
3362 case 'Z': /* insert_ ... */
3364 case 'z': /* remove_ ... */
3369 char type
= own_buf
[1];
3371 const int insert
= ch
== 'Z';
3372 char *p
= &own_buf
[3];
3374 p
= unpack_varlen_hex (p
, &addr
);
3375 len
= strtol (p
+ 1, &dataptr
, 16);
3377 /* Default to unrecognized/unsupported. */
3381 case '0': /* software-breakpoint */
3382 case '1': /* hardware-breakpoint */
3383 case '2': /* write watchpoint */
3384 case '3': /* read watchpoint */
3385 case '4': /* access watchpoint */
3386 require_running (own_buf
);
3387 if (insert
&& the_target
->insert_point
!= NULL
)
3389 /* Insert the breakpoint. If it is already inserted, nothing
3391 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3393 /* GDB may have sent us a list of *point parameters to be
3394 evaluated on the target's side. Read such list here. If we
3395 already have a list of parameters, GDB is telling us to drop
3396 that list and use this one instead. */
3397 if (!res
&& (type
== '0' || type
== '1'))
3399 /* Remove previous conditions. */
3400 clear_gdb_breakpoint_conditions (addr
);
3401 process_point_options (addr
, &dataptr
);
3404 else if (!insert
&& the_target
->remove_point
!= NULL
)
3405 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3417 write_enn (own_buf
);
3421 response_needed
= 0;
3422 if (!target_running ())
3423 /* The packet we received doesn't make sense - but we can't
3424 reply to it, either. */
3427 fprintf (stderr
, "Killing all inferiors\n");
3428 for_each_inferior (&all_processes
, kill_inferior_callback
);
3430 /* When using the extended protocol, we wait with no program
3431 running. The traditional protocol will exit instead. */
3432 if (extended_protocol
)
3434 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3435 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3443 ptid_t gdb_id
, thread_id
;
3445 require_running (own_buf
);
3447 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3448 thread_id
= gdb_id_to_thread_id (gdb_id
);
3449 if (ptid_equal (thread_id
, null_ptid
))
3451 write_enn (own_buf
);
3455 if (mythread_alive (thread_id
))
3458 write_enn (own_buf
);
3462 response_needed
= 0;
3464 /* Restarting the inferior is only supported in the extended
3466 if (extended_protocol
)
3468 if (target_running ())
3469 for_each_inferior (&all_processes
,
3470 kill_inferior_callback
);
3471 fprintf (stderr
, "GDBserver restarting\n");
3473 /* Wait till we are at 1st instruction in prog. */
3474 if (program_argv
!= NULL
)
3475 start_inferior (program_argv
);
3478 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3479 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3485 /* It is a request we don't understand. Respond with an
3486 empty packet so that gdb knows that we don't support this
3492 /* Extended (long) request. */
3493 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3497 /* It is a request we don't understand. Respond with an empty
3498 packet so that gdb knows that we don't support this
3504 if (new_packet_len
!= -1)
3505 putpkt_binary (own_buf
, new_packet_len
);
3509 response_needed
= 0;
3511 if (!extended_protocol
&& have_ran
&& !target_running ())
3513 /* In non-stop, defer exiting until GDB had a chance to query
3514 the whole vStopped list (until it gets an OK). */
3515 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3517 fprintf (stderr
, "GDBserver exiting\n");
3529 /* Event-loop callback for serial events. */
3532 handle_serial_event (int err
, gdb_client_data client_data
)
3535 fprintf (stderr
, "handling possible serial event\n");
3537 /* Really handle it. */
3538 if (process_serial_event () < 0)
3541 /* Be sure to not change the selected inferior behind GDB's back.
3542 Important in the non-stop mode asynchronous protocol. */
3543 set_desired_inferior (1);
3548 /* Event-loop callback for target events. */
3551 handle_target_event (int err
, gdb_client_data client_data
)
3554 fprintf (stderr
, "handling possible target event\n");
3556 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3559 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3561 int pid
= ptid_get_pid (last_ptid
);
3562 struct process_info
*process
= find_process_pid (pid
);
3563 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3565 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3566 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3568 mark_breakpoints_out (process
);
3569 mourn_inferior (process
);
3573 /* We're reporting this thread as stopped. Update its
3574 "want-stopped" state to what the client wants, until it
3575 gets a new resume action. */
3576 current_inferior
->last_resume_kind
= resume_stop
;
3577 current_inferior
->last_status
= last_status
;
3582 if (!target_running ())
3584 /* The last process exited. We're done. */
3588 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3590 /* A thread stopped with a signal, but gdb isn't
3591 connected to handle it. Pass it down to the
3592 inferior, as if it wasn't being traced. */
3593 struct thread_resume resume_info
;
3597 "GDB not connected; forwarding event %d for [%s]\n",
3598 (int) last_status
.kind
,
3599 target_pid_to_str (last_ptid
));
3601 resume_info
.thread
= last_ptid
;
3602 resume_info
.kind
= resume_continue
;
3603 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3604 (*the_target
->resume
) (&resume_info
, 1);
3606 else if (debug_threads
)
3607 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3608 (int) last_status
.kind
,
3609 target_pid_to_str (last_ptid
));
3613 struct vstop_notif
*vstop_notif
3614 = xmalloc (sizeof (struct vstop_notif
));
3616 vstop_notif
->status
= last_status
;
3617 vstop_notif
->ptid
= last_ptid
;
3618 /* Push Stop notification. */
3619 notif_push (¬if_stop
,
3620 (struct notif_event
*) vstop_notif
);
3624 /* Be sure to not change the selected inferior behind GDB's back.
3625 Important in the non-stop mode asynchronous protocol. */
3626 set_desired_inferior (1);