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 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 ();
710 /* Handle all of the extended 'q' packets. */
712 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
714 static struct inferior_list_entry
*thread_ptr
;
716 /* Reply the current thread id. */
717 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
720 require_running (own_buf
);
722 if (!ptid_equal (general_thread
, null_ptid
)
723 && !ptid_equal (general_thread
, minus_one_ptid
))
724 gdb_id
= general_thread
;
727 thread_ptr
= all_threads
.head
;
728 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
731 sprintf (own_buf
, "QC");
733 own_buf
= write_ptid (own_buf
, gdb_id
);
737 if (strcmp ("qSymbol::", own_buf
) == 0)
739 if (target_running () && the_target
->look_up_symbols
!= NULL
)
740 (*the_target
->look_up_symbols
) ();
742 strcpy (own_buf
, "OK");
746 if (!disable_packet_qfThreadInfo
)
748 if (strcmp ("qfThreadInfo", own_buf
) == 0)
752 require_running (own_buf
);
753 thread_ptr
= all_threads
.head
;
756 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
757 write_ptid (own_buf
, gdb_id
);
758 thread_ptr
= thread_ptr
->next
;
762 if (strcmp ("qsThreadInfo", own_buf
) == 0)
766 require_running (own_buf
);
767 if (thread_ptr
!= NULL
)
770 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
771 write_ptid (own_buf
, gdb_id
);
772 thread_ptr
= thread_ptr
->next
;
777 sprintf (own_buf
, "l");
783 if (the_target
->read_offsets
!= NULL
784 && strcmp ("qOffsets", own_buf
) == 0)
786 CORE_ADDR text
, data
;
788 require_running (own_buf
);
789 if (the_target
->read_offsets (&text
, &data
))
790 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
791 (long)text
, (long)data
, (long)data
);
798 if (the_target
->qxfer_spu
!= NULL
799 && strncmp ("qXfer:spu:read:", own_buf
, 15) == 0)
805 unsigned char *spu_buf
;
807 require_running (own_buf
);
808 strcpy (own_buf
, "E00");
809 if (decode_xfer_read (own_buf
+ 15, &annex
, &ofs
, &len
) < 0)
811 if (len
> PBUFSIZ
- 2)
813 spu_buf
= malloc (len
+ 1);
817 n
= (*the_target
->qxfer_spu
) (annex
, spu_buf
, NULL
, ofs
, len
+ 1);
821 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, len
, 1);
823 *new_packet_len_p
= write_qxfer_response (own_buf
, spu_buf
, n
, 0);
829 if (the_target
->qxfer_spu
!= NULL
830 && strncmp ("qXfer:spu:write:", own_buf
, 16) == 0)
836 unsigned char *spu_buf
;
838 require_running (own_buf
);
839 strcpy (own_buf
, "E00");
840 spu_buf
= malloc (packet_len
- 15);
843 if (decode_xfer_write (own_buf
+ 16, packet_len
- 16, &annex
,
844 &ofs
, &len
, spu_buf
) < 0)
850 n
= (*the_target
->qxfer_spu
)
851 (annex
, NULL
, (unsigned const char *)spu_buf
, ofs
, len
);
855 sprintf (own_buf
, "%x", n
);
861 if (the_target
->read_auxv
!= NULL
862 && strncmp ("qXfer:auxv:read:", own_buf
, 16) == 0)
870 require_running (own_buf
);
872 /* Reject any annex; grab the offset and length. */
873 if (decode_xfer_read (own_buf
+ 16, &annex
, &ofs
, &len
) < 0
876 strcpy (own_buf
, "E00");
880 /* Read one extra byte, as an indicator of whether there is
882 if (len
> PBUFSIZ
- 2)
884 data
= malloc (len
+ 1);
890 n
= (*the_target
->read_auxv
) (ofs
, data
, len
+ 1);
894 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
896 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
903 if (strncmp ("qXfer:features:read:", own_buf
, 20) == 0)
906 unsigned int len
, total_len
;
907 const char *document
;
910 require_running (own_buf
);
912 /* Grab the annex, offset, and length. */
913 if (decode_xfer_read (own_buf
+ 20, &annex
, &ofs
, &len
) < 0)
915 strcpy (own_buf
, "E00");
919 /* Now grab the correct annex. */
920 document
= get_features_xml (annex
);
921 if (document
== NULL
)
923 strcpy (own_buf
, "E00");
927 total_len
= strlen (document
);
928 if (len
> PBUFSIZ
- 2)
933 else if (len
< total_len
- ofs
)
934 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
937 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
943 if (strncmp ("qXfer:libraries:read:", own_buf
, 21) == 0)
946 unsigned int len
, total_len
;
948 struct inferior_list_entry
*dll_ptr
;
951 require_running (own_buf
);
953 /* Reject any annex; grab the offset and length. */
954 if (decode_xfer_read (own_buf
+ 21, &annex
, &ofs
, &len
) < 0
957 strcpy (own_buf
, "E00");
961 /* Over-estimate the necessary memory. Assume that every character
962 in the library name must be escaped. */
964 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
965 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
967 document
= malloc (total_len
);
968 if (document
== NULL
)
973 strcpy (document
, "<library-list>\n");
974 p
= document
+ strlen (document
);
976 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
978 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
981 strcpy (p
, " <library name=\"");
983 name
= xml_escape_text (dll
->name
);
987 strcpy (p
, "\"><segment address=\"");
989 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
991 strcpy (p
, "\"/></library>\n");
995 strcpy (p
, "</library-list>\n");
997 total_len
= strlen (document
);
998 if (len
> PBUFSIZ
- 2)
1001 if (ofs
> total_len
)
1002 write_enn (own_buf
);
1003 else if (len
< total_len
- ofs
)
1004 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1007 *new_packet_len_p
= write_qxfer_response (own_buf
, document
+ ofs
,
1008 total_len
- ofs
, 0);
1014 if (the_target
->qxfer_osdata
!= NULL
1015 && strncmp ("qXfer:osdata:read:", own_buf
, 18) == 0)
1021 unsigned char *workbuf
;
1023 strcpy (own_buf
, "E00");
1024 if (decode_xfer_read (own_buf
+ 18, &annex
, &ofs
, &len
) < 0)
1026 if (len
> PBUFSIZ
- 2)
1028 workbuf
= malloc (len
+ 1);
1032 n
= (*the_target
->qxfer_osdata
) (annex
, workbuf
, NULL
, ofs
, len
+ 1);
1034 write_enn (own_buf
);
1036 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, len
, 1);
1038 *new_packet_len_p
= write_qxfer_response (own_buf
, workbuf
, n
, 0);
1044 if (the_target
->qxfer_siginfo
!= NULL
1045 && strncmp ("qXfer:siginfo:read:", own_buf
, 19) == 0)
1047 unsigned char *data
;
1053 require_running (own_buf
);
1055 /* Reject any annex; grab the offset and length. */
1056 if (decode_xfer_read (own_buf
+ 19, &annex
, &ofs
, &len
) < 0
1057 || annex
[0] != '\0')
1059 strcpy (own_buf
, "E00");
1063 /* Read one extra byte, as an indicator of whether there is
1065 if (len
> PBUFSIZ
- 2)
1067 data
= malloc (len
+ 1);
1070 n
= (*the_target
->qxfer_siginfo
) (annex
, data
, NULL
, ofs
, len
+ 1);
1072 write_enn (own_buf
);
1074 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1076 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1082 if (the_target
->qxfer_siginfo
!= NULL
1083 && strncmp ("qXfer:siginfo:write:", own_buf
, 20) == 0)
1089 unsigned char *data
;
1091 require_running (own_buf
);
1093 strcpy (own_buf
, "E00");
1094 data
= malloc (packet_len
- 19);
1097 if (decode_xfer_write (own_buf
+ 20, packet_len
- 20, &annex
,
1098 &ofs
, &len
, data
) < 0)
1104 n
= (*the_target
->qxfer_siginfo
)
1105 (annex
, NULL
, (unsigned const char *)data
, ofs
, len
);
1107 write_enn (own_buf
);
1109 sprintf (own_buf
, "%x", n
);
1115 /* Protocol features query. */
1116 if (strncmp ("qSupported", own_buf
, 10) == 0
1117 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1119 char *p
= &own_buf
[10];
1121 /* Process each feature being provided by GDB. The first
1122 feature will follow a ':', and latter features will follow
1125 for (p
= strtok (p
+ 1, ";");
1127 p
= strtok (NULL
, ";"))
1129 if (strcmp (p
, "multiprocess+") == 0)
1131 /* GDB supports and wants multi-process support if
1133 if (target_supports_multi_process ())
1138 sprintf (own_buf
, "PacketSize=%x;QPassSignals+", PBUFSIZ
- 1);
1140 /* We do not have any hook to indicate whether the target backend
1141 supports qXfer:libraries:read, so always report it. */
1142 strcat (own_buf
, ";qXfer:libraries:read+");
1144 if (the_target
->read_auxv
!= NULL
)
1145 strcat (own_buf
, ";qXfer:auxv:read+");
1147 if (the_target
->qxfer_spu
!= NULL
)
1148 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1150 if (the_target
->qxfer_siginfo
!= NULL
)
1151 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1153 /* We always report qXfer:features:read, as targets may
1154 install XML files on a subsequent call to arch_setup.
1155 If we reported to GDB on startup that we don't support
1156 qXfer:feature:read at all, we will never be re-queried. */
1157 strcat (own_buf
, ";qXfer:features:read+");
1159 if (transport_is_reliable
)
1160 strcat (own_buf
, ";QStartNoAckMode+");
1162 if (the_target
->qxfer_osdata
!= NULL
)
1163 strcat (own_buf
, ";qXfer:osdata:read+");
1165 if (target_supports_multi_process ())
1166 strcat (own_buf
, ";multiprocess+");
1168 if (target_supports_non_stop ())
1169 strcat (own_buf
, ";QNonStop+");
1174 /* Thread-local storage support. */
1175 if (the_target
->get_tls_address
!= NULL
1176 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1178 char *p
= own_buf
+ 12;
1179 CORE_ADDR parts
[2], address
= 0;
1181 ptid_t ptid
= null_ptid
;
1183 require_running (own_buf
);
1185 for (i
= 0; i
< 3; i
++)
1193 p2
= strchr (p
, ',');
1206 ptid
= read_ptid (p
, NULL
);
1208 decode_address (&parts
[i
- 1], p
, len
);
1212 if (p
!= NULL
|| i
< 3)
1216 struct thread_info
*thread
= find_thread_ptid (ptid
);
1221 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1227 sprintf (own_buf
, "%llx", address
);
1232 write_enn (own_buf
);
1236 /* Otherwise, pretend we do not understand this packet. */
1239 /* Handle "monitor" commands. */
1240 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1242 char *mon
= malloc (PBUFSIZ
);
1243 int len
= strlen (own_buf
+ 6);
1247 write_enn (own_buf
);
1251 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1253 write_enn (own_buf
);
1257 mon
[len
/ 2] = '\0';
1261 if (the_target
->handle_monitor_command
== NULL
1262 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1263 /* Default processing. */
1264 handle_monitor_command (mon
);
1270 if (strncmp ("qSearch:memory:", own_buf
, sizeof ("qSearch:memory:") - 1) == 0)
1272 require_running (own_buf
);
1273 handle_search_memory (own_buf
, packet_len
);
1277 if (strcmp (own_buf
, "qAttached") == 0
1278 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1280 struct process_info
*process
;
1282 if (own_buf
[sizeof ("qAttached") - 1])
1284 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1285 process
= (struct process_info
*)
1286 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1290 require_running (own_buf
);
1291 process
= current_process ();
1294 if (process
== NULL
)
1296 write_enn (own_buf
);
1300 strcpy (own_buf
, process
->attached
? "1" : "0");
1304 /* Otherwise we didn't know what packet it was. Say we didn't
1309 /* Parse vCont packets. */
1311 handle_v_cont (char *own_buf
)
1315 struct thread_resume
*resume_info
;
1316 struct thread_resume default_action
= {{0}};
1318 /* Count the number of semicolons in the packet. There should be one
1319 for every action. */
1325 p
= strchr (p
, ';');
1328 resume_info
= malloc (n
* sizeof (resume_info
[0]));
1329 if (resume_info
== NULL
)
1337 if (p
[0] == 's' || p
[0] == 'S')
1338 resume_info
[i
].kind
= resume_step
;
1339 else if (p
[0] == 'c' || p
[0] == 'C')
1340 resume_info
[i
].kind
= resume_continue
;
1341 else if (p
[0] == 't')
1342 resume_info
[i
].kind
= resume_stop
;
1346 if (p
[0] == 'S' || p
[0] == 'C')
1349 sig
= strtol (p
+ 1, &q
, 16);
1354 if (!target_signal_to_host_p (sig
))
1356 resume_info
[i
].sig
= target_signal_to_host (sig
);
1360 resume_info
[i
].sig
= 0;
1366 resume_info
[i
].thread
= minus_one_ptid
;
1367 default_action
= resume_info
[i
];
1369 /* Note: we don't increment i here, we'll overwrite this entry
1370 the next time through. */
1372 else if (p
[0] == ':')
1374 ptid_t ptid
= read_ptid (p
+ 1, &q
);
1379 if (p
[0] != ';' && p
[0] != 0)
1382 resume_info
[i
].thread
= ptid
;
1389 resume_info
[i
] = default_action
;
1391 /* Still used in occasional places in the backend. */
1393 && !ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
1394 && resume_info
[0].kind
!= resume_stop
)
1395 cont_thread
= resume_info
[0].thread
;
1397 cont_thread
= minus_one_ptid
;
1398 set_desired_inferior (0);
1403 (*the_target
->resume
) (resume_info
, n
);
1411 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1412 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1413 disable_async_io ();
1418 write_enn (own_buf
);
1423 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1425 handle_v_attach (char *own_buf
)
1429 pid
= strtol (own_buf
+ 8, NULL
, 16);
1430 if (pid
!= 0 && attach_inferior (pid
) == 0)
1432 /* Don't report shared library events after attaching, even if
1433 some libraries are preloaded. GDB will always poll the
1434 library list. Avoids the "stopped by shared library event"
1435 notice on the GDB side. */
1440 /* In non-stop, we don't send a resume reply. Stop events
1441 will follow up using the normal notification
1446 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1452 write_enn (own_buf
);
1457 /* Run a new program. Return 1 if successful, 0 if failure. */
1459 handle_v_run (char *own_buf
)
1461 char *p
, *next_p
, **new_argv
;
1465 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
1471 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
1472 if (new_argv
== NULL
)
1474 write_enn (own_buf
);
1479 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
1481 next_p
= strchr (p
, ';');
1483 next_p
= p
+ strlen (p
);
1485 if (i
== 0 && p
== next_p
)
1489 /* FIXME: Fail request if out of memory instead of dying. */
1490 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
1491 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
1492 new_argv
[i
][(next_p
- p
) / 2] = '\0';
1501 if (new_argv
[0] == NULL
)
1503 /* GDB didn't specify a program to run. Use the program from the
1504 last run with the new argument list. */
1506 if (program_argv
== NULL
)
1508 /* FIXME: new_argv memory leak */
1509 write_enn (own_buf
);
1513 new_argv
[0] = strdup (program_argv
[0]);
1514 if (new_argv
[0] == NULL
)
1516 /* FIXME: new_argv memory leak */
1517 write_enn (own_buf
);
1522 /* Free the old argv and install the new one. */
1523 freeargv (program_argv
);
1524 program_argv
= new_argv
;
1526 start_inferior (program_argv
);
1527 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
1529 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1531 /* In non-stop, sending a resume reply doesn't set the general
1532 thread, but GDB assumes a vRun sets it (this is so GDB can
1533 query which is the main thread of the new inferior. */
1535 general_thread
= last_ptid
;
1541 write_enn (own_buf
);
1546 /* Kill process. Return 1 if successful, 0 if failure. */
1548 handle_v_kill (char *own_buf
)
1551 char *p
= &own_buf
[6];
1553 pid
= strtol (p
, NULL
, 16);
1556 if (pid
!= 0 && kill_inferior (pid
) == 0)
1558 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1559 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
1560 last_ptid
= pid_to_ptid (pid
);
1561 discard_queued_stop_replies (pid
);
1567 write_enn (own_buf
);
1572 /* Handle a 'vStopped' packet. */
1574 handle_v_stopped (char *own_buf
)
1576 /* If we're waiting for GDB to acknowledge a pending stop reply,
1577 consider that done. */
1580 struct vstop_notif
*head
;
1583 fprintf (stderr
, "vStopped: acking %s\n",
1584 target_pid_to_str (notif_queue
->ptid
));
1587 notif_queue
= notif_queue
->next
;
1591 /* Push another stop reply, or if there are no more left, an OK. */
1592 send_next_stop_reply (own_buf
);
1595 /* Handle all of the extended 'v' packets. */
1597 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
1599 if (!disable_packet_vCont
)
1601 if (strncmp (own_buf
, "vCont;", 6) == 0)
1603 require_running (own_buf
);
1604 handle_v_cont (own_buf
);
1608 if (strncmp (own_buf
, "vCont?", 6) == 0)
1610 strcpy (own_buf
, "vCont;c;C;s;S;t");
1615 if (strncmp (own_buf
, "vFile:", 6) == 0
1616 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
1619 if (strncmp (own_buf
, "vAttach;", 8) == 0)
1621 if (!multi_process
&& target_running ())
1623 fprintf (stderr
, "Already debugging a process\n");
1624 write_enn (own_buf
);
1627 handle_v_attach (own_buf
);
1631 if (strncmp (own_buf
, "vRun;", 5) == 0)
1633 if (!multi_process
&& target_running ())
1635 fprintf (stderr
, "Already debugging a process\n");
1636 write_enn (own_buf
);
1639 handle_v_run (own_buf
);
1643 if (strncmp (own_buf
, "vKill;", 6) == 0)
1645 if (!target_running ())
1647 fprintf (stderr
, "No process to kill\n");
1648 write_enn (own_buf
);
1651 handle_v_kill (own_buf
);
1655 if (strncmp (own_buf
, "vStopped", 8) == 0)
1657 handle_v_stopped (own_buf
);
1661 /* Otherwise we didn't know what packet it was. Say we didn't
1667 /* Resume inferior and wait for another event. In non-stop mode,
1668 don't really wait here, but return immediatelly to the event
1671 myresume (char *own_buf
, int step
, int sig
)
1673 struct thread_resume resume_info
[2];
1675 int valid_cont_thread
;
1677 set_desired_inferior (0);
1679 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
1680 && !ptid_equal (cont_thread
, minus_one_ptid
));
1682 if (step
|| sig
|| valid_cont_thread
)
1684 resume_info
[0].thread
1685 = ((struct inferior_list_entry
*) current_inferior
)->id
;
1687 resume_info
[0].kind
= resume_step
;
1689 resume_info
[0].kind
= resume_continue
;
1690 resume_info
[0].sig
= sig
;
1694 if (!valid_cont_thread
)
1696 resume_info
[n
].thread
= minus_one_ptid
;
1697 resume_info
[n
].kind
= resume_continue
;
1698 resume_info
[n
].sig
= 0;
1705 (*the_target
->resume
) (resume_info
, n
);
1711 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
1712 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
1713 disable_async_io ();
1717 /* Callback for for_each_inferior. Make a new stop reply for each
1721 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
1723 int pid
= * (int *) arg
;
1726 || ptid_get_pid (entry
->id
) == pid
)
1728 struct target_waitstatus status
;
1730 status
.kind
= TARGET_WAITKIND_STOPPED
;
1731 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1733 /* Pass the last stop reply back to GDB, but don't notify. */
1734 queue_stop_reply (entry
->id
, &status
);
1740 /* Status handler for the '?' packet. */
1743 handle_status (char *own_buf
)
1745 struct target_waitstatus status
;
1746 status
.kind
= TARGET_WAITKIND_STOPPED
;
1747 status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1749 /* In non-stop mode, we must send a stop reply for each stopped
1750 thread. In all-stop mode, just send one for the first stopped
1756 discard_queued_stop_replies (pid
);
1757 find_inferior (&all_threads
, queue_stop_reply_callback
, &pid
);
1759 /* The first is sent immediatly. OK is sent if there is no
1760 stopped thread, which is the same handling of the vStopped
1761 packet (by design). */
1762 send_next_stop_reply (own_buf
);
1766 if (all_threads
.head
)
1767 prepare_resume_reply (own_buf
,
1768 all_threads
.head
->id
, &status
);
1770 strcpy (own_buf
, "W00");
1775 gdbserver_version (void)
1777 printf ("GNU gdbserver %s%s\n"
1778 "Copyright (C) 2009 Free Software Foundation, Inc.\n"
1779 "gdbserver is free software, covered by the GNU General Public License.\n"
1780 "This gdbserver was configured as \"%s\"\n",
1781 PKGVERSION
, version
, host_name
);
1785 gdbserver_usage (FILE *stream
)
1787 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1788 "\tgdbserver [OPTIONS] --attach COMM PID\n"
1789 "\tgdbserver [OPTIONS] --multi COMM\n"
1791 "COMM may either be a tty device (for serial debugging), or \n"
1792 "HOST:PORT to listen for a TCP connection.\n"
1795 " --debug Enable general debugging output.\n"
1796 " --remote-debug Enable remote protocol debugging output.\n"
1797 " --version Display version information and exit.\n"
1798 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
1799 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
1800 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
1804 gdbserver_show_disableable (FILE *stream
)
1806 fprintf (stream
, "Disableable packets:\n"
1807 " vCont \tAll vCont packets\n"
1808 " qC \tQuerying the current thread\n"
1809 " qfThreadInfo\tThread listing\n"
1810 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
1811 " threads \tAll of the above\n");
1815 #undef require_running
1816 #define require_running(BUF) \
1817 if (!target_running ()) \
1824 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
1826 int pid
= * (int *) args
;
1828 if (ptid_get_pid (entry
->id
) == pid
)
1835 kill_inferior_callback (struct inferior_list_entry
*entry
)
1837 struct process_info
*process
= (struct process_info
*) entry
;
1838 int pid
= ptid_get_pid (process
->head
.id
);
1840 kill_inferior (pid
);
1841 discard_queued_stop_replies (pid
);
1844 /* Callback for for_each_inferior to detach or kill the inferior,
1845 depending on whether we attached to it or not.
1846 We inform the user whether we're detaching or killing the process
1847 as this is only called when gdbserver is about to exit. */
1850 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
1852 struct process_info
*process
= (struct process_info
*) entry
;
1853 int pid
= ptid_get_pid (process
->head
.id
);
1855 if (process
->attached
)
1856 detach_inferior (pid
);
1858 kill_inferior (pid
);
1860 discard_queued_stop_replies (pid
);
1863 /* for_each_inferior callback for detach_or_kill_for_exit to print
1864 the pids of started inferiors. */
1867 print_started_pid (struct inferior_list_entry
*entry
)
1869 struct process_info
*process
= (struct process_info
*) entry
;
1871 if (! process
->attached
)
1873 int pid
= ptid_get_pid (process
->head
.id
);
1874 fprintf (stderr
, " %d", pid
);
1878 /* for_each_inferior callback for detach_or_kill_for_exit to print
1879 the pids of attached inferiors. */
1882 print_attached_pid (struct inferior_list_entry
*entry
)
1884 struct process_info
*process
= (struct process_info
*) entry
;
1886 if (process
->attached
)
1888 int pid
= ptid_get_pid (process
->head
.id
);
1889 fprintf (stderr
, " %d", pid
);
1893 /* Call this when exiting gdbserver with possible inferiors that need
1894 to be killed or detached from. */
1897 detach_or_kill_for_exit (void)
1899 /* First print a list of the inferiors we will be killing/detaching.
1900 This is to assist the user, for example, in case the inferior unexpectedly
1901 dies after we exit: did we screw up or did the inferior exit on its own?
1902 Having this info will save some head-scratching. */
1904 if (have_started_inferiors_p ())
1906 fprintf (stderr
, "Killing process(es):");
1907 for_each_inferior (&all_processes
, print_started_pid
);
1908 fprintf (stderr
, "\n");
1910 if (have_attached_inferiors_p ())
1912 fprintf (stderr
, "Detaching process(es):");
1913 for_each_inferior (&all_processes
, print_attached_pid
);
1914 fprintf (stderr
, "\n");
1917 /* Now we can kill or detach the inferiors. */
1919 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
1923 join_inferiors_callback (struct inferior_list_entry
*entry
)
1925 struct process_info
*process
= (struct process_info
*) entry
;
1927 /* If we are attached, then we can exit. Otherwise, we need to hang
1928 around doing nothing, until the child is gone. */
1929 if (!process
->attached
)
1930 join_inferior (ptid_get_pid (process
->head
.id
));
1934 main (int argc
, char *argv
[])
1938 char *arg_end
, *port
;
1939 char **next_arg
= &argv
[1];
1944 while (*next_arg
!= NULL
&& **next_arg
== '-')
1946 if (strcmp (*next_arg
, "--version") == 0)
1948 gdbserver_version ();
1951 else if (strcmp (*next_arg
, "--help") == 0)
1953 gdbserver_usage (stdout
);
1956 else if (strcmp (*next_arg
, "--attach") == 0)
1958 else if (strcmp (*next_arg
, "--multi") == 0)
1960 else if (strcmp (*next_arg
, "--wrapper") == 0)
1964 wrapper_argv
= next_arg
;
1965 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
1968 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
1970 gdbserver_usage (stderr
);
1974 /* Consume the "--". */
1977 else if (strcmp (*next_arg
, "--debug") == 0)
1979 else if (strcmp (*next_arg
, "--remote-debug") == 0)
1981 else if (strcmp (*next_arg
, "--disable-packet") == 0)
1983 gdbserver_show_disableable (stdout
);
1986 else if (strncmp (*next_arg
,
1987 "--disable-packet=",
1988 sizeof ("--disable-packet=") - 1) == 0)
1990 char *packets
, *tok
;
1992 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
1993 for (tok
= strtok (packets
, ",");
1995 tok
= strtok (NULL
, ","))
1997 if (strcmp ("vCont", tok
) == 0)
1998 disable_packet_vCont
= 1;
1999 else if (strcmp ("Tthread", tok
) == 0)
2000 disable_packet_Tthread
= 1;
2001 else if (strcmp ("qC", tok
) == 0)
2002 disable_packet_qC
= 1;
2003 else if (strcmp ("qfThreadInfo", tok
) == 0)
2004 disable_packet_qfThreadInfo
= 1;
2005 else if (strcmp ("threads", tok
) == 0)
2007 disable_packet_vCont
= 1;
2008 disable_packet_Tthread
= 1;
2009 disable_packet_qC
= 1;
2010 disable_packet_qfThreadInfo
= 1;
2014 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2016 gdbserver_show_disableable (stderr
);
2023 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2031 if (setjmp (toplevel
))
2033 fprintf (stderr
, "Exiting\n");
2039 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2041 gdbserver_usage (stderr
);
2048 /* --attach used to come after PORT, so allow it there for
2050 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2057 && (*next_arg
== NULL
2058 || (*next_arg
)[0] == '\0'
2059 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2061 || next_arg
[1] != NULL
))
2066 gdbserver_usage (stderr
);
2070 initialize_inferiors ();
2071 initialize_async_io ();
2074 own_buf
= xmalloc (PBUFSIZ
+ 1);
2075 mem_buf
= xmalloc (PBUFSIZ
);
2077 if (pid
== 0 && *next_arg
!= NULL
)
2081 n
= argc
- (next_arg
- argv
);
2082 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2083 for (i
= 0; i
< n
; i
++)
2084 program_argv
[i
] = xstrdup (next_arg
[i
]);
2085 program_argv
[i
] = NULL
;
2087 /* Wait till we are at first instruction in program. */
2088 start_inferior (program_argv
);
2090 /* We are now (hopefully) stopped at the first instruction of
2091 the target process. This assumes that the target process was
2092 successfully created. */
2096 if (attach_inferior (pid
) == -1)
2097 error ("Attaching not supported on this target");
2099 /* Otherwise succeeded. */
2103 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2104 last_status
.value
.integer
= 0;
2105 last_ptid
= minus_one_ptid
;
2108 /* Don't report shared library events on the initial connection,
2109 even if some libraries are preloaded. Avoids the "stopped by
2110 shared library event" notice on gdb side. */
2113 if (setjmp (toplevel
))
2115 detach_or_kill_for_exit ();
2119 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2120 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2125 if (!was_running
&& !multi_mode
)
2127 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2139 if (setjmp (toplevel
) != 0)
2141 /* An error occurred. */
2142 if (response_needed
)
2144 write_enn (own_buf
);
2149 /* Wait for events. This will return when all event sources are
2150 removed from the event loop. */
2151 start_event_loop ();
2153 /* If an exit was requested (using the "monitor exit" command),
2154 terminate now. The only other way to get here is for
2155 getpkt to fail; close the connection and reopen it at the
2160 detach_or_kill_for_exit ();
2164 fprintf (stderr
, "Remote side has terminated connection. "
2165 "GDBserver will reopen the connection.\n");
2169 /* Event loop callback that handles a serial event. The first byte in
2170 the serial buffer gets us here. We expect characters to arrive at
2171 a brisk pace, so we read the rest of the packet with a blocking
2175 process_serial_event (void)
2185 int new_packet_len
= -1;
2187 /* Used to decide when gdbserver should exit in
2188 multi-mode/remote. */
2189 static int have_ran
= 0;
2192 have_ran
= target_running ();
2194 disable_async_io ();
2196 response_needed
= 0;
2197 packet_len
= getpkt (own_buf
);
2198 if (packet_len
<= 0)
2204 response_needed
= 1;
2211 handle_query (own_buf
, packet_len
, &new_packet_len
);
2214 handle_general_set (own_buf
);
2217 require_running (own_buf
);
2222 pid
= strtol (&own_buf
[i
], NULL
, 16);
2226 ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
2228 fprintf (stderr
, "Detaching from process %d\n", pid
);
2229 if (detach_inferior (pid
) != 0)
2230 write_enn (own_buf
);
2233 discard_queued_stop_replies (pid
);
2236 if (extended_protocol
)
2238 /* Treat this like a normal program exit. */
2239 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2240 last_status
.value
.integer
= 0;
2241 last_ptid
= pid_to_ptid (pid
);
2243 current_inferior
= NULL
;
2250 /* If we are attached, then we can exit. Otherwise, we
2251 need to hang around doing nothing, until the child is
2253 for_each_inferior (&all_processes
,
2254 join_inferiors_callback
);
2260 extended_protocol
= 1;
2264 handle_status (own_buf
);
2267 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
2269 ptid_t gdb_id
, thread_id
;
2272 require_running (own_buf
);
2274 gdb_id
= read_ptid (&own_buf
[2], NULL
);
2276 pid
= ptid_get_pid (gdb_id
);
2278 if (ptid_equal (gdb_id
, null_ptid
)
2279 || ptid_equal (gdb_id
, minus_one_ptid
))
2280 thread_id
= null_ptid
;
2282 && ptid_equal (pid_to_ptid (pid
),
2285 struct thread_info
*thread
=
2286 (struct thread_info
*) find_inferior (&all_threads
,
2291 write_enn (own_buf
);
2295 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
2299 thread_id
= gdb_id_to_thread_id (gdb_id
);
2300 if (ptid_equal (thread_id
, null_ptid
))
2302 write_enn (own_buf
);
2307 if (own_buf
[1] == 'g')
2309 if (ptid_equal (thread_id
, null_ptid
))
2311 /* GDB is telling us to choose any thread. Check if
2312 the currently selected thread is still valid. If
2313 it is not, select the first available. */
2314 struct thread_info
*thread
=
2315 (struct thread_info
*) find_inferior_id (&all_threads
,
2318 thread_id
= all_threads
.head
->id
;
2321 general_thread
= thread_id
;
2322 set_desired_inferior (1);
2324 else if (own_buf
[1] == 'c')
2325 cont_thread
= thread_id
;
2326 else if (own_buf
[1] == 's')
2327 step_thread
= thread_id
;
2333 /* Silently ignore it so that gdb can extend the protocol
2334 without compatibility headaches. */
2339 require_running (own_buf
);
2340 set_desired_inferior (1);
2341 registers_to_string (own_buf
);
2344 require_running (own_buf
);
2345 set_desired_inferior (1);
2346 registers_from_string (&own_buf
[1]);
2350 require_running (own_buf
);
2351 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
2352 if (read_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2353 convert_int_to_ascii (mem_buf
, own_buf
, len
);
2355 write_enn (own_buf
);
2358 require_running (own_buf
);
2359 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, mem_buf
);
2360 if (write_inferior_memory (mem_addr
, mem_buf
, len
) == 0)
2363 write_enn (own_buf
);
2366 require_running (own_buf
);
2367 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
2368 &mem_addr
, &len
, mem_buf
) < 0
2369 || write_inferior_memory (mem_addr
, mem_buf
, len
) != 0)
2370 write_enn (own_buf
);
2375 require_running (own_buf
);
2376 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2377 if (target_signal_to_host_p (sig
))
2378 signal
= target_signal_to_host (sig
);
2381 myresume (own_buf
, 0, signal
);
2384 require_running (own_buf
);
2385 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
2386 if (target_signal_to_host_p (sig
))
2387 signal
= target_signal_to_host (sig
);
2390 myresume (own_buf
, 1, signal
);
2393 require_running (own_buf
);
2395 myresume (own_buf
, 0, signal
);
2398 require_running (own_buf
);
2400 myresume (own_buf
, 1, signal
);
2402 case 'Z': /* insert_ ... */
2404 case 'z': /* remove_ ... */
2408 CORE_ADDR addr
= strtoul (&own_buf
[3], &lenptr
, 16);
2409 int len
= strtol (lenptr
+ 1, &dataptr
, 16);
2410 char type
= own_buf
[1];
2412 const int insert
= ch
== 'Z';
2414 /* Default to unrecognized/unsupported. */
2418 case '0': /* software-breakpoint */
2419 case '1': /* hardware-breakpoint */
2420 case '2': /* write watchpoint */
2421 case '3': /* read watchpoint */
2422 case '4': /* access watchpoint */
2423 require_running (own_buf
);
2424 if (insert
&& the_target
->insert_point
!= NULL
)
2425 res
= (*the_target
->insert_point
) (type
, addr
, len
);
2426 else if (!insert
&& the_target
->remove_point
!= NULL
)
2427 res
= (*the_target
->remove_point
) (type
, addr
, len
);
2439 write_enn (own_buf
);
2443 response_needed
= 0;
2444 if (!target_running ())
2445 /* The packet we received doesn't make sense - but we can't
2446 reply to it, either. */
2449 fprintf (stderr
, "Killing all inferiors\n");
2450 for_each_inferior (&all_processes
, kill_inferior_callback
);
2452 /* When using the extended protocol, we wait with no program
2453 running. The traditional protocol will exit instead. */
2454 if (extended_protocol
)
2456 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2457 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2467 ptid_t gdb_id
, thread_id
;
2469 require_running (own_buf
);
2471 gdb_id
= read_ptid (&own_buf
[1], NULL
);
2472 thread_id
= gdb_id_to_thread_id (gdb_id
);
2473 if (ptid_equal (thread_id
, null_ptid
))
2475 write_enn (own_buf
);
2479 if (mythread_alive (thread_id
))
2482 write_enn (own_buf
);
2486 response_needed
= 0;
2488 /* Restarting the inferior is only supported in the extended
2490 if (extended_protocol
)
2492 if (target_running ())
2493 for_each_inferior (&all_processes
,
2494 kill_inferior_callback
);
2495 fprintf (stderr
, "GDBserver restarting\n");
2497 /* Wait till we are at 1st instruction in prog. */
2498 if (program_argv
!= NULL
)
2499 start_inferior (program_argv
);
2502 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2503 last_status
.value
.sig
= TARGET_SIGNAL_KILL
;
2509 /* It is a request we don't understand. Respond with an
2510 empty packet so that gdb knows that we don't support this
2516 /* Extended (long) request. */
2517 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
2521 /* It is a request we don't understand. Respond with an empty
2522 packet so that gdb knows that we don't support this
2528 if (new_packet_len
!= -1)
2529 putpkt_binary (own_buf
, new_packet_len
);
2533 response_needed
= 0;
2535 if (!extended_protocol
&& have_ran
&& !target_running ())
2537 /* In non-stop, defer exiting until GDB had a chance to query
2538 the whole vStopped list (until it gets an OK). */
2541 fprintf (stderr
, "GDBserver exiting\n");
2548 /* Event-loop callback for serial events. */
2551 handle_serial_event (int err
, gdb_client_data client_data
)
2554 fprintf (stderr
, "handling possible serial event\n");
2556 /* Really handle it. */
2557 process_serial_event ();
2559 /* Be sure to not change the selected inferior behind GDB's back.
2560 Important in the non-stop mode asynchronous protocol. */
2561 set_desired_inferior (1);
2564 /* Event-loop callback for target events. */
2567 handle_target_event (int err
, gdb_client_data client_data
)
2570 fprintf (stderr
, "handling possible target event\n");
2572 last_ptid
= mywait (minus_one_ptid
, &last_status
,
2575 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
2577 /* Something interesting. Tell GDB about it. */
2578 push_event (last_ptid
, &last_status
);
2581 /* Be sure to not change the selected inferior behind GDB's back.
2582 Important in the non-stop mode asynchronous protocol. */
2583 set_desired_inferior (1);