1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2016 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 fprintf (stderr
, "[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 fprintf (stderr
, "[%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 if (disable_randomization
)
766 fprintf (stderr
, "[address space randomization disabled]\n");
768 fprintf (stderr
, "[address space randomization enabled]\n");
775 if (target_supports_tracepoints ()
776 && handle_tracepoint_general_set (own_buf
))
779 if (startswith (own_buf
, "QAgent:"))
781 char *mode
= own_buf
+ strlen ("QAgent:");
784 if (strcmp (mode
, "0") == 0)
786 else if (strcmp (mode
, "1") == 0)
790 /* We don't know what this value is, so complain to GDB. */
791 sprintf (own_buf
, "E.Unknown QAgent value");
795 /* Update the flag. */
798 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
803 if (handle_btrace_general_set (own_buf
))
806 if (handle_btrace_conf_general_set (own_buf
))
809 if (startswith (own_buf
, "QThreadEvents:"))
811 char *mode
= own_buf
+ strlen ("QThreadEvents:");
812 enum tribool req
= TRIBOOL_UNKNOWN
;
814 if (strcmp (mode
, "0") == 0)
816 else if (strcmp (mode
, "1") == 0)
820 char *mode_copy
= xstrdup (mode
);
822 /* We don't know what this mode is, so complain to GDB. */
823 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
829 report_thread_events
= (req
== TRIBOOL_TRUE
);
833 const char *req_str
= report_thread_events
? "enabled" : "disabled";
835 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
842 /* Otherwise we didn't know what packet it was. Say we didn't
848 get_features_xml (const char *annex
)
850 const struct target_desc
*desc
= current_target_desc ();
852 /* `desc->xmltarget' defines what to return when looking for the
853 "target.xml" file. Its contents can either be verbatim XML code
854 (prefixed with a '@') or else the name of the actual XML file to
855 be used in place of "target.xml".
857 This variable is set up from the auto-generated
858 init_registers_... routine for the current target. */
860 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
862 if (*desc
->xmltarget
== '@')
863 return desc
->xmltarget
+ 1;
865 annex
= desc
->xmltarget
;
870 extern const char *const xml_builtin
[][2];
873 /* Look for the annex. */
874 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
875 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
878 if (xml_builtin
[i
][0] != NULL
)
879 return xml_builtin
[i
][1];
887 monitor_show_help (void)
889 monitor_output ("The following monitor commands are supported:\n");
890 monitor_output (" set debug <0|1>\n");
891 monitor_output (" Enable general debugging messages\n");
892 monitor_output (" set debug-hw-points <0|1>\n");
893 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
894 monitor_output (" set remote-debug <0|1>\n");
895 monitor_output (" Enable remote protocol debugging messages\n");
896 monitor_output (" set debug-format option1[,option2,...]\n");
897 monitor_output (" Add additional information to debugging messages\n");
898 monitor_output (" Options: all, none");
899 monitor_output (", timestamp");
900 monitor_output ("\n");
901 monitor_output (" exit\n");
902 monitor_output (" Quit GDBserver\n");
905 /* Read trace frame or inferior memory. Returns the number of bytes
906 actually read, zero when no further transfer is possible, and -1 on
907 error. Return of a positive value smaller than LEN does not
908 indicate there's no more to be read, only the end of the transfer.
909 E.g., when GDB reads memory from a traceframe, a first request may
910 be served from a memory block that does not cover the whole request
911 length. A following request gets the rest served from either
912 another block (of the same traceframe) or from the read-only
916 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
920 if (current_traceframe
>= 0)
923 ULONGEST length
= len
;
925 if (traceframe_read_mem (current_traceframe
,
926 memaddr
, myaddr
, len
, &nbytes
))
928 /* Data read from trace buffer, we're done. */
931 if (!in_readonly_region (memaddr
, length
))
933 /* Otherwise we have a valid readonly case, fall through. */
934 /* (assume no half-trace half-real blocks for now) */
937 res
= prepare_to_access_memory ();
940 if (set_desired_thread (1))
941 res
= read_inferior_memory (memaddr
, myaddr
, len
);
944 done_accessing_memory ();
946 return res
== 0 ? len
: -1;
952 /* Write trace frame or inferior memory. Actually, writing to trace
953 frames is forbidden. */
956 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
958 if (current_traceframe
>= 0)
964 ret
= prepare_to_access_memory ();
967 if (set_desired_thread (1))
968 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
971 done_accessing_memory ();
977 /* Subroutine of handle_search_memory to simplify it. */
980 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
981 gdb_byte
*pattern
, unsigned pattern_len
,
982 gdb_byte
*search_buf
,
983 unsigned chunk_size
, unsigned search_buf_size
,
984 CORE_ADDR
*found_addrp
)
986 /* Prime the search buffer. */
988 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
991 warning ("Unable to access %ld bytes of target "
992 "memory at 0x%lx, halting search.",
993 (long) search_buf_size
, (long) start_addr
);
997 /* Perform the search.
999 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1000 When we've scanned N bytes we copy the trailing bytes to the start and
1001 read in another N bytes. */
1003 while (search_space_len
>= pattern_len
)
1005 gdb_byte
*found_ptr
;
1006 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1010 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1013 if (found_ptr
!= NULL
)
1015 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1016 *found_addrp
= found_addr
;
1020 /* Not found in this chunk, skip to next chunk. */
1022 /* Don't let search_space_len wrap here, it's unsigned. */
1023 if (search_space_len
>= chunk_size
)
1024 search_space_len
-= chunk_size
;
1026 search_space_len
= 0;
1028 if (search_space_len
>= pattern_len
)
1030 unsigned keep_len
= search_buf_size
- chunk_size
;
1031 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1034 /* Copy the trailing part of the previous iteration to the front
1035 of the buffer for the next iteration. */
1036 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1038 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1039 ? search_space_len
- keep_len
1042 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1043 nr_to_read
) != search_buf_size
)
1045 warning ("Unable to access %ld bytes of target memory "
1046 "at 0x%lx, halting search.",
1047 (long) nr_to_read
, (long) read_addr
);
1051 start_addr
+= chunk_size
;
1060 /* Handle qSearch:memory packets. */
1063 handle_search_memory (char *own_buf
, int packet_len
)
1065 CORE_ADDR start_addr
;
1066 CORE_ADDR search_space_len
;
1068 unsigned int pattern_len
;
1069 /* NOTE: also defined in find.c testcase. */
1070 #define SEARCH_CHUNK_SIZE 16000
1071 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1072 /* Buffer to hold memory contents for searching. */
1073 gdb_byte
*search_buf
;
1074 unsigned search_buf_size
;
1076 CORE_ADDR found_addr
;
1077 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1079 pattern
= (gdb_byte
*) malloc (packet_len
);
1080 if (pattern
== NULL
)
1082 error ("Unable to allocate memory to perform the search");
1083 strcpy (own_buf
, "E00");
1086 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1087 packet_len
- cmd_name_len
,
1088 &start_addr
, &search_space_len
,
1089 pattern
, &pattern_len
) < 0)
1092 error ("Error in parsing qSearch:memory packet");
1093 strcpy (own_buf
, "E00");
1097 search_buf_size
= chunk_size
+ pattern_len
- 1;
1099 /* No point in trying to allocate a buffer larger than the search space. */
1100 if (search_space_len
< search_buf_size
)
1101 search_buf_size
= search_space_len
;
1103 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1104 if (search_buf
== NULL
)
1107 error ("Unable to allocate memory to perform the search");
1108 strcpy (own_buf
, "E00");
1112 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1113 pattern
, pattern_len
,
1114 search_buf
, chunk_size
, search_buf_size
,
1118 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1119 else if (found
== 0)
1120 strcpy (own_buf
, "0");
1122 strcpy (own_buf
, "E00");
1128 #define require_running(BUF) \
1129 if (!target_running ()) \
1135 /* Parse options to --debug-format= and "monitor set debug-format".
1136 ARG is the text after "--debug-format=" or "monitor set debug-format".
1137 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1138 This triggers calls to monitor_output.
1139 The result is NULL if all options were parsed ok, otherwise an error
1140 message which the caller must free.
1142 N.B. These commands affect all debug format settings, they are not
1143 cumulative. If a format is not specified, it is turned off.
1144 However, we don't go to extra trouble with things like
1145 "monitor set debug-format all,none,timestamp".
1146 Instead we just parse them one at a time, in order.
1148 The syntax for "monitor set debug" we support here is not identical
1149 to gdb's "set debug foo on|off" because we also use this function to
1150 parse "--debug-format=foo,bar". */
1153 parse_debug_format_options (const char *arg
, int is_monitor
)
1155 VEC (char_ptr
) *options
;
1159 /* First turn all debug format options off. */
1160 debug_timestamp
= 0;
1162 /* First remove leading spaces, for "monitor set debug-format". */
1163 while (isspace (*arg
))
1166 options
= delim_string_to_char_ptr_vec (arg
, ',');
1168 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1170 if (strcmp (option
, "all") == 0)
1172 debug_timestamp
= 1;
1174 monitor_output ("All extra debug format options enabled.\n");
1176 else if (strcmp (option
, "none") == 0)
1178 debug_timestamp
= 0;
1180 monitor_output ("All extra debug format options disabled.\n");
1182 else if (strcmp (option
, "timestamp") == 0)
1184 debug_timestamp
= 1;
1186 monitor_output ("Timestamps will be added to debug output.\n");
1188 else if (*option
== '\0')
1190 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1195 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1198 free_char_ptr_vec (options
);
1203 free_char_ptr_vec (options
);
1207 /* Handle monitor commands not handled by target-specific handlers. */
1210 handle_monitor_command (char *mon
, char *own_buf
)
1212 if (strcmp (mon
, "set debug 1") == 0)
1215 monitor_output ("Debug output enabled.\n");
1217 else if (strcmp (mon
, "set debug 0") == 0)
1220 monitor_output ("Debug output disabled.\n");
1222 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1224 show_debug_regs
= 1;
1225 monitor_output ("H/W point debugging output enabled.\n");
1227 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1229 show_debug_regs
= 0;
1230 monitor_output ("H/W point debugging output disabled.\n");
1232 else if (strcmp (mon
, "set remote-debug 1") == 0)
1235 monitor_output ("Protocol debug output enabled.\n");
1237 else if (strcmp (mon
, "set remote-debug 0") == 0)
1240 monitor_output ("Protocol debug output disabled.\n");
1242 else if (startswith (mon
, "set debug-format "))
1245 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1248 if (error_msg
!= NULL
)
1250 monitor_output (error_msg
);
1251 monitor_show_help ();
1252 write_enn (own_buf
);
1256 else if (strcmp (mon
, "help") == 0)
1257 monitor_show_help ();
1258 else if (strcmp (mon
, "exit") == 0)
1262 monitor_output ("Unknown monitor command.\n\n");
1263 monitor_show_help ();
1264 write_enn (own_buf
);
1268 /* Associates a callback with each supported qXfer'able object. */
1272 /* The object this handler handles. */
1275 /* Request that the target transfer up to LEN 8-bit bytes of the
1276 target's OBJECT. The OFFSET, for a seekable object, specifies
1277 the starting point. The ANNEX can be used to provide additional
1278 data-specific information to the target.
1280 Return the number of bytes actually transfered, zero when no
1281 further transfer is possible, -1 on error, -2 when the transfer
1282 is not supported, and -3 on a verbose error message that should
1283 be preserved. Return of a positive value smaller than LEN does
1284 not indicate the end of the object, only the end of the transfer.
1286 One, and only one, of readbuf or writebuf must be non-NULL. */
1287 int (*xfer
) (const char *annex
,
1288 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1289 ULONGEST offset
, LONGEST len
);
1292 /* Handle qXfer:auxv:read. */
1295 handle_qxfer_auxv (const char *annex
,
1296 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1297 ULONGEST offset
, LONGEST len
)
1299 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1302 if (annex
[0] != '\0' || current_thread
== NULL
)
1305 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1308 /* Handle qXfer:exec-file:read. */
1311 handle_qxfer_exec_file (const char *const_annex
,
1312 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1313 ULONGEST offset
, LONGEST len
)
1319 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1322 if (const_annex
[0] == '\0')
1324 if (current_thread
== NULL
)
1327 pid
= pid_of (current_thread
);
1331 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1333 strcpy (annex
, const_annex
);
1334 annex
= unpack_varlen_hex (annex
, &pid
);
1336 if (annex
[0] != '\0')
1343 file
= (*the_target
->pid_to_exec_file
) (pid
);
1347 total_len
= strlen (file
);
1349 if (offset
> total_len
)
1352 if (offset
+ len
> total_len
)
1353 len
= total_len
- offset
;
1355 memcpy (readbuf
, file
+ offset
, len
);
1359 /* Handle qXfer:features:read. */
1362 handle_qxfer_features (const char *annex
,
1363 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1364 ULONGEST offset
, LONGEST len
)
1366 const char *document
;
1369 if (writebuf
!= NULL
)
1372 if (!target_running ())
1375 /* Grab the correct annex. */
1376 document
= get_features_xml (annex
);
1377 if (document
== NULL
)
1380 total_len
= strlen (document
);
1382 if (offset
> total_len
)
1385 if (offset
+ len
> total_len
)
1386 len
= total_len
- offset
;
1388 memcpy (readbuf
, document
+ offset
, len
);
1392 /* Worker routine for handle_qxfer_libraries.
1393 Add to the length pointed to by ARG a conservative estimate of the
1394 length needed to transmit the file name of INF. */
1397 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1399 struct dll_info
*dll
= (struct dll_info
*) inf
;
1400 unsigned int *total_len
= (unsigned int *) arg
;
1402 /* Over-estimate the necessary memory. Assume that every character
1403 in the library name must be escaped. */
1404 *total_len
+= 128 + 6 * strlen (dll
->name
);
1407 /* Worker routine for handle_qxfer_libraries.
1408 Emit the XML to describe the library in INF. */
1411 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1413 struct dll_info
*dll
= (struct dll_info
*) inf
;
1414 char **p_ptr
= (char **) arg
;
1418 strcpy (p
, " <library name=\"");
1420 name
= xml_escape_text (dll
->name
);
1424 strcpy (p
, "\"><segment address=\"");
1426 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1428 strcpy (p
, "\"/></library>\n");
1434 /* Handle qXfer:libraries:read. */
1437 handle_qxfer_libraries (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
)
1441 unsigned int total_len
;
1444 if (writebuf
!= NULL
)
1447 if (annex
[0] != '\0' || current_thread
== NULL
)
1451 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1454 document
= (char *) malloc (total_len
);
1455 if (document
== NULL
)
1458 strcpy (document
, "<library-list version=\"1.0\">\n");
1459 p
= document
+ strlen (document
);
1461 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1463 strcpy (p
, "</library-list>\n");
1465 total_len
= strlen (document
);
1467 if (offset
> total_len
)
1473 if (offset
+ len
> total_len
)
1474 len
= total_len
- offset
;
1476 memcpy (readbuf
, document
+ offset
, len
);
1481 /* Handle qXfer:libraries-svr4:read. */
1484 handle_qxfer_libraries_svr4 (const char *annex
,
1485 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1486 ULONGEST offset
, LONGEST len
)
1488 if (writebuf
!= NULL
)
1491 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1494 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1497 /* Handle qXfer:osadata:read. */
1500 handle_qxfer_osdata (const char *annex
,
1501 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1502 ULONGEST offset
, LONGEST len
)
1504 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1507 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1510 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1513 handle_qxfer_siginfo (const char *annex
,
1514 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1515 ULONGEST offset
, LONGEST len
)
1517 if (the_target
->qxfer_siginfo
== NULL
)
1520 if (annex
[0] != '\0' || current_thread
== NULL
)
1523 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1526 /* Handle qXfer:spu:read and qXfer:spu:write. */
1529 handle_qxfer_spu (const char *annex
,
1530 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1531 ULONGEST offset
, LONGEST len
)
1533 if (the_target
->qxfer_spu
== NULL
)
1536 if (current_thread
== NULL
)
1539 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1542 /* Handle qXfer:statictrace:read. */
1545 handle_qxfer_statictrace (const char *annex
,
1546 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1547 ULONGEST offset
, LONGEST len
)
1551 if (writebuf
!= NULL
)
1554 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1557 if (traceframe_read_sdata (current_traceframe
, offset
,
1558 readbuf
, len
, &nbytes
))
1563 /* Helper for handle_qxfer_threads_proper.
1564 Emit the XML to describe the thread of INF. */
1567 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1569 struct thread_info
*thread
= (struct thread_info
*) inf
;
1570 struct buffer
*buffer
= (struct buffer
*) arg
;
1571 ptid_t ptid
= thread_to_gdb_id (thread
);
1573 int core
= target_core_of_thread (ptid
);
1575 const char *name
= target_thread_name (ptid
);
1577 write_ptid (ptid_s
, ptid
);
1579 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1583 sprintf (core_s
, "%d", core
);
1584 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1588 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1590 buffer_xml_printf (buffer
, "/>\n");
1593 /* Helper for handle_qxfer_threads. */
1596 handle_qxfer_threads_proper (struct buffer
*buffer
)
1598 buffer_grow_str (buffer
, "<threads>\n");
1600 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1603 buffer_grow_str0 (buffer
, "</threads>\n");
1606 /* Handle qXfer:threads:read. */
1609 handle_qxfer_threads (const char *annex
,
1610 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1611 ULONGEST offset
, LONGEST len
)
1613 static char *result
= 0;
1614 static unsigned int result_length
= 0;
1616 if (writebuf
!= NULL
)
1619 if (annex
[0] != '\0')
1624 struct buffer buffer
;
1625 /* When asked for data at offset 0, generate everything and store into
1626 'result'. Successive reads will be served off 'result'. */
1630 buffer_init (&buffer
);
1632 handle_qxfer_threads_proper (&buffer
);
1634 result
= buffer_finish (&buffer
);
1635 result_length
= strlen (result
);
1636 buffer_free (&buffer
);
1639 if (offset
>= result_length
)
1641 /* We're out of data. */
1648 if (len
> result_length
- offset
)
1649 len
= result_length
- offset
;
1651 memcpy (readbuf
, result
+ offset
, len
);
1656 /* Handle qXfer:traceframe-info:read. */
1659 handle_qxfer_traceframe_info (const char *annex
,
1660 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1661 ULONGEST offset
, LONGEST len
)
1663 static char *result
= 0;
1664 static unsigned int result_length
= 0;
1666 if (writebuf
!= NULL
)
1669 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1674 struct buffer buffer
;
1676 /* When asked for data at offset 0, generate everything and
1677 store into 'result'. Successive reads will be served off
1681 buffer_init (&buffer
);
1683 traceframe_read_info (current_traceframe
, &buffer
);
1685 result
= buffer_finish (&buffer
);
1686 result_length
= strlen (result
);
1687 buffer_free (&buffer
);
1690 if (offset
>= result_length
)
1692 /* We're out of data. */
1699 if (len
> result_length
- offset
)
1700 len
= result_length
- offset
;
1702 memcpy (readbuf
, result
+ offset
, len
);
1706 /* Handle qXfer:fdpic:read. */
1709 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1710 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1712 if (the_target
->read_loadmap
== NULL
)
1715 if (current_thread
== NULL
)
1718 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1721 /* Handle qXfer:btrace:read. */
1724 handle_qxfer_btrace (const char *annex
,
1725 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1726 ULONGEST offset
, LONGEST len
)
1728 static struct buffer cache
;
1729 struct thread_info
*thread
;
1730 enum btrace_read_type type
;
1733 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1736 if (ptid_equal (general_thread
, null_ptid
)
1737 || ptid_equal (general_thread
, minus_one_ptid
))
1739 strcpy (own_buf
, "E.Must select a single thread.");
1743 thread
= find_thread_ptid (general_thread
);
1746 strcpy (own_buf
, "E.No such thread.");
1750 if (thread
->btrace
== NULL
)
1752 strcpy (own_buf
, "E.Btrace not enabled.");
1756 if (strcmp (annex
, "all") == 0)
1757 type
= BTRACE_READ_ALL
;
1758 else if (strcmp (annex
, "new") == 0)
1759 type
= BTRACE_READ_NEW
;
1760 else if (strcmp (annex
, "delta") == 0)
1761 type
= BTRACE_READ_DELTA
;
1764 strcpy (own_buf
, "E.Bad annex.");
1770 buffer_free (&cache
);
1772 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1775 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1779 else if (offset
> cache
.used_size
)
1781 buffer_free (&cache
);
1785 if (len
> cache
.used_size
- offset
)
1786 len
= cache
.used_size
- offset
;
1788 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1793 /* Handle qXfer:btrace-conf:read. */
1796 handle_qxfer_btrace_conf (const char *annex
,
1797 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1798 ULONGEST offset
, LONGEST len
)
1800 static struct buffer cache
;
1801 struct thread_info
*thread
;
1804 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1807 if (annex
[0] != '\0')
1810 if (ptid_equal (general_thread
, null_ptid
)
1811 || ptid_equal (general_thread
, minus_one_ptid
))
1813 strcpy (own_buf
, "E.Must select a single thread.");
1817 thread
= find_thread_ptid (general_thread
);
1820 strcpy (own_buf
, "E.No such thread.");
1824 if (thread
->btrace
== NULL
)
1826 strcpy (own_buf
, "E.Btrace not enabled.");
1832 buffer_free (&cache
);
1834 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1837 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1841 else if (offset
> cache
.used_size
)
1843 buffer_free (&cache
);
1847 if (len
> cache
.used_size
- offset
)
1848 len
= cache
.used_size
- offset
;
1850 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1855 static const struct qxfer qxfer_packets
[] =
1857 { "auxv", handle_qxfer_auxv
},
1858 { "btrace", handle_qxfer_btrace
},
1859 { "btrace-conf", handle_qxfer_btrace_conf
},
1860 { "exec-file", handle_qxfer_exec_file
},
1861 { "fdpic", handle_qxfer_fdpic
},
1862 { "features", handle_qxfer_features
},
1863 { "libraries", handle_qxfer_libraries
},
1864 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1865 { "osdata", handle_qxfer_osdata
},
1866 { "siginfo", handle_qxfer_siginfo
},
1867 { "spu", handle_qxfer_spu
},
1868 { "statictrace", handle_qxfer_statictrace
},
1869 { "threads", handle_qxfer_threads
},
1870 { "traceframe-info", handle_qxfer_traceframe_info
},
1874 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1882 if (!startswith (own_buf
, "qXfer:"))
1885 /* Grab the object, r/w and annex. */
1886 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1888 write_enn (own_buf
);
1893 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1896 const struct qxfer
*q
= &qxfer_packets
[i
];
1898 if (strcmp (object
, q
->object
) == 0)
1900 if (strcmp (rw
, "read") == 0)
1902 unsigned char *data
;
1907 /* Grab the offset and length. */
1908 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1910 write_enn (own_buf
);
1914 /* Read one extra byte, as an indicator of whether there is
1916 if (len
> PBUFSIZ
- 2)
1918 data
= (unsigned char *) malloc (len
+ 1);
1921 write_enn (own_buf
);
1924 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1932 /* Preserve error message. */
1935 write_enn (own_buf
);
1937 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1939 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1944 else if (strcmp (rw
, "write") == 0)
1949 unsigned char *data
;
1951 strcpy (own_buf
, "E00");
1952 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1955 write_enn (own_buf
);
1958 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1959 &ofs
, &len
, data
) < 0)
1962 write_enn (own_buf
);
1966 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1974 /* Preserve error message. */
1977 write_enn (own_buf
);
1979 sprintf (own_buf
, "%x", n
);
1992 /* Compute 32 bit CRC from inferior memory.
1994 On success, return 32 bit CRC.
1995 On failure, return (unsigned long long) -1. */
1997 static unsigned long long
1998 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2002 unsigned char byte
= 0;
2004 /* Return failure if memory read fails. */
2005 if (read_inferior_memory (base
, &byte
, 1) != 0)
2006 return (unsigned long long) -1;
2008 crc
= xcrc32 (&byte
, 1, crc
);
2011 return (unsigned long long) crc
;
2014 /* Add supported btrace packets to BUF. */
2017 supported_btrace_packets (char *buf
)
2019 int btrace_supported
= 0;
2021 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
2023 strcat (buf
, ";Qbtrace:bts+");
2024 strcat (buf
, ";Qbtrace-conf:bts:size+");
2026 btrace_supported
= 1;
2029 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2031 strcat (buf
, ";Qbtrace:pt+");
2032 strcat (buf
, ";Qbtrace-conf:pt:size+");
2034 btrace_supported
= 1;
2037 if (!btrace_supported
)
2040 strcat (buf
, ";Qbtrace:off+");
2041 strcat (buf
, ";qXfer:btrace:read+");
2042 strcat (buf
, ";qXfer:btrace-conf:read+");
2045 /* Handle all of the extended 'q' packets. */
2048 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2050 static struct inferior_list_entry
*thread_ptr
;
2052 /* Reply the current thread id. */
2053 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2056 require_running (own_buf
);
2058 if (!ptid_equal (general_thread
, null_ptid
)
2059 && !ptid_equal (general_thread
, minus_one_ptid
))
2060 gdb_id
= general_thread
;
2063 thread_ptr
= get_first_inferior (&all_threads
);
2064 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2067 sprintf (own_buf
, "QC");
2069 write_ptid (own_buf
, gdb_id
);
2073 if (strcmp ("qSymbol::", own_buf
) == 0)
2075 struct thread_info
*save_thread
= current_thread
;
2077 /* For qSymbol, GDB only changes the current thread if the
2078 previous current thread was of a different process. So if
2079 the previous thread is gone, we need to pick another one of
2080 the same process. This can happen e.g., if we followed an
2081 exec in a non-leader thread. */
2082 if (current_thread
== NULL
)
2085 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2087 /* Just in case, if we didn't find a thread, then bail out
2088 instead of crashing. */
2089 if (current_thread
== NULL
)
2091 write_enn (own_buf
);
2092 current_thread
= save_thread
;
2097 /* GDB is suggesting new symbols have been loaded. This may
2098 mean a new shared library has been detected as loaded, so
2099 take the opportunity to check if breakpoints we think are
2100 inserted, still are. Note that it isn't guaranteed that
2101 we'll see this when a shared library is loaded, and nor will
2102 we see this for unloads (although breakpoints in unloaded
2103 libraries shouldn't trigger), as GDB may not find symbols for
2104 the library at all. We also re-validate breakpoints when we
2105 see a second GDB breakpoint for the same address, and or when
2106 we access breakpoint shadows. */
2107 validate_breakpoints ();
2109 if (target_supports_tracepoints ())
2110 tracepoint_look_up_symbols ();
2112 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2113 (*the_target
->look_up_symbols
) ();
2115 current_thread
= save_thread
;
2117 strcpy (own_buf
, "OK");
2121 if (!disable_packet_qfThreadInfo
)
2123 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2127 require_running (own_buf
);
2128 thread_ptr
= get_first_inferior (&all_threads
);
2131 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2132 write_ptid (own_buf
, gdb_id
);
2133 thread_ptr
= thread_ptr
->next
;
2137 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2141 require_running (own_buf
);
2142 if (thread_ptr
!= NULL
)
2145 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2146 write_ptid (own_buf
, gdb_id
);
2147 thread_ptr
= thread_ptr
->next
;
2152 sprintf (own_buf
, "l");
2158 if (the_target
->read_offsets
!= NULL
2159 && strcmp ("qOffsets", own_buf
) == 0)
2161 CORE_ADDR text
, data
;
2163 require_running (own_buf
);
2164 if (the_target
->read_offsets (&text
, &data
))
2165 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2166 (long)text
, (long)data
, (long)data
);
2168 write_enn (own_buf
);
2173 /* Protocol features query. */
2174 if (startswith (own_buf
, "qSupported")
2175 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2177 char *p
= &own_buf
[10];
2178 int gdb_supports_qRelocInsn
= 0;
2180 /* Process each feature being provided by GDB. The first
2181 feature will follow a ':', and latter features will follow
2185 char **qsupported
= NULL
;
2190 /* Two passes, to avoid nested strtok calls in
2191 target_process_qsupported. */
2192 for (p
= strtok (p
+ 1, ";");
2194 p
= strtok (NULL
, ";"))
2197 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2198 qsupported
[count
- 1] = xstrdup (p
);
2201 for (i
= 0; i
< count
; i
++)
2204 if (strcmp (p
, "multiprocess+") == 0)
2206 /* GDB supports and wants multi-process support if
2208 if (target_supports_multi_process ())
2211 else if (strcmp (p
, "qRelocInsn+") == 0)
2213 /* GDB supports relocate instruction requests. */
2214 gdb_supports_qRelocInsn
= 1;
2216 else if (strcmp (p
, "swbreak+") == 0)
2218 /* GDB wants us to report whether a trap is caused
2219 by a software breakpoint and for us to handle PC
2220 adjustment if necessary on this target. */
2221 if (target_supports_stopped_by_sw_breakpoint ())
2222 swbreak_feature
= 1;
2224 else if (strcmp (p
, "hwbreak+") == 0)
2226 /* GDB wants us to report whether a trap is caused
2227 by a hardware breakpoint. */
2228 if (target_supports_stopped_by_hw_breakpoint ())
2229 hwbreak_feature
= 1;
2231 else if (strcmp (p
, "fork-events+") == 0)
2233 /* GDB supports and wants fork events if possible. */
2234 if (target_supports_fork_events ())
2235 report_fork_events
= 1;
2237 else if (strcmp (p
, "vfork-events+") == 0)
2239 /* GDB supports and wants vfork events if possible. */
2240 if (target_supports_vfork_events ())
2241 report_vfork_events
= 1;
2243 else if (strcmp (p
, "exec-events+") == 0)
2245 /* GDB supports and wants exec events if possible. */
2246 if (target_supports_exec_events ())
2247 report_exec_events
= 1;
2249 else if (strcmp (p
, "vContSupported+") == 0)
2250 vCont_supported
= 1;
2251 else if (strcmp (p
, "QThreadEvents+") == 0)
2253 else if (strcmp (p
, "no-resumed+") == 0)
2255 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2257 report_no_resumed
= 1;
2261 /* Move the unknown features all together. */
2262 qsupported
[i
] = NULL
;
2263 qsupported
[unknown
] = p
;
2268 /* Give the target backend a chance to process the unknown
2270 target_process_qsupported (qsupported
, unknown
);
2272 for (i
= 0; i
< count
; i
++)
2273 free (qsupported
[i
]);
2278 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2281 if (target_supports_catch_syscall ())
2282 strcat (own_buf
, ";QCatchSyscalls+");
2284 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2285 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2286 ";augmented-libraries-svr4-read+");
2289 /* We do not have any hook to indicate whether the non-SVR4 target
2290 backend supports qXfer:libraries:read, so always report it. */
2291 strcat (own_buf
, ";qXfer:libraries:read+");
2294 if (the_target
->read_auxv
!= NULL
)
2295 strcat (own_buf
, ";qXfer:auxv:read+");
2297 if (the_target
->qxfer_spu
!= NULL
)
2298 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2300 if (the_target
->qxfer_siginfo
!= NULL
)
2301 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2303 if (the_target
->read_loadmap
!= NULL
)
2304 strcat (own_buf
, ";qXfer:fdpic:read+");
2306 /* We always report qXfer:features:read, as targets may
2307 install XML files on a subsequent call to arch_setup.
2308 If we reported to GDB on startup that we don't support
2309 qXfer:feature:read at all, we will never be re-queried. */
2310 strcat (own_buf
, ";qXfer:features:read+");
2312 if (transport_is_reliable
)
2313 strcat (own_buf
, ";QStartNoAckMode+");
2315 if (the_target
->qxfer_osdata
!= NULL
)
2316 strcat (own_buf
, ";qXfer:osdata:read+");
2318 if (target_supports_multi_process ())
2319 strcat (own_buf
, ";multiprocess+");
2321 if (target_supports_fork_events ())
2322 strcat (own_buf
, ";fork-events+");
2324 if (target_supports_vfork_events ())
2325 strcat (own_buf
, ";vfork-events+");
2327 if (target_supports_exec_events ())
2328 strcat (own_buf
, ";exec-events+");
2330 if (target_supports_non_stop ())
2331 strcat (own_buf
, ";QNonStop+");
2333 if (target_supports_disable_randomization ())
2334 strcat (own_buf
, ";QDisableRandomization+");
2336 strcat (own_buf
, ";qXfer:threads:read+");
2338 if (target_supports_tracepoints ())
2340 strcat (own_buf
, ";ConditionalTracepoints+");
2341 strcat (own_buf
, ";TraceStateVariables+");
2342 strcat (own_buf
, ";TracepointSource+");
2343 strcat (own_buf
, ";DisconnectedTracing+");
2344 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2345 strcat (own_buf
, ";FastTracepoints+");
2346 strcat (own_buf
, ";StaticTracepoints+");
2347 strcat (own_buf
, ";InstallInTrace+");
2348 strcat (own_buf
, ";qXfer:statictrace:read+");
2349 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2350 strcat (own_buf
, ";EnableDisableTracepoints+");
2351 strcat (own_buf
, ";QTBuffer:size+");
2352 strcat (own_buf
, ";tracenz+");
2355 if (target_supports_hardware_single_step ()
2356 || target_supports_software_single_step () )
2358 strcat (own_buf
, ";ConditionalBreakpoints+");
2360 strcat (own_buf
, ";BreakpointCommands+");
2362 if (target_supports_agent ())
2363 strcat (own_buf
, ";QAgent+");
2365 supported_btrace_packets (own_buf
);
2367 if (target_supports_stopped_by_sw_breakpoint ())
2368 strcat (own_buf
, ";swbreak+");
2370 if (target_supports_stopped_by_hw_breakpoint ())
2371 strcat (own_buf
, ";hwbreak+");
2373 if (the_target
->pid_to_exec_file
!= NULL
)
2374 strcat (own_buf
, ";qXfer:exec-file:read+");
2376 strcat (own_buf
, ";vContSupported+");
2378 strcat (own_buf
, ";QThreadEvents+");
2380 strcat (own_buf
, ";no-resumed+");
2382 /* Reinitialize components as needed for the new connection. */
2383 hostio_handle_new_gdb_connection ();
2384 target_handle_new_gdb_connection ();
2389 /* Thread-local storage support. */
2390 if (the_target
->get_tls_address
!= NULL
2391 && startswith (own_buf
, "qGetTLSAddr:"))
2393 char *p
= own_buf
+ 12;
2394 CORE_ADDR parts
[2], address
= 0;
2396 ptid_t ptid
= null_ptid
;
2398 require_running (own_buf
);
2400 for (i
= 0; i
< 3; i
++)
2408 p2
= strchr (p
, ',');
2421 ptid
= read_ptid (p
, NULL
);
2423 decode_address (&parts
[i
- 1], p
, len
);
2427 if (p
!= NULL
|| i
< 3)
2431 struct thread_info
*thread
= find_thread_ptid (ptid
);
2436 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2442 strcpy (own_buf
, paddress(address
));
2447 write_enn (own_buf
);
2451 /* Otherwise, pretend we do not understand this packet. */
2454 /* Windows OS Thread Information Block address support. */
2455 if (the_target
->get_tib_address
!= NULL
2456 && startswith (own_buf
, "qGetTIBAddr:"))
2461 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2463 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2466 strcpy (own_buf
, paddress(tlb
));
2471 write_enn (own_buf
);
2477 /* Handle "monitor" commands. */
2478 if (startswith (own_buf
, "qRcmd,"))
2480 char *mon
= (char *) malloc (PBUFSIZ
);
2481 int len
= strlen (own_buf
+ 6);
2485 write_enn (own_buf
);
2490 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2492 write_enn (own_buf
);
2496 mon
[len
/ 2] = '\0';
2500 if (the_target
->handle_monitor_command
== NULL
2501 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2502 /* Default processing. */
2503 handle_monitor_command (mon
, own_buf
);
2509 if (startswith (own_buf
, "qSearch:memory:"))
2511 require_running (own_buf
);
2512 handle_search_memory (own_buf
, packet_len
);
2516 if (strcmp (own_buf
, "qAttached") == 0
2517 || startswith (own_buf
, "qAttached:"))
2519 struct process_info
*process
;
2521 if (own_buf
[sizeof ("qAttached") - 1])
2523 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2524 process
= (struct process_info
*)
2525 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2529 require_running (own_buf
);
2530 process
= current_process ();
2533 if (process
== NULL
)
2535 write_enn (own_buf
);
2539 strcpy (own_buf
, process
->attached
? "1" : "0");
2543 if (startswith (own_buf
, "qCRC:"))
2545 /* CRC check (compare-section). */
2549 unsigned long long crc
;
2551 require_running (own_buf
);
2552 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2553 if (*comma
++ != ',')
2555 write_enn (own_buf
);
2558 len
= strtoul (comma
, NULL
, 16);
2559 crc
= crc32 (base
, len
, 0xffffffff);
2560 /* Check for memory failure. */
2561 if (crc
== (unsigned long long) -1)
2563 write_enn (own_buf
);
2566 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2570 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2573 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2576 /* Otherwise we didn't know what packet it was. Say we didn't
2581 static void gdb_wants_all_threads_stopped (void);
2582 static void resume (struct thread_resume
*actions
, size_t n
);
2584 /* The callback that is passed to visit_actioned_threads. */
2585 typedef int (visit_actioned_threads_callback_ftype
)
2586 (const struct thread_resume
*, struct thread_info
*);
2588 /* Struct to pass data to visit_actioned_threads. */
2590 struct visit_actioned_threads_data
2592 const struct thread_resume
*actions
;
2594 visit_actioned_threads_callback_ftype
*callback
;
2597 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2598 true if CALLBACK returns true. Returns false if no matching thread
2599 is found or CALLBACK results false.
2600 Note: This function is itself a callback for find_inferior. */
2603 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2605 struct visit_actioned_threads_data
*data
2606 = (struct visit_actioned_threads_data
*) datap
;
2607 const struct thread_resume
*actions
= data
->actions
;
2608 size_t num_actions
= data
->num_actions
;
2609 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2612 for (i
= 0; i
< num_actions
; i
++)
2614 const struct thread_resume
*action
= &actions
[i
];
2616 if (ptid_equal (action
->thread
, minus_one_ptid
)
2617 || ptid_equal (action
->thread
, entry
->id
)
2618 || ((ptid_get_pid (action
->thread
)
2619 == ptid_get_pid (entry
->id
))
2620 && ptid_get_lwp (action
->thread
) == -1))
2622 struct thread_info
*thread
= (struct thread_info
*) entry
;
2624 if ((*callback
) (action
, thread
))
2632 /* Callback for visit_actioned_threads. If the thread has a pending
2633 status to report, report it now. */
2636 handle_pending_status (const struct thread_resume
*resumption
,
2637 struct thread_info
*thread
)
2639 if (thread
->status_pending_p
)
2641 thread
->status_pending_p
= 0;
2643 last_status
= thread
->last_status
;
2644 last_ptid
= thread
->entry
.id
;
2645 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2651 /* Parse vCont packets. */
2653 handle_v_cont (char *own_buf
)
2657 struct thread_resume
*resume_info
;
2658 struct thread_resume default_action
= {{0}};
2660 /* Count the number of semicolons in the packet. There should be one
2661 for every action. */
2667 p
= strchr (p
, ';');
2670 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2671 if (resume_info
== NULL
)
2679 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2681 if (p
[0] == 's' || p
[0] == 'S')
2682 resume_info
[i
].kind
= resume_step
;
2683 else if (p
[0] == 'r')
2684 resume_info
[i
].kind
= resume_step
;
2685 else if (p
[0] == 'c' || p
[0] == 'C')
2686 resume_info
[i
].kind
= resume_continue
;
2687 else if (p
[0] == 't')
2688 resume_info
[i
].kind
= resume_stop
;
2692 if (p
[0] == 'S' || p
[0] == 'C')
2695 sig
= strtol (p
+ 1, &q
, 16);
2700 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2702 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2704 else if (p
[0] == 'r')
2708 p
= unpack_varlen_hex (p
+ 1, &addr
);
2709 resume_info
[i
].step_range_start
= addr
;
2714 p
= unpack_varlen_hex (p
+ 1, &addr
);
2715 resume_info
[i
].step_range_end
= addr
;
2724 resume_info
[i
].thread
= minus_one_ptid
;
2725 default_action
= resume_info
[i
];
2727 /* Note: we don't increment i here, we'll overwrite this entry
2728 the next time through. */
2730 else if (p
[0] == ':')
2732 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2737 if (p
[0] != ';' && p
[0] != 0)
2740 resume_info
[i
].thread
= ptid
;
2747 resume_info
[i
] = default_action
;
2749 resume (resume_info
, n
);
2754 write_enn (own_buf
);
2759 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2762 resume (struct thread_resume
*actions
, size_t num_actions
)
2766 /* Check if among the threads that GDB wants actioned, there's
2767 one with a pending status to report. If so, skip actually
2768 resuming/stopping and report the pending event
2770 struct visit_actioned_threads_data data
;
2772 data
.actions
= actions
;
2773 data
.num_actions
= num_actions
;
2774 data
.callback
= handle_pending_status
;
2775 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2781 (*the_target
->resume
) (actions
, num_actions
);
2787 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2789 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2790 && !report_no_resumed
)
2792 /* The client does not support this stop reply. At least
2794 sprintf (own_buf
, "E.No unwaited-for children left.");
2795 disable_async_io ();
2799 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2800 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2801 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2802 current_thread
->last_status
= last_status
;
2804 /* From the client's perspective, all-stop mode always stops all
2805 threads implicitly (and the target backend has already done
2806 so by now). Tag all threads as "want-stopped", so we don't
2807 resume them implicitly without the client telling us to. */
2808 gdb_wants_all_threads_stopped ();
2809 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2810 disable_async_io ();
2812 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2813 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2814 target_mourn_inferior (last_ptid
);
2818 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2820 handle_v_attach (char *own_buf
)
2824 pid
= strtol (own_buf
+ 8, NULL
, 16);
2825 if (pid
!= 0 && attach_inferior (pid
) == 0)
2827 /* Don't report shared library events after attaching, even if
2828 some libraries are preloaded. GDB will always poll the
2829 library list. Avoids the "stopped by shared library event"
2830 notice on the GDB side. */
2835 /* In non-stop, we don't send a resume reply. Stop events
2836 will follow up using the normal notification
2841 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2847 write_enn (own_buf
);
2852 /* Run a new program. Return 1 if successful, 0 if failure. */
2854 handle_v_run (char *own_buf
)
2856 char *p
, *next_p
, **new_argv
;
2860 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2866 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2867 if (new_argv
== NULL
)
2869 write_enn (own_buf
);
2874 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2876 next_p
= strchr (p
, ';');
2878 next_p
= p
+ strlen (p
);
2880 if (i
== 0 && p
== next_p
)
2884 /* FIXME: Fail request if out of memory instead of dying. */
2885 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2886 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2887 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2896 if (new_argv
[0] == NULL
)
2898 /* GDB didn't specify a program to run. Use the program from the
2899 last run with the new argument list. */
2901 if (program_argv
== NULL
)
2903 write_enn (own_buf
);
2904 freeargv (new_argv
);
2908 new_argv
[0] = strdup (program_argv
[0]);
2909 if (new_argv
[0] == NULL
)
2911 write_enn (own_buf
);
2912 freeargv (new_argv
);
2917 /* Free the old argv and install the new one. */
2918 freeargv (program_argv
);
2919 program_argv
= new_argv
;
2921 start_inferior (program_argv
);
2922 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2924 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2926 /* In non-stop, sending a resume reply doesn't set the general
2927 thread, but GDB assumes a vRun sets it (this is so GDB can
2928 query which is the main thread of the new inferior. */
2930 general_thread
= last_ptid
;
2936 write_enn (own_buf
);
2941 /* Kill process. Return 1 if successful, 0 if failure. */
2943 handle_v_kill (char *own_buf
)
2946 char *p
= &own_buf
[6];
2948 pid
= strtol (p
, NULL
, 16);
2951 if (pid
!= 0 && kill_inferior (pid
) == 0)
2953 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2954 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2955 last_ptid
= pid_to_ptid (pid
);
2956 discard_queued_stop_replies (last_ptid
);
2962 write_enn (own_buf
);
2967 /* Handle all of the extended 'v' packets. */
2969 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2971 if (!disable_packet_vCont
)
2973 if (strcmp (own_buf
, "vCtrlC") == 0)
2975 (*the_target
->request_interrupt
) ();
2980 if (startswith (own_buf
, "vCont;"))
2982 handle_v_cont (own_buf
);
2986 if (startswith (own_buf
, "vCont?"))
2988 strcpy (own_buf
, "vCont;c;C;t");
2990 if (target_supports_hardware_single_step ()
2991 || target_supports_software_single_step ()
2992 || !vCont_supported
)
2994 /* If target supports single step either by hardware or by
2995 software, add actions s and S to the list of supported
2996 actions. On the other hand, if GDB doesn't request the
2997 supported vCont actions in qSupported packet, add s and
2998 S to the list too. */
2999 own_buf
= own_buf
+ strlen (own_buf
);
3000 strcpy (own_buf
, ";s;S");
3003 if (target_supports_range_stepping ())
3005 own_buf
= own_buf
+ strlen (own_buf
);
3006 strcpy (own_buf
, ";r");
3012 if (startswith (own_buf
, "vFile:")
3013 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3016 if (startswith (own_buf
, "vAttach;"))
3018 if ((!extended_protocol
|| !multi_process
) && target_running ())
3020 fprintf (stderr
, "Already debugging a process\n");
3021 write_enn (own_buf
);
3024 handle_v_attach (own_buf
);
3028 if (startswith (own_buf
, "vRun;"))
3030 if ((!extended_protocol
|| !multi_process
) && target_running ())
3032 fprintf (stderr
, "Already debugging a process\n");
3033 write_enn (own_buf
);
3036 handle_v_run (own_buf
);
3040 if (startswith (own_buf
, "vKill;"))
3042 if (!target_running ())
3044 fprintf (stderr
, "No process to kill\n");
3045 write_enn (own_buf
);
3048 handle_v_kill (own_buf
);
3052 if (handle_notif_ack (own_buf
, packet_len
))
3055 /* Otherwise we didn't know what packet it was. Say we didn't
3061 /* Resume thread and wait for another event. In non-stop mode,
3062 don't really wait here, but return immediatelly to the event
3065 myresume (char *own_buf
, int step
, int sig
)
3067 struct thread_resume resume_info
[2];
3069 int valid_cont_thread
;
3071 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3072 && !ptid_equal (cont_thread
, minus_one_ptid
));
3074 if (step
|| sig
|| valid_cont_thread
)
3076 resume_info
[0].thread
= current_ptid
;
3078 resume_info
[0].kind
= resume_step
;
3080 resume_info
[0].kind
= resume_continue
;
3081 resume_info
[0].sig
= sig
;
3085 if (!valid_cont_thread
)
3087 resume_info
[n
].thread
= minus_one_ptid
;
3088 resume_info
[n
].kind
= resume_continue
;
3089 resume_info
[n
].sig
= 0;
3093 resume (resume_info
, n
);
3096 /* Callback for for_each_inferior. Make a new stop reply for each
3100 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3102 struct thread_info
*thread
= (struct thread_info
*) entry
;
3104 /* For now, assume targets that don't have this callback also don't
3105 manage the thread's last_status field. */
3106 if (the_target
->thread_stopped
== NULL
)
3108 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3110 new_notif
->ptid
= entry
->id
;
3111 new_notif
->status
= thread
->last_status
;
3112 /* Pass the last stop reply back to GDB, but don't notify
3114 notif_event_enque (¬if_stop
,
3115 (struct notif_event
*) new_notif
);
3119 if (thread_stopped (thread
))
3124 = target_waitstatus_to_string (&thread
->last_status
);
3126 debug_printf ("Reporting thread %s as already stopped with %s\n",
3127 target_pid_to_str (entry
->id
),
3130 xfree (status_string
);
3133 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3135 /* Pass the last stop reply back to GDB, but don't notify
3137 queue_stop_reply (entry
->id
, &thread
->last_status
);
3144 /* Set this inferior threads's state as "want-stopped". We won't
3145 resume this thread until the client gives us another action for
3149 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3151 struct thread_info
*thread
= (struct thread_info
*) entry
;
3153 thread
->last_resume_kind
= resume_stop
;
3155 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3157 /* Most threads are stopped implicitly (all-stop); tag that with
3159 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3160 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3164 /* Set all threads' states as "want-stopped". */
3167 gdb_wants_all_threads_stopped (void)
3169 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3172 /* Clear the gdb_detached flag of every process. */
3175 gdb_reattached_process (struct inferior_list_entry
*entry
)
3177 struct process_info
*process
= (struct process_info
*) entry
;
3179 process
->gdb_detached
= 0;
3182 /* Callback for for_each_inferior. Clear the thread's pending status
3186 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3188 struct thread_info
*thread
= (struct thread_info
*) entry
;
3190 thread
->status_pending_p
= 0;
3193 /* Callback for for_each_inferior. If the thread is stopped with an
3194 interesting event, mark it as having a pending event. */
3197 set_pending_status_callback (struct inferior_list_entry
*entry
)
3199 struct thread_info
*thread
= (struct thread_info
*) entry
;
3201 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3202 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3203 /* A breakpoint, watchpoint or finished step from a previous
3204 GDB run isn't considered interesting for a new GDB run.
3205 If we left those pending, the new GDB could consider them
3206 random SIGTRAPs. This leaves out real async traps. We'd
3207 have to peek into the (target-specific) siginfo to
3208 distinguish those. */
3209 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3210 thread
->status_pending_p
= 1;
3213 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3214 pending status to report to GDB. */
3217 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3219 struct thread_info
*thread
= (struct thread_info
*) entry
;
3221 return thread
->status_pending_p
;
3224 /* Status handler for the '?' packet. */
3227 handle_status (char *own_buf
)
3229 /* GDB is connected, don't forward events to the target anymore. */
3230 for_each_inferior (&all_processes
, gdb_reattached_process
);
3232 /* In non-stop mode, we must send a stop reply for each stopped
3233 thread. In all-stop mode, just send one for the first stopped
3238 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3240 /* The first is sent immediatly. OK is sent if there is no
3241 stopped thread, which is the same handling of the vStopped
3242 packet (by design). */
3243 notif_write_event (¬if_stop
, own_buf
);
3247 struct inferior_list_entry
*thread
= NULL
;
3250 stabilize_threads ();
3251 gdb_wants_all_threads_stopped ();
3253 /* We can only report one status, but we might be coming out of
3254 non-stop -- if more than one thread is stopped with
3255 interesting events, leave events for the threads we're not
3256 reporting now pending. They'll be reported the next time the
3257 threads are resumed. Start by marking all interesting events
3259 for_each_inferior (&all_threads
, set_pending_status_callback
);
3261 /* Prefer the last thread that reported an event to GDB (even if
3262 that was a GDB_SIGNAL_TRAP). */
3263 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3264 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3265 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3266 thread
= find_inferior_id (&all_threads
, last_ptid
);
3268 /* If the last event thread is not found for some reason, look
3269 for some other thread that might have an event to report. */
3271 thread
= find_inferior (&all_threads
,
3272 find_status_pending_thread_callback
, NULL
);
3274 /* If we're still out of luck, simply pick the first thread in
3277 thread
= get_first_inferior (&all_threads
);
3281 struct thread_info
*tp
= (struct thread_info
*) thread
;
3283 /* We're reporting this event, so it's no longer
3285 tp
->status_pending_p
= 0;
3287 /* GDB assumes the current thread is the thread we're
3288 reporting the status for. */
3289 general_thread
= thread
->id
;
3290 set_desired_thread (1);
3292 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3293 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3296 strcpy (own_buf
, "W00");
3301 gdbserver_version (void)
3303 printf ("GNU gdbserver %s%s\n"
3304 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
3305 "gdbserver is free software, covered by the "
3306 "GNU General Public License.\n"
3307 "This gdbserver was configured as \"%s\"\n",
3308 PKGVERSION
, version
, host_name
);
3312 gdbserver_usage (FILE *stream
)
3314 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3315 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3316 "\tgdbserver [OPTIONS] --multi COMM\n"
3318 "COMM may either be a tty device (for serial debugging),\n"
3319 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3320 "stdin/stdout of gdbserver.\n"
3321 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3322 "PID is the process ID to attach to, when --attach is specified.\n"
3324 "Operating modes:\n"
3326 " --attach Attach to running process PID.\n"
3327 " --multi Start server without a specific program, and\n"
3328 " only quit when explicitly commanded.\n"
3329 " --once Exit after the first connection has closed.\n"
3330 " --help Print this message and then exit.\n"
3331 " --version Display version information and exit.\n"
3335 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3336 " --disable-randomization\n"
3337 " Run PROG with address space randomization disabled.\n"
3338 " --no-disable-randomization\n"
3339 " Don't disable address space randomization when\n"
3344 " --debug Enable general debugging output.\n"
3345 " --debug-format=opt1[,opt2,...]\n"
3346 " Specify extra content in debugging output.\n"
3351 " --remote-debug Enable remote protocol debugging output.\n"
3352 " --disable-packet=opt1[,opt2,...]\n"
3353 " Disable support for RSP packets or features.\n"
3355 " vCont, Tthread, qC, qfThreadInfo and \n"
3356 " threads (disable all threading packets).\n"
3358 "For more information, consult the GDB manual (available as on-line \n"
3359 "info or a printed manual).\n");
3360 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3361 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3365 gdbserver_show_disableable (FILE *stream
)
3367 fprintf (stream
, "Disableable packets:\n"
3368 " vCont \tAll vCont packets\n"
3369 " qC \tQuerying the current thread\n"
3370 " qfThreadInfo\tThread listing\n"
3371 " Tthread \tPassing the thread specifier in the "
3372 "T stop reply packet\n"
3373 " threads \tAll of the above\n");
3377 #undef require_running
3378 #define require_running(BUF) \
3379 if (!target_running ()) \
3386 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3388 int pid
= * (int *) args
;
3390 if (ptid_get_pid (entry
->id
) == pid
)
3397 kill_inferior_callback (struct inferior_list_entry
*entry
)
3399 struct process_info
*process
= (struct process_info
*) entry
;
3400 int pid
= ptid_get_pid (process
->entry
.id
);
3402 kill_inferior (pid
);
3403 discard_queued_stop_replies (pid_to_ptid (pid
));
3406 /* Callback for for_each_inferior to detach or kill the inferior,
3407 depending on whether we attached to it or not.
3408 We inform the user whether we're detaching or killing the process
3409 as this is only called when gdbserver is about to exit. */
3412 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3414 struct process_info
*process
= (struct process_info
*) entry
;
3415 int pid
= ptid_get_pid (process
->entry
.id
);
3417 if (process
->attached
)
3418 detach_inferior (pid
);
3420 kill_inferior (pid
);
3422 discard_queued_stop_replies (pid_to_ptid (pid
));
3425 /* for_each_inferior callback for detach_or_kill_for_exit to print
3426 the pids of started inferiors. */
3429 print_started_pid (struct inferior_list_entry
*entry
)
3431 struct process_info
*process
= (struct process_info
*) entry
;
3433 if (! process
->attached
)
3435 int pid
= ptid_get_pid (process
->entry
.id
);
3436 fprintf (stderr
, " %d", pid
);
3440 /* for_each_inferior callback for detach_or_kill_for_exit to print
3441 the pids of attached inferiors. */
3444 print_attached_pid (struct inferior_list_entry
*entry
)
3446 struct process_info
*process
= (struct process_info
*) entry
;
3448 if (process
->attached
)
3450 int pid
= ptid_get_pid (process
->entry
.id
);
3451 fprintf (stderr
, " %d", pid
);
3455 /* Call this when exiting gdbserver with possible inferiors that need
3456 to be killed or detached from. */
3459 detach_or_kill_for_exit (void)
3461 /* First print a list of the inferiors we will be killing/detaching.
3462 This is to assist the user, for example, in case the inferior unexpectedly
3463 dies after we exit: did we screw up or did the inferior exit on its own?
3464 Having this info will save some head-scratching. */
3466 if (have_started_inferiors_p ())
3468 fprintf (stderr
, "Killing process(es):");
3469 for_each_inferior (&all_processes
, print_started_pid
);
3470 fprintf (stderr
, "\n");
3472 if (have_attached_inferiors_p ())
3474 fprintf (stderr
, "Detaching process(es):");
3475 for_each_inferior (&all_processes
, print_attached_pid
);
3476 fprintf (stderr
, "\n");
3479 /* Now we can kill or detach the inferiors. */
3481 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3484 /* Value that will be passed to exit(3) when gdbserver exits. */
3485 static int exit_code
;
3487 /* Cleanup version of detach_or_kill_for_exit. */
3490 detach_or_kill_for_exit_cleanup (void *ignore
)
3495 detach_or_kill_for_exit ();
3498 CATCH (exception
, RETURN_MASK_ALL
)
3501 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3507 /* Main function. This is called by the real "main" function,
3508 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3510 static void ATTRIBUTE_NORETURN
3511 captured_main (int argc
, char *argv
[])
3515 char *arg_end
, *port
;
3516 char **next_arg
= &argv
[1];
3517 volatile int multi_mode
= 0;
3518 volatile int attach
= 0;
3521 while (*next_arg
!= NULL
&& **next_arg
== '-')
3523 if (strcmp (*next_arg
, "--version") == 0)
3525 gdbserver_version ();
3528 else if (strcmp (*next_arg
, "--help") == 0)
3530 gdbserver_usage (stdout
);
3533 else if (strcmp (*next_arg
, "--attach") == 0)
3535 else if (strcmp (*next_arg
, "--multi") == 0)
3537 else if (strcmp (*next_arg
, "--wrapper") == 0)
3541 wrapper_argv
= next_arg
;
3542 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3545 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3547 gdbserver_usage (stderr
);
3551 /* Consume the "--". */
3554 else if (strcmp (*next_arg
, "--debug") == 0)
3556 else if (startswith (*next_arg
, "--debug-format="))
3559 = parse_debug_format_options ((*next_arg
)
3560 + sizeof ("--debug-format=") - 1, 0);
3562 if (error_msg
!= NULL
)
3564 fprintf (stderr
, "%s", error_msg
);
3568 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3570 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3572 gdbserver_show_disableable (stdout
);
3575 else if (startswith (*next_arg
, "--disable-packet="))
3577 char *packets
, *tok
;
3579 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3580 for (tok
= strtok (packets
, ",");
3582 tok
= strtok (NULL
, ","))
3584 if (strcmp ("vCont", tok
) == 0)
3585 disable_packet_vCont
= 1;
3586 else if (strcmp ("Tthread", tok
) == 0)
3587 disable_packet_Tthread
= 1;
3588 else if (strcmp ("qC", tok
) == 0)
3589 disable_packet_qC
= 1;
3590 else if (strcmp ("qfThreadInfo", tok
) == 0)
3591 disable_packet_qfThreadInfo
= 1;
3592 else if (strcmp ("threads", tok
) == 0)
3594 disable_packet_vCont
= 1;
3595 disable_packet_Tthread
= 1;
3596 disable_packet_qC
= 1;
3597 disable_packet_qfThreadInfo
= 1;
3601 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3603 gdbserver_show_disableable (stderr
);
3608 else if (strcmp (*next_arg
, "-") == 0)
3610 /* "-" specifies a stdio connection and is a form of port
3612 *next_arg
= STDIO_CONNECTION_NAME
;
3615 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3616 disable_randomization
= 1;
3617 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3618 disable_randomization
= 0;
3619 else if (strcmp (*next_arg
, "--once") == 0)
3623 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3633 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3635 gdbserver_usage (stderr
);
3639 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3640 opened by remote_prepare. */
3643 save_original_signals_state ();
3645 /* We need to know whether the remote connection is stdio before
3646 starting the inferior. Inferiors created in this scenario have
3647 stdin,stdout redirected. So do this here before we call
3649 remote_prepare (port
);
3654 /* --attach used to come after PORT, so allow it there for
3656 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3663 && (*next_arg
== NULL
3664 || (*next_arg
)[0] == '\0'
3665 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3667 || next_arg
[1] != NULL
))
3672 gdbserver_usage (stderr
);
3676 initialize_async_io ();
3678 initialize_event_loop ();
3679 if (target_supports_tracepoints ())
3680 initialize_tracepoint ();
3681 initialize_notif ();
3683 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3684 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3686 if (pid
== 0 && *next_arg
!= NULL
)
3690 n
= argc
- (next_arg
- argv
);
3691 program_argv
= XNEWVEC (char *, n
+ 1);
3692 for (i
= 0; i
< n
; i
++)
3693 program_argv
[i
] = xstrdup (next_arg
[i
]);
3694 program_argv
[i
] = NULL
;
3696 /* Wait till we are at first instruction in program. */
3697 start_inferior (program_argv
);
3699 /* We are now (hopefully) stopped at the first instruction of
3700 the target process. This assumes that the target process was
3701 successfully created. */
3705 if (attach_inferior (pid
) == -1)
3706 error ("Attaching not supported on this target");
3708 /* Otherwise succeeded. */
3712 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3713 last_status
.value
.integer
= 0;
3714 last_ptid
= minus_one_ptid
;
3716 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3718 /* Don't report shared library events on the initial connection,
3719 even if some libraries are preloaded. Avoids the "stopped by
3720 shared library event" notice on gdb side. */
3723 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3724 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3729 if (!was_running
&& !multi_mode
)
3730 error ("No program to debug");
3737 report_fork_events
= 0;
3738 report_vfork_events
= 0;
3739 report_exec_events
= 0;
3740 /* Be sure we're out of tfind mode. */
3741 current_traceframe
= -1;
3742 cont_thread
= null_ptid
;
3743 swbreak_feature
= 0;
3744 hwbreak_feature
= 0;
3745 vCont_supported
= 0;
3751 /* Wait for events. This will return when all event sources
3752 are removed from the event loop. */
3753 start_event_loop ();
3755 /* If an exit was requested (using the "monitor exit"
3756 command), terminate now. */
3758 throw_quit ("Quit");
3760 /* The only other way to get here is for getpkt to fail:
3762 - If --once was specified, we're done.
3764 - If not in extended-remote mode, and we're no longer
3765 debugging anything, simply exit: GDB has disconnected
3766 after processing the last process exit.
3768 - Otherwise, close the connection and reopen it at the
3770 if (run_once
|| (!extended_protocol
&& !target_running ()))
3771 throw_quit ("Quit");
3774 "Remote side has terminated connection. "
3775 "GDBserver will reopen the connection.\n");
3777 /* Get rid of any pending statuses. An eventual reconnection
3778 (by the same GDB instance or another) will refresh all its
3779 state from scratch. */
3780 discard_queued_stop_replies (minus_one_ptid
);
3781 for_each_inferior (&all_threads
,
3782 clear_pending_status_callback
);
3786 if (disconnected_tracing
)
3788 /* Try to enable non-stop/async mode, so we we can
3789 both wait for an async socket accept, and handle
3790 async target events simultaneously. There's also
3791 no point either in having the target always stop
3792 all threads, when we're going to pass signals
3793 down without informing GDB. */
3796 if (start_non_stop (1))
3799 /* Detaching implicitly resumes all threads;
3800 simply disconnecting does not. */
3806 "Disconnected tracing disabled; "
3807 "stopping trace run.\n");
3812 CATCH (exception
, RETURN_MASK_ERROR
)
3815 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3817 if (response_needed
)
3819 write_enn (own_buf
);
3824 throw_quit ("Quit");
3830 /* Main function. */
3833 main (int argc
, char *argv
[])
3838 captured_main (argc
, argv
);
3840 CATCH (exception
, RETURN_MASK_ALL
)
3842 if (exception
.reason
== RETURN_ERROR
)
3845 fprintf (stderr
, "%s\n", exception
.message
);
3846 fprintf (stderr
, "Exiting\n");
3854 gdb_assert_not_reached ("captured_main should never return");
3857 /* Process options coming from Z packets for a breakpoint. PACKET is
3858 the packet buffer. *PACKET is updated to point to the first char
3859 after the last processed option. */
3862 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3864 char *dataptr
= *packet
;
3867 /* Check if data has the correct format. */
3868 if (*dataptr
!= ';')
3875 if (*dataptr
== ';')
3878 if (*dataptr
== 'X')
3880 /* Conditional expression. */
3882 debug_printf ("Found breakpoint condition.\n");
3883 if (!add_breakpoint_condition (bp
, &dataptr
))
3884 dataptr
= strchrnul (dataptr
, ';');
3886 else if (startswith (dataptr
, "cmds:"))
3888 dataptr
+= strlen ("cmds:");
3890 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3891 persist
= (*dataptr
== '1');
3893 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3894 dataptr
= strchrnul (dataptr
, ';');
3898 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3900 /* Skip tokens until we find one that we recognize. */
3901 dataptr
= strchrnul (dataptr
, ';');
3907 /* Event loop callback that handles a serial event. The first byte in
3908 the serial buffer gets us here. We expect characters to arrive at
3909 a brisk pace, so we read the rest of the packet with a blocking
3913 process_serial_event (void)
3924 int new_packet_len
= -1;
3926 disable_async_io ();
3928 response_needed
= 0;
3929 packet_len
= getpkt (own_buf
);
3930 if (packet_len
<= 0)
3933 /* Force an event loop break. */
3936 response_needed
= 1;
3943 handle_query (own_buf
, packet_len
, &new_packet_len
);
3946 handle_general_set (own_buf
);
3949 require_running (own_buf
);
3954 pid
= strtol (&own_buf
[i
], NULL
, 16);
3957 pid
= ptid_get_pid (current_ptid
);
3959 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3961 struct process_info
*process
= find_process_pid (pid
);
3963 if (process
== NULL
)
3965 write_enn (own_buf
);
3969 if (tracing
&& disconnected_tracing
)
3971 "Disconnected tracing in effect, "
3972 "leaving gdbserver attached to the process\n");
3974 if (any_persistent_commands ())
3976 "Persistent commands are present, "
3977 "leaving gdbserver attached to the process\n");
3979 /* Make sure we're in non-stop/async mode, so we we can both
3980 wait for an async socket accept, and handle async target
3981 events simultaneously. There's also no point either in
3982 having the target stop all threads, when we're going to
3983 pass signals down without informing GDB. */
3987 debug_printf ("Forcing non-stop mode\n");
3993 process
->gdb_detached
= 1;
3995 /* Detaching implicitly resumes all threads. */
3996 target_continue_no_signal (minus_one_ptid
);
3999 break; /* from switch/case */
4002 fprintf (stderr
, "Detaching from process %d\n", pid
);
4004 if (detach_inferior (pid
) != 0)
4005 write_enn (own_buf
);
4008 discard_queued_stop_replies (pid_to_ptid (pid
));
4011 if (extended_protocol
|| target_running ())
4013 /* There is still at least one inferior remaining or
4014 we are in extended mode, so don't terminate gdbserver,
4015 and instead treat this like a normal program exit. */
4016 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4017 last_status
.value
.integer
= 0;
4018 last_ptid
= pid_to_ptid (pid
);
4020 current_thread
= NULL
;
4027 /* If we are attached, then we can exit. Otherwise, we
4028 need to hang around doing nothing, until the child is
4030 join_inferior (pid
);
4036 extended_protocol
= 1;
4040 handle_status (own_buf
);
4043 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4045 ptid_t gdb_id
, thread_id
;
4048 require_running (own_buf
);
4050 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4052 pid
= ptid_get_pid (gdb_id
);
4054 if (ptid_equal (gdb_id
, null_ptid
)
4055 || ptid_equal (gdb_id
, minus_one_ptid
))
4056 thread_id
= null_ptid
;
4058 && ptid_equal (pid_to_ptid (pid
),
4061 struct thread_info
*thread
=
4062 (struct thread_info
*) find_inferior (&all_threads
,
4067 write_enn (own_buf
);
4071 thread_id
= thread
->entry
.id
;
4075 thread_id
= gdb_id_to_thread_id (gdb_id
);
4076 if (ptid_equal (thread_id
, null_ptid
))
4078 write_enn (own_buf
);
4083 if (own_buf
[1] == 'g')
4085 if (ptid_equal (thread_id
, null_ptid
))
4087 /* GDB is telling us to choose any thread. Check if
4088 the currently selected thread is still valid. If
4089 it is not, select the first available. */
4090 struct thread_info
*thread
=
4091 (struct thread_info
*) find_inferior_id (&all_threads
,
4094 thread
= get_first_thread ();
4095 thread_id
= thread
->entry
.id
;
4098 general_thread
= thread_id
;
4099 set_desired_thread (1);
4100 gdb_assert (current_thread
!= NULL
);
4102 else if (own_buf
[1] == 'c')
4103 cont_thread
= thread_id
;
4109 /* Silently ignore it so that gdb can extend the protocol
4110 without compatibility headaches. */
4115 require_running (own_buf
);
4116 if (current_traceframe
>= 0)
4118 struct regcache
*regcache
4119 = new_register_cache (current_target_desc ());
4121 if (fetch_traceframe_registers (current_traceframe
,
4123 registers_to_string (regcache
, own_buf
);
4125 write_enn (own_buf
);
4126 free_register_cache (regcache
);
4130 struct regcache
*regcache
;
4132 if (!set_desired_thread (1))
4133 write_enn (own_buf
);
4136 regcache
= get_thread_regcache (current_thread
, 1);
4137 registers_to_string (regcache
, own_buf
);
4142 require_running (own_buf
);
4143 if (current_traceframe
>= 0)
4144 write_enn (own_buf
);
4147 struct regcache
*regcache
;
4149 if (!set_desired_thread (1))
4150 write_enn (own_buf
);
4153 regcache
= get_thread_regcache (current_thread
, 1);
4154 registers_from_string (regcache
, &own_buf
[1]);
4160 require_running (own_buf
);
4161 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4162 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4164 write_enn (own_buf
);
4166 bin2hex (mem_buf
, own_buf
, res
);
4169 require_running (own_buf
);
4170 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4171 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4174 write_enn (own_buf
);
4177 require_running (own_buf
);
4178 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4179 &mem_addr
, &len
, &mem_buf
) < 0
4180 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4181 write_enn (own_buf
);
4186 require_running (own_buf
);
4187 hex2bin (own_buf
+ 1, &sig
, 1);
4188 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4189 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4192 myresume (own_buf
, 0, signal
);
4195 require_running (own_buf
);
4196 hex2bin (own_buf
+ 1, &sig
, 1);
4197 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4198 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4201 myresume (own_buf
, 1, signal
);
4204 require_running (own_buf
);
4206 myresume (own_buf
, 0, signal
);
4209 require_running (own_buf
);
4211 myresume (own_buf
, 1, signal
);
4213 case 'Z': /* insert_ ... */
4215 case 'z': /* remove_ ... */
4220 char type
= own_buf
[1];
4222 const int insert
= ch
== 'Z';
4223 char *p
= &own_buf
[3];
4225 p
= unpack_varlen_hex (p
, &addr
);
4226 kind
= strtol (p
+ 1, &dataptr
, 16);
4230 struct gdb_breakpoint
*bp
;
4232 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4237 /* GDB may have sent us a list of *point parameters to
4238 be evaluated on the target's side. Read such list
4239 here. If we already have a list of parameters, GDB
4240 is telling us to drop that list and use this one
4242 clear_breakpoint_conditions_and_commands (bp
);
4243 process_point_options (bp
, &dataptr
);
4247 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4255 write_enn (own_buf
);
4259 response_needed
= 0;
4260 if (!target_running ())
4261 /* The packet we received doesn't make sense - but we can't
4262 reply to it, either. */
4265 fprintf (stderr
, "Killing all inferiors\n");
4266 for_each_inferior (&all_processes
, kill_inferior_callback
);
4268 /* When using the extended protocol, we wait with no program
4269 running. The traditional protocol will exit instead. */
4270 if (extended_protocol
)
4272 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4273 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4281 ptid_t gdb_id
, thread_id
;
4283 require_running (own_buf
);
4285 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4286 thread_id
= gdb_id_to_thread_id (gdb_id
);
4287 if (ptid_equal (thread_id
, null_ptid
))
4289 write_enn (own_buf
);
4293 if (mythread_alive (thread_id
))
4296 write_enn (own_buf
);
4300 response_needed
= 0;
4302 /* Restarting the inferior is only supported in the extended
4304 if (extended_protocol
)
4306 if (target_running ())
4307 for_each_inferior (&all_processes
,
4308 kill_inferior_callback
);
4309 fprintf (stderr
, "GDBserver restarting\n");
4311 /* Wait till we are at 1st instruction in prog. */
4312 if (program_argv
!= NULL
)
4314 start_inferior (program_argv
);
4315 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4317 /* Stopped at the first instruction of the target
4319 general_thread
= last_ptid
;
4323 /* Something went wrong. */
4324 general_thread
= null_ptid
;
4329 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4330 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4336 /* It is a request we don't understand. Respond with an
4337 empty packet so that gdb knows that we don't support this
4343 /* Extended (long) request. */
4344 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4348 /* It is a request we don't understand. Respond with an empty
4349 packet so that gdb knows that we don't support this
4355 if (new_packet_len
!= -1)
4356 putpkt_binary (own_buf
, new_packet_len
);
4360 response_needed
= 0;
4368 /* Event-loop callback for serial events. */
4371 handle_serial_event (int err
, gdb_client_data client_data
)
4374 debug_printf ("handling possible serial event\n");
4376 /* Really handle it. */
4377 if (process_serial_event () < 0)
4380 /* Be sure to not change the selected thread behind GDB's back.
4381 Important in the non-stop mode asynchronous protocol. */
4382 set_desired_thread (1);
4387 /* Push a stop notification on the notification queue. */
4390 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4392 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4394 vstop_notif
->status
= *status
;
4395 vstop_notif
->ptid
= ptid
;
4396 /* Push Stop notification. */
4397 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4400 /* Event-loop callback for target events. */
4403 handle_target_event (int err
, gdb_client_data client_data
)
4406 debug_printf ("handling possible target event\n");
4408 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4411 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4413 if (gdb_connected () && report_no_resumed
)
4414 push_stop_notification (null_ptid
, &last_status
);
4416 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4418 int pid
= ptid_get_pid (last_ptid
);
4419 struct process_info
*process
= find_process_pid (pid
);
4420 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4422 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4423 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4425 mark_breakpoints_out (process
);
4426 target_mourn_inferior (last_ptid
);
4428 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4432 /* We're reporting this thread as stopped. Update its
4433 "want-stopped" state to what the client wants, until it
4434 gets a new resume action. */
4435 current_thread
->last_resume_kind
= resume_stop
;
4436 current_thread
->last_status
= last_status
;
4441 if (!target_running ())
4443 /* The last process exited. We're done. */
4447 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4448 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4449 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4453 /* A thread stopped with a signal, but gdb isn't
4454 connected to handle it. Pass it down to the
4455 inferior, as if it wasn't being traced. */
4456 enum gdb_signal signal
;
4459 debug_printf ("GDB not connected; forwarding event %d for"
4461 (int) last_status
.kind
,
4462 target_pid_to_str (last_ptid
));
4464 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4465 signal
= last_status
.value
.sig
;
4467 signal
= GDB_SIGNAL_0
;
4468 target_continue (last_ptid
, signal
);
4472 push_stop_notification (last_ptid
, &last_status
);
4475 /* Be sure to not change the selected thread behind GDB's back.
4476 Important in the non-stop mode asynchronous protocol. */
4477 set_desired_thread (1);