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"
36 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
37 `vCont'. Note the multi-process extensions made `vCont' a
38 requirement, so `Hc pPID.TID' is pretty much undefined. So
39 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
40 resuming all threads of the process (again, `Hc' isn't used for
41 multi-process), or a specific thread ptid_t.
43 We also set this when handling a single-thread `vCont' resume, as
44 some places in the backends check it to know when (and for which
45 thread) single-thread scheduler-locking is in effect. */
48 /* The thread set with an `Hg' packet. */
49 ptid_t general_thread
;
53 static int extended_protocol
;
54 static int response_needed
;
55 static int exit_requested
;
57 /* --once: Exit after the first connection has closed. */
63 /* Whether we should attempt to disable the operating system's address
64 space randomization feature before starting an inferior. */
65 int disable_randomization
= 1;
67 static char **program_argv
, **wrapper_argv
;
69 /* Enable miscellaneous debugging output. The name is historical - it
70 was originally used to debug LinuxThreads support. */
73 /* Enable debugging of h/w breakpoint/watchpoint support. */
76 int pass_signals
[GDB_SIGNAL_LAST
];
77 int program_signals
[GDB_SIGNAL_LAST
];
78 int program_signals_p
;
82 /* The PID of the originally created or attached inferior. Used to
83 send signals to the process when GDB sends us an asynchronous interrupt
84 (user hitting Control-C in the client), and to wait for the child to exit
85 when no longer debugging it. */
87 unsigned long signal_pid
;
90 /* A file descriptor for the controlling terminal. */
93 /* TERMINAL_FD's original foreground group. */
94 pid_t old_foreground_pgrp
;
96 /* Hand back terminal ownership to the original foreground group. */
99 restore_old_foreground_pgrp (void)
101 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
105 /* Set if you want to disable optional thread related packets support
106 in gdbserver, for the sake of testing GDB against stubs that don't
108 int disable_packet_vCont
;
109 int disable_packet_Tthread
;
110 int disable_packet_qC
;
111 int disable_packet_qfThreadInfo
;
113 /* Last status reported to GDB. */
114 static struct target_waitstatus last_status
;
115 static ptid_t last_ptid
;
117 static char *own_buf
;
118 static unsigned char *mem_buf
;
120 /* A sub-class of 'struct notif_event' for stop, holding information
121 relative to a single stop reply. We keep a queue of these to
122 push to GDB in non-stop mode. */
126 struct notif_event base
;
128 /* Thread or process that got the event. */
132 struct target_waitstatus status
;
135 DEFINE_QUEUE_P (notif_event_p
);
137 /* Put a stop reply to the stop reply queue. */
140 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
142 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
144 new_notif
->ptid
= ptid
;
145 new_notif
->status
= *status
;
147 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
151 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
152 QUEUE_ITER (notif_event_p
) *iter
,
153 struct notif_event
*event
,
159 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
161 if (q
->free_func
!= NULL
)
162 q
->free_func (event
);
164 QUEUE_remove_elem (notif_event_p
, q
, iter
);
170 /* Get rid of the currently pending stop replies for PID. If PID is
171 -1, then apply to all processes. */
174 discard_queued_stop_replies (int pid
)
176 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
177 remove_all_on_match_pid
, &pid
);
181 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
183 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
185 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
188 struct notif_server notif_stop
=
190 "vStopped", "Stop", NULL
, vstop_notif_reply
,
194 target_running (void)
196 return all_threads
.head
!= NULL
;
200 start_inferior (char **argv
)
202 char **new_argv
= argv
;
204 if (wrapper_argv
!= NULL
)
208 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
210 for (i
= 0; argv
[i
] != NULL
; i
++)
212 new_argv
= alloca (sizeof (char *) * count
);
214 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
215 new_argv
[count
++] = wrapper_argv
[i
];
216 for (i
= 0; argv
[i
] != NULL
; i
++)
217 new_argv
[count
++] = argv
[i
];
218 new_argv
[count
] = NULL
;
224 for (i
= 0; new_argv
[i
]; ++i
)
225 fprintf (stderr
, "new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
230 signal (SIGTTOU
, SIG_DFL
);
231 signal (SIGTTIN
, SIG_DFL
);
234 /* Clear this so the backend doesn't get confused, thinking
235 CONT_THREAD died, and it needs to resume all threads. */
236 cont_thread
= null_ptid
;
238 signal_pid
= create_inferior (new_argv
[0], new_argv
);
240 /* FIXME: we don't actually know at this point that the create
241 actually succeeded. We won't know that until we wait. */
242 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
247 signal (SIGTTOU
, SIG_IGN
);
248 signal (SIGTTIN
, SIG_IGN
);
249 terminal_fd
= fileno (stderr
);
250 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
251 tcsetpgrp (terminal_fd
, signal_pid
);
252 atexit (restore_old_foreground_pgrp
);
255 if (wrapper_argv
!= NULL
)
257 struct thread_resume resume_info
;
259 resume_info
.thread
= pid_to_ptid (signal_pid
);
260 resume_info
.kind
= resume_continue
;
263 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
265 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
270 (*the_target
->resume
) (&resume_info
, 1);
272 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
273 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
276 current_inferior
->last_resume_kind
= resume_stop
;
277 current_inferior
->last_status
= last_status
;
279 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
284 /* Wait till we are at 1st instruction in program, return new pid
285 (assuming success). */
286 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
288 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
289 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
291 current_inferior
->last_resume_kind
= resume_stop
;
292 current_inferior
->last_status
= last_status
;
299 attach_inferior (int pid
)
301 /* myattach should return -1 if attaching is unsupported,
302 0 if it succeeded, and call error() otherwise. */
304 if (myattach (pid
) != 0)
307 fprintf (stderr
, "Attached; pid = %d\n", pid
);
310 /* FIXME - It may be that we should get the SIGNAL_PID from the
311 attach function, so that it can be the main thread instead of
312 whichever we were told to attach to. */
315 /* Clear this so the backend doesn't get confused, thinking
316 CONT_THREAD died, and it needs to resume all threads. */
317 cont_thread
= null_ptid
;
321 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
323 /* GDB knows to ignore the first SIGSTOP after attaching to a running
324 process using the "attach" command, but this is different; it's
325 just using "target remote". Pretend it's just starting up. */
326 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
327 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
328 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
330 current_inferior
->last_resume_kind
= resume_stop
;
331 current_inferior
->last_status
= last_status
;
337 extern int remote_debug
;
339 /* Decode a qXfer read request. Return 0 if everything looks OK,
343 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
345 /* After the read marker and annex, qXfer looks like a
346 traditional 'm' packet. */
347 decode_m_packet (buf
, ofs
, len
);
353 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
355 /* Extract and NUL-terminate the object. */
357 while (*buf
&& *buf
!= ':')
363 /* Extract and NUL-terminate the read/write action. */
365 while (*buf
&& *buf
!= ':')
371 /* Extract and NUL-terminate the annex. */
373 while (*buf
&& *buf
!= ':')
383 /* Write the response to a successful qXfer read. Returns the
384 length of the (binary) data stored in BUF, corresponding
385 to as much of DATA/LEN as we could fit. IS_MORE controls
386 the first character of the response. */
388 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
397 return remote_escape_output (data
, len
, (unsigned char *) buf
+ 1, &out_len
,
401 /* Handle btrace enabling. */
404 handle_btrace_enable (struct thread_info
*thread
)
406 if (thread
->btrace
!= NULL
)
407 return "E.Btrace already enabled.";
409 thread
->btrace
= target_enable_btrace (thread
->entry
.id
);
410 if (thread
->btrace
== NULL
)
411 return "E.Could not enable btrace.";
416 /* Handle btrace disabling. */
419 handle_btrace_disable (struct thread_info
*thread
)
422 if (thread
->btrace
== NULL
)
423 return "E.Branch tracing not enabled.";
425 if (target_disable_btrace (thread
->btrace
) != 0)
426 return "E.Could not disable branch tracing.";
428 thread
->btrace
= NULL
;
432 /* Handle the "Qbtrace" packet. */
435 handle_btrace_general_set (char *own_buf
)
437 struct thread_info
*thread
;
441 if (strncmp ("Qbtrace:", own_buf
, strlen ("Qbtrace:")) != 0)
444 op
= own_buf
+ strlen ("Qbtrace:");
446 if (!target_supports_btrace ())
448 strcpy (own_buf
, "E.Target does not support branch tracing.");
452 if (ptid_equal (general_thread
, null_ptid
)
453 || ptid_equal (general_thread
, minus_one_ptid
))
455 strcpy (own_buf
, "E.Must select a single thread.");
459 thread
= find_thread_ptid (general_thread
);
462 strcpy (own_buf
, "E.No such thread.");
468 if (strcmp (op
, "bts") == 0)
469 err
= handle_btrace_enable (thread
);
470 else if (strcmp (op
, "off") == 0)
471 err
= handle_btrace_disable (thread
);
473 err
= "E.Bad Qbtrace operation. Use bts or off.";
476 strcpy (own_buf
, err
);
483 /* Handle all of the extended 'Q' packets. */
486 handle_general_set (char *own_buf
)
488 if (strncmp ("QPassSignals:", own_buf
, strlen ("QPassSignals:")) == 0)
490 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
491 const char *p
= own_buf
+ strlen ("QPassSignals:");
494 p
= decode_address_to_semicolon (&cursig
, p
);
495 for (i
= 0; i
< numsigs
; i
++)
501 /* Keep looping, to clear the remaining signals. */
504 p
= decode_address_to_semicolon (&cursig
, p
);
509 strcpy (own_buf
, "OK");
513 if (strncmp ("QProgramSignals:", own_buf
, strlen ("QProgramSignals:")) == 0)
515 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
516 const char *p
= own_buf
+ strlen ("QProgramSignals:");
519 program_signals_p
= 1;
521 p
= decode_address_to_semicolon (&cursig
, p
);
522 for (i
= 0; i
< numsigs
; i
++)
526 program_signals
[i
] = 1;
528 /* Keep looping, to clear the remaining signals. */
531 p
= decode_address_to_semicolon (&cursig
, p
);
534 program_signals
[i
] = 0;
536 strcpy (own_buf
, "OK");
540 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
544 fprintf (stderr
, "[noack mode enabled]\n");
553 if (strncmp (own_buf
, "QNonStop:", 9) == 0)
555 char *mode
= own_buf
+ 9;
559 if (strcmp (mode
, "0") == 0)
561 else if (strcmp (mode
, "1") == 0)
565 /* We don't know what this mode is, so complain to
567 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
573 req_str
= req
? "non-stop" : "all-stop";
574 if (start_non_stop (req
) != 0)
576 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
584 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
590 if (strncmp ("QDisableRandomization:", own_buf
,
591 strlen ("QDisableRandomization:")) == 0)
593 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
596 unpack_varlen_hex (packet
, &setting
);
597 disable_randomization
= setting
;
601 if (disable_randomization
)
602 fprintf (stderr
, "[address space randomization disabled]\n");
604 fprintf (stderr
, "[address space randomization enabled]\n");
611 if (target_supports_tracepoints ()
612 && handle_tracepoint_general_set (own_buf
))
615 if (strncmp ("QAgent:", own_buf
, strlen ("QAgent:")) == 0)
617 char *mode
= own_buf
+ strlen ("QAgent:");
620 if (strcmp (mode
, "0") == 0)
622 else if (strcmp (mode
, "1") == 0)
626 /* We don't know what this value is, so complain to GDB. */
627 sprintf (own_buf
, "E.Unknown QAgent value");
631 /* Update the flag. */
634 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
639 if (handle_btrace_general_set (own_buf
))
642 /* Otherwise we didn't know what packet it was. Say we didn't
648 get_features_xml (const char *annex
)
650 const struct target_desc
*desc
= current_target_desc ();
652 /* `desc->xmltarget' defines what to return when looking for the
653 "target.xml" file. Its contents can either be verbatim XML code
654 (prefixed with a '@') or else the name of the actual XML file to
655 be used in place of "target.xml".
657 This variable is set up from the auto-generated
658 init_registers_... routine for the current target. */
660 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
662 if (*desc
->xmltarget
== '@')
663 return desc
->xmltarget
+ 1;
665 annex
= desc
->xmltarget
;
670 extern const char *const xml_builtin
[][2];
673 /* Look for the annex. */
674 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
675 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
678 if (xml_builtin
[i
][0] != NULL
)
679 return xml_builtin
[i
][1];
687 monitor_show_help (void)
689 monitor_output ("The following monitor commands are supported:\n");
690 monitor_output (" set debug <0|1>\n");
691 monitor_output (" Enable general debugging messages\n");
692 monitor_output (" set debug-hw-points <0|1>\n");
693 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
694 monitor_output (" set remote-debug <0|1>\n");
695 monitor_output (" Enable remote protocol debugging messages\n");
696 monitor_output (" exit\n");
697 monitor_output (" Quit GDBserver\n");
700 /* Read trace frame or inferior memory. Returns the number of bytes
701 actually read, zero when no further transfer is possible, and -1 on
702 error. Return of a positive value smaller than LEN does not
703 indicate there's no more to be read, only the end of the transfer.
704 E.g., when GDB reads memory from a traceframe, a first request may
705 be served from a memory block that does not cover the whole request
706 length. A following request gets the rest served from either
707 another block (of the same traceframe) or from the read-only
711 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
715 if (current_traceframe
>= 0)
718 ULONGEST length
= len
;
720 if (traceframe_read_mem (current_traceframe
,
721 memaddr
, myaddr
, len
, &nbytes
))
723 /* Data read from trace buffer, we're done. */
726 if (!in_readonly_region (memaddr
, length
))
728 /* Otherwise we have a valid readonly case, fall through. */
729 /* (assume no half-trace half-real blocks for now) */
732 res
= prepare_to_access_memory ();
735 res
= read_inferior_memory (memaddr
, myaddr
, len
);
736 done_accessing_memory ();
738 return res
== 0 ? len
: -1;
744 /* Write trace frame or inferior memory. Actually, writing to trace
745 frames is forbidden. */
748 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
750 if (current_traceframe
>= 0)
756 ret
= prepare_to_access_memory ();
759 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
760 done_accessing_memory ();
766 /* Subroutine of handle_search_memory to simplify it. */
769 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
770 gdb_byte
*pattern
, unsigned pattern_len
,
771 gdb_byte
*search_buf
,
772 unsigned chunk_size
, unsigned search_buf_size
,
773 CORE_ADDR
*found_addrp
)
775 /* Prime the search buffer. */
777 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
780 warning ("Unable to access %ld bytes of target "
781 "memory at 0x%lx, halting search.",
782 (long) search_buf_size
, (long) start_addr
);
786 /* Perform the search.
788 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
789 When we've scanned N bytes we copy the trailing bytes to the start and
790 read in another N bytes. */
792 while (search_space_len
>= pattern_len
)
795 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
799 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
801 if (found_ptr
!= NULL
)
803 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
804 *found_addrp
= found_addr
;
808 /* Not found in this chunk, skip to next chunk. */
810 /* Don't let search_space_len wrap here, it's unsigned. */
811 if (search_space_len
>= chunk_size
)
812 search_space_len
-= chunk_size
;
814 search_space_len
= 0;
816 if (search_space_len
>= pattern_len
)
818 unsigned keep_len
= search_buf_size
- chunk_size
;
819 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
822 /* Copy the trailing part of the previous iteration to the front
823 of the buffer for the next iteration. */
824 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
826 nr_to_read
= (search_space_len
- keep_len
< chunk_size
827 ? search_space_len
- keep_len
830 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
831 nr_to_read
) != search_buf_size
)
833 warning ("Unable to access %ld bytes of target memory "
834 "at 0x%lx, halting search.",
835 (long) nr_to_read
, (long) read_addr
);
839 start_addr
+= chunk_size
;
848 /* Handle qSearch:memory packets. */
851 handle_search_memory (char *own_buf
, int packet_len
)
853 CORE_ADDR start_addr
;
854 CORE_ADDR search_space_len
;
856 unsigned int pattern_len
;
857 /* NOTE: also defined in find.c testcase. */
858 #define SEARCH_CHUNK_SIZE 16000
859 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
860 /* Buffer to hold memory contents for searching. */
861 gdb_byte
*search_buf
;
862 unsigned search_buf_size
;
864 CORE_ADDR found_addr
;
865 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
867 pattern
= malloc (packet_len
);
870 error ("Unable to allocate memory to perform the search");
871 strcpy (own_buf
, "E00");
874 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
875 packet_len
- cmd_name_len
,
876 &start_addr
, &search_space_len
,
877 pattern
, &pattern_len
) < 0)
880 error ("Error in parsing qSearch:memory packet");
881 strcpy (own_buf
, "E00");
885 search_buf_size
= chunk_size
+ pattern_len
- 1;
887 /* No point in trying to allocate a buffer larger than the search space. */
888 if (search_space_len
< search_buf_size
)
889 search_buf_size
= search_space_len
;
891 search_buf
= malloc (search_buf_size
);
892 if (search_buf
== NULL
)
895 error ("Unable to allocate memory to perform the search");
896 strcpy (own_buf
, "E00");
900 found
= handle_search_memory_1 (start_addr
, search_space_len
,
901 pattern
, pattern_len
,
902 search_buf
, chunk_size
, search_buf_size
,
906 sprintf (own_buf
, "1,%lx", (long) found_addr
);
908 strcpy (own_buf
, "0");
910 strcpy (own_buf
, "E00");
916 #define require_running(BUF) \
917 if (!target_running ()) \
923 /* Handle monitor commands not handled by target-specific handlers. */
926 handle_monitor_command (char *mon
, char *own_buf
)
928 if (strcmp (mon
, "set debug 1") == 0)
931 monitor_output ("Debug output enabled.\n");
933 else if (strcmp (mon
, "set debug 0") == 0)
936 monitor_output ("Debug output disabled.\n");
938 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
941 monitor_output ("H/W point debugging output enabled.\n");
943 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
946 monitor_output ("H/W point debugging output disabled.\n");
948 else if (strcmp (mon
, "set remote-debug 1") == 0)
951 monitor_output ("Protocol debug output enabled.\n");
953 else if (strcmp (mon
, "set remote-debug 0") == 0)
956 monitor_output ("Protocol debug output disabled.\n");
958 else if (strcmp (mon
, "help") == 0)
959 monitor_show_help ();
960 else if (strcmp (mon
, "exit") == 0)
964 monitor_output ("Unknown monitor command.\n\n");
965 monitor_show_help ();
970 /* Associates a callback with each supported qXfer'able object. */
974 /* The object this handler handles. */
977 /* Request that the target transfer up to LEN 8-bit bytes of the
978 target's OBJECT. The OFFSET, for a seekable object, specifies
979 the starting point. The ANNEX can be used to provide additional
980 data-specific information to the target.
982 Return the number of bytes actually transfered, zero when no
983 further transfer is possible, -1 on error, -2 when the transfer
984 is not supported, and -3 on a verbose error message that should
985 be preserved. Return of a positive value smaller than LEN does
986 not indicate the end of the object, only the end of the transfer.
988 One, and only one, of readbuf or writebuf must be non-NULL. */
989 int (*xfer
) (const char *annex
,
990 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
991 ULONGEST offset
, LONGEST len
);
994 /* Handle qXfer:auxv:read. */
997 handle_qxfer_auxv (const char *annex
,
998 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
999 ULONGEST offset
, LONGEST len
)
1001 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1004 if (annex
[0] != '\0' || !target_running ())
1007 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1010 /* Handle qXfer:features:read. */
1013 handle_qxfer_features (const char *annex
,
1014 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1015 ULONGEST offset
, LONGEST len
)
1017 const char *document
;
1020 if (writebuf
!= NULL
)
1023 if (!target_running ())
1026 /* Grab the correct annex. */
1027 document
= get_features_xml (annex
);
1028 if (document
== NULL
)
1031 total_len
= strlen (document
);
1033 if (offset
> total_len
)
1036 if (offset
+ len
> total_len
)
1037 len
= total_len
- offset
;
1039 memcpy (readbuf
, document
+ offset
, len
);
1043 /* Handle qXfer:libraries:read. */
1046 handle_qxfer_libraries (const char *annex
,
1047 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1048 ULONGEST offset
, LONGEST len
)
1050 unsigned int total_len
;
1052 struct inferior_list_entry
*dll_ptr
;
1054 if (writebuf
!= NULL
)
1057 if (annex
[0] != '\0' || !target_running ())
1060 /* Over-estimate the necessary memory. Assume that every character
1061 in the library name must be escaped. */
1063 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1064 total_len
+= 128 + 6 * strlen (((struct dll_info
*) dll_ptr
)->name
);
1066 document
= malloc (total_len
);
1067 if (document
== NULL
)
1070 strcpy (document
, "<library-list>\n");
1071 p
= document
+ strlen (document
);
1073 for (dll_ptr
= all_dlls
.head
; dll_ptr
!= NULL
; dll_ptr
= dll_ptr
->next
)
1075 struct dll_info
*dll
= (struct dll_info
*) dll_ptr
;
1078 strcpy (p
, " <library name=\"");
1080 name
= xml_escape_text (dll
->name
);
1084 strcpy (p
, "\"><segment address=\"");
1086 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1088 strcpy (p
, "\"/></library>\n");
1092 strcpy (p
, "</library-list>\n");
1094 total_len
= strlen (document
);
1096 if (offset
> total_len
)
1102 if (offset
+ len
> total_len
)
1103 len
= total_len
- offset
;
1105 memcpy (readbuf
, document
+ offset
, len
);
1110 /* Handle qXfer:libraries-svr4:read. */
1113 handle_qxfer_libraries_svr4 (const char *annex
,
1114 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1115 ULONGEST offset
, LONGEST len
)
1117 if (writebuf
!= NULL
)
1120 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1123 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1126 /* Handle qXfer:osadata:read. */
1129 handle_qxfer_osdata (const char *annex
,
1130 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1131 ULONGEST offset
, LONGEST len
)
1133 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1136 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1139 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1142 handle_qxfer_siginfo (const char *annex
,
1143 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1144 ULONGEST offset
, LONGEST len
)
1146 if (the_target
->qxfer_siginfo
== NULL
)
1149 if (annex
[0] != '\0' || !target_running ())
1152 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1155 /* Handle qXfer:spu:read and qXfer:spu:write. */
1158 handle_qxfer_spu (const char *annex
,
1159 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1160 ULONGEST offset
, LONGEST len
)
1162 if (the_target
->qxfer_spu
== NULL
)
1165 if (!target_running ())
1168 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1171 /* Handle qXfer:statictrace:read. */
1174 handle_qxfer_statictrace (const char *annex
,
1175 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1176 ULONGEST offset
, LONGEST len
)
1180 if (writebuf
!= NULL
)
1183 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1186 if (traceframe_read_sdata (current_traceframe
, offset
,
1187 readbuf
, len
, &nbytes
))
1192 /* Helper for handle_qxfer_threads. */
1195 handle_qxfer_threads_proper (struct buffer
*buffer
)
1197 struct inferior_list_entry
*thread
;
1199 buffer_grow_str (buffer
, "<threads>\n");
1201 for (thread
= all_threads
.head
; thread
; thread
= thread
->next
)
1203 ptid_t ptid
= thread_to_gdb_id ((struct thread_info
*)thread
);
1205 int core
= target_core_of_thread (ptid
);
1208 write_ptid (ptid_s
, ptid
);
1212 sprintf (core_s
, "%d", core
);
1213 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1218 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1223 buffer_grow_str0 (buffer
, "</threads>\n");
1226 /* Handle qXfer:threads:read. */
1229 handle_qxfer_threads (const char *annex
,
1230 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1231 ULONGEST offset
, LONGEST len
)
1233 static char *result
= 0;
1234 static unsigned int result_length
= 0;
1236 if (writebuf
!= NULL
)
1239 if (!target_running () || annex
[0] != '\0')
1244 struct buffer buffer
;
1245 /* When asked for data at offset 0, generate everything and store into
1246 'result'. Successive reads will be served off 'result'. */
1250 buffer_init (&buffer
);
1252 handle_qxfer_threads_proper (&buffer
);
1254 result
= buffer_finish (&buffer
);
1255 result_length
= strlen (result
);
1256 buffer_free (&buffer
);
1259 if (offset
>= result_length
)
1261 /* We're out of data. */
1268 if (len
> result_length
- offset
)
1269 len
= result_length
- offset
;
1271 memcpy (readbuf
, result
+ offset
, len
);
1276 /* Handle qXfer:traceframe-info:read. */
1279 handle_qxfer_traceframe_info (const char *annex
,
1280 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1281 ULONGEST offset
, LONGEST len
)
1283 static char *result
= 0;
1284 static unsigned int result_length
= 0;
1286 if (writebuf
!= NULL
)
1289 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1294 struct buffer buffer
;
1296 /* When asked for data at offset 0, generate everything and
1297 store into 'result'. Successive reads will be served off
1301 buffer_init (&buffer
);
1303 traceframe_read_info (current_traceframe
, &buffer
);
1305 result
= buffer_finish (&buffer
);
1306 result_length
= strlen (result
);
1307 buffer_free (&buffer
);
1310 if (offset
>= result_length
)
1312 /* We're out of data. */
1319 if (len
> result_length
- offset
)
1320 len
= result_length
- offset
;
1322 memcpy (readbuf
, result
+ offset
, len
);
1326 /* Handle qXfer:fdpic:read. */
1329 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1330 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1332 if (the_target
->read_loadmap
== NULL
)
1335 if (!target_running ())
1338 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1341 /* Handle qXfer:btrace:read. */
1344 handle_qxfer_btrace (const char *annex
,
1345 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1346 ULONGEST offset
, LONGEST len
)
1348 static struct buffer cache
;
1349 struct thread_info
*thread
;
1352 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1355 if (!target_running ())
1358 if (ptid_equal (general_thread
, null_ptid
)
1359 || ptid_equal (general_thread
, minus_one_ptid
))
1361 strcpy (own_buf
, "E.Must select a single thread.");
1365 thread
= find_thread_ptid (general_thread
);
1368 strcpy (own_buf
, "E.No such thread.");
1372 if (thread
->btrace
== NULL
)
1374 strcpy (own_buf
, "E.Btrace not enabled.");
1378 if (strcmp (annex
, "all") == 0)
1379 type
= btrace_read_all
;
1380 else if (strcmp (annex
, "new") == 0)
1381 type
= btrace_read_new
;
1384 strcpy (own_buf
, "E.Bad annex.");
1390 buffer_free (&cache
);
1392 target_read_btrace (thread
->btrace
, &cache
, type
);
1394 else if (offset
> cache
.used_size
)
1396 buffer_free (&cache
);
1400 if (len
> cache
.used_size
- offset
)
1401 len
= cache
.used_size
- offset
;
1403 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1408 static const struct qxfer qxfer_packets
[] =
1410 { "auxv", handle_qxfer_auxv
},
1411 { "btrace", handle_qxfer_btrace
},
1412 { "fdpic", handle_qxfer_fdpic
},
1413 { "features", handle_qxfer_features
},
1414 { "libraries", handle_qxfer_libraries
},
1415 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1416 { "osdata", handle_qxfer_osdata
},
1417 { "siginfo", handle_qxfer_siginfo
},
1418 { "spu", handle_qxfer_spu
},
1419 { "statictrace", handle_qxfer_statictrace
},
1420 { "threads", handle_qxfer_threads
},
1421 { "traceframe-info", handle_qxfer_traceframe_info
},
1425 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1433 if (strncmp (own_buf
, "qXfer:", 6) != 0)
1436 /* Grab the object, r/w and annex. */
1437 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1439 write_enn (own_buf
);
1444 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1447 const struct qxfer
*q
= &qxfer_packets
[i
];
1449 if (strcmp (object
, q
->object
) == 0)
1451 if (strcmp (rw
, "read") == 0)
1453 unsigned char *data
;
1458 /* Grab the offset and length. */
1459 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1461 write_enn (own_buf
);
1465 /* Read one extra byte, as an indicator of whether there is
1467 if (len
> PBUFSIZ
- 2)
1469 data
= malloc (len
+ 1);
1472 write_enn (own_buf
);
1475 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1483 /* Preserve error message. */
1486 write_enn (own_buf
);
1488 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1490 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1495 else if (strcmp (rw
, "write") == 0)
1500 unsigned char *data
;
1502 strcpy (own_buf
, "E00");
1503 data
= malloc (packet_len
- (offset
- own_buf
));
1506 write_enn (own_buf
);
1509 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1510 &ofs
, &len
, data
) < 0)
1513 write_enn (own_buf
);
1517 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1525 /* Preserve error message. */
1528 write_enn (own_buf
);
1530 sprintf (own_buf
, "%x", n
);
1543 /* Table used by the crc32 function to calcuate the checksum. */
1545 static unsigned int crc32_table
[256] =
1548 /* Compute 32 bit CRC from inferior memory.
1550 On success, return 32 bit CRC.
1551 On failure, return (unsigned long long) -1. */
1553 static unsigned long long
1554 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1556 if (!crc32_table
[1])
1558 /* Initialize the CRC table and the decoding table. */
1562 for (i
= 0; i
< 256; i
++)
1564 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1565 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1572 unsigned char byte
= 0;
1574 /* Return failure if memory read fails. */
1575 if (read_inferior_memory (base
, &byte
, 1) != 0)
1576 return (unsigned long long) -1;
1578 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1581 return (unsigned long long) crc
;
1584 /* Handle all of the extended 'q' packets. */
1587 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1589 static struct inferior_list_entry
*thread_ptr
;
1591 /* Reply the current thread id. */
1592 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1595 require_running (own_buf
);
1597 if (!ptid_equal (general_thread
, null_ptid
)
1598 && !ptid_equal (general_thread
, minus_one_ptid
))
1599 gdb_id
= general_thread
;
1602 thread_ptr
= all_threads
.head
;
1603 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1606 sprintf (own_buf
, "QC");
1608 write_ptid (own_buf
, gdb_id
);
1612 if (strcmp ("qSymbol::", own_buf
) == 0)
1614 /* GDB is suggesting new symbols have been loaded. This may
1615 mean a new shared library has been detected as loaded, so
1616 take the opportunity to check if breakpoints we think are
1617 inserted, still are. Note that it isn't guaranteed that
1618 we'll see this when a shared library is loaded, and nor will
1619 we see this for unloads (although breakpoints in unloaded
1620 libraries shouldn't trigger), as GDB may not find symbols for
1621 the library at all. We also re-validate breakpoints when we
1622 see a second GDB breakpoint for the same address, and or when
1623 we access breakpoint shadows. */
1624 validate_breakpoints ();
1626 if (target_supports_tracepoints ())
1627 tracepoint_look_up_symbols ();
1629 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1630 (*the_target
->look_up_symbols
) ();
1632 strcpy (own_buf
, "OK");
1636 if (!disable_packet_qfThreadInfo
)
1638 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1642 require_running (own_buf
);
1643 thread_ptr
= all_threads
.head
;
1646 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1647 write_ptid (own_buf
, gdb_id
);
1648 thread_ptr
= thread_ptr
->next
;
1652 if (strcmp ("qsThreadInfo", own_buf
) == 0)
1656 require_running (own_buf
);
1657 if (thread_ptr
!= NULL
)
1660 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1661 write_ptid (own_buf
, gdb_id
);
1662 thread_ptr
= thread_ptr
->next
;
1667 sprintf (own_buf
, "l");
1673 if (the_target
->read_offsets
!= NULL
1674 && strcmp ("qOffsets", own_buf
) == 0)
1676 CORE_ADDR text
, data
;
1678 require_running (own_buf
);
1679 if (the_target
->read_offsets (&text
, &data
))
1680 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
1681 (long)text
, (long)data
, (long)data
);
1683 write_enn (own_buf
);
1688 /* Protocol features query. */
1689 if (strncmp ("qSupported", own_buf
, 10) == 0
1690 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
1692 char *p
= &own_buf
[10];
1693 int gdb_supports_qRelocInsn
= 0;
1695 /* Start processing qSupported packet. */
1696 target_process_qsupported (NULL
);
1698 /* Process each feature being provided by GDB. The first
1699 feature will follow a ':', and latter features will follow
1703 char **qsupported
= NULL
;
1707 /* Two passes, to avoid nested strtok calls in
1708 target_process_qsupported. */
1709 for (p
= strtok (p
+ 1, ";");
1711 p
= strtok (NULL
, ";"))
1714 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
1715 qsupported
[count
- 1] = xstrdup (p
);
1718 for (i
= 0; i
< count
; i
++)
1721 if (strcmp (p
, "multiprocess+") == 0)
1723 /* GDB supports and wants multi-process support if
1725 if (target_supports_multi_process ())
1728 else if (strcmp (p
, "qRelocInsn+") == 0)
1730 /* GDB supports relocate instruction requests. */
1731 gdb_supports_qRelocInsn
= 1;
1734 target_process_qsupported (p
);
1743 "PacketSize=%x;QPassSignals+;QProgramSignals+",
1746 if (the_target
->qxfer_libraries_svr4
!= NULL
)
1747 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
1748 ";augmented-libraries-svr4-read+");
1751 /* We do not have any hook to indicate whether the non-SVR4 target
1752 backend supports qXfer:libraries:read, so always report it. */
1753 strcat (own_buf
, ";qXfer:libraries:read+");
1756 if (the_target
->read_auxv
!= NULL
)
1757 strcat (own_buf
, ";qXfer:auxv:read+");
1759 if (the_target
->qxfer_spu
!= NULL
)
1760 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
1762 if (the_target
->qxfer_siginfo
!= NULL
)
1763 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1765 if (the_target
->read_loadmap
!= NULL
)
1766 strcat (own_buf
, ";qXfer:fdpic:read+");
1768 /* We always report qXfer:features:read, as targets may
1769 install XML files on a subsequent call to arch_setup.
1770 If we reported to GDB on startup that we don't support
1771 qXfer:feature:read at all, we will never be re-queried. */
1772 strcat (own_buf
, ";qXfer:features:read+");
1774 if (transport_is_reliable
)
1775 strcat (own_buf
, ";QStartNoAckMode+");
1777 if (the_target
->qxfer_osdata
!= NULL
)
1778 strcat (own_buf
, ";qXfer:osdata:read+");
1780 if (target_supports_multi_process ())
1781 strcat (own_buf
, ";multiprocess+");
1783 if (target_supports_non_stop ())
1784 strcat (own_buf
, ";QNonStop+");
1786 if (target_supports_disable_randomization ())
1787 strcat (own_buf
, ";QDisableRandomization+");
1789 strcat (own_buf
, ";qXfer:threads:read+");
1791 if (target_supports_tracepoints ())
1793 strcat (own_buf
, ";ConditionalTracepoints+");
1794 strcat (own_buf
, ";TraceStateVariables+");
1795 strcat (own_buf
, ";TracepointSource+");
1796 strcat (own_buf
, ";DisconnectedTracing+");
1797 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
1798 strcat (own_buf
, ";FastTracepoints+");
1799 strcat (own_buf
, ";StaticTracepoints+");
1800 strcat (own_buf
, ";InstallInTrace+");
1801 strcat (own_buf
, ";qXfer:statictrace:read+");
1802 strcat (own_buf
, ";qXfer:traceframe-info:read+");
1803 strcat (own_buf
, ";EnableDisableTracepoints+");
1804 strcat (own_buf
, ";QTBuffer:size+");
1805 strcat (own_buf
, ";tracenz+");
1808 /* Support target-side breakpoint conditions and commands. */
1809 strcat (own_buf
, ";ConditionalBreakpoints+");
1810 strcat (own_buf
, ";BreakpointCommands+");
1812 if (target_supports_agent ())
1813 strcat (own_buf
, ";QAgent+");
1815 if (target_supports_btrace ())
1817 strcat (own_buf
, ";Qbtrace:bts+");
1818 strcat (own_buf
, ";Qbtrace:off+");
1819 strcat (own_buf
, ";qXfer:btrace:read+");
1825 /* Thread-local storage support. */
1826 if (the_target
->get_tls_address
!= NULL
1827 && strncmp ("qGetTLSAddr:", own_buf
, 12) == 0)
1829 char *p
= own_buf
+ 12;
1830 CORE_ADDR parts
[2], address
= 0;
1832 ptid_t ptid
= null_ptid
;
1834 require_running (own_buf
);
1836 for (i
= 0; i
< 3; i
++)
1844 p2
= strchr (p
, ',');
1857 ptid
= read_ptid (p
, NULL
);
1859 decode_address (&parts
[i
- 1], p
, len
);
1863 if (p
!= NULL
|| i
< 3)
1867 struct thread_info
*thread
= find_thread_ptid (ptid
);
1872 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
1878 strcpy (own_buf
, paddress(address
));
1883 write_enn (own_buf
);
1887 /* Otherwise, pretend we do not understand this packet. */
1890 /* Windows OS Thread Information Block address support. */
1891 if (the_target
->get_tib_address
!= NULL
1892 && strncmp ("qGetTIBAddr:", own_buf
, 12) == 0)
1897 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
1899 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
1902 strcpy (own_buf
, paddress(tlb
));
1907 write_enn (own_buf
);
1913 /* Handle "monitor" commands. */
1914 if (strncmp ("qRcmd,", own_buf
, 6) == 0)
1916 char *mon
= malloc (PBUFSIZ
);
1917 int len
= strlen (own_buf
+ 6);
1921 write_enn (own_buf
);
1925 if ((len
% 2) != 0 || unhexify (mon
, own_buf
+ 6, len
/ 2) != len
/ 2)
1927 write_enn (own_buf
);
1931 mon
[len
/ 2] = '\0';
1935 if (the_target
->handle_monitor_command
== NULL
1936 || (*the_target
->handle_monitor_command
) (mon
) == 0)
1937 /* Default processing. */
1938 handle_monitor_command (mon
, own_buf
);
1944 if (strncmp ("qSearch:memory:", own_buf
,
1945 sizeof ("qSearch:memory:") - 1) == 0)
1947 require_running (own_buf
);
1948 handle_search_memory (own_buf
, packet_len
);
1952 if (strcmp (own_buf
, "qAttached") == 0
1953 || strncmp (own_buf
, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1955 struct process_info
*process
;
1957 if (own_buf
[sizeof ("qAttached") - 1])
1959 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
1960 process
= (struct process_info
*)
1961 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
1965 require_running (own_buf
);
1966 process
= current_process ();
1969 if (process
== NULL
)
1971 write_enn (own_buf
);
1975 strcpy (own_buf
, process
->attached
? "1" : "0");
1979 if (strncmp ("qCRC:", own_buf
, 5) == 0)
1981 /* CRC check (compare-section). */
1985 unsigned long long crc
;
1987 require_running (own_buf
);
1988 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
1989 if (*comma
++ != ',')
1991 write_enn (own_buf
);
1994 len
= strtoul (comma
, NULL
, 16);
1995 crc
= crc32 (base
, len
, 0xffffffff);
1996 /* Check for memory failure. */
1997 if (crc
== (unsigned long long) -1)
1999 write_enn (own_buf
);
2002 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2006 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2009 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2012 /* Otherwise we didn't know what packet it was. Say we didn't
2017 static void gdb_wants_all_threads_stopped (void);
2019 /* Parse vCont packets. */
2021 handle_v_cont (char *own_buf
)
2025 struct thread_resume
*resume_info
;
2026 struct thread_resume default_action
= {{0}};
2028 /* Count the number of semicolons in the packet. There should be one
2029 for every action. */
2035 p
= strchr (p
, ';');
2038 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2039 if (resume_info
== NULL
)
2047 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2049 if (p
[0] == 's' || p
[0] == 'S')
2050 resume_info
[i
].kind
= resume_step
;
2051 else if (p
[0] == 'r')
2052 resume_info
[i
].kind
= resume_step
;
2053 else if (p
[0] == 'c' || p
[0] == 'C')
2054 resume_info
[i
].kind
= resume_continue
;
2055 else if (p
[0] == 't')
2056 resume_info
[i
].kind
= resume_stop
;
2060 if (p
[0] == 'S' || p
[0] == 'C')
2063 sig
= strtol (p
+ 1, &q
, 16);
2068 if (!gdb_signal_to_host_p (sig
))
2070 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2072 else if (p
[0] == 'r')
2076 p
= unpack_varlen_hex (p
+ 1, &addr
);
2077 resume_info
[i
].step_range_start
= addr
;
2082 p
= unpack_varlen_hex (p
+ 1, &addr
);
2083 resume_info
[i
].step_range_end
= addr
;
2092 resume_info
[i
].thread
= minus_one_ptid
;
2093 default_action
= resume_info
[i
];
2095 /* Note: we don't increment i here, we'll overwrite this entry
2096 the next time through. */
2098 else if (p
[0] == ':')
2100 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2105 if (p
[0] != ';' && p
[0] != 0)
2108 resume_info
[i
].thread
= ptid
;
2115 resume_info
[i
] = default_action
;
2117 /* `cont_thread' is still used in occasional places in the backend,
2118 to implement single-thread scheduler-locking. Doesn't make sense
2119 to set it if we see a stop request, or a wildcard action (one
2120 with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
2122 && !(ptid_equal (resume_info
[0].thread
, minus_one_ptid
)
2123 || ptid_get_lwp (resume_info
[0].thread
) == -1)
2124 && resume_info
[0].kind
!= resume_stop
)
2125 cont_thread
= resume_info
[0].thread
;
2127 cont_thread
= minus_one_ptid
;
2128 set_desired_inferior (0);
2133 (*the_target
->resume
) (resume_info
, n
);
2141 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2143 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2144 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2145 current_inferior
->last_status
= last_status
;
2147 /* From the client's perspective, all-stop mode always stops all
2148 threads implicitly (and the target backend has already done
2149 so by now). Tag all threads as "want-stopped", so we don't
2150 resume them implicitly without the client telling us to. */
2151 gdb_wants_all_threads_stopped ();
2152 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2153 disable_async_io ();
2155 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2156 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2157 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2162 write_enn (own_buf
);
2167 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2169 handle_v_attach (char *own_buf
)
2173 pid
= strtol (own_buf
+ 8, NULL
, 16);
2174 if (pid
!= 0 && attach_inferior (pid
) == 0)
2176 /* Don't report shared library events after attaching, even if
2177 some libraries are preloaded. GDB will always poll the
2178 library list. Avoids the "stopped by shared library event"
2179 notice on the GDB side. */
2184 /* In non-stop, we don't send a resume reply. Stop events
2185 will follow up using the normal notification
2190 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2196 write_enn (own_buf
);
2201 /* Run a new program. Return 1 if successful, 0 if failure. */
2203 handle_v_run (char *own_buf
)
2205 char *p
, *next_p
, **new_argv
;
2209 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2215 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2216 if (new_argv
== NULL
)
2218 write_enn (own_buf
);
2223 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2225 next_p
= strchr (p
, ';');
2227 next_p
= p
+ strlen (p
);
2229 if (i
== 0 && p
== next_p
)
2233 /* FIXME: Fail request if out of memory instead of dying. */
2234 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2235 unhexify (new_argv
[i
], p
, (next_p
- p
) / 2);
2236 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2245 if (new_argv
[0] == NULL
)
2247 /* GDB didn't specify a program to run. Use the program from the
2248 last run with the new argument list. */
2250 if (program_argv
== NULL
)
2252 write_enn (own_buf
);
2253 freeargv (new_argv
);
2257 new_argv
[0] = strdup (program_argv
[0]);
2258 if (new_argv
[0] == NULL
)
2260 write_enn (own_buf
);
2261 freeargv (new_argv
);
2266 /* Free the old argv and install the new one. */
2267 freeargv (program_argv
);
2268 program_argv
= new_argv
;
2270 start_inferior (program_argv
);
2271 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2273 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2275 /* In non-stop, sending a resume reply doesn't set the general
2276 thread, but GDB assumes a vRun sets it (this is so GDB can
2277 query which is the main thread of the new inferior. */
2279 general_thread
= last_ptid
;
2285 write_enn (own_buf
);
2290 /* Kill process. Return 1 if successful, 0 if failure. */
2292 handle_v_kill (char *own_buf
)
2295 char *p
= &own_buf
[6];
2297 pid
= strtol (p
, NULL
, 16);
2300 if (pid
!= 0 && kill_inferior (pid
) == 0)
2302 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2303 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2304 last_ptid
= pid_to_ptid (pid
);
2305 discard_queued_stop_replies (pid
);
2311 write_enn (own_buf
);
2316 /* Handle all of the extended 'v' packets. */
2318 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2320 if (!disable_packet_vCont
)
2322 if (strncmp (own_buf
, "vCont;", 6) == 0)
2324 require_running (own_buf
);
2325 handle_v_cont (own_buf
);
2329 if (strncmp (own_buf
, "vCont?", 6) == 0)
2331 strcpy (own_buf
, "vCont;c;C;s;S;t");
2332 if (target_supports_range_stepping ())
2334 own_buf
= own_buf
+ strlen (own_buf
);
2335 strcpy (own_buf
, ";r");
2341 if (strncmp (own_buf
, "vFile:", 6) == 0
2342 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2345 if (strncmp (own_buf
, "vAttach;", 8) == 0)
2347 if ((!extended_protocol
|| !multi_process
) && target_running ())
2349 fprintf (stderr
, "Already debugging a process\n");
2350 write_enn (own_buf
);
2353 handle_v_attach (own_buf
);
2357 if (strncmp (own_buf
, "vRun;", 5) == 0)
2359 if ((!extended_protocol
|| !multi_process
) && target_running ())
2361 fprintf (stderr
, "Already debugging a process\n");
2362 write_enn (own_buf
);
2365 handle_v_run (own_buf
);
2369 if (strncmp (own_buf
, "vKill;", 6) == 0)
2371 if (!target_running ())
2373 fprintf (stderr
, "No process to kill\n");
2374 write_enn (own_buf
);
2377 handle_v_kill (own_buf
);
2381 if (handle_notif_ack (own_buf
, packet_len
))
2384 /* Otherwise we didn't know what packet it was. Say we didn't
2390 /* Resume inferior and wait for another event. In non-stop mode,
2391 don't really wait here, but return immediatelly to the event
2394 myresume (char *own_buf
, int step
, int sig
)
2396 struct thread_resume resume_info
[2];
2398 int valid_cont_thread
;
2400 set_desired_inferior (0);
2402 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2403 && !ptid_equal (cont_thread
, minus_one_ptid
));
2405 if (step
|| sig
|| valid_cont_thread
)
2407 resume_info
[0].thread
= current_ptid
;
2409 resume_info
[0].kind
= resume_step
;
2411 resume_info
[0].kind
= resume_continue
;
2412 resume_info
[0].sig
= sig
;
2416 if (!valid_cont_thread
)
2418 resume_info
[n
].thread
= minus_one_ptid
;
2419 resume_info
[n
].kind
= resume_continue
;
2420 resume_info
[n
].sig
= 0;
2427 (*the_target
->resume
) (resume_info
, n
);
2433 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2435 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2436 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
2438 current_inferior
->last_resume_kind
= resume_stop
;
2439 current_inferior
->last_status
= last_status
;
2442 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2443 disable_async_io ();
2445 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2446 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2447 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2451 /* Callback for for_each_inferior. Make a new stop reply for each
2455 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2457 struct thread_info
*thread
= (struct thread_info
*) entry
;
2459 /* For now, assume targets that don't have this callback also don't
2460 manage the thread's last_status field. */
2461 if (the_target
->thread_stopped
== NULL
)
2463 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2465 new_notif
->ptid
= entry
->id
;
2466 new_notif
->status
= thread
->last_status
;
2467 /* Pass the last stop reply back to GDB, but don't notify
2469 notif_event_enque (¬if_stop
,
2470 (struct notif_event
*) new_notif
);
2474 if (thread_stopped (thread
))
2479 = target_waitstatus_to_string (&thread
->last_status
);
2482 "Reporting thread %s as already stopped with %s\n",
2483 target_pid_to_str (entry
->id
),
2486 xfree (status_string
);
2489 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2491 /* Pass the last stop reply back to GDB, but don't notify
2493 queue_stop_reply (entry
->id
, &thread
->last_status
);
2500 /* Set this inferior threads's state as "want-stopped". We won't
2501 resume this thread until the client gives us another action for
2505 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2507 struct thread_info
*thread
= (struct thread_info
*) entry
;
2509 thread
->last_resume_kind
= resume_stop
;
2511 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2513 /* Most threads are stopped implicitly (all-stop); tag that with
2515 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2516 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2520 /* Set all threads' states as "want-stopped". */
2523 gdb_wants_all_threads_stopped (void)
2525 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2528 /* Clear the gdb_detached flag of every process. */
2531 gdb_reattached_process (struct inferior_list_entry
*entry
)
2533 struct process_info
*process
= (struct process_info
*) entry
;
2535 process
->gdb_detached
= 0;
2538 /* Status handler for the '?' packet. */
2541 handle_status (char *own_buf
)
2543 /* GDB is connected, don't forward events to the target anymore. */
2544 for_each_inferior (&all_processes
, gdb_reattached_process
);
2546 /* In non-stop mode, we must send a stop reply for each stopped
2547 thread. In all-stop mode, just send one for the first stopped
2552 discard_queued_stop_replies (-1);
2553 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
2555 /* The first is sent immediatly. OK is sent if there is no
2556 stopped thread, which is the same handling of the vStopped
2557 packet (by design). */
2558 notif_write_event (¬if_stop
, own_buf
);
2563 stabilize_threads ();
2564 gdb_wants_all_threads_stopped ();
2566 if (all_threads
.head
)
2568 struct target_waitstatus status
;
2570 status
.kind
= TARGET_WAITKIND_STOPPED
;
2571 status
.value
.sig
= GDB_SIGNAL_TRAP
;
2572 prepare_resume_reply (own_buf
,
2573 all_threads
.head
->id
, &status
);
2576 strcpy (own_buf
, "W00");
2581 gdbserver_version (void)
2583 printf ("GNU gdbserver %s%s\n"
2584 "Copyright (C) 2013 Free Software Foundation, Inc.\n"
2585 "gdbserver is free software, covered by the "
2586 "GNU General Public License.\n"
2587 "This gdbserver was configured as \"%s\"\n",
2588 PKGVERSION
, version
, host_name
);
2592 gdbserver_usage (FILE *stream
)
2594 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2595 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2596 "\tgdbserver [OPTIONS] --multi COMM\n"
2598 "COMM may either be a tty device (for serial debugging), or \n"
2599 "HOST:PORT to listen for a TCP connection.\n"
2602 " --debug Enable general debugging output.\n"
2603 " --remote-debug Enable remote protocol debugging output.\n"
2604 " --version Display version information and exit.\n"
2605 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2606 " --once Exit after the first connection has "
2608 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2609 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
2613 gdbserver_show_disableable (FILE *stream
)
2615 fprintf (stream
, "Disableable packets:\n"
2616 " vCont \tAll vCont packets\n"
2617 " qC \tQuerying the current thread\n"
2618 " qfThreadInfo\tThread listing\n"
2619 " Tthread \tPassing the thread specifier in the "
2620 "T stop reply packet\n"
2621 " threads \tAll of the above\n");
2625 #undef require_running
2626 #define require_running(BUF) \
2627 if (!target_running ()) \
2634 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
2636 int pid
= * (int *) args
;
2638 if (ptid_get_pid (entry
->id
) == pid
)
2645 kill_inferior_callback (struct inferior_list_entry
*entry
)
2647 struct process_info
*process
= (struct process_info
*) entry
;
2648 int pid
= ptid_get_pid (process
->head
.id
);
2650 kill_inferior (pid
);
2651 discard_queued_stop_replies (pid
);
2654 /* Callback for for_each_inferior to detach or kill the inferior,
2655 depending on whether we attached to it or not.
2656 We inform the user whether we're detaching or killing the process
2657 as this is only called when gdbserver is about to exit. */
2660 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
2662 struct process_info
*process
= (struct process_info
*) entry
;
2663 int pid
= ptid_get_pid (process
->head
.id
);
2665 if (process
->attached
)
2666 detach_inferior (pid
);
2668 kill_inferior (pid
);
2670 discard_queued_stop_replies (pid
);
2673 /* for_each_inferior callback for detach_or_kill_for_exit to print
2674 the pids of started inferiors. */
2677 print_started_pid (struct inferior_list_entry
*entry
)
2679 struct process_info
*process
= (struct process_info
*) entry
;
2681 if (! process
->attached
)
2683 int pid
= ptid_get_pid (process
->head
.id
);
2684 fprintf (stderr
, " %d", pid
);
2688 /* for_each_inferior callback for detach_or_kill_for_exit to print
2689 the pids of attached inferiors. */
2692 print_attached_pid (struct inferior_list_entry
*entry
)
2694 struct process_info
*process
= (struct process_info
*) entry
;
2696 if (process
->attached
)
2698 int pid
= ptid_get_pid (process
->head
.id
);
2699 fprintf (stderr
, " %d", pid
);
2703 /* Call this when exiting gdbserver with possible inferiors that need
2704 to be killed or detached from. */
2707 detach_or_kill_for_exit (void)
2709 /* First print a list of the inferiors we will be killing/detaching.
2710 This is to assist the user, for example, in case the inferior unexpectedly
2711 dies after we exit: did we screw up or did the inferior exit on its own?
2712 Having this info will save some head-scratching. */
2714 if (have_started_inferiors_p ())
2716 fprintf (stderr
, "Killing process(es):");
2717 for_each_inferior (&all_processes
, print_started_pid
);
2718 fprintf (stderr
, "\n");
2720 if (have_attached_inferiors_p ())
2722 fprintf (stderr
, "Detaching process(es):");
2723 for_each_inferior (&all_processes
, print_attached_pid
);
2724 fprintf (stderr
, "\n");
2727 /* Now we can kill or detach the inferiors. */
2729 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
2733 main (int argc
, char *argv
[])
2737 char *arg_end
, *port
;
2738 char **next_arg
= &argv
[1];
2739 volatile int multi_mode
= 0;
2740 volatile int attach
= 0;
2743 while (*next_arg
!= NULL
&& **next_arg
== '-')
2745 if (strcmp (*next_arg
, "--version") == 0)
2747 gdbserver_version ();
2750 else if (strcmp (*next_arg
, "--help") == 0)
2752 gdbserver_usage (stdout
);
2755 else if (strcmp (*next_arg
, "--attach") == 0)
2757 else if (strcmp (*next_arg
, "--multi") == 0)
2759 else if (strcmp (*next_arg
, "--wrapper") == 0)
2763 wrapper_argv
= next_arg
;
2764 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
2767 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
2769 gdbserver_usage (stderr
);
2773 /* Consume the "--". */
2776 else if (strcmp (*next_arg
, "--debug") == 0)
2778 else if (strcmp (*next_arg
, "--remote-debug") == 0)
2780 else if (strcmp (*next_arg
, "--disable-packet") == 0)
2782 gdbserver_show_disableable (stdout
);
2785 else if (strncmp (*next_arg
,
2786 "--disable-packet=",
2787 sizeof ("--disable-packet=") - 1) == 0)
2789 char *packets
, *tok
;
2791 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
2792 for (tok
= strtok (packets
, ",");
2794 tok
= strtok (NULL
, ","))
2796 if (strcmp ("vCont", tok
) == 0)
2797 disable_packet_vCont
= 1;
2798 else if (strcmp ("Tthread", tok
) == 0)
2799 disable_packet_Tthread
= 1;
2800 else if (strcmp ("qC", tok
) == 0)
2801 disable_packet_qC
= 1;
2802 else if (strcmp ("qfThreadInfo", tok
) == 0)
2803 disable_packet_qfThreadInfo
= 1;
2804 else if (strcmp ("threads", tok
) == 0)
2806 disable_packet_vCont
= 1;
2807 disable_packet_Tthread
= 1;
2808 disable_packet_qC
= 1;
2809 disable_packet_qfThreadInfo
= 1;
2813 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
2815 gdbserver_show_disableable (stderr
);
2820 else if (strcmp (*next_arg
, "-") == 0)
2822 /* "-" specifies a stdio connection and is a form of port
2824 *next_arg
= STDIO_CONNECTION_NAME
;
2827 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
2828 disable_randomization
= 1;
2829 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
2830 disable_randomization
= 0;
2831 else if (strcmp (*next_arg
, "--once") == 0)
2835 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
2843 if (setjmp (toplevel
))
2845 fprintf (stderr
, "Exiting\n");
2851 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
2853 gdbserver_usage (stderr
);
2857 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
2858 opened by remote_prepare. */
2861 /* We need to know whether the remote connection is stdio before
2862 starting the inferior. Inferiors created in this scenario have
2863 stdin,stdout redirected. So do this here before we call
2865 remote_prepare (port
);
2870 /* --attach used to come after PORT, so allow it there for
2872 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
2879 && (*next_arg
== NULL
2880 || (*next_arg
)[0] == '\0'
2881 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
2883 || next_arg
[1] != NULL
))
2888 gdbserver_usage (stderr
);
2892 initialize_async_io ();
2894 initialize_event_loop ();
2895 if (target_supports_tracepoints ())
2896 initialize_tracepoint ();
2898 own_buf
= xmalloc (PBUFSIZ
+ 1);
2899 mem_buf
= xmalloc (PBUFSIZ
);
2901 if (pid
== 0 && *next_arg
!= NULL
)
2905 n
= argc
- (next_arg
- argv
);
2906 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
2907 for (i
= 0; i
< n
; i
++)
2908 program_argv
[i
] = xstrdup (next_arg
[i
]);
2909 program_argv
[i
] = NULL
;
2911 /* Wait till we are at first instruction in program. */
2912 start_inferior (program_argv
);
2914 /* We are now (hopefully) stopped at the first instruction of
2915 the target process. This assumes that the target process was
2916 successfully created. */
2920 if (attach_inferior (pid
) == -1)
2921 error ("Attaching not supported on this target");
2923 /* Otherwise succeeded. */
2927 last_status
.kind
= TARGET_WAITKIND_EXITED
;
2928 last_status
.value
.integer
= 0;
2929 last_ptid
= minus_one_ptid
;
2932 initialize_notif ();
2934 /* Don't report shared library events on the initial connection,
2935 even if some libraries are preloaded. Avoids the "stopped by
2936 shared library event" notice on gdb side. */
2939 if (setjmp (toplevel
))
2941 /* If something fails and longjmps while detaching or killing
2942 inferiors, we'd end up here again, stuck in an infinite loop
2943 trap. Be sure that if that happens, we exit immediately
2945 if (setjmp (toplevel
) == 0)
2946 detach_or_kill_for_exit ();
2948 fprintf (stderr
, "Detach or kill failed. Exiting\n");
2952 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2953 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2958 if (!was_running
&& !multi_mode
)
2960 fprintf (stderr
, "No program to debug. GDBserver exiting.\n");
2968 /* Be sure we're out of tfind mode. */
2969 current_traceframe
= -1;
2973 if (setjmp (toplevel
) != 0)
2975 /* An error occurred. */
2976 if (response_needed
)
2978 write_enn (own_buf
);
2983 /* Wait for events. This will return when all event sources are
2984 removed from the event loop. */
2985 start_event_loop ();
2987 /* If an exit was requested (using the "monitor exit" command),
2988 terminate now. The only other way to get here is for
2989 getpkt to fail; close the connection and reopen it at the
2992 if (exit_requested
|| run_once
)
2994 /* If something fails and longjmps while detaching or
2995 killing inferiors, we'd end up here again, stuck in an
2996 infinite loop trap. Be sure that if that happens, we
2997 exit immediately instead. */
2998 if (setjmp (toplevel
) == 0)
3000 detach_or_kill_for_exit ();
3005 fprintf (stderr
, "Detach or kill failed. Exiting\n");
3011 "Remote side has terminated connection. "
3012 "GDBserver will reopen the connection.\n");
3016 if (disconnected_tracing
)
3018 /* Try to enable non-stop/async mode, so we we can both
3019 wait for an async socket accept, and handle async
3020 target events simultaneously. There's also no point
3021 either in having the target always stop all threads,
3022 when we're going to pass signals down without
3026 if (start_non_stop (1))
3029 /* Detaching implicitly resumes all threads; simply
3030 disconnecting does not. */
3036 "Disconnected tracing disabled; stopping trace run.\n");
3043 /* Process options coming from Z packets for *point at address
3044 POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
3045 to point to the first char after the last processed option. */
3048 process_point_options (CORE_ADDR point_addr
, char **packet
)
3050 char *dataptr
= *packet
;
3053 /* Check if data has the correct format. */
3054 if (*dataptr
!= ';')
3061 if (*dataptr
== ';')
3064 if (*dataptr
== 'X')
3066 /* Conditional expression. */
3068 fprintf (stderr
, "Found breakpoint condition.\n");
3069 add_breakpoint_condition (point_addr
, &dataptr
);
3071 else if (strncmp (dataptr
, "cmds:", strlen ("cmds:")) == 0)
3073 dataptr
+= strlen ("cmds:");
3075 fprintf (stderr
, "Found breakpoint commands %s.\n", dataptr
);
3076 persist
= (*dataptr
== '1');
3078 add_breakpoint_commands (point_addr
, &dataptr
, persist
);
3082 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3084 /* Skip tokens until we find one that we recognize. */
3085 while (*dataptr
&& *dataptr
!= ';')
3092 /* Event loop callback that handles a serial event. The first byte in
3093 the serial buffer gets us here. We expect characters to arrive at
3094 a brisk pace, so we read the rest of the packet with a blocking
3098 process_serial_event (void)
3109 int new_packet_len
= -1;
3111 /* Used to decide when gdbserver should exit in
3112 multi-mode/remote. */
3113 static int have_ran
= 0;
3116 have_ran
= target_running ();
3118 disable_async_io ();
3120 response_needed
= 0;
3121 packet_len
= getpkt (own_buf
);
3122 if (packet_len
<= 0)
3125 /* Force an event loop break. */
3128 response_needed
= 1;
3135 handle_query (own_buf
, packet_len
, &new_packet_len
);
3138 handle_general_set (own_buf
);
3141 require_running (own_buf
);
3146 pid
= strtol (&own_buf
[i
], NULL
, 16);
3149 pid
= ptid_get_pid (current_ptid
);
3151 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3153 struct thread_resume resume_info
;
3154 struct process_info
*process
= find_process_pid (pid
);
3156 if (process
== NULL
)
3158 write_enn (own_buf
);
3162 if (tracing
&& disconnected_tracing
)
3164 "Disconnected tracing in effect, "
3165 "leaving gdbserver attached to the process\n");
3167 if (any_persistent_commands ())
3169 "Persistent commands are present, "
3170 "leaving gdbserver attached to the process\n");
3172 /* Make sure we're in non-stop/async mode, so we we can both
3173 wait for an async socket accept, and handle async target
3174 events simultaneously. There's also no point either in
3175 having the target stop all threads, when we're going to
3176 pass signals down without informing GDB. */
3180 fprintf (stderr
, "Forcing non-stop mode\n");
3186 process
->gdb_detached
= 1;
3188 /* Detaching implicitly resumes all threads. */
3189 resume_info
.thread
= minus_one_ptid
;
3190 resume_info
.kind
= resume_continue
;
3191 resume_info
.sig
= 0;
3192 (*the_target
->resume
) (&resume_info
, 1);
3195 break; /* from switch/case */
3198 fprintf (stderr
, "Detaching from process %d\n", pid
);
3200 if (detach_inferior (pid
) != 0)
3201 write_enn (own_buf
);
3204 discard_queued_stop_replies (pid
);
3207 if (extended_protocol
)
3209 /* Treat this like a normal program exit. */
3210 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3211 last_status
.value
.integer
= 0;
3212 last_ptid
= pid_to_ptid (pid
);
3214 current_inferior
= NULL
;
3221 /* If we are attached, then we can exit. Otherwise, we
3222 need to hang around doing nothing, until the child is
3224 join_inferior (pid
);
3230 extended_protocol
= 1;
3234 handle_status (own_buf
);
3237 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3239 ptid_t gdb_id
, thread_id
;
3242 require_running (own_buf
);
3244 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3246 pid
= ptid_get_pid (gdb_id
);
3248 if (ptid_equal (gdb_id
, null_ptid
)
3249 || ptid_equal (gdb_id
, minus_one_ptid
))
3250 thread_id
= null_ptid
;
3252 && ptid_equal (pid_to_ptid (pid
),
3255 struct thread_info
*thread
=
3256 (struct thread_info
*) find_inferior (&all_threads
,
3261 write_enn (own_buf
);
3265 thread_id
= ((struct inferior_list_entry
*)thread
)->id
;
3269 thread_id
= gdb_id_to_thread_id (gdb_id
);
3270 if (ptid_equal (thread_id
, null_ptid
))
3272 write_enn (own_buf
);
3277 if (own_buf
[1] == 'g')
3279 if (ptid_equal (thread_id
, null_ptid
))
3281 /* GDB is telling us to choose any thread. Check if
3282 the currently selected thread is still valid. If
3283 it is not, select the first available. */
3284 struct thread_info
*thread
=
3285 (struct thread_info
*) find_inferior_id (&all_threads
,
3288 thread_id
= all_threads
.head
->id
;
3291 general_thread
= thread_id
;
3292 set_desired_inferior (1);
3294 else if (own_buf
[1] == 'c')
3295 cont_thread
= thread_id
;
3301 /* Silently ignore it so that gdb can extend the protocol
3302 without compatibility headaches. */
3307 require_running (own_buf
);
3308 if (current_traceframe
>= 0)
3310 struct regcache
*regcache
3311 = new_register_cache (current_target_desc ());
3313 if (fetch_traceframe_registers (current_traceframe
,
3315 registers_to_string (regcache
, own_buf
);
3317 write_enn (own_buf
);
3318 free_register_cache (regcache
);
3322 struct regcache
*regcache
;
3324 set_desired_inferior (1);
3325 regcache
= get_thread_regcache (current_inferior
, 1);
3326 registers_to_string (regcache
, own_buf
);
3330 require_running (own_buf
);
3331 if (current_traceframe
>= 0)
3332 write_enn (own_buf
);
3335 struct regcache
*regcache
;
3337 set_desired_inferior (1);
3338 regcache
= get_thread_regcache (current_inferior
, 1);
3339 registers_from_string (regcache
, &own_buf
[1]);
3344 require_running (own_buf
);
3345 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3346 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3348 write_enn (own_buf
);
3350 convert_int_to_ascii (mem_buf
, own_buf
, res
);
3353 require_running (own_buf
);
3354 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3355 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3358 write_enn (own_buf
);
3361 require_running (own_buf
);
3362 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3363 &mem_addr
, &len
, &mem_buf
) < 0
3364 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3365 write_enn (own_buf
);
3370 require_running (own_buf
);
3371 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3372 if (gdb_signal_to_host_p (sig
))
3373 signal
= gdb_signal_to_host (sig
);
3376 myresume (own_buf
, 0, signal
);
3379 require_running (own_buf
);
3380 convert_ascii_to_int (own_buf
+ 1, &sig
, 1);
3381 if (gdb_signal_to_host_p (sig
))
3382 signal
= gdb_signal_to_host (sig
);
3385 myresume (own_buf
, 1, signal
);
3388 require_running (own_buf
);
3390 myresume (own_buf
, 0, signal
);
3393 require_running (own_buf
);
3395 myresume (own_buf
, 1, signal
);
3397 case 'Z': /* insert_ ... */
3399 case 'z': /* remove_ ... */
3404 char type
= own_buf
[1];
3406 const int insert
= ch
== 'Z';
3407 char *p
= &own_buf
[3];
3409 p
= unpack_varlen_hex (p
, &addr
);
3410 len
= strtol (p
+ 1, &dataptr
, 16);
3412 /* Default to unrecognized/unsupported. */
3416 case '0': /* software-breakpoint */
3417 case '1': /* hardware-breakpoint */
3418 case '2': /* write watchpoint */
3419 case '3': /* read watchpoint */
3420 case '4': /* access watchpoint */
3421 require_running (own_buf
);
3422 if (insert
&& the_target
->insert_point
!= NULL
)
3424 /* Insert the breakpoint. If it is already inserted, nothing
3426 res
= (*the_target
->insert_point
) (type
, addr
, len
);
3428 /* GDB may have sent us a list of *point parameters to be
3429 evaluated on the target's side. Read such list here. If we
3430 already have a list of parameters, GDB is telling us to drop
3431 that list and use this one instead. */
3432 if (!res
&& (type
== '0' || type
== '1'))
3434 /* Remove previous conditions. */
3435 clear_gdb_breakpoint_conditions (addr
);
3436 process_point_options (addr
, &dataptr
);
3439 else if (!insert
&& the_target
->remove_point
!= NULL
)
3440 res
= (*the_target
->remove_point
) (type
, addr
, len
);
3452 write_enn (own_buf
);
3456 response_needed
= 0;
3457 if (!target_running ())
3458 /* The packet we received doesn't make sense - but we can't
3459 reply to it, either. */
3462 fprintf (stderr
, "Killing all inferiors\n");
3463 for_each_inferior (&all_processes
, kill_inferior_callback
);
3465 /* When using the extended protocol, we wait with no program
3466 running. The traditional protocol will exit instead. */
3467 if (extended_protocol
)
3469 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3470 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3478 ptid_t gdb_id
, thread_id
;
3480 require_running (own_buf
);
3482 gdb_id
= read_ptid (&own_buf
[1], NULL
);
3483 thread_id
= gdb_id_to_thread_id (gdb_id
);
3484 if (ptid_equal (thread_id
, null_ptid
))
3486 write_enn (own_buf
);
3490 if (mythread_alive (thread_id
))
3493 write_enn (own_buf
);
3497 response_needed
= 0;
3499 /* Restarting the inferior is only supported in the extended
3501 if (extended_protocol
)
3503 if (target_running ())
3504 for_each_inferior (&all_processes
,
3505 kill_inferior_callback
);
3506 fprintf (stderr
, "GDBserver restarting\n");
3508 /* Wait till we are at 1st instruction in prog. */
3509 if (program_argv
!= NULL
)
3510 start_inferior (program_argv
);
3513 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3514 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3520 /* It is a request we don't understand. Respond with an
3521 empty packet so that gdb knows that we don't support this
3527 /* Extended (long) request. */
3528 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
3532 /* It is a request we don't understand. Respond with an empty
3533 packet so that gdb knows that we don't support this
3539 if (new_packet_len
!= -1)
3540 putpkt_binary (own_buf
, new_packet_len
);
3544 response_needed
= 0;
3546 if (!extended_protocol
&& have_ran
&& !target_running ())
3548 /* In non-stop, defer exiting until GDB had a chance to query
3549 the whole vStopped list (until it gets an OK). */
3550 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
3552 fprintf (stderr
, "GDBserver exiting\n");
3564 /* Event-loop callback for serial events. */
3567 handle_serial_event (int err
, gdb_client_data client_data
)
3570 fprintf (stderr
, "handling possible serial event\n");
3572 /* Really handle it. */
3573 if (process_serial_event () < 0)
3576 /* Be sure to not change the selected inferior behind GDB's back.
3577 Important in the non-stop mode asynchronous protocol. */
3578 set_desired_inferior (1);
3583 /* Event-loop callback for target events. */
3586 handle_target_event (int err
, gdb_client_data client_data
)
3589 fprintf (stderr
, "handling possible target event\n");
3591 last_ptid
= mywait (minus_one_ptid
, &last_status
,
3594 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3596 int pid
= ptid_get_pid (last_ptid
);
3597 struct process_info
*process
= find_process_pid (pid
);
3598 int forward_event
= !gdb_connected () || process
->gdb_detached
;
3600 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3601 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3603 mark_breakpoints_out (process
);
3604 mourn_inferior (process
);
3608 /* We're reporting this thread as stopped. Update its
3609 "want-stopped" state to what the client wants, until it
3610 gets a new resume action. */
3611 current_inferior
->last_resume_kind
= resume_stop
;
3612 current_inferior
->last_status
= last_status
;
3617 if (!target_running ())
3619 /* The last process exited. We're done. */
3623 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3625 /* A thread stopped with a signal, but gdb isn't
3626 connected to handle it. Pass it down to the
3627 inferior, as if it wasn't being traced. */
3628 struct thread_resume resume_info
;
3632 "GDB not connected; forwarding event %d for [%s]\n",
3633 (int) last_status
.kind
,
3634 target_pid_to_str (last_ptid
));
3636 resume_info
.thread
= last_ptid
;
3637 resume_info
.kind
= resume_continue
;
3638 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
3639 (*the_target
->resume
) (&resume_info
, 1);
3641 else if (debug_threads
)
3642 fprintf (stderr
, "GDB not connected; ignoring event %d for [%s]\n",
3643 (int) last_status
.kind
,
3644 target_pid_to_str (last_ptid
));
3648 struct vstop_notif
*vstop_notif
3649 = xmalloc (sizeof (struct vstop_notif
));
3651 vstop_notif
->status
= last_status
;
3652 vstop_notif
->ptid
= last_ptid
;
3653 /* Push Stop notification. */
3654 notif_push (¬if_stop
,
3655 (struct notif_event
*) vstop_notif
);
3659 /* Be sure to not change the selected inferior behind GDB's back.
3660 Important in the non-stop mode asynchronous protocol. */
3661 set_desired_inferior (1);