1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2013 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
30 #include "btrace-common.h"
31 #include "filestuff.h"
32 #include "tracepoint.h"
35 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
36 `vCont'. Note the multi-process extensions made `vCont' a
37 requirement, so `Hc pPID.TID' is pretty much undefined. So
38 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
39 resuming all threads of the process (again, `Hc' isn't used for
40 multi-process), or a specific thread ptid_t.
42 We also set this when handling a single-thread `vCont' resume, as
43 some places in the backends check it to know when (and for which
44 thread) single-thread scheduler-locking is in effect. */
47 /* The thread set with an `Hg' packet. */
48 ptid_t general_thread
;
52 static int extended_protocol
;
53 static int response_needed
;
54 static int exit_requested
;
56 /* --once: Exit after the first connection has closed. */
62 /* Whether we should attempt to disable the operating system's address
63 space randomization feature before starting an inferior. */
64 int disable_randomization
= 1;
66 static char **program_argv
, **wrapper_argv
;
68 /* Enable miscellaneous debugging output. The name is historical - it
69 was originally used to debug LinuxThreads support. */
72 /* Enable debugging of h/w breakpoint/watchpoint support. */
75 int pass_signals
[GDB_SIGNAL_LAST
];
76 int program_signals
[GDB_SIGNAL_LAST
];
77 int program_signals_p
;
81 /* The PID of the originally created or attached inferior. Used to
82 send signals to the process when GDB sends us an asynchronous interrupt
83 (user hitting Control-C in the client), and to wait for the child to exit
84 when no longer debugging it. */
86 unsigned long signal_pid
;
89 /* A file descriptor for the controlling terminal. */
92 /* TERMINAL_FD's original foreground group. */
93 pid_t old_foreground_pgrp
;
95 /* Hand back terminal ownership to the original foreground group. */
98 restore_old_foreground_pgrp (void)
100 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
104 /* Set if you want to disable optional thread related packets support
105 in gdbserver, for the sake of testing GDB against stubs that don't
107 int disable_packet_vCont
;
108 int disable_packet_Tthread
;
109 int disable_packet_qC
;
110 int disable_packet_qfThreadInfo
;
112 /* Last status reported to GDB. */
113 static struct target_waitstatus last_status
;
114 static ptid_t last_ptid
;
116 static char *own_buf
;
117 static unsigned char *mem_buf
;
119 /* A sub-class of 'struct notif_event' for stop, holding information
120 relative to a single stop reply. We keep a queue of these to
121 push to GDB in non-stop mode. */
125 struct notif_event base
;
127 /* Thread or process that got the event. */
131 struct target_waitstatus status
;
134 DEFINE_QUEUE_P (notif_event_p
);
136 /* Put a stop reply to the stop reply queue. */
139 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
141 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
143 new_notif
->ptid
= ptid
;
144 new_notif
->status
= *status
;
146 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
150 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
151 QUEUE_ITER (notif_event_p
) *iter
,
152 struct notif_event
*event
,
158 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
160 if (q
->free_func
!= NULL
)
161 q
->free_func (event
);
163 QUEUE_remove_elem (notif_event_p
, q
, iter
);
169 /* Get rid of the currently pending stop replies for PID. If PID is
170 -1, then apply to all processes. */
173 discard_queued_stop_replies (int pid
)
175 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
176 remove_all_on_match_pid
, &pid
);
180 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
182 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
184 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
187 struct notif_server notif_stop
=
189 "vStopped", "Stop", NULL
, vstop_notif_reply
,
193 target_running (void)
195 return all_threads
.head
!= NULL
;
199 start_inferior (char **argv
)
201 char **new_argv
= argv
;
203 if (wrapper_argv
!= NULL
)
207 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
209 for (i
= 0; argv
[i
] != NULL
; i
++)
211 new_argv
= alloca (sizeof (char *) * count
);
213 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
214 new_argv
[count
++] = wrapper_argv
[i
];
215 for (i
= 0; argv
[i
] != NULL
; i
++)
216 new_argv
[count
++] = argv
[i
];
217 new_argv
[count
] = NULL
;
223 for (i
= 0; new_argv
[i
]; ++i
)
224 fprintf (stderr
, "new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
229 signal (SIGTTOU
, SIG_DFL
);
230 signal (SIGTTIN
, SIG_DFL
);
233 /* Clear this so the backend doesn't get confused, thinking
234 CONT_THREAD died, and it needs to resume all threads. */
235 cont_thread
= null_ptid
;
237 signal_pid
= create_inferior (new_argv
[0], new_argv
);
239 /* FIXME: we don't actually know at this point that the create
240 actually succeeded. We won't know that until we wait. */
241 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
246 signal (SIGTTOU
, SIG_IGN
);
247 signal (SIGTTIN
, SIG_IGN
);
248 terminal_fd
= fileno (stderr
);
249 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
250 tcsetpgrp (terminal_fd
, signal_pid
);
251 atexit (restore_old_foreground_pgrp
);
254 if (wrapper_argv
!= NULL
)
256 struct thread_resume resume_info
;
258 resume_info
.thread
= pid_to_ptid (signal_pid
);
259 resume_info
.kind
= resume_continue
;
262 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
264 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
269 (*the_target
->resume
) (&resume_info
, 1);
271 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
272 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
275 current_inferior
->last_resume_kind
= resume_stop
;
276 current_inferior
->last_status
= last_status
;
278 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
283 /* Wait till we are at 1st instruction in program, return new pid
284 (assuming success). */
285 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
287 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
288 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
290 current_inferior
->last_resume_kind
= resume_stop
;
291 current_inferior
->last_status
= last_status
;
298 attach_inferior (int pid
)
300 /* myattach should return -1 if attaching is unsupported,
301 0 if it succeeded, and call error() otherwise. */
303 if (myattach (pid
) != 0)
306 fprintf (stderr
, "Attached; pid = %d\n", pid
);
309 /* FIXME - It may be that we should get the SIGNAL_PID from the
310 attach function, so that it can be the main thread instead of
311 whichever we were told to attach to. */
314 /* Clear this so the backend doesn't get confused, thinking
315 CONT_THREAD died, and it needs to resume all threads. */
316 cont_thread
= null_ptid
;
320 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
322 /* GDB knows to ignore the first SIGSTOP after attaching to a running
323 process using the "attach" command, but this is different; it's
324 just using "target remote". Pretend it's just starting up. */
325 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
326 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
327 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
329 current_inferior
->last_resume_kind
= resume_stop
;
330 current_inferior
->last_status
= last_status
;
336 extern int remote_debug
;
338 /* Decode a qXfer read request. Return 0 if everything looks OK,
342 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
344 /* After the read marker and annex, qXfer looks like a
345 traditional 'm' packet. */
346 decode_m_packet (buf
, ofs
, len
);
352 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
354 /* Extract and NUL-terminate the object. */
356 while (*buf
&& *buf
!= ':')
362 /* Extract and NUL-terminate the read/write action. */
364 while (*buf
&& *buf
!= ':')
370 /* Extract and NUL-terminate the annex. */
372 while (*buf
&& *buf
!= ':')
382 /* Write the response to a successful qXfer read. Returns the
383 length of the (binary) data stored in BUF, corresponding
384 to as much of DATA/LEN as we could fit. IS_MORE controls
385 the first character of the response. */
387 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
396 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
400 /* Handle btrace enabling. */
403 handle_btrace_enable (struct thread_info
*thread
)
405 if (thread
->btrace
!= NULL
)
406 return "E.Btrace already enabled.";
408 thread
->btrace
= target_enable_btrace (thread
->entry
.id
);
409 if (thread
->btrace
== NULL
)
410 return "E.Could not enable btrace.";
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 return "E.Branch tracing not enabled.";
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 return "E.Could not disable branch tracing.";
427 thread
->btrace
= NULL
;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf
)
436 struct thread_info
*thread
;
440 if (strncmp ("Qbtrace:", own_buf
, strlen ("Qbtrace:")) != 0)
443 op
= own_buf
+ strlen ("Qbtrace:");
445 if (!target_supports_btrace ())
447 strcpy (own_buf
, "E.Target does not support branch tracing.");
451 if (ptid_equal (general_thread
, null_ptid
)
452 || ptid_equal (general_thread
, minus_one_ptid
))
454 strcpy (own_buf
, "E.Must select a single thread.");
458 thread
= find_thread_ptid (general_thread
);
461 strcpy (own_buf
, "E.No such thread.");
467 if (strcmp (op
, "bts") == 0)
468 err
= handle_btrace_enable (thread
);
469 else if (strcmp (op
, "off") == 0)
470 err
= handle_btrace_disable (thread
);
472 err
= "E.Bad Qbtrace operation. Use bts or off.";
475 strcpy (own_buf
, err
);
482 /* Handle all of the extended 'Q' packets. */
485 handle_general_set (char *own_buf
)
487 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
489 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
490 const char *p
= own_buf
+ strlen ("QPassSignals:");
493 p
= decode_address_to_semicolon (&cursig
, p
);
494 for (i
= 0; i
< numsigs
; i
++)
500 /* Keep looping, to clear the remaining signals. */
503 p
= decode_address_to_semicolon (&cursig
, p
);
508 strcpy (own_buf
, "OK");
512 if (strncmp ("QProgramSignals:", own_buf
, strlen ("QProgramSignals:")) == 0)
514 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
515 const char *p
= own_buf
+ strlen ("QProgramSignals:");
518 program_signals_p
= 1;
520 p
= decode_address_to_semicolon (&cursig
, p
);
521 for (i
= 0; i
< numsigs
; i
++)
525 program_signals
[i
] = 1;
527 /* Keep looping, to clear the remaining signals. */
530 p
= decode_address_to_semicolon (&cursig
, p
);
533 program_signals
[i
] = 0;
535 strcpy (own_buf
, "OK");
539 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
543 fprintf (stderr
, "[noack mode enabled]\n");
552 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
554 char *mode
= own_buf
+ 9;
558 if (strcmp (mode
, "0") == 0)
560 else if (strcmp (mode
, "1") == 0)
564 /* We don't know what this mode is, so complain to
566 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
572 req_str
= req
? "non-stop" : "all-stop";
573 if (start_non_stop (req
) != 0)
575 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
583 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
589 if (strncmp ("QDisableRandomization:", own_buf
,
590 strlen ("QDisableRandomization:")) == 0)
592 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
595 unpack_varlen_hex (packet
, &setting
);
596 disable_randomization
= setting
;
600 if (disable_randomization
)
601 fprintf (stderr
, "[address space randomization disabled]\n");
603 fprintf (stderr
, "[address space randomization enabled]\n");
610 if (target_supports_tracepoints ()
611 && handle_tracepoint_general_set (own_buf
))
614 if (strncmp ("QAgent:", own_buf
, strlen ("QAgent:")) == 0)
616 char *mode
= own_buf
+ strlen ("QAgent:");
619 if (strcmp (mode
, "0") == 0)
621 else if (strcmp (mode
, "1") == 0)
625 /* We don't know what this value is, so complain to GDB. */
626 sprintf (own_buf
, "E.Unknown QAgent value");
630 /* Update the flag. */
633 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
638 if (handle_btrace_general_set (own_buf
))
641 /* Otherwise we didn't know what packet it was. Say we didn't
647 get_features_xml (const char *annex
)
649 const struct target_desc
*desc
= current_target_desc ();
651 /* `desc->xmltarget' defines what to return when looking for the
652 "target.xml" file. Its contents can either be verbatim XML code
653 (prefixed with a '@') or else the name of the actual XML file to
654 be used in place of "target.xml".
656 This variable is set up from the auto-generated
657 init_registers_... routine for the current target. */
659 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
661 if (*desc
->xmltarget
== '@')
662 return desc
->xmltarget
+ 1;
664 annex
= desc
->xmltarget
;
669 extern const char *const xml_builtin
[][2];
672 /* Look for the annex. */
673 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
674 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
677 if (xml_builtin
[i
][0] != NULL
)
678 return xml_builtin
[i
][1];
686 monitor_show_help (void)
688 monitor_output ("The following monitor commands are supported:\n");
689 monitor_output (" set debug <0|1>\n");
690 monitor_output (" Enable general debugging messages\n");
691 monitor_output (" set debug-hw-points <0|1>\n");
692 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
693 monitor_output (" set remote-debug <0|1>\n");
694 monitor_output (" Enable remote protocol debugging messages\n");
695 monitor_output (" exit\n");
696 monitor_output (" Quit GDBserver\n");
699 /* Read trace frame or inferior memory. Returns the number of bytes
700 actually read, zero when no further transfer is possible, and -1 on
701 error. Return of a positive value smaller than LEN does not
702 indicate there's no more to be read, only the end of the transfer.
703 E.g., when GDB reads memory from a traceframe, a first request may
704 be served from a memory block that does not cover the whole request
705 length. A following request gets the rest served from either
706 another block (of the same traceframe) or from the read-only
710 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
714 if (current_traceframe
>= 0)
717 ULONGEST length
= len
;
719 if (traceframe_read_mem (current_traceframe
,
720 memaddr
, myaddr
, len
, &nbytes
))
722 /* Data read from trace buffer, we're done. */
725 if (!in_readonly_region (memaddr
, length
))
727 /* Otherwise we have a valid readonly case, fall through. */
728 /* (assume no half-trace half-real blocks for now) */
731 res
= prepare_to_access_memory ();
734 res
= read_inferior_memory (memaddr
, myaddr
, len
);
735 done_accessing_memory ();
737 return res
== 0 ? len
: -1;
743 /* Write trace frame or inferior memory. Actually, writing to trace
744 frames is forbidden. */
747 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
749 if (current_traceframe
>= 0)
755 ret
= prepare_to_access_memory ();
758 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
759 done_accessing_memory ();
765 /* Subroutine of handle_search_memory to simplify it. */
768 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
769 gdb_byte
*pattern
, unsigned pattern_len
,
770 gdb_byte
*search_buf
,
771 unsigned chunk_size
, unsigned search_buf_size
,
772 CORE_ADDR
*found_addrp
)
774 /* Prime the search buffer. */
776 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
779 warning ("Unable to access %ld bytes of target "
780 "memory at 0x%lx, halting search.",
781 (long) search_buf_size
, (long) start_addr
);
785 /* Perform the search.
787 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
788 When we've scanned N bytes we copy the trailing bytes to the start and
789 read in another N bytes. */
791 while (search_space_len
>= pattern_len
)
794 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
798 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
800 if (found_ptr
!= NULL
)
802 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
803 *found_addrp
= found_addr
;
807 /* Not found in this chunk, skip to next chunk. */
809 /* Don't let search_space_len wrap here, it's unsigned. */
810 if (search_space_len
>= chunk_size
)
811 search_space_len
-= chunk_size
;
813 search_space_len
= 0;
815 if (search_space_len
>= pattern_len
)
817 unsigned keep_len
= search_buf_size
- chunk_size
;
818 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
821 /* Copy the trailing part of the previous iteration to the front
822 of the buffer for the next iteration. */
823 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
825 nr_to_read
= (search_space_len
- keep_len
< chunk_size
826 ? search_space_len
- keep_len
829 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
830 nr_to_read
) != search_buf_size
)
832 warning ("Unable to access %ld bytes of target memory "
833 "at 0x%lx, halting search.",
834 (long) nr_to_read
, (long) read_addr
);
838 start_addr
+= chunk_size
;
847 /* Handle qSearch:memory packets. */
850 handle_search_memory (char *own_buf
, int packet_len
)
852 CORE_ADDR start_addr
;
853 CORE_ADDR search_space_len
;
855 unsigned int pattern_len
;
856 /* NOTE: also defined in find.c testcase. */
857 #define SEARCH_CHUNK_SIZE 16000
858 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
859 /* Buffer to hold memory contents for searching. */
860 gdb_byte
*search_buf
;
861 unsigned search_buf_size
;
863 CORE_ADDR found_addr
;
864 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
866 pattern
= malloc (packet_len
);
869 error ("Unable to allocate memory to perform the search");
870 strcpy (own_buf
, "E00");
873 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
874 packet_len
- cmd_name_len
,
875 &start_addr
, &search_space_len
,
876 pattern
, &pattern_len
) < 0)
879 error ("Error in parsing qSearch:memory packet");
880 strcpy (own_buf
, "E00");
884 search_buf_size
= chunk_size
+ pattern_len
- 1;
886 /* No point in trying to allocate a buffer larger than the search space. */
887 if (search_space_len
< search_buf_size
)
888 search_buf_size
= search_space_len
;
890 search_buf
= malloc (search_buf_size
);
891 if (search_buf
== NULL
)
894 error ("Unable to allocate memory to perform the search");
895 strcpy (own_buf
, "E00");
899 found
= handle_search_memory_1 (start_addr
, search_space_len
,
900 pattern
, pattern_len
,
901 search_buf
, chunk_size
, search_buf_size
,
905 sprintf (own_buf
, "1,%lx", (long) found_addr
);
907 strcpy (own_buf
, "0");
909 strcpy (own_buf
, "E00");
915 #define require_running(BUF) \
916 if (!target_running ()) \
922 /* Handle monitor commands not handled by target-specific handlers. */
925 handle_monitor_command (char *mon
, char *own_buf
)
927 if (strcmp (mon
, "set debug 1") == 0)
930 monitor_output ("Debug output enabled.\n");
932 else if (strcmp (mon
, "set debug 0") == 0)
935 monitor_output ("Debug output disabled.\n");
937 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
940 monitor_output ("H/W point debugging output enabled.\n");
942 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
945 monitor_output ("H/W point debugging output disabled.\n");
947 else if (strcmp (mon
, "set remote-debug 1") == 0)
950 monitor_output ("Protocol debug output enabled.\n");
952 else if (strcmp (mon
, "set remote-debug 0") == 0)
955 monitor_output ("Protocol debug output disabled.\n");
957 else if (strcmp (mon
, "help") == 0)
958 monitor_show_help ();
959 else if (strcmp (mon
, "exit") == 0)
963 monitor_output ("Unknown monitor command.\n\n");
964 monitor_show_help ();
969 /* Associates a callback with each supported qXfer'able object. */
973 /* The object this handler handles. */
976 /* Request that the target transfer up to LEN 8-bit bytes of the
977 target's OBJECT. The OFFSET, for a seekable object, specifies
978 the starting point. The ANNEX can be used to provide additional
979 data-specific information to the target.
981 Return the number of bytes actually transfered, zero when no
982 further transfer is possible, -1 on error, -2 when the transfer
983 is not supported, and -3 on a verbose error message that should
984 be preserved. Return of a positive value smaller than LEN does
985 not indicate the end of the object, only the end of the transfer.
987 One, and only one, of readbuf or writebuf must be non-NULL. */
988 int (*xfer
) (const char *annex
,
989 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
990 ULONGEST offset
, LONGEST len
);
993 /* Handle qXfer:auxv:read. */
996 handle_qxfer_auxv (const char *annex
,
997 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
998 ULONGEST offset
, LONGEST len
)
1000 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1003 if (annex
[0] != '\0' || !target_running ())
1006 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1009 /* Handle qXfer:features:read. */
1012 handle_qxfer_features (const char *annex
,
1013 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1014 ULONGEST offset
, LONGEST len
)
1016 const char *document
;
1019 if (writebuf
!= NULL
)
1022 if (!target_running ())
1025 /* Grab the correct annex. */
1026 document
= get_features_xml (annex
);
1027 if (document
== NULL
)
1030 total_len
= strlen (document
);
1032 if (offset
> total_len
)
1035 if (offset
+ len
> total_len
)
1036 len
= total_len
- offset
;
1038 memcpy (readbuf
, document
+ offset
, len
);
1042 /* Handle qXfer:libraries:read. */
1045 handle_qxfer_libraries (const char *annex
,
1046 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1047 ULONGEST offset
, LONGEST len
)
1049 unsigned int total_len
;
1051 struct inferior_list_entry
*dll_ptr
;
1053 if (writebuf
!= NULL
)
1056 if (annex
[0] != '\0' || !target_running ())
1059 /* Over-estimate the necessary memory. Assume that every character
1060 in the library name must be escaped. */
1062 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1063 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1065 document
= malloc (total_len
);
1066 if (document
== NULL
)
1069 strcpy (document
, "<library-list>\n");
1070 p
= document
+ strlen (document
);
1072 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1074 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1077 strcpy (p
, " <library name=\"");
1079 name
= xml_escape_text (dll
->name
);
1083 strcpy (p
, "\"><segment address=\"");
1085 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1087 strcpy (p
, "\"/></library>\n");
1091 strcpy (p
, "</library-list>\n");
1093 total_len
= strlen (document
);
1095 if (offset
> total_len
)
1101 if (offset
+ len
> total_len
)
1102 len
= total_len
- offset
;
1104 memcpy (readbuf
, document
+ offset
, len
);
1109 /* Handle qXfer:libraries-svr4:read. */
1112 handle_qxfer_libraries_svr4 (const char *annex
,
1113 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1114 ULONGEST offset
, LONGEST len
)
1116 if (writebuf
!= NULL
)
1119 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1122 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1125 /* Handle qXfer:osadata:read. */
1128 handle_qxfer_osdata (const char *annex
,
1129 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1130 ULONGEST offset
, LONGEST len
)
1132 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1135 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1138 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1141 handle_qxfer_siginfo (const char *annex
,
1142 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1143 ULONGEST offset
, LONGEST len
)
1145 if (the_target
->qxfer_siginfo
== NULL
)
1148 if (annex
[0] != '\0' || !target_running ())
1151 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1154 /* Handle qXfer:spu:read and qXfer:spu:write. */
1157 handle_qxfer_spu (const char *annex
,
1158 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1159 ULONGEST offset
, LONGEST len
)
1161 if (the_target
->qxfer_spu
== NULL
)
1164 if (!target_running ())
1167 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1170 /* Handle qXfer:statictrace:read. */
1173 handle_qxfer_statictrace (const char *annex
,
1174 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1175 ULONGEST offset
, LONGEST len
)
1179 if (writebuf
!= NULL
)
1182 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1185 if (traceframe_read_sdata (current_traceframe
, offset
,
1186 readbuf
, len
, &nbytes
))
1191 /* Helper for handle_qxfer_threads. */
1194 handle_qxfer_threads_proper (struct buffer
*buffer
)
1196 struct inferior_list_entry
*thread
;
1198 buffer_grow_str (buffer
, "<threads>\n");
1200 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
1202 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
1204 int core
= target_core_of_thread (ptid
);
1207 write_ptid (ptid_s
, ptid
);
1211 sprintf (core_s
, "%d", core
);
1212 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1217 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1222 buffer_grow_str0 (buffer
, "</threads>\n");
1225 /* Handle qXfer:threads:read. */
1228 handle_qxfer_threads (const char *annex
,
1229 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1230 ULONGEST offset
, LONGEST len
)
1232 static char *result
= 0;
1233 static unsigned int result_length
= 0;
1235 if (writebuf
!= NULL
)
1238 if (!target_running () || annex
[0] != '\0')
1243 struct buffer buffer
;
1244 /* When asked for data at offset 0, generate everything and store into
1245 'result'. Successive reads will be served off 'result'. */
1249 buffer_init (&buffer
);
1251 handle_qxfer_threads_proper (&buffer
);
1253 result
= buffer_finish (&buffer
);
1254 result_length
= strlen (result
);
1255 buffer_free (&buffer
);
1258 if (offset
>= result_length
)
1260 /* We're out of data. */
1267 if (len
> result_length
- offset
)
1268 len
= result_length
- offset
;
1270 memcpy (readbuf
, result
+ offset
, len
);
1275 /* Handle qXfer:traceframe-info:read. */
1278 handle_qxfer_traceframe_info (const char *annex
,
1279 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1280 ULONGEST offset
, LONGEST len
)
1282 static char *result
= 0;
1283 static unsigned int result_length
= 0;
1285 if (writebuf
!= NULL
)
1288 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1293 struct buffer buffer
;
1295 /* When asked for data at offset 0, generate everything and
1296 store into 'result'. Successive reads will be served off
1300 buffer_init (&buffer
);
1302 traceframe_read_info (current_traceframe
, &buffer
);
1304 result
= buffer_finish (&buffer
);
1305 result_length
= strlen (result
);
1306 buffer_free (&buffer
);
1309 if (offset
>= result_length
)
1311 /* We're out of data. */
1318 if (len
> result_length
- offset
)
1319 len
= result_length
- offset
;
1321 memcpy (readbuf
, result
+ offset
, len
);
1325 /* Handle qXfer:fdpic:read. */
1328 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1329 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1331 if (the_target
->read_loadmap
== NULL
)
1334 if (!target_running ())
1337 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1340 /* Handle qXfer:btrace:read. */
1343 handle_qxfer_btrace (const char *annex
,
1344 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1345 ULONGEST offset
, LONGEST len
)
1347 static struct buffer cache
;
1348 struct thread_info
*thread
;
1351 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1354 if (!target_running ())
1357 if (ptid_equal (general_thread
, null_ptid
)
1358 || ptid_equal (general_thread
, minus_one_ptid
))
1360 strcpy (own_buf
, "E.Must select a single thread.");
1364 thread
= find_thread_ptid (general_thread
);
1367 strcpy (own_buf
, "E.No such thread.");
1371 if (thread
->btrace
== NULL
)
1373 strcpy (own_buf
, "E.Btrace not enabled.");
1377 if (strcmp (annex
, "all") == 0)
1378 type
= btrace_read_all
;
1379 else if (strcmp (annex
, "new") == 0)
1380 type
= btrace_read_new
;
1383 strcpy (own_buf
, "E.Bad annex.");
1389 buffer_free (&cache
);
1391 target_read_btrace (thread
->btrace
, &cache
, type
);
1393 else if (offset
> cache
.used_size
)
1395 buffer_free (&cache
);
1399 if (len
> cache
.used_size
- offset
)
1400 len
= cache
.used_size
- offset
;
1402 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1407 static const struct qxfer qxfer_packets
[] =
1409 { "auxv", handle_qxfer_auxv
},
1410 { "btrace", handle_qxfer_btrace
},
1411 { "fdpic", handle_qxfer_fdpic
},
1412 { "features", handle_qxfer_features
},
1413 { "libraries", handle_qxfer_libraries
},
1414 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1415 { "osdata", handle_qxfer_osdata
},
1416 { "siginfo", handle_qxfer_siginfo
},
1417 { "spu", handle_qxfer_spu
},
1418 { "statictrace", handle_qxfer_statictrace
},
1419 { "threads", handle_qxfer_threads
},
1420 { "traceframe-info", handle_qxfer_traceframe_info
},
1424 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1432 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1435 /* Grab the object, r/w and annex. */
1436 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1438 write_enn (own_buf
);
1443 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1446 const struct qxfer
*q
= &qxfer_packets
[i
];
1448 if (strcmp (object
, q
->object
) == 0)
1450 if (strcmp (rw
, "read") == 0)
1452 unsigned char *data
;
1457 /* Grab the offset and length. */
1458 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1460 write_enn (own_buf
);
1464 /* Read one extra byte, as an indicator of whether there is
1466 if (len
> PBUFSIZ
- 2)
1468 data
= malloc (len
+ 1);
1471 write_enn (own_buf
);
1474 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1482 /* Preserve error message. */
1485 write_enn (own_buf
);
1487 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1489 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1494 else if (strcmp (rw
, "write") == 0)
1499 unsigned char *data
;
1501 strcpy (own_buf
, "E00");
1502 data
= malloc (packet_len
- (offset
- own_buf
));
1505 write_enn (own_buf
);
1508 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1509 &ofs
, &len
, data
) < 0)
1512 write_enn (own_buf
);
1516 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1524 /* Preserve error message. */
1527 write_enn (own_buf
);
1529 sprintf (own_buf
, "%x", n
);
1542 /* Table used by the crc32 function to calcuate the checksum. */
1544 static unsigned int crc32_table
[256] =
1547 /* Compute 32 bit CRC from inferior memory.
1549 On success, return 32 bit CRC.
1550 On failure, return (unsigned long long) -1. */
1552 static unsigned long long
1553 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1555 if (!crc32_table
[1])
1557 /* Initialize the CRC table and the decoding table. */
1561 for (i
= 0; i
< 256; i
++)
1563 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1564 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1571 unsigned char byte
= 0;
1573 /* Return failure if memory read fails. */
1574 if (read_inferior_memory (base
, &byte
, 1) != 0)
1575 return (unsigned long long) -1;
1577 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1580 return (unsigned long long) crc
;
1583 /* Handle all of the extended 'q' packets. */
1586 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1588 static struct inferior_list_entry
*thread_ptr
;
1590 /* Reply the current thread id. */
1591 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1594 require_running (own_buf
);
1596 if (!ptid_equal (general_thread
, null_ptid
)
1597 && !ptid_equal (general_thread
, minus_one_ptid
))
1598 gdb_id
= general_thread
;
1601 thread_ptr
= all_threads
.head
;
1602 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1605 sprintf (own_buf
, "QC");
1607 write_ptid (own_buf
, gdb_id
);
1611 if (strcmp ("qSymbol::", own_buf
) == 0)
1613 /* GDB is suggesting new symbols have been loaded. This may
1614 mean a new shared library has been detected as loaded, so
1615 take the opportunity to check if breakpoints we think are
1616 inserted, still are. Note that it isn't guaranteed that
1617 we'll see this when a shared library is loaded, and nor will
1618 we see this for unloads (although breakpoints in unloaded
1619 libraries shouldn't trigger), as GDB may not find symbols for
1620 the library at all. We also re-validate breakpoints when we
1621 see a second GDB breakpoint for the same address, and or when
1622 we access breakpoint shadows. */
1623 validate_breakpoints ();
1625 if (target_supports_tracepoints ())
1626 tracepoint_look_up_symbols ();
1628 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1629 (*the_target
->look_up_symbols
) ();
1631 strcpy (own_buf
, "OK");
1635 if (!disable_packet_qfThreadInfo
)
1637 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1641 require_running (own_buf
);
1642 thread_ptr
= all_threads
.head
;
1645 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1646 write_ptid (own_buf
, gdb_id
);
1647 thread_ptr
= thread_ptr
->next
;
1651 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1655 require_running (own_buf
);
1656 if (thread_ptr
!= NULL
)
1659 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1660 write_ptid (own_buf
, gdb_id
);
1661 thread_ptr
= thread_ptr
->next
;
1666 sprintf (own_buf
, "l");
1672 if (the_target
->read_offsets
!= NULL
1673 && strcmp ("qOffsets", own_buf
) == 0)
1675 CORE_ADDR text
, data
;
1677 require_running (own_buf
);
1678 if (the_target
->read_offsets (&text
, &data
))
1679 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1680 (long)text
, (long)data
, (long)data
);
1682 write_enn (own_buf
);
1687 /* Protocol features query. */
1688 if (strncmp ("qSupported", own_buf
, 10) == 0
1689 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1691 char *p
= &own_buf
[10];
1692 int gdb_supports_qRelocInsn
= 0;
1694 /* Start processing qSupported packet. */
1695 target_process_qsupported (NULL
);
1697 /* Process each feature being provided by GDB. The first
1698 feature will follow a ':', and latter features will follow
1702 char **qsupported
= NULL
;
1706 /* Two passes, to avoid nested strtok calls in
1707 target_process_qsupported. */
1708 for (p
= strtok (p
+ 1, ";");
1710 p
= strtok (NULL
, ";"))
1713 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1714 qsupported
[count
- 1] = xstrdup (p
);
1717 for (i
= 0; i
< count
; i
++)
1720 if (strcmp (p
, "multiprocess+") == 0)
1722 /* GDB supports and wants multi-process support if
1724 if (target_supports_multi_process ())
1727 else if (strcmp (p
, "qRelocInsn+") == 0)
1729 /* GDB supports relocate instruction requests. */
1730 gdb_supports_qRelocInsn
= 1;
1733 target_process_qsupported (p
);
1742 "PacketSize=%x;QPassSignals+;QProgramSignals+",
1745 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1746 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
1747 ";augmented-libraries-svr4-read+");
1750 /* We do not have any hook to indicate whether the non-SVR4 target
1751 backend supports qXfer:libraries:read, so always report it. */
1752 strcat (own_buf
, ";qXfer:libraries:read+");
1755 if (the_target
->read_auxv
!= NULL
)
1756 strcat (own_buf
, ";qXfer:auxv:read+");
1758 if (the_target
->qxfer_spu
!= NULL
)
1759 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1761 if (the_target
->qxfer_siginfo
!= NULL
)
1762 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1764 if (the_target
->read_loadmap
!= NULL
)
1765 strcat (own_buf
, ";qXfer:fdpic:read+");
1767 /* We always report qXfer:features:read, as targets may
1768 install XML files on a subsequent call to arch_setup.
1769 If we reported to GDB on startup that we don't support
1770 qXfer:feature:read at all, we will never be re-queried. */
1771 strcat (own_buf
, ";qXfer:features:read+");
1773 if (transport_is_reliable
)
1774 strcat (own_buf
, ";QStartNoAckMode+");
1776 if (the_target
->qxfer_osdata
!= NULL
)
1777 strcat (own_buf
, ";qXfer:osdata:read+");
1779 if (target_supports_multi_process ())
1780 strcat (own_buf
, ";multiprocess+");
1782 if (target_supports_non_stop ())
1783 strcat (own_buf
, ";QNonStop+");
1785 if (target_supports_disable_randomization ())
1786 strcat (own_buf
, ";QDisableRandomization+");
1788 strcat (own_buf
, ";qXfer:threads:read+");
1790 if (target_supports_tracepoints ())
1792 strcat (own_buf
, ";ConditionalTracepoints+");
1793 strcat (own_buf
, ";TraceStateVariables+");
1794 strcat (own_buf
, ";TracepointSource+");
1795 strcat (own_buf
, ";DisconnectedTracing+");
1796 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1797 strcat (own_buf
, ";FastTracepoints+");
1798 strcat (own_buf
, ";StaticTracepoints+");
1799 strcat (own_buf
, ";InstallInTrace+");
1800 strcat (own_buf
, ";qXfer:statictrace:read+");
1801 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1802 strcat (own_buf
, ";EnableDisableTracepoints+");
1803 strcat (own_buf
, ";QTBuffer:size+");
1804 strcat (own_buf
, ";tracenz+");
1807 /* Support target-side breakpoint conditions and commands. */
1808 strcat (own_buf
, ";ConditionalBreakpoints+");
1809 strcat (own_buf
, ";BreakpointCommands+");
1811 if (target_supports_agent ())
1812 strcat (own_buf
, ";QAgent+");
1814 if (target_supports_btrace ())
1816 strcat (own_buf
, ";Qbtrace:bts+");
1817 strcat (own_buf
, ";Qbtrace:off+");
1818 strcat (own_buf
, ";qXfer:btrace:read+");
1824 /* Thread-local storage support. */
1825 if (the_target
->get_tls_address
!= NULL
1826 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1828 char *p
= own_buf
+ 12;
1829 CORE_ADDR parts
[2], address
= 0;
1831 ptid_t ptid
= null_ptid
;
1833 require_running (own_buf
);
1835 for (i
= 0; i
< 3; i
++)
1843 p2
= strchr (p
, ',');
1856 ptid
= read_ptid (p
, NULL
);
1858 decode_address (&parts
[i
- 1], p
, len
);
1862 if (p
!= NULL
|| i
< 3)
1866 struct thread_info
*thread
= find_thread_ptid (ptid
);
1871 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1877 strcpy (own_buf
, paddress(address
));
1882 write_enn (own_buf
);
1886 /* Otherwise, pretend we do not understand this packet. */
1889 /* Windows OS Thread Information Block address support. */
1890 if (the_target
->get_tib_address
!= NULL
1891 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1896 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1898 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1901 strcpy (own_buf
, paddress(tlb
));
1906 write_enn (own_buf
);
1912 /* Handle "monitor" commands. */
1913 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1915 char *mon
= malloc (PBUFSIZ
);
1916 int len
= strlen (own_buf
+ 6);
1920 write_enn (own_buf
);
1924 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1926 write_enn (own_buf
);
1930 mon
[len
/ 2] = '\0';
1934 if (the_target
->handle_monitor_command
== NULL
1935 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1936 /* Default processing. */
1937 handle_monitor_command (mon
, own_buf
);
1943 if (strncmp ("qSearch:memory:", own_buf
,
1944 sizeof ("qSearch:memory:") - 1) == 0)
1946 require_running (own_buf
);
1947 handle_search_memory (own_buf
, packet_len
);
1951 if (strcmp (own_buf
, "qAttached") == 0
1952 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1954 struct process_info
*process
;
1956 if (own_buf
[sizeof ("qAttached") - 1])
1958 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1959 process
= (struct process_info
*)
1960 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1964 require_running (own_buf
);
1965 process
= current_process ();
1968 if (process
== NULL
)
1970 write_enn (own_buf
);
1974 strcpy (own_buf
, process
->attached
? "1" : "0");
1978 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1980 /* CRC check (compare-section). */
1984 unsigned long long crc
;
1986 require_running (own_buf
);
1987 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
1988 if (*comma
++ != ',')
1990 write_enn (own_buf
);
1993 len
= strtoul (comma
, NULL
, 16);
1994 crc
= crc32 (base
, len
, 0xffffffff);
1995 /* Check for memory failure. */
1996 if (crc
== (unsigned long long) -1)
1998 write_enn (own_buf
);
2001 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2005 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2008 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2011 /* Otherwise we didn't know what packet it was. Say we didn't
2016 static void gdb_wants_all_threads_stopped (void);
2018 /* Parse vCont packets. */
2020 handle_v_cont (char *own_buf
)
2024 struct thread_resume
*resume_info
;
2025 struct thread_resume default_action
= {{0}};
2027 /* Count the number of semicolons in the packet. There should be one
2028 for every action. */
2034 p
= strchr (p
, ';');
2037 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2038 if (resume_info
== NULL
)
2046 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2048 if (p
[0] == 's' || p
[0] == 'S')
2049 resume_info
[i
].kind
= resume_step
;
2050 else if (p
[0] == 'r')
2051 resume_info
[i
].kind
= resume_step
;
2052 else if (p
[0] == 'c' || p
[0] == 'C')
2053 resume_info
[i
].kind
= resume_continue
;
2054 else if (p
[0] == 't')
2055 resume_info
[i
].kind
= resume_stop
;
2059 if (p
[0] == 'S' || p
[0] == 'C')
2062 sig
= strtol (p
+ 1, &q
, 16);
2067 if (!gdb_signal_to_host_p (sig
))
2069 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2071 else if (p
[0] == 'r')
2075 p
= unpack_varlen_hex (p
+ 1, &addr
);
2076 resume_info
[i
].step_range_start
= addr
;
2081 p
= unpack_varlen_hex (p
+ 1, &addr
);
2082 resume_info
[i
].step_range_end
= addr
;
2091 resume_info
[i
].thread
= minus_one_ptid
;
2092 default_action
= resume_info
[i
];
2094 /* Note: we don't increment i here, we'll overwrite this entry
2095 the next time through. */
2097 else if (p
[0] == ':')
2099 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2104 if (p
[0] != ';' && p
[0] != 0)
2107 resume_info
[i
].thread
= ptid
;
2114 resume_info
[i
] = default_action
;
2116 /* `cont_thread' is still used in occasional places in the backend,
2117 to implement single-thread scheduler-locking. Doesn't make sense
2118 to set it if we see a stop request, or a wildcard action (one
2119 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
2121 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
2122 || ptid_get_lwp (resume_info
[0].thread
) == -1)
2123 && resume_info
[0].kind
!= resume_stop
)
2124 cont_thread
= resume_info
[0].thread
;
2126 cont_thread
= minus_one_ptid
;
2127 set_desired_inferior (0);
2132 (*the_target
->resume
) (resume_info
, n
);
2140 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2142 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2143 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2144 current_inferior
->last_status
= last_status
;
2146 /* From the client's perspective, all-stop mode always stops all
2147 threads implicitly (and the target backend has already done
2148 so by now). Tag all threads as "want-stopped", so we don't
2149 resume them implicitly without the client telling us to. */
2150 gdb_wants_all_threads_stopped ();
2151 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2152 disable_async_io ();
2154 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2155 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2156 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2161 write_enn (own_buf
);
2166 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2168 handle_v_attach (char *own_buf
)
2172 pid
= strtol (own_buf
+ 8, NULL
, 16);
2173 if (pid
!= 0 && attach_inferior (pid
) == 0)
2175 /* Don't report shared library events after attaching, even if
2176 some libraries are preloaded. GDB will always poll the
2177 library list. Avoids the "stopped by shared library event"
2178 notice on the GDB side. */
2183 /* In non-stop, we don't send a resume reply. Stop events
2184 will follow up using the normal notification
2189 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2195 write_enn (own_buf
);
2200 /* Run a new program. Return 1 if successful, 0 if failure. */
2202 handle_v_run (char *own_buf
)
2204 char *p
, *next_p
, **new_argv
;
2208 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2214 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2215 if (new_argv
== NULL
)
2217 write_enn (own_buf
);
2222 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2224 next_p
= strchr (p
, ';');
2226 next_p
= p
+ strlen (p
);
2228 if (i
== 0 && p
== next_p
)
2232 /* FIXME: Fail request if out of memory instead of dying. */
2233 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2234 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2235 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2244 if (new_argv
[0] == NULL
)
2246 /* GDB didn't specify a program to run. Use the program from the
2247 last run with the new argument list. */
2249 if (program_argv
== NULL
)
2251 write_enn (own_buf
);
2252 freeargv (new_argv
);
2256 new_argv
[0] = strdup (program_argv
[0]);
2257 if (new_argv
[0] == NULL
)
2259 write_enn (own_buf
);
2260 freeargv (new_argv
);
2265 /* Free the old argv and install the new one. */
2266 freeargv (program_argv
);
2267 program_argv
= new_argv
;
2269 start_inferior (program_argv
);
2270 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2272 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2274 /* In non-stop, sending a resume reply doesn't set the general
2275 thread, but GDB assumes a vRun sets it (this is so GDB can
2276 query which is the main thread of the new inferior. */
2278 general_thread
= last_ptid
;
2284 write_enn (own_buf
);
2289 /* Kill process. Return 1 if successful, 0 if failure. */
2291 handle_v_kill (char *own_buf
)
2294 char *p
= &own_buf
[6];
2296 pid
= strtol (p
, NULL
, 16);
2299 if (pid
!= 0 && kill_inferior (pid
) == 0)
2301 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2302 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2303 last_ptid
= pid_to_ptid (pid
);
2304 discard_queued_stop_replies (pid
);
2310 write_enn (own_buf
);
2315 /* Handle all of the extended 'v' packets. */
2317 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2319 if (!disable_packet_vCont
)
2321 if (strncmp (own_buf
, "vCont;", 6) == 0)
2323 require_running (own_buf
);
2324 handle_v_cont (own_buf
);
2328 if (strncmp (own_buf
, "vCont?", 6) == 0)
2330 strcpy (own_buf
, "vCont;c;C;s;S;t");
2331 if (target_supports_range_stepping ())
2333 own_buf
= own_buf
+ strlen (own_buf
);
2334 strcpy (own_buf
, ";r");
2340 if (strncmp (own_buf
, "vFile:", 6) == 0
2341 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2344 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2346 if ((!extended_protocol
|| !multi_process
) && target_running ())
2348 fprintf (stderr
, "Already debugging a process\n");
2349 write_enn (own_buf
);
2352 handle_v_attach (own_buf
);
2356 if (strncmp (own_buf
, "vRun;", 5) == 0)
2358 if ((!extended_protocol
|| !multi_process
) && target_running ())
2360 fprintf (stderr
, "Already debugging a process\n");
2361 write_enn (own_buf
);
2364 handle_v_run (own_buf
);
2368 if (strncmp (own_buf
, "vKill;", 6) == 0)
2370 if (!target_running ())
2372 fprintf (stderr
, "No process to kill\n");
2373 write_enn (own_buf
);
2376 handle_v_kill (own_buf
);
2380 if (handle_notif_ack (own_buf
, packet_len
))
2383 /* Otherwise we didn't know what packet it was. Say we didn't
2389 /* Resume inferior and wait for another event. In non-stop mode,
2390 don't really wait here, but return immediatelly to the event
2393 myresume (char *own_buf
, int step
, int sig
)
2395 struct thread_resume resume_info
[2];
2397 int valid_cont_thread
;
2399 set_desired_inferior (0);
2401 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2402 && !ptid_equal (cont_thread
, minus_one_ptid
));
2404 if (step
|| sig
|| valid_cont_thread
)
2406 resume_info
[0].thread
= current_ptid
;
2408 resume_info
[0].kind
= resume_step
;
2410 resume_info
[0].kind
= resume_continue
;
2411 resume_info
[0].sig
= sig
;
2415 if (!valid_cont_thread
)
2417 resume_info
[n
].thread
= minus_one_ptid
;
2418 resume_info
[n
].kind
= resume_continue
;
2419 resume_info
[n
].sig
= 0;
2426 (*the_target
->resume
) (resume_info
, n
);
2432 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2434 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2435 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2437 current_inferior
->last_resume_kind
= resume_stop
;
2438 current_inferior
->last_status
= last_status
;
2441 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2442 disable_async_io ();
2444 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2445 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2446 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2450 /* Callback for for_each_inferior. Make a new stop reply for each
2454 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2456 struct thread_info
*thread
= (struct thread_info
*) entry
;
2458 /* For now, assume targets that don't have this callback also don't
2459 manage the thread's last_status field. */
2460 if (the_target
->thread_stopped
== NULL
)
2462 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2464 new_notif
->ptid
= entry
->id
;
2465 new_notif
->status
= thread
->last_status
;
2466 /* Pass the last stop reply back to GDB, but don't notify
2468 notif_event_enque (¬if_stop
,
2469 (struct notif_event
*) new_notif
);
2473 if (thread_stopped (thread
))
2478 = target_waitstatus_to_string (&thread
->last_status
);
2481 "Reporting thread %s as already stopped with %s\n",
2482 target_pid_to_str (entry
->id
),
2485 xfree (status_string
);
2488 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2490 /* Pass the last stop reply back to GDB, but don't notify
2492 queue_stop_reply (entry
->id
, &thread
->last_status
);
2499 /* Set this inferior threads's state as "want-stopped". We won't
2500 resume this thread until the client gives us another action for
2504 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2506 struct thread_info
*thread
= (struct thread_info
*) entry
;
2508 thread
->last_resume_kind
= resume_stop
;
2510 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2512 /* Most threads are stopped implicitly (all-stop); tag that with
2514 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2515 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2519 /* Set all threads' states as "want-stopped". */
2522 gdb_wants_all_threads_stopped (void)
2524 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2527 /* Clear the gdb_detached flag of every process. */
2530 gdb_reattached_process (struct inferior_list_entry
*entry
)
2532 struct process_info
*process
= (struct process_info
*) entry
;
2534 process
->gdb_detached
= 0;
2537 /* Status handler for the '?' packet. */
2540 handle_status (char *own_buf
)
2542 /* GDB is connected, don't forward events to the target anymore. */
2543 for_each_inferior (&all_processes
, gdb_reattached_process
);
2545 /* In non-stop mode, we must send a stop reply for each stopped
2546 thread. In all-stop mode, just send one for the first stopped
2551 discard_queued_stop_replies (-1);
2552 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2554 /* The first is sent immediatly. OK is sent if there is no
2555 stopped thread, which is the same handling of the vStopped
2556 packet (by design). */
2557 notif_write_event (¬if_stop
, own_buf
);
2562 stabilize_threads ();
2563 gdb_wants_all_threads_stopped ();
2565 if (all_threads
.head
)
2567 struct target_waitstatus status
;
2569 status
.kind
= TARGET_WAITKIND_STOPPED
;
2570 status
.value
.sig
= GDB_SIGNAL_TRAP
;
2571 prepare_resume_reply (own_buf
,
2572 all_threads
.head
->id
, &status
);
2575 strcpy (own_buf
, "W00");
2580 gdbserver_version (void)
2582 printf ("GNU gdbserver %s%s\n"
2583 "Copyright (C) 2013 Free Software Foundation, Inc.\n"
2584 "gdbserver is free software, covered by the "
2585 "GNU General Public License.\n"
2586 "This gdbserver was configured as \"%s\"\n",
2587 PKGVERSION
, version
, host_name
);
2591 gdbserver_usage (FILE *stream
)
2593 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2594 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2595 "\tgdbserver [OPTIONS] --multi COMM\n"
2597 "COMM may either be a tty device (for serial debugging), or \n"
2598 "HOST:PORT to listen for a TCP connection.\n"
2601 " --debug Enable general debugging output.\n"
2602 " --remote-debug Enable remote protocol debugging output.\n"
2603 " --version Display version information and exit.\n"
2604 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2605 " --once Exit after the first connection has "
2607 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2608 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2612 gdbserver_show_disableable (FILE *stream
)
2614 fprintf (stream
, "Disableable packets:\n"
2615 " vCont \tAll vCont packets\n"
2616 " qC \tQuerying the current thread\n"
2617 " qfThreadInfo\tThread listing\n"
2618 " Tthread \tPassing the thread specifier in the "
2619 "T stop reply packet\n"
2620 " threads \tAll of the above\n");
2624 #undef require_running
2625 #define require_running(BUF) \
2626 if (!target_running ()) \
2633 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2635 int pid
= * (int *) args
;
2637 if (ptid_get_pid (entry
->id
) == pid
)
2644 kill_inferior_callback (struct inferior_list_entry
*entry
)
2646 struct process_info
*process
= (struct process_info
*) entry
;
2647 int pid
= ptid_get_pid (process
->head
.id
);
2649 kill_inferior (pid
);
2650 discard_queued_stop_replies (pid
);
2653 /* Callback for for_each_inferior to detach or kill the inferior,
2654 depending on whether we attached to it or not.
2655 We inform the user whether we're detaching or killing the process
2656 as this is only called when gdbserver is about to exit. */
2659 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2661 struct process_info
*process
= (struct process_info
*) entry
;
2662 int pid
= ptid_get_pid (process
->head
.id
);
2664 if (process
->attached
)
2665 detach_inferior (pid
);
2667 kill_inferior (pid
);
2669 discard_queued_stop_replies (pid
);
2672 /* for_each_inferior callback for detach_or_kill_for_exit to print
2673 the pids of started inferiors. */
2676 print_started_pid (struct inferior_list_entry
*entry
)
2678 struct process_info
*process
= (struct process_info
*) entry
;
2680 if (! process
->attached
)
2682 int pid
= ptid_get_pid (process
->head
.id
);
2683 fprintf (stderr
, " %d", pid
);
2687 /* for_each_inferior callback for detach_or_kill_for_exit to print
2688 the pids of attached inferiors. */
2691 print_attached_pid (struct inferior_list_entry
*entry
)
2693 struct process_info
*process
= (struct process_info
*) entry
;
2695 if (process
->attached
)
2697 int pid
= ptid_get_pid (process
->head
.id
);
2698 fprintf (stderr
, " %d", pid
);
2702 /* Call this when exiting gdbserver with possible inferiors that need
2703 to be killed or detached from. */
2706 detach_or_kill_for_exit (void)
2708 /* First print a list of the inferiors we will be killing/detaching.
2709 This is to assist the user, for example, in case the inferior unexpectedly
2710 dies after we exit: did we screw up or did the inferior exit on its own?
2711 Having this info will save some head-scratching. */
2713 if (have_started_inferiors_p ())
2715 fprintf (stderr
, "Killing process(es):");
2716 for_each_inferior (&all_processes
, print_started_pid
);
2717 fprintf (stderr
, "\n");
2719 if (have_attached_inferiors_p ())
2721 fprintf (stderr
, "Detaching process(es):");
2722 for_each_inferior (&all_processes
, print_attached_pid
);
2723 fprintf (stderr
, "\n");
2726 /* Now we can kill or detach the inferiors. */
2728 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2732 main (int argc
, char *argv
[])
2736 char *arg_end
, *port
;
2737 char **next_arg
= &argv
[1];
2738 volatile int multi_mode
= 0;
2739 volatile int attach
= 0;
2742 while (*next_arg
!= NULL
&& **next_arg
== '-')
2744 if (strcmp (*next_arg
, "--version") == 0)
2746 gdbserver_version ();
2749 else if (strcmp (*next_arg
, "--help") == 0)
2751 gdbserver_usage (stdout
);
2754 else if (strcmp (*next_arg
, "--attach") == 0)
2756 else if (strcmp (*next_arg
, "--multi") == 0)
2758 else if (strcmp (*next_arg
, "--wrapper") == 0)
2762 wrapper_argv
= next_arg
;
2763 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2766 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2768 gdbserver_usage (stderr
);
2772 /* Consume the "--". */
2775 else if (strcmp (*next_arg
, "--debug") == 0)
2777 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2779 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2781 gdbserver_show_disableable (stdout
);
2784 else if (strncmp (*next_arg
,
2785 "--disable-packet=",
2786 sizeof ("--disable-packet=") - 1) == 0)
2788 char *packets
, *tok
;
2790 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2791 for (tok
= strtok (packets
, ",");
2793 tok
= strtok (NULL
, ","))
2795 if (strcmp ("vCont", tok
) == 0)
2796 disable_packet_vCont
= 1;
2797 else if (strcmp ("Tthread", tok
) == 0)
2798 disable_packet_Tthread
= 1;
2799 else if (strcmp ("qC", tok
) == 0)
2800 disable_packet_qC
= 1;
2801 else if (strcmp ("qfThreadInfo", tok
) == 0)
2802 disable_packet_qfThreadInfo
= 1;
2803 else if (strcmp ("threads", tok
) == 0)
2805 disable_packet_vCont
= 1;
2806 disable_packet_Tthread
= 1;
2807 disable_packet_qC
= 1;
2808 disable_packet_qfThreadInfo
= 1;
2812 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2814 gdbserver_show_disableable (stderr
);
2819 else if (strcmp (*next_arg
, "-") == 0)
2821 /* "-" specifies a stdio connection and is a form of port
2823 *next_arg
= STDIO_CONNECTION_NAME
;
2826 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2827 disable_randomization
= 1;
2828 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2829 disable_randomization
= 0;
2830 else if (strcmp (*next_arg
, "--once") == 0)
2834 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2842 if (setjmp (toplevel
))
2844 fprintf (stderr
, "Exiting\n");
2850 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2852 gdbserver_usage (stderr
);
2856 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
2857 opened by remote_prepare. */
2860 /* We need to know whether the remote connection is stdio before
2861 starting the inferior. Inferiors created in this scenario have
2862 stdin,stdout redirected. So do this here before we call
2864 remote_prepare (port
);
2869 /* --attach used to come after PORT, so allow it there for
2871 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2878 && (*next_arg
== NULL
2879 || (*next_arg
)[0] == '\0'
2880 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2882 || next_arg
[1] != NULL
))
2887 gdbserver_usage (stderr
);
2891 initialize_async_io ();
2893 initialize_event_loop ();
2894 if (target_supports_tracepoints ())
2895 initialize_tracepoint ();
2897 own_buf
= xmalloc (PBUFSIZ
+ 1);
2898 mem_buf
= xmalloc (PBUFSIZ
);
2900 if (pid
== 0 && *next_arg
!= NULL
)
2904 n
= argc
- (next_arg
- argv
);
2905 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2906 for (i
= 0; i
< n
; i
++)
2907 program_argv
[i
] = xstrdup (next_arg
[i
]);
2908 program_argv
[i
] = NULL
;
2910 /* Wait till we are at first instruction in program. */
2911 start_inferior (program_argv
);
2913 /* We are now (hopefully) stopped at the first instruction of
2914 the target process. This assumes that the target process was
2915 successfully created. */
2919 if (attach_inferior (pid
) == -1)
2920 error ("Attaching not supported on this target");
2922 /* Otherwise succeeded. */
2926 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2927 last_status
.value
.integer
= 0;
2928 last_ptid
= minus_one_ptid
;
2931 initialize_notif ();
2933 /* Don't report shared library events on the initial connection,
2934 even if some libraries are preloaded. Avoids the "stopped by
2935 shared library event" notice on gdb side. */
2938 if (setjmp (toplevel
))
2940 /* If something fails and longjmps while detaching or killing
2941 inferiors, we'd end up here again, stuck in an infinite loop
2942 trap. Be sure that if that happens, we exit immediately
2944 if (setjmp (toplevel
) == 0)
2945 detach_or_kill_for_exit ();
2947 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2951 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2952 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2957 if (!was_running
&& !multi_mode
)
2959 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2967 /* Be sure we're out of tfind mode. */
2968 current_traceframe
= -1;
2972 if (setjmp (toplevel
) != 0)
2974 /* An error occurred. */
2975 if (response_needed
)
2977 write_enn (own_buf
);
2982 /* Wait for events. This will return when all event sources are
2983 removed from the event loop. */
2984 start_event_loop ();
2986 /* If an exit was requested (using the "monitor exit" command),
2987 terminate now. The only other way to get here is for
2988 getpkt to fail; close the connection and reopen it at the
2991 if (exit_requested
|| run_once
)
2993 /* If something fails and longjmps while detaching or
2994 killing inferiors, we'd end up here again, stuck in an
2995 infinite loop trap. Be sure that if that happens, we
2996 exit immediately instead. */
2997 if (setjmp (toplevel
) == 0)
2999 detach_or_kill_for_exit ();
3004 fprintf (stderr
, "Detach or kill failed. Exiting\n");
3010 "Remote side has terminated connection. "
3011 "GDBserver will reopen the connection.\n");
3015 if (disconnected_tracing
)
3017 /* Try to enable non-stop/async mode, so we we can both
3018 wait for an async socket accept, and handle async
3019 target events simultaneously. There's also no point
3020 either in having the target always stop all threads,
3021 when we're going to pass signals down without
3025 if (start_non_stop (1))
3028 /* Detaching implicitly resumes all threads; simply
3029 disconnecting does not. */
3035 "Disconnected tracing disabled; stopping trace run.\n");
3042 /* Process options coming from Z packets for *point at address
3043 POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
3044 to point to the first char after the last processed option. */
3047 process_point_options (CORE_ADDR point_addr
, char **packet
)
3049 char *dataptr
= *packet
;
3052 /* Check if data has the correct format. */
3053 if (*dataptr
!= ';')
3060 if (*dataptr
== ';')
3063 if (*dataptr
== 'X')
3065 /* Conditional expression. */
3067 fprintf (stderr
, "Found breakpoint condition.\n");
3068 add_breakpoint_condition (point_addr
, &dataptr
);
3070 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
3072 dataptr
+= strlen ("cmds:");
3074 fprintf (stderr
, "Found breakpoint commands %s.\n", dataptr
);
3075 persist
= (*dataptr
== '1');
3077 add_breakpoint_commands (point_addr
, &dataptr
, persist
);
3081 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3083 /* Skip tokens until we find one that we recognize. */
3084 while (*dataptr
&& *dataptr
!= ';')
3091 /* Event loop callback that handles a serial event. The first byte in
3092 the serial buffer gets us here. We expect characters to arrive at
3093 a brisk pace, so we read the rest of the packet with a blocking
3097 process_serial_event (void)
3108 int new_packet_len
= -1;
3110 /* Used to decide when gdbserver should exit in
3111 multi-mode/remote. */
3112 static int have_ran
= 0;
3115 have_ran
= target_running ();
3117 disable_async_io ();
3119 response_needed
= 0;
3120 packet_len
= getpkt (own_buf
);
3121 if (packet_len
<= 0)
3124 /* Force an event loop break. */
3127 response_needed
= 1;
3134 handle_query (own_buf
, packet_len
, &new_packet_len
);
3137 handle_general_set (own_buf
);
3140 require_running (own_buf
);
3145 pid
= strtol (&own_buf
[i
], NULL
, 16);
3148 pid
= ptid_get_pid (current_ptid
);
3150 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3152 struct thread_resume resume_info
;
3153 struct process_info
*process
= find_process_pid (pid
);
3155 if (process
== NULL
)
3157 write_enn (own_buf
);
3161 if (tracing
&& disconnected_tracing
)
3163 "Disconnected tracing in effect, "
3164 "leaving gdbserver attached to the process\n");
3166 if (any_persistent_commands ())
3168 "Persistent commands are present, "
3169 "leaving gdbserver attached to the process\n");
3171 /* Make sure we're in non-stop/async mode, so we we can both
3172 wait for an async socket accept, and handle async target
3173 events simultaneously. There's also no point either in
3174 having the target stop all threads, when we're going to
3175 pass signals down without informing GDB. */
3179 fprintf (stderr
, "Forcing non-stop mode\n");
3185 process
->gdb_detached
= 1;
3187 /* Detaching implicitly resumes all threads. */
3188 resume_info
.thread
= minus_one_ptid
;
3189 resume_info
.kind
= resume_continue
;
3190 resume_info
.sig
= 0;
3191 (*the_target
->resume
) (&resume_info
, 1);
3194 break; /* from switch/case */
3197 fprintf (stderr
, "Detaching from process %d\n", pid
);
3199 if (detach_inferior (pid
) != 0)
3200 write_enn (own_buf
);
3203 discard_queued_stop_replies (pid
);
3206 if (extended_protocol
)
3208 /* Treat this like a normal program exit. */
3209 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3210 last_status
.value
.integer
= 0;
3211 last_ptid
= pid_to_ptid (pid
);
3213 current_inferior
= NULL
;
3220 /* If we are attached, then we can exit. Otherwise, we
3221 need to hang around doing nothing, until the child is
3223 join_inferior (pid
);
3229 extended_protocol
= 1;
3233 handle_status (own_buf
);
3236 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3238 ptid_t gdb_id
, thread_id
;
3241 require_running (own_buf
);
3243 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3245 pid
= ptid_get_pid (gdb_id
);
3247 if (ptid_equal (gdb_id
, null_ptid
)
3248 || ptid_equal (gdb_id
, minus_one_ptid
))
3249 thread_id
= null_ptid
;
3251 && ptid_equal (pid_to_ptid (pid
),
3254 struct thread_info
*thread
=
3255 (struct thread_info
*) find_inferior (&all_threads
,
3260 write_enn (own_buf
);
3264 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
3268 thread_id
= gdb_id_to_thread_id (gdb_id
);
3269 if (ptid_equal (thread_id
, null_ptid
))
3271 write_enn (own_buf
);
3276 if (own_buf
[1] == 'g')
3278 if (ptid_equal (thread_id
, null_ptid
))
3280 /* GDB is telling us to choose any thread. Check if
3281 the currently selected thread is still valid. If
3282 it is not, select the first available. */
3283 struct thread_info
*thread
=
3284 (struct thread_info
*) find_inferior_id (&all_threads
,
3287 thread_id
= all_threads
.head
->id
;
3290 general_thread
= thread_id
;
3291 set_desired_inferior (1);
3293 else if (own_buf
[1] == 'c')
3294 cont_thread
= thread_id
;
3300 /* Silently ignore it so that gdb can extend the protocol
3301 without compatibility headaches. */
3306 require_running (own_buf
);
3307 if (current_traceframe
>= 0)
3309 struct regcache
*regcache
3310 = new_register_cache (current_target_desc ());
3312 if (fetch_traceframe_registers (current_traceframe
,
3314 registers_to_string (regcache
, own_buf
);
3316 write_enn (own_buf
);
3317 free_register_cache (regcache
);
3321 struct regcache
*regcache
;
3323 set_desired_inferior (1);
3324 regcache
= get_thread_regcache (current_inferior
, 1);
3325 registers_to_string (regcache
, own_buf
);
3329 require_running (own_buf
);
3330 if (current_traceframe
>= 0)
3331 write_enn (own_buf
);
3334 struct regcache
*regcache
;
3336 set_desired_inferior (1);
3337 regcache
= get_thread_regcache (current_inferior
, 1);
3338 registers_from_string (regcache
, &own_buf
[1]);
3343 require_running (own_buf
);
3344 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3345 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3347 write_enn (own_buf
);
3349 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3352 require_running (own_buf
);
3353 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3354 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3357 write_enn (own_buf
);
3360 require_running (own_buf
);
3361 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3362 &mem_addr
, &len
, &mem_buf
) < 0
3363 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3364 write_enn (own_buf
);
3369 require_running (own_buf
);
3370 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3371 if (gdb_signal_to_host_p (sig
))
3372 signal
= gdb_signal_to_host (sig
);
3375 myresume (own_buf
, 0, signal
);
3378 require_running (own_buf
);
3379 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3380 if (gdb_signal_to_host_p (sig
))
3381 signal
= gdb_signal_to_host (sig
);
3384 myresume (own_buf
, 1, signal
);
3387 require_running (own_buf
);
3389 myresume (own_buf
, 0, signal
);
3392 require_running (own_buf
);
3394 myresume (own_buf
, 1, signal
);
3396 case 'Z': /* insert_ ... */
3398 case 'z': /* remove_ ... */
3403 char type
= own_buf
[1];
3405 const int insert
= ch
== 'Z';
3406 char *p
= &own_buf
[3];
3408 p
= unpack_varlen_hex (p
, &addr
);
3409 len
= strtol (p
+ 1, &dataptr
, 16);
3411 /* Default to unrecognized/unsupported. */
3415 case '0': /* software-breakpoint */
3416 case '1': /* hardware-breakpoint */
3417 case '2': /* write watchpoint */
3418 case '3': /* read watchpoint */
3419 case '4': /* access watchpoint */
3420 require_running (own_buf
);
3421 if (insert
&& the_target
->insert_point
!= NULL
)
3423 /* Insert the breakpoint. If it is already inserted, nothing
3425 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3427 /* GDB may have sent us a list of *point parameters to be
3428 evaluated on the target's side. Read such list here. If we
3429 already have a list of parameters, GDB is telling us to drop
3430 that list and use this one instead. */
3431 if (!res
&& (type
== '0' || type
== '1'))
3433 /* Remove previous conditions. */
3434 clear_gdb_breakpoint_conditions (addr
);
3435 process_point_options (addr
, &dataptr
);
3438 else if (!insert
&& the_target
->remove_point
!= NULL
)
3439 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3451 write_enn (own_buf
);
3455 response_needed
= 0;
3456 if (!target_running ())
3457 /* The packet we received doesn't make sense - but we can't
3458 reply to it, either. */
3461 fprintf (stderr
, "Killing all inferiors\n");
3462 for_each_inferior (&all_processes
, kill_inferior_callback
);
3464 /* When using the extended protocol, we wait with no program
3465 running. The traditional protocol will exit instead. */
3466 if (extended_protocol
)
3468 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3469 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3477 ptid_t gdb_id
, thread_id
;
3479 require_running (own_buf
);
3481 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3482 thread_id
= gdb_id_to_thread_id (gdb_id
);
3483 if (ptid_equal (thread_id
, null_ptid
))
3485 write_enn (own_buf
);
3489 if (mythread_alive (thread_id
))
3492 write_enn (own_buf
);
3496 response_needed
= 0;
3498 /* Restarting the inferior is only supported in the extended
3500 if (extended_protocol
)
3502 if (target_running ())
3503 for_each_inferior (&all_processes
,
3504 kill_inferior_callback
);
3505 fprintf (stderr
, "GDBserver restarting\n");
3507 /* Wait till we are at 1st instruction in prog. */
3508 if (program_argv
!= NULL
)
3509 start_inferior (program_argv
);
3512 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3513 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3519 /* It is a request we don't understand. Respond with an
3520 empty packet so that gdb knows that we don't support this
3526 /* Extended (long) request. */
3527 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3531 /* It is a request we don't understand. Respond with an empty
3532 packet so that gdb knows that we don't support this
3538 if (new_packet_len
!= -1)
3539 putpkt_binary (own_buf
, new_packet_len
);
3543 response_needed
= 0;
3545 if (!extended_protocol
&& have_ran
&& !target_running ())
3547 /* In non-stop, defer exiting until GDB had a chance to query
3548 the whole vStopped list (until it gets an OK). */
3549 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3551 fprintf (stderr
, "GDBserver exiting\n");
3563 /* Event-loop callback for serial events. */
3566 handle_serial_event (int err
, gdb_client_data client_data
)
3569 fprintf (stderr
, "handling possible serial event\n");
3571 /* Really handle it. */
3572 if (process_serial_event () < 0)
3575 /* Be sure to not change the selected inferior behind GDB's back.
3576 Important in the non-stop mode asynchronous protocol. */
3577 set_desired_inferior (1);
3582 /* Event-loop callback for target events. */
3585 handle_target_event (int err
, gdb_client_data client_data
)
3588 fprintf (stderr
, "handling possible target event\n");
3590 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3593 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3595 int pid
= ptid_get_pid (last_ptid
);
3596 struct process_info
*process
= find_process_pid (pid
);
3597 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3599 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3600 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3602 mark_breakpoints_out (process
);
3603 mourn_inferior (process
);
3607 /* We're reporting this thread as stopped. Update its
3608 "want-stopped" state to what the client wants, until it
3609 gets a new resume action. */
3610 current_inferior
->last_resume_kind
= resume_stop
;
3611 current_inferior
->last_status
= last_status
;
3616 if (!target_running ())
3618 /* The last process exited. We're done. */
3622 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3624 /* A thread stopped with a signal, but gdb isn't
3625 connected to handle it. Pass it down to the
3626 inferior, as if it wasn't being traced. */
3627 struct thread_resume resume_info
;
3631 "GDB not connected; forwarding event %d for [%s]\n",
3632 (int) last_status
.kind
,
3633 target_pid_to_str (last_ptid
));
3635 resume_info
.thread
= last_ptid
;
3636 resume_info
.kind
= resume_continue
;
3637 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3638 (*the_target
->resume
) (&resume_info
, 1);
3640 else if (debug_threads
)
3641 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3642 (int) last_status
.kind
,
3643 target_pid_to_str (last_ptid
));
3647 struct vstop_notif
*vstop_notif
3648 = xmalloc (sizeof (struct vstop_notif
));
3650 vstop_notif
->status
= last_status
;
3651 vstop_notif
->ptid
= last_ptid
;
3652 /* Push Stop notification. */
3653 notif_push (¬if_stop
,
3654 (struct notif_event
*) vstop_notif
);
3658 /* Be sure to not change the selected inferior behind GDB's back.
3659 Important in the non-stop mode asynchronous protocol. */
3660 set_desired_inferior (1);