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 /* 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
+ chunk_size
+ 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 monitor commands not handled by target-specific handlers. */
666 handle_monitor_command (char *mon
)
668 if (strcmp (mon
, "set debug 1") == 0)
671 monitor_output ("Debug output enabled.\n");
673 else if (strcmp (mon
, "set debug 0") == 0)
676 monitor_output ("Debug output disabled.\n");
678 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
681 monitor_output ("H/W point debugging output enabled.\n");
683 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
686 monitor_output ("H/W point debugging output disabled.\n");
688 else if (strcmp (mon
, "set remote-debug 1") == 0)
691 monitor_output ("Protocol debug output enabled.\n");
693 else if (strcmp (mon
, "set remote-debug 0") == 0)
696 monitor_output ("Protocol debug output disabled.\n");
698 else if (strcmp (mon
, "help") == 0)
699 monitor_show_help ();
700 else if (strcmp (mon
, "exit") == 0)
704 monitor_output ("Unknown monitor command.\n\n");
705 monitor_show_help ();
711 handle_threads_qxfer_proper (struct buffer
*buffer
)
713 struct inferior_list_entry
*thread
;
715 buffer_grow_str (buffer
, "<threads>\n");
717 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
719 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
724 write_ptid (ptid_s
, ptid
);
726 if (the_target
->core_of_thread
)
727 core
= (*the_target
->core_of_thread
) (ptid
);
731 sprintf (core_s
, "%d", core
);
732 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
737 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
742 buffer_grow_str0 (buffer
, "</threads>\n");
746 handle_threads_qxfer (const char *annex
,
747 unsigned char *readbuf
,
748 CORE_ADDR offset
, int length
)
750 static char *result
= 0;
751 static unsigned int result_length
= 0;
753 if (annex
&& strcmp (annex
, "") != 0)
758 struct buffer buffer
;
759 /* When asked for data at offset 0, generate everything and store into
760 'result'. Successive reads will be served off 'result'. */
764 buffer_init (&buffer
);
766 handle_threads_qxfer_proper (&buffer
);
768 result
= buffer_finish (&buffer
);
769 result_length
= strlen (result
);
770 buffer_free (&buffer
);
773 if (offset
>= result_length
)
775 /* We're out of data. */
782 if (length
> result_length
- offset
)
783 length
= result_length
- offset
;
785 memcpy (readbuf
, result
+ offset
, length
);
791 /* Handle all of the extended 'q' packets. */
793 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
795 static struct inferior_list_entry
*thread_ptr
;
797 /* Reply the current thread id. */
798 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
801 require_running (own_buf
);
803 if (!ptid_equal (general_thread
, null_ptid
)
804 && !ptid_equal (general_thread
, minus_one_ptid
))
805 gdb_id
= general_thread
;
808 thread_ptr
= all_threads
.head
;
809 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
812 sprintf (own_buf
, "QC");
814 own_buf
= write_ptid (own_buf
, gdb_id
);
818 if (strcmp ("qSymbol::", own_buf
) == 0)
820 if (target_running () && the_target
->look_up_symbols
!= NULL
)
821 (*the_target
->look_up_symbols
) ();
823 strcpy (own_buf
, "OK");
827 if (!disable_packet_qfThreadInfo
)
829 if (strcmp ("qfThreadInfo", own_buf
) == 0)
833 require_running (own_buf
);
834 thread_ptr
= all_threads
.head
;
837 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
838 write_ptid (own_buf
, gdb_id
);
839 thread_ptr
= thread_ptr
->next
;
843 if (strcmp ("qsThreadInfo", own_buf
) == 0)
847 require_running (own_buf
);
848 if (thread_ptr
!= NULL
)
851 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
852 write_ptid (own_buf
, gdb_id
);
853 thread_ptr
= thread_ptr
->next
;
858 sprintf (own_buf
, "l");
864 if (the_target
->read_offsets
!= NULL
865 && strcmp ("qOffsets", own_buf
) == 0)
867 CORE_ADDR text
, data
;
869 require_running (own_buf
);
870 if (the_target
->read_offsets (&text
, &data
))
871 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
872 (long)text
, (long)data
, (long)data
);
879 if (the_target
->qxfer_spu
!= NULL
880 && strncmp ("qXfer:spu:read:", own_buf
, 15) == 0)
886 unsigned char *spu_buf
;
888 require_running (own_buf
);
889 strcpy (own_buf
, "E00");
890 if (decode_xfer_read (own_buf
+ 15, &annex
, &ofs
, &len
) < 0)
892 if (len
> PBUFSIZ
- 2)
894 spu_buf
= malloc (len
+ 1);
898 n
= (*the_target
->qxfer_spu
) (annex
, spu_buf
, NULL
, ofs
, len
+ 1);
902 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, len
, 1);
904 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, n
, 0);
910 if (the_target
->qxfer_spu
!= NULL
911 && strncmp ("qXfer:spu:write:", own_buf
, 16) == 0)
917 unsigned char *spu_buf
;
919 require_running (own_buf
);
920 strcpy (own_buf
, "E00");
921 spu_buf
= malloc (packet_len
- 15);
924 if (decode_xfer_write (own_buf
+ 16, packet_len
- 16, &annex
,
925 &ofs
, &len
, spu_buf
) < 0)
931 n
= (*the_target
->qxfer_spu
)
932 (annex
, NULL
, (unsigned const char *)spu_buf
, ofs
, len
);
936 sprintf (own_buf
, "%x", n
);
942 if (the_target
->read_auxv
!= NULL
943 && strncmp ("qXfer:auxv:read:", own_buf
, 16) == 0)
951 require_running (own_buf
);
953 /* Reject any annex; grab the offset and length. */
954 if (decode_xfer_read (own_buf
+ 16, &annex
, &ofs
, &len
) < 0
957 strcpy (own_buf
, "E00");
961 /* Read one extra byte, as an indicator of whether there is
963 if (len
> PBUFSIZ
- 2)
965 data
= malloc (len
+ 1);
971 n
= (*the_target
->read_auxv
) (ofs
, data
, len
+ 1);
975 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
977 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
984 if (strncmp ("qXfer:features:read:", own_buf
, 20) == 0)
987 unsigned int len
, total_len
;
988 const char *document
;
991 require_running (own_buf
);
993 /* Grab the annex, offset, and length. */
994 if (decode_xfer_read (own_buf
+ 20, &annex
, &ofs
, &len
) < 0)
996 strcpy (own_buf
, "E00");
1000 /* Now grab the correct annex. */
1001 document
= get_features_xml (annex
);
1002 if (document
== NULL
)
1004 strcpy (own_buf
, "E00");
1008 total_len
= strlen (document
);
1009 if (len
> PBUFSIZ
- 2)
1012 if (ofs
> total_len
)
1013 write_enn (own_buf
);
1014 else if (len
< total_len
- ofs
)
1015 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1018 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1019 total_len
- ofs
, 0);
1024 if (strncmp ("qXfer:libraries:read:", own_buf
, 21) == 0)
1027 unsigned int len
, total_len
;
1029 struct inferior_list_entry
*dll_ptr
;
1032 require_running (own_buf
);
1034 /* Reject any annex; grab the offset and length. */
1035 if (decode_xfer_read (own_buf
+ 21, &annex
, &ofs
, &len
) < 0
1036 || annex
[0] != '\0')
1038 strcpy (own_buf
, "E00");
1042 /* Over-estimate the necessary memory. Assume that every character
1043 in the library name must be escaped. */
1045 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1046 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1048 document
= malloc (total_len
);
1049 if (document
== NULL
)
1051 write_enn (own_buf
);
1054 strcpy (document
, "<library-list>\n");
1055 p
= document
+ strlen (document
);
1057 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1059 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1062 strcpy (p
, " <library name=\"");
1064 name
= xml_escape_text (dll
->name
);
1068 strcpy (p
, "\"><segment address=\"");
1070 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1072 strcpy (p
, "\"/></library>\n");
1076 strcpy (p
, "</library-list>\n");
1078 total_len
= strlen (document
);
1079 if (len
> PBUFSIZ
- 2)
1082 if (ofs
> total_len
)
1083 write_enn (own_buf
);
1084 else if (len
< total_len
- ofs
)
1085 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1088 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1089 total_len
- ofs
, 0);
1095 if (the_target
->qxfer_osdata
!= NULL
1096 && strncmp ("qXfer:osdata:read:", own_buf
, 18) == 0)
1102 unsigned char *workbuf
;
1104 strcpy (own_buf
, "E00");
1105 if (decode_xfer_read (own_buf
+ 18, &annex
, &ofs
, &len
) < 0)
1107 if (len
> PBUFSIZ
- 2)
1109 workbuf
= malloc (len
+ 1);
1113 n
= (*the_target
->qxfer_osdata
) (annex
, workbuf
, NULL
, ofs
, len
+ 1);
1115 write_enn (own_buf
);
1117 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, len
, 1);
1119 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, n
, 0);
1125 if (the_target
->qxfer_siginfo
!= NULL
1126 && strncmp ("qXfer:siginfo:read:", own_buf
, 19) == 0)
1128 unsigned char *data
;
1134 require_running (own_buf
);
1136 /* Reject any annex; grab the offset and length. */
1137 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1138 || annex
[0] != '\0')
1140 strcpy (own_buf
, "E00");
1144 /* Read one extra byte, as an indicator of whether there is
1146 if (len
> PBUFSIZ
- 2)
1148 data
= malloc (len
+ 1);
1151 n
= (*the_target
->qxfer_siginfo
) (annex
, data
, NULL
, ofs
, len
+ 1);
1153 write_enn (own_buf
);
1155 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1157 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1163 if (the_target
->qxfer_siginfo
!= NULL
1164 && strncmp ("qXfer:siginfo:write:", own_buf
, 20) == 0)
1170 unsigned char *data
;
1172 require_running (own_buf
);
1174 strcpy (own_buf
, "E00");
1175 data
= malloc (packet_len
- 19);
1178 if (decode_xfer_write (own_buf
+ 20, packet_len
- 20, &annex
,
1179 &ofs
, &len
, data
) < 0)
1185 n
= (*the_target
->qxfer_siginfo
)
1186 (annex
, NULL
, (unsigned const char *)data
, ofs
, len
);
1188 write_enn (own_buf
);
1190 sprintf (own_buf
, "%x", n
);
1196 if (strncmp ("qXfer:threads:read:", own_buf
, 19) == 0)
1198 unsigned char *data
;
1204 require_running (own_buf
);
1206 /* Reject any annex; grab the offset and length. */
1207 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1208 || annex
[0] != '\0')
1210 strcpy (own_buf
, "E00");
1214 /* Read one extra byte, as an indicator of whether there is
1216 if (len
> PBUFSIZ
- 2)
1218 data
= malloc (len
+ 1);
1221 n
= handle_threads_qxfer (annex
, data
, ofs
, len
+ 1);
1223 write_enn (own_buf
);
1225 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1227 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1233 /* Protocol features query. */
1234 if (strncmp ("qSupported", own_buf
, 10) == 0
1235 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1237 char *p
= &own_buf
[10];
1239 /* Process each feature being provided by GDB. The first
1240 feature will follow a ':', and latter features will follow
1243 for (p
= strtok (p
+ 1, ";");
1245 p
= strtok (NULL
, ";"))
1247 if (strcmp (p
, "multiprocess+") == 0)
1249 /* GDB supports and wants multi-process support if
1251 if (target_supports_multi_process ())
1256 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1258 /* We do not have any hook to indicate whether the target backend
1259 supports qXfer:libraries:read, so always report it. */
1260 strcat (own_buf
, ";qXfer:libraries:read+");
1262 if (the_target
->read_auxv
!= NULL
)
1263 strcat (own_buf
, ";qXfer:auxv:read+");
1265 if (the_target
->qxfer_spu
!= NULL
)
1266 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1268 if (the_target
->qxfer_siginfo
!= NULL
)
1269 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1271 /* We always report qXfer:features:read, as targets may
1272 install XML files on a subsequent call to arch_setup.
1273 If we reported to GDB on startup that we don't support
1274 qXfer:feature:read at all, we will never be re-queried. */
1275 strcat (own_buf
, ";qXfer:features:read+");
1277 if (transport_is_reliable
)
1278 strcat (own_buf
, ";QStartNoAckMode+");
1280 if (the_target
->qxfer_osdata
!= NULL
)
1281 strcat (own_buf
, ";qXfer:osdata:read+");
1283 if (target_supports_multi_process ())
1284 strcat (own_buf
, ";multiprocess+");
1286 if (target_supports_non_stop ())
1287 strcat (own_buf
, ";QNonStop+");
1289 strcat (own_buf
, ";qXfer:threads:read+");
1294 /* Thread-local storage support. */
1295 if (the_target
->get_tls_address
!= NULL
1296 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1298 char *p
= own_buf
+ 12;
1299 CORE_ADDR parts
[2], address
= 0;
1301 ptid_t ptid
= null_ptid
;
1303 require_running (own_buf
);
1305 for (i
= 0; i
< 3; i
++)
1313 p2
= strchr (p
, ',');
1326 ptid
= read_ptid (p
, NULL
);
1328 decode_address (&parts
[i
- 1], p
, len
);
1332 if (p
!= NULL
|| i
< 3)
1336 struct thread_info
*thread
= find_thread_ptid (ptid
);
1341 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1347 sprintf (own_buf
, "%llx", address
);
1352 write_enn (own_buf
);
1356 /* Otherwise, pretend we do not understand this packet. */
1359 /* Handle "monitor" commands. */
1360 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1362 char *mon
= malloc (PBUFSIZ
);
1363 int len
= strlen (own_buf
+ 6);
1367 write_enn (own_buf
);
1371 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1373 write_enn (own_buf
);
1377 mon
[len
/ 2] = '\0';
1381 if (the_target
->handle_monitor_command
== NULL
1382 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1383 /* Default processing. */
1384 handle_monitor_command (mon
);
1390 if (strncmp ("qSearch:memory:", own_buf
, sizeof ("qSearch:memory:") - 1) == 0)
1392 require_running (own_buf
);
1393 handle_search_memory (own_buf
, packet_len
);
1397 if (strcmp (own_buf
, "qAttached") == 0
1398 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1400 struct process_info
*process
;
1402 if (own_buf
[sizeof ("qAttached") - 1])
1404 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1405 process
= (struct process_info
*)
1406 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1410 require_running (own_buf
);
1411 process
= current_process ();
1414 if (process
== NULL
)
1416 write_enn (own_buf
);
1420 strcpy (own_buf
, process
->attached
? "1" : "0");
1424 /* Otherwise we didn't know what packet it was. Say we didn't
1429 /* Parse vCont packets. */
1431 handle_v_cont (char *own_buf
)
1435 struct thread_resume
*resume_info
;
1436 struct thread_resume default_action
= {{0}};
1438 /* Count the number of semicolons in the packet. There should be one
1439 for every action. */
1445 p
= strchr (p
, ';');
1448 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1449 if (resume_info
== NULL
)
1457 if (p
[0] == 's' || p
[0] == 'S')
1458 resume_info
[i
].kind
= resume_step
;
1459 else if (p
[0] == 'c' || p
[0] == 'C')
1460 resume_info
[i
].kind
= resume_continue
;
1461 else if (p
[0] == 't')
1462 resume_info
[i
].kind
= resume_stop
;
1466 if (p
[0] == 'S' || p
[0] == 'C')
1469 sig
= strtol (p
+ 1, &q
, 16);
1474 if (!target_signal_to_host_p (sig
))
1476 resume_info
[i
].sig
= target_signal_to_host (sig
);
1480 resume_info
[i
].sig
= 0;
1486 resume_info
[i
].thread
= minus_one_ptid
;
1487 default_action
= resume_info
[i
];
1489 /* Note: we don't increment i here, we'll overwrite this entry
1490 the next time through. */
1492 else if (p
[0] == ':')
1494 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1499 if (p
[0] != ';' && p
[0] != 0)
1502 resume_info
[i
].thread
= ptid
;
1509 resume_info
[i
] = default_action
;
1511 /* Still used in occasional places in the backend. */
1513 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1514 && resume_info
[0].kind
!= resume_stop
)
1515 cont_thread
= resume_info
[0].thread
;
1517 cont_thread
= minus_one_ptid
;
1518 set_desired_inferior (0);
1523 (*the_target
->resume
) (resume_info
, n
);
1531 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1532 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1533 disable_async_io ();
1538 write_enn (own_buf
);
1543 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1545 handle_v_attach (char *own_buf
)
1549 pid
= strtol (own_buf
+ 8, NULL
, 16);
1550 if (pid
!= 0 && attach_inferior (pid
) == 0)
1552 /* Don't report shared library events after attaching, even if
1553 some libraries are preloaded. GDB will always poll the
1554 library list. Avoids the "stopped by shared library event"
1555 notice on the GDB side. */
1560 /* In non-stop, we don't send a resume reply. Stop events
1561 will follow up using the normal notification
1566 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1572 write_enn (own_buf
);
1577 /* Run a new program. Return 1 if successful, 0 if failure. */
1579 handle_v_run (char *own_buf
)
1581 char *p
, *next_p
, **new_argv
;
1585 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1591 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1592 if (new_argv
== NULL
)
1594 write_enn (own_buf
);
1599 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
1601 next_p
= strchr (p
, ';');
1603 next_p
= p
+ strlen (p
);
1605 if (i
== 0 && p
== next_p
)
1609 /* FIXME: Fail request if out of memory instead of dying. */
1610 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
1611 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
1612 new_argv
[i
][(next_p
- p
) / 2] = '\0';
1621 if (new_argv
[0] == NULL
)
1623 /* GDB didn't specify a program to run. Use the program from the
1624 last run with the new argument list. */
1626 if (program_argv
== NULL
)
1628 /* FIXME: new_argv memory leak */
1629 write_enn (own_buf
);
1633 new_argv
[0] = strdup (program_argv
[0]);
1634 if (new_argv
[0] == NULL
)
1636 /* FIXME: new_argv memory leak */
1637 write_enn (own_buf
);
1642 /* Free the old argv and install the new one. */
1643 freeargv (program_argv
);
1644 program_argv
= new_argv
;
1646 start_inferior (program_argv
);
1647 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
1649 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1651 /* In non-stop, sending a resume reply doesn't set the general
1652 thread, but GDB assumes a vRun sets it (this is so GDB can
1653 query which is the main thread of the new inferior. */
1655 general_thread
= last_ptid
;
1661 write_enn (own_buf
);
1666 /* Kill process. Return 1 if successful, 0 if failure. */
1668 handle_v_kill (char *own_buf
)
1671 char *p
= &own_buf
[6];
1673 pid
= strtol (p
, NULL
, 16);
1676 if (pid
!= 0 && kill_inferior (pid
) == 0)
1678 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1679 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
1680 last_ptid
= pid_to_ptid (pid
);
1681 discard_queued_stop_replies (pid
);
1687 write_enn (own_buf
);
1692 /* Handle a 'vStopped' packet. */
1694 handle_v_stopped (char *own_buf
)
1696 /* If we're waiting for GDB to acknowledge a pending stop reply,
1697 consider that done. */
1700 struct vstop_notif
*head
;
1703 fprintf (stderr
, "vStopped: acking %s\n",
1704 target_pid_to_str (notif_queue
->ptid
));
1707 notif_queue
= notif_queue
->next
;
1711 /* Push another stop reply, or if there are no more left, an OK. */
1712 send_next_stop_reply (own_buf
);
1715 /* Handle all of the extended 'v' packets. */
1717 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
1719 if (!disable_packet_vCont
)
1721 if (strncmp (own_buf
, "vCont;", 6) == 0)
1723 require_running (own_buf
);
1724 handle_v_cont (own_buf
);
1728 if (strncmp (own_buf
, "vCont?", 6) == 0)
1730 strcpy (own_buf
, "vCont;c;C;s;S;t");
1735 if (strncmp (own_buf
, "vFile:", 6) == 0
1736 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
1739 if (strncmp (own_buf
, "vAttach;", 8) == 0)
1741 if (!multi_process
&& target_running ())
1743 fprintf (stderr
, "Already debugging a process\n");
1744 write_enn (own_buf
);
1747 handle_v_attach (own_buf
);
1751 if (strncmp (own_buf
, "vRun;", 5) == 0)
1753 if (!multi_process
&& target_running ())
1755 fprintf (stderr
, "Already debugging a process\n");
1756 write_enn (own_buf
);
1759 handle_v_run (own_buf
);
1763 if (strncmp (own_buf
, "vKill;", 6) == 0)
1765 if (!target_running ())
1767 fprintf (stderr
, "No process to kill\n");
1768 write_enn (own_buf
);
1771 handle_v_kill (own_buf
);
1775 if (strncmp (own_buf
, "vStopped", 8) == 0)
1777 handle_v_stopped (own_buf
);
1781 /* Otherwise we didn't know what packet it was. Say we didn't
1787 /* Resume inferior and wait for another event. In non-stop mode,
1788 don't really wait here, but return immediatelly to the event
1791 myresume (char *own_buf
, int step
, int sig
)
1793 struct thread_resume resume_info
[2];
1795 int valid_cont_thread
;
1797 set_desired_inferior (0);
1799 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
1800 && !ptid_equal (cont_thread
, minus_one_ptid
));
1802 if (step
|| sig
|| valid_cont_thread
)
1804 resume_info
[0].thread
1805 = ((struct inferior_list_entry
*) current_inferior
)->id
;
1807 resume_info
[0].kind
= resume_step
;
1809 resume_info
[0].kind
= resume_continue
;
1810 resume_info
[0].sig
= sig
;
1814 if (!valid_cont_thread
)
1816 resume_info
[n
].thread
= minus_one_ptid
;
1817 resume_info
[n
].kind
= resume_continue
;
1818 resume_info
[n
].sig
= 0;
1825 (*the_target
->resume
) (resume_info
, n
);
1831 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1832 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1833 disable_async_io ();
1837 /* Callback for for_each_inferior. Make a new stop reply for each
1841 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
1843 int pid
= * (int *) arg
;
1846 || ptid_get_pid (entry
->id
) == pid
)
1848 struct target_waitstatus status
;
1850 status
.kind
= TARGET_WAITKIND_STOPPED
;
1851 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1853 /* Pass the last stop reply back to GDB, but don't notify. */
1854 queue_stop_reply (entry
->id
, &status
);
1860 /* Status handler for the '?' packet. */
1863 handle_status (char *own_buf
)
1865 struct target_waitstatus status
;
1866 status
.kind
= TARGET_WAITKIND_STOPPED
;
1867 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1869 /* In non-stop mode, we must send a stop reply for each stopped
1870 thread. In all-stop mode, just send one for the first stopped
1876 discard_queued_stop_replies (pid
);
1877 find_inferior (&all_threads
, queue_stop_reply_callback
, &pid
);
1879 /* The first is sent immediatly. OK is sent if there is no
1880 stopped thread, which is the same handling of the vStopped
1881 packet (by design). */
1882 send_next_stop_reply (own_buf
);
1886 if (all_threads
.head
)
1887 prepare_resume_reply (own_buf
,
1888 all_threads
.head
->id
, &status
);
1890 strcpy (own_buf
, "W00");
1895 gdbserver_version (void)
1897 printf ("GNU gdbserver %s%s\n"
1898 "Copyright (C) 2010 Free Software Foundation, Inc.\n"
1899 "gdbserver is free software, covered by the GNU General Public License.\n"
1900 "This gdbserver was configured as \"%s\"\n",
1901 PKGVERSION
, version
, host_name
);
1905 gdbserver_usage (FILE *stream
)
1907 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1908 "\tgdbserver [OPTIONS] --attach COMM PID\n"
1909 "\tgdbserver [OPTIONS] --multi COMM\n"
1911 "COMM may either be a tty device (for serial debugging), or \n"
1912 "HOST:PORT to listen for a TCP connection.\n"
1915 " --debug Enable general debugging output.\n"
1916 " --remote-debug Enable remote protocol debugging output.\n"
1917 " --version Display version information and exit.\n"
1918 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
1919 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
1920 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
1924 gdbserver_show_disableable (FILE *stream
)
1926 fprintf (stream
, "Disableable packets:\n"
1927 " vCont \tAll vCont packets\n"
1928 " qC \tQuerying the current thread\n"
1929 " qfThreadInfo\tThread listing\n"
1930 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
1931 " threads \tAll of the above\n");
1935 #undef require_running
1936 #define require_running(BUF) \
1937 if (!target_running ()) \
1944 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
1946 int pid
= * (int *) args
;
1948 if (ptid_get_pid (entry
->id
) == pid
)
1955 kill_inferior_callback (struct inferior_list_entry
*entry
)
1957 struct process_info
*process
= (struct process_info
*) entry
;
1958 int pid
= ptid_get_pid (process
->head
.id
);
1960 kill_inferior (pid
);
1961 discard_queued_stop_replies (pid
);
1964 /* Callback for for_each_inferior to detach or kill the inferior,
1965 depending on whether we attached to it or not.
1966 We inform the user whether we're detaching or killing the process
1967 as this is only called when gdbserver is about to exit. */
1970 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
1972 struct process_info
*process
= (struct process_info
*) entry
;
1973 int pid
= ptid_get_pid (process
->head
.id
);
1975 if (process
->attached
)
1976 detach_inferior (pid
);
1978 kill_inferior (pid
);
1980 discard_queued_stop_replies (pid
);
1983 /* for_each_inferior callback for detach_or_kill_for_exit to print
1984 the pids of started inferiors. */
1987 print_started_pid (struct inferior_list_entry
*entry
)
1989 struct process_info
*process
= (struct process_info
*) entry
;
1991 if (! process
->attached
)
1993 int pid
= ptid_get_pid (process
->head
.id
);
1994 fprintf (stderr
, " %d", pid
);
1998 /* for_each_inferior callback for detach_or_kill_for_exit to print
1999 the pids of attached inferiors. */
2002 print_attached_pid (struct inferior_list_entry
*entry
)
2004 struct process_info
*process
= (struct process_info
*) entry
;
2006 if (process
->attached
)
2008 int pid
= ptid_get_pid (process
->head
.id
);
2009 fprintf (stderr
, " %d", pid
);
2013 /* Call this when exiting gdbserver with possible inferiors that need
2014 to be killed or detached from. */
2017 detach_or_kill_for_exit (void)
2019 /* First print a list of the inferiors we will be killing/detaching.
2020 This is to assist the user, for example, in case the inferior unexpectedly
2021 dies after we exit: did we screw up or did the inferior exit on its own?
2022 Having this info will save some head-scratching. */
2024 if (have_started_inferiors_p ())
2026 fprintf (stderr
, "Killing process(es):");
2027 for_each_inferior (&all_processes
, print_started_pid
);
2028 fprintf (stderr
, "\n");
2030 if (have_attached_inferiors_p ())
2032 fprintf (stderr
, "Detaching process(es):");
2033 for_each_inferior (&all_processes
, print_attached_pid
);
2034 fprintf (stderr
, "\n");
2037 /* Now we can kill or detach the inferiors. */
2039 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2043 join_inferiors_callback (struct inferior_list_entry
*entry
)
2045 struct process_info
*process
= (struct process_info
*) entry
;
2047 /* If we are attached, then we can exit. Otherwise, we need to hang
2048 around doing nothing, until the child is gone. */
2049 if (!process
->attached
)
2050 join_inferior (ptid_get_pid (process
->head
.id
));
2054 main (int argc
, char *argv
[])
2058 char *arg_end
, *port
;
2059 char **next_arg
= &argv
[1];
2064 while (*next_arg
!= NULL
&& **next_arg
== '-')
2066 if (strcmp (*next_arg
, "--version") == 0)
2068 gdbserver_version ();
2071 else if (strcmp (*next_arg
, "--help") == 0)
2073 gdbserver_usage (stdout
);
2076 else if (strcmp (*next_arg
, "--attach") == 0)
2078 else if (strcmp (*next_arg
, "--multi") == 0)
2080 else if (strcmp (*next_arg
, "--wrapper") == 0)
2084 wrapper_argv
= next_arg
;
2085 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2088 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2090 gdbserver_usage (stderr
);
2094 /* Consume the "--". */
2097 else if (strcmp (*next_arg
, "--debug") == 0)
2099 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2101 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2103 gdbserver_show_disableable (stdout
);
2106 else if (strncmp (*next_arg
,
2107 "--disable-packet=",
2108 sizeof ("--disable-packet=") - 1) == 0)
2110 char *packets
, *tok
;
2112 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2113 for (tok
= strtok (packets
, ",");
2115 tok
= strtok (NULL
, ","))
2117 if (strcmp ("vCont", tok
) == 0)
2118 disable_packet_vCont
= 1;
2119 else if (strcmp ("Tthread", tok
) == 0)
2120 disable_packet_Tthread
= 1;
2121 else if (strcmp ("qC", tok
) == 0)
2122 disable_packet_qC
= 1;
2123 else if (strcmp ("qfThreadInfo", tok
) == 0)
2124 disable_packet_qfThreadInfo
= 1;
2125 else if (strcmp ("threads", tok
) == 0)
2127 disable_packet_vCont
= 1;
2128 disable_packet_Tthread
= 1;
2129 disable_packet_qC
= 1;
2130 disable_packet_qfThreadInfo
= 1;
2134 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2136 gdbserver_show_disableable (stderr
);
2143 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2151 if (setjmp (toplevel
))
2153 fprintf (stderr
, "Exiting\n");
2159 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2161 gdbserver_usage (stderr
);
2168 /* --attach used to come after PORT, so allow it there for
2170 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2177 && (*next_arg
== NULL
2178 || (*next_arg
)[0] == '\0'
2179 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2181 || next_arg
[1] != NULL
))
2186 gdbserver_usage (stderr
);
2190 initialize_inferiors ();
2191 initialize_async_io ();
2194 own_buf
= xmalloc (PBUFSIZ
+ 1);
2195 mem_buf
= xmalloc (PBUFSIZ
);
2197 if (pid
== 0 && *next_arg
!= NULL
)
2201 n
= argc
- (next_arg
- argv
);
2202 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2203 for (i
= 0; i
< n
; i
++)
2204 program_argv
[i
] = xstrdup (next_arg
[i
]);
2205 program_argv
[i
] = NULL
;
2207 /* Wait till we are at first instruction in program. */
2208 start_inferior (program_argv
);
2210 /* We are now (hopefully) stopped at the first instruction of
2211 the target process. This assumes that the target process was
2212 successfully created. */
2216 if (attach_inferior (pid
) == -1)
2217 error ("Attaching not supported on this target");
2219 /* Otherwise succeeded. */
2223 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2224 last_status
.value
.integer
= 0;
2225 last_ptid
= minus_one_ptid
;
2228 /* Don't report shared library events on the initial connection,
2229 even if some libraries are preloaded. Avoids the "stopped by
2230 shared library event" notice on gdb side. */
2233 if (setjmp (toplevel
))
2235 detach_or_kill_for_exit ();
2239 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2240 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2245 if (!was_running
&& !multi_mode
)
2247 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2259 if (setjmp (toplevel
) != 0)
2261 /* An error occurred. */
2262 if (response_needed
)
2264 write_enn (own_buf
);
2269 /* Wait for events. This will return when all event sources are
2270 removed from the event loop. */
2271 start_event_loop ();
2273 /* If an exit was requested (using the "monitor exit" command),
2274 terminate now. The only other way to get here is for
2275 getpkt to fail; close the connection and reopen it at the
2280 detach_or_kill_for_exit ();
2284 fprintf (stderr
, "Remote side has terminated connection. "
2285 "GDBserver will reopen the connection.\n");
2289 /* Event loop callback that handles a serial event. The first byte in
2290 the serial buffer gets us here. We expect characters to arrive at
2291 a brisk pace, so we read the rest of the packet with a blocking
2295 process_serial_event (void)
2305 int new_packet_len
= -1;
2307 /* Used to decide when gdbserver should exit in
2308 multi-mode/remote. */
2309 static int have_ran
= 0;
2312 have_ran
= target_running ();
2314 disable_async_io ();
2316 response_needed
= 0;
2317 packet_len
= getpkt (own_buf
);
2318 if (packet_len
<= 0)
2324 response_needed
= 1;
2331 handle_query (own_buf
, packet_len
, &new_packet_len
);
2334 handle_general_set (own_buf
);
2337 require_running (own_buf
);
2342 pid
= strtol (&own_buf
[i
], NULL
, 16);
2346 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2348 fprintf (stderr
, "Detaching from process %d\n", pid
);
2349 if (detach_inferior (pid
) != 0)
2350 write_enn (own_buf
);
2353 discard_queued_stop_replies (pid
);
2356 if (extended_protocol
)
2358 /* Treat this like a normal program exit. */
2359 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2360 last_status
.value
.integer
= 0;
2361 last_ptid
= pid_to_ptid (pid
);
2363 current_inferior
= NULL
;
2370 /* If we are attached, then we can exit. Otherwise, we
2371 need to hang around doing nothing, until the child is
2373 for_each_inferior (&all_processes
,
2374 join_inferiors_callback
);
2380 extended_protocol
= 1;
2384 handle_status (own_buf
);
2387 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2389 ptid_t gdb_id
, thread_id
;
2392 require_running (own_buf
);
2394 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2396 pid
= ptid_get_pid (gdb_id
);
2398 if (ptid_equal (gdb_id
, null_ptid
)
2399 || ptid_equal (gdb_id
, minus_one_ptid
))
2400 thread_id
= null_ptid
;
2402 && ptid_equal (pid_to_ptid (pid
),
2405 struct thread_info
*thread
=
2406 (struct thread_info
*) find_inferior (&all_threads
,
2411 write_enn (own_buf
);
2415 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2419 thread_id
= gdb_id_to_thread_id (gdb_id
);
2420 if (ptid_equal (thread_id
, null_ptid
))
2422 write_enn (own_buf
);
2427 if (own_buf
[1] == 'g')
2429 if (ptid_equal (thread_id
, null_ptid
))
2431 /* GDB is telling us to choose any thread. Check if
2432 the currently selected thread is still valid. If
2433 it is not, select the first available. */
2434 struct thread_info
*thread
=
2435 (struct thread_info
*) find_inferior_id (&all_threads
,
2438 thread_id
= all_threads
.head
->id
;
2441 general_thread
= thread_id
;
2442 set_desired_inferior (1);
2444 else if (own_buf
[1] == 'c')
2445 cont_thread
= thread_id
;
2446 else if (own_buf
[1] == 's')
2447 step_thread
= thread_id
;
2453 /* Silently ignore it so that gdb can extend the protocol
2454 without compatibility headaches. */
2459 require_running (own_buf
);
2460 set_desired_inferior (1);
2461 registers_to_string (own_buf
);
2464 require_running (own_buf
);
2465 set_desired_inferior (1);
2466 registers_from_string (&own_buf
[1]);
2470 require_running (own_buf
);
2471 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
2472 if (read_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2473 convert_int_to_ascii (mem_buf
, own_buf
, len
);
2475 write_enn (own_buf
);
2478 require_running (own_buf
);
2479 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, mem_buf
);
2480 if (write_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2483 write_enn (own_buf
);
2486 require_running (own_buf
);
2487 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
2488 &mem_addr
, &len
, mem_buf
) < 0
2489 || write_inferior_memory (mem_addr
, mem_buf
, len
) != 0)
2490 write_enn (own_buf
);
2495 require_running (own_buf
);
2496 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2497 if (target_signal_to_host_p (sig
))
2498 signal
= target_signal_to_host (sig
);
2501 myresume (own_buf
, 0, signal
);
2504 require_running (own_buf
);
2505 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2506 if (target_signal_to_host_p (sig
))
2507 signal
= target_signal_to_host (sig
);
2510 myresume (own_buf
, 1, signal
);
2513 require_running (own_buf
);
2515 myresume (own_buf
, 0, signal
);
2518 require_running (own_buf
);
2520 myresume (own_buf
, 1, signal
);
2522 case 'Z': /* insert_ ... */
2524 case 'z': /* remove_ ... */
2528 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
2529 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
2530 char type
= own_buf
[1];
2532 const int insert
= ch
== 'Z';
2534 /* Default to unrecognized/unsupported. */
2538 case '0': /* software-breakpoint */
2539 case '1': /* hardware-breakpoint */
2540 case '2': /* write watchpoint */
2541 case '3': /* read watchpoint */
2542 case '4': /* access watchpoint */
2543 require_running (own_buf
);
2544 if (insert
&& the_target
->insert_point
!= NULL
)
2545 res
= (*the_target
->insert_point
) (type
, addr
, len
);
2546 else if (!insert
&& the_target
->remove_point
!= NULL
)
2547 res
= (*the_target
->remove_point
) (type
, addr
, len
);
2559 write_enn (own_buf
);
2563 response_needed
= 0;
2564 if (!target_running ())
2565 /* The packet we received doesn't make sense - but we can't
2566 reply to it, either. */
2569 fprintf (stderr
, "Killing all inferiors\n");
2570 for_each_inferior (&all_processes
, kill_inferior_callback
);
2572 /* When using the extended protocol, we wait with no program
2573 running. The traditional protocol will exit instead. */
2574 if (extended_protocol
)
2576 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2577 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2587 ptid_t gdb_id
, thread_id
;
2589 require_running (own_buf
);
2591 gdb_id
= read_ptid (&own_buf
[1], NULL
);
2592 thread_id
= gdb_id_to_thread_id (gdb_id
);
2593 if (ptid_equal (thread_id
, null_ptid
))
2595 write_enn (own_buf
);
2599 if (mythread_alive (thread_id
))
2602 write_enn (own_buf
);
2606 response_needed
= 0;
2608 /* Restarting the inferior is only supported in the extended
2610 if (extended_protocol
)
2612 if (target_running ())
2613 for_each_inferior (&all_processes
,
2614 kill_inferior_callback
);
2615 fprintf (stderr
, "GDBserver restarting\n");
2617 /* Wait till we are at 1st instruction in prog. */
2618 if (program_argv
!= NULL
)
2619 start_inferior (program_argv
);
2622 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2623 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2629 /* It is a request we don't understand. Respond with an
2630 empty packet so that gdb knows that we don't support this
2636 /* Extended (long) request. */
2637 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
2641 /* It is a request we don't understand. Respond with an empty
2642 packet so that gdb knows that we don't support this
2648 if (new_packet_len
!= -1)
2649 putpkt_binary (own_buf
, new_packet_len
);
2653 response_needed
= 0;
2655 if (!extended_protocol
&& have_ran
&& !target_running ())
2657 /* In non-stop, defer exiting until GDB had a chance to query
2658 the whole vStopped list (until it gets an OK). */
2661 fprintf (stderr
, "GDBserver exiting\n");
2668 /* Event-loop callback for serial events. */
2671 handle_serial_event (int err
, gdb_client_data client_data
)
2674 fprintf (stderr
, "handling possible serial event\n");
2676 /* Really handle it. */
2677 process_serial_event ();
2679 /* Be sure to not change the selected inferior behind GDB's back.
2680 Important in the non-stop mode asynchronous protocol. */
2681 set_desired_inferior (1);
2684 /* Event-loop callback for target events. */
2687 handle_target_event (int err
, gdb_client_data client_data
)
2690 fprintf (stderr
, "handling possible target event\n");
2692 last_ptid
= mywait (minus_one_ptid
, &last_status
,
2695 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
2697 /* Something interesting. Tell GDB about it. */
2698 push_event (last_ptid
, &last_status
);
2701 /* Be sure to not change the selected inferior behind GDB's back.
2702 Important in the non-stop mode asynchronous protocol. */
2703 set_desired_inferior (1);