1 /* Main code for remote server for GDB.
2 Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 ptid_t general_thread
;
38 static int extended_protocol
;
39 static int response_needed
;
40 static int exit_requested
;
42 /* --once: Exit after the first connection has closed. */
48 /* Whether we should attempt to disable the operating system's address
49 space randomization feature before starting an inferior. */
50 int disable_randomization
= 1;
52 static char **program_argv
, **wrapper_argv
;
54 /* Enable miscellaneous debugging output. The name is historical - it
55 was originally used to debug LinuxThreads support. */
58 /* Enable debugging of h/w breakpoint/watchpoint support. */
61 int pass_signals
[TARGET_SIGNAL_LAST
];
65 const char *gdbserver_xmltarget
;
67 /* The PID of the originally created or attached inferior. Used to
68 send signals to the process when GDB sends us an asynchronous interrupt
69 (user hitting Control-C in the client), and to wait for the child to exit
70 when no longer debugging it. */
72 unsigned long signal_pid
;
75 /* A file descriptor for the controlling terminal. */
78 /* TERMINAL_FD's original foreground group. */
79 pid_t old_foreground_pgrp
;
81 /* Hand back terminal ownership to the original foreground group. */
84 restore_old_foreground_pgrp (void)
86 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
90 /* Set if you want to disable optional thread related packets support
91 in gdbserver, for the sake of testing GDB against stubs that don't
93 int disable_packet_vCont
;
94 int disable_packet_Tthread
;
95 int disable_packet_qC
;
96 int disable_packet_qfThreadInfo
;
98 /* Last status reported to GDB. */
99 static struct target_waitstatus last_status
;
100 static ptid_t last_ptid
;
102 static char *own_buf
;
103 static unsigned char *mem_buf
;
105 /* Structure holding information relative to a single stop reply. We
106 keep a queue of these (really a singly-linked list) to push to GDB
110 /* Pointer to next in list. */
111 struct vstop_notif
*next
;
113 /* Thread or process that got the event. */
117 struct target_waitstatus status
;
120 /* The pending stop replies list head. */
121 static struct vstop_notif
*notif_queue
= NULL
;
123 /* Put a stop reply to the stop reply queue. */
126 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
128 struct vstop_notif
*new_notif
;
130 new_notif
= xmalloc (sizeof (*new_notif
));
131 new_notif
->next
= NULL
;
132 new_notif
->ptid
= ptid
;
133 new_notif
->status
= *status
;
137 struct vstop_notif
*tail
;
138 for (tail
= notif_queue
;
142 tail
->next
= new_notif
;
145 notif_queue
= new_notif
;
150 struct vstop_notif
*n
;
152 for (n
= notif_queue
; n
; n
= n
->next
)
155 fprintf (stderr
, "pending stop replies: %d\n", i
);
159 /* Place an event in the stop reply queue, and push a notification if
160 we aren't sending one yet. */
163 push_event (ptid_t ptid
, struct target_waitstatus
*status
)
165 gdb_assert (status
->kind
!= TARGET_WAITKIND_IGNORE
);
167 queue_stop_reply (ptid
, status
);
169 /* If this is the first stop reply in the queue, then inform GDB
170 about it, by sending a Stop notification. */
171 if (notif_queue
->next
== NULL
)
176 prepare_resume_reply (p
,
177 notif_queue
->ptid
, ¬if_queue
->status
);
178 putpkt_notif (own_buf
);
182 /* Get rid of the currently pending stop replies for PID. If PID is
183 -1, then apply to all processes. */
186 discard_queued_stop_replies (int pid
)
188 struct vstop_notif
*prev
= NULL
, *reply
, *next
;
190 for (reply
= notif_queue
; reply
; reply
= next
)
195 || ptid_get_pid (reply
->ptid
) == pid
)
197 if (reply
== notif_queue
)
200 prev
->next
= reply
->next
;
209 /* If there are more stop replies to push, push one now. */
212 send_next_stop_reply (char *own_buf
)
215 prepare_resume_reply (own_buf
,
217 ¬if_queue
->status
);
223 target_running (void)
225 return all_threads
.head
!= NULL
;
229 start_inferior (char **argv
)
231 char **new_argv
= argv
;
233 if (wrapper_argv
!= NULL
)
237 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
239 for (i
= 0; argv
[i
] != NULL
; i
++)
241 new_argv
= alloca (sizeof (char *) * count
);
243 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
244 new_argv
[count
++] = wrapper_argv
[i
];
245 for (i
= 0; argv
[i
] != NULL
; i
++)
246 new_argv
[count
++] = argv
[i
];
247 new_argv
[count
] = NULL
;
253 for (i
= 0; new_argv
[i
]; ++i
)
254 fprintf (stderr
, "new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
259 signal (SIGTTOU
, SIG_DFL
);
260 signal (SIGTTIN
, SIG_DFL
);
263 signal_pid
= create_inferior (new_argv
[0], new_argv
);
265 /* FIXME: we don't actually know at this point that the create
266 actually succeeded. We won't know that until we wait. */
267 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
272 signal (SIGTTOU
, SIG_IGN
);
273 signal (SIGTTIN
, SIG_IGN
);
274 terminal_fd
= fileno (stderr
);
275 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
276 tcsetpgrp (terminal_fd
, signal_pid
);
277 atexit (restore_old_foreground_pgrp
);
280 if (wrapper_argv
!= NULL
)
282 struct thread_resume resume_info
;
284 resume_info
.thread
= pid_to_ptid (signal_pid
);
285 resume_info
.kind
= resume_continue
;
288 mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
290 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
295 (*the_target
->resume
) (&resume_info
, 1);
297 mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
298 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
301 current_inferior
->last_resume_kind
= resume_stop
;
302 current_inferior
->last_status
= last_status
;
304 while (last_status
.value
.sig
!= TARGET_SIGNAL_TRAP
);
306 current_inferior
->last_resume_kind
= resume_stop
;
307 current_inferior
->last_status
= last_status
;
311 /* Wait till we are at 1st instruction in program, return new pid
312 (assuming success). */
313 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
315 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
316 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
318 current_inferior
->last_resume_kind
= resume_stop
;
319 current_inferior
->last_status
= last_status
;
326 attach_inferior (int pid
)
328 /* myattach should return -1 if attaching is unsupported,
329 0 if it succeeded, and call error() otherwise. */
331 if (myattach (pid
) != 0)
334 fprintf (stderr
, "Attached; pid = %d\n", pid
);
337 /* FIXME - It may be that we should get the SIGNAL_PID from the
338 attach function, so that it can be the main thread instead of
339 whichever we were told to attach to. */
344 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
346 /* GDB knows to ignore the first SIGSTOP after attaching to a running
347 process using the "attach" command, but this is different; it's
348 just using "target remote". Pretend it's just starting up. */
349 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
350 && last_status
.value
.sig
== TARGET_SIGNAL_STOP
)
351 last_status
.value
.sig
= TARGET_SIGNAL_TRAP
;
353 current_inferior
->last_resume_kind
= resume_stop
;
354 current_inferior
->last_status
= last_status
;
360 extern int remote_debug
;
362 /* Decode a qXfer read request. Return 0 if everything looks OK,
366 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
368 /* After the read marker and annex, qXfer looks like a
369 traditional 'm' packet. */
370 decode_m_packet (buf
, ofs
, len
);
376 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
378 /* Extract and NUL-terminate the object. */
380 while (*buf
&& *buf
!= ':')
386 /* Extract and NUL-terminate the read/write action. */
388 while (*buf
&& *buf
!= ':')
394 /* Extract and NUL-terminate the annex. */
396 while (*buf
&& *buf
!= ':')
406 /* Write the response to a successful qXfer read. Returns the
407 length of the (binary) data stored in BUF, corresponding
408 to as much of DATA/LEN as we could fit. IS_MORE controls
409 the first character of the response. */
411 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
420 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
424 /* Handle all of the extended 'Q' packets. */
427 handle_general_set (char *own_buf
)
429 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
431 int numsigs
= (int) TARGET_SIGNAL_LAST
, i
;
432 const char *p
= own_buf
+ strlen ("QPassSignals:");
435 p
= decode_address_to_semicolon (&cursig
, p
);
436 for (i
= 0; i
< numsigs
; i
++)
442 /* Keep looping, to clear the remaining signals. */
445 p
= decode_address_to_semicolon (&cursig
, p
);
450 strcpy (own_buf
, "OK");
454 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
458 fprintf (stderr
, "[noack mode enabled]\n");
467 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
469 char *mode
= own_buf
+ 9;
473 if (strcmp (mode
, "0") == 0)
475 else if (strcmp (mode
, "1") == 0)
479 /* We don't know what this mode is, so complain to
481 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
487 req_str
= req
? "non-stop" : "all-stop";
488 if (start_non_stop (req
) != 0)
490 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
498 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
504 if (strncmp ("QDisableRandomization:", own_buf
,
505 strlen ("QDisableRandomization:")) == 0)
507 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
510 unpack_varlen_hex (packet
, &setting
);
511 disable_randomization
= setting
;
515 if (disable_randomization
)
516 fprintf (stderr
, "[address space randomization disabled]\n");
518 fprintf (stderr
, "[address space randomization enabled]\n");
525 if (target_supports_tracepoints ()
526 && handle_tracepoint_general_set (own_buf
))
529 /* Otherwise we didn't know what packet it was. Say we didn't
535 get_features_xml (const char *annex
)
537 /* gdbserver_xmltarget defines what to return when looking
538 for the "target.xml" file. Its contents can either be
539 verbatim XML code (prefixed with a '@') or else the name
540 of the actual XML file to be used in place of "target.xml".
542 This variable is set up from the auto-generated
543 init_registers_... routine for the current target. */
545 if (gdbserver_xmltarget
546 && strcmp (annex
, "target.xml") == 0)
548 if (*gdbserver_xmltarget
== '@')
549 return gdbserver_xmltarget
+ 1;
551 annex
= gdbserver_xmltarget
;
556 extern const char *const xml_builtin
[][2];
559 /* Look for the annex. */
560 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
561 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
564 if (xml_builtin
[i
][0] != NULL
)
565 return xml_builtin
[i
][1];
573 monitor_show_help (void)
575 monitor_output ("The following monitor commands are supported:\n");
576 monitor_output (" set debug <0|1>\n");
577 monitor_output (" Enable general debugging messages\n");
578 monitor_output (" set debug-hw-points <0|1>\n");
579 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
580 monitor_output (" set remote-debug <0|1>\n");
581 monitor_output (" Enable remote protocol debugging messages\n");
582 monitor_output (" exit\n");
583 monitor_output (" Quit GDBserver\n");
586 /* Read trace frame or inferior memory. Returns the number of bytes
587 actually read, zero when no further transfer is possible, and -1 on
588 error. Return of a positive value smaller than LEN does not
589 indicate there's no more to be read, only the end of the transfer.
590 E.g., when GDB reads memory from a traceframe, a first request may
591 be served from a memory block that does not cover the whole request
592 length. A following request gets the rest served from either
593 another block (of the same traceframe) or from the read-only
597 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
601 if (current_traceframe
>= 0)
604 ULONGEST length
= len
;
606 if (traceframe_read_mem (current_traceframe
,
607 memaddr
, myaddr
, len
, &nbytes
))
609 /* Data read from trace buffer, we're done. */
612 if (!in_readonly_region (memaddr
, length
))
614 /* Otherwise we have a valid readonly case, fall through. */
615 /* (assume no half-trace half-real blocks for now) */
618 res
= prepare_to_access_memory ();
621 res
= read_inferior_memory (memaddr
, myaddr
, len
);
622 done_accessing_memory ();
624 return res
== 0 ? len
: -1;
630 /* Write trace frame or inferior memory. Actually, writing to trace
631 frames is forbidden. */
634 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
636 if (current_traceframe
>= 0)
642 ret
= prepare_to_access_memory ();
645 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
646 done_accessing_memory ();
652 /* Subroutine of handle_search_memory to simplify it. */
655 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
656 gdb_byte
*pattern
, unsigned pattern_len
,
657 gdb_byte
*search_buf
,
658 unsigned chunk_size
, unsigned search_buf_size
,
659 CORE_ADDR
*found_addrp
)
661 /* Prime the search buffer. */
663 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
666 warning ("Unable to access target memory at 0x%lx, halting search.",
671 /* Perform the search.
673 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
674 When we've scanned N bytes we copy the trailing bytes to the start and
675 read in another N bytes. */
677 while (search_space_len
>= pattern_len
)
680 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
684 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
686 if (found_ptr
!= NULL
)
688 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
689 *found_addrp
= found_addr
;
693 /* Not found in this chunk, skip to next chunk. */
695 /* Don't let search_space_len wrap here, it's unsigned. */
696 if (search_space_len
>= chunk_size
)
697 search_space_len
-= chunk_size
;
699 search_space_len
= 0;
701 if (search_space_len
>= pattern_len
)
703 unsigned keep_len
= search_buf_size
- chunk_size
;
704 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
707 /* Copy the trailing part of the previous iteration to the front
708 of the buffer for the next iteration. */
709 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
711 nr_to_read
= (search_space_len
- keep_len
< chunk_size
712 ? search_space_len
- keep_len
715 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
716 nr_to_read
) != search_buf_size
)
718 warning ("Unable to access target memory "
719 "at 0x%lx, halting search.",
724 start_addr
+= chunk_size
;
733 /* Handle qSearch:memory packets. */
736 handle_search_memory (char *own_buf
, int packet_len
)
738 CORE_ADDR start_addr
;
739 CORE_ADDR search_space_len
;
741 unsigned int pattern_len
;
742 /* NOTE: also defined in find.c testcase. */
743 #define SEARCH_CHUNK_SIZE 16000
744 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
745 /* Buffer to hold memory contents for searching. */
746 gdb_byte
*search_buf
;
747 unsigned search_buf_size
;
749 CORE_ADDR found_addr
;
750 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
752 pattern
= malloc (packet_len
);
755 error ("Unable to allocate memory to perform the search");
756 strcpy (own_buf
, "E00");
759 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
760 packet_len
- cmd_name_len
,
761 &start_addr
, &search_space_len
,
762 pattern
, &pattern_len
) < 0)
765 error ("Error in parsing qSearch:memory packet");
766 strcpy (own_buf
, "E00");
770 search_buf_size
= chunk_size
+ pattern_len
- 1;
772 /* No point in trying to allocate a buffer larger than the search space. */
773 if (search_space_len
< search_buf_size
)
774 search_buf_size
= search_space_len
;
776 search_buf
= malloc (search_buf_size
);
777 if (search_buf
== NULL
)
780 error ("Unable to allocate memory to perform the search");
781 strcpy (own_buf
, "E00");
785 found
= handle_search_memory_1 (start_addr
, search_space_len
,
786 pattern
, pattern_len
,
787 search_buf
, chunk_size
, search_buf_size
,
791 sprintf (own_buf
, "1,%lx", (long) found_addr
);
793 strcpy (own_buf
, "0");
795 strcpy (own_buf
, "E00");
801 #define require_running(BUF) \
802 if (!target_running ()) \
808 /* Handle monitor commands not handled by target-specific handlers. */
811 handle_monitor_command (char *mon
)
813 if (strcmp (mon
, "set debug 1") == 0)
816 monitor_output ("Debug output enabled.\n");
818 else if (strcmp (mon
, "set debug 0") == 0)
821 monitor_output ("Debug output disabled.\n");
823 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
826 monitor_output ("H/W point debugging output enabled.\n");
828 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
831 monitor_output ("H/W point debugging output disabled.\n");
833 else if (strcmp (mon
, "set remote-debug 1") == 0)
836 monitor_output ("Protocol debug output enabled.\n");
838 else if (strcmp (mon
, "set remote-debug 0") == 0)
841 monitor_output ("Protocol debug output disabled.\n");
843 else if (strcmp (mon
, "help") == 0)
844 monitor_show_help ();
845 else if (strcmp (mon
, "exit") == 0)
849 monitor_output ("Unknown monitor command.\n\n");
850 monitor_show_help ();
855 /* Associates a callback with each supported qXfer'able object. */
859 /* The object this handler handles. */
862 /* Request that the target transfer up to LEN 8-bit bytes of the
863 target's OBJECT. The OFFSET, for a seekable object, specifies
864 the starting point. The ANNEX can be used to provide additional
865 data-specific information to the target.
867 Return the number of bytes actually transfered, zero when no
868 further transfer is possible, -1 on error, and -2 when the
869 transfer is not supported. Return of a positive value smaller
870 than LEN does not indicate the end of the object, only the end of
873 One, and only one, of readbuf or writebuf must be non-NULL. */
874 int (*xfer
) (const char *annex
,
875 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
876 ULONGEST offset
, LONGEST len
);
879 /* Handle qXfer:auxv:read. */
882 handle_qxfer_auxv (const char *annex
,
883 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
884 ULONGEST offset
, LONGEST len
)
886 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
889 if (annex
[0] != '\0' || !target_running ())
892 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
895 /* Handle qXfer:features:read. */
898 handle_qxfer_features (const char *annex
,
899 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
900 ULONGEST offset
, LONGEST len
)
902 const char *document
;
905 if (writebuf
!= NULL
)
908 if (!target_running ())
911 /* Grab the correct annex. */
912 document
= get_features_xml (annex
);
913 if (document
== NULL
)
916 total_len
= strlen (document
);
918 if (offset
> total_len
)
921 if (offset
+ len
> total_len
)
922 len
= total_len
- offset
;
924 memcpy (readbuf
, document
+ offset
, len
);
928 /* Handle qXfer:libraries:read. */
931 handle_qxfer_libraries (const char *annex
,
932 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
933 ULONGEST offset
, LONGEST len
)
935 unsigned int total_len
;
937 struct inferior_list_entry
*dll_ptr
;
939 if (writebuf
!= NULL
)
942 if (annex
[0] != '\0' || !target_running ())
945 /* Do not confuse this packet with qXfer:libraries-svr4:read. */
946 if (the_target
->qxfer_libraries_svr4
!= NULL
)
949 /* Over-estimate the necessary memory. Assume that every character
950 in the library name must be escaped. */
952 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
953 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
955 document
= malloc (total_len
);
956 if (document
== NULL
)
959 strcpy (document
, "<library-list>\n");
960 p
= document
+ strlen (document
);
962 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
964 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
967 strcpy (p
, " <library name=\"");
969 name
= xml_escape_text (dll
->name
);
973 strcpy (p
, "\"><segment address=\"");
975 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
977 strcpy (p
, "\"/></library>\n");
981 strcpy (p
, "</library-list>\n");
983 total_len
= strlen (document
);
985 if (offset
> total_len
)
991 if (offset
+ len
> total_len
)
992 len
= total_len
- offset
;
994 memcpy (readbuf
, document
+ offset
, len
);
999 /* Handle qXfer:libraries-svr4:read. */
1002 handle_qxfer_libraries_svr4 (const char *annex
,
1003 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1004 ULONGEST offset
, LONGEST len
)
1006 if (writebuf
!= NULL
)
1009 if (annex
[0] != '\0' || !target_running ()
1010 || the_target
->qxfer_libraries_svr4
== NULL
)
1013 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1016 /* Handle qXfer:osadata:read. */
1019 handle_qxfer_osdata (const char *annex
,
1020 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1021 ULONGEST offset
, LONGEST len
)
1023 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1026 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1029 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1032 handle_qxfer_siginfo (const char *annex
,
1033 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1034 ULONGEST offset
, LONGEST len
)
1036 if (the_target
->qxfer_siginfo
== NULL
)
1039 if (annex
[0] != '\0' || !target_running ())
1042 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1045 /* Handle qXfer:spu:read and qXfer:spu:write. */
1048 handle_qxfer_spu (const char *annex
,
1049 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1050 ULONGEST offset
, LONGEST len
)
1052 if (the_target
->qxfer_spu
== NULL
)
1055 if (!target_running ())
1058 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1061 /* Handle qXfer:statictrace:read. */
1064 handle_qxfer_statictrace (const char *annex
,
1065 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1066 ULONGEST offset
, LONGEST len
)
1070 if (writebuf
!= NULL
)
1073 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1076 if (traceframe_read_sdata (current_traceframe
, offset
,
1077 readbuf
, len
, &nbytes
))
1082 /* Helper for handle_qxfer_threads. */
1085 handle_qxfer_threads_proper (struct buffer
*buffer
)
1087 struct inferior_list_entry
*thread
;
1089 buffer_grow_str (buffer
, "<threads>\n");
1091 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
1093 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
1098 write_ptid (ptid_s
, ptid
);
1100 if (the_target
->core_of_thread
)
1101 core
= (*the_target
->core_of_thread
) (ptid
);
1105 sprintf (core_s
, "%d", core
);
1106 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1111 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1116 buffer_grow_str0 (buffer
, "</threads>\n");
1119 /* Handle qXfer:threads:read. */
1122 handle_qxfer_threads (const char *annex
,
1123 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1124 ULONGEST offset
, LONGEST len
)
1126 static char *result
= 0;
1127 static unsigned int result_length
= 0;
1129 if (writebuf
!= NULL
)
1132 if (!target_running () || annex
[0] != '\0')
1137 struct buffer buffer
;
1138 /* When asked for data at offset 0, generate everything and store into
1139 'result'. Successive reads will be served off 'result'. */
1143 buffer_init (&buffer
);
1145 handle_qxfer_threads_proper (&buffer
);
1147 result
= buffer_finish (&buffer
);
1148 result_length
= strlen (result
);
1149 buffer_free (&buffer
);
1152 if (offset
>= result_length
)
1154 /* We're out of data. */
1161 if (len
> result_length
- offset
)
1162 len
= result_length
- offset
;
1164 memcpy (readbuf
, result
+ offset
, len
);
1169 /* Handle qXfer:traceframe-info:read. */
1172 handle_qxfer_traceframe_info (const char *annex
,
1173 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1174 ULONGEST offset
, LONGEST len
)
1176 static char *result
= 0;
1177 static unsigned int result_length
= 0;
1179 if (writebuf
!= NULL
)
1182 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1187 struct buffer buffer
;
1189 /* When asked for data at offset 0, generate everything and
1190 store into 'result'. Successive reads will be served off
1194 buffer_init (&buffer
);
1196 traceframe_read_info (current_traceframe
, &buffer
);
1198 result
= buffer_finish (&buffer
);
1199 result_length
= strlen (result
);
1200 buffer_free (&buffer
);
1203 if (offset
>= result_length
)
1205 /* We're out of data. */
1212 if (len
> result_length
- offset
)
1213 len
= result_length
- offset
;
1215 memcpy (readbuf
, result
+ offset
, len
);
1219 /* Handle qXfer:fdpic:read. */
1222 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1223 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1225 if (the_target
->read_loadmap
== NULL
)
1228 if (!target_running ())
1231 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1234 static const struct qxfer qxfer_packets
[] =
1236 { "auxv", handle_qxfer_auxv
},
1237 { "fdpic", handle_qxfer_fdpic
},
1238 { "features", handle_qxfer_features
},
1239 { "libraries", handle_qxfer_libraries
},
1240 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1241 { "osdata", handle_qxfer_osdata
},
1242 { "siginfo", handle_qxfer_siginfo
},
1243 { "spu", handle_qxfer_spu
},
1244 { "statictrace", handle_qxfer_statictrace
},
1245 { "threads", handle_qxfer_threads
},
1246 { "traceframe-info", handle_qxfer_traceframe_info
},
1250 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1258 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1261 /* Grab the object, r/w and annex. */
1262 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1264 write_enn (own_buf
);
1269 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1272 const struct qxfer
*q
= &qxfer_packets
[i
];
1274 if (strcmp (object
, q
->object
) == 0)
1276 if (strcmp (rw
, "read") == 0)
1278 unsigned char *data
;
1283 /* Grab the offset and length. */
1284 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1286 write_enn (own_buf
);
1290 /* Read one extra byte, as an indicator of whether there is
1292 if (len
> PBUFSIZ
- 2)
1294 data
= malloc (len
+ 1);
1297 write_enn (own_buf
);
1300 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1307 write_enn (own_buf
);
1309 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1311 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1316 else if (strcmp (rw
, "write") == 0)
1321 unsigned char *data
;
1323 strcpy (own_buf
, "E00");
1324 data
= malloc (packet_len
- (offset
- own_buf
));
1327 write_enn (own_buf
);
1330 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1331 &ofs
, &len
, data
) < 0)
1334 write_enn (own_buf
);
1338 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1345 write_enn (own_buf
);
1347 sprintf (own_buf
, "%x", n
);
1360 /* Table used by the crc32 function to calcuate the checksum. */
1362 static unsigned int crc32_table
[256] =
1365 /* Compute 32 bit CRC from inferior memory.
1367 On success, return 32 bit CRC.
1368 On failure, return (unsigned long long) -1. */
1370 static unsigned long long
1371 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1373 if (!crc32_table
[1])
1375 /* Initialize the CRC table and the decoding table. */
1379 for (i
= 0; i
< 256; i
++)
1381 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1382 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1389 unsigned char byte
= 0;
1391 /* Return failure if memory read fails. */
1392 if (read_inferior_memory (base
, &byte
, 1) != 0)
1393 return (unsigned long long) -1;
1395 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1398 return (unsigned long long) crc
;
1401 /* Handle all of the extended 'q' packets. */
1404 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1406 static struct inferior_list_entry
*thread_ptr
;
1408 /* Reply the current thread id. */
1409 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1412 require_running (own_buf
);
1414 if (!ptid_equal (general_thread
, null_ptid
)
1415 && !ptid_equal (general_thread
, minus_one_ptid
))
1416 gdb_id
= general_thread
;
1419 thread_ptr
= all_threads
.head
;
1420 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1423 sprintf (own_buf
, "QC");
1425 write_ptid (own_buf
, gdb_id
);
1429 if (strcmp ("qSymbol::", own_buf
) == 0)
1431 /* GDB is suggesting new symbols have been loaded. This may
1432 mean a new shared library has been detected as loaded, so
1433 take the opportunity to check if breakpoints we think are
1434 inserted, still are. Note that it isn't guaranteed that
1435 we'll see this when a shared library is loaded, and nor will
1436 we see this for unloads (although breakpoints in unloaded
1437 libraries shouldn't trigger), as GDB may not find symbols for
1438 the library at all. We also re-validate breakpoints when we
1439 see a second GDB breakpoint for the same address, and or when
1440 we access breakpoint shadows. */
1441 validate_breakpoints ();
1443 if (target_supports_tracepoints ())
1444 tracepoint_look_up_symbols ();
1446 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1447 (*the_target
->look_up_symbols
) ();
1449 strcpy (own_buf
, "OK");
1453 if (!disable_packet_qfThreadInfo
)
1455 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1459 require_running (own_buf
);
1460 thread_ptr
= all_threads
.head
;
1463 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1464 write_ptid (own_buf
, gdb_id
);
1465 thread_ptr
= thread_ptr
->next
;
1469 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1473 require_running (own_buf
);
1474 if (thread_ptr
!= NULL
)
1477 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1478 write_ptid (own_buf
, gdb_id
);
1479 thread_ptr
= thread_ptr
->next
;
1484 sprintf (own_buf
, "l");
1490 if (the_target
->read_offsets
!= NULL
1491 && strcmp ("qOffsets", own_buf
) == 0)
1493 CORE_ADDR text
, data
;
1495 require_running (own_buf
);
1496 if (the_target
->read_offsets (&text
, &data
))
1497 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1498 (long)text
, (long)data
, (long)data
);
1500 write_enn (own_buf
);
1505 /* Protocol features query. */
1506 if (strncmp ("qSupported", own_buf
, 10) == 0
1507 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1509 char *p
= &own_buf
[10];
1510 int gdb_supports_qRelocInsn
= 0;
1512 /* Start processing qSupported packet. */
1513 target_process_qsupported (NULL
);
1515 /* Process each feature being provided by GDB. The first
1516 feature will follow a ':', and latter features will follow
1520 char **qsupported
= NULL
;
1524 /* Two passes, to avoid nested strtok calls in
1525 target_process_qsupported. */
1526 for (p
= strtok (p
+ 1, ";");
1528 p
= strtok (NULL
, ";"))
1531 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1532 qsupported
[count
- 1] = xstrdup (p
);
1535 for (i
= 0; i
< count
; i
++)
1538 if (strcmp (p
, "multiprocess+") == 0)
1540 /* GDB supports and wants multi-process support if
1542 if (target_supports_multi_process ())
1545 else if (strcmp (p
, "qRelocInsn+") == 0)
1547 /* GDB supports relocate instruction requests. */
1548 gdb_supports_qRelocInsn
= 1;
1551 target_process_qsupported (p
);
1559 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1561 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1562 strcat (own_buf
, ";qXfer:libraries-svr4:read+");
1565 /* We do not have any hook to indicate whether the non-SVR4 target
1566 backend supports qXfer:libraries:read, so always report it. */
1567 strcat (own_buf
, ";qXfer:libraries:read+");
1570 if (the_target
->read_auxv
!= NULL
)
1571 strcat (own_buf
, ";qXfer:auxv:read+");
1573 if (the_target
->qxfer_spu
!= NULL
)
1574 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1576 if (the_target
->qxfer_siginfo
!= NULL
)
1577 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1579 if (the_target
->read_loadmap
!= NULL
)
1580 strcat (own_buf
, ";qXfer:fdpic:read+");
1582 /* We always report qXfer:features:read, as targets may
1583 install XML files on a subsequent call to arch_setup.
1584 If we reported to GDB on startup that we don't support
1585 qXfer:feature:read at all, we will never be re-queried. */
1586 strcat (own_buf
, ";qXfer:features:read+");
1588 if (transport_is_reliable
)
1589 strcat (own_buf
, ";QStartNoAckMode+");
1591 if (the_target
->qxfer_osdata
!= NULL
)
1592 strcat (own_buf
, ";qXfer:osdata:read+");
1594 if (target_supports_multi_process ())
1595 strcat (own_buf
, ";multiprocess+");
1597 if (target_supports_non_stop ())
1598 strcat (own_buf
, ";QNonStop+");
1600 if (target_supports_disable_randomization ())
1601 strcat (own_buf
, ";QDisableRandomization+");
1603 strcat (own_buf
, ";qXfer:threads:read+");
1605 if (target_supports_tracepoints ())
1607 strcat (own_buf
, ";ConditionalTracepoints+");
1608 strcat (own_buf
, ";TraceStateVariables+");
1609 strcat (own_buf
, ";TracepointSource+");
1610 strcat (own_buf
, ";DisconnectedTracing+");
1611 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1612 strcat (own_buf
, ";FastTracepoints+");
1613 strcat (own_buf
, ";StaticTracepoints+");
1614 strcat (own_buf
, ";InstallInTrace+");
1615 strcat (own_buf
, ";qXfer:statictrace:read+");
1616 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1617 strcat (own_buf
, ";EnableDisableTracepoints+");
1618 strcat (own_buf
, ";tracenz+");
1624 /* Thread-local storage support. */
1625 if (the_target
->get_tls_address
!= NULL
1626 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1628 char *p
= own_buf
+ 12;
1629 CORE_ADDR parts
[2], address
= 0;
1631 ptid_t ptid
= null_ptid
;
1633 require_running (own_buf
);
1635 for (i
= 0; i
< 3; i
++)
1643 p2
= strchr (p
, ',');
1656 ptid
= read_ptid (p
, NULL
);
1658 decode_address (&parts
[i
- 1], p
, len
);
1662 if (p
!= NULL
|| i
< 3)
1666 struct thread_info
*thread
= find_thread_ptid (ptid
);
1671 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1677 strcpy (own_buf
, paddress(address
));
1682 write_enn (own_buf
);
1686 /* Otherwise, pretend we do not understand this packet. */
1689 /* Windows OS Thread Information Block address support. */
1690 if (the_target
->get_tib_address
!= NULL
1691 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1696 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1698 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1701 strcpy (own_buf
, paddress(tlb
));
1706 write_enn (own_buf
);
1712 /* Handle "monitor" commands. */
1713 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1715 char *mon
= malloc (PBUFSIZ
);
1716 int len
= strlen (own_buf
+ 6);
1720 write_enn (own_buf
);
1724 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1726 write_enn (own_buf
);
1730 mon
[len
/ 2] = '\0';
1734 if (the_target
->handle_monitor_command
== NULL
1735 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1736 /* Default processing. */
1737 handle_monitor_command (mon
);
1743 if (strncmp ("qSearch:memory:", own_buf
,
1744 sizeof ("qSearch:memory:") - 1) == 0)
1746 require_running (own_buf
);
1747 handle_search_memory (own_buf
, packet_len
);
1751 if (strcmp (own_buf
, "qAttached") == 0
1752 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1754 struct process_info
*process
;
1756 if (own_buf
[sizeof ("qAttached") - 1])
1758 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1759 process
= (struct process_info
*)
1760 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1764 require_running (own_buf
);
1765 process
= current_process ();
1768 if (process
== NULL
)
1770 write_enn (own_buf
);
1774 strcpy (own_buf
, process
->attached
? "1" : "0");
1778 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1780 /* CRC check (compare-section). */
1784 unsigned long long crc
;
1786 require_running (own_buf
);
1787 base
= strtoul (own_buf
+ 5, &comma
, 16);
1788 if (*comma
++ != ',')
1790 write_enn (own_buf
);
1793 len
= strtoul (comma
, NULL
, 16);
1794 crc
= crc32 (base
, len
, 0xffffffff);
1795 /* Check for memory failure. */
1796 if (crc
== (unsigned long long) -1)
1798 write_enn (own_buf
);
1801 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
1805 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
1808 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
1811 /* Otherwise we didn't know what packet it was. Say we didn't
1816 static void gdb_wants_all_threads_stopped (void);
1818 /* Parse vCont packets. */
1820 handle_v_cont (char *own_buf
)
1824 struct thread_resume
*resume_info
;
1825 struct thread_resume default_action
= {{0}};
1827 /* Count the number of semicolons in the packet. There should be one
1828 for every action. */
1834 p
= strchr (p
, ';');
1837 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1838 if (resume_info
== NULL
)
1846 if (p
[0] == 's' || p
[0] == 'S')
1847 resume_info
[i
].kind
= resume_step
;
1848 else if (p
[0] == 'c' || p
[0] == 'C')
1849 resume_info
[i
].kind
= resume_continue
;
1850 else if (p
[0] == 't')
1851 resume_info
[i
].kind
= resume_stop
;
1855 if (p
[0] == 'S' || p
[0] == 'C')
1858 sig
= strtol (p
+ 1, &q
, 16);
1863 if (!target_signal_to_host_p (sig
))
1865 resume_info
[i
].sig
= target_signal_to_host (sig
);
1869 resume_info
[i
].sig
= 0;
1875 resume_info
[i
].thread
= minus_one_ptid
;
1876 default_action
= resume_info
[i
];
1878 /* Note: we don't increment i here, we'll overwrite this entry
1879 the next time through. */
1881 else if (p
[0] == ':')
1883 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1888 if (p
[0] != ';' && p
[0] != 0)
1891 resume_info
[i
].thread
= ptid
;
1898 resume_info
[i
] = default_action
;
1900 /* Still used in occasional places in the backend. */
1902 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1903 && resume_info
[0].kind
!= resume_stop
)
1904 cont_thread
= resume_info
[0].thread
;
1906 cont_thread
= minus_one_ptid
;
1907 set_desired_inferior (0);
1912 (*the_target
->resume
) (resume_info
, n
);
1920 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1922 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
1923 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
1924 current_inferior
->last_status
= last_status
;
1926 /* From the client's perspective, all-stop mode always stops all
1927 threads implicitly (and the target backend has already done
1928 so by now). Tag all threads as "want-stopped", so we don't
1929 resume them implicitly without the client telling us to. */
1930 gdb_wants_all_threads_stopped ();
1931 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1932 disable_async_io ();
1934 if (last_status
.kind
== TARGET_WAITKIND_EXITED
1935 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
1936 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
1941 write_enn (own_buf
);
1946 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1948 handle_v_attach (char *own_buf
)
1952 pid
= strtol (own_buf
+ 8, NULL
, 16);
1953 if (pid
!= 0 && attach_inferior (pid
) == 0)
1955 /* Don't report shared library events after attaching, even if
1956 some libraries are preloaded. GDB will always poll the
1957 library list. Avoids the "stopped by shared library event"
1958 notice on the GDB side. */
1963 /* In non-stop, we don't send a resume reply. Stop events
1964 will follow up using the normal notification
1969 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1975 write_enn (own_buf
);
1980 /* Run a new program. Return 1 if successful, 0 if failure. */
1982 handle_v_run (char *own_buf
)
1984 char *p
, *next_p
, **new_argv
;
1988 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1994 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1995 if (new_argv
== NULL
)
1997 write_enn (own_buf
);
2002 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2004 next_p
= strchr (p
, ';');
2006 next_p
= p
+ strlen (p
);
2008 if (i
== 0 && p
== next_p
)
2012 /* FIXME: Fail request if out of memory instead of dying. */
2013 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2014 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2015 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2024 if (new_argv
[0] == NULL
)
2026 /* GDB didn't specify a program to run. Use the program from the
2027 last run with the new argument list. */
2029 if (program_argv
== NULL
)
2031 write_enn (own_buf
);
2032 freeargv (new_argv
);
2036 new_argv
[0] = strdup (program_argv
[0]);
2037 if (new_argv
[0] == NULL
)
2039 write_enn (own_buf
);
2040 freeargv (new_argv
);
2045 /* Free the old argv and install the new one. */
2046 freeargv (program_argv
);
2047 program_argv
= new_argv
;
2049 start_inferior (program_argv
);
2050 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2052 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2054 /* In non-stop, sending a resume reply doesn't set the general
2055 thread, but GDB assumes a vRun sets it (this is so GDB can
2056 query which is the main thread of the new inferior. */
2058 general_thread
= last_ptid
;
2064 write_enn (own_buf
);
2069 /* Kill process. Return 1 if successful, 0 if failure. */
2071 handle_v_kill (char *own_buf
)
2074 char *p
= &own_buf
[6];
2076 pid
= strtol (p
, NULL
, 16);
2079 if (pid
!= 0 && kill_inferior (pid
) == 0)
2081 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2082 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2083 last_ptid
= pid_to_ptid (pid
);
2084 discard_queued_stop_replies (pid
);
2090 write_enn (own_buf
);
2095 /* Handle a 'vStopped' packet. */
2097 handle_v_stopped (char *own_buf
)
2099 /* If we're waiting for GDB to acknowledge a pending stop reply,
2100 consider that done. */
2103 struct vstop_notif
*head
;
2106 fprintf (stderr
, "vStopped: acking %s\n",
2107 target_pid_to_str (notif_queue
->ptid
));
2110 notif_queue
= notif_queue
->next
;
2114 /* Push another stop reply, or if there are no more left, an OK. */
2115 send_next_stop_reply (own_buf
);
2118 /* Handle all of the extended 'v' packets. */
2120 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2122 if (!disable_packet_vCont
)
2124 if (strncmp (own_buf
, "vCont;", 6) == 0)
2126 require_running (own_buf
);
2127 handle_v_cont (own_buf
);
2131 if (strncmp (own_buf
, "vCont?", 6) == 0)
2133 strcpy (own_buf
, "vCont;c;C;s;S;t");
2138 if (strncmp (own_buf
, "vFile:", 6) == 0
2139 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2142 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2144 if (!multi_process
&& target_running ())
2146 fprintf (stderr
, "Already debugging a process\n");
2147 write_enn (own_buf
);
2150 handle_v_attach (own_buf
);
2154 if (strncmp (own_buf
, "vRun;", 5) == 0)
2156 if (!multi_process
&& target_running ())
2158 fprintf (stderr
, "Already debugging a process\n");
2159 write_enn (own_buf
);
2162 handle_v_run (own_buf
);
2166 if (strncmp (own_buf
, "vKill;", 6) == 0)
2168 if (!target_running ())
2170 fprintf (stderr
, "No process to kill\n");
2171 write_enn (own_buf
);
2174 handle_v_kill (own_buf
);
2178 if (strncmp (own_buf
, "vStopped", 8) == 0)
2180 handle_v_stopped (own_buf
);
2184 /* Otherwise we didn't know what packet it was. Say we didn't
2190 /* Resume inferior and wait for another event. In non-stop mode,
2191 don't really wait here, but return immediatelly to the event
2194 myresume (char *own_buf
, int step
, int sig
)
2196 struct thread_resume resume_info
[2];
2198 int valid_cont_thread
;
2200 set_desired_inferior (0);
2202 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2203 && !ptid_equal (cont_thread
, minus_one_ptid
));
2205 if (step
|| sig
|| valid_cont_thread
)
2207 resume_info
[0].thread
2208 = ((struct inferior_list_entry
*) current_inferior
)->id
;
2210 resume_info
[0].kind
= resume_step
;
2212 resume_info
[0].kind
= resume_continue
;
2213 resume_info
[0].sig
= sig
;
2217 if (!valid_cont_thread
)
2219 resume_info
[n
].thread
= minus_one_ptid
;
2220 resume_info
[n
].kind
= resume_continue
;
2221 resume_info
[n
].sig
= 0;
2228 (*the_target
->resume
) (resume_info
, n
);
2234 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2236 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2237 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2239 current_inferior
->last_resume_kind
= resume_stop
;
2240 current_inferior
->last_status
= last_status
;
2243 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2244 disable_async_io ();
2246 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2247 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2248 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2252 /* Callback for for_each_inferior. Make a new stop reply for each
2256 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2258 struct thread_info
*thread
= (struct thread_info
*) entry
;
2260 /* For now, assume targets that don't have this callback also don't
2261 manage the thread's last_status field. */
2262 if (the_target
->thread_stopped
== NULL
)
2264 /* Pass the last stop reply back to GDB, but don't notify
2266 queue_stop_reply (entry
->id
, &thread
->last_status
);
2270 if (thread_stopped (thread
))
2274 "Reporting thread %s as already stopped with %s\n",
2275 target_pid_to_str (entry
->id
),
2276 target_waitstatus_to_string (&thread
->last_status
));
2278 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2280 /* Pass the last stop reply back to GDB, but don't notify
2282 queue_stop_reply (entry
->id
, &thread
->last_status
);
2289 /* Set this inferior threads's state as "want-stopped". We won't
2290 resume this thread until the client gives us another action for
2294 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2296 struct thread_info
*thread
= (struct thread_info
*) entry
;
2298 thread
->last_resume_kind
= resume_stop
;
2300 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2302 /* Most threads are stopped implicitly (all-stop); tag that with
2304 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2305 thread
->last_status
.value
.sig
= TARGET_SIGNAL_0
;
2309 /* Set all threads' states as "want-stopped". */
2312 gdb_wants_all_threads_stopped (void)
2314 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2317 /* Clear the gdb_detached flag of every process. */
2320 gdb_reattached_process (struct inferior_list_entry
*entry
)
2322 struct process_info
*process
= (struct process_info
*) entry
;
2324 process
->gdb_detached
= 0;
2327 /* Status handler for the '?' packet. */
2330 handle_status (char *own_buf
)
2332 /* GDB is connected, don't forward events to the target anymore. */
2333 for_each_inferior (&all_processes
, gdb_reattached_process
);
2335 /* In non-stop mode, we must send a stop reply for each stopped
2336 thread. In all-stop mode, just send one for the first stopped
2341 discard_queued_stop_replies (-1);
2342 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2344 /* The first is sent immediatly. OK is sent if there is no
2345 stopped thread, which is the same handling of the vStopped
2346 packet (by design). */
2347 send_next_stop_reply (own_buf
);
2352 stabilize_threads ();
2353 gdb_wants_all_threads_stopped ();
2355 if (all_threads
.head
)
2357 struct target_waitstatus status
;
2359 status
.kind
= TARGET_WAITKIND_STOPPED
;
2360 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
2361 prepare_resume_reply (own_buf
,
2362 all_threads
.head
->id
, &status
);
2365 strcpy (own_buf
, "W00");
2370 gdbserver_version (void)
2372 printf ("GNU gdbserver %s%s\n"
2373 "Copyright (C) 2012 Free Software Foundation, Inc.\n"
2374 "gdbserver is free software, covered by the "
2375 "GNU General Public License.\n"
2376 "This gdbserver was configured as \"%s\"\n",
2377 PKGVERSION
, version
, host_name
);
2381 gdbserver_usage (FILE *stream
)
2383 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2384 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2385 "\tgdbserver [OPTIONS] --multi COMM\n"
2387 "COMM may either be a tty device (for serial debugging), or \n"
2388 "HOST:PORT to listen for a TCP connection.\n"
2391 " --debug Enable general debugging output.\n"
2392 " --remote-debug Enable remote protocol debugging output.\n"
2393 " --version Display version information and exit.\n"
2394 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2395 " --once Exit after the first connection has "
2397 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2398 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2402 gdbserver_show_disableable (FILE *stream
)
2404 fprintf (stream
, "Disableable packets:\n"
2405 " vCont \tAll vCont packets\n"
2406 " qC \tQuerying the current thread\n"
2407 " qfThreadInfo\tThread listing\n"
2408 " Tthread \tPassing the thread specifier in the "
2409 "T stop reply packet\n"
2410 " threads \tAll of the above\n");
2414 #undef require_running
2415 #define require_running(BUF) \
2416 if (!target_running ()) \
2423 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2425 int pid
= * (int *) args
;
2427 if (ptid_get_pid (entry
->id
) == pid
)
2434 kill_inferior_callback (struct inferior_list_entry
*entry
)
2436 struct process_info
*process
= (struct process_info
*) entry
;
2437 int pid
= ptid_get_pid (process
->head
.id
);
2439 kill_inferior (pid
);
2440 discard_queued_stop_replies (pid
);
2443 /* Callback for for_each_inferior to detach or kill the inferior,
2444 depending on whether we attached to it or not.
2445 We inform the user whether we're detaching or killing the process
2446 as this is only called when gdbserver is about to exit. */
2449 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2451 struct process_info
*process
= (struct process_info
*) entry
;
2452 int pid
= ptid_get_pid (process
->head
.id
);
2454 if (process
->attached
)
2455 detach_inferior (pid
);
2457 kill_inferior (pid
);
2459 discard_queued_stop_replies (pid
);
2462 /* for_each_inferior callback for detach_or_kill_for_exit to print
2463 the pids of started inferiors. */
2466 print_started_pid (struct inferior_list_entry
*entry
)
2468 struct process_info
*process
= (struct process_info
*) entry
;
2470 if (! process
->attached
)
2472 int pid
= ptid_get_pid (process
->head
.id
);
2473 fprintf (stderr
, " %d", pid
);
2477 /* for_each_inferior callback for detach_or_kill_for_exit to print
2478 the pids of attached inferiors. */
2481 print_attached_pid (struct inferior_list_entry
*entry
)
2483 struct process_info
*process
= (struct process_info
*) entry
;
2485 if (process
->attached
)
2487 int pid
= ptid_get_pid (process
->head
.id
);
2488 fprintf (stderr
, " %d", pid
);
2492 /* Call this when exiting gdbserver with possible inferiors that need
2493 to be killed or detached from. */
2496 detach_or_kill_for_exit (void)
2498 /* First print a list of the inferiors we will be killing/detaching.
2499 This is to assist the user, for example, in case the inferior unexpectedly
2500 dies after we exit: did we screw up or did the inferior exit on its own?
2501 Having this info will save some head-scratching. */
2503 if (have_started_inferiors_p ())
2505 fprintf (stderr
, "Killing process(es):");
2506 for_each_inferior (&all_processes
, print_started_pid
);
2507 fprintf (stderr
, "\n");
2509 if (have_attached_inferiors_p ())
2511 fprintf (stderr
, "Detaching process(es):");
2512 for_each_inferior (&all_processes
, print_attached_pid
);
2513 fprintf (stderr
, "\n");
2516 /* Now we can kill or detach the inferiors. */
2518 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2522 main (int argc
, char *argv
[])
2526 char *arg_end
, *port
;
2527 char **next_arg
= &argv
[1];
2532 while (*next_arg
!= NULL
&& **next_arg
== '-')
2534 if (strcmp (*next_arg
, "--version") == 0)
2536 gdbserver_version ();
2539 else if (strcmp (*next_arg
, "--help") == 0)
2541 gdbserver_usage (stdout
);
2544 else if (strcmp (*next_arg
, "--attach") == 0)
2546 else if (strcmp (*next_arg
, "--multi") == 0)
2548 else if (strcmp (*next_arg
, "--wrapper") == 0)
2552 wrapper_argv
= next_arg
;
2553 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2556 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2558 gdbserver_usage (stderr
);
2562 /* Consume the "--". */
2565 else if (strcmp (*next_arg
, "--debug") == 0)
2567 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2569 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2571 gdbserver_show_disableable (stdout
);
2574 else if (strncmp (*next_arg
,
2575 "--disable-packet=",
2576 sizeof ("--disable-packet=") - 1) == 0)
2578 char *packets
, *tok
;
2580 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2581 for (tok
= strtok (packets
, ",");
2583 tok
= strtok (NULL
, ","))
2585 if (strcmp ("vCont", tok
) == 0)
2586 disable_packet_vCont
= 1;
2587 else if (strcmp ("Tthread", tok
) == 0)
2588 disable_packet_Tthread
= 1;
2589 else if (strcmp ("qC", tok
) == 0)
2590 disable_packet_qC
= 1;
2591 else if (strcmp ("qfThreadInfo", tok
) == 0)
2592 disable_packet_qfThreadInfo
= 1;
2593 else if (strcmp ("threads", tok
) == 0)
2595 disable_packet_vCont
= 1;
2596 disable_packet_Tthread
= 1;
2597 disable_packet_qC
= 1;
2598 disable_packet_qfThreadInfo
= 1;
2602 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2604 gdbserver_show_disableable (stderr
);
2609 else if (strcmp (*next_arg
, "-") == 0)
2611 /* "-" specifies a stdio connection and is a form of port
2613 *next_arg
= STDIO_CONNECTION_NAME
;
2616 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2617 disable_randomization
= 1;
2618 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2619 disable_randomization
= 0;
2620 else if (strcmp (*next_arg
, "--once") == 0)
2624 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2632 if (setjmp (toplevel
))
2634 fprintf (stderr
, "Exiting\n");
2640 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2642 gdbserver_usage (stderr
);
2646 /* We need to know whether the remote connection is stdio before
2647 starting the inferior. Inferiors created in this scenario have
2648 stdin,stdout redirected. So do this here before we call
2650 remote_prepare (port
);
2655 /* --attach used to come after PORT, so allow it there for
2657 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2664 && (*next_arg
== NULL
2665 || (*next_arg
)[0] == '\0'
2666 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2668 || next_arg
[1] != NULL
))
2673 gdbserver_usage (stderr
);
2677 initialize_async_io ();
2679 if (target_supports_tracepoints ())
2680 initialize_tracepoint ();
2682 own_buf
= xmalloc (PBUFSIZ
+ 1);
2683 mem_buf
= xmalloc (PBUFSIZ
);
2685 if (pid
== 0 && *next_arg
!= NULL
)
2689 n
= argc
- (next_arg
- argv
);
2690 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2691 for (i
= 0; i
< n
; i
++)
2692 program_argv
[i
] = xstrdup (next_arg
[i
]);
2693 program_argv
[i
] = NULL
;
2695 /* Wait till we are at first instruction in program. */
2696 start_inferior (program_argv
);
2698 /* We are now (hopefully) stopped at the first instruction of
2699 the target process. This assumes that the target process was
2700 successfully created. */
2704 if (attach_inferior (pid
) == -1)
2705 error ("Attaching not supported on this target");
2707 /* Otherwise succeeded. */
2711 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2712 last_status
.value
.integer
= 0;
2713 last_ptid
= minus_one_ptid
;
2716 /* Don't report shared library events on the initial connection,
2717 even if some libraries are preloaded. Avoids the "stopped by
2718 shared library event" notice on gdb side. */
2721 if (setjmp (toplevel
))
2723 detach_or_kill_for_exit ();
2727 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2728 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2733 if (!was_running
&& !multi_mode
)
2735 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2743 /* Be sure we're out of tfind mode. */
2744 current_traceframe
= -1;
2748 if (setjmp (toplevel
) != 0)
2750 /* An error occurred. */
2751 if (response_needed
)
2753 write_enn (own_buf
);
2758 /* Wait for events. This will return when all event sources are
2759 removed from the event loop. */
2760 start_event_loop ();
2762 /* If an exit was requested (using the "monitor exit" command),
2763 terminate now. The only other way to get here is for
2764 getpkt to fail; close the connection and reopen it at the
2767 if (exit_requested
|| run_once
)
2769 detach_or_kill_for_exit ();
2774 "Remote side has terminated connection. "
2775 "GDBserver will reopen the connection.\n");
2779 if (disconnected_tracing
)
2781 /* Try to enable non-stop/async mode, so we we can both
2782 wait for an async socket accept, and handle async
2783 target events simultaneously. There's also no point
2784 either in having the target always stop all threads,
2785 when we're going to pass signals down without
2789 if (start_non_stop (1))
2792 /* Detaching implicitly resumes all threads; simply
2793 disconnecting does not. */
2799 "Disconnected tracing disabled; stopping trace run.\n");
2806 /* Event loop callback that handles a serial event. The first byte in
2807 the serial buffer gets us here. We expect characters to arrive at
2808 a brisk pace, so we read the rest of the packet with a blocking
2812 process_serial_event (void)
2823 int new_packet_len
= -1;
2825 /* Used to decide when gdbserver should exit in
2826 multi-mode/remote. */
2827 static int have_ran
= 0;
2830 have_ran
= target_running ();
2832 disable_async_io ();
2834 response_needed
= 0;
2835 packet_len
= getpkt (own_buf
);
2836 if (packet_len
<= 0)
2839 /* Force an event loop break. */
2842 response_needed
= 1;
2849 handle_query (own_buf
, packet_len
, &new_packet_len
);
2852 handle_general_set (own_buf
);
2855 require_running (own_buf
);
2860 pid
= strtol (&own_buf
[i
], NULL
, 16);
2864 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2866 if (tracing
&& disconnected_tracing
)
2868 struct thread_resume resume_info
;
2869 struct process_info
*process
= find_process_pid (pid
);
2871 if (process
== NULL
)
2873 write_enn (own_buf
);
2878 "Disconnected tracing in effect, "
2879 "leaving gdbserver attached to the process\n");
2881 /* Make sure we're in non-stop/async mode, so we we can both
2882 wait for an async socket accept, and handle async target
2883 events simultaneously. There's also no point either in
2884 having the target stop all threads, when we're going to
2885 pass signals down without informing GDB. */
2889 fprintf (stderr
, "Forcing non-stop mode\n");
2895 process
->gdb_detached
= 1;
2897 /* Detaching implicitly resumes all threads. */
2898 resume_info
.thread
= minus_one_ptid
;
2899 resume_info
.kind
= resume_continue
;
2900 resume_info
.sig
= 0;
2901 (*the_target
->resume
) (&resume_info
, 1);
2904 break; /* from switch/case */
2907 fprintf (stderr
, "Detaching from process %d\n", pid
);
2909 if (detach_inferior (pid
) != 0)
2910 write_enn (own_buf
);
2913 discard_queued_stop_replies (pid
);
2916 if (extended_protocol
)
2918 /* Treat this like a normal program exit. */
2919 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2920 last_status
.value
.integer
= 0;
2921 last_ptid
= pid_to_ptid (pid
);
2923 current_inferior
= NULL
;
2930 /* If we are attached, then we can exit. Otherwise, we
2931 need to hang around doing nothing, until the child is
2933 join_inferior (pid
);
2939 extended_protocol
= 1;
2943 handle_status (own_buf
);
2946 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2948 ptid_t gdb_id
, thread_id
;
2951 require_running (own_buf
);
2953 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2955 pid
= ptid_get_pid (gdb_id
);
2957 if (ptid_equal (gdb_id
, null_ptid
)
2958 || ptid_equal (gdb_id
, minus_one_ptid
))
2959 thread_id
= null_ptid
;
2961 && ptid_equal (pid_to_ptid (pid
),
2964 struct thread_info
*thread
=
2965 (struct thread_info
*) find_inferior (&all_threads
,
2970 write_enn (own_buf
);
2974 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2978 thread_id
= gdb_id_to_thread_id (gdb_id
);
2979 if (ptid_equal (thread_id
, null_ptid
))
2981 write_enn (own_buf
);
2986 if (own_buf
[1] == 'g')
2988 if (ptid_equal (thread_id
, null_ptid
))
2990 /* GDB is telling us to choose any thread. Check if
2991 the currently selected thread is still valid. If
2992 it is not, select the first available. */
2993 struct thread_info
*thread
=
2994 (struct thread_info
*) find_inferior_id (&all_threads
,
2997 thread_id
= all_threads
.head
->id
;
3000 general_thread
= thread_id
;
3001 set_desired_inferior (1);
3003 else if (own_buf
[1] == 'c')
3004 cont_thread
= thread_id
;
3010 /* Silently ignore it so that gdb can extend the protocol
3011 without compatibility headaches. */
3016 require_running (own_buf
);
3017 if (current_traceframe
>= 0)
3019 struct regcache
*regcache
= new_register_cache ();
3021 if (fetch_traceframe_registers (current_traceframe
,
3023 registers_to_string (regcache
, own_buf
);
3025 write_enn (own_buf
);
3026 free_register_cache (regcache
);
3030 struct regcache
*regcache
;
3032 set_desired_inferior (1);
3033 regcache
= get_thread_regcache (current_inferior
, 1);
3034 registers_to_string (regcache
, own_buf
);
3038 require_running (own_buf
);
3039 if (current_traceframe
>= 0)
3040 write_enn (own_buf
);
3043 struct regcache
*regcache
;
3045 set_desired_inferior (1);
3046 regcache
= get_thread_regcache (current_inferior
, 1);
3047 registers_from_string (regcache
, &own_buf
[1]);
3052 require_running (own_buf
);
3053 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3054 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3056 write_enn (own_buf
);
3058 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3061 require_running (own_buf
);
3062 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3063 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3066 write_enn (own_buf
);
3069 require_running (own_buf
);
3070 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3071 &mem_addr
, &len
, &mem_buf
) < 0
3072 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3073 write_enn (own_buf
);
3078 require_running (own_buf
);
3079 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3080 if (target_signal_to_host_p (sig
))
3081 signal
= target_signal_to_host (sig
);
3084 myresume (own_buf
, 0, signal
);
3087 require_running (own_buf
);
3088 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3089 if (target_signal_to_host_p (sig
))
3090 signal
= target_signal_to_host (sig
);
3093 myresume (own_buf
, 1, signal
);
3096 require_running (own_buf
);
3098 myresume (own_buf
, 0, signal
);
3101 require_running (own_buf
);
3103 myresume (own_buf
, 1, signal
);
3105 case 'Z': /* insert_ ... */
3107 case 'z': /* remove_ ... */
3111 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
3112 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
3113 char type
= own_buf
[1];
3115 const int insert
= ch
== 'Z';
3117 /* Default to unrecognized/unsupported. */
3121 case '0': /* software-breakpoint */
3122 case '1': /* hardware-breakpoint */
3123 case '2': /* write watchpoint */
3124 case '3': /* read watchpoint */
3125 case '4': /* access watchpoint */
3126 require_running (own_buf
);
3127 if (insert
&& the_target
->insert_point
!= NULL
)
3128 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3129 else if (!insert
&& the_target
->remove_point
!= NULL
)
3130 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3142 write_enn (own_buf
);
3146 response_needed
= 0;
3147 if (!target_running ())
3148 /* The packet we received doesn't make sense - but we can't
3149 reply to it, either. */
3152 fprintf (stderr
, "Killing all inferiors\n");
3153 for_each_inferior (&all_processes
, kill_inferior_callback
);
3155 /* When using the extended protocol, we wait with no program
3156 running. The traditional protocol will exit instead. */
3157 if (extended_protocol
)
3159 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3160 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
3168 ptid_t gdb_id
, thread_id
;
3170 require_running (own_buf
);
3172 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3173 thread_id
= gdb_id_to_thread_id (gdb_id
);
3174 if (ptid_equal (thread_id
, null_ptid
))
3176 write_enn (own_buf
);
3180 if (mythread_alive (thread_id
))
3183 write_enn (own_buf
);
3187 response_needed
= 0;
3189 /* Restarting the inferior is only supported in the extended
3191 if (extended_protocol
)
3193 if (target_running ())
3194 for_each_inferior (&all_processes
,
3195 kill_inferior_callback
);
3196 fprintf (stderr
, "GDBserver restarting\n");
3198 /* Wait till we are at 1st instruction in prog. */
3199 if (program_argv
!= NULL
)
3200 start_inferior (program_argv
);
3203 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3204 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
3210 /* It is a request we don't understand. Respond with an
3211 empty packet so that gdb knows that we don't support this
3217 /* Extended (long) request. */
3218 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3222 /* It is a request we don't understand. Respond with an empty
3223 packet so that gdb knows that we don't support this
3229 if (new_packet_len
!= -1)
3230 putpkt_binary (own_buf
, new_packet_len
);
3234 response_needed
= 0;
3236 if (!extended_protocol
&& have_ran
&& !target_running ())
3238 /* In non-stop, defer exiting until GDB had a chance to query
3239 the whole vStopped list (until it gets an OK). */
3242 fprintf (stderr
, "GDBserver exiting\n");
3254 /* Event-loop callback for serial events. */
3257 handle_serial_event (int err
, gdb_client_data client_data
)
3260 fprintf (stderr
, "handling possible serial event\n");
3262 /* Really handle it. */
3263 if (process_serial_event () < 0)
3266 /* Be sure to not change the selected inferior behind GDB's back.
3267 Important in the non-stop mode asynchronous protocol. */
3268 set_desired_inferior (1);
3273 /* Event-loop callback for target events. */
3276 handle_target_event (int err
, gdb_client_data client_data
)
3279 fprintf (stderr
, "handling possible target event\n");
3281 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3284 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3286 int pid
= ptid_get_pid (last_ptid
);
3287 struct process_info
*process
= find_process_pid (pid
);
3288 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3290 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3291 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3293 mark_breakpoints_out (process
);
3294 mourn_inferior (process
);
3298 /* We're reporting this thread as stopped. Update its
3299 "want-stopped" state to what the client wants, until it
3300 gets a new resume action. */
3301 current_inferior
->last_resume_kind
= resume_stop
;
3302 current_inferior
->last_status
= last_status
;
3307 if (!target_running ())
3309 /* The last process exited. We're done. */
3313 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3315 /* A thread stopped with a signal, but gdb isn't
3316 connected to handle it. Pass it down to the
3317 inferior, as if it wasn't being traced. */
3318 struct thread_resume resume_info
;
3322 "GDB not connected; forwarding event %d for [%s]\n",
3323 (int) last_status
.kind
,
3324 target_pid_to_str (last_ptid
));
3326 resume_info
.thread
= last_ptid
;
3327 resume_info
.kind
= resume_continue
;
3328 resume_info
.sig
= target_signal_to_host (last_status
.value
.sig
);
3329 (*the_target
->resume
) (&resume_info
, 1);
3331 else if (debug_threads
)
3332 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3333 (int) last_status
.kind
,
3334 target_pid_to_str (last_ptid
));
3338 /* Something interesting. Tell GDB about it. */
3339 push_event (last_ptid
, &last_status
);
3343 /* Be sure to not change the selected inferior behind GDB's back.
3344 Important in the non-stop mode asynchronous protocol. */
3345 set_desired_inferior (1);