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 Free Software Foundation, Inc.
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/>. */
36 ptid_t general_thread
;
41 static int extended_protocol
;
42 static int response_needed
;
43 static int exit_requested
;
48 static char **program_argv
, **wrapper_argv
;
50 /* Enable miscellaneous debugging output. The name is historical - it
51 was originally used to debug LinuxThreads support. */
54 /* Enable debugging of h/w breakpoint/watchpoint support. */
57 int pass_signals
[TARGET_SIGNAL_LAST
];
61 const char *gdbserver_xmltarget
;
63 /* The PID of the originally created or attached inferior. Used to
64 send signals to the process when GDB sends us an asynchronous interrupt
65 (user hitting Control-C in the client), and to wait for the child to exit
66 when no longer debugging it. */
68 unsigned long signal_pid
;
71 /* A file descriptor for the controlling terminal. */
74 /* TERMINAL_FD's original foreground group. */
75 pid_t old_foreground_pgrp
;
77 /* Hand back terminal ownership to the original foreground group. */
80 restore_old_foreground_pgrp (void)
82 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
86 /* Set if you want to disable optional thread related packets support
87 in gdbserver, for the sake of testing GDB against stubs that don't
89 int disable_packet_vCont
;
90 int disable_packet_Tthread
;
91 int disable_packet_qC
;
92 int disable_packet_qfThreadInfo
;
94 /* Last status reported to GDB. */
95 static struct target_waitstatus last_status
;
96 static ptid_t last_ptid
;
99 static unsigned char *mem_buf
;
101 /* Structure holding information relative to a single stop reply. We
102 keep a queue of these (really a singly-linked list) to push to GDB
106 /* Pointer to next in list. */
107 struct vstop_notif
*next
;
109 /* Thread or process that got the event. */
113 struct target_waitstatus status
;
116 /* The pending stop replies list head. */
117 static struct vstop_notif
*notif_queue
= NULL
;
119 /* Put a stop reply to the stop reply queue. */
122 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
124 struct vstop_notif
*new_notif
;
126 new_notif
= malloc (sizeof (*new_notif
));
127 new_notif
->next
= NULL
;
128 new_notif
->ptid
= ptid
;
129 new_notif
->status
= *status
;
133 struct vstop_notif
*tail
;
134 for (tail
= notif_queue
;
138 tail
->next
= new_notif
;
141 notif_queue
= new_notif
;
146 struct vstop_notif
*n
;
148 for (n
= notif_queue
; n
; n
= n
->next
)
151 fprintf (stderr
, "pending stop replies: %d\n", i
);
155 /* Place an event in the stop reply queue, and push a notification if
156 we aren't sending one yet. */
159 push_event (ptid_t ptid
, struct target_waitstatus
*status
)
161 queue_stop_reply (ptid
, status
);
163 /* If this is the first stop reply in the queue, then inform GDB
164 about it, by sending a Stop notification. */
165 if (notif_queue
->next
== NULL
)
170 prepare_resume_reply (p
,
171 notif_queue
->ptid
, ¬if_queue
->status
);
172 putpkt_notif (own_buf
);
176 /* Get rid of the currently pending stop replies for PID. If PID is
177 -1, then apply to all processes. */
180 discard_queued_stop_replies (int pid
)
182 struct vstop_notif
*prev
= NULL
, *reply
, *next
;
184 for (reply
= notif_queue
; reply
; reply
= next
)
189 || ptid_get_pid (reply
->ptid
) == pid
)
191 if (reply
== notif_queue
)
194 prev
->next
= reply
->next
;
203 /* If there are more stop replies to push, push one now. */
206 send_next_stop_reply (char *own_buf
)
209 prepare_resume_reply (own_buf
,
211 ¬if_queue
->status
);
217 target_running (void)
219 return all_threads
.head
!= NULL
;
223 start_inferior (char **argv
)
225 char **new_argv
= argv
;
227 if (wrapper_argv
!= NULL
)
231 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
233 for (i
= 0; argv
[i
] != NULL
; i
++)
235 new_argv
= alloca (sizeof (char *) * count
);
237 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
238 new_argv
[count
++] = wrapper_argv
[i
];
239 for (i
= 0; argv
[i
] != NULL
; i
++)
240 new_argv
[count
++] = argv
[i
];
241 new_argv
[count
] = NULL
;
247 for (i
= 0; new_argv
[i
]; ++i
)
248 fprintf (stderr
, "new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
253 signal (SIGTTOU
, SIG_DFL
);
254 signal (SIGTTIN
, SIG_DFL
);
257 signal_pid
= create_inferior (new_argv
[0], new_argv
);
259 /* FIXME: we don't actually know at this point that the create
260 actually succeeded. We won't know that until we wait. */
261 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
266 signal (SIGTTOU
, SIG_IGN
);
267 signal (SIGTTIN
, SIG_IGN
);
268 terminal_fd
= fileno (stderr
);
269 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
270 tcsetpgrp (terminal_fd
, signal_pid
);
271 atexit (restore_old_foreground_pgrp
);
274 if (wrapper_argv
!= NULL
)
276 struct thread_resume resume_info
;
279 resume_info
.thread
= pid_to_ptid (signal_pid
);
280 resume_info
.kind
= resume_continue
;
283 ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
285 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
290 (*the_target
->resume
) (&resume_info
, 1);
292 mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
293 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
296 while (last_status
.value
.sig
!= TARGET_SIGNAL_TRAP
);
301 /* Wait till we are at 1st instruction in program, return new pid
302 (assuming success). */
303 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
309 attach_inferior (int pid
)
311 /* myattach should return -1 if attaching is unsupported,
312 0 if it succeeded, and call error() otherwise. */
314 if (myattach (pid
) != 0)
317 fprintf (stderr
, "Attached; pid = %d\n", pid
);
320 /* FIXME - It may be that we should get the SIGNAL_PID from the
321 attach function, so that it can be the main thread instead of
322 whichever we were told to attach to. */
327 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
329 /* GDB knows to ignore the first SIGSTOP after attaching to a running
330 process using the "attach" command, but this is different; it's
331 just using "target remote". Pretend it's just starting up. */
332 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
333 && last_status
.value
.sig
== TARGET_SIGNAL_STOP
)
334 last_status
.value
.sig
= TARGET_SIGNAL_TRAP
;
340 extern int remote_debug
;
342 /* Decode a qXfer read request. Return 0 if everything looks OK,
346 decode_xfer_read (char *buf
, char **annex
, CORE_ADDR
*ofs
, unsigned int *len
)
348 /* Extract and NUL-terminate the annex. */
350 while (*buf
&& *buf
!= ':')
356 /* After the read marker and annex, qXfer looks like a
357 traditional 'm' packet. */
358 decode_m_packet (buf
, ofs
, len
);
363 /* Write the response to a successful qXfer read. Returns the
364 length of the (binary) data stored in BUF, corresponding
365 to as much of DATA/LEN as we could fit. IS_MORE controls
366 the first character of the response. */
368 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
377 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
381 /* Handle all of the extended 'Q' packets. */
384 handle_general_set (char *own_buf
)
386 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
388 int numsigs
= (int) TARGET_SIGNAL_LAST
, i
;
389 const char *p
= own_buf
+ strlen ("QPassSignals:");
392 p
= decode_address_to_semicolon (&cursig
, p
);
393 for (i
= 0; i
< numsigs
; i
++)
399 /* Keep looping, to clear the remaining signals. */
402 p
= decode_address_to_semicolon (&cursig
, p
);
407 strcpy (own_buf
, "OK");
411 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
415 fprintf (stderr
, "[noack mode enabled]\n");
424 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
426 char *mode
= own_buf
+ 9;
430 if (strcmp (mode
, "0") == 0)
432 else if (strcmp (mode
, "1") == 0)
436 /* We don't know what this mode is, so complain to
438 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
444 req_str
= req
? "non-stop" : "all-stop";
445 if (start_non_stop (req
) != 0)
447 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
455 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
461 if (target_supports_tracepoints ()
462 && handle_tracepoint_general_set (own_buf
))
465 /* Otherwise we didn't know what packet it was. Say we didn't
471 get_features_xml (const char *annex
)
473 /* gdbserver_xmltarget defines what to return when looking
474 for the "target.xml" file. Its contents can either be
475 verbatim XML code (prefixed with a '@') or else the name
476 of the actual XML file to be used in place of "target.xml".
478 This variable is set up from the auto-generated
479 init_registers_... routine for the current target. */
481 if (gdbserver_xmltarget
482 && strcmp (annex
, "target.xml") == 0)
484 if (*gdbserver_xmltarget
== '@')
485 return gdbserver_xmltarget
+ 1;
487 annex
= gdbserver_xmltarget
;
492 extern const char *const xml_builtin
[][2];
495 /* Look for the annex. */
496 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
497 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
500 if (xml_builtin
[i
][0] != NULL
)
501 return xml_builtin
[i
][1];
509 monitor_show_help (void)
511 monitor_output ("The following monitor commands are supported:\n");
512 monitor_output (" set debug <0|1>\n");
513 monitor_output (" Enable general debugging messages\n");
514 monitor_output (" set debug-hw-points <0|1>\n");
515 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
516 monitor_output (" set remote-debug <0|1>\n");
517 monitor_output (" Enable remote protocol debugging messages\n");
518 monitor_output (" exit\n");
519 monitor_output (" Quit GDBserver\n");
522 /* Read trace frame or inferior memory. */
525 read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
527 if (current_traceframe
>= 0)
530 ULONGEST length
= len
;
532 if (traceframe_read_mem (current_traceframe
,
533 memaddr
, myaddr
, len
, &nbytes
))
535 /* Data read from trace buffer, we're done. */
536 if (nbytes
== length
)
538 if (!in_readonly_region (memaddr
, length
))
540 /* Otherwise we have a valid readonly case, fall through. */
541 /* (assume no half-trace half-real blocks for now) */
544 return read_inferior_memory (memaddr
, myaddr
, len
);
547 /* Write trace frame or inferior memory. Actually, writing to trace
548 frames is forbidden. */
551 write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
553 if (current_traceframe
>= 0)
556 return write_inferior_memory (memaddr
, myaddr
, len
);
559 /* Subroutine of handle_search_memory to simplify it. */
562 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
563 gdb_byte
*pattern
, unsigned pattern_len
,
564 gdb_byte
*search_buf
,
565 unsigned chunk_size
, unsigned search_buf_size
,
566 CORE_ADDR
*found_addrp
)
568 /* Prime the search buffer. */
570 if (read_memory (start_addr
, search_buf
, search_buf_size
) != 0)
572 warning ("Unable to access target memory at 0x%lx, halting search.",
577 /* Perform the search.
579 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
580 When we've scanned N bytes we copy the trailing bytes to the start and
581 read in another N bytes. */
583 while (search_space_len
>= pattern_len
)
586 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
590 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
592 if (found_ptr
!= NULL
)
594 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
595 *found_addrp
= found_addr
;
599 /* Not found in this chunk, skip to next chunk. */
601 /* Don't let search_space_len wrap here, it's unsigned. */
602 if (search_space_len
>= chunk_size
)
603 search_space_len
-= chunk_size
;
605 search_space_len
= 0;
607 if (search_space_len
>= pattern_len
)
609 unsigned keep_len
= search_buf_size
- chunk_size
;
610 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
613 /* Copy the trailing part of the previous iteration to the front
614 of the buffer for the next iteration. */
615 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
617 nr_to_read
= (search_space_len
- keep_len
< chunk_size
618 ? search_space_len
- keep_len
621 if (read_memory (read_addr
, search_buf
+ keep_len
,
624 warning ("Unable to access target memory at 0x%lx, halting search.",
629 start_addr
+= chunk_size
;
638 /* Handle qSearch:memory packets. */
641 handle_search_memory (char *own_buf
, int packet_len
)
643 CORE_ADDR start_addr
;
644 CORE_ADDR search_space_len
;
646 unsigned int pattern_len
;
647 /* NOTE: also defined in find.c testcase. */
648 #define SEARCH_CHUNK_SIZE 16000
649 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
650 /* Buffer to hold memory contents for searching. */
651 gdb_byte
*search_buf
;
652 unsigned search_buf_size
;
654 CORE_ADDR found_addr
;
655 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
657 pattern
= malloc (packet_len
);
660 error ("Unable to allocate memory to perform the search");
661 strcpy (own_buf
, "E00");
664 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
665 packet_len
- cmd_name_len
,
666 &start_addr
, &search_space_len
,
667 pattern
, &pattern_len
) < 0)
670 error ("Error in parsing qSearch:memory packet");
671 strcpy (own_buf
, "E00");
675 search_buf_size
= chunk_size
+ pattern_len
- 1;
677 /* No point in trying to allocate a buffer larger than the search space. */
678 if (search_space_len
< search_buf_size
)
679 search_buf_size
= search_space_len
;
681 search_buf
= malloc (search_buf_size
);
682 if (search_buf
== NULL
)
685 error ("Unable to allocate memory to perform the search");
686 strcpy (own_buf
, "E00");
690 found
= handle_search_memory_1 (start_addr
, search_space_len
,
691 pattern
, pattern_len
,
692 search_buf
, chunk_size
, search_buf_size
,
696 sprintf (own_buf
, "1,%lx", (long) found_addr
);
698 strcpy (own_buf
, "0");
700 strcpy (own_buf
, "E00");
706 #define require_running(BUF) \
707 if (!target_running ()) \
713 /* Handle monitor commands not handled by target-specific handlers. */
716 handle_monitor_command (char *mon
)
718 if (strcmp (mon
, "set debug 1") == 0)
721 monitor_output ("Debug output enabled.\n");
723 else if (strcmp (mon
, "set debug 0") == 0)
726 monitor_output ("Debug output disabled.\n");
728 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
731 monitor_output ("H/W point debugging output enabled.\n");
733 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
736 monitor_output ("H/W point debugging output disabled.\n");
738 else if (strcmp (mon
, "set remote-debug 1") == 0)
741 monitor_output ("Protocol debug output enabled.\n");
743 else if (strcmp (mon
, "set remote-debug 0") == 0)
746 monitor_output ("Protocol debug output disabled.\n");
748 else if (strcmp (mon
, "help") == 0)
749 monitor_show_help ();
750 else if (strcmp (mon
, "exit") == 0)
754 monitor_output ("Unknown monitor command.\n\n");
755 monitor_show_help ();
761 handle_threads_qxfer_proper (struct buffer
*buffer
)
763 struct inferior_list_entry
*thread
;
765 buffer_grow_str (buffer
, "<threads>\n");
767 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
769 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
774 write_ptid (ptid_s
, ptid
);
776 if (the_target
->core_of_thread
)
777 core
= (*the_target
->core_of_thread
) (ptid
);
781 sprintf (core_s
, "%d", core
);
782 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
787 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
792 buffer_grow_str0 (buffer
, "</threads>\n");
796 handle_threads_qxfer (const char *annex
,
797 unsigned char *readbuf
,
798 CORE_ADDR offset
, int length
)
800 static char *result
= 0;
801 static unsigned int result_length
= 0;
803 if (annex
&& strcmp (annex
, "") != 0)
808 struct buffer buffer
;
809 /* When asked for data at offset 0, generate everything and store into
810 'result'. Successive reads will be served off 'result'. */
814 buffer_init (&buffer
);
816 handle_threads_qxfer_proper (&buffer
);
818 result
= buffer_finish (&buffer
);
819 result_length
= strlen (result
);
820 buffer_free (&buffer
);
823 if (offset
>= result_length
)
825 /* We're out of data. */
832 if (length
> result_length
- offset
)
833 length
= result_length
- offset
;
835 memcpy (readbuf
, result
+ offset
, length
);
841 /* Table used by the crc32 function to calcuate the checksum. */
843 static unsigned int crc32_table
[256] =
846 /* Compute 32 bit CRC from inferior memory.
848 On success, return 32 bit CRC.
849 On failure, return (unsigned long long) -1. */
851 static unsigned long long
852 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
856 /* Initialize the CRC table and the decoding table. */
860 for (i
= 0; i
< 256; i
++)
862 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
863 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
870 unsigned char byte
= 0;
872 /* Return failure if memory read fails. */
873 if (read_inferior_memory (base
, &byte
, 1) != 0)
874 return (unsigned long long) -1;
876 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
879 return (unsigned long long) crc
;
882 /* Handle all of the extended 'q' packets. */
884 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
886 static struct inferior_list_entry
*thread_ptr
;
888 /* Reply the current thread id. */
889 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
892 require_running (own_buf
);
894 if (!ptid_equal (general_thread
, null_ptid
)
895 && !ptid_equal (general_thread
, minus_one_ptid
))
896 gdb_id
= general_thread
;
899 thread_ptr
= all_threads
.head
;
900 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
903 sprintf (own_buf
, "QC");
905 own_buf
= write_ptid (own_buf
, gdb_id
);
909 if (strcmp ("qSymbol::", own_buf
) == 0)
911 /* GDB is suggesting new symbols have been loaded. This may
912 mean a new shared library has been detected as loaded, so
913 take the opportunity to check if breakpoints we think are
914 inserted, still are. Note that it isn't guaranteed that
915 we'll see this when a shared library is loaded, and nor will
916 we see this for unloads (although breakpoints in unloaded
917 libraries shouldn't trigger), as GDB may not find symbols for
918 the library at all. We also re-validate breakpoints when we
919 see a second GDB breakpoint for the same address, and or when
920 we access breakpoint shadows. */
921 validate_breakpoints ();
923 if (target_supports_tracepoints ())
924 tracepoint_look_up_symbols ();
926 if (target_running () && the_target
->look_up_symbols
!= NULL
)
927 (*the_target
->look_up_symbols
) ();
929 strcpy (own_buf
, "OK");
933 if (!disable_packet_qfThreadInfo
)
935 if (strcmp ("qfThreadInfo", own_buf
) == 0)
939 require_running (own_buf
);
940 thread_ptr
= all_threads
.head
;
943 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
944 write_ptid (own_buf
, gdb_id
);
945 thread_ptr
= thread_ptr
->next
;
949 if (strcmp ("qsThreadInfo", own_buf
) == 0)
953 require_running (own_buf
);
954 if (thread_ptr
!= NULL
)
957 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
958 write_ptid (own_buf
, gdb_id
);
959 thread_ptr
= thread_ptr
->next
;
964 sprintf (own_buf
, "l");
970 if (the_target
->read_offsets
!= NULL
971 && strcmp ("qOffsets", own_buf
) == 0)
973 CORE_ADDR text
, data
;
975 require_running (own_buf
);
976 if (the_target
->read_offsets (&text
, &data
))
977 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
978 (long)text
, (long)data
, (long)data
);
985 if (the_target
->qxfer_spu
!= NULL
986 && strncmp ("qXfer:spu:read:", own_buf
, 15) == 0)
992 unsigned char *spu_buf
;
994 require_running (own_buf
);
995 strcpy (own_buf
, "E00");
996 if (decode_xfer_read (own_buf
+ 15, &annex
, &ofs
, &len
) < 0)
998 if (len
> PBUFSIZ
- 2)
1000 spu_buf
= malloc (len
+ 1);
1004 n
= (*the_target
->qxfer_spu
) (annex
, spu_buf
, NULL
, ofs
, len
+ 1);
1006 write_enn (own_buf
);
1008 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, len
, 1);
1010 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, n
, 0);
1016 if (the_target
->qxfer_spu
!= NULL
1017 && strncmp ("qXfer:spu:write:", own_buf
, 16) == 0)
1023 unsigned char *spu_buf
;
1025 require_running (own_buf
);
1026 strcpy (own_buf
, "E00");
1027 spu_buf
= malloc (packet_len
- 15);
1030 if (decode_xfer_write (own_buf
+ 16, packet_len
- 16, &annex
,
1031 &ofs
, &len
, spu_buf
) < 0)
1037 n
= (*the_target
->qxfer_spu
)
1038 (annex
, NULL
, (unsigned const char *)spu_buf
, ofs
, len
);
1040 write_enn (own_buf
);
1042 sprintf (own_buf
, "%x", n
);
1048 if (the_target
->read_auxv
!= NULL
1049 && strncmp ("qXfer:auxv:read:", own_buf
, 16) == 0)
1051 unsigned char *data
;
1057 require_running (own_buf
);
1059 /* Reject any annex; grab the offset and length. */
1060 if (decode_xfer_read (own_buf
+ 16, &annex
, &ofs
, &len
) < 0
1061 || annex
[0] != '\0')
1063 strcpy (own_buf
, "E00");
1067 /* Read one extra byte, as an indicator of whether there is
1069 if (len
> PBUFSIZ
- 2)
1071 data
= malloc (len
+ 1);
1074 write_enn (own_buf
);
1077 n
= (*the_target
->read_auxv
) (ofs
, data
, len
+ 1);
1079 write_enn (own_buf
);
1081 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1083 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1090 if (strncmp ("qXfer:features:read:", own_buf
, 20) == 0)
1093 unsigned int len
, total_len
;
1094 const char *document
;
1097 require_running (own_buf
);
1099 /* Grab the annex, offset, and length. */
1100 if (decode_xfer_read (own_buf
+ 20, &annex
, &ofs
, &len
) < 0)
1102 strcpy (own_buf
, "E00");
1106 /* Now grab the correct annex. */
1107 document
= get_features_xml (annex
);
1108 if (document
== NULL
)
1110 strcpy (own_buf
, "E00");
1114 total_len
= strlen (document
);
1115 if (len
> PBUFSIZ
- 2)
1118 if (ofs
> total_len
)
1119 write_enn (own_buf
);
1120 else if (len
< total_len
- ofs
)
1121 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1124 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1125 total_len
- ofs
, 0);
1130 if (strncmp ("qXfer:libraries:read:", own_buf
, 21) == 0)
1133 unsigned int len
, total_len
;
1135 struct inferior_list_entry
*dll_ptr
;
1138 require_running (own_buf
);
1140 /* Reject any annex; grab the offset and length. */
1141 if (decode_xfer_read (own_buf
+ 21, &annex
, &ofs
, &len
) < 0
1142 || annex
[0] != '\0')
1144 strcpy (own_buf
, "E00");
1148 /* Over-estimate the necessary memory. Assume that every character
1149 in the library name must be escaped. */
1151 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1152 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1154 document
= malloc (total_len
);
1155 if (document
== NULL
)
1157 write_enn (own_buf
);
1160 strcpy (document
, "<library-list>\n");
1161 p
= document
+ strlen (document
);
1163 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1165 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1168 strcpy (p
, " <library name=\"");
1170 name
= xml_escape_text (dll
->name
);
1174 strcpy (p
, "\"><segment address=\"");
1176 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1178 strcpy (p
, "\"/></library>\n");
1182 strcpy (p
, "</library-list>\n");
1184 total_len
= strlen (document
);
1185 if (len
> PBUFSIZ
- 2)
1188 if (ofs
> total_len
)
1189 write_enn (own_buf
);
1190 else if (len
< total_len
- ofs
)
1191 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1194 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1195 total_len
- ofs
, 0);
1201 if (the_target
->qxfer_osdata
!= NULL
1202 && strncmp ("qXfer:osdata:read:", own_buf
, 18) == 0)
1208 unsigned char *workbuf
;
1210 strcpy (own_buf
, "E00");
1211 if (decode_xfer_read (own_buf
+ 18, &annex
, &ofs
, &len
) < 0)
1213 if (len
> PBUFSIZ
- 2)
1215 workbuf
= malloc (len
+ 1);
1219 n
= (*the_target
->qxfer_osdata
) (annex
, workbuf
, NULL
, ofs
, len
+ 1);
1221 write_enn (own_buf
);
1223 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, len
, 1);
1225 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, n
, 0);
1231 if (the_target
->qxfer_siginfo
!= NULL
1232 && strncmp ("qXfer:siginfo:read:", own_buf
, 19) == 0)
1234 unsigned char *data
;
1240 require_running (own_buf
);
1242 /* Reject any annex; grab the offset and length. */
1243 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1244 || annex
[0] != '\0')
1246 strcpy (own_buf
, "E00");
1250 /* Read one extra byte, as an indicator of whether there is
1252 if (len
> PBUFSIZ
- 2)
1254 data
= malloc (len
+ 1);
1257 n
= (*the_target
->qxfer_siginfo
) (annex
, data
, NULL
, ofs
, len
+ 1);
1259 write_enn (own_buf
);
1261 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1263 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1269 if (the_target
->qxfer_siginfo
!= NULL
1270 && strncmp ("qXfer:siginfo:write:", own_buf
, 20) == 0)
1276 unsigned char *data
;
1278 require_running (own_buf
);
1280 strcpy (own_buf
, "E00");
1281 data
= malloc (packet_len
- 19);
1284 if (decode_xfer_write (own_buf
+ 20, packet_len
- 20, &annex
,
1285 &ofs
, &len
, data
) < 0)
1291 n
= (*the_target
->qxfer_siginfo
)
1292 (annex
, NULL
, (unsigned const char *)data
, ofs
, len
);
1294 write_enn (own_buf
);
1296 sprintf (own_buf
, "%x", n
);
1302 if (strncmp ("qXfer:threads:read:", own_buf
, 19) == 0)
1304 unsigned char *data
;
1310 require_running (own_buf
);
1312 /* Reject any annex; grab the offset and length. */
1313 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1314 || annex
[0] != '\0')
1316 strcpy (own_buf
, "E00");
1320 /* Read one extra byte, as an indicator of whether there is
1322 if (len
> PBUFSIZ
- 2)
1324 data
= malloc (len
+ 1);
1327 n
= handle_threads_qxfer (annex
, data
, ofs
, len
+ 1);
1329 write_enn (own_buf
);
1331 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1333 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1339 if (strncmp ("qXfer:statictrace:read:", own_buf
,
1340 sizeof ("qXfer:statictrace:read:") -1) == 0)
1342 unsigned char *data
;
1348 require_running (own_buf
);
1350 if (current_traceframe
== -1)
1352 write_enn (own_buf
);
1356 /* Reject any annex; grab the offset and length. */
1357 if (decode_xfer_read (own_buf
+ sizeof ("qXfer:statictrace:read:") -1,
1358 &annex
, &ofs
, &len
) < 0
1359 || annex
[0] != '\0')
1361 strcpy (own_buf
, "E00");
1365 /* Read one extra byte, as an indicator of whether there is
1367 if (len
> PBUFSIZ
- 2)
1369 data
= malloc (len
+ 1);
1373 if (traceframe_read_sdata (current_traceframe
, ofs
,
1374 data
, len
+ 1, &nbytes
))
1375 write_enn (own_buf
);
1376 else if (nbytes
> len
)
1377 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1379 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, nbytes
, 0);
1385 /* Protocol features query. */
1386 if (strncmp ("qSupported", own_buf
, 10) == 0
1387 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1389 char *p
= &own_buf
[10];
1390 int gdb_supports_qRelocInsn
= 0;
1392 /* Start processing qSupported packet. */
1393 target_process_qsupported (NULL
);
1395 /* Process each feature being provided by GDB. The first
1396 feature will follow a ':', and latter features will follow
1400 char **qsupported
= NULL
;
1404 /* Two passes, to avoid nested strtok calls in
1405 target_process_qsupported. */
1406 for (p
= strtok (p
+ 1, ";");
1408 p
= strtok (NULL
, ";"))
1411 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1412 qsupported
[count
- 1] = xstrdup (p
);
1415 for (i
= 0; i
< count
; i
++)
1418 if (strcmp (p
, "multiprocess+") == 0)
1420 /* GDB supports and wants multi-process support if
1422 if (target_supports_multi_process ())
1425 else if (strcmp (p
, "qRelocInsn+") == 0)
1427 /* GDB supports relocate instruction requests. */
1428 gdb_supports_qRelocInsn
= 1;
1431 target_process_qsupported (p
);
1439 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1441 /* We do not have any hook to indicate whether the target backend
1442 supports qXfer:libraries:read, so always report it. */
1443 strcat (own_buf
, ";qXfer:libraries:read+");
1445 if (the_target
->read_auxv
!= NULL
)
1446 strcat (own_buf
, ";qXfer:auxv:read+");
1448 if (the_target
->qxfer_spu
!= NULL
)
1449 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1451 if (the_target
->qxfer_siginfo
!= NULL
)
1452 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1454 /* We always report qXfer:features:read, as targets may
1455 install XML files on a subsequent call to arch_setup.
1456 If we reported to GDB on startup that we don't support
1457 qXfer:feature:read at all, we will never be re-queried. */
1458 strcat (own_buf
, ";qXfer:features:read+");
1460 if (transport_is_reliable
)
1461 strcat (own_buf
, ";QStartNoAckMode+");
1463 if (the_target
->qxfer_osdata
!= NULL
)
1464 strcat (own_buf
, ";qXfer:osdata:read+");
1466 if (target_supports_multi_process ())
1467 strcat (own_buf
, ";multiprocess+");
1469 if (target_supports_non_stop ())
1470 strcat (own_buf
, ";QNonStop+");
1472 strcat (own_buf
, ";qXfer:threads:read+");
1474 if (target_supports_tracepoints ())
1476 strcat (own_buf
, ";ConditionalTracepoints+");
1477 strcat (own_buf
, ";TraceStateVariables+");
1478 strcat (own_buf
, ";TracepointSource+");
1479 strcat (own_buf
, ";DisconnectedTracing+");
1480 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1481 strcat (own_buf
, ";FastTracepoints+");
1482 strcat (own_buf
, ";StaticTracepoints+");
1483 strcat (own_buf
, ";qXfer:statictrace:read+");
1489 /* Thread-local storage support. */
1490 if (the_target
->get_tls_address
!= NULL
1491 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1493 char *p
= own_buf
+ 12;
1494 CORE_ADDR parts
[2], address
= 0;
1496 ptid_t ptid
= null_ptid
;
1498 require_running (own_buf
);
1500 for (i
= 0; i
< 3; i
++)
1508 p2
= strchr (p
, ',');
1521 ptid
= read_ptid (p
, NULL
);
1523 decode_address (&parts
[i
- 1], p
, len
);
1527 if (p
!= NULL
|| i
< 3)
1531 struct thread_info
*thread
= find_thread_ptid (ptid
);
1536 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1542 strcpy (own_buf
, paddress(address
));
1547 write_enn (own_buf
);
1551 /* Otherwise, pretend we do not understand this packet. */
1554 /* Windows OS Thread Information Block address support. */
1555 if (the_target
->get_tib_address
!= NULL
1556 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1561 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1563 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1566 strcpy (own_buf
, paddress(tlb
));
1571 write_enn (own_buf
);
1577 /* Handle "monitor" commands. */
1578 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1580 char *mon
= malloc (PBUFSIZ
);
1581 int len
= strlen (own_buf
+ 6);
1585 write_enn (own_buf
);
1589 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1591 write_enn (own_buf
);
1595 mon
[len
/ 2] = '\0';
1599 if (the_target
->handle_monitor_command
== NULL
1600 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1601 /* Default processing. */
1602 handle_monitor_command (mon
);
1608 if (strncmp ("qSearch:memory:", own_buf
, sizeof ("qSearch:memory:") - 1) == 0)
1610 require_running (own_buf
);
1611 handle_search_memory (own_buf
, packet_len
);
1615 if (strcmp (own_buf
, "qAttached") == 0
1616 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1618 struct process_info
*process
;
1620 if (own_buf
[sizeof ("qAttached") - 1])
1622 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1623 process
= (struct process_info
*)
1624 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1628 require_running (own_buf
);
1629 process
= current_process ();
1632 if (process
== NULL
)
1634 write_enn (own_buf
);
1638 strcpy (own_buf
, process
->attached
? "1" : "0");
1642 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1644 /* CRC check (compare-section). */
1648 unsigned long long crc
;
1650 require_running (own_buf
);
1651 base
= strtoul (own_buf
+ 5, &comma
, 16);
1652 if (*comma
++ != ',')
1654 write_enn (own_buf
);
1657 len
= strtoul (comma
, NULL
, 16);
1658 crc
= crc32 (base
, len
, 0xffffffff);
1659 /* Check for memory failure. */
1660 if (crc
== (unsigned long long) -1)
1662 write_enn (own_buf
);
1665 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
1669 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
1672 /* Otherwise we didn't know what packet it was. Say we didn't
1677 static void gdb_wants_all_threads_stopped (void);
1679 /* Parse vCont packets. */
1681 handle_v_cont (char *own_buf
)
1685 struct thread_resume
*resume_info
;
1686 struct thread_resume default_action
= {{0}};
1688 /* Count the number of semicolons in the packet. There should be one
1689 for every action. */
1695 p
= strchr (p
, ';');
1698 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1699 if (resume_info
== NULL
)
1707 if (p
[0] == 's' || p
[0] == 'S')
1708 resume_info
[i
].kind
= resume_step
;
1709 else if (p
[0] == 'c' || p
[0] == 'C')
1710 resume_info
[i
].kind
= resume_continue
;
1711 else if (p
[0] == 't')
1712 resume_info
[i
].kind
= resume_stop
;
1716 if (p
[0] == 'S' || p
[0] == 'C')
1719 sig
= strtol (p
+ 1, &q
, 16);
1724 if (!target_signal_to_host_p (sig
))
1726 resume_info
[i
].sig
= target_signal_to_host (sig
);
1730 resume_info
[i
].sig
= 0;
1736 resume_info
[i
].thread
= minus_one_ptid
;
1737 default_action
= resume_info
[i
];
1739 /* Note: we don't increment i here, we'll overwrite this entry
1740 the next time through. */
1742 else if (p
[0] == ':')
1744 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1749 if (p
[0] != ';' && p
[0] != 0)
1752 resume_info
[i
].thread
= ptid
;
1759 resume_info
[i
] = default_action
;
1761 /* Still used in occasional places in the backend. */
1763 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1764 && resume_info
[0].kind
!= resume_stop
)
1765 cont_thread
= resume_info
[0].thread
;
1767 cont_thread
= minus_one_ptid
;
1768 set_desired_inferior (0);
1773 (*the_target
->resume
) (resume_info
, n
);
1781 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1783 /* From the client's perspective, all-stop mode always stops all
1784 threads implicitly (and the target backend has already done
1785 so by now). Tag all threads as "want-stopped", so we don't
1786 resume them implicitly without the client telling us to. */
1787 gdb_wants_all_threads_stopped ();
1788 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1789 disable_async_io ();
1791 if (last_status
.kind
== TARGET_WAITKIND_EXITED
1792 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
1793 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
1798 write_enn (own_buf
);
1803 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1805 handle_v_attach (char *own_buf
)
1809 pid
= strtol (own_buf
+ 8, NULL
, 16);
1810 if (pid
!= 0 && attach_inferior (pid
) == 0)
1812 /* Don't report shared library events after attaching, even if
1813 some libraries are preloaded. GDB will always poll the
1814 library list. Avoids the "stopped by shared library event"
1815 notice on the GDB side. */
1820 /* In non-stop, we don't send a resume reply. Stop events
1821 will follow up using the normal notification
1826 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1832 write_enn (own_buf
);
1837 /* Run a new program. Return 1 if successful, 0 if failure. */
1839 handle_v_run (char *own_buf
)
1841 char *p
, *next_p
, **new_argv
;
1845 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1851 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1852 if (new_argv
== NULL
)
1854 write_enn (own_buf
);
1859 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
1861 next_p
= strchr (p
, ';');
1863 next_p
= p
+ strlen (p
);
1865 if (i
== 0 && p
== next_p
)
1869 /* FIXME: Fail request if out of memory instead of dying. */
1870 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
1871 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
1872 new_argv
[i
][(next_p
- p
) / 2] = '\0';
1881 if (new_argv
[0] == NULL
)
1883 /* GDB didn't specify a program to run. Use the program from the
1884 last run with the new argument list. */
1886 if (program_argv
== NULL
)
1888 /* FIXME: new_argv memory leak */
1889 write_enn (own_buf
);
1893 new_argv
[0] = strdup (program_argv
[0]);
1894 if (new_argv
[0] == NULL
)
1896 /* FIXME: new_argv memory leak */
1897 write_enn (own_buf
);
1902 /* Free the old argv and install the new one. */
1903 freeargv (program_argv
);
1904 program_argv
= new_argv
;
1906 start_inferior (program_argv
);
1907 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
1909 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1911 /* In non-stop, sending a resume reply doesn't set the general
1912 thread, but GDB assumes a vRun sets it (this is so GDB can
1913 query which is the main thread of the new inferior. */
1915 general_thread
= last_ptid
;
1921 write_enn (own_buf
);
1926 /* Kill process. Return 1 if successful, 0 if failure. */
1928 handle_v_kill (char *own_buf
)
1931 char *p
= &own_buf
[6];
1933 pid
= strtol (p
, NULL
, 16);
1936 if (pid
!= 0 && kill_inferior (pid
) == 0)
1938 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1939 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
1940 last_ptid
= pid_to_ptid (pid
);
1941 discard_queued_stop_replies (pid
);
1947 write_enn (own_buf
);
1952 /* Handle a 'vStopped' packet. */
1954 handle_v_stopped (char *own_buf
)
1956 /* If we're waiting for GDB to acknowledge a pending stop reply,
1957 consider that done. */
1960 struct vstop_notif
*head
;
1963 fprintf (stderr
, "vStopped: acking %s\n",
1964 target_pid_to_str (notif_queue
->ptid
));
1967 notif_queue
= notif_queue
->next
;
1971 /* Push another stop reply, or if there are no more left, an OK. */
1972 send_next_stop_reply (own_buf
);
1975 /* Handle all of the extended 'v' packets. */
1977 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
1979 if (!disable_packet_vCont
)
1981 if (strncmp (own_buf
, "vCont;", 6) == 0)
1983 require_running (own_buf
);
1984 handle_v_cont (own_buf
);
1988 if (strncmp (own_buf
, "vCont?", 6) == 0)
1990 strcpy (own_buf
, "vCont;c;C;s;S;t");
1995 if (strncmp (own_buf
, "vFile:", 6) == 0
1996 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
1999 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2001 if (!multi_process
&& target_running ())
2003 fprintf (stderr
, "Already debugging a process\n");
2004 write_enn (own_buf
);
2007 handle_v_attach (own_buf
);
2011 if (strncmp (own_buf
, "vRun;", 5) == 0)
2013 if (!multi_process
&& target_running ())
2015 fprintf (stderr
, "Already debugging a process\n");
2016 write_enn (own_buf
);
2019 handle_v_run (own_buf
);
2023 if (strncmp (own_buf
, "vKill;", 6) == 0)
2025 if (!target_running ())
2027 fprintf (stderr
, "No process to kill\n");
2028 write_enn (own_buf
);
2031 handle_v_kill (own_buf
);
2035 if (strncmp (own_buf
, "vStopped", 8) == 0)
2037 handle_v_stopped (own_buf
);
2041 /* Otherwise we didn't know what packet it was. Say we didn't
2047 /* Resume inferior and wait for another event. In non-stop mode,
2048 don't really wait here, but return immediatelly to the event
2051 myresume (char *own_buf
, int step
, int sig
)
2053 struct thread_resume resume_info
[2];
2055 int valid_cont_thread
;
2057 set_desired_inferior (0);
2059 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2060 && !ptid_equal (cont_thread
, minus_one_ptid
));
2062 if (step
|| sig
|| valid_cont_thread
)
2064 resume_info
[0].thread
2065 = ((struct inferior_list_entry
*) current_inferior
)->id
;
2067 resume_info
[0].kind
= resume_step
;
2069 resume_info
[0].kind
= resume_continue
;
2070 resume_info
[0].sig
= sig
;
2074 if (!valid_cont_thread
)
2076 resume_info
[n
].thread
= minus_one_ptid
;
2077 resume_info
[n
].kind
= resume_continue
;
2078 resume_info
[n
].sig
= 0;
2085 (*the_target
->resume
) (resume_info
, n
);
2091 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2092 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2093 disable_async_io ();
2095 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2096 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2097 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2101 /* Callback for for_each_inferior. Make a new stop reply for each
2105 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2107 struct thread_info
*thread
= (struct thread_info
*) entry
;
2109 /* For now, assume targets that don't have this callback also don't
2110 manage the thread's last_status field. */
2111 if (the_target
->thread_stopped
== NULL
)
2113 struct target_waitstatus status
;
2115 status
.kind
= TARGET_WAITKIND_STOPPED
;
2116 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
2118 /* Pass the last stop reply back to GDB, but don't notify
2120 queue_stop_reply (entry
->id
, &thread
->last_status
);
2124 if (thread_stopped (thread
))
2127 fprintf (stderr
, "Reporting thread %s as already stopped with %s\n",
2128 target_pid_to_str (entry
->id
),
2129 target_waitstatus_to_string (&thread
->last_status
));
2131 /* Pass the last stop reply back to GDB, but don't notify
2133 queue_stop_reply (entry
->id
, &thread
->last_status
);
2140 /* Set this inferior threads's state as "want-stopped". We won't
2141 resume this thread until the client gives us another action for
2145 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2147 struct thread_info
*thread
= (struct thread_info
*) entry
;
2149 thread
->last_resume_kind
= resume_stop
;
2151 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2153 /* Most threads are stopped implicitly (all-stop); tag that with
2155 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2156 thread
->last_status
.value
.sig
= TARGET_SIGNAL_0
;
2160 /* Set all threads' states as "want-stopped". */
2163 gdb_wants_all_threads_stopped (void)
2165 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2168 /* Clear the gdb_detached flag of every process. */
2171 gdb_reattached_process (struct inferior_list_entry
*entry
)
2173 struct process_info
*process
= (struct process_info
*) entry
;
2175 process
->gdb_detached
= 0;
2178 /* Status handler for the '?' packet. */
2181 handle_status (char *own_buf
)
2183 /* GDB is connected, don't forward events to the target anymore. */
2184 for_each_inferior (&all_processes
, gdb_reattached_process
);
2186 /* In non-stop mode, we must send a stop reply for each stopped
2187 thread. In all-stop mode, just send one for the first stopped
2192 discard_queued_stop_replies (-1);
2193 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2195 /* The first is sent immediatly. OK is sent if there is no
2196 stopped thread, which is the same handling of the vStopped
2197 packet (by design). */
2198 send_next_stop_reply (own_buf
);
2203 stabilize_threads ();
2204 gdb_wants_all_threads_stopped ();
2206 if (all_threads
.head
)
2208 struct target_waitstatus status
;
2210 status
.kind
= TARGET_WAITKIND_STOPPED
;
2211 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
2212 prepare_resume_reply (own_buf
,
2213 all_threads
.head
->id
, &status
);
2216 strcpy (own_buf
, "W00");
2221 gdbserver_version (void)
2223 printf ("GNU gdbserver %s%s\n"
2224 "Copyright (C) 2010 Free Software Foundation, Inc.\n"
2225 "gdbserver is free software, covered by the GNU General Public License.\n"
2226 "This gdbserver was configured as \"%s\"\n",
2227 PKGVERSION
, version
, host_name
);
2231 gdbserver_usage (FILE *stream
)
2233 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2234 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2235 "\tgdbserver [OPTIONS] --multi COMM\n"
2237 "COMM may either be a tty device (for serial debugging), or \n"
2238 "HOST:PORT to listen for a TCP connection.\n"
2241 " --debug Enable general debugging output.\n"
2242 " --remote-debug Enable remote protocol debugging output.\n"
2243 " --version Display version information and exit.\n"
2244 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
2245 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2246 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2250 gdbserver_show_disableable (FILE *stream
)
2252 fprintf (stream
, "Disableable packets:\n"
2253 " vCont \tAll vCont packets\n"
2254 " qC \tQuerying the current thread\n"
2255 " qfThreadInfo\tThread listing\n"
2256 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
2257 " threads \tAll of the above\n");
2261 #undef require_running
2262 #define require_running(BUF) \
2263 if (!target_running ()) \
2270 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2272 int pid
= * (int *) args
;
2274 if (ptid_get_pid (entry
->id
) == pid
)
2281 kill_inferior_callback (struct inferior_list_entry
*entry
)
2283 struct process_info
*process
= (struct process_info
*) entry
;
2284 int pid
= ptid_get_pid (process
->head
.id
);
2286 kill_inferior (pid
);
2287 discard_queued_stop_replies (pid
);
2290 /* Callback for for_each_inferior to detach or kill the inferior,
2291 depending on whether we attached to it or not.
2292 We inform the user whether we're detaching or killing the process
2293 as this is only called when gdbserver is about to exit. */
2296 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2298 struct process_info
*process
= (struct process_info
*) entry
;
2299 int pid
= ptid_get_pid (process
->head
.id
);
2301 if (process
->attached
)
2302 detach_inferior (pid
);
2304 kill_inferior (pid
);
2306 discard_queued_stop_replies (pid
);
2309 /* for_each_inferior callback for detach_or_kill_for_exit to print
2310 the pids of started inferiors. */
2313 print_started_pid (struct inferior_list_entry
*entry
)
2315 struct process_info
*process
= (struct process_info
*) entry
;
2317 if (! process
->attached
)
2319 int pid
= ptid_get_pid (process
->head
.id
);
2320 fprintf (stderr
, " %d", pid
);
2324 /* for_each_inferior callback for detach_or_kill_for_exit to print
2325 the pids of attached inferiors. */
2328 print_attached_pid (struct inferior_list_entry
*entry
)
2330 struct process_info
*process
= (struct process_info
*) entry
;
2332 if (process
->attached
)
2334 int pid
= ptid_get_pid (process
->head
.id
);
2335 fprintf (stderr
, " %d", pid
);
2339 /* Call this when exiting gdbserver with possible inferiors that need
2340 to be killed or detached from. */
2343 detach_or_kill_for_exit (void)
2345 /* First print a list of the inferiors we will be killing/detaching.
2346 This is to assist the user, for example, in case the inferior unexpectedly
2347 dies after we exit: did we screw up or did the inferior exit on its own?
2348 Having this info will save some head-scratching. */
2350 if (have_started_inferiors_p ())
2352 fprintf (stderr
, "Killing process(es):");
2353 for_each_inferior (&all_processes
, print_started_pid
);
2354 fprintf (stderr
, "\n");
2356 if (have_attached_inferiors_p ())
2358 fprintf (stderr
, "Detaching process(es):");
2359 for_each_inferior (&all_processes
, print_attached_pid
);
2360 fprintf (stderr
, "\n");
2363 /* Now we can kill or detach the inferiors. */
2365 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2369 join_inferiors_callback (struct inferior_list_entry
*entry
)
2371 struct process_info
*process
= (struct process_info
*) entry
;
2373 /* If we are attached, then we can exit. Otherwise, we need to hang
2374 around doing nothing, until the child is gone. */
2375 if (!process
->attached
)
2376 join_inferior (ptid_get_pid (process
->head
.id
));
2380 main (int argc
, char *argv
[])
2384 char *arg_end
, *port
;
2385 char **next_arg
= &argv
[1];
2390 while (*next_arg
!= NULL
&& **next_arg
== '-')
2392 if (strcmp (*next_arg
, "--version") == 0)
2394 gdbserver_version ();
2397 else if (strcmp (*next_arg
, "--help") == 0)
2399 gdbserver_usage (stdout
);
2402 else if (strcmp (*next_arg
, "--attach") == 0)
2404 else if (strcmp (*next_arg
, "--multi") == 0)
2406 else if (strcmp (*next_arg
, "--wrapper") == 0)
2410 wrapper_argv
= next_arg
;
2411 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2414 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2416 gdbserver_usage (stderr
);
2420 /* Consume the "--". */
2423 else if (strcmp (*next_arg
, "--debug") == 0)
2425 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2427 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2429 gdbserver_show_disableable (stdout
);
2432 else if (strncmp (*next_arg
,
2433 "--disable-packet=",
2434 sizeof ("--disable-packet=") - 1) == 0)
2436 char *packets
, *tok
;
2438 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2439 for (tok
= strtok (packets
, ",");
2441 tok
= strtok (NULL
, ","))
2443 if (strcmp ("vCont", tok
) == 0)
2444 disable_packet_vCont
= 1;
2445 else if (strcmp ("Tthread", tok
) == 0)
2446 disable_packet_Tthread
= 1;
2447 else if (strcmp ("qC", tok
) == 0)
2448 disable_packet_qC
= 1;
2449 else if (strcmp ("qfThreadInfo", tok
) == 0)
2450 disable_packet_qfThreadInfo
= 1;
2451 else if (strcmp ("threads", tok
) == 0)
2453 disable_packet_vCont
= 1;
2454 disable_packet_Tthread
= 1;
2455 disable_packet_qC
= 1;
2456 disable_packet_qfThreadInfo
= 1;
2460 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2462 gdbserver_show_disableable (stderr
);
2469 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2477 if (setjmp (toplevel
))
2479 fprintf (stderr
, "Exiting\n");
2485 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2487 gdbserver_usage (stderr
);
2494 /* --attach used to come after PORT, so allow it there for
2496 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2503 && (*next_arg
== NULL
2504 || (*next_arg
)[0] == '\0'
2505 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2507 || next_arg
[1] != NULL
))
2512 gdbserver_usage (stderr
);
2516 initialize_inferiors ();
2517 initialize_async_io ();
2519 if (target_supports_tracepoints ())
2520 initialize_tracepoint ();
2522 own_buf
= xmalloc (PBUFSIZ
+ 1);
2523 mem_buf
= xmalloc (PBUFSIZ
);
2525 if (pid
== 0 && *next_arg
!= NULL
)
2529 n
= argc
- (next_arg
- argv
);
2530 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2531 for (i
= 0; i
< n
; i
++)
2532 program_argv
[i
] = xstrdup (next_arg
[i
]);
2533 program_argv
[i
] = NULL
;
2535 /* Wait till we are at first instruction in program. */
2536 start_inferior (program_argv
);
2538 /* We are now (hopefully) stopped at the first instruction of
2539 the target process. This assumes that the target process was
2540 successfully created. */
2544 if (attach_inferior (pid
) == -1)
2545 error ("Attaching not supported on this target");
2547 /* Otherwise succeeded. */
2551 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2552 last_status
.value
.integer
= 0;
2553 last_ptid
= minus_one_ptid
;
2556 /* Don't report shared library events on the initial connection,
2557 even if some libraries are preloaded. Avoids the "stopped by
2558 shared library event" notice on gdb side. */
2561 if (setjmp (toplevel
))
2563 detach_or_kill_for_exit ();
2567 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2568 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2573 if (!was_running
&& !multi_mode
)
2575 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2583 /* Be sure we're out of tfind mode. */
2584 current_traceframe
= -1;
2588 if (setjmp (toplevel
) != 0)
2590 /* An error occurred. */
2591 if (response_needed
)
2593 write_enn (own_buf
);
2598 /* Wait for events. This will return when all event sources are
2599 removed from the event loop. */
2600 start_event_loop ();
2602 /* If an exit was requested (using the "monitor exit" command),
2603 terminate now. The only other way to get here is for
2604 getpkt to fail; close the connection and reopen it at the
2609 detach_or_kill_for_exit ();
2614 "Remote side has terminated connection. "
2615 "GDBserver will reopen the connection.\n");
2619 if (disconnected_tracing
)
2621 /* Try to enable non-stop/async mode, so we we can both
2622 wait for an async socket accept, and handle async
2623 target events simultaneously. There's also no point
2624 either in having the target always stop all threads,
2625 when we're going to pass signals down without
2629 if (start_non_stop (1))
2632 /* Detaching implicitly resumes all threads; simply
2633 disconnecting does not. */
2639 "Disconnected tracing disabled; stopping trace run.\n");
2646 /* Event loop callback that handles a serial event. The first byte in
2647 the serial buffer gets us here. We expect characters to arrive at
2648 a brisk pace, so we read the rest of the packet with a blocking
2652 process_serial_event (void)
2662 int new_packet_len
= -1;
2664 /* Used to decide when gdbserver should exit in
2665 multi-mode/remote. */
2666 static int have_ran
= 0;
2669 have_ran
= target_running ();
2671 disable_async_io ();
2673 response_needed
= 0;
2674 packet_len
= getpkt (own_buf
);
2675 if (packet_len
<= 0)
2678 /* Force an event loop break. */
2681 response_needed
= 1;
2688 handle_query (own_buf
, packet_len
, &new_packet_len
);
2691 handle_general_set (own_buf
);
2694 require_running (own_buf
);
2699 pid
= strtol (&own_buf
[i
], NULL
, 16);
2703 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2705 if (tracing
&& disconnected_tracing
)
2707 struct thread_resume resume_info
;
2708 struct process_info
*process
= find_process_pid (pid
);
2710 if (process
== NULL
)
2712 write_enn (own_buf
);
2717 "Disconnected tracing in effect, "
2718 "leaving gdbserver attached to the process\n");
2720 /* Make sure we're in non-stop/async mode, so we we can both
2721 wait for an async socket accept, and handle async target
2722 events simultaneously. There's also no point either in
2723 having the target stop all threads, when we're going to
2724 pass signals down without informing GDB. */
2728 fprintf (stderr
, "Forcing non-stop mode\n");
2734 process
->gdb_detached
= 1;
2736 /* Detaching implicitly resumes all threads. */
2737 resume_info
.thread
= minus_one_ptid
;
2738 resume_info
.kind
= resume_continue
;
2739 resume_info
.sig
= 0;
2740 (*the_target
->resume
) (&resume_info
, 1);
2743 break; /* from switch/case */
2746 fprintf (stderr
, "Detaching from process %d\n", pid
);
2748 if (detach_inferior (pid
) != 0)
2749 write_enn (own_buf
);
2752 discard_queued_stop_replies (pid
);
2755 if (extended_protocol
)
2757 /* Treat this like a normal program exit. */
2758 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2759 last_status
.value
.integer
= 0;
2760 last_ptid
= pid_to_ptid (pid
);
2762 current_inferior
= NULL
;
2769 /* If we are attached, then we can exit. Otherwise, we
2770 need to hang around doing nothing, until the child is
2772 for_each_inferior (&all_processes
,
2773 join_inferiors_callback
);
2779 extended_protocol
= 1;
2783 handle_status (own_buf
);
2786 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2788 ptid_t gdb_id
, thread_id
;
2791 require_running (own_buf
);
2793 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2795 pid
= ptid_get_pid (gdb_id
);
2797 if (ptid_equal (gdb_id
, null_ptid
)
2798 || ptid_equal (gdb_id
, minus_one_ptid
))
2799 thread_id
= null_ptid
;
2801 && ptid_equal (pid_to_ptid (pid
),
2804 struct thread_info
*thread
=
2805 (struct thread_info
*) find_inferior (&all_threads
,
2810 write_enn (own_buf
);
2814 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2818 thread_id
= gdb_id_to_thread_id (gdb_id
);
2819 if (ptid_equal (thread_id
, null_ptid
))
2821 write_enn (own_buf
);
2826 if (own_buf
[1] == 'g')
2828 if (ptid_equal (thread_id
, null_ptid
))
2830 /* GDB is telling us to choose any thread. Check if
2831 the currently selected thread is still valid. If
2832 it is not, select the first available. */
2833 struct thread_info
*thread
=
2834 (struct thread_info
*) find_inferior_id (&all_threads
,
2837 thread_id
= all_threads
.head
->id
;
2840 general_thread
= thread_id
;
2841 set_desired_inferior (1);
2843 else if (own_buf
[1] == 'c')
2844 cont_thread
= thread_id
;
2845 else if (own_buf
[1] == 's')
2846 step_thread
= thread_id
;
2852 /* Silently ignore it so that gdb can extend the protocol
2853 without compatibility headaches. */
2858 require_running (own_buf
);
2859 if (current_traceframe
>= 0)
2861 struct regcache
*regcache
= new_register_cache ();
2863 if (fetch_traceframe_registers (current_traceframe
,
2865 registers_to_string (regcache
, own_buf
);
2867 write_enn (own_buf
);
2868 free_register_cache (regcache
);
2872 struct regcache
*regcache
;
2874 set_desired_inferior (1);
2875 regcache
= get_thread_regcache (current_inferior
, 1);
2876 registers_to_string (regcache
, own_buf
);
2880 require_running (own_buf
);
2881 if (current_traceframe
>= 0)
2882 write_enn (own_buf
);
2885 struct regcache
*regcache
;
2887 set_desired_inferior (1);
2888 regcache
= get_thread_regcache (current_inferior
, 1);
2889 registers_from_string (regcache
, &own_buf
[1]);
2894 require_running (own_buf
);
2895 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
2896 if (read_memory (mem_addr
, mem_buf
, len
) == 0)
2897 convert_int_to_ascii (mem_buf
, own_buf
, len
);
2899 write_enn (own_buf
);
2902 require_running (own_buf
);
2903 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
2904 if (write_memory (mem_addr
, mem_buf
, len
) == 0)
2907 write_enn (own_buf
);
2910 require_running (own_buf
);
2911 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
2912 &mem_addr
, &len
, &mem_buf
) < 0
2913 || write_memory (mem_addr
, mem_buf
, len
) != 0)
2914 write_enn (own_buf
);
2919 require_running (own_buf
);
2920 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2921 if (target_signal_to_host_p (sig
))
2922 signal
= target_signal_to_host (sig
);
2925 myresume (own_buf
, 0, signal
);
2928 require_running (own_buf
);
2929 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2930 if (target_signal_to_host_p (sig
))
2931 signal
= target_signal_to_host (sig
);
2934 myresume (own_buf
, 1, signal
);
2937 require_running (own_buf
);
2939 myresume (own_buf
, 0, signal
);
2942 require_running (own_buf
);
2944 myresume (own_buf
, 1, signal
);
2946 case 'Z': /* insert_ ... */
2948 case 'z': /* remove_ ... */
2952 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
2953 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
2954 char type
= own_buf
[1];
2956 const int insert
= ch
== 'Z';
2958 /* Default to unrecognized/unsupported. */
2962 case '0': /* software-breakpoint */
2963 case '1': /* hardware-breakpoint */
2964 case '2': /* write watchpoint */
2965 case '3': /* read watchpoint */
2966 case '4': /* access watchpoint */
2967 require_running (own_buf
);
2968 if (insert
&& the_target
->insert_point
!= NULL
)
2969 res
= (*the_target
->insert_point
) (type
, addr
, len
);
2970 else if (!insert
&& the_target
->remove_point
!= NULL
)
2971 res
= (*the_target
->remove_point
) (type
, addr
, len
);
2983 write_enn (own_buf
);
2987 response_needed
= 0;
2988 if (!target_running ())
2989 /* The packet we received doesn't make sense - but we can't
2990 reply to it, either. */
2993 fprintf (stderr
, "Killing all inferiors\n");
2994 for_each_inferior (&all_processes
, kill_inferior_callback
);
2996 /* When using the extended protocol, we wait with no program
2997 running. The traditional protocol will exit instead. */
2998 if (extended_protocol
)
3000 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3001 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
3009 ptid_t gdb_id
, thread_id
;
3011 require_running (own_buf
);
3013 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3014 thread_id
= gdb_id_to_thread_id (gdb_id
);
3015 if (ptid_equal (thread_id
, null_ptid
))
3017 write_enn (own_buf
);
3021 if (mythread_alive (thread_id
))
3024 write_enn (own_buf
);
3028 response_needed
= 0;
3030 /* Restarting the inferior is only supported in the extended
3032 if (extended_protocol
)
3034 if (target_running ())
3035 for_each_inferior (&all_processes
,
3036 kill_inferior_callback
);
3037 fprintf (stderr
, "GDBserver restarting\n");
3039 /* Wait till we are at 1st instruction in prog. */
3040 if (program_argv
!= NULL
)
3041 start_inferior (program_argv
);
3044 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3045 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
3051 /* It is a request we don't understand. Respond with an
3052 empty packet so that gdb knows that we don't support this
3058 /* Extended (long) request. */
3059 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3063 /* It is a request we don't understand. Respond with an empty
3064 packet so that gdb knows that we don't support this
3070 if (new_packet_len
!= -1)
3071 putpkt_binary (own_buf
, new_packet_len
);
3075 response_needed
= 0;
3077 if (!extended_protocol
&& have_ran
&& !target_running ())
3079 /* In non-stop, defer exiting until GDB had a chance to query
3080 the whole vStopped list (until it gets an OK). */
3083 fprintf (stderr
, "GDBserver exiting\n");
3095 /* Event-loop callback for serial events. */
3098 handle_serial_event (int err
, gdb_client_data client_data
)
3101 fprintf (stderr
, "handling possible serial event\n");
3103 /* Really handle it. */
3104 if (process_serial_event () < 0)
3107 /* Be sure to not change the selected inferior behind GDB's back.
3108 Important in the non-stop mode asynchronous protocol. */
3109 set_desired_inferior (1);
3114 /* Event-loop callback for target events. */
3117 handle_target_event (int err
, gdb_client_data client_data
)
3120 fprintf (stderr
, "handling possible target event\n");
3122 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3125 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3127 int pid
= ptid_get_pid (last_ptid
);
3128 struct process_info
*process
= find_process_pid (pid
);
3129 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3131 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3132 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3134 mark_breakpoints_out (process
);
3135 mourn_inferior (process
);
3138 /* We're reporting this thread as stopped. Update it's
3139 "want-stopped" state to what the client wants, until it gets
3140 a new resume action. */
3141 gdb_wants_thread_stopped (¤t_inferior
->entry
);
3145 if (!target_running ())
3147 /* The last process exited. We're done. */
3151 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3153 /* A thread stopped with a signal, but gdb isn't
3154 connected to handle it. Pass it down to the
3155 inferior, as if it wasn't being traced. */
3156 struct thread_resume resume_info
;
3160 "GDB not connected; forwarding event %d for [%s]\n",
3161 (int) last_status
.kind
,
3162 target_pid_to_str (last_ptid
));
3164 resume_info
.thread
= last_ptid
;
3165 resume_info
.kind
= resume_continue
;
3166 resume_info
.sig
= target_signal_to_host (last_status
.value
.sig
);
3167 (*the_target
->resume
) (&resume_info
, 1);
3169 else if (debug_threads
)
3170 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3171 (int) last_status
.kind
,
3172 target_pid_to_str (last_ptid
));
3176 /* Something interesting. Tell GDB about it. */
3177 push_event (last_ptid
, &last_status
);
3181 /* Be sure to not change the selected inferior behind GDB's back.
3182 Important in the non-stop mode asynchronous protocol. */
3183 set_desired_inferior (1);