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 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 /* Otherwise we didn't know what packet it was. Say we didn't
458 get_features_xml (const char *annex
)
460 /* gdbserver_xmltarget defines what to return when looking
461 for the "target.xml" file. Its contents can either be
462 verbatim XML code (prefixed with a '@') or else the name
463 of the actual XML file to be used in place of "target.xml".
465 This variable is set up from the auto-generated
466 init_registers_... routine for the current target. */
468 if (gdbserver_xmltarget
469 && strcmp (annex
, "target.xml") == 0)
471 if (*gdbserver_xmltarget
== '@')
472 return gdbserver_xmltarget
+ 1;
474 annex
= gdbserver_xmltarget
;
479 extern const char *const xml_builtin
[][2];
482 /* Look for the annex. */
483 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
484 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
487 if (xml_builtin
[i
][0] != NULL
)
488 return xml_builtin
[i
][1];
496 monitor_show_help (void)
498 monitor_output ("The following monitor commands are supported:\n");
499 monitor_output (" set debug <0|1>\n");
500 monitor_output (" Enable general debugging messages\n");
501 monitor_output (" set debug-hw-points <0|1>\n");
502 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
503 monitor_output (" set remote-debug <0|1>\n");
504 monitor_output (" Enable remote protocol debugging messages\n");
505 monitor_output (" exit\n");
506 monitor_output (" Quit GDBserver\n");
509 /* Subroutine of handle_search_memory to simplify it. */
512 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
513 gdb_byte
*pattern
, unsigned pattern_len
,
514 gdb_byte
*search_buf
,
515 unsigned chunk_size
, unsigned search_buf_size
,
516 CORE_ADDR
*found_addrp
)
518 /* Prime the search buffer. */
520 if (read_inferior_memory (start_addr
, search_buf
, search_buf_size
) != 0)
522 warning ("Unable to access target memory at 0x%lx, halting search.",
527 /* Perform the search.
529 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
530 When we've scanned N bytes we copy the trailing bytes to the start and
531 read in another N bytes. */
533 while (search_space_len
>= pattern_len
)
536 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
540 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
542 if (found_ptr
!= NULL
)
544 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
545 *found_addrp
= found_addr
;
549 /* Not found in this chunk, skip to next chunk. */
551 /* Don't let search_space_len wrap here, it's unsigned. */
552 if (search_space_len
>= chunk_size
)
553 search_space_len
-= chunk_size
;
555 search_space_len
= 0;
557 if (search_space_len
>= pattern_len
)
559 unsigned keep_len
= search_buf_size
- chunk_size
;
560 CORE_ADDR read_addr
= start_addr
+ keep_len
;
563 /* Copy the trailing part of the previous iteration to the front
564 of the buffer for the next iteration. */
565 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
567 nr_to_read
= (search_space_len
- keep_len
< chunk_size
568 ? search_space_len
- keep_len
571 if (read_inferior_memory (read_addr
, search_buf
+ keep_len
,
574 warning ("Unable to access target memory at 0x%lx, halting search.",
579 start_addr
+= chunk_size
;
588 /* Handle qSearch:memory packets. */
591 handle_search_memory (char *own_buf
, int packet_len
)
593 CORE_ADDR start_addr
;
594 CORE_ADDR search_space_len
;
596 unsigned int pattern_len
;
597 /* NOTE: also defined in find.c testcase. */
598 #define SEARCH_CHUNK_SIZE 16000
599 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
600 /* Buffer to hold memory contents for searching. */
601 gdb_byte
*search_buf
;
602 unsigned search_buf_size
;
604 CORE_ADDR found_addr
;
605 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
607 pattern
= malloc (packet_len
);
610 error ("Unable to allocate memory to perform the search");
611 strcpy (own_buf
, "E00");
614 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
615 packet_len
- cmd_name_len
,
616 &start_addr
, &search_space_len
,
617 pattern
, &pattern_len
) < 0)
620 error ("Error in parsing qSearch:memory packet");
621 strcpy (own_buf
, "E00");
625 search_buf_size
= chunk_size
+ pattern_len
- 1;
627 /* No point in trying to allocate a buffer larger than the search space. */
628 if (search_space_len
< search_buf_size
)
629 search_buf_size
= search_space_len
;
631 search_buf
= malloc (search_buf_size
);
632 if (search_buf
== NULL
)
635 error ("Unable to allocate memory to perform the search");
636 strcpy (own_buf
, "E00");
640 found
= handle_search_memory_1 (start_addr
, search_space_len
,
641 pattern
, pattern_len
,
642 search_buf
, chunk_size
, search_buf_size
,
646 sprintf (own_buf
, "1,%lx", (long) found_addr
);
648 strcpy (own_buf
, "0");
650 strcpy (own_buf
, "E00");
656 #define require_running(BUF) \
657 if (!target_running ()) \
663 /* Handle all of the extended 'q' packets. */
665 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
667 static struct inferior_list_entry
*thread_ptr
;
669 /* Reply the current thread id. */
670 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
673 require_running (own_buf
);
675 if (!ptid_equal (general_thread
, null_ptid
)
676 && !ptid_equal (general_thread
, minus_one_ptid
))
677 gdb_id
= general_thread
;
680 thread_ptr
= all_threads
.head
;
681 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
684 sprintf (own_buf
, "QC");
686 own_buf
= write_ptid (own_buf
, gdb_id
);
690 if (strcmp ("qSymbol::", own_buf
) == 0)
692 if (target_running () && the_target
->look_up_symbols
!= NULL
)
693 (*the_target
->look_up_symbols
) ();
695 strcpy (own_buf
, "OK");
699 if (!disable_packet_qfThreadInfo
)
701 if (strcmp ("qfThreadInfo", own_buf
) == 0)
705 require_running (own_buf
);
706 thread_ptr
= all_threads
.head
;
709 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
710 write_ptid (own_buf
, gdb_id
);
711 thread_ptr
= thread_ptr
->next
;
715 if (strcmp ("qsThreadInfo", own_buf
) == 0)
719 require_running (own_buf
);
720 if (thread_ptr
!= NULL
)
723 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
724 write_ptid (own_buf
, gdb_id
);
725 thread_ptr
= thread_ptr
->next
;
730 sprintf (own_buf
, "l");
736 if (the_target
->read_offsets
!= NULL
737 && strcmp ("qOffsets", own_buf
) == 0)
739 CORE_ADDR text
, data
;
741 require_running (own_buf
);
742 if (the_target
->read_offsets (&text
, &data
))
743 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
744 (long)text
, (long)data
, (long)data
);
751 if (the_target
->qxfer_spu
!= NULL
752 && strncmp ("qXfer:spu:read:", own_buf
, 15) == 0)
758 unsigned char *spu_buf
;
760 require_running (own_buf
);
761 strcpy (own_buf
, "E00");
762 if (decode_xfer_read (own_buf
+ 15, &annex
, &ofs
, &len
) < 0)
764 if (len
> PBUFSIZ
- 2)
766 spu_buf
= malloc (len
+ 1);
770 n
= (*the_target
->qxfer_spu
) (annex
, spu_buf
, NULL
, ofs
, len
+ 1);
774 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, len
, 1);
776 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, n
, 0);
782 if (the_target
->qxfer_spu
!= NULL
783 && strncmp ("qXfer:spu:write:", own_buf
, 16) == 0)
789 unsigned char *spu_buf
;
791 require_running (own_buf
);
792 strcpy (own_buf
, "E00");
793 spu_buf
= malloc (packet_len
- 15);
796 if (decode_xfer_write (own_buf
+ 16, packet_len
- 16, &annex
,
797 &ofs
, &len
, spu_buf
) < 0)
803 n
= (*the_target
->qxfer_spu
)
804 (annex
, NULL
, (unsigned const char *)spu_buf
, ofs
, len
);
808 sprintf (own_buf
, "%x", n
);
814 if (the_target
->read_auxv
!= NULL
815 && strncmp ("qXfer:auxv:read:", own_buf
, 16) == 0)
823 require_running (own_buf
);
825 /* Reject any annex; grab the offset and length. */
826 if (decode_xfer_read (own_buf
+ 16, &annex
, &ofs
, &len
) < 0
829 strcpy (own_buf
, "E00");
833 /* Read one extra byte, as an indicator of whether there is
835 if (len
> PBUFSIZ
- 2)
837 data
= malloc (len
+ 1);
843 n
= (*the_target
->read_auxv
) (ofs
, data
, len
+ 1);
847 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
849 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
856 if (strncmp ("qXfer:features:read:", own_buf
, 20) == 0)
859 unsigned int len
, total_len
;
860 const char *document
;
863 require_running (own_buf
);
865 /* Grab the annex, offset, and length. */
866 if (decode_xfer_read (own_buf
+ 20, &annex
, &ofs
, &len
) < 0)
868 strcpy (own_buf
, "E00");
872 /* Now grab the correct annex. */
873 document
= get_features_xml (annex
);
874 if (document
== NULL
)
876 strcpy (own_buf
, "E00");
880 total_len
= strlen (document
);
881 if (len
> PBUFSIZ
- 2)
886 else if (len
< total_len
- ofs
)
887 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
890 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
896 if (strncmp ("qXfer:libraries:read:", own_buf
, 21) == 0)
899 unsigned int len
, total_len
;
901 struct inferior_list_entry
*dll_ptr
;
904 require_running (own_buf
);
906 /* Reject any annex; grab the offset and length. */
907 if (decode_xfer_read (own_buf
+ 21, &annex
, &ofs
, &len
) < 0
910 strcpy (own_buf
, "E00");
914 /* Over-estimate the necessary memory. Assume that every character
915 in the library name must be escaped. */
917 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
918 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
920 document
= malloc (total_len
);
921 if (document
== NULL
)
926 strcpy (document
, "<library-list>\n");
927 p
= document
+ strlen (document
);
929 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
931 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
934 strcpy (p
, " <library name=\"");
936 name
= xml_escape_text (dll
->name
);
940 strcpy (p
, "\"><segment address=\"");
942 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
944 strcpy (p
, "\"/></library>\n");
948 strcpy (p
, "</library-list>\n");
950 total_len
= strlen (document
);
951 if (len
> PBUFSIZ
- 2)
956 else if (len
< total_len
- ofs
)
957 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
960 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
967 if (the_target
->qxfer_osdata
!= NULL
968 && strncmp ("qXfer:osdata:read:", own_buf
, 18) == 0)
974 unsigned char *workbuf
;
976 strcpy (own_buf
, "E00");
977 if (decode_xfer_read (own_buf
+ 18, &annex
, &ofs
, &len
) < 0)
979 if (len
> PBUFSIZ
- 2)
981 workbuf
= malloc (len
+ 1);
985 n
= (*the_target
->qxfer_osdata
) (annex
, workbuf
, NULL
, ofs
, len
+ 1);
989 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, len
, 1);
991 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, n
, 0);
997 if (the_target
->qxfer_siginfo
!= NULL
998 && strncmp ("qXfer:siginfo:read:", own_buf
, 19) == 0)
1000 unsigned char *data
;
1006 require_running (own_buf
);
1008 /* Reject any annex; grab the offset and length. */
1009 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1010 || annex
[0] != '\0')
1012 strcpy (own_buf
, "E00");
1016 /* Read one extra byte, as an indicator of whether there is
1018 if (len
> PBUFSIZ
- 2)
1020 data
= malloc (len
+ 1);
1023 n
= (*the_target
->qxfer_siginfo
) (annex
, data
, NULL
, ofs
, len
+ 1);
1025 write_enn (own_buf
);
1027 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1029 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1035 if (the_target
->qxfer_siginfo
!= NULL
1036 && strncmp ("qXfer:siginfo:write:", own_buf
, 20) == 0)
1042 unsigned char *data
;
1044 require_running (own_buf
);
1046 strcpy (own_buf
, "E00");
1047 data
= malloc (packet_len
- 19);
1050 if (decode_xfer_write (own_buf
+ 20, packet_len
- 20, &annex
,
1051 &ofs
, &len
, data
) < 0)
1057 n
= (*the_target
->qxfer_siginfo
)
1058 (annex
, NULL
, (unsigned const char *)data
, ofs
, len
);
1060 write_enn (own_buf
);
1062 sprintf (own_buf
, "%x", n
);
1068 /* Protocol features query. */
1069 if (strncmp ("qSupported", own_buf
, 10) == 0
1070 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1072 char *p
= &own_buf
[10];
1074 /* Process each feature being provided by GDB. The first
1075 feature will follow a ':', and latter features will follow
1078 for (p
= strtok (p
+ 1, ";");
1080 p
= strtok (NULL
, ";"))
1082 if (strcmp (p
, "multiprocess+") == 0)
1084 /* GDB supports and wants multi-process support if
1086 if (target_supports_multi_process ())
1091 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1093 /* We do not have any hook to indicate whether the target backend
1094 supports qXfer:libraries:read, so always report it. */
1095 strcat (own_buf
, ";qXfer:libraries:read+");
1097 if (the_target
->read_auxv
!= NULL
)
1098 strcat (own_buf
, ";qXfer:auxv:read+");
1100 if (the_target
->qxfer_spu
!= NULL
)
1101 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1103 if (the_target
->qxfer_siginfo
!= NULL
)
1104 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1106 /* We always report qXfer:features:read, as targets may
1107 install XML files on a subsequent call to arch_setup.
1108 If we reported to GDB on startup that we don't support
1109 qXfer:feature:read at all, we will never be re-queried. */
1110 strcat (own_buf
, ";qXfer:features:read+");
1112 if (transport_is_reliable
)
1113 strcat (own_buf
, ";QStartNoAckMode+");
1115 if (the_target
->qxfer_osdata
!= NULL
)
1116 strcat (own_buf
, ";qXfer:osdata:read+");
1118 if (target_supports_multi_process ())
1119 strcat (own_buf
, ";multiprocess+");
1121 if (target_supports_non_stop ())
1122 strcat (own_buf
, ";QNonStop+");
1127 /* Thread-local storage support. */
1128 if (the_target
->get_tls_address
!= NULL
1129 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1131 char *p
= own_buf
+ 12;
1132 CORE_ADDR parts
[2], address
= 0;
1134 ptid_t ptid
= null_ptid
;
1136 require_running (own_buf
);
1138 for (i
= 0; i
< 3; i
++)
1146 p2
= strchr (p
, ',');
1159 ptid
= read_ptid (p
, NULL
);
1161 decode_address (&parts
[i
- 1], p
, len
);
1165 if (p
!= NULL
|| i
< 3)
1169 struct thread_info
*thread
= find_thread_ptid (ptid
);
1174 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1180 sprintf (own_buf
, "%llx", address
);
1185 write_enn (own_buf
);
1189 /* Otherwise, pretend we do not understand this packet. */
1192 /* Handle "monitor" commands. */
1193 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1195 char *mon
= malloc (PBUFSIZ
);
1196 int len
= strlen (own_buf
+ 6);
1200 write_enn (own_buf
);
1204 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1206 write_enn (own_buf
);
1210 mon
[len
/ 2] = '\0';
1214 if (strcmp (mon
, "set debug 1") == 0)
1217 monitor_output ("Debug output enabled.\n");
1219 else if (strcmp (mon
, "set debug 0") == 0)
1222 monitor_output ("Debug output disabled.\n");
1224 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1226 debug_hw_points
= 1;
1227 monitor_output ("H/W point debugging output enabled.\n");
1229 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1231 debug_hw_points
= 0;
1232 monitor_output ("H/W point debugging output disabled.\n");
1234 else if (strcmp (mon
, "set remote-debug 1") == 0)
1237 monitor_output ("Protocol debug output enabled.\n");
1239 else if (strcmp (mon
, "set remote-debug 0") == 0)
1242 monitor_output ("Protocol debug output disabled.\n");
1244 else if (strcmp (mon
, "help") == 0)
1245 monitor_show_help ();
1246 else if (strcmp (mon
, "exit") == 0)
1250 monitor_output ("Unknown monitor command.\n\n");
1251 monitor_show_help ();
1252 write_enn (own_buf
);
1259 if (strncmp ("qSearch:memory:", own_buf
, sizeof ("qSearch:memory:") - 1) == 0)
1261 require_running (own_buf
);
1262 handle_search_memory (own_buf
, packet_len
);
1266 if (strcmp (own_buf
, "qAttached") == 0
1267 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1269 struct process_info
*process
;
1271 if (own_buf
[sizeof ("qAttached") - 1])
1273 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1274 process
= (struct process_info
*)
1275 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1279 require_running (own_buf
);
1280 process
= current_process ();
1283 if (process
== NULL
)
1285 write_enn (own_buf
);
1289 strcpy (own_buf
, process
->attached
? "1" : "0");
1293 /* Otherwise we didn't know what packet it was. Say we didn't
1298 /* Parse vCont packets. */
1300 handle_v_cont (char *own_buf
)
1304 struct thread_resume
*resume_info
;
1305 struct thread_resume default_action
= {{0}};
1307 /* Count the number of semicolons in the packet. There should be one
1308 for every action. */
1314 p
= strchr (p
, ';');
1317 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1318 if (resume_info
== NULL
)
1326 if (p
[0] == 's' || p
[0] == 'S')
1327 resume_info
[i
].kind
= resume_step
;
1328 else if (p
[0] == 'c' || p
[0] == 'C')
1329 resume_info
[i
].kind
= resume_continue
;
1330 else if (p
[0] == 't')
1331 resume_info
[i
].kind
= resume_stop
;
1335 if (p
[0] == 'S' || p
[0] == 'C')
1338 sig
= strtol (p
+ 1, &q
, 16);
1343 if (!target_signal_to_host_p (sig
))
1345 resume_info
[i
].sig
= target_signal_to_host (sig
);
1349 resume_info
[i
].sig
= 0;
1355 resume_info
[i
].thread
= minus_one_ptid
;
1356 default_action
= resume_info
[i
];
1358 /* Note: we don't increment i here, we'll overwrite this entry
1359 the next time through. */
1361 else if (p
[0] == ':')
1363 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1368 if (p
[0] != ';' && p
[0] != 0)
1371 resume_info
[i
].thread
= ptid
;
1378 resume_info
[i
] = default_action
;
1380 /* Still used in occasional places in the backend. */
1382 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1383 && resume_info
[0].kind
!= resume_stop
)
1384 cont_thread
= resume_info
[0].thread
;
1386 cont_thread
= minus_one_ptid
;
1387 set_desired_inferior (0);
1392 (*the_target
->resume
) (resume_info
, n
);
1400 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1401 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1402 disable_async_io ();
1407 write_enn (own_buf
);
1412 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1414 handle_v_attach (char *own_buf
)
1418 pid
= strtol (own_buf
+ 8, NULL
, 16);
1419 if (pid
!= 0 && attach_inferior (pid
) == 0)
1421 /* Don't report shared library events after attaching, even if
1422 some libraries are preloaded. GDB will always poll the
1423 library list. Avoids the "stopped by shared library event"
1424 notice on the GDB side. */
1429 /* In non-stop, we don't send a resume reply. Stop events
1430 will follow up using the normal notification
1435 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1441 write_enn (own_buf
);
1446 /* Run a new program. Return 1 if successful, 0 if failure. */
1448 handle_v_run (char *own_buf
)
1450 char *p
, *next_p
, **new_argv
;
1454 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1460 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1461 if (new_argv
== NULL
)
1463 write_enn (own_buf
);
1468 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
1470 next_p
= strchr (p
, ';');
1472 next_p
= p
+ strlen (p
);
1474 if (i
== 0 && p
== next_p
)
1478 /* FIXME: Fail request if out of memory instead of dying. */
1479 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
1480 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
1481 new_argv
[i
][(next_p
- p
) / 2] = '\0';
1490 if (new_argv
[0] == NULL
)
1492 /* GDB didn't specify a program to run. Use the program from the
1493 last run with the new argument list. */
1495 if (program_argv
== NULL
)
1497 /* FIXME: new_argv memory leak */
1498 write_enn (own_buf
);
1502 new_argv
[0] = strdup (program_argv
[0]);
1503 if (new_argv
[0] == NULL
)
1505 /* FIXME: new_argv memory leak */
1506 write_enn (own_buf
);
1511 /* Free the old argv and install the new one. */
1512 freeargv (program_argv
);
1513 program_argv
= new_argv
;
1515 start_inferior (program_argv
);
1516 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
1518 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1520 /* In non-stop, sending a resume reply doesn't set the general
1521 thread, but GDB assumes a vRun sets it (this is so GDB can
1522 query which is the main thread of the new inferior. */
1524 general_thread
= last_ptid
;
1530 write_enn (own_buf
);
1535 /* Kill process. Return 1 if successful, 0 if failure. */
1537 handle_v_kill (char *own_buf
)
1540 char *p
= &own_buf
[6];
1542 pid
= strtol (p
, NULL
, 16);
1545 if (pid
!= 0 && kill_inferior (pid
) == 0)
1547 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1548 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
1549 last_ptid
= pid_to_ptid (pid
);
1550 discard_queued_stop_replies (pid
);
1556 write_enn (own_buf
);
1561 /* Handle a 'vStopped' packet. */
1563 handle_v_stopped (char *own_buf
)
1565 /* If we're waiting for GDB to acknowledge a pending stop reply,
1566 consider that done. */
1569 struct vstop_notif
*head
;
1572 fprintf (stderr
, "vStopped: acking %s\n",
1573 target_pid_to_str (notif_queue
->ptid
));
1576 notif_queue
= notif_queue
->next
;
1580 /* Push another stop reply, or if there are no more left, an OK. */
1581 send_next_stop_reply (own_buf
);
1584 /* Handle all of the extended 'v' packets. */
1586 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
1588 if (!disable_packet_vCont
)
1590 if (strncmp (own_buf
, "vCont;", 6) == 0)
1592 require_running (own_buf
);
1593 handle_v_cont (own_buf
);
1597 if (strncmp (own_buf
, "vCont?", 6) == 0)
1599 strcpy (own_buf
, "vCont;c;C;s;S;t");
1604 if (strncmp (own_buf
, "vFile:", 6) == 0
1605 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
1608 if (strncmp (own_buf
, "vAttach;", 8) == 0)
1610 if (!multi_process
&& target_running ())
1612 fprintf (stderr
, "Already debugging a process\n");
1613 write_enn (own_buf
);
1616 handle_v_attach (own_buf
);
1620 if (strncmp (own_buf
, "vRun;", 5) == 0)
1622 if (!multi_process
&& target_running ())
1624 fprintf (stderr
, "Already debugging a process\n");
1625 write_enn (own_buf
);
1628 handle_v_run (own_buf
);
1632 if (strncmp (own_buf
, "vKill;", 6) == 0)
1634 if (!target_running ())
1636 fprintf (stderr
, "No process to kill\n");
1637 write_enn (own_buf
);
1640 handle_v_kill (own_buf
);
1644 if (strncmp (own_buf
, "vStopped", 8) == 0)
1646 handle_v_stopped (own_buf
);
1650 /* Otherwise we didn't know what packet it was. Say we didn't
1656 /* Resume inferior and wait for another event. In non-stop mode,
1657 don't really wait here, but return immediatelly to the event
1660 myresume (char *own_buf
, int step
, int sig
)
1662 struct thread_resume resume_info
[2];
1664 int valid_cont_thread
;
1666 set_desired_inferior (0);
1668 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
1669 && !ptid_equal (cont_thread
, minus_one_ptid
));
1671 if (step
|| sig
|| valid_cont_thread
)
1673 resume_info
[0].thread
1674 = ((struct inferior_list_entry
*) current_inferior
)->id
;
1676 resume_info
[0].kind
= resume_step
;
1678 resume_info
[0].kind
= resume_continue
;
1679 resume_info
[0].sig
= sig
;
1683 if (!valid_cont_thread
)
1685 resume_info
[n
].thread
= minus_one_ptid
;
1686 resume_info
[n
].kind
= resume_continue
;
1687 resume_info
[n
].sig
= 0;
1694 (*the_target
->resume
) (resume_info
, n
);
1700 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1701 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1702 disable_async_io ();
1706 /* Callback for for_each_inferior. Make a new stop reply for each
1710 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
1712 int pid
= * (int *) arg
;
1715 || ptid_get_pid (entry
->id
) == pid
)
1717 struct target_waitstatus status
;
1719 status
.kind
= TARGET_WAITKIND_STOPPED
;
1720 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1722 /* Pass the last stop reply back to GDB, but don't notify. */
1723 queue_stop_reply (entry
->id
, &status
);
1729 /* Status handler for the '?' packet. */
1732 handle_status (char *own_buf
)
1734 struct target_waitstatus status
;
1735 status
.kind
= TARGET_WAITKIND_STOPPED
;
1736 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1738 /* In non-stop mode, we must send a stop reply for each stopped
1739 thread. In all-stop mode, just send one for the first stopped
1745 discard_queued_stop_replies (pid
);
1746 find_inferior (&all_threads
, queue_stop_reply_callback
, &pid
);
1748 /* The first is sent immediatly. OK is sent if there is no
1749 stopped thread, which is the same handling of the vStopped
1750 packet (by design). */
1751 send_next_stop_reply (own_buf
);
1755 if (all_threads
.head
)
1756 prepare_resume_reply (own_buf
,
1757 all_threads
.head
->id
, &status
);
1759 strcpy (own_buf
, "W00");
1764 gdbserver_version (void)
1766 printf ("GNU gdbserver %s%s\n"
1767 "Copyright (C) 2009 Free Software Foundation, Inc.\n"
1768 "gdbserver is free software, covered by the GNU General Public License.\n"
1769 "This gdbserver was configured as \"%s\"\n",
1770 PKGVERSION
, version
, host_name
);
1774 gdbserver_usage (FILE *stream
)
1776 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1777 "\tgdbserver [OPTIONS] --attach COMM PID\n"
1778 "\tgdbserver [OPTIONS] --multi COMM\n"
1780 "COMM may either be a tty device (for serial debugging), or \n"
1781 "HOST:PORT to listen for a TCP connection.\n"
1784 " --debug Enable general debugging output.\n"
1785 " --remote-debug Enable remote protocol debugging output.\n"
1786 " --version Display version information and exit.\n"
1787 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
1788 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
1789 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
1793 gdbserver_show_disableable (FILE *stream
)
1795 fprintf (stream
, "Disableable packets:\n"
1796 " vCont \tAll vCont packets\n"
1797 " qC \tQuerying the current thread\n"
1798 " qfThreadInfo\tThread listing\n"
1799 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
1800 " threads \tAll of the above\n");
1804 #undef require_running
1805 #define require_running(BUF) \
1806 if (!target_running ()) \
1813 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
1815 int pid
= * (int *) args
;
1817 if (ptid_get_pid (entry
->id
) == pid
)
1824 kill_inferior_callback (struct inferior_list_entry
*entry
)
1826 struct process_info
*process
= (struct process_info
*) entry
;
1827 int pid
= ptid_get_pid (process
->head
.id
);
1829 kill_inferior (pid
);
1830 discard_queued_stop_replies (pid
);
1833 /* Callback for for_each_inferior to detach or kill the inferior,
1834 depending on whether we attached to it or not.
1835 We inform the user whether we're detaching or killing the process
1836 as this is only called when gdbserver is about to exit. */
1839 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
1841 struct process_info
*process
= (struct process_info
*) entry
;
1842 int pid
= ptid_get_pid (process
->head
.id
);
1844 if (process
->attached
)
1845 detach_inferior (pid
);
1847 kill_inferior (pid
);
1849 discard_queued_stop_replies (pid
);
1852 /* for_each_inferior callback for detach_or_kill_for_exit to print
1853 the pids of started inferiors. */
1856 print_started_pid (struct inferior_list_entry
*entry
)
1858 struct process_info
*process
= (struct process_info
*) entry
;
1860 if (! process
->attached
)
1862 int pid
= ptid_get_pid (process
->head
.id
);
1863 fprintf (stderr
, " %d", pid
);
1867 /* for_each_inferior callback for detach_or_kill_for_exit to print
1868 the pids of attached inferiors. */
1871 print_attached_pid (struct inferior_list_entry
*entry
)
1873 struct process_info
*process
= (struct process_info
*) entry
;
1875 if (process
->attached
)
1877 int pid
= ptid_get_pid (process
->head
.id
);
1878 fprintf (stderr
, " %d", pid
);
1882 /* Call this when exiting gdbserver with possible inferiors that need
1883 to be killed or detached from. */
1886 detach_or_kill_for_exit (void)
1888 /* First print a list of the inferiors we will be killing/detaching.
1889 This is to assist the user, for example, in case the inferior unexpectedly
1890 dies after we exit: did we screw up or did the inferior exit on its own?
1891 Having this info will save some head-scratching. */
1893 if (have_started_inferiors_p ())
1895 fprintf (stderr
, "Killing process(es):");
1896 for_each_inferior (&all_processes
, print_started_pid
);
1897 fprintf (stderr
, "\n");
1899 if (have_attached_inferiors_p ())
1901 fprintf (stderr
, "Detaching process(es):");
1902 for_each_inferior (&all_processes
, print_attached_pid
);
1903 fprintf (stderr
, "\n");
1906 /* Now we can kill or detach the inferiors. */
1908 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
1912 join_inferiors_callback (struct inferior_list_entry
*entry
)
1914 struct process_info
*process
= (struct process_info
*) entry
;
1916 /* If we are attached, then we can exit. Otherwise, we need to hang
1917 around doing nothing, until the child is gone. */
1918 if (!process
->attached
)
1919 join_inferior (ptid_get_pid (process
->head
.id
));
1923 main (int argc
, char *argv
[])
1927 char *arg_end
, *port
;
1928 char **next_arg
= &argv
[1];
1933 while (*next_arg
!= NULL
&& **next_arg
== '-')
1935 if (strcmp (*next_arg
, "--version") == 0)
1937 gdbserver_version ();
1940 else if (strcmp (*next_arg
, "--help") == 0)
1942 gdbserver_usage (stdout
);
1945 else if (strcmp (*next_arg
, "--attach") == 0)
1947 else if (strcmp (*next_arg
, "--multi") == 0)
1949 else if (strcmp (*next_arg
, "--wrapper") == 0)
1953 wrapper_argv
= next_arg
;
1954 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
1957 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
1959 gdbserver_usage (stderr
);
1963 /* Consume the "--". */
1966 else if (strcmp (*next_arg
, "--debug") == 0)
1968 else if (strcmp (*next_arg
, "--remote-debug") == 0)
1970 else if (strcmp (*next_arg
, "--disable-packet") == 0)
1972 gdbserver_show_disableable (stdout
);
1975 else if (strncmp (*next_arg
,
1976 "--disable-packet=",
1977 sizeof ("--disable-packet=") - 1) == 0)
1979 char *packets
, *tok
;
1981 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
1982 for (tok
= strtok (packets
, ",");
1984 tok
= strtok (NULL
, ","))
1986 if (strcmp ("vCont", tok
) == 0)
1987 disable_packet_vCont
= 1;
1988 else if (strcmp ("Tthread", tok
) == 0)
1989 disable_packet_Tthread
= 1;
1990 else if (strcmp ("qC", tok
) == 0)
1991 disable_packet_qC
= 1;
1992 else if (strcmp ("qfThreadInfo", tok
) == 0)
1993 disable_packet_qfThreadInfo
= 1;
1994 else if (strcmp ("threads", tok
) == 0)
1996 disable_packet_vCont
= 1;
1997 disable_packet_Tthread
= 1;
1998 disable_packet_qC
= 1;
1999 disable_packet_qfThreadInfo
= 1;
2003 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2005 gdbserver_show_disableable (stderr
);
2012 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2020 if (setjmp (toplevel
))
2022 fprintf (stderr
, "Exiting\n");
2028 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2030 gdbserver_usage (stderr
);
2037 /* --attach used to come after PORT, so allow it there for
2039 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2046 && (*next_arg
== NULL
2047 || (*next_arg
)[0] == '\0'
2048 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2050 || next_arg
[1] != NULL
))
2055 gdbserver_usage (stderr
);
2059 initialize_inferiors ();
2060 initialize_async_io ();
2063 own_buf
= xmalloc (PBUFSIZ
+ 1);
2064 mem_buf
= xmalloc (PBUFSIZ
);
2066 if (pid
== 0 && *next_arg
!= NULL
)
2070 n
= argc
- (next_arg
- argv
);
2071 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2072 for (i
= 0; i
< n
; i
++)
2073 program_argv
[i
] = xstrdup (next_arg
[i
]);
2074 program_argv
[i
] = NULL
;
2076 /* Wait till we are at first instruction in program. */
2077 start_inferior (program_argv
);
2079 /* We are now (hopefully) stopped at the first instruction of
2080 the target process. This assumes that the target process was
2081 successfully created. */
2085 if (attach_inferior (pid
) == -1)
2086 error ("Attaching not supported on this target");
2088 /* Otherwise succeeded. */
2092 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2093 last_status
.value
.integer
= 0;
2094 last_ptid
= minus_one_ptid
;
2097 /* Don't report shared library events on the initial connection,
2098 even if some libraries are preloaded. Avoids the "stopped by
2099 shared library event" notice on gdb side. */
2102 if (setjmp (toplevel
))
2104 detach_or_kill_for_exit ();
2108 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2109 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2114 if (!was_running
&& !multi_mode
)
2116 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2128 if (setjmp (toplevel
) != 0)
2130 /* An error occurred. */
2131 if (response_needed
)
2133 write_enn (own_buf
);
2138 /* Wait for events. This will return when all event sources are
2139 removed from the event loop. */
2140 start_event_loop ();
2142 /* If an exit was requested (using the "monitor exit" command),
2143 terminate now. The only other way to get here is for
2144 getpkt to fail; close the connection and reopen it at the
2149 detach_or_kill_for_exit ();
2153 fprintf (stderr
, "Remote side has terminated connection. "
2154 "GDBserver will reopen the connection.\n");
2158 /* Event loop callback that handles a serial event. The first byte in
2159 the serial buffer gets us here. We expect characters to arrive at
2160 a brisk pace, so we read the rest of the packet with a blocking
2164 process_serial_event (void)
2174 int new_packet_len
= -1;
2176 /* Used to decide when gdbserver should exit in
2177 multi-mode/remote. */
2178 static int have_ran
= 0;
2181 have_ran
= target_running ();
2183 disable_async_io ();
2185 response_needed
= 0;
2186 packet_len
= getpkt (own_buf
);
2187 if (packet_len
<= 0)
2193 response_needed
= 1;
2200 handle_query (own_buf
, packet_len
, &new_packet_len
);
2203 handle_general_set (own_buf
);
2206 require_running (own_buf
);
2211 pid
= strtol (&own_buf
[i
], NULL
, 16);
2215 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2217 fprintf (stderr
, "Detaching from process %d\n", pid
);
2218 if (detach_inferior (pid
) != 0)
2219 write_enn (own_buf
);
2222 discard_queued_stop_replies (pid
);
2225 if (extended_protocol
)
2227 /* Treat this like a normal program exit. */
2228 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2229 last_status
.value
.integer
= 0;
2230 last_ptid
= pid_to_ptid (pid
);
2232 current_inferior
= NULL
;
2239 /* If we are attached, then we can exit. Otherwise, we
2240 need to hang around doing nothing, until the child is
2242 for_each_inferior (&all_processes
,
2243 join_inferiors_callback
);
2249 extended_protocol
= 1;
2253 handle_status (own_buf
);
2256 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2258 ptid_t gdb_id
, thread_id
;
2261 require_running (own_buf
);
2263 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2265 pid
= ptid_get_pid (gdb_id
);
2267 if (ptid_equal (gdb_id
, null_ptid
)
2268 || ptid_equal (gdb_id
, minus_one_ptid
))
2269 thread_id
= null_ptid
;
2271 && ptid_equal (pid_to_ptid (pid
),
2274 struct thread_info
*thread
=
2275 (struct thread_info
*) find_inferior (&all_threads
,
2280 write_enn (own_buf
);
2284 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2288 thread_id
= gdb_id_to_thread_id (gdb_id
);
2289 if (ptid_equal (thread_id
, null_ptid
))
2291 write_enn (own_buf
);
2296 if (own_buf
[1] == 'g')
2298 if (ptid_equal (thread_id
, null_ptid
))
2300 /* GDB is telling us to choose any thread. Check if
2301 the currently selected thread is still valid. If
2302 it is not, select the first available. */
2303 struct thread_info
*thread
=
2304 (struct thread_info
*) find_inferior_id (&all_threads
,
2307 thread_id
= all_threads
.head
->id
;
2310 general_thread
= thread_id
;
2311 set_desired_inferior (1);
2313 else if (own_buf
[1] == 'c')
2314 cont_thread
= thread_id
;
2315 else if (own_buf
[1] == 's')
2316 step_thread
= thread_id
;
2322 /* Silently ignore it so that gdb can extend the protocol
2323 without compatibility headaches. */
2328 require_running (own_buf
);
2329 set_desired_inferior (1);
2330 registers_to_string (own_buf
);
2333 require_running (own_buf
);
2334 set_desired_inferior (1);
2335 registers_from_string (&own_buf
[1]);
2339 require_running (own_buf
);
2340 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
2341 if (read_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2342 convert_int_to_ascii (mem_buf
, own_buf
, len
);
2344 write_enn (own_buf
);
2347 require_running (own_buf
);
2348 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, mem_buf
);
2349 if (write_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2352 write_enn (own_buf
);
2355 require_running (own_buf
);
2356 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
2357 &mem_addr
, &len
, mem_buf
) < 0
2358 || write_inferior_memory (mem_addr
, mem_buf
, len
) != 0)
2359 write_enn (own_buf
);
2364 require_running (own_buf
);
2365 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2366 if (target_signal_to_host_p (sig
))
2367 signal
= target_signal_to_host (sig
);
2370 myresume (own_buf
, 0, signal
);
2373 require_running (own_buf
);
2374 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2375 if (target_signal_to_host_p (sig
))
2376 signal
= target_signal_to_host (sig
);
2379 myresume (own_buf
, 1, signal
);
2382 require_running (own_buf
);
2384 myresume (own_buf
, 0, signal
);
2387 require_running (own_buf
);
2389 myresume (own_buf
, 1, signal
);
2391 case 'Z': /* insert_ ... */
2393 case 'z': /* remove_ ... */
2397 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
2398 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
2399 char type
= own_buf
[1];
2401 const int insert
= ch
== 'Z';
2403 /* Default to unrecognized/unsupported. */
2407 case '0': /* software-breakpoint */
2408 case '1': /* hardware-breakpoint */
2409 case '2': /* write watchpoint */
2410 case '3': /* read watchpoint */
2411 case '4': /* access watchpoint */
2412 require_running (own_buf
);
2413 if (insert
&& the_target
->insert_point
!= NULL
)
2414 res
= (*the_target
->insert_point
) (type
, addr
, len
);
2415 else if (!insert
&& the_target
->remove_point
!= NULL
)
2416 res
= (*the_target
->remove_point
) (type
, addr
, len
);
2428 write_enn (own_buf
);
2432 response_needed
= 0;
2433 if (!target_running ())
2434 /* The packet we received doesn't make sense - but we can't
2435 reply to it, either. */
2438 fprintf (stderr
, "Killing all inferiors\n");
2439 for_each_inferior (&all_processes
, kill_inferior_callback
);
2441 /* When using the extended protocol, we wait with no program
2442 running. The traditional protocol will exit instead. */
2443 if (extended_protocol
)
2445 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2446 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2456 ptid_t gdb_id
, thread_id
;
2458 require_running (own_buf
);
2460 gdb_id
= read_ptid (&own_buf
[1], NULL
);
2461 thread_id
= gdb_id_to_thread_id (gdb_id
);
2462 if (ptid_equal (thread_id
, null_ptid
))
2464 write_enn (own_buf
);
2468 if (mythread_alive (thread_id
))
2471 write_enn (own_buf
);
2475 response_needed
= 0;
2477 /* Restarting the inferior is only supported in the extended
2479 if (extended_protocol
)
2481 if (target_running ())
2482 for_each_inferior (&all_processes
,
2483 kill_inferior_callback
);
2484 fprintf (stderr
, "GDBserver restarting\n");
2486 /* Wait till we are at 1st instruction in prog. */
2487 if (program_argv
!= NULL
)
2488 start_inferior (program_argv
);
2491 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2492 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2498 /* It is a request we don't understand. Respond with an
2499 empty packet so that gdb knows that we don't support this
2505 /* Extended (long) request. */
2506 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
2510 /* It is a request we don't understand. Respond with an empty
2511 packet so that gdb knows that we don't support this
2517 if (new_packet_len
!= -1)
2518 putpkt_binary (own_buf
, new_packet_len
);
2522 response_needed
= 0;
2524 if (!extended_protocol
&& have_ran
&& !target_running ())
2526 /* In non-stop, defer exiting until GDB had a chance to query
2527 the whole vStopped list (until it gets an OK). */
2530 fprintf (stderr
, "GDBserver exiting\n");
2537 /* Event-loop callback for serial events. */
2540 handle_serial_event (int err
, gdb_client_data client_data
)
2543 fprintf (stderr
, "handling possible serial event\n");
2545 /* Really handle it. */
2546 process_serial_event ();
2548 /* Be sure to not change the selected inferior behind GDB's back.
2549 Important in the non-stop mode asynchronous protocol. */
2550 set_desired_inferior (1);
2553 /* Event-loop callback for target events. */
2556 handle_target_event (int err
, gdb_client_data client_data
)
2559 fprintf (stderr
, "handling possible target event\n");
2561 last_ptid
= mywait (minus_one_ptid
, &last_status
,
2564 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
2566 /* Something interesting. Tell GDB about it. */
2567 push_event (last_ptid
, &last_status
);
2570 /* Be sure to not change the selected inferior behind GDB's back.
2571 Important in the non-stop mode asynchronous protocol. */
2572 set_desired_inferior (1);