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"
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
;
122 static char *own_buf
;
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 struct thread_resume resume_info
;
263 memset (&resume_info
, 0, sizeof (resume_info
));
264 resume_info
.thread
= pid_to_ptid (signal_pid
);
265 resume_info
.kind
= resume_continue
;
268 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
270 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
274 (*the_target
->resume
) (&resume_info
, 1);
276 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
277 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
280 current_thread
->last_resume_kind
= resume_stop
;
281 current_thread
->last_status
= last_status
;
283 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
285 target_post_create_inferior ();
289 /* Wait till we are at 1st instruction in program, return new pid
290 (assuming success). */
291 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
293 target_post_create_inferior ();
295 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
296 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
298 current_thread
->last_resume_kind
= resume_stop
;
299 current_thread
->last_status
= last_status
;
302 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
308 attach_inferior (int pid
)
310 /* myattach should return -1 if attaching is unsupported,
311 0 if it succeeded, and call error() otherwise. */
313 if (myattach (pid
) != 0)
316 fprintf (stderr
, "Attached; pid = %d\n", pid
);
319 /* FIXME - It may be that we should get the SIGNAL_PID from the
320 attach function, so that it can be the main thread instead of
321 whichever we were told to attach to. */
326 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
328 /* GDB knows to ignore the first SIGSTOP after attaching to a running
329 process using the "attach" command, but this is different; it's
330 just using "target remote". Pretend it's just starting up. */
331 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
332 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
333 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
335 current_thread
->last_resume_kind
= resume_stop
;
336 current_thread
->last_status
= last_status
;
342 extern int remote_debug
;
344 /* Decode a qXfer read request. Return 0 if everything looks OK,
348 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
350 /* After the read marker and annex, qXfer looks like a
351 traditional 'm' packet. */
352 decode_m_packet (buf
, ofs
, len
);
358 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
360 /* Extract and NUL-terminate the object. */
362 while (*buf
&& *buf
!= ':')
368 /* Extract and NUL-terminate the read/write action. */
370 while (*buf
&& *buf
!= ':')
376 /* Extract and NUL-terminate the annex. */
378 while (*buf
&& *buf
!= ':')
388 /* Write the response to a successful qXfer read. Returns the
389 length of the (binary) data stored in BUF, corresponding
390 to as much of DATA/LEN as we could fit. IS_MORE controls
391 the first character of the response. */
393 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
402 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
403 &out_len
, PBUFSIZ
- 2) + 1;
406 /* Handle btrace enabling in BTS format. */
409 handle_btrace_enable_bts (struct thread_info
*thread
)
411 if (thread
->btrace
!= NULL
)
412 return "E.Btrace already enabled.";
414 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
415 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
416 ¤t_btrace_conf
);
417 if (thread
->btrace
== NULL
)
418 return "E.Could not enable btrace.";
423 /* Handle btrace enabling in Intel Processor Trace format. */
426 handle_btrace_enable_pt (struct thread_info
*thread
)
428 if (thread
->btrace
!= NULL
)
429 return "E.Btrace already enabled.";
431 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
432 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
433 ¤t_btrace_conf
);
434 if (thread
->btrace
== NULL
)
435 return "E.Could not enable btrace.";
440 /* Handle btrace disabling. */
443 handle_btrace_disable (struct thread_info
*thread
)
446 if (thread
->btrace
== NULL
)
447 return "E.Branch tracing not enabled.";
449 if (target_disable_btrace (thread
->btrace
) != 0)
450 return "E.Could not disable branch tracing.";
452 thread
->btrace
= NULL
;
456 /* Handle the "Qbtrace" packet. */
459 handle_btrace_general_set (char *own_buf
)
461 struct thread_info
*thread
;
465 if (!startswith (own_buf
, "Qbtrace:"))
468 op
= own_buf
+ strlen ("Qbtrace:");
470 if (ptid_equal (general_thread
, null_ptid
)
471 || ptid_equal (general_thread
, minus_one_ptid
))
473 strcpy (own_buf
, "E.Must select a single thread.");
477 thread
= find_thread_ptid (general_thread
);
480 strcpy (own_buf
, "E.No such thread.");
486 if (strcmp (op
, "bts") == 0)
487 err
= handle_btrace_enable_bts (thread
);
488 else if (strcmp (op
, "pt") == 0)
489 err
= handle_btrace_enable_pt (thread
);
490 else if (strcmp (op
, "off") == 0)
491 err
= handle_btrace_disable (thread
);
493 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
496 strcpy (own_buf
, err
);
503 /* Handle the "Qbtrace-conf" packet. */
506 handle_btrace_conf_general_set (char *own_buf
)
508 struct thread_info
*thread
;
511 if (!startswith (own_buf
, "Qbtrace-conf:"))
514 op
= own_buf
+ strlen ("Qbtrace-conf:");
516 if (ptid_equal (general_thread
, null_ptid
)
517 || ptid_equal (general_thread
, minus_one_ptid
))
519 strcpy (own_buf
, "E.Must select a single thread.");
523 thread
= find_thread_ptid (general_thread
);
526 strcpy (own_buf
, "E.No such thread.");
530 if (startswith (op
, "bts:size="))
536 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
537 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
539 strcpy (own_buf
, "E.Bad size value.");
543 current_btrace_conf
.bts
.size
= (unsigned int) size
;
545 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
551 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
552 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
554 strcpy (own_buf
, "E.Bad size value.");
558 current_btrace_conf
.pt
.size
= (unsigned int) size
;
562 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
570 /* Handle all of the extended 'Q' packets. */
573 handle_general_set (char *own_buf
)
575 if (startswith (own_buf
, "QPassSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QPassSignals:");
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QProgramSignals:"))
602 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
603 const char *p
= own_buf
+ strlen ("QProgramSignals:");
606 program_signals_p
= 1;
608 p
= decode_address_to_semicolon (&cursig
, p
);
609 for (i
= 0; i
< numsigs
; i
++)
613 program_signals
[i
] = 1;
615 /* Keep looping, to clear the remaining signals. */
618 p
= decode_address_to_semicolon (&cursig
, p
);
621 program_signals
[i
] = 0;
623 strcpy (own_buf
, "OK");
627 if (startswith (own_buf
, "QCatchSyscalls:"))
629 const char *p
= own_buf
+ sizeof ("QCatchSyscalls:") - 1;
632 struct process_info
*process
;
634 if (!target_running () || !target_supports_catch_syscall ())
640 if (strcmp (p
, "0") == 0)
642 else if (p
[0] == '1' && (p
[1] == ';' || p
[1] == '\0'))
646 fprintf (stderr
, "Unknown catch-syscalls mode requested: %s\n",
652 process
= current_process ();
653 VEC_truncate (int, process
->syscalls_to_catch
, 0);
663 p
= decode_address_to_semicolon (&sysno
, p
);
664 VEC_safe_push (int, process
->syscalls_to_catch
, (int) sysno
);
668 VEC_safe_push (int, process
->syscalls_to_catch
, ANY_SYSCALL
);
675 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
679 fprintf (stderr
, "[noack mode enabled]\n");
688 if (startswith (own_buf
, "QNonStop:"))
690 char *mode
= own_buf
+ 9;
694 if (strcmp (mode
, "0") == 0)
696 else if (strcmp (mode
, "1") == 0)
700 /* We don't know what this mode is, so complain to
702 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
708 req_str
= req
? "non-stop" : "all-stop";
709 if (start_non_stop (req
) != 0)
711 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
719 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
725 if (startswith (own_buf
, "QDisableRandomization:"))
727 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
730 unpack_varlen_hex (packet
, &setting
);
731 disable_randomization
= setting
;
735 if (disable_randomization
)
736 fprintf (stderr
, "[address space randomization disabled]\n");
738 fprintf (stderr
, "[address space randomization enabled]\n");
745 if (target_supports_tracepoints ()
746 && handle_tracepoint_general_set (own_buf
))
749 if (startswith (own_buf
, "QAgent:"))
751 char *mode
= own_buf
+ strlen ("QAgent:");
754 if (strcmp (mode
, "0") == 0)
756 else if (strcmp (mode
, "1") == 0)
760 /* We don't know what this value is, so complain to GDB. */
761 sprintf (own_buf
, "E.Unknown QAgent value");
765 /* Update the flag. */
768 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
773 if (handle_btrace_general_set (own_buf
))
776 if (handle_btrace_conf_general_set (own_buf
))
779 if (startswith (own_buf
, "QThreadEvents:"))
781 char *mode
= own_buf
+ strlen ("QThreadEvents:");
782 enum tribool req
= TRIBOOL_UNKNOWN
;
784 if (strcmp (mode
, "0") == 0)
786 else if (strcmp (mode
, "1") == 0)
790 char *mode_copy
= xstrdup (mode
);
792 /* We don't know what this mode is, so complain to GDB. */
793 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
799 report_thread_events
= (req
== TRIBOOL_TRUE
);
803 const char *req_str
= report_thread_events
? "enabled" : "disabled";
805 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
812 /* Otherwise we didn't know what packet it was. Say we didn't
818 get_features_xml (const char *annex
)
820 const struct target_desc
*desc
= current_target_desc ();
822 /* `desc->xmltarget' defines what to return when looking for the
823 "target.xml" file. Its contents can either be verbatim XML code
824 (prefixed with a '@') or else the name of the actual XML file to
825 be used in place of "target.xml".
827 This variable is set up from the auto-generated
828 init_registers_... routine for the current target. */
830 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
832 if (*desc
->xmltarget
== '@')
833 return desc
->xmltarget
+ 1;
835 annex
= desc
->xmltarget
;
840 extern const char *const xml_builtin
[][2];
843 /* Look for the annex. */
844 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
845 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
848 if (xml_builtin
[i
][0] != NULL
)
849 return xml_builtin
[i
][1];
857 monitor_show_help (void)
859 monitor_output ("The following monitor commands are supported:\n");
860 monitor_output (" set debug <0|1>\n");
861 monitor_output (" Enable general debugging messages\n");
862 monitor_output (" set debug-hw-points <0|1>\n");
863 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
864 monitor_output (" set remote-debug <0|1>\n");
865 monitor_output (" Enable remote protocol debugging messages\n");
866 monitor_output (" set debug-format option1[,option2,...]\n");
867 monitor_output (" Add additional information to debugging messages\n");
868 monitor_output (" Options: all, none");
869 monitor_output (", timestamp");
870 monitor_output ("\n");
871 monitor_output (" exit\n");
872 monitor_output (" Quit GDBserver\n");
875 /* Read trace frame or inferior memory. Returns the number of bytes
876 actually read, zero when no further transfer is possible, and -1 on
877 error. Return of a positive value smaller than LEN does not
878 indicate there's no more to be read, only the end of the transfer.
879 E.g., when GDB reads memory from a traceframe, a first request may
880 be served from a memory block that does not cover the whole request
881 length. A following request gets the rest served from either
882 another block (of the same traceframe) or from the read-only
886 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
890 if (current_traceframe
>= 0)
893 ULONGEST length
= len
;
895 if (traceframe_read_mem (current_traceframe
,
896 memaddr
, myaddr
, len
, &nbytes
))
898 /* Data read from trace buffer, we're done. */
901 if (!in_readonly_region (memaddr
, length
))
903 /* Otherwise we have a valid readonly case, fall through. */
904 /* (assume no half-trace half-real blocks for now) */
907 res
= prepare_to_access_memory ();
910 if (set_desired_thread (1))
911 res
= read_inferior_memory (memaddr
, myaddr
, len
);
914 done_accessing_memory ();
916 return res
== 0 ? len
: -1;
922 /* Write trace frame or inferior memory. Actually, writing to trace
923 frames is forbidden. */
926 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
928 if (current_traceframe
>= 0)
934 ret
= prepare_to_access_memory ();
937 if (set_desired_thread (1))
938 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
941 done_accessing_memory ();
947 /* Subroutine of handle_search_memory to simplify it. */
950 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
951 gdb_byte
*pattern
, unsigned pattern_len
,
952 gdb_byte
*search_buf
,
953 unsigned chunk_size
, unsigned search_buf_size
,
954 CORE_ADDR
*found_addrp
)
956 /* Prime the search buffer. */
958 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
961 warning ("Unable to access %ld bytes of target "
962 "memory at 0x%lx, halting search.",
963 (long) search_buf_size
, (long) start_addr
);
967 /* Perform the search.
969 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
970 When we've scanned N bytes we copy the trailing bytes to the start and
971 read in another N bytes. */
973 while (search_space_len
>= pattern_len
)
976 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
980 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
983 if (found_ptr
!= NULL
)
985 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
986 *found_addrp
= found_addr
;
990 /* Not found in this chunk, skip to next chunk. */
992 /* Don't let search_space_len wrap here, it's unsigned. */
993 if (search_space_len
>= chunk_size
)
994 search_space_len
-= chunk_size
;
996 search_space_len
= 0;
998 if (search_space_len
>= pattern_len
)
1000 unsigned keep_len
= search_buf_size
- chunk_size
;
1001 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
1004 /* Copy the trailing part of the previous iteration to the front
1005 of the buffer for the next iteration. */
1006 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1008 nr_to_read
= (search_space_len
- keep_len
< chunk_size
1009 ? search_space_len
- keep_len
1012 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
1013 nr_to_read
) != search_buf_size
)
1015 warning ("Unable to access %ld bytes of target memory "
1016 "at 0x%lx, halting search.",
1017 (long) nr_to_read
, (long) read_addr
);
1021 start_addr
+= chunk_size
;
1030 /* Handle qSearch:memory packets. */
1033 handle_search_memory (char *own_buf
, int packet_len
)
1035 CORE_ADDR start_addr
;
1036 CORE_ADDR search_space_len
;
1038 unsigned int pattern_len
;
1039 /* NOTE: also defined in find.c testcase. */
1040 #define SEARCH_CHUNK_SIZE 16000
1041 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1042 /* Buffer to hold memory contents for searching. */
1043 gdb_byte
*search_buf
;
1044 unsigned search_buf_size
;
1046 CORE_ADDR found_addr
;
1047 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1049 pattern
= (gdb_byte
*) malloc (packet_len
);
1050 if (pattern
== NULL
)
1052 error ("Unable to allocate memory to perform the search");
1053 strcpy (own_buf
, "E00");
1056 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1057 packet_len
- cmd_name_len
,
1058 &start_addr
, &search_space_len
,
1059 pattern
, &pattern_len
) < 0)
1062 error ("Error in parsing qSearch:memory packet");
1063 strcpy (own_buf
, "E00");
1067 search_buf_size
= chunk_size
+ pattern_len
- 1;
1069 /* No point in trying to allocate a buffer larger than the search space. */
1070 if (search_space_len
< search_buf_size
)
1071 search_buf_size
= search_space_len
;
1073 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1074 if (search_buf
== NULL
)
1077 error ("Unable to allocate memory to perform the search");
1078 strcpy (own_buf
, "E00");
1082 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1083 pattern
, pattern_len
,
1084 search_buf
, chunk_size
, search_buf_size
,
1088 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1089 else if (found
== 0)
1090 strcpy (own_buf
, "0");
1092 strcpy (own_buf
, "E00");
1098 #define require_running(BUF) \
1099 if (!target_running ()) \
1105 /* Parse options to --debug-format= and "monitor set debug-format".
1106 ARG is the text after "--debug-format=" or "monitor set debug-format".
1107 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1108 This triggers calls to monitor_output.
1109 The result is NULL if all options were parsed ok, otherwise an error
1110 message which the caller must free.
1112 N.B. These commands affect all debug format settings, they are not
1113 cumulative. If a format is not specified, it is turned off.
1114 However, we don't go to extra trouble with things like
1115 "monitor set debug-format all,none,timestamp".
1116 Instead we just parse them one at a time, in order.
1118 The syntax for "monitor set debug" we support here is not identical
1119 to gdb's "set debug foo on|off" because we also use this function to
1120 parse "--debug-format=foo,bar". */
1123 parse_debug_format_options (const char *arg
, int is_monitor
)
1125 VEC (char_ptr
) *options
;
1129 /* First turn all debug format options off. */
1130 debug_timestamp
= 0;
1132 /* First remove leading spaces, for "monitor set debug-format". */
1133 while (isspace (*arg
))
1136 options
= delim_string_to_char_ptr_vec (arg
, ',');
1138 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1140 if (strcmp (option
, "all") == 0)
1142 debug_timestamp
= 1;
1144 monitor_output ("All extra debug format options enabled.\n");
1146 else if (strcmp (option
, "none") == 0)
1148 debug_timestamp
= 0;
1150 monitor_output ("All extra debug format options disabled.\n");
1152 else if (strcmp (option
, "timestamp") == 0)
1154 debug_timestamp
= 1;
1156 monitor_output ("Timestamps will be added to debug output.\n");
1158 else if (*option
== '\0')
1160 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1165 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1168 free_char_ptr_vec (options
);
1173 free_char_ptr_vec (options
);
1177 /* Handle monitor commands not handled by target-specific handlers. */
1180 handle_monitor_command (char *mon
, char *own_buf
)
1182 if (strcmp (mon
, "set debug 1") == 0)
1185 monitor_output ("Debug output enabled.\n");
1187 else if (strcmp (mon
, "set debug 0") == 0)
1190 monitor_output ("Debug output disabled.\n");
1192 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1194 show_debug_regs
= 1;
1195 monitor_output ("H/W point debugging output enabled.\n");
1197 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1199 show_debug_regs
= 0;
1200 monitor_output ("H/W point debugging output disabled.\n");
1202 else if (strcmp (mon
, "set remote-debug 1") == 0)
1205 monitor_output ("Protocol debug output enabled.\n");
1207 else if (strcmp (mon
, "set remote-debug 0") == 0)
1210 monitor_output ("Protocol debug output disabled.\n");
1212 else if (startswith (mon
, "set debug-format "))
1215 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1218 if (error_msg
!= NULL
)
1220 monitor_output (error_msg
);
1221 monitor_show_help ();
1222 write_enn (own_buf
);
1226 else if (strcmp (mon
, "help") == 0)
1227 monitor_show_help ();
1228 else if (strcmp (mon
, "exit") == 0)
1232 monitor_output ("Unknown monitor command.\n\n");
1233 monitor_show_help ();
1234 write_enn (own_buf
);
1238 /* Associates a callback with each supported qXfer'able object. */
1242 /* The object this handler handles. */
1245 /* Request that the target transfer up to LEN 8-bit bytes of the
1246 target's OBJECT. The OFFSET, for a seekable object, specifies
1247 the starting point. The ANNEX can be used to provide additional
1248 data-specific information to the target.
1250 Return the number of bytes actually transfered, zero when no
1251 further transfer is possible, -1 on error, -2 when the transfer
1252 is not supported, and -3 on a verbose error message that should
1253 be preserved. Return of a positive value smaller than LEN does
1254 not indicate the end of the object, only the end of the transfer.
1256 One, and only one, of readbuf or writebuf must be non-NULL. */
1257 int (*xfer
) (const char *annex
,
1258 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1259 ULONGEST offset
, LONGEST len
);
1262 /* Handle qXfer:auxv:read. */
1265 handle_qxfer_auxv (const char *annex
,
1266 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1267 ULONGEST offset
, LONGEST len
)
1269 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1272 if (annex
[0] != '\0' || current_thread
== NULL
)
1275 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1278 /* Handle qXfer:exec-file:read. */
1281 handle_qxfer_exec_file (const char *const_annex
,
1282 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1283 ULONGEST offset
, LONGEST len
)
1289 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1292 if (const_annex
[0] == '\0')
1294 if (current_thread
== NULL
)
1297 pid
= pid_of (current_thread
);
1301 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1303 strcpy (annex
, const_annex
);
1304 annex
= unpack_varlen_hex (annex
, &pid
);
1306 if (annex
[0] != '\0')
1313 file
= (*the_target
->pid_to_exec_file
) (pid
);
1317 total_len
= strlen (file
);
1319 if (offset
> total_len
)
1322 if (offset
+ len
> total_len
)
1323 len
= total_len
- offset
;
1325 memcpy (readbuf
, file
+ offset
, len
);
1329 /* Handle qXfer:features:read. */
1332 handle_qxfer_features (const char *annex
,
1333 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1334 ULONGEST offset
, LONGEST len
)
1336 const char *document
;
1339 if (writebuf
!= NULL
)
1342 if (!target_running ())
1345 /* Grab the correct annex. */
1346 document
= get_features_xml (annex
);
1347 if (document
== NULL
)
1350 total_len
= strlen (document
);
1352 if (offset
> total_len
)
1355 if (offset
+ len
> total_len
)
1356 len
= total_len
- offset
;
1358 memcpy (readbuf
, document
+ offset
, len
);
1362 /* Worker routine for handle_qxfer_libraries.
1363 Add to the length pointed to by ARG a conservative estimate of the
1364 length needed to transmit the file name of INF. */
1367 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1369 struct dll_info
*dll
= (struct dll_info
*) inf
;
1370 unsigned int *total_len
= (unsigned int *) arg
;
1372 /* Over-estimate the necessary memory. Assume that every character
1373 in the library name must be escaped. */
1374 *total_len
+= 128 + 6 * strlen (dll
->name
);
1377 /* Worker routine for handle_qxfer_libraries.
1378 Emit the XML to describe the library in INF. */
1381 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1383 struct dll_info
*dll
= (struct dll_info
*) inf
;
1384 char **p_ptr
= (char **) arg
;
1388 strcpy (p
, " <library name=\"");
1390 name
= xml_escape_text (dll
->name
);
1394 strcpy (p
, "\"><segment address=\"");
1396 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1398 strcpy (p
, "\"/></library>\n");
1404 /* Handle qXfer:libraries:read. */
1407 handle_qxfer_libraries (const char *annex
,
1408 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1409 ULONGEST offset
, LONGEST len
)
1411 unsigned int total_len
;
1414 if (writebuf
!= NULL
)
1417 if (annex
[0] != '\0' || current_thread
== NULL
)
1421 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1424 document
= (char *) malloc (total_len
);
1425 if (document
== NULL
)
1428 strcpy (document
, "<library-list version=\"1.0\">\n");
1429 p
= document
+ strlen (document
);
1431 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1433 strcpy (p
, "</library-list>\n");
1435 total_len
= strlen (document
);
1437 if (offset
> total_len
)
1443 if (offset
+ len
> total_len
)
1444 len
= total_len
- offset
;
1446 memcpy (readbuf
, document
+ offset
, len
);
1451 /* Handle qXfer:libraries-svr4:read. */
1454 handle_qxfer_libraries_svr4 (const char *annex
,
1455 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1456 ULONGEST offset
, LONGEST len
)
1458 if (writebuf
!= NULL
)
1461 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1464 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1467 /* Handle qXfer:osadata:read. */
1470 handle_qxfer_osdata (const char *annex
,
1471 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1472 ULONGEST offset
, LONGEST len
)
1474 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1477 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1480 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1483 handle_qxfer_siginfo (const char *annex
,
1484 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1485 ULONGEST offset
, LONGEST len
)
1487 if (the_target
->qxfer_siginfo
== NULL
)
1490 if (annex
[0] != '\0' || current_thread
== NULL
)
1493 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1496 /* Handle qXfer:spu:read and qXfer:spu:write. */
1499 handle_qxfer_spu (const char *annex
,
1500 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1501 ULONGEST offset
, LONGEST len
)
1503 if (the_target
->qxfer_spu
== NULL
)
1506 if (current_thread
== NULL
)
1509 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1512 /* Handle qXfer:statictrace:read. */
1515 handle_qxfer_statictrace (const char *annex
,
1516 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1517 ULONGEST offset
, LONGEST len
)
1521 if (writebuf
!= NULL
)
1524 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1527 if (traceframe_read_sdata (current_traceframe
, offset
,
1528 readbuf
, len
, &nbytes
))
1533 /* Helper for handle_qxfer_threads_proper.
1534 Emit the XML to describe the thread of INF. */
1537 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1539 struct thread_info
*thread
= (struct thread_info
*) inf
;
1540 struct buffer
*buffer
= (struct buffer
*) arg
;
1541 ptid_t ptid
= thread_to_gdb_id (thread
);
1543 int core
= target_core_of_thread (ptid
);
1545 const char *name
= target_thread_name (ptid
);
1547 write_ptid (ptid_s
, ptid
);
1549 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1553 sprintf (core_s
, "%d", core
);
1554 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1558 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1560 buffer_xml_printf (buffer
, "/>\n");
1563 /* Helper for handle_qxfer_threads. */
1566 handle_qxfer_threads_proper (struct buffer
*buffer
)
1568 buffer_grow_str (buffer
, "<threads>\n");
1570 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1573 buffer_grow_str0 (buffer
, "</threads>\n");
1576 /* Handle qXfer:threads:read. */
1579 handle_qxfer_threads (const char *annex
,
1580 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1581 ULONGEST offset
, LONGEST len
)
1583 static char *result
= 0;
1584 static unsigned int result_length
= 0;
1586 if (writebuf
!= NULL
)
1589 if (annex
[0] != '\0')
1594 struct buffer buffer
;
1595 /* When asked for data at offset 0, generate everything and store into
1596 'result'. Successive reads will be served off 'result'. */
1600 buffer_init (&buffer
);
1602 handle_qxfer_threads_proper (&buffer
);
1604 result
= buffer_finish (&buffer
);
1605 result_length
= strlen (result
);
1606 buffer_free (&buffer
);
1609 if (offset
>= result_length
)
1611 /* We're out of data. */
1618 if (len
> result_length
- offset
)
1619 len
= result_length
- offset
;
1621 memcpy (readbuf
, result
+ offset
, len
);
1626 /* Handle qXfer:traceframe-info:read. */
1629 handle_qxfer_traceframe_info (const char *annex
,
1630 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1631 ULONGEST offset
, LONGEST len
)
1633 static char *result
= 0;
1634 static unsigned int result_length
= 0;
1636 if (writebuf
!= NULL
)
1639 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1644 struct buffer buffer
;
1646 /* When asked for data at offset 0, generate everything and
1647 store into 'result'. Successive reads will be served off
1651 buffer_init (&buffer
);
1653 traceframe_read_info (current_traceframe
, &buffer
);
1655 result
= buffer_finish (&buffer
);
1656 result_length
= strlen (result
);
1657 buffer_free (&buffer
);
1660 if (offset
>= result_length
)
1662 /* We're out of data. */
1669 if (len
> result_length
- offset
)
1670 len
= result_length
- offset
;
1672 memcpy (readbuf
, result
+ offset
, len
);
1676 /* Handle qXfer:fdpic:read. */
1679 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1680 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1682 if (the_target
->read_loadmap
== NULL
)
1685 if (current_thread
== NULL
)
1688 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1691 /* Handle qXfer:btrace:read. */
1694 handle_qxfer_btrace (const char *annex
,
1695 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1696 ULONGEST offset
, LONGEST len
)
1698 static struct buffer cache
;
1699 struct thread_info
*thread
;
1700 enum btrace_read_type type
;
1703 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1706 if (ptid_equal (general_thread
, null_ptid
)
1707 || ptid_equal (general_thread
, minus_one_ptid
))
1709 strcpy (own_buf
, "E.Must select a single thread.");
1713 thread
= find_thread_ptid (general_thread
);
1716 strcpy (own_buf
, "E.No such thread.");
1720 if (thread
->btrace
== NULL
)
1722 strcpy (own_buf
, "E.Btrace not enabled.");
1726 if (strcmp (annex
, "all") == 0)
1727 type
= BTRACE_READ_ALL
;
1728 else if (strcmp (annex
, "new") == 0)
1729 type
= BTRACE_READ_NEW
;
1730 else if (strcmp (annex
, "delta") == 0)
1731 type
= BTRACE_READ_DELTA
;
1734 strcpy (own_buf
, "E.Bad annex.");
1740 buffer_free (&cache
);
1742 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1745 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1749 else if (offset
> cache
.used_size
)
1751 buffer_free (&cache
);
1755 if (len
> cache
.used_size
- offset
)
1756 len
= cache
.used_size
- offset
;
1758 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1763 /* Handle qXfer:btrace-conf:read. */
1766 handle_qxfer_btrace_conf (const char *annex
,
1767 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1768 ULONGEST offset
, LONGEST len
)
1770 static struct buffer cache
;
1771 struct thread_info
*thread
;
1774 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1777 if (annex
[0] != '\0')
1780 if (ptid_equal (general_thread
, null_ptid
)
1781 || ptid_equal (general_thread
, minus_one_ptid
))
1783 strcpy (own_buf
, "E.Must select a single thread.");
1787 thread
= find_thread_ptid (general_thread
);
1790 strcpy (own_buf
, "E.No such thread.");
1794 if (thread
->btrace
== NULL
)
1796 strcpy (own_buf
, "E.Btrace not enabled.");
1802 buffer_free (&cache
);
1804 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1807 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1811 else if (offset
> cache
.used_size
)
1813 buffer_free (&cache
);
1817 if (len
> cache
.used_size
- offset
)
1818 len
= cache
.used_size
- offset
;
1820 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1825 static const struct qxfer qxfer_packets
[] =
1827 { "auxv", handle_qxfer_auxv
},
1828 { "btrace", handle_qxfer_btrace
},
1829 { "btrace-conf", handle_qxfer_btrace_conf
},
1830 { "exec-file", handle_qxfer_exec_file
},
1831 { "fdpic", handle_qxfer_fdpic
},
1832 { "features", handle_qxfer_features
},
1833 { "libraries", handle_qxfer_libraries
},
1834 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1835 { "osdata", handle_qxfer_osdata
},
1836 { "siginfo", handle_qxfer_siginfo
},
1837 { "spu", handle_qxfer_spu
},
1838 { "statictrace", handle_qxfer_statictrace
},
1839 { "threads", handle_qxfer_threads
},
1840 { "traceframe-info", handle_qxfer_traceframe_info
},
1844 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1852 if (!startswith (own_buf
, "qXfer:"))
1855 /* Grab the object, r/w and annex. */
1856 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1858 write_enn (own_buf
);
1863 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1866 const struct qxfer
*q
= &qxfer_packets
[i
];
1868 if (strcmp (object
, q
->object
) == 0)
1870 if (strcmp (rw
, "read") == 0)
1872 unsigned char *data
;
1877 /* Grab the offset and length. */
1878 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1880 write_enn (own_buf
);
1884 /* Read one extra byte, as an indicator of whether there is
1886 if (len
> PBUFSIZ
- 2)
1888 data
= (unsigned char *) malloc (len
+ 1);
1891 write_enn (own_buf
);
1894 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1902 /* Preserve error message. */
1905 write_enn (own_buf
);
1907 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1909 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1914 else if (strcmp (rw
, "write") == 0)
1919 unsigned char *data
;
1921 strcpy (own_buf
, "E00");
1922 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1925 write_enn (own_buf
);
1928 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1929 &ofs
, &len
, data
) < 0)
1932 write_enn (own_buf
);
1936 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1944 /* Preserve error message. */
1947 write_enn (own_buf
);
1949 sprintf (own_buf
, "%x", n
);
1962 /* Compute 32 bit CRC from inferior memory.
1964 On success, return 32 bit CRC.
1965 On failure, return (unsigned long long) -1. */
1967 static unsigned long long
1968 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1972 unsigned char byte
= 0;
1974 /* Return failure if memory read fails. */
1975 if (read_inferior_memory (base
, &byte
, 1) != 0)
1976 return (unsigned long long) -1;
1978 crc
= xcrc32 (&byte
, 1, crc
);
1981 return (unsigned long long) crc
;
1984 /* Add supported btrace packets to BUF. */
1987 supported_btrace_packets (char *buf
)
1989 int btrace_supported
= 0;
1991 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1993 strcat (buf
, ";Qbtrace:bts+");
1994 strcat (buf
, ";Qbtrace-conf:bts:size+");
1996 btrace_supported
= 1;
1999 if (target_supports_btrace (BTRACE_FORMAT_PT
))
2001 strcat (buf
, ";Qbtrace:pt+");
2002 strcat (buf
, ";Qbtrace-conf:pt:size+");
2004 btrace_supported
= 1;
2007 if (!btrace_supported
)
2010 strcat (buf
, ";Qbtrace:off+");
2011 strcat (buf
, ";qXfer:btrace:read+");
2012 strcat (buf
, ";qXfer:btrace-conf:read+");
2015 /* Handle all of the extended 'q' packets. */
2018 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
2020 static struct inferior_list_entry
*thread_ptr
;
2022 /* Reply the current thread id. */
2023 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
2026 require_running (own_buf
);
2028 if (!ptid_equal (general_thread
, null_ptid
)
2029 && !ptid_equal (general_thread
, minus_one_ptid
))
2030 gdb_id
= general_thread
;
2033 thread_ptr
= get_first_inferior (&all_threads
);
2034 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2037 sprintf (own_buf
, "QC");
2039 write_ptid (own_buf
, gdb_id
);
2043 if (strcmp ("qSymbol::", own_buf
) == 0)
2045 struct thread_info
*save_thread
= current_thread
;
2047 /* For qSymbol, GDB only changes the current thread if the
2048 previous current thread was of a different process. So if
2049 the previous thread is gone, we need to pick another one of
2050 the same process. This can happen e.g., if we followed an
2051 exec in a non-leader thread. */
2052 if (current_thread
== NULL
)
2055 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2057 /* Just in case, if we didn't find a thread, then bail out
2058 instead of crashing. */
2059 if (current_thread
== NULL
)
2061 write_enn (own_buf
);
2062 current_thread
= save_thread
;
2067 /* GDB is suggesting new symbols have been loaded. This may
2068 mean a new shared library has been detected as loaded, so
2069 take the opportunity to check if breakpoints we think are
2070 inserted, still are. Note that it isn't guaranteed that
2071 we'll see this when a shared library is loaded, and nor will
2072 we see this for unloads (although breakpoints in unloaded
2073 libraries shouldn't trigger), as GDB may not find symbols for
2074 the library at all. We also re-validate breakpoints when we
2075 see a second GDB breakpoint for the same address, and or when
2076 we access breakpoint shadows. */
2077 validate_breakpoints ();
2079 if (target_supports_tracepoints ())
2080 tracepoint_look_up_symbols ();
2082 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2083 (*the_target
->look_up_symbols
) ();
2085 current_thread
= save_thread
;
2087 strcpy (own_buf
, "OK");
2091 if (!disable_packet_qfThreadInfo
)
2093 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2097 require_running (own_buf
);
2098 thread_ptr
= get_first_inferior (&all_threads
);
2101 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2102 write_ptid (own_buf
, gdb_id
);
2103 thread_ptr
= thread_ptr
->next
;
2107 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2111 require_running (own_buf
);
2112 if (thread_ptr
!= NULL
)
2115 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2116 write_ptid (own_buf
, gdb_id
);
2117 thread_ptr
= thread_ptr
->next
;
2122 sprintf (own_buf
, "l");
2128 if (the_target
->read_offsets
!= NULL
2129 && strcmp ("qOffsets", own_buf
) == 0)
2131 CORE_ADDR text
, data
;
2133 require_running (own_buf
);
2134 if (the_target
->read_offsets (&text
, &data
))
2135 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2136 (long)text
, (long)data
, (long)data
);
2138 write_enn (own_buf
);
2143 /* Protocol features query. */
2144 if (startswith (own_buf
, "qSupported")
2145 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2147 char *p
= &own_buf
[10];
2148 int gdb_supports_qRelocInsn
= 0;
2150 /* Process each feature being provided by GDB. The first
2151 feature will follow a ':', and latter features will follow
2155 char **qsupported
= NULL
;
2160 /* Two passes, to avoid nested strtok calls in
2161 target_process_qsupported. */
2162 for (p
= strtok (p
+ 1, ";");
2164 p
= strtok (NULL
, ";"))
2167 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2168 qsupported
[count
- 1] = xstrdup (p
);
2171 for (i
= 0; i
< count
; i
++)
2174 if (strcmp (p
, "multiprocess+") == 0)
2176 /* GDB supports and wants multi-process support if
2178 if (target_supports_multi_process ())
2181 else if (strcmp (p
, "qRelocInsn+") == 0)
2183 /* GDB supports relocate instruction requests. */
2184 gdb_supports_qRelocInsn
= 1;
2186 else if (strcmp (p
, "swbreak+") == 0)
2188 /* GDB wants us to report whether a trap is caused
2189 by a software breakpoint and for us to handle PC
2190 adjustment if necessary on this target. */
2191 if (target_supports_stopped_by_sw_breakpoint ())
2192 swbreak_feature
= 1;
2194 else if (strcmp (p
, "hwbreak+") == 0)
2196 /* GDB wants us to report whether a trap is caused
2197 by a hardware breakpoint. */
2198 if (target_supports_stopped_by_hw_breakpoint ())
2199 hwbreak_feature
= 1;
2201 else if (strcmp (p
, "fork-events+") == 0)
2203 /* GDB supports and wants fork events if possible. */
2204 if (target_supports_fork_events ())
2205 report_fork_events
= 1;
2207 else if (strcmp (p
, "vfork-events+") == 0)
2209 /* GDB supports and wants vfork events if possible. */
2210 if (target_supports_vfork_events ())
2211 report_vfork_events
= 1;
2213 else if (strcmp (p
, "exec-events+") == 0)
2215 /* GDB supports and wants exec events if possible. */
2216 if (target_supports_exec_events ())
2217 report_exec_events
= 1;
2219 else if (strcmp (p
, "vContSupported+") == 0)
2220 vCont_supported
= 1;
2221 else if (strcmp (p
, "QThreadEvents+") == 0)
2223 else if (strcmp (p
, "no-resumed+") == 0)
2225 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2227 report_no_resumed
= 1;
2231 /* Move the unknown features all together. */
2232 qsupported
[i
] = NULL
;
2233 qsupported
[unknown
] = p
;
2238 /* Give the target backend a chance to process the unknown
2240 target_process_qsupported (qsupported
, unknown
);
2242 for (i
= 0; i
< count
; i
++)
2243 free (qsupported
[i
]);
2248 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2251 if (target_supports_catch_syscall ())
2252 strcat (own_buf
, ";QCatchSyscalls+");
2254 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2255 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2256 ";augmented-libraries-svr4-read+");
2259 /* We do not have any hook to indicate whether the non-SVR4 target
2260 backend supports qXfer:libraries:read, so always report it. */
2261 strcat (own_buf
, ";qXfer:libraries:read+");
2264 if (the_target
->read_auxv
!= NULL
)
2265 strcat (own_buf
, ";qXfer:auxv:read+");
2267 if (the_target
->qxfer_spu
!= NULL
)
2268 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2270 if (the_target
->qxfer_siginfo
!= NULL
)
2271 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2273 if (the_target
->read_loadmap
!= NULL
)
2274 strcat (own_buf
, ";qXfer:fdpic:read+");
2276 /* We always report qXfer:features:read, as targets may
2277 install XML files on a subsequent call to arch_setup.
2278 If we reported to GDB on startup that we don't support
2279 qXfer:feature:read at all, we will never be re-queried. */
2280 strcat (own_buf
, ";qXfer:features:read+");
2282 if (transport_is_reliable
)
2283 strcat (own_buf
, ";QStartNoAckMode+");
2285 if (the_target
->qxfer_osdata
!= NULL
)
2286 strcat (own_buf
, ";qXfer:osdata:read+");
2288 if (target_supports_multi_process ())
2289 strcat (own_buf
, ";multiprocess+");
2291 if (target_supports_fork_events ())
2292 strcat (own_buf
, ";fork-events+");
2294 if (target_supports_vfork_events ())
2295 strcat (own_buf
, ";vfork-events+");
2297 if (target_supports_exec_events ())
2298 strcat (own_buf
, ";exec-events+");
2300 if (target_supports_non_stop ())
2301 strcat (own_buf
, ";QNonStop+");
2303 if (target_supports_disable_randomization ())
2304 strcat (own_buf
, ";QDisableRandomization+");
2306 strcat (own_buf
, ";qXfer:threads:read+");
2308 if (target_supports_tracepoints ())
2310 strcat (own_buf
, ";ConditionalTracepoints+");
2311 strcat (own_buf
, ";TraceStateVariables+");
2312 strcat (own_buf
, ";TracepointSource+");
2313 strcat (own_buf
, ";DisconnectedTracing+");
2314 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2315 strcat (own_buf
, ";FastTracepoints+");
2316 strcat (own_buf
, ";StaticTracepoints+");
2317 strcat (own_buf
, ";InstallInTrace+");
2318 strcat (own_buf
, ";qXfer:statictrace:read+");
2319 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2320 strcat (own_buf
, ";EnableDisableTracepoints+");
2321 strcat (own_buf
, ";QTBuffer:size+");
2322 strcat (own_buf
, ";tracenz+");
2325 if (target_supports_hardware_single_step ()
2326 || target_supports_software_single_step () )
2328 strcat (own_buf
, ";ConditionalBreakpoints+");
2330 strcat (own_buf
, ";BreakpointCommands+");
2332 if (target_supports_agent ())
2333 strcat (own_buf
, ";QAgent+");
2335 supported_btrace_packets (own_buf
);
2337 if (target_supports_stopped_by_sw_breakpoint ())
2338 strcat (own_buf
, ";swbreak+");
2340 if (target_supports_stopped_by_hw_breakpoint ())
2341 strcat (own_buf
, ";hwbreak+");
2343 if (the_target
->pid_to_exec_file
!= NULL
)
2344 strcat (own_buf
, ";qXfer:exec-file:read+");
2346 strcat (own_buf
, ";vContSupported+");
2348 strcat (own_buf
, ";QThreadEvents+");
2350 strcat (own_buf
, ";no-resumed+");
2352 /* Reinitialize components as needed for the new connection. */
2353 hostio_handle_new_gdb_connection ();
2354 target_handle_new_gdb_connection ();
2359 /* Thread-local storage support. */
2360 if (the_target
->get_tls_address
!= NULL
2361 && startswith (own_buf
, "qGetTLSAddr:"))
2363 char *p
= own_buf
+ 12;
2364 CORE_ADDR parts
[2], address
= 0;
2366 ptid_t ptid
= null_ptid
;
2368 require_running (own_buf
);
2370 for (i
= 0; i
< 3; i
++)
2378 p2
= strchr (p
, ',');
2391 ptid
= read_ptid (p
, NULL
);
2393 decode_address (&parts
[i
- 1], p
, len
);
2397 if (p
!= NULL
|| i
< 3)
2401 struct thread_info
*thread
= find_thread_ptid (ptid
);
2406 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2412 strcpy (own_buf
, paddress(address
));
2417 write_enn (own_buf
);
2421 /* Otherwise, pretend we do not understand this packet. */
2424 /* Windows OS Thread Information Block address support. */
2425 if (the_target
->get_tib_address
!= NULL
2426 && startswith (own_buf
, "qGetTIBAddr:"))
2431 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2433 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2436 strcpy (own_buf
, paddress(tlb
));
2441 write_enn (own_buf
);
2447 /* Handle "monitor" commands. */
2448 if (startswith (own_buf
, "qRcmd,"))
2450 char *mon
= (char *) malloc (PBUFSIZ
);
2451 int len
= strlen (own_buf
+ 6);
2455 write_enn (own_buf
);
2460 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2462 write_enn (own_buf
);
2466 mon
[len
/ 2] = '\0';
2470 if (the_target
->handle_monitor_command
== NULL
2471 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2472 /* Default processing. */
2473 handle_monitor_command (mon
, own_buf
);
2479 if (startswith (own_buf
, "qSearch:memory:"))
2481 require_running (own_buf
);
2482 handle_search_memory (own_buf
, packet_len
);
2486 if (strcmp (own_buf
, "qAttached") == 0
2487 || startswith (own_buf
, "qAttached:"))
2489 struct process_info
*process
;
2491 if (own_buf
[sizeof ("qAttached") - 1])
2493 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2494 process
= (struct process_info
*)
2495 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2499 require_running (own_buf
);
2500 process
= current_process ();
2503 if (process
== NULL
)
2505 write_enn (own_buf
);
2509 strcpy (own_buf
, process
->attached
? "1" : "0");
2513 if (startswith (own_buf
, "qCRC:"))
2515 /* CRC check (compare-section). */
2519 unsigned long long crc
;
2521 require_running (own_buf
);
2522 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2523 if (*comma
++ != ',')
2525 write_enn (own_buf
);
2528 len
= strtoul (comma
, NULL
, 16);
2529 crc
= crc32 (base
, len
, 0xffffffff);
2530 /* Check for memory failure. */
2531 if (crc
== (unsigned long long) -1)
2533 write_enn (own_buf
);
2536 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2540 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2543 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2546 /* Otherwise we didn't know what packet it was. Say we didn't
2551 static void gdb_wants_all_threads_stopped (void);
2552 static void resume (struct thread_resume
*actions
, size_t n
);
2554 /* The callback that is passed to visit_actioned_threads. */
2555 typedef int (visit_actioned_threads_callback_ftype
)
2556 (const struct thread_resume
*, struct thread_info
*);
2558 /* Struct to pass data to visit_actioned_threads. */
2560 struct visit_actioned_threads_data
2562 const struct thread_resume
*actions
;
2564 visit_actioned_threads_callback_ftype
*callback
;
2567 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2568 true if CALLBACK returns true. Returns false if no matching thread
2569 is found or CALLBACK results false.
2570 Note: This function is itself a callback for find_inferior. */
2573 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2575 struct visit_actioned_threads_data
*data
2576 = (struct visit_actioned_threads_data
*) datap
;
2577 const struct thread_resume
*actions
= data
->actions
;
2578 size_t num_actions
= data
->num_actions
;
2579 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2582 for (i
= 0; i
< num_actions
; i
++)
2584 const struct thread_resume
*action
= &actions
[i
];
2586 if (ptid_equal (action
->thread
, minus_one_ptid
)
2587 || ptid_equal (action
->thread
, entry
->id
)
2588 || ((ptid_get_pid (action
->thread
)
2589 == ptid_get_pid (entry
->id
))
2590 && ptid_get_lwp (action
->thread
) == -1))
2592 struct thread_info
*thread
= (struct thread_info
*) entry
;
2594 if ((*callback
) (action
, thread
))
2602 /* Callback for visit_actioned_threads. If the thread has a pending
2603 status to report, report it now. */
2606 handle_pending_status (const struct thread_resume
*resumption
,
2607 struct thread_info
*thread
)
2609 if (thread
->status_pending_p
)
2611 thread
->status_pending_p
= 0;
2613 last_status
= thread
->last_status
;
2614 last_ptid
= thread
->entry
.id
;
2615 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2621 /* Parse vCont packets. */
2623 handle_v_cont (char *own_buf
)
2627 struct thread_resume
*resume_info
;
2628 struct thread_resume default_action
= {{0}};
2630 /* Count the number of semicolons in the packet. There should be one
2631 for every action. */
2637 p
= strchr (p
, ';');
2640 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2641 if (resume_info
== NULL
)
2649 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2651 if (p
[0] == 's' || p
[0] == 'S')
2652 resume_info
[i
].kind
= resume_step
;
2653 else if (p
[0] == 'r')
2654 resume_info
[i
].kind
= resume_step
;
2655 else if (p
[0] == 'c' || p
[0] == 'C')
2656 resume_info
[i
].kind
= resume_continue
;
2657 else if (p
[0] == 't')
2658 resume_info
[i
].kind
= resume_stop
;
2662 if (p
[0] == 'S' || p
[0] == 'C')
2665 sig
= strtol (p
+ 1, &q
, 16);
2670 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2672 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2674 else if (p
[0] == 'r')
2678 p
= unpack_varlen_hex (p
+ 1, &addr
);
2679 resume_info
[i
].step_range_start
= addr
;
2684 p
= unpack_varlen_hex (p
+ 1, &addr
);
2685 resume_info
[i
].step_range_end
= addr
;
2694 resume_info
[i
].thread
= minus_one_ptid
;
2695 default_action
= resume_info
[i
];
2697 /* Note: we don't increment i here, we'll overwrite this entry
2698 the next time through. */
2700 else if (p
[0] == ':')
2702 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2707 if (p
[0] != ';' && p
[0] != 0)
2710 resume_info
[i
].thread
= ptid
;
2717 resume_info
[i
] = default_action
;
2719 resume (resume_info
, n
);
2724 write_enn (own_buf
);
2729 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2732 resume (struct thread_resume
*actions
, size_t num_actions
)
2736 /* Check if among the threads that GDB wants actioned, there's
2737 one with a pending status to report. If so, skip actually
2738 resuming/stopping and report the pending event
2740 struct visit_actioned_threads_data data
;
2742 data
.actions
= actions
;
2743 data
.num_actions
= num_actions
;
2744 data
.callback
= handle_pending_status
;
2745 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2751 (*the_target
->resume
) (actions
, num_actions
);
2757 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2759 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2760 && !report_no_resumed
)
2762 /* The client does not support this stop reply. At least
2764 sprintf (own_buf
, "E.No unwaited-for children left.");
2765 disable_async_io ();
2769 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2770 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2771 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2772 current_thread
->last_status
= last_status
;
2774 /* From the client's perspective, all-stop mode always stops all
2775 threads implicitly (and the target backend has already done
2776 so by now). Tag all threads as "want-stopped", so we don't
2777 resume them implicitly without the client telling us to. */
2778 gdb_wants_all_threads_stopped ();
2779 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2780 disable_async_io ();
2782 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2783 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2784 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2788 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2790 handle_v_attach (char *own_buf
)
2794 pid
= strtol (own_buf
+ 8, NULL
, 16);
2795 if (pid
!= 0 && attach_inferior (pid
) == 0)
2797 /* Don't report shared library events after attaching, even if
2798 some libraries are preloaded. GDB will always poll the
2799 library list. Avoids the "stopped by shared library event"
2800 notice on the GDB side. */
2805 /* In non-stop, we don't send a resume reply. Stop events
2806 will follow up using the normal notification
2811 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2817 write_enn (own_buf
);
2822 /* Run a new program. Return 1 if successful, 0 if failure. */
2824 handle_v_run (char *own_buf
)
2826 char *p
, *next_p
, **new_argv
;
2830 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2836 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2837 if (new_argv
== NULL
)
2839 write_enn (own_buf
);
2844 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2846 next_p
= strchr (p
, ';');
2848 next_p
= p
+ strlen (p
);
2850 if (i
== 0 && p
== next_p
)
2854 /* FIXME: Fail request if out of memory instead of dying. */
2855 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2856 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2857 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2866 if (new_argv
[0] == NULL
)
2868 /* GDB didn't specify a program to run. Use the program from the
2869 last run with the new argument list. */
2871 if (program_argv
== NULL
)
2873 write_enn (own_buf
);
2874 freeargv (new_argv
);
2878 new_argv
[0] = strdup (program_argv
[0]);
2879 if (new_argv
[0] == NULL
)
2881 write_enn (own_buf
);
2882 freeargv (new_argv
);
2887 /* Free the old argv and install the new one. */
2888 freeargv (program_argv
);
2889 program_argv
= new_argv
;
2891 start_inferior (program_argv
);
2892 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2894 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2896 /* In non-stop, sending a resume reply doesn't set the general
2897 thread, but GDB assumes a vRun sets it (this is so GDB can
2898 query which is the main thread of the new inferior. */
2900 general_thread
= last_ptid
;
2906 write_enn (own_buf
);
2911 /* Kill process. Return 1 if successful, 0 if failure. */
2913 handle_v_kill (char *own_buf
)
2916 char *p
= &own_buf
[6];
2918 pid
= strtol (p
, NULL
, 16);
2921 if (pid
!= 0 && kill_inferior (pid
) == 0)
2923 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2924 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2925 last_ptid
= pid_to_ptid (pid
);
2926 discard_queued_stop_replies (last_ptid
);
2932 write_enn (own_buf
);
2937 /* Handle all of the extended 'v' packets. */
2939 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2941 if (!disable_packet_vCont
)
2943 if (strcmp (own_buf
, "vCtrlC") == 0)
2945 (*the_target
->request_interrupt
) ();
2950 if (startswith (own_buf
, "vCont;"))
2952 require_running (own_buf
);
2953 handle_v_cont (own_buf
);
2957 if (startswith (own_buf
, "vCont?"))
2959 strcpy (own_buf
, "vCont;c;C;t");
2961 if (target_supports_hardware_single_step () || !vCont_supported
)
2963 /* If target supports hardware single step, add actions s
2964 and S to the list of supported actions. On the other
2965 hand, if GDB doesn't request the supported vCont actions
2966 in qSupported packet, add s and S to the list too. */
2967 own_buf
= own_buf
+ strlen (own_buf
);
2968 strcpy (own_buf
, ";s;S");
2971 if (target_supports_range_stepping ())
2973 own_buf
= own_buf
+ strlen (own_buf
);
2974 strcpy (own_buf
, ";r");
2980 if (startswith (own_buf
, "vFile:")
2981 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2984 if (startswith (own_buf
, "vAttach;"))
2986 if ((!extended_protocol
|| !multi_process
) && target_running ())
2988 fprintf (stderr
, "Already debugging a process\n");
2989 write_enn (own_buf
);
2992 handle_v_attach (own_buf
);
2996 if (startswith (own_buf
, "vRun;"))
2998 if ((!extended_protocol
|| !multi_process
) && target_running ())
3000 fprintf (stderr
, "Already debugging a process\n");
3001 write_enn (own_buf
);
3004 handle_v_run (own_buf
);
3008 if (startswith (own_buf
, "vKill;"))
3010 if (!target_running ())
3012 fprintf (stderr
, "No process to kill\n");
3013 write_enn (own_buf
);
3016 handle_v_kill (own_buf
);
3020 if (handle_notif_ack (own_buf
, packet_len
))
3023 /* Otherwise we didn't know what packet it was. Say we didn't
3029 /* Resume thread and wait for another event. In non-stop mode,
3030 don't really wait here, but return immediatelly to the event
3033 myresume (char *own_buf
, int step
, int sig
)
3035 struct thread_resume resume_info
[2];
3037 int valid_cont_thread
;
3039 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3040 && !ptid_equal (cont_thread
, minus_one_ptid
));
3042 if (step
|| sig
|| valid_cont_thread
)
3044 resume_info
[0].thread
= current_ptid
;
3046 resume_info
[0].kind
= resume_step
;
3048 resume_info
[0].kind
= resume_continue
;
3049 resume_info
[0].sig
= sig
;
3053 if (!valid_cont_thread
)
3055 resume_info
[n
].thread
= minus_one_ptid
;
3056 resume_info
[n
].kind
= resume_continue
;
3057 resume_info
[n
].sig
= 0;
3061 resume (resume_info
, n
);
3064 /* Callback for for_each_inferior. Make a new stop reply for each
3068 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3070 struct thread_info
*thread
= (struct thread_info
*) entry
;
3072 /* For now, assume targets that don't have this callback also don't
3073 manage the thread's last_status field. */
3074 if (the_target
->thread_stopped
== NULL
)
3076 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3078 new_notif
->ptid
= entry
->id
;
3079 new_notif
->status
= thread
->last_status
;
3080 /* Pass the last stop reply back to GDB, but don't notify
3082 notif_event_enque (¬if_stop
,
3083 (struct notif_event
*) new_notif
);
3087 if (thread_stopped (thread
))
3092 = target_waitstatus_to_string (&thread
->last_status
);
3094 debug_printf ("Reporting thread %s as already stopped with %s\n",
3095 target_pid_to_str (entry
->id
),
3098 xfree (status_string
);
3101 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3103 /* Pass the last stop reply back to GDB, but don't notify
3105 queue_stop_reply (entry
->id
, &thread
->last_status
);
3112 /* Set this inferior threads's state as "want-stopped". We won't
3113 resume this thread until the client gives us another action for
3117 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3119 struct thread_info
*thread
= (struct thread_info
*) entry
;
3121 thread
->last_resume_kind
= resume_stop
;
3123 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3125 /* Most threads are stopped implicitly (all-stop); tag that with
3127 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3128 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3132 /* Set all threads' states as "want-stopped". */
3135 gdb_wants_all_threads_stopped (void)
3137 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3140 /* Clear the gdb_detached flag of every process. */
3143 gdb_reattached_process (struct inferior_list_entry
*entry
)
3145 struct process_info
*process
= (struct process_info
*) entry
;
3147 process
->gdb_detached
= 0;
3150 /* Callback for for_each_inferior. Clear the thread's pending status
3154 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3156 struct thread_info
*thread
= (struct thread_info
*) entry
;
3158 thread
->status_pending_p
= 0;
3161 /* Callback for for_each_inferior. If the thread is stopped with an
3162 interesting event, mark it as having a pending event. */
3165 set_pending_status_callback (struct inferior_list_entry
*entry
)
3167 struct thread_info
*thread
= (struct thread_info
*) entry
;
3169 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3170 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3171 /* A breakpoint, watchpoint or finished step from a previous
3172 GDB run isn't considered interesting for a new GDB run.
3173 If we left those pending, the new GDB could consider them
3174 random SIGTRAPs. This leaves out real async traps. We'd
3175 have to peek into the (target-specific) siginfo to
3176 distinguish those. */
3177 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3178 thread
->status_pending_p
= 1;
3181 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3182 pending status to report to GDB. */
3185 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3187 struct thread_info
*thread
= (struct thread_info
*) entry
;
3189 return thread
->status_pending_p
;
3192 /* Status handler for the '?' packet. */
3195 handle_status (char *own_buf
)
3197 /* GDB is connected, don't forward events to the target anymore. */
3198 for_each_inferior (&all_processes
, gdb_reattached_process
);
3200 /* In non-stop mode, we must send a stop reply for each stopped
3201 thread. In all-stop mode, just send one for the first stopped
3206 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3208 /* The first is sent immediatly. OK is sent if there is no
3209 stopped thread, which is the same handling of the vStopped
3210 packet (by design). */
3211 notif_write_event (¬if_stop
, own_buf
);
3215 struct inferior_list_entry
*thread
= NULL
;
3218 stabilize_threads ();
3219 gdb_wants_all_threads_stopped ();
3221 /* We can only report one status, but we might be coming out of
3222 non-stop -- if more than one thread is stopped with
3223 interesting events, leave events for the threads we're not
3224 reporting now pending. They'll be reported the next time the
3225 threads are resumed. Start by marking all interesting events
3227 for_each_inferior (&all_threads
, set_pending_status_callback
);
3229 /* Prefer the last thread that reported an event to GDB (even if
3230 that was a GDB_SIGNAL_TRAP). */
3231 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3232 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3233 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3234 thread
= find_inferior_id (&all_threads
, last_ptid
);
3236 /* If the last event thread is not found for some reason, look
3237 for some other thread that might have an event to report. */
3239 thread
= find_inferior (&all_threads
,
3240 find_status_pending_thread_callback
, NULL
);
3242 /* If we're still out of luck, simply pick the first thread in
3245 thread
= get_first_inferior (&all_threads
);
3249 struct thread_info
*tp
= (struct thread_info
*) thread
;
3251 /* We're reporting this event, so it's no longer
3253 tp
->status_pending_p
= 0;
3255 /* GDB assumes the current thread is the thread we're
3256 reporting the status for. */
3257 general_thread
= thread
->id
;
3258 set_desired_thread (1);
3260 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3261 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3264 strcpy (own_buf
, "W00");
3269 gdbserver_version (void)
3271 printf ("GNU gdbserver %s%s\n"
3272 "Copyright (C) 2016 Free Software Foundation, Inc.\n"
3273 "gdbserver is free software, covered by the "
3274 "GNU General Public License.\n"
3275 "This gdbserver was configured as \"%s\"\n",
3276 PKGVERSION
, version
, host_name
);
3280 gdbserver_usage (FILE *stream
)
3282 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3283 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3284 "\tgdbserver [OPTIONS] --multi COMM\n"
3286 "COMM may either be a tty device (for serial debugging),\n"
3287 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3288 "stdin/stdout of gdbserver.\n"
3289 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3290 "PID is the process ID to attach to, when --attach is specified.\n"
3292 "Operating modes:\n"
3294 " --attach Attach to running process PID.\n"
3295 " --multi Start server without a specific program, and\n"
3296 " only quit when explicitly commanded.\n"
3297 " --once Exit after the first connection has closed.\n"
3298 " --help Print this message and then exit.\n"
3299 " --version Display version information and exit.\n"
3303 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3304 " --disable-randomization\n"
3305 " Run PROG with address space randomization disabled.\n"
3306 " --no-disable-randomization\n"
3307 " Don't disable address space randomization when\n"
3312 " --debug Enable general debugging output.\n"
3313 " --debug-format=opt1[,opt2,...]\n"
3314 " Specify extra content in debugging output.\n"
3319 " --remote-debug Enable remote protocol debugging output.\n"
3320 " --disable-packet=opt1[,opt2,...]\n"
3321 " Disable support for RSP packets or features.\n"
3323 " vCont, Tthread, qC, qfThreadInfo and \n"
3324 " threads (disable all threading packets).\n"
3326 "For more information, consult the GDB manual (available as on-line \n"
3327 "info or a printed manual).\n");
3328 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3329 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3333 gdbserver_show_disableable (FILE *stream
)
3335 fprintf (stream
, "Disableable packets:\n"
3336 " vCont \tAll vCont packets\n"
3337 " qC \tQuerying the current thread\n"
3338 " qfThreadInfo\tThread listing\n"
3339 " Tthread \tPassing the thread specifier in the "
3340 "T stop reply packet\n"
3341 " threads \tAll of the above\n");
3345 #undef require_running
3346 #define require_running(BUF) \
3347 if (!target_running ()) \
3354 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3356 int pid
= * (int *) args
;
3358 if (ptid_get_pid (entry
->id
) == pid
)
3365 kill_inferior_callback (struct inferior_list_entry
*entry
)
3367 struct process_info
*process
= (struct process_info
*) entry
;
3368 int pid
= ptid_get_pid (process
->entry
.id
);
3370 kill_inferior (pid
);
3371 discard_queued_stop_replies (pid_to_ptid (pid
));
3374 /* Callback for for_each_inferior to detach or kill the inferior,
3375 depending on whether we attached to it or not.
3376 We inform the user whether we're detaching or killing the process
3377 as this is only called when gdbserver is about to exit. */
3380 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3382 struct process_info
*process
= (struct process_info
*) entry
;
3383 int pid
= ptid_get_pid (process
->entry
.id
);
3385 if (process
->attached
)
3386 detach_inferior (pid
);
3388 kill_inferior (pid
);
3390 discard_queued_stop_replies (pid_to_ptid (pid
));
3393 /* for_each_inferior callback for detach_or_kill_for_exit to print
3394 the pids of started inferiors. */
3397 print_started_pid (struct inferior_list_entry
*entry
)
3399 struct process_info
*process
= (struct process_info
*) entry
;
3401 if (! process
->attached
)
3403 int pid
= ptid_get_pid (process
->entry
.id
);
3404 fprintf (stderr
, " %d", pid
);
3408 /* for_each_inferior callback for detach_or_kill_for_exit to print
3409 the pids of attached inferiors. */
3412 print_attached_pid (struct inferior_list_entry
*entry
)
3414 struct process_info
*process
= (struct process_info
*) entry
;
3416 if (process
->attached
)
3418 int pid
= ptid_get_pid (process
->entry
.id
);
3419 fprintf (stderr
, " %d", pid
);
3423 /* Call this when exiting gdbserver with possible inferiors that need
3424 to be killed or detached from. */
3427 detach_or_kill_for_exit (void)
3429 /* First print a list of the inferiors we will be killing/detaching.
3430 This is to assist the user, for example, in case the inferior unexpectedly
3431 dies after we exit: did we screw up or did the inferior exit on its own?
3432 Having this info will save some head-scratching. */
3434 if (have_started_inferiors_p ())
3436 fprintf (stderr
, "Killing process(es):");
3437 for_each_inferior (&all_processes
, print_started_pid
);
3438 fprintf (stderr
, "\n");
3440 if (have_attached_inferiors_p ())
3442 fprintf (stderr
, "Detaching process(es):");
3443 for_each_inferior (&all_processes
, print_attached_pid
);
3444 fprintf (stderr
, "\n");
3447 /* Now we can kill or detach the inferiors. */
3449 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3452 /* Value that will be passed to exit(3) when gdbserver exits. */
3453 static int exit_code
;
3455 /* Cleanup version of detach_or_kill_for_exit. */
3458 detach_or_kill_for_exit_cleanup (void *ignore
)
3463 detach_or_kill_for_exit ();
3466 CATCH (exception
, RETURN_MASK_ALL
)
3469 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3475 /* Main function. This is called by the real "main" function,
3476 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3478 static void ATTRIBUTE_NORETURN
3479 captured_main (int argc
, char *argv
[])
3483 char *arg_end
, *port
;
3484 char **next_arg
= &argv
[1];
3485 volatile int multi_mode
= 0;
3486 volatile int attach
= 0;
3489 while (*next_arg
!= NULL
&& **next_arg
== '-')
3491 if (strcmp (*next_arg
, "--version") == 0)
3493 gdbserver_version ();
3496 else if (strcmp (*next_arg
, "--help") == 0)
3498 gdbserver_usage (stdout
);
3501 else if (strcmp (*next_arg
, "--attach") == 0)
3503 else if (strcmp (*next_arg
, "--multi") == 0)
3505 else if (strcmp (*next_arg
, "--wrapper") == 0)
3509 wrapper_argv
= next_arg
;
3510 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3513 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3515 gdbserver_usage (stderr
);
3519 /* Consume the "--". */
3522 else if (strcmp (*next_arg
, "--debug") == 0)
3524 else if (startswith (*next_arg
, "--debug-format="))
3527 = parse_debug_format_options ((*next_arg
)
3528 + sizeof ("--debug-format=") - 1, 0);
3530 if (error_msg
!= NULL
)
3532 fprintf (stderr
, "%s", error_msg
);
3536 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3538 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3540 gdbserver_show_disableable (stdout
);
3543 else if (startswith (*next_arg
, "--disable-packet="))
3545 char *packets
, *tok
;
3547 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3548 for (tok
= strtok (packets
, ",");
3550 tok
= strtok (NULL
, ","))
3552 if (strcmp ("vCont", tok
) == 0)
3553 disable_packet_vCont
= 1;
3554 else if (strcmp ("Tthread", tok
) == 0)
3555 disable_packet_Tthread
= 1;
3556 else if (strcmp ("qC", tok
) == 0)
3557 disable_packet_qC
= 1;
3558 else if (strcmp ("qfThreadInfo", tok
) == 0)
3559 disable_packet_qfThreadInfo
= 1;
3560 else if (strcmp ("threads", tok
) == 0)
3562 disable_packet_vCont
= 1;
3563 disable_packet_Tthread
= 1;
3564 disable_packet_qC
= 1;
3565 disable_packet_qfThreadInfo
= 1;
3569 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3571 gdbserver_show_disableable (stderr
);
3576 else if (strcmp (*next_arg
, "-") == 0)
3578 /* "-" specifies a stdio connection and is a form of port
3580 *next_arg
= STDIO_CONNECTION_NAME
;
3583 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3584 disable_randomization
= 1;
3585 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3586 disable_randomization
= 0;
3587 else if (strcmp (*next_arg
, "--once") == 0)
3591 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3601 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3603 gdbserver_usage (stderr
);
3607 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3608 opened by remote_prepare. */
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 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 thread_resume resume_info
;
3928 struct process_info
*process
= find_process_pid (pid
);
3930 if (process
== NULL
)
3932 write_enn (own_buf
);
3936 if (tracing
&& disconnected_tracing
)
3938 "Disconnected tracing in effect, "
3939 "leaving gdbserver attached to the process\n");
3941 if (any_persistent_commands ())
3943 "Persistent commands are present, "
3944 "leaving gdbserver attached to the process\n");
3946 /* Make sure we're in non-stop/async mode, so we we can both
3947 wait for an async socket accept, and handle async target
3948 events simultaneously. There's also no point either in
3949 having the target stop all threads, when we're going to
3950 pass signals down without informing GDB. */
3954 debug_printf ("Forcing non-stop mode\n");
3960 process
->gdb_detached
= 1;
3962 /* Detaching implicitly resumes all threads. */
3963 resume_info
.thread
= minus_one_ptid
;
3964 resume_info
.kind
= resume_continue
;
3965 resume_info
.sig
= 0;
3966 (*the_target
->resume
) (&resume_info
, 1);
3969 break; /* from switch/case */
3972 fprintf (stderr
, "Detaching from process %d\n", pid
);
3974 if (detach_inferior (pid
) != 0)
3975 write_enn (own_buf
);
3978 discard_queued_stop_replies (pid_to_ptid (pid
));
3981 if (extended_protocol
|| target_running ())
3983 /* There is still at least one inferior remaining or
3984 we are in extended mode, so don't terminate gdbserver,
3985 and instead treat this like a normal program exit. */
3986 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3987 last_status
.value
.integer
= 0;
3988 last_ptid
= pid_to_ptid (pid
);
3990 current_thread
= NULL
;
3997 /* If we are attached, then we can exit. Otherwise, we
3998 need to hang around doing nothing, until the child is
4000 join_inferior (pid
);
4006 extended_protocol
= 1;
4010 handle_status (own_buf
);
4013 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
4015 ptid_t gdb_id
, thread_id
;
4018 require_running (own_buf
);
4020 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4022 pid
= ptid_get_pid (gdb_id
);
4024 if (ptid_equal (gdb_id
, null_ptid
)
4025 || ptid_equal (gdb_id
, minus_one_ptid
))
4026 thread_id
= null_ptid
;
4028 && ptid_equal (pid_to_ptid (pid
),
4031 struct thread_info
*thread
=
4032 (struct thread_info
*) find_inferior (&all_threads
,
4037 write_enn (own_buf
);
4041 thread_id
= thread
->entry
.id
;
4045 thread_id
= gdb_id_to_thread_id (gdb_id
);
4046 if (ptid_equal (thread_id
, null_ptid
))
4048 write_enn (own_buf
);
4053 if (own_buf
[1] == 'g')
4055 if (ptid_equal (thread_id
, null_ptid
))
4057 /* GDB is telling us to choose any thread. Check if
4058 the currently selected thread is still valid. If
4059 it is not, select the first available. */
4060 struct thread_info
*thread
=
4061 (struct thread_info
*) find_inferior_id (&all_threads
,
4064 thread
= get_first_thread ();
4065 thread_id
= thread
->entry
.id
;
4068 general_thread
= thread_id
;
4069 set_desired_thread (1);
4070 gdb_assert (current_thread
!= NULL
);
4072 else if (own_buf
[1] == 'c')
4073 cont_thread
= thread_id
;
4079 /* Silently ignore it so that gdb can extend the protocol
4080 without compatibility headaches. */
4085 require_running (own_buf
);
4086 if (current_traceframe
>= 0)
4088 struct regcache
*regcache
4089 = new_register_cache (current_target_desc ());
4091 if (fetch_traceframe_registers (current_traceframe
,
4093 registers_to_string (regcache
, own_buf
);
4095 write_enn (own_buf
);
4096 free_register_cache (regcache
);
4100 struct regcache
*regcache
;
4102 if (!set_desired_thread (1))
4103 write_enn (own_buf
);
4106 regcache
= get_thread_regcache (current_thread
, 1);
4107 registers_to_string (regcache
, own_buf
);
4112 require_running (own_buf
);
4113 if (current_traceframe
>= 0)
4114 write_enn (own_buf
);
4117 struct regcache
*regcache
;
4119 if (!set_desired_thread (1))
4120 write_enn (own_buf
);
4123 regcache
= get_thread_regcache (current_thread
, 1);
4124 registers_from_string (regcache
, &own_buf
[1]);
4130 require_running (own_buf
);
4131 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4132 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4134 write_enn (own_buf
);
4136 bin2hex (mem_buf
, own_buf
, res
);
4139 require_running (own_buf
);
4140 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4141 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4144 write_enn (own_buf
);
4147 require_running (own_buf
);
4148 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4149 &mem_addr
, &len
, &mem_buf
) < 0
4150 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4151 write_enn (own_buf
);
4156 require_running (own_buf
);
4157 hex2bin (own_buf
+ 1, &sig
, 1);
4158 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4159 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4162 myresume (own_buf
, 0, signal
);
4165 require_running (own_buf
);
4166 hex2bin (own_buf
+ 1, &sig
, 1);
4167 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4168 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4171 myresume (own_buf
, 1, signal
);
4174 require_running (own_buf
);
4176 myresume (own_buf
, 0, signal
);
4179 require_running (own_buf
);
4181 myresume (own_buf
, 1, signal
);
4183 case 'Z': /* insert_ ... */
4185 case 'z': /* remove_ ... */
4190 char type
= own_buf
[1];
4192 const int insert
= ch
== 'Z';
4193 char *p
= &own_buf
[3];
4195 p
= unpack_varlen_hex (p
, &addr
);
4196 kind
= strtol (p
+ 1, &dataptr
, 16);
4200 struct breakpoint
*bp
;
4202 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4207 /* GDB may have sent us a list of *point parameters to
4208 be evaluated on the target's side. Read such list
4209 here. If we already have a list of parameters, GDB
4210 is telling us to drop that list and use this one
4212 clear_breakpoint_conditions_and_commands (bp
);
4213 process_point_options (bp
, &dataptr
);
4217 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4225 write_enn (own_buf
);
4229 response_needed
= 0;
4230 if (!target_running ())
4231 /* The packet we received doesn't make sense - but we can't
4232 reply to it, either. */
4235 fprintf (stderr
, "Killing all inferiors\n");
4236 for_each_inferior (&all_processes
, kill_inferior_callback
);
4238 /* When using the extended protocol, we wait with no program
4239 running. The traditional protocol will exit instead. */
4240 if (extended_protocol
)
4242 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4243 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4251 ptid_t gdb_id
, thread_id
;
4253 require_running (own_buf
);
4255 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4256 thread_id
= gdb_id_to_thread_id (gdb_id
);
4257 if (ptid_equal (thread_id
, null_ptid
))
4259 write_enn (own_buf
);
4263 if (mythread_alive (thread_id
))
4266 write_enn (own_buf
);
4270 response_needed
= 0;
4272 /* Restarting the inferior is only supported in the extended
4274 if (extended_protocol
)
4276 if (target_running ())
4277 for_each_inferior (&all_processes
,
4278 kill_inferior_callback
);
4279 fprintf (stderr
, "GDBserver restarting\n");
4281 /* Wait till we are at 1st instruction in prog. */
4282 if (program_argv
!= NULL
)
4284 start_inferior (program_argv
);
4285 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4287 /* Stopped at the first instruction of the target
4289 general_thread
= last_ptid
;
4293 /* Something went wrong. */
4294 general_thread
= null_ptid
;
4299 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4300 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4306 /* It is a request we don't understand. Respond with an
4307 empty packet so that gdb knows that we don't support this
4313 /* Extended (long) request. */
4314 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4318 /* It is a request we don't understand. Respond with an empty
4319 packet so that gdb knows that we don't support this
4325 if (new_packet_len
!= -1)
4326 putpkt_binary (own_buf
, new_packet_len
);
4330 response_needed
= 0;
4338 /* Event-loop callback for serial events. */
4341 handle_serial_event (int err
, gdb_client_data client_data
)
4344 debug_printf ("handling possible serial event\n");
4346 /* Really handle it. */
4347 if (process_serial_event () < 0)
4350 /* Be sure to not change the selected thread behind GDB's back.
4351 Important in the non-stop mode asynchronous protocol. */
4352 set_desired_thread (1);
4357 /* Push a stop notification on the notification queue. */
4360 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4362 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4364 vstop_notif
->status
= *status
;
4365 vstop_notif
->ptid
= ptid
;
4366 /* Push Stop notification. */
4367 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4370 /* Event-loop callback for target events. */
4373 handle_target_event (int err
, gdb_client_data client_data
)
4376 debug_printf ("handling possible target event\n");
4378 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4381 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4383 if (gdb_connected () && report_no_resumed
)
4384 push_stop_notification (null_ptid
, &last_status
);
4386 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4388 int pid
= ptid_get_pid (last_ptid
);
4389 struct process_info
*process
= find_process_pid (pid
);
4390 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4392 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4393 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4395 mark_breakpoints_out (process
);
4396 mourn_inferior (process
);
4398 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4402 /* We're reporting this thread as stopped. Update its
4403 "want-stopped" state to what the client wants, until it
4404 gets a new resume action. */
4405 current_thread
->last_resume_kind
= resume_stop
;
4406 current_thread
->last_status
= last_status
;
4411 if (!target_running ())
4413 /* The last process exited. We're done. */
4417 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4418 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4419 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4423 /* A thread stopped with a signal, but gdb isn't
4424 connected to handle it. Pass it down to the
4425 inferior, as if it wasn't being traced. */
4426 struct thread_resume resume_info
;
4429 debug_printf ("GDB not connected; forwarding event %d for"
4431 (int) last_status
.kind
,
4432 target_pid_to_str (last_ptid
));
4434 resume_info
.thread
= last_ptid
;
4435 resume_info
.kind
= resume_continue
;
4436 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4437 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4439 resume_info
.sig
= 0;
4440 (*the_target
->resume
) (&resume_info
, 1);
4444 push_stop_notification (last_ptid
, &last_status
);
4447 /* Be sure to not change the selected thread behind GDB's back.
4448 Important in the non-stop mode asynchronous protocol. */
4449 set_desired_thread (1);