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 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 ())
2295 /* Support target-side breakpoint conditions and commands.
2296 GDBserver needs to step over the breakpoint if the condition
2297 is false. GDBserver software single step is too simple, so
2298 disable conditional breakpoints if the target doesn't have
2299 hardware single step. */
2300 strcat (own_buf
, ";ConditionalBreakpoints+");
2302 strcat (own_buf
, ";BreakpointCommands+");
2304 if (target_supports_agent ())
2305 strcat (own_buf
, ";QAgent+");
2307 supported_btrace_packets (own_buf
);
2309 if (target_supports_stopped_by_sw_breakpoint ())
2310 strcat (own_buf
, ";swbreak+");
2312 if (target_supports_stopped_by_hw_breakpoint ())
2313 strcat (own_buf
, ";hwbreak+");
2315 if (the_target
->pid_to_exec_file
!= NULL
)
2316 strcat (own_buf
, ";qXfer:exec-file:read+");
2318 strcat (own_buf
, ";vContSupported+");
2320 strcat (own_buf
, ";QThreadEvents+");
2322 strcat (own_buf
, ";no-resumed+");
2324 /* Reinitialize components as needed for the new connection. */
2325 hostio_handle_new_gdb_connection ();
2326 target_handle_new_gdb_connection ();
2331 /* Thread-local storage support. */
2332 if (the_target
->get_tls_address
!= NULL
2333 && startswith (own_buf
, "qGetTLSAddr:"))
2335 char *p
= own_buf
+ 12;
2336 CORE_ADDR parts
[2], address
= 0;
2338 ptid_t ptid
= null_ptid
;
2340 require_running (own_buf
);
2342 for (i
= 0; i
< 3; i
++)
2350 p2
= strchr (p
, ',');
2363 ptid
= read_ptid (p
, NULL
);
2365 decode_address (&parts
[i
- 1], p
, len
);
2369 if (p
!= NULL
|| i
< 3)
2373 struct thread_info
*thread
= find_thread_ptid (ptid
);
2378 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2384 strcpy (own_buf
, paddress(address
));
2389 write_enn (own_buf
);
2393 /* Otherwise, pretend we do not understand this packet. */
2396 /* Windows OS Thread Information Block address support. */
2397 if (the_target
->get_tib_address
!= NULL
2398 && startswith (own_buf
, "qGetTIBAddr:"))
2403 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2405 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2408 strcpy (own_buf
, paddress(tlb
));
2413 write_enn (own_buf
);
2419 /* Handle "monitor" commands. */
2420 if (startswith (own_buf
, "qRcmd,"))
2422 char *mon
= (char *) malloc (PBUFSIZ
);
2423 int len
= strlen (own_buf
+ 6);
2427 write_enn (own_buf
);
2432 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2434 write_enn (own_buf
);
2438 mon
[len
/ 2] = '\0';
2442 if (the_target
->handle_monitor_command
== NULL
2443 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2444 /* Default processing. */
2445 handle_monitor_command (mon
, own_buf
);
2451 if (startswith (own_buf
, "qSearch:memory:"))
2453 require_running (own_buf
);
2454 handle_search_memory (own_buf
, packet_len
);
2458 if (strcmp (own_buf
, "qAttached") == 0
2459 || startswith (own_buf
, "qAttached:"))
2461 struct process_info
*process
;
2463 if (own_buf
[sizeof ("qAttached") - 1])
2465 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2466 process
= (struct process_info
*)
2467 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2471 require_running (own_buf
);
2472 process
= current_process ();
2475 if (process
== NULL
)
2477 write_enn (own_buf
);
2481 strcpy (own_buf
, process
->attached
? "1" : "0");
2485 if (startswith (own_buf
, "qCRC:"))
2487 /* CRC check (compare-section). */
2491 unsigned long long crc
;
2493 require_running (own_buf
);
2494 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2495 if (*comma
++ != ',')
2497 write_enn (own_buf
);
2500 len
= strtoul (comma
, NULL
, 16);
2501 crc
= crc32 (base
, len
, 0xffffffff);
2502 /* Check for memory failure. */
2503 if (crc
== (unsigned long long) -1)
2505 write_enn (own_buf
);
2508 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2512 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2515 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2518 /* Otherwise we didn't know what packet it was. Say we didn't
2523 static void gdb_wants_all_threads_stopped (void);
2524 static void resume (struct thread_resume
*actions
, size_t n
);
2526 /* The callback that is passed to visit_actioned_threads. */
2527 typedef int (visit_actioned_threads_callback_ftype
)
2528 (const struct thread_resume
*, struct thread_info
*);
2530 /* Struct to pass data to visit_actioned_threads. */
2532 struct visit_actioned_threads_data
2534 const struct thread_resume
*actions
;
2536 visit_actioned_threads_callback_ftype
*callback
;
2539 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2540 true if CALLBACK returns true. Returns false if no matching thread
2541 is found or CALLBACK results false.
2542 Note: This function is itself a callback for find_inferior. */
2545 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2547 struct visit_actioned_threads_data
*data
2548 = (struct visit_actioned_threads_data
*) datap
;
2549 const struct thread_resume
*actions
= data
->actions
;
2550 size_t num_actions
= data
->num_actions
;
2551 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2554 for (i
= 0; i
< num_actions
; i
++)
2556 const struct thread_resume
*action
= &actions
[i
];
2558 if (ptid_equal (action
->thread
, minus_one_ptid
)
2559 || ptid_equal (action
->thread
, entry
->id
)
2560 || ((ptid_get_pid (action
->thread
)
2561 == ptid_get_pid (entry
->id
))
2562 && ptid_get_lwp (action
->thread
) == -1))
2564 struct thread_info
*thread
= (struct thread_info
*) entry
;
2566 if ((*callback
) (action
, thread
))
2574 /* Callback for visit_actioned_threads. If the thread has a pending
2575 status to report, report it now. */
2578 handle_pending_status (const struct thread_resume
*resumption
,
2579 struct thread_info
*thread
)
2581 if (thread
->status_pending_p
)
2583 thread
->status_pending_p
= 0;
2585 last_status
= thread
->last_status
;
2586 last_ptid
= thread
->entry
.id
;
2587 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2593 /* Parse vCont packets. */
2595 handle_v_cont (char *own_buf
)
2599 struct thread_resume
*resume_info
;
2600 struct thread_resume default_action
= {{0}};
2602 /* Count the number of semicolons in the packet. There should be one
2603 for every action. */
2609 p
= strchr (p
, ';');
2612 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2613 if (resume_info
== NULL
)
2621 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2623 if (p
[0] == 's' || p
[0] == 'S')
2624 resume_info
[i
].kind
= resume_step
;
2625 else if (p
[0] == 'r')
2626 resume_info
[i
].kind
= resume_step
;
2627 else if (p
[0] == 'c' || p
[0] == 'C')
2628 resume_info
[i
].kind
= resume_continue
;
2629 else if (p
[0] == 't')
2630 resume_info
[i
].kind
= resume_stop
;
2634 if (p
[0] == 'S' || p
[0] == 'C')
2637 sig
= strtol (p
+ 1, &q
, 16);
2642 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2644 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2646 else if (p
[0] == 'r')
2650 p
= unpack_varlen_hex (p
+ 1, &addr
);
2651 resume_info
[i
].step_range_start
= addr
;
2656 p
= unpack_varlen_hex (p
+ 1, &addr
);
2657 resume_info
[i
].step_range_end
= addr
;
2666 resume_info
[i
].thread
= minus_one_ptid
;
2667 default_action
= resume_info
[i
];
2669 /* Note: we don't increment i here, we'll overwrite this entry
2670 the next time through. */
2672 else if (p
[0] == ':')
2674 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2679 if (p
[0] != ';' && p
[0] != 0)
2682 resume_info
[i
].thread
= ptid
;
2689 resume_info
[i
] = default_action
;
2691 resume (resume_info
, n
);
2696 write_enn (own_buf
);
2701 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2704 resume (struct thread_resume
*actions
, size_t num_actions
)
2708 /* Check if among the threads that GDB wants actioned, there's
2709 one with a pending status to report. If so, skip actually
2710 resuming/stopping and report the pending event
2712 struct visit_actioned_threads_data data
;
2714 data
.actions
= actions
;
2715 data
.num_actions
= num_actions
;
2716 data
.callback
= handle_pending_status
;
2717 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2723 (*the_target
->resume
) (actions
, num_actions
);
2729 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2731 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2732 && !report_no_resumed
)
2734 /* The client does not support this stop reply. At least
2736 sprintf (own_buf
, "E.No unwaited-for children left.");
2737 disable_async_io ();
2741 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2742 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2743 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2744 current_thread
->last_status
= last_status
;
2746 /* From the client's perspective, all-stop mode always stops all
2747 threads implicitly (and the target backend has already done
2748 so by now). Tag all threads as "want-stopped", so we don't
2749 resume them implicitly without the client telling us to. */
2750 gdb_wants_all_threads_stopped ();
2751 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2752 disable_async_io ();
2754 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2755 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2756 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2760 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2762 handle_v_attach (char *own_buf
)
2766 pid
= strtol (own_buf
+ 8, NULL
, 16);
2767 if (pid
!= 0 && attach_inferior (pid
) == 0)
2769 /* Don't report shared library events after attaching, even if
2770 some libraries are preloaded. GDB will always poll the
2771 library list. Avoids the "stopped by shared library event"
2772 notice on the GDB side. */
2777 /* In non-stop, we don't send a resume reply. Stop events
2778 will follow up using the normal notification
2783 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2789 write_enn (own_buf
);
2794 /* Run a new program. Return 1 if successful, 0 if failure. */
2796 handle_v_run (char *own_buf
)
2798 char *p
, *next_p
, **new_argv
;
2802 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2808 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2809 if (new_argv
== NULL
)
2811 write_enn (own_buf
);
2816 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2818 next_p
= strchr (p
, ';');
2820 next_p
= p
+ strlen (p
);
2822 if (i
== 0 && p
== next_p
)
2826 /* FIXME: Fail request if out of memory instead of dying. */
2827 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2828 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2829 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2838 if (new_argv
[0] == NULL
)
2840 /* GDB didn't specify a program to run. Use the program from the
2841 last run with the new argument list. */
2843 if (program_argv
== NULL
)
2845 write_enn (own_buf
);
2846 freeargv (new_argv
);
2850 new_argv
[0] = strdup (program_argv
[0]);
2851 if (new_argv
[0] == NULL
)
2853 write_enn (own_buf
);
2854 freeargv (new_argv
);
2859 /* Free the old argv and install the new one. */
2860 freeargv (program_argv
);
2861 program_argv
= new_argv
;
2863 start_inferior (program_argv
);
2864 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2866 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2868 /* In non-stop, sending a resume reply doesn't set the general
2869 thread, but GDB assumes a vRun sets it (this is so GDB can
2870 query which is the main thread of the new inferior. */
2872 general_thread
= last_ptid
;
2878 write_enn (own_buf
);
2883 /* Kill process. Return 1 if successful, 0 if failure. */
2885 handle_v_kill (char *own_buf
)
2888 char *p
= &own_buf
[6];
2890 pid
= strtol (p
, NULL
, 16);
2893 if (pid
!= 0 && kill_inferior (pid
) == 0)
2895 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2896 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2897 last_ptid
= pid_to_ptid (pid
);
2898 discard_queued_stop_replies (last_ptid
);
2904 write_enn (own_buf
);
2909 /* Handle all of the extended 'v' packets. */
2911 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2913 if (!disable_packet_vCont
)
2915 if (strcmp (own_buf
, "vCtrlC") == 0)
2917 (*the_target
->request_interrupt
) ();
2922 if (startswith (own_buf
, "vCont;"))
2924 require_running (own_buf
);
2925 handle_v_cont (own_buf
);
2929 if (startswith (own_buf
, "vCont?"))
2931 strcpy (own_buf
, "vCont;c;C;t");
2933 if (target_supports_hardware_single_step () || !vCont_supported
)
2935 /* If target supports hardware single step, add actions s
2936 and S to the list of supported actions. On the other
2937 hand, if GDB doesn't request the supported vCont actions
2938 in qSupported packet, add s and S to the list too. */
2939 own_buf
= own_buf
+ strlen (own_buf
);
2940 strcpy (own_buf
, ";s;S");
2943 if (target_supports_range_stepping ())
2945 own_buf
= own_buf
+ strlen (own_buf
);
2946 strcpy (own_buf
, ";r");
2952 if (startswith (own_buf
, "vFile:")
2953 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2956 if (startswith (own_buf
, "vAttach;"))
2958 if ((!extended_protocol
|| !multi_process
) && target_running ())
2960 fprintf (stderr
, "Already debugging a process\n");
2961 write_enn (own_buf
);
2964 handle_v_attach (own_buf
);
2968 if (startswith (own_buf
, "vRun;"))
2970 if ((!extended_protocol
|| !multi_process
) && target_running ())
2972 fprintf (stderr
, "Already debugging a process\n");
2973 write_enn (own_buf
);
2976 handle_v_run (own_buf
);
2980 if (startswith (own_buf
, "vKill;"))
2982 if (!target_running ())
2984 fprintf (stderr
, "No process to kill\n");
2985 write_enn (own_buf
);
2988 handle_v_kill (own_buf
);
2992 if (handle_notif_ack (own_buf
, packet_len
))
2995 /* Otherwise we didn't know what packet it was. Say we didn't
3001 /* Resume thread and wait for another event. In non-stop mode,
3002 don't really wait here, but return immediatelly to the event
3005 myresume (char *own_buf
, int step
, int sig
)
3007 struct thread_resume resume_info
[2];
3009 int valid_cont_thread
;
3011 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
3012 && !ptid_equal (cont_thread
, minus_one_ptid
));
3014 if (step
|| sig
|| valid_cont_thread
)
3016 resume_info
[0].thread
= current_ptid
;
3018 resume_info
[0].kind
= resume_step
;
3020 resume_info
[0].kind
= resume_continue
;
3021 resume_info
[0].sig
= sig
;
3025 if (!valid_cont_thread
)
3027 resume_info
[n
].thread
= minus_one_ptid
;
3028 resume_info
[n
].kind
= resume_continue
;
3029 resume_info
[n
].sig
= 0;
3033 resume (resume_info
, n
);
3036 /* Callback for for_each_inferior. Make a new stop reply for each
3040 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3042 struct thread_info
*thread
= (struct thread_info
*) entry
;
3044 /* For now, assume targets that don't have this callback also don't
3045 manage the thread's last_status field. */
3046 if (the_target
->thread_stopped
== NULL
)
3048 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3050 new_notif
->ptid
= entry
->id
;
3051 new_notif
->status
= thread
->last_status
;
3052 /* Pass the last stop reply back to GDB, but don't notify
3054 notif_event_enque (¬if_stop
,
3055 (struct notif_event
*) new_notif
);
3059 if (thread_stopped (thread
))
3064 = target_waitstatus_to_string (&thread
->last_status
);
3066 debug_printf ("Reporting thread %s as already stopped with %s\n",
3067 target_pid_to_str (entry
->id
),
3070 xfree (status_string
);
3073 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3075 /* Pass the last stop reply back to GDB, but don't notify
3077 queue_stop_reply (entry
->id
, &thread
->last_status
);
3084 /* Set this inferior threads's state as "want-stopped". We won't
3085 resume this thread until the client gives us another action for
3089 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3091 struct thread_info
*thread
= (struct thread_info
*) entry
;
3093 thread
->last_resume_kind
= resume_stop
;
3095 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3097 /* Most threads are stopped implicitly (all-stop); tag that with
3099 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3100 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3104 /* Set all threads' states as "want-stopped". */
3107 gdb_wants_all_threads_stopped (void)
3109 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3112 /* Clear the gdb_detached flag of every process. */
3115 gdb_reattached_process (struct inferior_list_entry
*entry
)
3117 struct process_info
*process
= (struct process_info
*) entry
;
3119 process
->gdb_detached
= 0;
3122 /* Callback for for_each_inferior. Clear the thread's pending status
3126 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3128 struct thread_info
*thread
= (struct thread_info
*) entry
;
3130 thread
->status_pending_p
= 0;
3133 /* Callback for for_each_inferior. If the thread is stopped with an
3134 interesting event, mark it as having a pending event. */
3137 set_pending_status_callback (struct inferior_list_entry
*entry
)
3139 struct thread_info
*thread
= (struct thread_info
*) entry
;
3141 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3142 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3143 /* A breakpoint, watchpoint or finished step from a previous
3144 GDB run isn't considered interesting for a new GDB run.
3145 If we left those pending, the new GDB could consider them
3146 random SIGTRAPs. This leaves out real async traps. We'd
3147 have to peek into the (target-specific) siginfo to
3148 distinguish those. */
3149 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3150 thread
->status_pending_p
= 1;
3153 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3154 pending status to report to GDB. */
3157 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3159 struct thread_info
*thread
= (struct thread_info
*) entry
;
3161 return thread
->status_pending_p
;
3164 /* Status handler for the '?' packet. */
3167 handle_status (char *own_buf
)
3169 /* GDB is connected, don't forward events to the target anymore. */
3170 for_each_inferior (&all_processes
, gdb_reattached_process
);
3172 /* In non-stop mode, we must send a stop reply for each stopped
3173 thread. In all-stop mode, just send one for the first stopped
3178 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3180 /* The first is sent immediatly. OK is sent if there is no
3181 stopped thread, which is the same handling of the vStopped
3182 packet (by design). */
3183 notif_write_event (¬if_stop
, own_buf
);
3187 struct inferior_list_entry
*thread
= NULL
;
3190 stabilize_threads ();
3191 gdb_wants_all_threads_stopped ();
3193 /* We can only report one status, but we might be coming out of
3194 non-stop -- if more than one thread is stopped with
3195 interesting events, leave events for the threads we're not
3196 reporting now pending. They'll be reported the next time the
3197 threads are resumed. Start by marking all interesting events
3199 for_each_inferior (&all_threads
, set_pending_status_callback
);
3201 /* Prefer the last thread that reported an event to GDB (even if
3202 that was a GDB_SIGNAL_TRAP). */
3203 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3204 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3205 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3206 thread
= find_inferior_id (&all_threads
, last_ptid
);
3208 /* If the last event thread is not found for some reason, look
3209 for some other thread that might have an event to report. */
3211 thread
= find_inferior (&all_threads
,
3212 find_status_pending_thread_callback
, NULL
);
3214 /* If we're still out of luck, simply pick the first thread in
3217 thread
= get_first_inferior (&all_threads
);
3221 struct thread_info
*tp
= (struct thread_info
*) thread
;
3223 /* We're reporting this event, so it's no longer
3225 tp
->status_pending_p
= 0;
3227 /* GDB assumes the current thread is the thread we're
3228 reporting the status for. */
3229 general_thread
= thread
->id
;
3230 set_desired_thread (1);
3232 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3233 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3236 strcpy (own_buf
, "W00");
3241 gdbserver_version (void)
3243 printf ("GNU gdbserver %s%s\n"
3244 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3245 "gdbserver is free software, covered by the "
3246 "GNU General Public License.\n"
3247 "This gdbserver was configured as \"%s\"\n",
3248 PKGVERSION
, version
, host_name
);
3252 gdbserver_usage (FILE *stream
)
3254 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3255 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3256 "\tgdbserver [OPTIONS] --multi COMM\n"
3258 "COMM may either be a tty device (for serial debugging),\n"
3259 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3260 "stdin/stdout of gdbserver.\n"
3261 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3262 "PID is the process ID to attach to, when --attach is specified.\n"
3264 "Operating modes:\n"
3266 " --attach Attach to running process PID.\n"
3267 " --multi Start server without a specific program, and\n"
3268 " only quit when explicitly commanded.\n"
3269 " --once Exit after the first connection has closed.\n"
3270 " --help Print this message and then exit.\n"
3271 " --version Display version information and exit.\n"
3275 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3276 " --disable-randomization\n"
3277 " Run PROG with address space randomization disabled.\n"
3278 " --no-disable-randomization\n"
3279 " Don't disable address space randomization when\n"
3284 " --debug Enable general debugging output.\n"
3285 " --debug-format=opt1[,opt2,...]\n"
3286 " Specify extra content in debugging output.\n"
3291 " --remote-debug Enable remote protocol debugging output.\n"
3292 " --disable-packet=opt1[,opt2,...]\n"
3293 " Disable support for RSP packets or features.\n"
3295 " vCont, Tthread, qC, qfThreadInfo and \n"
3296 " threads (disable all threading packets).\n"
3298 "For more information, consult the GDB manual (available as on-line \n"
3299 "info or a printed manual).\n");
3300 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3301 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3305 gdbserver_show_disableable (FILE *stream
)
3307 fprintf (stream
, "Disableable packets:\n"
3308 " vCont \tAll vCont packets\n"
3309 " qC \tQuerying the current thread\n"
3310 " qfThreadInfo\tThread listing\n"
3311 " Tthread \tPassing the thread specifier in the "
3312 "T stop reply packet\n"
3313 " threads \tAll of the above\n");
3317 #undef require_running
3318 #define require_running(BUF) \
3319 if (!target_running ()) \
3326 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3328 int pid
= * (int *) args
;
3330 if (ptid_get_pid (entry
->id
) == pid
)
3337 kill_inferior_callback (struct inferior_list_entry
*entry
)
3339 struct process_info
*process
= (struct process_info
*) entry
;
3340 int pid
= ptid_get_pid (process
->entry
.id
);
3342 kill_inferior (pid
);
3343 discard_queued_stop_replies (pid_to_ptid (pid
));
3346 /* Callback for for_each_inferior to detach or kill the inferior,
3347 depending on whether we attached to it or not.
3348 We inform the user whether we're detaching or killing the process
3349 as this is only called when gdbserver is about to exit. */
3352 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3354 struct process_info
*process
= (struct process_info
*) entry
;
3355 int pid
= ptid_get_pid (process
->entry
.id
);
3357 if (process
->attached
)
3358 detach_inferior (pid
);
3360 kill_inferior (pid
);
3362 discard_queued_stop_replies (pid_to_ptid (pid
));
3365 /* for_each_inferior callback for detach_or_kill_for_exit to print
3366 the pids of started inferiors. */
3369 print_started_pid (struct inferior_list_entry
*entry
)
3371 struct process_info
*process
= (struct process_info
*) entry
;
3373 if (! process
->attached
)
3375 int pid
= ptid_get_pid (process
->entry
.id
);
3376 fprintf (stderr
, " %d", pid
);
3380 /* for_each_inferior callback for detach_or_kill_for_exit to print
3381 the pids of attached inferiors. */
3384 print_attached_pid (struct inferior_list_entry
*entry
)
3386 struct process_info
*process
= (struct process_info
*) entry
;
3388 if (process
->attached
)
3390 int pid
= ptid_get_pid (process
->entry
.id
);
3391 fprintf (stderr
, " %d", pid
);
3395 /* Call this when exiting gdbserver with possible inferiors that need
3396 to be killed or detached from. */
3399 detach_or_kill_for_exit (void)
3401 /* First print a list of the inferiors we will be killing/detaching.
3402 This is to assist the user, for example, in case the inferior unexpectedly
3403 dies after we exit: did we screw up or did the inferior exit on its own?
3404 Having this info will save some head-scratching. */
3406 if (have_started_inferiors_p ())
3408 fprintf (stderr
, "Killing process(es):");
3409 for_each_inferior (&all_processes
, print_started_pid
);
3410 fprintf (stderr
, "\n");
3412 if (have_attached_inferiors_p ())
3414 fprintf (stderr
, "Detaching process(es):");
3415 for_each_inferior (&all_processes
, print_attached_pid
);
3416 fprintf (stderr
, "\n");
3419 /* Now we can kill or detach the inferiors. */
3421 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3424 /* Value that will be passed to exit(3) when gdbserver exits. */
3425 static int exit_code
;
3427 /* Cleanup version of detach_or_kill_for_exit. */
3430 detach_or_kill_for_exit_cleanup (void *ignore
)
3435 detach_or_kill_for_exit ();
3438 CATCH (exception
, RETURN_MASK_ALL
)
3441 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3447 /* Main function. This is called by the real "main" function,
3448 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3450 static void ATTRIBUTE_NORETURN
3451 captured_main (int argc
, char *argv
[])
3455 char *arg_end
, *port
;
3456 char **next_arg
= &argv
[1];
3457 volatile int multi_mode
= 0;
3458 volatile int attach
= 0;
3461 while (*next_arg
!= NULL
&& **next_arg
== '-')
3463 if (strcmp (*next_arg
, "--version") == 0)
3465 gdbserver_version ();
3468 else if (strcmp (*next_arg
, "--help") == 0)
3470 gdbserver_usage (stdout
);
3473 else if (strcmp (*next_arg
, "--attach") == 0)
3475 else if (strcmp (*next_arg
, "--multi") == 0)
3477 else if (strcmp (*next_arg
, "--wrapper") == 0)
3481 wrapper_argv
= next_arg
;
3482 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3485 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3487 gdbserver_usage (stderr
);
3491 /* Consume the "--". */
3494 else if (strcmp (*next_arg
, "--debug") == 0)
3496 else if (startswith (*next_arg
, "--debug-format="))
3499 = parse_debug_format_options ((*next_arg
)
3500 + sizeof ("--debug-format=") - 1, 0);
3502 if (error_msg
!= NULL
)
3504 fprintf (stderr
, "%s", error_msg
);
3508 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3510 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3512 gdbserver_show_disableable (stdout
);
3515 else if (startswith (*next_arg
, "--disable-packet="))
3517 char *packets
, *tok
;
3519 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3520 for (tok
= strtok (packets
, ",");
3522 tok
= strtok (NULL
, ","))
3524 if (strcmp ("vCont", tok
) == 0)
3525 disable_packet_vCont
= 1;
3526 else if (strcmp ("Tthread", tok
) == 0)
3527 disable_packet_Tthread
= 1;
3528 else if (strcmp ("qC", tok
) == 0)
3529 disable_packet_qC
= 1;
3530 else if (strcmp ("qfThreadInfo", tok
) == 0)
3531 disable_packet_qfThreadInfo
= 1;
3532 else if (strcmp ("threads", tok
) == 0)
3534 disable_packet_vCont
= 1;
3535 disable_packet_Tthread
= 1;
3536 disable_packet_qC
= 1;
3537 disable_packet_qfThreadInfo
= 1;
3541 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3543 gdbserver_show_disableable (stderr
);
3548 else if (strcmp (*next_arg
, "-") == 0)
3550 /* "-" specifies a stdio connection and is a form of port
3552 *next_arg
= STDIO_CONNECTION_NAME
;
3555 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3556 disable_randomization
= 1;
3557 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3558 disable_randomization
= 0;
3559 else if (strcmp (*next_arg
, "--once") == 0)
3563 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3573 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3575 gdbserver_usage (stderr
);
3579 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3580 opened by remote_prepare. */
3583 /* We need to know whether the remote connection is stdio before
3584 starting the inferior. Inferiors created in this scenario have
3585 stdin,stdout redirected. So do this here before we call
3587 remote_prepare (port
);
3592 /* --attach used to come after PORT, so allow it there for
3594 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3601 && (*next_arg
== NULL
3602 || (*next_arg
)[0] == '\0'
3603 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3605 || next_arg
[1] != NULL
))
3610 gdbserver_usage (stderr
);
3614 initialize_async_io ();
3616 initialize_event_loop ();
3617 if (target_supports_tracepoints ())
3618 initialize_tracepoint ();
3619 initialize_notif ();
3621 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3622 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3624 if (pid
== 0 && *next_arg
!= NULL
)
3628 n
= argc
- (next_arg
- argv
);
3629 program_argv
= XNEWVEC (char *, n
+ 1);
3630 for (i
= 0; i
< n
; i
++)
3631 program_argv
[i
] = xstrdup (next_arg
[i
]);
3632 program_argv
[i
] = NULL
;
3634 /* Wait till we are at first instruction in program. */
3635 start_inferior (program_argv
);
3637 /* We are now (hopefully) stopped at the first instruction of
3638 the target process. This assumes that the target process was
3639 successfully created. */
3643 if (attach_inferior (pid
) == -1)
3644 error ("Attaching not supported on this target");
3646 /* Otherwise succeeded. */
3650 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3651 last_status
.value
.integer
= 0;
3652 last_ptid
= minus_one_ptid
;
3654 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3656 /* Don't report shared library events on the initial connection,
3657 even if some libraries are preloaded. Avoids the "stopped by
3658 shared library event" notice on gdb side. */
3661 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3662 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3667 if (!was_running
&& !multi_mode
)
3668 error ("No program to debug");
3675 report_fork_events
= 0;
3676 report_vfork_events
= 0;
3677 report_exec_events
= 0;
3678 /* Be sure we're out of tfind mode. */
3679 current_traceframe
= -1;
3680 cont_thread
= null_ptid
;
3681 swbreak_feature
= 0;
3682 hwbreak_feature
= 0;
3683 vCont_supported
= 0;
3689 /* Wait for events. This will return when all event sources
3690 are removed from the event loop. */
3691 start_event_loop ();
3693 /* If an exit was requested (using the "monitor exit"
3694 command), terminate now. */
3696 throw_quit ("Quit");
3698 /* The only other way to get here is for getpkt to fail:
3700 - If --once was specified, we're done.
3702 - If not in extended-remote mode, and we're no longer
3703 debugging anything, simply exit: GDB has disconnected
3704 after processing the last process exit.
3706 - Otherwise, close the connection and reopen it at the
3708 if (run_once
|| (!extended_protocol
&& !target_running ()))
3709 throw_quit ("Quit");
3712 "Remote side has terminated connection. "
3713 "GDBserver will reopen the connection.\n");
3715 /* Get rid of any pending statuses. An eventual reconnection
3716 (by the same GDB instance or another) will refresh all its
3717 state from scratch. */
3718 discard_queued_stop_replies (minus_one_ptid
);
3719 for_each_inferior (&all_threads
,
3720 clear_pending_status_callback
);
3724 if (disconnected_tracing
)
3726 /* Try to enable non-stop/async mode, so we we can
3727 both wait for an async socket accept, and handle
3728 async target events simultaneously. There's also
3729 no point either in having the target always stop
3730 all threads, when we're going to pass signals
3731 down without informing GDB. */
3734 if (start_non_stop (1))
3737 /* Detaching implicitly resumes all threads;
3738 simply disconnecting does not. */
3744 "Disconnected tracing disabled; "
3745 "stopping trace run.\n");
3750 CATCH (exception
, RETURN_MASK_ERROR
)
3753 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3755 if (response_needed
)
3757 write_enn (own_buf
);
3762 throw_quit ("Quit");
3768 /* Main function. */
3771 main (int argc
, char *argv
[])
3776 captured_main (argc
, argv
);
3778 CATCH (exception
, RETURN_MASK_ALL
)
3780 if (exception
.reason
== RETURN_ERROR
)
3783 fprintf (stderr
, "%s\n", exception
.message
);
3784 fprintf (stderr
, "Exiting\n");
3792 gdb_assert_not_reached ("captured_main should never return");
3795 /* Skip PACKET until the next semi-colon (or end of string). */
3798 skip_to_semicolon (char **packet
)
3800 while (**packet
!= '\0' && **packet
!= ';')
3804 /* Process options coming from Z packets for a breakpoint. PACKET is
3805 the packet buffer. *PACKET is updated to point to the first char
3806 after the last processed option. */
3809 process_point_options (struct breakpoint
*bp
, char **packet
)
3811 char *dataptr
= *packet
;
3814 /* Check if data has the correct format. */
3815 if (*dataptr
!= ';')
3822 if (*dataptr
== ';')
3825 if (*dataptr
== 'X')
3827 /* Conditional expression. */
3829 debug_printf ("Found breakpoint condition.\n");
3830 if (!add_breakpoint_condition (bp
, &dataptr
))
3831 skip_to_semicolon (&dataptr
);
3833 else if (startswith (dataptr
, "cmds:"))
3835 dataptr
+= strlen ("cmds:");
3837 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3838 persist
= (*dataptr
== '1');
3840 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3841 skip_to_semicolon (&dataptr
);
3845 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3847 /* Skip tokens until we find one that we recognize. */
3848 skip_to_semicolon (&dataptr
);
3854 /* Event loop callback that handles a serial event. The first byte in
3855 the serial buffer gets us here. We expect characters to arrive at
3856 a brisk pace, so we read the rest of the packet with a blocking
3860 process_serial_event (void)
3871 int new_packet_len
= -1;
3873 disable_async_io ();
3875 response_needed
= 0;
3876 packet_len
= getpkt (own_buf
);
3877 if (packet_len
<= 0)
3880 /* Force an event loop break. */
3883 response_needed
= 1;
3890 handle_query (own_buf
, packet_len
, &new_packet_len
);
3893 handle_general_set (own_buf
);
3896 require_running (own_buf
);
3901 pid
= strtol (&own_buf
[i
], NULL
, 16);
3904 pid
= ptid_get_pid (current_ptid
);
3906 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3908 struct thread_resume resume_info
;
3909 struct process_info
*process
= find_process_pid (pid
);
3911 if (process
== NULL
)
3913 write_enn (own_buf
);
3917 if (tracing
&& disconnected_tracing
)
3919 "Disconnected tracing in effect, "
3920 "leaving gdbserver attached to the process\n");
3922 if (any_persistent_commands ())
3924 "Persistent commands are present, "
3925 "leaving gdbserver attached to the process\n");
3927 /* Make sure we're in non-stop/async mode, so we we can both
3928 wait for an async socket accept, and handle async target
3929 events simultaneously. There's also no point either in
3930 having the target stop all threads, when we're going to
3931 pass signals down without informing GDB. */
3935 debug_printf ("Forcing non-stop mode\n");
3941 process
->gdb_detached
= 1;
3943 /* Detaching implicitly resumes all threads. */
3944 resume_info
.thread
= minus_one_ptid
;
3945 resume_info
.kind
= resume_continue
;
3946 resume_info
.sig
= 0;
3947 (*the_target
->resume
) (&resume_info
, 1);
3950 break; /* from switch/case */
3953 fprintf (stderr
, "Detaching from process %d\n", pid
);
3955 if (detach_inferior (pid
) != 0)
3956 write_enn (own_buf
);
3959 discard_queued_stop_replies (pid_to_ptid (pid
));
3962 if (extended_protocol
)
3964 /* Treat this like a normal program exit. */
3965 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3966 last_status
.value
.integer
= 0;
3967 last_ptid
= pid_to_ptid (pid
);
3969 current_thread
= NULL
;
3976 /* If we are attached, then we can exit. Otherwise, we
3977 need to hang around doing nothing, until the child is
3979 join_inferior (pid
);
3985 extended_protocol
= 1;
3989 handle_status (own_buf
);
3992 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3994 ptid_t gdb_id
, thread_id
;
3997 require_running (own_buf
);
3999 gdb_id
= read_ptid (&own_buf
[2], NULL
);
4001 pid
= ptid_get_pid (gdb_id
);
4003 if (ptid_equal (gdb_id
, null_ptid
)
4004 || ptid_equal (gdb_id
, minus_one_ptid
))
4005 thread_id
= null_ptid
;
4007 && ptid_equal (pid_to_ptid (pid
),
4010 struct thread_info
*thread
=
4011 (struct thread_info
*) find_inferior (&all_threads
,
4016 write_enn (own_buf
);
4020 thread_id
= thread
->entry
.id
;
4024 thread_id
= gdb_id_to_thread_id (gdb_id
);
4025 if (ptid_equal (thread_id
, null_ptid
))
4027 write_enn (own_buf
);
4032 if (own_buf
[1] == 'g')
4034 if (ptid_equal (thread_id
, null_ptid
))
4036 /* GDB is telling us to choose any thread. Check if
4037 the currently selected thread is still valid. If
4038 it is not, select the first available. */
4039 struct thread_info
*thread
=
4040 (struct thread_info
*) find_inferior_id (&all_threads
,
4043 thread
= get_first_thread ();
4044 thread_id
= thread
->entry
.id
;
4047 general_thread
= thread_id
;
4048 set_desired_thread (1);
4049 gdb_assert (current_thread
!= NULL
);
4051 else if (own_buf
[1] == 'c')
4052 cont_thread
= thread_id
;
4058 /* Silently ignore it so that gdb can extend the protocol
4059 without compatibility headaches. */
4064 require_running (own_buf
);
4065 if (current_traceframe
>= 0)
4067 struct regcache
*regcache
4068 = new_register_cache (current_target_desc ());
4070 if (fetch_traceframe_registers (current_traceframe
,
4072 registers_to_string (regcache
, own_buf
);
4074 write_enn (own_buf
);
4075 free_register_cache (regcache
);
4079 struct regcache
*regcache
;
4081 if (!set_desired_thread (1))
4082 write_enn (own_buf
);
4085 regcache
= get_thread_regcache (current_thread
, 1);
4086 registers_to_string (regcache
, own_buf
);
4091 require_running (own_buf
);
4092 if (current_traceframe
>= 0)
4093 write_enn (own_buf
);
4096 struct regcache
*regcache
;
4098 if (!set_desired_thread (1))
4099 write_enn (own_buf
);
4102 regcache
= get_thread_regcache (current_thread
, 1);
4103 registers_from_string (regcache
, &own_buf
[1]);
4109 require_running (own_buf
);
4110 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4111 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4113 write_enn (own_buf
);
4115 bin2hex (mem_buf
, own_buf
, res
);
4118 require_running (own_buf
);
4119 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4120 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4123 write_enn (own_buf
);
4126 require_running (own_buf
);
4127 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4128 &mem_addr
, &len
, &mem_buf
) < 0
4129 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4130 write_enn (own_buf
);
4135 require_running (own_buf
);
4136 hex2bin (own_buf
+ 1, &sig
, 1);
4137 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4138 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4141 myresume (own_buf
, 0, signal
);
4144 require_running (own_buf
);
4145 hex2bin (own_buf
+ 1, &sig
, 1);
4146 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4147 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4150 myresume (own_buf
, 1, signal
);
4153 require_running (own_buf
);
4155 myresume (own_buf
, 0, signal
);
4158 require_running (own_buf
);
4160 myresume (own_buf
, 1, signal
);
4162 case 'Z': /* insert_ ... */
4164 case 'z': /* remove_ ... */
4169 char type
= own_buf
[1];
4171 const int insert
= ch
== 'Z';
4172 char *p
= &own_buf
[3];
4174 p
= unpack_varlen_hex (p
, &addr
);
4175 kind
= strtol (p
+ 1, &dataptr
, 16);
4179 struct breakpoint
*bp
;
4181 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4186 /* GDB may have sent us a list of *point parameters to
4187 be evaluated on the target's side. Read such list
4188 here. If we already have a list of parameters, GDB
4189 is telling us to drop that list and use this one
4191 clear_breakpoint_conditions_and_commands (bp
);
4192 process_point_options (bp
, &dataptr
);
4196 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4204 write_enn (own_buf
);
4208 response_needed
= 0;
4209 if (!target_running ())
4210 /* The packet we received doesn't make sense - but we can't
4211 reply to it, either. */
4214 fprintf (stderr
, "Killing all inferiors\n");
4215 for_each_inferior (&all_processes
, kill_inferior_callback
);
4217 /* When using the extended protocol, we wait with no program
4218 running. The traditional protocol will exit instead. */
4219 if (extended_protocol
)
4221 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4222 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4230 ptid_t gdb_id
, thread_id
;
4232 require_running (own_buf
);
4234 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4235 thread_id
= gdb_id_to_thread_id (gdb_id
);
4236 if (ptid_equal (thread_id
, null_ptid
))
4238 write_enn (own_buf
);
4242 if (mythread_alive (thread_id
))
4245 write_enn (own_buf
);
4249 response_needed
= 0;
4251 /* Restarting the inferior is only supported in the extended
4253 if (extended_protocol
)
4255 if (target_running ())
4256 for_each_inferior (&all_processes
,
4257 kill_inferior_callback
);
4258 fprintf (stderr
, "GDBserver restarting\n");
4260 /* Wait till we are at 1st instruction in prog. */
4261 if (program_argv
!= NULL
)
4263 start_inferior (program_argv
);
4264 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4266 /* Stopped at the first instruction of the target
4268 general_thread
= last_ptid
;
4272 /* Something went wrong. */
4273 general_thread
= null_ptid
;
4278 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4279 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4285 /* It is a request we don't understand. Respond with an
4286 empty packet so that gdb knows that we don't support this
4292 /* Extended (long) request. */
4293 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4297 /* It is a request we don't understand. Respond with an empty
4298 packet so that gdb knows that we don't support this
4304 if (new_packet_len
!= -1)
4305 putpkt_binary (own_buf
, new_packet_len
);
4309 response_needed
= 0;
4317 /* Event-loop callback for serial events. */
4320 handle_serial_event (int err
, gdb_client_data client_data
)
4323 debug_printf ("handling possible serial event\n");
4325 /* Really handle it. */
4326 if (process_serial_event () < 0)
4329 /* Be sure to not change the selected thread behind GDB's back.
4330 Important in the non-stop mode asynchronous protocol. */
4331 set_desired_thread (1);
4336 /* Push a stop notification on the notification queue. */
4339 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4341 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4343 vstop_notif
->status
= *status
;
4344 vstop_notif
->ptid
= ptid
;
4345 /* Push Stop notification. */
4346 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4349 /* Event-loop callback for target events. */
4352 handle_target_event (int err
, gdb_client_data client_data
)
4355 debug_printf ("handling possible target event\n");
4357 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4360 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4362 if (gdb_connected () && report_no_resumed
)
4363 push_stop_notification (null_ptid
, &last_status
);
4365 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4367 int pid
= ptid_get_pid (last_ptid
);
4368 struct process_info
*process
= find_process_pid (pid
);
4369 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4371 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4372 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4374 mark_breakpoints_out (process
);
4375 mourn_inferior (process
);
4377 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4381 /* We're reporting this thread as stopped. Update its
4382 "want-stopped" state to what the client wants, until it
4383 gets a new resume action. */
4384 current_thread
->last_resume_kind
= resume_stop
;
4385 current_thread
->last_status
= last_status
;
4390 if (!target_running ())
4392 /* The last process exited. We're done. */
4396 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4397 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4398 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4402 /* A thread stopped with a signal, but gdb isn't
4403 connected to handle it. Pass it down to the
4404 inferior, as if it wasn't being traced. */
4405 struct thread_resume resume_info
;
4408 debug_printf ("GDB not connected; forwarding event %d for"
4410 (int) last_status
.kind
,
4411 target_pid_to_str (last_ptid
));
4413 resume_info
.thread
= last_ptid
;
4414 resume_info
.kind
= resume_continue
;
4415 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4416 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4418 resume_info
.sig
= 0;
4419 (*the_target
->resume
) (&resume_info
, 1);
4423 push_stop_notification (last_ptid
, &last_status
);
4426 /* Be sure to not change the selected thread behind GDB's back.
4427 Important in the non-stop mode asynchronous protocol. */
4428 set_desired_thread (1);