1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2019 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 "gdbsupport/selftest.h"
46 #include "gdbsupport/scope-exit.h"
48 #define require_running_or_return(BUF) \
49 if (!target_running ()) \
55 #define require_running_or_break(BUF) \
56 if (!target_running ()) \
62 /* String containing the current directory (what getwd would return). */
64 char *current_directory
;
66 /* The environment to pass to the inferior when creating it. */
68 static gdb_environ our_environ
;
72 static int extended_protocol
;
73 static int response_needed
;
74 static int exit_requested
;
76 /* --once: Exit after the first connection has closed. */
79 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
80 static int report_no_resumed
;
85 /* Set the PROGRAM_PATH. Here we adjust the path of the provided
87 void set (gdb::unique_xmalloc_ptr
<char> &&path
)
89 m_path
= std::move (path
);
91 /* Make sure we're using the absolute path of the inferior when
93 if (!contains_dir_separator (m_path
.get ()))
97 /* Check if the file is in our CWD. If it is, then we prefix
98 its name with CURRENT_DIRECTORY. Otherwise, we leave the
99 name as-is because we'll try searching for it in $PATH. */
100 if (is_regular_file (m_path
.get (), ®_file_errno
))
101 m_path
= gdb_abspath (m_path
.get ());
105 /* Return the PROGRAM_PATH. */
107 { return m_path
.get (); }
110 /* The program name, adjusted if needed. */
111 gdb::unique_xmalloc_ptr
<char> m_path
;
113 static std::vector
<char *> program_args
;
114 static std::string wrapper_argv
;
116 /* The PID of the originally created or attached inferior. Used to
117 send signals to the process when GDB sends us an asynchronous interrupt
118 (user hitting Control-C in the client), and to wait for the child to exit
119 when no longer debugging it. */
121 unsigned long signal_pid
;
123 /* Set if you want to disable optional thread related packets support
124 in gdbserver, for the sake of testing GDB against stubs that don't
126 int disable_packet_vCont
;
127 int disable_packet_Tthread
;
128 int disable_packet_qC
;
129 int disable_packet_qfThreadInfo
;
131 static unsigned char *mem_buf
;
133 /* A sub-class of 'struct notif_event' for stop, holding information
134 relative to a single stop reply. We keep a queue of these to
135 push to GDB in non-stop mode. */
137 struct vstop_notif
: public notif_event
139 /* Thread or process that got the event. */
143 struct target_waitstatus status
;
146 /* The current btrace configuration. This is gdbserver's mirror of GDB's
147 btrace configuration. */
148 static struct btrace_config current_btrace_conf
;
150 /* The client remote protocol state. */
152 static client_state g_client_state
;
157 client_state
&cs
= g_client_state
;
162 /* Put a stop reply to the stop reply queue. */
165 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
167 struct vstop_notif
*new_notif
= new struct vstop_notif
;
169 new_notif
->ptid
= ptid
;
170 new_notif
->status
= *status
;
172 notif_event_enque (¬if_stop
, new_notif
);
176 remove_all_on_match_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
178 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
180 return vstop_event
->ptid
.matches (filter_ptid
);
186 discard_queued_stop_replies (ptid_t ptid
)
188 std::list
<notif_event
*>::iterator iter
, next
, end
;
189 end
= notif_stop
.queue
.end ();
190 for (iter
= notif_stop
.queue
.begin (); iter
!= end
; iter
= next
)
195 if (remove_all_on_match_ptid (*iter
, ptid
))
198 notif_stop
.queue
.erase (iter
);
204 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
206 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
208 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
211 /* Helper for in_queued_stop_replies. */
214 in_queued_stop_replies_ptid (struct notif_event
*event
, ptid_t filter_ptid
)
216 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
218 if (vstop_event
->ptid
.matches (filter_ptid
))
221 /* Don't resume fork children that GDB does not know about yet. */
222 if ((vstop_event
->status
.kind
== TARGET_WAITKIND_FORKED
223 || vstop_event
->status
.kind
== TARGET_WAITKIND_VFORKED
)
224 && vstop_event
->status
.value
.related_pid
.matches (filter_ptid
))
233 in_queued_stop_replies (ptid_t ptid
)
235 for (notif_event
*event
: notif_stop
.queue
)
237 if (in_queued_stop_replies_ptid (event
, ptid
))
244 struct notif_server notif_stop
=
246 "vStopped", "Stop", {}, vstop_notif_reply
,
250 target_running (void)
252 return get_first_thread () != NULL
;
255 /* See gdbsupport/common-inferior.h. */
260 return !wrapper_argv
.empty () ? wrapper_argv
.c_str () : NULL
;
263 /* See gdbsupport/common-inferior.h. */
266 get_exec_file (int err
)
268 if (err
&& program_path
.get () == NULL
)
269 error (_("No executable file specified."));
271 return program_path
.get ();
283 attach_inferior (int pid
)
285 client_state
&cs
= get_client_state ();
286 /* myattach should return -1 if attaching is unsupported,
287 0 if it succeeded, and call error() otherwise. */
289 if (find_process_pid (pid
) != nullptr)
290 error ("Already attached to process %d\n", pid
);
292 if (myattach (pid
) != 0)
295 fprintf (stderr
, "Attached; pid = %d\n", pid
);
298 /* FIXME - It may be that we should get the SIGNAL_PID from the
299 attach function, so that it can be the main thread instead of
300 whichever we were told to attach to. */
305 cs
.last_ptid
= mywait (ptid_t (pid
), &cs
.last_status
, 0, 0);
307 /* GDB knows to ignore the first SIGSTOP after attaching to a running
308 process using the "attach" command, but this is different; it's
309 just using "target remote". Pretend it's just starting up. */
310 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
311 && cs
.last_status
.value
.sig
== GDB_SIGNAL_STOP
)
312 cs
.last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
314 current_thread
->last_resume_kind
= resume_stop
;
315 current_thread
->last_status
= cs
.last_status
;
321 /* Decode a qXfer read request. Return 0 if everything looks OK,
325 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
327 /* After the read marker and annex, qXfer looks like a
328 traditional 'm' packet. */
329 decode_m_packet (buf
, ofs
, len
);
335 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
337 /* Extract and NUL-terminate the object. */
339 while (*buf
&& *buf
!= ':')
345 /* Extract and NUL-terminate the read/write action. */
347 while (*buf
&& *buf
!= ':')
353 /* Extract and NUL-terminate the annex. */
355 while (*buf
&& *buf
!= ':')
365 /* Write the response to a successful qXfer read. Returns the
366 length of the (binary) data stored in BUF, corresponding
367 to as much of DATA/LEN as we could fit. IS_MORE controls
368 the first character of the response. */
370 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
379 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
380 &out_len
, PBUFSIZ
- 2) + 1;
383 /* Handle btrace enabling in BTS format. */
386 handle_btrace_enable_bts (struct thread_info
*thread
)
388 if (thread
->btrace
!= NULL
)
389 error (_("Btrace already enabled."));
391 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
392 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
395 /* Handle btrace enabling in Intel Processor Trace format. */
398 handle_btrace_enable_pt (struct thread_info
*thread
)
400 if (thread
->btrace
!= NULL
)
401 error (_("Btrace already enabled."));
403 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
404 thread
->btrace
= target_enable_btrace (thread
->id
, ¤t_btrace_conf
);
407 /* Handle btrace disabling. */
410 handle_btrace_disable (struct thread_info
*thread
)
413 if (thread
->btrace
== NULL
)
414 error (_("Branch tracing not enabled."));
416 if (target_disable_btrace (thread
->btrace
) != 0)
417 error (_("Could not disable branch tracing."));
419 thread
->btrace
= NULL
;
422 /* Handle the "Qbtrace" packet. */
425 handle_btrace_general_set (char *own_buf
)
427 client_state
&cs
= get_client_state ();
428 struct thread_info
*thread
;
431 if (!startswith (own_buf
, "Qbtrace:"))
434 op
= own_buf
+ strlen ("Qbtrace:");
436 if (cs
.general_thread
== null_ptid
437 || cs
.general_thread
== minus_one_ptid
)
439 strcpy (own_buf
, "E.Must select a single thread.");
443 thread
= find_thread_ptid (cs
.general_thread
);
446 strcpy (own_buf
, "E.No such thread.");
452 if (strcmp (op
, "bts") == 0)
453 handle_btrace_enable_bts (thread
);
454 else if (strcmp (op
, "pt") == 0)
455 handle_btrace_enable_pt (thread
);
456 else if (strcmp (op
, "off") == 0)
457 handle_btrace_disable (thread
);
459 error (_("Bad Qbtrace operation. Use bts, pt, or off."));
463 catch (const gdb_exception_error
&exception
)
465 sprintf (own_buf
, "E.%s", exception
.what ());
471 /* Handle the "Qbtrace-conf" packet. */
474 handle_btrace_conf_general_set (char *own_buf
)
476 client_state
&cs
= get_client_state ();
477 struct thread_info
*thread
;
480 if (!startswith (own_buf
, "Qbtrace-conf:"))
483 op
= own_buf
+ strlen ("Qbtrace-conf:");
485 if (cs
.general_thread
== null_ptid
486 || cs
.general_thread
== minus_one_ptid
)
488 strcpy (own_buf
, "E.Must select a single thread.");
492 thread
= find_thread_ptid (cs
.general_thread
);
495 strcpy (own_buf
, "E.No such thread.");
499 if (startswith (op
, "bts:size="))
505 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
506 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
508 strcpy (own_buf
, "E.Bad size value.");
512 current_btrace_conf
.bts
.size
= (unsigned int) size
;
514 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
520 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
521 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
523 strcpy (own_buf
, "E.Bad size value.");
527 current_btrace_conf
.pt
.size
= (unsigned int) size
;
531 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
539 /* Handle all of the extended 'Q' packets. */
542 handle_general_set (char *own_buf
)
544 client_state
&cs
= get_client_state ();
545 if (startswith (own_buf
, "QPassSignals:"))
547 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
548 const char *p
= own_buf
+ strlen ("QPassSignals:");
551 p
= decode_address_to_semicolon (&cursig
, p
);
552 for (i
= 0; i
< numsigs
; i
++)
556 cs
.pass_signals
[i
] = 1;
558 /* Keep looping, to clear the remaining signals. */
561 p
= decode_address_to_semicolon (&cursig
, p
);
564 cs
.pass_signals
[i
] = 0;
566 strcpy (own_buf
, "OK");
570 if (startswith (own_buf
, "QProgramSignals:"))
572 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
573 const char *p
= own_buf
+ strlen ("QProgramSignals:");
576 cs
.program_signals_p
= 1;
578 p
= decode_address_to_semicolon (&cursig
, p
);
579 for (i
= 0; i
< numsigs
; i
++)
583 cs
.program_signals
[i
] = 1;
585 /* Keep looping, to clear the remaining signals. */
588 p
= decode_address_to_semicolon (&cursig
, p
);
591 cs
.program_signals
[i
] = 0;
593 strcpy (own_buf
, "OK");
597 if (startswith (own_buf
, "QCatchSyscalls:"))
599 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
602 struct process_info
*process
;
604 if (!target_running () || !target_supports_catch_syscall ())
610 if (strcmp (p
, "0") == 0)
612 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
616 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
622 process
= current_process ();
623 process
->syscalls_to_catch
.clear ();
633 p
= decode_address_to_semicolon (&sysno
, p
);
634 process
->syscalls_to_catch
.push_back (sysno
);
638 process
->syscalls_to_catch
.push_back (ANY_SYSCALL
);
645 if (strcmp (own_buf
, "QEnvironmentReset") == 0)
647 our_environ
= gdb_environ::from_host_environ ();
653 if (startswith (own_buf
, "QEnvironmentHexEncoded:"))
655 const char *p
= own_buf
+ sizeof ("QEnvironmentHexEncoded:") - 1;
656 /* The final form of the environment variable. FINAL_VAR will
657 hold the 'VAR=VALUE' format. */
658 std::string final_var
= hex2str (p
);
659 std::string var_name
, var_value
;
663 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p
);
664 debug_printf (_("[Environment variable to be set: '%s']\n"),
669 size_t pos
= final_var
.find ('=');
670 if (pos
== std::string::npos
)
672 warning (_("Unexpected format for environment variable: '%s'"),
678 var_name
= final_var
.substr (0, pos
);
679 var_value
= final_var
.substr (pos
+ 1, std::string::npos
);
681 our_environ
.set (var_name
.c_str (), var_value
.c_str ());
687 if (startswith (own_buf
, "QEnvironmentUnset:"))
689 const char *p
= own_buf
+ sizeof ("QEnvironmentUnset:") - 1;
690 std::string varname
= hex2str (p
);
694 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p
);
695 debug_printf (_("[Environment variable to be unset: '%s']\n"),
700 our_environ
.unset (varname
.c_str ());
706 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
710 debug_printf ("[noack mode enabled]\n");
719 if (startswith (own_buf
, "QNonStop:"))
721 char *mode
= own_buf
+ 9;
725 if (strcmp (mode
, "0") == 0)
727 else if (strcmp (mode
, "1") == 0)
731 /* We don't know what this mode is, so complain to
733 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
739 req_str
= req
? "non-stop" : "all-stop";
740 if (start_non_stop (req
) != 0)
742 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
750 debug_printf ("[%s mode enabled]\n", req_str
);
756 if (startswith (own_buf
, "QDisableRandomization:"))
758 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
761 unpack_varlen_hex (packet
, &setting
);
762 cs
.disable_randomization
= setting
;
766 debug_printf (cs
.disable_randomization
767 ? "[address space randomization disabled]\n"
768 : "[address space randomization enabled]\n");
775 if (target_supports_tracepoints ()
776 && handle_tracepoint_general_set (own_buf
))
779 if (startswith (own_buf
, "QAgent:"))
781 char *mode
= own_buf
+ strlen ("QAgent:");
784 if (strcmp (mode
, "0") == 0)
786 else if (strcmp (mode
, "1") == 0)
790 /* We don't know what this value is, so complain to GDB. */
791 sprintf (own_buf
, "E.Unknown QAgent value");
795 /* Update the flag. */
798 debug_printf ("[%s agent]\n", req
? "Enable" : "Disable");
803 if (handle_btrace_general_set (own_buf
))
806 if (handle_btrace_conf_general_set (own_buf
))
809 if (startswith (own_buf
, "QThreadEvents:"))
811 char *mode
= own_buf
+ strlen ("QThreadEvents:");
812 enum tribool req
= TRIBOOL_UNKNOWN
;
814 if (strcmp (mode
, "0") == 0)
816 else if (strcmp (mode
, "1") == 0)
820 /* We don't know what this mode is, so complain to GDB. */
821 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
826 cs
.report_thread_events
= (req
== TRIBOOL_TRUE
);
830 const char *req_str
= cs
.report_thread_events
? "enabled" : "disabled";
832 debug_printf ("[thread events are now %s]\n", req_str
);
839 if (startswith (own_buf
, "QStartupWithShell:"))
841 const char *value
= own_buf
+ strlen ("QStartupWithShell:");
843 if (strcmp (value
, "1") == 0)
844 startup_with_shell
= true;
845 else if (strcmp (value
, "0") == 0)
846 startup_with_shell
= false;
850 fprintf (stderr
, "Unknown value to startup-with-shell: %s\n",
857 debug_printf (_("[Inferior will %s started with shell]"),
858 startup_with_shell
? "be" : "not be");
864 if (startswith (own_buf
, "QSetWorkingDir:"))
866 const char *p
= own_buf
+ strlen ("QSetWorkingDir:");
870 std::string path
= hex2str (p
);
872 set_inferior_cwd (path
.c_str ());
875 debug_printf (_("[Set the inferior's current directory to %s]\n"),
880 /* An empty argument means that we should clear out any
881 previously set cwd for the inferior. */
882 set_inferior_cwd (NULL
);
886 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
893 /* Otherwise we didn't know what packet it was. Say we didn't
899 get_features_xml (const char *annex
)
901 const struct target_desc
*desc
= current_target_desc ();
903 /* `desc->xmltarget' defines what to return when looking for the
904 "target.xml" file. Its contents can either be verbatim XML code
905 (prefixed with a '@') or else the name of the actual XML file to
906 be used in place of "target.xml".
908 This variable is set up from the auto-generated
909 init_registers_... routine for the current target. */
911 if (strcmp (annex
, "target.xml") == 0)
913 const char *ret
= tdesc_get_features_xml (desc
);
923 extern const char *const xml_builtin
[][2];
926 /* Look for the annex. */
927 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
928 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
931 if (xml_builtin
[i
][0] != NULL
)
932 return xml_builtin
[i
][1];
940 monitor_show_help (void)
942 monitor_output ("The following monitor commands are supported:\n");
943 monitor_output (" set debug <0|1>\n");
944 monitor_output (" Enable general debugging messages\n");
945 monitor_output (" set debug-hw-points <0|1>\n");
946 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
947 monitor_output (" set remote-debug <0|1>\n");
948 monitor_output (" Enable remote protocol debugging messages\n");
949 monitor_output (" set debug-format option1[,option2,...]\n");
950 monitor_output (" Add additional information to debugging messages\n");
951 monitor_output (" Options: all, none");
952 monitor_output (", timestamp");
953 monitor_output ("\n");
954 monitor_output (" exit\n");
955 monitor_output (" Quit GDBserver\n");
958 /* Read trace frame or inferior memory. Returns the number of bytes
959 actually read, zero when no further transfer is possible, and -1 on
960 error. Return of a positive value smaller than LEN does not
961 indicate there's no more to be read, only the end of the transfer.
962 E.g., when GDB reads memory from a traceframe, a first request may
963 be served from a memory block that does not cover the whole request
964 length. A following request gets the rest served from either
965 another block (of the same traceframe) or from the read-only
969 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
971 client_state
&cs
= get_client_state ();
974 if (cs
.current_traceframe
>= 0)
977 ULONGEST length
= len
;
979 if (traceframe_read_mem (cs
.current_traceframe
,
980 memaddr
, myaddr
, len
, &nbytes
))
982 /* Data read from trace buffer, we're done. */
985 if (!in_readonly_region (memaddr
, length
))
987 /* Otherwise we have a valid readonly case, fall through. */
988 /* (assume no half-trace half-real blocks for now) */
991 res
= prepare_to_access_memory ();
994 if (set_desired_thread ())
995 res
= read_inferior_memory (memaddr
, myaddr
, len
);
998 done_accessing_memory ();
1000 return res
== 0 ? len
: -1;
1006 /* Write trace frame or inferior memory. Actually, writing to trace
1007 frames is forbidden. */
1010 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1012 client_state
&cs
= get_client_state ();
1013 if (cs
.current_traceframe
>= 0)
1019 ret
= prepare_to_access_memory ();
1022 if (set_desired_thread ())
1023 ret
= target_write_memory (memaddr
, myaddr
, len
);
1026 done_accessing_memory ();
1032 /* Subroutine of handle_search_memory to simplify it. */
1035 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
1036 gdb_byte
*pattern
, unsigned pattern_len
,
1037 gdb_byte
*search_buf
,
1038 unsigned chunk_size
, unsigned search_buf_size
,
1039 CORE_ADDR
*found_addrp
)
1041 /* Prime the search buffer. */
1043 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
1046 warning ("Unable to access %ld bytes of target "
1047 "memory at 0x%lx, halting search.",
1048 (long) search_buf_size
, (long) start_addr
);
1052 /* Perform the search.
1054 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1055 When we've scanned N bytes we copy the trailing bytes to the start and
1056 read in another N bytes. */
1058 while (search_space_len
>= pattern_len
)
1060 gdb_byte
*found_ptr
;
1061 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
1065 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
1068 if (found_ptr
!= NULL
)
1070 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1071 *found_addrp
= found_addr
;
1075 /* Not found in this chunk, skip to next chunk. */
1077 /* Don't let search_space_len wrap here, it's unsigned. */
1078 if (search_space_len
>= chunk_size
)
1079 search_space_len
-= chunk_size
;
1081 search_space_len
= 0;
1083 if (search_space_len
>= pattern_len
)
1085 unsigned keep_len
= search_buf_size
- chunk_size
;
1086 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1089 /* Copy the trailing part of the previous iteration to the front
1090 of the buffer for the next iteration. */
1091 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1093 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1094 ? search_space_len
- keep_len
1097 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1098 nr_to_read
) != search_buf_size
)
1100 warning ("Unable to access %ld bytes of target memory "
1101 "at 0x%lx, halting search.",
1102 (long) nr_to_read
, (long) read_addr
);
1106 start_addr
+= chunk_size
;
1115 /* Handle qSearch:memory packets. */
1118 handle_search_memory (char *own_buf
, int packet_len
)
1120 CORE_ADDR start_addr
;
1121 CORE_ADDR search_space_len
;
1123 unsigned int pattern_len
;
1124 /* NOTE: also defined in find.c testcase. */
1125 #define SEARCH_CHUNK_SIZE 16000
1126 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1127 /* Buffer to hold memory contents for searching. */
1128 gdb_byte
*search_buf
;
1129 unsigned search_buf_size
;
1131 CORE_ADDR found_addr
;
1132 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1134 pattern
= (gdb_byte
*) malloc (packet_len
);
1135 if (pattern
== NULL
)
1137 error ("Unable to allocate memory to perform the search");
1138 strcpy (own_buf
, "E00");
1141 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1142 packet_len
- cmd_name_len
,
1143 &start_addr
, &search_space_len
,
1144 pattern
, &pattern_len
) < 0)
1147 error ("Error in parsing qSearch:memory packet");
1148 strcpy (own_buf
, "E00");
1152 search_buf_size
= chunk_size
+ pattern_len
- 1;
1154 /* No point in trying to allocate a buffer larger than the search space. */
1155 if (search_space_len
< search_buf_size
)
1156 search_buf_size
= search_space_len
;
1158 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1159 if (search_buf
== NULL
)
1162 error ("Unable to allocate memory to perform the search");
1163 strcpy (own_buf
, "E00");
1167 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1168 pattern
, pattern_len
,
1169 search_buf
, chunk_size
, search_buf_size
,
1173 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1174 else if (found
== 0)
1175 strcpy (own_buf
, "0");
1177 strcpy (own_buf
, "E00");
1183 /* Handle the "D" packet. */
1186 handle_detach (char *own_buf
)
1188 client_state
&cs
= get_client_state ();
1190 process_info
*process
;
1192 if (cs
.multi_process
)
1195 int pid
= strtol (&own_buf
[2], NULL
, 16);
1197 process
= find_process_pid (pid
);
1201 process
= (current_thread
!= nullptr
1202 ? get_thread_process (current_thread
)
1206 if (process
== NULL
)
1208 write_enn (own_buf
);
1212 if ((tracing
&& disconnected_tracing
) || any_persistent_commands (process
))
1214 if (tracing
&& disconnected_tracing
)
1216 "Disconnected tracing in effect, "
1217 "leaving gdbserver attached to the process\n");
1219 if (any_persistent_commands (process
))
1221 "Persistent commands are present, "
1222 "leaving gdbserver attached to the process\n");
1224 /* Make sure we're in non-stop/async mode, so we we can both
1225 wait for an async socket accept, and handle async target
1226 events simultaneously. There's also no point either in
1227 having the target stop all threads, when we're going to
1228 pass signals down without informing GDB. */
1232 debug_printf ("Forcing non-stop mode\n");
1238 process
->gdb_detached
= 1;
1240 /* Detaching implicitly resumes all threads. */
1241 target_continue_no_signal (minus_one_ptid
);
1247 fprintf (stderr
, "Detaching from process %d\n", process
->pid
);
1250 /* We'll need this after PROCESS has been destroyed. */
1251 int pid
= process
->pid
;
1253 if (detach_inferior (process
) != 0)
1254 write_enn (own_buf
);
1257 discard_queued_stop_replies (ptid_t (pid
));
1260 if (extended_protocol
|| target_running ())
1262 /* There is still at least one inferior remaining or
1263 we are in extended mode, so don't terminate gdbserver,
1264 and instead treat this like a normal program exit. */
1265 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
1266 cs
.last_status
.value
.integer
= 0;
1267 cs
.last_ptid
= ptid_t (pid
);
1269 current_thread
= NULL
;
1276 /* If we are attached, then we can exit. Otherwise, we
1277 need to hang around doing nothing, until the child is
1279 join_inferior (pid
);
1285 /* Parse options to --debug-format= and "monitor set debug-format".
1286 ARG is the text after "--debug-format=" or "monitor set debug-format".
1287 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1288 This triggers calls to monitor_output.
1289 The result is an empty string if all options were parsed ok, otherwise an
1290 error message which the caller must free.
1292 N.B. These commands affect all debug format settings, they are not
1293 cumulative. If a format is not specified, it is turned off.
1294 However, we don't go to extra trouble with things like
1295 "monitor set debug-format all,none,timestamp".
1296 Instead we just parse them one at a time, in order.
1298 The syntax for "monitor set debug" we support here is not identical
1299 to gdb's "set debug foo on|off" because we also use this function to
1300 parse "--debug-format=foo,bar". */
1303 parse_debug_format_options (const char *arg
, int is_monitor
)
1305 /* First turn all debug format options off. */
1306 debug_timestamp
= 0;
1308 /* First remove leading spaces, for "monitor set debug-format". */
1309 while (isspace (*arg
))
1312 std::vector
<gdb::unique_xmalloc_ptr
<char>> options
1313 = delim_string_to_char_ptr_vec (arg
, ',');
1315 for (const gdb::unique_xmalloc_ptr
<char> &option
: options
)
1317 if (strcmp (option
.get (), "all") == 0)
1319 debug_timestamp
= 1;
1321 monitor_output ("All extra debug format options enabled.\n");
1323 else if (strcmp (option
.get (), "none") == 0)
1325 debug_timestamp
= 0;
1327 monitor_output ("All extra debug format options disabled.\n");
1329 else if (strcmp (option
.get (), "timestamp") == 0)
1331 debug_timestamp
= 1;
1333 monitor_output ("Timestamps will be added to debug output.\n");
1335 else if (*option
== '\0')
1337 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1341 return string_printf ("Unknown debug-format argument: \"%s\"\n",
1345 return std::string ();
1348 /* Handle monitor commands not handled by target-specific handlers. */
1351 handle_monitor_command (char *mon
, char *own_buf
)
1353 if (strcmp (mon
, "set debug 1") == 0)
1356 monitor_output ("Debug output enabled.\n");
1358 else if (strcmp (mon
, "set debug 0") == 0)
1361 monitor_output ("Debug output disabled.\n");
1363 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1365 show_debug_regs
= 1;
1366 monitor_output ("H/W point debugging output enabled.\n");
1368 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1370 show_debug_regs
= 0;
1371 monitor_output ("H/W point debugging output disabled.\n");
1373 else if (strcmp (mon
, "set remote-debug 1") == 0)
1376 monitor_output ("Protocol debug output enabled.\n");
1378 else if (strcmp (mon
, "set remote-debug 0") == 0)
1381 monitor_output ("Protocol debug output disabled.\n");
1383 else if (startswith (mon
, "set debug-format "))
1385 std::string error_msg
1386 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1389 if (!error_msg
.empty ())
1391 monitor_output (error_msg
.c_str ());
1392 monitor_show_help ();
1393 write_enn (own_buf
);
1396 else if (strcmp (mon
, "set debug-file") == 0)
1397 debug_set_output (nullptr);
1398 else if (startswith (mon
, "set debug-file "))
1399 debug_set_output (mon
+ sizeof ("set debug-file ") - 1);
1400 else if (strcmp (mon
, "help") == 0)
1401 monitor_show_help ();
1402 else if (strcmp (mon
, "exit") == 0)
1406 monitor_output ("Unknown monitor command.\n\n");
1407 monitor_show_help ();
1408 write_enn (own_buf
);
1412 /* Associates a callback with each supported qXfer'able object. */
1416 /* The object this handler handles. */
1419 /* Request that the target transfer up to LEN 8-bit bytes of the
1420 target's OBJECT. The OFFSET, for a seekable object, specifies
1421 the starting point. The ANNEX can be used to provide additional
1422 data-specific information to the target.
1424 Return the number of bytes actually transfered, zero when no
1425 further transfer is possible, -1 on error, -2 when the transfer
1426 is not supported, and -3 on a verbose error message that should
1427 be preserved. Return of a positive value smaller than LEN does
1428 not indicate the end of the object, only the end of the transfer.
1430 One, and only one, of readbuf or writebuf must be non-NULL. */
1431 int (*xfer
) (const char *annex
,
1432 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1433 ULONGEST offset
, LONGEST len
);
1436 /* Handle qXfer:auxv:read. */
1439 handle_qxfer_auxv (const char *annex
,
1440 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1441 ULONGEST offset
, LONGEST len
)
1443 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1446 if (annex
[0] != '\0' || current_thread
== NULL
)
1449 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1452 /* Handle qXfer:exec-file:read. */
1455 handle_qxfer_exec_file (const char *annex
,
1456 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1457 ULONGEST offset
, LONGEST len
)
1463 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1466 if (annex
[0] == '\0')
1468 if (current_thread
== NULL
)
1471 pid
= pid_of (current_thread
);
1475 annex
= unpack_varlen_hex (annex
, &pid
);
1476 if (annex
[0] != '\0')
1483 file
= (*the_target
->pid_to_exec_file
) (pid
);
1487 total_len
= strlen (file
);
1489 if (offset
> total_len
)
1492 if (offset
+ len
> total_len
)
1493 len
= total_len
- offset
;
1495 memcpy (readbuf
, file
+ offset
, len
);
1499 /* Handle qXfer:features:read. */
1502 handle_qxfer_features (const char *annex
,
1503 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1504 ULONGEST offset
, LONGEST len
)
1506 const char *document
;
1509 if (writebuf
!= NULL
)
1512 if (!target_running ())
1515 /* Grab the correct annex. */
1516 document
= get_features_xml (annex
);
1517 if (document
== NULL
)
1520 total_len
= strlen (document
);
1522 if (offset
> total_len
)
1525 if (offset
+ len
> total_len
)
1526 len
= total_len
- offset
;
1528 memcpy (readbuf
, document
+ offset
, len
);
1532 /* Handle qXfer:libraries:read. */
1535 handle_qxfer_libraries (const char *annex
,
1536 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1537 ULONGEST offset
, LONGEST len
)
1539 if (writebuf
!= NULL
)
1542 if (annex
[0] != '\0' || current_thread
== NULL
)
1545 std::string document
= "<library-list version=\"1.0\">\n";
1547 for (const dll_info
&dll
: all_dlls
)
1548 document
+= string_printf
1549 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1550 dll
.name
.c_str (), (long) dll
.base_addr
);
1552 document
+= "</library-list>\n";
1554 if (offset
> document
.length ())
1557 if (offset
+ len
> document
.length ())
1558 len
= document
.length () - offset
;
1560 memcpy (readbuf
, &document
[offset
], len
);
1565 /* Handle qXfer:libraries-svr4:read. */
1568 handle_qxfer_libraries_svr4 (const char *annex
,
1569 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1570 ULONGEST offset
, LONGEST len
)
1572 if (writebuf
!= NULL
)
1575 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1578 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1581 /* Handle qXfer:osadata:read. */
1584 handle_qxfer_osdata (const char *annex
,
1585 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1586 ULONGEST offset
, LONGEST len
)
1588 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1591 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1594 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1597 handle_qxfer_siginfo (const char *annex
,
1598 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1599 ULONGEST offset
, LONGEST len
)
1601 if (the_target
->qxfer_siginfo
== NULL
)
1604 if (annex
[0] != '\0' || current_thread
== NULL
)
1607 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1610 /* Handle qXfer:statictrace:read. */
1613 handle_qxfer_statictrace (const char *annex
,
1614 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1615 ULONGEST offset
, LONGEST len
)
1617 client_state
&cs
= get_client_state ();
1620 if (writebuf
!= NULL
)
1623 if (annex
[0] != '\0' || current_thread
== NULL
1624 || cs
.current_traceframe
== -1)
1627 if (traceframe_read_sdata (cs
.current_traceframe
, offset
,
1628 readbuf
, len
, &nbytes
))
1633 /* Helper for handle_qxfer_threads_proper.
1634 Emit the XML to describe the thread of INF. */
1637 handle_qxfer_threads_worker (thread_info
*thread
, struct buffer
*buffer
)
1639 ptid_t ptid
= ptid_of (thread
);
1641 int core
= target_core_of_thread (ptid
);
1643 const char *name
= target_thread_name (ptid
);
1646 bool handle_status
= target_thread_handle (ptid
, &handle
, &handle_len
);
1648 write_ptid (ptid_s
, ptid
);
1650 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1654 sprintf (core_s
, "%d", core
);
1655 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1659 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1663 char *handle_s
= (char *) alloca (handle_len
* 2 + 1);
1664 bin2hex (handle
, handle_s
, handle_len
);
1665 buffer_xml_printf (buffer
, " handle=\"%s\"", handle_s
);
1668 buffer_xml_printf (buffer
, "/>\n");
1671 /* Helper for handle_qxfer_threads. */
1674 handle_qxfer_threads_proper (struct buffer
*buffer
)
1676 buffer_grow_str (buffer
, "<threads>\n");
1678 for_each_thread ([&] (thread_info
*thread
)
1680 handle_qxfer_threads_worker (thread
, buffer
);
1683 buffer_grow_str0 (buffer
, "</threads>\n");
1686 /* Handle qXfer:threads:read. */
1689 handle_qxfer_threads (const char *annex
,
1690 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1691 ULONGEST offset
, LONGEST len
)
1693 static char *result
= 0;
1694 static unsigned int result_length
= 0;
1696 if (writebuf
!= NULL
)
1699 if (annex
[0] != '\0')
1704 struct buffer buffer
;
1705 /* When asked for data at offset 0, generate everything and store into
1706 'result'. Successive reads will be served off 'result'. */
1710 buffer_init (&buffer
);
1712 handle_qxfer_threads_proper (&buffer
);
1714 result
= buffer_finish (&buffer
);
1715 result_length
= strlen (result
);
1716 buffer_free (&buffer
);
1719 if (offset
>= result_length
)
1721 /* We're out of data. */
1728 if (len
> result_length
- offset
)
1729 len
= result_length
- offset
;
1731 memcpy (readbuf
, result
+ offset
, len
);
1736 /* Handle qXfer:traceframe-info:read. */
1739 handle_qxfer_traceframe_info (const char *annex
,
1740 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1741 ULONGEST offset
, LONGEST len
)
1743 client_state
&cs
= get_client_state ();
1744 static char *result
= 0;
1745 static unsigned int result_length
= 0;
1747 if (writebuf
!= NULL
)
1750 if (!target_running () || annex
[0] != '\0' || cs
.current_traceframe
== -1)
1755 struct buffer buffer
;
1757 /* When asked for data at offset 0, generate everything and
1758 store into 'result'. Successive reads will be served off
1762 buffer_init (&buffer
);
1764 traceframe_read_info (cs
.current_traceframe
, &buffer
);
1766 result
= buffer_finish (&buffer
);
1767 result_length
= strlen (result
);
1768 buffer_free (&buffer
);
1771 if (offset
>= result_length
)
1773 /* We're out of data. */
1780 if (len
> result_length
- offset
)
1781 len
= result_length
- offset
;
1783 memcpy (readbuf
, result
+ offset
, len
);
1787 /* Handle qXfer:fdpic:read. */
1790 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1791 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1793 if (the_target
->read_loadmap
== NULL
)
1796 if (current_thread
== NULL
)
1799 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1802 /* Handle qXfer:btrace:read. */
1805 handle_qxfer_btrace (const char *annex
,
1806 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1807 ULONGEST offset
, LONGEST len
)
1809 client_state
&cs
= get_client_state ();
1810 static struct buffer cache
;
1811 struct thread_info
*thread
;
1812 enum btrace_read_type type
;
1815 if (writebuf
!= NULL
)
1818 if (cs
.general_thread
== null_ptid
1819 || cs
.general_thread
== minus_one_ptid
)
1821 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1825 thread
= find_thread_ptid (cs
.general_thread
);
1828 strcpy (cs
.own_buf
, "E.No such thread.");
1832 if (thread
->btrace
== NULL
)
1834 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1838 if (strcmp (annex
, "all") == 0)
1839 type
= BTRACE_READ_ALL
;
1840 else if (strcmp (annex
, "new") == 0)
1841 type
= BTRACE_READ_NEW
;
1842 else if (strcmp (annex
, "delta") == 0)
1843 type
= BTRACE_READ_DELTA
;
1846 strcpy (cs
.own_buf
, "E.Bad annex.");
1852 buffer_free (&cache
);
1856 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1858 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1860 catch (const gdb_exception_error
&exception
)
1862 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1869 else if (offset
> cache
.used_size
)
1871 buffer_free (&cache
);
1875 if (len
> cache
.used_size
- offset
)
1876 len
= cache
.used_size
- offset
;
1878 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1883 /* Handle qXfer:btrace-conf:read. */
1886 handle_qxfer_btrace_conf (const char *annex
,
1887 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1888 ULONGEST offset
, LONGEST len
)
1890 client_state
&cs
= get_client_state ();
1891 static struct buffer cache
;
1892 struct thread_info
*thread
;
1895 if (writebuf
!= NULL
)
1898 if (annex
[0] != '\0')
1901 if (cs
.general_thread
== null_ptid
1902 || cs
.general_thread
== minus_one_ptid
)
1904 strcpy (cs
.own_buf
, "E.Must select a single thread.");
1908 thread
= find_thread_ptid (cs
.general_thread
);
1911 strcpy (cs
.own_buf
, "E.No such thread.");
1915 if (thread
->btrace
== NULL
)
1917 strcpy (cs
.own_buf
, "E.Btrace not enabled.");
1923 buffer_free (&cache
);
1927 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1929 memcpy (cs
.own_buf
, cache
.buffer
, cache
.used_size
);
1931 catch (const gdb_exception_error
&exception
)
1933 sprintf (cs
.own_buf
, "E.%s", exception
.what ());
1940 else if (offset
> cache
.used_size
)
1942 buffer_free (&cache
);
1946 if (len
> cache
.used_size
- offset
)
1947 len
= cache
.used_size
- offset
;
1949 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1954 static const struct qxfer qxfer_packets
[] =
1956 { "auxv", handle_qxfer_auxv
},
1957 { "btrace", handle_qxfer_btrace
},
1958 { "btrace-conf", handle_qxfer_btrace_conf
},
1959 { "exec-file", handle_qxfer_exec_file
},
1960 { "fdpic", handle_qxfer_fdpic
},
1961 { "features", handle_qxfer_features
},
1962 { "libraries", handle_qxfer_libraries
},
1963 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1964 { "osdata", handle_qxfer_osdata
},
1965 { "siginfo", handle_qxfer_siginfo
},
1966 { "statictrace", handle_qxfer_statictrace
},
1967 { "threads", handle_qxfer_threads
},
1968 { "traceframe-info", handle_qxfer_traceframe_info
},
1972 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1980 if (!startswith (own_buf
, "qXfer:"))
1983 /* Grab the object, r/w and annex. */
1984 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1986 write_enn (own_buf
);
1991 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1994 const struct qxfer
*q
= &qxfer_packets
[i
];
1996 if (strcmp (object
, q
->object
) == 0)
1998 if (strcmp (rw
, "read") == 0)
2000 unsigned char *data
;
2005 /* Grab the offset and length. */
2006 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
2008 write_enn (own_buf
);
2012 /* Read one extra byte, as an indicator of whether there is
2014 if (len
> PBUFSIZ
- 2)
2016 data
= (unsigned char *) malloc (len
+ 1);
2019 write_enn (own_buf
);
2022 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
2030 /* Preserve error message. */
2033 write_enn (own_buf
);
2035 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
2037 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
2042 else if (strcmp (rw
, "write") == 0)
2047 unsigned char *data
;
2049 strcpy (own_buf
, "E00");
2050 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
2053 write_enn (own_buf
);
2056 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
2057 &ofs
, &len
, data
) < 0)
2060 write_enn (own_buf
);
2064 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
2072 /* Preserve error message. */
2075 write_enn (own_buf
);
2077 sprintf (own_buf
, "%x", n
);
2090 /* Compute 32 bit CRC from inferior memory.
2092 On success, return 32 bit CRC.
2093 On failure, return (unsigned long long) -1. */
2095 static unsigned long long
2096 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
2100 unsigned char byte
= 0;
2102 /* Return failure if memory read fails. */
2103 if (read_inferior_memory (base
, &byte
, 1) != 0)
2104 return (unsigned long long) -1;
2106 crc
= xcrc32 (&byte
, 1, crc
);
2109 return (unsigned long long) crc
;
2112 /* Add supported btrace packets to BUF. */
2115 supported_btrace_packets (char *buf
)
2117 strcat (buf
, ";Qbtrace:bts+");
2118 strcat (buf
, ";Qbtrace-conf:bts:size+");
2119 strcat (buf
, ";Qbtrace:pt+");
2120 strcat (buf
, ";Qbtrace-conf:pt:size+");
2121 strcat (buf
, ";Qbtrace:off+");
2122 strcat (buf
, ";qXfer:btrace:read+");
2123 strcat (buf
, ";qXfer:btrace-conf:read+");
2126 /* Handle all of the extended 'q' packets. */
2129 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2131 client_state
&cs
= get_client_state ();
2132 static std::list
<thread_info
*>::const_iterator thread_iter
;
2134 /* Reply the current thread id. */
2135 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2138 require_running_or_return (own_buf
);
2140 if (cs
.general_thread
!= null_ptid
&& cs
.general_thread
!= minus_one_ptid
)
2141 ptid
= cs
.general_thread
;
2144 thread_iter
= all_threads
.begin ();
2145 ptid
= (*thread_iter
)->id
;
2148 sprintf (own_buf
, "QC");
2150 write_ptid (own_buf
, ptid
);
2154 if (strcmp ("qSymbol::", own_buf
) == 0)
2156 struct thread_info
*save_thread
= current_thread
;
2158 /* For qSymbol, GDB only changes the current thread if the
2159 previous current thread was of a different process. So if
2160 the previous thread is gone, we need to pick another one of
2161 the same process. This can happen e.g., if we followed an
2162 exec in a non-leader thread. */
2163 if (current_thread
== NULL
)
2166 = find_any_thread_of_pid (cs
.general_thread
.pid ());
2168 /* Just in case, if we didn't find a thread, then bail out
2169 instead of crashing. */
2170 if (current_thread
== NULL
)
2172 write_enn (own_buf
);
2173 current_thread
= save_thread
;
2178 /* GDB is suggesting new symbols have been loaded. This may
2179 mean a new shared library has been detected as loaded, so
2180 take the opportunity to check if breakpoints we think are
2181 inserted, still are. Note that it isn't guaranteed that
2182 we'll see this when a shared library is loaded, and nor will
2183 we see this for unloads (although breakpoints in unloaded
2184 libraries shouldn't trigger), as GDB may not find symbols for
2185 the library at all. We also re-validate breakpoints when we
2186 see a second GDB breakpoint for the same address, and or when
2187 we access breakpoint shadows. */
2188 validate_breakpoints ();
2190 if (target_supports_tracepoints ())
2191 tracepoint_look_up_symbols ();
2193 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2194 (*the_target
->look_up_symbols
) ();
2196 current_thread
= save_thread
;
2198 strcpy (own_buf
, "OK");
2202 if (!disable_packet_qfThreadInfo
)
2204 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2206 require_running_or_return (own_buf
);
2207 thread_iter
= all_threads
.begin ();
2210 ptid_t ptid
= (*thread_iter
)->id
;
2211 write_ptid (own_buf
, ptid
);
2216 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2218 require_running_or_return (own_buf
);
2219 if (thread_iter
!= all_threads
.end ())
2222 ptid_t ptid
= (*thread_iter
)->id
;
2223 write_ptid (own_buf
, ptid
);
2229 sprintf (own_buf
, "l");
2235 if (the_target
->read_offsets
!= NULL
2236 && strcmp ("qOffsets", own_buf
) == 0)
2238 CORE_ADDR text
, data
;
2240 require_running_or_return (own_buf
);
2241 if (the_target
->read_offsets (&text
, &data
))
2242 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2243 (long)text
, (long)data
, (long)data
);
2245 write_enn (own_buf
);
2250 /* Protocol features query. */
2251 if (startswith (own_buf
, "qSupported")
2252 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2254 char *p
= &own_buf
[10];
2255 int gdb_supports_qRelocInsn
= 0;
2257 /* Process each feature being provided by GDB. The first
2258 feature will follow a ':', and latter features will follow
2262 char **qsupported
= NULL
;
2267 /* Two passes, to avoid nested strtok calls in
2268 target_process_qsupported. */
2269 for (p
= strtok (p
+ 1, ";");
2271 p
= strtok (NULL
, ";"))
2274 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2275 qsupported
[count
- 1] = xstrdup (p
);
2278 for (i
= 0; i
< count
; i
++)
2281 if (strcmp (p
, "multiprocess+") == 0)
2283 /* GDB supports and wants multi-process support if
2285 if (target_supports_multi_process ())
2286 cs
.multi_process
= 1;
2288 else if (strcmp (p
, "qRelocInsn+") == 0)
2290 /* GDB supports relocate instruction requests. */
2291 gdb_supports_qRelocInsn
= 1;
2293 else if (strcmp (p
, "swbreak+") == 0)
2295 /* GDB wants us to report whether a trap is caused
2296 by a software breakpoint and for us to handle PC
2297 adjustment if necessary on this target. */
2298 if (target_supports_stopped_by_sw_breakpoint ())
2299 cs
.swbreak_feature
= 1;
2301 else if (strcmp (p
, "hwbreak+") == 0)
2303 /* GDB wants us to report whether a trap is caused
2304 by a hardware breakpoint. */
2305 if (target_supports_stopped_by_hw_breakpoint ())
2306 cs
.hwbreak_feature
= 1;
2308 else if (strcmp (p
, "fork-events+") == 0)
2310 /* GDB supports and wants fork events if possible. */
2311 if (target_supports_fork_events ())
2312 cs
.report_fork_events
= 1;
2314 else if (strcmp (p
, "vfork-events+") == 0)
2316 /* GDB supports and wants vfork events if possible. */
2317 if (target_supports_vfork_events ())
2318 cs
.report_vfork_events
= 1;
2320 else if (strcmp (p
, "exec-events+") == 0)
2322 /* GDB supports and wants exec events if possible. */
2323 if (target_supports_exec_events ())
2324 cs
.report_exec_events
= 1;
2326 else if (strcmp (p
, "vContSupported+") == 0)
2327 cs
.vCont_supported
= 1;
2328 else if (strcmp (p
, "QThreadEvents+") == 0)
2330 else if (strcmp (p
, "no-resumed+") == 0)
2332 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2334 report_no_resumed
= 1;
2338 /* Move the unknown features all together. */
2339 qsupported
[i
] = NULL
;
2340 qsupported
[unknown
] = p
;
2345 /* Give the target backend a chance to process the unknown
2347 target_process_qsupported (qsupported
, unknown
);
2349 for (i
= 0; i
< count
; i
++)
2350 free (qsupported
[i
]);
2355 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2356 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2357 "QEnvironmentReset+;QEnvironmentUnset+;"
2361 if (target_supports_catch_syscall ())
2362 strcat (own_buf
, ";QCatchSyscalls+");
2364 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2365 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2366 ";augmented-libraries-svr4-read+");
2369 /* We do not have any hook to indicate whether the non-SVR4 target
2370 backend supports qXfer:libraries:read, so always report it. */
2371 strcat (own_buf
, ";qXfer:libraries:read+");
2374 if (the_target
->read_auxv
!= NULL
)
2375 strcat (own_buf
, ";qXfer:auxv:read+");
2377 if (the_target
->qxfer_siginfo
!= NULL
)
2378 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2380 if (the_target
->read_loadmap
!= NULL
)
2381 strcat (own_buf
, ";qXfer:fdpic:read+");
2383 /* We always report qXfer:features:read, as targets may
2384 install XML files on a subsequent call to arch_setup.
2385 If we reported to GDB on startup that we don't support
2386 qXfer:feature:read at all, we will never be re-queried. */
2387 strcat (own_buf
, ";qXfer:features:read+");
2389 if (cs
.transport_is_reliable
)
2390 strcat (own_buf
, ";QStartNoAckMode+");
2392 if (the_target
->qxfer_osdata
!= NULL
)
2393 strcat (own_buf
, ";qXfer:osdata:read+");
2395 if (target_supports_multi_process ())
2396 strcat (own_buf
, ";multiprocess+");
2398 if (target_supports_fork_events ())
2399 strcat (own_buf
, ";fork-events+");
2401 if (target_supports_vfork_events ())
2402 strcat (own_buf
, ";vfork-events+");
2404 if (target_supports_exec_events ())
2405 strcat (own_buf
, ";exec-events+");
2407 if (target_supports_non_stop ())
2408 strcat (own_buf
, ";QNonStop+");
2410 if (target_supports_disable_randomization ())
2411 strcat (own_buf
, ";QDisableRandomization+");
2413 strcat (own_buf
, ";qXfer:threads:read+");
2415 if (target_supports_tracepoints ())
2417 strcat (own_buf
, ";ConditionalTracepoints+");
2418 strcat (own_buf
, ";TraceStateVariables+");
2419 strcat (own_buf
, ";TracepointSource+");
2420 strcat (own_buf
, ";DisconnectedTracing+");
2421 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2422 strcat (own_buf
, ";FastTracepoints+");
2423 strcat (own_buf
, ";StaticTracepoints+");
2424 strcat (own_buf
, ";InstallInTrace+");
2425 strcat (own_buf
, ";qXfer:statictrace:read+");
2426 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2427 strcat (own_buf
, ";EnableDisableTracepoints+");
2428 strcat (own_buf
, ";QTBuffer:size+");
2429 strcat (own_buf
, ";tracenz+");
2432 if (target_supports_hardware_single_step ()
2433 || target_supports_software_single_step () )
2435 strcat (own_buf
, ";ConditionalBreakpoints+");
2437 strcat (own_buf
, ";BreakpointCommands+");
2439 if (target_supports_agent ())
2440 strcat (own_buf
, ";QAgent+");
2442 supported_btrace_packets (own_buf
);
2444 if (target_supports_stopped_by_sw_breakpoint ())
2445 strcat (own_buf
, ";swbreak+");
2447 if (target_supports_stopped_by_hw_breakpoint ())
2448 strcat (own_buf
, ";hwbreak+");
2450 if (the_target
->pid_to_exec_file
!= NULL
)
2451 strcat (own_buf
, ";qXfer:exec-file:read+");
2453 strcat (own_buf
, ";vContSupported+");
2455 strcat (own_buf
, ";QThreadEvents+");
2457 strcat (own_buf
, ";no-resumed+");
2459 /* Reinitialize components as needed for the new connection. */
2460 hostio_handle_new_gdb_connection ();
2461 target_handle_new_gdb_connection ();
2466 /* Thread-local storage support. */
2467 if (the_target
->get_tls_address
!= NULL
2468 && startswith (own_buf
, "qGetTLSAddr:"))
2470 char *p
= own_buf
+ 12;
2471 CORE_ADDR parts
[2], address
= 0;
2473 ptid_t ptid
= null_ptid
;
2475 require_running_or_return (own_buf
);
2477 for (i
= 0; i
< 3; i
++)
2485 p2
= strchr (p
, ',');
2498 ptid
= read_ptid (p
, NULL
);
2500 decode_address (&parts
[i
- 1], p
, len
);
2504 if (p
!= NULL
|| i
< 3)
2508 struct thread_info
*thread
= find_thread_ptid (ptid
);
2513 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2519 strcpy (own_buf
, paddress(address
));
2524 write_enn (own_buf
);
2528 /* Otherwise, pretend we do not understand this packet. */
2531 /* Windows OS Thread Information Block address support. */
2532 if (the_target
->get_tib_address
!= NULL
2533 && startswith (own_buf
, "qGetTIBAddr:"))
2538 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2540 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2543 strcpy (own_buf
, paddress(tlb
));
2548 write_enn (own_buf
);
2554 /* Handle "monitor" commands. */
2555 if (startswith (own_buf
, "qRcmd,"))
2557 char *mon
= (char *) malloc (PBUFSIZ
);
2558 int len
= strlen (own_buf
+ 6);
2562 write_enn (own_buf
);
2567 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2569 write_enn (own_buf
);
2573 mon
[len
/ 2] = '\0';
2577 if (the_target
->handle_monitor_command
== NULL
2578 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2579 /* Default processing. */
2580 handle_monitor_command (mon
, own_buf
);
2586 if (startswith (own_buf
, "qSearch:memory:"))
2588 require_running_or_return (own_buf
);
2589 handle_search_memory (own_buf
, packet_len
);
2593 if (strcmp (own_buf
, "qAttached") == 0
2594 || startswith (own_buf
, "qAttached:"))
2596 struct process_info
*process
;
2598 if (own_buf
[sizeof ("qAttached") - 1])
2600 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2601 process
= find_process_pid (pid
);
2605 require_running_or_return (own_buf
);
2606 process
= current_process ();
2609 if (process
== NULL
)
2611 write_enn (own_buf
);
2615 strcpy (own_buf
, process
->attached
? "1" : "0");
2619 if (startswith (own_buf
, "qCRC:"))
2621 /* CRC check (compare-section). */
2625 unsigned long long crc
;
2627 require_running_or_return (own_buf
);
2628 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2629 if (*comma
++ != ',')
2631 write_enn (own_buf
);
2634 len
= strtoul (comma
, NULL
, 16);
2635 crc
= crc32 (base
, len
, 0xffffffff);
2636 /* Check for memory failure. */
2637 if (crc
== (unsigned long long) -1)
2639 write_enn (own_buf
);
2642 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2646 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2649 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2652 /* Otherwise we didn't know what packet it was. Say we didn't
2657 static void gdb_wants_all_threads_stopped (void);
2658 static void resume (struct thread_resume
*actions
, size_t n
);
2660 /* The callback that is passed to visit_actioned_threads. */
2661 typedef int (visit_actioned_threads_callback_ftype
)
2662 (const struct thread_resume
*, struct thread_info
*);
2664 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2665 true if CALLBACK returns true. Returns false if no matching thread
2666 is found or CALLBACK results false.
2667 Note: This function is itself a callback for find_thread. */
2670 visit_actioned_threads (thread_info
*thread
,
2671 const struct thread_resume
*actions
,
2673 visit_actioned_threads_callback_ftype
*callback
)
2675 for (size_t i
= 0; i
< num_actions
; i
++)
2677 const struct thread_resume
*action
= &actions
[i
];
2679 if (action
->thread
== minus_one_ptid
2680 || action
->thread
== thread
->id
2681 || ((action
->thread
.pid ()
2682 == thread
->id
.pid ())
2683 && action
->thread
.lwp () == -1))
2685 if ((*callback
) (action
, thread
))
2693 /* Callback for visit_actioned_threads. If the thread has a pending
2694 status to report, report it now. */
2697 handle_pending_status (const struct thread_resume
*resumption
,
2698 struct thread_info
*thread
)
2700 client_state
&cs
= get_client_state ();
2701 if (thread
->status_pending_p
)
2703 thread
->status_pending_p
= 0;
2705 cs
.last_status
= thread
->last_status
;
2706 cs
.last_ptid
= thread
->id
;
2707 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2713 /* Parse vCont packets. */
2715 handle_v_cont (char *own_buf
)
2719 struct thread_resume
*resume_info
;
2720 struct thread_resume default_action
{ null_ptid
};
2722 /* Count the number of semicolons in the packet. There should be one
2723 for every action. */
2729 p
= strchr (p
, ';');
2732 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2733 if (resume_info
== NULL
)
2741 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2743 if (p
[0] == 's' || p
[0] == 'S')
2744 resume_info
[i
].kind
= resume_step
;
2745 else if (p
[0] == 'r')
2746 resume_info
[i
].kind
= resume_step
;
2747 else if (p
[0] == 'c' || p
[0] == 'C')
2748 resume_info
[i
].kind
= resume_continue
;
2749 else if (p
[0] == 't')
2750 resume_info
[i
].kind
= resume_stop
;
2754 if (p
[0] == 'S' || p
[0] == 'C')
2757 int sig
= strtol (p
+ 1, &q
, 16);
2762 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2764 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2766 else if (p
[0] == 'r')
2770 p
= unpack_varlen_hex (p
+ 1, &addr
);
2771 resume_info
[i
].step_range_start
= addr
;
2776 p
= unpack_varlen_hex (p
+ 1, &addr
);
2777 resume_info
[i
].step_range_end
= addr
;
2786 resume_info
[i
].thread
= minus_one_ptid
;
2787 default_action
= resume_info
[i
];
2789 /* Note: we don't increment i here, we'll overwrite this entry
2790 the next time through. */
2792 else if (p
[0] == ':')
2795 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2800 if (p
[0] != ';' && p
[0] != 0)
2803 resume_info
[i
].thread
= ptid
;
2810 resume_info
[i
] = default_action
;
2812 resume (resume_info
, n
);
2817 write_enn (own_buf
);
2822 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2825 resume (struct thread_resume
*actions
, size_t num_actions
)
2827 client_state
&cs
= get_client_state ();
2830 /* Check if among the threads that GDB wants actioned, there's
2831 one with a pending status to report. If so, skip actually
2832 resuming/stopping and report the pending event
2835 thread_info
*thread_with_status
= find_thread ([&] (thread_info
*thread
)
2837 return visit_actioned_threads (thread
, actions
, num_actions
,
2838 handle_pending_status
);
2841 if (thread_with_status
!= NULL
)
2847 (*the_target
->resume
) (actions
, num_actions
);
2850 write_ok (cs
.own_buf
);
2853 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
, 0, 1);
2855 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2856 && !report_no_resumed
)
2858 /* The client does not support this stop reply. At least
2860 sprintf (cs
.own_buf
, "E.No unwaited-for children left.");
2861 disable_async_io ();
2865 if (cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
2866 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2867 && cs
.last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2868 current_thread
->last_status
= cs
.last_status
;
2870 /* From the client's perspective, all-stop mode always stops all
2871 threads implicitly (and the target backend has already done
2872 so by now). Tag all threads as "want-stopped", so we don't
2873 resume them implicitly without the client telling us to. */
2874 gdb_wants_all_threads_stopped ();
2875 prepare_resume_reply (cs
.own_buf
, cs
.last_ptid
, &cs
.last_status
);
2876 disable_async_io ();
2878 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
2879 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2880 target_mourn_inferior (cs
.last_ptid
);
2884 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2886 handle_v_attach (char *own_buf
)
2888 client_state
&cs
= get_client_state ();
2891 pid
= strtol (own_buf
+ 8, NULL
, 16);
2892 if (pid
!= 0 && attach_inferior (pid
) == 0)
2894 /* Don't report shared library events after attaching, even if
2895 some libraries are preloaded. GDB will always poll the
2896 library list. Avoids the "stopped by shared library event"
2897 notice on the GDB side. */
2902 /* In non-stop, we don't send a resume reply. Stop events
2903 will follow up using the normal notification
2908 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
2914 write_enn (own_buf
);
2919 /* Run a new program. Return 1 if successful, 0 if failure. */
2921 handle_v_run (char *own_buf
)
2923 client_state
&cs
= get_client_state ();
2925 std::vector
<char *> new_argv
;
2926 char *new_program_name
= NULL
;
2930 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2936 for (i
= 0, p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
, ++i
)
2938 next_p
= strchr (p
, ';');
2940 next_p
= p
+ strlen (p
);
2942 if (i
== 0 && p
== next_p
)
2944 /* No program specified. */
2945 new_program_name
= NULL
;
2947 else if (p
== next_p
)
2949 /* Empty argument. */
2950 new_argv
.push_back (xstrdup ("''"));
2954 size_t len
= (next_p
- p
) / 2;
2955 /* ARG is the unquoted argument received via the RSP. */
2956 char *arg
= (char *) xmalloc (len
+ 1);
2957 /* FULL_ARGS will contain the quoted version of ARG. */
2958 char *full_arg
= (char *) xmalloc ((len
+ 1) * 2);
2959 /* These are pointers used to navigate the strings above. */
2960 char *tmp_arg
= arg
;
2961 char *tmp_full_arg
= full_arg
;
2964 hex2bin (p
, (gdb_byte
*) arg
, len
);
2967 while (*tmp_arg
!= '\0')
2973 *tmp_full_arg
= '\'';
2979 /* Quote single quote. */
2980 *tmp_full_arg
= '\\';
2988 *tmp_full_arg
= *tmp_arg
;
2994 *tmp_full_arg
++ = '\'';
2996 /* Finish FULL_ARG and push it into the vector containing
2998 *tmp_full_arg
= '\0';
3000 new_program_name
= full_arg
;
3002 new_argv
.push_back (full_arg
);
3008 new_argv
.push_back (NULL
);
3010 if (new_program_name
== NULL
)
3012 /* GDB didn't specify a program to run. Use the program from the
3013 last run with the new argument list. */
3014 if (program_path
.get () == NULL
)
3016 write_enn (own_buf
);
3017 free_vector_argv (new_argv
);
3022 program_path
.set (gdb::unique_xmalloc_ptr
<char> (new_program_name
));
3024 /* Free the old argv and install the new one. */
3025 free_vector_argv (program_args
);
3026 program_args
= new_argv
;
3028 create_inferior (program_path
.get (), program_args
);
3030 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
3032 prepare_resume_reply (own_buf
, cs
.last_ptid
, &cs
.last_status
);
3034 /* In non-stop, sending a resume reply doesn't set the general
3035 thread, but GDB assumes a vRun sets it (this is so GDB can
3036 query which is the main thread of the new inferior. */
3038 cs
.general_thread
= cs
.last_ptid
;
3044 write_enn (own_buf
);
3049 /* Kill process. Return 1 if successful, 0 if failure. */
3051 handle_v_kill (char *own_buf
)
3053 client_state
&cs
= get_client_state ();
3055 char *p
= &own_buf
[6];
3056 if (cs
.multi_process
)
3057 pid
= strtol (p
, NULL
, 16);
3061 process_info
*proc
= find_process_pid (pid
);
3063 if (proc
!= nullptr && kill_inferior (proc
) == 0)
3065 cs
.last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
3066 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
3067 cs
.last_ptid
= ptid_t (pid
);
3068 discard_queued_stop_replies (cs
.last_ptid
);
3074 write_enn (own_buf
);
3079 /* Handle all of the extended 'v' packets. */
3081 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
3083 client_state
&cs
= get_client_state ();
3084 if (!disable_packet_vCont
)
3086 if (strcmp (own_buf
, "vCtrlC") == 0)
3088 (*the_target
->request_interrupt
) ();
3093 if (startswith (own_buf
, "vCont;"))
3095 handle_v_cont (own_buf
);
3099 if (startswith (own_buf
, "vCont?"))
3101 strcpy (own_buf
, "vCont;c;C;t");
3103 if (target_supports_hardware_single_step ()
3104 || target_supports_software_single_step ()
3105 || !cs
.vCont_supported
)
3107 /* If target supports single step either by hardware or by
3108 software, add actions s and S to the list of supported
3109 actions. On the other hand, if GDB doesn't request the
3110 supported vCont actions in qSupported packet, add s and
3111 S to the list too. */
3112 own_buf
= own_buf
+ strlen (own_buf
);
3113 strcpy (own_buf
, ";s;S");
3116 if (target_supports_range_stepping ())
3118 own_buf
= own_buf
+ strlen (own_buf
);
3119 strcpy (own_buf
, ";r");
3125 if (startswith (own_buf
, "vFile:")
3126 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
3129 if (startswith (own_buf
, "vAttach;"))
3131 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3133 fprintf (stderr
, "Already debugging a process\n");
3134 write_enn (own_buf
);
3137 handle_v_attach (own_buf
);
3141 if (startswith (own_buf
, "vRun;"))
3143 if ((!extended_protocol
|| !cs
.multi_process
) && target_running ())
3145 fprintf (stderr
, "Already debugging a process\n");
3146 write_enn (own_buf
);
3149 handle_v_run (own_buf
);
3153 if (startswith (own_buf
, "vKill;"))
3155 if (!target_running ())
3157 fprintf (stderr
, "No process to kill\n");
3158 write_enn (own_buf
);
3161 handle_v_kill (own_buf
);
3165 if (handle_notif_ack (own_buf
, packet_len
))
3168 /* Otherwise we didn't know what packet it was. Say we didn't
3174 /* Resume thread and wait for another event. In non-stop mode,
3175 don't really wait here, but return immediatelly to the event
3178 myresume (char *own_buf
, int step
, int sig
)
3180 client_state
&cs
= get_client_state ();
3181 struct thread_resume resume_info
[2];
3183 int valid_cont_thread
;
3185 valid_cont_thread
= (cs
.cont_thread
!= null_ptid
3186 && cs
.cont_thread
!= minus_one_ptid
);
3188 if (step
|| sig
|| valid_cont_thread
)
3190 resume_info
[0].thread
= current_ptid
;
3192 resume_info
[0].kind
= resume_step
;
3194 resume_info
[0].kind
= resume_continue
;
3195 resume_info
[0].sig
= sig
;
3199 if (!valid_cont_thread
)
3201 resume_info
[n
].thread
= minus_one_ptid
;
3202 resume_info
[n
].kind
= resume_continue
;
3203 resume_info
[n
].sig
= 0;
3207 resume (resume_info
, n
);
3210 /* Callback for for_each_thread. Make a new stop reply for each
3214 queue_stop_reply_callback (thread_info
*thread
)
3216 /* For now, assume targets that don't have this callback also don't
3217 manage the thread's last_status field. */
3218 if (the_target
->thread_stopped
== NULL
)
3220 struct vstop_notif
*new_notif
= new struct vstop_notif
;
3222 new_notif
->ptid
= thread
->id
;
3223 new_notif
->status
= thread
->last_status
;
3224 /* Pass the last stop reply back to GDB, but don't notify
3226 notif_event_enque (¬if_stop
, new_notif
);
3230 if (thread_stopped (thread
))
3234 std::string status_string
3235 = target_waitstatus_to_string (&thread
->last_status
);
3237 debug_printf ("Reporting thread %s as already stopped with %s\n",
3238 target_pid_to_str (thread
->id
),
3239 status_string
.c_str ());
3242 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3244 /* Pass the last stop reply back to GDB, but don't notify
3246 queue_stop_reply (thread
->id
, &thread
->last_status
);
3251 /* Set this inferior threads's state as "want-stopped". We won't
3252 resume this thread until the client gives us another action for
3256 gdb_wants_thread_stopped (thread_info
*thread
)
3258 thread
->last_resume_kind
= resume_stop
;
3260 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3262 /* Most threads are stopped implicitly (all-stop); tag that with
3264 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3265 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3269 /* Set all threads' states as "want-stopped". */
3272 gdb_wants_all_threads_stopped (void)
3274 for_each_thread (gdb_wants_thread_stopped
);
3277 /* Callback for for_each_thread. If the thread is stopped with an
3278 interesting event, mark it as having a pending event. */
3281 set_pending_status_callback (thread_info
*thread
)
3283 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3284 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3285 /* A breakpoint, watchpoint or finished step from a previous
3286 GDB run isn't considered interesting for a new GDB run.
3287 If we left those pending, the new GDB could consider them
3288 random SIGTRAPs. This leaves out real async traps. We'd
3289 have to peek into the (target-specific) siginfo to
3290 distinguish those. */
3291 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3292 thread
->status_pending_p
= 1;
3295 /* Status handler for the '?' packet. */
3298 handle_status (char *own_buf
)
3300 client_state
&cs
= get_client_state ();
3302 /* GDB is connected, don't forward events to the target anymore. */
3303 for_each_process ([] (process_info
*process
) {
3304 process
->gdb_detached
= 0;
3307 /* In non-stop mode, we must send a stop reply for each stopped
3308 thread. In all-stop mode, just send one for the first stopped
3313 for_each_thread (queue_stop_reply_callback
);
3315 /* The first is sent immediatly. OK is sent if there is no
3316 stopped thread, which is the same handling of the vStopped
3317 packet (by design). */
3318 notif_write_event (¬if_stop
, cs
.own_buf
);
3322 thread_info
*thread
= NULL
;
3325 stabilize_threads ();
3326 gdb_wants_all_threads_stopped ();
3328 /* We can only report one status, but we might be coming out of
3329 non-stop -- if more than one thread is stopped with
3330 interesting events, leave events for the threads we're not
3331 reporting now pending. They'll be reported the next time the
3332 threads are resumed. Start by marking all interesting events
3334 for_each_thread (set_pending_status_callback
);
3336 /* Prefer the last thread that reported an event to GDB (even if
3337 that was a GDB_SIGNAL_TRAP). */
3338 if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
3339 && cs
.last_status
.kind
!= TARGET_WAITKIND_EXITED
3340 && cs
.last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3341 thread
= find_thread_ptid (cs
.last_ptid
);
3343 /* If the last event thread is not found for some reason, look
3344 for some other thread that might have an event to report. */
3346 thread
= find_thread ([] (thread_info
*thr_arg
)
3348 return thr_arg
->status_pending_p
;
3351 /* If we're still out of luck, simply pick the first thread in
3354 thread
= get_first_thread ();
3358 struct thread_info
*tp
= (struct thread_info
*) thread
;
3360 /* We're reporting this event, so it's no longer
3362 tp
->status_pending_p
= 0;
3364 /* GDB assumes the current thread is the thread we're
3365 reporting the status for. */
3366 cs
.general_thread
= thread
->id
;
3367 set_desired_thread ();
3369 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3370 prepare_resume_reply (own_buf
, tp
->id
, &tp
->last_status
);
3373 strcpy (own_buf
, "W00");
3378 gdbserver_version (void)
3380 printf ("GNU gdbserver %s%s\n"
3381 "Copyright (C) 2019 Free Software Foundation, Inc.\n"
3382 "gdbserver is free software, covered by the "
3383 "GNU General Public License.\n"
3384 "This gdbserver was configured as \"%s\"\n",
3385 PKGVERSION
, version
, host_name
);
3389 gdbserver_usage (FILE *stream
)
3391 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3392 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3393 "\tgdbserver [OPTIONS] --multi COMM\n"
3395 "COMM may either be a tty device (for serial debugging),\n"
3396 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3397 "stdin/stdout of gdbserver.\n"
3398 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3399 "PID is the process ID to attach to, when --attach is specified.\n"
3401 "Operating modes:\n"
3403 " --attach Attach to running process PID.\n"
3404 " --multi Start server without a specific program, and\n"
3405 " only quit when explicitly commanded.\n"
3406 " --once Exit after the first connection has closed.\n"
3407 " --help Print this message and then exit.\n"
3408 " --version Display version information and exit.\n"
3412 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3413 " --disable-randomization\n"
3414 " Run PROG with address space randomization disabled.\n"
3415 " --no-disable-randomization\n"
3416 " Don't disable address space randomization when\n"
3418 " --startup-with-shell\n"
3419 " Start PROG using a shell. I.e., execs a shell that\n"
3420 " then execs PROG. (default)\n"
3421 " --no-startup-with-shell\n"
3422 " Exec PROG directly instead of using a shell.\n"
3423 " Disables argument globbing and variable substitution\n"
3424 " on UNIX-like systems.\n"
3428 " --debug Enable general debugging output.\n"
3429 " --debug-format=OPT1[,OPT2,...]\n"
3430 " Specify extra content in debugging output.\n"
3435 " --remote-debug Enable remote protocol debugging output.\n"
3436 " --disable-packet=OPT1[,OPT2,...]\n"
3437 " Disable support for RSP packets or features.\n"
3439 " vCont, Tthread, qC, qfThreadInfo and \n"
3440 " threads (disable all threading packets).\n"
3442 "For more information, consult the GDB manual (available as on-line \n"
3443 "info or a printed manual).\n");
3444 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3445 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3449 gdbserver_show_disableable (FILE *stream
)
3451 fprintf (stream
, "Disableable packets:\n"
3452 " vCont \tAll vCont packets\n"
3453 " qC \tQuerying the current thread\n"
3454 " qfThreadInfo\tThread listing\n"
3455 " Tthread \tPassing the thread specifier in the "
3456 "T stop reply packet\n"
3457 " threads \tAll of the above\n");
3461 kill_inferior_callback (process_info
*process
)
3463 kill_inferior (process
);
3464 discard_queued_stop_replies (ptid_t (process
->pid
));
3467 /* Call this when exiting gdbserver with possible inferiors that need
3468 to be killed or detached from. */
3471 detach_or_kill_for_exit (void)
3473 /* First print a list of the inferiors we will be killing/detaching.
3474 This is to assist the user, for example, in case the inferior unexpectedly
3475 dies after we exit: did we screw up or did the inferior exit on its own?
3476 Having this info will save some head-scratching. */
3478 if (have_started_inferiors_p ())
3480 fprintf (stderr
, "Killing process(es):");
3482 for_each_process ([] (process_info
*process
) {
3483 if (!process
->attached
)
3484 fprintf (stderr
, " %d", process
->pid
);
3487 fprintf (stderr
, "\n");
3489 if (have_attached_inferiors_p ())
3491 fprintf (stderr
, "Detaching process(es):");
3493 for_each_process ([] (process_info
*process
) {
3494 if (process
->attached
)
3495 fprintf (stderr
, " %d", process
->pid
);
3498 fprintf (stderr
, "\n");
3501 /* Now we can kill or detach the inferiors. */
3502 for_each_process ([] (process_info
*process
) {
3503 int pid
= process
->pid
;
3505 if (process
->attached
)
3506 detach_inferior (process
);
3508 kill_inferior (process
);
3510 discard_queued_stop_replies (ptid_t (pid
));
3514 /* Value that will be passed to exit(3) when gdbserver exits. */
3515 static int exit_code
;
3517 /* Wrapper for detach_or_kill_for_exit that catches and prints
3521 detach_or_kill_for_exit_cleanup ()
3525 detach_or_kill_for_exit ();
3527 catch (const gdb_exception
&exception
)
3530 fprintf (stderr
, "Detach or kill failed: %s\n",
3536 /* Main function. This is called by the real "main" function,
3537 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3539 static void ATTRIBUTE_NORETURN
3540 captured_main (int argc
, char *argv
[])
3545 const char *port
= NULL
;
3546 char **next_arg
= &argv
[1];
3547 volatile int multi_mode
= 0;
3548 volatile int attach
= 0;
3550 bool selftest
= false;
3552 const char *selftest_filter
= NULL
;
3555 current_directory
= getcwd (NULL
, 0);
3556 client_state
&cs
= get_client_state ();
3558 if (current_directory
== NULL
)
3560 error (_("Could not find current working directory: %s"),
3561 safe_strerror (errno
));
3564 while (*next_arg
!= NULL
&& **next_arg
== '-')
3566 if (strcmp (*next_arg
, "--version") == 0)
3568 gdbserver_version ();
3571 else if (strcmp (*next_arg
, "--help") == 0)
3573 gdbserver_usage (stdout
);
3576 else if (strcmp (*next_arg
, "--attach") == 0)
3578 else if (strcmp (*next_arg
, "--multi") == 0)
3580 else if (strcmp (*next_arg
, "--wrapper") == 0)
3587 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3589 wrapper_argv
+= *next_arg
;
3590 wrapper_argv
+= ' ';
3594 if (!wrapper_argv
.empty ())
3596 /* Erase the last whitespace. */
3597 wrapper_argv
.erase (wrapper_argv
.end () - 1);
3600 if (next_arg
== tmp
|| *next_arg
== NULL
)
3602 gdbserver_usage (stderr
);
3606 /* Consume the "--". */
3609 else if (strcmp (*next_arg
, "--debug") == 0)
3611 else if (startswith (*next_arg
, "--debug-format="))
3613 std::string error_msg
3614 = parse_debug_format_options ((*next_arg
)
3615 + sizeof ("--debug-format=") - 1, 0);
3617 if (!error_msg
.empty ())
3619 fprintf (stderr
, "%s", error_msg
.c_str ());
3623 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3625 else if (startswith (*next_arg
, "--debug-file="))
3626 debug_set_output ((*next_arg
) + sizeof ("--debug-file=") -1);
3627 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3629 gdbserver_show_disableable (stdout
);
3632 else if (startswith (*next_arg
, "--disable-packet="))
3634 char *packets
, *tok
;
3636 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3637 for (tok
= strtok (packets
, ",");
3639 tok
= strtok (NULL
, ","))
3641 if (strcmp ("vCont", tok
) == 0)
3642 disable_packet_vCont
= 1;
3643 else if (strcmp ("Tthread", tok
) == 0)
3644 disable_packet_Tthread
= 1;
3645 else if (strcmp ("qC", tok
) == 0)
3646 disable_packet_qC
= 1;
3647 else if (strcmp ("qfThreadInfo", tok
) == 0)
3648 disable_packet_qfThreadInfo
= 1;
3649 else if (strcmp ("threads", tok
) == 0)
3651 disable_packet_vCont
= 1;
3652 disable_packet_Tthread
= 1;
3653 disable_packet_qC
= 1;
3654 disable_packet_qfThreadInfo
= 1;
3658 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3660 gdbserver_show_disableable (stderr
);
3665 else if (strcmp (*next_arg
, "-") == 0)
3667 /* "-" specifies a stdio connection and is a form of port
3669 port
= STDIO_CONNECTION_NAME
;
3673 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3674 cs
.disable_randomization
= 1;
3675 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3676 cs
.disable_randomization
= 0;
3677 else if (strcmp (*next_arg
, "--startup-with-shell") == 0)
3678 startup_with_shell
= true;
3679 else if (strcmp (*next_arg
, "--no-startup-with-shell") == 0)
3680 startup_with_shell
= false;
3681 else if (strcmp (*next_arg
, "--once") == 0)
3683 else if (strcmp (*next_arg
, "--selftest") == 0)
3685 else if (startswith (*next_arg
, "--selftest="))
3689 selftest_filter
= *next_arg
+ strlen ("--selftest=");
3694 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3707 if ((port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3710 gdbserver_usage (stderr
);
3714 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3715 opened by remote_prepare. */
3718 save_original_signals_state (false);
3720 /* We need to know whether the remote connection is stdio before
3721 starting the inferior. Inferiors created in this scenario have
3722 stdin,stdout redirected. So do this here before we call
3725 remote_prepare (port
);
3730 /* --attach used to come after PORT, so allow it there for
3732 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3739 && (*next_arg
== NULL
3740 || (*next_arg
)[0] == '\0'
3741 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3743 || next_arg
[1] != NULL
))
3748 gdbserver_usage (stderr
);
3752 /* Gather information about the environment. */
3753 our_environ
= gdb_environ::from_host_environ ();
3755 initialize_async_io ();
3757 have_job_control ();
3758 initialize_event_loop ();
3759 if (target_supports_tracepoints ())
3760 initialize_tracepoint ();
3762 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3767 selftests::run_tests (selftest_filter
);
3769 printf (_("Selftests have been disabled for this build.\n"));
3771 throw_quit ("Quit");
3774 if (pid
== 0 && *next_arg
!= NULL
)
3778 n
= argc
- (next_arg
- argv
);
3779 program_path
.set (make_unique_xstrdup (next_arg
[0]));
3780 for (i
= 1; i
< n
; i
++)
3781 program_args
.push_back (xstrdup (next_arg
[i
]));
3782 program_args
.push_back (NULL
);
3784 /* Wait till we are at first instruction in program. */
3785 create_inferior (program_path
.get (), program_args
);
3787 /* We are now (hopefully) stopped at the first instruction of
3788 the target process. This assumes that the target process was
3789 successfully created. */
3793 if (attach_inferior (pid
) == -1)
3794 error ("Attaching not supported on this target");
3796 /* Otherwise succeeded. */
3800 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
3801 cs
.last_status
.value
.integer
= 0;
3802 cs
.last_ptid
= minus_one_ptid
;
3805 SCOPE_EXIT
{ detach_or_kill_for_exit_cleanup (); };
3807 /* Don't report shared library events on the initial connection,
3808 even if some libraries are preloaded. Avoids the "stopped by
3809 shared library event" notice on gdb side. */
3812 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
3813 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3818 if (!was_running
&& !multi_mode
)
3819 error ("No program to debug");
3824 cs
.multi_process
= 0;
3825 cs
.report_fork_events
= 0;
3826 cs
.report_vfork_events
= 0;
3827 cs
.report_exec_events
= 0;
3828 /* Be sure we're out of tfind mode. */
3829 cs
.current_traceframe
= -1;
3830 cs
.cont_thread
= null_ptid
;
3831 cs
.swbreak_feature
= 0;
3832 cs
.hwbreak_feature
= 0;
3833 cs
.vCont_supported
= 0;
3839 /* Wait for events. This will return when all event sources
3840 are removed from the event loop. */
3841 start_event_loop ();
3843 /* If an exit was requested (using the "monitor exit"
3844 command), terminate now. */
3846 throw_quit ("Quit");
3848 /* The only other way to get here is for getpkt to fail:
3850 - If --once was specified, we're done.
3852 - If not in extended-remote mode, and we're no longer
3853 debugging anything, simply exit: GDB has disconnected
3854 after processing the last process exit.
3856 - Otherwise, close the connection and reopen it at the
3858 if (run_once
|| (!extended_protocol
&& !target_running ()))
3859 throw_quit ("Quit");
3862 "Remote side has terminated connection. "
3863 "GDBserver will reopen the connection.\n");
3865 /* Get rid of any pending statuses. An eventual reconnection
3866 (by the same GDB instance or another) will refresh all its
3867 state from scratch. */
3868 discard_queued_stop_replies (minus_one_ptid
);
3869 for_each_thread ([] (thread_info
*thread
)
3871 thread
->status_pending_p
= 0;
3876 if (disconnected_tracing
)
3878 /* Try to enable non-stop/async mode, so we we can
3879 both wait for an async socket accept, and handle
3880 async target events simultaneously. There's also
3881 no point either in having the target always stop
3882 all threads, when we're going to pass signals
3883 down without informing GDB. */
3886 if (start_non_stop (1))
3889 /* Detaching implicitly resumes all threads;
3890 simply disconnecting does not. */
3896 "Disconnected tracing disabled; "
3897 "stopping trace run.\n");
3902 catch (const gdb_exception_error
&exception
)
3905 fprintf (stderr
, "gdbserver: %s\n", exception
.what ());
3907 if (response_needed
)
3909 write_enn (cs
.own_buf
);
3910 putpkt (cs
.own_buf
);
3914 throw_quit ("Quit");
3919 /* Main function. */
3922 main (int argc
, char *argv
[])
3927 captured_main (argc
, argv
);
3929 catch (const gdb_exception
&exception
)
3931 if (exception
.reason
== RETURN_ERROR
)
3934 fprintf (stderr
, "%s\n", exception
.what ());
3935 fprintf (stderr
, "Exiting\n");
3942 gdb_assert_not_reached ("captured_main should never return");
3945 /* Process options coming from Z packets for a breakpoint. PACKET is
3946 the packet buffer. *PACKET is updated to point to the first char
3947 after the last processed option. */
3950 process_point_options (struct gdb_breakpoint
*bp
, const char **packet
)
3952 const char *dataptr
= *packet
;
3955 /* Check if data has the correct format. */
3956 if (*dataptr
!= ';')
3963 if (*dataptr
== ';')
3966 if (*dataptr
== 'X')
3968 /* Conditional expression. */
3970 debug_printf ("Found breakpoint condition.\n");
3971 if (!add_breakpoint_condition (bp
, &dataptr
))
3972 dataptr
= strchrnul (dataptr
, ';');
3974 else if (startswith (dataptr
, "cmds:"))
3976 dataptr
+= strlen ("cmds:");
3978 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3979 persist
= (*dataptr
== '1');
3981 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3982 dataptr
= strchrnul (dataptr
, ';');
3986 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3988 /* Skip tokens until we find one that we recognize. */
3989 dataptr
= strchrnul (dataptr
, ';');
3995 /* Event loop callback that handles a serial event. The first byte in
3996 the serial buffer gets us here. We expect characters to arrive at
3997 a brisk pace, so we read the rest of the packet with a blocking
4001 process_serial_event (void)
4003 client_state
&cs
= get_client_state ();
4009 int new_packet_len
= -1;
4011 disable_async_io ();
4013 response_needed
= 0;
4014 packet_len
= getpkt (cs
.own_buf
);
4015 if (packet_len
<= 0)
4018 /* Force an event loop break. */
4021 response_needed
= 1;
4023 char ch
= cs
.own_buf
[0];
4027 handle_query (cs
.own_buf
, packet_len
, &new_packet_len
);
4030 handle_general_set (cs
.own_buf
);
4033 handle_detach (cs
.own_buf
);
4036 extended_protocol
= 1;
4037 write_ok (cs
.own_buf
);
4040 handle_status (cs
.own_buf
);
4043 if (cs
.own_buf
[1] == 'c' || cs
.own_buf
[1] == 'g' || cs
.own_buf
[1] == 's')
4045 require_running_or_break (cs
.own_buf
);
4047 ptid_t thread_id
= read_ptid (&cs
.own_buf
[2], NULL
);
4049 if (thread_id
== null_ptid
|| thread_id
== minus_one_ptid
)
4050 thread_id
= null_ptid
;
4051 else if (thread_id
.is_pid ())
4053 /* The ptid represents a pid. */
4054 thread_info
*thread
= find_any_thread_of_pid (thread_id
.pid ());
4058 write_enn (cs
.own_buf
);
4062 thread_id
= thread
->id
;
4066 /* The ptid represents a lwp/tid. */
4067 if (find_thread_ptid (thread_id
) == NULL
)
4069 write_enn (cs
.own_buf
);
4074 if (cs
.own_buf
[1] == 'g')
4076 if (thread_id
== null_ptid
)
4078 /* GDB is telling us to choose any thread. Check if
4079 the currently selected thread is still valid. If
4080 it is not, select the first available. */
4081 thread_info
*thread
= find_thread_ptid (cs
.general_thread
);
4083 thread
= get_first_thread ();
4084 thread_id
= thread
->id
;
4087 cs
.general_thread
= thread_id
;
4088 set_desired_thread ();
4089 gdb_assert (current_thread
!= NULL
);
4091 else if (cs
.own_buf
[1] == 'c')
4092 cs
.cont_thread
= thread_id
;
4094 write_ok (cs
.own_buf
);
4098 /* Silently ignore it so that gdb can extend the protocol
4099 without compatibility headaches. */
4100 cs
.own_buf
[0] = '\0';
4104 require_running_or_break (cs
.own_buf
);
4105 if (cs
.current_traceframe
>= 0)
4107 struct regcache
*regcache
4108 = new_register_cache (current_target_desc ());
4110 if (fetch_traceframe_registers (cs
.current_traceframe
,
4112 registers_to_string (regcache
, cs
.own_buf
);
4114 write_enn (cs
.own_buf
);
4115 free_register_cache (regcache
);
4119 struct regcache
*regcache
;
4121 if (!set_desired_thread ())
4122 write_enn (cs
.own_buf
);
4125 regcache
= get_thread_regcache (current_thread
, 1);
4126 registers_to_string (regcache
, cs
.own_buf
);
4131 require_running_or_break (cs
.own_buf
);
4132 if (cs
.current_traceframe
>= 0)
4133 write_enn (cs
.own_buf
);
4136 struct regcache
*regcache
;
4138 if (!set_desired_thread ())
4139 write_enn (cs
.own_buf
);
4142 regcache
= get_thread_regcache (current_thread
, 1);
4143 registers_from_string (regcache
, &cs
.own_buf
[1]);
4144 write_ok (cs
.own_buf
);
4150 require_running_or_break (cs
.own_buf
);
4151 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &len
);
4152 int res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4154 write_enn (cs
.own_buf
);
4156 bin2hex (mem_buf
, cs
.own_buf
, res
);
4160 require_running_or_break (cs
.own_buf
);
4161 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4162 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4163 write_ok (cs
.own_buf
);
4165 write_enn (cs
.own_buf
);
4168 require_running_or_break (cs
.own_buf
);
4169 if (decode_X_packet (&cs
.own_buf
[1], packet_len
- 1,
4170 &mem_addr
, &len
, &mem_buf
) < 0
4171 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4172 write_enn (cs
.own_buf
);
4174 write_ok (cs
.own_buf
);
4177 require_running_or_break (cs
.own_buf
);
4178 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4179 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4180 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4183 myresume (cs
.own_buf
, 0, signal
);
4186 require_running_or_break (cs
.own_buf
);
4187 hex2bin (cs
.own_buf
+ 1, &sig
, 1);
4188 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4189 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4192 myresume (cs
.own_buf
, 1, signal
);
4195 require_running_or_break (cs
.own_buf
);
4197 myresume (cs
.own_buf
, 0, signal
);
4200 require_running_or_break (cs
.own_buf
);
4202 myresume (cs
.own_buf
, 1, signal
);
4204 case 'Z': /* insert_ ... */
4206 case 'z': /* remove_ ... */
4211 char type
= cs
.own_buf
[1];
4213 const int insert
= ch
== 'Z';
4214 const char *p
= &cs
.own_buf
[3];
4216 p
= unpack_varlen_hex (p
, &addr
);
4217 kind
= strtol (p
+ 1, &dataptr
, 16);
4221 struct gdb_breakpoint
*bp
;
4223 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4228 /* GDB may have sent us a list of *point parameters to
4229 be evaluated on the target's side. Read such list
4230 here. If we already have a list of parameters, GDB
4231 is telling us to drop that list and use this one
4233 clear_breakpoint_conditions_and_commands (bp
);
4234 const char *options
= dataptr
;
4235 process_point_options (bp
, &options
);
4239 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4242 write_ok (cs
.own_buf
);
4245 cs
.own_buf
[0] = '\0';
4247 write_enn (cs
.own_buf
);
4251 response_needed
= 0;
4252 if (!target_running ())
4253 /* The packet we received doesn't make sense - but we can't
4254 reply to it, either. */
4257 fprintf (stderr
, "Killing all inferiors\n");
4259 for_each_process (kill_inferior_callback
);
4261 /* When using the extended protocol, we wait with no program
4262 running. The traditional protocol will exit instead. */
4263 if (extended_protocol
)
4265 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4266 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4274 require_running_or_break (cs
.own_buf
);
4276 ptid_t thread_id
= read_ptid (&cs
.own_buf
[1], NULL
);
4277 if (find_thread_ptid (thread_id
) == NULL
)
4279 write_enn (cs
.own_buf
);
4283 if (mythread_alive (thread_id
))
4284 write_ok (cs
.own_buf
);
4286 write_enn (cs
.own_buf
);
4290 response_needed
= 0;
4292 /* Restarting the inferior is only supported in the extended
4294 if (extended_protocol
)
4296 if (target_running ())
4297 for_each_process (kill_inferior_callback
);
4299 fprintf (stderr
, "GDBserver restarting\n");
4301 /* Wait till we are at 1st instruction in prog. */
4302 if (program_path
.get () != NULL
)
4304 create_inferior (program_path
.get (), program_args
);
4306 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4308 /* Stopped at the first instruction of the target
4310 cs
.general_thread
= cs
.last_ptid
;
4314 /* Something went wrong. */
4315 cs
.general_thread
= null_ptid
;
4320 cs
.last_status
.kind
= TARGET_WAITKIND_EXITED
;
4321 cs
.last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4327 /* It is a request we don't understand. Respond with an
4328 empty packet so that gdb knows that we don't support this
4330 cs
.own_buf
[0] = '\0';
4334 /* Extended (long) request. */
4335 handle_v_requests (cs
.own_buf
, packet_len
, &new_packet_len
);
4339 /* It is a request we don't understand. Respond with an empty
4340 packet so that gdb knows that we don't support this
4342 cs
.own_buf
[0] = '\0';
4346 if (new_packet_len
!= -1)
4347 putpkt_binary (cs
.own_buf
, new_packet_len
);
4349 putpkt (cs
.own_buf
);
4351 response_needed
= 0;
4359 /* Event-loop callback for serial events. */
4362 handle_serial_event (int err
, gdb_client_data client_data
)
4365 debug_printf ("handling possible serial event\n");
4367 /* Really handle it. */
4368 if (process_serial_event () < 0)
4371 /* Be sure to not change the selected thread behind GDB's back.
4372 Important in the non-stop mode asynchronous protocol. */
4373 set_desired_thread ();
4378 /* Push a stop notification on the notification queue. */
4381 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4383 struct vstop_notif
*vstop_notif
= new struct vstop_notif
;
4385 vstop_notif
->status
= *status
;
4386 vstop_notif
->ptid
= ptid
;
4387 /* Push Stop notification. */
4388 notif_push (¬if_stop
, vstop_notif
);
4391 /* Event-loop callback for target events. */
4394 handle_target_event (int err
, gdb_client_data client_data
)
4396 client_state
&cs
= get_client_state ();
4398 debug_printf ("handling possible target event\n");
4400 cs
.last_ptid
= mywait (minus_one_ptid
, &cs
.last_status
,
4403 if (cs
.last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4405 if (gdb_connected () && report_no_resumed
)
4406 push_stop_notification (null_ptid
, &cs
.last_status
);
4408 else if (cs
.last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4410 int pid
= cs
.last_ptid
.pid ();
4411 struct process_info
*process
= find_process_pid (pid
);
4412 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4414 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4415 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4417 mark_breakpoints_out (process
);
4418 target_mourn_inferior (cs
.last_ptid
);
4420 else if (cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4424 /* We're reporting this thread as stopped. Update its
4425 "want-stopped" state to what the client wants, until it
4426 gets a new resume action. */
4427 current_thread
->last_resume_kind
= resume_stop
;
4428 current_thread
->last_status
= cs
.last_status
;
4433 if (!target_running ())
4435 /* The last process exited. We're done. */
4439 if (cs
.last_status
.kind
== TARGET_WAITKIND_EXITED
4440 || cs
.last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4441 || cs
.last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4445 /* A thread stopped with a signal, but gdb isn't
4446 connected to handle it. Pass it down to the
4447 inferior, as if it wasn't being traced. */
4448 enum gdb_signal signal
;
4451 debug_printf ("GDB not connected; forwarding event %d for"
4453 (int) cs
.last_status
.kind
,
4454 target_pid_to_str (cs
.last_ptid
));
4456 if (cs
.last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4457 signal
= cs
.last_status
.value
.sig
;
4459 signal
= GDB_SIGNAL_0
;
4460 target_continue (cs
.last_ptid
, signal
);
4464 push_stop_notification (cs
.last_ptid
, &cs
.last_status
);
4467 /* Be sure to not change the selected thread behind GDB's back.
4468 Important in the non-stop mode asynchronous protocol. */
4469 set_desired_thread ();
4482 } // namespace selftests
4483 #endif /* GDB_SELF_TEST */