1 /* Main code for remote server for GDB.
2 Copyright (C) 1989, 1993-1995, 1997-2000, 2002-2012 Free Software
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdbthread.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 all of the extended 'Q' packets. */
403 handle_general_set (char *own_buf
)
405 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
407 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
408 const char *p
= own_buf
+ strlen ("QPassSignals:");
411 p
= decode_address_to_semicolon (&cursig
, p
);
412 for (i
= 0; i
< numsigs
; i
++)
418 /* Keep looping, to clear the remaining signals. */
421 p
= decode_address_to_semicolon (&cursig
, p
);
426 strcpy (own_buf
, "OK");
430 if (strncmp ("QProgramSignals:", own_buf
, strlen ("QProgramSignals:")) == 0)
432 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
433 const char *p
= own_buf
+ strlen ("QProgramSignals:");
436 program_signals_p
= 1;
438 p
= decode_address_to_semicolon (&cursig
, p
);
439 for (i
= 0; i
< numsigs
; i
++)
443 program_signals
[i
] = 1;
445 /* Keep looping, to clear the remaining signals. */
448 p
= decode_address_to_semicolon (&cursig
, p
);
451 program_signals
[i
] = 0;
453 strcpy (own_buf
, "OK");
457 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
461 fprintf (stderr
, "[noack mode enabled]\n");
470 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
472 char *mode
= own_buf
+ 9;
476 if (strcmp (mode
, "0") == 0)
478 else if (strcmp (mode
, "1") == 0)
482 /* We don't know what this mode is, so complain to
484 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
490 req_str
= req
? "non-stop" : "all-stop";
491 if (start_non_stop (req
) != 0)
493 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
501 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
507 if (strncmp ("QDisableRandomization:", own_buf
,
508 strlen ("QDisableRandomization:")) == 0)
510 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
513 unpack_varlen_hex (packet
, &setting
);
514 disable_randomization
= setting
;
518 if (disable_randomization
)
519 fprintf (stderr
, "[address space randomization disabled]\n");
521 fprintf (stderr
, "[address space randomization enabled]\n");
528 if (target_supports_tracepoints ()
529 && handle_tracepoint_general_set (own_buf
))
532 if (strncmp ("QAgent:", own_buf
, strlen ("QAgent:")) == 0)
534 char *mode
= own_buf
+ strlen ("QAgent:");
537 if (strcmp (mode
, "0") == 0)
539 else if (strcmp (mode
, "1") == 0)
543 /* We don't know what this value is, so complain to GDB. */
544 sprintf (own_buf
, "E.Unknown QAgent value");
548 /* Update the flag. */
551 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
556 /* Otherwise we didn't know what packet it was. Say we didn't
562 get_features_xml (const char *annex
)
564 /* gdbserver_xmltarget defines what to return when looking
565 for the "target.xml" file. Its contents can either be
566 verbatim XML code (prefixed with a '@') or else the name
567 of the actual XML file to be used in place of "target.xml".
569 This variable is set up from the auto-generated
570 init_registers_... routine for the current target. */
572 if (gdbserver_xmltarget
573 && strcmp (annex
, "target.xml") == 0)
575 if (*gdbserver_xmltarget
== '@')
576 return gdbserver_xmltarget
+ 1;
578 annex
= gdbserver_xmltarget
;
583 extern const char *const xml_builtin
[][2];
586 /* Look for the annex. */
587 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
588 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
591 if (xml_builtin
[i
][0] != NULL
)
592 return xml_builtin
[i
][1];
600 monitor_show_help (void)
602 monitor_output ("The following monitor commands are supported:\n");
603 monitor_output (" set debug <0|1>\n");
604 monitor_output (" Enable general debugging messages\n");
605 monitor_output (" set debug-hw-points <0|1>\n");
606 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
607 monitor_output (" set remote-debug <0|1>\n");
608 monitor_output (" Enable remote protocol debugging messages\n");
609 monitor_output (" exit\n");
610 monitor_output (" Quit GDBserver\n");
613 /* Read trace frame or inferior memory. Returns the number of bytes
614 actually read, zero when no further transfer is possible, and -1 on
615 error. Return of a positive value smaller than LEN does not
616 indicate there's no more to be read, only the end of the transfer.
617 E.g., when GDB reads memory from a traceframe, a first request may
618 be served from a memory block that does not cover the whole request
619 length. A following request gets the rest served from either
620 another block (of the same traceframe) or from the read-only
624 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
628 if (current_traceframe
>= 0)
631 ULONGEST length
= len
;
633 if (traceframe_read_mem (current_traceframe
,
634 memaddr
, myaddr
, len
, &nbytes
))
636 /* Data read from trace buffer, we're done. */
639 if (!in_readonly_region (memaddr
, length
))
641 /* Otherwise we have a valid readonly case, fall through. */
642 /* (assume no half-trace half-real blocks for now) */
645 res
= prepare_to_access_memory ();
648 res
= read_inferior_memory (memaddr
, myaddr
, len
);
649 done_accessing_memory ();
651 return res
== 0 ? len
: -1;
657 /* Write trace frame or inferior memory. Actually, writing to trace
658 frames is forbidden. */
661 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
663 if (current_traceframe
>= 0)
669 ret
= prepare_to_access_memory ();
672 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
673 done_accessing_memory ();
679 /* Subroutine of handle_search_memory to simplify it. */
682 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
683 gdb_byte
*pattern
, unsigned pattern_len
,
684 gdb_byte
*search_buf
,
685 unsigned chunk_size
, unsigned search_buf_size
,
686 CORE_ADDR
*found_addrp
)
688 /* Prime the search buffer. */
690 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
693 warning ("Unable to access %ld bytes of target "
694 "memory at 0x%lx, halting search.",
695 (long) search_buf_size
, (long) start_addr
);
699 /* Perform the search.
701 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
702 When we've scanned N bytes we copy the trailing bytes to the start and
703 read in another N bytes. */
705 while (search_space_len
>= pattern_len
)
708 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
712 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
714 if (found_ptr
!= NULL
)
716 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
717 *found_addrp
= found_addr
;
721 /* Not found in this chunk, skip to next chunk. */
723 /* Don't let search_space_len wrap here, it's unsigned. */
724 if (search_space_len
>= chunk_size
)
725 search_space_len
-= chunk_size
;
727 search_space_len
= 0;
729 if (search_space_len
>= pattern_len
)
731 unsigned keep_len
= search_buf_size
- chunk_size
;
732 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
735 /* Copy the trailing part of the previous iteration to the front
736 of the buffer for the next iteration. */
737 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
739 nr_to_read
= (search_space_len
- keep_len
< chunk_size
740 ? search_space_len
- keep_len
743 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
744 nr_to_read
) != search_buf_size
)
746 warning ("Unable to access %ld bytes of target memory "
747 "at 0x%lx, halting search.",
748 (long) nr_to_read
, (long) read_addr
);
752 start_addr
+= chunk_size
;
761 /* Handle qSearch:memory packets. */
764 handle_search_memory (char *own_buf
, int packet_len
)
766 CORE_ADDR start_addr
;
767 CORE_ADDR search_space_len
;
769 unsigned int pattern_len
;
770 /* NOTE: also defined in find.c testcase. */
771 #define SEARCH_CHUNK_SIZE 16000
772 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
773 /* Buffer to hold memory contents for searching. */
774 gdb_byte
*search_buf
;
775 unsigned search_buf_size
;
777 CORE_ADDR found_addr
;
778 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
780 pattern
= malloc (packet_len
);
783 error ("Unable to allocate memory to perform the search");
784 strcpy (own_buf
, "E00");
787 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
788 packet_len
- cmd_name_len
,
789 &start_addr
, &search_space_len
,
790 pattern
, &pattern_len
) < 0)
793 error ("Error in parsing qSearch:memory packet");
794 strcpy (own_buf
, "E00");
798 search_buf_size
= chunk_size
+ pattern_len
- 1;
800 /* No point in trying to allocate a buffer larger than the search space. */
801 if (search_space_len
< search_buf_size
)
802 search_buf_size
= search_space_len
;
804 search_buf
= malloc (search_buf_size
);
805 if (search_buf
== NULL
)
808 error ("Unable to allocate memory to perform the search");
809 strcpy (own_buf
, "E00");
813 found
= handle_search_memory_1 (start_addr
, search_space_len
,
814 pattern
, pattern_len
,
815 search_buf
, chunk_size
, search_buf_size
,
819 sprintf (own_buf
, "1,%lx", (long) found_addr
);
821 strcpy (own_buf
, "0");
823 strcpy (own_buf
, "E00");
829 #define require_running(BUF) \
830 if (!target_running ()) \
836 /* Handle monitor commands not handled by target-specific handlers. */
839 handle_monitor_command (char *mon
, char *own_buf
)
841 if (strcmp (mon
, "set debug 1") == 0)
844 monitor_output ("Debug output enabled.\n");
846 else if (strcmp (mon
, "set debug 0") == 0)
849 monitor_output ("Debug output disabled.\n");
851 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
854 monitor_output ("H/W point debugging output enabled.\n");
856 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
859 monitor_output ("H/W point debugging output disabled.\n");
861 else if (strcmp (mon
, "set remote-debug 1") == 0)
864 monitor_output ("Protocol debug output enabled.\n");
866 else if (strcmp (mon
, "set remote-debug 0") == 0)
869 monitor_output ("Protocol debug output disabled.\n");
871 else if (strcmp (mon
, "help") == 0)
872 monitor_show_help ();
873 else if (strcmp (mon
, "exit") == 0)
877 monitor_output ("Unknown monitor command.\n\n");
878 monitor_show_help ();
883 /* Associates a callback with each supported qXfer'able object. */
887 /* The object this handler handles. */
890 /* Request that the target transfer up to LEN 8-bit bytes of the
891 target's OBJECT. The OFFSET, for a seekable object, specifies
892 the starting point. The ANNEX can be used to provide additional
893 data-specific information to the target.
895 Return the number of bytes actually transfered, zero when no
896 further transfer is possible, -1 on error, and -2 when the
897 transfer is not supported. Return of a positive value smaller
898 than LEN does not indicate the end of the object, only the end of
901 One, and only one, of readbuf or writebuf must be non-NULL. */
902 int (*xfer
) (const char *annex
,
903 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
904 ULONGEST offset
, LONGEST len
);
907 /* Handle qXfer:auxv:read. */
910 handle_qxfer_auxv (const char *annex
,
911 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
912 ULONGEST offset
, LONGEST len
)
914 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
917 if (annex
[0] != '\0' || !target_running ())
920 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
923 /* Handle qXfer:features:read. */
926 handle_qxfer_features (const char *annex
,
927 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
928 ULONGEST offset
, LONGEST len
)
930 const char *document
;
933 if (writebuf
!= NULL
)
936 if (!target_running ())
939 /* Grab the correct annex. */
940 document
= get_features_xml (annex
);
941 if (document
== NULL
)
944 total_len
= strlen (document
);
946 if (offset
> total_len
)
949 if (offset
+ len
> total_len
)
950 len
= total_len
- offset
;
952 memcpy (readbuf
, document
+ offset
, len
);
956 /* Handle qXfer:libraries:read. */
959 handle_qxfer_libraries (const char *annex
,
960 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
961 ULONGEST offset
, LONGEST len
)
963 unsigned int total_len
;
965 struct inferior_list_entry
*dll_ptr
;
967 if (writebuf
!= NULL
)
970 if (annex
[0] != '\0' || !target_running ())
973 /* Over-estimate the necessary memory. Assume that every character
974 in the library name must be escaped. */
976 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
977 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
979 document
= malloc (total_len
);
980 if (document
== NULL
)
983 strcpy (document
, "<library-list>\n");
984 p
= document
+ strlen (document
);
986 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
988 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
991 strcpy (p
, " <library name=\"");
993 name
= xml_escape_text (dll
->name
);
997 strcpy (p
, "\"><segment address=\"");
999 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1001 strcpy (p
, "\"/></library>\n");
1005 strcpy (p
, "</library-list>\n");
1007 total_len
= strlen (document
);
1009 if (offset
> total_len
)
1015 if (offset
+ len
> total_len
)
1016 len
= total_len
- offset
;
1018 memcpy (readbuf
, document
+ offset
, len
);
1023 /* Handle qXfer:libraries-svr4:read. */
1026 handle_qxfer_libraries_svr4 (const char *annex
,
1027 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1028 ULONGEST offset
, LONGEST len
)
1030 if (writebuf
!= NULL
)
1033 if (annex
[0] != '\0' || !target_running ()
1034 || the_target
->qxfer_libraries_svr4
== NULL
)
1037 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1040 /* Handle qXfer:osadata:read. */
1043 handle_qxfer_osdata (const char *annex
,
1044 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1045 ULONGEST offset
, LONGEST len
)
1047 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1050 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1053 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1056 handle_qxfer_siginfo (const char *annex
,
1057 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1058 ULONGEST offset
, LONGEST len
)
1060 if (the_target
->qxfer_siginfo
== NULL
)
1063 if (annex
[0] != '\0' || !target_running ())
1066 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1069 /* Handle qXfer:spu:read and qXfer:spu:write. */
1072 handle_qxfer_spu (const char *annex
,
1073 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1074 ULONGEST offset
, LONGEST len
)
1076 if (the_target
->qxfer_spu
== NULL
)
1079 if (!target_running ())
1082 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1085 /* Handle qXfer:statictrace:read. */
1088 handle_qxfer_statictrace (const char *annex
,
1089 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1090 ULONGEST offset
, LONGEST len
)
1094 if (writebuf
!= NULL
)
1097 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1100 if (traceframe_read_sdata (current_traceframe
, offset
,
1101 readbuf
, len
, &nbytes
))
1106 /* Helper for handle_qxfer_threads. */
1109 handle_qxfer_threads_proper (struct buffer
*buffer
)
1111 struct inferior_list_entry
*thread
;
1113 buffer_grow_str (buffer
, "<threads>\n");
1115 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
1117 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
1119 int core
= target_core_of_thread (ptid
);
1122 write_ptid (ptid_s
, ptid
);
1126 sprintf (core_s
, "%d", core
);
1127 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1132 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1137 buffer_grow_str0 (buffer
, "</threads>\n");
1140 /* Handle qXfer:threads:read. */
1143 handle_qxfer_threads (const char *annex
,
1144 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1145 ULONGEST offset
, LONGEST len
)
1147 static char *result
= 0;
1148 static unsigned int result_length
= 0;
1150 if (writebuf
!= NULL
)
1153 if (!target_running () || annex
[0] != '\0')
1158 struct buffer buffer
;
1159 /* When asked for data at offset 0, generate everything and store into
1160 'result'. Successive reads will be served off 'result'. */
1164 buffer_init (&buffer
);
1166 handle_qxfer_threads_proper (&buffer
);
1168 result
= buffer_finish (&buffer
);
1169 result_length
= strlen (result
);
1170 buffer_free (&buffer
);
1173 if (offset
>= result_length
)
1175 /* We're out of data. */
1182 if (len
> result_length
- offset
)
1183 len
= result_length
- offset
;
1185 memcpy (readbuf
, result
+ offset
, len
);
1190 /* Handle qXfer:traceframe-info:read. */
1193 handle_qxfer_traceframe_info (const char *annex
,
1194 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1195 ULONGEST offset
, LONGEST len
)
1197 static char *result
= 0;
1198 static unsigned int result_length
= 0;
1200 if (writebuf
!= NULL
)
1203 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1208 struct buffer buffer
;
1210 /* When asked for data at offset 0, generate everything and
1211 store into 'result'. Successive reads will be served off
1215 buffer_init (&buffer
);
1217 traceframe_read_info (current_traceframe
, &buffer
);
1219 result
= buffer_finish (&buffer
);
1220 result_length
= strlen (result
);
1221 buffer_free (&buffer
);
1224 if (offset
>= result_length
)
1226 /* We're out of data. */
1233 if (len
> result_length
- offset
)
1234 len
= result_length
- offset
;
1236 memcpy (readbuf
, result
+ offset
, len
);
1240 /* Handle qXfer:fdpic:read. */
1243 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1244 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1246 if (the_target
->read_loadmap
== NULL
)
1249 if (!target_running ())
1252 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1255 static const struct qxfer qxfer_packets
[] =
1257 { "auxv", handle_qxfer_auxv
},
1258 { "fdpic", handle_qxfer_fdpic
},
1259 { "features", handle_qxfer_features
},
1260 { "libraries", handle_qxfer_libraries
},
1261 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1262 { "osdata", handle_qxfer_osdata
},
1263 { "siginfo", handle_qxfer_siginfo
},
1264 { "spu", handle_qxfer_spu
},
1265 { "statictrace", handle_qxfer_statictrace
},
1266 { "threads", handle_qxfer_threads
},
1267 { "traceframe-info", handle_qxfer_traceframe_info
},
1271 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1279 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1282 /* Grab the object, r/w and annex. */
1283 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1285 write_enn (own_buf
);
1290 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1293 const struct qxfer
*q
= &qxfer_packets
[i
];
1295 if (strcmp (object
, q
->object
) == 0)
1297 if (strcmp (rw
, "read") == 0)
1299 unsigned char *data
;
1304 /* Grab the offset and length. */
1305 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1307 write_enn (own_buf
);
1311 /* Read one extra byte, as an indicator of whether there is
1313 if (len
> PBUFSIZ
- 2)
1315 data
= malloc (len
+ 1);
1318 write_enn (own_buf
);
1321 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1328 write_enn (own_buf
);
1330 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1332 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1337 else if (strcmp (rw
, "write") == 0)
1342 unsigned char *data
;
1344 strcpy (own_buf
, "E00");
1345 data
= malloc (packet_len
- (offset
- own_buf
));
1348 write_enn (own_buf
);
1351 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1352 &ofs
, &len
, data
) < 0)
1355 write_enn (own_buf
);
1359 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1366 write_enn (own_buf
);
1368 sprintf (own_buf
, "%x", n
);
1381 /* Table used by the crc32 function to calcuate the checksum. */
1383 static unsigned int crc32_table
[256] =
1386 /* Compute 32 bit CRC from inferior memory.
1388 On success, return 32 bit CRC.
1389 On failure, return (unsigned long long) -1. */
1391 static unsigned long long
1392 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1394 if (!crc32_table
[1])
1396 /* Initialize the CRC table and the decoding table. */
1400 for (i
= 0; i
< 256; i
++)
1402 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1403 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1410 unsigned char byte
= 0;
1412 /* Return failure if memory read fails. */
1413 if (read_inferior_memory (base
, &byte
, 1) != 0)
1414 return (unsigned long long) -1;
1416 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1419 return (unsigned long long) crc
;
1422 /* Handle all of the extended 'q' packets. */
1425 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1427 static struct inferior_list_entry
*thread_ptr
;
1429 /* Reply the current thread id. */
1430 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1433 require_running (own_buf
);
1435 if (!ptid_equal (general_thread
, null_ptid
)
1436 && !ptid_equal (general_thread
, minus_one_ptid
))
1437 gdb_id
= general_thread
;
1440 thread_ptr
= all_threads
.head
;
1441 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1444 sprintf (own_buf
, "QC");
1446 write_ptid (own_buf
, gdb_id
);
1450 if (strcmp ("qSymbol::", own_buf
) == 0)
1452 /* GDB is suggesting new symbols have been loaded. This may
1453 mean a new shared library has been detected as loaded, so
1454 take the opportunity to check if breakpoints we think are
1455 inserted, still are. Note that it isn't guaranteed that
1456 we'll see this when a shared library is loaded, and nor will
1457 we see this for unloads (although breakpoints in unloaded
1458 libraries shouldn't trigger), as GDB may not find symbols for
1459 the library at all. We also re-validate breakpoints when we
1460 see a second GDB breakpoint for the same address, and or when
1461 we access breakpoint shadows. */
1462 validate_breakpoints ();
1464 if (target_supports_tracepoints ())
1465 tracepoint_look_up_symbols ();
1467 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1468 (*the_target
->look_up_symbols
) ();
1470 strcpy (own_buf
, "OK");
1474 if (!disable_packet_qfThreadInfo
)
1476 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1480 require_running (own_buf
);
1481 thread_ptr
= all_threads
.head
;
1484 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1485 write_ptid (own_buf
, gdb_id
);
1486 thread_ptr
= thread_ptr
->next
;
1490 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1494 require_running (own_buf
);
1495 if (thread_ptr
!= NULL
)
1498 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1499 write_ptid (own_buf
, gdb_id
);
1500 thread_ptr
= thread_ptr
->next
;
1505 sprintf (own_buf
, "l");
1511 if (the_target
->read_offsets
!= NULL
1512 && strcmp ("qOffsets", own_buf
) == 0)
1514 CORE_ADDR text
, data
;
1516 require_running (own_buf
);
1517 if (the_target
->read_offsets (&text
, &data
))
1518 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1519 (long)text
, (long)data
, (long)data
);
1521 write_enn (own_buf
);
1526 /* Protocol features query. */
1527 if (strncmp ("qSupported", own_buf
, 10) == 0
1528 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1530 char *p
= &own_buf
[10];
1531 int gdb_supports_qRelocInsn
= 0;
1533 /* Start processing qSupported packet. */
1534 target_process_qsupported (NULL
);
1536 /* Process each feature being provided by GDB. The first
1537 feature will follow a ':', and latter features will follow
1541 char **qsupported
= NULL
;
1545 /* Two passes, to avoid nested strtok calls in
1546 target_process_qsupported. */
1547 for (p
= strtok (p
+ 1, ";");
1549 p
= strtok (NULL
, ";"))
1552 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1553 qsupported
[count
- 1] = xstrdup (p
);
1556 for (i
= 0; i
< count
; i
++)
1559 if (strcmp (p
, "multiprocess+") == 0)
1561 /* GDB supports and wants multi-process support if
1563 if (target_supports_multi_process ())
1566 else if (strcmp (p
, "qRelocInsn+") == 0)
1568 /* GDB supports relocate instruction requests. */
1569 gdb_supports_qRelocInsn
= 1;
1572 target_process_qsupported (p
);
1581 "PacketSize=%x;QPassSignals+;QProgramSignals+",
1584 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1585 strcat (own_buf
, ";qXfer:libraries-svr4:read+");
1588 /* We do not have any hook to indicate whether the non-SVR4 target
1589 backend supports qXfer:libraries:read, so always report it. */
1590 strcat (own_buf
, ";qXfer:libraries:read+");
1593 if (the_target
->read_auxv
!= NULL
)
1594 strcat (own_buf
, ";qXfer:auxv:read+");
1596 if (the_target
->qxfer_spu
!= NULL
)
1597 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1599 if (the_target
->qxfer_siginfo
!= NULL
)
1600 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1602 if (the_target
->read_loadmap
!= NULL
)
1603 strcat (own_buf
, ";qXfer:fdpic:read+");
1605 /* We always report qXfer:features:read, as targets may
1606 install XML files on a subsequent call to arch_setup.
1607 If we reported to GDB on startup that we don't support
1608 qXfer:feature:read at all, we will never be re-queried. */
1609 strcat (own_buf
, ";qXfer:features:read+");
1611 if (transport_is_reliable
)
1612 strcat (own_buf
, ";QStartNoAckMode+");
1614 if (the_target
->qxfer_osdata
!= NULL
)
1615 strcat (own_buf
, ";qXfer:osdata:read+");
1617 if (target_supports_multi_process ())
1618 strcat (own_buf
, ";multiprocess+");
1620 if (target_supports_non_stop ())
1621 strcat (own_buf
, ";QNonStop+");
1623 if (target_supports_disable_randomization ())
1624 strcat (own_buf
, ";QDisableRandomization+");
1626 strcat (own_buf
, ";qXfer:threads:read+");
1628 if (target_supports_tracepoints ())
1630 strcat (own_buf
, ";ConditionalTracepoints+");
1631 strcat (own_buf
, ";TraceStateVariables+");
1632 strcat (own_buf
, ";TracepointSource+");
1633 strcat (own_buf
, ";DisconnectedTracing+");
1634 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1635 strcat (own_buf
, ";FastTracepoints+");
1636 strcat (own_buf
, ";StaticTracepoints+");
1637 strcat (own_buf
, ";InstallInTrace+");
1638 strcat (own_buf
, ";qXfer:statictrace:read+");
1639 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1640 strcat (own_buf
, ";EnableDisableTracepoints+");
1641 strcat (own_buf
, ";tracenz+");
1644 /* Support target-side breakpoint conditions and commands. */
1645 strcat (own_buf
, ";ConditionalBreakpoints+");
1646 strcat (own_buf
, ";BreakpointCommands+");
1648 if (target_supports_agent ())
1649 strcat (own_buf
, ";QAgent+");
1654 /* Thread-local storage support. */
1655 if (the_target
->get_tls_address
!= NULL
1656 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1658 char *p
= own_buf
+ 12;
1659 CORE_ADDR parts
[2], address
= 0;
1661 ptid_t ptid
= null_ptid
;
1663 require_running (own_buf
);
1665 for (i
= 0; i
< 3; i
++)
1673 p2
= strchr (p
, ',');
1686 ptid
= read_ptid (p
, NULL
);
1688 decode_address (&parts
[i
- 1], p
, len
);
1692 if (p
!= NULL
|| i
< 3)
1696 struct thread_info
*thread
= find_thread_ptid (ptid
);
1701 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1707 strcpy (own_buf
, paddress(address
));
1712 write_enn (own_buf
);
1716 /* Otherwise, pretend we do not understand this packet. */
1719 /* Windows OS Thread Information Block address support. */
1720 if (the_target
->get_tib_address
!= NULL
1721 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1726 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1728 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1731 strcpy (own_buf
, paddress(tlb
));
1736 write_enn (own_buf
);
1742 /* Handle "monitor" commands. */
1743 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1745 char *mon
= malloc (PBUFSIZ
);
1746 int len
= strlen (own_buf
+ 6);
1750 write_enn (own_buf
);
1754 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1756 write_enn (own_buf
);
1760 mon
[len
/ 2] = '\0';
1764 if (the_target
->handle_monitor_command
== NULL
1765 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1766 /* Default processing. */
1767 handle_monitor_command (mon
, own_buf
);
1773 if (strncmp ("qSearch:memory:", own_buf
,
1774 sizeof ("qSearch:memory:") - 1) == 0)
1776 require_running (own_buf
);
1777 handle_search_memory (own_buf
, packet_len
);
1781 if (strcmp (own_buf
, "qAttached") == 0
1782 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1784 struct process_info
*process
;
1786 if (own_buf
[sizeof ("qAttached") - 1])
1788 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1789 process
= (struct process_info
*)
1790 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1794 require_running (own_buf
);
1795 process
= current_process ();
1798 if (process
== NULL
)
1800 write_enn (own_buf
);
1804 strcpy (own_buf
, process
->attached
? "1" : "0");
1808 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1810 /* CRC check (compare-section). */
1814 unsigned long long crc
;
1816 require_running (own_buf
);
1817 base
= strtoul (own_buf
+ 5, &comma
, 16);
1818 if (*comma
++ != ',')
1820 write_enn (own_buf
);
1823 len
= strtoul (comma
, NULL
, 16);
1824 crc
= crc32 (base
, len
, 0xffffffff);
1825 /* Check for memory failure. */
1826 if (crc
== (unsigned long long) -1)
1828 write_enn (own_buf
);
1831 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
1835 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
1838 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
1841 /* Otherwise we didn't know what packet it was. Say we didn't
1846 static void gdb_wants_all_threads_stopped (void);
1848 /* Parse vCont packets. */
1850 handle_v_cont (char *own_buf
)
1854 struct thread_resume
*resume_info
;
1855 struct thread_resume default_action
= {{0}};
1857 /* Count the number of semicolons in the packet. There should be one
1858 for every action. */
1864 p
= strchr (p
, ';');
1867 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1868 if (resume_info
== NULL
)
1876 if (p
[0] == 's' || p
[0] == 'S')
1877 resume_info
[i
].kind
= resume_step
;
1878 else if (p
[0] == 'c' || p
[0] == 'C')
1879 resume_info
[i
].kind
= resume_continue
;
1880 else if (p
[0] == 't')
1881 resume_info
[i
].kind
= resume_stop
;
1885 if (p
[0] == 'S' || p
[0] == 'C')
1888 sig
= strtol (p
+ 1, &q
, 16);
1893 if (!gdb_signal_to_host_p (sig
))
1895 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
1899 resume_info
[i
].sig
= 0;
1905 resume_info
[i
].thread
= minus_one_ptid
;
1906 default_action
= resume_info
[i
];
1908 /* Note: we don't increment i here, we'll overwrite this entry
1909 the next time through. */
1911 else if (p
[0] == ':')
1913 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1918 if (p
[0] != ';' && p
[0] != 0)
1921 resume_info
[i
].thread
= ptid
;
1928 resume_info
[i
] = default_action
;
1930 /* `cont_thread' is still used in occasional places in the backend,
1931 to implement single-thread scheduler-locking. Doesn't make sense
1932 to set it if we see a stop request, or a wildcard action (one
1933 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
1935 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1936 || ptid_get_lwp (resume_info
[0].thread
) == -1)
1937 && resume_info
[0].kind
!= resume_stop
)
1938 cont_thread
= resume_info
[0].thread
;
1940 cont_thread
= minus_one_ptid
;
1941 set_desired_inferior (0);
1946 (*the_target
->resume
) (resume_info
, n
);
1954 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1956 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
1957 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
1958 current_inferior
->last_status
= last_status
;
1960 /* From the client's perspective, all-stop mode always stops all
1961 threads implicitly (and the target backend has already done
1962 so by now). Tag all threads as "want-stopped", so we don't
1963 resume them implicitly without the client telling us to. */
1964 gdb_wants_all_threads_stopped ();
1965 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1966 disable_async_io ();
1968 if (last_status
.kind
== TARGET_WAITKIND_EXITED
1969 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
1970 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
1975 write_enn (own_buf
);
1980 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1982 handle_v_attach (char *own_buf
)
1986 pid
= strtol (own_buf
+ 8, NULL
, 16);
1987 if (pid
!= 0 && attach_inferior (pid
) == 0)
1989 /* Don't report shared library events after attaching, even if
1990 some libraries are preloaded. GDB will always poll the
1991 library list. Avoids the "stopped by shared library event"
1992 notice on the GDB side. */
1997 /* In non-stop, we don't send a resume reply. Stop events
1998 will follow up using the normal notification
2003 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2009 write_enn (own_buf
);
2014 /* Run a new program. Return 1 if successful, 0 if failure. */
2016 handle_v_run (char *own_buf
)
2018 char *p
, *next_p
, **new_argv
;
2022 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2028 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2029 if (new_argv
== NULL
)
2031 write_enn (own_buf
);
2036 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2038 next_p
= strchr (p
, ';');
2040 next_p
= p
+ strlen (p
);
2042 if (i
== 0 && p
== next_p
)
2046 /* FIXME: Fail request if out of memory instead of dying. */
2047 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2048 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2049 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2058 if (new_argv
[0] == NULL
)
2060 /* GDB didn't specify a program to run. Use the program from the
2061 last run with the new argument list. */
2063 if (program_argv
== NULL
)
2065 write_enn (own_buf
);
2066 freeargv (new_argv
);
2070 new_argv
[0] = strdup (program_argv
[0]);
2071 if (new_argv
[0] == NULL
)
2073 write_enn (own_buf
);
2074 freeargv (new_argv
);
2079 /* Free the old argv and install the new one. */
2080 freeargv (program_argv
);
2081 program_argv
= new_argv
;
2083 start_inferior (program_argv
);
2084 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2086 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2088 /* In non-stop, sending a resume reply doesn't set the general
2089 thread, but GDB assumes a vRun sets it (this is so GDB can
2090 query which is the main thread of the new inferior. */
2092 general_thread
= last_ptid
;
2098 write_enn (own_buf
);
2103 /* Kill process. Return 1 if successful, 0 if failure. */
2105 handle_v_kill (char *own_buf
)
2108 char *p
= &own_buf
[6];
2110 pid
= strtol (p
, NULL
, 16);
2113 if (pid
!= 0 && kill_inferior (pid
) == 0)
2115 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2116 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2117 last_ptid
= pid_to_ptid (pid
);
2118 discard_queued_stop_replies (pid
);
2124 write_enn (own_buf
);
2129 /* Handle all of the extended 'v' packets. */
2131 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2133 if (!disable_packet_vCont
)
2135 if (strncmp (own_buf
, "vCont;", 6) == 0)
2137 require_running (own_buf
);
2138 handle_v_cont (own_buf
);
2142 if (strncmp (own_buf
, "vCont?", 6) == 0)
2144 strcpy (own_buf
, "vCont;c;C;s;S;t");
2149 if (strncmp (own_buf
, "vFile:", 6) == 0
2150 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2153 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2155 if ((!extended_protocol
|| !multi_process
) && target_running ())
2157 fprintf (stderr
, "Already debugging a process\n");
2158 write_enn (own_buf
);
2161 handle_v_attach (own_buf
);
2165 if (strncmp (own_buf
, "vRun;", 5) == 0)
2167 if ((!extended_protocol
|| !multi_process
) && target_running ())
2169 fprintf (stderr
, "Already debugging a process\n");
2170 write_enn (own_buf
);
2173 handle_v_run (own_buf
);
2177 if (strncmp (own_buf
, "vKill;", 6) == 0)
2179 if (!target_running ())
2181 fprintf (stderr
, "No process to kill\n");
2182 write_enn (own_buf
);
2185 handle_v_kill (own_buf
);
2189 if (handle_notif_ack (own_buf
, packet_len
))
2192 /* Otherwise we didn't know what packet it was. Say we didn't
2198 /* Resume inferior and wait for another event. In non-stop mode,
2199 don't really wait here, but return immediatelly to the event
2202 myresume (char *own_buf
, int step
, int sig
)
2204 struct thread_resume resume_info
[2];
2206 int valid_cont_thread
;
2208 set_desired_inferior (0);
2210 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2211 && !ptid_equal (cont_thread
, minus_one_ptid
));
2213 if (step
|| sig
|| valid_cont_thread
)
2215 resume_info
[0].thread
= current_ptid
;
2217 resume_info
[0].kind
= resume_step
;
2219 resume_info
[0].kind
= resume_continue
;
2220 resume_info
[0].sig
= sig
;
2224 if (!valid_cont_thread
)
2226 resume_info
[n
].thread
= minus_one_ptid
;
2227 resume_info
[n
].kind
= resume_continue
;
2228 resume_info
[n
].sig
= 0;
2235 (*the_target
->resume
) (resume_info
, n
);
2241 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2243 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2244 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2246 current_inferior
->last_resume_kind
= resume_stop
;
2247 current_inferior
->last_status
= last_status
;
2250 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2251 disable_async_io ();
2253 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2254 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2255 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2259 /* Callback for for_each_inferior. Make a new stop reply for each
2263 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2265 struct thread_info
*thread
= (struct thread_info
*) entry
;
2267 /* For now, assume targets that don't have this callback also don't
2268 manage the thread's last_status field. */
2269 if (the_target
->thread_stopped
== NULL
)
2271 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2273 new_notif
->ptid
= entry
->id
;
2274 new_notif
->status
= thread
->last_status
;
2275 /* Pass the last stop reply back to GDB, but don't notify
2277 notif_event_enque (¬if_stop
,
2278 (struct notif_event
*) new_notif
);
2282 if (thread_stopped (thread
))
2286 "Reporting thread %s as already stopped with %s\n",
2287 target_pid_to_str (entry
->id
),
2288 target_waitstatus_to_string (&thread
->last_status
));
2290 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2292 /* Pass the last stop reply back to GDB, but don't notify
2294 queue_stop_reply (entry
->id
, &thread
->last_status
);
2301 /* Set this inferior threads's state as "want-stopped". We won't
2302 resume this thread until the client gives us another action for
2306 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2308 struct thread_info
*thread
= (struct thread_info
*) entry
;
2310 thread
->last_resume_kind
= resume_stop
;
2312 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2314 /* Most threads are stopped implicitly (all-stop); tag that with
2316 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2317 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2321 /* Set all threads' states as "want-stopped". */
2324 gdb_wants_all_threads_stopped (void)
2326 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2329 /* Clear the gdb_detached flag of every process. */
2332 gdb_reattached_process (struct inferior_list_entry
*entry
)
2334 struct process_info
*process
= (struct process_info
*) entry
;
2336 process
->gdb_detached
= 0;
2339 /* Status handler for the '?' packet. */
2342 handle_status (char *own_buf
)
2344 /* GDB is connected, don't forward events to the target anymore. */
2345 for_each_inferior (&all_processes
, gdb_reattached_process
);
2347 /* In non-stop mode, we must send a stop reply for each stopped
2348 thread. In all-stop mode, just send one for the first stopped
2353 discard_queued_stop_replies (-1);
2354 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2356 /* The first is sent immediatly. OK is sent if there is no
2357 stopped thread, which is the same handling of the vStopped
2358 packet (by design). */
2359 notif_write_event (¬if_stop
, own_buf
);
2364 stabilize_threads ();
2365 gdb_wants_all_threads_stopped ();
2367 if (all_threads
.head
)
2369 struct target_waitstatus status
;
2371 status
.kind
= TARGET_WAITKIND_STOPPED
;
2372 status
.value
.sig
= GDB_SIGNAL_TRAP
;
2373 prepare_resume_reply (own_buf
,
2374 all_threads
.head
->id
, &status
);
2377 strcpy (own_buf
, "W00");
2382 gdbserver_version (void)
2384 printf ("GNU gdbserver %s%s\n"
2385 "Copyright (C) 2012 Free Software Foundation, Inc.\n"
2386 "gdbserver is free software, covered by the "
2387 "GNU General Public License.\n"
2388 "This gdbserver was configured as \"%s\"\n",
2389 PKGVERSION
, version
, host_name
);
2393 gdbserver_usage (FILE *stream
)
2395 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2396 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2397 "\tgdbserver [OPTIONS] --multi COMM\n"
2399 "COMM may either be a tty device (for serial debugging), or \n"
2400 "HOST:PORT to listen for a TCP connection.\n"
2403 " --debug Enable general debugging output.\n"
2404 " --remote-debug Enable remote protocol debugging output.\n"
2405 " --version Display version information and exit.\n"
2406 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2407 " --once Exit after the first connection has "
2409 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2410 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2414 gdbserver_show_disableable (FILE *stream
)
2416 fprintf (stream
, "Disableable packets:\n"
2417 " vCont \tAll vCont packets\n"
2418 " qC \tQuerying the current thread\n"
2419 " qfThreadInfo\tThread listing\n"
2420 " Tthread \tPassing the thread specifier in the "
2421 "T stop reply packet\n"
2422 " threads \tAll of the above\n");
2426 #undef require_running
2427 #define require_running(BUF) \
2428 if (!target_running ()) \
2435 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2437 int pid
= * (int *) args
;
2439 if (ptid_get_pid (entry
->id
) == pid
)
2446 kill_inferior_callback (struct inferior_list_entry
*entry
)
2448 struct process_info
*process
= (struct process_info
*) entry
;
2449 int pid
= ptid_get_pid (process
->head
.id
);
2451 kill_inferior (pid
);
2452 discard_queued_stop_replies (pid
);
2455 /* Callback for for_each_inferior to detach or kill the inferior,
2456 depending on whether we attached to it or not.
2457 We inform the user whether we're detaching or killing the process
2458 as this is only called when gdbserver is about to exit. */
2461 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2463 struct process_info
*process
= (struct process_info
*) entry
;
2464 int pid
= ptid_get_pid (process
->head
.id
);
2466 if (process
->attached
)
2467 detach_inferior (pid
);
2469 kill_inferior (pid
);
2471 discard_queued_stop_replies (pid
);
2474 /* for_each_inferior callback for detach_or_kill_for_exit to print
2475 the pids of started inferiors. */
2478 print_started_pid (struct inferior_list_entry
*entry
)
2480 struct process_info
*process
= (struct process_info
*) entry
;
2482 if (! process
->attached
)
2484 int pid
= ptid_get_pid (process
->head
.id
);
2485 fprintf (stderr
, " %d", pid
);
2489 /* for_each_inferior callback for detach_or_kill_for_exit to print
2490 the pids of attached inferiors. */
2493 print_attached_pid (struct inferior_list_entry
*entry
)
2495 struct process_info
*process
= (struct process_info
*) entry
;
2497 if (process
->attached
)
2499 int pid
= ptid_get_pid (process
->head
.id
);
2500 fprintf (stderr
, " %d", pid
);
2504 /* Call this when exiting gdbserver with possible inferiors that need
2505 to be killed or detached from. */
2508 detach_or_kill_for_exit (void)
2510 /* First print a list of the inferiors we will be killing/detaching.
2511 This is to assist the user, for example, in case the inferior unexpectedly
2512 dies after we exit: did we screw up or did the inferior exit on its own?
2513 Having this info will save some head-scratching. */
2515 if (have_started_inferiors_p ())
2517 fprintf (stderr
, "Killing process(es):");
2518 for_each_inferior (&all_processes
, print_started_pid
);
2519 fprintf (stderr
, "\n");
2521 if (have_attached_inferiors_p ())
2523 fprintf (stderr
, "Detaching process(es):");
2524 for_each_inferior (&all_processes
, print_attached_pid
);
2525 fprintf (stderr
, "\n");
2528 /* Now we can kill or detach the inferiors. */
2530 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2534 main (int argc
, char *argv
[])
2538 char *arg_end
, *port
;
2539 char **next_arg
= &argv
[1];
2540 volatile int multi_mode
= 0;
2541 volatile int attach
= 0;
2544 while (*next_arg
!= NULL
&& **next_arg
== '-')
2546 if (strcmp (*next_arg
, "--version") == 0)
2548 gdbserver_version ();
2551 else if (strcmp (*next_arg
, "--help") == 0)
2553 gdbserver_usage (stdout
);
2556 else if (strcmp (*next_arg
, "--attach") == 0)
2558 else if (strcmp (*next_arg
, "--multi") == 0)
2560 else if (strcmp (*next_arg
, "--wrapper") == 0)
2564 wrapper_argv
= next_arg
;
2565 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2568 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2570 gdbserver_usage (stderr
);
2574 /* Consume the "--". */
2577 else if (strcmp (*next_arg
, "--debug") == 0)
2579 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2581 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2583 gdbserver_show_disableable (stdout
);
2586 else if (strncmp (*next_arg
,
2587 "--disable-packet=",
2588 sizeof ("--disable-packet=") - 1) == 0)
2590 char *packets
, *tok
;
2592 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2593 for (tok
= strtok (packets
, ",");
2595 tok
= strtok (NULL
, ","))
2597 if (strcmp ("vCont", tok
) == 0)
2598 disable_packet_vCont
= 1;
2599 else if (strcmp ("Tthread", tok
) == 0)
2600 disable_packet_Tthread
= 1;
2601 else if (strcmp ("qC", tok
) == 0)
2602 disable_packet_qC
= 1;
2603 else if (strcmp ("qfThreadInfo", tok
) == 0)
2604 disable_packet_qfThreadInfo
= 1;
2605 else if (strcmp ("threads", tok
) == 0)
2607 disable_packet_vCont
= 1;
2608 disable_packet_Tthread
= 1;
2609 disable_packet_qC
= 1;
2610 disable_packet_qfThreadInfo
= 1;
2614 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2616 gdbserver_show_disableable (stderr
);
2621 else if (strcmp (*next_arg
, "-") == 0)
2623 /* "-" specifies a stdio connection and is a form of port
2625 *next_arg
= STDIO_CONNECTION_NAME
;
2628 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2629 disable_randomization
= 1;
2630 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2631 disable_randomization
= 0;
2632 else if (strcmp (*next_arg
, "--once") == 0)
2636 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2644 if (setjmp (toplevel
))
2646 fprintf (stderr
, "Exiting\n");
2652 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2654 gdbserver_usage (stderr
);
2658 /* We need to know whether the remote connection is stdio before
2659 starting the inferior. Inferiors created in this scenario have
2660 stdin,stdout redirected. So do this here before we call
2662 remote_prepare (port
);
2667 /* --attach used to come after PORT, so allow it there for
2669 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2676 && (*next_arg
== NULL
2677 || (*next_arg
)[0] == '\0'
2678 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2680 || next_arg
[1] != NULL
))
2685 gdbserver_usage (stderr
);
2689 initialize_async_io ();
2691 if (target_supports_tracepoints ())
2692 initialize_tracepoint ();
2694 own_buf
= xmalloc (PBUFSIZ
+ 1);
2695 mem_buf
= xmalloc (PBUFSIZ
);
2697 if (pid
== 0 && *next_arg
!= NULL
)
2701 n
= argc
- (next_arg
- argv
);
2702 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2703 for (i
= 0; i
< n
; i
++)
2704 program_argv
[i
] = xstrdup (next_arg
[i
]);
2705 program_argv
[i
] = NULL
;
2707 /* Wait till we are at first instruction in program. */
2708 start_inferior (program_argv
);
2710 /* We are now (hopefully) stopped at the first instruction of
2711 the target process. This assumes that the target process was
2712 successfully created. */
2716 if (attach_inferior (pid
) == -1)
2717 error ("Attaching not supported on this target");
2719 /* Otherwise succeeded. */
2723 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2724 last_status
.value
.integer
= 0;
2725 last_ptid
= minus_one_ptid
;
2728 initialize_notif ();
2730 /* Don't report shared library events on the initial connection,
2731 even if some libraries are preloaded. Avoids the "stopped by
2732 shared library event" notice on gdb side. */
2735 if (setjmp (toplevel
))
2737 /* If something fails and longjmps while detaching or killing
2738 inferiors, we'd end up here again, stuck in an infinite loop
2739 trap. Be sure that if that happens, we exit immediately
2741 if (setjmp (toplevel
) == 0)
2742 detach_or_kill_for_exit ();
2744 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2748 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2749 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2754 if (!was_running
&& !multi_mode
)
2756 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2764 /* Be sure we're out of tfind mode. */
2765 current_traceframe
= -1;
2769 if (setjmp (toplevel
) != 0)
2771 /* An error occurred. */
2772 if (response_needed
)
2774 write_enn (own_buf
);
2779 /* Wait for events. This will return when all event sources are
2780 removed from the event loop. */
2781 start_event_loop ();
2783 /* If an exit was requested (using the "monitor exit" command),
2784 terminate now. The only other way to get here is for
2785 getpkt to fail; close the connection and reopen it at the
2788 if (exit_requested
|| run_once
)
2790 /* If something fails and longjmps while detaching or
2791 killing inferiors, we'd end up here again, stuck in an
2792 infinite loop trap. Be sure that if that happens, we
2793 exit immediately instead. */
2794 if (setjmp (toplevel
) == 0)
2796 detach_or_kill_for_exit ();
2801 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2807 "Remote side has terminated connection. "
2808 "GDBserver will reopen the connection.\n");
2812 if (disconnected_tracing
)
2814 /* Try to enable non-stop/async mode, so we we can both
2815 wait for an async socket accept, and handle async
2816 target events simultaneously. There's also no point
2817 either in having the target always stop all threads,
2818 when we're going to pass signals down without
2822 if (start_non_stop (1))
2825 /* Detaching implicitly resumes all threads; simply
2826 disconnecting does not. */
2832 "Disconnected tracing disabled; stopping trace run.\n");
2839 /* Process options coming from Z packets for *point at address
2840 POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
2841 to point to the first char after the last processed option. */
2844 process_point_options (CORE_ADDR point_addr
, char **packet
)
2846 char *dataptr
= *packet
;
2849 /* Check if data has the correct format. */
2850 if (*dataptr
!= ';')
2857 if (*dataptr
== ';')
2860 if (*dataptr
== 'X')
2862 /* Conditional expression. */
2863 fprintf (stderr
, "Found breakpoint condition.\n");
2864 add_breakpoint_condition (point_addr
, &dataptr
);
2866 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
2868 dataptr
+= strlen ("cmds:");
2870 fprintf (stderr
, "Found breakpoint commands %s.\n", dataptr
);
2871 persist
= (*dataptr
== '1');
2873 add_breakpoint_commands (point_addr
, &dataptr
, persist
);
2877 fprintf (stderr
, "Unknown token %c, ignoring.\n",
2879 /* Skip tokens until we find one that we recognize. */
2880 while (*dataptr
&& *dataptr
!= ';')
2887 /* Event loop callback that handles a serial event. The first byte in
2888 the serial buffer gets us here. We expect characters to arrive at
2889 a brisk pace, so we read the rest of the packet with a blocking
2893 process_serial_event (void)
2904 int new_packet_len
= -1;
2906 /* Used to decide when gdbserver should exit in
2907 multi-mode/remote. */
2908 static int have_ran
= 0;
2911 have_ran
= target_running ();
2913 disable_async_io ();
2915 response_needed
= 0;
2916 packet_len
= getpkt (own_buf
);
2917 if (packet_len
<= 0)
2920 /* Force an event loop break. */
2923 response_needed
= 1;
2930 handle_query (own_buf
, packet_len
, &new_packet_len
);
2933 handle_general_set (own_buf
);
2936 require_running (own_buf
);
2941 pid
= strtol (&own_buf
[i
], NULL
, 16);
2944 pid
= ptid_get_pid (current_ptid
);
2946 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
2948 struct thread_resume resume_info
;
2949 struct process_info
*process
= find_process_pid (pid
);
2951 if (process
== NULL
)
2953 write_enn (own_buf
);
2957 if (tracing
&& disconnected_tracing
)
2959 "Disconnected tracing in effect, "
2960 "leaving gdbserver attached to the process\n");
2962 if (any_persistent_commands ())
2964 "Persistent commands are present, "
2965 "leaving gdbserver attached to the process\n");
2967 /* Make sure we're in non-stop/async mode, so we we can both
2968 wait for an async socket accept, and handle async target
2969 events simultaneously. There's also no point either in
2970 having the target stop all threads, when we're going to
2971 pass signals down without informing GDB. */
2975 fprintf (stderr
, "Forcing non-stop mode\n");
2981 process
->gdb_detached
= 1;
2983 /* Detaching implicitly resumes all threads. */
2984 resume_info
.thread
= minus_one_ptid
;
2985 resume_info
.kind
= resume_continue
;
2986 resume_info
.sig
= 0;
2987 (*the_target
->resume
) (&resume_info
, 1);
2990 break; /* from switch/case */
2993 fprintf (stderr
, "Detaching from process %d\n", pid
);
2995 if (detach_inferior (pid
) != 0)
2996 write_enn (own_buf
);
2999 discard_queued_stop_replies (pid
);
3002 if (extended_protocol
)
3004 /* Treat this like a normal program exit. */
3005 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3006 last_status
.value
.integer
= 0;
3007 last_ptid
= pid_to_ptid (pid
);
3009 current_inferior
= NULL
;
3016 /* If we are attached, then we can exit. Otherwise, we
3017 need to hang around doing nothing, until the child is
3019 join_inferior (pid
);
3025 extended_protocol
= 1;
3029 handle_status (own_buf
);
3032 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3034 ptid_t gdb_id
, thread_id
;
3037 require_running (own_buf
);
3039 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3041 pid
= ptid_get_pid (gdb_id
);
3043 if (ptid_equal (gdb_id
, null_ptid
)
3044 || ptid_equal (gdb_id
, minus_one_ptid
))
3045 thread_id
= null_ptid
;
3047 && ptid_equal (pid_to_ptid (pid
),
3050 struct thread_info
*thread
=
3051 (struct thread_info
*) find_inferior (&all_threads
,
3056 write_enn (own_buf
);
3060 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
3064 thread_id
= gdb_id_to_thread_id (gdb_id
);
3065 if (ptid_equal (thread_id
, null_ptid
))
3067 write_enn (own_buf
);
3072 if (own_buf
[1] == 'g')
3074 if (ptid_equal (thread_id
, null_ptid
))
3076 /* GDB is telling us to choose any thread. Check if
3077 the currently selected thread is still valid. If
3078 it is not, select the first available. */
3079 struct thread_info
*thread
=
3080 (struct thread_info
*) find_inferior_id (&all_threads
,
3083 thread_id
= all_threads
.head
->id
;
3086 general_thread
= thread_id
;
3087 set_desired_inferior (1);
3089 else if (own_buf
[1] == 'c')
3090 cont_thread
= thread_id
;
3096 /* Silently ignore it so that gdb can extend the protocol
3097 without compatibility headaches. */
3102 require_running (own_buf
);
3103 if (current_traceframe
>= 0)
3105 struct regcache
*regcache
= new_register_cache ();
3107 if (fetch_traceframe_registers (current_traceframe
,
3109 registers_to_string (regcache
, own_buf
);
3111 write_enn (own_buf
);
3112 free_register_cache (regcache
);
3116 struct regcache
*regcache
;
3118 set_desired_inferior (1);
3119 regcache
= get_thread_regcache (current_inferior
, 1);
3120 registers_to_string (regcache
, own_buf
);
3124 require_running (own_buf
);
3125 if (current_traceframe
>= 0)
3126 write_enn (own_buf
);
3129 struct regcache
*regcache
;
3131 set_desired_inferior (1);
3132 regcache
= get_thread_regcache (current_inferior
, 1);
3133 registers_from_string (regcache
, &own_buf
[1]);
3138 require_running (own_buf
);
3139 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3140 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3142 write_enn (own_buf
);
3144 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3147 require_running (own_buf
);
3148 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3149 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3152 write_enn (own_buf
);
3155 require_running (own_buf
);
3156 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3157 &mem_addr
, &len
, &mem_buf
) < 0
3158 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3159 write_enn (own_buf
);
3164 require_running (own_buf
);
3165 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3166 if (gdb_signal_to_host_p (sig
))
3167 signal
= gdb_signal_to_host (sig
);
3170 myresume (own_buf
, 0, signal
);
3173 require_running (own_buf
);
3174 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3175 if (gdb_signal_to_host_p (sig
))
3176 signal
= gdb_signal_to_host (sig
);
3179 myresume (own_buf
, 1, signal
);
3182 require_running (own_buf
);
3184 myresume (own_buf
, 0, signal
);
3187 require_running (own_buf
);
3189 myresume (own_buf
, 1, signal
);
3191 case 'Z': /* insert_ ... */
3193 case 'z': /* remove_ ... */
3197 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
3198 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
3199 char type
= own_buf
[1];
3201 const int insert
= ch
== 'Z';
3203 /* Default to unrecognized/unsupported. */
3207 case '0': /* software-breakpoint */
3208 case '1': /* hardware-breakpoint */
3209 case '2': /* write watchpoint */
3210 case '3': /* read watchpoint */
3211 case '4': /* access watchpoint */
3212 require_running (own_buf
);
3213 if (insert
&& the_target
->insert_point
!= NULL
)
3215 /* Insert the breakpoint. If it is already inserted, nothing
3217 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3219 /* GDB may have sent us a list of *point parameters to be
3220 evaluated on the target's side. Read such list here. If we
3221 already have a list of parameters, GDB is telling us to drop
3222 that list and use this one instead. */
3223 if (!res
&& (type
== '0' || type
== '1'))
3225 /* Remove previous conditions. */
3226 clear_gdb_breakpoint_conditions (addr
);
3227 process_point_options (addr
, &dataptr
);
3230 else if (!insert
&& the_target
->remove_point
!= NULL
)
3231 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3243 write_enn (own_buf
);
3247 response_needed
= 0;
3248 if (!target_running ())
3249 /* The packet we received doesn't make sense - but we can't
3250 reply to it, either. */
3253 fprintf (stderr
, "Killing all inferiors\n");
3254 for_each_inferior (&all_processes
, kill_inferior_callback
);
3256 /* When using the extended protocol, we wait with no program
3257 running. The traditional protocol will exit instead. */
3258 if (extended_protocol
)
3260 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3261 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3269 ptid_t gdb_id
, thread_id
;
3271 require_running (own_buf
);
3273 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3274 thread_id
= gdb_id_to_thread_id (gdb_id
);
3275 if (ptid_equal (thread_id
, null_ptid
))
3277 write_enn (own_buf
);
3281 if (mythread_alive (thread_id
))
3284 write_enn (own_buf
);
3288 response_needed
= 0;
3290 /* Restarting the inferior is only supported in the extended
3292 if (extended_protocol
)
3294 if (target_running ())
3295 for_each_inferior (&all_processes
,
3296 kill_inferior_callback
);
3297 fprintf (stderr
, "GDBserver restarting\n");
3299 /* Wait till we are at 1st instruction in prog. */
3300 if (program_argv
!= NULL
)
3301 start_inferior (program_argv
);
3304 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3305 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3311 /* It is a request we don't understand. Respond with an
3312 empty packet so that gdb knows that we don't support this
3318 /* Extended (long) request. */
3319 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3323 /* It is a request we don't understand. Respond with an empty
3324 packet so that gdb knows that we don't support this
3330 if (new_packet_len
!= -1)
3331 putpkt_binary (own_buf
, new_packet_len
);
3335 response_needed
= 0;
3337 if (!extended_protocol
&& have_ran
&& !target_running ())
3339 /* In non-stop, defer exiting until GDB had a chance to query
3340 the whole vStopped list (until it gets an OK). */
3341 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3343 fprintf (stderr
, "GDBserver exiting\n");
3355 /* Event-loop callback for serial events. */
3358 handle_serial_event (int err
, gdb_client_data client_data
)
3361 fprintf (stderr
, "handling possible serial event\n");
3363 /* Really handle it. */
3364 if (process_serial_event () < 0)
3367 /* Be sure to not change the selected inferior behind GDB's back.
3368 Important in the non-stop mode asynchronous protocol. */
3369 set_desired_inferior (1);
3374 /* Event-loop callback for target events. */
3377 handle_target_event (int err
, gdb_client_data client_data
)
3380 fprintf (stderr
, "handling possible target event\n");
3382 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3385 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3387 int pid
= ptid_get_pid (last_ptid
);
3388 struct process_info
*process
= find_process_pid (pid
);
3389 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3391 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3392 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3394 mark_breakpoints_out (process
);
3395 mourn_inferior (process
);
3399 /* We're reporting this thread as stopped. Update its
3400 "want-stopped" state to what the client wants, until it
3401 gets a new resume action. */
3402 current_inferior
->last_resume_kind
= resume_stop
;
3403 current_inferior
->last_status
= last_status
;
3408 if (!target_running ())
3410 /* The last process exited. We're done. */
3414 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3416 /* A thread stopped with a signal, but gdb isn't
3417 connected to handle it. Pass it down to the
3418 inferior, as if it wasn't being traced. */
3419 struct thread_resume resume_info
;
3423 "GDB not connected; forwarding event %d for [%s]\n",
3424 (int) last_status
.kind
,
3425 target_pid_to_str (last_ptid
));
3427 resume_info
.thread
= last_ptid
;
3428 resume_info
.kind
= resume_continue
;
3429 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3430 (*the_target
->resume
) (&resume_info
, 1);
3432 else if (debug_threads
)
3433 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3434 (int) last_status
.kind
,
3435 target_pid_to_str (last_ptid
));
3439 struct vstop_notif
*vstop_notif
3440 = xmalloc (sizeof (struct vstop_notif
));
3442 vstop_notif
->status
= last_status
;
3443 vstop_notif
->ptid
= last_ptid
;
3444 /* Push Stop notification. */
3445 notif_push (¬if_stop
,
3446 (struct notif_event
*) vstop_notif
);
3450 /* Be sure to not change the selected inferior behind GDB's back.
3451 Important in the non-stop mode asynchronous protocol. */
3452 set_desired_inferior (1);