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"
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 struct thread_resume resume_info
;
263 memset (&resume_info
, 0, sizeof (resume_info
));
264 resume_info
.thread
= pid_to_ptid (signal_pid
);
265 resume_info
.kind
= resume_continue
;
268 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
270 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
274 (*the_target
->resume
) (&resume_info
, 1);
276 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
277 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
280 current_thread
->last_resume_kind
= resume_stop
;
281 current_thread
->last_status
= last_status
;
283 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
285 target_post_create_inferior ();
289 /* Wait till we are at 1st instruction in program, return new pid
290 (assuming success). */
291 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
293 target_post_create_inferior ();
295 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
296 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
298 current_thread
->last_resume_kind
= resume_stop
;
299 current_thread
->last_status
= last_status
;
302 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
308 attach_inferior (int pid
)
310 /* myattach should return -1 if attaching is unsupported,
311 0 if it succeeded, and call error() otherwise. */
313 if (myattach (pid
) != 0)
316 fprintf (stderr
, "Attached; pid = %d\n", pid
);
319 /* FIXME - It may be that we should get the SIGNAL_PID from the
320 attach function, so that it can be the main thread instead of
321 whichever we were told to attach to. */
326 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
328 /* GDB knows to ignore the first SIGSTOP after attaching to a running
329 process using the "attach" command, but this is different; it's
330 just using "target remote". Pretend it's just starting up. */
331 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
332 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
333 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
335 current_thread
->last_resume_kind
= resume_stop
;
336 current_thread
->last_status
= last_status
;
342 extern int remote_debug
;
344 /* Decode a qXfer read request. Return 0 if everything looks OK,
348 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
350 /* After the read marker and annex, qXfer looks like a
351 traditional 'm' packet. */
352 decode_m_packet (buf
, ofs
, len
);
358 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
360 /* Extract and NUL-terminate the object. */
362 while (*buf
&& *buf
!= ':')
368 /* Extract and NUL-terminate the read/write action. */
370 while (*buf
&& *buf
!= ':')
376 /* Extract and NUL-terminate the annex. */
378 while (*buf
&& *buf
!= ':')
388 /* Write the response to a successful qXfer read. Returns the
389 length of the (binary) data stored in BUF, corresponding
390 to as much of DATA/LEN as we could fit. IS_MORE controls
391 the first character of the response. */
393 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
402 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
403 &out_len
, PBUFSIZ
- 2) + 1;
406 /* Handle btrace enabling in BTS format. */
409 handle_btrace_enable_bts (struct thread_info
*thread
)
411 if (thread
->btrace
!= NULL
)
412 return "E.Btrace already enabled.";
414 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
415 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
416 ¤t_btrace_conf
);
417 if (thread
->btrace
== NULL
)
418 return "E.Could not enable btrace.";
423 /* Handle btrace enabling in Intel Processor Trace format. */
426 handle_btrace_enable_pt (struct thread_info
*thread
)
428 if (thread
->btrace
!= NULL
)
429 return "E.Btrace already enabled.";
431 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
432 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
433 ¤t_btrace_conf
);
434 if (thread
->btrace
== NULL
)
435 return "E.Could not enable btrace.";
440 /* Handle btrace disabling. */
443 handle_btrace_disable (struct thread_info
*thread
)
446 if (thread
->btrace
== NULL
)
447 return "E.Branch tracing not enabled.";
449 if (target_disable_btrace (thread
->btrace
) != 0)
450 return "E.Could not disable branch tracing.";
452 thread
->btrace
= NULL
;
456 /* Handle the "Qbtrace" packet. */
459 handle_btrace_general_set (char *own_buf
)
461 struct thread_info
*thread
;
465 if (!startswith (own_buf
, "Qbtrace:"))
468 op
= own_buf
+ strlen ("Qbtrace:");
470 if (ptid_equal (general_thread
, null_ptid
)
471 || ptid_equal (general_thread
, minus_one_ptid
))
473 strcpy (own_buf
, "E.Must select a single thread.");
477 thread
= find_thread_ptid (general_thread
);
480 strcpy (own_buf
, "E.No such thread.");
486 if (strcmp (op
, "bts") == 0)
487 err
= handle_btrace_enable_bts (thread
);
488 else if (strcmp (op
, "pt") == 0)
489 err
= handle_btrace_enable_pt (thread
);
490 else if (strcmp (op
, "off") == 0)
491 err
= handle_btrace_disable (thread
);
493 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
496 strcpy (own_buf
, err
);
503 /* Handle the "Qbtrace-conf" packet. */
506 handle_btrace_conf_general_set (char *own_buf
)
508 struct thread_info
*thread
;
511 if (!startswith (own_buf
, "Qbtrace-conf:"))
514 op
= own_buf
+ strlen ("Qbtrace-conf:");
516 if (ptid_equal (general_thread
, null_ptid
)
517 || ptid_equal (general_thread
, minus_one_ptid
))
519 strcpy (own_buf
, "E.Must select a single thread.");
523 thread
= find_thread_ptid (general_thread
);
526 strcpy (own_buf
, "E.No such thread.");
530 if (startswith (op
, "bts:size="))
536 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
537 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
539 strcpy (own_buf
, "E.Bad size value.");
543 current_btrace_conf
.bts
.size
= (unsigned int) size
;
545 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
551 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
552 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
554 strcpy (own_buf
, "E.Bad size value.");
558 current_btrace_conf
.pt
.size
= (unsigned int) size
;
562 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
570 /* Handle all of the extended 'Q' packets. */
573 handle_general_set (char *own_buf
)
575 if (startswith (own_buf
, "QPassSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QPassSignals:");
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QProgramSignals:"))
602 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
603 const char *p
= own_buf
+ strlen ("QProgramSignals:");
606 program_signals_p
= 1;
608 p
= decode_address_to_semicolon (&cursig
, p
);
609 for (i
= 0; i
< numsigs
; i
++)
613 program_signals
[i
] = 1;
615 /* Keep looping, to clear the remaining signals. */
618 p
= decode_address_to_semicolon (&cursig
, p
);
621 program_signals
[i
] = 0;
623 strcpy (own_buf
, "OK");
627 if (startswith (own_buf
, "QCatchSyscalls:"))
629 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
632 struct process_info
*process
;
634 if (!target_running () || !target_supports_catch_syscall ())
640 if (strcmp (p
, "0") == 0)
642 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
646 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
652 process
= current_process ();
653 VEC_truncate (int, process
->syscalls_to_catch
, 0);
663 p
= decode_address_to_semicolon (&sysno
, p
);
664 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
668 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
675 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
679 fprintf (stderr
, "[noack mode enabled]\n");
688 if (startswith (own_buf
, "QNonStop:"))
690 char *mode
= own_buf
+ 9;
694 if (strcmp (mode
, "0") == 0)
696 else if (strcmp (mode
, "1") == 0)
700 /* We don't know what this mode is, so complain to
702 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
708 req_str
= req
? "non-stop" : "all-stop";
709 if (start_non_stop (req
) != 0)
711 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
719 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
725 if (startswith (own_buf
, "QDisableRandomization:"))
727 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
730 unpack_varlen_hex (packet
, &setting
);
731 disable_randomization
= setting
;
735 if (disable_randomization
)
736 fprintf (stderr
, "[address space randomization disabled]\n");
738 fprintf (stderr
, "[address space randomization enabled]\n");
745 if (target_supports_tracepoints ()
746 && handle_tracepoint_general_set (own_buf
))
749 if (startswith (own_buf
, "QAgent:"))
751 char *mode
= own_buf
+ strlen ("QAgent:");
754 if (strcmp (mode
, "0") == 0)
756 else if (strcmp (mode
, "1") == 0)
760 /* We don't know what this value is, so complain to GDB. */
761 sprintf (own_buf
, "E.Unknown QAgent value");
765 /* Update the flag. */
768 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
773 if (handle_btrace_general_set (own_buf
))
776 if (handle_btrace_conf_general_set (own_buf
))
779 if (startswith (own_buf
, "QThreadEvents:"))
781 char *mode
= own_buf
+ strlen ("QThreadEvents:");
782 enum tribool req
= TRIBOOL_UNKNOWN
;
784 if (strcmp (mode
, "0") == 0)
786 else if (strcmp (mode
, "1") == 0)
790 char *mode_copy
= xstrdup (mode
);
792 /* We don't know what this mode is, so complain to GDB. */
793 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
799 report_thread_events
= (req
== TRIBOOL_TRUE
);
803 const char *req_str
= report_thread_events
? "enabled" : "disabled";
805 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
812 /* Otherwise we didn't know what packet it was. Say we didn't
818 get_features_xml (const char *annex
)
820 const struct target_desc
*desc
= current_target_desc ();
822 /* `desc->xmltarget' defines what to return when looking for the
823 "target.xml" file. Its contents can either be verbatim XML code
824 (prefixed with a '@') or else the name of the actual XML file to
825 be used in place of "target.xml".
827 This variable is set up from the auto-generated
828 init_registers_... routine for the current target. */
830 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
832 if (*desc
->xmltarget
== '@')
833 return desc
->xmltarget
+ 1;
835 annex
= desc
->xmltarget
;
840 extern const char *const xml_builtin
[][2];
843 /* Look for the annex. */
844 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
845 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
848 if (xml_builtin
[i
][0] != NULL
)
849 return xml_builtin
[i
][1];
857 monitor_show_help (void)
859 monitor_output ("The following monitor commands are supported:\n");
860 monitor_output (" set debug <0|1>\n");
861 monitor_output (" Enable general debugging messages\n");
862 monitor_output (" set debug-hw-points <0|1>\n");
863 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
864 monitor_output (" set remote-debug <0|1>\n");
865 monitor_output (" Enable remote protocol debugging messages\n");
866 monitor_output (" set debug-format option1[,option2,...]\n");
867 monitor_output (" Add additional information to debugging messages\n");
868 monitor_output (" Options: all, none");
869 monitor_output (", timestamp");
870 monitor_output ("\n");
871 monitor_output (" exit\n");
872 monitor_output (" Quit GDBserver\n");
875 /* Read trace frame or inferior memory. Returns the number of bytes
876 actually read, zero when no further transfer is possible, and -1 on
877 error. Return of a positive value smaller than LEN does not
878 indicate there's no more to be read, only the end of the transfer.
879 E.g., when GDB reads memory from a traceframe, a first request may
880 be served from a memory block that does not cover the whole request
881 length. A following request gets the rest served from either
882 another block (of the same traceframe) or from the read-only
886 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
890 if (current_traceframe
>= 0)
893 ULONGEST length
= len
;
895 if (traceframe_read_mem (current_traceframe
,
896 memaddr
, myaddr
, len
, &nbytes
))
898 /* Data read from trace buffer, we're done. */
901 if (!in_readonly_region (memaddr
, length
))
903 /* Otherwise we have a valid readonly case, fall through. */
904 /* (assume no half-trace half-real blocks for now) */
907 res
= prepare_to_access_memory ();
910 if (set_desired_thread (1))
911 res
= read_inferior_memory (memaddr
, myaddr
, len
);
914 done_accessing_memory ();
916 return res
== 0 ? len
: -1;
922 /* Write trace frame or inferior memory. Actually, writing to trace
923 frames is forbidden. */
926 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
928 if (current_traceframe
>= 0)
934 ret
= prepare_to_access_memory ();
937 if (set_desired_thread (1))
938 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
941 done_accessing_memory ();
947 /* Subroutine of handle_search_memory to simplify it. */
950 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
951 gdb_byte
*pattern
, unsigned pattern_len
,
952 gdb_byte
*search_buf
,
953 unsigned chunk_size
, unsigned search_buf_size
,
954 CORE_ADDR
*found_addrp
)
956 /* Prime the search buffer. */
958 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
961 warning ("Unable to access %ld bytes of target "
962 "memory at 0x%lx, halting search.",
963 (long) search_buf_size
, (long) start_addr
);
967 /* Perform the search.
969 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
970 When we've scanned N bytes we copy the trailing bytes to the start and
971 read in another N bytes. */
973 while (search_space_len
>= pattern_len
)
976 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
980 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
983 if (found_ptr
!= NULL
)
985 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
986 *found_addrp
= found_addr
;
990 /* Not found in this chunk, skip to next chunk. */
992 /* Don't let search_space_len wrap here, it's unsigned. */
993 if (search_space_len
>= chunk_size
)
994 search_space_len
-= chunk_size
;
996 search_space_len
= 0;
998 if (search_space_len
>= pattern_len
)
1000 unsigned keep_len
= search_buf_size
- chunk_size
;
1001 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1004 /* Copy the trailing part of the previous iteration to the front
1005 of the buffer for the next iteration. */
1006 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1008 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1009 ? search_space_len
- keep_len
1012 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1013 nr_to_read
) != search_buf_size
)
1015 warning ("Unable to access %ld bytes of target memory "
1016 "at 0x%lx, halting search.",
1017 (long) nr_to_read
, (long) read_addr
);
1021 start_addr
+= chunk_size
;
1030 /* Handle qSearch:memory packets. */
1033 handle_search_memory (char *own_buf
, int packet_len
)
1035 CORE_ADDR start_addr
;
1036 CORE_ADDR search_space_len
;
1038 unsigned int pattern_len
;
1039 /* NOTE: also defined in find.c testcase. */
1040 #define SEARCH_CHUNK_SIZE 16000
1041 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1042 /* Buffer to hold memory contents for searching. */
1043 gdb_byte
*search_buf
;
1044 unsigned search_buf_size
;
1046 CORE_ADDR found_addr
;
1047 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1049 pattern
= (gdb_byte
*) malloc (packet_len
);
1050 if (pattern
== NULL
)
1052 error ("Unable to allocate memory to perform the search");
1053 strcpy (own_buf
, "E00");
1056 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1057 packet_len
- cmd_name_len
,
1058 &start_addr
, &search_space_len
,
1059 pattern
, &pattern_len
) < 0)
1062 error ("Error in parsing qSearch:memory packet");
1063 strcpy (own_buf
, "E00");
1067 search_buf_size
= chunk_size
+ pattern_len
- 1;
1069 /* No point in trying to allocate a buffer larger than the search space. */
1070 if (search_space_len
< search_buf_size
)
1071 search_buf_size
= search_space_len
;
1073 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1074 if (search_buf
== NULL
)
1077 error ("Unable to allocate memory to perform the search");
1078 strcpy (own_buf
, "E00");
1082 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1083 pattern
, pattern_len
,
1084 search_buf
, chunk_size
, search_buf_size
,
1088 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1089 else if (found
== 0)
1090 strcpy (own_buf
, "0");
1092 strcpy (own_buf
, "E00");
1098 #define require_running(BUF) \
1099 if (!target_running ()) \
1105 /* Parse options to --debug-format= and "monitor set debug-format".
1106 ARG is the text after "--debug-format=" or "monitor set debug-format".
1107 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1108 This triggers calls to monitor_output.
1109 The result is NULL if all options were parsed ok, otherwise an error
1110 message which the caller must free.
1112 N.B. These commands affect all debug format settings, they are not
1113 cumulative. If a format is not specified, it is turned off.
1114 However, we don't go to extra trouble with things like
1115 "monitor set debug-format all,none,timestamp".
1116 Instead we just parse them one at a time, in order.
1118 The syntax for "monitor set debug" we support here is not identical
1119 to gdb's "set debug foo on|off" because we also use this function to
1120 parse "--debug-format=foo,bar". */
1123 parse_debug_format_options (const char *arg
, int is_monitor
)
1125 VEC (char_ptr
) *options
;
1129 /* First turn all debug format options off. */
1130 debug_timestamp
= 0;
1132 /* First remove leading spaces, for "monitor set debug-format". */
1133 while (isspace (*arg
))
1136 options
= delim_string_to_char_ptr_vec (arg
, ',');
1138 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1140 if (strcmp (option
, "all") == 0)
1142 debug_timestamp
= 1;
1144 monitor_output ("All extra debug format options enabled.\n");
1146 else if (strcmp (option
, "none") == 0)
1148 debug_timestamp
= 0;
1150 monitor_output ("All extra debug format options disabled.\n");
1152 else if (strcmp (option
, "timestamp") == 0)
1154 debug_timestamp
= 1;
1156 monitor_output ("Timestamps will be added to debug output.\n");
1158 else if (*option
== '\0')
1160 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1165 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1168 free_char_ptr_vec (options
);
1173 free_char_ptr_vec (options
);
1177 /* Handle monitor commands not handled by target-specific handlers. */
1180 handle_monitor_command (char *mon
, char *own_buf
)
1182 if (strcmp (mon
, "set debug 1") == 0)
1185 monitor_output ("Debug output enabled.\n");
1187 else if (strcmp (mon
, "set debug 0") == 0)
1190 monitor_output ("Debug output disabled.\n");
1192 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1194 show_debug_regs
= 1;
1195 monitor_output ("H/W point debugging output enabled.\n");
1197 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1199 show_debug_regs
= 0;
1200 monitor_output ("H/W point debugging output disabled.\n");
1202 else if (strcmp (mon
, "set remote-debug 1") == 0)
1205 monitor_output ("Protocol debug output enabled.\n");
1207 else if (strcmp (mon
, "set remote-debug 0") == 0)
1210 monitor_output ("Protocol debug output disabled.\n");
1212 else if (startswith (mon
, "set debug-format "))
1215 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1218 if (error_msg
!= NULL
)
1220 monitor_output (error_msg
);
1221 monitor_show_help ();
1222 write_enn (own_buf
);
1226 else if (strcmp (mon
, "help") == 0)
1227 monitor_show_help ();
1228 else if (strcmp (mon
, "exit") == 0)
1232 monitor_output ("Unknown monitor command.\n\n");
1233 monitor_show_help ();
1234 write_enn (own_buf
);
1238 /* Associates a callback with each supported qXfer'able object. */
1242 /* The object this handler handles. */
1245 /* Request that the target transfer up to LEN 8-bit bytes of the
1246 target's OBJECT. The OFFSET, for a seekable object, specifies
1247 the starting point. The ANNEX can be used to provide additional
1248 data-specific information to the target.
1250 Return the number of bytes actually transfered, zero when no
1251 further transfer is possible, -1 on error, -2 when the transfer
1252 is not supported, and -3 on a verbose error message that should
1253 be preserved. Return of a positive value smaller than LEN does
1254 not indicate the end of the object, only the end of the transfer.
1256 One, and only one, of readbuf or writebuf must be non-NULL. */
1257 int (*xfer
) (const char *annex
,
1258 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1259 ULONGEST offset
, LONGEST len
);
1262 /* Handle qXfer:auxv:read. */
1265 handle_qxfer_auxv (const char *annex
,
1266 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1267 ULONGEST offset
, LONGEST len
)
1269 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1272 if (annex
[0] != '\0' || current_thread
== NULL
)
1275 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1278 /* Handle qXfer:exec-file:read. */
1281 handle_qxfer_exec_file (const char *const_annex
,
1282 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1283 ULONGEST offset
, LONGEST len
)
1289 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1292 if (const_annex
[0] == '\0')
1294 if (current_thread
== NULL
)
1297 pid
= pid_of (current_thread
);
1301 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1303 strcpy (annex
, const_annex
);
1304 annex
= unpack_varlen_hex (annex
, &pid
);
1306 if (annex
[0] != '\0')
1313 file
= (*the_target
->pid_to_exec_file
) (pid
);
1317 total_len
= strlen (file
);
1319 if (offset
> total_len
)
1322 if (offset
+ len
> total_len
)
1323 len
= total_len
- offset
;
1325 memcpy (readbuf
, file
+ offset
, len
);
1329 /* Handle qXfer:features:read. */
1332 handle_qxfer_features (const char *annex
,
1333 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1334 ULONGEST offset
, LONGEST len
)
1336 const char *document
;
1339 if (writebuf
!= NULL
)
1342 if (!target_running ())
1345 /* Grab the correct annex. */
1346 document
= get_features_xml (annex
);
1347 if (document
== NULL
)
1350 total_len
= strlen (document
);
1352 if (offset
> total_len
)
1355 if (offset
+ len
> total_len
)
1356 len
= total_len
- offset
;
1358 memcpy (readbuf
, document
+ offset
, len
);
1362 /* Worker routine for handle_qxfer_libraries.
1363 Add to the length pointed to by ARG a conservative estimate of the
1364 length needed to transmit the file name of INF. */
1367 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1369 struct dll_info
*dll
= (struct dll_info
*) inf
;
1370 unsigned int *total_len
= (unsigned int *) arg
;
1372 /* Over-estimate the necessary memory. Assume that every character
1373 in the library name must be escaped. */
1374 *total_len
+= 128 + 6 * strlen (dll
->name
);
1377 /* Worker routine for handle_qxfer_libraries.
1378 Emit the XML to describe the library in INF. */
1381 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1383 struct dll_info
*dll
= (struct dll_info
*) inf
;
1384 char **p_ptr
= (char **) arg
;
1388 strcpy (p
, " <library name=\"");
1390 name
= xml_escape_text (dll
->name
);
1394 strcpy (p
, "\"><segment address=\"");
1396 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1398 strcpy (p
, "\"/></library>\n");
1404 /* Handle qXfer:libraries:read. */
1407 handle_qxfer_libraries (const char *annex
,
1408 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1409 ULONGEST offset
, LONGEST len
)
1411 unsigned int total_len
;
1414 if (writebuf
!= NULL
)
1417 if (annex
[0] != '\0' || current_thread
== NULL
)
1421 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1424 document
= (char *) malloc (total_len
);
1425 if (document
== NULL
)
1428 strcpy (document
, "<library-list version=\"1.0\">\n");
1429 p
= document
+ strlen (document
);
1431 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1433 strcpy (p
, "</library-list>\n");
1435 total_len
= strlen (document
);
1437 if (offset
> total_len
)
1443 if (offset
+ len
> total_len
)
1444 len
= total_len
- offset
;
1446 memcpy (readbuf
, document
+ offset
, len
);
1451 /* Handle qXfer:libraries-svr4:read. */
1454 handle_qxfer_libraries_svr4 (const char *annex
,
1455 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1456 ULONGEST offset
, LONGEST len
)
1458 if (writebuf
!= NULL
)
1461 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1464 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1467 /* Handle qXfer:osadata:read. */
1470 handle_qxfer_osdata (const char *annex
,
1471 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1472 ULONGEST offset
, LONGEST len
)
1474 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1477 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1480 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1483 handle_qxfer_siginfo (const char *annex
,
1484 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1485 ULONGEST offset
, LONGEST len
)
1487 if (the_target
->qxfer_siginfo
== NULL
)
1490 if (annex
[0] != '\0' || current_thread
== NULL
)
1493 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1496 /* Handle qXfer:spu:read and qXfer:spu:write. */
1499 handle_qxfer_spu (const char *annex
,
1500 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1501 ULONGEST offset
, LONGEST len
)
1503 if (the_target
->qxfer_spu
== NULL
)
1506 if (current_thread
== NULL
)
1509 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1512 /* Handle qXfer:statictrace:read. */
1515 handle_qxfer_statictrace (const char *annex
,
1516 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1517 ULONGEST offset
, LONGEST len
)
1521 if (writebuf
!= NULL
)
1524 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1527 if (traceframe_read_sdata (current_traceframe
, offset
,
1528 readbuf
, len
, &nbytes
))
1533 /* Helper for handle_qxfer_threads_proper.
1534 Emit the XML to describe the thread of INF. */
1537 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1539 struct thread_info
*thread
= (struct thread_info
*) inf
;
1540 struct buffer
*buffer
= (struct buffer
*) arg
;
1541 ptid_t ptid
= thread_to_gdb_id (thread
);
1543 int core
= target_core_of_thread (ptid
);
1545 const char *name
= target_thread_name (ptid
);
1547 write_ptid (ptid_s
, ptid
);
1549 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1553 sprintf (core_s
, "%d", core
);
1554 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1558 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1560 buffer_xml_printf (buffer
, "/>\n");
1563 /* Helper for handle_qxfer_threads. */
1566 handle_qxfer_threads_proper (struct buffer
*buffer
)
1568 buffer_grow_str (buffer
, "<threads>\n");
1570 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1573 buffer_grow_str0 (buffer
, "</threads>\n");
1576 /* Handle qXfer:threads:read. */
1579 handle_qxfer_threads (const char *annex
,
1580 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1581 ULONGEST offset
, LONGEST len
)
1583 static char *result
= 0;
1584 static unsigned int result_length
= 0;
1586 if (writebuf
!= NULL
)
1589 if (annex
[0] != '\0')
1594 struct buffer buffer
;
1595 /* When asked for data at offset 0, generate everything and store into
1596 'result'. Successive reads will be served off 'result'. */
1600 buffer_init (&buffer
);
1602 handle_qxfer_threads_proper (&buffer
);
1604 result
= buffer_finish (&buffer
);
1605 result_length
= strlen (result
);
1606 buffer_free (&buffer
);
1609 if (offset
>= result_length
)
1611 /* We're out of data. */
1618 if (len
> result_length
- offset
)
1619 len
= result_length
- offset
;
1621 memcpy (readbuf
, result
+ offset
, len
);
1626 /* Handle qXfer:traceframe-info:read. */
1629 handle_qxfer_traceframe_info (const char *annex
,
1630 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1631 ULONGEST offset
, LONGEST len
)
1633 static char *result
= 0;
1634 static unsigned int result_length
= 0;
1636 if (writebuf
!= NULL
)
1639 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1644 struct buffer buffer
;
1646 /* When asked for data at offset 0, generate everything and
1647 store into 'result'. Successive reads will be served off
1651 buffer_init (&buffer
);
1653 traceframe_read_info (current_traceframe
, &buffer
);
1655 result
= buffer_finish (&buffer
);
1656 result_length
= strlen (result
);
1657 buffer_free (&buffer
);
1660 if (offset
>= result_length
)
1662 /* We're out of data. */
1669 if (len
> result_length
- offset
)
1670 len
= result_length
- offset
;
1672 memcpy (readbuf
, result
+ offset
, len
);
1676 /* Handle qXfer:fdpic:read. */
1679 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1680 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1682 if (the_target
->read_loadmap
== NULL
)
1685 if (current_thread
== NULL
)
1688 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1691 /* Handle qXfer:btrace:read. */
1694 handle_qxfer_btrace (const char *annex
,
1695 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1696 ULONGEST offset
, LONGEST len
)
1698 static struct buffer cache
;
1699 struct thread_info
*thread
;
1700 enum btrace_read_type type
;
1703 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1706 if (ptid_equal (general_thread
, null_ptid
)
1707 || ptid_equal (general_thread
, minus_one_ptid
))
1709 strcpy (own_buf
, "E.Must select a single thread.");
1713 thread
= find_thread_ptid (general_thread
);
1716 strcpy (own_buf
, "E.No such thread.");
1720 if (thread
->btrace
== NULL
)
1722 strcpy (own_buf
, "E.Btrace not enabled.");
1726 if (strcmp (annex
, "all") == 0)
1727 type
= BTRACE_READ_ALL
;
1728 else if (strcmp (annex
, "new") == 0)
1729 type
= BTRACE_READ_NEW
;
1730 else if (strcmp (annex
, "delta") == 0)
1731 type
= BTRACE_READ_DELTA
;
1734 strcpy (own_buf
, "E.Bad annex.");
1740 buffer_free (&cache
);
1742 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1745 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1749 else if (offset
> cache
.used_size
)
1751 buffer_free (&cache
);
1755 if (len
> cache
.used_size
- offset
)
1756 len
= cache
.used_size
- offset
;
1758 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1763 /* Handle qXfer:btrace-conf:read. */
1766 handle_qxfer_btrace_conf (const char *annex
,
1767 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1768 ULONGEST offset
, LONGEST len
)
1770 static struct buffer cache
;
1771 struct thread_info
*thread
;
1774 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1777 if (annex
[0] != '\0')
1780 if (ptid_equal (general_thread
, null_ptid
)
1781 || ptid_equal (general_thread
, minus_one_ptid
))
1783 strcpy (own_buf
, "E.Must select a single thread.");
1787 thread
= find_thread_ptid (general_thread
);
1790 strcpy (own_buf
, "E.No such thread.");
1794 if (thread
->btrace
== NULL
)
1796 strcpy (own_buf
, "E.Btrace not enabled.");
1802 buffer_free (&cache
);
1804 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1807 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1811 else if (offset
> cache
.used_size
)
1813 buffer_free (&cache
);
1817 if (len
> cache
.used_size
- offset
)
1818 len
= cache
.used_size
- offset
;
1820 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1825 static const struct qxfer qxfer_packets
[] =
1827 { "auxv", handle_qxfer_auxv
},
1828 { "btrace", handle_qxfer_btrace
},
1829 { "btrace-conf", handle_qxfer_btrace_conf
},
1830 { "exec-file", handle_qxfer_exec_file
},
1831 { "fdpic", handle_qxfer_fdpic
},
1832 { "features", handle_qxfer_features
},
1833 { "libraries", handle_qxfer_libraries
},
1834 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1835 { "osdata", handle_qxfer_osdata
},
1836 { "siginfo", handle_qxfer_siginfo
},
1837 { "spu", handle_qxfer_spu
},
1838 { "statictrace", handle_qxfer_statictrace
},
1839 { "threads", handle_qxfer_threads
},
1840 { "traceframe-info", handle_qxfer_traceframe_info
},
1844 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1852 if (!startswith (own_buf
, "qXfer:"))
1855 /* Grab the object, r/w and annex. */
1856 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1858 write_enn (own_buf
);
1863 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1866 const struct qxfer
*q
= &qxfer_packets
[i
];
1868 if (strcmp (object
, q
->object
) == 0)
1870 if (strcmp (rw
, "read") == 0)
1872 unsigned char *data
;
1877 /* Grab the offset and length. */
1878 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1880 write_enn (own_buf
);
1884 /* Read one extra byte, as an indicator of whether there is
1886 if (len
> PBUFSIZ
- 2)
1888 data
= (unsigned char *) malloc (len
+ 1);
1891 write_enn (own_buf
);
1894 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1902 /* Preserve error message. */
1905 write_enn (own_buf
);
1907 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1909 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1914 else if (strcmp (rw
, "write") == 0)
1919 unsigned char *data
;
1921 strcpy (own_buf
, "E00");
1922 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1925 write_enn (own_buf
);
1928 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1929 &ofs
, &len
, data
) < 0)
1932 write_enn (own_buf
);
1936 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1944 /* Preserve error message. */
1947 write_enn (own_buf
);
1949 sprintf (own_buf
, "%x", n
);
1962 /* Compute 32 bit CRC from inferior memory.
1964 On success, return 32 bit CRC.
1965 On failure, return (unsigned long long) -1. */
1967 static unsigned long long
1968 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1972 unsigned char byte
= 0;
1974 /* Return failure if memory read fails. */
1975 if (read_inferior_memory (base
, &byte
, 1) != 0)
1976 return (unsigned long long) -1;
1978 crc
= xcrc32 (&byte
, 1, crc
);
1981 return (unsigned long long) crc
;
1984 /* Add supported btrace packets to BUF. */
1987 supported_btrace_packets (char *buf
)
1989 int btrace_supported
= 0;
1991 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1993 strcat (buf
, ";Qbtrace:bts+");
1994 strcat (buf
, ";Qbtrace-conf:bts:size+");
1996 btrace_supported
= 1;
1999 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2001 strcat (buf
, ";Qbtrace:pt+");
2002 strcat (buf
, ";Qbtrace-conf:pt:size+");
2004 btrace_supported
= 1;
2007 if (!btrace_supported
)
2010 strcat (buf
, ";Qbtrace:off+");
2011 strcat (buf
, ";qXfer:btrace:read+");
2012 strcat (buf
, ";qXfer:btrace-conf:read+");
2015 /* Handle all of the extended 'q' packets. */
2018 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2020 static struct inferior_list_entry
*thread_ptr
;
2022 /* Reply the current thread id. */
2023 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2026 require_running (own_buf
);
2028 if (!ptid_equal (general_thread
, null_ptid
)
2029 && !ptid_equal (general_thread
, minus_one_ptid
))
2030 gdb_id
= general_thread
;
2033 thread_ptr
= get_first_inferior (&all_threads
);
2034 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2037 sprintf (own_buf
, "QC");
2039 write_ptid (own_buf
, gdb_id
);
2043 if (strcmp ("qSymbol::", own_buf
) == 0)
2045 struct thread_info
*save_thread
= current_thread
;
2047 /* For qSymbol, GDB only changes the current thread if the
2048 previous current thread was of a different process. So if
2049 the previous thread is gone, we need to pick another one of
2050 the same process. This can happen e.g., if we followed an
2051 exec in a non-leader thread. */
2052 if (current_thread
== NULL
)
2055 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2057 /* Just in case, if we didn't find a thread, then bail out
2058 instead of crashing. */
2059 if (current_thread
== NULL
)
2061 write_enn (own_buf
);
2062 current_thread
= save_thread
;
2067 /* GDB is suggesting new symbols have been loaded. This may
2068 mean a new shared library has been detected as loaded, so
2069 take the opportunity to check if breakpoints we think are
2070 inserted, still are. Note that it isn't guaranteed that
2071 we'll see this when a shared library is loaded, and nor will
2072 we see this for unloads (although breakpoints in unloaded
2073 libraries shouldn't trigger), as GDB may not find symbols for
2074 the library at all. We also re-validate breakpoints when we
2075 see a second GDB breakpoint for the same address, and or when
2076 we access breakpoint shadows. */
2077 validate_breakpoints ();
2079 if (target_supports_tracepoints ())
2080 tracepoint_look_up_symbols ();
2082 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2083 (*the_target
->look_up_symbols
) ();
2085 current_thread
= save_thread
;
2087 strcpy (own_buf
, "OK");
2091 if (!disable_packet_qfThreadInfo
)
2093 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2097 require_running (own_buf
);
2098 thread_ptr
= get_first_inferior (&all_threads
);
2101 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2102 write_ptid (own_buf
, gdb_id
);
2103 thread_ptr
= thread_ptr
->next
;
2107 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2111 require_running (own_buf
);
2112 if (thread_ptr
!= NULL
)
2115 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2116 write_ptid (own_buf
, gdb_id
);
2117 thread_ptr
= thread_ptr
->next
;
2122 sprintf (own_buf
, "l");
2128 if (the_target
->read_offsets
!= NULL
2129 && strcmp ("qOffsets", own_buf
) == 0)
2131 CORE_ADDR text
, data
;
2133 require_running (own_buf
);
2134 if (the_target
->read_offsets (&text
, &data
))
2135 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2136 (long)text
, (long)data
, (long)data
);
2138 write_enn (own_buf
);
2143 /* Protocol features query. */
2144 if (startswith (own_buf
, "qSupported")
2145 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2147 char *p
= &own_buf
[10];
2148 int gdb_supports_qRelocInsn
= 0;
2150 /* Process each feature being provided by GDB. The first
2151 feature will follow a ':', and latter features will follow
2155 char **qsupported
= NULL
;
2160 /* Two passes, to avoid nested strtok calls in
2161 target_process_qsupported. */
2162 for (p
= strtok (p
+ 1, ";");
2164 p
= strtok (NULL
, ";"))
2167 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2168 qsupported
[count
- 1] = xstrdup (p
);
2171 for (i
= 0; i
< count
; i
++)
2174 if (strcmp (p
, "multiprocess+") == 0)
2176 /* GDB supports and wants multi-process support if
2178 if (target_supports_multi_process ())
2181 else if (strcmp (p
, "qRelocInsn+") == 0)
2183 /* GDB supports relocate instruction requests. */
2184 gdb_supports_qRelocInsn
= 1;
2186 else if (strcmp (p
, "swbreak+") == 0)
2188 /* GDB wants us to report whether a trap is caused
2189 by a software breakpoint and for us to handle PC
2190 adjustment if necessary on this target. */
2191 if (target_supports_stopped_by_sw_breakpoint ())
2192 swbreak_feature
= 1;
2194 else if (strcmp (p
, "hwbreak+") == 0)
2196 /* GDB wants us to report whether a trap is caused
2197 by a hardware breakpoint. */
2198 if (target_supports_stopped_by_hw_breakpoint ())
2199 hwbreak_feature
= 1;
2201 else if (strcmp (p
, "fork-events+") == 0)
2203 /* GDB supports and wants fork events if possible. */
2204 if (target_supports_fork_events ())
2205 report_fork_events
= 1;
2207 else if (strcmp (p
, "vfork-events+") == 0)
2209 /* GDB supports and wants vfork events if possible. */
2210 if (target_supports_vfork_events ())
2211 report_vfork_events
= 1;
2213 else if (strcmp (p
, "exec-events+") == 0)
2215 /* GDB supports and wants exec events if possible. */
2216 if (target_supports_exec_events ())
2217 report_exec_events
= 1;
2219 else if (strcmp (p
, "vContSupported+") == 0)
2220 vCont_supported
= 1;
2221 else if (strcmp (p
, "QThreadEvents+") == 0)
2223 else if (strcmp (p
, "no-resumed+") == 0)
2225 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2227 report_no_resumed
= 1;
2231 /* Move the unknown features all together. */
2232 qsupported
[i
] = NULL
;
2233 qsupported
[unknown
] = p
;
2238 /* Give the target backend a chance to process the unknown
2240 target_process_qsupported (qsupported
, unknown
);
2242 for (i
= 0; i
< count
; i
++)
2243 free (qsupported
[i
]);
2248 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2251 if (target_supports_catch_syscall ())
2252 strcat (own_buf
, ";QCatchSyscalls+");
2254 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2255 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2256 ";augmented-libraries-svr4-read+");
2259 /* We do not have any hook to indicate whether the non-SVR4 target
2260 backend supports qXfer:libraries:read, so always report it. */
2261 strcat (own_buf
, ";qXfer:libraries:read+");
2264 if (the_target
->read_auxv
!= NULL
)
2265 strcat (own_buf
, ";qXfer:auxv:read+");
2267 if (the_target
->qxfer_spu
!= NULL
)
2268 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2270 if (the_target
->qxfer_siginfo
!= NULL
)
2271 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2273 if (the_target
->read_loadmap
!= NULL
)
2274 strcat (own_buf
, ";qXfer:fdpic:read+");
2276 /* We always report qXfer:features:read, as targets may
2277 install XML files on a subsequent call to arch_setup.
2278 If we reported to GDB on startup that we don't support
2279 qXfer:feature:read at all, we will never be re-queried. */
2280 strcat (own_buf
, ";qXfer:features:read+");
2282 if (transport_is_reliable
)
2283 strcat (own_buf
, ";QStartNoAckMode+");
2285 if (the_target
->qxfer_osdata
!= NULL
)
2286 strcat (own_buf
, ";qXfer:osdata:read+");
2288 if (target_supports_multi_process ())
2289 strcat (own_buf
, ";multiprocess+");
2291 if (target_supports_fork_events ())
2292 strcat (own_buf
, ";fork-events+");
2294 if (target_supports_vfork_events ())
2295 strcat (own_buf
, ";vfork-events+");
2297 if (target_supports_exec_events ())
2298 strcat (own_buf
, ";exec-events+");
2300 if (target_supports_non_stop ())
2301 strcat (own_buf
, ";QNonStop+");
2303 if (target_supports_disable_randomization ())
2304 strcat (own_buf
, ";QDisableRandomization+");
2306 strcat (own_buf
, ";qXfer:threads:read+");
2308 if (target_supports_tracepoints ())
2310 strcat (own_buf
, ";ConditionalTracepoints+");
2311 strcat (own_buf
, ";TraceStateVariables+");
2312 strcat (own_buf
, ";TracepointSource+");
2313 strcat (own_buf
, ";DisconnectedTracing+");
2314 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2315 strcat (own_buf
, ";FastTracepoints+");
2316 strcat (own_buf
, ";StaticTracepoints+");
2317 strcat (own_buf
, ";InstallInTrace+");
2318 strcat (own_buf
, ";qXfer:statictrace:read+");
2319 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2320 strcat (own_buf
, ";EnableDisableTracepoints+");
2321 strcat (own_buf
, ";QTBuffer:size+");
2322 strcat (own_buf
, ";tracenz+");
2325 if (target_supports_hardware_single_step ()
2326 || target_supports_software_single_step () )
2328 strcat (own_buf
, ";ConditionalBreakpoints+");
2330 strcat (own_buf
, ";BreakpointCommands+");
2332 if (target_supports_agent ())
2333 strcat (own_buf
, ";QAgent+");
2335 supported_btrace_packets (own_buf
);
2337 if (target_supports_stopped_by_sw_breakpoint ())
2338 strcat (own_buf
, ";swbreak+");
2340 if (target_supports_stopped_by_hw_breakpoint ())
2341 strcat (own_buf
, ";hwbreak+");
2343 if (the_target
->pid_to_exec_file
!= NULL
)
2344 strcat (own_buf
, ";qXfer:exec-file:read+");
2346 strcat (own_buf
, ";vContSupported+");
2348 strcat (own_buf
, ";QThreadEvents+");
2350 strcat (own_buf
, ";no-resumed+");
2352 /* Reinitialize components as needed for the new connection. */
2353 hostio_handle_new_gdb_connection ();
2354 target_handle_new_gdb_connection ();
2359 /* Thread-local storage support. */
2360 if (the_target
->get_tls_address
!= NULL
2361 && startswith (own_buf
, "qGetTLSAddr:"))
2363 char *p
= own_buf
+ 12;
2364 CORE_ADDR parts
[2], address
= 0;
2366 ptid_t ptid
= null_ptid
;
2368 require_running (own_buf
);
2370 for (i
= 0; i
< 3; i
++)
2378 p2
= strchr (p
, ',');
2391 ptid
= read_ptid (p
, NULL
);
2393 decode_address (&parts
[i
- 1], p
, len
);
2397 if (p
!= NULL
|| i
< 3)
2401 struct thread_info
*thread
= find_thread_ptid (ptid
);
2406 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2412 strcpy (own_buf
, paddress(address
));
2417 write_enn (own_buf
);
2421 /* Otherwise, pretend we do not understand this packet. */
2424 /* Windows OS Thread Information Block address support. */
2425 if (the_target
->get_tib_address
!= NULL
2426 && startswith (own_buf
, "qGetTIBAddr:"))
2431 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2433 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2436 strcpy (own_buf
, paddress(tlb
));
2441 write_enn (own_buf
);
2447 /* Handle "monitor" commands. */
2448 if (startswith (own_buf
, "qRcmd,"))
2450 char *mon
= (char *) malloc (PBUFSIZ
);
2451 int len
= strlen (own_buf
+ 6);
2455 write_enn (own_buf
);
2460 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2462 write_enn (own_buf
);
2466 mon
[len
/ 2] = '\0';
2470 if (the_target
->handle_monitor_command
== NULL
2471 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2472 /* Default processing. */
2473 handle_monitor_command (mon
, own_buf
);
2479 if (startswith (own_buf
, "qSearch:memory:"))
2481 require_running (own_buf
);
2482 handle_search_memory (own_buf
, packet_len
);
2486 if (strcmp (own_buf
, "qAttached") == 0
2487 || startswith (own_buf
, "qAttached:"))
2489 struct process_info
*process
;
2491 if (own_buf
[sizeof ("qAttached") - 1])
2493 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2494 process
= (struct process_info
*)
2495 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2499 require_running (own_buf
);
2500 process
= current_process ();
2503 if (process
== NULL
)
2505 write_enn (own_buf
);
2509 strcpy (own_buf
, process
->attached
? "1" : "0");
2513 if (startswith (own_buf
, "qCRC:"))
2515 /* CRC check (compare-section). */
2519 unsigned long long crc
;
2521 require_running (own_buf
);
2522 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2523 if (*comma
++ != ',')
2525 write_enn (own_buf
);
2528 len
= strtoul (comma
, NULL
, 16);
2529 crc
= crc32 (base
, len
, 0xffffffff);
2530 /* Check for memory failure. */
2531 if (crc
== (unsigned long long) -1)
2533 write_enn (own_buf
);
2536 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2540 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2543 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2546 /* Otherwise we didn't know what packet it was. Say we didn't
2551 static void gdb_wants_all_threads_stopped (void);
2552 static void resume (struct thread_resume
*actions
, size_t n
);
2554 /* The callback that is passed to visit_actioned_threads. */
2555 typedef int (visit_actioned_threads_callback_ftype
)
2556 (const struct thread_resume
*, struct thread_info
*);
2558 /* Struct to pass data to visit_actioned_threads. */
2560 struct visit_actioned_threads_data
2562 const struct thread_resume
*actions
;
2564 visit_actioned_threads_callback_ftype
*callback
;
2567 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2568 true if CALLBACK returns true. Returns false if no matching thread
2569 is found or CALLBACK results false.
2570 Note: This function is itself a callback for find_inferior. */
2573 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2575 struct visit_actioned_threads_data
*data
2576 = (struct visit_actioned_threads_data
*) datap
;
2577 const struct thread_resume
*actions
= data
->actions
;
2578 size_t num_actions
= data
->num_actions
;
2579 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2582 for (i
= 0; i
< num_actions
; i
++)
2584 const struct thread_resume
*action
= &actions
[i
];
2586 if (ptid_equal (action
->thread
, minus_one_ptid
)
2587 || ptid_equal (action
->thread
, entry
->id
)
2588 || ((ptid_get_pid (action
->thread
)
2589 == ptid_get_pid (entry
->id
))
2590 && ptid_get_lwp (action
->thread
) == -1))
2592 struct thread_info
*thread
= (struct thread_info
*) entry
;
2594 if ((*callback
) (action
, thread
))
2602 /* Callback for visit_actioned_threads. If the thread has a pending
2603 status to report, report it now. */
2606 handle_pending_status (const struct thread_resume
*resumption
,
2607 struct thread_info
*thread
)
2609 if (thread
->status_pending_p
)
2611 thread
->status_pending_p
= 0;
2613 last_status
= thread
->last_status
;
2614 last_ptid
= thread
->entry
.id
;
2615 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2621 /* Parse vCont packets. */
2623 handle_v_cont (char *own_buf
)
2627 struct thread_resume
*resume_info
;
2628 struct thread_resume default_action
= {{0}};
2630 /* Count the number of semicolons in the packet. There should be one
2631 for every action. */
2637 p
= strchr (p
, ';');
2640 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2641 if (resume_info
== NULL
)
2649 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2651 if (p
[0] == 's' || p
[0] == 'S')
2652 resume_info
[i
].kind
= resume_step
;
2653 else if (p
[0] == 'r')
2654 resume_info
[i
].kind
= resume_step
;
2655 else if (p
[0] == 'c' || p
[0] == 'C')
2656 resume_info
[i
].kind
= resume_continue
;
2657 else if (p
[0] == 't')
2658 resume_info
[i
].kind
= resume_stop
;
2662 if (p
[0] == 'S' || p
[0] == 'C')
2665 sig
= strtol (p
+ 1, &q
, 16);
2670 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2672 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2674 else if (p
[0] == 'r')
2678 p
= unpack_varlen_hex (p
+ 1, &addr
);
2679 resume_info
[i
].step_range_start
= addr
;
2684 p
= unpack_varlen_hex (p
+ 1, &addr
);
2685 resume_info
[i
].step_range_end
= addr
;
2694 resume_info
[i
].thread
= minus_one_ptid
;
2695 default_action
= resume_info
[i
];
2697 /* Note: we don't increment i here, we'll overwrite this entry
2698 the next time through. */
2700 else if (p
[0] == ':')
2702 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2707 if (p
[0] != ';' && p
[0] != 0)
2710 resume_info
[i
].thread
= ptid
;
2717 resume_info
[i
] = default_action
;
2719 resume (resume_info
, n
);
2724 write_enn (own_buf
);
2729 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2732 resume (struct thread_resume
*actions
, size_t num_actions
)
2736 /* Check if among the threads that GDB wants actioned, there's
2737 one with a pending status to report. If so, skip actually
2738 resuming/stopping and report the pending event
2740 struct visit_actioned_threads_data data
;
2742 data
.actions
= actions
;
2743 data
.num_actions
= num_actions
;
2744 data
.callback
= handle_pending_status
;
2745 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2751 (*the_target
->resume
) (actions
, num_actions
);
2757 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2759 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2760 && !report_no_resumed
)
2762 /* The client does not support this stop reply. At least
2764 sprintf (own_buf
, "E.No unwaited-for children left.");
2765 disable_async_io ();
2769 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2770 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2771 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2772 current_thread
->last_status
= last_status
;
2774 /* From the client's perspective, all-stop mode always stops all
2775 threads implicitly (and the target backend has already done
2776 so by now). Tag all threads as "want-stopped", so we don't
2777 resume them implicitly without the client telling us to. */
2778 gdb_wants_all_threads_stopped ();
2779 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2780 disable_async_io ();
2782 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2783 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2784 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2788 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2790 handle_v_attach (char *own_buf
)
2794 pid
= strtol (own_buf
+ 8, NULL
, 16);
2795 if (pid
!= 0 && attach_inferior (pid
) == 0)
2797 /* Don't report shared library events after attaching, even if
2798 some libraries are preloaded. GDB will always poll the
2799 library list. Avoids the "stopped by shared library event"
2800 notice on the GDB side. */
2805 /* In non-stop, we don't send a resume reply. Stop events
2806 will follow up using the normal notification
2811 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2817 write_enn (own_buf
);
2822 /* Run a new program. Return 1 if successful, 0 if failure. */
2824 handle_v_run (char *own_buf
)
2826 char *p
, *next_p
, **new_argv
;
2830 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2836 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2837 if (new_argv
== NULL
)
2839 write_enn (own_buf
);
2844 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2846 next_p
= strchr (p
, ';');
2848 next_p
= p
+ strlen (p
);
2850 if (i
== 0 && p
== next_p
)
2854 /* FIXME: Fail request if out of memory instead of dying. */
2855 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2856 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2857 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2866 if (new_argv
[0] == NULL
)
2868 /* GDB didn't specify a program to run. Use the program from the
2869 last run with the new argument list. */
2871 if (program_argv
== NULL
)
2873 write_enn (own_buf
);
2874 freeargv (new_argv
);
2878 new_argv
[0] = strdup (program_argv
[0]);
2879 if (new_argv
[0] == NULL
)
2881 write_enn (own_buf
);
2882 freeargv (new_argv
);
2887 /* Free the old argv and install the new one. */
2888 freeargv (program_argv
);
2889 program_argv
= new_argv
;
2891 start_inferior (program_argv
);
2892 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2894 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2896 /* In non-stop, sending a resume reply doesn't set the general
2897 thread, but GDB assumes a vRun sets it (this is so GDB can
2898 query which is the main thread of the new inferior. */
2900 general_thread
= last_ptid
;
2906 write_enn (own_buf
);
2911 /* Kill process. Return 1 if successful, 0 if failure. */
2913 handle_v_kill (char *own_buf
)
2916 char *p
= &own_buf
[6];
2918 pid
= strtol (p
, NULL
, 16);
2921 if (pid
!= 0 && kill_inferior (pid
) == 0)
2923 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2924 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2925 last_ptid
= pid_to_ptid (pid
);
2926 discard_queued_stop_replies (last_ptid
);
2932 write_enn (own_buf
);
2937 /* Handle all of the extended 'v' packets. */
2939 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2941 if (!disable_packet_vCont
)
2943 if (strcmp (own_buf
, "vCtrlC") == 0)
2945 (*the_target
->request_interrupt
) ();
2950 if (startswith (own_buf
, "vCont;"))
2952 require_running (own_buf
);
2953 handle_v_cont (own_buf
);
2957 if (startswith (own_buf
, "vCont?"))
2959 strcpy (own_buf
, "vCont;c;C;t");
2961 if (target_supports_hardware_single_step ()
2962 || target_supports_software_single_step ()
2963 || !vCont_supported
)
2965 /* If target supports single step either by hardware or by
2966 software, add actions s and S to the list of supported
2967 actions. On the other hand, if GDB doesn't request the
2968 supported vCont actions in qSupported packet, add s and
2969 S to the list too. */
2970 own_buf
= own_buf
+ strlen (own_buf
);
2971 strcpy (own_buf
, ";s;S");
2974 if (target_supports_range_stepping ())
2976 own_buf
= own_buf
+ strlen (own_buf
);
2977 strcpy (own_buf
, ";r");
2983 if (startswith (own_buf
, "vFile:")
2984 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2987 if (startswith (own_buf
, "vAttach;"))
2989 if ((!extended_protocol
|| !multi_process
) && target_running ())
2991 fprintf (stderr
, "Already debugging a process\n");
2992 write_enn (own_buf
);
2995 handle_v_attach (own_buf
);
2999 if (startswith (own_buf
, "vRun;"))
3001 if ((!extended_protocol
|| !multi_process
) && target_running ())
3003 fprintf (stderr
, "Already debugging a process\n");
3004 write_enn (own_buf
);
3007 handle_v_run (own_buf
);
3011 if (startswith (own_buf
, "vKill;"))
3013 if (!target_running ())
3015 fprintf (stderr
, "No process to kill\n");
3016 write_enn (own_buf
);
3019 handle_v_kill (own_buf
);
3023 if (handle_notif_ack (own_buf
, packet_len
))
3026 /* Otherwise we didn't know what packet it was. Say we didn't
3032 /* Resume thread and wait for another event. In non-stop mode,
3033 don't really wait here, but return immediatelly to the event
3036 myresume (char *own_buf
, int step
, int sig
)
3038 struct thread_resume resume_info
[2];
3040 int valid_cont_thread
;
3042 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3043 && !ptid_equal (cont_thread
, minus_one_ptid
));
3045 if (step
|| sig
|| valid_cont_thread
)
3047 resume_info
[0].thread
= current_ptid
;
3049 resume_info
[0].kind
= resume_step
;
3051 resume_info
[0].kind
= resume_continue
;
3052 resume_info
[0].sig
= sig
;
3056 if (!valid_cont_thread
)
3058 resume_info
[n
].thread
= minus_one_ptid
;
3059 resume_info
[n
].kind
= resume_continue
;
3060 resume_info
[n
].sig
= 0;
3064 resume (resume_info
, n
);
3067 /* Callback for for_each_inferior. Make a new stop reply for each
3071 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3073 struct thread_info
*thread
= (struct thread_info
*) entry
;
3075 /* For now, assume targets that don't have this callback also don't
3076 manage the thread's last_status field. */
3077 if (the_target
->thread_stopped
== NULL
)
3079 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3081 new_notif
->ptid
= entry
->id
;
3082 new_notif
->status
= thread
->last_status
;
3083 /* Pass the last stop reply back to GDB, but don't notify
3085 notif_event_enque (¬if_stop
,
3086 (struct notif_event
*) new_notif
);
3090 if (thread_stopped (thread
))
3095 = target_waitstatus_to_string (&thread
->last_status
);
3097 debug_printf ("Reporting thread %s as already stopped with %s\n",
3098 target_pid_to_str (entry
->id
),
3101 xfree (status_string
);
3104 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3106 /* Pass the last stop reply back to GDB, but don't notify
3108 queue_stop_reply (entry
->id
, &thread
->last_status
);
3115 /* Set this inferior threads's state as "want-stopped". We won't
3116 resume this thread until the client gives us another action for
3120 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3122 struct thread_info
*thread
= (struct thread_info
*) entry
;
3124 thread
->last_resume_kind
= resume_stop
;
3126 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3128 /* Most threads are stopped implicitly (all-stop); tag that with
3130 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3131 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3135 /* Set all threads' states as "want-stopped". */
3138 gdb_wants_all_threads_stopped (void)
3140 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3143 /* Clear the gdb_detached flag of every process. */
3146 gdb_reattached_process (struct inferior_list_entry
*entry
)
3148 struct process_info
*process
= (struct process_info
*) entry
;
3150 process
->gdb_detached
= 0;
3153 /* Callback for for_each_inferior. Clear the thread's pending status
3157 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3159 struct thread_info
*thread
= (struct thread_info
*) entry
;
3161 thread
->status_pending_p
= 0;
3164 /* Callback for for_each_inferior. If the thread is stopped with an
3165 interesting event, mark it as having a pending event. */
3168 set_pending_status_callback (struct inferior_list_entry
*entry
)
3170 struct thread_info
*thread
= (struct thread_info
*) entry
;
3172 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3173 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3174 /* A breakpoint, watchpoint or finished step from a previous
3175 GDB run isn't considered interesting for a new GDB run.
3176 If we left those pending, the new GDB could consider them
3177 random SIGTRAPs. This leaves out real async traps. We'd
3178 have to peek into the (target-specific) siginfo to
3179 distinguish those. */
3180 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3181 thread
->status_pending_p
= 1;
3184 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3185 pending status to report to GDB. */
3188 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3190 struct thread_info
*thread
= (struct thread_info
*) entry
;
3192 return thread
->status_pending_p
;
3195 /* Status handler for the '?' packet. */
3198 handle_status (char *own_buf
)
3200 /* GDB is connected, don't forward events to the target anymore. */
3201 for_each_inferior (&all_processes
, gdb_reattached_process
);
3203 /* In non-stop mode, we must send a stop reply for each stopped
3204 thread. In all-stop mode, just send one for the first stopped
3209 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3211 /* The first is sent immediatly. OK is sent if there is no
3212 stopped thread, which is the same handling of the vStopped
3213 packet (by design). */
3214 notif_write_event (¬if_stop
, own_buf
);
3218 struct inferior_list_entry
*thread
= NULL
;
3221 stabilize_threads ();
3222 gdb_wants_all_threads_stopped ();
3224 /* We can only report one status, but we might be coming out of
3225 non-stop -- if more than one thread is stopped with
3226 interesting events, leave events for the threads we're not
3227 reporting now pending. They'll be reported the next time the
3228 threads are resumed. Start by marking all interesting events
3230 for_each_inferior (&all_threads
, set_pending_status_callback
);
3232 /* Prefer the last thread that reported an event to GDB (even if
3233 that was a GDB_SIGNAL_TRAP). */
3234 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3235 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3236 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3237 thread
= find_inferior_id (&all_threads
, last_ptid
);
3239 /* If the last event thread is not found for some reason, look
3240 for some other thread that might have an event to report. */
3242 thread
= find_inferior (&all_threads
,
3243 find_status_pending_thread_callback
, NULL
);
3245 /* If we're still out of luck, simply pick the first thread in
3248 thread
= get_first_inferior (&all_threads
);
3252 struct thread_info
*tp
= (struct thread_info
*) thread
;
3254 /* We're reporting this event, so it's no longer
3256 tp
->status_pending_p
= 0;
3258 /* GDB assumes the current thread is the thread we're
3259 reporting the status for. */
3260 general_thread
= thread
->id
;
3261 set_desired_thread (1);
3263 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3264 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3267 strcpy (own_buf
, "W00");
3272 gdbserver_version (void)
3274 printf ("GNU gdbserver %s%s\n"
3275 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
3276 "gdbserver is free software, covered by the "
3277 "GNU General Public License.\n"
3278 "This gdbserver was configured as \"%s\"\n",
3279 PKGVERSION
, version
, host_name
);
3283 gdbserver_usage (FILE *stream
)
3285 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3286 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3287 "\tgdbserver [OPTIONS] --multi COMM\n"
3289 "COMM may either be a tty device (for serial debugging),\n"
3290 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3291 "stdin/stdout of gdbserver.\n"
3292 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3293 "PID is the process ID to attach to, when --attach is specified.\n"
3295 "Operating modes:\n"
3297 " --attach Attach to running process PID.\n"
3298 " --multi Start server without a specific program, and\n"
3299 " only quit when explicitly commanded.\n"
3300 " --once Exit after the first connection has closed.\n"
3301 " --help Print this message and then exit.\n"
3302 " --version Display version information and exit.\n"
3306 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3307 " --disable-randomization\n"
3308 " Run PROG with address space randomization disabled.\n"
3309 " --no-disable-randomization\n"
3310 " Don't disable address space randomization when\n"
3315 " --debug Enable general debugging output.\n"
3316 " --debug-format=opt1[,opt2,...]\n"
3317 " Specify extra content in debugging output.\n"
3322 " --remote-debug Enable remote protocol debugging output.\n"
3323 " --disable-packet=opt1[,opt2,...]\n"
3324 " Disable support for RSP packets or features.\n"
3326 " vCont, Tthread, qC, qfThreadInfo and \n"
3327 " threads (disable all threading packets).\n"
3329 "For more information, consult the GDB manual (available as on-line \n"
3330 "info or a printed manual).\n");
3331 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3332 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3336 gdbserver_show_disableable (FILE *stream
)
3338 fprintf (stream
, "Disableable packets:\n"
3339 " vCont \tAll vCont packets\n"
3340 " qC \tQuerying the current thread\n"
3341 " qfThreadInfo\tThread listing\n"
3342 " Tthread \tPassing the thread specifier in the "
3343 "T stop reply packet\n"
3344 " threads \tAll of the above\n");
3348 #undef require_running
3349 #define require_running(BUF) \
3350 if (!target_running ()) \
3357 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3359 int pid
= * (int *) args
;
3361 if (ptid_get_pid (entry
->id
) == pid
)
3368 kill_inferior_callback (struct inferior_list_entry
*entry
)
3370 struct process_info
*process
= (struct process_info
*) entry
;
3371 int pid
= ptid_get_pid (process
->entry
.id
);
3373 kill_inferior (pid
);
3374 discard_queued_stop_replies (pid_to_ptid (pid
));
3377 /* Callback for for_each_inferior to detach or kill the inferior,
3378 depending on whether we attached to it or not.
3379 We inform the user whether we're detaching or killing the process
3380 as this is only called when gdbserver is about to exit. */
3383 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3385 struct process_info
*process
= (struct process_info
*) entry
;
3386 int pid
= ptid_get_pid (process
->entry
.id
);
3388 if (process
->attached
)
3389 detach_inferior (pid
);
3391 kill_inferior (pid
);
3393 discard_queued_stop_replies (pid_to_ptid (pid
));
3396 /* for_each_inferior callback for detach_or_kill_for_exit to print
3397 the pids of started inferiors. */
3400 print_started_pid (struct inferior_list_entry
*entry
)
3402 struct process_info
*process
= (struct process_info
*) entry
;
3404 if (! process
->attached
)
3406 int pid
= ptid_get_pid (process
->entry
.id
);
3407 fprintf (stderr
, " %d", pid
);
3411 /* for_each_inferior callback for detach_or_kill_for_exit to print
3412 the pids of attached inferiors. */
3415 print_attached_pid (struct inferior_list_entry
*entry
)
3417 struct process_info
*process
= (struct process_info
*) entry
;
3419 if (process
->attached
)
3421 int pid
= ptid_get_pid (process
->entry
.id
);
3422 fprintf (stderr
, " %d", pid
);
3426 /* Call this when exiting gdbserver with possible inferiors that need
3427 to be killed or detached from. */
3430 detach_or_kill_for_exit (void)
3432 /* First print a list of the inferiors we will be killing/detaching.
3433 This is to assist the user, for example, in case the inferior unexpectedly
3434 dies after we exit: did we screw up or did the inferior exit on its own?
3435 Having this info will save some head-scratching. */
3437 if (have_started_inferiors_p ())
3439 fprintf (stderr
, "Killing process(es):");
3440 for_each_inferior (&all_processes
, print_started_pid
);
3441 fprintf (stderr
, "\n");
3443 if (have_attached_inferiors_p ())
3445 fprintf (stderr
, "Detaching process(es):");
3446 for_each_inferior (&all_processes
, print_attached_pid
);
3447 fprintf (stderr
, "\n");
3450 /* Now we can kill or detach the inferiors. */
3452 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3455 /* Value that will be passed to exit(3) when gdbserver exits. */
3456 static int exit_code
;
3458 /* Cleanup version of detach_or_kill_for_exit. */
3461 detach_or_kill_for_exit_cleanup (void *ignore
)
3466 detach_or_kill_for_exit ();
3469 CATCH (exception
, RETURN_MASK_ALL
)
3472 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3478 /* Main function. This is called by the real "main" function,
3479 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3481 static void ATTRIBUTE_NORETURN
3482 captured_main (int argc
, char *argv
[])
3486 char *arg_end
, *port
;
3487 char **next_arg
= &argv
[1];
3488 volatile int multi_mode
= 0;
3489 volatile int attach
= 0;
3492 while (*next_arg
!= NULL
&& **next_arg
== '-')
3494 if (strcmp (*next_arg
, "--version") == 0)
3496 gdbserver_version ();
3499 else if (strcmp (*next_arg
, "--help") == 0)
3501 gdbserver_usage (stdout
);
3504 else if (strcmp (*next_arg
, "--attach") == 0)
3506 else if (strcmp (*next_arg
, "--multi") == 0)
3508 else if (strcmp (*next_arg
, "--wrapper") == 0)
3512 wrapper_argv
= next_arg
;
3513 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3516 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3518 gdbserver_usage (stderr
);
3522 /* Consume the "--". */
3525 else if (strcmp (*next_arg
, "--debug") == 0)
3527 else if (startswith (*next_arg
, "--debug-format="))
3530 = parse_debug_format_options ((*next_arg
)
3531 + sizeof ("--debug-format=") - 1, 0);
3533 if (error_msg
!= NULL
)
3535 fprintf (stderr
, "%s", error_msg
);
3539 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3541 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3543 gdbserver_show_disableable (stdout
);
3546 else if (startswith (*next_arg
, "--disable-packet="))
3548 char *packets
, *tok
;
3550 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3551 for (tok
= strtok (packets
, ",");
3553 tok
= strtok (NULL
, ","))
3555 if (strcmp ("vCont", tok
) == 0)
3556 disable_packet_vCont
= 1;
3557 else if (strcmp ("Tthread", tok
) == 0)
3558 disable_packet_Tthread
= 1;
3559 else if (strcmp ("qC", tok
) == 0)
3560 disable_packet_qC
= 1;
3561 else if (strcmp ("qfThreadInfo", tok
) == 0)
3562 disable_packet_qfThreadInfo
= 1;
3563 else if (strcmp ("threads", tok
) == 0)
3565 disable_packet_vCont
= 1;
3566 disable_packet_Tthread
= 1;
3567 disable_packet_qC
= 1;
3568 disable_packet_qfThreadInfo
= 1;
3572 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3574 gdbserver_show_disableable (stderr
);
3579 else if (strcmp (*next_arg
, "-") == 0)
3581 /* "-" specifies a stdio connection and is a form of port
3583 *next_arg
= STDIO_CONNECTION_NAME
;
3586 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3587 disable_randomization
= 1;
3588 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3589 disable_randomization
= 0;
3590 else if (strcmp (*next_arg
, "--once") == 0)
3594 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3604 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3606 gdbserver_usage (stderr
);
3610 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3611 opened by remote_prepare. */
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 thread_resume resume_info
;
3931 struct process_info
*process
= find_process_pid (pid
);
3933 if (process
== NULL
)
3935 write_enn (own_buf
);
3939 if (tracing
&& disconnected_tracing
)
3941 "Disconnected tracing in effect, "
3942 "leaving gdbserver attached to the process\n");
3944 if (any_persistent_commands ())
3946 "Persistent commands are present, "
3947 "leaving gdbserver attached to the process\n");
3949 /* Make sure we're in non-stop/async mode, so we we can both
3950 wait for an async socket accept, and handle async target
3951 events simultaneously. There's also no point either in
3952 having the target stop all threads, when we're going to
3953 pass signals down without informing GDB. */
3957 debug_printf ("Forcing non-stop mode\n");
3963 process
->gdb_detached
= 1;
3965 /* Detaching implicitly resumes all threads. */
3966 resume_info
.thread
= minus_one_ptid
;
3967 resume_info
.kind
= resume_continue
;
3968 resume_info
.sig
= 0;
3969 (*the_target
->resume
) (&resume_info
, 1);
3972 break; /* from switch/case */
3975 fprintf (stderr
, "Detaching from process %d\n", pid
);
3977 if (detach_inferior (pid
) != 0)
3978 write_enn (own_buf
);
3981 discard_queued_stop_replies (pid_to_ptid (pid
));
3984 if (extended_protocol
|| target_running ())
3986 /* There is still at least one inferior remaining or
3987 we are in extended mode, so don't terminate gdbserver,
3988 and instead treat this like a normal program exit. */
3989 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3990 last_status
.value
.integer
= 0;
3991 last_ptid
= pid_to_ptid (pid
);
3993 current_thread
= NULL
;
4000 /* If we are attached, then we can exit. Otherwise, we
4001 need to hang around doing nothing, until the child is
4003 join_inferior (pid
);
4009 extended_protocol
= 1;
4013 handle_status (own_buf
);
4016 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4018 ptid_t gdb_id
, thread_id
;
4021 require_running (own_buf
);
4023 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4025 pid
= ptid_get_pid (gdb_id
);
4027 if (ptid_equal (gdb_id
, null_ptid
)
4028 || ptid_equal (gdb_id
, minus_one_ptid
))
4029 thread_id
= null_ptid
;
4031 && ptid_equal (pid_to_ptid (pid
),
4034 struct thread_info
*thread
=
4035 (struct thread_info
*) find_inferior (&all_threads
,
4040 write_enn (own_buf
);
4044 thread_id
= thread
->entry
.id
;
4048 thread_id
= gdb_id_to_thread_id (gdb_id
);
4049 if (ptid_equal (thread_id
, null_ptid
))
4051 write_enn (own_buf
);
4056 if (own_buf
[1] == 'g')
4058 if (ptid_equal (thread_id
, null_ptid
))
4060 /* GDB is telling us to choose any thread. Check if
4061 the currently selected thread is still valid. If
4062 it is not, select the first available. */
4063 struct thread_info
*thread
=
4064 (struct thread_info
*) find_inferior_id (&all_threads
,
4067 thread
= get_first_thread ();
4068 thread_id
= thread
->entry
.id
;
4071 general_thread
= thread_id
;
4072 set_desired_thread (1);
4073 gdb_assert (current_thread
!= NULL
);
4075 else if (own_buf
[1] == 'c')
4076 cont_thread
= thread_id
;
4082 /* Silently ignore it so that gdb can extend the protocol
4083 without compatibility headaches. */
4088 require_running (own_buf
);
4089 if (current_traceframe
>= 0)
4091 struct regcache
*regcache
4092 = new_register_cache (current_target_desc ());
4094 if (fetch_traceframe_registers (current_traceframe
,
4096 registers_to_string (regcache
, own_buf
);
4098 write_enn (own_buf
);
4099 free_register_cache (regcache
);
4103 struct regcache
*regcache
;
4105 if (!set_desired_thread (1))
4106 write_enn (own_buf
);
4109 regcache
= get_thread_regcache (current_thread
, 1);
4110 registers_to_string (regcache
, own_buf
);
4115 require_running (own_buf
);
4116 if (current_traceframe
>= 0)
4117 write_enn (own_buf
);
4120 struct regcache
*regcache
;
4122 if (!set_desired_thread (1))
4123 write_enn (own_buf
);
4126 regcache
= get_thread_regcache (current_thread
, 1);
4127 registers_from_string (regcache
, &own_buf
[1]);
4133 require_running (own_buf
);
4134 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4135 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4137 write_enn (own_buf
);
4139 bin2hex (mem_buf
, own_buf
, res
);
4142 require_running (own_buf
);
4143 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4144 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4147 write_enn (own_buf
);
4150 require_running (own_buf
);
4151 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4152 &mem_addr
, &len
, &mem_buf
) < 0
4153 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4154 write_enn (own_buf
);
4159 require_running (own_buf
);
4160 hex2bin (own_buf
+ 1, &sig
, 1);
4161 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4162 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4165 myresume (own_buf
, 0, signal
);
4168 require_running (own_buf
);
4169 hex2bin (own_buf
+ 1, &sig
, 1);
4170 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4171 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4174 myresume (own_buf
, 1, signal
);
4177 require_running (own_buf
);
4179 myresume (own_buf
, 0, signal
);
4182 require_running (own_buf
);
4184 myresume (own_buf
, 1, signal
);
4186 case 'Z': /* insert_ ... */
4188 case 'z': /* remove_ ... */
4193 char type
= own_buf
[1];
4195 const int insert
= ch
== 'Z';
4196 char *p
= &own_buf
[3];
4198 p
= unpack_varlen_hex (p
, &addr
);
4199 kind
= strtol (p
+ 1, &dataptr
, 16);
4203 struct gdb_breakpoint
*bp
;
4205 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4210 /* GDB may have sent us a list of *point parameters to
4211 be evaluated on the target's side. Read such list
4212 here. If we already have a list of parameters, GDB
4213 is telling us to drop that list and use this one
4215 clear_breakpoint_conditions_and_commands (bp
);
4216 process_point_options (bp
, &dataptr
);
4220 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4228 write_enn (own_buf
);
4232 response_needed
= 0;
4233 if (!target_running ())
4234 /* The packet we received doesn't make sense - but we can't
4235 reply to it, either. */
4238 fprintf (stderr
, "Killing all inferiors\n");
4239 for_each_inferior (&all_processes
, kill_inferior_callback
);
4241 /* When using the extended protocol, we wait with no program
4242 running. The traditional protocol will exit instead. */
4243 if (extended_protocol
)
4245 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4246 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4254 ptid_t gdb_id
, thread_id
;
4256 require_running (own_buf
);
4258 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4259 thread_id
= gdb_id_to_thread_id (gdb_id
);
4260 if (ptid_equal (thread_id
, null_ptid
))
4262 write_enn (own_buf
);
4266 if (mythread_alive (thread_id
))
4269 write_enn (own_buf
);
4273 response_needed
= 0;
4275 /* Restarting the inferior is only supported in the extended
4277 if (extended_protocol
)
4279 if (target_running ())
4280 for_each_inferior (&all_processes
,
4281 kill_inferior_callback
);
4282 fprintf (stderr
, "GDBserver restarting\n");
4284 /* Wait till we are at 1st instruction in prog. */
4285 if (program_argv
!= NULL
)
4287 start_inferior (program_argv
);
4288 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4290 /* Stopped at the first instruction of the target
4292 general_thread
= last_ptid
;
4296 /* Something went wrong. */
4297 general_thread
= null_ptid
;
4302 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4303 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4309 /* It is a request we don't understand. Respond with an
4310 empty packet so that gdb knows that we don't support this
4316 /* Extended (long) request. */
4317 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4321 /* It is a request we don't understand. Respond with an empty
4322 packet so that gdb knows that we don't support this
4328 if (new_packet_len
!= -1)
4329 putpkt_binary (own_buf
, new_packet_len
);
4333 response_needed
= 0;
4341 /* Event-loop callback for serial events. */
4344 handle_serial_event (int err
, gdb_client_data client_data
)
4347 debug_printf ("handling possible serial event\n");
4349 /* Really handle it. */
4350 if (process_serial_event () < 0)
4353 /* Be sure to not change the selected thread behind GDB's back.
4354 Important in the non-stop mode asynchronous protocol. */
4355 set_desired_thread (1);
4360 /* Push a stop notification on the notification queue. */
4363 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4365 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4367 vstop_notif
->status
= *status
;
4368 vstop_notif
->ptid
= ptid
;
4369 /* Push Stop notification. */
4370 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4373 /* Event-loop callback for target events. */
4376 handle_target_event (int err
, gdb_client_data client_data
)
4379 debug_printf ("handling possible target event\n");
4381 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4384 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4386 if (gdb_connected () && report_no_resumed
)
4387 push_stop_notification (null_ptid
, &last_status
);
4389 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4391 int pid
= ptid_get_pid (last_ptid
);
4392 struct process_info
*process
= find_process_pid (pid
);
4393 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4395 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4396 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4398 mark_breakpoints_out (process
);
4399 mourn_inferior (process
);
4401 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4405 /* We're reporting this thread as stopped. Update its
4406 "want-stopped" state to what the client wants, until it
4407 gets a new resume action. */
4408 current_thread
->last_resume_kind
= resume_stop
;
4409 current_thread
->last_status
= last_status
;
4414 if (!target_running ())
4416 /* The last process exited. We're done. */
4420 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4421 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4422 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4426 /* A thread stopped with a signal, but gdb isn't
4427 connected to handle it. Pass it down to the
4428 inferior, as if it wasn't being traced. */
4429 struct thread_resume resume_info
;
4432 debug_printf ("GDB not connected; forwarding event %d for"
4434 (int) last_status
.kind
,
4435 target_pid_to_str (last_ptid
));
4437 resume_info
.thread
= last_ptid
;
4438 resume_info
.kind
= resume_continue
;
4439 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4440 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4442 resume_info
.sig
= 0;
4443 (*the_target
->resume
) (&resume_info
, 1);
4447 push_stop_notification (last_ptid
, &last_status
);
4450 /* Be sure to not change the selected thread behind GDB's back.
4451 Important in the non-stop mode asynchronous protocol. */
4452 set_desired_thread (1);