1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2016 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
44 multi-process), or a specific thread ptid_t. */
47 /* The thread set with an `Hg' packet. */
48 ptid_t general_thread
;
52 static int extended_protocol
;
53 static int response_needed
;
54 static int exit_requested
;
56 /* --once: Exit after the first connection has closed. */
60 int report_fork_events
;
61 int report_vfork_events
;
62 int report_exec_events
;
63 int report_thread_events
;
65 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
66 static int report_no_resumed
;
72 /* True if the "vContSupported" feature is active. In that case, GDB
73 wants us to report whether single step is supported in the reply to
75 static int vCont_supported
;
77 /* Whether we should attempt to disable the operating system's address
78 space randomization feature before starting an inferior. */
79 int disable_randomization
= 1;
81 static char **program_argv
, **wrapper_argv
;
83 int pass_signals
[GDB_SIGNAL_LAST
];
84 int program_signals
[GDB_SIGNAL_LAST
];
85 int program_signals_p
;
87 /* The PID of the originally created or attached inferior. Used to
88 send signals to the process when GDB sends us an asynchronous interrupt
89 (user hitting Control-C in the client), and to wait for the child to exit
90 when no longer debugging it. */
92 unsigned long signal_pid
;
95 /* A file descriptor for the controlling terminal. */
98 /* TERMINAL_FD's original foreground group. */
99 pid_t old_foreground_pgrp
;
101 /* Hand back terminal ownership to the original foreground group. */
104 restore_old_foreground_pgrp (void)
106 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
110 /* Set if you want to disable optional thread related packets support
111 in gdbserver, for the sake of testing GDB against stubs that don't
113 int disable_packet_vCont
;
114 int disable_packet_Tthread
;
115 int disable_packet_qC
;
116 int disable_packet_qfThreadInfo
;
118 /* Last status reported to GDB. */
119 static struct target_waitstatus last_status
;
120 static ptid_t last_ptid
;
123 static unsigned char *mem_buf
;
125 /* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
131 struct notif_event base
;
133 /* Thread or process that got the event. */
137 struct target_waitstatus status
;
140 /* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142 static struct btrace_config current_btrace_conf
;
144 DEFINE_QUEUE_P (notif_event_p
);
146 /* Put a stop reply to the stop reply queue. */
149 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
151 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
153 new_notif
->ptid
= ptid
;
154 new_notif
->status
= *status
;
156 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
160 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
161 QUEUE_ITER (notif_event_p
) *iter
,
162 struct notif_event
*event
,
165 ptid_t filter_ptid
= *(ptid_t
*) data
;
166 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
168 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
170 if (q
->free_func
!= NULL
)
171 q
->free_func (event
);
173 QUEUE_remove_elem (notif_event_p
, q
, iter
);
182 discard_queued_stop_replies (ptid_t ptid
)
184 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
185 remove_all_on_match_ptid
, &ptid
);
189 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
191 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
193 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
196 struct notif_server notif_stop
=
198 "vStopped", "Stop", NULL
, vstop_notif_reply
,
202 target_running (void)
204 return get_first_thread () != NULL
;
208 start_inferior (char **argv
)
210 char **new_argv
= argv
;
212 if (wrapper_argv
!= NULL
)
216 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
218 for (i
= 0; argv
[i
] != NULL
; i
++)
220 new_argv
= XALLOCAVEC (char *, count
);
222 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
223 new_argv
[count
++] = wrapper_argv
[i
];
224 for (i
= 0; argv
[i
] != NULL
; i
++)
225 new_argv
[count
++] = argv
[i
];
226 new_argv
[count
] = NULL
;
232 for (i
= 0; new_argv
[i
]; ++i
)
233 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
238 signal (SIGTTOU
, SIG_DFL
);
239 signal (SIGTTIN
, SIG_DFL
);
242 signal_pid
= create_inferior (new_argv
[0], new_argv
);
244 /* FIXME: we don't actually know at this point that the create
245 actually succeeded. We won't know that until we wait. */
246 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
251 signal (SIGTTOU
, SIG_IGN
);
252 signal (SIGTTIN
, SIG_IGN
);
253 terminal_fd
= fileno (stderr
);
254 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
255 tcsetpgrp (terminal_fd
, signal_pid
);
256 atexit (restore_old_foreground_pgrp
);
259 if (wrapper_argv
!= NULL
)
261 ptid_t ptid
= pid_to_ptid (signal_pid
);
263 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
265 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
269 target_continue_no_signal (ptid
);
271 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
272 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
275 current_thread
->last_resume_kind
= resume_stop
;
276 current_thread
->last_status
= last_status
;
278 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
280 target_post_create_inferior ();
284 /* Wait till we are at 1st instruction in program, return new pid
285 (assuming success). */
286 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
288 target_post_create_inferior ();
290 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
291 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
293 current_thread
->last_resume_kind
= resume_stop
;
294 current_thread
->last_status
= last_status
;
297 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
303 attach_inferior (int pid
)
305 /* myattach should return -1 if attaching is unsupported,
306 0 if it succeeded, and call error() otherwise. */
308 if (myattach (pid
) != 0)
311 fprintf (stderr
, "Attached; pid = %d\n", pid
);
314 /* FIXME - It may be that we should get the SIGNAL_PID from the
315 attach function, so that it can be the main thread instead of
316 whichever we were told to attach to. */
321 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
323 /* GDB knows to ignore the first SIGSTOP after attaching to a running
324 process using the "attach" command, but this is different; it's
325 just using "target remote". Pretend it's just starting up. */
326 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
327 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
328 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
330 current_thread
->last_resume_kind
= resume_stop
;
331 current_thread
->last_status
= last_status
;
337 extern int remote_debug
;
339 /* Decode a qXfer read request. Return 0 if everything looks OK,
343 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
345 /* After the read marker and annex, qXfer looks like a
346 traditional 'm' packet. */
347 decode_m_packet (buf
, ofs
, len
);
353 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
355 /* Extract and NUL-terminate the object. */
357 while (*buf
&& *buf
!= ':')
363 /* Extract and NUL-terminate the read/write action. */
365 while (*buf
&& *buf
!= ':')
371 /* Extract and NUL-terminate the annex. */
373 while (*buf
&& *buf
!= ':')
383 /* Write the response to a successful qXfer read. Returns the
384 length of the (binary) data stored in BUF, corresponding
385 to as much of DATA/LEN as we could fit. IS_MORE controls
386 the first character of the response. */
388 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
397 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
398 &out_len
, PBUFSIZ
- 2) + 1;
401 /* Handle btrace enabling in BTS format. */
404 handle_btrace_enable_bts (struct thread_info
*thread
)
406 if (thread
->btrace
!= NULL
)
407 return "E.Btrace already enabled.";
409 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
410 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
411 ¤t_btrace_conf
);
412 if (thread
->btrace
== NULL
)
413 return "E.Could not enable btrace.";
418 /* Handle btrace enabling in Intel Processor Trace format. */
421 handle_btrace_enable_pt (struct thread_info
*thread
)
423 if (thread
->btrace
!= NULL
)
424 return "E.Btrace already enabled.";
426 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
427 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
428 ¤t_btrace_conf
);
429 if (thread
->btrace
== NULL
)
430 return "E.Could not enable btrace.";
435 /* Handle btrace disabling. */
438 handle_btrace_disable (struct thread_info
*thread
)
441 if (thread
->btrace
== NULL
)
442 return "E.Branch tracing not enabled.";
444 if (target_disable_btrace (thread
->btrace
) != 0)
445 return "E.Could not disable branch tracing.";
447 thread
->btrace
= NULL
;
451 /* Handle the "Qbtrace" packet. */
454 handle_btrace_general_set (char *own_buf
)
456 struct thread_info
*thread
;
460 if (!startswith (own_buf
, "Qbtrace:"))
463 op
= own_buf
+ strlen ("Qbtrace:");
465 if (ptid_equal (general_thread
, null_ptid
)
466 || ptid_equal (general_thread
, minus_one_ptid
))
468 strcpy (own_buf
, "E.Must select a single thread.");
472 thread
= find_thread_ptid (general_thread
);
475 strcpy (own_buf
, "E.No such thread.");
481 if (strcmp (op
, "bts") == 0)
482 err
= handle_btrace_enable_bts (thread
);
483 else if (strcmp (op
, "pt") == 0)
484 err
= handle_btrace_enable_pt (thread
);
485 else if (strcmp (op
, "off") == 0)
486 err
= handle_btrace_disable (thread
);
488 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
491 strcpy (own_buf
, err
);
498 /* Handle the "Qbtrace-conf" packet. */
501 handle_btrace_conf_general_set (char *own_buf
)
503 struct thread_info
*thread
;
506 if (!startswith (own_buf
, "Qbtrace-conf:"))
509 op
= own_buf
+ strlen ("Qbtrace-conf:");
511 if (ptid_equal (general_thread
, null_ptid
)
512 || ptid_equal (general_thread
, minus_one_ptid
))
514 strcpy (own_buf
, "E.Must select a single thread.");
518 thread
= find_thread_ptid (general_thread
);
521 strcpy (own_buf
, "E.No such thread.");
525 if (startswith (op
, "bts:size="))
531 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
532 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
534 strcpy (own_buf
, "E.Bad size value.");
538 current_btrace_conf
.bts
.size
= (unsigned int) size
;
540 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
546 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
547 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
549 strcpy (own_buf
, "E.Bad size value.");
553 current_btrace_conf
.pt
.size
= (unsigned int) size
;
557 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
565 /* Handle all of the extended 'Q' packets. */
568 handle_general_set (char *own_buf
)
570 if (startswith (own_buf
, "QPassSignals:"))
572 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
573 const char *p
= own_buf
+ strlen ("QPassSignals:");
576 p
= decode_address_to_semicolon (&cursig
, p
);
577 for (i
= 0; i
< numsigs
; i
++)
583 /* Keep looping, to clear the remaining signals. */
586 p
= decode_address_to_semicolon (&cursig
, p
);
591 strcpy (own_buf
, "OK");
595 if (startswith (own_buf
, "QProgramSignals:"))
597 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
598 const char *p
= own_buf
+ strlen ("QProgramSignals:");
601 program_signals_p
= 1;
603 p
= decode_address_to_semicolon (&cursig
, p
);
604 for (i
= 0; i
< numsigs
; i
++)
608 program_signals
[i
] = 1;
610 /* Keep looping, to clear the remaining signals. */
613 p
= decode_address_to_semicolon (&cursig
, p
);
616 program_signals
[i
] = 0;
618 strcpy (own_buf
, "OK");
622 if (startswith (own_buf
, "QCatchSyscalls:"))
624 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
627 struct process_info
*process
;
629 if (!target_running () || !target_supports_catch_syscall ())
635 if (strcmp (p
, "0") == 0)
637 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
641 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
647 process
= current_process ();
648 VEC_truncate (int, process
->syscalls_to_catch
, 0);
658 p
= decode_address_to_semicolon (&sysno
, p
);
659 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
663 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
670 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
674 fprintf (stderr
, "[noack mode enabled]\n");
683 if (startswith (own_buf
, "QNonStop:"))
685 char *mode
= own_buf
+ 9;
689 if (strcmp (mode
, "0") == 0)
691 else if (strcmp (mode
, "1") == 0)
695 /* We don't know what this mode is, so complain to
697 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
703 req_str
= req
? "non-stop" : "all-stop";
704 if (start_non_stop (req
) != 0)
706 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
714 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
720 if (startswith (own_buf
, "QDisableRandomization:"))
722 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
725 unpack_varlen_hex (packet
, &setting
);
726 disable_randomization
= setting
;
730 if (disable_randomization
)
731 fprintf (stderr
, "[address space randomization disabled]\n");
733 fprintf (stderr
, "[address space randomization enabled]\n");
740 if (target_supports_tracepoints ()
741 && handle_tracepoint_general_set (own_buf
))
744 if (startswith (own_buf
, "QAgent:"))
746 char *mode
= own_buf
+ strlen ("QAgent:");
749 if (strcmp (mode
, "0") == 0)
751 else if (strcmp (mode
, "1") == 0)
755 /* We don't know what this value is, so complain to GDB. */
756 sprintf (own_buf
, "E.Unknown QAgent value");
760 /* Update the flag. */
763 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
768 if (handle_btrace_general_set (own_buf
))
771 if (handle_btrace_conf_general_set (own_buf
))
774 if (startswith (own_buf
, "QThreadEvents:"))
776 char *mode
= own_buf
+ strlen ("QThreadEvents:");
777 enum tribool req
= TRIBOOL_UNKNOWN
;
779 if (strcmp (mode
, "0") == 0)
781 else if (strcmp (mode
, "1") == 0)
785 char *mode_copy
= xstrdup (mode
);
787 /* We don't know what this mode is, so complain to GDB. */
788 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
794 report_thread_events
= (req
== TRIBOOL_TRUE
);
798 const char *req_str
= report_thread_events
? "enabled" : "disabled";
800 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
807 /* Otherwise we didn't know what packet it was. Say we didn't
813 get_features_xml (const char *annex
)
815 const struct target_desc
*desc
= current_target_desc ();
817 /* `desc->xmltarget' defines what to return when looking for the
818 "target.xml" file. Its contents can either be verbatim XML code
819 (prefixed with a '@') or else the name of the actual XML file to
820 be used in place of "target.xml".
822 This variable is set up from the auto-generated
823 init_registers_... routine for the current target. */
825 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
827 if (*desc
->xmltarget
== '@')
828 return desc
->xmltarget
+ 1;
830 annex
= desc
->xmltarget
;
835 extern const char *const xml_builtin
[][2];
838 /* Look for the annex. */
839 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
840 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
843 if (xml_builtin
[i
][0] != NULL
)
844 return xml_builtin
[i
][1];
852 monitor_show_help (void)
854 monitor_output ("The following monitor commands are supported:\n");
855 monitor_output (" set debug <0|1>\n");
856 monitor_output (" Enable general debugging messages\n");
857 monitor_output (" set debug-hw-points <0|1>\n");
858 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
859 monitor_output (" set remote-debug <0|1>\n");
860 monitor_output (" Enable remote protocol debugging messages\n");
861 monitor_output (" set debug-format option1[,option2,...]\n");
862 monitor_output (" Add additional information to debugging messages\n");
863 monitor_output (" Options: all, none");
864 monitor_output (", timestamp");
865 monitor_output ("\n");
866 monitor_output (" exit\n");
867 monitor_output (" Quit GDBserver\n");
870 /* Read trace frame or inferior memory. Returns the number of bytes
871 actually read, zero when no further transfer is possible, and -1 on
872 error. Return of a positive value smaller than LEN does not
873 indicate there's no more to be read, only the end of the transfer.
874 E.g., when GDB reads memory from a traceframe, a first request may
875 be served from a memory block that does not cover the whole request
876 length. A following request gets the rest served from either
877 another block (of the same traceframe) or from the read-only
881 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
885 if (current_traceframe
>= 0)
888 ULONGEST length
= len
;
890 if (traceframe_read_mem (current_traceframe
,
891 memaddr
, myaddr
, len
, &nbytes
))
893 /* Data read from trace buffer, we're done. */
896 if (!in_readonly_region (memaddr
, length
))
898 /* Otherwise we have a valid readonly case, fall through. */
899 /* (assume no half-trace half-real blocks for now) */
902 res
= prepare_to_access_memory ();
905 if (set_desired_thread (1))
906 res
= read_inferior_memory (memaddr
, myaddr
, len
);
909 done_accessing_memory ();
911 return res
== 0 ? len
: -1;
917 /* Write trace frame or inferior memory. Actually, writing to trace
918 frames is forbidden. */
921 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
923 if (current_traceframe
>= 0)
929 ret
= prepare_to_access_memory ();
932 if (set_desired_thread (1))
933 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
936 done_accessing_memory ();
942 /* Subroutine of handle_search_memory to simplify it. */
945 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
946 gdb_byte
*pattern
, unsigned pattern_len
,
947 gdb_byte
*search_buf
,
948 unsigned chunk_size
, unsigned search_buf_size
,
949 CORE_ADDR
*found_addrp
)
951 /* Prime the search buffer. */
953 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
956 warning ("Unable to access %ld bytes of target "
957 "memory at 0x%lx, halting search.",
958 (long) search_buf_size
, (long) start_addr
);
962 /* Perform the search.
964 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
965 When we've scanned N bytes we copy the trailing bytes to the start and
966 read in another N bytes. */
968 while (search_space_len
>= pattern_len
)
971 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
975 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
978 if (found_ptr
!= NULL
)
980 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
981 *found_addrp
= found_addr
;
985 /* Not found in this chunk, skip to next chunk. */
987 /* Don't let search_space_len wrap here, it's unsigned. */
988 if (search_space_len
>= chunk_size
)
989 search_space_len
-= chunk_size
;
991 search_space_len
= 0;
993 if (search_space_len
>= pattern_len
)
995 unsigned keep_len
= search_buf_size
- chunk_size
;
996 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
999 /* Copy the trailing part of the previous iteration to the front
1000 of the buffer for the next iteration. */
1001 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1003 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1004 ? search_space_len
- keep_len
1007 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1008 nr_to_read
) != search_buf_size
)
1010 warning ("Unable to access %ld bytes of target memory "
1011 "at 0x%lx, halting search.",
1012 (long) nr_to_read
, (long) read_addr
);
1016 start_addr
+= chunk_size
;
1025 /* Handle qSearch:memory packets. */
1028 handle_search_memory (char *own_buf
, int packet_len
)
1030 CORE_ADDR start_addr
;
1031 CORE_ADDR search_space_len
;
1033 unsigned int pattern_len
;
1034 /* NOTE: also defined in find.c testcase. */
1035 #define SEARCH_CHUNK_SIZE 16000
1036 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1037 /* Buffer to hold memory contents for searching. */
1038 gdb_byte
*search_buf
;
1039 unsigned search_buf_size
;
1041 CORE_ADDR found_addr
;
1042 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1044 pattern
= (gdb_byte
*) malloc (packet_len
);
1045 if (pattern
== NULL
)
1047 error ("Unable to allocate memory to perform the search");
1048 strcpy (own_buf
, "E00");
1051 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1052 packet_len
- cmd_name_len
,
1053 &start_addr
, &search_space_len
,
1054 pattern
, &pattern_len
) < 0)
1057 error ("Error in parsing qSearch:memory packet");
1058 strcpy (own_buf
, "E00");
1062 search_buf_size
= chunk_size
+ pattern_len
- 1;
1064 /* No point in trying to allocate a buffer larger than the search space. */
1065 if (search_space_len
< search_buf_size
)
1066 search_buf_size
= search_space_len
;
1068 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1069 if (search_buf
== NULL
)
1072 error ("Unable to allocate memory to perform the search");
1073 strcpy (own_buf
, "E00");
1077 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1078 pattern
, pattern_len
,
1079 search_buf
, chunk_size
, search_buf_size
,
1083 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1084 else if (found
== 0)
1085 strcpy (own_buf
, "0");
1087 strcpy (own_buf
, "E00");
1093 #define require_running(BUF) \
1094 if (!target_running ()) \
1100 /* Parse options to --debug-format= and "monitor set debug-format".
1101 ARG is the text after "--debug-format=" or "monitor set debug-format".
1102 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1103 This triggers calls to monitor_output.
1104 The result is NULL if all options were parsed ok, otherwise an error
1105 message which the caller must free.
1107 N.B. These commands affect all debug format settings, they are not
1108 cumulative. If a format is not specified, it is turned off.
1109 However, we don't go to extra trouble with things like
1110 "monitor set debug-format all,none,timestamp".
1111 Instead we just parse them one at a time, in order.
1113 The syntax for "monitor set debug" we support here is not identical
1114 to gdb's "set debug foo on|off" because we also use this function to
1115 parse "--debug-format=foo,bar". */
1118 parse_debug_format_options (const char *arg
, int is_monitor
)
1120 VEC (char_ptr
) *options
;
1124 /* First turn all debug format options off. */
1125 debug_timestamp
= 0;
1127 /* First remove leading spaces, for "monitor set debug-format". */
1128 while (isspace (*arg
))
1131 options
= delim_string_to_char_ptr_vec (arg
, ',');
1133 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1135 if (strcmp (option
, "all") == 0)
1137 debug_timestamp
= 1;
1139 monitor_output ("All extra debug format options enabled.\n");
1141 else if (strcmp (option
, "none") == 0)
1143 debug_timestamp
= 0;
1145 monitor_output ("All extra debug format options disabled.\n");
1147 else if (strcmp (option
, "timestamp") == 0)
1149 debug_timestamp
= 1;
1151 monitor_output ("Timestamps will be added to debug output.\n");
1153 else if (*option
== '\0')
1155 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1160 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1163 free_char_ptr_vec (options
);
1168 free_char_ptr_vec (options
);
1172 /* Handle monitor commands not handled by target-specific handlers. */
1175 handle_monitor_command (char *mon
, char *own_buf
)
1177 if (strcmp (mon
, "set debug 1") == 0)
1180 monitor_output ("Debug output enabled.\n");
1182 else if (strcmp (mon
, "set debug 0") == 0)
1185 monitor_output ("Debug output disabled.\n");
1187 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1189 show_debug_regs
= 1;
1190 monitor_output ("H/W point debugging output enabled.\n");
1192 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1194 show_debug_regs
= 0;
1195 monitor_output ("H/W point debugging output disabled.\n");
1197 else if (strcmp (mon
, "set remote-debug 1") == 0)
1200 monitor_output ("Protocol debug output enabled.\n");
1202 else if (strcmp (mon
, "set remote-debug 0") == 0)
1205 monitor_output ("Protocol debug output disabled.\n");
1207 else if (startswith (mon
, "set debug-format "))
1210 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1213 if (error_msg
!= NULL
)
1215 monitor_output (error_msg
);
1216 monitor_show_help ();
1217 write_enn (own_buf
);
1221 else if (strcmp (mon
, "help") == 0)
1222 monitor_show_help ();
1223 else if (strcmp (mon
, "exit") == 0)
1227 monitor_output ("Unknown monitor command.\n\n");
1228 monitor_show_help ();
1229 write_enn (own_buf
);
1233 /* Associates a callback with each supported qXfer'able object. */
1237 /* The object this handler handles. */
1240 /* Request that the target transfer up to LEN 8-bit bytes of the
1241 target's OBJECT. The OFFSET, for a seekable object, specifies
1242 the starting point. The ANNEX can be used to provide additional
1243 data-specific information to the target.
1245 Return the number of bytes actually transfered, zero when no
1246 further transfer is possible, -1 on error, -2 when the transfer
1247 is not supported, and -3 on a verbose error message that should
1248 be preserved. Return of a positive value smaller than LEN does
1249 not indicate the end of the object, only the end of the transfer.
1251 One, and only one, of readbuf or writebuf must be non-NULL. */
1252 int (*xfer
) (const char *annex
,
1253 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1254 ULONGEST offset
, LONGEST len
);
1257 /* Handle qXfer:auxv:read. */
1260 handle_qxfer_auxv (const char *annex
,
1261 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1262 ULONGEST offset
, LONGEST len
)
1264 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1267 if (annex
[0] != '\0' || current_thread
== NULL
)
1270 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1273 /* Handle qXfer:exec-file:read. */
1276 handle_qxfer_exec_file (const char *const_annex
,
1277 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1278 ULONGEST offset
, LONGEST len
)
1284 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1287 if (const_annex
[0] == '\0')
1289 if (current_thread
== NULL
)
1292 pid
= pid_of (current_thread
);
1296 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1298 strcpy (annex
, const_annex
);
1299 annex
= unpack_varlen_hex (annex
, &pid
);
1301 if (annex
[0] != '\0')
1308 file
= (*the_target
->pid_to_exec_file
) (pid
);
1312 total_len
= strlen (file
);
1314 if (offset
> total_len
)
1317 if (offset
+ len
> total_len
)
1318 len
= total_len
- offset
;
1320 memcpy (readbuf
, file
+ offset
, len
);
1324 /* Handle qXfer:features:read. */
1327 handle_qxfer_features (const char *annex
,
1328 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1329 ULONGEST offset
, LONGEST len
)
1331 const char *document
;
1334 if (writebuf
!= NULL
)
1337 if (!target_running ())
1340 /* Grab the correct annex. */
1341 document
= get_features_xml (annex
);
1342 if (document
== NULL
)
1345 total_len
= strlen (document
);
1347 if (offset
> total_len
)
1350 if (offset
+ len
> total_len
)
1351 len
= total_len
- offset
;
1353 memcpy (readbuf
, document
+ offset
, len
);
1357 /* Worker routine for handle_qxfer_libraries.
1358 Add to the length pointed to by ARG a conservative estimate of the
1359 length needed to transmit the file name of INF. */
1362 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1364 struct dll_info
*dll
= (struct dll_info
*) inf
;
1365 unsigned int *total_len
= (unsigned int *) arg
;
1367 /* Over-estimate the necessary memory. Assume that every character
1368 in the library name must be escaped. */
1369 *total_len
+= 128 + 6 * strlen (dll
->name
);
1372 /* Worker routine for handle_qxfer_libraries.
1373 Emit the XML to describe the library in INF. */
1376 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1378 struct dll_info
*dll
= (struct dll_info
*) inf
;
1379 char **p_ptr
= (char **) arg
;
1383 strcpy (p
, " <library name=\"");
1385 name
= xml_escape_text (dll
->name
);
1389 strcpy (p
, "\"><segment address=\"");
1391 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1393 strcpy (p
, "\"/></library>\n");
1399 /* Handle qXfer:libraries:read. */
1402 handle_qxfer_libraries (const char *annex
,
1403 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1404 ULONGEST offset
, LONGEST len
)
1406 unsigned int total_len
;
1409 if (writebuf
!= NULL
)
1412 if (annex
[0] != '\0' || current_thread
== NULL
)
1416 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1419 document
= (char *) malloc (total_len
);
1420 if (document
== NULL
)
1423 strcpy (document
, "<library-list version=\"1.0\">\n");
1424 p
= document
+ strlen (document
);
1426 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1428 strcpy (p
, "</library-list>\n");
1430 total_len
= strlen (document
);
1432 if (offset
> total_len
)
1438 if (offset
+ len
> total_len
)
1439 len
= total_len
- offset
;
1441 memcpy (readbuf
, document
+ offset
, len
);
1446 /* Handle qXfer:libraries-svr4:read. */
1449 handle_qxfer_libraries_svr4 (const char *annex
,
1450 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1451 ULONGEST offset
, LONGEST len
)
1453 if (writebuf
!= NULL
)
1456 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1459 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1462 /* Handle qXfer:osadata:read. */
1465 handle_qxfer_osdata (const char *annex
,
1466 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1467 ULONGEST offset
, LONGEST len
)
1469 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1472 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1475 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1478 handle_qxfer_siginfo (const char *annex
,
1479 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1480 ULONGEST offset
, LONGEST len
)
1482 if (the_target
->qxfer_siginfo
== NULL
)
1485 if (annex
[0] != '\0' || current_thread
== NULL
)
1488 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1491 /* Handle qXfer:spu:read and qXfer:spu:write. */
1494 handle_qxfer_spu (const char *annex
,
1495 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1496 ULONGEST offset
, LONGEST len
)
1498 if (the_target
->qxfer_spu
== NULL
)
1501 if (current_thread
== NULL
)
1504 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1507 /* Handle qXfer:statictrace:read. */
1510 handle_qxfer_statictrace (const char *annex
,
1511 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1512 ULONGEST offset
, LONGEST len
)
1516 if (writebuf
!= NULL
)
1519 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1522 if (traceframe_read_sdata (current_traceframe
, offset
,
1523 readbuf
, len
, &nbytes
))
1528 /* Helper for handle_qxfer_threads_proper.
1529 Emit the XML to describe the thread of INF. */
1532 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1534 struct thread_info
*thread
= (struct thread_info
*) inf
;
1535 struct buffer
*buffer
= (struct buffer
*) arg
;
1536 ptid_t ptid
= thread_to_gdb_id (thread
);
1538 int core
= target_core_of_thread (ptid
);
1540 const char *name
= target_thread_name (ptid
);
1542 write_ptid (ptid_s
, ptid
);
1544 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1548 sprintf (core_s
, "%d", core
);
1549 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1553 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1555 buffer_xml_printf (buffer
, "/>\n");
1558 /* Helper for handle_qxfer_threads. */
1561 handle_qxfer_threads_proper (struct buffer
*buffer
)
1563 buffer_grow_str (buffer
, "<threads>\n");
1565 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1568 buffer_grow_str0 (buffer
, "</threads>\n");
1571 /* Handle qXfer:threads:read. */
1574 handle_qxfer_threads (const char *annex
,
1575 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1576 ULONGEST offset
, LONGEST len
)
1578 static char *result
= 0;
1579 static unsigned int result_length
= 0;
1581 if (writebuf
!= NULL
)
1584 if (annex
[0] != '\0')
1589 struct buffer buffer
;
1590 /* When asked for data at offset 0, generate everything and store into
1591 'result'. Successive reads will be served off 'result'. */
1595 buffer_init (&buffer
);
1597 handle_qxfer_threads_proper (&buffer
);
1599 result
= buffer_finish (&buffer
);
1600 result_length
= strlen (result
);
1601 buffer_free (&buffer
);
1604 if (offset
>= result_length
)
1606 /* We're out of data. */
1613 if (len
> result_length
- offset
)
1614 len
= result_length
- offset
;
1616 memcpy (readbuf
, result
+ offset
, len
);
1621 /* Handle qXfer:traceframe-info:read. */
1624 handle_qxfer_traceframe_info (const char *annex
,
1625 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1626 ULONGEST offset
, LONGEST len
)
1628 static char *result
= 0;
1629 static unsigned int result_length
= 0;
1631 if (writebuf
!= NULL
)
1634 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1639 struct buffer buffer
;
1641 /* When asked for data at offset 0, generate everything and
1642 store into 'result'. Successive reads will be served off
1646 buffer_init (&buffer
);
1648 traceframe_read_info (current_traceframe
, &buffer
);
1650 result
= buffer_finish (&buffer
);
1651 result_length
= strlen (result
);
1652 buffer_free (&buffer
);
1655 if (offset
>= result_length
)
1657 /* We're out of data. */
1664 if (len
> result_length
- offset
)
1665 len
= result_length
- offset
;
1667 memcpy (readbuf
, result
+ offset
, len
);
1671 /* Handle qXfer:fdpic:read. */
1674 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1675 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1677 if (the_target
->read_loadmap
== NULL
)
1680 if (current_thread
== NULL
)
1683 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1686 /* Handle qXfer:btrace:read. */
1689 handle_qxfer_btrace (const char *annex
,
1690 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1691 ULONGEST offset
, LONGEST len
)
1693 static struct buffer cache
;
1694 struct thread_info
*thread
;
1695 enum btrace_read_type type
;
1698 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1701 if (ptid_equal (general_thread
, null_ptid
)
1702 || ptid_equal (general_thread
, minus_one_ptid
))
1704 strcpy (own_buf
, "E.Must select a single thread.");
1708 thread
= find_thread_ptid (general_thread
);
1711 strcpy (own_buf
, "E.No such thread.");
1715 if (thread
->btrace
== NULL
)
1717 strcpy (own_buf
, "E.Btrace not enabled.");
1721 if (strcmp (annex
, "all") == 0)
1722 type
= BTRACE_READ_ALL
;
1723 else if (strcmp (annex
, "new") == 0)
1724 type
= BTRACE_READ_NEW
;
1725 else if (strcmp (annex
, "delta") == 0)
1726 type
= BTRACE_READ_DELTA
;
1729 strcpy (own_buf
, "E.Bad annex.");
1735 buffer_free (&cache
);
1737 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1740 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1744 else if (offset
> cache
.used_size
)
1746 buffer_free (&cache
);
1750 if (len
> cache
.used_size
- offset
)
1751 len
= cache
.used_size
- offset
;
1753 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1758 /* Handle qXfer:btrace-conf:read. */
1761 handle_qxfer_btrace_conf (const char *annex
,
1762 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1763 ULONGEST offset
, LONGEST len
)
1765 static struct buffer cache
;
1766 struct thread_info
*thread
;
1769 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1772 if (annex
[0] != '\0')
1775 if (ptid_equal (general_thread
, null_ptid
)
1776 || ptid_equal (general_thread
, minus_one_ptid
))
1778 strcpy (own_buf
, "E.Must select a single thread.");
1782 thread
= find_thread_ptid (general_thread
);
1785 strcpy (own_buf
, "E.No such thread.");
1789 if (thread
->btrace
== NULL
)
1791 strcpy (own_buf
, "E.Btrace not enabled.");
1797 buffer_free (&cache
);
1799 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1802 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1806 else if (offset
> cache
.used_size
)
1808 buffer_free (&cache
);
1812 if (len
> cache
.used_size
- offset
)
1813 len
= cache
.used_size
- offset
;
1815 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1820 static const struct qxfer qxfer_packets
[] =
1822 { "auxv", handle_qxfer_auxv
},
1823 { "btrace", handle_qxfer_btrace
},
1824 { "btrace-conf", handle_qxfer_btrace_conf
},
1825 { "exec-file", handle_qxfer_exec_file
},
1826 { "fdpic", handle_qxfer_fdpic
},
1827 { "features", handle_qxfer_features
},
1828 { "libraries", handle_qxfer_libraries
},
1829 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1830 { "osdata", handle_qxfer_osdata
},
1831 { "siginfo", handle_qxfer_siginfo
},
1832 { "spu", handle_qxfer_spu
},
1833 { "statictrace", handle_qxfer_statictrace
},
1834 { "threads", handle_qxfer_threads
},
1835 { "traceframe-info", handle_qxfer_traceframe_info
},
1839 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1847 if (!startswith (own_buf
, "qXfer:"))
1850 /* Grab the object, r/w and annex. */
1851 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1853 write_enn (own_buf
);
1858 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1861 const struct qxfer
*q
= &qxfer_packets
[i
];
1863 if (strcmp (object
, q
->object
) == 0)
1865 if (strcmp (rw
, "read") == 0)
1867 unsigned char *data
;
1872 /* Grab the offset and length. */
1873 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1875 write_enn (own_buf
);
1879 /* Read one extra byte, as an indicator of whether there is
1881 if (len
> PBUFSIZ
- 2)
1883 data
= (unsigned char *) malloc (len
+ 1);
1886 write_enn (own_buf
);
1889 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1897 /* Preserve error message. */
1900 write_enn (own_buf
);
1902 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1904 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1909 else if (strcmp (rw
, "write") == 0)
1914 unsigned char *data
;
1916 strcpy (own_buf
, "E00");
1917 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1920 write_enn (own_buf
);
1923 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1924 &ofs
, &len
, data
) < 0)
1927 write_enn (own_buf
);
1931 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1939 /* Preserve error message. */
1942 write_enn (own_buf
);
1944 sprintf (own_buf
, "%x", n
);
1957 /* Compute 32 bit CRC from inferior memory.
1959 On success, return 32 bit CRC.
1960 On failure, return (unsigned long long) -1. */
1962 static unsigned long long
1963 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1967 unsigned char byte
= 0;
1969 /* Return failure if memory read fails. */
1970 if (read_inferior_memory (base
, &byte
, 1) != 0)
1971 return (unsigned long long) -1;
1973 crc
= xcrc32 (&byte
, 1, crc
);
1976 return (unsigned long long) crc
;
1979 /* Add supported btrace packets to BUF. */
1982 supported_btrace_packets (char *buf
)
1984 int btrace_supported
= 0;
1986 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1988 strcat (buf
, ";Qbtrace:bts+");
1989 strcat (buf
, ";Qbtrace-conf:bts:size+");
1991 btrace_supported
= 1;
1994 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1996 strcat (buf
, ";Qbtrace:pt+");
1997 strcat (buf
, ";Qbtrace-conf:pt:size+");
1999 btrace_supported
= 1;
2002 if (!btrace_supported
)
2005 strcat (buf
, ";Qbtrace:off+");
2006 strcat (buf
, ";qXfer:btrace:read+");
2007 strcat (buf
, ";qXfer:btrace-conf:read+");
2010 /* Handle all of the extended 'q' packets. */
2013 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2015 static struct inferior_list_entry
*thread_ptr
;
2017 /* Reply the current thread id. */
2018 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2021 require_running (own_buf
);
2023 if (!ptid_equal (general_thread
, null_ptid
)
2024 && !ptid_equal (general_thread
, minus_one_ptid
))
2025 gdb_id
= general_thread
;
2028 thread_ptr
= get_first_inferior (&all_threads
);
2029 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2032 sprintf (own_buf
, "QC");
2034 write_ptid (own_buf
, gdb_id
);
2038 if (strcmp ("qSymbol::", own_buf
) == 0)
2040 struct thread_info
*save_thread
= current_thread
;
2042 /* For qSymbol, GDB only changes the current thread if the
2043 previous current thread was of a different process. So if
2044 the previous thread is gone, we need to pick another one of
2045 the same process. This can happen e.g., if we followed an
2046 exec in a non-leader thread. */
2047 if (current_thread
== NULL
)
2050 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2052 /* Just in case, if we didn't find a thread, then bail out
2053 instead of crashing. */
2054 if (current_thread
== NULL
)
2056 write_enn (own_buf
);
2057 current_thread
= save_thread
;
2062 /* GDB is suggesting new symbols have been loaded. This may
2063 mean a new shared library has been detected as loaded, so
2064 take the opportunity to check if breakpoints we think are
2065 inserted, still are. Note that it isn't guaranteed that
2066 we'll see this when a shared library is loaded, and nor will
2067 we see this for unloads (although breakpoints in unloaded
2068 libraries shouldn't trigger), as GDB may not find symbols for
2069 the library at all. We also re-validate breakpoints when we
2070 see a second GDB breakpoint for the same address, and or when
2071 we access breakpoint shadows. */
2072 validate_breakpoints ();
2074 if (target_supports_tracepoints ())
2075 tracepoint_look_up_symbols ();
2077 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2078 (*the_target
->look_up_symbols
) ();
2080 current_thread
= save_thread
;
2082 strcpy (own_buf
, "OK");
2086 if (!disable_packet_qfThreadInfo
)
2088 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2092 require_running (own_buf
);
2093 thread_ptr
= get_first_inferior (&all_threads
);
2096 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2097 write_ptid (own_buf
, gdb_id
);
2098 thread_ptr
= thread_ptr
->next
;
2102 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2106 require_running (own_buf
);
2107 if (thread_ptr
!= NULL
)
2110 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2111 write_ptid (own_buf
, gdb_id
);
2112 thread_ptr
= thread_ptr
->next
;
2117 sprintf (own_buf
, "l");
2123 if (the_target
->read_offsets
!= NULL
2124 && strcmp ("qOffsets", own_buf
) == 0)
2126 CORE_ADDR text
, data
;
2128 require_running (own_buf
);
2129 if (the_target
->read_offsets (&text
, &data
))
2130 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2131 (long)text
, (long)data
, (long)data
);
2133 write_enn (own_buf
);
2138 /* Protocol features query. */
2139 if (startswith (own_buf
, "qSupported")
2140 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2142 char *p
= &own_buf
[10];
2143 int gdb_supports_qRelocInsn
= 0;
2145 /* Process each feature being provided by GDB. The first
2146 feature will follow a ':', and latter features will follow
2150 char **qsupported
= NULL
;
2155 /* Two passes, to avoid nested strtok calls in
2156 target_process_qsupported. */
2157 for (p
= strtok (p
+ 1, ";");
2159 p
= strtok (NULL
, ";"))
2162 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2163 qsupported
[count
- 1] = xstrdup (p
);
2166 for (i
= 0; i
< count
; i
++)
2169 if (strcmp (p
, "multiprocess+") == 0)
2171 /* GDB supports and wants multi-process support if
2173 if (target_supports_multi_process ())
2176 else if (strcmp (p
, "qRelocInsn+") == 0)
2178 /* GDB supports relocate instruction requests. */
2179 gdb_supports_qRelocInsn
= 1;
2181 else if (strcmp (p
, "swbreak+") == 0)
2183 /* GDB wants us to report whether a trap is caused
2184 by a software breakpoint and for us to handle PC
2185 adjustment if necessary on this target. */
2186 if (target_supports_stopped_by_sw_breakpoint ())
2187 swbreak_feature
= 1;
2189 else if (strcmp (p
, "hwbreak+") == 0)
2191 /* GDB wants us to report whether a trap is caused
2192 by a hardware breakpoint. */
2193 if (target_supports_stopped_by_hw_breakpoint ())
2194 hwbreak_feature
= 1;
2196 else if (strcmp (p
, "fork-events+") == 0)
2198 /* GDB supports and wants fork events if possible. */
2199 if (target_supports_fork_events ())
2200 report_fork_events
= 1;
2202 else if (strcmp (p
, "vfork-events+") == 0)
2204 /* GDB supports and wants vfork events if possible. */
2205 if (target_supports_vfork_events ())
2206 report_vfork_events
= 1;
2208 else if (strcmp (p
, "exec-events+") == 0)
2210 /* GDB supports and wants exec events if possible. */
2211 if (target_supports_exec_events ())
2212 report_exec_events
= 1;
2214 else if (strcmp (p
, "vContSupported+") == 0)
2215 vCont_supported
= 1;
2216 else if (strcmp (p
, "QThreadEvents+") == 0)
2218 else if (strcmp (p
, "no-resumed+") == 0)
2220 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2222 report_no_resumed
= 1;
2226 /* Move the unknown features all together. */
2227 qsupported
[i
] = NULL
;
2228 qsupported
[unknown
] = p
;
2233 /* Give the target backend a chance to process the unknown
2235 target_process_qsupported (qsupported
, unknown
);
2237 for (i
= 0; i
< count
; i
++)
2238 free (qsupported
[i
]);
2243 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2246 if (target_supports_catch_syscall ())
2247 strcat (own_buf
, ";QCatchSyscalls+");
2249 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2250 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2251 ";augmented-libraries-svr4-read+");
2254 /* We do not have any hook to indicate whether the non-SVR4 target
2255 backend supports qXfer:libraries:read, so always report it. */
2256 strcat (own_buf
, ";qXfer:libraries:read+");
2259 if (the_target
->read_auxv
!= NULL
)
2260 strcat (own_buf
, ";qXfer:auxv:read+");
2262 if (the_target
->qxfer_spu
!= NULL
)
2263 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2265 if (the_target
->qxfer_siginfo
!= NULL
)
2266 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2268 if (the_target
->read_loadmap
!= NULL
)
2269 strcat (own_buf
, ";qXfer:fdpic:read+");
2271 /* We always report qXfer:features:read, as targets may
2272 install XML files on a subsequent call to arch_setup.
2273 If we reported to GDB on startup that we don't support
2274 qXfer:feature:read at all, we will never be re-queried. */
2275 strcat (own_buf
, ";qXfer:features:read+");
2277 if (transport_is_reliable
)
2278 strcat (own_buf
, ";QStartNoAckMode+");
2280 if (the_target
->qxfer_osdata
!= NULL
)
2281 strcat (own_buf
, ";qXfer:osdata:read+");
2283 if (target_supports_multi_process ())
2284 strcat (own_buf
, ";multiprocess+");
2286 if (target_supports_fork_events ())
2287 strcat (own_buf
, ";fork-events+");
2289 if (target_supports_vfork_events ())
2290 strcat (own_buf
, ";vfork-events+");
2292 if (target_supports_exec_events ())
2293 strcat (own_buf
, ";exec-events+");
2295 if (target_supports_non_stop ())
2296 strcat (own_buf
, ";QNonStop+");
2298 if (target_supports_disable_randomization ())
2299 strcat (own_buf
, ";QDisableRandomization+");
2301 strcat (own_buf
, ";qXfer:threads:read+");
2303 if (target_supports_tracepoints ())
2305 strcat (own_buf
, ";ConditionalTracepoints+");
2306 strcat (own_buf
, ";TraceStateVariables+");
2307 strcat (own_buf
, ";TracepointSource+");
2308 strcat (own_buf
, ";DisconnectedTracing+");
2309 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2310 strcat (own_buf
, ";FastTracepoints+");
2311 strcat (own_buf
, ";StaticTracepoints+");
2312 strcat (own_buf
, ";InstallInTrace+");
2313 strcat (own_buf
, ";qXfer:statictrace:read+");
2314 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2315 strcat (own_buf
, ";EnableDisableTracepoints+");
2316 strcat (own_buf
, ";QTBuffer:size+");
2317 strcat (own_buf
, ";tracenz+");
2320 if (target_supports_hardware_single_step ()
2321 || target_supports_software_single_step () )
2323 strcat (own_buf
, ";ConditionalBreakpoints+");
2325 strcat (own_buf
, ";BreakpointCommands+");
2327 if (target_supports_agent ())
2328 strcat (own_buf
, ";QAgent+");
2330 supported_btrace_packets (own_buf
);
2332 if (target_supports_stopped_by_sw_breakpoint ())
2333 strcat (own_buf
, ";swbreak+");
2335 if (target_supports_stopped_by_hw_breakpoint ())
2336 strcat (own_buf
, ";hwbreak+");
2338 if (the_target
->pid_to_exec_file
!= NULL
)
2339 strcat (own_buf
, ";qXfer:exec-file:read+");
2341 strcat (own_buf
, ";vContSupported+");
2343 strcat (own_buf
, ";QThreadEvents+");
2345 strcat (own_buf
, ";no-resumed+");
2347 /* Reinitialize components as needed for the new connection. */
2348 hostio_handle_new_gdb_connection ();
2349 target_handle_new_gdb_connection ();
2354 /* Thread-local storage support. */
2355 if (the_target
->get_tls_address
!= NULL
2356 && startswith (own_buf
, "qGetTLSAddr:"))
2358 char *p
= own_buf
+ 12;
2359 CORE_ADDR parts
[2], address
= 0;
2361 ptid_t ptid
= null_ptid
;
2363 require_running (own_buf
);
2365 for (i
= 0; i
< 3; i
++)
2373 p2
= strchr (p
, ',');
2386 ptid
= read_ptid (p
, NULL
);
2388 decode_address (&parts
[i
- 1], p
, len
);
2392 if (p
!= NULL
|| i
< 3)
2396 struct thread_info
*thread
= find_thread_ptid (ptid
);
2401 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2407 strcpy (own_buf
, paddress(address
));
2412 write_enn (own_buf
);
2416 /* Otherwise, pretend we do not understand this packet. */
2419 /* Windows OS Thread Information Block address support. */
2420 if (the_target
->get_tib_address
!= NULL
2421 && startswith (own_buf
, "qGetTIBAddr:"))
2426 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2428 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2431 strcpy (own_buf
, paddress(tlb
));
2436 write_enn (own_buf
);
2442 /* Handle "monitor" commands. */
2443 if (startswith (own_buf
, "qRcmd,"))
2445 char *mon
= (char *) malloc (PBUFSIZ
);
2446 int len
= strlen (own_buf
+ 6);
2450 write_enn (own_buf
);
2455 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2457 write_enn (own_buf
);
2461 mon
[len
/ 2] = '\0';
2465 if (the_target
->handle_monitor_command
== NULL
2466 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2467 /* Default processing. */
2468 handle_monitor_command (mon
, own_buf
);
2474 if (startswith (own_buf
, "qSearch:memory:"))
2476 require_running (own_buf
);
2477 handle_search_memory (own_buf
, packet_len
);
2481 if (strcmp (own_buf
, "qAttached") == 0
2482 || startswith (own_buf
, "qAttached:"))
2484 struct process_info
*process
;
2486 if (own_buf
[sizeof ("qAttached") - 1])
2488 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2489 process
= (struct process_info
*)
2490 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2494 require_running (own_buf
);
2495 process
= current_process ();
2498 if (process
== NULL
)
2500 write_enn (own_buf
);
2504 strcpy (own_buf
, process
->attached
? "1" : "0");
2508 if (startswith (own_buf
, "qCRC:"))
2510 /* CRC check (compare-section). */
2514 unsigned long long crc
;
2516 require_running (own_buf
);
2517 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2518 if (*comma
++ != ',')
2520 write_enn (own_buf
);
2523 len
= strtoul (comma
, NULL
, 16);
2524 crc
= crc32 (base
, len
, 0xffffffff);
2525 /* Check for memory failure. */
2526 if (crc
== (unsigned long long) -1)
2528 write_enn (own_buf
);
2531 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2535 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2538 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2541 /* Otherwise we didn't know what packet it was. Say we didn't
2546 static void gdb_wants_all_threads_stopped (void);
2547 static void resume (struct thread_resume
*actions
, size_t n
);
2549 /* The callback that is passed to visit_actioned_threads. */
2550 typedef int (visit_actioned_threads_callback_ftype
)
2551 (const struct thread_resume
*, struct thread_info
*);
2553 /* Struct to pass data to visit_actioned_threads. */
2555 struct visit_actioned_threads_data
2557 const struct thread_resume
*actions
;
2559 visit_actioned_threads_callback_ftype
*callback
;
2562 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2563 true if CALLBACK returns true. Returns false if no matching thread
2564 is found or CALLBACK results false.
2565 Note: This function is itself a callback for find_inferior. */
2568 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2570 struct visit_actioned_threads_data
*data
2571 = (struct visit_actioned_threads_data
*) datap
;
2572 const struct thread_resume
*actions
= data
->actions
;
2573 size_t num_actions
= data
->num_actions
;
2574 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2577 for (i
= 0; i
< num_actions
; i
++)
2579 const struct thread_resume
*action
= &actions
[i
];
2581 if (ptid_equal (action
->thread
, minus_one_ptid
)
2582 || ptid_equal (action
->thread
, entry
->id
)
2583 || ((ptid_get_pid (action
->thread
)
2584 == ptid_get_pid (entry
->id
))
2585 && ptid_get_lwp (action
->thread
) == -1))
2587 struct thread_info
*thread
= (struct thread_info
*) entry
;
2589 if ((*callback
) (action
, thread
))
2597 /* Callback for visit_actioned_threads. If the thread has a pending
2598 status to report, report it now. */
2601 handle_pending_status (const struct thread_resume
*resumption
,
2602 struct thread_info
*thread
)
2604 if (thread
->status_pending_p
)
2606 thread
->status_pending_p
= 0;
2608 last_status
= thread
->last_status
;
2609 last_ptid
= thread
->entry
.id
;
2610 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2616 /* Parse vCont packets. */
2618 handle_v_cont (char *own_buf
)
2622 struct thread_resume
*resume_info
;
2623 struct thread_resume default_action
= {{0}};
2625 /* Count the number of semicolons in the packet. There should be one
2626 for every action. */
2632 p
= strchr (p
, ';');
2635 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2636 if (resume_info
== NULL
)
2644 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2646 if (p
[0] == 's' || p
[0] == 'S')
2647 resume_info
[i
].kind
= resume_step
;
2648 else if (p
[0] == 'r')
2649 resume_info
[i
].kind
= resume_step
;
2650 else if (p
[0] == 'c' || p
[0] == 'C')
2651 resume_info
[i
].kind
= resume_continue
;
2652 else if (p
[0] == 't')
2653 resume_info
[i
].kind
= resume_stop
;
2657 if (p
[0] == 'S' || p
[0] == 'C')
2660 sig
= strtol (p
+ 1, &q
, 16);
2665 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2667 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2669 else if (p
[0] == 'r')
2673 p
= unpack_varlen_hex (p
+ 1, &addr
);
2674 resume_info
[i
].step_range_start
= addr
;
2679 p
= unpack_varlen_hex (p
+ 1, &addr
);
2680 resume_info
[i
].step_range_end
= addr
;
2689 resume_info
[i
].thread
= minus_one_ptid
;
2690 default_action
= resume_info
[i
];
2692 /* Note: we don't increment i here, we'll overwrite this entry
2693 the next time through. */
2695 else if (p
[0] == ':')
2697 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2702 if (p
[0] != ';' && p
[0] != 0)
2705 resume_info
[i
].thread
= ptid
;
2712 resume_info
[i
] = default_action
;
2714 resume (resume_info
, n
);
2719 write_enn (own_buf
);
2724 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2727 resume (struct thread_resume
*actions
, size_t num_actions
)
2731 /* Check if among the threads that GDB wants actioned, there's
2732 one with a pending status to report. If so, skip actually
2733 resuming/stopping and report the pending event
2735 struct visit_actioned_threads_data data
;
2737 data
.actions
= actions
;
2738 data
.num_actions
= num_actions
;
2739 data
.callback
= handle_pending_status
;
2740 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2746 (*the_target
->resume
) (actions
, num_actions
);
2752 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2754 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2755 && !report_no_resumed
)
2757 /* The client does not support this stop reply. At least
2759 sprintf (own_buf
, "E.No unwaited-for children left.");
2760 disable_async_io ();
2764 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2765 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2766 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2767 current_thread
->last_status
= last_status
;
2769 /* From the client's perspective, all-stop mode always stops all
2770 threads implicitly (and the target backend has already done
2771 so by now). Tag all threads as "want-stopped", so we don't
2772 resume them implicitly without the client telling us to. */
2773 gdb_wants_all_threads_stopped ();
2774 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2775 disable_async_io ();
2777 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2778 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2779 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2783 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2785 handle_v_attach (char *own_buf
)
2789 pid
= strtol (own_buf
+ 8, NULL
, 16);
2790 if (pid
!= 0 && attach_inferior (pid
) == 0)
2792 /* Don't report shared library events after attaching, even if
2793 some libraries are preloaded. GDB will always poll the
2794 library list. Avoids the "stopped by shared library event"
2795 notice on the GDB side. */
2800 /* In non-stop, we don't send a resume reply. Stop events
2801 will follow up using the normal notification
2806 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2812 write_enn (own_buf
);
2817 /* Run a new program. Return 1 if successful, 0 if failure. */
2819 handle_v_run (char *own_buf
)
2821 char *p
, *next_p
, **new_argv
;
2825 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2831 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2832 if (new_argv
== NULL
)
2834 write_enn (own_buf
);
2839 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2841 next_p
= strchr (p
, ';');
2843 next_p
= p
+ strlen (p
);
2845 if (i
== 0 && p
== next_p
)
2849 /* FIXME: Fail request if out of memory instead of dying. */
2850 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2851 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2852 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2861 if (new_argv
[0] == NULL
)
2863 /* GDB didn't specify a program to run. Use the program from the
2864 last run with the new argument list. */
2866 if (program_argv
== NULL
)
2868 write_enn (own_buf
);
2869 freeargv (new_argv
);
2873 new_argv
[0] = strdup (program_argv
[0]);
2874 if (new_argv
[0] == NULL
)
2876 write_enn (own_buf
);
2877 freeargv (new_argv
);
2882 /* Free the old argv and install the new one. */
2883 freeargv (program_argv
);
2884 program_argv
= new_argv
;
2886 start_inferior (program_argv
);
2887 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2889 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2891 /* In non-stop, sending a resume reply doesn't set the general
2892 thread, but GDB assumes a vRun sets it (this is so GDB can
2893 query which is the main thread of the new inferior. */
2895 general_thread
= last_ptid
;
2901 write_enn (own_buf
);
2906 /* Kill process. Return 1 if successful, 0 if failure. */
2908 handle_v_kill (char *own_buf
)
2911 char *p
= &own_buf
[6];
2913 pid
= strtol (p
, NULL
, 16);
2916 if (pid
!= 0 && kill_inferior (pid
) == 0)
2918 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2919 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2920 last_ptid
= pid_to_ptid (pid
);
2921 discard_queued_stop_replies (last_ptid
);
2927 write_enn (own_buf
);
2932 /* Handle all of the extended 'v' packets. */
2934 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2936 if (!disable_packet_vCont
)
2938 if (strcmp (own_buf
, "vCtrlC") == 0)
2940 (*the_target
->request_interrupt
) ();
2945 if (startswith (own_buf
, "vCont;"))
2947 require_running (own_buf
);
2948 handle_v_cont (own_buf
);
2952 if (startswith (own_buf
, "vCont?"))
2954 strcpy (own_buf
, "vCont;c;C;t");
2956 if (target_supports_hardware_single_step ()
2957 || target_supports_software_single_step ()
2958 || !vCont_supported
)
2960 /* If target supports single step either by hardware or by
2961 software, add actions s and S to the list of supported
2962 actions. On the other hand, if GDB doesn't request the
2963 supported vCont actions in qSupported packet, add s and
2964 S to the list too. */
2965 own_buf
= own_buf
+ strlen (own_buf
);
2966 strcpy (own_buf
, ";s;S");
2969 if (target_supports_range_stepping ())
2971 own_buf
= own_buf
+ strlen (own_buf
);
2972 strcpy (own_buf
, ";r");
2978 if (startswith (own_buf
, "vFile:")
2979 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2982 if (startswith (own_buf
, "vAttach;"))
2984 if ((!extended_protocol
|| !multi_process
) && target_running ())
2986 fprintf (stderr
, "Already debugging a process\n");
2987 write_enn (own_buf
);
2990 handle_v_attach (own_buf
);
2994 if (startswith (own_buf
, "vRun;"))
2996 if ((!extended_protocol
|| !multi_process
) && target_running ())
2998 fprintf (stderr
, "Already debugging a process\n");
2999 write_enn (own_buf
);
3002 handle_v_run (own_buf
);
3006 if (startswith (own_buf
, "vKill;"))
3008 if (!target_running ())
3010 fprintf (stderr
, "No process to kill\n");
3011 write_enn (own_buf
);
3014 handle_v_kill (own_buf
);
3018 if (handle_notif_ack (own_buf
, packet_len
))
3021 /* Otherwise we didn't know what packet it was. Say we didn't
3027 /* Resume thread and wait for another event. In non-stop mode,
3028 don't really wait here, but return immediatelly to the event
3031 myresume (char *own_buf
, int step
, int sig
)
3033 struct thread_resume resume_info
[2];
3035 int valid_cont_thread
;
3037 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3038 && !ptid_equal (cont_thread
, minus_one_ptid
));
3040 if (step
|| sig
|| valid_cont_thread
)
3042 resume_info
[0].thread
= current_ptid
;
3044 resume_info
[0].kind
= resume_step
;
3046 resume_info
[0].kind
= resume_continue
;
3047 resume_info
[0].sig
= sig
;
3051 if (!valid_cont_thread
)
3053 resume_info
[n
].thread
= minus_one_ptid
;
3054 resume_info
[n
].kind
= resume_continue
;
3055 resume_info
[n
].sig
= 0;
3059 resume (resume_info
, n
);
3062 /* Callback for for_each_inferior. Make a new stop reply for each
3066 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3068 struct thread_info
*thread
= (struct thread_info
*) entry
;
3070 /* For now, assume targets that don't have this callback also don't
3071 manage the thread's last_status field. */
3072 if (the_target
->thread_stopped
== NULL
)
3074 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3076 new_notif
->ptid
= entry
->id
;
3077 new_notif
->status
= thread
->last_status
;
3078 /* Pass the last stop reply back to GDB, but don't notify
3080 notif_event_enque (¬if_stop
,
3081 (struct notif_event
*) new_notif
);
3085 if (thread_stopped (thread
))
3090 = target_waitstatus_to_string (&thread
->last_status
);
3092 debug_printf ("Reporting thread %s as already stopped with %s\n",
3093 target_pid_to_str (entry
->id
),
3096 xfree (status_string
);
3099 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3101 /* Pass the last stop reply back to GDB, but don't notify
3103 queue_stop_reply (entry
->id
, &thread
->last_status
);
3110 /* Set this inferior threads's state as "want-stopped". We won't
3111 resume this thread until the client gives us another action for
3115 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3117 struct thread_info
*thread
= (struct thread_info
*) entry
;
3119 thread
->last_resume_kind
= resume_stop
;
3121 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3123 /* Most threads are stopped implicitly (all-stop); tag that with
3125 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3126 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3130 /* Set all threads' states as "want-stopped". */
3133 gdb_wants_all_threads_stopped (void)
3135 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3138 /* Clear the gdb_detached flag of every process. */
3141 gdb_reattached_process (struct inferior_list_entry
*entry
)
3143 struct process_info
*process
= (struct process_info
*) entry
;
3145 process
->gdb_detached
= 0;
3148 /* Callback for for_each_inferior. Clear the thread's pending status
3152 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3154 struct thread_info
*thread
= (struct thread_info
*) entry
;
3156 thread
->status_pending_p
= 0;
3159 /* Callback for for_each_inferior. If the thread is stopped with an
3160 interesting event, mark it as having a pending event. */
3163 set_pending_status_callback (struct inferior_list_entry
*entry
)
3165 struct thread_info
*thread
= (struct thread_info
*) entry
;
3167 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3168 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3169 /* A breakpoint, watchpoint or finished step from a previous
3170 GDB run isn't considered interesting for a new GDB run.
3171 If we left those pending, the new GDB could consider them
3172 random SIGTRAPs. This leaves out real async traps. We'd
3173 have to peek into the (target-specific) siginfo to
3174 distinguish those. */
3175 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3176 thread
->status_pending_p
= 1;
3179 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3180 pending status to report to GDB. */
3183 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3185 struct thread_info
*thread
= (struct thread_info
*) entry
;
3187 return thread
->status_pending_p
;
3190 /* Status handler for the '?' packet. */
3193 handle_status (char *own_buf
)
3195 /* GDB is connected, don't forward events to the target anymore. */
3196 for_each_inferior (&all_processes
, gdb_reattached_process
);
3198 /* In non-stop mode, we must send a stop reply for each stopped
3199 thread. In all-stop mode, just send one for the first stopped
3204 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3206 /* The first is sent immediatly. OK is sent if there is no
3207 stopped thread, which is the same handling of the vStopped
3208 packet (by design). */
3209 notif_write_event (¬if_stop
, own_buf
);
3213 struct inferior_list_entry
*thread
= NULL
;
3216 stabilize_threads ();
3217 gdb_wants_all_threads_stopped ();
3219 /* We can only report one status, but we might be coming out of
3220 non-stop -- if more than one thread is stopped with
3221 interesting events, leave events for the threads we're not
3222 reporting now pending. They'll be reported the next time the
3223 threads are resumed. Start by marking all interesting events
3225 for_each_inferior (&all_threads
, set_pending_status_callback
);
3227 /* Prefer the last thread that reported an event to GDB (even if
3228 that was a GDB_SIGNAL_TRAP). */
3229 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3230 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3231 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3232 thread
= find_inferior_id (&all_threads
, last_ptid
);
3234 /* If the last event thread is not found for some reason, look
3235 for some other thread that might have an event to report. */
3237 thread
= find_inferior (&all_threads
,
3238 find_status_pending_thread_callback
, NULL
);
3240 /* If we're still out of luck, simply pick the first thread in
3243 thread
= get_first_inferior (&all_threads
);
3247 struct thread_info
*tp
= (struct thread_info
*) thread
;
3249 /* We're reporting this event, so it's no longer
3251 tp
->status_pending_p
= 0;
3253 /* GDB assumes the current thread is the thread we're
3254 reporting the status for. */
3255 general_thread
= thread
->id
;
3256 set_desired_thread (1);
3258 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3259 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3262 strcpy (own_buf
, "W00");
3267 gdbserver_version (void)
3269 printf ("GNU gdbserver %s%s\n"
3270 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
3271 "gdbserver is free software, covered by the "
3272 "GNU General Public License.\n"
3273 "This gdbserver was configured as \"%s\"\n",
3274 PKGVERSION
, version
, host_name
);
3278 gdbserver_usage (FILE *stream
)
3280 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3281 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3282 "\tgdbserver [OPTIONS] --multi COMM\n"
3284 "COMM may either be a tty device (for serial debugging),\n"
3285 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3286 "stdin/stdout of gdbserver.\n"
3287 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3288 "PID is the process ID to attach to, when --attach is specified.\n"
3290 "Operating modes:\n"
3292 " --attach Attach to running process PID.\n"
3293 " --multi Start server without a specific program, and\n"
3294 " only quit when explicitly commanded.\n"
3295 " --once Exit after the first connection has closed.\n"
3296 " --help Print this message and then exit.\n"
3297 " --version Display version information and exit.\n"
3301 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3302 " --disable-randomization\n"
3303 " Run PROG with address space randomization disabled.\n"
3304 " --no-disable-randomization\n"
3305 " Don't disable address space randomization when\n"
3310 " --debug Enable general debugging output.\n"
3311 " --debug-format=opt1[,opt2,...]\n"
3312 " Specify extra content in debugging output.\n"
3317 " --remote-debug Enable remote protocol debugging output.\n"
3318 " --disable-packet=opt1[,opt2,...]\n"
3319 " Disable support for RSP packets or features.\n"
3321 " vCont, Tthread, qC, qfThreadInfo and \n"
3322 " threads (disable all threading packets).\n"
3324 "For more information, consult the GDB manual (available as on-line \n"
3325 "info or a printed manual).\n");
3326 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3327 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3331 gdbserver_show_disableable (FILE *stream
)
3333 fprintf (stream
, "Disableable packets:\n"
3334 " vCont \tAll vCont packets\n"
3335 " qC \tQuerying the current thread\n"
3336 " qfThreadInfo\tThread listing\n"
3337 " Tthread \tPassing the thread specifier in the "
3338 "T stop reply packet\n"
3339 " threads \tAll of the above\n");
3343 #undef require_running
3344 #define require_running(BUF) \
3345 if (!target_running ()) \
3352 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3354 int pid
= * (int *) args
;
3356 if (ptid_get_pid (entry
->id
) == pid
)
3363 kill_inferior_callback (struct inferior_list_entry
*entry
)
3365 struct process_info
*process
= (struct process_info
*) entry
;
3366 int pid
= ptid_get_pid (process
->entry
.id
);
3368 kill_inferior (pid
);
3369 discard_queued_stop_replies (pid_to_ptid (pid
));
3372 /* Callback for for_each_inferior to detach or kill the inferior,
3373 depending on whether we attached to it or not.
3374 We inform the user whether we're detaching or killing the process
3375 as this is only called when gdbserver is about to exit. */
3378 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3380 struct process_info
*process
= (struct process_info
*) entry
;
3381 int pid
= ptid_get_pid (process
->entry
.id
);
3383 if (process
->attached
)
3384 detach_inferior (pid
);
3386 kill_inferior (pid
);
3388 discard_queued_stop_replies (pid_to_ptid (pid
));
3391 /* for_each_inferior callback for detach_or_kill_for_exit to print
3392 the pids of started inferiors. */
3395 print_started_pid (struct inferior_list_entry
*entry
)
3397 struct process_info
*process
= (struct process_info
*) entry
;
3399 if (! process
->attached
)
3401 int pid
= ptid_get_pid (process
->entry
.id
);
3402 fprintf (stderr
, " %d", pid
);
3406 /* for_each_inferior callback for detach_or_kill_for_exit to print
3407 the pids of attached inferiors. */
3410 print_attached_pid (struct inferior_list_entry
*entry
)
3412 struct process_info
*process
= (struct process_info
*) entry
;
3414 if (process
->attached
)
3416 int pid
= ptid_get_pid (process
->entry
.id
);
3417 fprintf (stderr
, " %d", pid
);
3421 /* Call this when exiting gdbserver with possible inferiors that need
3422 to be killed or detached from. */
3425 detach_or_kill_for_exit (void)
3427 /* First print a list of the inferiors we will be killing/detaching.
3428 This is to assist the user, for example, in case the inferior unexpectedly
3429 dies after we exit: did we screw up or did the inferior exit on its own?
3430 Having this info will save some head-scratching. */
3432 if (have_started_inferiors_p ())
3434 fprintf (stderr
, "Killing process(es):");
3435 for_each_inferior (&all_processes
, print_started_pid
);
3436 fprintf (stderr
, "\n");
3438 if (have_attached_inferiors_p ())
3440 fprintf (stderr
, "Detaching process(es):");
3441 for_each_inferior (&all_processes
, print_attached_pid
);
3442 fprintf (stderr
, "\n");
3445 /* Now we can kill or detach the inferiors. */
3447 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3450 /* Value that will be passed to exit(3) when gdbserver exits. */
3451 static int exit_code
;
3453 /* Cleanup version of detach_or_kill_for_exit. */
3456 detach_or_kill_for_exit_cleanup (void *ignore
)
3461 detach_or_kill_for_exit ();
3464 CATCH (exception
, RETURN_MASK_ALL
)
3467 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3473 /* Main function. This is called by the real "main" function,
3474 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3476 static void ATTRIBUTE_NORETURN
3477 captured_main (int argc
, char *argv
[])
3481 char *arg_end
, *port
;
3482 char **next_arg
= &argv
[1];
3483 volatile int multi_mode
= 0;
3484 volatile int attach
= 0;
3487 while (*next_arg
!= NULL
&& **next_arg
== '-')
3489 if (strcmp (*next_arg
, "--version") == 0)
3491 gdbserver_version ();
3494 else if (strcmp (*next_arg
, "--help") == 0)
3496 gdbserver_usage (stdout
);
3499 else if (strcmp (*next_arg
, "--attach") == 0)
3501 else if (strcmp (*next_arg
, "--multi") == 0)
3503 else if (strcmp (*next_arg
, "--wrapper") == 0)
3507 wrapper_argv
= next_arg
;
3508 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3511 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3513 gdbserver_usage (stderr
);
3517 /* Consume the "--". */
3520 else if (strcmp (*next_arg
, "--debug") == 0)
3522 else if (startswith (*next_arg
, "--debug-format="))
3525 = parse_debug_format_options ((*next_arg
)
3526 + sizeof ("--debug-format=") - 1, 0);
3528 if (error_msg
!= NULL
)
3530 fprintf (stderr
, "%s", error_msg
);
3534 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3536 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3538 gdbserver_show_disableable (stdout
);
3541 else if (startswith (*next_arg
, "--disable-packet="))
3543 char *packets
, *tok
;
3545 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3546 for (tok
= strtok (packets
, ",");
3548 tok
= strtok (NULL
, ","))
3550 if (strcmp ("vCont", tok
) == 0)
3551 disable_packet_vCont
= 1;
3552 else if (strcmp ("Tthread", tok
) == 0)
3553 disable_packet_Tthread
= 1;
3554 else if (strcmp ("qC", tok
) == 0)
3555 disable_packet_qC
= 1;
3556 else if (strcmp ("qfThreadInfo", tok
) == 0)
3557 disable_packet_qfThreadInfo
= 1;
3558 else if (strcmp ("threads", tok
) == 0)
3560 disable_packet_vCont
= 1;
3561 disable_packet_Tthread
= 1;
3562 disable_packet_qC
= 1;
3563 disable_packet_qfThreadInfo
= 1;
3567 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3569 gdbserver_show_disableable (stderr
);
3574 else if (strcmp (*next_arg
, "-") == 0)
3576 /* "-" specifies a stdio connection and is a form of port
3578 *next_arg
= STDIO_CONNECTION_NAME
;
3581 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3582 disable_randomization
= 1;
3583 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3584 disable_randomization
= 0;
3585 else if (strcmp (*next_arg
, "--once") == 0)
3589 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3599 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3601 gdbserver_usage (stderr
);
3605 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3606 opened by remote_prepare. */
3609 save_original_signals_state ();
3611 /* We need to know whether the remote connection is stdio before
3612 starting the inferior. Inferiors created in this scenario have
3613 stdin,stdout redirected. So do this here before we call
3615 remote_prepare (port
);
3620 /* --attach used to come after PORT, so allow it there for
3622 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3629 && (*next_arg
== NULL
3630 || (*next_arg
)[0] == '\0'
3631 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3633 || next_arg
[1] != NULL
))
3638 gdbserver_usage (stderr
);
3642 initialize_async_io ();
3644 initialize_event_loop ();
3645 if (target_supports_tracepoints ())
3646 initialize_tracepoint ();
3647 initialize_notif ();
3649 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3650 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3652 if (pid
== 0 && *next_arg
!= NULL
)
3656 n
= argc
- (next_arg
- argv
);
3657 program_argv
= XNEWVEC (char *, n
+ 1);
3658 for (i
= 0; i
< n
; i
++)
3659 program_argv
[i
] = xstrdup (next_arg
[i
]);
3660 program_argv
[i
] = NULL
;
3662 /* Wait till we are at first instruction in program. */
3663 start_inferior (program_argv
);
3665 /* We are now (hopefully) stopped at the first instruction of
3666 the target process. This assumes that the target process was
3667 successfully created. */
3671 if (attach_inferior (pid
) == -1)
3672 error ("Attaching not supported on this target");
3674 /* Otherwise succeeded. */
3678 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3679 last_status
.value
.integer
= 0;
3680 last_ptid
= minus_one_ptid
;
3682 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3684 /* Don't report shared library events on the initial connection,
3685 even if some libraries are preloaded. Avoids the "stopped by
3686 shared library event" notice on gdb side. */
3689 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3690 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3695 if (!was_running
&& !multi_mode
)
3696 error ("No program to debug");
3703 report_fork_events
= 0;
3704 report_vfork_events
= 0;
3705 report_exec_events
= 0;
3706 /* Be sure we're out of tfind mode. */
3707 current_traceframe
= -1;
3708 cont_thread
= null_ptid
;
3709 swbreak_feature
= 0;
3710 hwbreak_feature
= 0;
3711 vCont_supported
= 0;
3717 /* Wait for events. This will return when all event sources
3718 are removed from the event loop. */
3719 start_event_loop ();
3721 /* If an exit was requested (using the "monitor exit"
3722 command), terminate now. */
3724 throw_quit ("Quit");
3726 /* The only other way to get here is for getpkt to fail:
3728 - If --once was specified, we're done.
3730 - If not in extended-remote mode, and we're no longer
3731 debugging anything, simply exit: GDB has disconnected
3732 after processing the last process exit.
3734 - Otherwise, close the connection and reopen it at the
3736 if (run_once
|| (!extended_protocol
&& !target_running ()))
3737 throw_quit ("Quit");
3740 "Remote side has terminated connection. "
3741 "GDBserver will reopen the connection.\n");
3743 /* Get rid of any pending statuses. An eventual reconnection
3744 (by the same GDB instance or another) will refresh all its
3745 state from scratch. */
3746 discard_queued_stop_replies (minus_one_ptid
);
3747 for_each_inferior (&all_threads
,
3748 clear_pending_status_callback
);
3752 if (disconnected_tracing
)
3754 /* Try to enable non-stop/async mode, so we we can
3755 both wait for an async socket accept, and handle
3756 async target events simultaneously. There's also
3757 no point either in having the target always stop
3758 all threads, when we're going to pass signals
3759 down without informing GDB. */
3762 if (start_non_stop (1))
3765 /* Detaching implicitly resumes all threads;
3766 simply disconnecting does not. */
3772 "Disconnected tracing disabled; "
3773 "stopping trace run.\n");
3778 CATCH (exception
, RETURN_MASK_ERROR
)
3781 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3783 if (response_needed
)
3785 write_enn (own_buf
);
3790 throw_quit ("Quit");
3796 /* Main function. */
3799 main (int argc
, char *argv
[])
3804 captured_main (argc
, argv
);
3806 CATCH (exception
, RETURN_MASK_ALL
)
3808 if (exception
.reason
== RETURN_ERROR
)
3811 fprintf (stderr
, "%s\n", exception
.message
);
3812 fprintf (stderr
, "Exiting\n");
3820 gdb_assert_not_reached ("captured_main should never return");
3823 /* Process options coming from Z packets for a breakpoint. PACKET is
3824 the packet buffer. *PACKET is updated to point to the first char
3825 after the last processed option. */
3828 process_point_options (struct gdb_breakpoint
*bp
, char **packet
)
3830 char *dataptr
= *packet
;
3833 /* Check if data has the correct format. */
3834 if (*dataptr
!= ';')
3841 if (*dataptr
== ';')
3844 if (*dataptr
== 'X')
3846 /* Conditional expression. */
3848 debug_printf ("Found breakpoint condition.\n");
3849 if (!add_breakpoint_condition (bp
, &dataptr
))
3850 dataptr
= strchrnul (dataptr
, ';');
3852 else if (startswith (dataptr
, "cmds:"))
3854 dataptr
+= strlen ("cmds:");
3856 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3857 persist
= (*dataptr
== '1');
3859 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3860 dataptr
= strchrnul (dataptr
, ';');
3864 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3866 /* Skip tokens until we find one that we recognize. */
3867 dataptr
= strchrnul (dataptr
, ';');
3873 /* Event loop callback that handles a serial event. The first byte in
3874 the serial buffer gets us here. We expect characters to arrive at
3875 a brisk pace, so we read the rest of the packet with a blocking
3879 process_serial_event (void)
3890 int new_packet_len
= -1;
3892 disable_async_io ();
3894 response_needed
= 0;
3895 packet_len
= getpkt (own_buf
);
3896 if (packet_len
<= 0)
3899 /* Force an event loop break. */
3902 response_needed
= 1;
3909 handle_query (own_buf
, packet_len
, &new_packet_len
);
3912 handle_general_set (own_buf
);
3915 require_running (own_buf
);
3920 pid
= strtol (&own_buf
[i
], NULL
, 16);
3923 pid
= ptid_get_pid (current_ptid
);
3925 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3927 struct process_info
*process
= find_process_pid (pid
);
3929 if (process
== NULL
)
3931 write_enn (own_buf
);
3935 if (tracing
&& disconnected_tracing
)
3937 "Disconnected tracing in effect, "
3938 "leaving gdbserver attached to the process\n");
3940 if (any_persistent_commands ())
3942 "Persistent commands are present, "
3943 "leaving gdbserver attached to the process\n");
3945 /* Make sure we're in non-stop/async mode, so we we can both
3946 wait for an async socket accept, and handle async target
3947 events simultaneously. There's also no point either in
3948 having the target stop all threads, when we're going to
3949 pass signals down without informing GDB. */
3953 debug_printf ("Forcing non-stop mode\n");
3959 process
->gdb_detached
= 1;
3961 /* Detaching implicitly resumes all threads. */
3962 target_continue_no_signal (minus_one_ptid
);
3965 break; /* from switch/case */
3968 fprintf (stderr
, "Detaching from process %d\n", pid
);
3970 if (detach_inferior (pid
) != 0)
3971 write_enn (own_buf
);
3974 discard_queued_stop_replies (pid_to_ptid (pid
));
3977 if (extended_protocol
|| target_running ())
3979 /* There is still at least one inferior remaining or
3980 we are in extended mode, so don't terminate gdbserver,
3981 and instead treat this like a normal program exit. */
3982 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3983 last_status
.value
.integer
= 0;
3984 last_ptid
= pid_to_ptid (pid
);
3986 current_thread
= NULL
;
3993 /* If we are attached, then we can exit. Otherwise, we
3994 need to hang around doing nothing, until the child is
3996 join_inferior (pid
);
4002 extended_protocol
= 1;
4006 handle_status (own_buf
);
4009 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4011 ptid_t gdb_id
, thread_id
;
4014 require_running (own_buf
);
4016 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4018 pid
= ptid_get_pid (gdb_id
);
4020 if (ptid_equal (gdb_id
, null_ptid
)
4021 || ptid_equal (gdb_id
, minus_one_ptid
))
4022 thread_id
= null_ptid
;
4024 && ptid_equal (pid_to_ptid (pid
),
4027 struct thread_info
*thread
=
4028 (struct thread_info
*) find_inferior (&all_threads
,
4033 write_enn (own_buf
);
4037 thread_id
= thread
->entry
.id
;
4041 thread_id
= gdb_id_to_thread_id (gdb_id
);
4042 if (ptid_equal (thread_id
, null_ptid
))
4044 write_enn (own_buf
);
4049 if (own_buf
[1] == 'g')
4051 if (ptid_equal (thread_id
, null_ptid
))
4053 /* GDB is telling us to choose any thread. Check if
4054 the currently selected thread is still valid. If
4055 it is not, select the first available. */
4056 struct thread_info
*thread
=
4057 (struct thread_info
*) find_inferior_id (&all_threads
,
4060 thread
= get_first_thread ();
4061 thread_id
= thread
->entry
.id
;
4064 general_thread
= thread_id
;
4065 set_desired_thread (1);
4066 gdb_assert (current_thread
!= NULL
);
4068 else if (own_buf
[1] == 'c')
4069 cont_thread
= thread_id
;
4075 /* Silently ignore it so that gdb can extend the protocol
4076 without compatibility headaches. */
4081 require_running (own_buf
);
4082 if (current_traceframe
>= 0)
4084 struct regcache
*regcache
4085 = new_register_cache (current_target_desc ());
4087 if (fetch_traceframe_registers (current_traceframe
,
4089 registers_to_string (regcache
, own_buf
);
4091 write_enn (own_buf
);
4092 free_register_cache (regcache
);
4096 struct regcache
*regcache
;
4098 if (!set_desired_thread (1))
4099 write_enn (own_buf
);
4102 regcache
= get_thread_regcache (current_thread
, 1);
4103 registers_to_string (regcache
, own_buf
);
4108 require_running (own_buf
);
4109 if (current_traceframe
>= 0)
4110 write_enn (own_buf
);
4113 struct regcache
*regcache
;
4115 if (!set_desired_thread (1))
4116 write_enn (own_buf
);
4119 regcache
= get_thread_regcache (current_thread
, 1);
4120 registers_from_string (regcache
, &own_buf
[1]);
4126 require_running (own_buf
);
4127 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4128 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4130 write_enn (own_buf
);
4132 bin2hex (mem_buf
, own_buf
, res
);
4135 require_running (own_buf
);
4136 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4137 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4140 write_enn (own_buf
);
4143 require_running (own_buf
);
4144 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4145 &mem_addr
, &len
, &mem_buf
) < 0
4146 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4147 write_enn (own_buf
);
4152 require_running (own_buf
);
4153 hex2bin (own_buf
+ 1, &sig
, 1);
4154 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4155 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4158 myresume (own_buf
, 0, signal
);
4161 require_running (own_buf
);
4162 hex2bin (own_buf
+ 1, &sig
, 1);
4163 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4164 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4167 myresume (own_buf
, 1, signal
);
4170 require_running (own_buf
);
4172 myresume (own_buf
, 0, signal
);
4175 require_running (own_buf
);
4177 myresume (own_buf
, 1, signal
);
4179 case 'Z': /* insert_ ... */
4181 case 'z': /* remove_ ... */
4186 char type
= own_buf
[1];
4188 const int insert
= ch
== 'Z';
4189 char *p
= &own_buf
[3];
4191 p
= unpack_varlen_hex (p
, &addr
);
4192 kind
= strtol (p
+ 1, &dataptr
, 16);
4196 struct gdb_breakpoint
*bp
;
4198 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4203 /* GDB may have sent us a list of *point parameters to
4204 be evaluated on the target's side. Read such list
4205 here. If we already have a list of parameters, GDB
4206 is telling us to drop that list and use this one
4208 clear_breakpoint_conditions_and_commands (bp
);
4209 process_point_options (bp
, &dataptr
);
4213 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4221 write_enn (own_buf
);
4225 response_needed
= 0;
4226 if (!target_running ())
4227 /* The packet we received doesn't make sense - but we can't
4228 reply to it, either. */
4231 fprintf (stderr
, "Killing all inferiors\n");
4232 for_each_inferior (&all_processes
, kill_inferior_callback
);
4234 /* When using the extended protocol, we wait with no program
4235 running. The traditional protocol will exit instead. */
4236 if (extended_protocol
)
4238 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4239 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4247 ptid_t gdb_id
, thread_id
;
4249 require_running (own_buf
);
4251 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4252 thread_id
= gdb_id_to_thread_id (gdb_id
);
4253 if (ptid_equal (thread_id
, null_ptid
))
4255 write_enn (own_buf
);
4259 if (mythread_alive (thread_id
))
4262 write_enn (own_buf
);
4266 response_needed
= 0;
4268 /* Restarting the inferior is only supported in the extended
4270 if (extended_protocol
)
4272 if (target_running ())
4273 for_each_inferior (&all_processes
,
4274 kill_inferior_callback
);
4275 fprintf (stderr
, "GDBserver restarting\n");
4277 /* Wait till we are at 1st instruction in prog. */
4278 if (program_argv
!= NULL
)
4280 start_inferior (program_argv
);
4281 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4283 /* Stopped at the first instruction of the target
4285 general_thread
= last_ptid
;
4289 /* Something went wrong. */
4290 general_thread
= null_ptid
;
4295 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4296 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4302 /* It is a request we don't understand. Respond with an
4303 empty packet so that gdb knows that we don't support this
4309 /* Extended (long) request. */
4310 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4314 /* It is a request we don't understand. Respond with an empty
4315 packet so that gdb knows that we don't support this
4321 if (new_packet_len
!= -1)
4322 putpkt_binary (own_buf
, new_packet_len
);
4326 response_needed
= 0;
4334 /* Event-loop callback for serial events. */
4337 handle_serial_event (int err
, gdb_client_data client_data
)
4340 debug_printf ("handling possible serial event\n");
4342 /* Really handle it. */
4343 if (process_serial_event () < 0)
4346 /* Be sure to not change the selected thread behind GDB's back.
4347 Important in the non-stop mode asynchronous protocol. */
4348 set_desired_thread (1);
4353 /* Push a stop notification on the notification queue. */
4356 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4358 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4360 vstop_notif
->status
= *status
;
4361 vstop_notif
->ptid
= ptid
;
4362 /* Push Stop notification. */
4363 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4366 /* Event-loop callback for target events. */
4369 handle_target_event (int err
, gdb_client_data client_data
)
4372 debug_printf ("handling possible target event\n");
4374 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4377 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4379 if (gdb_connected () && report_no_resumed
)
4380 push_stop_notification (null_ptid
, &last_status
);
4382 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4384 int pid
= ptid_get_pid (last_ptid
);
4385 struct process_info
*process
= find_process_pid (pid
);
4386 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4388 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4389 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4391 mark_breakpoints_out (process
);
4392 mourn_inferior (process
);
4394 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4398 /* We're reporting this thread as stopped. Update its
4399 "want-stopped" state to what the client wants, until it
4400 gets a new resume action. */
4401 current_thread
->last_resume_kind
= resume_stop
;
4402 current_thread
->last_status
= last_status
;
4407 if (!target_running ())
4409 /* The last process exited. We're done. */
4413 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4414 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4415 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4419 /* A thread stopped with a signal, but gdb isn't
4420 connected to handle it. Pass it down to the
4421 inferior, as if it wasn't being traced. */
4422 enum gdb_signal signal
;
4425 debug_printf ("GDB not connected; forwarding event %d for"
4427 (int) last_status
.kind
,
4428 target_pid_to_str (last_ptid
));
4430 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4431 signal
= last_status
.value
.sig
;
4433 signal
= GDB_SIGNAL_0
;
4434 target_continue (last_ptid
, signal
);
4438 push_stop_notification (last_ptid
, &last_status
);
4441 /* Be sure to not change the selected thread behind GDB's back.
4442 Important in the non-stop mode asynchronous protocol. */
4443 set_desired_thread (1);