1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2015 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"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
44 multi-process), or a specific thread ptid_t. */
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. */
60 int report_fork_events
;
61 int report_vfork_events
;
66 /* Whether we should attempt to disable the operating system's address
67 space randomization feature before starting an inferior. */
68 int disable_randomization
= 1;
70 static char **program_argv
, **wrapper_argv
;
72 int pass_signals
[GDB_SIGNAL_LAST
];
73 int program_signals
[GDB_SIGNAL_LAST
];
74 int program_signals_p
;
76 /* The PID of the originally created or attached inferior. Used to
77 send signals to the process when GDB sends us an asynchronous interrupt
78 (user hitting Control-C in the client), and to wait for the child to exit
79 when no longer debugging it. */
81 unsigned long signal_pid
;
84 /* A file descriptor for the controlling terminal. */
87 /* TERMINAL_FD's original foreground group. */
88 pid_t old_foreground_pgrp
;
90 /* Hand back terminal ownership to the original foreground group. */
93 restore_old_foreground_pgrp (void)
95 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
99 /* Set if you want to disable optional thread related packets support
100 in gdbserver, for the sake of testing GDB against stubs that don't
102 int disable_packet_vCont
;
103 int disable_packet_Tthread
;
104 int disable_packet_qC
;
105 int disable_packet_qfThreadInfo
;
107 /* Last status reported to GDB. */
108 static struct target_waitstatus last_status
;
109 static ptid_t last_ptid
;
111 static char *own_buf
;
112 static unsigned char *mem_buf
;
114 /* A sub-class of 'struct notif_event' for stop, holding information
115 relative to a single stop reply. We keep a queue of these to
116 push to GDB in non-stop mode. */
120 struct notif_event base
;
122 /* Thread or process that got the event. */
126 struct target_waitstatus status
;
129 /* The current btrace configuration. This is gdbserver's mirror of GDB's
130 btrace configuration. */
131 static struct btrace_config current_btrace_conf
;
133 DEFINE_QUEUE_P (notif_event_p
);
135 /* Put a stop reply to the stop reply queue. */
138 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
140 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
142 new_notif
->ptid
= ptid
;
143 new_notif
->status
= *status
;
145 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
149 remove_all_on_match_pid (QUEUE (notif_event_p
) *q
,
150 QUEUE_ITER (notif_event_p
) *iter
,
151 struct notif_event
*event
,
157 || ptid_get_pid (((struct vstop_notif
*) event
)->ptid
) == *pid
)
159 if (q
->free_func
!= NULL
)
160 q
->free_func (event
);
162 QUEUE_remove_elem (notif_event_p
, q
, iter
);
168 /* Get rid of the currently pending stop replies for PID. If PID is
169 -1, then apply to all processes. */
172 discard_queued_stop_replies (int pid
)
174 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
175 remove_all_on_match_pid
, &pid
);
179 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
181 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
183 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
186 struct notif_server notif_stop
=
188 "vStopped", "Stop", NULL
, vstop_notif_reply
,
192 target_running (void)
194 return get_first_thread () != NULL
;
198 start_inferior (char **argv
)
200 char **new_argv
= argv
;
202 if (wrapper_argv
!= NULL
)
206 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
208 for (i
= 0; argv
[i
] != NULL
; i
++)
210 new_argv
= alloca (sizeof (char *) * count
);
212 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
213 new_argv
[count
++] = wrapper_argv
[i
];
214 for (i
= 0; argv
[i
] != NULL
; i
++)
215 new_argv
[count
++] = argv
[i
];
216 new_argv
[count
] = NULL
;
222 for (i
= 0; new_argv
[i
]; ++i
)
223 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
228 signal (SIGTTOU
, SIG_DFL
);
229 signal (SIGTTIN
, SIG_DFL
);
232 signal_pid
= create_inferior (new_argv
[0], new_argv
);
234 /* FIXME: we don't actually know at this point that the create
235 actually succeeded. We won't know that until we wait. */
236 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
241 signal (SIGTTOU
, SIG_IGN
);
242 signal (SIGTTIN
, SIG_IGN
);
243 terminal_fd
= fileno (stderr
);
244 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
245 tcsetpgrp (terminal_fd
, signal_pid
);
246 atexit (restore_old_foreground_pgrp
);
249 if (wrapper_argv
!= NULL
)
251 struct thread_resume resume_info
;
253 memset (&resume_info
, 0, sizeof (resume_info
));
254 resume_info
.thread
= pid_to_ptid (signal_pid
);
255 resume_info
.kind
= resume_continue
;
258 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
260 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
265 (*the_target
->resume
) (&resume_info
, 1);
267 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
268 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
271 current_thread
->last_resume_kind
= resume_stop
;
272 current_thread
->last_status
= last_status
;
274 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
279 /* Wait till we are at 1st instruction in program, return new pid
280 (assuming success). */
281 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
283 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
284 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
286 current_thread
->last_resume_kind
= resume_stop
;
287 current_thread
->last_status
= last_status
;
290 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
296 attach_inferior (int pid
)
298 /* myattach should return -1 if attaching is unsupported,
299 0 if it succeeded, and call error() otherwise. */
301 if (myattach (pid
) != 0)
304 fprintf (stderr
, "Attached; pid = %d\n", pid
);
307 /* FIXME - It may be that we should get the SIGNAL_PID from the
308 attach function, so that it can be the main thread instead of
309 whichever we were told to attach to. */
314 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
316 /* GDB knows to ignore the first SIGSTOP after attaching to a running
317 process using the "attach" command, but this is different; it's
318 just using "target remote". Pretend it's just starting up. */
319 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
320 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
321 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
323 current_thread
->last_resume_kind
= resume_stop
;
324 current_thread
->last_status
= last_status
;
330 extern int remote_debug
;
332 /* Decode a qXfer read request. Return 0 if everything looks OK,
336 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
338 /* After the read marker and annex, qXfer looks like a
339 traditional 'm' packet. */
340 decode_m_packet (buf
, ofs
, len
);
346 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
348 /* Extract and NUL-terminate the object. */
350 while (*buf
&& *buf
!= ':')
356 /* Extract and NUL-terminate the read/write action. */
358 while (*buf
&& *buf
!= ':')
364 /* Extract and NUL-terminate the annex. */
366 while (*buf
&& *buf
!= ':')
376 /* Write the response to a successful qXfer read. Returns the
377 length of the (binary) data stored in BUF, corresponding
378 to as much of DATA/LEN as we could fit. IS_MORE controls
379 the first character of the response. */
381 write_qxfer_response (char *buf
, const void *data
, int len
, int is_more
)
390 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
391 &out_len
, PBUFSIZ
- 2) + 1;
394 /* Handle btrace enabling in BTS format. */
397 handle_btrace_enable_bts (struct thread_info
*thread
)
399 if (thread
->btrace
!= NULL
)
400 return "E.Btrace already enabled.";
402 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
403 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
404 ¤t_btrace_conf
);
405 if (thread
->btrace
== NULL
)
406 return "E.Could not enable btrace.";
411 /* Handle btrace enabling in Intel(R) Processor Trace format. */
414 handle_btrace_enable_pt (struct thread_info
*thread
)
416 if (thread
->btrace
!= NULL
)
417 return "E.Btrace already enabled.";
419 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
420 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
421 ¤t_btrace_conf
);
422 if (thread
->btrace
== NULL
)
423 return "E.Could not enable btrace.";
428 /* Handle btrace disabling. */
431 handle_btrace_disable (struct thread_info
*thread
)
434 if (thread
->btrace
== NULL
)
435 return "E.Branch tracing not enabled.";
437 if (target_disable_btrace (thread
->btrace
) != 0)
438 return "E.Could not disable branch tracing.";
440 thread
->btrace
= NULL
;
444 /* Handle the "Qbtrace" packet. */
447 handle_btrace_general_set (char *own_buf
)
449 struct thread_info
*thread
;
453 if (!startswith (own_buf
, "Qbtrace:"))
456 op
= own_buf
+ strlen ("Qbtrace:");
458 if (ptid_equal (general_thread
, null_ptid
)
459 || ptid_equal (general_thread
, minus_one_ptid
))
461 strcpy (own_buf
, "E.Must select a single thread.");
465 thread
= find_thread_ptid (general_thread
);
468 strcpy (own_buf
, "E.No such thread.");
474 if (strcmp (op
, "bts") == 0)
475 err
= handle_btrace_enable_bts (thread
);
476 else if (strcmp (op
, "pt") == 0)
477 err
= handle_btrace_enable_pt (thread
);
478 else if (strcmp (op
, "off") == 0)
479 err
= handle_btrace_disable (thread
);
481 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
484 strcpy (own_buf
, err
);
491 /* Handle the "Qbtrace-conf" packet. */
494 handle_btrace_conf_general_set (char *own_buf
)
496 struct thread_info
*thread
;
499 if (!startswith (own_buf
, "Qbtrace-conf:"))
502 op
= own_buf
+ strlen ("Qbtrace-conf:");
504 if (ptid_equal (general_thread
, null_ptid
)
505 || ptid_equal (general_thread
, minus_one_ptid
))
507 strcpy (own_buf
, "E.Must select a single thread.");
511 thread
= find_thread_ptid (general_thread
);
514 strcpy (own_buf
, "E.No such thread.");
518 if (startswith (op
, "bts:size="))
524 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
525 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
527 strcpy (own_buf
, "E.Bad size value.");
531 current_btrace_conf
.bts
.size
= (unsigned int) size
;
533 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
539 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
540 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
542 strcpy (own_buf
, "E.Bad size value.");
546 current_btrace_conf
.pt
.size
= (unsigned int) size
;
550 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
558 /* Handle all of the extended 'Q' packets. */
561 handle_general_set (char *own_buf
)
563 if (startswith (own_buf
, "QPassSignals:"))
565 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
566 const char *p
= own_buf
+ strlen ("QPassSignals:");
569 p
= decode_address_to_semicolon (&cursig
, p
);
570 for (i
= 0; i
< numsigs
; i
++)
576 /* Keep looping, to clear the remaining signals. */
579 p
= decode_address_to_semicolon (&cursig
, p
);
584 strcpy (own_buf
, "OK");
588 if (startswith (own_buf
, "QProgramSignals:"))
590 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
591 const char *p
= own_buf
+ strlen ("QProgramSignals:");
594 program_signals_p
= 1;
596 p
= decode_address_to_semicolon (&cursig
, p
);
597 for (i
= 0; i
< numsigs
; i
++)
601 program_signals
[i
] = 1;
603 /* Keep looping, to clear the remaining signals. */
606 p
= decode_address_to_semicolon (&cursig
, p
);
609 program_signals
[i
] = 0;
611 strcpy (own_buf
, "OK");
615 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
619 fprintf (stderr
, "[noack mode enabled]\n");
628 if (startswith (own_buf
, "QNonStop:"))
630 char *mode
= own_buf
+ 9;
634 if (strcmp (mode
, "0") == 0)
636 else if (strcmp (mode
, "1") == 0)
640 /* We don't know what this mode is, so complain to
642 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
648 req_str
= req
? "non-stop" : "all-stop";
649 if (start_non_stop (req
) != 0)
651 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
659 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
665 if (startswith (own_buf
, "QDisableRandomization:"))
667 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
670 unpack_varlen_hex (packet
, &setting
);
671 disable_randomization
= setting
;
675 if (disable_randomization
)
676 fprintf (stderr
, "[address space randomization disabled]\n");
678 fprintf (stderr
, "[address space randomization enabled]\n");
685 if (target_supports_tracepoints ()
686 && handle_tracepoint_general_set (own_buf
))
689 if (startswith (own_buf
, "QAgent:"))
691 char *mode
= own_buf
+ strlen ("QAgent:");
694 if (strcmp (mode
, "0") == 0)
696 else if (strcmp (mode
, "1") == 0)
700 /* We don't know what this value is, so complain to GDB. */
701 sprintf (own_buf
, "E.Unknown QAgent value");
705 /* Update the flag. */
708 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
713 if (handle_btrace_general_set (own_buf
))
716 if (handle_btrace_conf_general_set (own_buf
))
719 /* Otherwise we didn't know what packet it was. Say we didn't
725 get_features_xml (const char *annex
)
727 const struct target_desc
*desc
= current_target_desc ();
729 /* `desc->xmltarget' defines what to return when looking for the
730 "target.xml" file. Its contents can either be verbatim XML code
731 (prefixed with a '@') or else the name of the actual XML file to
732 be used in place of "target.xml".
734 This variable is set up from the auto-generated
735 init_registers_... routine for the current target. */
737 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
739 if (*desc
->xmltarget
== '@')
740 return desc
->xmltarget
+ 1;
742 annex
= desc
->xmltarget
;
747 extern const char *const xml_builtin
[][2];
750 /* Look for the annex. */
751 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
752 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
755 if (xml_builtin
[i
][0] != NULL
)
756 return xml_builtin
[i
][1];
764 monitor_show_help (void)
766 monitor_output ("The following monitor commands are supported:\n");
767 monitor_output (" set debug <0|1>\n");
768 monitor_output (" Enable general debugging messages\n");
769 monitor_output (" set debug-hw-points <0|1>\n");
770 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
771 monitor_output (" set remote-debug <0|1>\n");
772 monitor_output (" Enable remote protocol debugging messages\n");
773 monitor_output (" set debug-format option1[,option2,...]\n");
774 monitor_output (" Add additional information to debugging messages\n");
775 monitor_output (" Options: all, none");
776 monitor_output (", timestamp");
777 monitor_output ("\n");
778 monitor_output (" exit\n");
779 monitor_output (" Quit GDBserver\n");
782 /* Read trace frame or inferior memory. Returns the number of bytes
783 actually read, zero when no further transfer is possible, and -1 on
784 error. Return of a positive value smaller than LEN does not
785 indicate there's no more to be read, only the end of the transfer.
786 E.g., when GDB reads memory from a traceframe, a first request may
787 be served from a memory block that does not cover the whole request
788 length. A following request gets the rest served from either
789 another block (of the same traceframe) or from the read-only
793 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
797 if (current_traceframe
>= 0)
800 ULONGEST length
= len
;
802 if (traceframe_read_mem (current_traceframe
,
803 memaddr
, myaddr
, len
, &nbytes
))
805 /* Data read from trace buffer, we're done. */
808 if (!in_readonly_region (memaddr
, length
))
810 /* Otherwise we have a valid readonly case, fall through. */
811 /* (assume no half-trace half-real blocks for now) */
814 res
= prepare_to_access_memory ();
817 res
= read_inferior_memory (memaddr
, myaddr
, len
);
818 done_accessing_memory ();
820 return res
== 0 ? len
: -1;
826 /* Write trace frame or inferior memory. Actually, writing to trace
827 frames is forbidden. */
830 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
832 if (current_traceframe
>= 0)
838 ret
= prepare_to_access_memory ();
841 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
842 done_accessing_memory ();
848 /* Subroutine of handle_search_memory to simplify it. */
851 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
852 gdb_byte
*pattern
, unsigned pattern_len
,
853 gdb_byte
*search_buf
,
854 unsigned chunk_size
, unsigned search_buf_size
,
855 CORE_ADDR
*found_addrp
)
857 /* Prime the search buffer. */
859 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
862 warning ("Unable to access %ld bytes of target "
863 "memory at 0x%lx, halting search.",
864 (long) search_buf_size
, (long) start_addr
);
868 /* Perform the search.
870 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
871 When we've scanned N bytes we copy the trailing bytes to the start and
872 read in another N bytes. */
874 while (search_space_len
>= pattern_len
)
877 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
881 found_ptr
= memmem (search_buf
, nr_search_bytes
, pattern
, pattern_len
);
883 if (found_ptr
!= NULL
)
885 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
886 *found_addrp
= found_addr
;
890 /* Not found in this chunk, skip to next chunk. */
892 /* Don't let search_space_len wrap here, it's unsigned. */
893 if (search_space_len
>= chunk_size
)
894 search_space_len
-= chunk_size
;
896 search_space_len
= 0;
898 if (search_space_len
>= pattern_len
)
900 unsigned keep_len
= search_buf_size
- chunk_size
;
901 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
904 /* Copy the trailing part of the previous iteration to the front
905 of the buffer for the next iteration. */
906 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
908 nr_to_read
= (search_space_len
- keep_len
< chunk_size
909 ? search_space_len
- keep_len
912 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
913 nr_to_read
) != search_buf_size
)
915 warning ("Unable to access %ld bytes of target memory "
916 "at 0x%lx, halting search.",
917 (long) nr_to_read
, (long) read_addr
);
921 start_addr
+= chunk_size
;
930 /* Handle qSearch:memory packets. */
933 handle_search_memory (char *own_buf
, int packet_len
)
935 CORE_ADDR start_addr
;
936 CORE_ADDR search_space_len
;
938 unsigned int pattern_len
;
939 /* NOTE: also defined in find.c testcase. */
940 #define SEARCH_CHUNK_SIZE 16000
941 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
942 /* Buffer to hold memory contents for searching. */
943 gdb_byte
*search_buf
;
944 unsigned search_buf_size
;
946 CORE_ADDR found_addr
;
947 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
949 pattern
= malloc (packet_len
);
952 error ("Unable to allocate memory to perform the search");
953 strcpy (own_buf
, "E00");
956 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
957 packet_len
- cmd_name_len
,
958 &start_addr
, &search_space_len
,
959 pattern
, &pattern_len
) < 0)
962 error ("Error in parsing qSearch:memory packet");
963 strcpy (own_buf
, "E00");
967 search_buf_size
= chunk_size
+ pattern_len
- 1;
969 /* No point in trying to allocate a buffer larger than the search space. */
970 if (search_space_len
< search_buf_size
)
971 search_buf_size
= search_space_len
;
973 search_buf
= malloc (search_buf_size
);
974 if (search_buf
== NULL
)
977 error ("Unable to allocate memory to perform the search");
978 strcpy (own_buf
, "E00");
982 found
= handle_search_memory_1 (start_addr
, search_space_len
,
983 pattern
, pattern_len
,
984 search_buf
, chunk_size
, search_buf_size
,
988 sprintf (own_buf
, "1,%lx", (long) found_addr
);
990 strcpy (own_buf
, "0");
992 strcpy (own_buf
, "E00");
998 #define require_running(BUF) \
999 if (!target_running ()) \
1005 /* Parse options to --debug-format= and "monitor set debug-format".
1006 ARG is the text after "--debug-format=" or "monitor set debug-format".
1007 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1008 This triggers calls to monitor_output.
1009 The result is NULL if all options were parsed ok, otherwise an error
1010 message which the caller must free.
1012 N.B. These commands affect all debug format settings, they are not
1013 cumulative. If a format is not specified, it is turned off.
1014 However, we don't go to extra trouble with things like
1015 "monitor set debug-format all,none,timestamp".
1016 Instead we just parse them one at a time, in order.
1018 The syntax for "monitor set debug" we support here is not identical
1019 to gdb's "set debug foo on|off" because we also use this function to
1020 parse "--debug-format=foo,bar". */
1023 parse_debug_format_options (const char *arg
, int is_monitor
)
1025 VEC (char_ptr
) *options
;
1029 /* First turn all debug format options off. */
1030 debug_timestamp
= 0;
1032 /* First remove leading spaces, for "monitor set debug-format". */
1033 while (isspace (*arg
))
1036 options
= delim_string_to_char_ptr_vec (arg
, ',');
1038 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1040 if (strcmp (option
, "all") == 0)
1042 debug_timestamp
= 1;
1044 monitor_output ("All extra debug format options enabled.\n");
1046 else if (strcmp (option
, "none") == 0)
1048 debug_timestamp
= 0;
1050 monitor_output ("All extra debug format options disabled.\n");
1052 else if (strcmp (option
, "timestamp") == 0)
1054 debug_timestamp
= 1;
1056 monitor_output ("Timestamps will be added to debug output.\n");
1058 else if (*option
== '\0')
1060 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1065 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1068 free_char_ptr_vec (options
);
1073 free_char_ptr_vec (options
);
1077 /* Handle monitor commands not handled by target-specific handlers. */
1080 handle_monitor_command (char *mon
, char *own_buf
)
1082 if (strcmp (mon
, "set debug 1") == 0)
1085 monitor_output ("Debug output enabled.\n");
1087 else if (strcmp (mon
, "set debug 0") == 0)
1090 monitor_output ("Debug output disabled.\n");
1092 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1094 show_debug_regs
= 1;
1095 monitor_output ("H/W point debugging output enabled.\n");
1097 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1099 show_debug_regs
= 0;
1100 monitor_output ("H/W point debugging output disabled.\n");
1102 else if (strcmp (mon
, "set remote-debug 1") == 0)
1105 monitor_output ("Protocol debug output enabled.\n");
1107 else if (strcmp (mon
, "set remote-debug 0") == 0)
1110 monitor_output ("Protocol debug output disabled.\n");
1112 else if (startswith (mon
, "set debug-format "))
1115 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1118 if (error_msg
!= NULL
)
1120 monitor_output (error_msg
);
1121 monitor_show_help ();
1122 write_enn (own_buf
);
1126 else if (strcmp (mon
, "help") == 0)
1127 monitor_show_help ();
1128 else if (strcmp (mon
, "exit") == 0)
1132 monitor_output ("Unknown monitor command.\n\n");
1133 monitor_show_help ();
1134 write_enn (own_buf
);
1138 /* Associates a callback with each supported qXfer'able object. */
1142 /* The object this handler handles. */
1145 /* Request that the target transfer up to LEN 8-bit bytes of the
1146 target's OBJECT. The OFFSET, for a seekable object, specifies
1147 the starting point. The ANNEX can be used to provide additional
1148 data-specific information to the target.
1150 Return the number of bytes actually transfered, zero when no
1151 further transfer is possible, -1 on error, -2 when the transfer
1152 is not supported, and -3 on a verbose error message that should
1153 be preserved. Return of a positive value smaller than LEN does
1154 not indicate the end of the object, only the end of the transfer.
1156 One, and only one, of readbuf or writebuf must be non-NULL. */
1157 int (*xfer
) (const char *annex
,
1158 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1159 ULONGEST offset
, LONGEST len
);
1162 /* Handle qXfer:auxv:read. */
1165 handle_qxfer_auxv (const char *annex
,
1166 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1167 ULONGEST offset
, LONGEST len
)
1169 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1172 if (annex
[0] != '\0' || !target_running ())
1175 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1178 /* Handle qXfer:exec-file:read. */
1181 handle_qxfer_exec_file (const char *const_annex
,
1182 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1183 ULONGEST offset
, LONGEST len
)
1189 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1192 if (const_annex
[0] == '\0')
1194 if (current_thread
== NULL
)
1197 pid
= pid_of (current_thread
);
1201 char *annex
= alloca (strlen (const_annex
) + 1);
1203 strcpy (annex
, const_annex
);
1204 annex
= unpack_varlen_hex (annex
, &pid
);
1206 if (annex
[0] != '\0')
1213 file
= (*the_target
->pid_to_exec_file
) (pid
);
1217 total_len
= strlen (file
);
1219 if (offset
> total_len
)
1222 if (offset
+ len
> total_len
)
1223 len
= total_len
- offset
;
1225 memcpy (readbuf
, file
+ offset
, len
);
1229 /* Handle qXfer:features:read. */
1232 handle_qxfer_features (const char *annex
,
1233 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1234 ULONGEST offset
, LONGEST len
)
1236 const char *document
;
1239 if (writebuf
!= NULL
)
1242 if (!target_running ())
1245 /* Grab the correct annex. */
1246 document
= get_features_xml (annex
);
1247 if (document
== NULL
)
1250 total_len
= strlen (document
);
1252 if (offset
> total_len
)
1255 if (offset
+ len
> total_len
)
1256 len
= total_len
- offset
;
1258 memcpy (readbuf
, document
+ offset
, len
);
1262 /* Worker routine for handle_qxfer_libraries.
1263 Add to the length pointed to by ARG a conservative estimate of the
1264 length needed to transmit the file name of INF. */
1267 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1269 struct dll_info
*dll
= (struct dll_info
*) inf
;
1270 unsigned int *total_len
= arg
;
1272 /* Over-estimate the necessary memory. Assume that every character
1273 in the library name must be escaped. */
1274 *total_len
+= 128 + 6 * strlen (dll
->name
);
1277 /* Worker routine for handle_qxfer_libraries.
1278 Emit the XML to describe the library in INF. */
1281 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1283 struct dll_info
*dll
= (struct dll_info
*) inf
;
1288 strcpy (p
, " <library name=\"");
1290 name
= xml_escape_text (dll
->name
);
1294 strcpy (p
, "\"><segment address=\"");
1296 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1298 strcpy (p
, "\"/></library>\n");
1304 /* Handle qXfer:libraries:read. */
1307 handle_qxfer_libraries (const char *annex
,
1308 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1309 ULONGEST offset
, LONGEST len
)
1311 unsigned int total_len
;
1314 if (writebuf
!= NULL
)
1317 if (annex
[0] != '\0' || !target_running ())
1321 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1324 document
= malloc (total_len
);
1325 if (document
== NULL
)
1328 strcpy (document
, "<library-list version=\"1.0\">\n");
1329 p
= document
+ strlen (document
);
1331 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1333 strcpy (p
, "</library-list>\n");
1335 total_len
= strlen (document
);
1337 if (offset
> total_len
)
1343 if (offset
+ len
> total_len
)
1344 len
= total_len
- offset
;
1346 memcpy (readbuf
, document
+ offset
, len
);
1351 /* Handle qXfer:libraries-svr4:read. */
1354 handle_qxfer_libraries_svr4 (const char *annex
,
1355 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1356 ULONGEST offset
, LONGEST len
)
1358 if (writebuf
!= NULL
)
1361 if (!target_running () || the_target
->qxfer_libraries_svr4
== NULL
)
1364 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1367 /* Handle qXfer:osadata:read. */
1370 handle_qxfer_osdata (const char *annex
,
1371 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1372 ULONGEST offset
, LONGEST len
)
1374 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1377 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1380 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1383 handle_qxfer_siginfo (const char *annex
,
1384 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1385 ULONGEST offset
, LONGEST len
)
1387 if (the_target
->qxfer_siginfo
== NULL
)
1390 if (annex
[0] != '\0' || !target_running ())
1393 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1396 /* Handle qXfer:spu:read and qXfer:spu:write. */
1399 handle_qxfer_spu (const char *annex
,
1400 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1401 ULONGEST offset
, LONGEST len
)
1403 if (the_target
->qxfer_spu
== NULL
)
1406 if (!target_running ())
1409 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1412 /* Handle qXfer:statictrace:read. */
1415 handle_qxfer_statictrace (const char *annex
,
1416 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1417 ULONGEST offset
, LONGEST len
)
1421 if (writebuf
!= NULL
)
1424 if (annex
[0] != '\0' || !target_running () || current_traceframe
== -1)
1427 if (traceframe_read_sdata (current_traceframe
, offset
,
1428 readbuf
, len
, &nbytes
))
1433 /* Helper for handle_qxfer_threads_proper.
1434 Emit the XML to describe the thread of INF. */
1437 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1439 struct thread_info
*thread
= (struct thread_info
*) inf
;
1440 struct buffer
*buffer
= arg
;
1441 ptid_t ptid
= thread_to_gdb_id (thread
);
1443 int core
= target_core_of_thread (ptid
);
1446 write_ptid (ptid_s
, ptid
);
1450 sprintf (core_s
, "%d", core
);
1451 buffer_xml_printf (buffer
, "<thread id=\"%s\" core=\"%s\"/>\n",
1456 buffer_xml_printf (buffer
, "<thread id=\"%s\"/>\n",
1461 /* Helper for handle_qxfer_threads. */
1464 handle_qxfer_threads_proper (struct buffer
*buffer
)
1466 buffer_grow_str (buffer
, "<threads>\n");
1468 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1471 buffer_grow_str0 (buffer
, "</threads>\n");
1474 /* Handle qXfer:threads:read. */
1477 handle_qxfer_threads (const char *annex
,
1478 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1479 ULONGEST offset
, LONGEST len
)
1481 static char *result
= 0;
1482 static unsigned int result_length
= 0;
1484 if (writebuf
!= NULL
)
1487 if (!target_running () || annex
[0] != '\0')
1492 struct buffer buffer
;
1493 /* When asked for data at offset 0, generate everything and store into
1494 'result'. Successive reads will be served off 'result'. */
1498 buffer_init (&buffer
);
1500 handle_qxfer_threads_proper (&buffer
);
1502 result
= buffer_finish (&buffer
);
1503 result_length
= strlen (result
);
1504 buffer_free (&buffer
);
1507 if (offset
>= result_length
)
1509 /* We're out of data. */
1516 if (len
> result_length
- offset
)
1517 len
= result_length
- offset
;
1519 memcpy (readbuf
, result
+ offset
, len
);
1524 /* Handle qXfer:traceframe-info:read. */
1527 handle_qxfer_traceframe_info (const char *annex
,
1528 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1529 ULONGEST offset
, LONGEST len
)
1531 static char *result
= 0;
1532 static unsigned int result_length
= 0;
1534 if (writebuf
!= NULL
)
1537 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1542 struct buffer buffer
;
1544 /* When asked for data at offset 0, generate everything and
1545 store into 'result'. Successive reads will be served off
1549 buffer_init (&buffer
);
1551 traceframe_read_info (current_traceframe
, &buffer
);
1553 result
= buffer_finish (&buffer
);
1554 result_length
= strlen (result
);
1555 buffer_free (&buffer
);
1558 if (offset
>= result_length
)
1560 /* We're out of data. */
1567 if (len
> result_length
- offset
)
1568 len
= result_length
- offset
;
1570 memcpy (readbuf
, result
+ offset
, len
);
1574 /* Handle qXfer:fdpic:read. */
1577 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1578 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1580 if (the_target
->read_loadmap
== NULL
)
1583 if (!target_running ())
1586 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1589 /* Handle qXfer:btrace:read. */
1592 handle_qxfer_btrace (const char *annex
,
1593 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1594 ULONGEST offset
, LONGEST len
)
1596 static struct buffer cache
;
1597 struct thread_info
*thread
;
1600 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1603 if (!target_running ())
1606 if (ptid_equal (general_thread
, null_ptid
)
1607 || ptid_equal (general_thread
, minus_one_ptid
))
1609 strcpy (own_buf
, "E.Must select a single thread.");
1613 thread
= find_thread_ptid (general_thread
);
1616 strcpy (own_buf
, "E.No such thread.");
1620 if (thread
->btrace
== NULL
)
1622 strcpy (own_buf
, "E.Btrace not enabled.");
1626 if (strcmp (annex
, "all") == 0)
1627 type
= BTRACE_READ_ALL
;
1628 else if (strcmp (annex
, "new") == 0)
1629 type
= BTRACE_READ_NEW
;
1630 else if (strcmp (annex
, "delta") == 0)
1631 type
= BTRACE_READ_DELTA
;
1634 strcpy (own_buf
, "E.Bad annex.");
1640 buffer_free (&cache
);
1642 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1645 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1649 else if (offset
> cache
.used_size
)
1651 buffer_free (&cache
);
1655 if (len
> cache
.used_size
- offset
)
1656 len
= cache
.used_size
- offset
;
1658 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1663 /* Handle qXfer:btrace-conf:read. */
1666 handle_qxfer_btrace_conf (const char *annex
,
1667 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1668 ULONGEST offset
, LONGEST len
)
1670 static struct buffer cache
;
1671 struct thread_info
*thread
;
1674 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1677 if (annex
[0] != '\0' || !target_running ())
1680 if (ptid_equal (general_thread
, null_ptid
)
1681 || ptid_equal (general_thread
, minus_one_ptid
))
1683 strcpy (own_buf
, "E.Must select a single thread.");
1687 thread
= find_thread_ptid (general_thread
);
1690 strcpy (own_buf
, "E.No such thread.");
1694 if (thread
->btrace
== NULL
)
1696 strcpy (own_buf
, "E.Btrace not enabled.");
1702 buffer_free (&cache
);
1704 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1707 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1711 else if (offset
> cache
.used_size
)
1713 buffer_free (&cache
);
1717 if (len
> cache
.used_size
- offset
)
1718 len
= cache
.used_size
- offset
;
1720 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1725 static const struct qxfer qxfer_packets
[] =
1727 { "auxv", handle_qxfer_auxv
},
1728 { "btrace", handle_qxfer_btrace
},
1729 { "btrace-conf", handle_qxfer_btrace_conf
},
1730 { "exec-file", handle_qxfer_exec_file
},
1731 { "fdpic", handle_qxfer_fdpic
},
1732 { "features", handle_qxfer_features
},
1733 { "libraries", handle_qxfer_libraries
},
1734 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1735 { "osdata", handle_qxfer_osdata
},
1736 { "siginfo", handle_qxfer_siginfo
},
1737 { "spu", handle_qxfer_spu
},
1738 { "statictrace", handle_qxfer_statictrace
},
1739 { "threads", handle_qxfer_threads
},
1740 { "traceframe-info", handle_qxfer_traceframe_info
},
1744 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1752 if (!startswith (own_buf
, "qXfer:"))
1755 /* Grab the object, r/w and annex. */
1756 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1758 write_enn (own_buf
);
1763 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1766 const struct qxfer
*q
= &qxfer_packets
[i
];
1768 if (strcmp (object
, q
->object
) == 0)
1770 if (strcmp (rw
, "read") == 0)
1772 unsigned char *data
;
1777 /* Grab the offset and length. */
1778 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1780 write_enn (own_buf
);
1784 /* Read one extra byte, as an indicator of whether there is
1786 if (len
> PBUFSIZ
- 2)
1788 data
= malloc (len
+ 1);
1791 write_enn (own_buf
);
1794 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1802 /* Preserve error message. */
1805 write_enn (own_buf
);
1807 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1809 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1814 else if (strcmp (rw
, "write") == 0)
1819 unsigned char *data
;
1821 strcpy (own_buf
, "E00");
1822 data
= malloc (packet_len
- (offset
- own_buf
));
1825 write_enn (own_buf
);
1828 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1829 &ofs
, &len
, data
) < 0)
1832 write_enn (own_buf
);
1836 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1844 /* Preserve error message. */
1847 write_enn (own_buf
);
1849 sprintf (own_buf
, "%x", n
);
1862 /* Table used by the crc32 function to calcuate the checksum. */
1864 static unsigned int crc32_table
[256] =
1867 /* Compute 32 bit CRC from inferior memory.
1869 On success, return 32 bit CRC.
1870 On failure, return (unsigned long long) -1. */
1872 static unsigned long long
1873 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1875 if (!crc32_table
[1])
1877 /* Initialize the CRC table and the decoding table. */
1881 for (i
= 0; i
< 256; i
++)
1883 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1884 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1891 unsigned char byte
= 0;
1893 /* Return failure if memory read fails. */
1894 if (read_inferior_memory (base
, &byte
, 1) != 0)
1895 return (unsigned long long) -1;
1897 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1900 return (unsigned long long) crc
;
1903 /* Add supported btrace packets to BUF. */
1906 supported_btrace_packets (char *buf
)
1908 int btrace_supported
= 0;
1910 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1912 strcat (buf
, ";Qbtrace:bts+");
1913 strcat (buf
, ";Qbtrace-conf:bts:size+");
1915 btrace_supported
= 1;
1918 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1920 strcat (buf
, ";Qbtrace:pt+");
1921 strcat (buf
, ";Qbtrace-conf:pt:size+");
1923 btrace_supported
= 1;
1926 if (!btrace_supported
)
1929 strcat (buf
, ";Qbtrace:off+");
1930 strcat (buf
, ";qXfer:btrace:read+");
1931 strcat (buf
, ";qXfer:btrace-conf:read+");
1934 /* Handle all of the extended 'q' packets. */
1937 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1939 static struct inferior_list_entry
*thread_ptr
;
1941 /* Reply the current thread id. */
1942 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1945 require_running (own_buf
);
1947 if (!ptid_equal (general_thread
, null_ptid
)
1948 && !ptid_equal (general_thread
, minus_one_ptid
))
1949 gdb_id
= general_thread
;
1952 thread_ptr
= get_first_inferior (&all_threads
);
1953 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1956 sprintf (own_buf
, "QC");
1958 write_ptid (own_buf
, gdb_id
);
1962 if (strcmp ("qSymbol::", own_buf
) == 0)
1964 /* GDB is suggesting new symbols have been loaded. This may
1965 mean a new shared library has been detected as loaded, so
1966 take the opportunity to check if breakpoints we think are
1967 inserted, still are. Note that it isn't guaranteed that
1968 we'll see this when a shared library is loaded, and nor will
1969 we see this for unloads (although breakpoints in unloaded
1970 libraries shouldn't trigger), as GDB may not find symbols for
1971 the library at all. We also re-validate breakpoints when we
1972 see a second GDB breakpoint for the same address, and or when
1973 we access breakpoint shadows. */
1974 validate_breakpoints ();
1976 if (target_supports_tracepoints ())
1977 tracepoint_look_up_symbols ();
1979 if (target_running () && the_target
->look_up_symbols
!= NULL
)
1980 (*the_target
->look_up_symbols
) ();
1982 strcpy (own_buf
, "OK");
1986 if (!disable_packet_qfThreadInfo
)
1988 if (strcmp ("qfThreadInfo", own_buf
) == 0)
1992 require_running (own_buf
);
1993 thread_ptr
= get_first_inferior (&all_threads
);
1996 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1997 write_ptid (own_buf
, gdb_id
);
1998 thread_ptr
= thread_ptr
->next
;
2002 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2006 require_running (own_buf
);
2007 if (thread_ptr
!= NULL
)
2010 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2011 write_ptid (own_buf
, gdb_id
);
2012 thread_ptr
= thread_ptr
->next
;
2017 sprintf (own_buf
, "l");
2023 if (the_target
->read_offsets
!= NULL
2024 && strcmp ("qOffsets", own_buf
) == 0)
2026 CORE_ADDR text
, data
;
2028 require_running (own_buf
);
2029 if (the_target
->read_offsets (&text
, &data
))
2030 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2031 (long)text
, (long)data
, (long)data
);
2033 write_enn (own_buf
);
2038 /* Protocol features query. */
2039 if (startswith (own_buf
, "qSupported")
2040 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2042 char *p
= &own_buf
[10];
2043 int gdb_supports_qRelocInsn
= 0;
2045 /* Start processing qSupported packet. */
2046 target_process_qsupported (NULL
);
2048 /* Process each feature being provided by GDB. The first
2049 feature will follow a ':', and latter features will follow
2053 char **qsupported
= NULL
;
2057 /* Two passes, to avoid nested strtok calls in
2058 target_process_qsupported. */
2059 for (p
= strtok (p
+ 1, ";");
2061 p
= strtok (NULL
, ";"))
2064 qsupported
= xrealloc (qsupported
, count
* sizeof (char *));
2065 qsupported
[count
- 1] = xstrdup (p
);
2068 for (i
= 0; i
< count
; i
++)
2071 if (strcmp (p
, "multiprocess+") == 0)
2073 /* GDB supports and wants multi-process support if
2075 if (target_supports_multi_process ())
2078 else if (strcmp (p
, "qRelocInsn+") == 0)
2080 /* GDB supports relocate instruction requests. */
2081 gdb_supports_qRelocInsn
= 1;
2083 else if (strcmp (p
, "swbreak+") == 0)
2085 /* GDB wants us to report whether a trap is caused
2086 by a software breakpoint and for us to handle PC
2087 adjustment if necessary on this target. */
2088 if (target_supports_stopped_by_sw_breakpoint ())
2089 swbreak_feature
= 1;
2091 else if (strcmp (p
, "hwbreak+") == 0)
2093 /* GDB wants us to report whether a trap is caused
2094 by a hardware breakpoint. */
2095 if (target_supports_stopped_by_hw_breakpoint ())
2096 hwbreak_feature
= 1;
2098 else if (strcmp (p
, "fork-events+") == 0)
2100 /* GDB supports and wants fork events if possible. */
2101 if (target_supports_fork_events ())
2102 report_fork_events
= 1;
2104 else if (strcmp (p
, "vfork-events+") == 0)
2106 /* GDB supports and wants vfork events if possible. */
2107 if (target_supports_vfork_events ())
2108 report_vfork_events
= 1;
2111 target_process_qsupported (p
);
2120 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2123 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2124 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2125 ";augmented-libraries-svr4-read+");
2128 /* We do not have any hook to indicate whether the non-SVR4 target
2129 backend supports qXfer:libraries:read, so always report it. */
2130 strcat (own_buf
, ";qXfer:libraries:read+");
2133 if (the_target
->read_auxv
!= NULL
)
2134 strcat (own_buf
, ";qXfer:auxv:read+");
2136 if (the_target
->qxfer_spu
!= NULL
)
2137 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2139 if (the_target
->qxfer_siginfo
!= NULL
)
2140 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2142 if (the_target
->read_loadmap
!= NULL
)
2143 strcat (own_buf
, ";qXfer:fdpic:read+");
2145 /* We always report qXfer:features:read, as targets may
2146 install XML files on a subsequent call to arch_setup.
2147 If we reported to GDB on startup that we don't support
2148 qXfer:feature:read at all, we will never be re-queried. */
2149 strcat (own_buf
, ";qXfer:features:read+");
2151 if (transport_is_reliable
)
2152 strcat (own_buf
, ";QStartNoAckMode+");
2154 if (the_target
->qxfer_osdata
!= NULL
)
2155 strcat (own_buf
, ";qXfer:osdata:read+");
2157 if (target_supports_multi_process ())
2158 strcat (own_buf
, ";multiprocess+");
2160 if (target_supports_fork_events ())
2161 strcat (own_buf
, ";fork-events+");
2163 if (target_supports_vfork_events ())
2164 strcat (own_buf
, ";vfork-events+");
2166 if (target_supports_non_stop ())
2167 strcat (own_buf
, ";QNonStop+");
2169 if (target_supports_disable_randomization ())
2170 strcat (own_buf
, ";QDisableRandomization+");
2172 strcat (own_buf
, ";qXfer:threads:read+");
2174 if (target_supports_tracepoints ())
2176 strcat (own_buf
, ";ConditionalTracepoints+");
2177 strcat (own_buf
, ";TraceStateVariables+");
2178 strcat (own_buf
, ";TracepointSource+");
2179 strcat (own_buf
, ";DisconnectedTracing+");
2180 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2181 strcat (own_buf
, ";FastTracepoints+");
2182 strcat (own_buf
, ";StaticTracepoints+");
2183 strcat (own_buf
, ";InstallInTrace+");
2184 strcat (own_buf
, ";qXfer:statictrace:read+");
2185 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2186 strcat (own_buf
, ";EnableDisableTracepoints+");
2187 strcat (own_buf
, ";QTBuffer:size+");
2188 strcat (own_buf
, ";tracenz+");
2191 /* Support target-side breakpoint conditions and commands. */
2192 if (target_supports_conditional_breakpoints ())
2193 strcat (own_buf
, ";ConditionalBreakpoints+");
2194 strcat (own_buf
, ";BreakpointCommands+");
2196 if (target_supports_agent ())
2197 strcat (own_buf
, ";QAgent+");
2199 supported_btrace_packets (own_buf
);
2201 if (target_supports_stopped_by_sw_breakpoint ())
2202 strcat (own_buf
, ";swbreak+");
2204 if (target_supports_stopped_by_hw_breakpoint ())
2205 strcat (own_buf
, ";hwbreak+");
2207 if (the_target
->pid_to_exec_file
!= NULL
)
2208 strcat (own_buf
, ";qXfer:exec-file:read+");
2210 /* Reinitialize components as needed for the new connection. */
2211 hostio_handle_new_gdb_connection ();
2212 target_handle_new_gdb_connection ();
2217 /* Thread-local storage support. */
2218 if (the_target
->get_tls_address
!= NULL
2219 && startswith (own_buf
, "qGetTLSAddr:"))
2221 char *p
= own_buf
+ 12;
2222 CORE_ADDR parts
[2], address
= 0;
2224 ptid_t ptid
= null_ptid
;
2226 require_running (own_buf
);
2228 for (i
= 0; i
< 3; i
++)
2236 p2
= strchr (p
, ',');
2249 ptid
= read_ptid (p
, NULL
);
2251 decode_address (&parts
[i
- 1], p
, len
);
2255 if (p
!= NULL
|| i
< 3)
2259 struct thread_info
*thread
= find_thread_ptid (ptid
);
2264 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2270 strcpy (own_buf
, paddress(address
));
2275 write_enn (own_buf
);
2279 /* Otherwise, pretend we do not understand this packet. */
2282 /* Windows OS Thread Information Block address support. */
2283 if (the_target
->get_tib_address
!= NULL
2284 && startswith (own_buf
, "qGetTIBAddr:"))
2289 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2291 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2294 strcpy (own_buf
, paddress(tlb
));
2299 write_enn (own_buf
);
2305 /* Handle "monitor" commands. */
2306 if (startswith (own_buf
, "qRcmd,"))
2308 char *mon
= malloc (PBUFSIZ
);
2309 int len
= strlen (own_buf
+ 6);
2313 write_enn (own_buf
);
2318 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2320 write_enn (own_buf
);
2324 mon
[len
/ 2] = '\0';
2328 if (the_target
->handle_monitor_command
== NULL
2329 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2330 /* Default processing. */
2331 handle_monitor_command (mon
, own_buf
);
2337 if (startswith (own_buf
, "qSearch:memory:"))
2339 require_running (own_buf
);
2340 handle_search_memory (own_buf
, packet_len
);
2344 if (strcmp (own_buf
, "qAttached") == 0
2345 || startswith (own_buf
, "qAttached:"))
2347 struct process_info
*process
;
2349 if (own_buf
[sizeof ("qAttached") - 1])
2351 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2352 process
= (struct process_info
*)
2353 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2357 require_running (own_buf
);
2358 process
= current_process ();
2361 if (process
== NULL
)
2363 write_enn (own_buf
);
2367 strcpy (own_buf
, process
->attached
? "1" : "0");
2371 if (startswith (own_buf
, "qCRC:"))
2373 /* CRC check (compare-section). */
2377 unsigned long long crc
;
2379 require_running (own_buf
);
2380 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2381 if (*comma
++ != ',')
2383 write_enn (own_buf
);
2386 len
= strtoul (comma
, NULL
, 16);
2387 crc
= crc32 (base
, len
, 0xffffffff);
2388 /* Check for memory failure. */
2389 if (crc
== (unsigned long long) -1)
2391 write_enn (own_buf
);
2394 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2398 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2401 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2404 /* Otherwise we didn't know what packet it was. Say we didn't
2409 static void gdb_wants_all_threads_stopped (void);
2410 static void resume (struct thread_resume
*actions
, size_t n
);
2412 /* The callback that is passed to visit_actioned_threads. */
2413 typedef int (visit_actioned_threads_callback_ftype
)
2414 (const struct thread_resume
*, struct thread_info
*);
2416 /* Struct to pass data to visit_actioned_threads. */
2418 struct visit_actioned_threads_data
2420 const struct thread_resume
*actions
;
2422 visit_actioned_threads_callback_ftype
*callback
;
2425 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2426 true if CALLBACK returns true. Returns false if no matching thread
2427 is found or CALLBACK results false.
2428 Note: This function is itself a callback for find_inferior. */
2431 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2433 struct visit_actioned_threads_data
*data
= datap
;
2434 const struct thread_resume
*actions
= data
->actions
;
2435 size_t num_actions
= data
->num_actions
;
2436 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2439 for (i
= 0; i
< num_actions
; i
++)
2441 const struct thread_resume
*action
= &actions
[i
];
2443 if (ptid_equal (action
->thread
, minus_one_ptid
)
2444 || ptid_equal (action
->thread
, entry
->id
)
2445 || ((ptid_get_pid (action
->thread
)
2446 == ptid_get_pid (entry
->id
))
2447 && ptid_get_lwp (action
->thread
) == -1))
2449 struct thread_info
*thread
= (struct thread_info
*) entry
;
2451 if ((*callback
) (action
, thread
))
2459 /* Callback for visit_actioned_threads. If the thread has a pending
2460 status to report, report it now. */
2463 handle_pending_status (const struct thread_resume
*resumption
,
2464 struct thread_info
*thread
)
2466 if (thread
->status_pending_p
)
2468 thread
->status_pending_p
= 0;
2470 last_status
= thread
->last_status
;
2471 last_ptid
= thread
->entry
.id
;
2472 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2478 /* Parse vCont packets. */
2480 handle_v_cont (char *own_buf
)
2484 struct thread_resume
*resume_info
;
2485 struct thread_resume default_action
= {{0}};
2487 /* Count the number of semicolons in the packet. There should be one
2488 for every action. */
2494 p
= strchr (p
, ';');
2497 resume_info
= malloc (n
* sizeof (resume_info
[0]));
2498 if (resume_info
== NULL
)
2506 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2508 if (p
[0] == 's' || p
[0] == 'S')
2509 resume_info
[i
].kind
= resume_step
;
2510 else if (p
[0] == 'r')
2511 resume_info
[i
].kind
= resume_step
;
2512 else if (p
[0] == 'c' || p
[0] == 'C')
2513 resume_info
[i
].kind
= resume_continue
;
2514 else if (p
[0] == 't')
2515 resume_info
[i
].kind
= resume_stop
;
2519 if (p
[0] == 'S' || p
[0] == 'C')
2522 sig
= strtol (p
+ 1, &q
, 16);
2527 if (!gdb_signal_to_host_p (sig
))
2529 resume_info
[i
].sig
= gdb_signal_to_host (sig
);
2531 else if (p
[0] == 'r')
2535 p
= unpack_varlen_hex (p
+ 1, &addr
);
2536 resume_info
[i
].step_range_start
= addr
;
2541 p
= unpack_varlen_hex (p
+ 1, &addr
);
2542 resume_info
[i
].step_range_end
= addr
;
2551 resume_info
[i
].thread
= minus_one_ptid
;
2552 default_action
= resume_info
[i
];
2554 /* Note: we don't increment i here, we'll overwrite this entry
2555 the next time through. */
2557 else if (p
[0] == ':')
2559 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2564 if (p
[0] != ';' && p
[0] != 0)
2567 resume_info
[i
].thread
= ptid
;
2574 resume_info
[i
] = default_action
;
2576 set_desired_thread (0);
2578 resume (resume_info
, n
);
2583 write_enn (own_buf
);
2588 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2591 resume (struct thread_resume
*actions
, size_t num_actions
)
2595 /* Check if among the threads that GDB wants actioned, there's
2596 one with a pending status to report. If so, skip actually
2597 resuming/stopping and report the pending event
2599 struct visit_actioned_threads_data data
;
2601 data
.actions
= actions
;
2602 data
.num_actions
= num_actions
;
2603 data
.callback
= handle_pending_status
;
2604 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2610 (*the_target
->resume
) (actions
, num_actions
);
2616 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2618 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
2620 /* No proper RSP support for this yet. At least return
2622 sprintf (own_buf
, "E.No unwaited-for children left.");
2623 disable_async_io ();
2627 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2628 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2629 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2630 current_thread
->last_status
= last_status
;
2632 /* From the client's perspective, all-stop mode always stops all
2633 threads implicitly (and the target backend has already done
2634 so by now). Tag all threads as "want-stopped", so we don't
2635 resume them implicitly without the client telling us to. */
2636 gdb_wants_all_threads_stopped ();
2637 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2638 disable_async_io ();
2640 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2641 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2642 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2646 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2648 handle_v_attach (char *own_buf
)
2652 pid
= strtol (own_buf
+ 8, NULL
, 16);
2653 if (pid
!= 0 && attach_inferior (pid
) == 0)
2655 /* Don't report shared library events after attaching, even if
2656 some libraries are preloaded. GDB will always poll the
2657 library list. Avoids the "stopped by shared library event"
2658 notice on the GDB side. */
2663 /* In non-stop, we don't send a resume reply. Stop events
2664 will follow up using the normal notification
2669 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2675 write_enn (own_buf
);
2680 /* Run a new program. Return 1 if successful, 0 if failure. */
2682 handle_v_run (char *own_buf
)
2684 char *p
, *next_p
, **new_argv
;
2688 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2694 new_argv
= calloc (new_argc
+ 2, sizeof (char *));
2695 if (new_argv
== NULL
)
2697 write_enn (own_buf
);
2702 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2704 next_p
= strchr (p
, ';');
2706 next_p
= p
+ strlen (p
);
2708 if (i
== 0 && p
== next_p
)
2712 /* FIXME: Fail request if out of memory instead of dying. */
2713 new_argv
[i
] = xmalloc (1 + (next_p
- p
) / 2);
2714 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2715 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2724 if (new_argv
[0] == NULL
)
2726 /* GDB didn't specify a program to run. Use the program from the
2727 last run with the new argument list. */
2729 if (program_argv
== NULL
)
2731 write_enn (own_buf
);
2732 freeargv (new_argv
);
2736 new_argv
[0] = strdup (program_argv
[0]);
2737 if (new_argv
[0] == NULL
)
2739 write_enn (own_buf
);
2740 freeargv (new_argv
);
2745 /* Free the old argv and install the new one. */
2746 freeargv (program_argv
);
2747 program_argv
= new_argv
;
2749 start_inferior (program_argv
);
2750 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2752 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2754 /* In non-stop, sending a resume reply doesn't set the general
2755 thread, but GDB assumes a vRun sets it (this is so GDB can
2756 query which is the main thread of the new inferior. */
2758 general_thread
= last_ptid
;
2764 write_enn (own_buf
);
2769 /* Kill process. Return 1 if successful, 0 if failure. */
2771 handle_v_kill (char *own_buf
)
2774 char *p
= &own_buf
[6];
2776 pid
= strtol (p
, NULL
, 16);
2779 if (pid
!= 0 && kill_inferior (pid
) == 0)
2781 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2782 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2783 last_ptid
= pid_to_ptid (pid
);
2784 discard_queued_stop_replies (pid
);
2790 write_enn (own_buf
);
2795 /* Handle all of the extended 'v' packets. */
2797 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2799 if (!disable_packet_vCont
)
2801 if (startswith (own_buf
, "vCont;"))
2803 require_running (own_buf
);
2804 handle_v_cont (own_buf
);
2808 if (startswith (own_buf
, "vCont?"))
2810 strcpy (own_buf
, "vCont;c;C;s;S;t");
2811 if (target_supports_range_stepping ())
2813 own_buf
= own_buf
+ strlen (own_buf
);
2814 strcpy (own_buf
, ";r");
2820 if (startswith (own_buf
, "vFile:")
2821 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2824 if (startswith (own_buf
, "vAttach;"))
2826 if ((!extended_protocol
|| !multi_process
) && target_running ())
2828 fprintf (stderr
, "Already debugging a process\n");
2829 write_enn (own_buf
);
2832 handle_v_attach (own_buf
);
2836 if (startswith (own_buf
, "vRun;"))
2838 if ((!extended_protocol
|| !multi_process
) && target_running ())
2840 fprintf (stderr
, "Already debugging a process\n");
2841 write_enn (own_buf
);
2844 handle_v_run (own_buf
);
2848 if (startswith (own_buf
, "vKill;"))
2850 if (!target_running ())
2852 fprintf (stderr
, "No process to kill\n");
2853 write_enn (own_buf
);
2856 handle_v_kill (own_buf
);
2860 if (handle_notif_ack (own_buf
, packet_len
))
2863 /* Otherwise we didn't know what packet it was. Say we didn't
2869 /* Resume thread and wait for another event. In non-stop mode,
2870 don't really wait here, but return immediatelly to the event
2873 myresume (char *own_buf
, int step
, int sig
)
2875 struct thread_resume resume_info
[2];
2877 int valid_cont_thread
;
2879 set_desired_thread (0);
2881 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2882 && !ptid_equal (cont_thread
, minus_one_ptid
));
2884 if (step
|| sig
|| valid_cont_thread
)
2886 resume_info
[0].thread
= current_ptid
;
2888 resume_info
[0].kind
= resume_step
;
2890 resume_info
[0].kind
= resume_continue
;
2891 resume_info
[0].sig
= sig
;
2895 if (!valid_cont_thread
)
2897 resume_info
[n
].thread
= minus_one_ptid
;
2898 resume_info
[n
].kind
= resume_continue
;
2899 resume_info
[n
].sig
= 0;
2903 resume (resume_info
, n
);
2906 /* Callback for for_each_inferior. Make a new stop reply for each
2910 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
2912 struct thread_info
*thread
= (struct thread_info
*) entry
;
2914 /* For now, assume targets that don't have this callback also don't
2915 manage the thread's last_status field. */
2916 if (the_target
->thread_stopped
== NULL
)
2918 struct vstop_notif
*new_notif
= xmalloc (sizeof (*new_notif
));
2920 new_notif
->ptid
= entry
->id
;
2921 new_notif
->status
= thread
->last_status
;
2922 /* Pass the last stop reply back to GDB, but don't notify
2924 notif_event_enque (¬if_stop
,
2925 (struct notif_event
*) new_notif
);
2929 if (thread_stopped (thread
))
2934 = target_waitstatus_to_string (&thread
->last_status
);
2936 debug_printf ("Reporting thread %s as already stopped with %s\n",
2937 target_pid_to_str (entry
->id
),
2940 xfree (status_string
);
2943 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
2945 /* Pass the last stop reply back to GDB, but don't notify
2947 queue_stop_reply (entry
->id
, &thread
->last_status
);
2954 /* Set this inferior threads's state as "want-stopped". We won't
2955 resume this thread until the client gives us another action for
2959 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
2961 struct thread_info
*thread
= (struct thread_info
*) entry
;
2963 thread
->last_resume_kind
= resume_stop
;
2965 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2967 /* Most threads are stopped implicitly (all-stop); tag that with
2969 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
2970 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
2974 /* Set all threads' states as "want-stopped". */
2977 gdb_wants_all_threads_stopped (void)
2979 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
2982 /* Clear the gdb_detached flag of every process. */
2985 gdb_reattached_process (struct inferior_list_entry
*entry
)
2987 struct process_info
*process
= (struct process_info
*) entry
;
2989 process
->gdb_detached
= 0;
2992 /* Callback for for_each_inferior. Clear the thread's pending status
2996 clear_pending_status_callback (struct inferior_list_entry
*entry
)
2998 struct thread_info
*thread
= (struct thread_info
*) entry
;
3000 thread
->status_pending_p
= 0;
3003 /* Callback for for_each_inferior. If the thread is stopped with an
3004 interesting event, mark it as having a pending event. */
3007 set_pending_status_callback (struct inferior_list_entry
*entry
)
3009 struct thread_info
*thread
= (struct thread_info
*) entry
;
3011 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3012 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3013 /* A breakpoint, watchpoint or finished step from a previous
3014 GDB run isn't considered interesting for a new GDB run.
3015 If we left those pending, the new GDB could consider them
3016 random SIGTRAPs. This leaves out real async traps. We'd
3017 have to peek into the (target-specific) siginfo to
3018 distinguish those. */
3019 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3020 thread
->status_pending_p
= 1;
3023 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3024 pending status to report to GDB. */
3027 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3029 struct thread_info
*thread
= (struct thread_info
*) entry
;
3031 return thread
->status_pending_p
;
3034 /* Status handler for the '?' packet. */
3037 handle_status (char *own_buf
)
3039 /* GDB is connected, don't forward events to the target anymore. */
3040 for_each_inferior (&all_processes
, gdb_reattached_process
);
3042 /* In non-stop mode, we must send a stop reply for each stopped
3043 thread. In all-stop mode, just send one for the first stopped
3048 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3050 /* The first is sent immediatly. OK is sent if there is no
3051 stopped thread, which is the same handling of the vStopped
3052 packet (by design). */
3053 notif_write_event (¬if_stop
, own_buf
);
3057 struct inferior_list_entry
*thread
= NULL
;
3060 stabilize_threads ();
3061 gdb_wants_all_threads_stopped ();
3063 /* We can only report one status, but we might be coming out of
3064 non-stop -- if more than one thread is stopped with
3065 interesting events, leave events for the threads we're not
3066 reporting now pending. They'll be reported the next time the
3067 threads are resumed. Start by marking all interesting events
3069 for_each_inferior (&all_threads
, set_pending_status_callback
);
3071 /* Prefer the last thread that reported an event to GDB (even if
3072 that was a GDB_SIGNAL_TRAP). */
3073 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3074 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3075 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3076 thread
= find_inferior_id (&all_threads
, last_ptid
);
3078 /* If the last event thread is not found for some reason, look
3079 for some other thread that might have an event to report. */
3081 thread
= find_inferior (&all_threads
,
3082 find_status_pending_thread_callback
, NULL
);
3084 /* If we're still out of luck, simply pick the first thread in
3087 thread
= get_first_inferior (&all_threads
);
3091 struct thread_info
*tp
= (struct thread_info
*) thread
;
3093 /* We're reporting this event, so it's no longer
3095 tp
->status_pending_p
= 0;
3097 /* GDB assumes the current thread is the thread we're
3098 reporting the status for. */
3099 general_thread
= thread
->id
;
3100 set_desired_thread (1);
3102 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3103 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3106 strcpy (own_buf
, "W00");
3111 gdbserver_version (void)
3113 printf ("GNU gdbserver %s%s\n"
3114 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3115 "gdbserver is free software, covered by the "
3116 "GNU General Public License.\n"
3117 "This gdbserver was configured as \"%s\"\n",
3118 PKGVERSION
, version
, host_name
);
3122 gdbserver_usage (FILE *stream
)
3124 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3125 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3126 "\tgdbserver [OPTIONS] --multi COMM\n"
3128 "COMM may either be a tty device (for serial debugging),\n"
3129 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3130 "stdin/stdout of gdbserver.\n"
3131 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3132 "PID is the process ID to attach to, when --attach is specified.\n"
3134 "Operating modes:\n"
3136 " --attach Attach to running process PID.\n"
3137 " --multi Start server without a specific program, and\n"
3138 " only quit when explicitly commanded.\n"
3139 " --once Exit after the first connection has closed.\n"
3140 " --help Print this message and then exit.\n"
3141 " --version Display version information and exit.\n"
3145 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3146 " --disable-randomization\n"
3147 " Run PROG with address space randomization disabled.\n"
3148 " --no-disable-randomization\n"
3149 " Don't disable address space randomization when\n"
3154 " --debug Enable general debugging output.\n"
3155 " --debug-format=opt1[,opt2,...]\n"
3156 " Specify extra content in debugging output.\n"
3161 " --remote-debug Enable remote protocol debugging output.\n"
3162 " --disable-packet=opt1[,opt2,...]\n"
3163 " Disable support for RSP packets or features.\n"
3165 " vCont, Tthread, qC, qfThreadInfo and \n"
3166 " threads (disable all threading packets).\n"
3168 "For more information, consult the GDB manual (available as on-line \n"
3169 "info or a printed manual).\n");
3170 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3171 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3175 gdbserver_show_disableable (FILE *stream
)
3177 fprintf (stream
, "Disableable packets:\n"
3178 " vCont \tAll vCont packets\n"
3179 " qC \tQuerying the current thread\n"
3180 " qfThreadInfo\tThread listing\n"
3181 " Tthread \tPassing the thread specifier in the "
3182 "T stop reply packet\n"
3183 " threads \tAll of the above\n");
3187 #undef require_running
3188 #define require_running(BUF) \
3189 if (!target_running ()) \
3196 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3198 int pid
= * (int *) args
;
3200 if (ptid_get_pid (entry
->id
) == pid
)
3207 kill_inferior_callback (struct inferior_list_entry
*entry
)
3209 struct process_info
*process
= (struct process_info
*) entry
;
3210 int pid
= ptid_get_pid (process
->entry
.id
);
3212 kill_inferior (pid
);
3213 discard_queued_stop_replies (pid
);
3216 /* Callback for for_each_inferior to detach or kill the inferior,
3217 depending on whether we attached to it or not.
3218 We inform the user whether we're detaching or killing the process
3219 as this is only called when gdbserver is about to exit. */
3222 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3224 struct process_info
*process
= (struct process_info
*) entry
;
3225 int pid
= ptid_get_pid (process
->entry
.id
);
3227 if (process
->attached
)
3228 detach_inferior (pid
);
3230 kill_inferior (pid
);
3232 discard_queued_stop_replies (pid
);
3235 /* for_each_inferior callback for detach_or_kill_for_exit to print
3236 the pids of started inferiors. */
3239 print_started_pid (struct inferior_list_entry
*entry
)
3241 struct process_info
*process
= (struct process_info
*) entry
;
3243 if (! process
->attached
)
3245 int pid
= ptid_get_pid (process
->entry
.id
);
3246 fprintf (stderr
, " %d", pid
);
3250 /* for_each_inferior callback for detach_or_kill_for_exit to print
3251 the pids of attached inferiors. */
3254 print_attached_pid (struct inferior_list_entry
*entry
)
3256 struct process_info
*process
= (struct process_info
*) entry
;
3258 if (process
->attached
)
3260 int pid
= ptid_get_pid (process
->entry
.id
);
3261 fprintf (stderr
, " %d", pid
);
3265 /* Call this when exiting gdbserver with possible inferiors that need
3266 to be killed or detached from. */
3269 detach_or_kill_for_exit (void)
3271 /* First print a list of the inferiors we will be killing/detaching.
3272 This is to assist the user, for example, in case the inferior unexpectedly
3273 dies after we exit: did we screw up or did the inferior exit on its own?
3274 Having this info will save some head-scratching. */
3276 if (have_started_inferiors_p ())
3278 fprintf (stderr
, "Killing process(es):");
3279 for_each_inferior (&all_processes
, print_started_pid
);
3280 fprintf (stderr
, "\n");
3282 if (have_attached_inferiors_p ())
3284 fprintf (stderr
, "Detaching process(es):");
3285 for_each_inferior (&all_processes
, print_attached_pid
);
3286 fprintf (stderr
, "\n");
3289 /* Now we can kill or detach the inferiors. */
3291 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3294 /* Value that will be passed to exit(3) when gdbserver exits. */
3295 static int exit_code
;
3297 /* Cleanup version of detach_or_kill_for_exit. */
3300 detach_or_kill_for_exit_cleanup (void *ignore
)
3305 detach_or_kill_for_exit ();
3308 CATCH (exception
, RETURN_MASK_ALL
)
3311 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3317 /* Main function. This is called by the real "main" function,
3318 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3320 static void ATTRIBUTE_NORETURN
3321 captured_main (int argc
, char *argv
[])
3325 char *arg_end
, *port
;
3326 char **next_arg
= &argv
[1];
3327 volatile int multi_mode
= 0;
3328 volatile int attach
= 0;
3331 while (*next_arg
!= NULL
&& **next_arg
== '-')
3333 if (strcmp (*next_arg
, "--version") == 0)
3335 gdbserver_version ();
3338 else if (strcmp (*next_arg
, "--help") == 0)
3340 gdbserver_usage (stdout
);
3343 else if (strcmp (*next_arg
, "--attach") == 0)
3345 else if (strcmp (*next_arg
, "--multi") == 0)
3347 else if (strcmp (*next_arg
, "--wrapper") == 0)
3351 wrapper_argv
= next_arg
;
3352 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3355 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3357 gdbserver_usage (stderr
);
3361 /* Consume the "--". */
3364 else if (strcmp (*next_arg
, "--debug") == 0)
3366 else if (startswith (*next_arg
, "--debug-format="))
3369 = parse_debug_format_options ((*next_arg
)
3370 + sizeof ("--debug-format=") - 1, 0);
3372 if (error_msg
!= NULL
)
3374 fprintf (stderr
, "%s", error_msg
);
3378 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3380 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3382 gdbserver_show_disableable (stdout
);
3385 else if (startswith (*next_arg
, "--disable-packet="))
3387 char *packets
, *tok
;
3389 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3390 for (tok
= strtok (packets
, ",");
3392 tok
= strtok (NULL
, ","))
3394 if (strcmp ("vCont", tok
) == 0)
3395 disable_packet_vCont
= 1;
3396 else if (strcmp ("Tthread", tok
) == 0)
3397 disable_packet_Tthread
= 1;
3398 else if (strcmp ("qC", tok
) == 0)
3399 disable_packet_qC
= 1;
3400 else if (strcmp ("qfThreadInfo", tok
) == 0)
3401 disable_packet_qfThreadInfo
= 1;
3402 else if (strcmp ("threads", tok
) == 0)
3404 disable_packet_vCont
= 1;
3405 disable_packet_Tthread
= 1;
3406 disable_packet_qC
= 1;
3407 disable_packet_qfThreadInfo
= 1;
3411 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3413 gdbserver_show_disableable (stderr
);
3418 else if (strcmp (*next_arg
, "-") == 0)
3420 /* "-" specifies a stdio connection and is a form of port
3422 *next_arg
= STDIO_CONNECTION_NAME
;
3425 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3426 disable_randomization
= 1;
3427 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3428 disable_randomization
= 0;
3429 else if (strcmp (*next_arg
, "--once") == 0)
3433 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3443 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3445 gdbserver_usage (stderr
);
3449 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3450 opened by remote_prepare. */
3453 /* We need to know whether the remote connection is stdio before
3454 starting the inferior. Inferiors created in this scenario have
3455 stdin,stdout redirected. So do this here before we call
3457 remote_prepare (port
);
3462 /* --attach used to come after PORT, so allow it there for
3464 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3471 && (*next_arg
== NULL
3472 || (*next_arg
)[0] == '\0'
3473 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3475 || next_arg
[1] != NULL
))
3480 gdbserver_usage (stderr
);
3484 initialize_async_io ();
3486 initialize_event_loop ();
3487 if (target_supports_tracepoints ())
3488 initialize_tracepoint ();
3490 own_buf
= xmalloc (PBUFSIZ
+ 1);
3491 mem_buf
= xmalloc (PBUFSIZ
);
3493 if (pid
== 0 && *next_arg
!= NULL
)
3497 n
= argc
- (next_arg
- argv
);
3498 program_argv
= xmalloc (sizeof (char *) * (n
+ 1));
3499 for (i
= 0; i
< n
; i
++)
3500 program_argv
[i
] = xstrdup (next_arg
[i
]);
3501 program_argv
[i
] = NULL
;
3503 /* Wait till we are at first instruction in program. */
3504 start_inferior (program_argv
);
3506 /* We are now (hopefully) stopped at the first instruction of
3507 the target process. This assumes that the target process was
3508 successfully created. */
3512 if (attach_inferior (pid
) == -1)
3513 error ("Attaching not supported on this target");
3515 /* Otherwise succeeded. */
3519 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3520 last_status
.value
.integer
= 0;
3521 last_ptid
= minus_one_ptid
;
3523 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3525 initialize_notif ();
3527 /* Don't report shared library events on the initial connection,
3528 even if some libraries are preloaded. Avoids the "stopped by
3529 shared library event" notice on gdb side. */
3532 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3533 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3538 if (!was_running
&& !multi_mode
)
3539 error ("No program to debug");
3546 report_fork_events
= 0;
3547 report_vfork_events
= 0;
3548 /* Be sure we're out of tfind mode. */
3549 current_traceframe
= -1;
3550 cont_thread
= null_ptid
;
3551 swbreak_feature
= 0;
3552 hwbreak_feature
= 0;
3558 /* Wait for events. This will return when all event sources
3559 are removed from the event loop. */
3560 start_event_loop ();
3562 /* If an exit was requested (using the "monitor exit"
3563 command), terminate now. The only other way to get
3564 here is for getpkt to fail; close the connection
3565 and reopen it at the top of the loop. */
3567 if (exit_requested
|| run_once
)
3568 throw_quit ("Quit");
3571 "Remote side has terminated connection. "
3572 "GDBserver will reopen the connection.\n");
3574 /* Get rid of any pending statuses. An eventual reconnection
3575 (by the same GDB instance or another) will refresh all its
3576 state from scratch. */
3577 discard_queued_stop_replies (-1);
3578 for_each_inferior (&all_threads
,
3579 clear_pending_status_callback
);
3583 if (disconnected_tracing
)
3585 /* Try to enable non-stop/async mode, so we we can
3586 both wait for an async socket accept, and handle
3587 async target events simultaneously. There's also
3588 no point either in having the target always stop
3589 all threads, when we're going to pass signals
3590 down without informing GDB. */
3593 if (start_non_stop (1))
3596 /* Detaching implicitly resumes all threads;
3597 simply disconnecting does not. */
3603 "Disconnected tracing disabled; "
3604 "stopping trace run.\n");
3609 CATCH (exception
, RETURN_MASK_ERROR
)
3611 if (response_needed
)
3613 write_enn (own_buf
);
3621 /* Main function. */
3624 main (int argc
, char *argv
[])
3629 captured_main (argc
, argv
);
3631 CATCH (exception
, RETURN_MASK_ALL
)
3633 if (exception
.reason
== RETURN_ERROR
)
3636 fprintf (stderr
, "%s\n", exception
.message
);
3637 fprintf (stderr
, "Exiting\n");
3645 gdb_assert_not_reached ("captured_main should never return");
3648 /* Skip PACKET until the next semi-colon (or end of string). */
3651 skip_to_semicolon (char **packet
)
3653 while (**packet
!= '\0' && **packet
!= ';')
3657 /* Process options coming from Z packets for a breakpoint. PACKET is
3658 the packet buffer. *PACKET is updated to point to the first char
3659 after the last processed option. */
3662 process_point_options (struct breakpoint
*bp
, char **packet
)
3664 char *dataptr
= *packet
;
3667 /* Check if data has the correct format. */
3668 if (*dataptr
!= ';')
3675 if (*dataptr
== ';')
3678 if (*dataptr
== 'X')
3680 /* Conditional expression. */
3682 debug_printf ("Found breakpoint condition.\n");
3683 if (!add_breakpoint_condition (bp
, &dataptr
))
3684 skip_to_semicolon (&dataptr
);
3686 else if (startswith (dataptr
, "cmds:"))
3688 dataptr
+= strlen ("cmds:");
3690 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3691 persist
= (*dataptr
== '1');
3693 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3694 skip_to_semicolon (&dataptr
);
3698 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3700 /* Skip tokens until we find one that we recognize. */
3701 skip_to_semicolon (&dataptr
);
3707 /* Event loop callback that handles a serial event. The first byte in
3708 the serial buffer gets us here. We expect characters to arrive at
3709 a brisk pace, so we read the rest of the packet with a blocking
3713 process_serial_event (void)
3724 int new_packet_len
= -1;
3726 /* Used to decide when gdbserver should exit in
3727 multi-mode/remote. */
3728 static int have_ran
= 0;
3731 have_ran
= target_running ();
3733 disable_async_io ();
3735 response_needed
= 0;
3736 packet_len
= getpkt (own_buf
);
3737 if (packet_len
<= 0)
3740 /* Force an event loop break. */
3743 response_needed
= 1;
3750 handle_query (own_buf
, packet_len
, &new_packet_len
);
3753 handle_general_set (own_buf
);
3756 require_running (own_buf
);
3761 pid
= strtol (&own_buf
[i
], NULL
, 16);
3764 pid
= ptid_get_pid (current_ptid
);
3766 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3768 struct thread_resume resume_info
;
3769 struct process_info
*process
= find_process_pid (pid
);
3771 if (process
== NULL
)
3773 write_enn (own_buf
);
3777 if (tracing
&& disconnected_tracing
)
3779 "Disconnected tracing in effect, "
3780 "leaving gdbserver attached to the process\n");
3782 if (any_persistent_commands ())
3784 "Persistent commands are present, "
3785 "leaving gdbserver attached to the process\n");
3787 /* Make sure we're in non-stop/async mode, so we we can both
3788 wait for an async socket accept, and handle async target
3789 events simultaneously. There's also no point either in
3790 having the target stop all threads, when we're going to
3791 pass signals down without informing GDB. */
3795 debug_printf ("Forcing non-stop mode\n");
3801 process
->gdb_detached
= 1;
3803 /* Detaching implicitly resumes all threads. */
3804 resume_info
.thread
= minus_one_ptid
;
3805 resume_info
.kind
= resume_continue
;
3806 resume_info
.sig
= 0;
3807 (*the_target
->resume
) (&resume_info
, 1);
3810 break; /* from switch/case */
3813 fprintf (stderr
, "Detaching from process %d\n", pid
);
3815 if (detach_inferior (pid
) != 0)
3816 write_enn (own_buf
);
3819 discard_queued_stop_replies (pid
);
3822 if (extended_protocol
)
3824 /* Treat this like a normal program exit. */
3825 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3826 last_status
.value
.integer
= 0;
3827 last_ptid
= pid_to_ptid (pid
);
3829 current_thread
= NULL
;
3836 /* If we are attached, then we can exit. Otherwise, we
3837 need to hang around doing nothing, until the child is
3839 join_inferior (pid
);
3845 extended_protocol
= 1;
3849 handle_status (own_buf
);
3852 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3854 ptid_t gdb_id
, thread_id
;
3857 require_running (own_buf
);
3859 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3861 pid
= ptid_get_pid (gdb_id
);
3863 if (ptid_equal (gdb_id
, null_ptid
)
3864 || ptid_equal (gdb_id
, minus_one_ptid
))
3865 thread_id
= null_ptid
;
3867 && ptid_equal (pid_to_ptid (pid
),
3870 struct thread_info
*thread
=
3871 (struct thread_info
*) find_inferior (&all_threads
,
3876 write_enn (own_buf
);
3880 thread_id
= thread
->entry
.id
;
3884 thread_id
= gdb_id_to_thread_id (gdb_id
);
3885 if (ptid_equal (thread_id
, null_ptid
))
3887 write_enn (own_buf
);
3892 if (own_buf
[1] == 'g')
3894 if (ptid_equal (thread_id
, null_ptid
))
3896 /* GDB is telling us to choose any thread. Check if
3897 the currently selected thread is still valid. If
3898 it is not, select the first available. */
3899 struct thread_info
*thread
=
3900 (struct thread_info
*) find_inferior_id (&all_threads
,
3904 thread
= get_first_thread ();
3905 thread_id
= thread
->entry
.id
;
3909 general_thread
= thread_id
;
3910 set_desired_thread (1);
3912 else if (own_buf
[1] == 'c')
3913 cont_thread
= thread_id
;
3919 /* Silently ignore it so that gdb can extend the protocol
3920 without compatibility headaches. */
3925 require_running (own_buf
);
3926 if (current_traceframe
>= 0)
3928 struct regcache
*regcache
3929 = new_register_cache (current_target_desc ());
3931 if (fetch_traceframe_registers (current_traceframe
,
3933 registers_to_string (regcache
, own_buf
);
3935 write_enn (own_buf
);
3936 free_register_cache (regcache
);
3940 struct regcache
*regcache
;
3942 set_desired_thread (1);
3943 regcache
= get_thread_regcache (current_thread
, 1);
3944 registers_to_string (regcache
, own_buf
);
3948 require_running (own_buf
);
3949 if (current_traceframe
>= 0)
3950 write_enn (own_buf
);
3953 struct regcache
*regcache
;
3955 set_desired_thread (1);
3956 regcache
= get_thread_regcache (current_thread
, 1);
3957 registers_from_string (regcache
, &own_buf
[1]);
3962 require_running (own_buf
);
3963 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
3964 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
3966 write_enn (own_buf
);
3968 bin2hex (mem_buf
, own_buf
, res
);
3971 require_running (own_buf
);
3972 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
3973 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
3976 write_enn (own_buf
);
3979 require_running (own_buf
);
3980 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
3981 &mem_addr
, &len
, &mem_buf
) < 0
3982 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
3983 write_enn (own_buf
);
3988 require_running (own_buf
);
3989 hex2bin (own_buf
+ 1, &sig
, 1);
3990 if (gdb_signal_to_host_p (sig
))
3991 signal
= gdb_signal_to_host (sig
);
3994 myresume (own_buf
, 0, signal
);
3997 require_running (own_buf
);
3998 hex2bin (own_buf
+ 1, &sig
, 1);
3999 if (gdb_signal_to_host_p (sig
))
4000 signal
= gdb_signal_to_host (sig
);
4003 myresume (own_buf
, 1, signal
);
4006 require_running (own_buf
);
4008 myresume (own_buf
, 0, signal
);
4011 require_running (own_buf
);
4013 myresume (own_buf
, 1, signal
);
4015 case 'Z': /* insert_ ... */
4017 case 'z': /* remove_ ... */
4022 char type
= own_buf
[1];
4024 const int insert
= ch
== 'Z';
4025 char *p
= &own_buf
[3];
4027 p
= unpack_varlen_hex (p
, &addr
);
4028 len
= strtol (p
+ 1, &dataptr
, 16);
4032 struct breakpoint
*bp
;
4034 bp
= set_gdb_breakpoint (type
, addr
, len
, &res
);
4039 /* GDB may have sent us a list of *point parameters to
4040 be evaluated on the target's side. Read such list
4041 here. If we already have a list of parameters, GDB
4042 is telling us to drop that list and use this one
4044 clear_breakpoint_conditions_and_commands (bp
);
4045 process_point_options (bp
, &dataptr
);
4049 res
= delete_gdb_breakpoint (type
, addr
, len
);
4057 write_enn (own_buf
);
4061 response_needed
= 0;
4062 if (!target_running ())
4063 /* The packet we received doesn't make sense - but we can't
4064 reply to it, either. */
4067 fprintf (stderr
, "Killing all inferiors\n");
4068 for_each_inferior (&all_processes
, kill_inferior_callback
);
4070 /* When using the extended protocol, we wait with no program
4071 running. The traditional protocol will exit instead. */
4072 if (extended_protocol
)
4074 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4075 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4083 ptid_t gdb_id
, thread_id
;
4085 require_running (own_buf
);
4087 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4088 thread_id
= gdb_id_to_thread_id (gdb_id
);
4089 if (ptid_equal (thread_id
, null_ptid
))
4091 write_enn (own_buf
);
4095 if (mythread_alive (thread_id
))
4098 write_enn (own_buf
);
4102 response_needed
= 0;
4104 /* Restarting the inferior is only supported in the extended
4106 if (extended_protocol
)
4108 if (target_running ())
4109 for_each_inferior (&all_processes
,
4110 kill_inferior_callback
);
4111 fprintf (stderr
, "GDBserver restarting\n");
4113 /* Wait till we are at 1st instruction in prog. */
4114 if (program_argv
!= NULL
)
4115 start_inferior (program_argv
);
4118 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4119 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4125 /* It is a request we don't understand. Respond with an
4126 empty packet so that gdb knows that we don't support this
4132 /* Extended (long) request. */
4133 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4137 /* It is a request we don't understand. Respond with an empty
4138 packet so that gdb knows that we don't support this
4144 if (new_packet_len
!= -1)
4145 putpkt_binary (own_buf
, new_packet_len
);
4149 response_needed
= 0;
4151 if (!extended_protocol
&& have_ran
&& !target_running ())
4153 /* In non-stop, defer exiting until GDB had a chance to query
4154 the whole vStopped list (until it gets an OK). */
4155 if (QUEUE_is_empty (notif_event_p
, notif_stop
.queue
))
4157 /* Be transparent when GDB is connected through stdio -- no
4158 need to spam GDB's console. */
4159 if (!remote_connection_is_stdio ())
4160 fprintf (stderr
, "GDBserver exiting\n");
4172 /* Event-loop callback for serial events. */
4175 handle_serial_event (int err
, gdb_client_data client_data
)
4178 debug_printf ("handling possible serial event\n");
4180 /* Really handle it. */
4181 if (process_serial_event () < 0)
4184 /* Be sure to not change the selected thread behind GDB's back.
4185 Important in the non-stop mode asynchronous protocol. */
4186 set_desired_thread (1);
4191 /* Event-loop callback for target events. */
4194 handle_target_event (int err
, gdb_client_data client_data
)
4197 debug_printf ("handling possible target event\n");
4199 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4202 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4204 /* No RSP support for this yet. */
4206 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4208 int pid
= ptid_get_pid (last_ptid
);
4209 struct process_info
*process
= find_process_pid (pid
);
4210 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4212 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4213 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4215 mark_breakpoints_out (process
);
4216 mourn_inferior (process
);
4220 /* We're reporting this thread as stopped. Update its
4221 "want-stopped" state to what the client wants, until it
4222 gets a new resume action. */
4223 current_thread
->last_resume_kind
= resume_stop
;
4224 current_thread
->last_status
= last_status
;
4229 if (!target_running ())
4231 /* The last process exited. We're done. */
4235 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4237 /* A thread stopped with a signal, but gdb isn't
4238 connected to handle it. Pass it down to the
4239 inferior, as if it wasn't being traced. */
4240 struct thread_resume resume_info
;
4243 debug_printf ("GDB not connected; forwarding event %d for"
4245 (int) last_status
.kind
,
4246 target_pid_to_str (last_ptid
));
4248 resume_info
.thread
= last_ptid
;
4249 resume_info
.kind
= resume_continue
;
4250 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4251 (*the_target
->resume
) (&resume_info
, 1);
4253 else if (debug_threads
)
4254 debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
4255 (int) last_status
.kind
,
4256 target_pid_to_str (last_ptid
));
4260 struct vstop_notif
*vstop_notif
4261 = xmalloc (sizeof (struct vstop_notif
));
4263 vstop_notif
->status
= last_status
;
4264 vstop_notif
->ptid
= last_ptid
;
4265 /* Push Stop notification. */
4266 notif_push (¬if_stop
,
4267 (struct notif_event
*) vstop_notif
);
4271 /* Be sure to not change the selected thread behind GDB's back.
4272 Important in the non-stop mode asynchronous protocol. */
4273 set_desired_thread (1);