1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2020 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"
21 #include "gdbsupport/agent.h"
24 #include "gdbsupport/rsp-low.h"
25 #include "gdbsupport/signals-state-save-restore.h"
31 #include "gdbsupport/gdb_vecs.h"
32 #include "gdbsupport/gdb_wait.h"
33 #include "gdbsupport/btrace-common.h"
34 #include "gdbsupport/filestuff.h"
35 #include "tracepoint.h"
39 #include "gdbsupport/common-inferior.h"
40 #include "gdbsupport/job-control.h"
41 #include "gdbsupport/environ.h"
42 #include "filenames.h"
43 #include "gdbsupport/pathstuff.h"
45 #include "xml-builtin.h"
48 #include "gdbsupport/selftest.h"
49 #include "gdbsupport/scope-exit.h"
51 #define require_running_or_return(BUF) \
52 if (!target_running ()) \
58 #define require_running_or_break(BUF) \
59 if (!target_running ()) \
65 /* String containing the current directory (what getwd would return). */
67 char *current_directory
;
69 /* The environment to pass to the inferior when creating it. */
71 static gdb_environ our_environ
;
75 static bool extended_protocol
;
76 static bool response_needed
;
77 static bool exit_requested
;
79 /* --once: Exit after the first connection has closed. */
82 /* Whether to report TARGET_WAITKIND_NO_RESUMED events. */
83 static bool report_no_resumed
;
88 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
90 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
92 m_path
= std::move (path
);
94 /* Make sure we're using the absolute path of the inferior when
96 if (!contains_dir_separator (m_path
.get ()))
100 /* Check if the file is in our CWD. If it is, then we prefix
101 its name with CURRENT_DIRECTORY. Otherwise, we leave the
102 name as-is because we'll try searching for it in $PATH. */
103 if (is_regular_file (m_path
.get (), ®_file_errno
))
104 m_path
= gdb_abspath (m_path
.get ());
108 /* Return the PROGRAM_PATH. */
110 { return m_path
.get (); }
113 /* The program name, adjusted if needed. */
114 gdb::unique_xmalloc_ptr
<char> m_path
;
116 static std::vector
<char *> program_args
;
117 static std::string wrapper_argv
;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid
;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 bool disable_packet_vCont
;
130 bool disable_packet_Tthread
;
131 bool disable_packet_qC
;
132 bool disable_packet_qfThreadInfo
;
134 static unsigned char *mem_buf
;
136 /* A sub-class of 'struct notif_event' for stop, holding information
137 relative to a single stop reply. We keep a queue of these to
138 push to GDB in non-stop mode. */
140 struct vstop_notif
: public notif_event
142 /* Thread or process that got the event. */
146 struct target_waitstatus status
;
149 /* The current btrace configuration. This is gdbserver's mirror of GDB's
150 btrace configuration. */
151 static struct btrace_config current_btrace_conf
;
153 /* The client remote protocol state. */
155 static client_state g_client_state
;
160 client_state
&cs
= g_client_state
;
165 /* Put a stop reply to the stop reply queue. */
168 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
170 struct vstop_notif
*new_notif
= new struct vstop_notif
;
172 new_notif
->ptid
= ptid
;
173 new_notif
->status
= *status
;
175 notif_event_enque (¬if_stop
, new_notif
);
179 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
181 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
183 return vstop_event
->ptid
.matches (filter_ptid
);
189 discard_queued_stop_replies (ptid_t ptid
)
191 std::list
<notif_event
*>::iterator iter
, next
, end
;
192 end
= notif_stop
.queue
.end ();
193 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
198 if (remove_all_on_match_ptid (*iter
, ptid
))
201 notif_stop
.queue
.erase (iter
);
207 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
209 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
211 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
214 /* Helper for in_queued_stop_replies. */
217 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
219 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
221 if (vstop_event
->ptid
.matches (filter_ptid
))
224 /* Don't resume fork children that GDB does not know about yet. */
225 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
226 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
227 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
236 in_queued_stop_replies (ptid_t ptid
)
238 for (notif_event
*event
: notif_stop
.queue
)
240 if (in_queued_stop_replies_ptid (event
, ptid
))
247 struct notif_server notif_stop
=
249 "vStopped", "Stop", {}, vstop_notif_reply
,
253 target_running (void)
255 return get_first_thread () != NULL
;
258 /* See gdbsupport/common-inferior.h. */
263 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
266 /* See gdbsupport/common-inferior.h. */
269 get_exec_file (int err
)
271 if (err
&& program_path
.get () == NULL
)
272 error (_("No executable file specified."));
274 return program_path
.get ();
286 attach_inferior (int pid
)
288 client_state
&cs
= get_client_state ();
289 /* myattach should return -1 if attaching is unsupported,
290 0 if it succeeded, and call error() otherwise. */
292 if (find_process_pid (pid
) != nullptr)
293 error ("Already attached to process %d\n", pid
);
295 if (myattach (pid
) != 0)
298 fprintf (stderr
, "Attached; pid = %d\n", pid
);
301 /* FIXME - It may be that we should get the SIGNAL_PID from the
302 attach function, so that it can be the main thread instead of
303 whichever we were told to attach to. */
308 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
310 /* GDB knows to ignore the first SIGSTOP after attaching to a running
311 process using the "attach" command, but this is different; it's
312 just using "target remote". Pretend it's just starting up. */
313 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
314 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
315 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
317 current_thread
->last_resume_kind
= resume_stop
;
318 current_thread
->last_status
= cs
.last_status
;
324 /* Decode a qXfer read request. Return 0 if everything looks OK,
328 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
330 /* After the read marker and annex, qXfer looks like a
331 traditional 'm' packet. */
332 decode_m_packet (buf
, ofs
, len
);
338 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
340 /* Extract and NUL-terminate the object. */
342 while (*buf
&& *buf
!= ':')
348 /* Extract and NUL-terminate the read/write action. */
350 while (*buf
&& *buf
!= ':')
356 /* Extract and NUL-terminate the annex. */
358 while (*buf
&& *buf
!= ':')
368 /* Write the response to a successful qXfer read. Returns the
369 length of the (binary) data stored in BUF, corresponding
370 to as much of DATA/LEN as we could fit. IS_MORE controls
371 the first character of the response. */
373 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
382 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
383 &out_len
, PBUFSIZ
- 2) + 1;
386 /* Handle btrace enabling in BTS format. */
389 handle_btrace_enable_bts (struct thread_info
*thread
)
391 if (thread
->btrace
!= NULL
)
392 error (_("Btrace already enabled."));
394 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
395 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
398 /* Handle btrace enabling in Intel Processor Trace format. */
401 handle_btrace_enable_pt (struct thread_info
*thread
)
403 if (thread
->btrace
!= NULL
)
404 error (_("Btrace already enabled."));
406 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
407 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
410 /* Handle btrace disabling. */
413 handle_btrace_disable (struct thread_info
*thread
)
416 if (thread
->btrace
== NULL
)
417 error (_("Branch tracing not enabled."));
419 if (target_disable_btrace (thread
->btrace
) != 0)
420 error (_("Could not disable branch tracing."));
422 thread
->btrace
= NULL
;
425 /* Handle the "Qbtrace" packet. */
428 handle_btrace_general_set (char *own_buf
)
430 client_state
&cs
= get_client_state ();
431 struct thread_info
*thread
;
434 if (!startswith (own_buf
, "Qbtrace:"))
437 op
= own_buf
+ strlen ("Qbtrace:");
439 if (cs
.general_thread
== null_ptid
440 || cs
.general_thread
== minus_one_ptid
)
442 strcpy (own_buf
, "E.Must select a single thread.");
446 thread
= find_thread_ptid (cs
.general_thread
);
449 strcpy (own_buf
, "E.No such thread.");
455 if (strcmp (op
, "bts") == 0)
456 handle_btrace_enable_bts (thread
);
457 else if (strcmp (op
, "pt") == 0)
458 handle_btrace_enable_pt (thread
);
459 else if (strcmp (op
, "off") == 0)
460 handle_btrace_disable (thread
);
462 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
466 catch (const gdb_exception_error
&exception
)
468 sprintf (own_buf
, "E.%s", exception
.what ());
474 /* Handle the "Qbtrace-conf" packet. */
477 handle_btrace_conf_general_set (char *own_buf
)
479 client_state
&cs
= get_client_state ();
480 struct thread_info
*thread
;
483 if (!startswith (own_buf
, "Qbtrace-conf:"))
486 op
= own_buf
+ strlen ("Qbtrace-conf:");
488 if (cs
.general_thread
== null_ptid
489 || cs
.general_thread
== minus_one_ptid
)
491 strcpy (own_buf
, "E.Must select a single thread.");
495 thread
= find_thread_ptid (cs
.general_thread
);
498 strcpy (own_buf
, "E.No such thread.");
502 if (startswith (op
, "bts:size="))
508 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
509 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
511 strcpy (own_buf
, "E.Bad size value.");
515 current_btrace_conf
.bts
.size
= (unsigned int) size
;
517 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
523 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
524 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
526 strcpy (own_buf
, "E.Bad size value.");
530 current_btrace_conf
.pt
.size
= (unsigned int) size
;
534 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
542 /* Handle all of the extended 'Q' packets. */
545 handle_general_set (char *own_buf
)
547 client_state
&cs
= get_client_state ();
548 if (startswith (own_buf
, "QPassSignals:"))
550 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
551 const char *p
= own_buf
+ strlen ("QPassSignals:");
554 p
= decode_address_to_semicolon (&cursig
, p
);
555 for (i
= 0; i
< numsigs
; i
++)
559 cs
.pass_signals
[i
] = 1;
561 /* Keep looping, to clear the remaining signals. */
564 p
= decode_address_to_semicolon (&cursig
, p
);
567 cs
.pass_signals
[i
] = 0;
569 strcpy (own_buf
, "OK");
573 if (startswith (own_buf
, "QProgramSignals:"))
575 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
576 const char *p
= own_buf
+ strlen ("QProgramSignals:");
579 cs
.program_signals_p
= 1;
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
586 cs
.program_signals
[i
] = 1;
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
594 cs
.program_signals
[i
] = 0;
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QCatchSyscalls:"))
602 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
605 struct process_info
*process
;
607 if (!target_running () || !target_supports_catch_syscall ())
613 if (strcmp (p
, "0") == 0)
615 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
619 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
625 process
= current_process ();
626 process
->syscalls_to_catch
.clear ();
636 p
= decode_address_to_semicolon (&sysno
, p
);
637 process
->syscalls_to_catch
.push_back (sysno
);
641 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
648 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
650 our_environ
= gdb_environ::from_host_environ ();
656 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
658 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
659 /* The final form of the environment variable. FINAL_VAR will
660 hold the 'VAR=VALUE' format. */
661 std::string final_var
= hex2str (p
);
662 std::string var_name
, var_value
;
666 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
667 debug_printf (_("[Environment variable to be set: '%s']\n"),
672 size_t pos
= final_var
.find ('=');
673 if (pos
== std::string::npos
)
675 warning (_("Unexpected format for environment variable: '%s'"),
681 var_name
= final_var
.substr (0, pos
);
682 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
684 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
690 if (startswith (own_buf
, "QEnvironmentUnset:"))
692 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
693 std::string varname
= hex2str (p
);
697 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
698 debug_printf (_("[Environment variable to be unset: '%s']\n"),
703 our_environ
.unset (varname
.c_str ());
709 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
713 debug_printf ("[noack mode enabled]\n");
722 if (startswith (own_buf
, "QNonStop:"))
724 char *mode
= own_buf
+ 9;
728 if (strcmp (mode
, "0") == 0)
730 else if (strcmp (mode
, "1") == 0)
734 /* We don't know what this mode is, so complain to
736 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
742 req_str
= req
? "non-stop" : "all-stop";
743 if (the_target
->pt
->start_non_stop (req
== 1) != 0)
745 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
750 non_stop
= (req
!= 0);
753 debug_printf ("[%s mode enabled]\n", req_str
);
759 if (startswith (own_buf
, "QDisableRandomization:"))
761 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
764 unpack_varlen_hex (packet
, &setting
);
765 cs
.disable_randomization
= setting
;
769 debug_printf (cs
.disable_randomization
770 ? "[address space randomization disabled]\n"
771 : "[address space randomization enabled]\n");
778 if (target_supports_tracepoints ()
779 && handle_tracepoint_general_set (own_buf
))
782 if (startswith (own_buf
, "QAgent:"))
784 char *mode
= own_buf
+ strlen ("QAgent:");
787 if (strcmp (mode
, "0") == 0)
789 else if (strcmp (mode
, "1") == 0)
793 /* We don't know what this value is, so complain to GDB. */
794 sprintf (own_buf
, "E.Unknown QAgent value");
798 /* Update the flag. */
801 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
806 if (handle_btrace_general_set (own_buf
))
809 if (handle_btrace_conf_general_set (own_buf
))
812 if (startswith (own_buf
, "QThreadEvents:"))
814 char *mode
= own_buf
+ strlen ("QThreadEvents:");
815 enum tribool req
= TRIBOOL_UNKNOWN
;
817 if (strcmp (mode
, "0") == 0)
819 else if (strcmp (mode
, "1") == 0)
823 /* We don't know what this mode is, so complain to GDB. */
824 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
829 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
833 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
835 debug_printf ("[thread events are now %s]\n", req_str
);
842 if (startswith (own_buf
, "QStartupWithShell:"))
844 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
846 if (strcmp (value
, "1") == 0)
847 startup_with_shell
= true;
848 else if (strcmp (value
, "0") == 0)
849 startup_with_shell
= false;
853 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
860 debug_printf (_("[Inferior will %s started with shell]"),
861 startup_with_shell
? "be" : "not be");
867 if (startswith (own_buf
, "QSetWorkingDir:"))
869 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
873 std::string path
= hex2str (p
);
875 set_inferior_cwd (path
.c_str ());
878 debug_printf (_("[Set the inferior's current directory to %s]\n"),
883 /* An empty argument means that we should clear out any
884 previously set cwd for the inferior. */
885 set_inferior_cwd (NULL
);
889 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
896 /* Otherwise we didn't know what packet it was. Say we didn't
902 get_features_xml (const char *annex
)
904 const struct target_desc
*desc
= current_target_desc ();
906 /* `desc->xmltarget' defines what to return when looking for the
907 "target.xml" file. Its contents can either be verbatim XML code
908 (prefixed with a '@') or else the name of the actual XML file to
909 be used in place of "target.xml".
911 This variable is set up from the auto-generated
912 init_registers_... routine for the current target. */
914 if (strcmp (annex
, "target.xml") == 0)
916 const char *ret
= tdesc_get_features_xml (desc
);
928 /* Look for the annex. */
929 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
930 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
933 if (xml_builtin
[i
][0] != NULL
)
934 return xml_builtin
[i
][1];
942 monitor_show_help (void)
944 monitor_output ("The following monitor commands are supported:\n");
945 monitor_output (" set debug <0|1>\n");
946 monitor_output (" Enable general debugging messages\n");
947 monitor_output (" set debug-hw-points <0|1>\n");
948 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
949 monitor_output (" set remote-debug <0|1>\n");
950 monitor_output (" Enable remote protocol debugging messages\n");
951 monitor_output (" set debug-format option1[,option2,...]\n");
952 monitor_output (" Add additional information to debugging messages\n");
953 monitor_output (" Options: all, none");
954 monitor_output (", timestamp");
955 monitor_output ("\n");
956 monitor_output (" exit\n");
957 monitor_output (" Quit GDBserver\n");
960 /* Read trace frame or inferior memory. Returns the number of bytes
961 actually read, zero when no further transfer is possible, and -1 on
962 error. Return of a positive value smaller than LEN does not
963 indicate there's no more to be read, only the end of the transfer.
964 E.g., when GDB reads memory from a traceframe, a first request may
965 be served from a memory block that does not cover the whole request
966 length. A following request gets the rest served from either
967 another block (of the same traceframe) or from the read-only
971 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
973 client_state
&cs
= get_client_state ();
976 if (cs
.current_traceframe
>= 0)
979 ULONGEST length
= len
;
981 if (traceframe_read_mem (cs
.current_traceframe
,
982 memaddr
, myaddr
, len
, &nbytes
))
984 /* Data read from trace buffer, we're done. */
987 if (!in_readonly_region (memaddr
, length
))
989 /* Otherwise we have a valid readonly case, fall through. */
990 /* (assume no half-trace half-real blocks for now) */
993 res
= prepare_to_access_memory ();
996 if (set_desired_thread ())
997 res
= read_inferior_memory (memaddr
, myaddr
, len
);
1000 done_accessing_memory ();
1002 return res
== 0 ? len
: -1;
1008 /* Write trace frame or inferior memory. Actually, writing to trace
1009 frames is forbidden. */
1012 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1014 client_state
&cs
= get_client_state ();
1015 if (cs
.current_traceframe
>= 0)
1021 ret
= prepare_to_access_memory ();
1024 if (set_desired_thread ())
1025 ret
= target_write_memory (memaddr
, myaddr
, len
);
1028 done_accessing_memory ();
1034 /* Subroutine of handle_search_memory to simplify it. */
1037 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1038 gdb_byte
*pattern
, unsigned pattern_len
,
1039 gdb_byte
*search_buf
,
1040 unsigned chunk_size
, unsigned search_buf_size
,
1041 CORE_ADDR
*found_addrp
)
1043 /* Prime the search buffer. */
1045 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1048 warning ("Unable to access %ld bytes of target "
1049 "memory at 0x%lx, halting search.",
1050 (long) search_buf_size
, (long) start_addr
);
1054 /* Perform the search.
1056 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1057 When we've scanned N bytes we copy the trailing bytes to the start and
1058 read in another N bytes. */
1060 while (search_space_len
>= pattern_len
)
1062 gdb_byte
*found_ptr
;
1063 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1067 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1070 if (found_ptr
!= NULL
)
1072 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1073 *found_addrp
= found_addr
;
1077 /* Not found in this chunk, skip to next chunk. */
1079 /* Don't let search_space_len wrap here, it's unsigned. */
1080 if (search_space_len
>= chunk_size
)
1081 search_space_len
-= chunk_size
;
1083 search_space_len
= 0;
1085 if (search_space_len
>= pattern_len
)
1087 unsigned keep_len
= search_buf_size
- chunk_size
;
1088 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1091 /* Copy the trailing part of the previous iteration to the front
1092 of the buffer for the next iteration. */
1093 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1095 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1096 ? search_space_len
- keep_len
1099 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1100 nr_to_read
) != search_buf_size
)
1102 warning ("Unable to access %ld bytes of target memory "
1103 "at 0x%lx, halting search.",
1104 (long) nr_to_read
, (long) read_addr
);
1108 start_addr
+= chunk_size
;
1117 /* Handle qSearch:memory packets. */
1120 handle_search_memory (char *own_buf
, int packet_len
)
1122 CORE_ADDR start_addr
;
1123 CORE_ADDR search_space_len
;
1125 unsigned int pattern_len
;
1126 /* NOTE: also defined in find.c testcase. */
1127 #define SEARCH_CHUNK_SIZE 16000
1128 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1129 /* Buffer to hold memory contents for searching. */
1130 gdb_byte
*search_buf
;
1131 unsigned search_buf_size
;
1133 CORE_ADDR found_addr
;
1134 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1136 pattern
= (gdb_byte
*) malloc (packet_len
);
1137 if (pattern
== NULL
)
1139 error ("Unable to allocate memory to perform the search");
1140 strcpy (own_buf
, "E00");
1143 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1144 packet_len
- cmd_name_len
,
1145 &start_addr
, &search_space_len
,
1146 pattern
, &pattern_len
) < 0)
1149 error ("Error in parsing qSearch:memory packet");
1150 strcpy (own_buf
, "E00");
1154 search_buf_size
= chunk_size
+ pattern_len
- 1;
1156 /* No point in trying to allocate a buffer larger than the search space. */
1157 if (search_space_len
< search_buf_size
)
1158 search_buf_size
= search_space_len
;
1160 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1161 if (search_buf
== NULL
)
1164 error ("Unable to allocate memory to perform the search");
1165 strcpy (own_buf
, "E00");
1169 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1170 pattern
, pattern_len
,
1171 search_buf
, chunk_size
, search_buf_size
,
1175 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1176 else if (found
== 0)
1177 strcpy (own_buf
, "0");
1179 strcpy (own_buf
, "E00");
1185 /* Handle the "D" packet. */
1188 handle_detach (char *own_buf
)
1190 client_state
&cs
= get_client_state ();
1192 process_info
*process
;
1194 if (cs
.multi_process
)
1197 int pid
= strtol (&own_buf
[2], NULL
, 16);
1199 process
= find_process_pid (pid
);
1203 process
= (current_thread
!= nullptr
1204 ? get_thread_process (current_thread
)
1208 if (process
== NULL
)
1210 write_enn (own_buf
);
1214 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1216 if (tracing
&& disconnected_tracing
)
1218 "Disconnected tracing in effect, "
1219 "leaving gdbserver attached to the process\n");
1221 if (any_persistent_commands (process
))
1223 "Persistent commands are present, "
1224 "leaving gdbserver attached to the process\n");
1226 /* Make sure we're in non-stop/async mode, so we we can both
1227 wait for an async socket accept, and handle async target
1228 events simultaneously. There's also no point either in
1229 having the target stop all threads, when we're going to
1230 pass signals down without informing GDB. */
1234 debug_printf ("Forcing non-stop mode\n");
1237 the_target
->pt
->start_non_stop (true);
1240 process
->gdb_detached
= 1;
1242 /* Detaching implicitly resumes all threads. */
1243 target_continue_no_signal (minus_one_ptid
);
1249 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1252 /* We'll need this after PROCESS has been destroyed. */
1253 int pid
= process
->pid
;
1255 if (detach_inferior (process
) != 0)
1256 write_enn (own_buf
);
1259 discard_queued_stop_replies (ptid_t (pid
));
1262 if (extended_protocol
|| target_running ())
1264 /* There is still at least one inferior remaining or
1265 we are in extended mode, so don't terminate gdbserver,
1266 and instead treat this like a normal program exit. */
1267 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1268 cs
.last_status
.value
.integer
= 0;
1269 cs
.last_ptid
= ptid_t (pid
);
1271 current_thread
= NULL
;
1278 /* If we are attached, then we can exit. Otherwise, we
1279 need to hang around doing nothing, until the child is
1281 join_inferior (pid
);
1287 /* Parse options to --debug-format= and "monitor set debug-format".
1288 ARG is the text after "--debug-format=" or "monitor set debug-format".
1289 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1290 This triggers calls to monitor_output.
1291 The result is an empty string if all options were parsed ok, otherwise an
1292 error message which the caller must free.
1294 N.B. These commands affect all debug format settings, they are not
1295 cumulative. If a format is not specified, it is turned off.
1296 However, we don't go to extra trouble with things like
1297 "monitor set debug-format all,none,timestamp".
1298 Instead we just parse them one at a time, in order.
1300 The syntax for "monitor set debug" we support here is not identical
1301 to gdb's "set debug foo on|off" because we also use this function to
1302 parse "--debug-format=foo,bar". */
1305 parse_debug_format_options (const char *arg
, int is_monitor
)
1307 /* First turn all debug format options off. */
1308 debug_timestamp
= 0;
1310 /* First remove leading spaces, for "monitor set debug-format". */
1311 while (isspace (*arg
))
1314 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1315 = delim_string_to_char_ptr_vec (arg
, ',');
1317 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1319 if (strcmp (option
.get (), "all") == 0)
1321 debug_timestamp
= 1;
1323 monitor_output ("All extra debug format options enabled.\n");
1325 else if (strcmp (option
.get (), "none") == 0)
1327 debug_timestamp
= 0;
1329 monitor_output ("All extra debug format options disabled.\n");
1331 else if (strcmp (option
.get (), "timestamp") == 0)
1333 debug_timestamp
= 1;
1335 monitor_output ("Timestamps will be added to debug output.\n");
1337 else if (*option
== '\0')
1339 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1343 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1347 return std::string ();
1350 /* Handle monitor commands not handled by target-specific handlers. */
1353 handle_monitor_command (char *mon
, char *own_buf
)
1355 if (strcmp (mon
, "set debug 1") == 0)
1358 monitor_output ("Debug output enabled.\n");
1360 else if (strcmp (mon
, "set debug 0") == 0)
1363 monitor_output ("Debug output disabled.\n");
1365 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1367 show_debug_regs
= 1;
1368 monitor_output ("H/W point debugging output enabled.\n");
1370 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1372 show_debug_regs
= 0;
1373 monitor_output ("H/W point debugging output disabled.\n");
1375 else if (strcmp (mon
, "set remote-debug 1") == 0)
1378 monitor_output ("Protocol debug output enabled.\n");
1380 else if (strcmp (mon
, "set remote-debug 0") == 0)
1383 monitor_output ("Protocol debug output disabled.\n");
1385 else if (startswith (mon
, "set debug-format "))
1387 std::string error_msg
1388 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1391 if (!error_msg
.empty ())
1393 monitor_output (error_msg
.c_str ());
1394 monitor_show_help ();
1395 write_enn (own_buf
);
1398 else if (strcmp (mon
, "set debug-file") == 0)
1399 debug_set_output (nullptr);
1400 else if (startswith (mon
, "set debug-file "))
1401 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1402 else if (strcmp (mon
, "help") == 0)
1403 monitor_show_help ();
1404 else if (strcmp (mon
, "exit") == 0)
1405 exit_requested
= true;
1408 monitor_output ("Unknown monitor command.\n\n");
1409 monitor_show_help ();
1410 write_enn (own_buf
);
1414 /* Associates a callback with each supported qXfer'able object. */
1418 /* The object this handler handles. */
1421 /* Request that the target transfer up to LEN 8-bit bytes of the
1422 target's OBJECT. The OFFSET, for a seekable object, specifies
1423 the starting point. The ANNEX can be used to provide additional
1424 data-specific information to the target.
1426 Return the number of bytes actually transfered, zero when no
1427 further transfer is possible, -1 on error, -2 when the transfer
1428 is not supported, and -3 on a verbose error message that should
1429 be preserved. Return of a positive value smaller than LEN does
1430 not indicate the end of the object, only the end of the transfer.
1432 One, and only one, of readbuf or writebuf must be non-NULL. */
1433 int (*xfer
) (const char *annex
,
1434 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1435 ULONGEST offset
, LONGEST len
);
1438 /* Handle qXfer:auxv:read. */
1441 handle_qxfer_auxv (const char *annex
,
1442 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1443 ULONGEST offset
, LONGEST len
)
1445 if (!the_target
->pt
->supports_read_auxv () || writebuf
!= NULL
)
1448 if (annex
[0] != '\0' || current_thread
== NULL
)
1451 return the_target
->pt
->read_auxv (offset
, readbuf
, len
);
1454 /* Handle qXfer:exec-file:read. */
1457 handle_qxfer_exec_file (const char *annex
,
1458 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1459 ULONGEST offset
, LONGEST len
)
1465 if (!the_target
->pt
->supports_pid_to_exec_file () || writebuf
!= NULL
)
1468 if (annex
[0] == '\0')
1470 if (current_thread
== NULL
)
1473 pid
= pid_of (current_thread
);
1477 annex
= unpack_varlen_hex (annex
, &pid
);
1478 if (annex
[0] != '\0')
1485 file
= the_target
->pt
->pid_to_exec_file (pid
);
1489 total_len
= strlen (file
);
1491 if (offset
> total_len
)
1494 if (offset
+ len
> total_len
)
1495 len
= total_len
- offset
;
1497 memcpy (readbuf
, file
+ offset
, len
);
1501 /* Handle qXfer:features:read. */
1504 handle_qxfer_features (const char *annex
,
1505 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1506 ULONGEST offset
, LONGEST len
)
1508 const char *document
;
1511 if (writebuf
!= NULL
)
1514 if (!target_running ())
1517 /* Grab the correct annex. */
1518 document
= get_features_xml (annex
);
1519 if (document
== NULL
)
1522 total_len
= strlen (document
);
1524 if (offset
> total_len
)
1527 if (offset
+ len
> total_len
)
1528 len
= total_len
- offset
;
1530 memcpy (readbuf
, document
+ offset
, len
);
1534 /* Handle qXfer:libraries:read. */
1537 handle_qxfer_libraries (const char *annex
,
1538 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1539 ULONGEST offset
, LONGEST len
)
1541 if (writebuf
!= NULL
)
1544 if (annex
[0] != '\0' || current_thread
== NULL
)
1547 std::string document
= "<library-list version=\"1.0\">\n";
1549 for (const dll_info
&dll
: all_dlls
)
1550 document
+= string_printf
1551 (" <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
1552 dll
.name
.c_str (), paddress (dll
.base_addr
));
1554 document
+= "</library-list>\n";
1556 if (offset
> document
.length ())
1559 if (offset
+ len
> document
.length ())
1560 len
= document
.length () - offset
;
1562 memcpy (readbuf
, &document
[offset
], len
);
1567 /* Handle qXfer:libraries-svr4:read. */
1570 handle_qxfer_libraries_svr4 (const char *annex
,
1571 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1572 ULONGEST offset
, LONGEST len
)
1574 if (writebuf
!= NULL
)
1577 if (current_thread
== NULL
1578 || !the_target
->pt
->supports_qxfer_libraries_svr4 ())
1581 return the_target
->pt
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
,
1585 /* Handle qXfer:osadata:read. */
1588 handle_qxfer_osdata (const char *annex
,
1589 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1590 ULONGEST offset
, LONGEST len
)
1592 if (!the_target
->pt
->supports_qxfer_osdata () || writebuf
!= NULL
)
1595 return the_target
->pt
->qxfer_osdata (annex
, readbuf
, NULL
, offset
, len
);
1598 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1601 handle_qxfer_siginfo (const char *annex
,
1602 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1603 ULONGEST offset
, LONGEST len
)
1605 if (!the_target
->pt
->supports_qxfer_siginfo ())
1608 if (annex
[0] != '\0' || current_thread
== NULL
)
1611 return the_target
->pt
->qxfer_siginfo (annex
, readbuf
, writebuf
, offset
, len
);
1614 /* Handle qXfer:statictrace:read. */
1617 handle_qxfer_statictrace (const char *annex
,
1618 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1619 ULONGEST offset
, LONGEST len
)
1621 client_state
&cs
= get_client_state ();
1624 if (writebuf
!= NULL
)
1627 if (annex
[0] != '\0' || current_thread
== NULL
1628 || cs
.current_traceframe
== -1)
1631 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1632 readbuf
, len
, &nbytes
))
1637 /* Helper for handle_qxfer_threads_proper.
1638 Emit the XML to describe the thread of INF. */
1641 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1643 ptid_t ptid
= ptid_of (thread
);
1645 int core
= target_core_of_thread (ptid
);
1647 const char *name
= target_thread_name (ptid
);
1650 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1652 write_ptid (ptid_s
, ptid
);
1654 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1658 sprintf (core_s
, "%d", core
);
1659 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1663 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1667 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1668 bin2hex (handle
, handle_s
, handle_len
);
1669 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1672 buffer_xml_printf (buffer
, "/>\n");
1675 /* Helper for handle_qxfer_threads. */
1678 handle_qxfer_threads_proper (struct buffer
*buffer
)
1680 buffer_grow_str (buffer
, "<threads>\n");
1682 for_each_thread ([&] (thread_info
*thread
)
1684 handle_qxfer_threads_worker (thread
, buffer
);
1687 buffer_grow_str0 (buffer
, "</threads>\n");
1690 /* Handle qXfer:threads:read. */
1693 handle_qxfer_threads (const char *annex
,
1694 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1695 ULONGEST offset
, LONGEST len
)
1697 static char *result
= 0;
1698 static unsigned int result_length
= 0;
1700 if (writebuf
!= NULL
)
1703 if (annex
[0] != '\0')
1708 struct buffer buffer
;
1709 /* When asked for data at offset 0, generate everything and store into
1710 'result'. Successive reads will be served off 'result'. */
1714 buffer_init (&buffer
);
1716 handle_qxfer_threads_proper (&buffer
);
1718 result
= buffer_finish (&buffer
);
1719 result_length
= strlen (result
);
1720 buffer_free (&buffer
);
1723 if (offset
>= result_length
)
1725 /* We're out of data. */
1732 if (len
> result_length
- offset
)
1733 len
= result_length
- offset
;
1735 memcpy (readbuf
, result
+ offset
, len
);
1740 /* Handle qXfer:traceframe-info:read. */
1743 handle_qxfer_traceframe_info (const char *annex
,
1744 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1745 ULONGEST offset
, LONGEST len
)
1747 client_state
&cs
= get_client_state ();
1748 static char *result
= 0;
1749 static unsigned int result_length
= 0;
1751 if (writebuf
!= NULL
)
1754 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1759 struct buffer buffer
;
1761 /* When asked for data at offset 0, generate everything and
1762 store into 'result'. Successive reads will be served off
1766 buffer_init (&buffer
);
1768 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1770 result
= buffer_finish (&buffer
);
1771 result_length
= strlen (result
);
1772 buffer_free (&buffer
);
1775 if (offset
>= result_length
)
1777 /* We're out of data. */
1784 if (len
> result_length
- offset
)
1785 len
= result_length
- offset
;
1787 memcpy (readbuf
, result
+ offset
, len
);
1791 /* Handle qXfer:fdpic:read. */
1794 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1795 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1797 if (!the_target
->pt
->supports_read_loadmap ())
1800 if (current_thread
== NULL
)
1803 return the_target
->pt
->read_loadmap (annex
, offset
, readbuf
, len
);
1806 /* Handle qXfer:btrace:read. */
1809 handle_qxfer_btrace (const char *annex
,
1810 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1811 ULONGEST offset
, LONGEST len
)
1813 client_state
&cs
= get_client_state ();
1814 static struct buffer cache
;
1815 struct thread_info
*thread
;
1816 enum btrace_read_type type
;
1819 if (writebuf
!= NULL
)
1822 if (cs
.general_thread
== null_ptid
1823 || cs
.general_thread
== minus_one_ptid
)
1825 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1829 thread
= find_thread_ptid (cs
.general_thread
);
1832 strcpy (cs
.own_buf
, "E.No such thread.");
1836 if (thread
->btrace
== NULL
)
1838 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1842 if (strcmp (annex
, "all") == 0)
1843 type
= BTRACE_READ_ALL
;
1844 else if (strcmp (annex
, "new") == 0)
1845 type
= BTRACE_READ_NEW
;
1846 else if (strcmp (annex
, "delta") == 0)
1847 type
= BTRACE_READ_DELTA
;
1850 strcpy (cs
.own_buf
, "E.Bad annex.");
1856 buffer_free (&cache
);
1860 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1862 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1864 catch (const gdb_exception_error
&exception
)
1866 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1873 else if (offset
> cache
.used_size
)
1875 buffer_free (&cache
);
1879 if (len
> cache
.used_size
- offset
)
1880 len
= cache
.used_size
- offset
;
1882 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1887 /* Handle qXfer:btrace-conf:read. */
1890 handle_qxfer_btrace_conf (const char *annex
,
1891 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1892 ULONGEST offset
, LONGEST len
)
1894 client_state
&cs
= get_client_state ();
1895 static struct buffer cache
;
1896 struct thread_info
*thread
;
1899 if (writebuf
!= NULL
)
1902 if (annex
[0] != '\0')
1905 if (cs
.general_thread
== null_ptid
1906 || cs
.general_thread
== minus_one_ptid
)
1908 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1912 thread
= find_thread_ptid (cs
.general_thread
);
1915 strcpy (cs
.own_buf
, "E.No such thread.");
1919 if (thread
->btrace
== NULL
)
1921 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1927 buffer_free (&cache
);
1931 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1933 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1935 catch (const gdb_exception_error
&exception
)
1937 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1944 else if (offset
> cache
.used_size
)
1946 buffer_free (&cache
);
1950 if (len
> cache
.used_size
- offset
)
1951 len
= cache
.used_size
- offset
;
1953 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1958 static const struct qxfer qxfer_packets
[] =
1960 { "auxv", handle_qxfer_auxv
},
1961 { "btrace", handle_qxfer_btrace
},
1962 { "btrace-conf", handle_qxfer_btrace_conf
},
1963 { "exec-file", handle_qxfer_exec_file
},
1964 { "fdpic", handle_qxfer_fdpic
},
1965 { "features", handle_qxfer_features
},
1966 { "libraries", handle_qxfer_libraries
},
1967 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1968 { "osdata", handle_qxfer_osdata
},
1969 { "siginfo", handle_qxfer_siginfo
},
1970 { "statictrace", handle_qxfer_statictrace
},
1971 { "threads", handle_qxfer_threads
},
1972 { "traceframe-info", handle_qxfer_traceframe_info
},
1976 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1984 if (!startswith (own_buf
, "qXfer:"))
1987 /* Grab the object, r/w and annex. */
1988 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1990 write_enn (own_buf
);
1995 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1998 const struct qxfer
*q
= &qxfer_packets
[i
];
2000 if (strcmp (object
, q
->object
) == 0)
2002 if (strcmp (rw
, "read") == 0)
2004 unsigned char *data
;
2009 /* Grab the offset and length. */
2010 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2012 write_enn (own_buf
);
2016 /* Read one extra byte, as an indicator of whether there is
2018 if (len
> PBUFSIZ
- 2)
2020 data
= (unsigned char *) malloc (len
+ 1);
2023 write_enn (own_buf
);
2026 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2034 /* Preserve error message. */
2037 write_enn (own_buf
);
2039 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2041 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2046 else if (strcmp (rw
, "write") == 0)
2051 unsigned char *data
;
2053 strcpy (own_buf
, "E00");
2054 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2057 write_enn (own_buf
);
2060 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2061 &ofs
, &len
, data
) < 0)
2064 write_enn (own_buf
);
2068 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2076 /* Preserve error message. */
2079 write_enn (own_buf
);
2081 sprintf (own_buf
, "%x", n
);
2094 /* Compute 32 bit CRC from inferior memory.
2096 On success, return 32 bit CRC.
2097 On failure, return (unsigned long long) -1. */
2099 static unsigned long long
2100 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2104 unsigned char byte
= 0;
2106 /* Return failure if memory read fails. */
2107 if (read_inferior_memory (base
, &byte
, 1) != 0)
2108 return (unsigned long long) -1;
2110 crc
= xcrc32 (&byte
, 1, crc
);
2113 return (unsigned long long) crc
;
2116 /* Add supported btrace packets to BUF. */
2119 supported_btrace_packets (char *buf
)
2121 strcat (buf
, ";Qbtrace:bts+");
2122 strcat (buf
, ";Qbtrace-conf:bts:size+");
2123 strcat (buf
, ";Qbtrace:pt+");
2124 strcat (buf
, ";Qbtrace-conf:pt:size+");
2125 strcat (buf
, ";Qbtrace:off+");
2126 strcat (buf
, ";qXfer:btrace:read+");
2127 strcat (buf
, ";qXfer:btrace-conf:read+");
2130 /* Handle all of the extended 'q' packets. */
2133 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2135 client_state
&cs
= get_client_state ();
2136 static std::list
<thread_info
*>::const_iterator thread_iter
;
2138 /* Reply the current thread id. */
2139 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2142 require_running_or_return (own_buf
);
2144 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2145 ptid
= cs
.general_thread
;
2148 thread_iter
= all_threads
.begin ();
2149 ptid
= (*thread_iter
)->id
;
2152 sprintf (own_buf
, "QC");
2154 write_ptid (own_buf
, ptid
);
2158 if (strcmp ("qSymbol::", own_buf
) == 0)
2160 struct thread_info
*save_thread
= current_thread
;
2162 /* For qSymbol, GDB only changes the current thread if the
2163 previous current thread was of a different process. So if
2164 the previous thread is gone, we need to pick another one of
2165 the same process. This can happen e.g., if we followed an
2166 exec in a non-leader thread. */
2167 if (current_thread
== NULL
)
2170 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2172 /* Just in case, if we didn't find a thread, then bail out
2173 instead of crashing. */
2174 if (current_thread
== NULL
)
2176 write_enn (own_buf
);
2177 current_thread
= save_thread
;
2182 /* GDB is suggesting new symbols have been loaded. This may
2183 mean a new shared library has been detected as loaded, so
2184 take the opportunity to check if breakpoints we think are
2185 inserted, still are. Note that it isn't guaranteed that
2186 we'll see this when a shared library is loaded, and nor will
2187 we see this for unloads (although breakpoints in unloaded
2188 libraries shouldn't trigger), as GDB may not find symbols for
2189 the library at all. We also re-validate breakpoints when we
2190 see a second GDB breakpoint for the same address, and or when
2191 we access breakpoint shadows. */
2192 validate_breakpoints ();
2194 if (target_supports_tracepoints ())
2195 tracepoint_look_up_symbols ();
2197 if (current_thread
!= NULL
)
2198 the_target
->pt
->look_up_symbols ();
2200 current_thread
= save_thread
;
2202 strcpy (own_buf
, "OK");
2206 if (!disable_packet_qfThreadInfo
)
2208 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2210 require_running_or_return (own_buf
);
2211 thread_iter
= all_threads
.begin ();
2214 ptid_t ptid
= (*thread_iter
)->id
;
2215 write_ptid (own_buf
, ptid
);
2220 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2222 require_running_or_return (own_buf
);
2223 if (thread_iter
!= all_threads
.end ())
2226 ptid_t ptid
= (*thread_iter
)->id
;
2227 write_ptid (own_buf
, ptid
);
2233 sprintf (own_buf
, "l");
2239 if (the_target
->pt
->supports_read_offsets ()
2240 && strcmp ("qOffsets", own_buf
) == 0)
2242 CORE_ADDR text
, data
;
2244 require_running_or_return (own_buf
);
2245 if (the_target
->pt
->read_offsets (&text
, &data
))
2246 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2247 (long)text
, (long)data
, (long)data
);
2249 write_enn (own_buf
);
2254 /* Protocol features query. */
2255 if (startswith (own_buf
, "qSupported")
2256 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2258 char *p
= &own_buf
[10];
2259 int gdb_supports_qRelocInsn
= 0;
2261 /* Process each feature being provided by GDB. The first
2262 feature will follow a ':', and latter features will follow
2266 char **qsupported
= NULL
;
2271 /* Two passes, to avoid nested strtok calls in
2272 target_process_qsupported. */
2274 for (p
= strtok_r (p
+ 1, ";", &saveptr
);
2276 p
= strtok_r (NULL
, ";", &saveptr
))
2279 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2280 qsupported
[count
- 1] = xstrdup (p
);
2283 for (i
= 0; i
< count
; i
++)
2286 if (strcmp (p
, "multiprocess+") == 0)
2288 /* GDB supports and wants multi-process support if
2290 if (target_supports_multi_process ())
2291 cs
.multi_process
= 1;
2293 else if (strcmp (p
, "qRelocInsn+") == 0)
2295 /* GDB supports relocate instruction requests. */
2296 gdb_supports_qRelocInsn
= 1;
2298 else if (strcmp (p
, "swbreak+") == 0)
2300 /* GDB wants us to report whether a trap is caused
2301 by a software breakpoint and for us to handle PC
2302 adjustment if necessary on this target. */
2303 if (target_supports_stopped_by_sw_breakpoint ())
2304 cs
.swbreak_feature
= 1;
2306 else if (strcmp (p
, "hwbreak+") == 0)
2308 /* GDB wants us to report whether a trap is caused
2309 by a hardware breakpoint. */
2310 if (target_supports_stopped_by_hw_breakpoint ())
2311 cs
.hwbreak_feature
= 1;
2313 else if (strcmp (p
, "fork-events+") == 0)
2315 /* GDB supports and wants fork events if possible. */
2316 if (target_supports_fork_events ())
2317 cs
.report_fork_events
= 1;
2319 else if (strcmp (p
, "vfork-events+") == 0)
2321 /* GDB supports and wants vfork events if possible. */
2322 if (target_supports_vfork_events ())
2323 cs
.report_vfork_events
= 1;
2325 else if (strcmp (p
, "exec-events+") == 0)
2327 /* GDB supports and wants exec events if possible. */
2328 if (target_supports_exec_events ())
2329 cs
.report_exec_events
= 1;
2331 else if (strcmp (p
, "vContSupported+") == 0)
2332 cs
.vCont_supported
= 1;
2333 else if (strcmp (p
, "QThreadEvents+") == 0)
2335 else if (strcmp (p
, "no-resumed+") == 0)
2337 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2339 report_no_resumed
= true;
2343 /* Move the unknown features all together. */
2344 qsupported
[i
] = NULL
;
2345 qsupported
[unknown
] = p
;
2350 /* Give the target backend a chance to process the unknown
2352 target_process_qsupported (qsupported
, unknown
);
2354 for (i
= 0; i
< count
; i
++)
2355 free (qsupported
[i
]);
2360 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2361 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2362 "QEnvironmentReset+;QEnvironmentUnset+;"
2366 if (target_supports_catch_syscall ())
2367 strcat (own_buf
, ";QCatchSyscalls+");
2369 if (the_target
->pt
->supports_qxfer_libraries_svr4 ())
2370 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2371 ";augmented-libraries-svr4-read+");
2374 /* We do not have any hook to indicate whether the non-SVR4 target
2375 backend supports qXfer:libraries:read, so always report it. */
2376 strcat (own_buf
, ";qXfer:libraries:read+");
2379 if (the_target
->pt
->supports_read_auxv ())
2380 strcat (own_buf
, ";qXfer:auxv:read+");
2382 if (the_target
->pt
->supports_qxfer_siginfo ())
2383 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2385 if (the_target
->pt
->supports_read_loadmap ())
2386 strcat (own_buf
, ";qXfer:fdpic:read+");
2388 /* We always report qXfer:features:read, as targets may
2389 install XML files on a subsequent call to arch_setup.
2390 If we reported to GDB on startup that we don't support
2391 qXfer:feature:read at all, we will never be re-queried. */
2392 strcat (own_buf
, ";qXfer:features:read+");
2394 if (cs
.transport_is_reliable
)
2395 strcat (own_buf
, ";QStartNoAckMode+");
2397 if (the_target
->pt
->supports_qxfer_osdata ())
2398 strcat (own_buf
, ";qXfer:osdata:read+");
2400 if (target_supports_multi_process ())
2401 strcat (own_buf
, ";multiprocess+");
2403 if (target_supports_fork_events ())
2404 strcat (own_buf
, ";fork-events+");
2406 if (target_supports_vfork_events ())
2407 strcat (own_buf
, ";vfork-events+");
2409 if (target_supports_exec_events ())
2410 strcat (own_buf
, ";exec-events+");
2412 if (target_supports_non_stop ())
2413 strcat (own_buf
, ";QNonStop+");
2415 if (target_supports_disable_randomization ())
2416 strcat (own_buf
, ";QDisableRandomization+");
2418 strcat (own_buf
, ";qXfer:threads:read+");
2420 if (target_supports_tracepoints ())
2422 strcat (own_buf
, ";ConditionalTracepoints+");
2423 strcat (own_buf
, ";TraceStateVariables+");
2424 strcat (own_buf
, ";TracepointSource+");
2425 strcat (own_buf
, ";DisconnectedTracing+");
2426 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2427 strcat (own_buf
, ";FastTracepoints+");
2428 strcat (own_buf
, ";StaticTracepoints+");
2429 strcat (own_buf
, ";InstallInTrace+");
2430 strcat (own_buf
, ";qXfer:statictrace:read+");
2431 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2432 strcat (own_buf
, ";EnableDisableTracepoints+");
2433 strcat (own_buf
, ";QTBuffer:size+");
2434 strcat (own_buf
, ";tracenz+");
2437 if (target_supports_hardware_single_step ()
2438 || target_supports_software_single_step () )
2440 strcat (own_buf
, ";ConditionalBreakpoints+");
2442 strcat (own_buf
, ";BreakpointCommands+");
2444 if (target_supports_agent ())
2445 strcat (own_buf
, ";QAgent+");
2447 supported_btrace_packets (own_buf
);
2449 if (target_supports_stopped_by_sw_breakpoint ())
2450 strcat (own_buf
, ";swbreak+");
2452 if (target_supports_stopped_by_hw_breakpoint ())
2453 strcat (own_buf
, ";hwbreak+");
2455 if (the_target
->pt
->supports_pid_to_exec_file ())
2456 strcat (own_buf
, ";qXfer:exec-file:read+");
2458 strcat (own_buf
, ";vContSupported+");
2460 strcat (own_buf
, ";QThreadEvents+");
2462 strcat (own_buf
, ";no-resumed+");
2464 /* Reinitialize components as needed for the new connection. */
2465 hostio_handle_new_gdb_connection ();
2466 target_handle_new_gdb_connection ();
2471 /* Thread-local storage support. */
2472 if (the_target
->pt
->supports_get_tls_address ()
2473 && startswith (own_buf
, "qGetTLSAddr:"))
2475 char *p
= own_buf
+ 12;
2476 CORE_ADDR parts
[2], address
= 0;
2478 ptid_t ptid
= null_ptid
;
2480 require_running_or_return (own_buf
);
2482 for (i
= 0; i
< 3; i
++)
2490 p2
= strchr (p
, ',');
2503 ptid
= read_ptid (p
, NULL
);
2505 decode_address (&parts
[i
- 1], p
, len
);
2509 if (p
!= NULL
|| i
< 3)
2513 struct thread_info
*thread
= find_thread_ptid (ptid
);
2518 err
= the_target
->pt
->get_tls_address (thread
, parts
[0], parts
[1],
2524 strcpy (own_buf
, paddress(address
));
2529 write_enn (own_buf
);
2533 /* Otherwise, pretend we do not understand this packet. */
2536 /* Windows OS Thread Information Block address support. */
2537 if (the_target
->pt
->supports_get_tib_address ()
2538 && startswith (own_buf
, "qGetTIBAddr:"))
2543 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2545 n
= the_target
->pt
->get_tib_address (ptid
, &tlb
);
2548 strcpy (own_buf
, paddress(tlb
));
2553 write_enn (own_buf
);
2559 /* Handle "monitor" commands. */
2560 if (startswith (own_buf
, "qRcmd,"))
2562 char *mon
= (char *) malloc (PBUFSIZ
);
2563 int len
= strlen (own_buf
+ 6);
2567 write_enn (own_buf
);
2572 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2574 write_enn (own_buf
);
2578 mon
[len
/ 2] = '\0';
2582 if (the_target
->pt
->handle_monitor_command (mon
) == 0)
2583 /* Default processing. */
2584 handle_monitor_command (mon
, own_buf
);
2590 if (startswith (own_buf
, "qSearch:memory:"))
2592 require_running_or_return (own_buf
);
2593 handle_search_memory (own_buf
, packet_len
);
2597 if (strcmp (own_buf
, "qAttached") == 0
2598 || startswith (own_buf
, "qAttached:"))
2600 struct process_info
*process
;
2602 if (own_buf
[sizeof ("qAttached") - 1])
2604 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2605 process
= find_process_pid (pid
);
2609 require_running_or_return (own_buf
);
2610 process
= current_process ();
2613 if (process
== NULL
)
2615 write_enn (own_buf
);
2619 strcpy (own_buf
, process
->attached
? "1" : "0");
2623 if (startswith (own_buf
, "qCRC:"))
2625 /* CRC check (compare-section). */
2629 unsigned long long crc
;
2631 require_running_or_return (own_buf
);
2632 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2633 if (*comma
++ != ',')
2635 write_enn (own_buf
);
2638 len
= strtoul (comma
, NULL
, 16);
2639 crc
= crc32 (base
, len
, 0xffffffff);
2640 /* Check for memory failure. */
2641 if (crc
== (unsigned long long) -1)
2643 write_enn (own_buf
);
2646 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2650 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2653 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2656 /* Otherwise we didn't know what packet it was. Say we didn't
2661 static void gdb_wants_all_threads_stopped (void);
2662 static void resume (struct thread_resume
*actions
, size_t n
);
2664 /* The callback that is passed to visit_actioned_threads. */
2665 typedef int (visit_actioned_threads_callback_ftype
)
2666 (const struct thread_resume
*, struct thread_info
*);
2668 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2669 true if CALLBACK returns true. Returns false if no matching thread
2670 is found or CALLBACK results false.
2671 Note: This function is itself a callback for find_thread. */
2674 visit_actioned_threads (thread_info
*thread
,
2675 const struct thread_resume
*actions
,
2677 visit_actioned_threads_callback_ftype
*callback
)
2679 for (size_t i
= 0; i
< num_actions
; i
++)
2681 const struct thread_resume
*action
= &actions
[i
];
2683 if (action
->thread
== minus_one_ptid
2684 || action
->thread
== thread
->id
2685 || ((action
->thread
.pid ()
2686 == thread
->id
.pid ())
2687 && action
->thread
.lwp () == -1))
2689 if ((*callback
) (action
, thread
))
2697 /* Callback for visit_actioned_threads. If the thread has a pending
2698 status to report, report it now. */
2701 handle_pending_status (const struct thread_resume
*resumption
,
2702 struct thread_info
*thread
)
2704 client_state
&cs
= get_client_state ();
2705 if (thread
->status_pending_p
)
2707 thread
->status_pending_p
= 0;
2709 cs
.last_status
= thread
->last_status
;
2710 cs
.last_ptid
= thread
->id
;
2711 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2717 /* Parse vCont packets. */
2719 handle_v_cont (char *own_buf
)
2723 struct thread_resume
*resume_info
;
2724 struct thread_resume default_action
{ null_ptid
};
2726 /* Count the number of semicolons in the packet. There should be one
2727 for every action. */
2733 p
= strchr (p
, ';');
2736 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2737 if (resume_info
== NULL
)
2745 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2747 if (p
[0] == 's' || p
[0] == 'S')
2748 resume_info
[i
].kind
= resume_step
;
2749 else if (p
[0] == 'r')
2750 resume_info
[i
].kind
= resume_step
;
2751 else if (p
[0] == 'c' || p
[0] == 'C')
2752 resume_info
[i
].kind
= resume_continue
;
2753 else if (p
[0] == 't')
2754 resume_info
[i
].kind
= resume_stop
;
2758 if (p
[0] == 'S' || p
[0] == 'C')
2761 int sig
= strtol (p
+ 1, &q
, 16);
2766 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2768 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2770 else if (p
[0] == 'r')
2774 p
= unpack_varlen_hex (p
+ 1, &addr
);
2775 resume_info
[i
].step_range_start
= addr
;
2780 p
= unpack_varlen_hex (p
+ 1, &addr
);
2781 resume_info
[i
].step_range_end
= addr
;
2790 resume_info
[i
].thread
= minus_one_ptid
;
2791 default_action
= resume_info
[i
];
2793 /* Note: we don't increment i here, we'll overwrite this entry
2794 the next time through. */
2796 else if (p
[0] == ':')
2799 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2804 if (p
[0] != ';' && p
[0] != 0)
2807 resume_info
[i
].thread
= ptid
;
2814 resume_info
[i
] = default_action
;
2816 resume (resume_info
, n
);
2821 write_enn (own_buf
);
2826 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2829 resume (struct thread_resume
*actions
, size_t num_actions
)
2831 client_state
&cs
= get_client_state ();
2834 /* Check if among the threads that GDB wants actioned, there's
2835 one with a pending status to report. If so, skip actually
2836 resuming/stopping and report the pending event
2839 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2841 return visit_actioned_threads (thread
, actions
, num_actions
,
2842 handle_pending_status
);
2845 if (thread_with_status
!= NULL
)
2851 the_target
->pt
->resume (actions
, num_actions
);
2854 write_ok (cs
.own_buf
);
2857 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2859 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2860 && !report_no_resumed
)
2862 /* The client does not support this stop reply. At least
2864 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2865 disable_async_io ();
2869 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2870 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2871 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2872 current_thread
->last_status
= cs
.last_status
;
2874 /* From the client's perspective, all-stop mode always stops all
2875 threads implicitly (and the target backend has already done
2876 so by now). Tag all threads as "want-stopped", so we don't
2877 resume them implicitly without the client telling us to. */
2878 gdb_wants_all_threads_stopped ();
2879 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2880 disable_async_io ();
2882 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2883 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2884 target_mourn_inferior (cs
.last_ptid
);
2888 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2890 handle_v_attach (char *own_buf
)
2892 client_state
&cs
= get_client_state ();
2895 pid
= strtol (own_buf
+ 8, NULL
, 16);
2896 if (pid
!= 0 && attach_inferior (pid
) == 0)
2898 /* Don't report shared library events after attaching, even if
2899 some libraries are preloaded. GDB will always poll the
2900 library list. Avoids the "stopped by shared library event"
2901 notice on the GDB side. */
2906 /* In non-stop, we don't send a resume reply. Stop events
2907 will follow up using the normal notification
2912 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2918 write_enn (own_buf
);
2923 /* Run a new program. Return 1 if successful, 0 if failure. */
2925 handle_v_run (char *own_buf
)
2927 client_state
&cs
= get_client_state ();
2929 std::vector
<char *> new_argv
;
2930 char *new_program_name
= NULL
;
2934 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2940 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2942 next_p
= strchr (p
, ';');
2944 next_p
= p
+ strlen (p
);
2946 if (i
== 0 && p
== next_p
)
2948 /* No program specified. */
2949 new_program_name
= NULL
;
2951 else if (p
== next_p
)
2953 /* Empty argument. */
2954 new_argv
.push_back (xstrdup ("''"));
2958 size_t len
= (next_p
- p
) / 2;
2959 /* ARG is the unquoted argument received via the RSP. */
2960 char *arg
= (char *) xmalloc (len
+ 1);
2961 /* FULL_ARGS will contain the quoted version of ARG. */
2962 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2963 /* These are pointers used to navigate the strings above. */
2964 char *tmp_arg
= arg
;
2965 char *tmp_full_arg
= full_arg
;
2968 hex2bin (p
, (gdb_byte
*) arg
, len
);
2971 while (*tmp_arg
!= '\0')
2977 *tmp_full_arg
= '\'';
2983 /* Quote single quote. */
2984 *tmp_full_arg
= '\\';
2992 *tmp_full_arg
= *tmp_arg
;
2998 *tmp_full_arg
++ = '\'';
3000 /* Finish FULL_ARG and push it into the vector containing
3002 *tmp_full_arg
= '\0';
3004 new_program_name
= full_arg
;
3006 new_argv
.push_back (full_arg
);
3012 new_argv
.push_back (NULL
);
3014 if (new_program_name
== NULL
)
3016 /* GDB didn't specify a program to run. Use the program from the
3017 last run with the new argument list. */
3018 if (program_path
.get () == NULL
)
3020 write_enn (own_buf
);
3021 free_vector_argv (new_argv
);
3026 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3028 /* Free the old argv and install the new one. */
3029 free_vector_argv (program_args
);
3030 program_args
= new_argv
;
3032 target_create_inferior (program_path
.get (), program_args
);
3034 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3036 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3038 /* In non-stop, sending a resume reply doesn't set the general
3039 thread, but GDB assumes a vRun sets it (this is so GDB can
3040 query which is the main thread of the new inferior. */
3042 cs
.general_thread
= cs
.last_ptid
;
3048 write_enn (own_buf
);
3053 /* Kill process. Return 1 if successful, 0 if failure. */
3055 handle_v_kill (char *own_buf
)
3057 client_state
&cs
= get_client_state ();
3059 char *p
= &own_buf
[6];
3060 if (cs
.multi_process
)
3061 pid
= strtol (p
, NULL
, 16);
3065 process_info
*proc
= find_process_pid (pid
);
3067 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3069 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3070 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3071 cs
.last_ptid
= ptid_t (pid
);
3072 discard_queued_stop_replies (cs
.last_ptid
);
3078 write_enn (own_buf
);
3083 /* Handle all of the extended 'v' packets. */
3085 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3087 client_state
&cs
= get_client_state ();
3088 if (!disable_packet_vCont
)
3090 if (strcmp (own_buf
, "vCtrlC") == 0)
3092 the_target
->pt
->request_interrupt ();
3097 if (startswith (own_buf
, "vCont;"))
3099 handle_v_cont (own_buf
);
3103 if (startswith (own_buf
, "vCont?"))
3105 strcpy (own_buf
, "vCont;c;C;t");
3107 if (target_supports_hardware_single_step ()
3108 || target_supports_software_single_step ()
3109 || !cs
.vCont_supported
)
3111 /* If target supports single step either by hardware or by
3112 software, add actions s and S to the list of supported
3113 actions. On the other hand, if GDB doesn't request the
3114 supported vCont actions in qSupported packet, add s and
3115 S to the list too. */
3116 own_buf
= own_buf
+ strlen (own_buf
);
3117 strcpy (own_buf
, ";s;S");
3120 if (target_supports_range_stepping ())
3122 own_buf
= own_buf
+ strlen (own_buf
);
3123 strcpy (own_buf
, ";r");
3129 if (startswith (own_buf
, "vFile:")
3130 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3133 if (startswith (own_buf
, "vAttach;"))
3135 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3137 fprintf (stderr
, "Already debugging a process\n");
3138 write_enn (own_buf
);
3141 handle_v_attach (own_buf
);
3145 if (startswith (own_buf
, "vRun;"))
3147 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3149 fprintf (stderr
, "Already debugging a process\n");
3150 write_enn (own_buf
);
3153 handle_v_run (own_buf
);
3157 if (startswith (own_buf
, "vKill;"))
3159 if (!target_running ())
3161 fprintf (stderr
, "No process to kill\n");
3162 write_enn (own_buf
);
3165 handle_v_kill (own_buf
);
3169 if (handle_notif_ack (own_buf
, packet_len
))
3172 /* Otherwise we didn't know what packet it was. Say we didn't
3178 /* Resume thread and wait for another event. In non-stop mode,
3179 don't really wait here, but return immediatelly to the event
3182 myresume (char *own_buf
, int step
, int sig
)
3184 client_state
&cs
= get_client_state ();
3185 struct thread_resume resume_info
[2];
3187 int valid_cont_thread
;
3189 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3190 && cs
.cont_thread
!= minus_one_ptid
);
3192 if (step
|| sig
|| valid_cont_thread
)
3194 resume_info
[0].thread
= current_ptid
;
3196 resume_info
[0].kind
= resume_step
;
3198 resume_info
[0].kind
= resume_continue
;
3199 resume_info
[0].sig
= sig
;
3203 if (!valid_cont_thread
)
3205 resume_info
[n
].thread
= minus_one_ptid
;
3206 resume_info
[n
].kind
= resume_continue
;
3207 resume_info
[n
].sig
= 0;
3211 resume (resume_info
, n
);
3214 /* Callback for for_each_thread. Make a new stop reply for each
3218 queue_stop_reply_callback (thread_info
*thread
)
3220 /* For now, assume targets that don't have this callback also don't
3221 manage the thread's last_status field. */
3222 if (!the_target
->pt
->supports_thread_stopped ())
3224 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3226 new_notif
->ptid
= thread
->id
;
3227 new_notif
->status
= thread
->last_status
;
3228 /* Pass the last stop reply back to GDB, but don't notify
3230 notif_event_enque (¬if_stop
, new_notif
);
3234 if (target_thread_stopped (thread
))
3238 std::string status_string
3239 = target_waitstatus_to_string (&thread
->last_status
);
3241 debug_printf ("Reporting thread %s as already stopped with %s\n",
3242 target_pid_to_str (thread
->id
),
3243 status_string
.c_str ());
3246 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3248 /* Pass the last stop reply back to GDB, but don't notify
3250 queue_stop_reply (thread
->id
, &thread
->last_status
);
3255 /* Set this inferior threads's state as "want-stopped". We won't
3256 resume this thread until the client gives us another action for
3260 gdb_wants_thread_stopped (thread_info
*thread
)
3262 thread
->last_resume_kind
= resume_stop
;
3264 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3266 /* Most threads are stopped implicitly (all-stop); tag that with
3268 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3269 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3273 /* Set all threads' states as "want-stopped". */
3276 gdb_wants_all_threads_stopped (void)
3278 for_each_thread (gdb_wants_thread_stopped
);
3281 /* Callback for for_each_thread. If the thread is stopped with an
3282 interesting event, mark it as having a pending event. */
3285 set_pending_status_callback (thread_info
*thread
)
3287 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3288 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3289 /* A breakpoint, watchpoint or finished step from a previous
3290 GDB run isn't considered interesting for a new GDB run.
3291 If we left those pending, the new GDB could consider them
3292 random SIGTRAPs. This leaves out real async traps. We'd
3293 have to peek into the (target-specific) siginfo to
3294 distinguish those. */
3295 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3296 thread
->status_pending_p
= 1;
3299 /* Status handler for the '?' packet. */
3302 handle_status (char *own_buf
)
3304 client_state
&cs
= get_client_state ();
3306 /* GDB is connected, don't forward events to the target anymore. */
3307 for_each_process ([] (process_info
*process
) {
3308 process
->gdb_detached
= 0;
3311 /* In non-stop mode, we must send a stop reply for each stopped
3312 thread. In all-stop mode, just send one for the first stopped
3317 for_each_thread (queue_stop_reply_callback
);
3319 /* The first is sent immediatly. OK is sent if there is no
3320 stopped thread, which is the same handling of the vStopped
3321 packet (by design). */
3322 notif_write_event (¬if_stop
, cs
.own_buf
);
3326 thread_info
*thread
= NULL
;
3328 target_pause_all (false);
3329 target_stabilize_threads ();
3330 gdb_wants_all_threads_stopped ();
3332 /* We can only report one status, but we might be coming out of
3333 non-stop -- if more than one thread is stopped with
3334 interesting events, leave events for the threads we're not
3335 reporting now pending. They'll be reported the next time the
3336 threads are resumed. Start by marking all interesting events
3338 for_each_thread (set_pending_status_callback
);
3340 /* Prefer the last thread that reported an event to GDB (even if
3341 that was a GDB_SIGNAL_TRAP). */
3342 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3343 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3344 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3345 thread
= find_thread_ptid (cs
.last_ptid
);
3347 /* If the last event thread is not found for some reason, look
3348 for some other thread that might have an event to report. */
3350 thread
= find_thread ([] (thread_info
*thr_arg
)
3352 return thr_arg
->status_pending_p
;
3355 /* If we're still out of luck, simply pick the first thread in
3358 thread
= get_first_thread ();
3362 struct thread_info
*tp
= (struct thread_info
*) thread
;
3364 /* We're reporting this event, so it's no longer
3366 tp
->status_pending_p
= 0;
3368 /* GDB assumes the current thread is the thread we're
3369 reporting the status for. */
3370 cs
.general_thread
= thread
->id
;
3371 set_desired_thread ();
3373 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3374 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3377 strcpy (own_buf
, "W00");
3382 gdbserver_version (void)
3384 printf ("GNU gdbserver %s%s\n"
3385 "Copyright (C) 2020 Free Software Foundation, Inc.\n"
3386 "gdbserver is free software, covered by the "
3387 "GNU General Public License.\n"
3388 "This gdbserver was configured as \"%s\"\n",
3389 PKGVERSION
, version
, host_name
);
3393 gdbserver_usage (FILE *stream
)
3395 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3396 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3397 "\tgdbserver [OPTIONS] --multi COMM\n"
3399 "COMM may either be a tty device (for serial debugging),\n"
3400 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3401 "stdin/stdout of gdbserver.\n"
3402 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3403 "PID is the process ID to attach to, when --attach is specified.\n"
3405 "Operating modes:\n"
3407 " --attach Attach to running process PID.\n"
3408 " --multi Start server without a specific program, and\n"
3409 " only quit when explicitly commanded.\n"
3410 " --once Exit after the first connection has closed.\n"
3411 " --help Print this message and then exit.\n"
3412 " --version Display version information and exit.\n"
3416 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3417 " --disable-randomization\n"
3418 " Run PROG with address space randomization disabled.\n"
3419 " --no-disable-randomization\n"
3420 " Don't disable address space randomization when\n"
3422 " --startup-with-shell\n"
3423 " Start PROG using a shell. I.e., execs a shell that\n"
3424 " then execs PROG. (default)\n"
3425 " --no-startup-with-shell\n"
3426 " Exec PROG directly instead of using a shell.\n"
3427 " Disables argument globbing and variable substitution\n"
3428 " on UNIX-like systems.\n"
3432 " --debug Enable general debugging output.\n"
3433 " --debug-format=OPT1[,OPT2,...]\n"
3434 " Specify extra content in debugging output.\n"
3439 " --remote-debug Enable remote protocol debugging output.\n"
3440 " --disable-packet=OPT1[,OPT2,...]\n"
3441 " Disable support for RSP packets or features.\n"
3443 " vCont, Tthread, qC, qfThreadInfo and \n"
3444 " threads (disable all threading packets).\n"
3446 "For more information, consult the GDB manual (available as on-line \n"
3447 "info or a printed manual).\n");
3448 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3449 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3453 gdbserver_show_disableable (FILE *stream
)
3455 fprintf (stream
, "Disableable packets:\n"
3456 " vCont \tAll vCont packets\n"
3457 " qC \tQuerying the current thread\n"
3458 " qfThreadInfo\tThread listing\n"
3459 " Tthread \tPassing the thread specifier in the "
3460 "T stop reply packet\n"
3461 " threads \tAll of the above\n");
3465 kill_inferior_callback (process_info
*process
)
3467 kill_inferior (process
);
3468 discard_queued_stop_replies (ptid_t (process
->pid
));
3471 /* Call this when exiting gdbserver with possible inferiors that need
3472 to be killed or detached from. */
3475 detach_or_kill_for_exit (void)
3477 /* First print a list of the inferiors we will be killing/detaching.
3478 This is to assist the user, for example, in case the inferior unexpectedly
3479 dies after we exit: did we screw up or did the inferior exit on its own?
3480 Having this info will save some head-scratching. */
3482 if (have_started_inferiors_p ())
3484 fprintf (stderr
, "Killing process(es):");
3486 for_each_process ([] (process_info
*process
) {
3487 if (!process
->attached
)
3488 fprintf (stderr
, " %d", process
->pid
);
3491 fprintf (stderr
, "\n");
3493 if (have_attached_inferiors_p ())
3495 fprintf (stderr
, "Detaching process(es):");
3497 for_each_process ([] (process_info
*process
) {
3498 if (process
->attached
)
3499 fprintf (stderr
, " %d", process
->pid
);
3502 fprintf (stderr
, "\n");
3505 /* Now we can kill or detach the inferiors. */
3506 for_each_process ([] (process_info
*process
) {
3507 int pid
= process
->pid
;
3509 if (process
->attached
)
3510 detach_inferior (process
);
3512 kill_inferior (process
);
3514 discard_queued_stop_replies (ptid_t (pid
));
3518 /* Value that will be passed to exit(3) when gdbserver exits. */
3519 static int exit_code
;
3521 /* Wrapper for detach_or_kill_for_exit that catches and prints
3525 detach_or_kill_for_exit_cleanup ()
3529 detach_or_kill_for_exit ();
3531 catch (const gdb_exception
&exception
)
3534 fprintf (stderr
, "Detach or kill failed: %s\n",
3540 /* Main function. This is called by the real "main" function,
3541 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3543 static void ATTRIBUTE_NORETURN
3544 captured_main (int argc
, char *argv
[])
3549 const char *port
= NULL
;
3550 char **next_arg
= &argv
[1];
3551 volatile int multi_mode
= 0;
3552 volatile int attach
= 0;
3554 bool selftest
= false;
3556 const char *selftest_filter
= NULL
;
3559 current_directory
= getcwd (NULL
, 0);
3560 client_state
&cs
= get_client_state ();
3562 if (current_directory
== NULL
)
3564 error (_("Could not find current working directory: %s"),
3565 safe_strerror (errno
));
3568 while (*next_arg
!= NULL
&& **next_arg
== '-')
3570 if (strcmp (*next_arg
, "--version") == 0)
3572 gdbserver_version ();
3575 else if (strcmp (*next_arg
, "--help") == 0)
3577 gdbserver_usage (stdout
);
3580 else if (strcmp (*next_arg
, "--attach") == 0)
3582 else if (strcmp (*next_arg
, "--multi") == 0)
3584 else if (strcmp (*next_arg
, "--wrapper") == 0)
3591 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3593 wrapper_argv
+= *next_arg
;
3594 wrapper_argv
+= ' ';
3598 if (!wrapper_argv
.empty ())
3600 /* Erase the last whitespace. */
3601 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3604 if (next_arg
== tmp
|| *next_arg
== NULL
)
3606 gdbserver_usage (stderr
);
3610 /* Consume the "--". */
3613 else if (strcmp (*next_arg
, "--debug") == 0)
3615 else if (startswith (*next_arg
, "--debug-format="))
3617 std::string error_msg
3618 = parse_debug_format_options ((*next_arg
)
3619 + sizeof ("--debug-format=") - 1, 0);
3621 if (!error_msg
.empty ())
3623 fprintf (stderr
, "%s", error_msg
.c_str ());
3627 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3629 else if (startswith (*next_arg
, "--debug-file="))
3630 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3631 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3633 gdbserver_show_disableable (stdout
);
3636 else if (startswith (*next_arg
, "--disable-packet="))
3638 char *packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3640 for (char *tok
= strtok_r (packets
, ",", &saveptr
);
3642 tok
= strtok_r (NULL
, ",", &saveptr
))
3644 if (strcmp ("vCont", tok
) == 0)
3645 disable_packet_vCont
= true;
3646 else if (strcmp ("Tthread", tok
) == 0)
3647 disable_packet_Tthread
= true;
3648 else if (strcmp ("qC", tok
) == 0)
3649 disable_packet_qC
= true;
3650 else if (strcmp ("qfThreadInfo", tok
) == 0)
3651 disable_packet_qfThreadInfo
= true;
3652 else if (strcmp ("threads", tok
) == 0)
3654 disable_packet_vCont
= true;
3655 disable_packet_Tthread
= true;
3656 disable_packet_qC
= true;
3657 disable_packet_qfThreadInfo
= true;
3661 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3663 gdbserver_show_disableable (stderr
);
3668 else if (strcmp (*next_arg
, "-") == 0)
3670 /* "-" specifies a stdio connection and is a form of port
3672 port
= STDIO_CONNECTION_NAME
;
3676 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3677 cs
.disable_randomization
= 1;
3678 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3679 cs
.disable_randomization
= 0;
3680 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3681 startup_with_shell
= true;
3682 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3683 startup_with_shell
= false;
3684 else if (strcmp (*next_arg
, "--once") == 0)
3686 else if (strcmp (*next_arg
, "--selftest") == 0)
3688 else if (startswith (*next_arg
, "--selftest="))
3692 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3697 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3710 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3713 gdbserver_usage (stderr
);
3717 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3718 opened by remote_prepare. */
3721 save_original_signals_state (false);
3723 /* We need to know whether the remote connection is stdio before
3724 starting the inferior. Inferiors created in this scenario have
3725 stdin,stdout redirected. So do this here before we call
3728 remote_prepare (port
);
3733 /* --attach used to come after PORT, so allow it there for
3735 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3742 && (*next_arg
== NULL
3743 || (*next_arg
)[0] == '\0'
3744 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3746 || next_arg
[1] != NULL
))
3751 gdbserver_usage (stderr
);
3755 /* Gather information about the environment. */
3756 our_environ
= gdb_environ::from_host_environ ();
3758 initialize_async_io ();
3760 have_job_control ();
3761 initialize_event_loop ();
3762 if (target_supports_tracepoints ())
3763 initialize_tracepoint ();
3765 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3770 selftests::run_tests (selftest_filter
);
3772 printf (_("Selftests have been disabled for this build.\n"));
3774 throw_quit ("Quit");
3777 if (pid
== 0 && *next_arg
!= NULL
)
3781 n
= argc
- (next_arg
- argv
);
3782 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3783 for (i
= 1; i
< n
; i
++)
3784 program_args
.push_back (xstrdup (next_arg
[i
]));
3785 program_args
.push_back (NULL
);
3787 /* Wait till we are at first instruction in program. */
3788 target_create_inferior (program_path
.get (), program_args
);
3790 /* We are now (hopefully) stopped at the first instruction of
3791 the target process. This assumes that the target process was
3792 successfully created. */
3796 if (attach_inferior (pid
) == -1)
3797 error ("Attaching not supported on this target");
3799 /* Otherwise succeeded. */
3803 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3804 cs
.last_status
.value
.integer
= 0;
3805 cs
.last_ptid
= minus_one_ptid
;
3808 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3810 /* Don't report shared library events on the initial connection,
3811 even if some libraries are preloaded. Avoids the "stopped by
3812 shared library event" notice on gdb side. */
3815 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3816 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3821 if (!was_running
&& !multi_mode
)
3822 error ("No program to debug");
3827 cs
.multi_process
= 0;
3828 cs
.report_fork_events
= 0;
3829 cs
.report_vfork_events
= 0;
3830 cs
.report_exec_events
= 0;
3831 /* Be sure we're out of tfind mode. */
3832 cs
.current_traceframe
= -1;
3833 cs
.cont_thread
= null_ptid
;
3834 cs
.swbreak_feature
= 0;
3835 cs
.hwbreak_feature
= 0;
3836 cs
.vCont_supported
= 0;
3842 /* Wait for events. This will return when all event sources
3843 are removed from the event loop. */
3844 start_event_loop ();
3846 /* If an exit was requested (using the "monitor exit"
3847 command), terminate now. */
3849 throw_quit ("Quit");
3851 /* The only other way to get here is for getpkt to fail:
3853 - If --once was specified, we're done.
3855 - If not in extended-remote mode, and we're no longer
3856 debugging anything, simply exit: GDB has disconnected
3857 after processing the last process exit.
3859 - Otherwise, close the connection and reopen it at the
3861 if (run_once
|| (!extended_protocol
&& !target_running ()))
3862 throw_quit ("Quit");
3865 "Remote side has terminated connection. "
3866 "GDBserver will reopen the connection.\n");
3868 /* Get rid of any pending statuses. An eventual reconnection
3869 (by the same GDB instance or another) will refresh all its
3870 state from scratch. */
3871 discard_queued_stop_replies (minus_one_ptid
);
3872 for_each_thread ([] (thread_info
*thread
)
3874 thread
->status_pending_p
= 0;
3879 if (disconnected_tracing
)
3881 /* Try to enable non-stop/async mode, so we we can
3882 both wait for an async socket accept, and handle
3883 async target events simultaneously. There's also
3884 no point either in having the target always stop
3885 all threads, when we're going to pass signals
3886 down without informing GDB. */
3889 if (the_target
->pt
->start_non_stop (true))
3892 /* Detaching implicitly resumes all threads;
3893 simply disconnecting does not. */
3899 "Disconnected tracing disabled; "
3900 "stopping trace run.\n");
3905 catch (const gdb_exception_error
&exception
)
3908 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3910 if (response_needed
)
3912 write_enn (cs
.own_buf
);
3913 putpkt (cs
.own_buf
);
3917 throw_quit ("Quit");
3922 /* Main function. */
3925 main (int argc
, char *argv
[])
3930 captured_main (argc
, argv
);
3932 catch (const gdb_exception
&exception
)
3934 if (exception
.reason
== RETURN_ERROR
)
3937 fprintf (stderr
, "%s\n", exception
.what ());
3938 fprintf (stderr
, "Exiting\n");
3945 gdb_assert_not_reached ("captured_main should never return");
3948 /* Process options coming from Z packets for a breakpoint. PACKET is
3949 the packet buffer. *PACKET is updated to point to the first char
3950 after the last processed option. */
3953 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3955 const char *dataptr
= *packet
;
3958 /* Check if data has the correct format. */
3959 if (*dataptr
!= ';')
3966 if (*dataptr
== ';')
3969 if (*dataptr
== 'X')
3971 /* Conditional expression. */
3973 debug_printf ("Found breakpoint condition.\n");
3974 if (!add_breakpoint_condition (bp
, &dataptr
))
3975 dataptr
= strchrnul (dataptr
, ';');
3977 else if (startswith (dataptr
, "cmds:"))
3979 dataptr
+= strlen ("cmds:");
3981 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3982 persist
= (*dataptr
== '1');
3984 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3985 dataptr
= strchrnul (dataptr
, ';');
3989 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3991 /* Skip tokens until we find one that we recognize. */
3992 dataptr
= strchrnul (dataptr
, ';');
3998 /* Event loop callback that handles a serial event. The first byte in
3999 the serial buffer gets us here. We expect characters to arrive at
4000 a brisk pace, so we read the rest of the packet with a blocking
4004 process_serial_event (void)
4006 client_state
&cs
= get_client_state ();
4012 int new_packet_len
= -1;
4014 disable_async_io ();
4016 response_needed
= false;
4017 packet_len
= getpkt (cs
.own_buf
);
4018 if (packet_len
<= 0)
4021 /* Force an event loop break. */
4024 response_needed
= true;
4026 char ch
= cs
.own_buf
[0];
4030 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4033 handle_general_set (cs
.own_buf
);
4036 handle_detach (cs
.own_buf
);
4039 extended_protocol
= true;
4040 write_ok (cs
.own_buf
);
4043 handle_status (cs
.own_buf
);
4046 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4048 require_running_or_break (cs
.own_buf
);
4050 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4052 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4053 thread_id
= null_ptid
;
4054 else if (thread_id
.is_pid ())
4056 /* The ptid represents a pid. */
4057 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4061 write_enn (cs
.own_buf
);
4065 thread_id
= thread
->id
;
4069 /* The ptid represents a lwp/tid. */
4070 if (find_thread_ptid (thread_id
) == NULL
)
4072 write_enn (cs
.own_buf
);
4077 if (cs
.own_buf
[1] == 'g')
4079 if (thread_id
== null_ptid
)
4081 /* GDB is telling us to choose any thread. Check if
4082 the currently selected thread is still valid. If
4083 it is not, select the first available. */
4084 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4086 thread
= get_first_thread ();
4087 thread_id
= thread
->id
;
4090 cs
.general_thread
= thread_id
;
4091 set_desired_thread ();
4092 gdb_assert (current_thread
!= NULL
);
4094 else if (cs
.own_buf
[1] == 'c')
4095 cs
.cont_thread
= thread_id
;
4097 write_ok (cs
.own_buf
);
4101 /* Silently ignore it so that gdb can extend the protocol
4102 without compatibility headaches. */
4103 cs
.own_buf
[0] = '\0';
4107 require_running_or_break (cs
.own_buf
);
4108 if (cs
.current_traceframe
>= 0)
4110 struct regcache
*regcache
4111 = new_register_cache (current_target_desc ());
4113 if (fetch_traceframe_registers (cs
.current_traceframe
,
4115 registers_to_string (regcache
, cs
.own_buf
);
4117 write_enn (cs
.own_buf
);
4118 free_register_cache (regcache
);
4122 struct regcache
*regcache
;
4124 if (!set_desired_thread ())
4125 write_enn (cs
.own_buf
);
4128 regcache
= get_thread_regcache (current_thread
, 1);
4129 registers_to_string (regcache
, cs
.own_buf
);
4134 require_running_or_break (cs
.own_buf
);
4135 if (cs
.current_traceframe
>= 0)
4136 write_enn (cs
.own_buf
);
4139 struct regcache
*regcache
;
4141 if (!set_desired_thread ())
4142 write_enn (cs
.own_buf
);
4145 regcache
= get_thread_regcache (current_thread
, 1);
4146 registers_from_string (regcache
, &cs
.own_buf
[1]);
4147 write_ok (cs
.own_buf
);
4153 require_running_or_break (cs
.own_buf
);
4154 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4155 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4157 write_enn (cs
.own_buf
);
4159 bin2hex (mem_buf
, cs
.own_buf
, res
);
4163 require_running_or_break (cs
.own_buf
);
4164 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4165 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4166 write_ok (cs
.own_buf
);
4168 write_enn (cs
.own_buf
);
4171 require_running_or_break (cs
.own_buf
);
4172 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4173 &mem_addr
, &len
, &mem_buf
) < 0
4174 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4175 write_enn (cs
.own_buf
);
4177 write_ok (cs
.own_buf
);
4180 require_running_or_break (cs
.own_buf
);
4181 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4182 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4183 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4186 myresume (cs
.own_buf
, 0, signal
);
4189 require_running_or_break (cs
.own_buf
);
4190 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4191 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4192 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4195 myresume (cs
.own_buf
, 1, signal
);
4198 require_running_or_break (cs
.own_buf
);
4200 myresume (cs
.own_buf
, 0, signal
);
4203 require_running_or_break (cs
.own_buf
);
4205 myresume (cs
.own_buf
, 1, signal
);
4207 case 'Z': /* insert_ ... */
4209 case 'z': /* remove_ ... */
4214 char type
= cs
.own_buf
[1];
4216 const int insert
= ch
== 'Z';
4217 const char *p
= &cs
.own_buf
[3];
4219 p
= unpack_varlen_hex (p
, &addr
);
4220 kind
= strtol (p
+ 1, &dataptr
, 16);
4224 struct gdb_breakpoint
*bp
;
4226 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4231 /* GDB may have sent us a list of *point parameters to
4232 be evaluated on the target's side. Read such list
4233 here. If we already have a list of parameters, GDB
4234 is telling us to drop that list and use this one
4236 clear_breakpoint_conditions_and_commands (bp
);
4237 const char *options
= dataptr
;
4238 process_point_options (bp
, &options
);
4242 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4245 write_ok (cs
.own_buf
);
4248 cs
.own_buf
[0] = '\0';
4250 write_enn (cs
.own_buf
);
4254 response_needed
= false;
4255 if (!target_running ())
4256 /* The packet we received doesn't make sense - but we can't
4257 reply to it, either. */
4260 fprintf (stderr
, "Killing all inferiors\n");
4262 for_each_process (kill_inferior_callback
);
4264 /* When using the extended protocol, we wait with no program
4265 running. The traditional protocol will exit instead. */
4266 if (extended_protocol
)
4268 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4269 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4277 require_running_or_break (cs
.own_buf
);
4279 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4280 if (find_thread_ptid (thread_id
) == NULL
)
4282 write_enn (cs
.own_buf
);
4286 if (mythread_alive (thread_id
))
4287 write_ok (cs
.own_buf
);
4289 write_enn (cs
.own_buf
);
4293 response_needed
= false;
4295 /* Restarting the inferior is only supported in the extended
4297 if (extended_protocol
)
4299 if (target_running ())
4300 for_each_process (kill_inferior_callback
);
4302 fprintf (stderr
, "GDBserver restarting\n");
4304 /* Wait till we are at 1st instruction in prog. */
4305 if (program_path
.get () != NULL
)
4307 target_create_inferior (program_path
.get (), program_args
);
4309 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4311 /* Stopped at the first instruction of the target
4313 cs
.general_thread
= cs
.last_ptid
;
4317 /* Something went wrong. */
4318 cs
.general_thread
= null_ptid
;
4323 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4324 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4330 /* It is a request we don't understand. Respond with an
4331 empty packet so that gdb knows that we don't support this
4333 cs
.own_buf
[0] = '\0';
4337 /* Extended (long) request. */
4338 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4342 /* It is a request we don't understand. Respond with an empty
4343 packet so that gdb knows that we don't support this
4345 cs
.own_buf
[0] = '\0';
4349 if (new_packet_len
!= -1)
4350 putpkt_binary (cs
.own_buf
, new_packet_len
);
4352 putpkt (cs
.own_buf
);
4354 response_needed
= false;
4362 /* Event-loop callback for serial events. */
4365 handle_serial_event (int err
, gdb_client_data client_data
)
4368 debug_printf ("handling possible serial event\n");
4370 /* Really handle it. */
4371 if (process_serial_event () < 0)
4374 /* Be sure to not change the selected thread behind GDB's back.
4375 Important in the non-stop mode asynchronous protocol. */
4376 set_desired_thread ();
4381 /* Push a stop notification on the notification queue. */
4384 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4386 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4388 vstop_notif
->status
= *status
;
4389 vstop_notif
->ptid
= ptid
;
4390 /* Push Stop notification. */
4391 notif_push (¬if_stop
, vstop_notif
);
4394 /* Event-loop callback for target events. */
4397 handle_target_event (int err
, gdb_client_data client_data
)
4399 client_state
&cs
= get_client_state ();
4401 debug_printf ("handling possible target event\n");
4403 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4406 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4408 if (gdb_connected () && report_no_resumed
)
4409 push_stop_notification (null_ptid
, &cs
.last_status
);
4411 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4413 int pid
= cs
.last_ptid
.pid ();
4414 struct process_info
*process
= find_process_pid (pid
);
4415 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4417 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4418 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4420 mark_breakpoints_out (process
);
4421 target_mourn_inferior (cs
.last_ptid
);
4423 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4427 /* We're reporting this thread as stopped. Update its
4428 "want-stopped" state to what the client wants, until it
4429 gets a new resume action. */
4430 current_thread
->last_resume_kind
= resume_stop
;
4431 current_thread
->last_status
= cs
.last_status
;
4436 if (!target_running ())
4438 /* The last process exited. We're done. */
4442 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4443 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4444 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4448 /* A thread stopped with a signal, but gdb isn't
4449 connected to handle it. Pass it down to the
4450 inferior, as if it wasn't being traced. */
4451 enum gdb_signal signal
;
4454 debug_printf ("GDB not connected; forwarding event %d for"
4456 (int) cs
.last_status
.kind
,
4457 target_pid_to_str (cs
.last_ptid
));
4459 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4460 signal
= cs
.last_status
.value
.sig
;
4462 signal
= GDB_SIGNAL_0
;
4463 target_continue (cs
.last_ptid
, signal
);
4467 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4470 /* Be sure to not change the selected thread behind GDB's back.
4471 Important in the non-stop mode asynchronous protocol. */
4472 set_desired_thread ();
4485 } // namespace selftests
4486 #endif /* GDB_SELF_TEST */