1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2015 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(R) 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 (strcmp (own_buf
, "QStartNoAckMode") == 0)
631 fprintf (stderr
, "[noack mode enabled]\n");
640 if (startswith (own_buf
, "QNonStop:"))
642 char *mode
= own_buf
+ 9;
646 if (strcmp (mode
, "0") == 0)
648 else if (strcmp (mode
, "1") == 0)
652 /* We don't know what this mode is, so complain to
654 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
660 req_str
= req
? "non-stop" : "all-stop";
661 if (start_non_stop (req
) != 0)
663 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
671 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
677 if (startswith (own_buf
, "QDisableRandomization:"))
679 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
682 unpack_varlen_hex (packet
, &setting
);
683 disable_randomization
= setting
;
687 if (disable_randomization
)
688 fprintf (stderr
, "[address space randomization disabled]\n");
690 fprintf (stderr
, "[address space randomization enabled]\n");
697 if (target_supports_tracepoints ()
698 && handle_tracepoint_general_set (own_buf
))
701 if (startswith (own_buf
, "QAgent:"))
703 char *mode
= own_buf
+ strlen ("QAgent:");
706 if (strcmp (mode
, "0") == 0)
708 else if (strcmp (mode
, "1") == 0)
712 /* We don't know what this value is, so complain to GDB. */
713 sprintf (own_buf
, "E.Unknown QAgent value");
717 /* Update the flag. */
720 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
725 if (handle_btrace_general_set (own_buf
))
728 if (handle_btrace_conf_general_set (own_buf
))
731 if (startswith (own_buf
, "QThreadEvents:"))
733 char *mode
= own_buf
+ strlen ("QThreadEvents:");
734 enum tribool req
= TRIBOOL_UNKNOWN
;
736 if (strcmp (mode
, "0") == 0)
738 else if (strcmp (mode
, "1") == 0)
742 char *mode_copy
= xstrdup (mode
);
744 /* We don't know what this mode is, so complain to GDB. */
745 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
751 report_thread_events
= (req
== TRIBOOL_TRUE
);
755 const char *req_str
= report_thread_events
? "enabled" : "disabled";
757 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
764 /* Otherwise we didn't know what packet it was. Say we didn't
770 get_features_xml (const char *annex
)
772 const struct target_desc
*desc
= current_target_desc ();
774 /* `desc->xmltarget' defines what to return when looking for the
775 "target.xml" file. Its contents can either be verbatim XML code
776 (prefixed with a '@') or else the name of the actual XML file to
777 be used in place of "target.xml".
779 This variable is set up from the auto-generated
780 init_registers_... routine for the current target. */
782 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
784 if (*desc
->xmltarget
== '@')
785 return desc
->xmltarget
+ 1;
787 annex
= desc
->xmltarget
;
792 extern const char *const xml_builtin
[][2];
795 /* Look for the annex. */
796 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
797 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
800 if (xml_builtin
[i
][0] != NULL
)
801 return xml_builtin
[i
][1];
809 monitor_show_help (void)
811 monitor_output ("The following monitor commands are supported:\n");
812 monitor_output (" set debug <0|1>\n");
813 monitor_output (" Enable general debugging messages\n");
814 monitor_output (" set debug-hw-points <0|1>\n");
815 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
816 monitor_output (" set remote-debug <0|1>\n");
817 monitor_output (" Enable remote protocol debugging messages\n");
818 monitor_output (" set debug-format option1[,option2,...]\n");
819 monitor_output (" Add additional information to debugging messages\n");
820 monitor_output (" Options: all, none");
821 monitor_output (", timestamp");
822 monitor_output ("\n");
823 monitor_output (" exit\n");
824 monitor_output (" Quit GDBserver\n");
827 /* Read trace frame or inferior memory. Returns the number of bytes
828 actually read, zero when no further transfer is possible, and -1 on
829 error. Return of a positive value smaller than LEN does not
830 indicate there's no more to be read, only the end of the transfer.
831 E.g., when GDB reads memory from a traceframe, a first request may
832 be served from a memory block that does not cover the whole request
833 length. A following request gets the rest served from either
834 another block (of the same traceframe) or from the read-only
838 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
842 if (current_traceframe
>= 0)
845 ULONGEST length
= len
;
847 if (traceframe_read_mem (current_traceframe
,
848 memaddr
, myaddr
, len
, &nbytes
))
850 /* Data read from trace buffer, we're done. */
853 if (!in_readonly_region (memaddr
, length
))
855 /* Otherwise we have a valid readonly case, fall through. */
856 /* (assume no half-trace half-real blocks for now) */
859 res
= prepare_to_access_memory ();
862 if (set_desired_thread (1))
863 res
= read_inferior_memory (memaddr
, myaddr
, len
);
866 done_accessing_memory ();
868 return res
== 0 ? len
: -1;
874 /* Write trace frame or inferior memory. Actually, writing to trace
875 frames is forbidden. */
878 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
880 if (current_traceframe
>= 0)
886 ret
= prepare_to_access_memory ();
889 if (set_desired_thread (1))
890 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
893 done_accessing_memory ();
899 /* Subroutine of handle_search_memory to simplify it. */
902 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
903 gdb_byte
*pattern
, unsigned pattern_len
,
904 gdb_byte
*search_buf
,
905 unsigned chunk_size
, unsigned search_buf_size
,
906 CORE_ADDR
*found_addrp
)
908 /* Prime the search buffer. */
910 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
913 warning ("Unable to access %ld bytes of target "
914 "memory at 0x%lx, halting search.",
915 (long) search_buf_size
, (long) start_addr
);
919 /* Perform the search.
921 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
922 When we've scanned N bytes we copy the trailing bytes to the start and
923 read in another N bytes. */
925 while (search_space_len
>= pattern_len
)
928 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
932 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
935 if (found_ptr
!= NULL
)
937 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
938 *found_addrp
= found_addr
;
942 /* Not found in this chunk, skip to next chunk. */
944 /* Don't let search_space_len wrap here, it's unsigned. */
945 if (search_space_len
>= chunk_size
)
946 search_space_len
-= chunk_size
;
948 search_space_len
= 0;
950 if (search_space_len
>= pattern_len
)
952 unsigned keep_len
= search_buf_size
- chunk_size
;
953 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
956 /* Copy the trailing part of the previous iteration to the front
957 of the buffer for the next iteration. */
958 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
960 nr_to_read
= (search_space_len
- keep_len
< chunk_size
961 ? search_space_len
- keep_len
964 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
965 nr_to_read
) != search_buf_size
)
967 warning ("Unable to access %ld bytes of target memory "
968 "at 0x%lx, halting search.",
969 (long) nr_to_read
, (long) read_addr
);
973 start_addr
+= chunk_size
;
982 /* Handle qSearch:memory packets. */
985 handle_search_memory (char *own_buf
, int packet_len
)
987 CORE_ADDR start_addr
;
988 CORE_ADDR search_space_len
;
990 unsigned int pattern_len
;
991 /* NOTE: also defined in find.c testcase. */
992 #define SEARCH_CHUNK_SIZE 16000
993 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
994 /* Buffer to hold memory contents for searching. */
995 gdb_byte
*search_buf
;
996 unsigned search_buf_size
;
998 CORE_ADDR found_addr
;
999 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1001 pattern
= (gdb_byte
*) malloc (packet_len
);
1002 if (pattern
== NULL
)
1004 error ("Unable to allocate memory to perform the search");
1005 strcpy (own_buf
, "E00");
1008 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1009 packet_len
- cmd_name_len
,
1010 &start_addr
, &search_space_len
,
1011 pattern
, &pattern_len
) < 0)
1014 error ("Error in parsing qSearch:memory packet");
1015 strcpy (own_buf
, "E00");
1019 search_buf_size
= chunk_size
+ pattern_len
- 1;
1021 /* No point in trying to allocate a buffer larger than the search space. */
1022 if (search_space_len
< search_buf_size
)
1023 search_buf_size
= search_space_len
;
1025 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1026 if (search_buf
== NULL
)
1029 error ("Unable to allocate memory to perform the search");
1030 strcpy (own_buf
, "E00");
1034 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1035 pattern
, pattern_len
,
1036 search_buf
, chunk_size
, search_buf_size
,
1040 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1041 else if (found
== 0)
1042 strcpy (own_buf
, "0");
1044 strcpy (own_buf
, "E00");
1050 #define require_running(BUF) \
1051 if (!target_running ()) \
1057 /* Parse options to --debug-format= and "monitor set debug-format".
1058 ARG is the text after "--debug-format=" or "monitor set debug-format".
1059 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1060 This triggers calls to monitor_output.
1061 The result is NULL if all options were parsed ok, otherwise an error
1062 message which the caller must free.
1064 N.B. These commands affect all debug format settings, they are not
1065 cumulative. If a format is not specified, it is turned off.
1066 However, we don't go to extra trouble with things like
1067 "monitor set debug-format all,none,timestamp".
1068 Instead we just parse them one at a time, in order.
1070 The syntax for "monitor set debug" we support here is not identical
1071 to gdb's "set debug foo on|off" because we also use this function to
1072 parse "--debug-format=foo,bar". */
1075 parse_debug_format_options (const char *arg
, int is_monitor
)
1077 VEC (char_ptr
) *options
;
1081 /* First turn all debug format options off. */
1082 debug_timestamp
= 0;
1084 /* First remove leading spaces, for "monitor set debug-format". */
1085 while (isspace (*arg
))
1088 options
= delim_string_to_char_ptr_vec (arg
, ',');
1090 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1092 if (strcmp (option
, "all") == 0)
1094 debug_timestamp
= 1;
1096 monitor_output ("All extra debug format options enabled.\n");
1098 else if (strcmp (option
, "none") == 0)
1100 debug_timestamp
= 0;
1102 monitor_output ("All extra debug format options disabled.\n");
1104 else if (strcmp (option
, "timestamp") == 0)
1106 debug_timestamp
= 1;
1108 monitor_output ("Timestamps will be added to debug output.\n");
1110 else if (*option
== '\0')
1112 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1117 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1120 free_char_ptr_vec (options
);
1125 free_char_ptr_vec (options
);
1129 /* Handle monitor commands not handled by target-specific handlers. */
1132 handle_monitor_command (char *mon
, char *own_buf
)
1134 if (strcmp (mon
, "set debug 1") == 0)
1137 monitor_output ("Debug output enabled.\n");
1139 else if (strcmp (mon
, "set debug 0") == 0)
1142 monitor_output ("Debug output disabled.\n");
1144 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1146 show_debug_regs
= 1;
1147 monitor_output ("H/W point debugging output enabled.\n");
1149 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1151 show_debug_regs
= 0;
1152 monitor_output ("H/W point debugging output disabled.\n");
1154 else if (strcmp (mon
, "set remote-debug 1") == 0)
1157 monitor_output ("Protocol debug output enabled.\n");
1159 else if (strcmp (mon
, "set remote-debug 0") == 0)
1162 monitor_output ("Protocol debug output disabled.\n");
1164 else if (startswith (mon
, "set debug-format "))
1167 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1170 if (error_msg
!= NULL
)
1172 monitor_output (error_msg
);
1173 monitor_show_help ();
1174 write_enn (own_buf
);
1178 else if (strcmp (mon
, "help") == 0)
1179 monitor_show_help ();
1180 else if (strcmp (mon
, "exit") == 0)
1184 monitor_output ("Unknown monitor command.\n\n");
1185 monitor_show_help ();
1186 write_enn (own_buf
);
1190 /* Associates a callback with each supported qXfer'able object. */
1194 /* The object this handler handles. */
1197 /* Request that the target transfer up to LEN 8-bit bytes of the
1198 target's OBJECT. The OFFSET, for a seekable object, specifies
1199 the starting point. The ANNEX can be used to provide additional
1200 data-specific information to the target.
1202 Return the number of bytes actually transfered, zero when no
1203 further transfer is possible, -1 on error, -2 when the transfer
1204 is not supported, and -3 on a verbose error message that should
1205 be preserved. Return of a positive value smaller than LEN does
1206 not indicate the end of the object, only the end of the transfer.
1208 One, and only one, of readbuf or writebuf must be non-NULL. */
1209 int (*xfer
) (const char *annex
,
1210 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1211 ULONGEST offset
, LONGEST len
);
1214 /* Handle qXfer:auxv:read. */
1217 handle_qxfer_auxv (const char *annex
,
1218 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1219 ULONGEST offset
, LONGEST len
)
1221 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1224 if (annex
[0] != '\0' || current_thread
== NULL
)
1227 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1230 /* Handle qXfer:exec-file:read. */
1233 handle_qxfer_exec_file (const char *const_annex
,
1234 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1235 ULONGEST offset
, LONGEST len
)
1241 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1244 if (const_annex
[0] == '\0')
1246 if (current_thread
== NULL
)
1249 pid
= pid_of (current_thread
);
1253 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1255 strcpy (annex
, const_annex
);
1256 annex
= unpack_varlen_hex (annex
, &pid
);
1258 if (annex
[0] != '\0')
1265 file
= (*the_target
->pid_to_exec_file
) (pid
);
1269 total_len
= strlen (file
);
1271 if (offset
> total_len
)
1274 if (offset
+ len
> total_len
)
1275 len
= total_len
- offset
;
1277 memcpy (readbuf
, file
+ offset
, len
);
1281 /* Handle qXfer:features:read. */
1284 handle_qxfer_features (const char *annex
,
1285 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1286 ULONGEST offset
, LONGEST len
)
1288 const char *document
;
1291 if (writebuf
!= NULL
)
1294 if (!target_running ())
1297 /* Grab the correct annex. */
1298 document
= get_features_xml (annex
);
1299 if (document
== NULL
)
1302 total_len
= strlen (document
);
1304 if (offset
> total_len
)
1307 if (offset
+ len
> total_len
)
1308 len
= total_len
- offset
;
1310 memcpy (readbuf
, document
+ offset
, len
);
1314 /* Worker routine for handle_qxfer_libraries.
1315 Add to the length pointed to by ARG a conservative estimate of the
1316 length needed to transmit the file name of INF. */
1319 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1321 struct dll_info
*dll
= (struct dll_info
*) inf
;
1322 unsigned int *total_len
= (unsigned int *) arg
;
1324 /* Over-estimate the necessary memory. Assume that every character
1325 in the library name must be escaped. */
1326 *total_len
+= 128 + 6 * strlen (dll
->name
);
1329 /* Worker routine for handle_qxfer_libraries.
1330 Emit the XML to describe the library in INF. */
1333 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1335 struct dll_info
*dll
= (struct dll_info
*) inf
;
1336 char **p_ptr
= (char **) arg
;
1340 strcpy (p
, " <library name=\"");
1342 name
= xml_escape_text (dll
->name
);
1346 strcpy (p
, "\"><segment address=\"");
1348 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1350 strcpy (p
, "\"/></library>\n");
1356 /* Handle qXfer:libraries:read. */
1359 handle_qxfer_libraries (const char *annex
,
1360 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1361 ULONGEST offset
, LONGEST len
)
1363 unsigned int total_len
;
1366 if (writebuf
!= NULL
)
1369 if (annex
[0] != '\0' || current_thread
== NULL
)
1373 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1376 document
= (char *) malloc (total_len
);
1377 if (document
== NULL
)
1380 strcpy (document
, "<library-list version=\"1.0\">\n");
1381 p
= document
+ strlen (document
);
1383 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1385 strcpy (p
, "</library-list>\n");
1387 total_len
= strlen (document
);
1389 if (offset
> total_len
)
1395 if (offset
+ len
> total_len
)
1396 len
= total_len
- offset
;
1398 memcpy (readbuf
, document
+ offset
, len
);
1403 /* Handle qXfer:libraries-svr4:read. */
1406 handle_qxfer_libraries_svr4 (const char *annex
,
1407 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1408 ULONGEST offset
, LONGEST len
)
1410 if (writebuf
!= NULL
)
1413 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1416 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1419 /* Handle qXfer:osadata:read. */
1422 handle_qxfer_osdata (const char *annex
,
1423 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1424 ULONGEST offset
, LONGEST len
)
1426 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1429 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1432 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1435 handle_qxfer_siginfo (const char *annex
,
1436 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1437 ULONGEST offset
, LONGEST len
)
1439 if (the_target
->qxfer_siginfo
== NULL
)
1442 if (annex
[0] != '\0' || current_thread
== NULL
)
1445 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1448 /* Handle qXfer:spu:read and qXfer:spu:write. */
1451 handle_qxfer_spu (const char *annex
,
1452 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1453 ULONGEST offset
, LONGEST len
)
1455 if (the_target
->qxfer_spu
== NULL
)
1458 if (current_thread
== NULL
)
1461 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1464 /* Handle qXfer:statictrace:read. */
1467 handle_qxfer_statictrace (const char *annex
,
1468 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1469 ULONGEST offset
, LONGEST len
)
1473 if (writebuf
!= NULL
)
1476 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1479 if (traceframe_read_sdata (current_traceframe
, offset
,
1480 readbuf
, len
, &nbytes
))
1485 /* Helper for handle_qxfer_threads_proper.
1486 Emit the XML to describe the thread of INF. */
1489 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1491 struct thread_info
*thread
= (struct thread_info
*) inf
;
1492 struct buffer
*buffer
= (struct buffer
*) arg
;
1493 ptid_t ptid
= thread_to_gdb_id (thread
);
1495 int core
= target_core_of_thread (ptid
);
1497 const char *name
= target_thread_name (ptid
);
1499 write_ptid (ptid_s
, ptid
);
1501 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1505 sprintf (core_s
, "%d", core
);
1506 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1510 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1512 buffer_xml_printf (buffer
, "/>\n");
1515 /* Helper for handle_qxfer_threads. */
1518 handle_qxfer_threads_proper (struct buffer
*buffer
)
1520 buffer_grow_str (buffer
, "<threads>\n");
1522 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1525 buffer_grow_str0 (buffer
, "</threads>\n");
1528 /* Handle qXfer:threads:read. */
1531 handle_qxfer_threads (const char *annex
,
1532 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1533 ULONGEST offset
, LONGEST len
)
1535 static char *result
= 0;
1536 static unsigned int result_length
= 0;
1538 if (writebuf
!= NULL
)
1541 if (annex
[0] != '\0')
1546 struct buffer buffer
;
1547 /* When asked for data at offset 0, generate everything and store into
1548 'result'. Successive reads will be served off 'result'. */
1552 buffer_init (&buffer
);
1554 handle_qxfer_threads_proper (&buffer
);
1556 result
= buffer_finish (&buffer
);
1557 result_length
= strlen (result
);
1558 buffer_free (&buffer
);
1561 if (offset
>= result_length
)
1563 /* We're out of data. */
1570 if (len
> result_length
- offset
)
1571 len
= result_length
- offset
;
1573 memcpy (readbuf
, result
+ offset
, len
);
1578 /* Handle qXfer:traceframe-info:read. */
1581 handle_qxfer_traceframe_info (const char *annex
,
1582 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1583 ULONGEST offset
, LONGEST len
)
1585 static char *result
= 0;
1586 static unsigned int result_length
= 0;
1588 if (writebuf
!= NULL
)
1591 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1596 struct buffer buffer
;
1598 /* When asked for data at offset 0, generate everything and
1599 store into 'result'. Successive reads will be served off
1603 buffer_init (&buffer
);
1605 traceframe_read_info (current_traceframe
, &buffer
);
1607 result
= buffer_finish (&buffer
);
1608 result_length
= strlen (result
);
1609 buffer_free (&buffer
);
1612 if (offset
>= result_length
)
1614 /* We're out of data. */
1621 if (len
> result_length
- offset
)
1622 len
= result_length
- offset
;
1624 memcpy (readbuf
, result
+ offset
, len
);
1628 /* Handle qXfer:fdpic:read. */
1631 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1632 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1634 if (the_target
->read_loadmap
== NULL
)
1637 if (current_thread
== NULL
)
1640 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1643 /* Handle qXfer:btrace:read. */
1646 handle_qxfer_btrace (const char *annex
,
1647 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1648 ULONGEST offset
, LONGEST len
)
1650 static struct buffer cache
;
1651 struct thread_info
*thread
;
1652 enum btrace_read_type type
;
1655 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1658 if (ptid_equal (general_thread
, null_ptid
)
1659 || ptid_equal (general_thread
, minus_one_ptid
))
1661 strcpy (own_buf
, "E.Must select a single thread.");
1665 thread
= find_thread_ptid (general_thread
);
1668 strcpy (own_buf
, "E.No such thread.");
1672 if (thread
->btrace
== NULL
)
1674 strcpy (own_buf
, "E.Btrace not enabled.");
1678 if (strcmp (annex
, "all") == 0)
1679 type
= BTRACE_READ_ALL
;
1680 else if (strcmp (annex
, "new") == 0)
1681 type
= BTRACE_READ_NEW
;
1682 else if (strcmp (annex
, "delta") == 0)
1683 type
= BTRACE_READ_DELTA
;
1686 strcpy (own_buf
, "E.Bad annex.");
1692 buffer_free (&cache
);
1694 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1697 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1701 else if (offset
> cache
.used_size
)
1703 buffer_free (&cache
);
1707 if (len
> cache
.used_size
- offset
)
1708 len
= cache
.used_size
- offset
;
1710 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1715 /* Handle qXfer:btrace-conf:read. */
1718 handle_qxfer_btrace_conf (const char *annex
,
1719 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1720 ULONGEST offset
, LONGEST len
)
1722 static struct buffer cache
;
1723 struct thread_info
*thread
;
1726 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1729 if (annex
[0] != '\0')
1732 if (ptid_equal (general_thread
, null_ptid
)
1733 || ptid_equal (general_thread
, minus_one_ptid
))
1735 strcpy (own_buf
, "E.Must select a single thread.");
1739 thread
= find_thread_ptid (general_thread
);
1742 strcpy (own_buf
, "E.No such thread.");
1746 if (thread
->btrace
== NULL
)
1748 strcpy (own_buf
, "E.Btrace not enabled.");
1754 buffer_free (&cache
);
1756 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1759 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1763 else if (offset
> cache
.used_size
)
1765 buffer_free (&cache
);
1769 if (len
> cache
.used_size
- offset
)
1770 len
= cache
.used_size
- offset
;
1772 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1777 static const struct qxfer qxfer_packets
[] =
1779 { "auxv", handle_qxfer_auxv
},
1780 { "btrace", handle_qxfer_btrace
},
1781 { "btrace-conf", handle_qxfer_btrace_conf
},
1782 { "exec-file", handle_qxfer_exec_file
},
1783 { "fdpic", handle_qxfer_fdpic
},
1784 { "features", handle_qxfer_features
},
1785 { "libraries", handle_qxfer_libraries
},
1786 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1787 { "osdata", handle_qxfer_osdata
},
1788 { "siginfo", handle_qxfer_siginfo
},
1789 { "spu", handle_qxfer_spu
},
1790 { "statictrace", handle_qxfer_statictrace
},
1791 { "threads", handle_qxfer_threads
},
1792 { "traceframe-info", handle_qxfer_traceframe_info
},
1796 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1804 if (!startswith (own_buf
, "qXfer:"))
1807 /* Grab the object, r/w and annex. */
1808 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1810 write_enn (own_buf
);
1815 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1818 const struct qxfer
*q
= &qxfer_packets
[i
];
1820 if (strcmp (object
, q
->object
) == 0)
1822 if (strcmp (rw
, "read") == 0)
1824 unsigned char *data
;
1829 /* Grab the offset and length. */
1830 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1832 write_enn (own_buf
);
1836 /* Read one extra byte, as an indicator of whether there is
1838 if (len
> PBUFSIZ
- 2)
1840 data
= (unsigned char *) malloc (len
+ 1);
1843 write_enn (own_buf
);
1846 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1854 /* Preserve error message. */
1857 write_enn (own_buf
);
1859 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1861 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1866 else if (strcmp (rw
, "write") == 0)
1871 unsigned char *data
;
1873 strcpy (own_buf
, "E00");
1874 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1877 write_enn (own_buf
);
1880 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1881 &ofs
, &len
, data
) < 0)
1884 write_enn (own_buf
);
1888 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1896 /* Preserve error message. */
1899 write_enn (own_buf
);
1901 sprintf (own_buf
, "%x", n
);
1914 /* Table used by the crc32 function to calcuate the checksum. */
1916 static unsigned int crc32_table
[256] =
1919 /* Compute 32 bit CRC from inferior memory.
1921 On success, return 32 bit CRC.
1922 On failure, return (unsigned long long) -1. */
1924 static unsigned long long
1925 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1927 if (!crc32_table
[1])
1929 /* Initialize the CRC table and the decoding table. */
1933 for (i
= 0; i
< 256; i
++)
1935 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1936 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1943 unsigned char byte
= 0;
1945 /* Return failure if memory read fails. */
1946 if (read_inferior_memory (base
, &byte
, 1) != 0)
1947 return (unsigned long long) -1;
1949 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ byte
) & 255];
1952 return (unsigned long long) crc
;
1955 /* Add supported btrace packets to BUF. */
1958 supported_btrace_packets (char *buf
)
1960 int btrace_supported
= 0;
1962 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1964 strcat (buf
, ";Qbtrace:bts+");
1965 strcat (buf
, ";Qbtrace-conf:bts:size+");
1967 btrace_supported
= 1;
1970 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1972 strcat (buf
, ";Qbtrace:pt+");
1973 strcat (buf
, ";Qbtrace-conf:pt:size+");
1975 btrace_supported
= 1;
1978 if (!btrace_supported
)
1981 strcat (buf
, ";Qbtrace:off+");
1982 strcat (buf
, ";qXfer:btrace:read+");
1983 strcat (buf
, ";qXfer:btrace-conf:read+");
1986 /* Handle all of the extended 'q' packets. */
1989 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1991 static struct inferior_list_entry
*thread_ptr
;
1993 /* Reply the current thread id. */
1994 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1997 require_running (own_buf
);
1999 if (!ptid_equal (general_thread
, null_ptid
)
2000 && !ptid_equal (general_thread
, minus_one_ptid
))
2001 gdb_id
= general_thread
;
2004 thread_ptr
= get_first_inferior (&all_threads
);
2005 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2008 sprintf (own_buf
, "QC");
2010 write_ptid (own_buf
, gdb_id
);
2014 if (strcmp ("qSymbol::", own_buf
) == 0)
2016 struct thread_info
*save_thread
= current_thread
;
2018 /* For qSymbol, GDB only changes the current thread if the
2019 previous current thread was of a different process. So if
2020 the previous thread is gone, we need to pick another one of
2021 the same process. This can happen e.g., if we followed an
2022 exec in a non-leader thread. */
2023 if (current_thread
== NULL
)
2026 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2028 /* Just in case, if we didn't find a thread, then bail out
2029 instead of crashing. */
2030 if (current_thread
== NULL
)
2032 write_enn (own_buf
);
2033 current_thread
= save_thread
;
2038 /* GDB is suggesting new symbols have been loaded. This may
2039 mean a new shared library has been detected as loaded, so
2040 take the opportunity to check if breakpoints we think are
2041 inserted, still are. Note that it isn't guaranteed that
2042 we'll see this when a shared library is loaded, and nor will
2043 we see this for unloads (although breakpoints in unloaded
2044 libraries shouldn't trigger), as GDB may not find symbols for
2045 the library at all. We also re-validate breakpoints when we
2046 see a second GDB breakpoint for the same address, and or when
2047 we access breakpoint shadows. */
2048 validate_breakpoints ();
2050 if (target_supports_tracepoints ())
2051 tracepoint_look_up_symbols ();
2053 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2054 (*the_target
->look_up_symbols
) ();
2056 current_thread
= save_thread
;
2058 strcpy (own_buf
, "OK");
2062 if (!disable_packet_qfThreadInfo
)
2064 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2068 require_running (own_buf
);
2069 thread_ptr
= get_first_inferior (&all_threads
);
2072 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2073 write_ptid (own_buf
, gdb_id
);
2074 thread_ptr
= thread_ptr
->next
;
2078 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2082 require_running (own_buf
);
2083 if (thread_ptr
!= NULL
)
2086 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2087 write_ptid (own_buf
, gdb_id
);
2088 thread_ptr
= thread_ptr
->next
;
2093 sprintf (own_buf
, "l");
2099 if (the_target
->read_offsets
!= NULL
2100 && strcmp ("qOffsets", own_buf
) == 0)
2102 CORE_ADDR text
, data
;
2104 require_running (own_buf
);
2105 if (the_target
->read_offsets (&text
, &data
))
2106 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2107 (long)text
, (long)data
, (long)data
);
2109 write_enn (own_buf
);
2114 /* Protocol features query. */
2115 if (startswith (own_buf
, "qSupported")
2116 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2118 char *p
= &own_buf
[10];
2119 int gdb_supports_qRelocInsn
= 0;
2121 /* Process each feature being provided by GDB. The first
2122 feature will follow a ':', and latter features will follow
2126 char **qsupported
= NULL
;
2131 /* Two passes, to avoid nested strtok calls in
2132 target_process_qsupported. */
2133 for (p
= strtok (p
+ 1, ";");
2135 p
= strtok (NULL
, ";"))
2138 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2139 qsupported
[count
- 1] = xstrdup (p
);
2142 for (i
= 0; i
< count
; i
++)
2145 if (strcmp (p
, "multiprocess+") == 0)
2147 /* GDB supports and wants multi-process support if
2149 if (target_supports_multi_process ())
2152 else if (strcmp (p
, "qRelocInsn+") == 0)
2154 /* GDB supports relocate instruction requests. */
2155 gdb_supports_qRelocInsn
= 1;
2157 else if (strcmp (p
, "swbreak+") == 0)
2159 /* GDB wants us to report whether a trap is caused
2160 by a software breakpoint and for us to handle PC
2161 adjustment if necessary on this target. */
2162 if (target_supports_stopped_by_sw_breakpoint ())
2163 swbreak_feature
= 1;
2165 else if (strcmp (p
, "hwbreak+") == 0)
2167 /* GDB wants us to report whether a trap is caused
2168 by a hardware breakpoint. */
2169 if (target_supports_stopped_by_hw_breakpoint ())
2170 hwbreak_feature
= 1;
2172 else if (strcmp (p
, "fork-events+") == 0)
2174 /* GDB supports and wants fork events if possible. */
2175 if (target_supports_fork_events ())
2176 report_fork_events
= 1;
2178 else if (strcmp (p
, "vfork-events+") == 0)
2180 /* GDB supports and wants vfork events if possible. */
2181 if (target_supports_vfork_events ())
2182 report_vfork_events
= 1;
2184 else if (strcmp (p
, "exec-events+") == 0)
2186 /* GDB supports and wants exec events if possible. */
2187 if (target_supports_exec_events ())
2188 report_exec_events
= 1;
2190 else if (strcmp (p
, "vContSupported+") == 0)
2191 vCont_supported
= 1;
2192 else if (strcmp (p
, "QThreadEvents+") == 0)
2194 else if (strcmp (p
, "no-resumed+") == 0)
2196 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2198 report_no_resumed
= 1;
2202 /* Move the unknown features all together. */
2203 qsupported
[i
] = NULL
;
2204 qsupported
[unknown
] = p
;
2209 /* Give the target backend a chance to process the unknown
2211 target_process_qsupported (qsupported
, unknown
);
2213 for (i
= 0; i
< count
; i
++)
2214 free (qsupported
[i
]);
2219 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2222 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2223 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2224 ";augmented-libraries-svr4-read+");
2227 /* We do not have any hook to indicate whether the non-SVR4 target
2228 backend supports qXfer:libraries:read, so always report it. */
2229 strcat (own_buf
, ";qXfer:libraries:read+");
2232 if (the_target
->read_auxv
!= NULL
)
2233 strcat (own_buf
, ";qXfer:auxv:read+");
2235 if (the_target
->qxfer_spu
!= NULL
)
2236 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2238 if (the_target
->qxfer_siginfo
!= NULL
)
2239 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2241 if (the_target
->read_loadmap
!= NULL
)
2242 strcat (own_buf
, ";qXfer:fdpic:read+");
2244 /* We always report qXfer:features:read, as targets may
2245 install XML files on a subsequent call to arch_setup.
2246 If we reported to GDB on startup that we don't support
2247 qXfer:feature:read at all, we will never be re-queried. */
2248 strcat (own_buf
, ";qXfer:features:read+");
2250 if (transport_is_reliable
)
2251 strcat (own_buf
, ";QStartNoAckMode+");
2253 if (the_target
->qxfer_osdata
!= NULL
)
2254 strcat (own_buf
, ";qXfer:osdata:read+");
2256 if (target_supports_multi_process ())
2257 strcat (own_buf
, ";multiprocess+");
2259 if (target_supports_fork_events ())
2260 strcat (own_buf
, ";fork-events+");
2262 if (target_supports_vfork_events ())
2263 strcat (own_buf
, ";vfork-events+");
2265 if (target_supports_exec_events ())
2266 strcat (own_buf
, ";exec-events+");
2268 if (target_supports_non_stop ())
2269 strcat (own_buf
, ";QNonStop+");
2271 if (target_supports_disable_randomization ())
2272 strcat (own_buf
, ";QDisableRandomization+");
2274 strcat (own_buf
, ";qXfer:threads:read+");
2276 if (target_supports_tracepoints ())
2278 strcat (own_buf
, ";ConditionalTracepoints+");
2279 strcat (own_buf
, ";TraceStateVariables+");
2280 strcat (own_buf
, ";TracepointSource+");
2281 strcat (own_buf
, ";DisconnectedTracing+");
2282 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2283 strcat (own_buf
, ";FastTracepoints+");
2284 strcat (own_buf
, ";StaticTracepoints+");
2285 strcat (own_buf
, ";InstallInTrace+");
2286 strcat (own_buf
, ";qXfer:statictrace:read+");
2287 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2288 strcat (own_buf
, ";EnableDisableTracepoints+");
2289 strcat (own_buf
, ";QTBuffer:size+");
2290 strcat (own_buf
, ";tracenz+");
2293 if (target_supports_hardware_single_step ()
2294 || target_supports_software_single_step () )
2296 strcat (own_buf
, ";ConditionalBreakpoints+");
2298 strcat (own_buf
, ";BreakpointCommands+");
2300 if (target_supports_agent ())
2301 strcat (own_buf
, ";QAgent+");
2303 supported_btrace_packets (own_buf
);
2305 if (target_supports_stopped_by_sw_breakpoint ())
2306 strcat (own_buf
, ";swbreak+");
2308 if (target_supports_stopped_by_hw_breakpoint ())
2309 strcat (own_buf
, ";hwbreak+");
2311 if (the_target
->pid_to_exec_file
!= NULL
)
2312 strcat (own_buf
, ";qXfer:exec-file:read+");
2314 strcat (own_buf
, ";vContSupported+");
2316 strcat (own_buf
, ";QThreadEvents+");
2318 strcat (own_buf
, ";no-resumed+");
2320 /* Reinitialize components as needed for the new connection. */
2321 hostio_handle_new_gdb_connection ();
2322 target_handle_new_gdb_connection ();
2327 /* Thread-local storage support. */
2328 if (the_target
->get_tls_address
!= NULL
2329 && startswith (own_buf
, "qGetTLSAddr:"))
2331 char *p
= own_buf
+ 12;
2332 CORE_ADDR parts
[2], address
= 0;
2334 ptid_t ptid
= null_ptid
;
2336 require_running (own_buf
);
2338 for (i
= 0; i
< 3; i
++)
2346 p2
= strchr (p
, ',');
2359 ptid
= read_ptid (p
, NULL
);
2361 decode_address (&parts
[i
- 1], p
, len
);
2365 if (p
!= NULL
|| i
< 3)
2369 struct thread_info
*thread
= find_thread_ptid (ptid
);
2374 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2380 strcpy (own_buf
, paddress(address
));
2385 write_enn (own_buf
);
2389 /* Otherwise, pretend we do not understand this packet. */
2392 /* Windows OS Thread Information Block address support. */
2393 if (the_target
->get_tib_address
!= NULL
2394 && startswith (own_buf
, "qGetTIBAddr:"))
2399 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2401 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2404 strcpy (own_buf
, paddress(tlb
));
2409 write_enn (own_buf
);
2415 /* Handle "monitor" commands. */
2416 if (startswith (own_buf
, "qRcmd,"))
2418 char *mon
= (char *) malloc (PBUFSIZ
);
2419 int len
= strlen (own_buf
+ 6);
2423 write_enn (own_buf
);
2428 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2430 write_enn (own_buf
);
2434 mon
[len
/ 2] = '\0';
2438 if (the_target
->handle_monitor_command
== NULL
2439 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2440 /* Default processing. */
2441 handle_monitor_command (mon
, own_buf
);
2447 if (startswith (own_buf
, "qSearch:memory:"))
2449 require_running (own_buf
);
2450 handle_search_memory (own_buf
, packet_len
);
2454 if (strcmp (own_buf
, "qAttached") == 0
2455 || startswith (own_buf
, "qAttached:"))
2457 struct process_info
*process
;
2459 if (own_buf
[sizeof ("qAttached") - 1])
2461 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2462 process
= (struct process_info
*)
2463 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2467 require_running (own_buf
);
2468 process
= current_process ();
2471 if (process
== NULL
)
2473 write_enn (own_buf
);
2477 strcpy (own_buf
, process
->attached
? "1" : "0");
2481 if (startswith (own_buf
, "qCRC:"))
2483 /* CRC check (compare-section). */
2487 unsigned long long crc
;
2489 require_running (own_buf
);
2490 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2491 if (*comma
++ != ',')
2493 write_enn (own_buf
);
2496 len
= strtoul (comma
, NULL
, 16);
2497 crc
= crc32 (base
, len
, 0xffffffff);
2498 /* Check for memory failure. */
2499 if (crc
== (unsigned long long) -1)
2501 write_enn (own_buf
);
2504 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2508 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2511 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2514 /* Otherwise we didn't know what packet it was. Say we didn't
2519 static void gdb_wants_all_threads_stopped (void);
2520 static void resume (struct thread_resume
*actions
, size_t n
);
2522 /* The callback that is passed to visit_actioned_threads. */
2523 typedef int (visit_actioned_threads_callback_ftype
)
2524 (const struct thread_resume
*, struct thread_info
*);
2526 /* Struct to pass data to visit_actioned_threads. */
2528 struct visit_actioned_threads_data
2530 const struct thread_resume
*actions
;
2532 visit_actioned_threads_callback_ftype
*callback
;
2535 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2536 true if CALLBACK returns true. Returns false if no matching thread
2537 is found or CALLBACK results false.
2538 Note: This function is itself a callback for find_inferior. */
2541 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2543 struct visit_actioned_threads_data
*data
2544 = (struct visit_actioned_threads_data
*) datap
;
2545 const struct thread_resume
*actions
= data
->actions
;
2546 size_t num_actions
= data
->num_actions
;
2547 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2550 for (i
= 0; i
< num_actions
; i
++)
2552 const struct thread_resume
*action
= &actions
[i
];
2554 if (ptid_equal (action
->thread
, minus_one_ptid
)
2555 || ptid_equal (action
->thread
, entry
->id
)
2556 || ((ptid_get_pid (action
->thread
)
2557 == ptid_get_pid (entry
->id
))
2558 && ptid_get_lwp (action
->thread
) == -1))
2560 struct thread_info
*thread
= (struct thread_info
*) entry
;
2562 if ((*callback
) (action
, thread
))
2570 /* Callback for visit_actioned_threads. If the thread has a pending
2571 status to report, report it now. */
2574 handle_pending_status (const struct thread_resume
*resumption
,
2575 struct thread_info
*thread
)
2577 if (thread
->status_pending_p
)
2579 thread
->status_pending_p
= 0;
2581 last_status
= thread
->last_status
;
2582 last_ptid
= thread
->entry
.id
;
2583 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2589 /* Parse vCont packets. */
2591 handle_v_cont (char *own_buf
)
2595 struct thread_resume
*resume_info
;
2596 struct thread_resume default_action
= {{0}};
2598 /* Count the number of semicolons in the packet. There should be one
2599 for every action. */
2605 p
= strchr (p
, ';');
2608 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2609 if (resume_info
== NULL
)
2617 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2619 if (p
[0] == 's' || p
[0] == 'S')
2620 resume_info
[i
].kind
= resume_step
;
2621 else if (p
[0] == 'r')
2622 resume_info
[i
].kind
= resume_step
;
2623 else if (p
[0] == 'c' || p
[0] == 'C')
2624 resume_info
[i
].kind
= resume_continue
;
2625 else if (p
[0] == 't')
2626 resume_info
[i
].kind
= resume_stop
;
2630 if (p
[0] == 'S' || p
[0] == 'C')
2633 sig
= strtol (p
+ 1, &q
, 16);
2638 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2640 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2642 else if (p
[0] == 'r')
2646 p
= unpack_varlen_hex (p
+ 1, &addr
);
2647 resume_info
[i
].step_range_start
= addr
;
2652 p
= unpack_varlen_hex (p
+ 1, &addr
);
2653 resume_info
[i
].step_range_end
= addr
;
2662 resume_info
[i
].thread
= minus_one_ptid
;
2663 default_action
= resume_info
[i
];
2665 /* Note: we don't increment i here, we'll overwrite this entry
2666 the next time through. */
2668 else if (p
[0] == ':')
2670 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2675 if (p
[0] != ';' && p
[0] != 0)
2678 resume_info
[i
].thread
= ptid
;
2685 resume_info
[i
] = default_action
;
2687 resume (resume_info
, n
);
2692 write_enn (own_buf
);
2697 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2700 resume (struct thread_resume
*actions
, size_t num_actions
)
2704 /* Check if among the threads that GDB wants actioned, there's
2705 one with a pending status to report. If so, skip actually
2706 resuming/stopping and report the pending event
2708 struct visit_actioned_threads_data data
;
2710 data
.actions
= actions
;
2711 data
.num_actions
= num_actions
;
2712 data
.callback
= handle_pending_status
;
2713 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2719 (*the_target
->resume
) (actions
, num_actions
);
2725 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2727 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2728 && !report_no_resumed
)
2730 /* The client does not support this stop reply. At least
2732 sprintf (own_buf
, "E.No unwaited-for children left.");
2733 disable_async_io ();
2737 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2738 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2739 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2740 current_thread
->last_status
= last_status
;
2742 /* From the client's perspective, all-stop mode always stops all
2743 threads implicitly (and the target backend has already done
2744 so by now). Tag all threads as "want-stopped", so we don't
2745 resume them implicitly without the client telling us to. */
2746 gdb_wants_all_threads_stopped ();
2747 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2748 disable_async_io ();
2750 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2751 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2752 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2756 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2758 handle_v_attach (char *own_buf
)
2762 pid
= strtol (own_buf
+ 8, NULL
, 16);
2763 if (pid
!= 0 && attach_inferior (pid
) == 0)
2765 /* Don't report shared library events after attaching, even if
2766 some libraries are preloaded. GDB will always poll the
2767 library list. Avoids the "stopped by shared library event"
2768 notice on the GDB side. */
2773 /* In non-stop, we don't send a resume reply. Stop events
2774 will follow up using the normal notification
2779 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2785 write_enn (own_buf
);
2790 /* Run a new program. Return 1 if successful, 0 if failure. */
2792 handle_v_run (char *own_buf
)
2794 char *p
, *next_p
, **new_argv
;
2798 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2804 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2805 if (new_argv
== NULL
)
2807 write_enn (own_buf
);
2812 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2814 next_p
= strchr (p
, ';');
2816 next_p
= p
+ strlen (p
);
2818 if (i
== 0 && p
== next_p
)
2822 /* FIXME: Fail request if out of memory instead of dying. */
2823 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2824 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2825 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2834 if (new_argv
[0] == NULL
)
2836 /* GDB didn't specify a program to run. Use the program from the
2837 last run with the new argument list. */
2839 if (program_argv
== NULL
)
2841 write_enn (own_buf
);
2842 freeargv (new_argv
);
2846 new_argv
[0] = strdup (program_argv
[0]);
2847 if (new_argv
[0] == NULL
)
2849 write_enn (own_buf
);
2850 freeargv (new_argv
);
2855 /* Free the old argv and install the new one. */
2856 freeargv (program_argv
);
2857 program_argv
= new_argv
;
2859 start_inferior (program_argv
);
2860 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2862 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2864 /* In non-stop, sending a resume reply doesn't set the general
2865 thread, but GDB assumes a vRun sets it (this is so GDB can
2866 query which is the main thread of the new inferior. */
2868 general_thread
= last_ptid
;
2874 write_enn (own_buf
);
2879 /* Kill process. Return 1 if successful, 0 if failure. */
2881 handle_v_kill (char *own_buf
)
2884 char *p
= &own_buf
[6];
2886 pid
= strtol (p
, NULL
, 16);
2889 if (pid
!= 0 && kill_inferior (pid
) == 0)
2891 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2892 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2893 last_ptid
= pid_to_ptid (pid
);
2894 discard_queued_stop_replies (last_ptid
);
2900 write_enn (own_buf
);
2905 /* Handle all of the extended 'v' packets. */
2907 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2909 if (!disable_packet_vCont
)
2911 if (strcmp (own_buf
, "vCtrlC") == 0)
2913 (*the_target
->request_interrupt
) ();
2918 if (startswith (own_buf
, "vCont;"))
2920 require_running (own_buf
);
2921 handle_v_cont (own_buf
);
2925 if (startswith (own_buf
, "vCont?"))
2927 strcpy (own_buf
, "vCont;c;C;t");
2929 if (target_supports_hardware_single_step () || !vCont_supported
)
2931 /* If target supports hardware single step, add actions s
2932 and S to the list of supported actions. On the other
2933 hand, if GDB doesn't request the supported vCont actions
2934 in qSupported packet, add s and S to the list too. */
2935 own_buf
= own_buf
+ strlen (own_buf
);
2936 strcpy (own_buf
, ";s;S");
2939 if (target_supports_range_stepping ())
2941 own_buf
= own_buf
+ strlen (own_buf
);
2942 strcpy (own_buf
, ";r");
2948 if (startswith (own_buf
, "vFile:")
2949 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2952 if (startswith (own_buf
, "vAttach;"))
2954 if ((!extended_protocol
|| !multi_process
) && target_running ())
2956 fprintf (stderr
, "Already debugging a process\n");
2957 write_enn (own_buf
);
2960 handle_v_attach (own_buf
);
2964 if (startswith (own_buf
, "vRun;"))
2966 if ((!extended_protocol
|| !multi_process
) && target_running ())
2968 fprintf (stderr
, "Already debugging a process\n");
2969 write_enn (own_buf
);
2972 handle_v_run (own_buf
);
2976 if (startswith (own_buf
, "vKill;"))
2978 if (!target_running ())
2980 fprintf (stderr
, "No process to kill\n");
2981 write_enn (own_buf
);
2984 handle_v_kill (own_buf
);
2988 if (handle_notif_ack (own_buf
, packet_len
))
2991 /* Otherwise we didn't know what packet it was. Say we didn't
2997 /* Resume thread and wait for another event. In non-stop mode,
2998 don't really wait here, but return immediatelly to the event
3001 myresume (char *own_buf
, int step
, int sig
)
3003 struct thread_resume resume_info
[2];
3005 int valid_cont_thread
;
3007 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3008 && !ptid_equal (cont_thread
, minus_one_ptid
));
3010 if (step
|| sig
|| valid_cont_thread
)
3012 resume_info
[0].thread
= current_ptid
;
3014 resume_info
[0].kind
= resume_step
;
3016 resume_info
[0].kind
= resume_continue
;
3017 resume_info
[0].sig
= sig
;
3021 if (!valid_cont_thread
)
3023 resume_info
[n
].thread
= minus_one_ptid
;
3024 resume_info
[n
].kind
= resume_continue
;
3025 resume_info
[n
].sig
= 0;
3029 resume (resume_info
, n
);
3032 /* Callback for for_each_inferior. Make a new stop reply for each
3036 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3038 struct thread_info
*thread
= (struct thread_info
*) entry
;
3040 /* For now, assume targets that don't have this callback also don't
3041 manage the thread's last_status field. */
3042 if (the_target
->thread_stopped
== NULL
)
3044 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3046 new_notif
->ptid
= entry
->id
;
3047 new_notif
->status
= thread
->last_status
;
3048 /* Pass the last stop reply back to GDB, but don't notify
3050 notif_event_enque (¬if_stop
,
3051 (struct notif_event
*) new_notif
);
3055 if (thread_stopped (thread
))
3060 = target_waitstatus_to_string (&thread
->last_status
);
3062 debug_printf ("Reporting thread %s as already stopped with %s\n",
3063 target_pid_to_str (entry
->id
),
3066 xfree (status_string
);
3069 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3071 /* Pass the last stop reply back to GDB, but don't notify
3073 queue_stop_reply (entry
->id
, &thread
->last_status
);
3080 /* Set this inferior threads's state as "want-stopped". We won't
3081 resume this thread until the client gives us another action for
3085 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3087 struct thread_info
*thread
= (struct thread_info
*) entry
;
3089 thread
->last_resume_kind
= resume_stop
;
3091 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3093 /* Most threads are stopped implicitly (all-stop); tag that with
3095 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3096 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3100 /* Set all threads' states as "want-stopped". */
3103 gdb_wants_all_threads_stopped (void)
3105 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3108 /* Clear the gdb_detached flag of every process. */
3111 gdb_reattached_process (struct inferior_list_entry
*entry
)
3113 struct process_info
*process
= (struct process_info
*) entry
;
3115 process
->gdb_detached
= 0;
3118 /* Callback for for_each_inferior. Clear the thread's pending status
3122 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3124 struct thread_info
*thread
= (struct thread_info
*) entry
;
3126 thread
->status_pending_p
= 0;
3129 /* Callback for for_each_inferior. If the thread is stopped with an
3130 interesting event, mark it as having a pending event. */
3133 set_pending_status_callback (struct inferior_list_entry
*entry
)
3135 struct thread_info
*thread
= (struct thread_info
*) entry
;
3137 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3138 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3139 /* A breakpoint, watchpoint or finished step from a previous
3140 GDB run isn't considered interesting for a new GDB run.
3141 If we left those pending, the new GDB could consider them
3142 random SIGTRAPs. This leaves out real async traps. We'd
3143 have to peek into the (target-specific) siginfo to
3144 distinguish those. */
3145 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3146 thread
->status_pending_p
= 1;
3149 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3150 pending status to report to GDB. */
3153 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3155 struct thread_info
*thread
= (struct thread_info
*) entry
;
3157 return thread
->status_pending_p
;
3160 /* Status handler for the '?' packet. */
3163 handle_status (char *own_buf
)
3165 /* GDB is connected, don't forward events to the target anymore. */
3166 for_each_inferior (&all_processes
, gdb_reattached_process
);
3168 /* In non-stop mode, we must send a stop reply for each stopped
3169 thread. In all-stop mode, just send one for the first stopped
3174 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3176 /* The first is sent immediatly. OK is sent if there is no
3177 stopped thread, which is the same handling of the vStopped
3178 packet (by design). */
3179 notif_write_event (¬if_stop
, own_buf
);
3183 struct inferior_list_entry
*thread
= NULL
;
3186 stabilize_threads ();
3187 gdb_wants_all_threads_stopped ();
3189 /* We can only report one status, but we might be coming out of
3190 non-stop -- if more than one thread is stopped with
3191 interesting events, leave events for the threads we're not
3192 reporting now pending. They'll be reported the next time the
3193 threads are resumed. Start by marking all interesting events
3195 for_each_inferior (&all_threads
, set_pending_status_callback
);
3197 /* Prefer the last thread that reported an event to GDB (even if
3198 that was a GDB_SIGNAL_TRAP). */
3199 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3200 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3201 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3202 thread
= find_inferior_id (&all_threads
, last_ptid
);
3204 /* If the last event thread is not found for some reason, look
3205 for some other thread that might have an event to report. */
3207 thread
= find_inferior (&all_threads
,
3208 find_status_pending_thread_callback
, NULL
);
3210 /* If we're still out of luck, simply pick the first thread in
3213 thread
= get_first_inferior (&all_threads
);
3217 struct thread_info
*tp
= (struct thread_info
*) thread
;
3219 /* We're reporting this event, so it's no longer
3221 tp
->status_pending_p
= 0;
3223 /* GDB assumes the current thread is the thread we're
3224 reporting the status for. */
3225 general_thread
= thread
->id
;
3226 set_desired_thread (1);
3228 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3229 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3232 strcpy (own_buf
, "W00");
3237 gdbserver_version (void)
3239 printf ("GNU gdbserver %s%s\n"
3240 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3241 "gdbserver is free software, covered by the "
3242 "GNU General Public License.\n"
3243 "This gdbserver was configured as \"%s\"\n",
3244 PKGVERSION
, version
, host_name
);
3248 gdbserver_usage (FILE *stream
)
3250 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3251 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3252 "\tgdbserver [OPTIONS] --multi COMM\n"
3254 "COMM may either be a tty device (for serial debugging),\n"
3255 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3256 "stdin/stdout of gdbserver.\n"
3257 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3258 "PID is the process ID to attach to, when --attach is specified.\n"
3260 "Operating modes:\n"
3262 " --attach Attach to running process PID.\n"
3263 " --multi Start server without a specific program, and\n"
3264 " only quit when explicitly commanded.\n"
3265 " --once Exit after the first connection has closed.\n"
3266 " --help Print this message and then exit.\n"
3267 " --version Display version information and exit.\n"
3271 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3272 " --disable-randomization\n"
3273 " Run PROG with address space randomization disabled.\n"
3274 " --no-disable-randomization\n"
3275 " Don't disable address space randomization when\n"
3280 " --debug Enable general debugging output.\n"
3281 " --debug-format=opt1[,opt2,...]\n"
3282 " Specify extra content in debugging output.\n"
3287 " --remote-debug Enable remote protocol debugging output.\n"
3288 " --disable-packet=opt1[,opt2,...]\n"
3289 " Disable support for RSP packets or features.\n"
3291 " vCont, Tthread, qC, qfThreadInfo and \n"
3292 " threads (disable all threading packets).\n"
3294 "For more information, consult the GDB manual (available as on-line \n"
3295 "info or a printed manual).\n");
3296 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3297 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3301 gdbserver_show_disableable (FILE *stream
)
3303 fprintf (stream
, "Disableable packets:\n"
3304 " vCont \tAll vCont packets\n"
3305 " qC \tQuerying the current thread\n"
3306 " qfThreadInfo\tThread listing\n"
3307 " Tthread \tPassing the thread specifier in the "
3308 "T stop reply packet\n"
3309 " threads \tAll of the above\n");
3313 #undef require_running
3314 #define require_running(BUF) \
3315 if (!target_running ()) \
3322 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3324 int pid
= * (int *) args
;
3326 if (ptid_get_pid (entry
->id
) == pid
)
3333 kill_inferior_callback (struct inferior_list_entry
*entry
)
3335 struct process_info
*process
= (struct process_info
*) entry
;
3336 int pid
= ptid_get_pid (process
->entry
.id
);
3338 kill_inferior (pid
);
3339 discard_queued_stop_replies (pid_to_ptid (pid
));
3342 /* Callback for for_each_inferior to detach or kill the inferior,
3343 depending on whether we attached to it or not.
3344 We inform the user whether we're detaching or killing the process
3345 as this is only called when gdbserver is about to exit. */
3348 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3350 struct process_info
*process
= (struct process_info
*) entry
;
3351 int pid
= ptid_get_pid (process
->entry
.id
);
3353 if (process
->attached
)
3354 detach_inferior (pid
);
3356 kill_inferior (pid
);
3358 discard_queued_stop_replies (pid_to_ptid (pid
));
3361 /* for_each_inferior callback for detach_or_kill_for_exit to print
3362 the pids of started inferiors. */
3365 print_started_pid (struct inferior_list_entry
*entry
)
3367 struct process_info
*process
= (struct process_info
*) entry
;
3369 if (! process
->attached
)
3371 int pid
= ptid_get_pid (process
->entry
.id
);
3372 fprintf (stderr
, " %d", pid
);
3376 /* for_each_inferior callback for detach_or_kill_for_exit to print
3377 the pids of attached inferiors. */
3380 print_attached_pid (struct inferior_list_entry
*entry
)
3382 struct process_info
*process
= (struct process_info
*) entry
;
3384 if (process
->attached
)
3386 int pid
= ptid_get_pid (process
->entry
.id
);
3387 fprintf (stderr
, " %d", pid
);
3391 /* Call this when exiting gdbserver with possible inferiors that need
3392 to be killed or detached from. */
3395 detach_or_kill_for_exit (void)
3397 /* First print a list of the inferiors we will be killing/detaching.
3398 This is to assist the user, for example, in case the inferior unexpectedly
3399 dies after we exit: did we screw up or did the inferior exit on its own?
3400 Having this info will save some head-scratching. */
3402 if (have_started_inferiors_p ())
3404 fprintf (stderr
, "Killing process(es):");
3405 for_each_inferior (&all_processes
, print_started_pid
);
3406 fprintf (stderr
, "\n");
3408 if (have_attached_inferiors_p ())
3410 fprintf (stderr
, "Detaching process(es):");
3411 for_each_inferior (&all_processes
, print_attached_pid
);
3412 fprintf (stderr
, "\n");
3415 /* Now we can kill or detach the inferiors. */
3417 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3420 /* Value that will be passed to exit(3) when gdbserver exits. */
3421 static int exit_code
;
3423 /* Cleanup version of detach_or_kill_for_exit. */
3426 detach_or_kill_for_exit_cleanup (void *ignore
)
3431 detach_or_kill_for_exit ();
3434 CATCH (exception
, RETURN_MASK_ALL
)
3437 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3443 /* Main function. This is called by the real "main" function,
3444 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3446 static void ATTRIBUTE_NORETURN
3447 captured_main (int argc
, char *argv
[])
3451 char *arg_end
, *port
;
3452 char **next_arg
= &argv
[1];
3453 volatile int multi_mode
= 0;
3454 volatile int attach
= 0;
3457 while (*next_arg
!= NULL
&& **next_arg
== '-')
3459 if (strcmp (*next_arg
, "--version") == 0)
3461 gdbserver_version ();
3464 else if (strcmp (*next_arg
, "--help") == 0)
3466 gdbserver_usage (stdout
);
3469 else if (strcmp (*next_arg
, "--attach") == 0)
3471 else if (strcmp (*next_arg
, "--multi") == 0)
3473 else if (strcmp (*next_arg
, "--wrapper") == 0)
3477 wrapper_argv
= next_arg
;
3478 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3481 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3483 gdbserver_usage (stderr
);
3487 /* Consume the "--". */
3490 else if (strcmp (*next_arg
, "--debug") == 0)
3492 else if (startswith (*next_arg
, "--debug-format="))
3495 = parse_debug_format_options ((*next_arg
)
3496 + sizeof ("--debug-format=") - 1, 0);
3498 if (error_msg
!= NULL
)
3500 fprintf (stderr
, "%s", error_msg
);
3504 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3506 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3508 gdbserver_show_disableable (stdout
);
3511 else if (startswith (*next_arg
, "--disable-packet="))
3513 char *packets
, *tok
;
3515 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3516 for (tok
= strtok (packets
, ",");
3518 tok
= strtok (NULL
, ","))
3520 if (strcmp ("vCont", tok
) == 0)
3521 disable_packet_vCont
= 1;
3522 else if (strcmp ("Tthread", tok
) == 0)
3523 disable_packet_Tthread
= 1;
3524 else if (strcmp ("qC", tok
) == 0)
3525 disable_packet_qC
= 1;
3526 else if (strcmp ("qfThreadInfo", tok
) == 0)
3527 disable_packet_qfThreadInfo
= 1;
3528 else if (strcmp ("threads", tok
) == 0)
3530 disable_packet_vCont
= 1;
3531 disable_packet_Tthread
= 1;
3532 disable_packet_qC
= 1;
3533 disable_packet_qfThreadInfo
= 1;
3537 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3539 gdbserver_show_disableable (stderr
);
3544 else if (strcmp (*next_arg
, "-") == 0)
3546 /* "-" specifies a stdio connection and is a form of port
3548 *next_arg
= STDIO_CONNECTION_NAME
;
3551 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3552 disable_randomization
= 1;
3553 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3554 disable_randomization
= 0;
3555 else if (strcmp (*next_arg
, "--once") == 0)
3559 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3569 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3571 gdbserver_usage (stderr
);
3575 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3576 opened by remote_prepare. */
3579 /* We need to know whether the remote connection is stdio before
3580 starting the inferior. Inferiors created in this scenario have
3581 stdin,stdout redirected. So do this here before we call
3583 remote_prepare (port
);
3588 /* --attach used to come after PORT, so allow it there for
3590 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3597 && (*next_arg
== NULL
3598 || (*next_arg
)[0] == '\0'
3599 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3601 || next_arg
[1] != NULL
))
3606 gdbserver_usage (stderr
);
3610 initialize_async_io ();
3612 initialize_event_loop ();
3613 if (target_supports_tracepoints ())
3614 initialize_tracepoint ();
3615 initialize_notif ();
3617 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3618 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3620 if (pid
== 0 && *next_arg
!= NULL
)
3624 n
= argc
- (next_arg
- argv
);
3625 program_argv
= XNEWVEC (char *, n
+ 1);
3626 for (i
= 0; i
< n
; i
++)
3627 program_argv
[i
] = xstrdup (next_arg
[i
]);
3628 program_argv
[i
] = NULL
;
3630 /* Wait till we are at first instruction in program. */
3631 start_inferior (program_argv
);
3633 /* We are now (hopefully) stopped at the first instruction of
3634 the target process. This assumes that the target process was
3635 successfully created. */
3639 if (attach_inferior (pid
) == -1)
3640 error ("Attaching not supported on this target");
3642 /* Otherwise succeeded. */
3646 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3647 last_status
.value
.integer
= 0;
3648 last_ptid
= minus_one_ptid
;
3650 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3652 /* Don't report shared library events on the initial connection,
3653 even if some libraries are preloaded. Avoids the "stopped by
3654 shared library event" notice on gdb side. */
3657 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3658 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3663 if (!was_running
&& !multi_mode
)
3664 error ("No program to debug");
3671 report_fork_events
= 0;
3672 report_vfork_events
= 0;
3673 report_exec_events
= 0;
3674 /* Be sure we're out of tfind mode. */
3675 current_traceframe
= -1;
3676 cont_thread
= null_ptid
;
3677 swbreak_feature
= 0;
3678 hwbreak_feature
= 0;
3679 vCont_supported
= 0;
3685 /* Wait for events. This will return when all event sources
3686 are removed from the event loop. */
3687 start_event_loop ();
3689 /* If an exit was requested (using the "monitor exit"
3690 command), terminate now. */
3692 throw_quit ("Quit");
3694 /* The only other way to get here is for getpkt to fail:
3696 - If --once was specified, we're done.
3698 - If not in extended-remote mode, and we're no longer
3699 debugging anything, simply exit: GDB has disconnected
3700 after processing the last process exit.
3702 - Otherwise, close the connection and reopen it at the
3704 if (run_once
|| (!extended_protocol
&& !target_running ()))
3705 throw_quit ("Quit");
3708 "Remote side has terminated connection. "
3709 "GDBserver will reopen the connection.\n");
3711 /* Get rid of any pending statuses. An eventual reconnection
3712 (by the same GDB instance or another) will refresh all its
3713 state from scratch. */
3714 discard_queued_stop_replies (minus_one_ptid
);
3715 for_each_inferior (&all_threads
,
3716 clear_pending_status_callback
);
3720 if (disconnected_tracing
)
3722 /* Try to enable non-stop/async mode, so we we can
3723 both wait for an async socket accept, and handle
3724 async target events simultaneously. There's also
3725 no point either in having the target always stop
3726 all threads, when we're going to pass signals
3727 down without informing GDB. */
3730 if (start_non_stop (1))
3733 /* Detaching implicitly resumes all threads;
3734 simply disconnecting does not. */
3740 "Disconnected tracing disabled; "
3741 "stopping trace run.\n");
3746 CATCH (exception
, RETURN_MASK_ERROR
)
3749 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3751 if (response_needed
)
3753 write_enn (own_buf
);
3758 throw_quit ("Quit");
3764 /* Main function. */
3767 main (int argc
, char *argv
[])
3772 captured_main (argc
, argv
);
3774 CATCH (exception
, RETURN_MASK_ALL
)
3776 if (exception
.reason
== RETURN_ERROR
)
3779 fprintf (stderr
, "%s\n", exception
.message
);
3780 fprintf (stderr
, "Exiting\n");
3788 gdb_assert_not_reached ("captured_main should never return");
3791 /* Skip PACKET until the next semi-colon (or end of string). */
3794 skip_to_semicolon (char **packet
)
3796 while (**packet
!= '\0' && **packet
!= ';')
3800 /* Process options coming from Z packets for a breakpoint. PACKET is
3801 the packet buffer. *PACKET is updated to point to the first char
3802 after the last processed option. */
3805 process_point_options (struct breakpoint
*bp
, char **packet
)
3807 char *dataptr
= *packet
;
3810 /* Check if data has the correct format. */
3811 if (*dataptr
!= ';')
3818 if (*dataptr
== ';')
3821 if (*dataptr
== 'X')
3823 /* Conditional expression. */
3825 debug_printf ("Found breakpoint condition.\n");
3826 if (!add_breakpoint_condition (bp
, &dataptr
))
3827 skip_to_semicolon (&dataptr
);
3829 else if (startswith (dataptr
, "cmds:"))
3831 dataptr
+= strlen ("cmds:");
3833 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3834 persist
= (*dataptr
== '1');
3836 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3837 skip_to_semicolon (&dataptr
);
3841 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3843 /* Skip tokens until we find one that we recognize. */
3844 skip_to_semicolon (&dataptr
);
3850 /* Event loop callback that handles a serial event. The first byte in
3851 the serial buffer gets us here. We expect characters to arrive at
3852 a brisk pace, so we read the rest of the packet with a blocking
3856 process_serial_event (void)
3867 int new_packet_len
= -1;
3869 disable_async_io ();
3871 response_needed
= 0;
3872 packet_len
= getpkt (own_buf
);
3873 if (packet_len
<= 0)
3876 /* Force an event loop break. */
3879 response_needed
= 1;
3886 handle_query (own_buf
, packet_len
, &new_packet_len
);
3889 handle_general_set (own_buf
);
3892 require_running (own_buf
);
3897 pid
= strtol (&own_buf
[i
], NULL
, 16);
3900 pid
= ptid_get_pid (current_ptid
);
3902 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3904 struct thread_resume resume_info
;
3905 struct process_info
*process
= find_process_pid (pid
);
3907 if (process
== NULL
)
3909 write_enn (own_buf
);
3913 if (tracing
&& disconnected_tracing
)
3915 "Disconnected tracing in effect, "
3916 "leaving gdbserver attached to the process\n");
3918 if (any_persistent_commands ())
3920 "Persistent commands are present, "
3921 "leaving gdbserver attached to the process\n");
3923 /* Make sure we're in non-stop/async mode, so we we can both
3924 wait for an async socket accept, and handle async target
3925 events simultaneously. There's also no point either in
3926 having the target stop all threads, when we're going to
3927 pass signals down without informing GDB. */
3931 debug_printf ("Forcing non-stop mode\n");
3937 process
->gdb_detached
= 1;
3939 /* Detaching implicitly resumes all threads. */
3940 resume_info
.thread
= minus_one_ptid
;
3941 resume_info
.kind
= resume_continue
;
3942 resume_info
.sig
= 0;
3943 (*the_target
->resume
) (&resume_info
, 1);
3946 break; /* from switch/case */
3949 fprintf (stderr
, "Detaching from process %d\n", pid
);
3951 if (detach_inferior (pid
) != 0)
3952 write_enn (own_buf
);
3955 discard_queued_stop_replies (pid_to_ptid (pid
));
3958 if (extended_protocol
|| target_running ())
3960 /* There is still at least one inferior remaining or
3961 we are in extended mode, so don't terminate gdbserver,
3962 and instead treat this like a normal program exit. */
3963 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3964 last_status
.value
.integer
= 0;
3965 last_ptid
= pid_to_ptid (pid
);
3967 current_thread
= NULL
;
3974 /* If we are attached, then we can exit. Otherwise, we
3975 need to hang around doing nothing, until the child is
3977 join_inferior (pid
);
3983 extended_protocol
= 1;
3987 handle_status (own_buf
);
3990 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3992 ptid_t gdb_id
, thread_id
;
3995 require_running (own_buf
);
3997 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3999 pid
= ptid_get_pid (gdb_id
);
4001 if (ptid_equal (gdb_id
, null_ptid
)
4002 || ptid_equal (gdb_id
, minus_one_ptid
))
4003 thread_id
= null_ptid
;
4005 && ptid_equal (pid_to_ptid (pid
),
4008 struct thread_info
*thread
=
4009 (struct thread_info
*) find_inferior (&all_threads
,
4014 write_enn (own_buf
);
4018 thread_id
= thread
->entry
.id
;
4022 thread_id
= gdb_id_to_thread_id (gdb_id
);
4023 if (ptid_equal (thread_id
, null_ptid
))
4025 write_enn (own_buf
);
4030 if (own_buf
[1] == 'g')
4032 if (ptid_equal (thread_id
, null_ptid
))
4034 /* GDB is telling us to choose any thread. Check if
4035 the currently selected thread is still valid. If
4036 it is not, select the first available. */
4037 struct thread_info
*thread
=
4038 (struct thread_info
*) find_inferior_id (&all_threads
,
4041 thread
= get_first_thread ();
4042 thread_id
= thread
->entry
.id
;
4045 general_thread
= thread_id
;
4046 set_desired_thread (1);
4047 gdb_assert (current_thread
!= NULL
);
4049 else if (own_buf
[1] == 'c')
4050 cont_thread
= thread_id
;
4056 /* Silently ignore it so that gdb can extend the protocol
4057 without compatibility headaches. */
4062 require_running (own_buf
);
4063 if (current_traceframe
>= 0)
4065 struct regcache
*regcache
4066 = new_register_cache (current_target_desc ());
4068 if (fetch_traceframe_registers (current_traceframe
,
4070 registers_to_string (regcache
, own_buf
);
4072 write_enn (own_buf
);
4073 free_register_cache (regcache
);
4077 struct regcache
*regcache
;
4079 if (!set_desired_thread (1))
4080 write_enn (own_buf
);
4083 regcache
= get_thread_regcache (current_thread
, 1);
4084 registers_to_string (regcache
, own_buf
);
4089 require_running (own_buf
);
4090 if (current_traceframe
>= 0)
4091 write_enn (own_buf
);
4094 struct regcache
*regcache
;
4096 if (!set_desired_thread (1))
4097 write_enn (own_buf
);
4100 regcache
= get_thread_regcache (current_thread
, 1);
4101 registers_from_string (regcache
, &own_buf
[1]);
4107 require_running (own_buf
);
4108 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4109 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4111 write_enn (own_buf
);
4113 bin2hex (mem_buf
, own_buf
, res
);
4116 require_running (own_buf
);
4117 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4118 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4121 write_enn (own_buf
);
4124 require_running (own_buf
);
4125 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4126 &mem_addr
, &len
, &mem_buf
) < 0
4127 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4128 write_enn (own_buf
);
4133 require_running (own_buf
);
4134 hex2bin (own_buf
+ 1, &sig
, 1);
4135 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4136 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4139 myresume (own_buf
, 0, signal
);
4142 require_running (own_buf
);
4143 hex2bin (own_buf
+ 1, &sig
, 1);
4144 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4145 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4148 myresume (own_buf
, 1, signal
);
4151 require_running (own_buf
);
4153 myresume (own_buf
, 0, signal
);
4156 require_running (own_buf
);
4158 myresume (own_buf
, 1, signal
);
4160 case 'Z': /* insert_ ... */
4162 case 'z': /* remove_ ... */
4167 char type
= own_buf
[1];
4169 const int insert
= ch
== 'Z';
4170 char *p
= &own_buf
[3];
4172 p
= unpack_varlen_hex (p
, &addr
);
4173 kind
= strtol (p
+ 1, &dataptr
, 16);
4177 struct breakpoint
*bp
;
4179 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4184 /* GDB may have sent us a list of *point parameters to
4185 be evaluated on the target's side. Read such list
4186 here. If we already have a list of parameters, GDB
4187 is telling us to drop that list and use this one
4189 clear_breakpoint_conditions_and_commands (bp
);
4190 process_point_options (bp
, &dataptr
);
4194 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4202 write_enn (own_buf
);
4206 response_needed
= 0;
4207 if (!target_running ())
4208 /* The packet we received doesn't make sense - but we can't
4209 reply to it, either. */
4212 fprintf (stderr
, "Killing all inferiors\n");
4213 for_each_inferior (&all_processes
, kill_inferior_callback
);
4215 /* When using the extended protocol, we wait with no program
4216 running. The traditional protocol will exit instead. */
4217 if (extended_protocol
)
4219 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4220 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4228 ptid_t gdb_id
, thread_id
;
4230 require_running (own_buf
);
4232 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4233 thread_id
= gdb_id_to_thread_id (gdb_id
);
4234 if (ptid_equal (thread_id
, null_ptid
))
4236 write_enn (own_buf
);
4240 if (mythread_alive (thread_id
))
4243 write_enn (own_buf
);
4247 response_needed
= 0;
4249 /* Restarting the inferior is only supported in the extended
4251 if (extended_protocol
)
4253 if (target_running ())
4254 for_each_inferior (&all_processes
,
4255 kill_inferior_callback
);
4256 fprintf (stderr
, "GDBserver restarting\n");
4258 /* Wait till we are at 1st instruction in prog. */
4259 if (program_argv
!= NULL
)
4261 start_inferior (program_argv
);
4262 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4264 /* Stopped at the first instruction of the target
4266 general_thread
= last_ptid
;
4270 /* Something went wrong. */
4271 general_thread
= null_ptid
;
4276 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4277 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4283 /* It is a request we don't understand. Respond with an
4284 empty packet so that gdb knows that we don't support this
4290 /* Extended (long) request. */
4291 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4295 /* It is a request we don't understand. Respond with an empty
4296 packet so that gdb knows that we don't support this
4302 if (new_packet_len
!= -1)
4303 putpkt_binary (own_buf
, new_packet_len
);
4307 response_needed
= 0;
4315 /* Event-loop callback for serial events. */
4318 handle_serial_event (int err
, gdb_client_data client_data
)
4321 debug_printf ("handling possible serial event\n");
4323 /* Really handle it. */
4324 if (process_serial_event () < 0)
4327 /* Be sure to not change the selected thread behind GDB's back.
4328 Important in the non-stop mode asynchronous protocol. */
4329 set_desired_thread (1);
4334 /* Push a stop notification on the notification queue. */
4337 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4339 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4341 vstop_notif
->status
= *status
;
4342 vstop_notif
->ptid
= ptid
;
4343 /* Push Stop notification. */
4344 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4347 /* Event-loop callback for target events. */
4350 handle_target_event (int err
, gdb_client_data client_data
)
4353 debug_printf ("handling possible target event\n");
4355 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4358 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4360 if (gdb_connected () && report_no_resumed
)
4361 push_stop_notification (null_ptid
, &last_status
);
4363 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4365 int pid
= ptid_get_pid (last_ptid
);
4366 struct process_info
*process
= find_process_pid (pid
);
4367 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4369 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4370 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4372 mark_breakpoints_out (process
);
4373 mourn_inferior (process
);
4375 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4379 /* We're reporting this thread as stopped. Update its
4380 "want-stopped" state to what the client wants, until it
4381 gets a new resume action. */
4382 current_thread
->last_resume_kind
= resume_stop
;
4383 current_thread
->last_status
= last_status
;
4388 if (!target_running ())
4390 /* The last process exited. We're done. */
4394 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4395 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4396 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4400 /* A thread stopped with a signal, but gdb isn't
4401 connected to handle it. Pass it down to the
4402 inferior, as if it wasn't being traced. */
4403 struct thread_resume resume_info
;
4406 debug_printf ("GDB not connected; forwarding event %d for"
4408 (int) last_status
.kind
,
4409 target_pid_to_str (last_ptid
));
4411 resume_info
.thread
= last_ptid
;
4412 resume_info
.kind
= resume_continue
;
4413 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4414 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4416 resume_info
.sig
= 0;
4417 (*the_target
->resume
) (&resume_info
, 1);
4421 push_stop_notification (last_ptid
, &last_status
);
4424 /* Be sure to not change the selected thread behind GDB's back.
4425 Important in the non-stop mode asynchronous protocol. */
4426 set_desired_thread (1);