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 struct notif_server notif_stop
=
198 "vStopped", "Stop", NULL
, vstop_notif_reply
,
202 target_running (void)
204 return get_first_thread () != NULL
;
208 start_inferior (char **argv
)
210 char **new_argv
= argv
;
212 if (wrapper_argv
!= NULL
)
216 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
218 for (i
= 0; argv
[i
] != NULL
; i
++)
220 new_argv
= XALLOCAVEC (char *, count
);
222 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
223 new_argv
[count
++] = wrapper_argv
[i
];
224 for (i
= 0; argv
[i
] != NULL
; i
++)
225 new_argv
[count
++] = argv
[i
];
226 new_argv
[count
] = NULL
;
232 for (i
= 0; new_argv
[i
]; ++i
)
233 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
238 signal (SIGTTOU
, SIG_DFL
);
239 signal (SIGTTIN
, SIG_DFL
);
242 signal_pid
= create_inferior (new_argv
[0], new_argv
);
244 /* FIXME: we don't actually know at this point that the create
245 actually succeeded. We won't know that until we wait. */
246 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
251 signal (SIGTTOU
, SIG_IGN
);
252 signal (SIGTTIN
, SIG_IGN
);
253 terminal_fd
= fileno (stderr
);
254 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
255 tcsetpgrp (terminal_fd
, signal_pid
);
256 atexit (restore_old_foreground_pgrp
);
259 if (wrapper_argv
!= NULL
)
261 ptid_t ptid
= pid_to_ptid (signal_pid
);
263 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
265 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
269 target_continue_no_signal (ptid
);
271 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
272 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
275 current_thread
->last_resume_kind
= resume_stop
;
276 current_thread
->last_status
= last_status
;
278 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
280 target_post_create_inferior ();
284 /* Wait till we are at 1st instruction in program, return new pid
285 (assuming success). */
286 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
288 /* At this point, the target process, if it exits, is stopped. Do not call
289 the function target_post_create_inferior if the process has already
290 exited, as the target implementation of the routine may rely on the
291 process being live. */
292 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
293 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
295 target_post_create_inferior ();
296 current_thread
->last_resume_kind
= resume_stop
;
297 current_thread
->last_status
= last_status
;
300 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
306 attach_inferior (int pid
)
308 /* myattach should return -1 if attaching is unsupported,
309 0 if it succeeded, and call error() otherwise. */
311 if (myattach (pid
) != 0)
314 fprintf (stderr
, "Attached; pid = %d\n", pid
);
317 /* FIXME - It may be that we should get the SIGNAL_PID from the
318 attach function, so that it can be the main thread instead of
319 whichever we were told to attach to. */
324 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
326 /* GDB knows to ignore the first SIGSTOP after attaching to a running
327 process using the "attach" command, but this is different; it's
328 just using "target remote". Pretend it's just starting up. */
329 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
330 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
331 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
333 current_thread
->last_resume_kind
= resume_stop
;
334 current_thread
->last_status
= last_status
;
340 extern int remote_debug
;
342 /* Decode a qXfer read request. Return 0 if everything looks OK,
346 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
348 /* After the read marker and annex, qXfer looks like a
349 traditional 'm' packet. */
350 decode_m_packet (buf
, ofs
, len
);
356 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
358 /* Extract and NUL-terminate the object. */
360 while (*buf
&& *buf
!= ':')
366 /* Extract and NUL-terminate the read/write action. */
368 while (*buf
&& *buf
!= ':')
374 /* Extract and NUL-terminate the annex. */
376 while (*buf
&& *buf
!= ':')
386 /* Write the response to a successful qXfer read. Returns the
387 length of the (binary) data stored in BUF, corresponding
388 to as much of DATA/LEN as we could fit. IS_MORE controls
389 the first character of the response. */
391 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
400 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
401 &out_len
, PBUFSIZ
- 2) + 1;
404 /* Handle btrace enabling in BTS format. */
407 handle_btrace_enable_bts (struct thread_info
*thread
)
409 if (thread
->btrace
!= NULL
)
410 return "E.Btrace already enabled.";
412 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
413 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
414 ¤t_btrace_conf
);
415 if (thread
->btrace
== NULL
)
416 return "E.Could not enable btrace.";
421 /* Handle btrace enabling in Intel Processor Trace format. */
424 handle_btrace_enable_pt (struct thread_info
*thread
)
426 if (thread
->btrace
!= NULL
)
427 return "E.Btrace already enabled.";
429 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
430 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
431 ¤t_btrace_conf
);
432 if (thread
->btrace
== NULL
)
433 return "E.Could not enable btrace.";
438 /* Handle btrace disabling. */
441 handle_btrace_disable (struct thread_info
*thread
)
444 if (thread
->btrace
== NULL
)
445 return "E.Branch tracing not enabled.";
447 if (target_disable_btrace (thread
->btrace
) != 0)
448 return "E.Could not disable branch tracing.";
450 thread
->btrace
= NULL
;
454 /* Handle the "Qbtrace" packet. */
457 handle_btrace_general_set (char *own_buf
)
459 struct thread_info
*thread
;
463 if (!startswith (own_buf
, "Qbtrace:"))
466 op
= own_buf
+ strlen ("Qbtrace:");
468 if (ptid_equal (general_thread
, null_ptid
)
469 || ptid_equal (general_thread
, minus_one_ptid
))
471 strcpy (own_buf
, "E.Must select a single thread.");
475 thread
= find_thread_ptid (general_thread
);
478 strcpy (own_buf
, "E.No such thread.");
484 if (strcmp (op
, "bts") == 0)
485 err
= handle_btrace_enable_bts (thread
);
486 else if (strcmp (op
, "pt") == 0)
487 err
= handle_btrace_enable_pt (thread
);
488 else if (strcmp (op
, "off") == 0)
489 err
= handle_btrace_disable (thread
);
491 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
494 strcpy (own_buf
, err
);
501 /* Handle the "Qbtrace-conf" packet. */
504 handle_btrace_conf_general_set (char *own_buf
)
506 struct thread_info
*thread
;
509 if (!startswith (own_buf
, "Qbtrace-conf:"))
512 op
= own_buf
+ strlen ("Qbtrace-conf:");
514 if (ptid_equal (general_thread
, null_ptid
)
515 || ptid_equal (general_thread
, minus_one_ptid
))
517 strcpy (own_buf
, "E.Must select a single thread.");
521 thread
= find_thread_ptid (general_thread
);
524 strcpy (own_buf
, "E.No such thread.");
528 if (startswith (op
, "bts:size="))
534 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
535 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
537 strcpy (own_buf
, "E.Bad size value.");
541 current_btrace_conf
.bts
.size
= (unsigned int) size
;
543 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
549 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
550 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
552 strcpy (own_buf
, "E.Bad size value.");
556 current_btrace_conf
.pt
.size
= (unsigned int) size
;
560 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
568 /* Handle all of the extended 'Q' packets. */
571 handle_general_set (char *own_buf
)
573 if (startswith (own_buf
, "QPassSignals:"))
575 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
576 const char *p
= own_buf
+ strlen ("QPassSignals:");
579 p
= decode_address_to_semicolon (&cursig
, p
);
580 for (i
= 0; i
< numsigs
; i
++)
586 /* Keep looping, to clear the remaining signals. */
589 p
= decode_address_to_semicolon (&cursig
, p
);
594 strcpy (own_buf
, "OK");
598 if (startswith (own_buf
, "QProgramSignals:"))
600 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
601 const char *p
= own_buf
+ strlen ("QProgramSignals:");
604 program_signals_p
= 1;
606 p
= decode_address_to_semicolon (&cursig
, p
);
607 for (i
= 0; i
< numsigs
; i
++)
611 program_signals
[i
] = 1;
613 /* Keep looping, to clear the remaining signals. */
616 p
= decode_address_to_semicolon (&cursig
, p
);
619 program_signals
[i
] = 0;
621 strcpy (own_buf
, "OK");
625 if (startswith (own_buf
, "QCatchSyscalls:"))
627 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
630 struct process_info
*process
;
632 if (!target_running () || !target_supports_catch_syscall ())
638 if (strcmp (p
, "0") == 0)
640 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
644 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
650 process
= current_process ();
651 VEC_truncate (int, process
->syscalls_to_catch
, 0);
661 p
= decode_address_to_semicolon (&sysno
, p
);
662 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
666 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
673 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
677 fprintf (stderr
, "[noack mode enabled]\n");
686 if (startswith (own_buf
, "QNonStop:"))
688 char *mode
= own_buf
+ 9;
692 if (strcmp (mode
, "0") == 0)
694 else if (strcmp (mode
, "1") == 0)
698 /* We don't know what this mode is, so complain to
700 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
706 req_str
= req
? "non-stop" : "all-stop";
707 if (start_non_stop (req
) != 0)
709 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
717 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
723 if (startswith (own_buf
, "QDisableRandomization:"))
725 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
728 unpack_varlen_hex (packet
, &setting
);
729 disable_randomization
= setting
;
733 if (disable_randomization
)
734 fprintf (stderr
, "[address space randomization disabled]\n");
736 fprintf (stderr
, "[address space randomization enabled]\n");
743 if (target_supports_tracepoints ()
744 && handle_tracepoint_general_set (own_buf
))
747 if (startswith (own_buf
, "QAgent:"))
749 char *mode
= own_buf
+ strlen ("QAgent:");
752 if (strcmp (mode
, "0") == 0)
754 else if (strcmp (mode
, "1") == 0)
758 /* We don't know what this value is, so complain to GDB. */
759 sprintf (own_buf
, "E.Unknown QAgent value");
763 /* Update the flag. */
766 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
771 if (handle_btrace_general_set (own_buf
))
774 if (handle_btrace_conf_general_set (own_buf
))
777 if (startswith (own_buf
, "QThreadEvents:"))
779 char *mode
= own_buf
+ strlen ("QThreadEvents:");
780 enum tribool req
= TRIBOOL_UNKNOWN
;
782 if (strcmp (mode
, "0") == 0)
784 else if (strcmp (mode
, "1") == 0)
788 char *mode_copy
= xstrdup (mode
);
790 /* We don't know what this mode is, so complain to GDB. */
791 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
797 report_thread_events
= (req
== TRIBOOL_TRUE
);
801 const char *req_str
= report_thread_events
? "enabled" : "disabled";
803 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
810 /* Otherwise we didn't know what packet it was. Say we didn't
816 get_features_xml (const char *annex
)
818 const struct target_desc
*desc
= current_target_desc ();
820 /* `desc->xmltarget' defines what to return when looking for the
821 "target.xml" file. Its contents can either be verbatim XML code
822 (prefixed with a '@') or else the name of the actual XML file to
823 be used in place of "target.xml".
825 This variable is set up from the auto-generated
826 init_registers_... routine for the current target. */
828 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
830 if (*desc
->xmltarget
== '@')
831 return desc
->xmltarget
+ 1;
833 annex
= desc
->xmltarget
;
838 extern const char *const xml_builtin
[][2];
841 /* Look for the annex. */
842 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
843 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
846 if (xml_builtin
[i
][0] != NULL
)
847 return xml_builtin
[i
][1];
855 monitor_show_help (void)
857 monitor_output ("The following monitor commands are supported:\n");
858 monitor_output (" set debug <0|1>\n");
859 monitor_output (" Enable general debugging messages\n");
860 monitor_output (" set debug-hw-points <0|1>\n");
861 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
862 monitor_output (" set remote-debug <0|1>\n");
863 monitor_output (" Enable remote protocol debugging messages\n");
864 monitor_output (" set debug-format option1[,option2,...]\n");
865 monitor_output (" Add additional information to debugging messages\n");
866 monitor_output (" Options: all, none");
867 monitor_output (", timestamp");
868 monitor_output ("\n");
869 monitor_output (" exit\n");
870 monitor_output (" Quit GDBserver\n");
873 /* Read trace frame or inferior memory. Returns the number of bytes
874 actually read, zero when no further transfer is possible, and -1 on
875 error. Return of a positive value smaller than LEN does not
876 indicate there's no more to be read, only the end of the transfer.
877 E.g., when GDB reads memory from a traceframe, a first request may
878 be served from a memory block that does not cover the whole request
879 length. A following request gets the rest served from either
880 another block (of the same traceframe) or from the read-only
884 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
888 if (current_traceframe
>= 0)
891 ULONGEST length
= len
;
893 if (traceframe_read_mem (current_traceframe
,
894 memaddr
, myaddr
, len
, &nbytes
))
896 /* Data read from trace buffer, we're done. */
899 if (!in_readonly_region (memaddr
, length
))
901 /* Otherwise we have a valid readonly case, fall through. */
902 /* (assume no half-trace half-real blocks for now) */
905 res
= prepare_to_access_memory ();
908 if (set_desired_thread (1))
909 res
= read_inferior_memory (memaddr
, myaddr
, len
);
912 done_accessing_memory ();
914 return res
== 0 ? len
: -1;
920 /* Write trace frame or inferior memory. Actually, writing to trace
921 frames is forbidden. */
924 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
926 if (current_traceframe
>= 0)
932 ret
= prepare_to_access_memory ();
935 if (set_desired_thread (1))
936 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
939 done_accessing_memory ();
945 /* Subroutine of handle_search_memory to simplify it. */
948 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
949 gdb_byte
*pattern
, unsigned pattern_len
,
950 gdb_byte
*search_buf
,
951 unsigned chunk_size
, unsigned search_buf_size
,
952 CORE_ADDR
*found_addrp
)
954 /* Prime the search buffer. */
956 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
959 warning ("Unable to access %ld bytes of target "
960 "memory at 0x%lx, halting search.",
961 (long) search_buf_size
, (long) start_addr
);
965 /* Perform the search.
967 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
968 When we've scanned N bytes we copy the trailing bytes to the start and
969 read in another N bytes. */
971 while (search_space_len
>= pattern_len
)
974 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
978 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
981 if (found_ptr
!= NULL
)
983 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
984 *found_addrp
= found_addr
;
988 /* Not found in this chunk, skip to next chunk. */
990 /* Don't let search_space_len wrap here, it's unsigned. */
991 if (search_space_len
>= chunk_size
)
992 search_space_len
-= chunk_size
;
994 search_space_len
= 0;
996 if (search_space_len
>= pattern_len
)
998 unsigned keep_len
= search_buf_size
- chunk_size
;
999 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1002 /* Copy the trailing part of the previous iteration to the front
1003 of the buffer for the next iteration. */
1004 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1006 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1007 ? search_space_len
- keep_len
1010 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1011 nr_to_read
) != search_buf_size
)
1013 warning ("Unable to access %ld bytes of target memory "
1014 "at 0x%lx, halting search.",
1015 (long) nr_to_read
, (long) read_addr
);
1019 start_addr
+= chunk_size
;
1028 /* Handle qSearch:memory packets. */
1031 handle_search_memory (char *own_buf
, int packet_len
)
1033 CORE_ADDR start_addr
;
1034 CORE_ADDR search_space_len
;
1036 unsigned int pattern_len
;
1037 /* NOTE: also defined in find.c testcase. */
1038 #define SEARCH_CHUNK_SIZE 16000
1039 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1040 /* Buffer to hold memory contents for searching. */
1041 gdb_byte
*search_buf
;
1042 unsigned search_buf_size
;
1044 CORE_ADDR found_addr
;
1045 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1047 pattern
= (gdb_byte
*) malloc (packet_len
);
1048 if (pattern
== NULL
)
1050 error ("Unable to allocate memory to perform the search");
1051 strcpy (own_buf
, "E00");
1054 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1055 packet_len
- cmd_name_len
,
1056 &start_addr
, &search_space_len
,
1057 pattern
, &pattern_len
) < 0)
1060 error ("Error in parsing qSearch:memory packet");
1061 strcpy (own_buf
, "E00");
1065 search_buf_size
= chunk_size
+ pattern_len
- 1;
1067 /* No point in trying to allocate a buffer larger than the search space. */
1068 if (search_space_len
< search_buf_size
)
1069 search_buf_size
= search_space_len
;
1071 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1072 if (search_buf
== NULL
)
1075 error ("Unable to allocate memory to perform the search");
1076 strcpy (own_buf
, "E00");
1080 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1081 pattern
, pattern_len
,
1082 search_buf
, chunk_size
, search_buf_size
,
1086 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1087 else if (found
== 0)
1088 strcpy (own_buf
, "0");
1090 strcpy (own_buf
, "E00");
1096 #define require_running(BUF) \
1097 if (!target_running ()) \
1103 /* Parse options to --debug-format= and "monitor set debug-format".
1104 ARG is the text after "--debug-format=" or "monitor set debug-format".
1105 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1106 This triggers calls to monitor_output.
1107 The result is NULL if all options were parsed ok, otherwise an error
1108 message which the caller must free.
1110 N.B. These commands affect all debug format settings, they are not
1111 cumulative. If a format is not specified, it is turned off.
1112 However, we don't go to extra trouble with things like
1113 "monitor set debug-format all,none,timestamp".
1114 Instead we just parse them one at a time, in order.
1116 The syntax for "monitor set debug" we support here is not identical
1117 to gdb's "set debug foo on|off" because we also use this function to
1118 parse "--debug-format=foo,bar". */
1121 parse_debug_format_options (const char *arg
, int is_monitor
)
1123 VEC (char_ptr
) *options
;
1127 /* First turn all debug format options off. */
1128 debug_timestamp
= 0;
1130 /* First remove leading spaces, for "monitor set debug-format". */
1131 while (isspace (*arg
))
1134 options
= delim_string_to_char_ptr_vec (arg
, ',');
1136 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1138 if (strcmp (option
, "all") == 0)
1140 debug_timestamp
= 1;
1142 monitor_output ("All extra debug format options enabled.\n");
1144 else if (strcmp (option
, "none") == 0)
1146 debug_timestamp
= 0;
1148 monitor_output ("All extra debug format options disabled.\n");
1150 else if (strcmp (option
, "timestamp") == 0)
1152 debug_timestamp
= 1;
1154 monitor_output ("Timestamps will be added to debug output.\n");
1156 else if (*option
== '\0')
1158 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1163 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1166 free_char_ptr_vec (options
);
1171 free_char_ptr_vec (options
);
1175 /* Handle monitor commands not handled by target-specific handlers. */
1178 handle_monitor_command (char *mon
, char *own_buf
)
1180 if (strcmp (mon
, "set debug 1") == 0)
1183 monitor_output ("Debug output enabled.\n");
1185 else if (strcmp (mon
, "set debug 0") == 0)
1188 monitor_output ("Debug output disabled.\n");
1190 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1192 show_debug_regs
= 1;
1193 monitor_output ("H/W point debugging output enabled.\n");
1195 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1197 show_debug_regs
= 0;
1198 monitor_output ("H/W point debugging output disabled.\n");
1200 else if (strcmp (mon
, "set remote-debug 1") == 0)
1203 monitor_output ("Protocol debug output enabled.\n");
1205 else if (strcmp (mon
, "set remote-debug 0") == 0)
1208 monitor_output ("Protocol debug output disabled.\n");
1210 else if (startswith (mon
, "set debug-format "))
1213 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1216 if (error_msg
!= NULL
)
1218 monitor_output (error_msg
);
1219 monitor_show_help ();
1220 write_enn (own_buf
);
1224 else if (strcmp (mon
, "help") == 0)
1225 monitor_show_help ();
1226 else if (strcmp (mon
, "exit") == 0)
1230 monitor_output ("Unknown monitor command.\n\n");
1231 monitor_show_help ();
1232 write_enn (own_buf
);
1236 /* Associates a callback with each supported qXfer'able object. */
1240 /* The object this handler handles. */
1243 /* Request that the target transfer up to LEN 8-bit bytes of the
1244 target's OBJECT. The OFFSET, for a seekable object, specifies
1245 the starting point. The ANNEX can be used to provide additional
1246 data-specific information to the target.
1248 Return the number of bytes actually transfered, zero when no
1249 further transfer is possible, -1 on error, -2 when the transfer
1250 is not supported, and -3 on a verbose error message that should
1251 be preserved. Return of a positive value smaller than LEN does
1252 not indicate the end of the object, only the end of the transfer.
1254 One, and only one, of readbuf or writebuf must be non-NULL. */
1255 int (*xfer
) (const char *annex
,
1256 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1257 ULONGEST offset
, LONGEST len
);
1260 /* Handle qXfer:auxv:read. */
1263 handle_qxfer_auxv (const char *annex
,
1264 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1265 ULONGEST offset
, LONGEST len
)
1267 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1270 if (annex
[0] != '\0' || current_thread
== NULL
)
1273 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1276 /* Handle qXfer:exec-file:read. */
1279 handle_qxfer_exec_file (const char *const_annex
,
1280 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1281 ULONGEST offset
, LONGEST len
)
1287 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1290 if (const_annex
[0] == '\0')
1292 if (current_thread
== NULL
)
1295 pid
= pid_of (current_thread
);
1299 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1301 strcpy (annex
, const_annex
);
1302 annex
= unpack_varlen_hex (annex
, &pid
);
1304 if (annex
[0] != '\0')
1311 file
= (*the_target
->pid_to_exec_file
) (pid
);
1315 total_len
= strlen (file
);
1317 if (offset
> total_len
)
1320 if (offset
+ len
> total_len
)
1321 len
= total_len
- offset
;
1323 memcpy (readbuf
, file
+ offset
, len
);
1327 /* Handle qXfer:features:read. */
1330 handle_qxfer_features (const char *annex
,
1331 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1332 ULONGEST offset
, LONGEST len
)
1334 const char *document
;
1337 if (writebuf
!= NULL
)
1340 if (!target_running ())
1343 /* Grab the correct annex. */
1344 document
= get_features_xml (annex
);
1345 if (document
== NULL
)
1348 total_len
= strlen (document
);
1350 if (offset
> total_len
)
1353 if (offset
+ len
> total_len
)
1354 len
= total_len
- offset
;
1356 memcpy (readbuf
, document
+ offset
, len
);
1360 /* Worker routine for handle_qxfer_libraries.
1361 Add to the length pointed to by ARG a conservative estimate of the
1362 length needed to transmit the file name of INF. */
1365 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1367 struct dll_info
*dll
= (struct dll_info
*) inf
;
1368 unsigned int *total_len
= (unsigned int *) arg
;
1370 /* Over-estimate the necessary memory. Assume that every character
1371 in the library name must be escaped. */
1372 *total_len
+= 128 + 6 * strlen (dll
->name
);
1375 /* Worker routine for handle_qxfer_libraries.
1376 Emit the XML to describe the library in INF. */
1379 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1381 struct dll_info
*dll
= (struct dll_info
*) inf
;
1382 char **p_ptr
= (char **) arg
;
1386 strcpy (p
, " <library name=\"");
1388 name
= xml_escape_text (dll
->name
);
1392 strcpy (p
, "\"><segment address=\"");
1394 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1396 strcpy (p
, "\"/></library>\n");
1402 /* Handle qXfer:libraries:read. */
1405 handle_qxfer_libraries (const char *annex
,
1406 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1407 ULONGEST offset
, LONGEST len
)
1409 unsigned int total_len
;
1412 if (writebuf
!= NULL
)
1415 if (annex
[0] != '\0' || current_thread
== NULL
)
1419 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1422 document
= (char *) malloc (total_len
);
1423 if (document
== NULL
)
1426 strcpy (document
, "<library-list version=\"1.0\">\n");
1427 p
= document
+ strlen (document
);
1429 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1431 strcpy (p
, "</library-list>\n");
1433 total_len
= strlen (document
);
1435 if (offset
> total_len
)
1441 if (offset
+ len
> total_len
)
1442 len
= total_len
- offset
;
1444 memcpy (readbuf
, document
+ offset
, len
);
1449 /* Handle qXfer:libraries-svr4:read. */
1452 handle_qxfer_libraries_svr4 (const char *annex
,
1453 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1454 ULONGEST offset
, LONGEST len
)
1456 if (writebuf
!= NULL
)
1459 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1462 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1465 /* Handle qXfer:osadata:read. */
1468 handle_qxfer_osdata (const char *annex
,
1469 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1470 ULONGEST offset
, LONGEST len
)
1472 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1475 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1478 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1481 handle_qxfer_siginfo (const char *annex
,
1482 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1483 ULONGEST offset
, LONGEST len
)
1485 if (the_target
->qxfer_siginfo
== NULL
)
1488 if (annex
[0] != '\0' || current_thread
== NULL
)
1491 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1494 /* Handle qXfer:spu:read and qXfer:spu:write. */
1497 handle_qxfer_spu (const char *annex
,
1498 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1499 ULONGEST offset
, LONGEST len
)
1501 if (the_target
->qxfer_spu
== NULL
)
1504 if (current_thread
== NULL
)
1507 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1510 /* Handle qXfer:statictrace:read. */
1513 handle_qxfer_statictrace (const char *annex
,
1514 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1515 ULONGEST offset
, LONGEST len
)
1519 if (writebuf
!= NULL
)
1522 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1525 if (traceframe_read_sdata (current_traceframe
, offset
,
1526 readbuf
, len
, &nbytes
))
1531 /* Helper for handle_qxfer_threads_proper.
1532 Emit the XML to describe the thread of INF. */
1535 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1537 struct thread_info
*thread
= (struct thread_info
*) inf
;
1538 struct buffer
*buffer
= (struct buffer
*) arg
;
1539 ptid_t ptid
= thread_to_gdb_id (thread
);
1541 int core
= target_core_of_thread (ptid
);
1543 const char *name
= target_thread_name (ptid
);
1545 write_ptid (ptid_s
, ptid
);
1547 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1551 sprintf (core_s
, "%d", core
);
1552 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1556 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1558 buffer_xml_printf (buffer
, "/>\n");
1561 /* Helper for handle_qxfer_threads. */
1564 handle_qxfer_threads_proper (struct buffer
*buffer
)
1566 buffer_grow_str (buffer
, "<threads>\n");
1568 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1571 buffer_grow_str0 (buffer
, "</threads>\n");
1574 /* Handle qXfer:threads:read. */
1577 handle_qxfer_threads (const char *annex
,
1578 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1579 ULONGEST offset
, LONGEST len
)
1581 static char *result
= 0;
1582 static unsigned int result_length
= 0;
1584 if (writebuf
!= NULL
)
1587 if (annex
[0] != '\0')
1592 struct buffer buffer
;
1593 /* When asked for data at offset 0, generate everything and store into
1594 'result'. Successive reads will be served off 'result'. */
1598 buffer_init (&buffer
);
1600 handle_qxfer_threads_proper (&buffer
);
1602 result
= buffer_finish (&buffer
);
1603 result_length
= strlen (result
);
1604 buffer_free (&buffer
);
1607 if (offset
>= result_length
)
1609 /* We're out of data. */
1616 if (len
> result_length
- offset
)
1617 len
= result_length
- offset
;
1619 memcpy (readbuf
, result
+ offset
, len
);
1624 /* Handle qXfer:traceframe-info:read. */
1627 handle_qxfer_traceframe_info (const char *annex
,
1628 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1629 ULONGEST offset
, LONGEST len
)
1631 static char *result
= 0;
1632 static unsigned int result_length
= 0;
1634 if (writebuf
!= NULL
)
1637 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1642 struct buffer buffer
;
1644 /* When asked for data at offset 0, generate everything and
1645 store into 'result'. Successive reads will be served off
1649 buffer_init (&buffer
);
1651 traceframe_read_info (current_traceframe
, &buffer
);
1653 result
= buffer_finish (&buffer
);
1654 result_length
= strlen (result
);
1655 buffer_free (&buffer
);
1658 if (offset
>= result_length
)
1660 /* We're out of data. */
1667 if (len
> result_length
- offset
)
1668 len
= result_length
- offset
;
1670 memcpy (readbuf
, result
+ offset
, len
);
1674 /* Handle qXfer:fdpic:read. */
1677 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1678 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1680 if (the_target
->read_loadmap
== NULL
)
1683 if (current_thread
== NULL
)
1686 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1689 /* Handle qXfer:btrace:read. */
1692 handle_qxfer_btrace (const char *annex
,
1693 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1694 ULONGEST offset
, LONGEST len
)
1696 static struct buffer cache
;
1697 struct thread_info
*thread
;
1698 enum btrace_read_type type
;
1701 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1704 if (ptid_equal (general_thread
, null_ptid
)
1705 || ptid_equal (general_thread
, minus_one_ptid
))
1707 strcpy (own_buf
, "E.Must select a single thread.");
1711 thread
= find_thread_ptid (general_thread
);
1714 strcpy (own_buf
, "E.No such thread.");
1718 if (thread
->btrace
== NULL
)
1720 strcpy (own_buf
, "E.Btrace not enabled.");
1724 if (strcmp (annex
, "all") == 0)
1725 type
= BTRACE_READ_ALL
;
1726 else if (strcmp (annex
, "new") == 0)
1727 type
= BTRACE_READ_NEW
;
1728 else if (strcmp (annex
, "delta") == 0)
1729 type
= BTRACE_READ_DELTA
;
1732 strcpy (own_buf
, "E.Bad annex.");
1738 buffer_free (&cache
);
1740 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1743 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1747 else if (offset
> cache
.used_size
)
1749 buffer_free (&cache
);
1753 if (len
> cache
.used_size
- offset
)
1754 len
= cache
.used_size
- offset
;
1756 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1761 /* Handle qXfer:btrace-conf:read. */
1764 handle_qxfer_btrace_conf (const char *annex
,
1765 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1766 ULONGEST offset
, LONGEST len
)
1768 static struct buffer cache
;
1769 struct thread_info
*thread
;
1772 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1775 if (annex
[0] != '\0')
1778 if (ptid_equal (general_thread
, null_ptid
)
1779 || ptid_equal (general_thread
, minus_one_ptid
))
1781 strcpy (own_buf
, "E.Must select a single thread.");
1785 thread
= find_thread_ptid (general_thread
);
1788 strcpy (own_buf
, "E.No such thread.");
1792 if (thread
->btrace
== NULL
)
1794 strcpy (own_buf
, "E.Btrace not enabled.");
1800 buffer_free (&cache
);
1802 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1805 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1809 else if (offset
> cache
.used_size
)
1811 buffer_free (&cache
);
1815 if (len
> cache
.used_size
- offset
)
1816 len
= cache
.used_size
- offset
;
1818 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1823 static const struct qxfer qxfer_packets
[] =
1825 { "auxv", handle_qxfer_auxv
},
1826 { "btrace", handle_qxfer_btrace
},
1827 { "btrace-conf", handle_qxfer_btrace_conf
},
1828 { "exec-file", handle_qxfer_exec_file
},
1829 { "fdpic", handle_qxfer_fdpic
},
1830 { "features", handle_qxfer_features
},
1831 { "libraries", handle_qxfer_libraries
},
1832 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1833 { "osdata", handle_qxfer_osdata
},
1834 { "siginfo", handle_qxfer_siginfo
},
1835 { "spu", handle_qxfer_spu
},
1836 { "statictrace", handle_qxfer_statictrace
},
1837 { "threads", handle_qxfer_threads
},
1838 { "traceframe-info", handle_qxfer_traceframe_info
},
1842 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1850 if (!startswith (own_buf
, "qXfer:"))
1853 /* Grab the object, r/w and annex. */
1854 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1856 write_enn (own_buf
);
1861 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1864 const struct qxfer
*q
= &qxfer_packets
[i
];
1866 if (strcmp (object
, q
->object
) == 0)
1868 if (strcmp (rw
, "read") == 0)
1870 unsigned char *data
;
1875 /* Grab the offset and length. */
1876 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1878 write_enn (own_buf
);
1882 /* Read one extra byte, as an indicator of whether there is
1884 if (len
> PBUFSIZ
- 2)
1886 data
= (unsigned char *) malloc (len
+ 1);
1889 write_enn (own_buf
);
1892 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1900 /* Preserve error message. */
1903 write_enn (own_buf
);
1905 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1907 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1912 else if (strcmp (rw
, "write") == 0)
1917 unsigned char *data
;
1919 strcpy (own_buf
, "E00");
1920 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1923 write_enn (own_buf
);
1926 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1927 &ofs
, &len
, data
) < 0)
1930 write_enn (own_buf
);
1934 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1942 /* Preserve error message. */
1945 write_enn (own_buf
);
1947 sprintf (own_buf
, "%x", n
);
1960 /* Compute 32 bit CRC from inferior memory.
1962 On success, return 32 bit CRC.
1963 On failure, return (unsigned long long) -1. */
1965 static unsigned long long
1966 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1970 unsigned char byte
= 0;
1972 /* Return failure if memory read fails. */
1973 if (read_inferior_memory (base
, &byte
, 1) != 0)
1974 return (unsigned long long) -1;
1976 crc
= xcrc32 (&byte
, 1, crc
);
1979 return (unsigned long long) crc
;
1982 /* Add supported btrace packets to BUF. */
1985 supported_btrace_packets (char *buf
)
1987 int btrace_supported
= 0;
1989 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1991 strcat (buf
, ";Qbtrace:bts+");
1992 strcat (buf
, ";Qbtrace-conf:bts:size+");
1994 btrace_supported
= 1;
1997 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1999 strcat (buf
, ";Qbtrace:pt+");
2000 strcat (buf
, ";Qbtrace-conf:pt:size+");
2002 btrace_supported
= 1;
2005 if (!btrace_supported
)
2008 strcat (buf
, ";Qbtrace:off+");
2009 strcat (buf
, ";qXfer:btrace:read+");
2010 strcat (buf
, ";qXfer:btrace-conf:read+");
2013 /* Handle all of the extended 'q' packets. */
2016 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2018 static struct inferior_list_entry
*thread_ptr
;
2020 /* Reply the current thread id. */
2021 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2024 require_running (own_buf
);
2026 if (!ptid_equal (general_thread
, null_ptid
)
2027 && !ptid_equal (general_thread
, minus_one_ptid
))
2028 gdb_id
= general_thread
;
2031 thread_ptr
= get_first_inferior (&all_threads
);
2032 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2035 sprintf (own_buf
, "QC");
2037 write_ptid (own_buf
, gdb_id
);
2041 if (strcmp ("qSymbol::", own_buf
) == 0)
2043 struct thread_info
*save_thread
= current_thread
;
2045 /* For qSymbol, GDB only changes the current thread if the
2046 previous current thread was of a different process. So if
2047 the previous thread is gone, we need to pick another one of
2048 the same process. This can happen e.g., if we followed an
2049 exec in a non-leader thread. */
2050 if (current_thread
== NULL
)
2053 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2055 /* Just in case, if we didn't find a thread, then bail out
2056 instead of crashing. */
2057 if (current_thread
== NULL
)
2059 write_enn (own_buf
);
2060 current_thread
= save_thread
;
2065 /* GDB is suggesting new symbols have been loaded. This may
2066 mean a new shared library has been detected as loaded, so
2067 take the opportunity to check if breakpoints we think are
2068 inserted, still are. Note that it isn't guaranteed that
2069 we'll see this when a shared library is loaded, and nor will
2070 we see this for unloads (although breakpoints in unloaded
2071 libraries shouldn't trigger), as GDB may not find symbols for
2072 the library at all. We also re-validate breakpoints when we
2073 see a second GDB breakpoint for the same address, and or when
2074 we access breakpoint shadows. */
2075 validate_breakpoints ();
2077 if (target_supports_tracepoints ())
2078 tracepoint_look_up_symbols ();
2080 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2081 (*the_target
->look_up_symbols
) ();
2083 current_thread
= save_thread
;
2085 strcpy (own_buf
, "OK");
2089 if (!disable_packet_qfThreadInfo
)
2091 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2095 require_running (own_buf
);
2096 thread_ptr
= get_first_inferior (&all_threads
);
2099 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2100 write_ptid (own_buf
, gdb_id
);
2101 thread_ptr
= thread_ptr
->next
;
2105 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2109 require_running (own_buf
);
2110 if (thread_ptr
!= NULL
)
2113 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2114 write_ptid (own_buf
, gdb_id
);
2115 thread_ptr
= thread_ptr
->next
;
2120 sprintf (own_buf
, "l");
2126 if (the_target
->read_offsets
!= NULL
2127 && strcmp ("qOffsets", own_buf
) == 0)
2129 CORE_ADDR text
, data
;
2131 require_running (own_buf
);
2132 if (the_target
->read_offsets (&text
, &data
))
2133 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2134 (long)text
, (long)data
, (long)data
);
2136 write_enn (own_buf
);
2141 /* Protocol features query. */
2142 if (startswith (own_buf
, "qSupported")
2143 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2145 char *p
= &own_buf
[10];
2146 int gdb_supports_qRelocInsn
= 0;
2148 /* Process each feature being provided by GDB. The first
2149 feature will follow a ':', and latter features will follow
2153 char **qsupported
= NULL
;
2158 /* Two passes, to avoid nested strtok calls in
2159 target_process_qsupported. */
2160 for (p
= strtok (p
+ 1, ";");
2162 p
= strtok (NULL
, ";"))
2165 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2166 qsupported
[count
- 1] = xstrdup (p
);
2169 for (i
= 0; i
< count
; i
++)
2172 if (strcmp (p
, "multiprocess+") == 0)
2174 /* GDB supports and wants multi-process support if
2176 if (target_supports_multi_process ())
2179 else if (strcmp (p
, "qRelocInsn+") == 0)
2181 /* GDB supports relocate instruction requests. */
2182 gdb_supports_qRelocInsn
= 1;
2184 else if (strcmp (p
, "swbreak+") == 0)
2186 /* GDB wants us to report whether a trap is caused
2187 by a software breakpoint and for us to handle PC
2188 adjustment if necessary on this target. */
2189 if (target_supports_stopped_by_sw_breakpoint ())
2190 swbreak_feature
= 1;
2192 else if (strcmp (p
, "hwbreak+") == 0)
2194 /* GDB wants us to report whether a trap is caused
2195 by a hardware breakpoint. */
2196 if (target_supports_stopped_by_hw_breakpoint ())
2197 hwbreak_feature
= 1;
2199 else if (strcmp (p
, "fork-events+") == 0)
2201 /* GDB supports and wants fork events if possible. */
2202 if (target_supports_fork_events ())
2203 report_fork_events
= 1;
2205 else if (strcmp (p
, "vfork-events+") == 0)
2207 /* GDB supports and wants vfork events if possible. */
2208 if (target_supports_vfork_events ())
2209 report_vfork_events
= 1;
2211 else if (strcmp (p
, "exec-events+") == 0)
2213 /* GDB supports and wants exec events if possible. */
2214 if (target_supports_exec_events ())
2215 report_exec_events
= 1;
2217 else if (strcmp (p
, "vContSupported+") == 0)
2218 vCont_supported
= 1;
2219 else if (strcmp (p
, "QThreadEvents+") == 0)
2221 else if (strcmp (p
, "no-resumed+") == 0)
2223 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2225 report_no_resumed
= 1;
2229 /* Move the unknown features all together. */
2230 qsupported
[i
] = NULL
;
2231 qsupported
[unknown
] = p
;
2236 /* Give the target backend a chance to process the unknown
2238 target_process_qsupported (qsupported
, unknown
);
2240 for (i
= 0; i
< count
; i
++)
2241 free (qsupported
[i
]);
2246 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2249 if (target_supports_catch_syscall ())
2250 strcat (own_buf
, ";QCatchSyscalls+");
2252 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2253 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2254 ";augmented-libraries-svr4-read+");
2257 /* We do not have any hook to indicate whether the non-SVR4 target
2258 backend supports qXfer:libraries:read, so always report it. */
2259 strcat (own_buf
, ";qXfer:libraries:read+");
2262 if (the_target
->read_auxv
!= NULL
)
2263 strcat (own_buf
, ";qXfer:auxv:read+");
2265 if (the_target
->qxfer_spu
!= NULL
)
2266 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2268 if (the_target
->qxfer_siginfo
!= NULL
)
2269 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2271 if (the_target
->read_loadmap
!= NULL
)
2272 strcat (own_buf
, ";qXfer:fdpic:read+");
2274 /* We always report qXfer:features:read, as targets may
2275 install XML files on a subsequent call to arch_setup.
2276 If we reported to GDB on startup that we don't support
2277 qXfer:feature:read at all, we will never be re-queried. */
2278 strcat (own_buf
, ";qXfer:features:read+");
2280 if (transport_is_reliable
)
2281 strcat (own_buf
, ";QStartNoAckMode+");
2283 if (the_target
->qxfer_osdata
!= NULL
)
2284 strcat (own_buf
, ";qXfer:osdata:read+");
2286 if (target_supports_multi_process ())
2287 strcat (own_buf
, ";multiprocess+");
2289 if (target_supports_fork_events ())
2290 strcat (own_buf
, ";fork-events+");
2292 if (target_supports_vfork_events ())
2293 strcat (own_buf
, ";vfork-events+");
2295 if (target_supports_exec_events ())
2296 strcat (own_buf
, ";exec-events+");
2298 if (target_supports_non_stop ())
2299 strcat (own_buf
, ";QNonStop+");
2301 if (target_supports_disable_randomization ())
2302 strcat (own_buf
, ";QDisableRandomization+");
2304 strcat (own_buf
, ";qXfer:threads:read+");
2306 if (target_supports_tracepoints ())
2308 strcat (own_buf
, ";ConditionalTracepoints+");
2309 strcat (own_buf
, ";TraceStateVariables+");
2310 strcat (own_buf
, ";TracepointSource+");
2311 strcat (own_buf
, ";DisconnectedTracing+");
2312 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2313 strcat (own_buf
, ";FastTracepoints+");
2314 strcat (own_buf
, ";StaticTracepoints+");
2315 strcat (own_buf
, ";InstallInTrace+");
2316 strcat (own_buf
, ";qXfer:statictrace:read+");
2317 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2318 strcat (own_buf
, ";EnableDisableTracepoints+");
2319 strcat (own_buf
, ";QTBuffer:size+");
2320 strcat (own_buf
, ";tracenz+");
2323 if (target_supports_hardware_single_step ()
2324 || target_supports_software_single_step () )
2326 strcat (own_buf
, ";ConditionalBreakpoints+");
2328 strcat (own_buf
, ";BreakpointCommands+");
2330 if (target_supports_agent ())
2331 strcat (own_buf
, ";QAgent+");
2333 supported_btrace_packets (own_buf
);
2335 if (target_supports_stopped_by_sw_breakpoint ())
2336 strcat (own_buf
, ";swbreak+");
2338 if (target_supports_stopped_by_hw_breakpoint ())
2339 strcat (own_buf
, ";hwbreak+");
2341 if (the_target
->pid_to_exec_file
!= NULL
)
2342 strcat (own_buf
, ";qXfer:exec-file:read+");
2344 strcat (own_buf
, ";vContSupported+");
2346 strcat (own_buf
, ";QThreadEvents+");
2348 strcat (own_buf
, ";no-resumed+");
2350 /* Reinitialize components as needed for the new connection. */
2351 hostio_handle_new_gdb_connection ();
2352 target_handle_new_gdb_connection ();
2357 /* Thread-local storage support. */
2358 if (the_target
->get_tls_address
!= NULL
2359 && startswith (own_buf
, "qGetTLSAddr:"))
2361 char *p
= own_buf
+ 12;
2362 CORE_ADDR parts
[2], address
= 0;
2364 ptid_t ptid
= null_ptid
;
2366 require_running (own_buf
);
2368 for (i
= 0; i
< 3; i
++)
2376 p2
= strchr (p
, ',');
2389 ptid
= read_ptid (p
, NULL
);
2391 decode_address (&parts
[i
- 1], p
, len
);
2395 if (p
!= NULL
|| i
< 3)
2399 struct thread_info
*thread
= find_thread_ptid (ptid
);
2404 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2410 strcpy (own_buf
, paddress(address
));
2415 write_enn (own_buf
);
2419 /* Otherwise, pretend we do not understand this packet. */
2422 /* Windows OS Thread Information Block address support. */
2423 if (the_target
->get_tib_address
!= NULL
2424 && startswith (own_buf
, "qGetTIBAddr:"))
2429 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2431 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2434 strcpy (own_buf
, paddress(tlb
));
2439 write_enn (own_buf
);
2445 /* Handle "monitor" commands. */
2446 if (startswith (own_buf
, "qRcmd,"))
2448 char *mon
= (char *) malloc (PBUFSIZ
);
2449 int len
= strlen (own_buf
+ 6);
2453 write_enn (own_buf
);
2458 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2460 write_enn (own_buf
);
2464 mon
[len
/ 2] = '\0';
2468 if (the_target
->handle_monitor_command
== NULL
2469 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2470 /* Default processing. */
2471 handle_monitor_command (mon
, own_buf
);
2477 if (startswith (own_buf
, "qSearch:memory:"))
2479 require_running (own_buf
);
2480 handle_search_memory (own_buf
, packet_len
);
2484 if (strcmp (own_buf
, "qAttached") == 0
2485 || startswith (own_buf
, "qAttached:"))
2487 struct process_info
*process
;
2489 if (own_buf
[sizeof ("qAttached") - 1])
2491 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2492 process
= (struct process_info
*)
2493 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2497 require_running (own_buf
);
2498 process
= current_process ();
2501 if (process
== NULL
)
2503 write_enn (own_buf
);
2507 strcpy (own_buf
, process
->attached
? "1" : "0");
2511 if (startswith (own_buf
, "qCRC:"))
2513 /* CRC check (compare-section). */
2517 unsigned long long crc
;
2519 require_running (own_buf
);
2520 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2521 if (*comma
++ != ',')
2523 write_enn (own_buf
);
2526 len
= strtoul (comma
, NULL
, 16);
2527 crc
= crc32 (base
, len
, 0xffffffff);
2528 /* Check for memory failure. */
2529 if (crc
== (unsigned long long) -1)
2531 write_enn (own_buf
);
2534 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2538 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2541 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2544 /* Otherwise we didn't know what packet it was. Say we didn't
2549 static void gdb_wants_all_threads_stopped (void);
2550 static void resume (struct thread_resume
*actions
, size_t n
);
2552 /* The callback that is passed to visit_actioned_threads. */
2553 typedef int (visit_actioned_threads_callback_ftype
)
2554 (const struct thread_resume
*, struct thread_info
*);
2556 /* Struct to pass data to visit_actioned_threads. */
2558 struct visit_actioned_threads_data
2560 const struct thread_resume
*actions
;
2562 visit_actioned_threads_callback_ftype
*callback
;
2565 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2566 true if CALLBACK returns true. Returns false if no matching thread
2567 is found or CALLBACK results false.
2568 Note: This function is itself a callback for find_inferior. */
2571 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2573 struct visit_actioned_threads_data
*data
2574 = (struct visit_actioned_threads_data
*) datap
;
2575 const struct thread_resume
*actions
= data
->actions
;
2576 size_t num_actions
= data
->num_actions
;
2577 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2580 for (i
= 0; i
< num_actions
; i
++)
2582 const struct thread_resume
*action
= &actions
[i
];
2584 if (ptid_equal (action
->thread
, minus_one_ptid
)
2585 || ptid_equal (action
->thread
, entry
->id
)
2586 || ((ptid_get_pid (action
->thread
)
2587 == ptid_get_pid (entry
->id
))
2588 && ptid_get_lwp (action
->thread
) == -1))
2590 struct thread_info
*thread
= (struct thread_info
*) entry
;
2592 if ((*callback
) (action
, thread
))
2600 /* Callback for visit_actioned_threads. If the thread has a pending
2601 status to report, report it now. */
2604 handle_pending_status (const struct thread_resume
*resumption
,
2605 struct thread_info
*thread
)
2607 if (thread
->status_pending_p
)
2609 thread
->status_pending_p
= 0;
2611 last_status
= thread
->last_status
;
2612 last_ptid
= thread
->entry
.id
;
2613 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2619 /* Parse vCont packets. */
2621 handle_v_cont (char *own_buf
)
2625 struct thread_resume
*resume_info
;
2626 struct thread_resume default_action
= {{0}};
2628 /* Count the number of semicolons in the packet. There should be one
2629 for every action. */
2635 p
= strchr (p
, ';');
2638 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2639 if (resume_info
== NULL
)
2647 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2649 if (p
[0] == 's' || p
[0] == 'S')
2650 resume_info
[i
].kind
= resume_step
;
2651 else if (p
[0] == 'r')
2652 resume_info
[i
].kind
= resume_step
;
2653 else if (p
[0] == 'c' || p
[0] == 'C')
2654 resume_info
[i
].kind
= resume_continue
;
2655 else if (p
[0] == 't')
2656 resume_info
[i
].kind
= resume_stop
;
2660 if (p
[0] == 'S' || p
[0] == 'C')
2663 sig
= strtol (p
+ 1, &q
, 16);
2668 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2670 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2672 else if (p
[0] == 'r')
2676 p
= unpack_varlen_hex (p
+ 1, &addr
);
2677 resume_info
[i
].step_range_start
= addr
;
2682 p
= unpack_varlen_hex (p
+ 1, &addr
);
2683 resume_info
[i
].step_range_end
= addr
;
2692 resume_info
[i
].thread
= minus_one_ptid
;
2693 default_action
= resume_info
[i
];
2695 /* Note: we don't increment i here, we'll overwrite this entry
2696 the next time through. */
2698 else if (p
[0] == ':')
2700 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2705 if (p
[0] != ';' && p
[0] != 0)
2708 resume_info
[i
].thread
= ptid
;
2715 resume_info
[i
] = default_action
;
2717 resume (resume_info
, n
);
2722 write_enn (own_buf
);
2727 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2730 resume (struct thread_resume
*actions
, size_t num_actions
)
2734 /* Check if among the threads that GDB wants actioned, there's
2735 one with a pending status to report. If so, skip actually
2736 resuming/stopping and report the pending event
2738 struct visit_actioned_threads_data data
;
2740 data
.actions
= actions
;
2741 data
.num_actions
= num_actions
;
2742 data
.callback
= handle_pending_status
;
2743 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2749 (*the_target
->resume
) (actions
, num_actions
);
2755 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2757 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2758 && !report_no_resumed
)
2760 /* The client does not support this stop reply. At least
2762 sprintf (own_buf
, "E.No unwaited-for children left.");
2763 disable_async_io ();
2767 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2768 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2769 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2770 current_thread
->last_status
= last_status
;
2772 /* From the client's perspective, all-stop mode always stops all
2773 threads implicitly (and the target backend has already done
2774 so by now). Tag all threads as "want-stopped", so we don't
2775 resume them implicitly without the client telling us to. */
2776 gdb_wants_all_threads_stopped ();
2777 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2778 disable_async_io ();
2780 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2781 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2782 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2786 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2788 handle_v_attach (char *own_buf
)
2792 pid
= strtol (own_buf
+ 8, NULL
, 16);
2793 if (pid
!= 0 && attach_inferior (pid
) == 0)
2795 /* Don't report shared library events after attaching, even if
2796 some libraries are preloaded. GDB will always poll the
2797 library list. Avoids the "stopped by shared library event"
2798 notice on the GDB side. */
2803 /* In non-stop, we don't send a resume reply. Stop events
2804 will follow up using the normal notification
2809 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2815 write_enn (own_buf
);
2820 /* Run a new program. Return 1 if successful, 0 if failure. */
2822 handle_v_run (char *own_buf
)
2824 char *p
, *next_p
, **new_argv
;
2828 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2834 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2835 if (new_argv
== NULL
)
2837 write_enn (own_buf
);
2842 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2844 next_p
= strchr (p
, ';');
2846 next_p
= p
+ strlen (p
);
2848 if (i
== 0 && p
== next_p
)
2852 /* FIXME: Fail request if out of memory instead of dying. */
2853 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2854 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2855 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2864 if (new_argv
[0] == NULL
)
2866 /* GDB didn't specify a program to run. Use the program from the
2867 last run with the new argument list. */
2869 if (program_argv
== NULL
)
2871 write_enn (own_buf
);
2872 freeargv (new_argv
);
2876 new_argv
[0] = strdup (program_argv
[0]);
2877 if (new_argv
[0] == NULL
)
2879 write_enn (own_buf
);
2880 freeargv (new_argv
);
2885 /* Free the old argv and install the new one. */
2886 freeargv (program_argv
);
2887 program_argv
= new_argv
;
2889 start_inferior (program_argv
);
2890 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2892 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2894 /* In non-stop, sending a resume reply doesn't set the general
2895 thread, but GDB assumes a vRun sets it (this is so GDB can
2896 query which is the main thread of the new inferior. */
2898 general_thread
= last_ptid
;
2904 write_enn (own_buf
);
2909 /* Kill process. Return 1 if successful, 0 if failure. */
2911 handle_v_kill (char *own_buf
)
2914 char *p
= &own_buf
[6];
2916 pid
= strtol (p
, NULL
, 16);
2919 if (pid
!= 0 && kill_inferior (pid
) == 0)
2921 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2922 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2923 last_ptid
= pid_to_ptid (pid
);
2924 discard_queued_stop_replies (last_ptid
);
2930 write_enn (own_buf
);
2935 /* Handle all of the extended 'v' packets. */
2937 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2939 if (!disable_packet_vCont
)
2941 if (strcmp (own_buf
, "vCtrlC") == 0)
2943 (*the_target
->request_interrupt
) ();
2948 if (startswith (own_buf
, "vCont;"))
2950 require_running (own_buf
);
2951 handle_v_cont (own_buf
);
2955 if (startswith (own_buf
, "vCont?"))
2957 strcpy (own_buf
, "vCont;c;C;t");
2959 if (target_supports_hardware_single_step ()
2960 || target_supports_software_single_step ()
2961 || !vCont_supported
)
2963 /* If target supports single step either by hardware or by
2964 software, add actions s and S to the list of supported
2965 actions. On the other hand, if GDB doesn't request the
2966 supported vCont actions in qSupported packet, add s and
2967 S to the list too. */
2968 own_buf
= own_buf
+ strlen (own_buf
);
2969 strcpy (own_buf
, ";s;S");
2972 if (target_supports_range_stepping ())
2974 own_buf
= own_buf
+ strlen (own_buf
);
2975 strcpy (own_buf
, ";r");
2981 if (startswith (own_buf
, "vFile:")
2982 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2985 if (startswith (own_buf
, "vAttach;"))
2987 if ((!extended_protocol
|| !multi_process
) && target_running ())
2989 fprintf (stderr
, "Already debugging a process\n");
2990 write_enn (own_buf
);
2993 handle_v_attach (own_buf
);
2997 if (startswith (own_buf
, "vRun;"))
2999 if ((!extended_protocol
|| !multi_process
) && target_running ())
3001 fprintf (stderr
, "Already debugging a process\n");
3002 write_enn (own_buf
);
3005 handle_v_run (own_buf
);
3009 if (startswith (own_buf
, "vKill;"))
3011 if (!target_running ())
3013 fprintf (stderr
, "No process to kill\n");
3014 write_enn (own_buf
);
3017 handle_v_kill (own_buf
);
3021 if (handle_notif_ack (own_buf
, packet_len
))
3024 /* Otherwise we didn't know what packet it was. Say we didn't
3030 /* Resume thread and wait for another event. In non-stop mode,
3031 don't really wait here, but return immediatelly to the event
3034 myresume (char *own_buf
, int step
, int sig
)
3036 struct thread_resume resume_info
[2];
3038 int valid_cont_thread
;
3040 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3041 && !ptid_equal (cont_thread
, minus_one_ptid
));
3043 if (step
|| sig
|| valid_cont_thread
)
3045 resume_info
[0].thread
= current_ptid
;
3047 resume_info
[0].kind
= resume_step
;
3049 resume_info
[0].kind
= resume_continue
;
3050 resume_info
[0].sig
= sig
;
3054 if (!valid_cont_thread
)
3056 resume_info
[n
].thread
= minus_one_ptid
;
3057 resume_info
[n
].kind
= resume_continue
;
3058 resume_info
[n
].sig
= 0;
3062 resume (resume_info
, n
);
3065 /* Callback for for_each_inferior. Make a new stop reply for each
3069 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3071 struct thread_info
*thread
= (struct thread_info
*) entry
;
3073 /* For now, assume targets that don't have this callback also don't
3074 manage the thread's last_status field. */
3075 if (the_target
->thread_stopped
== NULL
)
3077 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3079 new_notif
->ptid
= entry
->id
;
3080 new_notif
->status
= thread
->last_status
;
3081 /* Pass the last stop reply back to GDB, but don't notify
3083 notif_event_enque (¬if_stop
,
3084 (struct notif_event
*) new_notif
);
3088 if (thread_stopped (thread
))
3093 = target_waitstatus_to_string (&thread
->last_status
);
3095 debug_printf ("Reporting thread %s as already stopped with %s\n",
3096 target_pid_to_str (entry
->id
),
3099 xfree (status_string
);
3102 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3104 /* Pass the last stop reply back to GDB, but don't notify
3106 queue_stop_reply (entry
->id
, &thread
->last_status
);
3113 /* Set this inferior threads's state as "want-stopped". We won't
3114 resume this thread until the client gives us another action for
3118 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3120 struct thread_info
*thread
= (struct thread_info
*) entry
;
3122 thread
->last_resume_kind
= resume_stop
;
3124 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3126 /* Most threads are stopped implicitly (all-stop); tag that with
3128 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3129 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3133 /* Set all threads' states as "want-stopped". */
3136 gdb_wants_all_threads_stopped (void)
3138 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3141 /* Clear the gdb_detached flag of every process. */
3144 gdb_reattached_process (struct inferior_list_entry
*entry
)
3146 struct process_info
*process
= (struct process_info
*) entry
;
3148 process
->gdb_detached
= 0;
3151 /* Callback for for_each_inferior. Clear the thread's pending status
3155 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3157 struct thread_info
*thread
= (struct thread_info
*) entry
;
3159 thread
->status_pending_p
= 0;
3162 /* Callback for for_each_inferior. If the thread is stopped with an
3163 interesting event, mark it as having a pending event. */
3166 set_pending_status_callback (struct inferior_list_entry
*entry
)
3168 struct thread_info
*thread
= (struct thread_info
*) entry
;
3170 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3171 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3172 /* A breakpoint, watchpoint or finished step from a previous
3173 GDB run isn't considered interesting for a new GDB run.
3174 If we left those pending, the new GDB could consider them
3175 random SIGTRAPs. This leaves out real async traps. We'd
3176 have to peek into the (target-specific) siginfo to
3177 distinguish those. */
3178 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3179 thread
->status_pending_p
= 1;
3182 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3183 pending status to report to GDB. */
3186 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3188 struct thread_info
*thread
= (struct thread_info
*) entry
;
3190 return thread
->status_pending_p
;
3193 /* Status handler for the '?' packet. */
3196 handle_status (char *own_buf
)
3198 /* GDB is connected, don't forward events to the target anymore. */
3199 for_each_inferior (&all_processes
, gdb_reattached_process
);
3201 /* In non-stop mode, we must send a stop reply for each stopped
3202 thread. In all-stop mode, just send one for the first stopped
3207 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3209 /* The first is sent immediatly. OK is sent if there is no
3210 stopped thread, which is the same handling of the vStopped
3211 packet (by design). */
3212 notif_write_event (¬if_stop
, own_buf
);
3216 struct inferior_list_entry
*thread
= NULL
;
3219 stabilize_threads ();
3220 gdb_wants_all_threads_stopped ();
3222 /* We can only report one status, but we might be coming out of
3223 non-stop -- if more than one thread is stopped with
3224 interesting events, leave events for the threads we're not
3225 reporting now pending. They'll be reported the next time the
3226 threads are resumed. Start by marking all interesting events
3228 for_each_inferior (&all_threads
, set_pending_status_callback
);
3230 /* Prefer the last thread that reported an event to GDB (even if
3231 that was a GDB_SIGNAL_TRAP). */
3232 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3233 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3234 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3235 thread
= find_inferior_id (&all_threads
, last_ptid
);
3237 /* If the last event thread is not found for some reason, look
3238 for some other thread that might have an event to report. */
3240 thread
= find_inferior (&all_threads
,
3241 find_status_pending_thread_callback
, NULL
);
3243 /* If we're still out of luck, simply pick the first thread in
3246 thread
= get_first_inferior (&all_threads
);
3250 struct thread_info
*tp
= (struct thread_info
*) thread
;
3252 /* We're reporting this event, so it's no longer
3254 tp
->status_pending_p
= 0;
3256 /* GDB assumes the current thread is the thread we're
3257 reporting the status for. */
3258 general_thread
= thread
->id
;
3259 set_desired_thread (1);
3261 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3262 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3265 strcpy (own_buf
, "W00");
3270 gdbserver_version (void)
3272 printf ("GNU gdbserver %s%s\n"
3273 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
3274 "gdbserver is free software, covered by the "
3275 "GNU General Public License.\n"
3276 "This gdbserver was configured as \"%s\"\n",
3277 PKGVERSION
, version
, host_name
);
3281 gdbserver_usage (FILE *stream
)
3283 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3284 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3285 "\tgdbserver [OPTIONS] --multi COMM\n"
3287 "COMM may either be a tty device (for serial debugging),\n"
3288 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3289 "stdin/stdout of gdbserver.\n"
3290 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3291 "PID is the process ID to attach to, when --attach is specified.\n"
3293 "Operating modes:\n"
3295 " --attach Attach to running process PID.\n"
3296 " --multi Start server without a specific program, and\n"
3297 " only quit when explicitly commanded.\n"
3298 " --once Exit after the first connection has closed.\n"
3299 " --help Print this message and then exit.\n"
3300 " --version Display version information and exit.\n"
3304 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3305 " --disable-randomization\n"
3306 " Run PROG with address space randomization disabled.\n"
3307 " --no-disable-randomization\n"
3308 " Don't disable address space randomization when\n"
3313 " --debug Enable general debugging output.\n"
3314 " --debug-format=opt1[,opt2,...]\n"
3315 " Specify extra content in debugging output.\n"
3320 " --remote-debug Enable remote protocol debugging output.\n"
3321 " --disable-packet=opt1[,opt2,...]\n"
3322 " Disable support for RSP packets or features.\n"
3324 " vCont, Tthread, qC, qfThreadInfo and \n"
3325 " threads (disable all threading packets).\n"
3327 "For more information, consult the GDB manual (available as on-line \n"
3328 "info or a printed manual).\n");
3329 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3330 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3334 gdbserver_show_disableable (FILE *stream
)
3336 fprintf (stream
, "Disableable packets:\n"
3337 " vCont \tAll vCont packets\n"
3338 " qC \tQuerying the current thread\n"
3339 " qfThreadInfo\tThread listing\n"
3340 " Tthread \tPassing the thread specifier in the "
3341 "T stop reply packet\n"
3342 " threads \tAll of the above\n");
3346 #undef require_running
3347 #define require_running(BUF) \
3348 if (!target_running ()) \
3355 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3357 int pid
= * (int *) args
;
3359 if (ptid_get_pid (entry
->id
) == pid
)
3366 kill_inferior_callback (struct inferior_list_entry
*entry
)
3368 struct process_info
*process
= (struct process_info
*) entry
;
3369 int pid
= ptid_get_pid (process
->entry
.id
);
3371 kill_inferior (pid
);
3372 discard_queued_stop_replies (pid_to_ptid (pid
));
3375 /* Callback for for_each_inferior to detach or kill the inferior,
3376 depending on whether we attached to it or not.
3377 We inform the user whether we're detaching or killing the process
3378 as this is only called when gdbserver is about to exit. */
3381 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3383 struct process_info
*process
= (struct process_info
*) entry
;
3384 int pid
= ptid_get_pid (process
->entry
.id
);
3386 if (process
->attached
)
3387 detach_inferior (pid
);
3389 kill_inferior (pid
);
3391 discard_queued_stop_replies (pid_to_ptid (pid
));
3394 /* for_each_inferior callback for detach_or_kill_for_exit to print
3395 the pids of started inferiors. */
3398 print_started_pid (struct inferior_list_entry
*entry
)
3400 struct process_info
*process
= (struct process_info
*) entry
;
3402 if (! process
->attached
)
3404 int pid
= ptid_get_pid (process
->entry
.id
);
3405 fprintf (stderr
, " %d", pid
);
3409 /* for_each_inferior callback for detach_or_kill_for_exit to print
3410 the pids of attached inferiors. */
3413 print_attached_pid (struct inferior_list_entry
*entry
)
3415 struct process_info
*process
= (struct process_info
*) entry
;
3417 if (process
->attached
)
3419 int pid
= ptid_get_pid (process
->entry
.id
);
3420 fprintf (stderr
, " %d", pid
);
3424 /* Call this when exiting gdbserver with possible inferiors that need
3425 to be killed or detached from. */
3428 detach_or_kill_for_exit (void)
3430 /* First print a list of the inferiors we will be killing/detaching.
3431 This is to assist the user, for example, in case the inferior unexpectedly
3432 dies after we exit: did we screw up or did the inferior exit on its own?
3433 Having this info will save some head-scratching. */
3435 if (have_started_inferiors_p ())
3437 fprintf (stderr
, "Killing process(es):");
3438 for_each_inferior (&all_processes
, print_started_pid
);
3439 fprintf (stderr
, "\n");
3441 if (have_attached_inferiors_p ())
3443 fprintf (stderr
, "Detaching process(es):");
3444 for_each_inferior (&all_processes
, print_attached_pid
);
3445 fprintf (stderr
, "\n");
3448 /* Now we can kill or detach the inferiors. */
3450 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3453 /* Value that will be passed to exit(3) when gdbserver exits. */
3454 static int exit_code
;
3456 /* Cleanup version of detach_or_kill_for_exit. */
3459 detach_or_kill_for_exit_cleanup (void *ignore
)
3464 detach_or_kill_for_exit ();
3467 CATCH (exception
, RETURN_MASK_ALL
)
3470 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3476 /* Main function. This is called by the real "main" function,
3477 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3479 static void ATTRIBUTE_NORETURN
3480 captured_main (int argc
, char *argv
[])
3484 char *arg_end
, *port
;
3485 char **next_arg
= &argv
[1];
3486 volatile int multi_mode
= 0;
3487 volatile int attach
= 0;
3490 while (*next_arg
!= NULL
&& **next_arg
== '-')
3492 if (strcmp (*next_arg
, "--version") == 0)
3494 gdbserver_version ();
3497 else if (strcmp (*next_arg
, "--help") == 0)
3499 gdbserver_usage (stdout
);
3502 else if (strcmp (*next_arg
, "--attach") == 0)
3504 else if (strcmp (*next_arg
, "--multi") == 0)
3506 else if (strcmp (*next_arg
, "--wrapper") == 0)
3510 wrapper_argv
= next_arg
;
3511 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3514 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3516 gdbserver_usage (stderr
);
3520 /* Consume the "--". */
3523 else if (strcmp (*next_arg
, "--debug") == 0)
3525 else if (startswith (*next_arg
, "--debug-format="))
3528 = parse_debug_format_options ((*next_arg
)
3529 + sizeof ("--debug-format=") - 1, 0);
3531 if (error_msg
!= NULL
)
3533 fprintf (stderr
, "%s", error_msg
);
3537 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3539 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3541 gdbserver_show_disableable (stdout
);
3544 else if (startswith (*next_arg
, "--disable-packet="))
3546 char *packets
, *tok
;
3548 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3549 for (tok
= strtok (packets
, ",");
3551 tok
= strtok (NULL
, ","))
3553 if (strcmp ("vCont", tok
) == 0)
3554 disable_packet_vCont
= 1;
3555 else if (strcmp ("Tthread", tok
) == 0)
3556 disable_packet_Tthread
= 1;
3557 else if (strcmp ("qC", tok
) == 0)
3558 disable_packet_qC
= 1;
3559 else if (strcmp ("qfThreadInfo", tok
) == 0)
3560 disable_packet_qfThreadInfo
= 1;
3561 else if (strcmp ("threads", tok
) == 0)
3563 disable_packet_vCont
= 1;
3564 disable_packet_Tthread
= 1;
3565 disable_packet_qC
= 1;
3566 disable_packet_qfThreadInfo
= 1;
3570 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3572 gdbserver_show_disableable (stderr
);
3577 else if (strcmp (*next_arg
, "-") == 0)
3579 /* "-" specifies a stdio connection and is a form of port
3581 *next_arg
= STDIO_CONNECTION_NAME
;
3584 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3585 disable_randomization
= 1;
3586 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3587 disable_randomization
= 0;
3588 else if (strcmp (*next_arg
, "--once") == 0)
3592 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3602 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3604 gdbserver_usage (stderr
);
3608 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3609 opened by remote_prepare. */
3612 save_original_signals_state ();
3614 /* We need to know whether the remote connection is stdio before
3615 starting the inferior. Inferiors created in this scenario have
3616 stdin,stdout redirected. So do this here before we call
3618 remote_prepare (port
);
3623 /* --attach used to come after PORT, so allow it there for
3625 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3632 && (*next_arg
== NULL
3633 || (*next_arg
)[0] == '\0'
3634 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3636 || next_arg
[1] != NULL
))
3641 gdbserver_usage (stderr
);
3645 initialize_async_io ();
3647 initialize_event_loop ();
3648 if (target_supports_tracepoints ())
3649 initialize_tracepoint ();
3650 initialize_notif ();
3652 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3653 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3655 if (pid
== 0 && *next_arg
!= NULL
)
3659 n
= argc
- (next_arg
- argv
);
3660 program_argv
= XNEWVEC (char *, n
+ 1);
3661 for (i
= 0; i
< n
; i
++)
3662 program_argv
[i
] = xstrdup (next_arg
[i
]);
3663 program_argv
[i
] = NULL
;
3665 /* Wait till we are at first instruction in program. */
3666 start_inferior (program_argv
);
3668 /* We are now (hopefully) stopped at the first instruction of
3669 the target process. This assumes that the target process was
3670 successfully created. */
3674 if (attach_inferior (pid
) == -1)
3675 error ("Attaching not supported on this target");
3677 /* Otherwise succeeded. */
3681 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3682 last_status
.value
.integer
= 0;
3683 last_ptid
= minus_one_ptid
;
3685 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3687 /* Don't report shared library events on the initial connection,
3688 even if some libraries are preloaded. Avoids the "stopped by
3689 shared library event" notice on gdb side. */
3692 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3693 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3698 if (!was_running
&& !multi_mode
)
3699 error ("No program to debug");
3706 report_fork_events
= 0;
3707 report_vfork_events
= 0;
3708 report_exec_events
= 0;
3709 /* Be sure we're out of tfind mode. */
3710 current_traceframe
= -1;
3711 cont_thread
= null_ptid
;
3712 swbreak_feature
= 0;
3713 hwbreak_feature
= 0;
3714 vCont_supported
= 0;
3720 /* Wait for events. This will return when all event sources
3721 are removed from the event loop. */
3722 start_event_loop ();
3724 /* If an exit was requested (using the "monitor exit"
3725 command), terminate now. */
3727 throw_quit ("Quit");
3729 /* The only other way to get here is for getpkt to fail:
3731 - If --once was specified, we're done.
3733 - If not in extended-remote mode, and we're no longer
3734 debugging anything, simply exit: GDB has disconnected
3735 after processing the last process exit.
3737 - Otherwise, close the connection and reopen it at the
3739 if (run_once
|| (!extended_protocol
&& !target_running ()))
3740 throw_quit ("Quit");
3743 "Remote side has terminated connection. "
3744 "GDBserver will reopen the connection.\n");
3746 /* Get rid of any pending statuses. An eventual reconnection
3747 (by the same GDB instance or another) will refresh all its
3748 state from scratch. */
3749 discard_queued_stop_replies (minus_one_ptid
);
3750 for_each_inferior (&all_threads
,
3751 clear_pending_status_callback
);
3755 if (disconnected_tracing
)
3757 /* Try to enable non-stop/async mode, so we we can
3758 both wait for an async socket accept, and handle
3759 async target events simultaneously. There's also
3760 no point either in having the target always stop
3761 all threads, when we're going to pass signals
3762 down without informing GDB. */
3765 if (start_non_stop (1))
3768 /* Detaching implicitly resumes all threads;
3769 simply disconnecting does not. */
3775 "Disconnected tracing disabled; "
3776 "stopping trace run.\n");
3781 CATCH (exception
, RETURN_MASK_ERROR
)
3784 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3786 if (response_needed
)
3788 write_enn (own_buf
);
3793 throw_quit ("Quit");
3799 /* Main function. */
3802 main (int argc
, char *argv
[])
3807 captured_main (argc
, argv
);
3809 CATCH (exception
, RETURN_MASK_ALL
)
3811 if (exception
.reason
== RETURN_ERROR
)
3814 fprintf (stderr
, "%s\n", exception
.message
);
3815 fprintf (stderr
, "Exiting\n");
3823 gdb_assert_not_reached ("captured_main should never return");
3826 /* Process options coming from Z packets for a breakpoint. PACKET is
3827 the packet buffer. *PACKET is updated to point to the first char
3828 after the last processed option. */
3831 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3833 char *dataptr
= *packet
;
3836 /* Check if data has the correct format. */
3837 if (*dataptr
!= ';')
3844 if (*dataptr
== ';')
3847 if (*dataptr
== 'X')
3849 /* Conditional expression. */
3851 debug_printf ("Found breakpoint condition.\n");
3852 if (!add_breakpoint_condition (bp
, &dataptr
))
3853 dataptr
= strchrnul (dataptr
, ';');
3855 else if (startswith (dataptr
, "cmds:"))
3857 dataptr
+= strlen ("cmds:");
3859 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3860 persist
= (*dataptr
== '1');
3862 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3863 dataptr
= strchrnul (dataptr
, ';');
3867 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3869 /* Skip tokens until we find one that we recognize. */
3870 dataptr
= strchrnul (dataptr
, ';');
3876 /* Event loop callback that handles a serial event. The first byte in
3877 the serial buffer gets us here. We expect characters to arrive at
3878 a brisk pace, so we read the rest of the packet with a blocking
3882 process_serial_event (void)
3893 int new_packet_len
= -1;
3895 disable_async_io ();
3897 response_needed
= 0;
3898 packet_len
= getpkt (own_buf
);
3899 if (packet_len
<= 0)
3902 /* Force an event loop break. */
3905 response_needed
= 1;
3912 handle_query (own_buf
, packet_len
, &new_packet_len
);
3915 handle_general_set (own_buf
);
3918 require_running (own_buf
);
3923 pid
= strtol (&own_buf
[i
], NULL
, 16);
3926 pid
= ptid_get_pid (current_ptid
);
3928 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3930 struct process_info
*process
= find_process_pid (pid
);
3932 if (process
== NULL
)
3934 write_enn (own_buf
);
3938 if (tracing
&& disconnected_tracing
)
3940 "Disconnected tracing in effect, "
3941 "leaving gdbserver attached to the process\n");
3943 if (any_persistent_commands ())
3945 "Persistent commands are present, "
3946 "leaving gdbserver attached to the process\n");
3948 /* Make sure we're in non-stop/async mode, so we we can both
3949 wait for an async socket accept, and handle async target
3950 events simultaneously. There's also no point either in
3951 having the target stop all threads, when we're going to
3952 pass signals down without informing GDB. */
3956 debug_printf ("Forcing non-stop mode\n");
3962 process
->gdb_detached
= 1;
3964 /* Detaching implicitly resumes all threads. */
3965 target_continue_no_signal (minus_one_ptid
);
3968 break; /* from switch/case */
3971 fprintf (stderr
, "Detaching from process %d\n", pid
);
3973 if (detach_inferior (pid
) != 0)
3974 write_enn (own_buf
);
3977 discard_queued_stop_replies (pid_to_ptid (pid
));
3980 if (extended_protocol
|| target_running ())
3982 /* There is still at least one inferior remaining or
3983 we are in extended mode, so don't terminate gdbserver,
3984 and instead treat this like a normal program exit. */
3985 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3986 last_status
.value
.integer
= 0;
3987 last_ptid
= pid_to_ptid (pid
);
3989 current_thread
= NULL
;
3996 /* If we are attached, then we can exit. Otherwise, we
3997 need to hang around doing nothing, until the child is
3999 join_inferior (pid
);
4005 extended_protocol
= 1;
4009 handle_status (own_buf
);
4012 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4014 ptid_t gdb_id
, thread_id
;
4017 require_running (own_buf
);
4019 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4021 pid
= ptid_get_pid (gdb_id
);
4023 if (ptid_equal (gdb_id
, null_ptid
)
4024 || ptid_equal (gdb_id
, minus_one_ptid
))
4025 thread_id
= null_ptid
;
4027 && ptid_equal (pid_to_ptid (pid
),
4030 struct thread_info
*thread
=
4031 (struct thread_info
*) find_inferior (&all_threads
,
4036 write_enn (own_buf
);
4040 thread_id
= thread
->entry
.id
;
4044 thread_id
= gdb_id_to_thread_id (gdb_id
);
4045 if (ptid_equal (thread_id
, null_ptid
))
4047 write_enn (own_buf
);
4052 if (own_buf
[1] == 'g')
4054 if (ptid_equal (thread_id
, null_ptid
))
4056 /* GDB is telling us to choose any thread. Check if
4057 the currently selected thread is still valid. If
4058 it is not, select the first available. */
4059 struct thread_info
*thread
=
4060 (struct thread_info
*) find_inferior_id (&all_threads
,
4063 thread
= get_first_thread ();
4064 thread_id
= thread
->entry
.id
;
4067 general_thread
= thread_id
;
4068 set_desired_thread (1);
4069 gdb_assert (current_thread
!= NULL
);
4071 else if (own_buf
[1] == 'c')
4072 cont_thread
= thread_id
;
4078 /* Silently ignore it so that gdb can extend the protocol
4079 without compatibility headaches. */
4084 require_running (own_buf
);
4085 if (current_traceframe
>= 0)
4087 struct regcache
*regcache
4088 = new_register_cache (current_target_desc ());
4090 if (fetch_traceframe_registers (current_traceframe
,
4092 registers_to_string (regcache
, own_buf
);
4094 write_enn (own_buf
);
4095 free_register_cache (regcache
);
4099 struct regcache
*regcache
;
4101 if (!set_desired_thread (1))
4102 write_enn (own_buf
);
4105 regcache
= get_thread_regcache (current_thread
, 1);
4106 registers_to_string (regcache
, own_buf
);
4111 require_running (own_buf
);
4112 if (current_traceframe
>= 0)
4113 write_enn (own_buf
);
4116 struct regcache
*regcache
;
4118 if (!set_desired_thread (1))
4119 write_enn (own_buf
);
4122 regcache
= get_thread_regcache (current_thread
, 1);
4123 registers_from_string (regcache
, &own_buf
[1]);
4129 require_running (own_buf
);
4130 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4131 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4133 write_enn (own_buf
);
4135 bin2hex (mem_buf
, own_buf
, res
);
4138 require_running (own_buf
);
4139 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4140 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4143 write_enn (own_buf
);
4146 require_running (own_buf
);
4147 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4148 &mem_addr
, &len
, &mem_buf
) < 0
4149 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4150 write_enn (own_buf
);
4155 require_running (own_buf
);
4156 hex2bin (own_buf
+ 1, &sig
, 1);
4157 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4158 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4161 myresume (own_buf
, 0, signal
);
4164 require_running (own_buf
);
4165 hex2bin (own_buf
+ 1, &sig
, 1);
4166 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4167 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4170 myresume (own_buf
, 1, signal
);
4173 require_running (own_buf
);
4175 myresume (own_buf
, 0, signal
);
4178 require_running (own_buf
);
4180 myresume (own_buf
, 1, signal
);
4182 case 'Z': /* insert_ ... */
4184 case 'z': /* remove_ ... */
4189 char type
= own_buf
[1];
4191 const int insert
= ch
== 'Z';
4192 char *p
= &own_buf
[3];
4194 p
= unpack_varlen_hex (p
, &addr
);
4195 kind
= strtol (p
+ 1, &dataptr
, 16);
4199 struct gdb_breakpoint
*bp
;
4201 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4206 /* GDB may have sent us a list of *point parameters to
4207 be evaluated on the target's side. Read such list
4208 here. If we already have a list of parameters, GDB
4209 is telling us to drop that list and use this one
4211 clear_breakpoint_conditions_and_commands (bp
);
4212 process_point_options (bp
, &dataptr
);
4216 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4224 write_enn (own_buf
);
4228 response_needed
= 0;
4229 if (!target_running ())
4230 /* The packet we received doesn't make sense - but we can't
4231 reply to it, either. */
4234 fprintf (stderr
, "Killing all inferiors\n");
4235 for_each_inferior (&all_processes
, kill_inferior_callback
);
4237 /* When using the extended protocol, we wait with no program
4238 running. The traditional protocol will exit instead. */
4239 if (extended_protocol
)
4241 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4242 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4250 ptid_t gdb_id
, thread_id
;
4252 require_running (own_buf
);
4254 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4255 thread_id
= gdb_id_to_thread_id (gdb_id
);
4256 if (ptid_equal (thread_id
, null_ptid
))
4258 write_enn (own_buf
);
4262 if (mythread_alive (thread_id
))
4265 write_enn (own_buf
);
4269 response_needed
= 0;
4271 /* Restarting the inferior is only supported in the extended
4273 if (extended_protocol
)
4275 if (target_running ())
4276 for_each_inferior (&all_processes
,
4277 kill_inferior_callback
);
4278 fprintf (stderr
, "GDBserver restarting\n");
4280 /* Wait till we are at 1st instruction in prog. */
4281 if (program_argv
!= NULL
)
4283 start_inferior (program_argv
);
4284 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4286 /* Stopped at the first instruction of the target
4288 general_thread
= last_ptid
;
4292 /* Something went wrong. */
4293 general_thread
= null_ptid
;
4298 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4299 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4305 /* It is a request we don't understand. Respond with an
4306 empty packet so that gdb knows that we don't support this
4312 /* Extended (long) request. */
4313 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4317 /* It is a request we don't understand. Respond with an empty
4318 packet so that gdb knows that we don't support this
4324 if (new_packet_len
!= -1)
4325 putpkt_binary (own_buf
, new_packet_len
);
4329 response_needed
= 0;
4337 /* Event-loop callback for serial events. */
4340 handle_serial_event (int err
, gdb_client_data client_data
)
4343 debug_printf ("handling possible serial event\n");
4345 /* Really handle it. */
4346 if (process_serial_event () < 0)
4349 /* Be sure to not change the selected thread behind GDB's back.
4350 Important in the non-stop mode asynchronous protocol. */
4351 set_desired_thread (1);
4356 /* Push a stop notification on the notification queue. */
4359 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4361 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4363 vstop_notif
->status
= *status
;
4364 vstop_notif
->ptid
= ptid
;
4365 /* Push Stop notification. */
4366 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4369 /* Event-loop callback for target events. */
4372 handle_target_event (int err
, gdb_client_data client_data
)
4375 debug_printf ("handling possible target event\n");
4377 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4380 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4382 if (gdb_connected () && report_no_resumed
)
4383 push_stop_notification (null_ptid
, &last_status
);
4385 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4387 int pid
= ptid_get_pid (last_ptid
);
4388 struct process_info
*process
= find_process_pid (pid
);
4389 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4391 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4392 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4394 mark_breakpoints_out (process
);
4395 mourn_inferior (process
);
4397 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4401 /* We're reporting this thread as stopped. Update its
4402 "want-stopped" state to what the client wants, until it
4403 gets a new resume action. */
4404 current_thread
->last_resume_kind
= resume_stop
;
4405 current_thread
->last_status
= last_status
;
4410 if (!target_running ())
4412 /* The last process exited. We're done. */
4416 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4417 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4418 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4422 /* A thread stopped with a signal, but gdb isn't
4423 connected to handle it. Pass it down to the
4424 inferior, as if it wasn't being traced. */
4425 enum gdb_signal signal
;
4428 debug_printf ("GDB not connected; forwarding event %d for"
4430 (int) last_status
.kind
,
4431 target_pid_to_str (last_ptid
));
4433 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4434 signal
= last_status
.value
.sig
;
4436 signal
= GDB_SIGNAL_0
;
4437 target_continue (last_ptid
, signal
);
4441 push_stop_notification (last_ptid
, &last_status
);
4444 /* Be sure to not change the selected thread behind GDB's back.
4445 Important in the non-stop mode asynchronous protocol. */
4446 set_desired_thread (1);