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
;
245 signal (SIGTTOU
, SIG_DFL
);
246 signal (SIGTTIN
, SIG_DFL
);
249 signal_pid
= create_inferior (new_argv
[0], new_argv
);
251 /* FIXME: we don't actually know at this point that the create
252 actually succeeded. We won't know that until we wait. */
253 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
258 signal (SIGTTOU
, SIG_IGN
);
259 signal (SIGTTIN
, SIG_IGN
);
260 terminal_fd
= fileno (stderr
);
261 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
262 tcsetpgrp (terminal_fd
, signal_pid
);
263 atexit (restore_old_foreground_pgrp
);
266 if (wrapper_argv
!= NULL
)
268 struct thread_resume resume_info
;
271 resume_info
.thread
= pid_to_ptid (signal_pid
);
272 resume_info
.kind
= resume_continue
;
275 ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
277 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
282 (*the_target
->resume
) (&resume_info
, 1);
284 mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
285 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
288 while (last_status
.value
.sig
!= TARGET_SIGNAL_TRAP
);
293 /* Wait till we are at 1st instruction in program, return new pid
294 (assuming success). */
295 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
301 attach_inferior (int pid
)
303 /* myattach should return -1 if attaching is unsupported,
304 0 if it succeeded, and call error() otherwise. */
306 if (myattach (pid
) != 0)
309 fprintf (stderr
, "Attached; pid = %d\n", pid
);
312 /* FIXME - It may be that we should get the SIGNAL_PID from the
313 attach function, so that it can be the main thread instead of
314 whichever we were told to attach to. */
319 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
321 /* GDB knows to ignore the first SIGSTOP after attaching to a running
322 process using the "attach" command, but this is different; it's
323 just using "target remote". Pretend it's just starting up. */
324 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
325 && last_status
.value
.sig
== TARGET_SIGNAL_STOP
)
326 last_status
.value
.sig
= TARGET_SIGNAL_TRAP
;
332 extern int remote_debug
;
334 /* Decode a qXfer read request. Return 0 if everything looks OK,
338 decode_xfer_read (char *buf
, char **annex
, CORE_ADDR
*ofs
, unsigned int *len
)
340 /* Extract and NUL-terminate the annex. */
342 while (*buf
&& *buf
!= ':')
348 /* After the read marker and annex, qXfer looks like a
349 traditional 'm' packet. */
350 decode_m_packet (buf
, ofs
, len
);
355 /* Write the response to a successful qXfer read. Returns the
356 length of the (binary) data stored in BUF, corresponding
357 to as much of DATA/LEN as we could fit. IS_MORE controls
358 the first character of the response. */
360 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
369 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
373 /* Handle all of the extended 'Q' packets. */
375 handle_general_set (char *own_buf
)
377 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
379 int numsigs
= (int) TARGET_SIGNAL_LAST
, i
;
380 const char *p
= own_buf
+ strlen ("QPassSignals:");
383 p
= decode_address_to_semicolon (&cursig
, p
);
384 for (i
= 0; i
< numsigs
; i
++)
390 /* Keep looping, to clear the remaining signals. */
393 p
= decode_address_to_semicolon (&cursig
, p
);
398 strcpy (own_buf
, "OK");
402 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
406 fprintf (stderr
, "[noack mode enabled]\n");
415 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
417 char *mode
= own_buf
+ 9;
421 if (strcmp (mode
, "0") == 0)
423 else if (strcmp (mode
, "1") == 0)
427 /* We don't know what this mode is, so complain to
429 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
435 req_str
= req
? "non-stop" : "all-stop";
436 if (start_non_stop (req
) != 0)
438 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
446 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
452 if (target_supports_tracepoints ()
453 && handle_tracepoint_general_set (own_buf
))
456 /* Otherwise we didn't know what packet it was. Say we didn't
462 get_features_xml (const char *annex
)
464 /* gdbserver_xmltarget defines what to return when looking
465 for the "target.xml" file. Its contents can either be
466 verbatim XML code (prefixed with a '@') or else the name
467 of the actual XML file to be used in place of "target.xml".
469 This variable is set up from the auto-generated
470 init_registers_... routine for the current target. */
472 if (gdbserver_xmltarget
473 && strcmp (annex
, "target.xml") == 0)
475 if (*gdbserver_xmltarget
== '@')
476 return gdbserver_xmltarget
+ 1;
478 annex
= gdbserver_xmltarget
;
483 extern const char *const xml_builtin
[][2];
486 /* Look for the annex. */
487 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
488 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
491 if (xml_builtin
[i
][0] != NULL
)
492 return xml_builtin
[i
][1];
500 monitor_show_help (void)
502 monitor_output ("The following monitor commands are supported:\n");
503 monitor_output (" set debug <0|1>\n");
504 monitor_output (" Enable general debugging messages\n");
505 monitor_output (" set debug-hw-points <0|1>\n");
506 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
507 monitor_output (" set remote-debug <0|1>\n");
508 monitor_output (" Enable remote protocol debugging messages\n");
509 monitor_output (" exit\n");
510 monitor_output (" Quit GDBserver\n");
513 /* Read trace frame or inferior memory. */
516 read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
518 if (current_traceframe
>= 0)
521 ULONGEST length
= len
;
523 if (traceframe_read_mem (current_traceframe
,
524 memaddr
, myaddr
, len
, &nbytes
))
526 /* Data read from trace buffer, we're done. */
527 if (nbytes
== length
)
529 if (!in_readonly_region (memaddr
, length
))
531 /* Otherwise we have a valid readonly case, fall through. */
532 /* (assume no half-trace half-real blocks for now) */
535 return read_inferior_memory (memaddr
, myaddr
, len
);
538 /* Write trace frame or inferior memory. Actually, writing to trace
539 frames is forbidden. */
542 write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
544 if (current_traceframe
>= 0)
547 return write_inferior_memory (memaddr
, myaddr
, len
);
550 /* Subroutine of handle_search_memory to simplify it. */
553 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
554 gdb_byte
*pattern
, unsigned pattern_len
,
555 gdb_byte
*search_buf
,
556 unsigned chunk_size
, unsigned search_buf_size
,
557 CORE_ADDR
*found_addrp
)
559 /* Prime the search buffer. */
561 if (read_memory (start_addr
, search_buf
, search_buf_size
) != 0)
563 warning ("Unable to access target memory at 0x%lx, halting search.",
568 /* Perform the search.
570 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
571 When we've scanned N bytes we copy the trailing bytes to the start and
572 read in another N bytes. */
574 while (search_space_len
>= pattern_len
)
577 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
581 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
583 if (found_ptr
!= NULL
)
585 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
586 *found_addrp
= found_addr
;
590 /* Not found in this chunk, skip to next chunk. */
592 /* Don't let search_space_len wrap here, it's unsigned. */
593 if (search_space_len
>= chunk_size
)
594 search_space_len
-= chunk_size
;
596 search_space_len
= 0;
598 if (search_space_len
>= pattern_len
)
600 unsigned keep_len
= search_buf_size
- chunk_size
;
601 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
604 /* Copy the trailing part of the previous iteration to the front
605 of the buffer for the next iteration. */
606 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
608 nr_to_read
= (search_space_len
- keep_len
< chunk_size
609 ? search_space_len
- keep_len
612 if (read_memory (read_addr
, search_buf
+ keep_len
,
615 warning ("Unable to access target memory at 0x%lx, halting search.",
620 start_addr
+= chunk_size
;
629 /* Handle qSearch:memory packets. */
632 handle_search_memory (char *own_buf
, int packet_len
)
634 CORE_ADDR start_addr
;
635 CORE_ADDR search_space_len
;
637 unsigned int pattern_len
;
638 /* NOTE: also defined in find.c testcase. */
639 #define SEARCH_CHUNK_SIZE 16000
640 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
641 /* Buffer to hold memory contents for searching. */
642 gdb_byte
*search_buf
;
643 unsigned search_buf_size
;
645 CORE_ADDR found_addr
;
646 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
648 pattern
= malloc (packet_len
);
651 error ("Unable to allocate memory to perform the search");
652 strcpy (own_buf
, "E00");
655 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
656 packet_len
- cmd_name_len
,
657 &start_addr
, &search_space_len
,
658 pattern
, &pattern_len
) < 0)
661 error ("Error in parsing qSearch:memory packet");
662 strcpy (own_buf
, "E00");
666 search_buf_size
= chunk_size
+ pattern_len
- 1;
668 /* No point in trying to allocate a buffer larger than the search space. */
669 if (search_space_len
< search_buf_size
)
670 search_buf_size
= search_space_len
;
672 search_buf
= malloc (search_buf_size
);
673 if (search_buf
== NULL
)
676 error ("Unable to allocate memory to perform the search");
677 strcpy (own_buf
, "E00");
681 found
= handle_search_memory_1 (start_addr
, search_space_len
,
682 pattern
, pattern_len
,
683 search_buf
, chunk_size
, search_buf_size
,
687 sprintf (own_buf
, "1,%lx", (long) found_addr
);
689 strcpy (own_buf
, "0");
691 strcpy (own_buf
, "E00");
697 #define require_running(BUF) \
698 if (!target_running ()) \
704 /* Handle monitor commands not handled by target-specific handlers. */
707 handle_monitor_command (char *mon
)
709 if (strcmp (mon
, "set debug 1") == 0)
712 monitor_output ("Debug output enabled.\n");
714 else if (strcmp (mon
, "set debug 0") == 0)
717 monitor_output ("Debug output disabled.\n");
719 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
722 monitor_output ("H/W point debugging output enabled.\n");
724 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
727 monitor_output ("H/W point debugging output disabled.\n");
729 else if (strcmp (mon
, "set remote-debug 1") == 0)
732 monitor_output ("Protocol debug output enabled.\n");
734 else if (strcmp (mon
, "set remote-debug 0") == 0)
737 monitor_output ("Protocol debug output disabled.\n");
739 else if (strcmp (mon
, "help") == 0)
740 monitor_show_help ();
741 else if (strcmp (mon
, "exit") == 0)
745 monitor_output ("Unknown monitor command.\n\n");
746 monitor_show_help ();
752 handle_threads_qxfer_proper (struct buffer
*buffer
)
754 struct inferior_list_entry
*thread
;
756 buffer_grow_str (buffer
, "<threads>\n");
758 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
760 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
765 write_ptid (ptid_s
, ptid
);
767 if (the_target
->core_of_thread
)
768 core
= (*the_target
->core_of_thread
) (ptid
);
772 sprintf (core_s
, "%d", core
);
773 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
778 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
783 buffer_grow_str0 (buffer
, "</threads>\n");
787 handle_threads_qxfer (const char *annex
,
788 unsigned char *readbuf
,
789 CORE_ADDR offset
, int length
)
791 static char *result
= 0;
792 static unsigned int result_length
= 0;
794 if (annex
&& strcmp (annex
, "") != 0)
799 struct buffer buffer
;
800 /* When asked for data at offset 0, generate everything and store into
801 'result'. Successive reads will be served off 'result'. */
805 buffer_init (&buffer
);
807 handle_threads_qxfer_proper (&buffer
);
809 result
= buffer_finish (&buffer
);
810 result_length
= strlen (result
);
811 buffer_free (&buffer
);
814 if (offset
>= result_length
)
816 /* We're out of data. */
823 if (length
> result_length
- offset
)
824 length
= result_length
- offset
;
826 memcpy (readbuf
, result
+ offset
, length
);
832 /* Table used by the crc32 function to calcuate the checksum. */
834 static unsigned int crc32_table
[256] =
837 /* Compute 32 bit CRC from inferior memory.
839 On success, return 32 bit CRC.
840 On failure, return (unsigned long long) -1. */
842 static unsigned long long
843 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
847 /* Initialize the CRC table and the decoding table. */
851 for (i
= 0; i
< 256; i
++)
853 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
854 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
861 unsigned char byte
= 0;
863 /* Return failure if memory read fails. */
864 if (read_inferior_memory (base
, &byte
, 1) != 0)
865 return (unsigned long long) -1;
867 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
870 return (unsigned long long) crc
;
873 /* Handle all of the extended 'q' packets. */
875 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
877 static struct inferior_list_entry
*thread_ptr
;
879 /* Reply the current thread id. */
880 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
883 require_running (own_buf
);
885 if (!ptid_equal (general_thread
, null_ptid
)
886 && !ptid_equal (general_thread
, minus_one_ptid
))
887 gdb_id
= general_thread
;
890 thread_ptr
= all_threads
.head
;
891 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
894 sprintf (own_buf
, "QC");
896 own_buf
= write_ptid (own_buf
, gdb_id
);
900 if (strcmp ("qSymbol::", own_buf
) == 0)
902 /* GDB is suggesting new symbols have been loaded. This may
903 mean a new shared library has been detected as loaded, so
904 take the opportunity to check if breakpoints we think are
905 inserted, still are. Note that it isn't guaranteed that
906 we'll see this when a shared library is loaded, and nor will
907 we see this for unloads (although breakpoints in unloaded
908 libraries shouldn't trigger), as GDB may not find symbols for
909 the library at all. We also re-validate breakpoints when we
910 see a second GDB breakpoint for the same address, and or when
911 we access breakpoint shadows. */
912 validate_breakpoints ();
914 if (target_running () && the_target
->look_up_symbols
!= NULL
)
915 (*the_target
->look_up_symbols
) ();
917 strcpy (own_buf
, "OK");
921 if (!disable_packet_qfThreadInfo
)
923 if (strcmp ("qfThreadInfo", own_buf
) == 0)
927 require_running (own_buf
);
928 thread_ptr
= all_threads
.head
;
931 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
932 write_ptid (own_buf
, gdb_id
);
933 thread_ptr
= thread_ptr
->next
;
937 if (strcmp ("qsThreadInfo", own_buf
) == 0)
941 require_running (own_buf
);
942 if (thread_ptr
!= NULL
)
945 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
946 write_ptid (own_buf
, gdb_id
);
947 thread_ptr
= thread_ptr
->next
;
952 sprintf (own_buf
, "l");
958 if (the_target
->read_offsets
!= NULL
959 && strcmp ("qOffsets", own_buf
) == 0)
961 CORE_ADDR text
, data
;
963 require_running (own_buf
);
964 if (the_target
->read_offsets (&text
, &data
))
965 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
966 (long)text
, (long)data
, (long)data
);
973 if (the_target
->qxfer_spu
!= NULL
974 && strncmp ("qXfer:spu:read:", own_buf
, 15) == 0)
980 unsigned char *spu_buf
;
982 require_running (own_buf
);
983 strcpy (own_buf
, "E00");
984 if (decode_xfer_read (own_buf
+ 15, &annex
, &ofs
, &len
) < 0)
986 if (len
> PBUFSIZ
- 2)
988 spu_buf
= malloc (len
+ 1);
992 n
= (*the_target
->qxfer_spu
) (annex
, spu_buf
, NULL
, ofs
, len
+ 1);
996 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, len
, 1);
998 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, n
, 0);
1004 if (the_target
->qxfer_spu
!= NULL
1005 && strncmp ("qXfer:spu:write:", own_buf
, 16) == 0)
1011 unsigned char *spu_buf
;
1013 require_running (own_buf
);
1014 strcpy (own_buf
, "E00");
1015 spu_buf
= malloc (packet_len
- 15);
1018 if (decode_xfer_write (own_buf
+ 16, packet_len
- 16, &annex
,
1019 &ofs
, &len
, spu_buf
) < 0)
1025 n
= (*the_target
->qxfer_spu
)
1026 (annex
, NULL
, (unsigned const char *)spu_buf
, ofs
, len
);
1028 write_enn (own_buf
);
1030 sprintf (own_buf
, "%x", n
);
1036 if (the_target
->read_auxv
!= NULL
1037 && strncmp ("qXfer:auxv:read:", own_buf
, 16) == 0)
1039 unsigned char *data
;
1045 require_running (own_buf
);
1047 /* Reject any annex; grab the offset and length. */
1048 if (decode_xfer_read (own_buf
+ 16, &annex
, &ofs
, &len
) < 0
1049 || annex
[0] != '\0')
1051 strcpy (own_buf
, "E00");
1055 /* Read one extra byte, as an indicator of whether there is
1057 if (len
> PBUFSIZ
- 2)
1059 data
= malloc (len
+ 1);
1062 write_enn (own_buf
);
1065 n
= (*the_target
->read_auxv
) (ofs
, data
, len
+ 1);
1067 write_enn (own_buf
);
1069 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1071 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1078 if (strncmp ("qXfer:features:read:", own_buf
, 20) == 0)
1081 unsigned int len
, total_len
;
1082 const char *document
;
1085 require_running (own_buf
);
1087 /* Grab the annex, offset, and length. */
1088 if (decode_xfer_read (own_buf
+ 20, &annex
, &ofs
, &len
) < 0)
1090 strcpy (own_buf
, "E00");
1094 /* Now grab the correct annex. */
1095 document
= get_features_xml (annex
);
1096 if (document
== NULL
)
1098 strcpy (own_buf
, "E00");
1102 total_len
= strlen (document
);
1103 if (len
> PBUFSIZ
- 2)
1106 if (ofs
> total_len
)
1107 write_enn (own_buf
);
1108 else if (len
< total_len
- ofs
)
1109 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1112 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1113 total_len
- ofs
, 0);
1118 if (strncmp ("qXfer:libraries:read:", own_buf
, 21) == 0)
1121 unsigned int len
, total_len
;
1123 struct inferior_list_entry
*dll_ptr
;
1126 require_running (own_buf
);
1128 /* Reject any annex; grab the offset and length. */
1129 if (decode_xfer_read (own_buf
+ 21, &annex
, &ofs
, &len
) < 0
1130 || annex
[0] != '\0')
1132 strcpy (own_buf
, "E00");
1136 /* Over-estimate the necessary memory. Assume that every character
1137 in the library name must be escaped. */
1139 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1140 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1142 document
= malloc (total_len
);
1143 if (document
== NULL
)
1145 write_enn (own_buf
);
1148 strcpy (document
, "<library-list>\n");
1149 p
= document
+ strlen (document
);
1151 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1153 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1156 strcpy (p
, " <library name=\"");
1158 name
= xml_escape_text (dll
->name
);
1162 strcpy (p
, "\"><segment address=\"");
1164 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1166 strcpy (p
, "\"/></library>\n");
1170 strcpy (p
, "</library-list>\n");
1172 total_len
= strlen (document
);
1173 if (len
> PBUFSIZ
- 2)
1176 if (ofs
> total_len
)
1177 write_enn (own_buf
);
1178 else if (len
< total_len
- ofs
)
1179 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1182 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1183 total_len
- ofs
, 0);
1189 if (the_target
->qxfer_osdata
!= NULL
1190 && strncmp ("qXfer:osdata:read:", own_buf
, 18) == 0)
1196 unsigned char *workbuf
;
1198 strcpy (own_buf
, "E00");
1199 if (decode_xfer_read (own_buf
+ 18, &annex
, &ofs
, &len
) < 0)
1201 if (len
> PBUFSIZ
- 2)
1203 workbuf
= malloc (len
+ 1);
1207 n
= (*the_target
->qxfer_osdata
) (annex
, workbuf
, NULL
, ofs
, len
+ 1);
1209 write_enn (own_buf
);
1211 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, len
, 1);
1213 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, n
, 0);
1219 if (the_target
->qxfer_siginfo
!= NULL
1220 && strncmp ("qXfer:siginfo:read:", own_buf
, 19) == 0)
1222 unsigned char *data
;
1228 require_running (own_buf
);
1230 /* Reject any annex; grab the offset and length. */
1231 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1232 || annex
[0] != '\0')
1234 strcpy (own_buf
, "E00");
1238 /* Read one extra byte, as an indicator of whether there is
1240 if (len
> PBUFSIZ
- 2)
1242 data
= malloc (len
+ 1);
1245 n
= (*the_target
->qxfer_siginfo
) (annex
, data
, NULL
, ofs
, len
+ 1);
1247 write_enn (own_buf
);
1249 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1251 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1257 if (the_target
->qxfer_siginfo
!= NULL
1258 && strncmp ("qXfer:siginfo:write:", own_buf
, 20) == 0)
1264 unsigned char *data
;
1266 require_running (own_buf
);
1268 strcpy (own_buf
, "E00");
1269 data
= malloc (packet_len
- 19);
1272 if (decode_xfer_write (own_buf
+ 20, packet_len
- 20, &annex
,
1273 &ofs
, &len
, data
) < 0)
1279 n
= (*the_target
->qxfer_siginfo
)
1280 (annex
, NULL
, (unsigned const char *)data
, ofs
, len
);
1282 write_enn (own_buf
);
1284 sprintf (own_buf
, "%x", n
);
1290 if (strncmp ("qXfer:threads:read:", own_buf
, 19) == 0)
1292 unsigned char *data
;
1298 require_running (own_buf
);
1300 /* Reject any annex; grab the offset and length. */
1301 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1302 || annex
[0] != '\0')
1304 strcpy (own_buf
, "E00");
1308 /* Read one extra byte, as an indicator of whether there is
1310 if (len
> PBUFSIZ
- 2)
1312 data
= malloc (len
+ 1);
1315 n
= handle_threads_qxfer (annex
, data
, ofs
, len
+ 1);
1317 write_enn (own_buf
);
1319 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1321 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1327 /* Protocol features query. */
1328 if (strncmp ("qSupported", own_buf
, 10) == 0
1329 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1331 char *p
= &own_buf
[10];
1333 /* Start processing qSupported packet. */
1334 target_process_qsupported (NULL
);
1336 /* Process each feature being provided by GDB. The first
1337 feature will follow a ':', and latter features will follow
1340 for (p
= strtok (p
+ 1, ";");
1342 p
= strtok (NULL
, ";"))
1344 if (strcmp (p
, "multiprocess+") == 0)
1346 /* GDB supports and wants multi-process support if
1348 if (target_supports_multi_process ())
1352 target_process_qsupported (p
);
1355 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1357 /* We do not have any hook to indicate whether the target backend
1358 supports qXfer:libraries:read, so always report it. */
1359 strcat (own_buf
, ";qXfer:libraries:read+");
1361 if (the_target
->read_auxv
!= NULL
)
1362 strcat (own_buf
, ";qXfer:auxv:read+");
1364 if (the_target
->qxfer_spu
!= NULL
)
1365 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1367 if (the_target
->qxfer_siginfo
!= NULL
)
1368 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1370 /* We always report qXfer:features:read, as targets may
1371 install XML files on a subsequent call to arch_setup.
1372 If we reported to GDB on startup that we don't support
1373 qXfer:feature:read at all, we will never be re-queried. */
1374 strcat (own_buf
, ";qXfer:features:read+");
1376 if (transport_is_reliable
)
1377 strcat (own_buf
, ";QStartNoAckMode+");
1379 if (the_target
->qxfer_osdata
!= NULL
)
1380 strcat (own_buf
, ";qXfer:osdata:read+");
1382 if (target_supports_multi_process ())
1383 strcat (own_buf
, ";multiprocess+");
1385 if (target_supports_non_stop ())
1386 strcat (own_buf
, ";QNonStop+");
1388 strcat (own_buf
, ";qXfer:threads:read+");
1390 if (target_supports_tracepoints ())
1392 strcat (own_buf
, ";ConditionalTracepoints+");
1393 strcat (own_buf
, ";TraceStateVariables+");
1394 strcat (own_buf
, ";TracepointSource+");
1395 strcat (own_buf
, ";DisconnectedTracing+");
1401 /* Thread-local storage support. */
1402 if (the_target
->get_tls_address
!= NULL
1403 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1405 char *p
= own_buf
+ 12;
1406 CORE_ADDR parts
[2], address
= 0;
1408 ptid_t ptid
= null_ptid
;
1410 require_running (own_buf
);
1412 for (i
= 0; i
< 3; i
++)
1420 p2
= strchr (p
, ',');
1433 ptid
= read_ptid (p
, NULL
);
1435 decode_address (&parts
[i
- 1], p
, len
);
1439 if (p
!= NULL
|| i
< 3)
1443 struct thread_info
*thread
= find_thread_ptid (ptid
);
1448 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1454 sprintf (own_buf
, "%llx", address
);
1459 write_enn (own_buf
);
1463 /* Otherwise, pretend we do not understand this packet. */
1466 /* Handle "monitor" commands. */
1467 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1469 char *mon
= malloc (PBUFSIZ
);
1470 int len
= strlen (own_buf
+ 6);
1474 write_enn (own_buf
);
1478 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1480 write_enn (own_buf
);
1484 mon
[len
/ 2] = '\0';
1488 if (the_target
->handle_monitor_command
== NULL
1489 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1490 /* Default processing. */
1491 handle_monitor_command (mon
);
1497 if (strncmp ("qSearch:memory:", own_buf
, sizeof ("qSearch:memory:") - 1) == 0)
1499 require_running (own_buf
);
1500 handle_search_memory (own_buf
, packet_len
);
1504 if (strcmp (own_buf
, "qAttached") == 0
1505 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1507 struct process_info
*process
;
1509 if (own_buf
[sizeof ("qAttached") - 1])
1511 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1512 process
= (struct process_info
*)
1513 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1517 require_running (own_buf
);
1518 process
= current_process ();
1521 if (process
== NULL
)
1523 write_enn (own_buf
);
1527 strcpy (own_buf
, process
->attached
? "1" : "0");
1531 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1533 /* CRC check (compare-section). */
1537 unsigned long long crc
;
1539 require_running (own_buf
);
1540 base
= strtoul (own_buf
+ 5, &comma
, 16);
1541 if (*comma
++ != ',')
1543 write_enn (own_buf
);
1546 len
= strtoul (comma
, NULL
, 16);
1547 crc
= crc32 (base
, len
, 0xffffffff);
1548 /* Check for memory failure. */
1549 if (crc
== (unsigned long long) -1)
1551 write_enn (own_buf
);
1554 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
1558 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
1561 /* Otherwise we didn't know what packet it was. Say we didn't
1566 /* Parse vCont packets. */
1568 handle_v_cont (char *own_buf
)
1572 struct thread_resume
*resume_info
;
1573 struct thread_resume default_action
= {{0}};
1575 /* Count the number of semicolons in the packet. There should be one
1576 for every action. */
1582 p
= strchr (p
, ';');
1585 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1586 if (resume_info
== NULL
)
1594 if (p
[0] == 's' || p
[0] == 'S')
1595 resume_info
[i
].kind
= resume_step
;
1596 else if (p
[0] == 'c' || p
[0] == 'C')
1597 resume_info
[i
].kind
= resume_continue
;
1598 else if (p
[0] == 't')
1599 resume_info
[i
].kind
= resume_stop
;
1603 if (p
[0] == 'S' || p
[0] == 'C')
1606 sig
= strtol (p
+ 1, &q
, 16);
1611 if (!target_signal_to_host_p (sig
))
1613 resume_info
[i
].sig
= target_signal_to_host (sig
);
1617 resume_info
[i
].sig
= 0;
1623 resume_info
[i
].thread
= minus_one_ptid
;
1624 default_action
= resume_info
[i
];
1626 /* Note: we don't increment i here, we'll overwrite this entry
1627 the next time through. */
1629 else if (p
[0] == ':')
1631 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1636 if (p
[0] != ';' && p
[0] != 0)
1639 resume_info
[i
].thread
= ptid
;
1646 resume_info
[i
] = default_action
;
1648 /* Still used in occasional places in the backend. */
1650 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1651 && resume_info
[0].kind
!= resume_stop
)
1652 cont_thread
= resume_info
[0].thread
;
1654 cont_thread
= minus_one_ptid
;
1655 set_desired_inferior (0);
1660 (*the_target
->resume
) (resume_info
, n
);
1668 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1669 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1670 disable_async_io ();
1675 write_enn (own_buf
);
1680 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1682 handle_v_attach (char *own_buf
)
1686 pid
= strtol (own_buf
+ 8, NULL
, 16);
1687 if (pid
!= 0 && attach_inferior (pid
) == 0)
1689 /* Don't report shared library events after attaching, even if
1690 some libraries are preloaded. GDB will always poll the
1691 library list. Avoids the "stopped by shared library event"
1692 notice on the GDB side. */
1697 /* In non-stop, we don't send a resume reply. Stop events
1698 will follow up using the normal notification
1703 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1709 write_enn (own_buf
);
1714 /* Run a new program. Return 1 if successful, 0 if failure. */
1716 handle_v_run (char *own_buf
)
1718 char *p
, *next_p
, **new_argv
;
1722 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1728 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1729 if (new_argv
== NULL
)
1731 write_enn (own_buf
);
1736 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
1738 next_p
= strchr (p
, ';');
1740 next_p
= p
+ strlen (p
);
1742 if (i
== 0 && p
== next_p
)
1746 /* FIXME: Fail request if out of memory instead of dying. */
1747 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
1748 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
1749 new_argv
[i
][(next_p
- p
) / 2] = '\0';
1758 if (new_argv
[0] == NULL
)
1760 /* GDB didn't specify a program to run. Use the program from the
1761 last run with the new argument list. */
1763 if (program_argv
== NULL
)
1765 /* FIXME: new_argv memory leak */
1766 write_enn (own_buf
);
1770 new_argv
[0] = strdup (program_argv
[0]);
1771 if (new_argv
[0] == NULL
)
1773 /* FIXME: new_argv memory leak */
1774 write_enn (own_buf
);
1779 /* Free the old argv and install the new one. */
1780 freeargv (program_argv
);
1781 program_argv
= new_argv
;
1783 start_inferior (program_argv
);
1784 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
1786 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1788 /* In non-stop, sending a resume reply doesn't set the general
1789 thread, but GDB assumes a vRun sets it (this is so GDB can
1790 query which is the main thread of the new inferior. */
1792 general_thread
= last_ptid
;
1798 write_enn (own_buf
);
1803 /* Kill process. Return 1 if successful, 0 if failure. */
1805 handle_v_kill (char *own_buf
)
1808 char *p
= &own_buf
[6];
1810 pid
= strtol (p
, NULL
, 16);
1813 if (pid
!= 0 && kill_inferior (pid
) == 0)
1815 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1816 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
1817 last_ptid
= pid_to_ptid (pid
);
1818 discard_queued_stop_replies (pid
);
1824 write_enn (own_buf
);
1829 /* Handle a 'vStopped' packet. */
1831 handle_v_stopped (char *own_buf
)
1833 /* If we're waiting for GDB to acknowledge a pending stop reply,
1834 consider that done. */
1837 struct vstop_notif
*head
;
1840 fprintf (stderr
, "vStopped: acking %s\n",
1841 target_pid_to_str (notif_queue
->ptid
));
1844 notif_queue
= notif_queue
->next
;
1848 /* Push another stop reply, or if there are no more left, an OK. */
1849 send_next_stop_reply (own_buf
);
1852 /* Handle all of the extended 'v' packets. */
1854 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
1856 if (!disable_packet_vCont
)
1858 if (strncmp (own_buf
, "vCont;", 6) == 0)
1860 require_running (own_buf
);
1861 handle_v_cont (own_buf
);
1865 if (strncmp (own_buf
, "vCont?", 6) == 0)
1867 strcpy (own_buf
, "vCont;c;C;s;S;t");
1872 if (strncmp (own_buf
, "vFile:", 6) == 0
1873 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
1876 if (strncmp (own_buf
, "vAttach;", 8) == 0)
1878 if (!multi_process
&& target_running ())
1880 fprintf (stderr
, "Already debugging a process\n");
1881 write_enn (own_buf
);
1884 handle_v_attach (own_buf
);
1888 if (strncmp (own_buf
, "vRun;", 5) == 0)
1890 if (!multi_process
&& target_running ())
1892 fprintf (stderr
, "Already debugging a process\n");
1893 write_enn (own_buf
);
1896 handle_v_run (own_buf
);
1900 if (strncmp (own_buf
, "vKill;", 6) == 0)
1902 if (!target_running ())
1904 fprintf (stderr
, "No process to kill\n");
1905 write_enn (own_buf
);
1908 handle_v_kill (own_buf
);
1912 if (strncmp (own_buf
, "vStopped", 8) == 0)
1914 handle_v_stopped (own_buf
);
1918 /* Otherwise we didn't know what packet it was. Say we didn't
1924 /* Resume inferior and wait for another event. In non-stop mode,
1925 don't really wait here, but return immediatelly to the event
1928 myresume (char *own_buf
, int step
, int sig
)
1930 struct thread_resume resume_info
[2];
1932 int valid_cont_thread
;
1934 set_desired_inferior (0);
1936 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
1937 && !ptid_equal (cont_thread
, minus_one_ptid
));
1939 if (step
|| sig
|| valid_cont_thread
)
1941 resume_info
[0].thread
1942 = ((struct inferior_list_entry
*) current_inferior
)->id
;
1944 resume_info
[0].kind
= resume_step
;
1946 resume_info
[0].kind
= resume_continue
;
1947 resume_info
[0].sig
= sig
;
1951 if (!valid_cont_thread
)
1953 resume_info
[n
].thread
= minus_one_ptid
;
1954 resume_info
[n
].kind
= resume_continue
;
1955 resume_info
[n
].sig
= 0;
1962 (*the_target
->resume
) (resume_info
, n
);
1968 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1969 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1970 disable_async_io ();
1974 /* Callback for for_each_inferior. Make a new stop reply for each
1978 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
1980 struct thread_info
*thread
= (struct thread_info
*) entry
;
1982 /* For now, assume targets that don't have this callback also don't
1983 manage the thread's last_status field. */
1984 if (the_target
->thread_stopped
== NULL
)
1986 struct target_waitstatus status
;
1988 status
.kind
= TARGET_WAITKIND_STOPPED
;
1989 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1991 /* Pass the last stop reply back to GDB, but don't notify
1993 queue_stop_reply (entry
->id
, &thread
->last_status
);
1997 if (thread_stopped (thread
))
2000 fprintf (stderr
, "Reporting thread %s as already stopped with %s\n",
2001 target_pid_to_str (entry
->id
),
2002 target_waitstatus_to_string (&thread
->last_status
));
2004 /* Pass the last stop reply back to GDB, but don't notify
2006 queue_stop_reply (entry
->id
, &thread
->last_status
);
2013 /* Set this inferior LWP's state as "want-stopped". We won't resume
2014 this LWP until the client gives us another action for it. */
2017 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2019 struct thread_info
*thread
= (struct thread_info
*) entry
;
2021 thread
->last_resume_kind
= resume_stop
;
2023 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2025 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2026 thread
->last_status
.value
.sig
= TARGET_SIGNAL_0
;
2030 /* Set all threads' states as "want-stopped". */
2033 gdb_wants_all_threads_stopped (void)
2035 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2038 /* Clear the gdb_detached flag of every process. */
2041 gdb_reattached_process (struct inferior_list_entry
*entry
)
2043 struct process_info
*process
= (struct process_info
*) entry
;
2045 process
->gdb_detached
= 0;
2048 /* Status handler for the '?' packet. */
2051 handle_status (char *own_buf
)
2053 /* GDB is connected, don't forward events to the target anymore. */
2054 for_each_inferior (&all_processes
, gdb_reattached_process
);
2056 /* In non-stop mode, we must send a stop reply for each stopped
2057 thread. In all-stop mode, just send one for the first stopped
2062 discard_queued_stop_replies (-1);
2063 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2065 /* The first is sent immediatly. OK is sent if there is no
2066 stopped thread, which is the same handling of the vStopped
2067 packet (by design). */
2068 send_next_stop_reply (own_buf
);
2073 gdb_wants_all_threads_stopped ();
2075 if (all_threads
.head
)
2077 struct target_waitstatus status
;
2079 status
.kind
= TARGET_WAITKIND_STOPPED
;
2080 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
2081 prepare_resume_reply (own_buf
,
2082 all_threads
.head
->id
, &status
);
2085 strcpy (own_buf
, "W00");
2090 gdbserver_version (void)
2092 printf ("GNU gdbserver %s%s\n"
2093 "Copyright (C) 2010 Free Software Foundation, Inc.\n"
2094 "gdbserver is free software, covered by the GNU General Public License.\n"
2095 "This gdbserver was configured as \"%s\"\n",
2096 PKGVERSION
, version
, host_name
);
2100 gdbserver_usage (FILE *stream
)
2102 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2103 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2104 "\tgdbserver [OPTIONS] --multi COMM\n"
2106 "COMM may either be a tty device (for serial debugging), or \n"
2107 "HOST:PORT to listen for a TCP connection.\n"
2110 " --debug Enable general debugging output.\n"
2111 " --remote-debug Enable remote protocol debugging output.\n"
2112 " --version Display version information and exit.\n"
2113 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
2114 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2115 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2119 gdbserver_show_disableable (FILE *stream
)
2121 fprintf (stream
, "Disableable packets:\n"
2122 " vCont \tAll vCont packets\n"
2123 " qC \tQuerying the current thread\n"
2124 " qfThreadInfo\tThread listing\n"
2125 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
2126 " threads \tAll of the above\n");
2130 #undef require_running
2131 #define require_running(BUF) \
2132 if (!target_running ()) \
2139 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2141 int pid
= * (int *) args
;
2143 if (ptid_get_pid (entry
->id
) == pid
)
2150 kill_inferior_callback (struct inferior_list_entry
*entry
)
2152 struct process_info
*process
= (struct process_info
*) entry
;
2153 int pid
= ptid_get_pid (process
->head
.id
);
2155 kill_inferior (pid
);
2156 discard_queued_stop_replies (pid
);
2159 /* Callback for for_each_inferior to detach or kill the inferior,
2160 depending on whether we attached to it or not.
2161 We inform the user whether we're detaching or killing the process
2162 as this is only called when gdbserver is about to exit. */
2165 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2167 struct process_info
*process
= (struct process_info
*) entry
;
2168 int pid
= ptid_get_pid (process
->head
.id
);
2170 if (process
->attached
)
2171 detach_inferior (pid
);
2173 kill_inferior (pid
);
2175 discard_queued_stop_replies (pid
);
2178 /* for_each_inferior callback for detach_or_kill_for_exit to print
2179 the pids of started inferiors. */
2182 print_started_pid (struct inferior_list_entry
*entry
)
2184 struct process_info
*process
= (struct process_info
*) entry
;
2186 if (! process
->attached
)
2188 int pid
= ptid_get_pid (process
->head
.id
);
2189 fprintf (stderr
, " %d", pid
);
2193 /* for_each_inferior callback for detach_or_kill_for_exit to print
2194 the pids of attached inferiors. */
2197 print_attached_pid (struct inferior_list_entry
*entry
)
2199 struct process_info
*process
= (struct process_info
*) entry
;
2201 if (process
->attached
)
2203 int pid
= ptid_get_pid (process
->head
.id
);
2204 fprintf (stderr
, " %d", pid
);
2208 /* Call this when exiting gdbserver with possible inferiors that need
2209 to be killed or detached from. */
2212 detach_or_kill_for_exit (void)
2214 /* First print a list of the inferiors we will be killing/detaching.
2215 This is to assist the user, for example, in case the inferior unexpectedly
2216 dies after we exit: did we screw up or did the inferior exit on its own?
2217 Having this info will save some head-scratching. */
2219 if (have_started_inferiors_p ())
2221 fprintf (stderr
, "Killing process(es):");
2222 for_each_inferior (&all_processes
, print_started_pid
);
2223 fprintf (stderr
, "\n");
2225 if (have_attached_inferiors_p ())
2227 fprintf (stderr
, "Detaching process(es):");
2228 for_each_inferior (&all_processes
, print_attached_pid
);
2229 fprintf (stderr
, "\n");
2232 /* Now we can kill or detach the inferiors. */
2234 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2238 join_inferiors_callback (struct inferior_list_entry
*entry
)
2240 struct process_info
*process
= (struct process_info
*) entry
;
2242 /* If we are attached, then we can exit. Otherwise, we need to hang
2243 around doing nothing, until the child is gone. */
2244 if (!process
->attached
)
2245 join_inferior (ptid_get_pid (process
->head
.id
));
2249 main (int argc
, char *argv
[])
2253 char *arg_end
, *port
;
2254 char **next_arg
= &argv
[1];
2259 while (*next_arg
!= NULL
&& **next_arg
== '-')
2261 if (strcmp (*next_arg
, "--version") == 0)
2263 gdbserver_version ();
2266 else if (strcmp (*next_arg
, "--help") == 0)
2268 gdbserver_usage (stdout
);
2271 else if (strcmp (*next_arg
, "--attach") == 0)
2273 else if (strcmp (*next_arg
, "--multi") == 0)
2275 else if (strcmp (*next_arg
, "--wrapper") == 0)
2279 wrapper_argv
= next_arg
;
2280 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2283 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2285 gdbserver_usage (stderr
);
2289 /* Consume the "--". */
2292 else if (strcmp (*next_arg
, "--debug") == 0)
2294 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2296 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2298 gdbserver_show_disableable (stdout
);
2301 else if (strncmp (*next_arg
,
2302 "--disable-packet=",
2303 sizeof ("--disable-packet=") - 1) == 0)
2305 char *packets
, *tok
;
2307 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2308 for (tok
= strtok (packets
, ",");
2310 tok
= strtok (NULL
, ","))
2312 if (strcmp ("vCont", tok
) == 0)
2313 disable_packet_vCont
= 1;
2314 else if (strcmp ("Tthread", tok
) == 0)
2315 disable_packet_Tthread
= 1;
2316 else if (strcmp ("qC", tok
) == 0)
2317 disable_packet_qC
= 1;
2318 else if (strcmp ("qfThreadInfo", tok
) == 0)
2319 disable_packet_qfThreadInfo
= 1;
2320 else if (strcmp ("threads", tok
) == 0)
2322 disable_packet_vCont
= 1;
2323 disable_packet_Tthread
= 1;
2324 disable_packet_qC
= 1;
2325 disable_packet_qfThreadInfo
= 1;
2329 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2331 gdbserver_show_disableable (stderr
);
2338 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2346 if (setjmp (toplevel
))
2348 fprintf (stderr
, "Exiting\n");
2354 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2356 gdbserver_usage (stderr
);
2363 /* --attach used to come after PORT, so allow it there for
2365 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2372 && (*next_arg
== NULL
2373 || (*next_arg
)[0] == '\0'
2374 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2376 || next_arg
[1] != NULL
))
2381 gdbserver_usage (stderr
);
2385 initialize_inferiors ();
2386 initialize_async_io ();
2388 if (target_supports_tracepoints ())
2389 initialize_tracepoint ();
2391 own_buf
= xmalloc (PBUFSIZ
+ 1);
2392 mem_buf
= xmalloc (PBUFSIZ
);
2394 if (pid
== 0 && *next_arg
!= NULL
)
2398 n
= argc
- (next_arg
- argv
);
2399 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2400 for (i
= 0; i
< n
; i
++)
2401 program_argv
[i
] = xstrdup (next_arg
[i
]);
2402 program_argv
[i
] = NULL
;
2404 /* Wait till we are at first instruction in program. */
2405 start_inferior (program_argv
);
2407 /* We are now (hopefully) stopped at the first instruction of
2408 the target process. This assumes that the target process was
2409 successfully created. */
2413 if (attach_inferior (pid
) == -1)
2414 error ("Attaching not supported on this target");
2416 /* Otherwise succeeded. */
2420 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2421 last_status
.value
.integer
= 0;
2422 last_ptid
= minus_one_ptid
;
2425 /* Don't report shared library events on the initial connection,
2426 even if some libraries are preloaded. Avoids the "stopped by
2427 shared library event" notice on gdb side. */
2430 if (setjmp (toplevel
))
2432 detach_or_kill_for_exit ();
2436 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2437 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2442 if (!was_running
&& !multi_mode
)
2444 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2452 /* Be sure we're out of tfind mode. */
2453 current_traceframe
= -1;
2457 if (setjmp (toplevel
) != 0)
2459 /* An error occurred. */
2460 if (response_needed
)
2462 write_enn (own_buf
);
2467 /* Wait for events. This will return when all event sources are
2468 removed from the event loop. */
2469 start_event_loop ();
2471 /* If an exit was requested (using the "monitor exit" command),
2472 terminate now. The only other way to get here is for
2473 getpkt to fail; close the connection and reopen it at the
2478 detach_or_kill_for_exit ();
2483 "Remote side has terminated connection. "
2484 "GDBserver will reopen the connection.\n");
2488 if (disconnected_tracing
)
2490 /* Try to enable non-stop/async mode, so we we can both
2491 wait for an async socket accept, and handle async
2492 target events simultaneously. There's also no point
2493 either in having the target always stop all threads,
2494 when we're going to pass signals down without
2498 if (start_non_stop (1))
2501 /* Detaching implicitly resumes all threads; simply
2502 disconnecting does not. */
2508 "Disconnected tracing disabled; stopping trace run.\n");
2515 /* Event loop callback that handles a serial event. The first byte in
2516 the serial buffer gets us here. We expect characters to arrive at
2517 a brisk pace, so we read the rest of the packet with a blocking
2521 process_serial_event (void)
2531 int new_packet_len
= -1;
2533 /* Used to decide when gdbserver should exit in
2534 multi-mode/remote. */
2535 static int have_ran
= 0;
2538 have_ran
= target_running ();
2540 disable_async_io ();
2542 response_needed
= 0;
2543 packet_len
= getpkt (own_buf
);
2544 if (packet_len
<= 0)
2547 /* Force an event loop break. */
2550 response_needed
= 1;
2557 handle_query (own_buf
, packet_len
, &new_packet_len
);
2560 handle_general_set (own_buf
);
2563 require_running (own_buf
);
2568 pid
= strtol (&own_buf
[i
], NULL
, 16);
2572 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2574 if (tracing
&& disconnected_tracing
)
2576 struct thread_resume resume_info
;
2577 struct process_info
*process
= find_process_pid (pid
);
2579 if (process
== NULL
)
2581 write_enn (own_buf
);
2586 "Disconnected tracing in effect, "
2587 "leaving gdbserver attached to the process\n");
2589 /* Make sure we're in non-stop/async mode, so we we can both
2590 wait for an async socket accept, and handle async target
2591 events simultaneously. There's also no point either in
2592 having the target stop all threads, when we're going to
2593 pass signals down without informing GDB. */
2597 fprintf (stderr
, "Forcing non-stop mode\n");
2603 process
->gdb_detached
= 1;
2605 /* Detaching implicitly resumes all threads. */
2606 resume_info
.thread
= minus_one_ptid
;
2607 resume_info
.kind
= resume_continue
;
2608 resume_info
.sig
= 0;
2609 (*the_target
->resume
) (&resume_info
, 1);
2612 break; /* from switch/case */
2615 fprintf (stderr
, "Detaching from process %d\n", pid
);
2617 if (detach_inferior (pid
) != 0)
2618 write_enn (own_buf
);
2621 discard_queued_stop_replies (pid
);
2624 if (extended_protocol
)
2626 /* Treat this like a normal program exit. */
2627 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2628 last_status
.value
.integer
= 0;
2629 last_ptid
= pid_to_ptid (pid
);
2631 current_inferior
= NULL
;
2638 /* If we are attached, then we can exit. Otherwise, we
2639 need to hang around doing nothing, until the child is
2641 for_each_inferior (&all_processes
,
2642 join_inferiors_callback
);
2648 extended_protocol
= 1;
2652 handle_status (own_buf
);
2655 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2657 ptid_t gdb_id
, thread_id
;
2660 require_running (own_buf
);
2662 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2664 pid
= ptid_get_pid (gdb_id
);
2666 if (ptid_equal (gdb_id
, null_ptid
)
2667 || ptid_equal (gdb_id
, minus_one_ptid
))
2668 thread_id
= null_ptid
;
2670 && ptid_equal (pid_to_ptid (pid
),
2673 struct thread_info
*thread
=
2674 (struct thread_info
*) find_inferior (&all_threads
,
2679 write_enn (own_buf
);
2683 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2687 thread_id
= gdb_id_to_thread_id (gdb_id
);
2688 if (ptid_equal (thread_id
, null_ptid
))
2690 write_enn (own_buf
);
2695 if (own_buf
[1] == 'g')
2697 if (ptid_equal (thread_id
, null_ptid
))
2699 /* GDB is telling us to choose any thread. Check if
2700 the currently selected thread is still valid. If
2701 it is not, select the first available. */
2702 struct thread_info
*thread
=
2703 (struct thread_info
*) find_inferior_id (&all_threads
,
2706 thread_id
= all_threads
.head
->id
;
2709 general_thread
= thread_id
;
2710 set_desired_inferior (1);
2712 else if (own_buf
[1] == 'c')
2713 cont_thread
= thread_id
;
2714 else if (own_buf
[1] == 's')
2715 step_thread
= thread_id
;
2721 /* Silently ignore it so that gdb can extend the protocol
2722 without compatibility headaches. */
2727 require_running (own_buf
);
2728 if (current_traceframe
>= 0)
2730 struct regcache
*regcache
= new_register_cache ();
2732 if (fetch_traceframe_registers (current_traceframe
,
2734 registers_to_string (regcache
, own_buf
);
2736 write_enn (own_buf
);
2737 free_register_cache (regcache
);
2741 struct regcache
*regcache
;
2743 set_desired_inferior (1);
2744 regcache
= get_thread_regcache (current_inferior
, 1);
2745 registers_to_string (regcache
, own_buf
);
2749 require_running (own_buf
);
2750 if (current_traceframe
>= 0)
2751 write_enn (own_buf
);
2754 struct regcache
*regcache
;
2756 set_desired_inferior (1);
2757 regcache
= get_thread_regcache (current_inferior
, 1);
2758 registers_from_string (regcache
, &own_buf
[1]);
2763 require_running (own_buf
);
2764 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
2765 if (read_memory (mem_addr
, mem_buf
, len
) == 0)
2766 convert_int_to_ascii (mem_buf
, own_buf
, len
);
2768 write_enn (own_buf
);
2771 require_running (own_buf
);
2772 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, mem_buf
);
2773 if (write_memory (mem_addr
, mem_buf
, len
) == 0)
2776 write_enn (own_buf
);
2779 require_running (own_buf
);
2780 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
2781 &mem_addr
, &len
, mem_buf
) < 0
2782 || write_memory (mem_addr
, mem_buf
, len
) != 0)
2783 write_enn (own_buf
);
2788 require_running (own_buf
);
2789 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2790 if (target_signal_to_host_p (sig
))
2791 signal
= target_signal_to_host (sig
);
2794 myresume (own_buf
, 0, signal
);
2797 require_running (own_buf
);
2798 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2799 if (target_signal_to_host_p (sig
))
2800 signal
= target_signal_to_host (sig
);
2803 myresume (own_buf
, 1, signal
);
2806 require_running (own_buf
);
2808 myresume (own_buf
, 0, signal
);
2811 require_running (own_buf
);
2813 myresume (own_buf
, 1, signal
);
2815 case 'Z': /* insert_ ... */
2817 case 'z': /* remove_ ... */
2821 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
2822 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
2823 char type
= own_buf
[1];
2825 const int insert
= ch
== 'Z';
2827 /* Default to unrecognized/unsupported. */
2831 case '0': /* software-breakpoint */
2832 case '1': /* hardware-breakpoint */
2833 case '2': /* write watchpoint */
2834 case '3': /* read watchpoint */
2835 case '4': /* access watchpoint */
2836 require_running (own_buf
);
2837 if (insert
&& the_target
->insert_point
!= NULL
)
2838 res
= (*the_target
->insert_point
) (type
, addr
, len
);
2839 else if (!insert
&& the_target
->remove_point
!= NULL
)
2840 res
= (*the_target
->remove_point
) (type
, addr
, len
);
2852 write_enn (own_buf
);
2856 response_needed
= 0;
2857 if (!target_running ())
2858 /* The packet we received doesn't make sense - but we can't
2859 reply to it, either. */
2862 fprintf (stderr
, "Killing all inferiors\n");
2863 for_each_inferior (&all_processes
, kill_inferior_callback
);
2865 /* When using the extended protocol, we wait with no program
2866 running. The traditional protocol will exit instead. */
2867 if (extended_protocol
)
2869 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2870 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2878 ptid_t gdb_id
, thread_id
;
2880 require_running (own_buf
);
2882 gdb_id
= read_ptid (&own_buf
[1], NULL
);
2883 thread_id
= gdb_id_to_thread_id (gdb_id
);
2884 if (ptid_equal (thread_id
, null_ptid
))
2886 write_enn (own_buf
);
2890 if (mythread_alive (thread_id
))
2893 write_enn (own_buf
);
2897 response_needed
= 0;
2899 /* Restarting the inferior is only supported in the extended
2901 if (extended_protocol
)
2903 if (target_running ())
2904 for_each_inferior (&all_processes
,
2905 kill_inferior_callback
);
2906 fprintf (stderr
, "GDBserver restarting\n");
2908 /* Wait till we are at 1st instruction in prog. */
2909 if (program_argv
!= NULL
)
2910 start_inferior (program_argv
);
2913 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2914 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2920 /* It is a request we don't understand. Respond with an
2921 empty packet so that gdb knows that we don't support this
2927 /* Extended (long) request. */
2928 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
2932 /* It is a request we don't understand. Respond with an empty
2933 packet so that gdb knows that we don't support this
2939 if (new_packet_len
!= -1)
2940 putpkt_binary (own_buf
, new_packet_len
);
2944 response_needed
= 0;
2946 if (!extended_protocol
&& have_ran
&& !target_running ())
2948 /* In non-stop, defer exiting until GDB had a chance to query
2949 the whole vStopped list (until it gets an OK). */
2952 fprintf (stderr
, "GDBserver exiting\n");
2964 /* Event-loop callback for serial events. */
2967 handle_serial_event (int err
, gdb_client_data client_data
)
2970 fprintf (stderr
, "handling possible serial event\n");
2972 /* Really handle it. */
2973 if (process_serial_event () < 0)
2976 /* Be sure to not change the selected inferior behind GDB's back.
2977 Important in the non-stop mode asynchronous protocol. */
2978 set_desired_inferior (1);
2983 /* Event-loop callback for target events. */
2986 handle_target_event (int err
, gdb_client_data client_data
)
2989 fprintf (stderr
, "handling possible target event\n");
2991 last_ptid
= mywait (minus_one_ptid
, &last_status
,
2994 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
2996 int pid
= ptid_get_pid (last_ptid
);
2997 struct process_info
*process
= find_process_pid (pid
);
2998 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3000 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3001 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3002 mourn_inferior (process
);
3006 if (!target_running ())
3008 /* The last process exited. We're done. */
3012 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3014 /* A thread stopped with a signal, but gdb isn't
3015 connected to handle it. Pass it down to the
3016 inferior, as if it wasn't being traced. */
3017 struct thread_resume resume_info
;
3021 "GDB not connected; forwarding event %d for [%s]\n",
3022 (int) last_status
.kind
,
3023 target_pid_to_str (last_ptid
));
3025 resume_info
.thread
= last_ptid
;
3026 resume_info
.kind
= resume_continue
;
3027 resume_info
.sig
= last_status
.value
.sig
;
3028 (*the_target
->resume
) (&resume_info
, 1);
3030 else if (debug_threads
)
3031 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3032 (int) last_status
.kind
,
3033 target_pid_to_str (last_ptid
));
3037 /* Something interesting. Tell GDB about it. */
3038 push_event (last_ptid
, &last_status
);
3042 /* Be sure to not change the selected inferior behind GDB's back.
3043 Important in the non-stop mode asynchronous protocol. */
3044 set_desired_inferior (1);