1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 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"
25 #include "signals-state-save-restore.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
;
62 int report_exec_events
;
63 int report_thread_events
;
65 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
66 static int report_no_resumed
;
72 /* True if the "vContSupported" feature is active. In that case, GDB
73 wants us to report whether single step is supported in the reply to
75 static int vCont_supported
;
77 /* Whether we should attempt to disable the operating system's address
78 space randomization feature before starting an inferior. */
79 int disable_randomization
= 1;
81 static char **program_argv
, **wrapper_argv
;
83 int pass_signals
[GDB_SIGNAL_LAST
];
84 int program_signals
[GDB_SIGNAL_LAST
];
85 int program_signals_p
;
87 /* The PID of the originally created or attached inferior. Used to
88 send signals to the process when GDB sends us an asynchronous interrupt
89 (user hitting Control-C in the client), and to wait for the child to exit
90 when no longer debugging it. */
92 unsigned long signal_pid
;
95 /* A file descriptor for the controlling terminal. */
98 /* TERMINAL_FD's original foreground group. */
99 pid_t old_foreground_pgrp
;
101 /* Hand back terminal ownership to the original foreground group. */
104 restore_old_foreground_pgrp (void)
106 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
110 /* Set if you want to disable optional thread related packets support
111 in gdbserver, for the sake of testing GDB against stubs that don't
113 int disable_packet_vCont
;
114 int disable_packet_Tthread
;
115 int disable_packet_qC
;
116 int disable_packet_qfThreadInfo
;
118 /* Last status reported to GDB. */
119 static struct target_waitstatus last_status
;
120 static ptid_t last_ptid
;
123 static unsigned char *mem_buf
;
125 /* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
131 struct notif_event base
;
133 /* Thread or process that got the event. */
137 struct target_waitstatus status
;
140 /* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142 static struct btrace_config current_btrace_conf
;
144 DEFINE_QUEUE_P (notif_event_p
);
146 /* Put a stop reply to the stop reply queue. */
149 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
151 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
153 new_notif
->ptid
= ptid
;
154 new_notif
->status
= *status
;
156 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
160 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
161 QUEUE_ITER (notif_event_p
) *iter
,
162 struct notif_event
*event
,
165 ptid_t filter_ptid
= *(ptid_t
*) data
;
166 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
168 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
170 if (q
->free_func
!= NULL
)
171 q
->free_func (event
);
173 QUEUE_remove_elem (notif_event_p
, q
, iter
);
182 discard_queued_stop_replies (ptid_t ptid
)
184 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
185 remove_all_on_match_ptid
, &ptid
);
189 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
191 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
193 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
196 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
199 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
200 QUEUE_ITER (notif_event_p
) *iter
,
201 struct notif_event
*event
,
204 ptid_t filter_ptid
= *(ptid_t
*) data
;
205 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
207 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
210 /* Don't resume fork children that GDB does not know about yet. */
211 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
212 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
213 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
222 in_queued_stop_replies (ptid_t ptid
)
224 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
225 in_queued_stop_replies_ptid
, &ptid
);
228 struct notif_server notif_stop
=
230 "vStopped", "Stop", NULL
, vstop_notif_reply
,
234 target_running (void)
236 return get_first_thread () != NULL
;
240 start_inferior (char **argv
)
242 char **new_argv
= argv
;
244 if (wrapper_argv
!= NULL
)
248 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
250 for (i
= 0; argv
[i
] != NULL
; i
++)
252 new_argv
= XALLOCAVEC (char *, count
);
254 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
255 new_argv
[count
++] = wrapper_argv
[i
];
256 for (i
= 0; argv
[i
] != NULL
; i
++)
257 new_argv
[count
++] = argv
[i
];
258 new_argv
[count
] = NULL
;
264 for (i
= 0; new_argv
[i
]; ++i
)
265 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
270 signal (SIGTTOU
, SIG_DFL
);
271 signal (SIGTTIN
, SIG_DFL
);
274 signal_pid
= create_inferior (new_argv
[0], new_argv
);
276 /* FIXME: we don't actually know at this point that the create
277 actually succeeded. We won't know that until we wait. */
278 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
283 signal (SIGTTOU
, SIG_IGN
);
284 signal (SIGTTIN
, SIG_IGN
);
285 terminal_fd
= fileno (stderr
);
286 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
287 tcsetpgrp (terminal_fd
, signal_pid
);
288 atexit (restore_old_foreground_pgrp
);
291 if (wrapper_argv
!= NULL
)
293 ptid_t ptid
= pid_to_ptid (signal_pid
);
295 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
297 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
301 target_continue_no_signal (ptid
);
303 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
304 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
307 current_thread
->last_resume_kind
= resume_stop
;
308 current_thread
->last_status
= last_status
;
310 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
312 target_post_create_inferior ();
316 /* Wait till we are at 1st instruction in program, return new pid
317 (assuming success). */
318 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
320 /* At this point, the target process, if it exits, is stopped. Do not call
321 the function target_post_create_inferior if the process has already
322 exited, as the target implementation of the routine may rely on the
323 process being live. */
324 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
325 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
327 target_post_create_inferior ();
328 current_thread
->last_resume_kind
= resume_stop
;
329 current_thread
->last_status
= last_status
;
332 target_mourn_inferior (last_ptid
);
338 attach_inferior (int pid
)
340 /* myattach should return -1 if attaching is unsupported,
341 0 if it succeeded, and call error() otherwise. */
343 if (myattach (pid
) != 0)
346 fprintf (stderr
, "Attached; pid = %d\n", pid
);
349 /* FIXME - It may be that we should get the SIGNAL_PID from the
350 attach function, so that it can be the main thread instead of
351 whichever we were told to attach to. */
356 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
358 /* GDB knows to ignore the first SIGSTOP after attaching to a running
359 process using the "attach" command, but this is different; it's
360 just using "target remote". Pretend it's just starting up. */
361 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
362 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
363 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
365 current_thread
->last_resume_kind
= resume_stop
;
366 current_thread
->last_status
= last_status
;
372 extern int remote_debug
;
374 /* Decode a qXfer read request. Return 0 if everything looks OK,
378 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
380 /* After the read marker and annex, qXfer looks like a
381 traditional 'm' packet. */
382 decode_m_packet (buf
, ofs
, len
);
388 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
390 /* Extract and NUL-terminate the object. */
392 while (*buf
&& *buf
!= ':')
398 /* Extract and NUL-terminate the read/write action. */
400 while (*buf
&& *buf
!= ':')
406 /* Extract and NUL-terminate the annex. */
408 while (*buf
&& *buf
!= ':')
418 /* Write the response to a successful qXfer read. Returns the
419 length of the (binary) data stored in BUF, corresponding
420 to as much of DATA/LEN as we could fit. IS_MORE controls
421 the first character of the response. */
423 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
432 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
433 &out_len
, PBUFSIZ
- 2) + 1;
436 /* Handle btrace enabling in BTS format. */
439 handle_btrace_enable_bts (struct thread_info
*thread
)
441 if (thread
->btrace
!= NULL
)
442 return "E.Btrace already enabled.";
444 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
445 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
446 ¤t_btrace_conf
);
447 if (thread
->btrace
== NULL
)
448 return "E.Could not enable btrace.";
453 /* Handle btrace enabling in Intel Processor Trace format. */
456 handle_btrace_enable_pt (struct thread_info
*thread
)
458 if (thread
->btrace
!= NULL
)
459 return "E.Btrace already enabled.";
461 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
462 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
463 ¤t_btrace_conf
);
464 if (thread
->btrace
== NULL
)
465 return "E.Could not enable btrace.";
470 /* Handle btrace disabling. */
473 handle_btrace_disable (struct thread_info
*thread
)
476 if (thread
->btrace
== NULL
)
477 return "E.Branch tracing not enabled.";
479 if (target_disable_btrace (thread
->btrace
) != 0)
480 return "E.Could not disable branch tracing.";
482 thread
->btrace
= NULL
;
486 /* Handle the "Qbtrace" packet. */
489 handle_btrace_general_set (char *own_buf
)
491 struct thread_info
*thread
;
495 if (!startswith (own_buf
, "Qbtrace:"))
498 op
= own_buf
+ strlen ("Qbtrace:");
500 if (ptid_equal (general_thread
, null_ptid
)
501 || ptid_equal (general_thread
, minus_one_ptid
))
503 strcpy (own_buf
, "E.Must select a single thread.");
507 thread
= find_thread_ptid (general_thread
);
510 strcpy (own_buf
, "E.No such thread.");
516 if (strcmp (op
, "bts") == 0)
517 err
= handle_btrace_enable_bts (thread
);
518 else if (strcmp (op
, "pt") == 0)
519 err
= handle_btrace_enable_pt (thread
);
520 else if (strcmp (op
, "off") == 0)
521 err
= handle_btrace_disable (thread
);
523 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
526 strcpy (own_buf
, err
);
533 /* Handle the "Qbtrace-conf" packet. */
536 handle_btrace_conf_general_set (char *own_buf
)
538 struct thread_info
*thread
;
541 if (!startswith (own_buf
, "Qbtrace-conf:"))
544 op
= own_buf
+ strlen ("Qbtrace-conf:");
546 if (ptid_equal (general_thread
, null_ptid
)
547 || ptid_equal (general_thread
, minus_one_ptid
))
549 strcpy (own_buf
, "E.Must select a single thread.");
553 thread
= find_thread_ptid (general_thread
);
556 strcpy (own_buf
, "E.No such thread.");
560 if (startswith (op
, "bts:size="))
566 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
567 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
569 strcpy (own_buf
, "E.Bad size value.");
573 current_btrace_conf
.bts
.size
= (unsigned int) size
;
575 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
581 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
582 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
584 strcpy (own_buf
, "E.Bad size value.");
588 current_btrace_conf
.pt
.size
= (unsigned int) size
;
592 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
600 /* Handle all of the extended 'Q' packets. */
603 handle_general_set (char *own_buf
)
605 if (startswith (own_buf
, "QPassSignals:"))
607 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
608 const char *p
= own_buf
+ strlen ("QPassSignals:");
611 p
= decode_address_to_semicolon (&cursig
, p
);
612 for (i
= 0; i
< numsigs
; i
++)
618 /* Keep looping, to clear the remaining signals. */
621 p
= decode_address_to_semicolon (&cursig
, p
);
626 strcpy (own_buf
, "OK");
630 if (startswith (own_buf
, "QProgramSignals:"))
632 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
633 const char *p
= own_buf
+ strlen ("QProgramSignals:");
636 program_signals_p
= 1;
638 p
= decode_address_to_semicolon (&cursig
, p
);
639 for (i
= 0; i
< numsigs
; i
++)
643 program_signals
[i
] = 1;
645 /* Keep looping, to clear the remaining signals. */
648 p
= decode_address_to_semicolon (&cursig
, p
);
651 program_signals
[i
] = 0;
653 strcpy (own_buf
, "OK");
657 if (startswith (own_buf
, "QCatchSyscalls:"))
659 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
662 struct process_info
*process
;
664 if (!target_running () || !target_supports_catch_syscall ())
670 if (strcmp (p
, "0") == 0)
672 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
676 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
682 process
= current_process ();
683 VEC_truncate (int, process
->syscalls_to_catch
, 0);
693 p
= decode_address_to_semicolon (&sysno
, p
);
694 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
698 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
705 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
709 debug_printf ("[noack mode enabled]\n");
718 if (startswith (own_buf
, "QNonStop:"))
720 char *mode
= own_buf
+ 9;
724 if (strcmp (mode
, "0") == 0)
726 else if (strcmp (mode
, "1") == 0)
730 /* We don't know what this mode is, so complain to
732 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
738 req_str
= req
? "non-stop" : "all-stop";
739 if (start_non_stop (req
) != 0)
741 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
749 debug_printf ("[%s mode enabled]\n", req_str
);
755 if (startswith (own_buf
, "QDisableRandomization:"))
757 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
760 unpack_varlen_hex (packet
, &setting
);
761 disable_randomization
= setting
;
765 debug_printf (disable_randomization
766 ? "[address space randomization disabled]\n"
767 : "[address space randomization enabled]\n");
774 if (target_supports_tracepoints ()
775 && handle_tracepoint_general_set (own_buf
))
778 if (startswith (own_buf
, "QAgent:"))
780 char *mode
= own_buf
+ strlen ("QAgent:");
783 if (strcmp (mode
, "0") == 0)
785 else if (strcmp (mode
, "1") == 0)
789 /* We don't know what this value is, so complain to GDB. */
790 sprintf (own_buf
, "E.Unknown QAgent value");
794 /* Update the flag. */
797 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
802 if (handle_btrace_general_set (own_buf
))
805 if (handle_btrace_conf_general_set (own_buf
))
808 if (startswith (own_buf
, "QThreadEvents:"))
810 char *mode
= own_buf
+ strlen ("QThreadEvents:");
811 enum tribool req
= TRIBOOL_UNKNOWN
;
813 if (strcmp (mode
, "0") == 0)
815 else if (strcmp (mode
, "1") == 0)
819 char *mode_copy
= xstrdup (mode
);
821 /* We don't know what this mode is, so complain to GDB. */
822 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
828 report_thread_events
= (req
== TRIBOOL_TRUE
);
832 const char *req_str
= report_thread_events
? "enabled" : "disabled";
834 debug_printf ("[thread events are now %s]\n", req_str
);
841 /* Otherwise we didn't know what packet it was. Say we didn't
847 get_features_xml (const char *annex
)
849 const struct target_desc
*desc
= current_target_desc ();
851 /* `desc->xmltarget' defines what to return when looking for the
852 "target.xml" file. Its contents can either be verbatim XML code
853 (prefixed with a '@') or else the name of the actual XML file to
854 be used in place of "target.xml".
856 This variable is set up from the auto-generated
857 init_registers_... routine for the current target. */
859 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
861 if (*desc
->xmltarget
== '@')
862 return desc
->xmltarget
+ 1;
864 annex
= desc
->xmltarget
;
869 extern const char *const xml_builtin
[][2];
872 /* Look for the annex. */
873 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
874 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
877 if (xml_builtin
[i
][0] != NULL
)
878 return xml_builtin
[i
][1];
886 monitor_show_help (void)
888 monitor_output ("The following monitor commands are supported:\n");
889 monitor_output (" set debug <0|1>\n");
890 monitor_output (" Enable general debugging messages\n");
891 monitor_output (" set debug-hw-points <0|1>\n");
892 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
893 monitor_output (" set remote-debug <0|1>\n");
894 monitor_output (" Enable remote protocol debugging messages\n");
895 monitor_output (" set debug-format option1[,option2,...]\n");
896 monitor_output (" Add additional information to debugging messages\n");
897 monitor_output (" Options: all, none");
898 monitor_output (", timestamp");
899 monitor_output ("\n");
900 monitor_output (" exit\n");
901 monitor_output (" Quit GDBserver\n");
904 /* Read trace frame or inferior memory. Returns the number of bytes
905 actually read, zero when no further transfer is possible, and -1 on
906 error. Return of a positive value smaller than LEN does not
907 indicate there's no more to be read, only the end of the transfer.
908 E.g., when GDB reads memory from a traceframe, a first request may
909 be served from a memory block that does not cover the whole request
910 length. A following request gets the rest served from either
911 another block (of the same traceframe) or from the read-only
915 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
919 if (current_traceframe
>= 0)
922 ULONGEST length
= len
;
924 if (traceframe_read_mem (current_traceframe
,
925 memaddr
, myaddr
, len
, &nbytes
))
927 /* Data read from trace buffer, we're done. */
930 if (!in_readonly_region (memaddr
, length
))
932 /* Otherwise we have a valid readonly case, fall through. */
933 /* (assume no half-trace half-real blocks for now) */
936 res
= prepare_to_access_memory ();
939 if (set_desired_thread (1))
940 res
= read_inferior_memory (memaddr
, myaddr
, len
);
943 done_accessing_memory ();
945 return res
== 0 ? len
: -1;
951 /* Write trace frame or inferior memory. Actually, writing to trace
952 frames is forbidden. */
955 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
957 if (current_traceframe
>= 0)
963 ret
= prepare_to_access_memory ();
966 if (set_desired_thread (1))
967 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
970 done_accessing_memory ();
976 /* Subroutine of handle_search_memory to simplify it. */
979 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
980 gdb_byte
*pattern
, unsigned pattern_len
,
981 gdb_byte
*search_buf
,
982 unsigned chunk_size
, unsigned search_buf_size
,
983 CORE_ADDR
*found_addrp
)
985 /* Prime the search buffer. */
987 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
990 warning ("Unable to access %ld bytes of target "
991 "memory at 0x%lx, halting search.",
992 (long) search_buf_size
, (long) start_addr
);
996 /* Perform the search.
998 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
999 When we've scanned N bytes we copy the trailing bytes to the start and
1000 read in another N bytes. */
1002 while (search_space_len
>= pattern_len
)
1004 gdb_byte
*found_ptr
;
1005 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1009 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1012 if (found_ptr
!= NULL
)
1014 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1015 *found_addrp
= found_addr
;
1019 /* Not found in this chunk, skip to next chunk. */
1021 /* Don't let search_space_len wrap here, it's unsigned. */
1022 if (search_space_len
>= chunk_size
)
1023 search_space_len
-= chunk_size
;
1025 search_space_len
= 0;
1027 if (search_space_len
>= pattern_len
)
1029 unsigned keep_len
= search_buf_size
- chunk_size
;
1030 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1033 /* Copy the trailing part of the previous iteration to the front
1034 of the buffer for the next iteration. */
1035 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1037 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1038 ? search_space_len
- keep_len
1041 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1042 nr_to_read
) != search_buf_size
)
1044 warning ("Unable to access %ld bytes of target memory "
1045 "at 0x%lx, halting search.",
1046 (long) nr_to_read
, (long) read_addr
);
1050 start_addr
+= chunk_size
;
1059 /* Handle qSearch:memory packets. */
1062 handle_search_memory (char *own_buf
, int packet_len
)
1064 CORE_ADDR start_addr
;
1065 CORE_ADDR search_space_len
;
1067 unsigned int pattern_len
;
1068 /* NOTE: also defined in find.c testcase. */
1069 #define SEARCH_CHUNK_SIZE 16000
1070 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1071 /* Buffer to hold memory contents for searching. */
1072 gdb_byte
*search_buf
;
1073 unsigned search_buf_size
;
1075 CORE_ADDR found_addr
;
1076 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1078 pattern
= (gdb_byte
*) malloc (packet_len
);
1079 if (pattern
== NULL
)
1081 error ("Unable to allocate memory to perform the search");
1082 strcpy (own_buf
, "E00");
1085 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1086 packet_len
- cmd_name_len
,
1087 &start_addr
, &search_space_len
,
1088 pattern
, &pattern_len
) < 0)
1091 error ("Error in parsing qSearch:memory packet");
1092 strcpy (own_buf
, "E00");
1096 search_buf_size
= chunk_size
+ pattern_len
- 1;
1098 /* No point in trying to allocate a buffer larger than the search space. */
1099 if (search_space_len
< search_buf_size
)
1100 search_buf_size
= search_space_len
;
1102 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1103 if (search_buf
== NULL
)
1106 error ("Unable to allocate memory to perform the search");
1107 strcpy (own_buf
, "E00");
1111 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1112 pattern
, pattern_len
,
1113 search_buf
, chunk_size
, search_buf_size
,
1117 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1118 else if (found
== 0)
1119 strcpy (own_buf
, "0");
1121 strcpy (own_buf
, "E00");
1127 #define require_running(BUF) \
1128 if (!target_running ()) \
1134 /* Parse options to --debug-format= and "monitor set debug-format".
1135 ARG is the text after "--debug-format=" or "monitor set debug-format".
1136 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1137 This triggers calls to monitor_output.
1138 The result is NULL if all options were parsed ok, otherwise an error
1139 message which the caller must free.
1141 N.B. These commands affect all debug format settings, they are not
1142 cumulative. If a format is not specified, it is turned off.
1143 However, we don't go to extra trouble with things like
1144 "monitor set debug-format all,none,timestamp".
1145 Instead we just parse them one at a time, in order.
1147 The syntax for "monitor set debug" we support here is not identical
1148 to gdb's "set debug foo on|off" because we also use this function to
1149 parse "--debug-format=foo,bar". */
1152 parse_debug_format_options (const char *arg
, int is_monitor
)
1154 VEC (char_ptr
) *options
;
1158 /* First turn all debug format options off. */
1159 debug_timestamp
= 0;
1161 /* First remove leading spaces, for "monitor set debug-format". */
1162 while (isspace (*arg
))
1165 options
= delim_string_to_char_ptr_vec (arg
, ',');
1167 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1169 if (strcmp (option
, "all") == 0)
1171 debug_timestamp
= 1;
1173 monitor_output ("All extra debug format options enabled.\n");
1175 else if (strcmp (option
, "none") == 0)
1177 debug_timestamp
= 0;
1179 monitor_output ("All extra debug format options disabled.\n");
1181 else if (strcmp (option
, "timestamp") == 0)
1183 debug_timestamp
= 1;
1185 monitor_output ("Timestamps will be added to debug output.\n");
1187 else if (*option
== '\0')
1189 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1194 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1197 free_char_ptr_vec (options
);
1202 free_char_ptr_vec (options
);
1206 /* Handle monitor commands not handled by target-specific handlers. */
1209 handle_monitor_command (char *mon
, char *own_buf
)
1211 if (strcmp (mon
, "set debug 1") == 0)
1214 monitor_output ("Debug output enabled.\n");
1216 else if (strcmp (mon
, "set debug 0") == 0)
1219 monitor_output ("Debug output disabled.\n");
1221 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1223 show_debug_regs
= 1;
1224 monitor_output ("H/W point debugging output enabled.\n");
1226 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1228 show_debug_regs
= 0;
1229 monitor_output ("H/W point debugging output disabled.\n");
1231 else if (strcmp (mon
, "set remote-debug 1") == 0)
1234 monitor_output ("Protocol debug output enabled.\n");
1236 else if (strcmp (mon
, "set remote-debug 0") == 0)
1239 monitor_output ("Protocol debug output disabled.\n");
1241 else if (startswith (mon
, "set debug-format "))
1244 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1247 if (error_msg
!= NULL
)
1249 monitor_output (error_msg
);
1250 monitor_show_help ();
1251 write_enn (own_buf
);
1255 else if (strcmp (mon
, "help") == 0)
1256 monitor_show_help ();
1257 else if (strcmp (mon
, "exit") == 0)
1261 monitor_output ("Unknown monitor command.\n\n");
1262 monitor_show_help ();
1263 write_enn (own_buf
);
1267 /* Associates a callback with each supported qXfer'able object. */
1271 /* The object this handler handles. */
1274 /* Request that the target transfer up to LEN 8-bit bytes of the
1275 target's OBJECT. The OFFSET, for a seekable object, specifies
1276 the starting point. The ANNEX can be used to provide additional
1277 data-specific information to the target.
1279 Return the number of bytes actually transfered, zero when no
1280 further transfer is possible, -1 on error, -2 when the transfer
1281 is not supported, and -3 on a verbose error message that should
1282 be preserved. Return of a positive value smaller than LEN does
1283 not indicate the end of the object, only the end of the transfer.
1285 One, and only one, of readbuf or writebuf must be non-NULL. */
1286 int (*xfer
) (const char *annex
,
1287 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1288 ULONGEST offset
, LONGEST len
);
1291 /* Handle qXfer:auxv:read. */
1294 handle_qxfer_auxv (const char *annex
,
1295 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1296 ULONGEST offset
, LONGEST len
)
1298 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1301 if (annex
[0] != '\0' || current_thread
== NULL
)
1304 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1307 /* Handle qXfer:exec-file:read. */
1310 handle_qxfer_exec_file (const char *const_annex
,
1311 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1312 ULONGEST offset
, LONGEST len
)
1318 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1321 if (const_annex
[0] == '\0')
1323 if (current_thread
== NULL
)
1326 pid
= pid_of (current_thread
);
1330 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1332 strcpy (annex
, const_annex
);
1333 annex
= unpack_varlen_hex (annex
, &pid
);
1335 if (annex
[0] != '\0')
1342 file
= (*the_target
->pid_to_exec_file
) (pid
);
1346 total_len
= strlen (file
);
1348 if (offset
> total_len
)
1351 if (offset
+ len
> total_len
)
1352 len
= total_len
- offset
;
1354 memcpy (readbuf
, file
+ offset
, len
);
1358 /* Handle qXfer:features:read. */
1361 handle_qxfer_features (const char *annex
,
1362 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1363 ULONGEST offset
, LONGEST len
)
1365 const char *document
;
1368 if (writebuf
!= NULL
)
1371 if (!target_running ())
1374 /* Grab the correct annex. */
1375 document
= get_features_xml (annex
);
1376 if (document
== NULL
)
1379 total_len
= strlen (document
);
1381 if (offset
> total_len
)
1384 if (offset
+ len
> total_len
)
1385 len
= total_len
- offset
;
1387 memcpy (readbuf
, document
+ offset
, len
);
1391 /* Worker routine for handle_qxfer_libraries.
1392 Add to the length pointed to by ARG a conservative estimate of the
1393 length needed to transmit the file name of INF. */
1396 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1398 struct dll_info
*dll
= (struct dll_info
*) inf
;
1399 unsigned int *total_len
= (unsigned int *) arg
;
1401 /* Over-estimate the necessary memory. Assume that every character
1402 in the library name must be escaped. */
1403 *total_len
+= 128 + 6 * strlen (dll
->name
);
1406 /* Worker routine for handle_qxfer_libraries.
1407 Emit the XML to describe the library in INF. */
1410 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1412 struct dll_info
*dll
= (struct dll_info
*) inf
;
1413 char **p_ptr
= (char **) arg
;
1417 strcpy (p
, " <library name=\"");
1419 name
= xml_escape_text (dll
->name
);
1423 strcpy (p
, "\"><segment address=\"");
1425 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1427 strcpy (p
, "\"/></library>\n");
1433 /* Handle qXfer:libraries:read. */
1436 handle_qxfer_libraries (const char *annex
,
1437 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1438 ULONGEST offset
, LONGEST len
)
1440 unsigned int total_len
;
1443 if (writebuf
!= NULL
)
1446 if (annex
[0] != '\0' || current_thread
== NULL
)
1450 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1453 document
= (char *) malloc (total_len
);
1454 if (document
== NULL
)
1457 strcpy (document
, "<library-list version=\"1.0\">\n");
1458 p
= document
+ strlen (document
);
1460 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1462 strcpy (p
, "</library-list>\n");
1464 total_len
= strlen (document
);
1466 if (offset
> total_len
)
1472 if (offset
+ len
> total_len
)
1473 len
= total_len
- offset
;
1475 memcpy (readbuf
, document
+ offset
, len
);
1480 /* Handle qXfer:libraries-svr4:read. */
1483 handle_qxfer_libraries_svr4 (const char *annex
,
1484 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1485 ULONGEST offset
, LONGEST len
)
1487 if (writebuf
!= NULL
)
1490 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1493 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1496 /* Handle qXfer:osadata:read. */
1499 handle_qxfer_osdata (const char *annex
,
1500 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1501 ULONGEST offset
, LONGEST len
)
1503 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1506 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1509 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1512 handle_qxfer_siginfo (const char *annex
,
1513 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1514 ULONGEST offset
, LONGEST len
)
1516 if (the_target
->qxfer_siginfo
== NULL
)
1519 if (annex
[0] != '\0' || current_thread
== NULL
)
1522 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1525 /* Handle qXfer:spu:read and qXfer:spu:write. */
1528 handle_qxfer_spu (const char *annex
,
1529 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1530 ULONGEST offset
, LONGEST len
)
1532 if (the_target
->qxfer_spu
== NULL
)
1535 if (current_thread
== NULL
)
1538 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1541 /* Handle qXfer:statictrace:read. */
1544 handle_qxfer_statictrace (const char *annex
,
1545 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1546 ULONGEST offset
, LONGEST len
)
1550 if (writebuf
!= NULL
)
1553 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1556 if (traceframe_read_sdata (current_traceframe
, offset
,
1557 readbuf
, len
, &nbytes
))
1562 /* Helper for handle_qxfer_threads_proper.
1563 Emit the XML to describe the thread of INF. */
1566 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1568 struct thread_info
*thread
= (struct thread_info
*) inf
;
1569 struct buffer
*buffer
= (struct buffer
*) arg
;
1570 ptid_t ptid
= thread_to_gdb_id (thread
);
1572 int core
= target_core_of_thread (ptid
);
1574 const char *name
= target_thread_name (ptid
);
1576 write_ptid (ptid_s
, ptid
);
1578 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1582 sprintf (core_s
, "%d", core
);
1583 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1587 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1589 buffer_xml_printf (buffer
, "/>\n");
1592 /* Helper for handle_qxfer_threads. */
1595 handle_qxfer_threads_proper (struct buffer
*buffer
)
1597 buffer_grow_str (buffer
, "<threads>\n");
1599 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1602 buffer_grow_str0 (buffer
, "</threads>\n");
1605 /* Handle qXfer:threads:read. */
1608 handle_qxfer_threads (const char *annex
,
1609 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1610 ULONGEST offset
, LONGEST len
)
1612 static char *result
= 0;
1613 static unsigned int result_length
= 0;
1615 if (writebuf
!= NULL
)
1618 if (annex
[0] != '\0')
1623 struct buffer buffer
;
1624 /* When asked for data at offset 0, generate everything and store into
1625 'result'. Successive reads will be served off 'result'. */
1629 buffer_init (&buffer
);
1631 handle_qxfer_threads_proper (&buffer
);
1633 result
= buffer_finish (&buffer
);
1634 result_length
= strlen (result
);
1635 buffer_free (&buffer
);
1638 if (offset
>= result_length
)
1640 /* We're out of data. */
1647 if (len
> result_length
- offset
)
1648 len
= result_length
- offset
;
1650 memcpy (readbuf
, result
+ offset
, len
);
1655 /* Handle qXfer:traceframe-info:read. */
1658 handle_qxfer_traceframe_info (const char *annex
,
1659 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1660 ULONGEST offset
, LONGEST len
)
1662 static char *result
= 0;
1663 static unsigned int result_length
= 0;
1665 if (writebuf
!= NULL
)
1668 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1673 struct buffer buffer
;
1675 /* When asked for data at offset 0, generate everything and
1676 store into 'result'. Successive reads will be served off
1680 buffer_init (&buffer
);
1682 traceframe_read_info (current_traceframe
, &buffer
);
1684 result
= buffer_finish (&buffer
);
1685 result_length
= strlen (result
);
1686 buffer_free (&buffer
);
1689 if (offset
>= result_length
)
1691 /* We're out of data. */
1698 if (len
> result_length
- offset
)
1699 len
= result_length
- offset
;
1701 memcpy (readbuf
, result
+ offset
, len
);
1705 /* Handle qXfer:fdpic:read. */
1708 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1709 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1711 if (the_target
->read_loadmap
== NULL
)
1714 if (current_thread
== NULL
)
1717 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1720 /* Handle qXfer:btrace:read. */
1723 handle_qxfer_btrace (const char *annex
,
1724 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1725 ULONGEST offset
, LONGEST len
)
1727 static struct buffer cache
;
1728 struct thread_info
*thread
;
1729 enum btrace_read_type type
;
1732 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1735 if (ptid_equal (general_thread
, null_ptid
)
1736 || ptid_equal (general_thread
, minus_one_ptid
))
1738 strcpy (own_buf
, "E.Must select a single thread.");
1742 thread
= find_thread_ptid (general_thread
);
1745 strcpy (own_buf
, "E.No such thread.");
1749 if (thread
->btrace
== NULL
)
1751 strcpy (own_buf
, "E.Btrace not enabled.");
1755 if (strcmp (annex
, "all") == 0)
1756 type
= BTRACE_READ_ALL
;
1757 else if (strcmp (annex
, "new") == 0)
1758 type
= BTRACE_READ_NEW
;
1759 else if (strcmp (annex
, "delta") == 0)
1760 type
= BTRACE_READ_DELTA
;
1763 strcpy (own_buf
, "E.Bad annex.");
1769 buffer_free (&cache
);
1771 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1774 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1778 else if (offset
> cache
.used_size
)
1780 buffer_free (&cache
);
1784 if (len
> cache
.used_size
- offset
)
1785 len
= cache
.used_size
- offset
;
1787 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1792 /* Handle qXfer:btrace-conf:read. */
1795 handle_qxfer_btrace_conf (const char *annex
,
1796 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1797 ULONGEST offset
, LONGEST len
)
1799 static struct buffer cache
;
1800 struct thread_info
*thread
;
1803 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1806 if (annex
[0] != '\0')
1809 if (ptid_equal (general_thread
, null_ptid
)
1810 || ptid_equal (general_thread
, minus_one_ptid
))
1812 strcpy (own_buf
, "E.Must select a single thread.");
1816 thread
= find_thread_ptid (general_thread
);
1819 strcpy (own_buf
, "E.No such thread.");
1823 if (thread
->btrace
== NULL
)
1825 strcpy (own_buf
, "E.Btrace not enabled.");
1831 buffer_free (&cache
);
1833 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1836 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1840 else if (offset
> cache
.used_size
)
1842 buffer_free (&cache
);
1846 if (len
> cache
.used_size
- offset
)
1847 len
= cache
.used_size
- offset
;
1849 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1854 static const struct qxfer qxfer_packets
[] =
1856 { "auxv", handle_qxfer_auxv
},
1857 { "btrace", handle_qxfer_btrace
},
1858 { "btrace-conf", handle_qxfer_btrace_conf
},
1859 { "exec-file", handle_qxfer_exec_file
},
1860 { "fdpic", handle_qxfer_fdpic
},
1861 { "features", handle_qxfer_features
},
1862 { "libraries", handle_qxfer_libraries
},
1863 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1864 { "osdata", handle_qxfer_osdata
},
1865 { "siginfo", handle_qxfer_siginfo
},
1866 { "spu", handle_qxfer_spu
},
1867 { "statictrace", handle_qxfer_statictrace
},
1868 { "threads", handle_qxfer_threads
},
1869 { "traceframe-info", handle_qxfer_traceframe_info
},
1873 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1881 if (!startswith (own_buf
, "qXfer:"))
1884 /* Grab the object, r/w and annex. */
1885 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1887 write_enn (own_buf
);
1892 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1895 const struct qxfer
*q
= &qxfer_packets
[i
];
1897 if (strcmp (object
, q
->object
) == 0)
1899 if (strcmp (rw
, "read") == 0)
1901 unsigned char *data
;
1906 /* Grab the offset and length. */
1907 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1909 write_enn (own_buf
);
1913 /* Read one extra byte, as an indicator of whether there is
1915 if (len
> PBUFSIZ
- 2)
1917 data
= (unsigned char *) malloc (len
+ 1);
1920 write_enn (own_buf
);
1923 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1931 /* Preserve error message. */
1934 write_enn (own_buf
);
1936 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1938 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1943 else if (strcmp (rw
, "write") == 0)
1948 unsigned char *data
;
1950 strcpy (own_buf
, "E00");
1951 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1954 write_enn (own_buf
);
1957 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1958 &ofs
, &len
, data
) < 0)
1961 write_enn (own_buf
);
1965 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1973 /* Preserve error message. */
1976 write_enn (own_buf
);
1978 sprintf (own_buf
, "%x", n
);
1991 /* Compute 32 bit CRC from inferior memory.
1993 On success, return 32 bit CRC.
1994 On failure, return (unsigned long long) -1. */
1996 static unsigned long long
1997 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2001 unsigned char byte
= 0;
2003 /* Return failure if memory read fails. */
2004 if (read_inferior_memory (base
, &byte
, 1) != 0)
2005 return (unsigned long long) -1;
2007 crc
= xcrc32 (&byte
, 1, crc
);
2010 return (unsigned long long) crc
;
2013 /* Add supported btrace packets to BUF. */
2016 supported_btrace_packets (char *buf
)
2018 int btrace_supported
= 0;
2020 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2022 strcat (buf
, ";Qbtrace:bts+");
2023 strcat (buf
, ";Qbtrace-conf:bts:size+");
2025 btrace_supported
= 1;
2028 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2030 strcat (buf
, ";Qbtrace:pt+");
2031 strcat (buf
, ";Qbtrace-conf:pt:size+");
2033 btrace_supported
= 1;
2036 if (!btrace_supported
)
2039 strcat (buf
, ";Qbtrace:off+");
2040 strcat (buf
, ";qXfer:btrace:read+");
2041 strcat (buf
, ";qXfer:btrace-conf:read+");
2044 /* Handle all of the extended 'q' packets. */
2047 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2049 static struct inferior_list_entry
*thread_ptr
;
2051 /* Reply the current thread id. */
2052 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2055 require_running (own_buf
);
2057 if (!ptid_equal (general_thread
, null_ptid
)
2058 && !ptid_equal (general_thread
, minus_one_ptid
))
2059 gdb_id
= general_thread
;
2062 thread_ptr
= get_first_inferior (&all_threads
);
2063 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2066 sprintf (own_buf
, "QC");
2068 write_ptid (own_buf
, gdb_id
);
2072 if (strcmp ("qSymbol::", own_buf
) == 0)
2074 struct thread_info
*save_thread
= current_thread
;
2076 /* For qSymbol, GDB only changes the current thread if the
2077 previous current thread was of a different process. So if
2078 the previous thread is gone, we need to pick another one of
2079 the same process. This can happen e.g., if we followed an
2080 exec in a non-leader thread. */
2081 if (current_thread
== NULL
)
2084 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2086 /* Just in case, if we didn't find a thread, then bail out
2087 instead of crashing. */
2088 if (current_thread
== NULL
)
2090 write_enn (own_buf
);
2091 current_thread
= save_thread
;
2096 /* GDB is suggesting new symbols have been loaded. This may
2097 mean a new shared library has been detected as loaded, so
2098 take the opportunity to check if breakpoints we think are
2099 inserted, still are. Note that it isn't guaranteed that
2100 we'll see this when a shared library is loaded, and nor will
2101 we see this for unloads (although breakpoints in unloaded
2102 libraries shouldn't trigger), as GDB may not find symbols for
2103 the library at all. We also re-validate breakpoints when we
2104 see a second GDB breakpoint for the same address, and or when
2105 we access breakpoint shadows. */
2106 validate_breakpoints ();
2108 if (target_supports_tracepoints ())
2109 tracepoint_look_up_symbols ();
2111 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2112 (*the_target
->look_up_symbols
) ();
2114 current_thread
= save_thread
;
2116 strcpy (own_buf
, "OK");
2120 if (!disable_packet_qfThreadInfo
)
2122 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2126 require_running (own_buf
);
2127 thread_ptr
= get_first_inferior (&all_threads
);
2130 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2131 write_ptid (own_buf
, gdb_id
);
2132 thread_ptr
= thread_ptr
->next
;
2136 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2140 require_running (own_buf
);
2141 if (thread_ptr
!= NULL
)
2144 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2145 write_ptid (own_buf
, gdb_id
);
2146 thread_ptr
= thread_ptr
->next
;
2151 sprintf (own_buf
, "l");
2157 if (the_target
->read_offsets
!= NULL
2158 && strcmp ("qOffsets", own_buf
) == 0)
2160 CORE_ADDR text
, data
;
2162 require_running (own_buf
);
2163 if (the_target
->read_offsets (&text
, &data
))
2164 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2165 (long)text
, (long)data
, (long)data
);
2167 write_enn (own_buf
);
2172 /* Protocol features query. */
2173 if (startswith (own_buf
, "qSupported")
2174 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2176 char *p
= &own_buf
[10];
2177 int gdb_supports_qRelocInsn
= 0;
2179 /* Process each feature being provided by GDB. The first
2180 feature will follow a ':', and latter features will follow
2184 char **qsupported
= NULL
;
2189 /* Two passes, to avoid nested strtok calls in
2190 target_process_qsupported. */
2191 for (p
= strtok (p
+ 1, ";");
2193 p
= strtok (NULL
, ";"))
2196 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2197 qsupported
[count
- 1] = xstrdup (p
);
2200 for (i
= 0; i
< count
; i
++)
2203 if (strcmp (p
, "multiprocess+") == 0)
2205 /* GDB supports and wants multi-process support if
2207 if (target_supports_multi_process ())
2210 else if (strcmp (p
, "qRelocInsn+") == 0)
2212 /* GDB supports relocate instruction requests. */
2213 gdb_supports_qRelocInsn
= 1;
2215 else if (strcmp (p
, "swbreak+") == 0)
2217 /* GDB wants us to report whether a trap is caused
2218 by a software breakpoint and for us to handle PC
2219 adjustment if necessary on this target. */
2220 if (target_supports_stopped_by_sw_breakpoint ())
2221 swbreak_feature
= 1;
2223 else if (strcmp (p
, "hwbreak+") == 0)
2225 /* GDB wants us to report whether a trap is caused
2226 by a hardware breakpoint. */
2227 if (target_supports_stopped_by_hw_breakpoint ())
2228 hwbreak_feature
= 1;
2230 else if (strcmp (p
, "fork-events+") == 0)
2232 /* GDB supports and wants fork events if possible. */
2233 if (target_supports_fork_events ())
2234 report_fork_events
= 1;
2236 else if (strcmp (p
, "vfork-events+") == 0)
2238 /* GDB supports and wants vfork events if possible. */
2239 if (target_supports_vfork_events ())
2240 report_vfork_events
= 1;
2242 else if (strcmp (p
, "exec-events+") == 0)
2244 /* GDB supports and wants exec events if possible. */
2245 if (target_supports_exec_events ())
2246 report_exec_events
= 1;
2248 else if (strcmp (p
, "vContSupported+") == 0)
2249 vCont_supported
= 1;
2250 else if (strcmp (p
, "QThreadEvents+") == 0)
2252 else if (strcmp (p
, "no-resumed+") == 0)
2254 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2256 report_no_resumed
= 1;
2260 /* Move the unknown features all together. */
2261 qsupported
[i
] = NULL
;
2262 qsupported
[unknown
] = p
;
2267 /* Give the target backend a chance to process the unknown
2269 target_process_qsupported (qsupported
, unknown
);
2271 for (i
= 0; i
< count
; i
++)
2272 free (qsupported
[i
]);
2277 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2280 if (target_supports_catch_syscall ())
2281 strcat (own_buf
, ";QCatchSyscalls+");
2283 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2284 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2285 ";augmented-libraries-svr4-read+");
2288 /* We do not have any hook to indicate whether the non-SVR4 target
2289 backend supports qXfer:libraries:read, so always report it. */
2290 strcat (own_buf
, ";qXfer:libraries:read+");
2293 if (the_target
->read_auxv
!= NULL
)
2294 strcat (own_buf
, ";qXfer:auxv:read+");
2296 if (the_target
->qxfer_spu
!= NULL
)
2297 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2299 if (the_target
->qxfer_siginfo
!= NULL
)
2300 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2302 if (the_target
->read_loadmap
!= NULL
)
2303 strcat (own_buf
, ";qXfer:fdpic:read+");
2305 /* We always report qXfer:features:read, as targets may
2306 install XML files on a subsequent call to arch_setup.
2307 If we reported to GDB on startup that we don't support
2308 qXfer:feature:read at all, we will never be re-queried. */
2309 strcat (own_buf
, ";qXfer:features:read+");
2311 if (transport_is_reliable
)
2312 strcat (own_buf
, ";QStartNoAckMode+");
2314 if (the_target
->qxfer_osdata
!= NULL
)
2315 strcat (own_buf
, ";qXfer:osdata:read+");
2317 if (target_supports_multi_process ())
2318 strcat (own_buf
, ";multiprocess+");
2320 if (target_supports_fork_events ())
2321 strcat (own_buf
, ";fork-events+");
2323 if (target_supports_vfork_events ())
2324 strcat (own_buf
, ";vfork-events+");
2326 if (target_supports_exec_events ())
2327 strcat (own_buf
, ";exec-events+");
2329 if (target_supports_non_stop ())
2330 strcat (own_buf
, ";QNonStop+");
2332 if (target_supports_disable_randomization ())
2333 strcat (own_buf
, ";QDisableRandomization+");
2335 strcat (own_buf
, ";qXfer:threads:read+");
2337 if (target_supports_tracepoints ())
2339 strcat (own_buf
, ";ConditionalTracepoints+");
2340 strcat (own_buf
, ";TraceStateVariables+");
2341 strcat (own_buf
, ";TracepointSource+");
2342 strcat (own_buf
, ";DisconnectedTracing+");
2343 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2344 strcat (own_buf
, ";FastTracepoints+");
2345 strcat (own_buf
, ";StaticTracepoints+");
2346 strcat (own_buf
, ";InstallInTrace+");
2347 strcat (own_buf
, ";qXfer:statictrace:read+");
2348 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2349 strcat (own_buf
, ";EnableDisableTracepoints+");
2350 strcat (own_buf
, ";QTBuffer:size+");
2351 strcat (own_buf
, ";tracenz+");
2354 if (target_supports_hardware_single_step ()
2355 || target_supports_software_single_step () )
2357 strcat (own_buf
, ";ConditionalBreakpoints+");
2359 strcat (own_buf
, ";BreakpointCommands+");
2361 if (target_supports_agent ())
2362 strcat (own_buf
, ";QAgent+");
2364 supported_btrace_packets (own_buf
);
2366 if (target_supports_stopped_by_sw_breakpoint ())
2367 strcat (own_buf
, ";swbreak+");
2369 if (target_supports_stopped_by_hw_breakpoint ())
2370 strcat (own_buf
, ";hwbreak+");
2372 if (the_target
->pid_to_exec_file
!= NULL
)
2373 strcat (own_buf
, ";qXfer:exec-file:read+");
2375 strcat (own_buf
, ";vContSupported+");
2377 strcat (own_buf
, ";QThreadEvents+");
2379 strcat (own_buf
, ";no-resumed+");
2381 /* Reinitialize components as needed for the new connection. */
2382 hostio_handle_new_gdb_connection ();
2383 target_handle_new_gdb_connection ();
2388 /* Thread-local storage support. */
2389 if (the_target
->get_tls_address
!= NULL
2390 && startswith (own_buf
, "qGetTLSAddr:"))
2392 char *p
= own_buf
+ 12;
2393 CORE_ADDR parts
[2], address
= 0;
2395 ptid_t ptid
= null_ptid
;
2397 require_running (own_buf
);
2399 for (i
= 0; i
< 3; i
++)
2407 p2
= strchr (p
, ',');
2420 ptid
= read_ptid (p
, NULL
);
2422 decode_address (&parts
[i
- 1], p
, len
);
2426 if (p
!= NULL
|| i
< 3)
2430 struct thread_info
*thread
= find_thread_ptid (ptid
);
2435 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2441 strcpy (own_buf
, paddress(address
));
2446 write_enn (own_buf
);
2450 /* Otherwise, pretend we do not understand this packet. */
2453 /* Windows OS Thread Information Block address support. */
2454 if (the_target
->get_tib_address
!= NULL
2455 && startswith (own_buf
, "qGetTIBAddr:"))
2460 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2462 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2465 strcpy (own_buf
, paddress(tlb
));
2470 write_enn (own_buf
);
2476 /* Handle "monitor" commands. */
2477 if (startswith (own_buf
, "qRcmd,"))
2479 char *mon
= (char *) malloc (PBUFSIZ
);
2480 int len
= strlen (own_buf
+ 6);
2484 write_enn (own_buf
);
2489 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2491 write_enn (own_buf
);
2495 mon
[len
/ 2] = '\0';
2499 if (the_target
->handle_monitor_command
== NULL
2500 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2501 /* Default processing. */
2502 handle_monitor_command (mon
, own_buf
);
2508 if (startswith (own_buf
, "qSearch:memory:"))
2510 require_running (own_buf
);
2511 handle_search_memory (own_buf
, packet_len
);
2515 if (strcmp (own_buf
, "qAttached") == 0
2516 || startswith (own_buf
, "qAttached:"))
2518 struct process_info
*process
;
2520 if (own_buf
[sizeof ("qAttached") - 1])
2522 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2523 process
= (struct process_info
*)
2524 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2528 require_running (own_buf
);
2529 process
= current_process ();
2532 if (process
== NULL
)
2534 write_enn (own_buf
);
2538 strcpy (own_buf
, process
->attached
? "1" : "0");
2542 if (startswith (own_buf
, "qCRC:"))
2544 /* CRC check (compare-section). */
2548 unsigned long long crc
;
2550 require_running (own_buf
);
2551 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2552 if (*comma
++ != ',')
2554 write_enn (own_buf
);
2557 len
= strtoul (comma
, NULL
, 16);
2558 crc
= crc32 (base
, len
, 0xffffffff);
2559 /* Check for memory failure. */
2560 if (crc
== (unsigned long long) -1)
2562 write_enn (own_buf
);
2565 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2569 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2572 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2575 /* Otherwise we didn't know what packet it was. Say we didn't
2580 static void gdb_wants_all_threads_stopped (void);
2581 static void resume (struct thread_resume
*actions
, size_t n
);
2583 /* The callback that is passed to visit_actioned_threads. */
2584 typedef int (visit_actioned_threads_callback_ftype
)
2585 (const struct thread_resume
*, struct thread_info
*);
2587 /* Struct to pass data to visit_actioned_threads. */
2589 struct visit_actioned_threads_data
2591 const struct thread_resume
*actions
;
2593 visit_actioned_threads_callback_ftype
*callback
;
2596 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2597 true if CALLBACK returns true. Returns false if no matching thread
2598 is found or CALLBACK results false.
2599 Note: This function is itself a callback for find_inferior. */
2602 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2604 struct visit_actioned_threads_data
*data
2605 = (struct visit_actioned_threads_data
*) datap
;
2606 const struct thread_resume
*actions
= data
->actions
;
2607 size_t num_actions
= data
->num_actions
;
2608 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2611 for (i
= 0; i
< num_actions
; i
++)
2613 const struct thread_resume
*action
= &actions
[i
];
2615 if (ptid_equal (action
->thread
, minus_one_ptid
)
2616 || ptid_equal (action
->thread
, entry
->id
)
2617 || ((ptid_get_pid (action
->thread
)
2618 == ptid_get_pid (entry
->id
))
2619 && ptid_get_lwp (action
->thread
) == -1))
2621 struct thread_info
*thread
= (struct thread_info
*) entry
;
2623 if ((*callback
) (action
, thread
))
2631 /* Callback for visit_actioned_threads. If the thread has a pending
2632 status to report, report it now. */
2635 handle_pending_status (const struct thread_resume
*resumption
,
2636 struct thread_info
*thread
)
2638 if (thread
->status_pending_p
)
2640 thread
->status_pending_p
= 0;
2642 last_status
= thread
->last_status
;
2643 last_ptid
= thread
->entry
.id
;
2644 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2650 /* Parse vCont packets. */
2652 handle_v_cont (char *own_buf
)
2656 struct thread_resume
*resume_info
;
2657 struct thread_resume default_action
= {{0}};
2659 /* Count the number of semicolons in the packet. There should be one
2660 for every action. */
2666 p
= strchr (p
, ';');
2669 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2670 if (resume_info
== NULL
)
2678 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2680 if (p
[0] == 's' || p
[0] == 'S')
2681 resume_info
[i
].kind
= resume_step
;
2682 else if (p
[0] == 'r')
2683 resume_info
[i
].kind
= resume_step
;
2684 else if (p
[0] == 'c' || p
[0] == 'C')
2685 resume_info
[i
].kind
= resume_continue
;
2686 else if (p
[0] == 't')
2687 resume_info
[i
].kind
= resume_stop
;
2691 if (p
[0] == 'S' || p
[0] == 'C')
2694 sig
= strtol (p
+ 1, &q
, 16);
2699 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2701 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2703 else if (p
[0] == 'r')
2707 p
= unpack_varlen_hex (p
+ 1, &addr
);
2708 resume_info
[i
].step_range_start
= addr
;
2713 p
= unpack_varlen_hex (p
+ 1, &addr
);
2714 resume_info
[i
].step_range_end
= addr
;
2723 resume_info
[i
].thread
= minus_one_ptid
;
2724 default_action
= resume_info
[i
];
2726 /* Note: we don't increment i here, we'll overwrite this entry
2727 the next time through. */
2729 else if (p
[0] == ':')
2731 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2736 if (p
[0] != ';' && p
[0] != 0)
2739 resume_info
[i
].thread
= ptid
;
2746 resume_info
[i
] = default_action
;
2748 resume (resume_info
, n
);
2753 write_enn (own_buf
);
2758 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2761 resume (struct thread_resume
*actions
, size_t num_actions
)
2765 /* Check if among the threads that GDB wants actioned, there's
2766 one with a pending status to report. If so, skip actually
2767 resuming/stopping and report the pending event
2769 struct visit_actioned_threads_data data
;
2771 data
.actions
= actions
;
2772 data
.num_actions
= num_actions
;
2773 data
.callback
= handle_pending_status
;
2774 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2780 (*the_target
->resume
) (actions
, num_actions
);
2786 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2788 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2789 && !report_no_resumed
)
2791 /* The client does not support this stop reply. At least
2793 sprintf (own_buf
, "E.No unwaited-for children left.");
2794 disable_async_io ();
2798 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2799 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2800 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2801 current_thread
->last_status
= last_status
;
2803 /* From the client's perspective, all-stop mode always stops all
2804 threads implicitly (and the target backend has already done
2805 so by now). Tag all threads as "want-stopped", so we don't
2806 resume them implicitly without the client telling us to. */
2807 gdb_wants_all_threads_stopped ();
2808 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2809 disable_async_io ();
2811 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2812 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2813 target_mourn_inferior (last_ptid
);
2817 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2819 handle_v_attach (char *own_buf
)
2823 pid
= strtol (own_buf
+ 8, NULL
, 16);
2824 if (pid
!= 0 && attach_inferior (pid
) == 0)
2826 /* Don't report shared library events after attaching, even if
2827 some libraries are preloaded. GDB will always poll the
2828 library list. Avoids the "stopped by shared library event"
2829 notice on the GDB side. */
2834 /* In non-stop, we don't send a resume reply. Stop events
2835 will follow up using the normal notification
2840 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2846 write_enn (own_buf
);
2851 /* Run a new program. Return 1 if successful, 0 if failure. */
2853 handle_v_run (char *own_buf
)
2855 char *p
, *next_p
, **new_argv
;
2859 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2865 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2866 if (new_argv
== NULL
)
2868 write_enn (own_buf
);
2873 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2875 next_p
= strchr (p
, ';');
2877 next_p
= p
+ strlen (p
);
2879 if (i
== 0 && p
== next_p
)
2883 /* FIXME: Fail request if out of memory instead of dying. */
2884 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2885 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2886 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2895 if (new_argv
[0] == NULL
)
2897 /* GDB didn't specify a program to run. Use the program from the
2898 last run with the new argument list. */
2900 if (program_argv
== NULL
)
2902 write_enn (own_buf
);
2903 freeargv (new_argv
);
2907 new_argv
[0] = strdup (program_argv
[0]);
2908 if (new_argv
[0] == NULL
)
2910 write_enn (own_buf
);
2911 freeargv (new_argv
);
2916 /* Free the old argv and install the new one. */
2917 freeargv (program_argv
);
2918 program_argv
= new_argv
;
2920 start_inferior (program_argv
);
2921 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2923 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2925 /* In non-stop, sending a resume reply doesn't set the general
2926 thread, but GDB assumes a vRun sets it (this is so GDB can
2927 query which is the main thread of the new inferior. */
2929 general_thread
= last_ptid
;
2935 write_enn (own_buf
);
2940 /* Kill process. Return 1 if successful, 0 if failure. */
2942 handle_v_kill (char *own_buf
)
2945 char *p
= &own_buf
[6];
2947 pid
= strtol (p
, NULL
, 16);
2950 if (pid
!= 0 && kill_inferior (pid
) == 0)
2952 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2953 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2954 last_ptid
= pid_to_ptid (pid
);
2955 discard_queued_stop_replies (last_ptid
);
2961 write_enn (own_buf
);
2966 /* Handle all of the extended 'v' packets. */
2968 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2970 if (!disable_packet_vCont
)
2972 if (strcmp (own_buf
, "vCtrlC") == 0)
2974 (*the_target
->request_interrupt
) ();
2979 if (startswith (own_buf
, "vCont;"))
2981 handle_v_cont (own_buf
);
2985 if (startswith (own_buf
, "vCont?"))
2987 strcpy (own_buf
, "vCont;c;C;t");
2989 if (target_supports_hardware_single_step ()
2990 || target_supports_software_single_step ()
2991 || !vCont_supported
)
2993 /* If target supports single step either by hardware or by
2994 software, add actions s and S to the list of supported
2995 actions. On the other hand, if GDB doesn't request the
2996 supported vCont actions in qSupported packet, add s and
2997 S to the list too. */
2998 own_buf
= own_buf
+ strlen (own_buf
);
2999 strcpy (own_buf
, ";s;S");
3002 if (target_supports_range_stepping ())
3004 own_buf
= own_buf
+ strlen (own_buf
);
3005 strcpy (own_buf
, ";r");
3011 if (startswith (own_buf
, "vFile:")
3012 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3015 if (startswith (own_buf
, "vAttach;"))
3017 if ((!extended_protocol
|| !multi_process
) && target_running ())
3019 fprintf (stderr
, "Already debugging a process\n");
3020 write_enn (own_buf
);
3023 handle_v_attach (own_buf
);
3027 if (startswith (own_buf
, "vRun;"))
3029 if ((!extended_protocol
|| !multi_process
) && target_running ())
3031 fprintf (stderr
, "Already debugging a process\n");
3032 write_enn (own_buf
);
3035 handle_v_run (own_buf
);
3039 if (startswith (own_buf
, "vKill;"))
3041 if (!target_running ())
3043 fprintf (stderr
, "No process to kill\n");
3044 write_enn (own_buf
);
3047 handle_v_kill (own_buf
);
3051 if (handle_notif_ack (own_buf
, packet_len
))
3054 /* Otherwise we didn't know what packet it was. Say we didn't
3060 /* Resume thread and wait for another event. In non-stop mode,
3061 don't really wait here, but return immediatelly to the event
3064 myresume (char *own_buf
, int step
, int sig
)
3066 struct thread_resume resume_info
[2];
3068 int valid_cont_thread
;
3070 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3071 && !ptid_equal (cont_thread
, minus_one_ptid
));
3073 if (step
|| sig
|| valid_cont_thread
)
3075 resume_info
[0].thread
= current_ptid
;
3077 resume_info
[0].kind
= resume_step
;
3079 resume_info
[0].kind
= resume_continue
;
3080 resume_info
[0].sig
= sig
;
3084 if (!valid_cont_thread
)
3086 resume_info
[n
].thread
= minus_one_ptid
;
3087 resume_info
[n
].kind
= resume_continue
;
3088 resume_info
[n
].sig
= 0;
3092 resume (resume_info
, n
);
3095 /* Callback for for_each_inferior. Make a new stop reply for each
3099 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3101 struct thread_info
*thread
= (struct thread_info
*) entry
;
3103 /* For now, assume targets that don't have this callback also don't
3104 manage the thread's last_status field. */
3105 if (the_target
->thread_stopped
== NULL
)
3107 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3109 new_notif
->ptid
= entry
->id
;
3110 new_notif
->status
= thread
->last_status
;
3111 /* Pass the last stop reply back to GDB, but don't notify
3113 notif_event_enque (¬if_stop
,
3114 (struct notif_event
*) new_notif
);
3118 if (thread_stopped (thread
))
3123 = target_waitstatus_to_string (&thread
->last_status
);
3125 debug_printf ("Reporting thread %s as already stopped with %s\n",
3126 target_pid_to_str (entry
->id
),
3129 xfree (status_string
);
3132 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3134 /* Pass the last stop reply back to GDB, but don't notify
3136 queue_stop_reply (entry
->id
, &thread
->last_status
);
3143 /* Set this inferior threads's state as "want-stopped". We won't
3144 resume this thread until the client gives us another action for
3148 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3150 struct thread_info
*thread
= (struct thread_info
*) entry
;
3152 thread
->last_resume_kind
= resume_stop
;
3154 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3156 /* Most threads are stopped implicitly (all-stop); tag that with
3158 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3159 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3163 /* Set all threads' states as "want-stopped". */
3166 gdb_wants_all_threads_stopped (void)
3168 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3171 /* Clear the gdb_detached flag of every process. */
3174 gdb_reattached_process (struct inferior_list_entry
*entry
)
3176 struct process_info
*process
= (struct process_info
*) entry
;
3178 process
->gdb_detached
= 0;
3181 /* Callback for for_each_inferior. Clear the thread's pending status
3185 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3187 struct thread_info
*thread
= (struct thread_info
*) entry
;
3189 thread
->status_pending_p
= 0;
3192 /* Callback for for_each_inferior. If the thread is stopped with an
3193 interesting event, mark it as having a pending event. */
3196 set_pending_status_callback (struct inferior_list_entry
*entry
)
3198 struct thread_info
*thread
= (struct thread_info
*) entry
;
3200 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3201 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3202 /* A breakpoint, watchpoint or finished step from a previous
3203 GDB run isn't considered interesting for a new GDB run.
3204 If we left those pending, the new GDB could consider them
3205 random SIGTRAPs. This leaves out real async traps. We'd
3206 have to peek into the (target-specific) siginfo to
3207 distinguish those. */
3208 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3209 thread
->status_pending_p
= 1;
3212 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3213 pending status to report to GDB. */
3216 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3218 struct thread_info
*thread
= (struct thread_info
*) entry
;
3220 return thread
->status_pending_p
;
3223 /* Status handler for the '?' packet. */
3226 handle_status (char *own_buf
)
3228 /* GDB is connected, don't forward events to the target anymore. */
3229 for_each_inferior (&all_processes
, gdb_reattached_process
);
3231 /* In non-stop mode, we must send a stop reply for each stopped
3232 thread. In all-stop mode, just send one for the first stopped
3237 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3239 /* The first is sent immediatly. OK is sent if there is no
3240 stopped thread, which is the same handling of the vStopped
3241 packet (by design). */
3242 notif_write_event (¬if_stop
, own_buf
);
3246 struct inferior_list_entry
*thread
= NULL
;
3249 stabilize_threads ();
3250 gdb_wants_all_threads_stopped ();
3252 /* We can only report one status, but we might be coming out of
3253 non-stop -- if more than one thread is stopped with
3254 interesting events, leave events for the threads we're not
3255 reporting now pending. They'll be reported the next time the
3256 threads are resumed. Start by marking all interesting events
3258 for_each_inferior (&all_threads
, set_pending_status_callback
);
3260 /* Prefer the last thread that reported an event to GDB (even if
3261 that was a GDB_SIGNAL_TRAP). */
3262 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3263 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3264 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3265 thread
= find_inferior_id (&all_threads
, last_ptid
);
3267 /* If the last event thread is not found for some reason, look
3268 for some other thread that might have an event to report. */
3270 thread
= find_inferior (&all_threads
,
3271 find_status_pending_thread_callback
, NULL
);
3273 /* If we're still out of luck, simply pick the first thread in
3276 thread
= get_first_inferior (&all_threads
);
3280 struct thread_info
*tp
= (struct thread_info
*) thread
;
3282 /* We're reporting this event, so it's no longer
3284 tp
->status_pending_p
= 0;
3286 /* GDB assumes the current thread is the thread we're
3287 reporting the status for. */
3288 general_thread
= thread
->id
;
3289 set_desired_thread (1);
3291 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3292 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3295 strcpy (own_buf
, "W00");
3300 gdbserver_version (void)
3302 printf ("GNU gdbserver %s%s\n"
3303 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3304 "gdbserver is free software, covered by the "
3305 "GNU General Public License.\n"
3306 "This gdbserver was configured as \"%s\"\n",
3307 PKGVERSION
, version
, host_name
);
3311 gdbserver_usage (FILE *stream
)
3313 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3314 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3315 "\tgdbserver [OPTIONS] --multi COMM\n"
3317 "COMM may either be a tty device (for serial debugging),\n"
3318 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3319 "stdin/stdout of gdbserver.\n"
3320 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3321 "PID is the process ID to attach to, when --attach is specified.\n"
3323 "Operating modes:\n"
3325 " --attach Attach to running process PID.\n"
3326 " --multi Start server without a specific program, and\n"
3327 " only quit when explicitly commanded.\n"
3328 " --once Exit after the first connection has closed.\n"
3329 " --help Print this message and then exit.\n"
3330 " --version Display version information and exit.\n"
3334 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3335 " --disable-randomization\n"
3336 " Run PROG with address space randomization disabled.\n"
3337 " --no-disable-randomization\n"
3338 " Don't disable address space randomization when\n"
3343 " --debug Enable general debugging output.\n"
3344 " --debug-format=opt1[,opt2,...]\n"
3345 " Specify extra content in debugging output.\n"
3350 " --remote-debug Enable remote protocol debugging output.\n"
3351 " --disable-packet=opt1[,opt2,...]\n"
3352 " Disable support for RSP packets or features.\n"
3354 " vCont, Tthread, qC, qfThreadInfo and \n"
3355 " threads (disable all threading packets).\n"
3357 "For more information, consult the GDB manual (available as on-line \n"
3358 "info or a printed manual).\n");
3359 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3360 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3364 gdbserver_show_disableable (FILE *stream
)
3366 fprintf (stream
, "Disableable packets:\n"
3367 " vCont \tAll vCont packets\n"
3368 " qC \tQuerying the current thread\n"
3369 " qfThreadInfo\tThread listing\n"
3370 " Tthread \tPassing the thread specifier in the "
3371 "T stop reply packet\n"
3372 " threads \tAll of the above\n");
3376 #undef require_running
3377 #define require_running(BUF) \
3378 if (!target_running ()) \
3385 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3387 int pid
= * (int *) args
;
3389 if (ptid_get_pid (entry
->id
) == pid
)
3396 kill_inferior_callback (struct inferior_list_entry
*entry
)
3398 struct process_info
*process
= (struct process_info
*) entry
;
3399 int pid
= ptid_get_pid (process
->entry
.id
);
3401 kill_inferior (pid
);
3402 discard_queued_stop_replies (pid_to_ptid (pid
));
3405 /* Callback for for_each_inferior to detach or kill the inferior,
3406 depending on whether we attached to it or not.
3407 We inform the user whether we're detaching or killing the process
3408 as this is only called when gdbserver is about to exit. */
3411 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3413 struct process_info
*process
= (struct process_info
*) entry
;
3414 int pid
= ptid_get_pid (process
->entry
.id
);
3416 if (process
->attached
)
3417 detach_inferior (pid
);
3419 kill_inferior (pid
);
3421 discard_queued_stop_replies (pid_to_ptid (pid
));
3424 /* for_each_inferior callback for detach_or_kill_for_exit to print
3425 the pids of started inferiors. */
3428 print_started_pid (struct inferior_list_entry
*entry
)
3430 struct process_info
*process
= (struct process_info
*) entry
;
3432 if (! process
->attached
)
3434 int pid
= ptid_get_pid (process
->entry
.id
);
3435 fprintf (stderr
, " %d", pid
);
3439 /* for_each_inferior callback for detach_or_kill_for_exit to print
3440 the pids of attached inferiors. */
3443 print_attached_pid (struct inferior_list_entry
*entry
)
3445 struct process_info
*process
= (struct process_info
*) entry
;
3447 if (process
->attached
)
3449 int pid
= ptid_get_pid (process
->entry
.id
);
3450 fprintf (stderr
, " %d", pid
);
3454 /* Call this when exiting gdbserver with possible inferiors that need
3455 to be killed or detached from. */
3458 detach_or_kill_for_exit (void)
3460 /* First print a list of the inferiors we will be killing/detaching.
3461 This is to assist the user, for example, in case the inferior unexpectedly
3462 dies after we exit: did we screw up or did the inferior exit on its own?
3463 Having this info will save some head-scratching. */
3465 if (have_started_inferiors_p ())
3467 fprintf (stderr
, "Killing process(es):");
3468 for_each_inferior (&all_processes
, print_started_pid
);
3469 fprintf (stderr
, "\n");
3471 if (have_attached_inferiors_p ())
3473 fprintf (stderr
, "Detaching process(es):");
3474 for_each_inferior (&all_processes
, print_attached_pid
);
3475 fprintf (stderr
, "\n");
3478 /* Now we can kill or detach the inferiors. */
3480 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3483 /* Value that will be passed to exit(3) when gdbserver exits. */
3484 static int exit_code
;
3486 /* Cleanup version of detach_or_kill_for_exit. */
3489 detach_or_kill_for_exit_cleanup (void *ignore
)
3494 detach_or_kill_for_exit ();
3497 CATCH (exception
, RETURN_MASK_ALL
)
3500 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3506 /* Main function. This is called by the real "main" function,
3507 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3509 static void ATTRIBUTE_NORETURN
3510 captured_main (int argc
, char *argv
[])
3514 char *arg_end
, *port
;
3515 char **next_arg
= &argv
[1];
3516 volatile int multi_mode
= 0;
3517 volatile int attach
= 0;
3520 while (*next_arg
!= NULL
&& **next_arg
== '-')
3522 if (strcmp (*next_arg
, "--version") == 0)
3524 gdbserver_version ();
3527 else if (strcmp (*next_arg
, "--help") == 0)
3529 gdbserver_usage (stdout
);
3532 else if (strcmp (*next_arg
, "--attach") == 0)
3534 else if (strcmp (*next_arg
, "--multi") == 0)
3536 else if (strcmp (*next_arg
, "--wrapper") == 0)
3540 wrapper_argv
= next_arg
;
3541 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3544 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3546 gdbserver_usage (stderr
);
3550 /* Consume the "--". */
3553 else if (strcmp (*next_arg
, "--debug") == 0)
3555 else if (startswith (*next_arg
, "--debug-format="))
3558 = parse_debug_format_options ((*next_arg
)
3559 + sizeof ("--debug-format=") - 1, 0);
3561 if (error_msg
!= NULL
)
3563 fprintf (stderr
, "%s", error_msg
);
3567 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3569 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3571 gdbserver_show_disableable (stdout
);
3574 else if (startswith (*next_arg
, "--disable-packet="))
3576 char *packets
, *tok
;
3578 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3579 for (tok
= strtok (packets
, ",");
3581 tok
= strtok (NULL
, ","))
3583 if (strcmp ("vCont", tok
) == 0)
3584 disable_packet_vCont
= 1;
3585 else if (strcmp ("Tthread", tok
) == 0)
3586 disable_packet_Tthread
= 1;
3587 else if (strcmp ("qC", tok
) == 0)
3588 disable_packet_qC
= 1;
3589 else if (strcmp ("qfThreadInfo", tok
) == 0)
3590 disable_packet_qfThreadInfo
= 1;
3591 else if (strcmp ("threads", tok
) == 0)
3593 disable_packet_vCont
= 1;
3594 disable_packet_Tthread
= 1;
3595 disable_packet_qC
= 1;
3596 disable_packet_qfThreadInfo
= 1;
3600 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3602 gdbserver_show_disableable (stderr
);
3607 else if (strcmp (*next_arg
, "-") == 0)
3609 /* "-" specifies a stdio connection and is a form of port
3611 *next_arg
= STDIO_CONNECTION_NAME
;
3614 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3615 disable_randomization
= 1;
3616 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3617 disable_randomization
= 0;
3618 else if (strcmp (*next_arg
, "--once") == 0)
3622 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3632 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3634 gdbserver_usage (stderr
);
3638 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3639 opened by remote_prepare. */
3642 save_original_signals_state ();
3644 /* We need to know whether the remote connection is stdio before
3645 starting the inferior. Inferiors created in this scenario have
3646 stdin,stdout redirected. So do this here before we call
3648 remote_prepare (port
);
3653 /* --attach used to come after PORT, so allow it there for
3655 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3662 && (*next_arg
== NULL
3663 || (*next_arg
)[0] == '\0'
3664 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3666 || next_arg
[1] != NULL
))
3671 gdbserver_usage (stderr
);
3675 initialize_async_io ();
3677 initialize_event_loop ();
3678 if (target_supports_tracepoints ())
3679 initialize_tracepoint ();
3680 initialize_notif ();
3682 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3683 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3685 if (pid
== 0 && *next_arg
!= NULL
)
3689 n
= argc
- (next_arg
- argv
);
3690 program_argv
= XNEWVEC (char *, n
+ 1);
3691 for (i
= 0; i
< n
; i
++)
3692 program_argv
[i
] = xstrdup (next_arg
[i
]);
3693 program_argv
[i
] = NULL
;
3695 /* Wait till we are at first instruction in program. */
3696 start_inferior (program_argv
);
3698 /* We are now (hopefully) stopped at the first instruction of
3699 the target process. This assumes that the target process was
3700 successfully created. */
3704 if (attach_inferior (pid
) == -1)
3705 error ("Attaching not supported on this target");
3707 /* Otherwise succeeded. */
3711 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3712 last_status
.value
.integer
= 0;
3713 last_ptid
= minus_one_ptid
;
3715 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3717 /* Don't report shared library events on the initial connection,
3718 even if some libraries are preloaded. Avoids the "stopped by
3719 shared library event" notice on gdb side. */
3722 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3723 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3728 if (!was_running
&& !multi_mode
)
3729 error ("No program to debug");
3736 report_fork_events
= 0;
3737 report_vfork_events
= 0;
3738 report_exec_events
= 0;
3739 /* Be sure we're out of tfind mode. */
3740 current_traceframe
= -1;
3741 cont_thread
= null_ptid
;
3742 swbreak_feature
= 0;
3743 hwbreak_feature
= 0;
3744 vCont_supported
= 0;
3750 /* Wait for events. This will return when all event sources
3751 are removed from the event loop. */
3752 start_event_loop ();
3754 /* If an exit was requested (using the "monitor exit"
3755 command), terminate now. */
3757 throw_quit ("Quit");
3759 /* The only other way to get here is for getpkt to fail:
3761 - If --once was specified, we're done.
3763 - If not in extended-remote mode, and we're no longer
3764 debugging anything, simply exit: GDB has disconnected
3765 after processing the last process exit.
3767 - Otherwise, close the connection and reopen it at the
3769 if (run_once
|| (!extended_protocol
&& !target_running ()))
3770 throw_quit ("Quit");
3773 "Remote side has terminated connection. "
3774 "GDBserver will reopen the connection.\n");
3776 /* Get rid of any pending statuses. An eventual reconnection
3777 (by the same GDB instance or another) will refresh all its
3778 state from scratch. */
3779 discard_queued_stop_replies (minus_one_ptid
);
3780 for_each_inferior (&all_threads
,
3781 clear_pending_status_callback
);
3785 if (disconnected_tracing
)
3787 /* Try to enable non-stop/async mode, so we we can
3788 both wait for an async socket accept, and handle
3789 async target events simultaneously. There's also
3790 no point either in having the target always stop
3791 all threads, when we're going to pass signals
3792 down without informing GDB. */
3795 if (start_non_stop (1))
3798 /* Detaching implicitly resumes all threads;
3799 simply disconnecting does not. */
3805 "Disconnected tracing disabled; "
3806 "stopping trace run.\n");
3811 CATCH (exception
, RETURN_MASK_ERROR
)
3814 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3816 if (response_needed
)
3818 write_enn (own_buf
);
3823 throw_quit ("Quit");
3829 /* Main function. */
3832 main (int argc
, char *argv
[])
3837 captured_main (argc
, argv
);
3839 CATCH (exception
, RETURN_MASK_ALL
)
3841 if (exception
.reason
== RETURN_ERROR
)
3844 fprintf (stderr
, "%s\n", exception
.message
);
3845 fprintf (stderr
, "Exiting\n");
3853 gdb_assert_not_reached ("captured_main should never return");
3856 /* Process options coming from Z packets for a breakpoint. PACKET is
3857 the packet buffer. *PACKET is updated to point to the first char
3858 after the last processed option. */
3861 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3863 char *dataptr
= *packet
;
3866 /* Check if data has the correct format. */
3867 if (*dataptr
!= ';')
3874 if (*dataptr
== ';')
3877 if (*dataptr
== 'X')
3879 /* Conditional expression. */
3881 debug_printf ("Found breakpoint condition.\n");
3882 if (!add_breakpoint_condition (bp
, &dataptr
))
3883 dataptr
= strchrnul (dataptr
, ';');
3885 else if (startswith (dataptr
, "cmds:"))
3887 dataptr
+= strlen ("cmds:");
3889 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3890 persist
= (*dataptr
== '1');
3892 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3893 dataptr
= strchrnul (dataptr
, ';');
3897 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3899 /* Skip tokens until we find one that we recognize. */
3900 dataptr
= strchrnul (dataptr
, ';');
3906 /* Event loop callback that handles a serial event. The first byte in
3907 the serial buffer gets us here. We expect characters to arrive at
3908 a brisk pace, so we read the rest of the packet with a blocking
3912 process_serial_event (void)
3923 int new_packet_len
= -1;
3925 disable_async_io ();
3927 response_needed
= 0;
3928 packet_len
= getpkt (own_buf
);
3929 if (packet_len
<= 0)
3932 /* Force an event loop break. */
3935 response_needed
= 1;
3942 handle_query (own_buf
, packet_len
, &new_packet_len
);
3945 handle_general_set (own_buf
);
3948 require_running (own_buf
);
3953 pid
= strtol (&own_buf
[i
], NULL
, 16);
3956 pid
= ptid_get_pid (current_ptid
);
3958 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3960 struct process_info
*process
= find_process_pid (pid
);
3962 if (process
== NULL
)
3964 write_enn (own_buf
);
3968 if (tracing
&& disconnected_tracing
)
3970 "Disconnected tracing in effect, "
3971 "leaving gdbserver attached to the process\n");
3973 if (any_persistent_commands ())
3975 "Persistent commands are present, "
3976 "leaving gdbserver attached to the process\n");
3978 /* Make sure we're in non-stop/async mode, so we we can both
3979 wait for an async socket accept, and handle async target
3980 events simultaneously. There's also no point either in
3981 having the target stop all threads, when we're going to
3982 pass signals down without informing GDB. */
3986 debug_printf ("Forcing non-stop mode\n");
3992 process
->gdb_detached
= 1;
3994 /* Detaching implicitly resumes all threads. */
3995 target_continue_no_signal (minus_one_ptid
);
3998 break; /* from switch/case */
4001 fprintf (stderr
, "Detaching from process %d\n", pid
);
4003 if (detach_inferior (pid
) != 0)
4004 write_enn (own_buf
);
4007 discard_queued_stop_replies (pid_to_ptid (pid
));
4010 if (extended_protocol
|| target_running ())
4012 /* There is still at least one inferior remaining or
4013 we are in extended mode, so don't terminate gdbserver,
4014 and instead treat this like a normal program exit. */
4015 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4016 last_status
.value
.integer
= 0;
4017 last_ptid
= pid_to_ptid (pid
);
4019 current_thread
= NULL
;
4026 /* If we are attached, then we can exit. Otherwise, we
4027 need to hang around doing nothing, until the child is
4029 join_inferior (pid
);
4035 extended_protocol
= 1;
4039 handle_status (own_buf
);
4042 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4044 ptid_t gdb_id
, thread_id
;
4047 require_running (own_buf
);
4049 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4051 pid
= ptid_get_pid (gdb_id
);
4053 if (ptid_equal (gdb_id
, null_ptid
)
4054 || ptid_equal (gdb_id
, minus_one_ptid
))
4055 thread_id
= null_ptid
;
4057 && ptid_equal (pid_to_ptid (pid
),
4060 struct thread_info
*thread
=
4061 (struct thread_info
*) find_inferior (&all_threads
,
4066 write_enn (own_buf
);
4070 thread_id
= thread
->entry
.id
;
4074 thread_id
= gdb_id_to_thread_id (gdb_id
);
4075 if (ptid_equal (thread_id
, null_ptid
))
4077 write_enn (own_buf
);
4082 if (own_buf
[1] == 'g')
4084 if (ptid_equal (thread_id
, null_ptid
))
4086 /* GDB is telling us to choose any thread. Check if
4087 the currently selected thread is still valid. If
4088 it is not, select the first available. */
4089 struct thread_info
*thread
=
4090 (struct thread_info
*) find_inferior_id (&all_threads
,
4093 thread
= get_first_thread ();
4094 thread_id
= thread
->entry
.id
;
4097 general_thread
= thread_id
;
4098 set_desired_thread (1);
4099 gdb_assert (current_thread
!= NULL
);
4101 else if (own_buf
[1] == 'c')
4102 cont_thread
= thread_id
;
4108 /* Silently ignore it so that gdb can extend the protocol
4109 without compatibility headaches. */
4114 require_running (own_buf
);
4115 if (current_traceframe
>= 0)
4117 struct regcache
*regcache
4118 = new_register_cache (current_target_desc ());
4120 if (fetch_traceframe_registers (current_traceframe
,
4122 registers_to_string (regcache
, own_buf
);
4124 write_enn (own_buf
);
4125 free_register_cache (regcache
);
4129 struct regcache
*regcache
;
4131 if (!set_desired_thread (1))
4132 write_enn (own_buf
);
4135 regcache
= get_thread_regcache (current_thread
, 1);
4136 registers_to_string (regcache
, own_buf
);
4141 require_running (own_buf
);
4142 if (current_traceframe
>= 0)
4143 write_enn (own_buf
);
4146 struct regcache
*regcache
;
4148 if (!set_desired_thread (1))
4149 write_enn (own_buf
);
4152 regcache
= get_thread_regcache (current_thread
, 1);
4153 registers_from_string (regcache
, &own_buf
[1]);
4159 require_running (own_buf
);
4160 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4161 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4163 write_enn (own_buf
);
4165 bin2hex (mem_buf
, own_buf
, res
);
4168 require_running (own_buf
);
4169 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4170 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4173 write_enn (own_buf
);
4176 require_running (own_buf
);
4177 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4178 &mem_addr
, &len
, &mem_buf
) < 0
4179 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4180 write_enn (own_buf
);
4185 require_running (own_buf
);
4186 hex2bin (own_buf
+ 1, &sig
, 1);
4187 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4188 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4191 myresume (own_buf
, 0, signal
);
4194 require_running (own_buf
);
4195 hex2bin (own_buf
+ 1, &sig
, 1);
4196 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4197 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4200 myresume (own_buf
, 1, signal
);
4203 require_running (own_buf
);
4205 myresume (own_buf
, 0, signal
);
4208 require_running (own_buf
);
4210 myresume (own_buf
, 1, signal
);
4212 case 'Z': /* insert_ ... */
4214 case 'z': /* remove_ ... */
4219 char type
= own_buf
[1];
4221 const int insert
= ch
== 'Z';
4222 char *p
= &own_buf
[3];
4224 p
= unpack_varlen_hex (p
, &addr
);
4225 kind
= strtol (p
+ 1, &dataptr
, 16);
4229 struct gdb_breakpoint
*bp
;
4231 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4236 /* GDB may have sent us a list of *point parameters to
4237 be evaluated on the target's side. Read such list
4238 here. If we already have a list of parameters, GDB
4239 is telling us to drop that list and use this one
4241 clear_breakpoint_conditions_and_commands (bp
);
4242 process_point_options (bp
, &dataptr
);
4246 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4254 write_enn (own_buf
);
4258 response_needed
= 0;
4259 if (!target_running ())
4260 /* The packet we received doesn't make sense - but we can't
4261 reply to it, either. */
4264 fprintf (stderr
, "Killing all inferiors\n");
4265 for_each_inferior (&all_processes
, kill_inferior_callback
);
4267 /* When using the extended protocol, we wait with no program
4268 running. The traditional protocol will exit instead. */
4269 if (extended_protocol
)
4271 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4272 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4280 ptid_t gdb_id
, thread_id
;
4282 require_running (own_buf
);
4284 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4285 thread_id
= gdb_id_to_thread_id (gdb_id
);
4286 if (ptid_equal (thread_id
, null_ptid
))
4288 write_enn (own_buf
);
4292 if (mythread_alive (thread_id
))
4295 write_enn (own_buf
);
4299 response_needed
= 0;
4301 /* Restarting the inferior is only supported in the extended
4303 if (extended_protocol
)
4305 if (target_running ())
4306 for_each_inferior (&all_processes
,
4307 kill_inferior_callback
);
4308 fprintf (stderr
, "GDBserver restarting\n");
4310 /* Wait till we are at 1st instruction in prog. */
4311 if (program_argv
!= NULL
)
4313 start_inferior (program_argv
);
4314 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4316 /* Stopped at the first instruction of the target
4318 general_thread
= last_ptid
;
4322 /* Something went wrong. */
4323 general_thread
= null_ptid
;
4328 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4329 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4335 /* It is a request we don't understand. Respond with an
4336 empty packet so that gdb knows that we don't support this
4342 /* Extended (long) request. */
4343 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4347 /* It is a request we don't understand. Respond with an empty
4348 packet so that gdb knows that we don't support this
4354 if (new_packet_len
!= -1)
4355 putpkt_binary (own_buf
, new_packet_len
);
4359 response_needed
= 0;
4367 /* Event-loop callback for serial events. */
4370 handle_serial_event (int err
, gdb_client_data client_data
)
4373 debug_printf ("handling possible serial event\n");
4375 /* Really handle it. */
4376 if (process_serial_event () < 0)
4379 /* Be sure to not change the selected thread behind GDB's back.
4380 Important in the non-stop mode asynchronous protocol. */
4381 set_desired_thread (1);
4386 /* Push a stop notification on the notification queue. */
4389 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4391 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4393 vstop_notif
->status
= *status
;
4394 vstop_notif
->ptid
= ptid
;
4395 /* Push Stop notification. */
4396 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4399 /* Event-loop callback for target events. */
4402 handle_target_event (int err
, gdb_client_data client_data
)
4405 debug_printf ("handling possible target event\n");
4407 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4410 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4412 if (gdb_connected () && report_no_resumed
)
4413 push_stop_notification (null_ptid
, &last_status
);
4415 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4417 int pid
= ptid_get_pid (last_ptid
);
4418 struct process_info
*process
= find_process_pid (pid
);
4419 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4421 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4422 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4424 mark_breakpoints_out (process
);
4425 target_mourn_inferior (last_ptid
);
4427 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4431 /* We're reporting this thread as stopped. Update its
4432 "want-stopped" state to what the client wants, until it
4433 gets a new resume action. */
4434 current_thread
->last_resume_kind
= resume_stop
;
4435 current_thread
->last_status
= last_status
;
4440 if (!target_running ())
4442 /* The last process exited. We're done. */
4446 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4447 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4448 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4452 /* A thread stopped with a signal, but gdb isn't
4453 connected to handle it. Pass it down to the
4454 inferior, as if it wasn't being traced. */
4455 enum gdb_signal signal
;
4458 debug_printf ("GDB not connected; forwarding event %d for"
4460 (int) last_status
.kind
,
4461 target_pid_to_str (last_ptid
));
4463 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4464 signal
= last_status
.value
.sig
;
4466 signal
= GDB_SIGNAL_0
;
4467 target_continue (last_ptid
, signal
);
4471 push_stop_notification (last_ptid
, &last_status
);
4474 /* Be sure to not change the selected thread behind GDB's back.
4475 Important in the non-stop mode asynchronous protocol. */
4476 set_desired_thread (1);