1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2018 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"
42 #include "filenames.h"
43 #include "pathstuff.h"
45 #include "common/selftest.h"
47 #define require_running_or_return(BUF) \
48 if (!target_running ()) \
54 #define require_running_or_break(BUF) \
55 if (!target_running ()) \
61 /* String containing the current directory (what getwd would return). */
63 char *current_directory
;
65 /* The environment to pass to the inferior when creating it. */
67 static gdb_environ our_environ
;
69 /* Start the inferior using a shell. */
71 /* We always try to start the inferior using a shell. */
73 int startup_with_shell
= 1;
77 static int extended_protocol
;
78 static int response_needed
;
79 static int exit_requested
;
81 /* --once: Exit after the first connection has closed. */
84 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
85 static int report_no_resumed
;
90 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
92 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
94 m_path
= std::move (path
);
96 /* Make sure we're using the absolute path of the inferior when
98 if (!contains_dir_separator (m_path
.get ()))
102 /* Check if the file is in our CWD. If it is, then we prefix
103 its name with CURRENT_DIRECTORY. Otherwise, we leave the
104 name as-is because we'll try searching for it in $PATH. */
105 if (is_regular_file (m_path
.get (), ®_file_errno
))
106 m_path
= gdb_abspath (m_path
.get ());
110 /* Return the PROGRAM_PATH. */
112 { return m_path
.get (); }
115 /* The program name, adjusted if needed. */
116 gdb::unique_xmalloc_ptr
<char> m_path
;
118 static std::vector
<char *> program_args
;
119 static std::string wrapper_argv
;
121 /* The PID of the originally created or attached inferior. Used to
122 send signals to the process when GDB sends us an asynchronous interrupt
123 (user hitting Control-C in the client), and to wait for the child to exit
124 when no longer debugging it. */
126 unsigned long signal_pid
;
128 /* Set if you want to disable optional thread related packets support
129 in gdbserver, for the sake of testing GDB against stubs that don't
131 int disable_packet_vCont
;
132 int disable_packet_Tthread
;
133 int disable_packet_qC
;
134 int disable_packet_qfThreadInfo
;
136 static unsigned char *mem_buf
;
138 /* A sub-class of 'struct notif_event' for stop, holding information
139 relative to a single stop reply. We keep a queue of these to
140 push to GDB in non-stop mode. */
144 struct notif_event base
;
146 /* Thread or process that got the event. */
150 struct target_waitstatus status
;
153 /* The current btrace configuration. This is gdbserver's mirror of GDB's
154 btrace configuration. */
155 static struct btrace_config current_btrace_conf
;
157 DEFINE_QUEUE_P (notif_event_p
);
159 /* The client remote protocol state. */
161 static client_state g_client_state
;
166 client_state
&cs
= g_client_state
;
171 /* Put a stop reply to the stop reply queue. */
174 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
176 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
178 new_notif
->ptid
= ptid
;
179 new_notif
->status
= *status
;
181 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
185 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
186 QUEUE_ITER (notif_event_p
) *iter
,
187 struct notif_event
*event
,
190 ptid_t filter_ptid
= *(ptid_t
*) data
;
191 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
193 if (vstop_event
->ptid
.matches (filter_ptid
))
195 if (q
->free_func
!= NULL
)
196 q
->free_func (event
);
198 QUEUE_remove_elem (notif_event_p
, q
, iter
);
207 discard_queued_stop_replies (ptid_t ptid
)
209 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
210 remove_all_on_match_ptid
, &ptid
);
214 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
216 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
218 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
221 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
224 in_queued_stop_replies_ptid (QUEUE (notif_event_p
) *q
,
225 QUEUE_ITER (notif_event_p
) *iter
,
226 struct notif_event
*event
,
229 ptid_t filter_ptid
= *(ptid_t
*) data
;
230 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
232 if (vstop_event
->ptid
.matches (filter_ptid
))
235 /* Don't resume fork children that GDB does not know about yet. */
236 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
237 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
238 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
247 in_queued_stop_replies (ptid_t ptid
)
249 return !QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
250 in_queued_stop_replies_ptid
, &ptid
);
253 struct notif_server notif_stop
=
255 "vStopped", "Stop", NULL
, vstop_notif_reply
,
259 target_running (void)
261 return get_first_thread () != NULL
;
264 /* See common/common-inferior.h. */
269 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
272 /* See common/common-inferior.h. */
275 get_exec_file (int err
)
277 if (err
&& program_path
.get () == NULL
)
278 error (_("No executable file specified."));
280 return program_path
.get ();
292 attach_inferior (int pid
)
294 client_state
&cs
= get_client_state ();
295 /* myattach should return -1 if attaching is unsupported,
296 0 if it succeeded, and call error() otherwise. */
298 if (myattach (pid
) != 0)
301 fprintf (stderr
, "Attached; pid = %d\n", pid
);
304 /* FIXME - It may be that we should get the SIGNAL_PID from the
305 attach function, so that it can be the main thread instead of
306 whichever we were told to attach to. */
311 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
313 /* GDB knows to ignore the first SIGSTOP after attaching to a running
314 process using the "attach" command, but this is different; it's
315 just using "target remote". Pretend it's just starting up. */
316 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
317 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
318 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
320 current_thread
->last_resume_kind
= resume_stop
;
321 current_thread
->last_status
= cs
.last_status
;
327 extern int remote_debug
;
329 /* Decode a qXfer read request. Return 0 if everything looks OK,
333 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
335 /* After the read marker and annex, qXfer looks like a
336 traditional 'm' packet. */
337 decode_m_packet (buf
, ofs
, len
);
343 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
345 /* Extract and NUL-terminate the object. */
347 while (*buf
&& *buf
!= ':')
353 /* Extract and NUL-terminate the read/write action. */
355 while (*buf
&& *buf
!= ':')
361 /* Extract and NUL-terminate the annex. */
363 while (*buf
&& *buf
!= ':')
373 /* Write the response to a successful qXfer read. Returns the
374 length of the (binary) data stored in BUF, corresponding
375 to as much of DATA/LEN as we could fit. IS_MORE controls
376 the first character of the response. */
378 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
387 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
388 &out_len
, PBUFSIZ
- 2) + 1;
391 /* Handle btrace enabling in BTS format. */
394 handle_btrace_enable_bts (struct thread_info
*thread
)
396 if (thread
->btrace
!= NULL
)
397 error (_("Btrace already enabled."));
399 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
400 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
403 /* Handle btrace enabling in Intel Processor Trace format. */
406 handle_btrace_enable_pt (struct thread_info
*thread
)
408 if (thread
->btrace
!= NULL
)
409 error (_("Btrace already enabled."));
411 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
412 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info
*thread
)
421 if (thread
->btrace
== NULL
)
422 error (_("Branch tracing not enabled."));
424 if (target_disable_btrace (thread
->btrace
) != 0)
425 error (_("Could not disable branch tracing."));
427 thread
->btrace
= NULL
;
430 /* Handle the "Qbtrace" packet. */
433 handle_btrace_general_set (char *own_buf
)
435 client_state
&cs
= get_client_state ();
436 struct thread_info
*thread
;
439 if (!startswith (own_buf
, "Qbtrace:"))
442 op
= own_buf
+ strlen ("Qbtrace:");
444 if (cs
.general_thread
== null_ptid
445 || cs
.general_thread
== minus_one_ptid
)
447 strcpy (own_buf
, "E.Must select a single thread.");
451 thread
= find_thread_ptid (cs
.general_thread
);
454 strcpy (own_buf
, "E.No such thread.");
460 if (strcmp (op
, "bts") == 0)
461 handle_btrace_enable_bts (thread
);
462 else if (strcmp (op
, "pt") == 0)
463 handle_btrace_enable_pt (thread
);
464 else if (strcmp (op
, "off") == 0)
465 handle_btrace_disable (thread
);
467 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
471 CATCH (exception
, RETURN_MASK_ERROR
)
473 sprintf (own_buf
, "E.%s", exception
.message
);
480 /* Handle the "Qbtrace-conf" packet. */
483 handle_btrace_conf_general_set (char *own_buf
)
485 client_state
&cs
= get_client_state ();
486 struct thread_info
*thread
;
489 if (!startswith (own_buf
, "Qbtrace-conf:"))
492 op
= own_buf
+ strlen ("Qbtrace-conf:");
494 if (cs
.general_thread
== null_ptid
495 || cs
.general_thread
== minus_one_ptid
)
497 strcpy (own_buf
, "E.Must select a single thread.");
501 thread
= find_thread_ptid (cs
.general_thread
);
504 strcpy (own_buf
, "E.No such thread.");
508 if (startswith (op
, "bts:size="))
514 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
515 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
517 strcpy (own_buf
, "E.Bad size value.");
521 current_btrace_conf
.bts
.size
= (unsigned int) size
;
523 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
529 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
530 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
532 strcpy (own_buf
, "E.Bad size value.");
536 current_btrace_conf
.pt
.size
= (unsigned int) size
;
540 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
548 /* Handle all of the extended 'Q' packets. */
551 handle_general_set (char *own_buf
)
553 client_state
&cs
= get_client_state ();
554 if (startswith (own_buf
, "QPassSignals:"))
556 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
557 const char *p
= own_buf
+ strlen ("QPassSignals:");
560 p
= decode_address_to_semicolon (&cursig
, p
);
561 for (i
= 0; i
< numsigs
; i
++)
565 cs
.pass_signals
[i
] = 1;
567 /* Keep looping, to clear the remaining signals. */
570 p
= decode_address_to_semicolon (&cursig
, p
);
573 cs
.pass_signals
[i
] = 0;
575 strcpy (own_buf
, "OK");
579 if (startswith (own_buf
, "QProgramSignals:"))
581 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
582 const char *p
= own_buf
+ strlen ("QProgramSignals:");
585 cs
.program_signals_p
= 1;
587 p
= decode_address_to_semicolon (&cursig
, p
);
588 for (i
= 0; i
< numsigs
; i
++)
592 cs
.program_signals
[i
] = 1;
594 /* Keep looping, to clear the remaining signals. */
597 p
= decode_address_to_semicolon (&cursig
, p
);
600 cs
.program_signals
[i
] = 0;
602 strcpy (own_buf
, "OK");
606 if (startswith (own_buf
, "QCatchSyscalls:"))
608 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
611 struct process_info
*process
;
613 if (!target_running () || !target_supports_catch_syscall ())
619 if (strcmp (p
, "0") == 0)
621 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
625 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
631 process
= current_process ();
632 process
->syscalls_to_catch
.clear ();
642 p
= decode_address_to_semicolon (&sysno
, p
);
643 process
->syscalls_to_catch
.push_back (sysno
);
647 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
654 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
656 our_environ
= gdb_environ::from_host_environ ();
662 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
664 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
665 /* The final form of the environment variable. FINAL_VAR will
666 hold the 'VAR=VALUE' format. */
667 std::string final_var
= hex2str (p
);
668 std::string var_name
, var_value
;
672 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
673 debug_printf (_("[Environment variable to be set: '%s']\n"),
678 size_t pos
= final_var
.find ('=');
679 if (pos
== std::string::npos
)
681 warning (_("Unexpected format for environment variable: '%s'"),
687 var_name
= final_var
.substr (0, pos
);
688 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
690 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
696 if (startswith (own_buf
, "QEnvironmentUnset:"))
698 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
699 std::string varname
= hex2str (p
);
703 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
704 debug_printf (_("[Environment variable to be unset: '%s']\n"),
709 our_environ
.unset (varname
.c_str ());
715 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
719 debug_printf ("[noack mode enabled]\n");
728 if (startswith (own_buf
, "QNonStop:"))
730 char *mode
= own_buf
+ 9;
734 if (strcmp (mode
, "0") == 0)
736 else if (strcmp (mode
, "1") == 0)
740 /* We don't know what this mode is, so complain to
742 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
748 req_str
= req
? "non-stop" : "all-stop";
749 if (start_non_stop (req
) != 0)
751 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
759 debug_printf ("[%s mode enabled]\n", req_str
);
765 if (startswith (own_buf
, "QDisableRandomization:"))
767 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
770 unpack_varlen_hex (packet
, &setting
);
771 cs
.disable_randomization
= setting
;
775 debug_printf (cs
.disable_randomization
776 ? "[address space randomization disabled]\n"
777 : "[address space randomization enabled]\n");
784 if (target_supports_tracepoints ()
785 && handle_tracepoint_general_set (own_buf
))
788 if (startswith (own_buf
, "QAgent:"))
790 char *mode
= own_buf
+ strlen ("QAgent:");
793 if (strcmp (mode
, "0") == 0)
795 else if (strcmp (mode
, "1") == 0)
799 /* We don't know what this value is, so complain to GDB. */
800 sprintf (own_buf
, "E.Unknown QAgent value");
804 /* Update the flag. */
807 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
812 if (handle_btrace_general_set (own_buf
))
815 if (handle_btrace_conf_general_set (own_buf
))
818 if (startswith (own_buf
, "QThreadEvents:"))
820 char *mode
= own_buf
+ strlen ("QThreadEvents:");
821 enum tribool req
= TRIBOOL_UNKNOWN
;
823 if (strcmp (mode
, "0") == 0)
825 else if (strcmp (mode
, "1") == 0)
829 /* We don't know what this mode is, so complain to GDB. */
830 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
835 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
839 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
841 debug_printf ("[thread events are now %s]\n", req_str
);
848 if (startswith (own_buf
, "QStartupWithShell:"))
850 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
852 if (strcmp (value
, "1") == 0)
853 startup_with_shell
= true;
854 else if (strcmp (value
, "0") == 0)
855 startup_with_shell
= false;
859 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
866 debug_printf (_("[Inferior will %s started with shell]"),
867 startup_with_shell
? "be" : "not be");
873 if (startswith (own_buf
, "QSetWorkingDir:"))
875 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
879 std::string path
= hex2str (p
);
881 set_inferior_cwd (path
.c_str ());
884 debug_printf (_("[Set the inferior's current directory to %s]\n"),
889 /* An empty argument means that we should clear out any
890 previously set cwd for the inferior. */
891 set_inferior_cwd (NULL
);
895 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
902 /* Otherwise we didn't know what packet it was. Say we didn't
908 get_features_xml (const char *annex
)
910 const struct target_desc
*desc
= current_target_desc ();
912 /* `desc->xmltarget' defines what to return when looking for the
913 "target.xml" file. Its contents can either be verbatim XML code
914 (prefixed with a '@') or else the name of the actual XML file to
915 be used in place of "target.xml".
917 This variable is set up from the auto-generated
918 init_registers_... routine for the current target. */
920 if (strcmp (annex
, "target.xml") == 0)
922 const char *ret
= tdesc_get_features_xml (desc
);
932 extern const char *const xml_builtin
[][2];
935 /* Look for the annex. */
936 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
937 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
940 if (xml_builtin
[i
][0] != NULL
)
941 return xml_builtin
[i
][1];
949 monitor_show_help (void)
951 monitor_output ("The following monitor commands are supported:\n");
952 monitor_output (" set debug <0|1>\n");
953 monitor_output (" Enable general debugging messages\n");
954 monitor_output (" set debug-hw-points <0|1>\n");
955 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
956 monitor_output (" set remote-debug <0|1>\n");
957 monitor_output (" Enable remote protocol debugging messages\n");
958 monitor_output (" set debug-format option1[,option2,...]\n");
959 monitor_output (" Add additional information to debugging messages\n");
960 monitor_output (" Options: all, none");
961 monitor_output (", timestamp");
962 monitor_output ("\n");
963 monitor_output (" exit\n");
964 monitor_output (" Quit GDBserver\n");
967 /* Read trace frame or inferior memory. Returns the number of bytes
968 actually read, zero when no further transfer is possible, and -1 on
969 error. Return of a positive value smaller than LEN does not
970 indicate there's no more to be read, only the end of the transfer.
971 E.g., when GDB reads memory from a traceframe, a first request may
972 be served from a memory block that does not cover the whole request
973 length. A following request gets the rest served from either
974 another block (of the same traceframe) or from the read-only
978 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
980 client_state
&cs
= get_client_state ();
983 if (cs
.current_traceframe
>= 0)
986 ULONGEST length
= len
;
988 if (traceframe_read_mem (cs
.current_traceframe
,
989 memaddr
, myaddr
, len
, &nbytes
))
991 /* Data read from trace buffer, we're done. */
994 if (!in_readonly_region (memaddr
, length
))
996 /* Otherwise we have a valid readonly case, fall through. */
997 /* (assume no half-trace half-real blocks for now) */
1000 res
= prepare_to_access_memory ();
1003 if (set_desired_thread ())
1004 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1007 done_accessing_memory ();
1009 return res
== 0 ? len
: -1;
1015 /* Write trace frame or inferior memory. Actually, writing to trace
1016 frames is forbidden. */
1019 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1021 client_state
&cs
= get_client_state ();
1022 if (cs
.current_traceframe
>= 0)
1028 ret
= prepare_to_access_memory ();
1031 if (set_desired_thread ())
1032 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
1035 done_accessing_memory ();
1041 /* Subroutine of handle_search_memory to simplify it. */
1044 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1045 gdb_byte
*pattern
, unsigned pattern_len
,
1046 gdb_byte
*search_buf
,
1047 unsigned chunk_size
, unsigned search_buf_size
,
1048 CORE_ADDR
*found_addrp
)
1050 /* Prime the search buffer. */
1052 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1055 warning ("Unable to access %ld bytes of target "
1056 "memory at 0x%lx, halting search.",
1057 (long) search_buf_size
, (long) start_addr
);
1061 /* Perform the search.
1063 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1064 When we've scanned N bytes we copy the trailing bytes to the start and
1065 read in another N bytes. */
1067 while (search_space_len
>= pattern_len
)
1069 gdb_byte
*found_ptr
;
1070 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1074 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1077 if (found_ptr
!= NULL
)
1079 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1080 *found_addrp
= found_addr
;
1084 /* Not found in this chunk, skip to next chunk. */
1086 /* Don't let search_space_len wrap here, it's unsigned. */
1087 if (search_space_len
>= chunk_size
)
1088 search_space_len
-= chunk_size
;
1090 search_space_len
= 0;
1092 if (search_space_len
>= pattern_len
)
1094 unsigned keep_len
= search_buf_size
- chunk_size
;
1095 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1098 /* Copy the trailing part of the previous iteration to the front
1099 of the buffer for the next iteration. */
1100 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1102 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1103 ? search_space_len
- keep_len
1106 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1107 nr_to_read
) != search_buf_size
)
1109 warning ("Unable to access %ld bytes of target memory "
1110 "at 0x%lx, halting search.",
1111 (long) nr_to_read
, (long) read_addr
);
1115 start_addr
+= chunk_size
;
1124 /* Handle qSearch:memory packets. */
1127 handle_search_memory (char *own_buf
, int packet_len
)
1129 CORE_ADDR start_addr
;
1130 CORE_ADDR search_space_len
;
1132 unsigned int pattern_len
;
1133 /* NOTE: also defined in find.c testcase. */
1134 #define SEARCH_CHUNK_SIZE 16000
1135 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1136 /* Buffer to hold memory contents for searching. */
1137 gdb_byte
*search_buf
;
1138 unsigned search_buf_size
;
1140 CORE_ADDR found_addr
;
1141 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1143 pattern
= (gdb_byte
*) malloc (packet_len
);
1144 if (pattern
== NULL
)
1146 error ("Unable to allocate memory to perform the search");
1147 strcpy (own_buf
, "E00");
1150 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1151 packet_len
- cmd_name_len
,
1152 &start_addr
, &search_space_len
,
1153 pattern
, &pattern_len
) < 0)
1156 error ("Error in parsing qSearch:memory packet");
1157 strcpy (own_buf
, "E00");
1161 search_buf_size
= chunk_size
+ pattern_len
- 1;
1163 /* No point in trying to allocate a buffer larger than the search space. */
1164 if (search_space_len
< search_buf_size
)
1165 search_buf_size
= search_space_len
;
1167 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1168 if (search_buf
== NULL
)
1171 error ("Unable to allocate memory to perform the search");
1172 strcpy (own_buf
, "E00");
1176 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1177 pattern
, pattern_len
,
1178 search_buf
, chunk_size
, search_buf_size
,
1182 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1183 else if (found
== 0)
1184 strcpy (own_buf
, "0");
1186 strcpy (own_buf
, "E00");
1192 /* Handle the "D" packet. */
1195 handle_detach (char *own_buf
)
1197 client_state
&cs
= get_client_state ();
1199 process_info
*process
;
1201 if (cs
.multi_process
)
1204 int pid
= strtol (&own_buf
[2], NULL
, 16);
1206 process
= find_process_pid (pid
);
1210 process
= (current_thread
!= nullptr
1211 ? get_thread_process (current_thread
)
1215 if (process
== NULL
)
1217 write_enn (own_buf
);
1221 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1223 if (tracing
&& disconnected_tracing
)
1225 "Disconnected tracing in effect, "
1226 "leaving gdbserver attached to the process\n");
1228 if (any_persistent_commands (process
))
1230 "Persistent commands are present, "
1231 "leaving gdbserver attached to the process\n");
1233 /* Make sure we're in non-stop/async mode, so we we can both
1234 wait for an async socket accept, and handle async target
1235 events simultaneously. There's also no point either in
1236 having the target stop all threads, when we're going to
1237 pass signals down without informing GDB. */
1241 debug_printf ("Forcing non-stop mode\n");
1247 process
->gdb_detached
= 1;
1249 /* Detaching implicitly resumes all threads. */
1250 target_continue_no_signal (minus_one_ptid
);
1256 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1258 if (detach_inferior (process
) != 0)
1259 write_enn (own_buf
);
1262 discard_queued_stop_replies (ptid_t (process
->pid
));
1265 if (extended_protocol
|| target_running ())
1267 /* There is still at least one inferior remaining or
1268 we are in extended mode, so don't terminate gdbserver,
1269 and instead treat this like a normal program exit. */
1270 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1271 cs
.last_status
.value
.integer
= 0;
1272 cs
.last_ptid
= ptid_t (process
->pid
);
1274 current_thread
= NULL
;
1281 /* If we are attached, then we can exit. Otherwise, we
1282 need to hang around doing nothing, until the child is
1284 join_inferior (process
);
1290 /* Parse options to --debug-format= and "monitor set debug-format".
1291 ARG is the text after "--debug-format=" or "monitor set debug-format".
1292 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1293 This triggers calls to monitor_output.
1294 The result is an empty string if all options were parsed ok, otherwise an
1295 error message which the caller must free.
1297 N.B. These commands affect all debug format settings, they are not
1298 cumulative. If a format is not specified, it is turned off.
1299 However, we don't go to extra trouble with things like
1300 "monitor set debug-format all,none,timestamp".
1301 Instead we just parse them one at a time, in order.
1303 The syntax for "monitor set debug" we support here is not identical
1304 to gdb's "set debug foo on|off" because we also use this function to
1305 parse "--debug-format=foo,bar". */
1308 parse_debug_format_options (const char *arg
, int is_monitor
)
1310 /* First turn all debug format options off. */
1311 debug_timestamp
= 0;
1313 /* First remove leading spaces, for "monitor set debug-format". */
1314 while (isspace (*arg
))
1317 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1318 = delim_string_to_char_ptr_vec (arg
, ',');
1320 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1322 if (strcmp (option
.get (), "all") == 0)
1324 debug_timestamp
= 1;
1326 monitor_output ("All extra debug format options enabled.\n");
1328 else if (strcmp (option
.get (), "none") == 0)
1330 debug_timestamp
= 0;
1332 monitor_output ("All extra debug format options disabled.\n");
1334 else if (strcmp (option
.get (), "timestamp") == 0)
1336 debug_timestamp
= 1;
1338 monitor_output ("Timestamps will be added to debug output.\n");
1340 else if (*option
== '\0')
1342 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1346 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1350 return std::string ();
1353 /* Handle monitor commands not handled by target-specific handlers. */
1356 handle_monitor_command (char *mon
, char *own_buf
)
1358 if (strcmp (mon
, "set debug 1") == 0)
1361 monitor_output ("Debug output enabled.\n");
1363 else if (strcmp (mon
, "set debug 0") == 0)
1366 monitor_output ("Debug output disabled.\n");
1368 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1370 show_debug_regs
= 1;
1371 monitor_output ("H/W point debugging output enabled.\n");
1373 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1375 show_debug_regs
= 0;
1376 monitor_output ("H/W point debugging output disabled.\n");
1378 else if (strcmp (mon
, "set remote-debug 1") == 0)
1381 monitor_output ("Protocol debug output enabled.\n");
1383 else if (strcmp (mon
, "set remote-debug 0") == 0)
1386 monitor_output ("Protocol debug output disabled.\n");
1388 else if (startswith (mon
, "set debug-format "))
1390 std::string error_msg
1391 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1394 if (!error_msg
.empty ())
1396 monitor_output (error_msg
.c_str ());
1397 monitor_show_help ();
1398 write_enn (own_buf
);
1401 else if (strcmp (mon
, "help") == 0)
1402 monitor_show_help ();
1403 else if (strcmp (mon
, "exit") == 0)
1407 monitor_output ("Unknown monitor command.\n\n");
1408 monitor_show_help ();
1409 write_enn (own_buf
);
1413 /* Associates a callback with each supported qXfer'able object. */
1417 /* The object this handler handles. */
1420 /* Request that the target transfer up to LEN 8-bit bytes of the
1421 target's OBJECT. The OFFSET, for a seekable object, specifies
1422 the starting point. The ANNEX can be used to provide additional
1423 data-specific information to the target.
1425 Return the number of bytes actually transfered, zero when no
1426 further transfer is possible, -1 on error, -2 when the transfer
1427 is not supported, and -3 on a verbose error message that should
1428 be preserved. Return of a positive value smaller than LEN does
1429 not indicate the end of the object, only the end of the transfer.
1431 One, and only one, of readbuf or writebuf must be non-NULL. */
1432 int (*xfer
) (const char *annex
,
1433 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1434 ULONGEST offset
, LONGEST len
);
1437 /* Handle qXfer:auxv:read. */
1440 handle_qxfer_auxv (const char *annex
,
1441 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1442 ULONGEST offset
, LONGEST len
)
1444 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1447 if (annex
[0] != '\0' || current_thread
== NULL
)
1450 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1453 /* Handle qXfer:exec-file:read. */
1456 handle_qxfer_exec_file (const char *annex
,
1457 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1458 ULONGEST offset
, LONGEST len
)
1464 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1467 if (annex
[0] == '\0')
1469 if (current_thread
== NULL
)
1472 pid
= pid_of (current_thread
);
1476 annex
= unpack_varlen_hex (annex
, &pid
);
1477 if (annex
[0] != '\0')
1484 file
= (*the_target
->pid_to_exec_file
) (pid
);
1488 total_len
= strlen (file
);
1490 if (offset
> total_len
)
1493 if (offset
+ len
> total_len
)
1494 len
= total_len
- offset
;
1496 memcpy (readbuf
, file
+ offset
, len
);
1500 /* Handle qXfer:features:read. */
1503 handle_qxfer_features (const char *annex
,
1504 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1505 ULONGEST offset
, LONGEST len
)
1507 const char *document
;
1510 if (writebuf
!= NULL
)
1513 if (!target_running ())
1516 /* Grab the correct annex. */
1517 document
= get_features_xml (annex
);
1518 if (document
== NULL
)
1521 total_len
= strlen (document
);
1523 if (offset
> total_len
)
1526 if (offset
+ len
> total_len
)
1527 len
= total_len
- offset
;
1529 memcpy (readbuf
, document
+ offset
, len
);
1533 /* Handle qXfer:libraries:read. */
1536 handle_qxfer_libraries (const char *annex
,
1537 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1538 ULONGEST offset
, LONGEST len
)
1540 if (writebuf
!= NULL
)
1543 if (annex
[0] != '\0' || current_thread
== NULL
)
1546 std::string document
= "<library-list version=\"1.0\">\n";
1548 for (const dll_info
&dll
: all_dlls
)
1549 document
+= string_printf
1550 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1551 dll
.name
.c_str (), (long) dll
.base_addr
);
1553 document
+= "</library-list>\n";
1555 if (offset
> document
.length ())
1558 if (offset
+ len
> document
.length ())
1559 len
= document
.length () - offset
;
1561 memcpy (readbuf
, &document
[offset
], len
);
1566 /* Handle qXfer:libraries-svr4:read. */
1569 handle_qxfer_libraries_svr4 (const char *annex
,
1570 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1571 ULONGEST offset
, LONGEST len
)
1573 if (writebuf
!= NULL
)
1576 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1579 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1582 /* Handle qXfer:osadata:read. */
1585 handle_qxfer_osdata (const char *annex
,
1586 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1587 ULONGEST offset
, LONGEST len
)
1589 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1592 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1595 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1598 handle_qxfer_siginfo (const char *annex
,
1599 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1600 ULONGEST offset
, LONGEST len
)
1602 if (the_target
->qxfer_siginfo
== NULL
)
1605 if (annex
[0] != '\0' || current_thread
== NULL
)
1608 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1611 /* Handle qXfer:spu:read and qXfer:spu:write. */
1614 handle_qxfer_spu (const char *annex
,
1615 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1616 ULONGEST offset
, LONGEST len
)
1618 if (the_target
->qxfer_spu
== NULL
)
1621 if (current_thread
== NULL
)
1624 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1627 /* Handle qXfer:statictrace:read. */
1630 handle_qxfer_statictrace (const char *annex
,
1631 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1632 ULONGEST offset
, LONGEST len
)
1634 client_state
&cs
= get_client_state ();
1637 if (writebuf
!= NULL
)
1640 if (annex
[0] != '\0' || current_thread
== NULL
1641 || cs
.current_traceframe
== -1)
1644 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1645 readbuf
, len
, &nbytes
))
1650 /* Helper for handle_qxfer_threads_proper.
1651 Emit the XML to describe the thread of INF. */
1654 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1656 ptid_t ptid
= ptid_of (thread
);
1658 int core
= target_core_of_thread (ptid
);
1660 const char *name
= target_thread_name (ptid
);
1663 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1665 write_ptid (ptid_s
, ptid
);
1667 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1671 sprintf (core_s
, "%d", core
);
1672 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1676 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1680 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1681 bin2hex (handle
, handle_s
, handle_len
);
1682 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1685 buffer_xml_printf (buffer
, "/>\n");
1688 /* Helper for handle_qxfer_threads. */
1691 handle_qxfer_threads_proper (struct buffer
*buffer
)
1693 buffer_grow_str (buffer
, "<threads>\n");
1695 for_each_thread ([&] (thread_info
*thread
)
1697 handle_qxfer_threads_worker (thread
, buffer
);
1700 buffer_grow_str0 (buffer
, "</threads>\n");
1703 /* Handle qXfer:threads:read. */
1706 handle_qxfer_threads (const char *annex
,
1707 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1708 ULONGEST offset
, LONGEST len
)
1710 static char *result
= 0;
1711 static unsigned int result_length
= 0;
1713 if (writebuf
!= NULL
)
1716 if (annex
[0] != '\0')
1721 struct buffer buffer
;
1722 /* When asked for data at offset 0, generate everything and store into
1723 'result'. Successive reads will be served off 'result'. */
1727 buffer_init (&buffer
);
1729 handle_qxfer_threads_proper (&buffer
);
1731 result
= buffer_finish (&buffer
);
1732 result_length
= strlen (result
);
1733 buffer_free (&buffer
);
1736 if (offset
>= result_length
)
1738 /* We're out of data. */
1745 if (len
> result_length
- offset
)
1746 len
= result_length
- offset
;
1748 memcpy (readbuf
, result
+ offset
, len
);
1753 /* Handle qXfer:traceframe-info:read. */
1756 handle_qxfer_traceframe_info (const char *annex
,
1757 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1758 ULONGEST offset
, LONGEST len
)
1760 client_state
&cs
= get_client_state ();
1761 static char *result
= 0;
1762 static unsigned int result_length
= 0;
1764 if (writebuf
!= NULL
)
1767 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1772 struct buffer buffer
;
1774 /* When asked for data at offset 0, generate everything and
1775 store into 'result'. Successive reads will be served off
1779 buffer_init (&buffer
);
1781 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1783 result
= buffer_finish (&buffer
);
1784 result_length
= strlen (result
);
1785 buffer_free (&buffer
);
1788 if (offset
>= result_length
)
1790 /* We're out of data. */
1797 if (len
> result_length
- offset
)
1798 len
= result_length
- offset
;
1800 memcpy (readbuf
, result
+ offset
, len
);
1804 /* Handle qXfer:fdpic:read. */
1807 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1808 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1810 if (the_target
->read_loadmap
== NULL
)
1813 if (current_thread
== NULL
)
1816 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1819 /* Handle qXfer:btrace:read. */
1822 handle_qxfer_btrace (const char *annex
,
1823 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1824 ULONGEST offset
, LONGEST len
)
1826 client_state
&cs
= get_client_state ();
1827 static struct buffer cache
;
1828 struct thread_info
*thread
;
1829 enum btrace_read_type type
;
1832 if (writebuf
!= NULL
)
1835 if (cs
.general_thread
== null_ptid
1836 || cs
.general_thread
== minus_one_ptid
)
1838 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1842 thread
= find_thread_ptid (cs
.general_thread
);
1845 strcpy (cs
.own_buf
, "E.No such thread.");
1849 if (thread
->btrace
== NULL
)
1851 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1855 if (strcmp (annex
, "all") == 0)
1856 type
= BTRACE_READ_ALL
;
1857 else if (strcmp (annex
, "new") == 0)
1858 type
= BTRACE_READ_NEW
;
1859 else if (strcmp (annex
, "delta") == 0)
1860 type
= BTRACE_READ_DELTA
;
1863 strcpy (cs
.own_buf
, "E.Bad annex.");
1869 buffer_free (&cache
);
1873 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1875 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1877 CATCH (exception
, RETURN_MASK_ERROR
)
1879 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1887 else if (offset
> cache
.used_size
)
1889 buffer_free (&cache
);
1893 if (len
> cache
.used_size
- offset
)
1894 len
= cache
.used_size
- offset
;
1896 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1901 /* Handle qXfer:btrace-conf:read. */
1904 handle_qxfer_btrace_conf (const char *annex
,
1905 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1906 ULONGEST offset
, LONGEST len
)
1908 client_state
&cs
= get_client_state ();
1909 static struct buffer cache
;
1910 struct thread_info
*thread
;
1913 if (writebuf
!= NULL
)
1916 if (annex
[0] != '\0')
1919 if (cs
.general_thread
== null_ptid
1920 || cs
.general_thread
== minus_one_ptid
)
1922 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1926 thread
= find_thread_ptid (cs
.general_thread
);
1929 strcpy (cs
.own_buf
, "E.No such thread.");
1933 if (thread
->btrace
== NULL
)
1935 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1941 buffer_free (&cache
);
1945 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1947 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1949 CATCH (exception
, RETURN_MASK_ERROR
)
1951 sprintf (cs
.own_buf
, "E.%s", exception
.message
);
1959 else if (offset
> cache
.used_size
)
1961 buffer_free (&cache
);
1965 if (len
> cache
.used_size
- offset
)
1966 len
= cache
.used_size
- offset
;
1968 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1973 static const struct qxfer qxfer_packets
[] =
1975 { "auxv", handle_qxfer_auxv
},
1976 { "btrace", handle_qxfer_btrace
},
1977 { "btrace-conf", handle_qxfer_btrace_conf
},
1978 { "exec-file", handle_qxfer_exec_file
},
1979 { "fdpic", handle_qxfer_fdpic
},
1980 { "features", handle_qxfer_features
},
1981 { "libraries", handle_qxfer_libraries
},
1982 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1983 { "osdata", handle_qxfer_osdata
},
1984 { "siginfo", handle_qxfer_siginfo
},
1985 { "spu", handle_qxfer_spu
},
1986 { "statictrace", handle_qxfer_statictrace
},
1987 { "threads", handle_qxfer_threads
},
1988 { "traceframe-info", handle_qxfer_traceframe_info
},
1992 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2000 if (!startswith (own_buf
, "qXfer:"))
2003 /* Grab the object, r/w and annex. */
2004 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
2006 write_enn (own_buf
);
2011 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
2014 const struct qxfer
*q
= &qxfer_packets
[i
];
2016 if (strcmp (object
, q
->object
) == 0)
2018 if (strcmp (rw
, "read") == 0)
2020 unsigned char *data
;
2025 /* Grab the offset and length. */
2026 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2028 write_enn (own_buf
);
2032 /* Read one extra byte, as an indicator of whether there is
2034 if (len
> PBUFSIZ
- 2)
2036 data
= (unsigned char *) malloc (len
+ 1);
2039 write_enn (own_buf
);
2042 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2050 /* Preserve error message. */
2053 write_enn (own_buf
);
2055 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2057 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2062 else if (strcmp (rw
, "write") == 0)
2067 unsigned char *data
;
2069 strcpy (own_buf
, "E00");
2070 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2073 write_enn (own_buf
);
2076 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2077 &ofs
, &len
, data
) < 0)
2080 write_enn (own_buf
);
2084 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2092 /* Preserve error message. */
2095 write_enn (own_buf
);
2097 sprintf (own_buf
, "%x", n
);
2110 /* Compute 32 bit CRC from inferior memory.
2112 On success, return 32 bit CRC.
2113 On failure, return (unsigned long long) -1. */
2115 static unsigned long long
2116 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2120 unsigned char byte
= 0;
2122 /* Return failure if memory read fails. */
2123 if (read_inferior_memory (base
, &byte
, 1) != 0)
2124 return (unsigned long long) -1;
2126 crc
= xcrc32 (&byte
, 1, crc
);
2129 return (unsigned long long) crc
;
2132 /* Add supported btrace packets to BUF. */
2135 supported_btrace_packets (char *buf
)
2137 strcat (buf
, ";Qbtrace:bts+");
2138 strcat (buf
, ";Qbtrace-conf:bts:size+");
2139 strcat (buf
, ";Qbtrace:pt+");
2140 strcat (buf
, ";Qbtrace-conf:pt:size+");
2141 strcat (buf
, ";Qbtrace:off+");
2142 strcat (buf
, ";qXfer:btrace:read+");
2143 strcat (buf
, ";qXfer:btrace-conf:read+");
2146 /* Handle all of the extended 'q' packets. */
2149 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2151 client_state
&cs
= get_client_state ();
2152 static std::list
<thread_info
*>::const_iterator thread_iter
;
2154 /* Reply the current thread id. */
2155 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2158 require_running_or_return (own_buf
);
2160 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2161 ptid
= cs
.general_thread
;
2164 thread_iter
= all_threads
.begin ();
2165 ptid
= (*thread_iter
)->id
;
2168 sprintf (own_buf
, "QC");
2170 write_ptid (own_buf
, ptid
);
2174 if (strcmp ("qSymbol::", own_buf
) == 0)
2176 struct thread_info
*save_thread
= current_thread
;
2178 /* For qSymbol, GDB only changes the current thread if the
2179 previous current thread was of a different process. So if
2180 the previous thread is gone, we need to pick another one of
2181 the same process. This can happen e.g., if we followed an
2182 exec in a non-leader thread. */
2183 if (current_thread
== NULL
)
2186 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2188 /* Just in case, if we didn't find a thread, then bail out
2189 instead of crashing. */
2190 if (current_thread
== NULL
)
2192 write_enn (own_buf
);
2193 current_thread
= save_thread
;
2198 /* GDB is suggesting new symbols have been loaded. This may
2199 mean a new shared library has been detected as loaded, so
2200 take the opportunity to check if breakpoints we think are
2201 inserted, still are. Note that it isn't guaranteed that
2202 we'll see this when a shared library is loaded, and nor will
2203 we see this for unloads (although breakpoints in unloaded
2204 libraries shouldn't trigger), as GDB may not find symbols for
2205 the library at all. We also re-validate breakpoints when we
2206 see a second GDB breakpoint for the same address, and or when
2207 we access breakpoint shadows. */
2208 validate_breakpoints ();
2210 if (target_supports_tracepoints ())
2211 tracepoint_look_up_symbols ();
2213 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2214 (*the_target
->look_up_symbols
) ();
2216 current_thread
= save_thread
;
2218 strcpy (own_buf
, "OK");
2222 if (!disable_packet_qfThreadInfo
)
2224 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2226 require_running_or_return (own_buf
);
2227 thread_iter
= all_threads
.begin ();
2230 ptid_t ptid
= (*thread_iter
)->id
;
2231 write_ptid (own_buf
, ptid
);
2236 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2238 require_running_or_return (own_buf
);
2239 if (thread_iter
!= all_threads
.end ())
2242 ptid_t ptid
= (*thread_iter
)->id
;
2243 write_ptid (own_buf
, ptid
);
2249 sprintf (own_buf
, "l");
2255 if (the_target
->read_offsets
!= NULL
2256 && strcmp ("qOffsets", own_buf
) == 0)
2258 CORE_ADDR text
, data
;
2260 require_running_or_return (own_buf
);
2261 if (the_target
->read_offsets (&text
, &data
))
2262 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2263 (long)text
, (long)data
, (long)data
);
2265 write_enn (own_buf
);
2270 /* Protocol features query. */
2271 if (startswith (own_buf
, "qSupported")
2272 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2274 char *p
= &own_buf
[10];
2275 int gdb_supports_qRelocInsn
= 0;
2277 /* Process each feature being provided by GDB. The first
2278 feature will follow a ':', and latter features will follow
2282 char **qsupported
= NULL
;
2287 /* Two passes, to avoid nested strtok calls in
2288 target_process_qsupported. */
2289 for (p
= strtok (p
+ 1, ";");
2291 p
= strtok (NULL
, ";"))
2294 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2295 qsupported
[count
- 1] = xstrdup (p
);
2298 for (i
= 0; i
< count
; i
++)
2301 if (strcmp (p
, "multiprocess+") == 0)
2303 /* GDB supports and wants multi-process support if
2305 if (target_supports_multi_process ())
2306 cs
.multi_process
= 1;
2308 else if (strcmp (p
, "qRelocInsn+") == 0)
2310 /* GDB supports relocate instruction requests. */
2311 gdb_supports_qRelocInsn
= 1;
2313 else if (strcmp (p
, "swbreak+") == 0)
2315 /* GDB wants us to report whether a trap is caused
2316 by a software breakpoint and for us to handle PC
2317 adjustment if necessary on this target. */
2318 if (target_supports_stopped_by_sw_breakpoint ())
2319 cs
.swbreak_feature
= 1;
2321 else if (strcmp (p
, "hwbreak+") == 0)
2323 /* GDB wants us to report whether a trap is caused
2324 by a hardware breakpoint. */
2325 if (target_supports_stopped_by_hw_breakpoint ())
2326 cs
.hwbreak_feature
= 1;
2328 else if (strcmp (p
, "fork-events+") == 0)
2330 /* GDB supports and wants fork events if possible. */
2331 if (target_supports_fork_events ())
2332 cs
.report_fork_events
= 1;
2334 else if (strcmp (p
, "vfork-events+") == 0)
2336 /* GDB supports and wants vfork events if possible. */
2337 if (target_supports_vfork_events ())
2338 cs
.report_vfork_events
= 1;
2340 else if (strcmp (p
, "exec-events+") == 0)
2342 /* GDB supports and wants exec events if possible. */
2343 if (target_supports_exec_events ())
2344 cs
.report_exec_events
= 1;
2346 else if (strcmp (p
, "vContSupported+") == 0)
2347 cs
.vCont_supported
= 1;
2348 else if (strcmp (p
, "QThreadEvents+") == 0)
2350 else if (strcmp (p
, "no-resumed+") == 0)
2352 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2354 report_no_resumed
= 1;
2358 /* Move the unknown features all together. */
2359 qsupported
[i
] = NULL
;
2360 qsupported
[unknown
] = p
;
2365 /* Give the target backend a chance to process the unknown
2367 target_process_qsupported (qsupported
, unknown
);
2369 for (i
= 0; i
< count
; i
++)
2370 free (qsupported
[i
]);
2375 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2376 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2377 "QEnvironmentReset+;QEnvironmentUnset+;"
2381 if (target_supports_catch_syscall ())
2382 strcat (own_buf
, ";QCatchSyscalls+");
2384 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2385 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2386 ";augmented-libraries-svr4-read+");
2389 /* We do not have any hook to indicate whether the non-SVR4 target
2390 backend supports qXfer:libraries:read, so always report it. */
2391 strcat (own_buf
, ";qXfer:libraries:read+");
2394 if (the_target
->read_auxv
!= NULL
)
2395 strcat (own_buf
, ";qXfer:auxv:read+");
2397 if (the_target
->qxfer_spu
!= NULL
)
2398 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2400 if (the_target
->qxfer_siginfo
!= NULL
)
2401 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2403 if (the_target
->read_loadmap
!= NULL
)
2404 strcat (own_buf
, ";qXfer:fdpic:read+");
2406 /* We always report qXfer:features:read, as targets may
2407 install XML files on a subsequent call to arch_setup.
2408 If we reported to GDB on startup that we don't support
2409 qXfer:feature:read at all, we will never be re-queried. */
2410 strcat (own_buf
, ";qXfer:features:read+");
2412 if (cs
.transport_is_reliable
)
2413 strcat (own_buf
, ";QStartNoAckMode+");
2415 if (the_target
->qxfer_osdata
!= NULL
)
2416 strcat (own_buf
, ";qXfer:osdata:read+");
2418 if (target_supports_multi_process ())
2419 strcat (own_buf
, ";multiprocess+");
2421 if (target_supports_fork_events ())
2422 strcat (own_buf
, ";fork-events+");
2424 if (target_supports_vfork_events ())
2425 strcat (own_buf
, ";vfork-events+");
2427 if (target_supports_exec_events ())
2428 strcat (own_buf
, ";exec-events+");
2430 if (target_supports_non_stop ())
2431 strcat (own_buf
, ";QNonStop+");
2433 if (target_supports_disable_randomization ())
2434 strcat (own_buf
, ";QDisableRandomization+");
2436 strcat (own_buf
, ";qXfer:threads:read+");
2438 if (target_supports_tracepoints ())
2440 strcat (own_buf
, ";ConditionalTracepoints+");
2441 strcat (own_buf
, ";TraceStateVariables+");
2442 strcat (own_buf
, ";TracepointSource+");
2443 strcat (own_buf
, ";DisconnectedTracing+");
2444 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2445 strcat (own_buf
, ";FastTracepoints+");
2446 strcat (own_buf
, ";StaticTracepoints+");
2447 strcat (own_buf
, ";InstallInTrace+");
2448 strcat (own_buf
, ";qXfer:statictrace:read+");
2449 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2450 strcat (own_buf
, ";EnableDisableTracepoints+");
2451 strcat (own_buf
, ";QTBuffer:size+");
2452 strcat (own_buf
, ";tracenz+");
2455 if (target_supports_hardware_single_step ()
2456 || target_supports_software_single_step () )
2458 strcat (own_buf
, ";ConditionalBreakpoints+");
2460 strcat (own_buf
, ";BreakpointCommands+");
2462 if (target_supports_agent ())
2463 strcat (own_buf
, ";QAgent+");
2465 supported_btrace_packets (own_buf
);
2467 if (target_supports_stopped_by_sw_breakpoint ())
2468 strcat (own_buf
, ";swbreak+");
2470 if (target_supports_stopped_by_hw_breakpoint ())
2471 strcat (own_buf
, ";hwbreak+");
2473 if (the_target
->pid_to_exec_file
!= NULL
)
2474 strcat (own_buf
, ";qXfer:exec-file:read+");
2476 strcat (own_buf
, ";vContSupported+");
2478 strcat (own_buf
, ";QThreadEvents+");
2480 strcat (own_buf
, ";no-resumed+");
2482 /* Reinitialize components as needed for the new connection. */
2483 hostio_handle_new_gdb_connection ();
2484 target_handle_new_gdb_connection ();
2489 /* Thread-local storage support. */
2490 if (the_target
->get_tls_address
!= NULL
2491 && startswith (own_buf
, "qGetTLSAddr:"))
2493 char *p
= own_buf
+ 12;
2494 CORE_ADDR parts
[2], address
= 0;
2496 ptid_t ptid
= null_ptid
;
2498 require_running_or_return (own_buf
);
2500 for (i
= 0; i
< 3; i
++)
2508 p2
= strchr (p
, ',');
2521 ptid
= read_ptid (p
, NULL
);
2523 decode_address (&parts
[i
- 1], p
, len
);
2527 if (p
!= NULL
|| i
< 3)
2531 struct thread_info
*thread
= find_thread_ptid (ptid
);
2536 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2542 strcpy (own_buf
, paddress(address
));
2547 write_enn (own_buf
);
2551 /* Otherwise, pretend we do not understand this packet. */
2554 /* Windows OS Thread Information Block address support. */
2555 if (the_target
->get_tib_address
!= NULL
2556 && startswith (own_buf
, "qGetTIBAddr:"))
2561 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2563 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2566 strcpy (own_buf
, paddress(tlb
));
2571 write_enn (own_buf
);
2577 /* Handle "monitor" commands. */
2578 if (startswith (own_buf
, "qRcmd,"))
2580 char *mon
= (char *) malloc (PBUFSIZ
);
2581 int len
= strlen (own_buf
+ 6);
2585 write_enn (own_buf
);
2590 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2592 write_enn (own_buf
);
2596 mon
[len
/ 2] = '\0';
2600 if (the_target
->handle_monitor_command
== NULL
2601 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2602 /* Default processing. */
2603 handle_monitor_command (mon
, own_buf
);
2609 if (startswith (own_buf
, "qSearch:memory:"))
2611 require_running_or_return (own_buf
);
2612 handle_search_memory (own_buf
, packet_len
);
2616 if (strcmp (own_buf
, "qAttached") == 0
2617 || startswith (own_buf
, "qAttached:"))
2619 struct process_info
*process
;
2621 if (own_buf
[sizeof ("qAttached") - 1])
2623 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2624 process
= find_process_pid (pid
);
2628 require_running_or_return (own_buf
);
2629 process
= current_process ();
2632 if (process
== NULL
)
2634 write_enn (own_buf
);
2638 strcpy (own_buf
, process
->attached
? "1" : "0");
2642 if (startswith (own_buf
, "qCRC:"))
2644 /* CRC check (compare-section). */
2648 unsigned long long crc
;
2650 require_running_or_return (own_buf
);
2651 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2652 if (*comma
++ != ',')
2654 write_enn (own_buf
);
2657 len
= strtoul (comma
, NULL
, 16);
2658 crc
= crc32 (base
, len
, 0xffffffff);
2659 /* Check for memory failure. */
2660 if (crc
== (unsigned long long) -1)
2662 write_enn (own_buf
);
2665 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2669 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2672 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2675 /* Otherwise we didn't know what packet it was. Say we didn't
2680 static void gdb_wants_all_threads_stopped (void);
2681 static void resume (struct thread_resume
*actions
, size_t n
);
2683 /* The callback that is passed to visit_actioned_threads. */
2684 typedef int (visit_actioned_threads_callback_ftype
)
2685 (const struct thread_resume
*, struct thread_info
*);
2687 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2688 true if CALLBACK returns true. Returns false if no matching thread
2689 is found or CALLBACK results false.
2690 Note: This function is itself a callback for find_thread. */
2693 visit_actioned_threads (thread_info
*thread
,
2694 const struct thread_resume
*actions
,
2696 visit_actioned_threads_callback_ftype
*callback
)
2698 for (size_t i
= 0; i
< num_actions
; i
++)
2700 const struct thread_resume
*action
= &actions
[i
];
2702 if (action
->thread
== minus_one_ptid
2703 || action
->thread
== thread
->id
2704 || ((action
->thread
.pid ()
2705 == thread
->id
.pid ())
2706 && action
->thread
.lwp () == -1))
2708 if ((*callback
) (action
, thread
))
2716 /* Callback for visit_actioned_threads. If the thread has a pending
2717 status to report, report it now. */
2720 handle_pending_status (const struct thread_resume
*resumption
,
2721 struct thread_info
*thread
)
2723 client_state
&cs
= get_client_state ();
2724 if (thread
->status_pending_p
)
2726 thread
->status_pending_p
= 0;
2728 cs
.last_status
= thread
->last_status
;
2729 cs
.last_ptid
= thread
->id
;
2730 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2736 /* Parse vCont packets. */
2738 handle_v_cont (char *own_buf
)
2742 struct thread_resume
*resume_info
;
2743 struct thread_resume default_action
{ null_ptid
};
2745 /* Count the number of semicolons in the packet. There should be one
2746 for every action. */
2752 p
= strchr (p
, ';');
2755 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2756 if (resume_info
== NULL
)
2764 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2766 if (p
[0] == 's' || p
[0] == 'S')
2767 resume_info
[i
].kind
= resume_step
;
2768 else if (p
[0] == 'r')
2769 resume_info
[i
].kind
= resume_step
;
2770 else if (p
[0] == 'c' || p
[0] == 'C')
2771 resume_info
[i
].kind
= resume_continue
;
2772 else if (p
[0] == 't')
2773 resume_info
[i
].kind
= resume_stop
;
2777 if (p
[0] == 'S' || p
[0] == 'C')
2780 int sig
= strtol (p
+ 1, &q
, 16);
2785 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2787 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2789 else if (p
[0] == 'r')
2793 p
= unpack_varlen_hex (p
+ 1, &addr
);
2794 resume_info
[i
].step_range_start
= addr
;
2799 p
= unpack_varlen_hex (p
+ 1, &addr
);
2800 resume_info
[i
].step_range_end
= addr
;
2809 resume_info
[i
].thread
= minus_one_ptid
;
2810 default_action
= resume_info
[i
];
2812 /* Note: we don't increment i here, we'll overwrite this entry
2813 the next time through. */
2815 else if (p
[0] == ':')
2818 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2823 if (p
[0] != ';' && p
[0] != 0)
2826 resume_info
[i
].thread
= ptid
;
2833 resume_info
[i
] = default_action
;
2835 resume (resume_info
, n
);
2840 write_enn (own_buf
);
2845 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2848 resume (struct thread_resume
*actions
, size_t num_actions
)
2850 client_state
&cs
= get_client_state ();
2853 /* Check if among the threads that GDB wants actioned, there's
2854 one with a pending status to report. If so, skip actually
2855 resuming/stopping and report the pending event
2858 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2860 return visit_actioned_threads (thread
, actions
, num_actions
,
2861 handle_pending_status
);
2864 if (thread_with_status
!= NULL
)
2870 (*the_target
->resume
) (actions
, num_actions
);
2873 write_ok (cs
.own_buf
);
2876 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2878 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2879 && !report_no_resumed
)
2881 /* The client does not support this stop reply. At least
2883 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2884 disable_async_io ();
2888 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2889 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2890 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2891 current_thread
->last_status
= cs
.last_status
;
2893 /* From the client's perspective, all-stop mode always stops all
2894 threads implicitly (and the target backend has already done
2895 so by now). Tag all threads as "want-stopped", so we don't
2896 resume them implicitly without the client telling us to. */
2897 gdb_wants_all_threads_stopped ();
2898 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2899 disable_async_io ();
2901 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2902 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2903 target_mourn_inferior (cs
.last_ptid
);
2907 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2909 handle_v_attach (char *own_buf
)
2911 client_state
&cs
= get_client_state ();
2914 pid
= strtol (own_buf
+ 8, NULL
, 16);
2915 if (pid
!= 0 && attach_inferior (pid
) == 0)
2917 /* Don't report shared library events after attaching, even if
2918 some libraries are preloaded. GDB will always poll the
2919 library list. Avoids the "stopped by shared library event"
2920 notice on the GDB side. */
2925 /* In non-stop, we don't send a resume reply. Stop events
2926 will follow up using the normal notification
2931 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2937 write_enn (own_buf
);
2942 /* Run a new program. Return 1 if successful, 0 if failure. */
2944 handle_v_run (char *own_buf
)
2946 client_state
&cs
= get_client_state ();
2948 std::vector
<char *> new_argv
;
2949 char *new_program_name
= NULL
;
2953 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2959 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2961 next_p
= strchr (p
, ';');
2963 next_p
= p
+ strlen (p
);
2965 if (i
== 0 && p
== next_p
)
2967 /* No program specified. */
2968 new_program_name
= NULL
;
2970 else if (p
== next_p
)
2972 /* Empty argument. */
2973 new_argv
.push_back (xstrdup ("''"));
2977 size_t len
= (next_p
- p
) / 2;
2978 /* ARG is the unquoted argument received via the RSP. */
2979 char *arg
= (char *) xmalloc (len
+ 1);
2980 /* FULL_ARGS will contain the quoted version of ARG. */
2981 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2982 /* These are pointers used to navigate the strings above. */
2983 char *tmp_arg
= arg
;
2984 char *tmp_full_arg
= full_arg
;
2987 hex2bin (p
, (gdb_byte
*) arg
, len
);
2990 while (*tmp_arg
!= '\0')
2996 *tmp_full_arg
= '\'';
3002 /* Quote single quote. */
3003 *tmp_full_arg
= '\\';
3011 *tmp_full_arg
= *tmp_arg
;
3017 *tmp_full_arg
++ = '\'';
3019 /* Finish FULL_ARG and push it into the vector containing
3021 *tmp_full_arg
= '\0';
3023 new_program_name
= full_arg
;
3025 new_argv
.push_back (full_arg
);
3031 new_argv
.push_back (NULL
);
3033 if (new_program_name
== NULL
)
3035 /* GDB didn't specify a program to run. Use the program from the
3036 last run with the new argument list. */
3037 if (program_path
.get () == NULL
)
3039 write_enn (own_buf
);
3040 free_vector_argv (new_argv
);
3045 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3047 /* Free the old argv and install the new one. */
3048 free_vector_argv (program_args
);
3049 program_args
= new_argv
;
3051 create_inferior (program_path
.get (), program_args
);
3053 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3055 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3057 /* In non-stop, sending a resume reply doesn't set the general
3058 thread, but GDB assumes a vRun sets it (this is so GDB can
3059 query which is the main thread of the new inferior. */
3061 cs
.general_thread
= cs
.last_ptid
;
3067 write_enn (own_buf
);
3072 /* Kill process. Return 1 if successful, 0 if failure. */
3074 handle_v_kill (char *own_buf
)
3076 client_state
&cs
= get_client_state ();
3078 char *p
= &own_buf
[6];
3079 if (cs
.multi_process
)
3080 pid
= strtol (p
, NULL
, 16);
3084 process_info
*proc
= find_process_pid (pid
);
3086 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3088 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3089 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3090 cs
.last_ptid
= ptid_t (pid
);
3091 discard_queued_stop_replies (cs
.last_ptid
);
3097 write_enn (own_buf
);
3102 /* Handle all of the extended 'v' packets. */
3104 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3106 client_state
&cs
= get_client_state ();
3107 if (!disable_packet_vCont
)
3109 if (strcmp (own_buf
, "vCtrlC") == 0)
3111 (*the_target
->request_interrupt
) ();
3116 if (startswith (own_buf
, "vCont;"))
3118 handle_v_cont (own_buf
);
3122 if (startswith (own_buf
, "vCont?"))
3124 strcpy (own_buf
, "vCont;c;C;t");
3126 if (target_supports_hardware_single_step ()
3127 || target_supports_software_single_step ()
3128 || !cs
.vCont_supported
)
3130 /* If target supports single step either by hardware or by
3131 software, add actions s and S to the list of supported
3132 actions. On the other hand, if GDB doesn't request the
3133 supported vCont actions in qSupported packet, add s and
3134 S to the list too. */
3135 own_buf
= own_buf
+ strlen (own_buf
);
3136 strcpy (own_buf
, ";s;S");
3139 if (target_supports_range_stepping ())
3141 own_buf
= own_buf
+ strlen (own_buf
);
3142 strcpy (own_buf
, ";r");
3148 if (startswith (own_buf
, "vFile:")
3149 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3152 if (startswith (own_buf
, "vAttach;"))
3154 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3156 fprintf (stderr
, "Already debugging a process\n");
3157 write_enn (own_buf
);
3160 handle_v_attach (own_buf
);
3164 if (startswith (own_buf
, "vRun;"))
3166 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3168 fprintf (stderr
, "Already debugging a process\n");
3169 write_enn (own_buf
);
3172 handle_v_run (own_buf
);
3176 if (startswith (own_buf
, "vKill;"))
3178 if (!target_running ())
3180 fprintf (stderr
, "No process to kill\n");
3181 write_enn (own_buf
);
3184 handle_v_kill (own_buf
);
3188 if (handle_notif_ack (own_buf
, packet_len
))
3191 /* Otherwise we didn't know what packet it was. Say we didn't
3197 /* Resume thread and wait for another event. In non-stop mode,
3198 don't really wait here, but return immediatelly to the event
3201 myresume (char *own_buf
, int step
, int sig
)
3203 client_state
&cs
= get_client_state ();
3204 struct thread_resume resume_info
[2];
3206 int valid_cont_thread
;
3208 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3209 && cs
.cont_thread
!= minus_one_ptid
);
3211 if (step
|| sig
|| valid_cont_thread
)
3213 resume_info
[0].thread
= current_ptid
;
3215 resume_info
[0].kind
= resume_step
;
3217 resume_info
[0].kind
= resume_continue
;
3218 resume_info
[0].sig
= sig
;
3222 if (!valid_cont_thread
)
3224 resume_info
[n
].thread
= minus_one_ptid
;
3225 resume_info
[n
].kind
= resume_continue
;
3226 resume_info
[n
].sig
= 0;
3230 resume (resume_info
, n
);
3233 /* Callback for for_each_thread. Make a new stop reply for each
3237 queue_stop_reply_callback (thread_info
*thread
)
3239 /* For now, assume targets that don't have this callback also don't
3240 manage the thread's last_status field. */
3241 if (the_target
->thread_stopped
== NULL
)
3243 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3245 new_notif
->ptid
= thread
->id
;
3246 new_notif
->status
= thread
->last_status
;
3247 /* Pass the last stop reply back to GDB, but don't notify
3249 notif_event_enque (¬if_stop
,
3250 (struct notif_event
*) new_notif
);
3254 if (thread_stopped (thread
))
3258 std::string status_string
3259 = target_waitstatus_to_string (&thread
->last_status
);
3261 debug_printf ("Reporting thread %s as already stopped with %s\n",
3262 target_pid_to_str (thread
->id
),
3263 status_string
.c_str ());
3266 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3268 /* Pass the last stop reply back to GDB, but don't notify
3270 queue_stop_reply (thread
->id
, &thread
->last_status
);
3275 /* Set this inferior threads's state as "want-stopped". We won't
3276 resume this thread until the client gives us another action for
3280 gdb_wants_thread_stopped (thread_info
*thread
)
3282 thread
->last_resume_kind
= resume_stop
;
3284 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3286 /* Most threads are stopped implicitly (all-stop); tag that with
3288 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3289 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3293 /* Set all threads' states as "want-stopped". */
3296 gdb_wants_all_threads_stopped (void)
3298 for_each_thread (gdb_wants_thread_stopped
);
3301 /* Callback for for_each_thread. If the thread is stopped with an
3302 interesting event, mark it as having a pending event. */
3305 set_pending_status_callback (thread_info
*thread
)
3307 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3308 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3309 /* A breakpoint, watchpoint or finished step from a previous
3310 GDB run isn't considered interesting for a new GDB run.
3311 If we left those pending, the new GDB could consider them
3312 random SIGTRAPs. This leaves out real async traps. We'd
3313 have to peek into the (target-specific) siginfo to
3314 distinguish those. */
3315 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3316 thread
->status_pending_p
= 1;
3319 /* Status handler for the '?' packet. */
3322 handle_status (char *own_buf
)
3324 client_state
&cs
= get_client_state ();
3326 /* GDB is connected, don't forward events to the target anymore. */
3327 for_each_process ([] (process_info
*process
) {
3328 process
->gdb_detached
= 0;
3331 /* In non-stop mode, we must send a stop reply for each stopped
3332 thread. In all-stop mode, just send one for the first stopped
3337 for_each_thread (queue_stop_reply_callback
);
3339 /* The first is sent immediatly. OK is sent if there is no
3340 stopped thread, which is the same handling of the vStopped
3341 packet (by design). */
3342 notif_write_event (¬if_stop
, cs
.own_buf
);
3346 thread_info
*thread
= NULL
;
3349 stabilize_threads ();
3350 gdb_wants_all_threads_stopped ();
3352 /* We can only report one status, but we might be coming out of
3353 non-stop -- if more than one thread is stopped with
3354 interesting events, leave events for the threads we're not
3355 reporting now pending. They'll be reported the next time the
3356 threads are resumed. Start by marking all interesting events
3358 for_each_thread (set_pending_status_callback
);
3360 /* Prefer the last thread that reported an event to GDB (even if
3361 that was a GDB_SIGNAL_TRAP). */
3362 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3363 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3364 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3365 thread
= find_thread_ptid (cs
.last_ptid
);
3367 /* If the last event thread is not found for some reason, look
3368 for some other thread that might have an event to report. */
3370 thread
= find_thread ([] (thread_info
*thr_arg
)
3372 return thr_arg
->status_pending_p
;
3375 /* If we're still out of luck, simply pick the first thread in
3378 thread
= get_first_thread ();
3382 struct thread_info
*tp
= (struct thread_info
*) thread
;
3384 /* We're reporting this event, so it's no longer
3386 tp
->status_pending_p
= 0;
3388 /* GDB assumes the current thread is the thread we're
3389 reporting the status for. */
3390 cs
.general_thread
= thread
->id
;
3391 set_desired_thread ();
3393 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3394 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3397 strcpy (own_buf
, "W00");
3402 gdbserver_version (void)
3404 printf ("GNU gdbserver %s%s\n"
3405 "Copyright (C) 2018 Free Software Foundation, Inc.\n"
3406 "gdbserver is free software, covered by the "
3407 "GNU General Public License.\n"
3408 "This gdbserver was configured as \"%s\"\n",
3409 PKGVERSION
, version
, host_name
);
3413 gdbserver_usage (FILE *stream
)
3415 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3416 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3417 "\tgdbserver [OPTIONS] --multi COMM\n"
3419 "COMM may either be a tty device (for serial debugging),\n"
3420 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3421 "stdin/stdout of gdbserver.\n"
3422 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3423 "PID is the process ID to attach to, when --attach is specified.\n"
3425 "Operating modes:\n"
3427 " --attach Attach to running process PID.\n"
3428 " --multi Start server without a specific program, and\n"
3429 " only quit when explicitly commanded.\n"
3430 " --once Exit after the first connection has closed.\n"
3431 " --help Print this message and then exit.\n"
3432 " --version Display version information and exit.\n"
3436 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3437 " --disable-randomization\n"
3438 " Run PROG with address space randomization disabled.\n"
3439 " --no-disable-randomization\n"
3440 " Don't disable address space randomization when\n"
3442 " --startup-with-shell\n"
3443 " Start PROG using a shell. I.e., execs a shell that\n"
3444 " then execs PROG. (default)\n"
3445 " --no-startup-with-shell\n"
3446 " Exec PROG directly instead of using a shell.\n"
3447 " Disables argument globbing and variable substitution\n"
3448 " on UNIX-like systems.\n"
3452 " --debug Enable general debugging output.\n"
3453 " --debug-format=opt1[,opt2,...]\n"
3454 " Specify extra content in debugging output.\n"
3459 " --remote-debug Enable remote protocol debugging output.\n"
3460 " --disable-packet=opt1[,opt2,...]\n"
3461 " Disable support for RSP packets or features.\n"
3463 " vCont, Tthread, qC, qfThreadInfo and \n"
3464 " threads (disable all threading packets).\n"
3466 "For more information, consult the GDB manual (available as on-line \n"
3467 "info or a printed manual).\n");
3468 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3469 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3473 gdbserver_show_disableable (FILE *stream
)
3475 fprintf (stream
, "Disableable packets:\n"
3476 " vCont \tAll vCont packets\n"
3477 " qC \tQuerying the current thread\n"
3478 " qfThreadInfo\tThread listing\n"
3479 " Tthread \tPassing the thread specifier in the "
3480 "T stop reply packet\n"
3481 " threads \tAll of the above\n");
3485 kill_inferior_callback (process_info
*process
)
3487 kill_inferior (process
);
3488 discard_queued_stop_replies (ptid_t (process
->pid
));
3491 /* Call this when exiting gdbserver with possible inferiors that need
3492 to be killed or detached from. */
3495 detach_or_kill_for_exit (void)
3497 /* First print a list of the inferiors we will be killing/detaching.
3498 This is to assist the user, for example, in case the inferior unexpectedly
3499 dies after we exit: did we screw up or did the inferior exit on its own?
3500 Having this info will save some head-scratching. */
3502 if (have_started_inferiors_p ())
3504 fprintf (stderr
, "Killing process(es):");
3506 for_each_process ([] (process_info
*process
) {
3507 if (!process
->attached
)
3508 fprintf (stderr
, " %d", process
->pid
);
3511 fprintf (stderr
, "\n");
3513 if (have_attached_inferiors_p ())
3515 fprintf (stderr
, "Detaching process(es):");
3517 for_each_process ([] (process_info
*process
) {
3518 if (process
->attached
)
3519 fprintf (stderr
, " %d", process
->pid
);
3522 fprintf (stderr
, "\n");
3525 /* Now we can kill or detach the inferiors. */
3526 for_each_process ([] (process_info
*process
) {
3527 int pid
= process
->pid
;
3529 if (process
->attached
)
3530 detach_inferior (process
);
3532 kill_inferior (process
);
3534 discard_queued_stop_replies (ptid_t (pid
));
3538 /* Value that will be passed to exit(3) when gdbserver exits. */
3539 static int exit_code
;
3541 /* Cleanup version of detach_or_kill_for_exit. */
3544 detach_or_kill_for_exit_cleanup (void *ignore
)
3549 detach_or_kill_for_exit ();
3552 CATCH (exception
, RETURN_MASK_ALL
)
3555 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3561 /* Main function. This is called by the real "main" function,
3562 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3564 static void ATTRIBUTE_NORETURN
3565 captured_main (int argc
, char *argv
[])
3570 const char *port
= NULL
;
3571 char **next_arg
= &argv
[1];
3572 volatile int multi_mode
= 0;
3573 volatile int attach
= 0;
3575 bool selftest
= false;
3577 const char *selftest_filter
= NULL
;
3580 current_directory
= getcwd (NULL
, 0);
3581 client_state
&cs
= get_client_state ();
3583 if (current_directory
== NULL
)
3585 error (_("Could not find current working directory: %s"),
3586 safe_strerror (errno
));
3589 while (*next_arg
!= NULL
&& **next_arg
== '-')
3591 if (strcmp (*next_arg
, "--version") == 0)
3593 gdbserver_version ();
3596 else if (strcmp (*next_arg
, "--help") == 0)
3598 gdbserver_usage (stdout
);
3601 else if (strcmp (*next_arg
, "--attach") == 0)
3603 else if (strcmp (*next_arg
, "--multi") == 0)
3605 else if (strcmp (*next_arg
, "--wrapper") == 0)
3612 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3614 wrapper_argv
+= *next_arg
;
3615 wrapper_argv
+= ' ';
3619 if (!wrapper_argv
.empty ())
3621 /* Erase the last whitespace. */
3622 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3625 if (next_arg
== tmp
|| *next_arg
== NULL
)
3627 gdbserver_usage (stderr
);
3631 /* Consume the "--". */
3634 else if (strcmp (*next_arg
, "--debug") == 0)
3636 else if (startswith (*next_arg
, "--debug-format="))
3638 std::string error_msg
3639 = parse_debug_format_options ((*next_arg
)
3640 + sizeof ("--debug-format=") - 1, 0);
3642 if (!error_msg
.empty ())
3644 fprintf (stderr
, "%s", error_msg
.c_str ());
3648 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3650 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3652 gdbserver_show_disableable (stdout
);
3655 else if (startswith (*next_arg
, "--disable-packet="))
3657 char *packets
, *tok
;
3659 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3660 for (tok
= strtok (packets
, ",");
3662 tok
= strtok (NULL
, ","))
3664 if (strcmp ("vCont", tok
) == 0)
3665 disable_packet_vCont
= 1;
3666 else if (strcmp ("Tthread", tok
) == 0)
3667 disable_packet_Tthread
= 1;
3668 else if (strcmp ("qC", tok
) == 0)
3669 disable_packet_qC
= 1;
3670 else if (strcmp ("qfThreadInfo", tok
) == 0)
3671 disable_packet_qfThreadInfo
= 1;
3672 else if (strcmp ("threads", tok
) == 0)
3674 disable_packet_vCont
= 1;
3675 disable_packet_Tthread
= 1;
3676 disable_packet_qC
= 1;
3677 disable_packet_qfThreadInfo
= 1;
3681 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3683 gdbserver_show_disableable (stderr
);
3688 else if (strcmp (*next_arg
, "-") == 0)
3690 /* "-" specifies a stdio connection and is a form of port
3692 port
= STDIO_CONNECTION_NAME
;
3696 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3697 cs
.disable_randomization
= 1;
3698 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3699 cs
.disable_randomization
= 0;
3700 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3701 startup_with_shell
= true;
3702 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3703 startup_with_shell
= false;
3704 else if (strcmp (*next_arg
, "--once") == 0)
3706 else if (strcmp (*next_arg
, "--selftest") == 0)
3708 else if (startswith (*next_arg
, "--selftest="))
3712 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3717 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3730 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3733 gdbserver_usage (stderr
);
3737 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3738 opened by remote_prepare. */
3741 save_original_signals_state (false);
3743 /* We need to know whether the remote connection is stdio before
3744 starting the inferior. Inferiors created in this scenario have
3745 stdin,stdout redirected. So do this here before we call
3748 remote_prepare (port
);
3753 /* --attach used to come after PORT, so allow it there for
3755 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3762 && (*next_arg
== NULL
3763 || (*next_arg
)[0] == '\0'
3764 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3766 || next_arg
[1] != NULL
))
3771 gdbserver_usage (stderr
);
3775 /* Gather information about the environment. */
3776 our_environ
= gdb_environ::from_host_environ ();
3778 initialize_async_io ();
3780 have_job_control ();
3781 initialize_event_loop ();
3782 if (target_supports_tracepoints ())
3783 initialize_tracepoint ();
3784 initialize_notif ();
3786 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3791 selftests::run_tests (selftest_filter
);
3793 printf (_("Selftests have been disabled for this build.\n"));
3795 throw_quit ("Quit");
3798 if (pid
== 0 && *next_arg
!= NULL
)
3802 n
= argc
- (next_arg
- argv
);
3803 program_path
.set (gdb::unique_xmalloc_ptr
<char> (xstrdup (next_arg
[0])));
3804 for (i
= 1; i
< n
; i
++)
3805 program_args
.push_back (xstrdup (next_arg
[i
]));
3806 program_args
.push_back (NULL
);
3808 /* Wait till we are at first instruction in program. */
3809 create_inferior (program_path
.get (), program_args
);
3811 /* We are now (hopefully) stopped at the first instruction of
3812 the target process. This assumes that the target process was
3813 successfully created. */
3817 if (attach_inferior (pid
) == -1)
3818 error ("Attaching not supported on this target");
3820 /* Otherwise succeeded. */
3824 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3825 cs
.last_status
.value
.integer
= 0;
3826 cs
.last_ptid
= minus_one_ptid
;
3828 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3830 /* Don't report shared library events on the initial connection,
3831 even if some libraries are preloaded. Avoids the "stopped by
3832 shared library event" notice on gdb side. */
3835 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3836 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3841 if (!was_running
&& !multi_mode
)
3842 error ("No program to debug");
3847 cs
.multi_process
= 0;
3848 cs
.report_fork_events
= 0;
3849 cs
.report_vfork_events
= 0;
3850 cs
.report_exec_events
= 0;
3851 /* Be sure we're out of tfind mode. */
3852 cs
.current_traceframe
= -1;
3853 cs
.cont_thread
= null_ptid
;
3854 cs
.swbreak_feature
= 0;
3855 cs
.hwbreak_feature
= 0;
3856 cs
.vCont_supported
= 0;
3862 /* Wait for events. This will return when all event sources
3863 are removed from the event loop. */
3864 start_event_loop ();
3866 /* If an exit was requested (using the "monitor exit"
3867 command), terminate now. */
3869 throw_quit ("Quit");
3871 /* The only other way to get here is for getpkt to fail:
3873 - If --once was specified, we're done.
3875 - If not in extended-remote mode, and we're no longer
3876 debugging anything, simply exit: GDB has disconnected
3877 after processing the last process exit.
3879 - Otherwise, close the connection and reopen it at the
3881 if (run_once
|| (!extended_protocol
&& !target_running ()))
3882 throw_quit ("Quit");
3885 "Remote side has terminated connection. "
3886 "GDBserver will reopen the connection.\n");
3888 /* Get rid of any pending statuses. An eventual reconnection
3889 (by the same GDB instance or another) will refresh all its
3890 state from scratch. */
3891 discard_queued_stop_replies (minus_one_ptid
);
3892 for_each_thread ([] (thread_info
*thread
)
3894 thread
->status_pending_p
= 0;
3899 if (disconnected_tracing
)
3901 /* Try to enable non-stop/async mode, so we we can
3902 both wait for an async socket accept, and handle
3903 async target events simultaneously. There's also
3904 no point either in having the target always stop
3905 all threads, when we're going to pass signals
3906 down without informing GDB. */
3909 if (start_non_stop (1))
3912 /* Detaching implicitly resumes all threads;
3913 simply disconnecting does not. */
3919 "Disconnected tracing disabled; "
3920 "stopping trace run.\n");
3925 CATCH (exception
, RETURN_MASK_ERROR
)
3928 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3930 if (response_needed
)
3932 write_enn (cs
.own_buf
);
3933 putpkt (cs
.own_buf
);
3937 throw_quit ("Quit");
3943 /* Main function. */
3946 main (int argc
, char *argv
[])
3951 captured_main (argc
, argv
);
3953 CATCH (exception
, RETURN_MASK_ALL
)
3955 if (exception
.reason
== RETURN_ERROR
)
3958 fprintf (stderr
, "%s\n", exception
.message
);
3959 fprintf (stderr
, "Exiting\n");
3967 gdb_assert_not_reached ("captured_main should never return");
3970 /* Process options coming from Z packets for a breakpoint. PACKET is
3971 the packet buffer. *PACKET is updated to point to the first char
3972 after the last processed option. */
3975 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3977 const char *dataptr
= *packet
;
3980 /* Check if data has the correct format. */
3981 if (*dataptr
!= ';')
3988 if (*dataptr
== ';')
3991 if (*dataptr
== 'X')
3993 /* Conditional expression. */
3995 debug_printf ("Found breakpoint condition.\n");
3996 if (!add_breakpoint_condition (bp
, &dataptr
))
3997 dataptr
= strchrnul (dataptr
, ';');
3999 else if (startswith (dataptr
, "cmds:"))
4001 dataptr
+= strlen ("cmds:");
4003 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
4004 persist
= (*dataptr
== '1');
4006 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
4007 dataptr
= strchrnul (dataptr
, ';');
4011 fprintf (stderr
, "Unknown token %c, ignoring.\n",
4013 /* Skip tokens until we find one that we recognize. */
4014 dataptr
= strchrnul (dataptr
, ';');
4020 /* Event loop callback that handles a serial event. The first byte in
4021 the serial buffer gets us here. We expect characters to arrive at
4022 a brisk pace, so we read the rest of the packet with a blocking
4026 process_serial_event (void)
4028 client_state
&cs
= get_client_state ();
4034 int new_packet_len
= -1;
4036 disable_async_io ();
4038 response_needed
= 0;
4039 packet_len
= getpkt (cs
.own_buf
);
4040 if (packet_len
<= 0)
4043 /* Force an event loop break. */
4046 response_needed
= 1;
4048 char ch
= cs
.own_buf
[0];
4052 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4055 handle_general_set (cs
.own_buf
);
4058 handle_detach (cs
.own_buf
);
4061 extended_protocol
= 1;
4062 write_ok (cs
.own_buf
);
4065 handle_status (cs
.own_buf
);
4068 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4070 require_running_or_break (cs
.own_buf
);
4072 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4074 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4075 thread_id
= null_ptid
;
4076 else if (thread_id
.is_pid ())
4078 /* The ptid represents a pid. */
4079 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4083 write_enn (cs
.own_buf
);
4087 thread_id
= thread
->id
;
4091 /* The ptid represents a lwp/tid. */
4092 if (find_thread_ptid (thread_id
) == NULL
)
4094 write_enn (cs
.own_buf
);
4099 if (cs
.own_buf
[1] == 'g')
4101 if (thread_id
== null_ptid
)
4103 /* GDB is telling us to choose any thread. Check if
4104 the currently selected thread is still valid. If
4105 it is not, select the first available. */
4106 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4108 thread
= get_first_thread ();
4109 thread_id
= thread
->id
;
4112 cs
.general_thread
= thread_id
;
4113 set_desired_thread ();
4114 gdb_assert (current_thread
!= NULL
);
4116 else if (cs
.own_buf
[1] == 'c')
4117 cs
.cont_thread
= thread_id
;
4119 write_ok (cs
.own_buf
);
4123 /* Silently ignore it so that gdb can extend the protocol
4124 without compatibility headaches. */
4125 cs
.own_buf
[0] = '\0';
4129 require_running_or_break (cs
.own_buf
);
4130 if (cs
.current_traceframe
>= 0)
4132 struct regcache
*regcache
4133 = new_register_cache (current_target_desc ());
4135 if (fetch_traceframe_registers (cs
.current_traceframe
,
4137 registers_to_string (regcache
, cs
.own_buf
);
4139 write_enn (cs
.own_buf
);
4140 free_register_cache (regcache
);
4144 struct regcache
*regcache
;
4146 if (!set_desired_thread ())
4147 write_enn (cs
.own_buf
);
4150 regcache
= get_thread_regcache (current_thread
, 1);
4151 registers_to_string (regcache
, cs
.own_buf
);
4156 require_running_or_break (cs
.own_buf
);
4157 if (cs
.current_traceframe
>= 0)
4158 write_enn (cs
.own_buf
);
4161 struct regcache
*regcache
;
4163 if (!set_desired_thread ())
4164 write_enn (cs
.own_buf
);
4167 regcache
= get_thread_regcache (current_thread
, 1);
4168 registers_from_string (regcache
, &cs
.own_buf
[1]);
4169 write_ok (cs
.own_buf
);
4175 require_running_or_break (cs
.own_buf
);
4176 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4177 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4179 write_enn (cs
.own_buf
);
4181 bin2hex (mem_buf
, cs
.own_buf
, res
);
4185 require_running_or_break (cs
.own_buf
);
4186 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4187 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4188 write_ok (cs
.own_buf
);
4190 write_enn (cs
.own_buf
);
4193 require_running_or_break (cs
.own_buf
);
4194 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4195 &mem_addr
, &len
, &mem_buf
) < 0
4196 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4197 write_enn (cs
.own_buf
);
4199 write_ok (cs
.own_buf
);
4202 require_running_or_break (cs
.own_buf
);
4203 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4204 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4205 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4208 myresume (cs
.own_buf
, 0, signal
);
4211 require_running_or_break (cs
.own_buf
);
4212 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4213 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4214 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4217 myresume (cs
.own_buf
, 1, signal
);
4220 require_running_or_break (cs
.own_buf
);
4222 myresume (cs
.own_buf
, 0, signal
);
4225 require_running_or_break (cs
.own_buf
);
4227 myresume (cs
.own_buf
, 1, signal
);
4229 case 'Z': /* insert_ ... */
4231 case 'z': /* remove_ ... */
4236 char type
= cs
.own_buf
[1];
4238 const int insert
= ch
== 'Z';
4239 const char *p
= &cs
.own_buf
[3];
4241 p
= unpack_varlen_hex (p
, &addr
);
4242 kind
= strtol (p
+ 1, &dataptr
, 16);
4246 struct gdb_breakpoint
*bp
;
4248 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4253 /* GDB may have sent us a list of *point parameters to
4254 be evaluated on the target's side. Read such list
4255 here. If we already have a list of parameters, GDB
4256 is telling us to drop that list and use this one
4258 clear_breakpoint_conditions_and_commands (bp
);
4259 const char *options
= dataptr
;
4260 process_point_options (bp
, &options
);
4264 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4267 write_ok (cs
.own_buf
);
4270 cs
.own_buf
[0] = '\0';
4272 write_enn (cs
.own_buf
);
4276 response_needed
= 0;
4277 if (!target_running ())
4278 /* The packet we received doesn't make sense - but we can't
4279 reply to it, either. */
4282 fprintf (stderr
, "Killing all inferiors\n");
4284 for_each_process (kill_inferior_callback
);
4286 /* When using the extended protocol, we wait with no program
4287 running. The traditional protocol will exit instead. */
4288 if (extended_protocol
)
4290 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4291 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4299 require_running_or_break (cs
.own_buf
);
4301 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4302 if (find_thread_ptid (thread_id
) == NULL
)
4304 write_enn (cs
.own_buf
);
4308 if (mythread_alive (thread_id
))
4309 write_ok (cs
.own_buf
);
4311 write_enn (cs
.own_buf
);
4315 response_needed
= 0;
4317 /* Restarting the inferior is only supported in the extended
4319 if (extended_protocol
)
4321 if (target_running ())
4322 for_each_process (kill_inferior_callback
);
4324 fprintf (stderr
, "GDBserver restarting\n");
4326 /* Wait till we are at 1st instruction in prog. */
4327 if (program_path
.get () != NULL
)
4329 create_inferior (program_path
.get (), program_args
);
4331 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4333 /* Stopped at the first instruction of the target
4335 cs
.general_thread
= cs
.last_ptid
;
4339 /* Something went wrong. */
4340 cs
.general_thread
= null_ptid
;
4345 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4346 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4352 /* It is a request we don't understand. Respond with an
4353 empty packet so that gdb knows that we don't support this
4355 cs
.own_buf
[0] = '\0';
4359 /* Extended (long) request. */
4360 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4364 /* It is a request we don't understand. Respond with an empty
4365 packet so that gdb knows that we don't support this
4367 cs
.own_buf
[0] = '\0';
4371 if (new_packet_len
!= -1)
4372 putpkt_binary (cs
.own_buf
, new_packet_len
);
4374 putpkt (cs
.own_buf
);
4376 response_needed
= 0;
4384 /* Event-loop callback for serial events. */
4387 handle_serial_event (int err
, gdb_client_data client_data
)
4390 debug_printf ("handling possible serial event\n");
4392 /* Really handle it. */
4393 if (process_serial_event () < 0)
4396 /* Be sure to not change the selected thread behind GDB's back.
4397 Important in the non-stop mode asynchronous protocol. */
4398 set_desired_thread ();
4403 /* Push a stop notification on the notification queue. */
4406 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4408 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4410 vstop_notif
->status
= *status
;
4411 vstop_notif
->ptid
= ptid
;
4412 /* Push Stop notification. */
4413 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4416 /* Event-loop callback for target events. */
4419 handle_target_event (int err
, gdb_client_data client_data
)
4421 client_state
&cs
= get_client_state ();
4423 debug_printf ("handling possible target event\n");
4425 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4428 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4430 if (gdb_connected () && report_no_resumed
)
4431 push_stop_notification (null_ptid
, &cs
.last_status
);
4433 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4435 int pid
= cs
.last_ptid
.pid ();
4436 struct process_info
*process
= find_process_pid (pid
);
4437 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4439 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4440 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4442 mark_breakpoints_out (process
);
4443 target_mourn_inferior (cs
.last_ptid
);
4445 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4449 /* We're reporting this thread as stopped. Update its
4450 "want-stopped" state to what the client wants, until it
4451 gets a new resume action. */
4452 current_thread
->last_resume_kind
= resume_stop
;
4453 current_thread
->last_status
= cs
.last_status
;
4458 if (!target_running ())
4460 /* The last process exited. We're done. */
4464 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4465 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4466 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4470 /* A thread stopped with a signal, but gdb isn't
4471 connected to handle it. Pass it down to the
4472 inferior, as if it wasn't being traced. */
4473 enum gdb_signal signal
;
4476 debug_printf ("GDB not connected; forwarding event %d for"
4478 (int) cs
.last_status
.kind
,
4479 target_pid_to_str (cs
.last_ptid
));
4481 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4482 signal
= cs
.last_status
.value
.sig
;
4484 signal
= GDB_SIGNAL_0
;
4485 target_continue (cs
.last_ptid
, signal
);
4489 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4492 /* Be sure to not change the selected thread behind GDB's back.
4493 Important in the non-stop mode asynchronous protocol. */
4494 set_desired_thread ();
4507 } // namespace selftests
4508 #endif /* GDB_SELF_TEST */