1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
43 /* The environment to pass to the inferior when creating it. */
45 static gdb_environ our_environ
;
47 /* Start the inferior using a shell. */
49 /* We always try to start the inferior using a shell. */
51 int startup_with_shell
= 1;
53 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
54 `vCont'. Note the multi-process extensions made `vCont' a
55 requirement, so `Hc pPID.TID' is pretty much undefined. So
56 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
57 resuming all threads of the process (again, `Hc' isn't used for
58 multi-process), or a specific thread ptid_t. */
61 /* The thread set with an `Hg' packet. */
62 ptid_t general_thread
;
66 static int extended_protocol
;
67 static int response_needed
;
68 static int exit_requested
;
70 /* --once: Exit after the first connection has closed. */
74 int report_fork_events
;
75 int report_vfork_events
;
76 int report_exec_events
;
77 int report_thread_events
;
79 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
80 static int report_no_resumed
;
86 /* True if the "vContSupported" feature is active. In that case, GDB
87 wants us to report whether single step is supported in the reply to
89 static int vCont_supported
;
91 /* Whether we should attempt to disable the operating system's address
92 space randomization feature before starting an inferior. */
93 int disable_randomization
= 1;
95 static char *program_name
= NULL
;
96 static std::vector
<char *> program_args
;
97 static std::string wrapper_argv
;
99 int pass_signals
[GDB_SIGNAL_LAST
];
100 int program_signals
[GDB_SIGNAL_LAST
];
101 int program_signals_p
;
103 /* The PID of the originally created or attached inferior. Used to
104 send signals to the process when GDB sends us an asynchronous interrupt
105 (user hitting Control-C in the client), and to wait for the child to exit
106 when no longer debugging it. */
108 unsigned long signal_pid
;
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 struct target_waitstatus last_status
;
123 static unsigned char *mem_buf
;
125 /* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
131 struct notif_event base
;
133 /* Thread or process that got the event. */
137 struct target_waitstatus status
;
140 /* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142 static struct btrace_config current_btrace_conf
;
144 DEFINE_QUEUE_P (notif_event_p
);
146 /* Put a stop reply to the stop reply queue. */
149 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
151 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
153 new_notif
->ptid
= ptid
;
154 new_notif
->status
= *status
;
156 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
160 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
161 QUEUE_ITER (notif_event_p
) *iter
,
162 struct notif_event
*event
,
165 ptid_t filter_ptid
= *(ptid_t
*) data
;
166 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
168 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
170 if (q
->free_func
!= NULL
)
171 q
->free_func (event
);
173 QUEUE_remove_elem (notif_event_p
, q
, iter
);
182 discard_queued_stop_replies (ptid_t ptid
)
184 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
185 remove_all_on_match_ptid
, &ptid
);
189 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
191 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
193 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
196 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
199 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
200 QUEUE_ITER (notif_event_p
) *iter
,
201 struct notif_event
*event
,
204 ptid_t filter_ptid
= *(ptid_t
*) data
;
205 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
207 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
210 /* Don't resume fork children that GDB does not know about yet. */
211 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
212 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
213 && ptid_match (vstop_event
->status
.value
.related_pid
, filter_ptid
))
222 in_queued_stop_replies (ptid_t ptid
)
224 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
225 in_queued_stop_replies_ptid
, &ptid
);
228 struct notif_server notif_stop
=
230 "vStopped", "Stop", NULL
, vstop_notif_reply
,
234 target_running (void)
236 return get_first_thread () != NULL
;
239 /* See common/common-inferior.h. */
244 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
247 /* See common/common-inferior.h. */
250 get_exec_file (int err
)
252 if (err
&& program_name
== NULL
)
253 error (_("No executable file specified."));
267 attach_inferior (int pid
)
269 /* myattach should return -1 if attaching is unsupported,
270 0 if it succeeded, and call error() otherwise. */
272 if (myattach (pid
) != 0)
275 fprintf (stderr
, "Attached; pid = %d\n", pid
);
278 /* FIXME - It may be that we should get the SIGNAL_PID from the
279 attach function, so that it can be the main thread instead of
280 whichever we were told to attach to. */
285 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
287 /* GDB knows to ignore the first SIGSTOP after attaching to a running
288 process using the "attach" command, but this is different; it's
289 just using "target remote". Pretend it's just starting up. */
290 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
291 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
292 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
294 current_thread
->last_resume_kind
= resume_stop
;
295 current_thread
->last_status
= last_status
;
301 extern int remote_debug
;
303 /* Decode a qXfer read request. Return 0 if everything looks OK,
307 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
309 /* After the read marker and annex, qXfer looks like a
310 traditional 'm' packet. */
311 decode_m_packet (buf
, ofs
, len
);
317 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
319 /* Extract and NUL-terminate the object. */
321 while (*buf
&& *buf
!= ':')
327 /* Extract and NUL-terminate the read/write action. */
329 while (*buf
&& *buf
!= ':')
335 /* Extract and NUL-terminate the annex. */
337 while (*buf
&& *buf
!= ':')
347 /* Write the response to a successful qXfer read. Returns the
348 length of the (binary) data stored in BUF, corresponding
349 to as much of DATA/LEN as we could fit. IS_MORE controls
350 the first character of the response. */
352 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
361 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
362 &out_len
, PBUFSIZ
- 2) + 1;
365 /* Handle btrace enabling in BTS format. */
368 handle_btrace_enable_bts (struct thread_info
*thread
)
370 if (thread
->btrace
!= NULL
)
371 return "E.Btrace already enabled.";
373 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
374 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
375 ¤t_btrace_conf
);
376 if (thread
->btrace
== NULL
)
377 return "E.Could not enable btrace.";
382 /* Handle btrace enabling in Intel Processor Trace format. */
385 handle_btrace_enable_pt (struct thread_info
*thread
)
387 if (thread
->btrace
!= NULL
)
388 return "E.Btrace already enabled.";
390 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
391 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
392 ¤t_btrace_conf
);
393 if (thread
->btrace
== NULL
)
394 return "E.Could not enable btrace.";
399 /* Handle btrace disabling. */
402 handle_btrace_disable (struct thread_info
*thread
)
405 if (thread
->btrace
== NULL
)
406 return "E.Branch tracing not enabled.";
408 if (target_disable_btrace (thread
->btrace
) != 0)
409 return "E.Could not disable branch tracing.";
411 thread
->btrace
= NULL
;
415 /* Handle the "Qbtrace" packet. */
418 handle_btrace_general_set (char *own_buf
)
420 struct thread_info
*thread
;
424 if (!startswith (own_buf
, "Qbtrace:"))
427 op
= own_buf
+ strlen ("Qbtrace:");
429 if (ptid_equal (general_thread
, null_ptid
)
430 || ptid_equal (general_thread
, minus_one_ptid
))
432 strcpy (own_buf
, "E.Must select a single thread.");
436 thread
= find_thread_ptid (general_thread
);
439 strcpy (own_buf
, "E.No such thread.");
445 if (strcmp (op
, "bts") == 0)
446 err
= handle_btrace_enable_bts (thread
);
447 else if (strcmp (op
, "pt") == 0)
448 err
= handle_btrace_enable_pt (thread
);
449 else if (strcmp (op
, "off") == 0)
450 err
= handle_btrace_disable (thread
);
452 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
455 strcpy (own_buf
, err
);
462 /* Handle the "Qbtrace-conf" packet. */
465 handle_btrace_conf_general_set (char *own_buf
)
467 struct thread_info
*thread
;
470 if (!startswith (own_buf
, "Qbtrace-conf:"))
473 op
= own_buf
+ strlen ("Qbtrace-conf:");
475 if (ptid_equal (general_thread
, null_ptid
)
476 || ptid_equal (general_thread
, minus_one_ptid
))
478 strcpy (own_buf
, "E.Must select a single thread.");
482 thread
= find_thread_ptid (general_thread
);
485 strcpy (own_buf
, "E.No such thread.");
489 if (startswith (op
, "bts:size="))
495 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
496 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
498 strcpy (own_buf
, "E.Bad size value.");
502 current_btrace_conf
.bts
.size
= (unsigned int) size
;
504 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
510 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
511 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
513 strcpy (own_buf
, "E.Bad size value.");
517 current_btrace_conf
.pt
.size
= (unsigned int) size
;
521 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
529 /* Handle all of the extended 'Q' packets. */
532 handle_general_set (char *own_buf
)
534 if (startswith (own_buf
, "QPassSignals:"))
536 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
537 const char *p
= own_buf
+ strlen ("QPassSignals:");
540 p
= decode_address_to_semicolon (&cursig
, p
);
541 for (i
= 0; i
< numsigs
; i
++)
547 /* Keep looping, to clear the remaining signals. */
550 p
= decode_address_to_semicolon (&cursig
, p
);
555 strcpy (own_buf
, "OK");
559 if (startswith (own_buf
, "QProgramSignals:"))
561 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
562 const char *p
= own_buf
+ strlen ("QProgramSignals:");
565 program_signals_p
= 1;
567 p
= decode_address_to_semicolon (&cursig
, p
);
568 for (i
= 0; i
< numsigs
; i
++)
572 program_signals
[i
] = 1;
574 /* Keep looping, to clear the remaining signals. */
577 p
= decode_address_to_semicolon (&cursig
, p
);
580 program_signals
[i
] = 0;
582 strcpy (own_buf
, "OK");
586 if (startswith (own_buf
, "QCatchSyscalls:"))
588 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
591 struct process_info
*process
;
593 if (!target_running () || !target_supports_catch_syscall ())
599 if (strcmp (p
, "0") == 0)
601 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
605 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
611 process
= current_process ();
612 VEC_truncate (int, process
->syscalls_to_catch
, 0);
622 p
= decode_address_to_semicolon (&sysno
, p
);
623 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
627 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
634 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
638 debug_printf ("[noack mode enabled]\n");
647 if (startswith (own_buf
, "QNonStop:"))
649 char *mode
= own_buf
+ 9;
653 if (strcmp (mode
, "0") == 0)
655 else if (strcmp (mode
, "1") == 0)
659 /* We don't know what this mode is, so complain to
661 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
667 req_str
= req
? "non-stop" : "all-stop";
668 if (start_non_stop (req
) != 0)
670 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
678 debug_printf ("[%s mode enabled]\n", req_str
);
684 if (startswith (own_buf
, "QDisableRandomization:"))
686 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
689 unpack_varlen_hex (packet
, &setting
);
690 disable_randomization
= setting
;
694 debug_printf (disable_randomization
695 ? "[address space randomization disabled]\n"
696 : "[address space randomization enabled]\n");
703 if (target_supports_tracepoints ()
704 && handle_tracepoint_general_set (own_buf
))
707 if (startswith (own_buf
, "QAgent:"))
709 char *mode
= own_buf
+ strlen ("QAgent:");
712 if (strcmp (mode
, "0") == 0)
714 else if (strcmp (mode
, "1") == 0)
718 /* We don't know what this value is, so complain to GDB. */
719 sprintf (own_buf
, "E.Unknown QAgent value");
723 /* Update the flag. */
726 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
731 if (handle_btrace_general_set (own_buf
))
734 if (handle_btrace_conf_general_set (own_buf
))
737 if (startswith (own_buf
, "QThreadEvents:"))
739 char *mode
= own_buf
+ strlen ("QThreadEvents:");
740 enum tribool req
= TRIBOOL_UNKNOWN
;
742 if (strcmp (mode
, "0") == 0)
744 else if (strcmp (mode
, "1") == 0)
748 char *mode_copy
= xstrdup (mode
);
750 /* We don't know what this mode is, so complain to GDB. */
751 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
757 report_thread_events
= (req
== TRIBOOL_TRUE
);
761 const char *req_str
= report_thread_events
? "enabled" : "disabled";
763 debug_printf ("[thread events are now %s]\n", req_str
);
770 if (startswith (own_buf
, "QStartupWithShell:"))
772 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
774 if (strcmp (value
, "1") == 0)
775 startup_with_shell
= true;
776 else if (strcmp (value
, "0") == 0)
777 startup_with_shell
= false;
781 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
788 debug_printf (_("[Inferior will %s started with shell]"),
789 startup_with_shell
? "be" : "not be");
795 /* Otherwise we didn't know what packet it was. Say we didn't
801 get_features_xml (const char *annex
)
803 const struct target_desc
*desc
= current_target_desc ();
805 /* `desc->xmltarget' defines what to return when looking for the
806 "target.xml" file. Its contents can either be verbatim XML code
807 (prefixed with a '@') or else the name of the actual XML file to
808 be used in place of "target.xml".
810 This variable is set up from the auto-generated
811 init_registers_... routine for the current target. */
813 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
815 if (*desc
->xmltarget
== '@')
816 return desc
->xmltarget
+ 1;
818 annex
= desc
->xmltarget
;
823 extern const char *const xml_builtin
[][2];
826 /* Look for the annex. */
827 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
828 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
831 if (xml_builtin
[i
][0] != NULL
)
832 return xml_builtin
[i
][1];
840 monitor_show_help (void)
842 monitor_output ("The following monitor commands are supported:\n");
843 monitor_output (" set debug <0|1>\n");
844 monitor_output (" Enable general debugging messages\n");
845 monitor_output (" set debug-hw-points <0|1>\n");
846 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
847 monitor_output (" set remote-debug <0|1>\n");
848 monitor_output (" Enable remote protocol debugging messages\n");
849 monitor_output (" set debug-format option1[,option2,...]\n");
850 monitor_output (" Add additional information to debugging messages\n");
851 monitor_output (" Options: all, none");
852 monitor_output (", timestamp");
853 monitor_output ("\n");
854 monitor_output (" exit\n");
855 monitor_output (" Quit GDBserver\n");
858 /* Read trace frame or inferior memory. Returns the number of bytes
859 actually read, zero when no further transfer is possible, and -1 on
860 error. Return of a positive value smaller than LEN does not
861 indicate there's no more to be read, only the end of the transfer.
862 E.g., when GDB reads memory from a traceframe, a first request may
863 be served from a memory block that does not cover the whole request
864 length. A following request gets the rest served from either
865 another block (of the same traceframe) or from the read-only
869 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
873 if (current_traceframe
>= 0)
876 ULONGEST length
= len
;
878 if (traceframe_read_mem (current_traceframe
,
879 memaddr
, myaddr
, len
, &nbytes
))
881 /* Data read from trace buffer, we're done. */
884 if (!in_readonly_region (memaddr
, length
))
886 /* Otherwise we have a valid readonly case, fall through. */
887 /* (assume no half-trace half-real blocks for now) */
890 res
= prepare_to_access_memory ();
893 if (set_desired_thread (1))
894 res
= read_inferior_memory (memaddr
, myaddr
, len
);
897 done_accessing_memory ();
899 return res
== 0 ? len
: -1;
905 /* Write trace frame or inferior memory. Actually, writing to trace
906 frames is forbidden. */
909 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
911 if (current_traceframe
>= 0)
917 ret
= prepare_to_access_memory ();
920 if (set_desired_thread (1))
921 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
924 done_accessing_memory ();
930 /* Subroutine of handle_search_memory to simplify it. */
933 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
934 gdb_byte
*pattern
, unsigned pattern_len
,
935 gdb_byte
*search_buf
,
936 unsigned chunk_size
, unsigned search_buf_size
,
937 CORE_ADDR
*found_addrp
)
939 /* Prime the search buffer. */
941 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
944 warning ("Unable to access %ld bytes of target "
945 "memory at 0x%lx, halting search.",
946 (long) search_buf_size
, (long) start_addr
);
950 /* Perform the search.
952 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
953 When we've scanned N bytes we copy the trailing bytes to the start and
954 read in another N bytes. */
956 while (search_space_len
>= pattern_len
)
959 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
963 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
966 if (found_ptr
!= NULL
)
968 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
969 *found_addrp
= found_addr
;
973 /* Not found in this chunk, skip to next chunk. */
975 /* Don't let search_space_len wrap here, it's unsigned. */
976 if (search_space_len
>= chunk_size
)
977 search_space_len
-= chunk_size
;
979 search_space_len
= 0;
981 if (search_space_len
>= pattern_len
)
983 unsigned keep_len
= search_buf_size
- chunk_size
;
984 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
987 /* Copy the trailing part of the previous iteration to the front
988 of the buffer for the next iteration. */
989 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
991 nr_to_read
= (search_space_len
- keep_len
< chunk_size
992 ? search_space_len
- keep_len
995 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
996 nr_to_read
) != search_buf_size
)
998 warning ("Unable to access %ld bytes of target memory "
999 "at 0x%lx, halting search.",
1000 (long) nr_to_read
, (long) read_addr
);
1004 start_addr
+= chunk_size
;
1013 /* Handle qSearch:memory packets. */
1016 handle_search_memory (char *own_buf
, int packet_len
)
1018 CORE_ADDR start_addr
;
1019 CORE_ADDR search_space_len
;
1021 unsigned int pattern_len
;
1022 /* NOTE: also defined in find.c testcase. */
1023 #define SEARCH_CHUNK_SIZE 16000
1024 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1025 /* Buffer to hold memory contents for searching. */
1026 gdb_byte
*search_buf
;
1027 unsigned search_buf_size
;
1029 CORE_ADDR found_addr
;
1030 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1032 pattern
= (gdb_byte
*) malloc (packet_len
);
1033 if (pattern
== NULL
)
1035 error ("Unable to allocate memory to perform the search");
1036 strcpy (own_buf
, "E00");
1039 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1040 packet_len
- cmd_name_len
,
1041 &start_addr
, &search_space_len
,
1042 pattern
, &pattern_len
) < 0)
1045 error ("Error in parsing qSearch:memory packet");
1046 strcpy (own_buf
, "E00");
1050 search_buf_size
= chunk_size
+ pattern_len
- 1;
1052 /* No point in trying to allocate a buffer larger than the search space. */
1053 if (search_space_len
< search_buf_size
)
1054 search_buf_size
= search_space_len
;
1056 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1057 if (search_buf
== NULL
)
1060 error ("Unable to allocate memory to perform the search");
1061 strcpy (own_buf
, "E00");
1065 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1066 pattern
, pattern_len
,
1067 search_buf
, chunk_size
, search_buf_size
,
1071 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1072 else if (found
== 0)
1073 strcpy (own_buf
, "0");
1075 strcpy (own_buf
, "E00");
1081 #define require_running(BUF) \
1082 if (!target_running ()) \
1088 /* Parse options to --debug-format= and "monitor set debug-format".
1089 ARG is the text after "--debug-format=" or "monitor set debug-format".
1090 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1091 This triggers calls to monitor_output.
1092 The result is NULL if all options were parsed ok, otherwise an error
1093 message which the caller must free.
1095 N.B. These commands affect all debug format settings, they are not
1096 cumulative. If a format is not specified, it is turned off.
1097 However, we don't go to extra trouble with things like
1098 "monitor set debug-format all,none,timestamp".
1099 Instead we just parse them one at a time, in order.
1101 The syntax for "monitor set debug" we support here is not identical
1102 to gdb's "set debug foo on|off" because we also use this function to
1103 parse "--debug-format=foo,bar". */
1106 parse_debug_format_options (const char *arg
, int is_monitor
)
1108 VEC (char_ptr
) *options
;
1112 /* First turn all debug format options off. */
1113 debug_timestamp
= 0;
1115 /* First remove leading spaces, for "monitor set debug-format". */
1116 while (isspace (*arg
))
1119 options
= delim_string_to_char_ptr_vec (arg
, ',');
1121 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1123 if (strcmp (option
, "all") == 0)
1125 debug_timestamp
= 1;
1127 monitor_output ("All extra debug format options enabled.\n");
1129 else if (strcmp (option
, "none") == 0)
1131 debug_timestamp
= 0;
1133 monitor_output ("All extra debug format options disabled.\n");
1135 else if (strcmp (option
, "timestamp") == 0)
1137 debug_timestamp
= 1;
1139 monitor_output ("Timestamps will be added to debug output.\n");
1141 else if (*option
== '\0')
1143 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1148 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1151 free_char_ptr_vec (options
);
1156 free_char_ptr_vec (options
);
1160 /* Handle monitor commands not handled by target-specific handlers. */
1163 handle_monitor_command (char *mon
, char *own_buf
)
1165 if (strcmp (mon
, "set debug 1") == 0)
1168 monitor_output ("Debug output enabled.\n");
1170 else if (strcmp (mon
, "set debug 0") == 0)
1173 monitor_output ("Debug output disabled.\n");
1175 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1177 show_debug_regs
= 1;
1178 monitor_output ("H/W point debugging output enabled.\n");
1180 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1182 show_debug_regs
= 0;
1183 monitor_output ("H/W point debugging output disabled.\n");
1185 else if (strcmp (mon
, "set remote-debug 1") == 0)
1188 monitor_output ("Protocol debug output enabled.\n");
1190 else if (strcmp (mon
, "set remote-debug 0") == 0)
1193 monitor_output ("Protocol debug output disabled.\n");
1195 else if (startswith (mon
, "set debug-format "))
1198 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1201 if (error_msg
!= NULL
)
1203 monitor_output (error_msg
);
1204 monitor_show_help ();
1205 write_enn (own_buf
);
1209 else if (strcmp (mon
, "help") == 0)
1210 monitor_show_help ();
1211 else if (strcmp (mon
, "exit") == 0)
1215 monitor_output ("Unknown monitor command.\n\n");
1216 monitor_show_help ();
1217 write_enn (own_buf
);
1221 /* Associates a callback with each supported qXfer'able object. */
1225 /* The object this handler handles. */
1228 /* Request that the target transfer up to LEN 8-bit bytes of the
1229 target's OBJECT. The OFFSET, for a seekable object, specifies
1230 the starting point. The ANNEX can be used to provide additional
1231 data-specific information to the target.
1233 Return the number of bytes actually transfered, zero when no
1234 further transfer is possible, -1 on error, -2 when the transfer
1235 is not supported, and -3 on a verbose error message that should
1236 be preserved. Return of a positive value smaller than LEN does
1237 not indicate the end of the object, only the end of the transfer.
1239 One, and only one, of readbuf or writebuf must be non-NULL. */
1240 int (*xfer
) (const char *annex
,
1241 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1242 ULONGEST offset
, LONGEST len
);
1245 /* Handle qXfer:auxv:read. */
1248 handle_qxfer_auxv (const char *annex
,
1249 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1250 ULONGEST offset
, LONGEST len
)
1252 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1255 if (annex
[0] != '\0' || current_thread
== NULL
)
1258 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1261 /* Handle qXfer:exec-file:read. */
1264 handle_qxfer_exec_file (const char *const_annex
,
1265 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1266 ULONGEST offset
, LONGEST len
)
1272 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1275 if (const_annex
[0] == '\0')
1277 if (current_thread
== NULL
)
1280 pid
= pid_of (current_thread
);
1284 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1286 strcpy (annex
, const_annex
);
1287 annex
= unpack_varlen_hex (annex
, &pid
);
1289 if (annex
[0] != '\0')
1296 file
= (*the_target
->pid_to_exec_file
) (pid
);
1300 total_len
= strlen (file
);
1302 if (offset
> total_len
)
1305 if (offset
+ len
> total_len
)
1306 len
= total_len
- offset
;
1308 memcpy (readbuf
, file
+ offset
, len
);
1312 /* Handle qXfer:features:read. */
1315 handle_qxfer_features (const char *annex
,
1316 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1317 ULONGEST offset
, LONGEST len
)
1319 const char *document
;
1322 if (writebuf
!= NULL
)
1325 if (!target_running ())
1328 /* Grab the correct annex. */
1329 document
= get_features_xml (annex
);
1330 if (document
== NULL
)
1333 total_len
= strlen (document
);
1335 if (offset
> total_len
)
1338 if (offset
+ len
> total_len
)
1339 len
= total_len
- offset
;
1341 memcpy (readbuf
, document
+ offset
, len
);
1345 /* Worker routine for handle_qxfer_libraries.
1346 Add to the length pointed to by ARG a conservative estimate of the
1347 length needed to transmit the file name of INF. */
1350 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1352 struct dll_info
*dll
= (struct dll_info
*) inf
;
1353 unsigned int *total_len
= (unsigned int *) arg
;
1355 /* Over-estimate the necessary memory. Assume that every character
1356 in the library name must be escaped. */
1357 *total_len
+= 128 + 6 * strlen (dll
->name
);
1360 /* Worker routine for handle_qxfer_libraries.
1361 Emit the XML to describe the library in INF. */
1364 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1366 struct dll_info
*dll
= (struct dll_info
*) inf
;
1367 char **p_ptr
= (char **) arg
;
1371 strcpy (p
, " <library name=\"");
1373 name
= xml_escape_text (dll
->name
);
1377 strcpy (p
, "\"><segment address=\"");
1379 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1381 strcpy (p
, "\"/></library>\n");
1387 /* Handle qXfer:libraries:read. */
1390 handle_qxfer_libraries (const char *annex
,
1391 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1392 ULONGEST offset
, LONGEST len
)
1394 unsigned int total_len
;
1397 if (writebuf
!= NULL
)
1400 if (annex
[0] != '\0' || current_thread
== NULL
)
1404 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1407 document
= (char *) malloc (total_len
);
1408 if (document
== NULL
)
1411 strcpy (document
, "<library-list version=\"1.0\">\n");
1412 p
= document
+ strlen (document
);
1414 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1416 strcpy (p
, "</library-list>\n");
1418 total_len
= strlen (document
);
1420 if (offset
> total_len
)
1426 if (offset
+ len
> total_len
)
1427 len
= total_len
- offset
;
1429 memcpy (readbuf
, document
+ offset
, len
);
1434 /* Handle qXfer:libraries-svr4:read. */
1437 handle_qxfer_libraries_svr4 (const char *annex
,
1438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1439 ULONGEST offset
, LONGEST len
)
1441 if (writebuf
!= NULL
)
1444 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1447 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1450 /* Handle qXfer:osadata:read. */
1453 handle_qxfer_osdata (const char *annex
,
1454 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1455 ULONGEST offset
, LONGEST len
)
1457 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1460 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1463 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1466 handle_qxfer_siginfo (const char *annex
,
1467 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1468 ULONGEST offset
, LONGEST len
)
1470 if (the_target
->qxfer_siginfo
== NULL
)
1473 if (annex
[0] != '\0' || current_thread
== NULL
)
1476 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1479 /* Handle qXfer:spu:read and qXfer:spu:write. */
1482 handle_qxfer_spu (const char *annex
,
1483 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1484 ULONGEST offset
, LONGEST len
)
1486 if (the_target
->qxfer_spu
== NULL
)
1489 if (current_thread
== NULL
)
1492 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1495 /* Handle qXfer:statictrace:read. */
1498 handle_qxfer_statictrace (const char *annex
,
1499 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1500 ULONGEST offset
, LONGEST len
)
1504 if (writebuf
!= NULL
)
1507 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1510 if (traceframe_read_sdata (current_traceframe
, offset
,
1511 readbuf
, len
, &nbytes
))
1516 /* Helper for handle_qxfer_threads_proper.
1517 Emit the XML to describe the thread of INF. */
1520 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1522 struct thread_info
*thread
= (struct thread_info
*) inf
;
1523 struct buffer
*buffer
= (struct buffer
*) arg
;
1524 ptid_t ptid
= thread_to_gdb_id (thread
);
1526 int core
= target_core_of_thread (ptid
);
1528 const char *name
= target_thread_name (ptid
);
1530 write_ptid (ptid_s
, ptid
);
1532 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1536 sprintf (core_s
, "%d", core
);
1537 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1541 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1543 buffer_xml_printf (buffer
, "/>\n");
1546 /* Helper for handle_qxfer_threads. */
1549 handle_qxfer_threads_proper (struct buffer
*buffer
)
1551 buffer_grow_str (buffer
, "<threads>\n");
1553 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1556 buffer_grow_str0 (buffer
, "</threads>\n");
1559 /* Handle qXfer:threads:read. */
1562 handle_qxfer_threads (const char *annex
,
1563 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1564 ULONGEST offset
, LONGEST len
)
1566 static char *result
= 0;
1567 static unsigned int result_length
= 0;
1569 if (writebuf
!= NULL
)
1572 if (annex
[0] != '\0')
1577 struct buffer buffer
;
1578 /* When asked for data at offset 0, generate everything and store into
1579 'result'. Successive reads will be served off 'result'. */
1583 buffer_init (&buffer
);
1585 handle_qxfer_threads_proper (&buffer
);
1587 result
= buffer_finish (&buffer
);
1588 result_length
= strlen (result
);
1589 buffer_free (&buffer
);
1592 if (offset
>= result_length
)
1594 /* We're out of data. */
1601 if (len
> result_length
- offset
)
1602 len
= result_length
- offset
;
1604 memcpy (readbuf
, result
+ offset
, len
);
1609 /* Handle qXfer:traceframe-info:read. */
1612 handle_qxfer_traceframe_info (const char *annex
,
1613 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1614 ULONGEST offset
, LONGEST len
)
1616 static char *result
= 0;
1617 static unsigned int result_length
= 0;
1619 if (writebuf
!= NULL
)
1622 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1627 struct buffer buffer
;
1629 /* When asked for data at offset 0, generate everything and
1630 store into 'result'. Successive reads will be served off
1634 buffer_init (&buffer
);
1636 traceframe_read_info (current_traceframe
, &buffer
);
1638 result
= buffer_finish (&buffer
);
1639 result_length
= strlen (result
);
1640 buffer_free (&buffer
);
1643 if (offset
>= result_length
)
1645 /* We're out of data. */
1652 if (len
> result_length
- offset
)
1653 len
= result_length
- offset
;
1655 memcpy (readbuf
, result
+ offset
, len
);
1659 /* Handle qXfer:fdpic:read. */
1662 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1663 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1665 if (the_target
->read_loadmap
== NULL
)
1668 if (current_thread
== NULL
)
1671 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1674 /* Handle qXfer:btrace:read. */
1677 handle_qxfer_btrace (const char *annex
,
1678 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1679 ULONGEST offset
, LONGEST len
)
1681 static struct buffer cache
;
1682 struct thread_info
*thread
;
1683 enum btrace_read_type type
;
1686 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1689 if (ptid_equal (general_thread
, null_ptid
)
1690 || ptid_equal (general_thread
, minus_one_ptid
))
1692 strcpy (own_buf
, "E.Must select a single thread.");
1696 thread
= find_thread_ptid (general_thread
);
1699 strcpy (own_buf
, "E.No such thread.");
1703 if (thread
->btrace
== NULL
)
1705 strcpy (own_buf
, "E.Btrace not enabled.");
1709 if (strcmp (annex
, "all") == 0)
1710 type
= BTRACE_READ_ALL
;
1711 else if (strcmp (annex
, "new") == 0)
1712 type
= BTRACE_READ_NEW
;
1713 else if (strcmp (annex
, "delta") == 0)
1714 type
= BTRACE_READ_DELTA
;
1717 strcpy (own_buf
, "E.Bad annex.");
1723 buffer_free (&cache
);
1725 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1728 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1732 else if (offset
> cache
.used_size
)
1734 buffer_free (&cache
);
1738 if (len
> cache
.used_size
- offset
)
1739 len
= cache
.used_size
- offset
;
1741 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1746 /* Handle qXfer:btrace-conf:read. */
1749 handle_qxfer_btrace_conf (const char *annex
,
1750 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1751 ULONGEST offset
, LONGEST len
)
1753 static struct buffer cache
;
1754 struct thread_info
*thread
;
1757 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1760 if (annex
[0] != '\0')
1763 if (ptid_equal (general_thread
, null_ptid
)
1764 || ptid_equal (general_thread
, minus_one_ptid
))
1766 strcpy (own_buf
, "E.Must select a single thread.");
1770 thread
= find_thread_ptid (general_thread
);
1773 strcpy (own_buf
, "E.No such thread.");
1777 if (thread
->btrace
== NULL
)
1779 strcpy (own_buf
, "E.Btrace not enabled.");
1785 buffer_free (&cache
);
1787 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1790 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1794 else if (offset
> cache
.used_size
)
1796 buffer_free (&cache
);
1800 if (len
> cache
.used_size
- offset
)
1801 len
= cache
.used_size
- offset
;
1803 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1808 static const struct qxfer qxfer_packets
[] =
1810 { "auxv", handle_qxfer_auxv
},
1811 { "btrace", handle_qxfer_btrace
},
1812 { "btrace-conf", handle_qxfer_btrace_conf
},
1813 { "exec-file", handle_qxfer_exec_file
},
1814 { "fdpic", handle_qxfer_fdpic
},
1815 { "features", handle_qxfer_features
},
1816 { "libraries", handle_qxfer_libraries
},
1817 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1818 { "osdata", handle_qxfer_osdata
},
1819 { "siginfo", handle_qxfer_siginfo
},
1820 { "spu", handle_qxfer_spu
},
1821 { "statictrace", handle_qxfer_statictrace
},
1822 { "threads", handle_qxfer_threads
},
1823 { "traceframe-info", handle_qxfer_traceframe_info
},
1827 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1835 if (!startswith (own_buf
, "qXfer:"))
1838 /* Grab the object, r/w and annex. */
1839 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1841 write_enn (own_buf
);
1846 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1849 const struct qxfer
*q
= &qxfer_packets
[i
];
1851 if (strcmp (object
, q
->object
) == 0)
1853 if (strcmp (rw
, "read") == 0)
1855 unsigned char *data
;
1860 /* Grab the offset and length. */
1861 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1863 write_enn (own_buf
);
1867 /* Read one extra byte, as an indicator of whether there is
1869 if (len
> PBUFSIZ
- 2)
1871 data
= (unsigned char *) malloc (len
+ 1);
1874 write_enn (own_buf
);
1877 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1885 /* Preserve error message. */
1888 write_enn (own_buf
);
1890 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1892 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1897 else if (strcmp (rw
, "write") == 0)
1902 unsigned char *data
;
1904 strcpy (own_buf
, "E00");
1905 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1908 write_enn (own_buf
);
1911 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1912 &ofs
, &len
, data
) < 0)
1915 write_enn (own_buf
);
1919 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1927 /* Preserve error message. */
1930 write_enn (own_buf
);
1932 sprintf (own_buf
, "%x", n
);
1945 /* Compute 32 bit CRC from inferior memory.
1947 On success, return 32 bit CRC.
1948 On failure, return (unsigned long long) -1. */
1950 static unsigned long long
1951 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1955 unsigned char byte
= 0;
1957 /* Return failure if memory read fails. */
1958 if (read_inferior_memory (base
, &byte
, 1) != 0)
1959 return (unsigned long long) -1;
1961 crc
= xcrc32 (&byte
, 1, crc
);
1964 return (unsigned long long) crc
;
1967 /* Add supported btrace packets to BUF. */
1970 supported_btrace_packets (char *buf
)
1972 int btrace_supported
= 0;
1974 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1976 strcat (buf
, ";Qbtrace:bts+");
1977 strcat (buf
, ";Qbtrace-conf:bts:size+");
1979 btrace_supported
= 1;
1982 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1984 strcat (buf
, ";Qbtrace:pt+");
1985 strcat (buf
, ";Qbtrace-conf:pt:size+");
1987 btrace_supported
= 1;
1990 if (!btrace_supported
)
1993 strcat (buf
, ";Qbtrace:off+");
1994 strcat (buf
, ";qXfer:btrace:read+");
1995 strcat (buf
, ";qXfer:btrace-conf:read+");
1998 /* Handle all of the extended 'q' packets. */
2001 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2003 static struct inferior_list_entry
*thread_ptr
;
2005 /* Reply the current thread id. */
2006 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2009 require_running (own_buf
);
2011 if (!ptid_equal (general_thread
, null_ptid
)
2012 && !ptid_equal (general_thread
, minus_one_ptid
))
2013 gdb_id
= general_thread
;
2016 thread_ptr
= get_first_inferior (&all_threads
);
2017 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2020 sprintf (own_buf
, "QC");
2022 write_ptid (own_buf
, gdb_id
);
2026 if (strcmp ("qSymbol::", own_buf
) == 0)
2028 struct thread_info
*save_thread
= current_thread
;
2030 /* For qSymbol, GDB only changes the current thread if the
2031 previous current thread was of a different process. So if
2032 the previous thread is gone, we need to pick another one of
2033 the same process. This can happen e.g., if we followed an
2034 exec in a non-leader thread. */
2035 if (current_thread
== NULL
)
2038 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2040 /* Just in case, if we didn't find a thread, then bail out
2041 instead of crashing. */
2042 if (current_thread
== NULL
)
2044 write_enn (own_buf
);
2045 current_thread
= save_thread
;
2050 /* GDB is suggesting new symbols have been loaded. This may
2051 mean a new shared library has been detected as loaded, so
2052 take the opportunity to check if breakpoints we think are
2053 inserted, still are. Note that it isn't guaranteed that
2054 we'll see this when a shared library is loaded, and nor will
2055 we see this for unloads (although breakpoints in unloaded
2056 libraries shouldn't trigger), as GDB may not find symbols for
2057 the library at all. We also re-validate breakpoints when we
2058 see a second GDB breakpoint for the same address, and or when
2059 we access breakpoint shadows. */
2060 validate_breakpoints ();
2062 if (target_supports_tracepoints ())
2063 tracepoint_look_up_symbols ();
2065 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2066 (*the_target
->look_up_symbols
) ();
2068 current_thread
= save_thread
;
2070 strcpy (own_buf
, "OK");
2074 if (!disable_packet_qfThreadInfo
)
2076 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2080 require_running (own_buf
);
2081 thread_ptr
= get_first_inferior (&all_threads
);
2084 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2085 write_ptid (own_buf
, gdb_id
);
2086 thread_ptr
= thread_ptr
->next
;
2090 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2094 require_running (own_buf
);
2095 if (thread_ptr
!= NULL
)
2098 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2099 write_ptid (own_buf
, gdb_id
);
2100 thread_ptr
= thread_ptr
->next
;
2105 sprintf (own_buf
, "l");
2111 if (the_target
->read_offsets
!= NULL
2112 && strcmp ("qOffsets", own_buf
) == 0)
2114 CORE_ADDR text
, data
;
2116 require_running (own_buf
);
2117 if (the_target
->read_offsets (&text
, &data
))
2118 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2119 (long)text
, (long)data
, (long)data
);
2121 write_enn (own_buf
);
2126 /* Protocol features query. */
2127 if (startswith (own_buf
, "qSupported")
2128 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2130 char *p
= &own_buf
[10];
2131 int gdb_supports_qRelocInsn
= 0;
2133 /* Process each feature being provided by GDB. The first
2134 feature will follow a ':', and latter features will follow
2138 char **qsupported
= NULL
;
2143 /* Two passes, to avoid nested strtok calls in
2144 target_process_qsupported. */
2145 for (p
= strtok (p
+ 1, ";");
2147 p
= strtok (NULL
, ";"))
2150 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2151 qsupported
[count
- 1] = xstrdup (p
);
2154 for (i
= 0; i
< count
; i
++)
2157 if (strcmp (p
, "multiprocess+") == 0)
2159 /* GDB supports and wants multi-process support if
2161 if (target_supports_multi_process ())
2164 else if (strcmp (p
, "qRelocInsn+") == 0)
2166 /* GDB supports relocate instruction requests. */
2167 gdb_supports_qRelocInsn
= 1;
2169 else if (strcmp (p
, "swbreak+") == 0)
2171 /* GDB wants us to report whether a trap is caused
2172 by a software breakpoint and for us to handle PC
2173 adjustment if necessary on this target. */
2174 if (target_supports_stopped_by_sw_breakpoint ())
2175 swbreak_feature
= 1;
2177 else if (strcmp (p
, "hwbreak+") == 0)
2179 /* GDB wants us to report whether a trap is caused
2180 by a hardware breakpoint. */
2181 if (target_supports_stopped_by_hw_breakpoint ())
2182 hwbreak_feature
= 1;
2184 else if (strcmp (p
, "fork-events+") == 0)
2186 /* GDB supports and wants fork events if possible. */
2187 if (target_supports_fork_events ())
2188 report_fork_events
= 1;
2190 else if (strcmp (p
, "vfork-events+") == 0)
2192 /* GDB supports and wants vfork events if possible. */
2193 if (target_supports_vfork_events ())
2194 report_vfork_events
= 1;
2196 else if (strcmp (p
, "exec-events+") == 0)
2198 /* GDB supports and wants exec events if possible. */
2199 if (target_supports_exec_events ())
2200 report_exec_events
= 1;
2202 else if (strcmp (p
, "vContSupported+") == 0)
2203 vCont_supported
= 1;
2204 else if (strcmp (p
, "QThreadEvents+") == 0)
2206 else if (strcmp (p
, "no-resumed+") == 0)
2208 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2210 report_no_resumed
= 1;
2214 /* Move the unknown features all together. */
2215 qsupported
[i
] = NULL
;
2216 qsupported
[unknown
] = p
;
2221 /* Give the target backend a chance to process the unknown
2223 target_process_qsupported (qsupported
, unknown
);
2225 for (i
= 0; i
< count
; i
++)
2226 free (qsupported
[i
]);
2231 "PacketSize=%x;QPassSignals+;QProgramSignals+;QStartupWithShell+",
2234 if (target_supports_catch_syscall ())
2235 strcat (own_buf
, ";QCatchSyscalls+");
2237 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2238 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2239 ";augmented-libraries-svr4-read+");
2242 /* We do not have any hook to indicate whether the non-SVR4 target
2243 backend supports qXfer:libraries:read, so always report it. */
2244 strcat (own_buf
, ";qXfer:libraries:read+");
2247 if (the_target
->read_auxv
!= NULL
)
2248 strcat (own_buf
, ";qXfer:auxv:read+");
2250 if (the_target
->qxfer_spu
!= NULL
)
2251 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2253 if (the_target
->qxfer_siginfo
!= NULL
)
2254 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2256 if (the_target
->read_loadmap
!= NULL
)
2257 strcat (own_buf
, ";qXfer:fdpic:read+");
2259 /* We always report qXfer:features:read, as targets may
2260 install XML files on a subsequent call to arch_setup.
2261 If we reported to GDB on startup that we don't support
2262 qXfer:feature:read at all, we will never be re-queried. */
2263 strcat (own_buf
, ";qXfer:features:read+");
2265 if (transport_is_reliable
)
2266 strcat (own_buf
, ";QStartNoAckMode+");
2268 if (the_target
->qxfer_osdata
!= NULL
)
2269 strcat (own_buf
, ";qXfer:osdata:read+");
2271 if (target_supports_multi_process ())
2272 strcat (own_buf
, ";multiprocess+");
2274 if (target_supports_fork_events ())
2275 strcat (own_buf
, ";fork-events+");
2277 if (target_supports_vfork_events ())
2278 strcat (own_buf
, ";vfork-events+");
2280 if (target_supports_exec_events ())
2281 strcat (own_buf
, ";exec-events+");
2283 if (target_supports_non_stop ())
2284 strcat (own_buf
, ";QNonStop+");
2286 if (target_supports_disable_randomization ())
2287 strcat (own_buf
, ";QDisableRandomization+");
2289 strcat (own_buf
, ";qXfer:threads:read+");
2291 if (target_supports_tracepoints ())
2293 strcat (own_buf
, ";ConditionalTracepoints+");
2294 strcat (own_buf
, ";TraceStateVariables+");
2295 strcat (own_buf
, ";TracepointSource+");
2296 strcat (own_buf
, ";DisconnectedTracing+");
2297 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2298 strcat (own_buf
, ";FastTracepoints+");
2299 strcat (own_buf
, ";StaticTracepoints+");
2300 strcat (own_buf
, ";InstallInTrace+");
2301 strcat (own_buf
, ";qXfer:statictrace:read+");
2302 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2303 strcat (own_buf
, ";EnableDisableTracepoints+");
2304 strcat (own_buf
, ";QTBuffer:size+");
2305 strcat (own_buf
, ";tracenz+");
2308 if (target_supports_hardware_single_step ()
2309 || target_supports_software_single_step () )
2311 strcat (own_buf
, ";ConditionalBreakpoints+");
2313 strcat (own_buf
, ";BreakpointCommands+");
2315 if (target_supports_agent ())
2316 strcat (own_buf
, ";QAgent+");
2318 supported_btrace_packets (own_buf
);
2320 if (target_supports_stopped_by_sw_breakpoint ())
2321 strcat (own_buf
, ";swbreak+");
2323 if (target_supports_stopped_by_hw_breakpoint ())
2324 strcat (own_buf
, ";hwbreak+");
2326 if (the_target
->pid_to_exec_file
!= NULL
)
2327 strcat (own_buf
, ";qXfer:exec-file:read+");
2329 strcat (own_buf
, ";vContSupported+");
2331 strcat (own_buf
, ";QThreadEvents+");
2333 strcat (own_buf
, ";no-resumed+");
2335 /* Reinitialize components as needed for the new connection. */
2336 hostio_handle_new_gdb_connection ();
2337 target_handle_new_gdb_connection ();
2342 /* Thread-local storage support. */
2343 if (the_target
->get_tls_address
!= NULL
2344 && startswith (own_buf
, "qGetTLSAddr:"))
2346 char *p
= own_buf
+ 12;
2347 CORE_ADDR parts
[2], address
= 0;
2349 ptid_t ptid
= null_ptid
;
2351 require_running (own_buf
);
2353 for (i
= 0; i
< 3; i
++)
2361 p2
= strchr (p
, ',');
2374 ptid
= read_ptid (p
, NULL
);
2376 decode_address (&parts
[i
- 1], p
, len
);
2380 if (p
!= NULL
|| i
< 3)
2384 struct thread_info
*thread
= find_thread_ptid (ptid
);
2389 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2395 strcpy (own_buf
, paddress(address
));
2400 write_enn (own_buf
);
2404 /* Otherwise, pretend we do not understand this packet. */
2407 /* Windows OS Thread Information Block address support. */
2408 if (the_target
->get_tib_address
!= NULL
2409 && startswith (own_buf
, "qGetTIBAddr:"))
2414 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2416 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2419 strcpy (own_buf
, paddress(tlb
));
2424 write_enn (own_buf
);
2430 /* Handle "monitor" commands. */
2431 if (startswith (own_buf
, "qRcmd,"))
2433 char *mon
= (char *) malloc (PBUFSIZ
);
2434 int len
= strlen (own_buf
+ 6);
2438 write_enn (own_buf
);
2443 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2445 write_enn (own_buf
);
2449 mon
[len
/ 2] = '\0';
2453 if (the_target
->handle_monitor_command
== NULL
2454 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2455 /* Default processing. */
2456 handle_monitor_command (mon
, own_buf
);
2462 if (startswith (own_buf
, "qSearch:memory:"))
2464 require_running (own_buf
);
2465 handle_search_memory (own_buf
, packet_len
);
2469 if (strcmp (own_buf
, "qAttached") == 0
2470 || startswith (own_buf
, "qAttached:"))
2472 struct process_info
*process
;
2474 if (own_buf
[sizeof ("qAttached") - 1])
2476 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2477 process
= (struct process_info
*)
2478 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2482 require_running (own_buf
);
2483 process
= current_process ();
2486 if (process
== NULL
)
2488 write_enn (own_buf
);
2492 strcpy (own_buf
, process
->attached
? "1" : "0");
2496 if (startswith (own_buf
, "qCRC:"))
2498 /* CRC check (compare-section). */
2502 unsigned long long crc
;
2504 require_running (own_buf
);
2505 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2506 if (*comma
++ != ',')
2508 write_enn (own_buf
);
2511 len
= strtoul (comma
, NULL
, 16);
2512 crc
= crc32 (base
, len
, 0xffffffff);
2513 /* Check for memory failure. */
2514 if (crc
== (unsigned long long) -1)
2516 write_enn (own_buf
);
2519 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2523 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2526 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2529 /* Otherwise we didn't know what packet it was. Say we didn't
2534 static void gdb_wants_all_threads_stopped (void);
2535 static void resume (struct thread_resume
*actions
, size_t n
);
2537 /* The callback that is passed to visit_actioned_threads. */
2538 typedef int (visit_actioned_threads_callback_ftype
)
2539 (const struct thread_resume
*, struct thread_info
*);
2541 /* Struct to pass data to visit_actioned_threads. */
2543 struct visit_actioned_threads_data
2545 const struct thread_resume
*actions
;
2547 visit_actioned_threads_callback_ftype
*callback
;
2550 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2551 true if CALLBACK returns true. Returns false if no matching thread
2552 is found or CALLBACK results false.
2553 Note: This function is itself a callback for find_inferior. */
2556 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2558 struct visit_actioned_threads_data
*data
2559 = (struct visit_actioned_threads_data
*) datap
;
2560 const struct thread_resume
*actions
= data
->actions
;
2561 size_t num_actions
= data
->num_actions
;
2562 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2565 for (i
= 0; i
< num_actions
; i
++)
2567 const struct thread_resume
*action
= &actions
[i
];
2569 if (ptid_equal (action
->thread
, minus_one_ptid
)
2570 || ptid_equal (action
->thread
, entry
->id
)
2571 || ((ptid_get_pid (action
->thread
)
2572 == ptid_get_pid (entry
->id
))
2573 && ptid_get_lwp (action
->thread
) == -1))
2575 struct thread_info
*thread
= (struct thread_info
*) entry
;
2577 if ((*callback
) (action
, thread
))
2585 /* Callback for visit_actioned_threads. If the thread has a pending
2586 status to report, report it now. */
2589 handle_pending_status (const struct thread_resume
*resumption
,
2590 struct thread_info
*thread
)
2592 if (thread
->status_pending_p
)
2594 thread
->status_pending_p
= 0;
2596 last_status
= thread
->last_status
;
2597 last_ptid
= thread
->entry
.id
;
2598 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2604 /* Parse vCont packets. */
2606 handle_v_cont (char *own_buf
)
2610 struct thread_resume
*resume_info
;
2611 struct thread_resume default_action
{ null_ptid
};
2613 /* Count the number of semicolons in the packet. There should be one
2614 for every action. */
2620 p
= strchr (p
, ';');
2623 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2624 if (resume_info
== NULL
)
2632 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2634 if (p
[0] == 's' || p
[0] == 'S')
2635 resume_info
[i
].kind
= resume_step
;
2636 else if (p
[0] == 'r')
2637 resume_info
[i
].kind
= resume_step
;
2638 else if (p
[0] == 'c' || p
[0] == 'C')
2639 resume_info
[i
].kind
= resume_continue
;
2640 else if (p
[0] == 't')
2641 resume_info
[i
].kind
= resume_stop
;
2645 if (p
[0] == 'S' || p
[0] == 'C')
2648 sig
= strtol (p
+ 1, &q
, 16);
2653 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2655 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2657 else if (p
[0] == 'r')
2661 p
= unpack_varlen_hex (p
+ 1, &addr
);
2662 resume_info
[i
].step_range_start
= addr
;
2667 p
= unpack_varlen_hex (p
+ 1, &addr
);
2668 resume_info
[i
].step_range_end
= addr
;
2677 resume_info
[i
].thread
= minus_one_ptid
;
2678 default_action
= resume_info
[i
];
2680 /* Note: we don't increment i here, we'll overwrite this entry
2681 the next time through. */
2683 else if (p
[0] == ':')
2685 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2690 if (p
[0] != ';' && p
[0] != 0)
2693 resume_info
[i
].thread
= ptid
;
2700 resume_info
[i
] = default_action
;
2702 resume (resume_info
, n
);
2707 write_enn (own_buf
);
2712 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2715 resume (struct thread_resume
*actions
, size_t num_actions
)
2719 /* Check if among the threads that GDB wants actioned, there's
2720 one with a pending status to report. If so, skip actually
2721 resuming/stopping and report the pending event
2723 struct visit_actioned_threads_data data
;
2725 data
.actions
= actions
;
2726 data
.num_actions
= num_actions
;
2727 data
.callback
= handle_pending_status
;
2728 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2734 (*the_target
->resume
) (actions
, num_actions
);
2740 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2742 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2743 && !report_no_resumed
)
2745 /* The client does not support this stop reply. At least
2747 sprintf (own_buf
, "E.No unwaited-for children left.");
2748 disable_async_io ();
2752 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2753 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2754 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2755 current_thread
->last_status
= last_status
;
2757 /* From the client's perspective, all-stop mode always stops all
2758 threads implicitly (and the target backend has already done
2759 so by now). Tag all threads as "want-stopped", so we don't
2760 resume them implicitly without the client telling us to. */
2761 gdb_wants_all_threads_stopped ();
2762 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2763 disable_async_io ();
2765 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2766 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2767 target_mourn_inferior (last_ptid
);
2771 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2773 handle_v_attach (char *own_buf
)
2777 pid
= strtol (own_buf
+ 8, NULL
, 16);
2778 if (pid
!= 0 && attach_inferior (pid
) == 0)
2780 /* Don't report shared library events after attaching, even if
2781 some libraries are preloaded. GDB will always poll the
2782 library list. Avoids the "stopped by shared library event"
2783 notice on the GDB side. */
2788 /* In non-stop, we don't send a resume reply. Stop events
2789 will follow up using the normal notification
2794 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2800 write_enn (own_buf
);
2805 /* Run a new program. Return 1 if successful, 0 if failure. */
2807 handle_v_run (char *own_buf
)
2810 std::vector
<char *> new_argv
;
2811 char *new_program_name
= NULL
;
2815 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2821 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2823 next_p
= strchr (p
, ';');
2825 next_p
= p
+ strlen (p
);
2827 if (i
== 0 && p
== next_p
)
2829 /* No program specified. */
2830 new_program_name
= NULL
;
2832 else if (p
== next_p
)
2834 /* Empty argument. */
2835 new_argv
.push_back (xstrdup ("''"));
2839 size_t len
= (next_p
- p
) / 2;
2840 /* ARG is the unquoted argument received via the RSP. */
2841 char *arg
= (char *) xmalloc (len
+ 1);
2842 /* FULL_ARGS will contain the quoted version of ARG. */
2843 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2844 /* These are pointers used to navigate the strings above. */
2845 char *tmp_arg
= arg
;
2846 char *tmp_full_arg
= full_arg
;
2849 hex2bin (p
, (gdb_byte
*) arg
, len
);
2852 while (*tmp_arg
!= '\0')
2858 *tmp_full_arg
= '\'';
2864 /* Quote single quote. */
2865 *tmp_full_arg
= '\\';
2873 *tmp_full_arg
= *tmp_arg
;
2879 *tmp_full_arg
++ = '\'';
2881 /* Finish FULL_ARG and push it into the vector containing
2883 *tmp_full_arg
= '\0';
2885 new_program_name
= full_arg
;
2887 new_argv
.push_back (full_arg
);
2893 new_argv
.push_back (NULL
);
2895 if (new_program_name
== NULL
)
2897 /* GDB didn't specify a program to run. Use the program from the
2898 last run with the new argument list. */
2899 if (program_name
== NULL
)
2901 write_enn (own_buf
);
2902 free_vector_argv (new_argv
);
2908 xfree (program_name
);
2909 program_name
= new_program_name
;
2912 /* Free the old argv and install the new one. */
2913 free_vector_argv (program_args
);
2914 program_args
= new_argv
;
2916 create_inferior (program_name
, program_args
);
2918 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2920 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2922 /* In non-stop, sending a resume reply doesn't set the general
2923 thread, but GDB assumes a vRun sets it (this is so GDB can
2924 query which is the main thread of the new inferior. */
2926 general_thread
= last_ptid
;
2932 write_enn (own_buf
);
2937 /* Kill process. Return 1 if successful, 0 if failure. */
2939 handle_v_kill (char *own_buf
)
2942 char *p
= &own_buf
[6];
2944 pid
= strtol (p
, NULL
, 16);
2947 if (pid
!= 0 && kill_inferior (pid
) == 0)
2949 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2950 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2951 last_ptid
= pid_to_ptid (pid
);
2952 discard_queued_stop_replies (last_ptid
);
2958 write_enn (own_buf
);
2963 /* Handle all of the extended 'v' packets. */
2965 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2967 if (!disable_packet_vCont
)
2969 if (strcmp (own_buf
, "vCtrlC") == 0)
2971 (*the_target
->request_interrupt
) ();
2976 if (startswith (own_buf
, "vCont;"))
2978 handle_v_cont (own_buf
);
2982 if (startswith (own_buf
, "vCont?"))
2984 strcpy (own_buf
, "vCont;c;C;t");
2986 if (target_supports_hardware_single_step ()
2987 || target_supports_software_single_step ()
2988 || !vCont_supported
)
2990 /* If target supports single step either by hardware or by
2991 software, add actions s and S to the list of supported
2992 actions. On the other hand, if GDB doesn't request the
2993 supported vCont actions in qSupported packet, add s and
2994 S to the list too. */
2995 own_buf
= own_buf
+ strlen (own_buf
);
2996 strcpy (own_buf
, ";s;S");
2999 if (target_supports_range_stepping ())
3001 own_buf
= own_buf
+ strlen (own_buf
);
3002 strcpy (own_buf
, ";r");
3008 if (startswith (own_buf
, "vFile:")
3009 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3012 if (startswith (own_buf
, "vAttach;"))
3014 if ((!extended_protocol
|| !multi_process
) && target_running ())
3016 fprintf (stderr
, "Already debugging a process\n");
3017 write_enn (own_buf
);
3020 handle_v_attach (own_buf
);
3024 if (startswith (own_buf
, "vRun;"))
3026 if ((!extended_protocol
|| !multi_process
) && target_running ())
3028 fprintf (stderr
, "Already debugging a process\n");
3029 write_enn (own_buf
);
3032 handle_v_run (own_buf
);
3036 if (startswith (own_buf
, "vKill;"))
3038 if (!target_running ())
3040 fprintf (stderr
, "No process to kill\n");
3041 write_enn (own_buf
);
3044 handle_v_kill (own_buf
);
3048 if (handle_notif_ack (own_buf
, packet_len
))
3051 /* Otherwise we didn't know what packet it was. Say we didn't
3057 /* Resume thread and wait for another event. In non-stop mode,
3058 don't really wait here, but return immediatelly to the event
3061 myresume (char *own_buf
, int step
, int sig
)
3063 struct thread_resume resume_info
[2];
3065 int valid_cont_thread
;
3067 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3068 && !ptid_equal (cont_thread
, minus_one_ptid
));
3070 if (step
|| sig
|| valid_cont_thread
)
3072 resume_info
[0].thread
= current_ptid
;
3074 resume_info
[0].kind
= resume_step
;
3076 resume_info
[0].kind
= resume_continue
;
3077 resume_info
[0].sig
= sig
;
3081 if (!valid_cont_thread
)
3083 resume_info
[n
].thread
= minus_one_ptid
;
3084 resume_info
[n
].kind
= resume_continue
;
3085 resume_info
[n
].sig
= 0;
3089 resume (resume_info
, n
);
3092 /* Callback for for_each_inferior. Make a new stop reply for each
3096 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3098 struct thread_info
*thread
= (struct thread_info
*) entry
;
3100 /* For now, assume targets that don't have this callback also don't
3101 manage the thread's last_status field. */
3102 if (the_target
->thread_stopped
== NULL
)
3104 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3106 new_notif
->ptid
= entry
->id
;
3107 new_notif
->status
= thread
->last_status
;
3108 /* Pass the last stop reply back to GDB, but don't notify
3110 notif_event_enque (¬if_stop
,
3111 (struct notif_event
*) new_notif
);
3115 if (thread_stopped (thread
))
3120 = target_waitstatus_to_string (&thread
->last_status
);
3122 debug_printf ("Reporting thread %s as already stopped with %s\n",
3123 target_pid_to_str (entry
->id
),
3126 xfree (status_string
);
3129 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3131 /* Pass the last stop reply back to GDB, but don't notify
3133 queue_stop_reply (entry
->id
, &thread
->last_status
);
3140 /* Set this inferior threads's state as "want-stopped". We won't
3141 resume this thread until the client gives us another action for
3145 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3147 struct thread_info
*thread
= (struct thread_info
*) entry
;
3149 thread
->last_resume_kind
= resume_stop
;
3151 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3153 /* Most threads are stopped implicitly (all-stop); tag that with
3155 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3156 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3160 /* Set all threads' states as "want-stopped". */
3163 gdb_wants_all_threads_stopped (void)
3165 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3168 /* Clear the gdb_detached flag of every process. */
3171 gdb_reattached_process (struct inferior_list_entry
*entry
)
3173 struct process_info
*process
= (struct process_info
*) entry
;
3175 process
->gdb_detached
= 0;
3178 /* Callback for for_each_inferior. Clear the thread's pending status
3182 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3184 struct thread_info
*thread
= (struct thread_info
*) entry
;
3186 thread
->status_pending_p
= 0;
3189 /* Callback for for_each_inferior. If the thread is stopped with an
3190 interesting event, mark it as having a pending event. */
3193 set_pending_status_callback (struct inferior_list_entry
*entry
)
3195 struct thread_info
*thread
= (struct thread_info
*) entry
;
3197 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3198 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3199 /* A breakpoint, watchpoint or finished step from a previous
3200 GDB run isn't considered interesting for a new GDB run.
3201 If we left those pending, the new GDB could consider them
3202 random SIGTRAPs. This leaves out real async traps. We'd
3203 have to peek into the (target-specific) siginfo to
3204 distinguish those. */
3205 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3206 thread
->status_pending_p
= 1;
3209 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3210 pending status to report to GDB. */
3213 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3215 struct thread_info
*thread
= (struct thread_info
*) entry
;
3217 return thread
->status_pending_p
;
3220 /* Status handler for the '?' packet. */
3223 handle_status (char *own_buf
)
3225 /* GDB is connected, don't forward events to the target anymore. */
3226 for_each_inferior (&all_processes
, gdb_reattached_process
);
3228 /* In non-stop mode, we must send a stop reply for each stopped
3229 thread. In all-stop mode, just send one for the first stopped
3234 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3236 /* The first is sent immediatly. OK is sent if there is no
3237 stopped thread, which is the same handling of the vStopped
3238 packet (by design). */
3239 notif_write_event (¬if_stop
, own_buf
);
3243 struct inferior_list_entry
*thread
= NULL
;
3246 stabilize_threads ();
3247 gdb_wants_all_threads_stopped ();
3249 /* We can only report one status, but we might be coming out of
3250 non-stop -- if more than one thread is stopped with
3251 interesting events, leave events for the threads we're not
3252 reporting now pending. They'll be reported the next time the
3253 threads are resumed. Start by marking all interesting events
3255 for_each_inferior (&all_threads
, set_pending_status_callback
);
3257 /* Prefer the last thread that reported an event to GDB (even if
3258 that was a GDB_SIGNAL_TRAP). */
3259 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3260 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3261 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3262 thread
= find_inferior_id (&all_threads
, last_ptid
);
3264 /* If the last event thread is not found for some reason, look
3265 for some other thread that might have an event to report. */
3267 thread
= find_inferior (&all_threads
,
3268 find_status_pending_thread_callback
, NULL
);
3270 /* If we're still out of luck, simply pick the first thread in
3273 thread
= get_first_inferior (&all_threads
);
3277 struct thread_info
*tp
= (struct thread_info
*) thread
;
3279 /* We're reporting this event, so it's no longer
3281 tp
->status_pending_p
= 0;
3283 /* GDB assumes the current thread is the thread we're
3284 reporting the status for. */
3285 general_thread
= thread
->id
;
3286 set_desired_thread (1);
3288 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3289 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3292 strcpy (own_buf
, "W00");
3297 gdbserver_version (void)
3299 printf ("GNU gdbserver %s%s\n"
3300 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3301 "gdbserver is free software, covered by the "
3302 "GNU General Public License.\n"
3303 "This gdbserver was configured as \"%s\"\n",
3304 PKGVERSION
, version
, host_name
);
3308 gdbserver_usage (FILE *stream
)
3310 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3311 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3312 "\tgdbserver [OPTIONS] --multi COMM\n"
3314 "COMM may either be a tty device (for serial debugging),\n"
3315 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3316 "stdin/stdout of gdbserver.\n"
3317 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3318 "PID is the process ID to attach to, when --attach is specified.\n"
3320 "Operating modes:\n"
3322 " --attach Attach to running process PID.\n"
3323 " --multi Start server without a specific program, and\n"
3324 " only quit when explicitly commanded.\n"
3325 " --once Exit after the first connection has closed.\n"
3326 " --help Print this message and then exit.\n"
3327 " --version Display version information and exit.\n"
3331 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3332 " --disable-randomization\n"
3333 " Run PROG with address space randomization disabled.\n"
3334 " --no-disable-randomization\n"
3335 " Don't disable address space randomization when\n"
3337 " --startup-with-shell\n"
3338 " Start PROG using a shell. I.e., execs a shell that\n"
3339 " then execs PROG. (default)\n"
3340 " --no-startup-with-shell\n"
3341 " Exec PROG directly instead of using a shell.\n"
3342 " Disables argument globbing and variable substitution\n"
3343 " on UNIX-like systems.\n"
3347 " --debug Enable general debugging output.\n"
3348 " --debug-format=opt1[,opt2,...]\n"
3349 " Specify extra content in debugging output.\n"
3354 " --remote-debug Enable remote protocol debugging output.\n"
3355 " --disable-packet=opt1[,opt2,...]\n"
3356 " Disable support for RSP packets or features.\n"
3358 " vCont, Tthread, qC, qfThreadInfo and \n"
3359 " threads (disable all threading packets).\n"
3361 "For more information, consult the GDB manual (available as on-line \n"
3362 "info or a printed manual).\n");
3363 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3364 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3368 gdbserver_show_disableable (FILE *stream
)
3370 fprintf (stream
, "Disableable packets:\n"
3371 " vCont \tAll vCont packets\n"
3372 " qC \tQuerying the current thread\n"
3373 " qfThreadInfo\tThread listing\n"
3374 " Tthread \tPassing the thread specifier in the "
3375 "T stop reply packet\n"
3376 " threads \tAll of the above\n");
3380 #undef require_running
3381 #define require_running(BUF) \
3382 if (!target_running ()) \
3389 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3391 int pid
= * (int *) args
;
3393 if (ptid_get_pid (entry
->id
) == pid
)
3400 kill_inferior_callback (struct inferior_list_entry
*entry
)
3402 struct process_info
*process
= (struct process_info
*) entry
;
3403 int pid
= ptid_get_pid (process
->entry
.id
);
3405 kill_inferior (pid
);
3406 discard_queued_stop_replies (pid_to_ptid (pid
));
3409 /* Callback for for_each_inferior to detach or kill the inferior,
3410 depending on whether we attached to it or not.
3411 We inform the user whether we're detaching or killing the process
3412 as this is only called when gdbserver is about to exit. */
3415 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3417 struct process_info
*process
= (struct process_info
*) entry
;
3418 int pid
= ptid_get_pid (process
->entry
.id
);
3420 if (process
->attached
)
3421 detach_inferior (pid
);
3423 kill_inferior (pid
);
3425 discard_queued_stop_replies (pid_to_ptid (pid
));
3428 /* for_each_inferior callback for detach_or_kill_for_exit to print
3429 the pids of started inferiors. */
3432 print_started_pid (struct inferior_list_entry
*entry
)
3434 struct process_info
*process
= (struct process_info
*) entry
;
3436 if (! process
->attached
)
3438 int pid
= ptid_get_pid (process
->entry
.id
);
3439 fprintf (stderr
, " %d", pid
);
3443 /* for_each_inferior callback for detach_or_kill_for_exit to print
3444 the pids of attached inferiors. */
3447 print_attached_pid (struct inferior_list_entry
*entry
)
3449 struct process_info
*process
= (struct process_info
*) entry
;
3451 if (process
->attached
)
3453 int pid
= ptid_get_pid (process
->entry
.id
);
3454 fprintf (stderr
, " %d", pid
);
3458 /* Call this when exiting gdbserver with possible inferiors that need
3459 to be killed or detached from. */
3462 detach_or_kill_for_exit (void)
3464 /* First print a list of the inferiors we will be killing/detaching.
3465 This is to assist the user, for example, in case the inferior unexpectedly
3466 dies after we exit: did we screw up or did the inferior exit on its own?
3467 Having this info will save some head-scratching. */
3469 if (have_started_inferiors_p ())
3471 fprintf (stderr
, "Killing process(es):");
3472 for_each_inferior (&all_processes
, print_started_pid
);
3473 fprintf (stderr
, "\n");
3475 if (have_attached_inferiors_p ())
3477 fprintf (stderr
, "Detaching process(es):");
3478 for_each_inferior (&all_processes
, print_attached_pid
);
3479 fprintf (stderr
, "\n");
3482 /* Now we can kill or detach the inferiors. */
3484 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3487 /* Value that will be passed to exit(3) when gdbserver exits. */
3488 static int exit_code
;
3490 /* Cleanup version of detach_or_kill_for_exit. */
3493 detach_or_kill_for_exit_cleanup (void *ignore
)
3498 detach_or_kill_for_exit ();
3501 CATCH (exception
, RETURN_MASK_ALL
)
3504 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3510 /* Main function. This is called by the real "main" function,
3511 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3513 static void ATTRIBUTE_NORETURN
3514 captured_main (int argc
, char *argv
[])
3519 const char *port
= NULL
;
3520 char **next_arg
= &argv
[1];
3521 volatile int multi_mode
= 0;
3522 volatile int attach
= 0;
3525 while (*next_arg
!= NULL
&& **next_arg
== '-')
3527 if (strcmp (*next_arg
, "--version") == 0)
3529 gdbserver_version ();
3532 else if (strcmp (*next_arg
, "--help") == 0)
3534 gdbserver_usage (stdout
);
3537 else if (strcmp (*next_arg
, "--attach") == 0)
3539 else if (strcmp (*next_arg
, "--multi") == 0)
3541 else if (strcmp (*next_arg
, "--wrapper") == 0)
3548 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3550 wrapper_argv
+= *next_arg
;
3551 wrapper_argv
+= ' ';
3555 if (!wrapper_argv
.empty ())
3557 /* Erase the last whitespace. */
3558 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3561 if (next_arg
== tmp
|| *next_arg
== NULL
)
3563 gdbserver_usage (stderr
);
3567 /* Consume the "--". */
3570 else if (strcmp (*next_arg
, "--debug") == 0)
3572 else if (startswith (*next_arg
, "--debug-format="))
3575 = parse_debug_format_options ((*next_arg
)
3576 + sizeof ("--debug-format=") - 1, 0);
3578 if (error_msg
!= NULL
)
3580 fprintf (stderr
, "%s", error_msg
);
3584 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3586 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3588 gdbserver_show_disableable (stdout
);
3591 else if (startswith (*next_arg
, "--disable-packet="))
3593 char *packets
, *tok
;
3595 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3596 for (tok
= strtok (packets
, ",");
3598 tok
= strtok (NULL
, ","))
3600 if (strcmp ("vCont", tok
) == 0)
3601 disable_packet_vCont
= 1;
3602 else if (strcmp ("Tthread", tok
) == 0)
3603 disable_packet_Tthread
= 1;
3604 else if (strcmp ("qC", tok
) == 0)
3605 disable_packet_qC
= 1;
3606 else if (strcmp ("qfThreadInfo", tok
) == 0)
3607 disable_packet_qfThreadInfo
= 1;
3608 else if (strcmp ("threads", tok
) == 0)
3610 disable_packet_vCont
= 1;
3611 disable_packet_Tthread
= 1;
3612 disable_packet_qC
= 1;
3613 disable_packet_qfThreadInfo
= 1;
3617 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3619 gdbserver_show_disableable (stderr
);
3624 else if (strcmp (*next_arg
, "-") == 0)
3626 /* "-" specifies a stdio connection and is a form of port
3628 port
= STDIO_CONNECTION_NAME
;
3632 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3633 disable_randomization
= 1;
3634 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3635 disable_randomization
= 0;
3636 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3637 startup_with_shell
= true;
3638 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3639 startup_with_shell
= false;
3640 else if (strcmp (*next_arg
, "--once") == 0)
3644 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3657 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3659 gdbserver_usage (stderr
);
3663 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3664 opened by remote_prepare. */
3667 save_original_signals_state ();
3669 /* We need to know whether the remote connection is stdio before
3670 starting the inferior. Inferiors created in this scenario have
3671 stdin,stdout redirected. So do this here before we call
3673 remote_prepare (port
);
3678 /* --attach used to come after PORT, so allow it there for
3680 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3687 && (*next_arg
== NULL
3688 || (*next_arg
)[0] == '\0'
3689 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3691 || next_arg
[1] != NULL
))
3696 gdbserver_usage (stderr
);
3700 /* Gather information about the environment. */
3701 our_environ
= gdb_environ::from_host_environ ();
3703 initialize_async_io ();
3705 have_job_control ();
3706 initialize_event_loop ();
3707 if (target_supports_tracepoints ())
3708 initialize_tracepoint ();
3709 initialize_notif ();
3711 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3712 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3714 if (pid
== 0 && *next_arg
!= NULL
)
3718 n
= argc
- (next_arg
- argv
);
3719 program_name
= xstrdup (next_arg
[0]);
3720 for (i
= 1; i
< n
; i
++)
3721 program_args
.push_back (xstrdup (next_arg
[i
]));
3722 program_args
.push_back (NULL
);
3724 /* Wait till we are at first instruction in program. */
3725 create_inferior (program_name
, program_args
);
3727 /* We are now (hopefully) stopped at the first instruction of
3728 the target process. This assumes that the target process was
3729 successfully created. */
3733 if (attach_inferior (pid
) == -1)
3734 error ("Attaching not supported on this target");
3736 /* Otherwise succeeded. */
3740 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3741 last_status
.value
.integer
= 0;
3742 last_ptid
= minus_one_ptid
;
3744 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3746 /* Don't report shared library events on the initial connection,
3747 even if some libraries are preloaded. Avoids the "stopped by
3748 shared library event" notice on gdb side. */
3751 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3752 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3757 if (!was_running
&& !multi_mode
)
3758 error ("No program to debug");
3765 report_fork_events
= 0;
3766 report_vfork_events
= 0;
3767 report_exec_events
= 0;
3768 /* Be sure we're out of tfind mode. */
3769 current_traceframe
= -1;
3770 cont_thread
= null_ptid
;
3771 swbreak_feature
= 0;
3772 hwbreak_feature
= 0;
3773 vCont_supported
= 0;
3779 /* Wait for events. This will return when all event sources
3780 are removed from the event loop. */
3781 start_event_loop ();
3783 /* If an exit was requested (using the "monitor exit"
3784 command), terminate now. */
3786 throw_quit ("Quit");
3788 /* The only other way to get here is for getpkt to fail:
3790 - If --once was specified, we're done.
3792 - If not in extended-remote mode, and we're no longer
3793 debugging anything, simply exit: GDB has disconnected
3794 after processing the last process exit.
3796 - Otherwise, close the connection and reopen it at the
3798 if (run_once
|| (!extended_protocol
&& !target_running ()))
3799 throw_quit ("Quit");
3802 "Remote side has terminated connection. "
3803 "GDBserver will reopen the connection.\n");
3805 /* Get rid of any pending statuses. An eventual reconnection
3806 (by the same GDB instance or another) will refresh all its
3807 state from scratch. */
3808 discard_queued_stop_replies (minus_one_ptid
);
3809 for_each_inferior (&all_threads
,
3810 clear_pending_status_callback
);
3814 if (disconnected_tracing
)
3816 /* Try to enable non-stop/async mode, so we we can
3817 both wait for an async socket accept, and handle
3818 async target events simultaneously. There's also
3819 no point either in having the target always stop
3820 all threads, when we're going to pass signals
3821 down without informing GDB. */
3824 if (start_non_stop (1))
3827 /* Detaching implicitly resumes all threads;
3828 simply disconnecting does not. */
3834 "Disconnected tracing disabled; "
3835 "stopping trace run.\n");
3840 CATCH (exception
, RETURN_MASK_ERROR
)
3843 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3845 if (response_needed
)
3847 write_enn (own_buf
);
3852 throw_quit ("Quit");
3858 /* Main function. */
3861 main (int argc
, char *argv
[])
3866 captured_main (argc
, argv
);
3868 CATCH (exception
, RETURN_MASK_ALL
)
3870 if (exception
.reason
== RETURN_ERROR
)
3873 fprintf (stderr
, "%s\n", exception
.message
);
3874 fprintf (stderr
, "Exiting\n");
3882 gdb_assert_not_reached ("captured_main should never return");
3885 /* Process options coming from Z packets for a breakpoint. PACKET is
3886 the packet buffer. *PACKET is updated to point to the first char
3887 after the last processed option. */
3890 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3892 char *dataptr
= *packet
;
3895 /* Check if data has the correct format. */
3896 if (*dataptr
!= ';')
3903 if (*dataptr
== ';')
3906 if (*dataptr
== 'X')
3908 /* Conditional expression. */
3910 debug_printf ("Found breakpoint condition.\n");
3911 if (!add_breakpoint_condition (bp
, &dataptr
))
3912 dataptr
= strchrnul (dataptr
, ';');
3914 else if (startswith (dataptr
, "cmds:"))
3916 dataptr
+= strlen ("cmds:");
3918 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3919 persist
= (*dataptr
== '1');
3921 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3922 dataptr
= strchrnul (dataptr
, ';');
3926 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3928 /* Skip tokens until we find one that we recognize. */
3929 dataptr
= strchrnul (dataptr
, ';');
3935 /* Event loop callback that handles a serial event. The first byte in
3936 the serial buffer gets us here. We expect characters to arrive at
3937 a brisk pace, so we read the rest of the packet with a blocking
3941 process_serial_event (void)
3952 int new_packet_len
= -1;
3954 disable_async_io ();
3956 response_needed
= 0;
3957 packet_len
= getpkt (own_buf
);
3958 if (packet_len
<= 0)
3961 /* Force an event loop break. */
3964 response_needed
= 1;
3971 handle_query (own_buf
, packet_len
, &new_packet_len
);
3974 handle_general_set (own_buf
);
3977 require_running (own_buf
);
3982 pid
= strtol (&own_buf
[i
], NULL
, 16);
3985 pid
= ptid_get_pid (current_ptid
);
3987 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3989 struct process_info
*process
= find_process_pid (pid
);
3991 if (process
== NULL
)
3993 write_enn (own_buf
);
3997 if (tracing
&& disconnected_tracing
)
3999 "Disconnected tracing in effect, "
4000 "leaving gdbserver attached to the process\n");
4002 if (any_persistent_commands ())
4004 "Persistent commands are present, "
4005 "leaving gdbserver attached to the process\n");
4007 /* Make sure we're in non-stop/async mode, so we we can both
4008 wait for an async socket accept, and handle async target
4009 events simultaneously. There's also no point either in
4010 having the target stop all threads, when we're going to
4011 pass signals down without informing GDB. */
4015 debug_printf ("Forcing non-stop mode\n");
4021 process
->gdb_detached
= 1;
4023 /* Detaching implicitly resumes all threads. */
4024 target_continue_no_signal (minus_one_ptid
);
4027 break; /* from switch/case */
4030 fprintf (stderr
, "Detaching from process %d\n", pid
);
4032 if (detach_inferior (pid
) != 0)
4033 write_enn (own_buf
);
4036 discard_queued_stop_replies (pid_to_ptid (pid
));
4039 if (extended_protocol
|| target_running ())
4041 /* There is still at least one inferior remaining or
4042 we are in extended mode, so don't terminate gdbserver,
4043 and instead treat this like a normal program exit. */
4044 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4045 last_status
.value
.integer
= 0;
4046 last_ptid
= pid_to_ptid (pid
);
4048 current_thread
= NULL
;
4055 /* If we are attached, then we can exit. Otherwise, we
4056 need to hang around doing nothing, until the child is
4058 join_inferior (pid
);
4064 extended_protocol
= 1;
4068 handle_status (own_buf
);
4071 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4073 ptid_t gdb_id
, thread_id
;
4076 require_running (own_buf
);
4078 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4080 pid
= ptid_get_pid (gdb_id
);
4082 if (ptid_equal (gdb_id
, null_ptid
)
4083 || ptid_equal (gdb_id
, minus_one_ptid
))
4084 thread_id
= null_ptid
;
4086 && ptid_equal (pid_to_ptid (pid
),
4089 struct thread_info
*thread
=
4090 (struct thread_info
*) find_inferior (&all_threads
,
4095 write_enn (own_buf
);
4099 thread_id
= thread
->entry
.id
;
4103 thread_id
= gdb_id_to_thread_id (gdb_id
);
4104 if (ptid_equal (thread_id
, null_ptid
))
4106 write_enn (own_buf
);
4111 if (own_buf
[1] == 'g')
4113 if (ptid_equal (thread_id
, null_ptid
))
4115 /* GDB is telling us to choose any thread. Check if
4116 the currently selected thread is still valid. If
4117 it is not, select the first available. */
4118 struct thread_info
*thread
=
4119 (struct thread_info
*) find_inferior_id (&all_threads
,
4122 thread
= get_first_thread ();
4123 thread_id
= thread
->entry
.id
;
4126 general_thread
= thread_id
;
4127 set_desired_thread (1);
4128 gdb_assert (current_thread
!= NULL
);
4130 else if (own_buf
[1] == 'c')
4131 cont_thread
= thread_id
;
4137 /* Silently ignore it so that gdb can extend the protocol
4138 without compatibility headaches. */
4143 require_running (own_buf
);
4144 if (current_traceframe
>= 0)
4146 struct regcache
*regcache
4147 = new_register_cache (current_target_desc ());
4149 if (fetch_traceframe_registers (current_traceframe
,
4151 registers_to_string (regcache
, own_buf
);
4153 write_enn (own_buf
);
4154 free_register_cache (regcache
);
4158 struct regcache
*regcache
;
4160 if (!set_desired_thread (1))
4161 write_enn (own_buf
);
4164 regcache
= get_thread_regcache (current_thread
, 1);
4165 registers_to_string (regcache
, own_buf
);
4170 require_running (own_buf
);
4171 if (current_traceframe
>= 0)
4172 write_enn (own_buf
);
4175 struct regcache
*regcache
;
4177 if (!set_desired_thread (1))
4178 write_enn (own_buf
);
4181 regcache
= get_thread_regcache (current_thread
, 1);
4182 registers_from_string (regcache
, &own_buf
[1]);
4188 require_running (own_buf
);
4189 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4190 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4192 write_enn (own_buf
);
4194 bin2hex (mem_buf
, own_buf
, res
);
4197 require_running (own_buf
);
4198 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4199 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4202 write_enn (own_buf
);
4205 require_running (own_buf
);
4206 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4207 &mem_addr
, &len
, &mem_buf
) < 0
4208 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4209 write_enn (own_buf
);
4214 require_running (own_buf
);
4215 hex2bin (own_buf
+ 1, &sig
, 1);
4216 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4217 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4220 myresume (own_buf
, 0, signal
);
4223 require_running (own_buf
);
4224 hex2bin (own_buf
+ 1, &sig
, 1);
4225 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4226 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4229 myresume (own_buf
, 1, signal
);
4232 require_running (own_buf
);
4234 myresume (own_buf
, 0, signal
);
4237 require_running (own_buf
);
4239 myresume (own_buf
, 1, signal
);
4241 case 'Z': /* insert_ ... */
4243 case 'z': /* remove_ ... */
4248 char type
= own_buf
[1];
4250 const int insert
= ch
== 'Z';
4251 char *p
= &own_buf
[3];
4253 p
= unpack_varlen_hex (p
, &addr
);
4254 kind
= strtol (p
+ 1, &dataptr
, 16);
4258 struct gdb_breakpoint
*bp
;
4260 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4265 /* GDB may have sent us a list of *point parameters to
4266 be evaluated on the target's side. Read such list
4267 here. If we already have a list of parameters, GDB
4268 is telling us to drop that list and use this one
4270 clear_breakpoint_conditions_and_commands (bp
);
4271 process_point_options (bp
, &dataptr
);
4275 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4283 write_enn (own_buf
);
4287 response_needed
= 0;
4288 if (!target_running ())
4289 /* The packet we received doesn't make sense - but we can't
4290 reply to it, either. */
4293 fprintf (stderr
, "Killing all inferiors\n");
4294 for_each_inferior (&all_processes
, kill_inferior_callback
);
4296 /* When using the extended protocol, we wait with no program
4297 running. The traditional protocol will exit instead. */
4298 if (extended_protocol
)
4300 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4301 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4309 ptid_t gdb_id
, thread_id
;
4311 require_running (own_buf
);
4313 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4314 thread_id
= gdb_id_to_thread_id (gdb_id
);
4315 if (ptid_equal (thread_id
, null_ptid
))
4317 write_enn (own_buf
);
4321 if (mythread_alive (thread_id
))
4324 write_enn (own_buf
);
4328 response_needed
= 0;
4330 /* Restarting the inferior is only supported in the extended
4332 if (extended_protocol
)
4334 if (target_running ())
4335 for_each_inferior (&all_processes
,
4336 kill_inferior_callback
);
4337 fprintf (stderr
, "GDBserver restarting\n");
4339 /* Wait till we are at 1st instruction in prog. */
4340 if (program_name
!= NULL
)
4342 create_inferior (program_name
, program_args
);
4344 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4346 /* Stopped at the first instruction of the target
4348 general_thread
= last_ptid
;
4352 /* Something went wrong. */
4353 general_thread
= null_ptid
;
4358 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4359 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4365 /* It is a request we don't understand. Respond with an
4366 empty packet so that gdb knows that we don't support this
4372 /* Extended (long) request. */
4373 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4377 /* It is a request we don't understand. Respond with an empty
4378 packet so that gdb knows that we don't support this
4384 if (new_packet_len
!= -1)
4385 putpkt_binary (own_buf
, new_packet_len
);
4389 response_needed
= 0;
4397 /* Event-loop callback for serial events. */
4400 handle_serial_event (int err
, gdb_client_data client_data
)
4403 debug_printf ("handling possible serial event\n");
4405 /* Really handle it. */
4406 if (process_serial_event () < 0)
4409 /* Be sure to not change the selected thread behind GDB's back.
4410 Important in the non-stop mode asynchronous protocol. */
4411 set_desired_thread (1);
4416 /* Push a stop notification on the notification queue. */
4419 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4421 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4423 vstop_notif
->status
= *status
;
4424 vstop_notif
->ptid
= ptid
;
4425 /* Push Stop notification. */
4426 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4429 /* Event-loop callback for target events. */
4432 handle_target_event (int err
, gdb_client_data client_data
)
4435 debug_printf ("handling possible target event\n");
4437 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4440 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4442 if (gdb_connected () && report_no_resumed
)
4443 push_stop_notification (null_ptid
, &last_status
);
4445 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4447 int pid
= ptid_get_pid (last_ptid
);
4448 struct process_info
*process
= find_process_pid (pid
);
4449 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4451 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4452 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4454 mark_breakpoints_out (process
);
4455 target_mourn_inferior (last_ptid
);
4457 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4461 /* We're reporting this thread as stopped. Update its
4462 "want-stopped" state to what the client wants, until it
4463 gets a new resume action. */
4464 current_thread
->last_resume_kind
= resume_stop
;
4465 current_thread
->last_status
= last_status
;
4470 if (!target_running ())
4472 /* The last process exited. We're done. */
4476 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4477 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4478 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4482 /* A thread stopped with a signal, but gdb isn't
4483 connected to handle it. Pass it down to the
4484 inferior, as if it wasn't being traced. */
4485 enum gdb_signal signal
;
4488 debug_printf ("GDB not connected; forwarding event %d for"
4490 (int) last_status
.kind
,
4491 target_pid_to_str (last_ptid
));
4493 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4494 signal
= last_status
.value
.sig
;
4496 signal
= GDB_SIGNAL_0
;
4497 target_continue (last_ptid
, signal
);
4501 push_stop_notification (last_ptid
, &last_status
);
4504 /* Be sure to not change the selected thread behind GDB's back.
4505 Important in the non-stop mode asynchronous protocol. */
4506 set_desired_thread (1);