1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2015 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
40 `vCont'. Note the multi-process extensions made `vCont' a
41 requirement, so `Hc pPID.TID' is pretty much undefined. So
42 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
43 resuming all threads of the process (again, `Hc' isn't used for
44 multi-process), or a specific thread ptid_t. */
47 /* The thread set with an `Hg' packet. */
48 ptid_t general_thread
;
52 static int extended_protocol
;
53 static int response_needed
;
54 static int exit_requested
;
56 /* --once: Exit after the first connection has closed. */
60 int report_fork_events
;
61 int report_vfork_events
;
62 int report_exec_events
;
63 int report_thread_events
;
65 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
66 static int report_no_resumed
;
72 /* True if the "vContSupported" feature is active. In that case, GDB
73 wants us to report whether single step is supported in the reply to
75 static int vCont_supported
;
77 /* Whether we should attempt to disable the operating system's address
78 space randomization feature before starting an inferior. */
79 int disable_randomization
= 1;
81 static char **program_argv
, **wrapper_argv
;
83 int pass_signals
[GDB_SIGNAL_LAST
];
84 int program_signals
[GDB_SIGNAL_LAST
];
85 int program_signals_p
;
87 /* The PID of the originally created or attached inferior. Used to
88 send signals to the process when GDB sends us an asynchronous interrupt
89 (user hitting Control-C in the client), and to wait for the child to exit
90 when no longer debugging it. */
92 unsigned long signal_pid
;
95 /* A file descriptor for the controlling terminal. */
98 /* TERMINAL_FD's original foreground group. */
99 pid_t old_foreground_pgrp
;
101 /* Hand back terminal ownership to the original foreground group. */
104 restore_old_foreground_pgrp (void)
106 tcsetpgrp (terminal_fd
, old_foreground_pgrp
);
110 /* Set if you want to disable optional thread related packets support
111 in gdbserver, for the sake of testing GDB against stubs that don't
113 int disable_packet_vCont
;
114 int disable_packet_Tthread
;
115 int disable_packet_qC
;
116 int disable_packet_qfThreadInfo
;
118 /* Last status reported to GDB. */
119 static struct target_waitstatus last_status
;
120 static ptid_t last_ptid
;
122 static char *own_buf
;
123 static unsigned char *mem_buf
;
125 /* A sub-class of 'struct notif_event' for stop, holding information
126 relative to a single stop reply. We keep a queue of these to
127 push to GDB in non-stop mode. */
131 struct notif_event base
;
133 /* Thread or process that got the event. */
137 struct target_waitstatus status
;
140 /* The current btrace configuration. This is gdbserver's mirror of GDB's
141 btrace configuration. */
142 static struct btrace_config current_btrace_conf
;
144 DEFINE_QUEUE_P (notif_event_p
);
146 /* Put a stop reply to the stop reply queue. */
149 queue_stop_reply (ptid_t ptid
, struct target_waitstatus
*status
)
151 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
153 new_notif
->ptid
= ptid
;
154 new_notif
->status
= *status
;
156 notif_event_enque (¬if_stop
, (struct notif_event
*) new_notif
);
160 remove_all_on_match_ptid (QUEUE (notif_event_p
) *q
,
161 QUEUE_ITER (notif_event_p
) *iter
,
162 struct notif_event
*event
,
165 ptid_t filter_ptid
= *(ptid_t
*) data
;
166 struct vstop_notif
*vstop_event
= (struct vstop_notif
*) event
;
168 if (ptid_match (vstop_event
->ptid
, filter_ptid
))
170 if (q
->free_func
!= NULL
)
171 q
->free_func (event
);
173 QUEUE_remove_elem (notif_event_p
, q
, iter
);
182 discard_queued_stop_replies (ptid_t ptid
)
184 QUEUE_iterate (notif_event_p
, notif_stop
.queue
,
185 remove_all_on_match_ptid
, &ptid
);
189 vstop_notif_reply (struct notif_event
*event
, char *own_buf
)
191 struct vstop_notif
*vstop
= (struct vstop_notif
*) event
;
193 prepare_resume_reply (own_buf
, vstop
->ptid
, &vstop
->status
);
196 struct notif_server notif_stop
=
198 "vStopped", "Stop", NULL
, vstop_notif_reply
,
202 target_running (void)
204 return get_first_thread () != NULL
;
208 start_inferior (char **argv
)
210 char **new_argv
= argv
;
212 if (wrapper_argv
!= NULL
)
216 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
218 for (i
= 0; argv
[i
] != NULL
; i
++)
220 new_argv
= XALLOCAVEC (char *, count
);
222 for (i
= 0; wrapper_argv
[i
] != NULL
; i
++)
223 new_argv
[count
++] = wrapper_argv
[i
];
224 for (i
= 0; argv
[i
] != NULL
; i
++)
225 new_argv
[count
++] = argv
[i
];
226 new_argv
[count
] = NULL
;
232 for (i
= 0; new_argv
[i
]; ++i
)
233 debug_printf ("new_argv[%d] = \"%s\"\n", i
, new_argv
[i
]);
238 signal (SIGTTOU
, SIG_DFL
);
239 signal (SIGTTIN
, SIG_DFL
);
242 signal_pid
= create_inferior (new_argv
[0], new_argv
);
244 /* FIXME: we don't actually know at this point that the create
245 actually succeeded. We won't know that until we wait. */
246 fprintf (stderr
, "Process %s created; pid = %ld\n", argv
[0],
251 signal (SIGTTOU
, SIG_IGN
);
252 signal (SIGTTIN
, SIG_IGN
);
253 terminal_fd
= fileno (stderr
);
254 old_foreground_pgrp
= tcgetpgrp (terminal_fd
);
255 tcsetpgrp (terminal_fd
, signal_pid
);
256 atexit (restore_old_foreground_pgrp
);
259 if (wrapper_argv
!= NULL
)
261 struct thread_resume resume_info
;
263 memset (&resume_info
, 0, sizeof (resume_info
));
264 resume_info
.thread
= pid_to_ptid (signal_pid
);
265 resume_info
.kind
= resume_continue
;
268 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
270 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
274 (*the_target
->resume
) (&resume_info
, 1);
276 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
277 if (last_status
.kind
!= TARGET_WAITKIND_STOPPED
)
280 current_thread
->last_resume_kind
= resume_stop
;
281 current_thread
->last_status
= last_status
;
283 while (last_status
.value
.sig
!= GDB_SIGNAL_TRAP
);
285 target_post_create_inferior ();
289 /* Wait till we are at 1st instruction in program, return new pid
290 (assuming success). */
291 last_ptid
= mywait (pid_to_ptid (signal_pid
), &last_status
, 0, 0);
293 target_post_create_inferior ();
295 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
296 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
298 current_thread
->last_resume_kind
= resume_stop
;
299 current_thread
->last_status
= last_status
;
302 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
308 attach_inferior (int pid
)
310 /* myattach should return -1 if attaching is unsupported,
311 0 if it succeeded, and call error() otherwise. */
313 if (myattach (pid
) != 0)
316 fprintf (stderr
, "Attached; pid = %d\n", pid
);
319 /* FIXME - It may be that we should get the SIGNAL_PID from the
320 attach function, so that it can be the main thread instead of
321 whichever we were told to attach to. */
326 last_ptid
= mywait (pid_to_ptid (pid
), &last_status
, 0, 0);
328 /* GDB knows to ignore the first SIGSTOP after attaching to a running
329 process using the "attach" command, but this is different; it's
330 just using "target remote". Pretend it's just starting up. */
331 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
332 && last_status
.value
.sig
== GDB_SIGNAL_STOP
)
333 last_status
.value
.sig
= GDB_SIGNAL_TRAP
;
335 current_thread
->last_resume_kind
= resume_stop
;
336 current_thread
->last_status
= last_status
;
342 extern int remote_debug
;
344 /* Decode a qXfer read request. Return 0 if everything looks OK,
348 decode_xfer_read (char *buf
, CORE_ADDR
*ofs
, unsigned int *len
)
350 /* After the read marker and annex, qXfer looks like a
351 traditional 'm' packet. */
352 decode_m_packet (buf
, ofs
, len
);
358 decode_xfer (char *buf
, char **object
, char **rw
, char **annex
, char **offset
)
360 /* Extract and NUL-terminate the object. */
362 while (*buf
&& *buf
!= ':')
368 /* Extract and NUL-terminate the read/write action. */
370 while (*buf
&& *buf
!= ':')
376 /* Extract and NUL-terminate the annex. */
378 while (*buf
&& *buf
!= ':')
388 /* Write the response to a successful qXfer read. Returns the
389 length of the (binary) data stored in BUF, corresponding
390 to as much of DATA/LEN as we could fit. IS_MORE controls
391 the first character of the response. */
393 write_qxfer_response (char *buf
, const gdb_byte
*data
, int len
, int is_more
)
402 return remote_escape_output (data
, len
, 1, (unsigned char *) buf
+ 1,
403 &out_len
, PBUFSIZ
- 2) + 1;
406 /* Handle btrace enabling in BTS format. */
409 handle_btrace_enable_bts (struct thread_info
*thread
)
411 if (thread
->btrace
!= NULL
)
412 return "E.Btrace already enabled.";
414 current_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
415 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
416 ¤t_btrace_conf
);
417 if (thread
->btrace
== NULL
)
418 return "E.Could not enable btrace.";
423 /* Handle btrace enabling in Intel(R) Processor Trace format. */
426 handle_btrace_enable_pt (struct thread_info
*thread
)
428 if (thread
->btrace
!= NULL
)
429 return "E.Btrace already enabled.";
431 current_btrace_conf
.format
= BTRACE_FORMAT_PT
;
432 thread
->btrace
= target_enable_btrace (thread
->entry
.id
,
433 ¤t_btrace_conf
);
434 if (thread
->btrace
== NULL
)
435 return "E.Could not enable btrace.";
440 /* Handle btrace disabling. */
443 handle_btrace_disable (struct thread_info
*thread
)
446 if (thread
->btrace
== NULL
)
447 return "E.Branch tracing not enabled.";
449 if (target_disable_btrace (thread
->btrace
) != 0)
450 return "E.Could not disable branch tracing.";
452 thread
->btrace
= NULL
;
456 /* Handle the "Qbtrace" packet. */
459 handle_btrace_general_set (char *own_buf
)
461 struct thread_info
*thread
;
465 if (!startswith (own_buf
, "Qbtrace:"))
468 op
= own_buf
+ strlen ("Qbtrace:");
470 if (ptid_equal (general_thread
, null_ptid
)
471 || ptid_equal (general_thread
, minus_one_ptid
))
473 strcpy (own_buf
, "E.Must select a single thread.");
477 thread
= find_thread_ptid (general_thread
);
480 strcpy (own_buf
, "E.No such thread.");
486 if (strcmp (op
, "bts") == 0)
487 err
= handle_btrace_enable_bts (thread
);
488 else if (strcmp (op
, "pt") == 0)
489 err
= handle_btrace_enable_pt (thread
);
490 else if (strcmp (op
, "off") == 0)
491 err
= handle_btrace_disable (thread
);
493 err
= "E.Bad Qbtrace operation. Use bts, pt, or off.";
496 strcpy (own_buf
, err
);
503 /* Handle the "Qbtrace-conf" packet. */
506 handle_btrace_conf_general_set (char *own_buf
)
508 struct thread_info
*thread
;
511 if (!startswith (own_buf
, "Qbtrace-conf:"))
514 op
= own_buf
+ strlen ("Qbtrace-conf:");
516 if (ptid_equal (general_thread
, null_ptid
)
517 || ptid_equal (general_thread
, minus_one_ptid
))
519 strcpy (own_buf
, "E.Must select a single thread.");
523 thread
= find_thread_ptid (general_thread
);
526 strcpy (own_buf
, "E.No such thread.");
530 if (startswith (op
, "bts:size="))
536 size
= strtoul (op
+ strlen ("bts:size="), &endp
, 16);
537 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
539 strcpy (own_buf
, "E.Bad size value.");
543 current_btrace_conf
.bts
.size
= (unsigned int) size
;
545 else if (strncmp (op
, "pt:size=", strlen ("pt:size=")) == 0)
551 size
= strtoul (op
+ strlen ("pt:size="), &endp
, 16);
552 if (endp
== NULL
|| *endp
!= 0 || errno
!= 0 || size
> UINT_MAX
)
554 strcpy (own_buf
, "E.Bad size value.");
558 current_btrace_conf
.pt
.size
= (unsigned int) size
;
562 strcpy (own_buf
, "E.Bad Qbtrace configuration option.");
570 /* Handle all of the extended 'Q' packets. */
573 handle_general_set (char *own_buf
)
575 if (startswith (own_buf
, "QPassSignals:"))
577 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
578 const char *p
= own_buf
+ strlen ("QPassSignals:");
581 p
= decode_address_to_semicolon (&cursig
, p
);
582 for (i
= 0; i
< numsigs
; i
++)
588 /* Keep looping, to clear the remaining signals. */
591 p
= decode_address_to_semicolon (&cursig
, p
);
596 strcpy (own_buf
, "OK");
600 if (startswith (own_buf
, "QProgramSignals:"))
602 int numsigs
= (int) GDB_SIGNAL_LAST
, i
;
603 const char *p
= own_buf
+ strlen ("QProgramSignals:");
606 program_signals_p
= 1;
608 p
= decode_address_to_semicolon (&cursig
, p
);
609 for (i
= 0; i
< numsigs
; i
++)
613 program_signals
[i
] = 1;
615 /* Keep looping, to clear the remaining signals. */
618 p
= decode_address_to_semicolon (&cursig
, p
);
621 program_signals
[i
] = 0;
623 strcpy (own_buf
, "OK");
627 if (strcmp (own_buf
, "QStartNoAckMode") == 0)
631 fprintf (stderr
, "[noack mode enabled]\n");
640 if (startswith (own_buf
, "QNonStop:"))
642 char *mode
= own_buf
+ 9;
646 if (strcmp (mode
, "0") == 0)
648 else if (strcmp (mode
, "1") == 0)
652 /* We don't know what this mode is, so complain to
654 fprintf (stderr
, "Unknown non-stop mode requested: %s\n",
660 req_str
= req
? "non-stop" : "all-stop";
661 if (start_non_stop (req
) != 0)
663 fprintf (stderr
, "Setting %s mode failed\n", req_str
);
671 fprintf (stderr
, "[%s mode enabled]\n", req_str
);
677 if (startswith (own_buf
, "QDisableRandomization:"))
679 char *packet
= own_buf
+ strlen ("QDisableRandomization:");
682 unpack_varlen_hex (packet
, &setting
);
683 disable_randomization
= setting
;
687 if (disable_randomization
)
688 fprintf (stderr
, "[address space randomization disabled]\n");
690 fprintf (stderr
, "[address space randomization enabled]\n");
697 if (target_supports_tracepoints ()
698 && handle_tracepoint_general_set (own_buf
))
701 if (startswith (own_buf
, "QAgent:"))
703 char *mode
= own_buf
+ strlen ("QAgent:");
706 if (strcmp (mode
, "0") == 0)
708 else if (strcmp (mode
, "1") == 0)
712 /* We don't know what this value is, so complain to GDB. */
713 sprintf (own_buf
, "E.Unknown QAgent value");
717 /* Update the flag. */
720 fprintf (stderr
, "[%s agent]\n", req
? "Enable" : "Disable");
725 if (handle_btrace_general_set (own_buf
))
728 if (handle_btrace_conf_general_set (own_buf
))
731 if (startswith (own_buf
, "QThreadEvents:"))
733 char *mode
= own_buf
+ strlen ("QThreadEvents:");
734 enum tribool req
= TRIBOOL_UNKNOWN
;
736 if (strcmp (mode
, "0") == 0)
738 else if (strcmp (mode
, "1") == 0)
742 char *mode_copy
= xstrdup (mode
);
744 /* We don't know what this mode is, so complain to GDB. */
745 sprintf (own_buf
, "E.Unknown thread-events mode requested: %s\n",
751 report_thread_events
= (req
== TRIBOOL_TRUE
);
755 const char *req_str
= report_thread_events
? "enabled" : "disabled";
757 fprintf (stderr
, "[thread events are now %s]\n", req_str
);
764 /* Otherwise we didn't know what packet it was. Say we didn't
770 get_features_xml (const char *annex
)
772 const struct target_desc
*desc
= current_target_desc ();
774 /* `desc->xmltarget' defines what to return when looking for the
775 "target.xml" file. Its contents can either be verbatim XML code
776 (prefixed with a '@') or else the name of the actual XML file to
777 be used in place of "target.xml".
779 This variable is set up from the auto-generated
780 init_registers_... routine for the current target. */
782 if (desc
->xmltarget
!= NULL
&& strcmp (annex
, "target.xml") == 0)
784 if (*desc
->xmltarget
== '@')
785 return desc
->xmltarget
+ 1;
787 annex
= desc
->xmltarget
;
792 extern const char *const xml_builtin
[][2];
795 /* Look for the annex. */
796 for (i
= 0; xml_builtin
[i
][0] != NULL
; i
++)
797 if (strcmp (annex
, xml_builtin
[i
][0]) == 0)
800 if (xml_builtin
[i
][0] != NULL
)
801 return xml_builtin
[i
][1];
809 monitor_show_help (void)
811 monitor_output ("The following monitor commands are supported:\n");
812 monitor_output (" set debug <0|1>\n");
813 monitor_output (" Enable general debugging messages\n");
814 monitor_output (" set debug-hw-points <0|1>\n");
815 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
816 monitor_output (" set remote-debug <0|1>\n");
817 monitor_output (" Enable remote protocol debugging messages\n");
818 monitor_output (" set debug-format option1[,option2,...]\n");
819 monitor_output (" Add additional information to debugging messages\n");
820 monitor_output (" Options: all, none");
821 monitor_output (", timestamp");
822 monitor_output ("\n");
823 monitor_output (" exit\n");
824 monitor_output (" Quit GDBserver\n");
827 /* Read trace frame or inferior memory. Returns the number of bytes
828 actually read, zero when no further transfer is possible, and -1 on
829 error. Return of a positive value smaller than LEN does not
830 indicate there's no more to be read, only the end of the transfer.
831 E.g., when GDB reads memory from a traceframe, a first request may
832 be served from a memory block that does not cover the whole request
833 length. A following request gets the rest served from either
834 another block (of the same traceframe) or from the read-only
838 gdb_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
842 if (current_traceframe
>= 0)
845 ULONGEST length
= len
;
847 if (traceframe_read_mem (current_traceframe
,
848 memaddr
, myaddr
, len
, &nbytes
))
850 /* Data read from trace buffer, we're done. */
853 if (!in_readonly_region (memaddr
, length
))
855 /* Otherwise we have a valid readonly case, fall through. */
856 /* (assume no half-trace half-real blocks for now) */
859 res
= prepare_to_access_memory ();
862 if (set_desired_thread (1))
863 res
= read_inferior_memory (memaddr
, myaddr
, len
);
866 done_accessing_memory ();
868 return res
== 0 ? len
: -1;
874 /* Write trace frame or inferior memory. Actually, writing to trace
875 frames is forbidden. */
878 gdb_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
880 if (current_traceframe
>= 0)
886 ret
= prepare_to_access_memory ();
889 if (set_desired_thread (1))
890 ret
= write_inferior_memory (memaddr
, myaddr
, len
);
893 done_accessing_memory ();
899 /* Subroutine of handle_search_memory to simplify it. */
902 handle_search_memory_1 (CORE_ADDR start_addr
, CORE_ADDR search_space_len
,
903 gdb_byte
*pattern
, unsigned pattern_len
,
904 gdb_byte
*search_buf
,
905 unsigned chunk_size
, unsigned search_buf_size
,
906 CORE_ADDR
*found_addrp
)
908 /* Prime the search buffer. */
910 if (gdb_read_memory (start_addr
, search_buf
, search_buf_size
)
913 warning ("Unable to access %ld bytes of target "
914 "memory at 0x%lx, halting search.",
915 (long) search_buf_size
, (long) start_addr
);
919 /* Perform the search.
921 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
922 When we've scanned N bytes we copy the trailing bytes to the start and
923 read in another N bytes. */
925 while (search_space_len
>= pattern_len
)
928 unsigned nr_search_bytes
= (search_space_len
< search_buf_size
932 found_ptr
= (gdb_byte
*) memmem (search_buf
, nr_search_bytes
, pattern
,
935 if (found_ptr
!= NULL
)
937 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
938 *found_addrp
= found_addr
;
942 /* Not found in this chunk, skip to next chunk. */
944 /* Don't let search_space_len wrap here, it's unsigned. */
945 if (search_space_len
>= chunk_size
)
946 search_space_len
-= chunk_size
;
948 search_space_len
= 0;
950 if (search_space_len
>= pattern_len
)
952 unsigned keep_len
= search_buf_size
- chunk_size
;
953 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
956 /* Copy the trailing part of the previous iteration to the front
957 of the buffer for the next iteration. */
958 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
960 nr_to_read
= (search_space_len
- keep_len
< chunk_size
961 ? search_space_len
- keep_len
964 if (gdb_read_memory (read_addr
, search_buf
+ keep_len
,
965 nr_to_read
) != search_buf_size
)
967 warning ("Unable to access %ld bytes of target memory "
968 "at 0x%lx, halting search.",
969 (long) nr_to_read
, (long) read_addr
);
973 start_addr
+= chunk_size
;
982 /* Handle qSearch:memory packets. */
985 handle_search_memory (char *own_buf
, int packet_len
)
987 CORE_ADDR start_addr
;
988 CORE_ADDR search_space_len
;
990 unsigned int pattern_len
;
991 /* NOTE: also defined in find.c testcase. */
992 #define SEARCH_CHUNK_SIZE 16000
993 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
994 /* Buffer to hold memory contents for searching. */
995 gdb_byte
*search_buf
;
996 unsigned search_buf_size
;
998 CORE_ADDR found_addr
;
999 int cmd_name_len
= sizeof ("qSearch:memory:") - 1;
1001 pattern
= (gdb_byte
*) malloc (packet_len
);
1002 if (pattern
== NULL
)
1004 error ("Unable to allocate memory to perform the search");
1005 strcpy (own_buf
, "E00");
1008 if (decode_search_memory_packet (own_buf
+ cmd_name_len
,
1009 packet_len
- cmd_name_len
,
1010 &start_addr
, &search_space_len
,
1011 pattern
, &pattern_len
) < 0)
1014 error ("Error in parsing qSearch:memory packet");
1015 strcpy (own_buf
, "E00");
1019 search_buf_size
= chunk_size
+ pattern_len
- 1;
1021 /* No point in trying to allocate a buffer larger than the search space. */
1022 if (search_space_len
< search_buf_size
)
1023 search_buf_size
= search_space_len
;
1025 search_buf
= (gdb_byte
*) malloc (search_buf_size
);
1026 if (search_buf
== NULL
)
1029 error ("Unable to allocate memory to perform the search");
1030 strcpy (own_buf
, "E00");
1034 found
= handle_search_memory_1 (start_addr
, search_space_len
,
1035 pattern
, pattern_len
,
1036 search_buf
, chunk_size
, search_buf_size
,
1040 sprintf (own_buf
, "1,%lx", (long) found_addr
);
1041 else if (found
== 0)
1042 strcpy (own_buf
, "0");
1044 strcpy (own_buf
, "E00");
1050 #define require_running(BUF) \
1051 if (!target_running ()) \
1057 /* Parse options to --debug-format= and "monitor set debug-format".
1058 ARG is the text after "--debug-format=" or "monitor set debug-format".
1059 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1060 This triggers calls to monitor_output.
1061 The result is NULL if all options were parsed ok, otherwise an error
1062 message which the caller must free.
1064 N.B. These commands affect all debug format settings, they are not
1065 cumulative. If a format is not specified, it is turned off.
1066 However, we don't go to extra trouble with things like
1067 "monitor set debug-format all,none,timestamp".
1068 Instead we just parse them one at a time, in order.
1070 The syntax for "monitor set debug" we support here is not identical
1071 to gdb's "set debug foo on|off" because we also use this function to
1072 parse "--debug-format=foo,bar". */
1075 parse_debug_format_options (const char *arg
, int is_monitor
)
1077 VEC (char_ptr
) *options
;
1081 /* First turn all debug format options off. */
1082 debug_timestamp
= 0;
1084 /* First remove leading spaces, for "monitor set debug-format". */
1085 while (isspace (*arg
))
1088 options
= delim_string_to_char_ptr_vec (arg
, ',');
1090 for (ix
= 0; VEC_iterate (char_ptr
, options
, ix
, option
); ++ix
)
1092 if (strcmp (option
, "all") == 0)
1094 debug_timestamp
= 1;
1096 monitor_output ("All extra debug format options enabled.\n");
1098 else if (strcmp (option
, "none") == 0)
1100 debug_timestamp
= 0;
1102 monitor_output ("All extra debug format options disabled.\n");
1104 else if (strcmp (option
, "timestamp") == 0)
1106 debug_timestamp
= 1;
1108 monitor_output ("Timestamps will be added to debug output.\n");
1110 else if (*option
== '\0')
1112 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1117 char *msg
= xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1120 free_char_ptr_vec (options
);
1125 free_char_ptr_vec (options
);
1129 /* Handle monitor commands not handled by target-specific handlers. */
1132 handle_monitor_command (char *mon
, char *own_buf
)
1134 if (strcmp (mon
, "set debug 1") == 0)
1137 monitor_output ("Debug output enabled.\n");
1139 else if (strcmp (mon
, "set debug 0") == 0)
1142 monitor_output ("Debug output disabled.\n");
1144 else if (strcmp (mon
, "set debug-hw-points 1") == 0)
1146 show_debug_regs
= 1;
1147 monitor_output ("H/W point debugging output enabled.\n");
1149 else if (strcmp (mon
, "set debug-hw-points 0") == 0)
1151 show_debug_regs
= 0;
1152 monitor_output ("H/W point debugging output disabled.\n");
1154 else if (strcmp (mon
, "set remote-debug 1") == 0)
1157 monitor_output ("Protocol debug output enabled.\n");
1159 else if (strcmp (mon
, "set remote-debug 0") == 0)
1162 monitor_output ("Protocol debug output disabled.\n");
1164 else if (startswith (mon
, "set debug-format "))
1167 = parse_debug_format_options (mon
+ sizeof ("set debug-format ") - 1,
1170 if (error_msg
!= NULL
)
1172 monitor_output (error_msg
);
1173 monitor_show_help ();
1174 write_enn (own_buf
);
1178 else if (strcmp (mon
, "help") == 0)
1179 monitor_show_help ();
1180 else if (strcmp (mon
, "exit") == 0)
1184 monitor_output ("Unknown monitor command.\n\n");
1185 monitor_show_help ();
1186 write_enn (own_buf
);
1190 /* Associates a callback with each supported qXfer'able object. */
1194 /* The object this handler handles. */
1197 /* Request that the target transfer up to LEN 8-bit bytes of the
1198 target's OBJECT. The OFFSET, for a seekable object, specifies
1199 the starting point. The ANNEX can be used to provide additional
1200 data-specific information to the target.
1202 Return the number of bytes actually transfered, zero when no
1203 further transfer is possible, -1 on error, -2 when the transfer
1204 is not supported, and -3 on a verbose error message that should
1205 be preserved. Return of a positive value smaller than LEN does
1206 not indicate the end of the object, only the end of the transfer.
1208 One, and only one, of readbuf or writebuf must be non-NULL. */
1209 int (*xfer
) (const char *annex
,
1210 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1211 ULONGEST offset
, LONGEST len
);
1214 /* Handle qXfer:auxv:read. */
1217 handle_qxfer_auxv (const char *annex
,
1218 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1219 ULONGEST offset
, LONGEST len
)
1221 if (the_target
->read_auxv
== NULL
|| writebuf
!= NULL
)
1224 if (annex
[0] != '\0' || current_thread
== NULL
)
1227 return (*the_target
->read_auxv
) (offset
, readbuf
, len
);
1230 /* Handle qXfer:exec-file:read. */
1233 handle_qxfer_exec_file (const char *const_annex
,
1234 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1235 ULONGEST offset
, LONGEST len
)
1241 if (the_target
->pid_to_exec_file
== NULL
|| writebuf
!= NULL
)
1244 if (const_annex
[0] == '\0')
1246 if (current_thread
== NULL
)
1249 pid
= pid_of (current_thread
);
1253 char *annex
= (char *) alloca (strlen (const_annex
) + 1);
1255 strcpy (annex
, const_annex
);
1256 annex
= unpack_varlen_hex (annex
, &pid
);
1258 if (annex
[0] != '\0')
1265 file
= (*the_target
->pid_to_exec_file
) (pid
);
1269 total_len
= strlen (file
);
1271 if (offset
> total_len
)
1274 if (offset
+ len
> total_len
)
1275 len
= total_len
- offset
;
1277 memcpy (readbuf
, file
+ offset
, len
);
1281 /* Handle qXfer:features:read. */
1284 handle_qxfer_features (const char *annex
,
1285 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1286 ULONGEST offset
, LONGEST len
)
1288 const char *document
;
1291 if (writebuf
!= NULL
)
1294 if (!target_running ())
1297 /* Grab the correct annex. */
1298 document
= get_features_xml (annex
);
1299 if (document
== NULL
)
1302 total_len
= strlen (document
);
1304 if (offset
> total_len
)
1307 if (offset
+ len
> total_len
)
1308 len
= total_len
- offset
;
1310 memcpy (readbuf
, document
+ offset
, len
);
1314 /* Worker routine for handle_qxfer_libraries.
1315 Add to the length pointed to by ARG a conservative estimate of the
1316 length needed to transmit the file name of INF. */
1319 accumulate_file_name_length (struct inferior_list_entry
*inf
, void *arg
)
1321 struct dll_info
*dll
= (struct dll_info
*) inf
;
1322 unsigned int *total_len
= (unsigned int *) arg
;
1324 /* Over-estimate the necessary memory. Assume that every character
1325 in the library name must be escaped. */
1326 *total_len
+= 128 + 6 * strlen (dll
->name
);
1329 /* Worker routine for handle_qxfer_libraries.
1330 Emit the XML to describe the library in INF. */
1333 emit_dll_description (struct inferior_list_entry
*inf
, void *arg
)
1335 struct dll_info
*dll
= (struct dll_info
*) inf
;
1336 char **p_ptr
= (char **) arg
;
1340 strcpy (p
, " <library name=\"");
1342 name
= xml_escape_text (dll
->name
);
1346 strcpy (p
, "\"><segment address=\"");
1348 sprintf (p
, "0x%lx", (long) dll
->base_addr
);
1350 strcpy (p
, "\"/></library>\n");
1356 /* Handle qXfer:libraries:read. */
1359 handle_qxfer_libraries (const char *annex
,
1360 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1361 ULONGEST offset
, LONGEST len
)
1363 unsigned int total_len
;
1366 if (writebuf
!= NULL
)
1369 if (annex
[0] != '\0' || current_thread
== NULL
)
1373 for_each_inferior_with_data (&all_dlls
, accumulate_file_name_length
,
1376 document
= (char *) malloc (total_len
);
1377 if (document
== NULL
)
1380 strcpy (document
, "<library-list version=\"1.0\">\n");
1381 p
= document
+ strlen (document
);
1383 for_each_inferior_with_data (&all_dlls
, emit_dll_description
, &p
);
1385 strcpy (p
, "</library-list>\n");
1387 total_len
= strlen (document
);
1389 if (offset
> total_len
)
1395 if (offset
+ len
> total_len
)
1396 len
= total_len
- offset
;
1398 memcpy (readbuf
, document
+ offset
, len
);
1403 /* Handle qXfer:libraries-svr4:read. */
1406 handle_qxfer_libraries_svr4 (const char *annex
,
1407 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1408 ULONGEST offset
, LONGEST len
)
1410 if (writebuf
!= NULL
)
1413 if (current_thread
== NULL
|| the_target
->qxfer_libraries_svr4
== NULL
)
1416 return the_target
->qxfer_libraries_svr4 (annex
, readbuf
, writebuf
, offset
, len
);
1419 /* Handle qXfer:osadata:read. */
1422 handle_qxfer_osdata (const char *annex
,
1423 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1424 ULONGEST offset
, LONGEST len
)
1426 if (the_target
->qxfer_osdata
== NULL
|| writebuf
!= NULL
)
1429 return (*the_target
->qxfer_osdata
) (annex
, readbuf
, NULL
, offset
, len
);
1432 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1435 handle_qxfer_siginfo (const char *annex
,
1436 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1437 ULONGEST offset
, LONGEST len
)
1439 if (the_target
->qxfer_siginfo
== NULL
)
1442 if (annex
[0] != '\0' || current_thread
== NULL
)
1445 return (*the_target
->qxfer_siginfo
) (annex
, readbuf
, writebuf
, offset
, len
);
1448 /* Handle qXfer:spu:read and qXfer:spu:write. */
1451 handle_qxfer_spu (const char *annex
,
1452 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1453 ULONGEST offset
, LONGEST len
)
1455 if (the_target
->qxfer_spu
== NULL
)
1458 if (current_thread
== NULL
)
1461 return (*the_target
->qxfer_spu
) (annex
, readbuf
, writebuf
, offset
, len
);
1464 /* Handle qXfer:statictrace:read. */
1467 handle_qxfer_statictrace (const char *annex
,
1468 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1469 ULONGEST offset
, LONGEST len
)
1473 if (writebuf
!= NULL
)
1476 if (annex
[0] != '\0' || current_thread
== NULL
|| current_traceframe
== -1)
1479 if (traceframe_read_sdata (current_traceframe
, offset
,
1480 readbuf
, len
, &nbytes
))
1485 /* Helper for handle_qxfer_threads_proper.
1486 Emit the XML to describe the thread of INF. */
1489 handle_qxfer_threads_worker (struct inferior_list_entry
*inf
, void *arg
)
1491 struct thread_info
*thread
= (struct thread_info
*) inf
;
1492 struct buffer
*buffer
= (struct buffer
*) arg
;
1493 ptid_t ptid
= thread_to_gdb_id (thread
);
1495 int core
= target_core_of_thread (ptid
);
1497 const char *name
= target_thread_name (ptid
);
1499 write_ptid (ptid_s
, ptid
);
1501 buffer_xml_printf (buffer
, "<thread id=\"%s\"", ptid_s
);
1505 sprintf (core_s
, "%d", core
);
1506 buffer_xml_printf (buffer
, " core=\"%s\"", core_s
);
1510 buffer_xml_printf (buffer
, " name=\"%s\"", name
);
1512 buffer_xml_printf (buffer
, "/>\n");
1515 /* Helper for handle_qxfer_threads. */
1518 handle_qxfer_threads_proper (struct buffer
*buffer
)
1520 buffer_grow_str (buffer
, "<threads>\n");
1522 for_each_inferior_with_data (&all_threads
, handle_qxfer_threads_worker
,
1525 buffer_grow_str0 (buffer
, "</threads>\n");
1528 /* Handle qXfer:threads:read. */
1531 handle_qxfer_threads (const char *annex
,
1532 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1533 ULONGEST offset
, LONGEST len
)
1535 static char *result
= 0;
1536 static unsigned int result_length
= 0;
1538 if (writebuf
!= NULL
)
1541 if (annex
[0] != '\0')
1546 struct buffer buffer
;
1547 /* When asked for data at offset 0, generate everything and store into
1548 'result'. Successive reads will be served off 'result'. */
1552 buffer_init (&buffer
);
1554 handle_qxfer_threads_proper (&buffer
);
1556 result
= buffer_finish (&buffer
);
1557 result_length
= strlen (result
);
1558 buffer_free (&buffer
);
1561 if (offset
>= result_length
)
1563 /* We're out of data. */
1570 if (len
> result_length
- offset
)
1571 len
= result_length
- offset
;
1573 memcpy (readbuf
, result
+ offset
, len
);
1578 /* Handle qXfer:traceframe-info:read. */
1581 handle_qxfer_traceframe_info (const char *annex
,
1582 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1583 ULONGEST offset
, LONGEST len
)
1585 static char *result
= 0;
1586 static unsigned int result_length
= 0;
1588 if (writebuf
!= NULL
)
1591 if (!target_running () || annex
[0] != '\0' || current_traceframe
== -1)
1596 struct buffer buffer
;
1598 /* When asked for data at offset 0, generate everything and
1599 store into 'result'. Successive reads will be served off
1603 buffer_init (&buffer
);
1605 traceframe_read_info (current_traceframe
, &buffer
);
1607 result
= buffer_finish (&buffer
);
1608 result_length
= strlen (result
);
1609 buffer_free (&buffer
);
1612 if (offset
>= result_length
)
1614 /* We're out of data. */
1621 if (len
> result_length
- offset
)
1622 len
= result_length
- offset
;
1624 memcpy (readbuf
, result
+ offset
, len
);
1628 /* Handle qXfer:fdpic:read. */
1631 handle_qxfer_fdpic (const char *annex
, gdb_byte
*readbuf
,
1632 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1634 if (the_target
->read_loadmap
== NULL
)
1637 if (current_thread
== NULL
)
1640 return (*the_target
->read_loadmap
) (annex
, offset
, readbuf
, len
);
1643 /* Handle qXfer:btrace:read. */
1646 handle_qxfer_btrace (const char *annex
,
1647 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1648 ULONGEST offset
, LONGEST len
)
1650 static struct buffer cache
;
1651 struct thread_info
*thread
;
1652 enum btrace_read_type type
;
1655 if (the_target
->read_btrace
== NULL
|| writebuf
!= NULL
)
1658 if (ptid_equal (general_thread
, null_ptid
)
1659 || ptid_equal (general_thread
, minus_one_ptid
))
1661 strcpy (own_buf
, "E.Must select a single thread.");
1665 thread
= find_thread_ptid (general_thread
);
1668 strcpy (own_buf
, "E.No such thread.");
1672 if (thread
->btrace
== NULL
)
1674 strcpy (own_buf
, "E.Btrace not enabled.");
1678 if (strcmp (annex
, "all") == 0)
1679 type
= BTRACE_READ_ALL
;
1680 else if (strcmp (annex
, "new") == 0)
1681 type
= BTRACE_READ_NEW
;
1682 else if (strcmp (annex
, "delta") == 0)
1683 type
= BTRACE_READ_DELTA
;
1686 strcpy (own_buf
, "E.Bad annex.");
1692 buffer_free (&cache
);
1694 result
= target_read_btrace (thread
->btrace
, &cache
, type
);
1697 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1701 else if (offset
> cache
.used_size
)
1703 buffer_free (&cache
);
1707 if (len
> cache
.used_size
- offset
)
1708 len
= cache
.used_size
- offset
;
1710 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1715 /* Handle qXfer:btrace-conf:read. */
1718 handle_qxfer_btrace_conf (const char *annex
,
1719 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1720 ULONGEST offset
, LONGEST len
)
1722 static struct buffer cache
;
1723 struct thread_info
*thread
;
1726 if (the_target
->read_btrace_conf
== NULL
|| writebuf
!= NULL
)
1729 if (annex
[0] != '\0')
1732 if (ptid_equal (general_thread
, null_ptid
)
1733 || ptid_equal (general_thread
, minus_one_ptid
))
1735 strcpy (own_buf
, "E.Must select a single thread.");
1739 thread
= find_thread_ptid (general_thread
);
1742 strcpy (own_buf
, "E.No such thread.");
1746 if (thread
->btrace
== NULL
)
1748 strcpy (own_buf
, "E.Btrace not enabled.");
1754 buffer_free (&cache
);
1756 result
= target_read_btrace_conf (thread
->btrace
, &cache
);
1759 memcpy (own_buf
, cache
.buffer
, cache
.used_size
);
1763 else if (offset
> cache
.used_size
)
1765 buffer_free (&cache
);
1769 if (len
> cache
.used_size
- offset
)
1770 len
= cache
.used_size
- offset
;
1772 memcpy (readbuf
, cache
.buffer
+ offset
, len
);
1777 static const struct qxfer qxfer_packets
[] =
1779 { "auxv", handle_qxfer_auxv
},
1780 { "btrace", handle_qxfer_btrace
},
1781 { "btrace-conf", handle_qxfer_btrace_conf
},
1782 { "exec-file", handle_qxfer_exec_file
},
1783 { "fdpic", handle_qxfer_fdpic
},
1784 { "features", handle_qxfer_features
},
1785 { "libraries", handle_qxfer_libraries
},
1786 { "libraries-svr4", handle_qxfer_libraries_svr4
},
1787 { "osdata", handle_qxfer_osdata
},
1788 { "siginfo", handle_qxfer_siginfo
},
1789 { "spu", handle_qxfer_spu
},
1790 { "statictrace", handle_qxfer_statictrace
},
1791 { "threads", handle_qxfer_threads
},
1792 { "traceframe-info", handle_qxfer_traceframe_info
},
1796 handle_qxfer (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1804 if (!startswith (own_buf
, "qXfer:"))
1807 /* Grab the object, r/w and annex. */
1808 if (decode_xfer (own_buf
+ 6, &object
, &rw
, &annex
, &offset
) < 0)
1810 write_enn (own_buf
);
1815 i
< sizeof (qxfer_packets
) / sizeof (qxfer_packets
[0]);
1818 const struct qxfer
*q
= &qxfer_packets
[i
];
1820 if (strcmp (object
, q
->object
) == 0)
1822 if (strcmp (rw
, "read") == 0)
1824 unsigned char *data
;
1829 /* Grab the offset and length. */
1830 if (decode_xfer_read (offset
, &ofs
, &len
) < 0)
1832 write_enn (own_buf
);
1836 /* Read one extra byte, as an indicator of whether there is
1838 if (len
> PBUFSIZ
- 2)
1840 data
= (unsigned char *) malloc (len
+ 1);
1843 write_enn (own_buf
);
1846 n
= (*q
->xfer
) (annex
, data
, NULL
, ofs
, len
+ 1);
1854 /* Preserve error message. */
1857 write_enn (own_buf
);
1859 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, len
, 1);
1861 *new_packet_len_p
= write_qxfer_response (own_buf
, data
, n
, 0);
1866 else if (strcmp (rw
, "write") == 0)
1871 unsigned char *data
;
1873 strcpy (own_buf
, "E00");
1874 data
= (unsigned char *) malloc (packet_len
- (offset
- own_buf
));
1877 write_enn (own_buf
);
1880 if (decode_xfer_write (offset
, packet_len
- (offset
- own_buf
),
1881 &ofs
, &len
, data
) < 0)
1884 write_enn (own_buf
);
1888 n
= (*q
->xfer
) (annex
, NULL
, data
, ofs
, len
);
1896 /* Preserve error message. */
1899 write_enn (own_buf
);
1901 sprintf (own_buf
, "%x", n
);
1914 /* Compute 32 bit CRC from inferior memory.
1916 On success, return 32 bit CRC.
1917 On failure, return (unsigned long long) -1. */
1919 static unsigned long long
1920 crc32 (CORE_ADDR base
, int len
, unsigned int crc
)
1924 unsigned char byte
= 0;
1926 /* Return failure if memory read fails. */
1927 if (read_inferior_memory (base
, &byte
, 1) != 0)
1928 return (unsigned long long) -1;
1930 crc
= xcrc32 (&byte
, 1, crc
);
1933 return (unsigned long long) crc
;
1936 /* Add supported btrace packets to BUF. */
1939 supported_btrace_packets (char *buf
)
1941 int btrace_supported
= 0;
1943 if (target_supports_btrace (BTRACE_FORMAT_BTS
))
1945 strcat (buf
, ";Qbtrace:bts+");
1946 strcat (buf
, ";Qbtrace-conf:bts:size+");
1948 btrace_supported
= 1;
1951 if (target_supports_btrace (BTRACE_FORMAT_PT
))
1953 strcat (buf
, ";Qbtrace:pt+");
1954 strcat (buf
, ";Qbtrace-conf:pt:size+");
1956 btrace_supported
= 1;
1959 if (!btrace_supported
)
1962 strcat (buf
, ";Qbtrace:off+");
1963 strcat (buf
, ";qXfer:btrace:read+");
1964 strcat (buf
, ";qXfer:btrace-conf:read+");
1967 /* Handle all of the extended 'q' packets. */
1970 handle_query (char *own_buf
, int packet_len
, int *new_packet_len_p
)
1972 static struct inferior_list_entry
*thread_ptr
;
1974 /* Reply the current thread id. */
1975 if (strcmp ("qC", own_buf
) == 0 && !disable_packet_qC
)
1978 require_running (own_buf
);
1980 if (!ptid_equal (general_thread
, null_ptid
)
1981 && !ptid_equal (general_thread
, minus_one_ptid
))
1982 gdb_id
= general_thread
;
1985 thread_ptr
= get_first_inferior (&all_threads
);
1986 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
1989 sprintf (own_buf
, "QC");
1991 write_ptid (own_buf
, gdb_id
);
1995 if (strcmp ("qSymbol::", own_buf
) == 0)
1997 struct thread_info
*save_thread
= current_thread
;
1999 /* For qSymbol, GDB only changes the current thread if the
2000 previous current thread was of a different process. So if
2001 the previous thread is gone, we need to pick another one of
2002 the same process. This can happen e.g., if we followed an
2003 exec in a non-leader thread. */
2004 if (current_thread
== NULL
)
2007 = find_any_thread_of_pid (ptid_get_pid (general_thread
));
2009 /* Just in case, if we didn't find a thread, then bail out
2010 instead of crashing. */
2011 if (current_thread
== NULL
)
2013 write_enn (own_buf
);
2014 current_thread
= save_thread
;
2019 /* GDB is suggesting new symbols have been loaded. This may
2020 mean a new shared library has been detected as loaded, so
2021 take the opportunity to check if breakpoints we think are
2022 inserted, still are. Note that it isn't guaranteed that
2023 we'll see this when a shared library is loaded, and nor will
2024 we see this for unloads (although breakpoints in unloaded
2025 libraries shouldn't trigger), as GDB may not find symbols for
2026 the library at all. We also re-validate breakpoints when we
2027 see a second GDB breakpoint for the same address, and or when
2028 we access breakpoint shadows. */
2029 validate_breakpoints ();
2031 if (target_supports_tracepoints ())
2032 tracepoint_look_up_symbols ();
2034 if (current_thread
!= NULL
&& the_target
->look_up_symbols
!= NULL
)
2035 (*the_target
->look_up_symbols
) ();
2037 current_thread
= save_thread
;
2039 strcpy (own_buf
, "OK");
2043 if (!disable_packet_qfThreadInfo
)
2045 if (strcmp ("qfThreadInfo", own_buf
) == 0)
2049 require_running (own_buf
);
2050 thread_ptr
= get_first_inferior (&all_threads
);
2053 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2054 write_ptid (own_buf
, gdb_id
);
2055 thread_ptr
= thread_ptr
->next
;
2059 if (strcmp ("qsThreadInfo", own_buf
) == 0)
2063 require_running (own_buf
);
2064 if (thread_ptr
!= NULL
)
2067 gdb_id
= thread_to_gdb_id ((struct thread_info
*)thread_ptr
);
2068 write_ptid (own_buf
, gdb_id
);
2069 thread_ptr
= thread_ptr
->next
;
2074 sprintf (own_buf
, "l");
2080 if (the_target
->read_offsets
!= NULL
2081 && strcmp ("qOffsets", own_buf
) == 0)
2083 CORE_ADDR text
, data
;
2085 require_running (own_buf
);
2086 if (the_target
->read_offsets (&text
, &data
))
2087 sprintf (own_buf
, "Text=%lX;Data=%lX;Bss=%lX",
2088 (long)text
, (long)data
, (long)data
);
2090 write_enn (own_buf
);
2095 /* Protocol features query. */
2096 if (startswith (own_buf
, "qSupported")
2097 && (own_buf
[10] == ':' || own_buf
[10] == '\0'))
2099 char *p
= &own_buf
[10];
2100 int gdb_supports_qRelocInsn
= 0;
2102 /* Process each feature being provided by GDB. The first
2103 feature will follow a ':', and latter features will follow
2107 char **qsupported
= NULL
;
2112 /* Two passes, to avoid nested strtok calls in
2113 target_process_qsupported. */
2114 for (p
= strtok (p
+ 1, ";");
2116 p
= strtok (NULL
, ";"))
2119 qsupported
= XRESIZEVEC (char *, qsupported
, count
);
2120 qsupported
[count
- 1] = xstrdup (p
);
2123 for (i
= 0; i
< count
; i
++)
2126 if (strcmp (p
, "multiprocess+") == 0)
2128 /* GDB supports and wants multi-process support if
2130 if (target_supports_multi_process ())
2133 else if (strcmp (p
, "qRelocInsn+") == 0)
2135 /* GDB supports relocate instruction requests. */
2136 gdb_supports_qRelocInsn
= 1;
2138 else if (strcmp (p
, "swbreak+") == 0)
2140 /* GDB wants us to report whether a trap is caused
2141 by a software breakpoint and for us to handle PC
2142 adjustment if necessary on this target. */
2143 if (target_supports_stopped_by_sw_breakpoint ())
2144 swbreak_feature
= 1;
2146 else if (strcmp (p
, "hwbreak+") == 0)
2148 /* GDB wants us to report whether a trap is caused
2149 by a hardware breakpoint. */
2150 if (target_supports_stopped_by_hw_breakpoint ())
2151 hwbreak_feature
= 1;
2153 else if (strcmp (p
, "fork-events+") == 0)
2155 /* GDB supports and wants fork events if possible. */
2156 if (target_supports_fork_events ())
2157 report_fork_events
= 1;
2159 else if (strcmp (p
, "vfork-events+") == 0)
2161 /* GDB supports and wants vfork events if possible. */
2162 if (target_supports_vfork_events ())
2163 report_vfork_events
= 1;
2165 else if (strcmp (p
, "exec-events+") == 0)
2167 /* GDB supports and wants exec events if possible. */
2168 if (target_supports_exec_events ())
2169 report_exec_events
= 1;
2171 else if (strcmp (p
, "vContSupported+") == 0)
2172 vCont_supported
= 1;
2173 else if (strcmp (p
, "QThreadEvents+") == 0)
2175 else if (strcmp (p
, "no-resumed+") == 0)
2177 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2179 report_no_resumed
= 1;
2183 /* Move the unknown features all together. */
2184 qsupported
[i
] = NULL
;
2185 qsupported
[unknown
] = p
;
2190 /* Give the target backend a chance to process the unknown
2192 target_process_qsupported (qsupported
, unknown
);
2194 for (i
= 0; i
< count
; i
++)
2195 free (qsupported
[i
]);
2200 "PacketSize=%x;QPassSignals+;QProgramSignals+",
2203 if (the_target
->qxfer_libraries_svr4
!= NULL
)
2204 strcat (own_buf
, ";qXfer:libraries-svr4:read+"
2205 ";augmented-libraries-svr4-read+");
2208 /* We do not have any hook to indicate whether the non-SVR4 target
2209 backend supports qXfer:libraries:read, so always report it. */
2210 strcat (own_buf
, ";qXfer:libraries:read+");
2213 if (the_target
->read_auxv
!= NULL
)
2214 strcat (own_buf
, ";qXfer:auxv:read+");
2216 if (the_target
->qxfer_spu
!= NULL
)
2217 strcat (own_buf
, ";qXfer:spu:read+;qXfer:spu:write+");
2219 if (the_target
->qxfer_siginfo
!= NULL
)
2220 strcat (own_buf
, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2222 if (the_target
->read_loadmap
!= NULL
)
2223 strcat (own_buf
, ";qXfer:fdpic:read+");
2225 /* We always report qXfer:features:read, as targets may
2226 install XML files on a subsequent call to arch_setup.
2227 If we reported to GDB on startup that we don't support
2228 qXfer:feature:read at all, we will never be re-queried. */
2229 strcat (own_buf
, ";qXfer:features:read+");
2231 if (transport_is_reliable
)
2232 strcat (own_buf
, ";QStartNoAckMode+");
2234 if (the_target
->qxfer_osdata
!= NULL
)
2235 strcat (own_buf
, ";qXfer:osdata:read+");
2237 if (target_supports_multi_process ())
2238 strcat (own_buf
, ";multiprocess+");
2240 if (target_supports_fork_events ())
2241 strcat (own_buf
, ";fork-events+");
2243 if (target_supports_vfork_events ())
2244 strcat (own_buf
, ";vfork-events+");
2246 if (target_supports_exec_events ())
2247 strcat (own_buf
, ";exec-events+");
2249 if (target_supports_non_stop ())
2250 strcat (own_buf
, ";QNonStop+");
2252 if (target_supports_disable_randomization ())
2253 strcat (own_buf
, ";QDisableRandomization+");
2255 strcat (own_buf
, ";qXfer:threads:read+");
2257 if (target_supports_tracepoints ())
2259 strcat (own_buf
, ";ConditionalTracepoints+");
2260 strcat (own_buf
, ";TraceStateVariables+");
2261 strcat (own_buf
, ";TracepointSource+");
2262 strcat (own_buf
, ";DisconnectedTracing+");
2263 if (gdb_supports_qRelocInsn
&& target_supports_fast_tracepoints ())
2264 strcat (own_buf
, ";FastTracepoints+");
2265 strcat (own_buf
, ";StaticTracepoints+");
2266 strcat (own_buf
, ";InstallInTrace+");
2267 strcat (own_buf
, ";qXfer:statictrace:read+");
2268 strcat (own_buf
, ";qXfer:traceframe-info:read+");
2269 strcat (own_buf
, ";EnableDisableTracepoints+");
2270 strcat (own_buf
, ";QTBuffer:size+");
2271 strcat (own_buf
, ";tracenz+");
2274 if (target_supports_hardware_single_step ()
2275 || target_supports_software_single_step () )
2277 strcat (own_buf
, ";ConditionalBreakpoints+");
2279 strcat (own_buf
, ";BreakpointCommands+");
2281 if (target_supports_agent ())
2282 strcat (own_buf
, ";QAgent+");
2284 supported_btrace_packets (own_buf
);
2286 if (target_supports_stopped_by_sw_breakpoint ())
2287 strcat (own_buf
, ";swbreak+");
2289 if (target_supports_stopped_by_hw_breakpoint ())
2290 strcat (own_buf
, ";hwbreak+");
2292 if (the_target
->pid_to_exec_file
!= NULL
)
2293 strcat (own_buf
, ";qXfer:exec-file:read+");
2295 strcat (own_buf
, ";vContSupported+");
2297 strcat (own_buf
, ";QThreadEvents+");
2299 strcat (own_buf
, ";no-resumed+");
2301 /* Reinitialize components as needed for the new connection. */
2302 hostio_handle_new_gdb_connection ();
2303 target_handle_new_gdb_connection ();
2308 /* Thread-local storage support. */
2309 if (the_target
->get_tls_address
!= NULL
2310 && startswith (own_buf
, "qGetTLSAddr:"))
2312 char *p
= own_buf
+ 12;
2313 CORE_ADDR parts
[2], address
= 0;
2315 ptid_t ptid
= null_ptid
;
2317 require_running (own_buf
);
2319 for (i
= 0; i
< 3; i
++)
2327 p2
= strchr (p
, ',');
2340 ptid
= read_ptid (p
, NULL
);
2342 decode_address (&parts
[i
- 1], p
, len
);
2346 if (p
!= NULL
|| i
< 3)
2350 struct thread_info
*thread
= find_thread_ptid (ptid
);
2355 err
= the_target
->get_tls_address (thread
, parts
[0], parts
[1],
2361 strcpy (own_buf
, paddress(address
));
2366 write_enn (own_buf
);
2370 /* Otherwise, pretend we do not understand this packet. */
2373 /* Windows OS Thread Information Block address support. */
2374 if (the_target
->get_tib_address
!= NULL
2375 && startswith (own_buf
, "qGetTIBAddr:"))
2380 ptid_t ptid
= read_ptid (own_buf
+ 12, &annex
);
2382 n
= (*the_target
->get_tib_address
) (ptid
, &tlb
);
2385 strcpy (own_buf
, paddress(tlb
));
2390 write_enn (own_buf
);
2396 /* Handle "monitor" commands. */
2397 if (startswith (own_buf
, "qRcmd,"))
2399 char *mon
= (char *) malloc (PBUFSIZ
);
2400 int len
= strlen (own_buf
+ 6);
2404 write_enn (own_buf
);
2409 || hex2bin (own_buf
+ 6, (gdb_byte
*) mon
, len
/ 2) != len
/ 2)
2411 write_enn (own_buf
);
2415 mon
[len
/ 2] = '\0';
2419 if (the_target
->handle_monitor_command
== NULL
2420 || (*the_target
->handle_monitor_command
) (mon
) == 0)
2421 /* Default processing. */
2422 handle_monitor_command (mon
, own_buf
);
2428 if (startswith (own_buf
, "qSearch:memory:"))
2430 require_running (own_buf
);
2431 handle_search_memory (own_buf
, packet_len
);
2435 if (strcmp (own_buf
, "qAttached") == 0
2436 || startswith (own_buf
, "qAttached:"))
2438 struct process_info
*process
;
2440 if (own_buf
[sizeof ("qAttached") - 1])
2442 int pid
= strtoul (own_buf
+ sizeof ("qAttached:") - 1, NULL
, 16);
2443 process
= (struct process_info
*)
2444 find_inferior_id (&all_processes
, pid_to_ptid (pid
));
2448 require_running (own_buf
);
2449 process
= current_process ();
2452 if (process
== NULL
)
2454 write_enn (own_buf
);
2458 strcpy (own_buf
, process
->attached
? "1" : "0");
2462 if (startswith (own_buf
, "qCRC:"))
2464 /* CRC check (compare-section). */
2468 unsigned long long crc
;
2470 require_running (own_buf
);
2471 comma
= unpack_varlen_hex (own_buf
+ 5, &base
);
2472 if (*comma
++ != ',')
2474 write_enn (own_buf
);
2477 len
= strtoul (comma
, NULL
, 16);
2478 crc
= crc32 (base
, len
, 0xffffffff);
2479 /* Check for memory failure. */
2480 if (crc
== (unsigned long long) -1)
2482 write_enn (own_buf
);
2485 sprintf (own_buf
, "C%lx", (unsigned long) crc
);
2489 if (handle_qxfer (own_buf
, packet_len
, new_packet_len_p
))
2492 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf
))
2495 /* Otherwise we didn't know what packet it was. Say we didn't
2500 static void gdb_wants_all_threads_stopped (void);
2501 static void resume (struct thread_resume
*actions
, size_t n
);
2503 /* The callback that is passed to visit_actioned_threads. */
2504 typedef int (visit_actioned_threads_callback_ftype
)
2505 (const struct thread_resume
*, struct thread_info
*);
2507 /* Struct to pass data to visit_actioned_threads. */
2509 struct visit_actioned_threads_data
2511 const struct thread_resume
*actions
;
2513 visit_actioned_threads_callback_ftype
*callback
;
2516 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2517 true if CALLBACK returns true. Returns false if no matching thread
2518 is found or CALLBACK results false.
2519 Note: This function is itself a callback for find_inferior. */
2522 visit_actioned_threads (struct inferior_list_entry
*entry
, void *datap
)
2524 struct visit_actioned_threads_data
*data
2525 = (struct visit_actioned_threads_data
*) datap
;
2526 const struct thread_resume
*actions
= data
->actions
;
2527 size_t num_actions
= data
->num_actions
;
2528 visit_actioned_threads_callback_ftype
*callback
= data
->callback
;
2531 for (i
= 0; i
< num_actions
; i
++)
2533 const struct thread_resume
*action
= &actions
[i
];
2535 if (ptid_equal (action
->thread
, minus_one_ptid
)
2536 || ptid_equal (action
->thread
, entry
->id
)
2537 || ((ptid_get_pid (action
->thread
)
2538 == ptid_get_pid (entry
->id
))
2539 && ptid_get_lwp (action
->thread
) == -1))
2541 struct thread_info
*thread
= (struct thread_info
*) entry
;
2543 if ((*callback
) (action
, thread
))
2551 /* Callback for visit_actioned_threads. If the thread has a pending
2552 status to report, report it now. */
2555 handle_pending_status (const struct thread_resume
*resumption
,
2556 struct thread_info
*thread
)
2558 if (thread
->status_pending_p
)
2560 thread
->status_pending_p
= 0;
2562 last_status
= thread
->last_status
;
2563 last_ptid
= thread
->entry
.id
;
2564 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2570 /* Parse vCont packets. */
2572 handle_v_cont (char *own_buf
)
2576 struct thread_resume
*resume_info
;
2577 struct thread_resume default_action
= {{0}};
2579 /* Count the number of semicolons in the packet. There should be one
2580 for every action. */
2586 p
= strchr (p
, ';');
2589 resume_info
= (struct thread_resume
*) malloc (n
* sizeof (resume_info
[0]));
2590 if (resume_info
== NULL
)
2598 memset (&resume_info
[i
], 0, sizeof resume_info
[i
]);
2600 if (p
[0] == 's' || p
[0] == 'S')
2601 resume_info
[i
].kind
= resume_step
;
2602 else if (p
[0] == 'r')
2603 resume_info
[i
].kind
= resume_step
;
2604 else if (p
[0] == 'c' || p
[0] == 'C')
2605 resume_info
[i
].kind
= resume_continue
;
2606 else if (p
[0] == 't')
2607 resume_info
[i
].kind
= resume_stop
;
2611 if (p
[0] == 'S' || p
[0] == 'C')
2614 sig
= strtol (p
+ 1, &q
, 16);
2619 if (!gdb_signal_to_host_p ((enum gdb_signal
) sig
))
2621 resume_info
[i
].sig
= gdb_signal_to_host ((enum gdb_signal
) sig
);
2623 else if (p
[0] == 'r')
2627 p
= unpack_varlen_hex (p
+ 1, &addr
);
2628 resume_info
[i
].step_range_start
= addr
;
2633 p
= unpack_varlen_hex (p
+ 1, &addr
);
2634 resume_info
[i
].step_range_end
= addr
;
2643 resume_info
[i
].thread
= minus_one_ptid
;
2644 default_action
= resume_info
[i
];
2646 /* Note: we don't increment i here, we'll overwrite this entry
2647 the next time through. */
2649 else if (p
[0] == ':')
2651 ptid_t ptid
= read_ptid (p
+ 1, &q
);
2656 if (p
[0] != ';' && p
[0] != 0)
2659 resume_info
[i
].thread
= ptid
;
2666 resume_info
[i
] = default_action
;
2668 resume (resume_info
, n
);
2673 write_enn (own_buf
);
2678 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2681 resume (struct thread_resume
*actions
, size_t num_actions
)
2685 /* Check if among the threads that GDB wants actioned, there's
2686 one with a pending status to report. If so, skip actually
2687 resuming/stopping and report the pending event
2689 struct visit_actioned_threads_data data
;
2691 data
.actions
= actions
;
2692 data
.num_actions
= num_actions
;
2693 data
.callback
= handle_pending_status
;
2694 if (find_inferior (&all_threads
, visit_actioned_threads
, &data
) != NULL
)
2700 (*the_target
->resume
) (actions
, num_actions
);
2706 last_ptid
= mywait (minus_one_ptid
, &last_status
, 0, 1);
2708 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
2709 && !report_no_resumed
)
2711 /* The client does not support this stop reply. At least
2713 sprintf (own_buf
, "E.No unwaited-for children left.");
2714 disable_async_io ();
2718 if (last_status
.kind
!= TARGET_WAITKIND_EXITED
2719 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
2720 && last_status
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
2721 current_thread
->last_status
= last_status
;
2723 /* From the client's perspective, all-stop mode always stops all
2724 threads implicitly (and the target backend has already done
2725 so by now). Tag all threads as "want-stopped", so we don't
2726 resume them implicitly without the client telling us to. */
2727 gdb_wants_all_threads_stopped ();
2728 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2729 disable_async_io ();
2731 if (last_status
.kind
== TARGET_WAITKIND_EXITED
2732 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
2733 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid
)));
2737 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2739 handle_v_attach (char *own_buf
)
2743 pid
= strtol (own_buf
+ 8, NULL
, 16);
2744 if (pid
!= 0 && attach_inferior (pid
) == 0)
2746 /* Don't report shared library events after attaching, even if
2747 some libraries are preloaded. GDB will always poll the
2748 library list. Avoids the "stopped by shared library event"
2749 notice on the GDB side. */
2754 /* In non-stop, we don't send a resume reply. Stop events
2755 will follow up using the normal notification
2760 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2766 write_enn (own_buf
);
2771 /* Run a new program. Return 1 if successful, 0 if failure. */
2773 handle_v_run (char *own_buf
)
2775 char *p
, *next_p
, **new_argv
;
2779 for (p
= own_buf
+ strlen ("vRun;"); p
&& *p
; p
= strchr (p
, ';'))
2785 new_argv
= (char **) calloc (new_argc
+ 2, sizeof (char *));
2786 if (new_argv
== NULL
)
2788 write_enn (own_buf
);
2793 for (p
= own_buf
+ strlen ("vRun;"); *p
; p
= next_p
)
2795 next_p
= strchr (p
, ';');
2797 next_p
= p
+ strlen (p
);
2799 if (i
== 0 && p
== next_p
)
2803 /* FIXME: Fail request if out of memory instead of dying. */
2804 new_argv
[i
] = (char *) xmalloc (1 + (next_p
- p
) / 2);
2805 hex2bin (p
, (gdb_byte
*) new_argv
[i
], (next_p
- p
) / 2);
2806 new_argv
[i
][(next_p
- p
) / 2] = '\0';
2815 if (new_argv
[0] == NULL
)
2817 /* GDB didn't specify a program to run. Use the program from the
2818 last run with the new argument list. */
2820 if (program_argv
== NULL
)
2822 write_enn (own_buf
);
2823 freeargv (new_argv
);
2827 new_argv
[0] = strdup (program_argv
[0]);
2828 if (new_argv
[0] == NULL
)
2830 write_enn (own_buf
);
2831 freeargv (new_argv
);
2836 /* Free the old argv and install the new one. */
2837 freeargv (program_argv
);
2838 program_argv
= new_argv
;
2840 start_inferior (program_argv
);
2841 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
2843 prepare_resume_reply (own_buf
, last_ptid
, &last_status
);
2845 /* In non-stop, sending a resume reply doesn't set the general
2846 thread, but GDB assumes a vRun sets it (this is so GDB can
2847 query which is the main thread of the new inferior. */
2849 general_thread
= last_ptid
;
2855 write_enn (own_buf
);
2860 /* Kill process. Return 1 if successful, 0 if failure. */
2862 handle_v_kill (char *own_buf
)
2865 char *p
= &own_buf
[6];
2867 pid
= strtol (p
, NULL
, 16);
2870 if (pid
!= 0 && kill_inferior (pid
) == 0)
2872 last_status
.kind
= TARGET_WAITKIND_SIGNALLED
;
2873 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
2874 last_ptid
= pid_to_ptid (pid
);
2875 discard_queued_stop_replies (last_ptid
);
2881 write_enn (own_buf
);
2886 /* Handle all of the extended 'v' packets. */
2888 handle_v_requests (char *own_buf
, int packet_len
, int *new_packet_len
)
2890 if (!disable_packet_vCont
)
2892 if (strcmp (own_buf
, "vCtrlC") == 0)
2894 (*the_target
->request_interrupt
) ();
2899 if (startswith (own_buf
, "vCont;"))
2901 require_running (own_buf
);
2902 handle_v_cont (own_buf
);
2906 if (startswith (own_buf
, "vCont?"))
2908 strcpy (own_buf
, "vCont;c;C;t");
2910 if (target_supports_hardware_single_step () || !vCont_supported
)
2912 /* If target supports hardware single step, add actions s
2913 and S to the list of supported actions. On the other
2914 hand, if GDB doesn't request the supported vCont actions
2915 in qSupported packet, add s and S to the list too. */
2916 own_buf
= own_buf
+ strlen (own_buf
);
2917 strcpy (own_buf
, ";s;S");
2920 if (target_supports_range_stepping ())
2922 own_buf
= own_buf
+ strlen (own_buf
);
2923 strcpy (own_buf
, ";r");
2929 if (startswith (own_buf
, "vFile:")
2930 && handle_vFile (own_buf
, packet_len
, new_packet_len
))
2933 if (startswith (own_buf
, "vAttach;"))
2935 if ((!extended_protocol
|| !multi_process
) && target_running ())
2937 fprintf (stderr
, "Already debugging a process\n");
2938 write_enn (own_buf
);
2941 handle_v_attach (own_buf
);
2945 if (startswith (own_buf
, "vRun;"))
2947 if ((!extended_protocol
|| !multi_process
) && target_running ())
2949 fprintf (stderr
, "Already debugging a process\n");
2950 write_enn (own_buf
);
2953 handle_v_run (own_buf
);
2957 if (startswith (own_buf
, "vKill;"))
2959 if (!target_running ())
2961 fprintf (stderr
, "No process to kill\n");
2962 write_enn (own_buf
);
2965 handle_v_kill (own_buf
);
2969 if (handle_notif_ack (own_buf
, packet_len
))
2972 /* Otherwise we didn't know what packet it was. Say we didn't
2978 /* Resume thread and wait for another event. In non-stop mode,
2979 don't really wait here, but return immediatelly to the event
2982 myresume (char *own_buf
, int step
, int sig
)
2984 struct thread_resume resume_info
[2];
2986 int valid_cont_thread
;
2988 valid_cont_thread
= (!ptid_equal (cont_thread
, null_ptid
)
2989 && !ptid_equal (cont_thread
, minus_one_ptid
));
2991 if (step
|| sig
|| valid_cont_thread
)
2993 resume_info
[0].thread
= current_ptid
;
2995 resume_info
[0].kind
= resume_step
;
2997 resume_info
[0].kind
= resume_continue
;
2998 resume_info
[0].sig
= sig
;
3002 if (!valid_cont_thread
)
3004 resume_info
[n
].thread
= minus_one_ptid
;
3005 resume_info
[n
].kind
= resume_continue
;
3006 resume_info
[n
].sig
= 0;
3010 resume (resume_info
, n
);
3013 /* Callback for for_each_inferior. Make a new stop reply for each
3017 queue_stop_reply_callback (struct inferior_list_entry
*entry
, void *arg
)
3019 struct thread_info
*thread
= (struct thread_info
*) entry
;
3021 /* For now, assume targets that don't have this callback also don't
3022 manage the thread's last_status field. */
3023 if (the_target
->thread_stopped
== NULL
)
3025 struct vstop_notif
*new_notif
= XNEW (struct vstop_notif
);
3027 new_notif
->ptid
= entry
->id
;
3028 new_notif
->status
= thread
->last_status
;
3029 /* Pass the last stop reply back to GDB, but don't notify
3031 notif_event_enque (¬if_stop
,
3032 (struct notif_event
*) new_notif
);
3036 if (thread_stopped (thread
))
3041 = target_waitstatus_to_string (&thread
->last_status
);
3043 debug_printf ("Reporting thread %s as already stopped with %s\n",
3044 target_pid_to_str (entry
->id
),
3047 xfree (status_string
);
3050 gdb_assert (thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3052 /* Pass the last stop reply back to GDB, but don't notify
3054 queue_stop_reply (entry
->id
, &thread
->last_status
);
3061 /* Set this inferior threads's state as "want-stopped". We won't
3062 resume this thread until the client gives us another action for
3066 gdb_wants_thread_stopped (struct inferior_list_entry
*entry
)
3068 struct thread_info
*thread
= (struct thread_info
*) entry
;
3070 thread
->last_resume_kind
= resume_stop
;
3072 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
3074 /* Most threads are stopped implicitly (all-stop); tag that with
3076 thread
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
3077 thread
->last_status
.value
.sig
= GDB_SIGNAL_0
;
3081 /* Set all threads' states as "want-stopped". */
3084 gdb_wants_all_threads_stopped (void)
3086 for_each_inferior (&all_threads
, gdb_wants_thread_stopped
);
3089 /* Clear the gdb_detached flag of every process. */
3092 gdb_reattached_process (struct inferior_list_entry
*entry
)
3094 struct process_info
*process
= (struct process_info
*) entry
;
3096 process
->gdb_detached
= 0;
3099 /* Callback for for_each_inferior. Clear the thread's pending status
3103 clear_pending_status_callback (struct inferior_list_entry
*entry
)
3105 struct thread_info
*thread
= (struct thread_info
*) entry
;
3107 thread
->status_pending_p
= 0;
3110 /* Callback for for_each_inferior. If the thread is stopped with an
3111 interesting event, mark it as having a pending event. */
3114 set_pending_status_callback (struct inferior_list_entry
*entry
)
3116 struct thread_info
*thread
= (struct thread_info
*) entry
;
3118 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
3119 || (thread
->last_status
.value
.sig
!= GDB_SIGNAL_0
3120 /* A breakpoint, watchpoint or finished step from a previous
3121 GDB run isn't considered interesting for a new GDB run.
3122 If we left those pending, the new GDB could consider them
3123 random SIGTRAPs. This leaves out real async traps. We'd
3124 have to peek into the (target-specific) siginfo to
3125 distinguish those. */
3126 && thread
->last_status
.value
.sig
!= GDB_SIGNAL_TRAP
))
3127 thread
->status_pending_p
= 1;
3130 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3131 pending status to report to GDB. */
3134 find_status_pending_thread_callback (struct inferior_list_entry
*entry
, void *data
)
3136 struct thread_info
*thread
= (struct thread_info
*) entry
;
3138 return thread
->status_pending_p
;
3141 /* Status handler for the '?' packet. */
3144 handle_status (char *own_buf
)
3146 /* GDB is connected, don't forward events to the target anymore. */
3147 for_each_inferior (&all_processes
, gdb_reattached_process
);
3149 /* In non-stop mode, we must send a stop reply for each stopped
3150 thread. In all-stop mode, just send one for the first stopped
3155 find_inferior (&all_threads
, queue_stop_reply_callback
, NULL
);
3157 /* The first is sent immediatly. OK is sent if there is no
3158 stopped thread, which is the same handling of the vStopped
3159 packet (by design). */
3160 notif_write_event (¬if_stop
, own_buf
);
3164 struct inferior_list_entry
*thread
= NULL
;
3167 stabilize_threads ();
3168 gdb_wants_all_threads_stopped ();
3170 /* We can only report one status, but we might be coming out of
3171 non-stop -- if more than one thread is stopped with
3172 interesting events, leave events for the threads we're not
3173 reporting now pending. They'll be reported the next time the
3174 threads are resumed. Start by marking all interesting events
3176 for_each_inferior (&all_threads
, set_pending_status_callback
);
3178 /* Prefer the last thread that reported an event to GDB (even if
3179 that was a GDB_SIGNAL_TRAP). */
3180 if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
3181 && last_status
.kind
!= TARGET_WAITKIND_EXITED
3182 && last_status
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3183 thread
= find_inferior_id (&all_threads
, last_ptid
);
3185 /* If the last event thread is not found for some reason, look
3186 for some other thread that might have an event to report. */
3188 thread
= find_inferior (&all_threads
,
3189 find_status_pending_thread_callback
, NULL
);
3191 /* If we're still out of luck, simply pick the first thread in
3194 thread
= get_first_inferior (&all_threads
);
3198 struct thread_info
*tp
= (struct thread_info
*) thread
;
3200 /* We're reporting this event, so it's no longer
3202 tp
->status_pending_p
= 0;
3204 /* GDB assumes the current thread is the thread we're
3205 reporting the status for. */
3206 general_thread
= thread
->id
;
3207 set_desired_thread (1);
3209 gdb_assert (tp
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
);
3210 prepare_resume_reply (own_buf
, tp
->entry
.id
, &tp
->last_status
);
3213 strcpy (own_buf
, "W00");
3218 gdbserver_version (void)
3220 printf ("GNU gdbserver %s%s\n"
3221 "Copyright (C) 2015 Free Software Foundation, Inc.\n"
3222 "gdbserver is free software, covered by the "
3223 "GNU General Public License.\n"
3224 "This gdbserver was configured as \"%s\"\n",
3225 PKGVERSION
, version
, host_name
);
3229 gdbserver_usage (FILE *stream
)
3231 fprintf (stream
, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3232 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3233 "\tgdbserver [OPTIONS] --multi COMM\n"
3235 "COMM may either be a tty device (for serial debugging),\n"
3236 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3237 "stdin/stdout of gdbserver.\n"
3238 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3239 "PID is the process ID to attach to, when --attach is specified.\n"
3241 "Operating modes:\n"
3243 " --attach Attach to running process PID.\n"
3244 " --multi Start server without a specific program, and\n"
3245 " only quit when explicitly commanded.\n"
3246 " --once Exit after the first connection has closed.\n"
3247 " --help Print this message and then exit.\n"
3248 " --version Display version information and exit.\n"
3252 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3253 " --disable-randomization\n"
3254 " Run PROG with address space randomization disabled.\n"
3255 " --no-disable-randomization\n"
3256 " Don't disable address space randomization when\n"
3261 " --debug Enable general debugging output.\n"
3262 " --debug-format=opt1[,opt2,...]\n"
3263 " Specify extra content in debugging output.\n"
3268 " --remote-debug Enable remote protocol debugging output.\n"
3269 " --disable-packet=opt1[,opt2,...]\n"
3270 " Disable support for RSP packets or features.\n"
3272 " vCont, Tthread, qC, qfThreadInfo and \n"
3273 " threads (disable all threading packets).\n"
3275 "For more information, consult the GDB manual (available as on-line \n"
3276 "info or a printed manual).\n");
3277 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3278 fprintf (stream
, "Report bugs to \"%s\".\n", REPORT_BUGS_TO
);
3282 gdbserver_show_disableable (FILE *stream
)
3284 fprintf (stream
, "Disableable packets:\n"
3285 " vCont \tAll vCont packets\n"
3286 " qC \tQuerying the current thread\n"
3287 " qfThreadInfo\tThread listing\n"
3288 " Tthread \tPassing the thread specifier in the "
3289 "T stop reply packet\n"
3290 " threads \tAll of the above\n");
3294 #undef require_running
3295 #define require_running(BUF) \
3296 if (!target_running ()) \
3303 first_thread_of (struct inferior_list_entry
*entry
, void *args
)
3305 int pid
= * (int *) args
;
3307 if (ptid_get_pid (entry
->id
) == pid
)
3314 kill_inferior_callback (struct inferior_list_entry
*entry
)
3316 struct process_info
*process
= (struct process_info
*) entry
;
3317 int pid
= ptid_get_pid (process
->entry
.id
);
3319 kill_inferior (pid
);
3320 discard_queued_stop_replies (pid_to_ptid (pid
));
3323 /* Callback for for_each_inferior to detach or kill the inferior,
3324 depending on whether we attached to it or not.
3325 We inform the user whether we're detaching or killing the process
3326 as this is only called when gdbserver is about to exit. */
3329 detach_or_kill_inferior_callback (struct inferior_list_entry
*entry
)
3331 struct process_info
*process
= (struct process_info
*) entry
;
3332 int pid
= ptid_get_pid (process
->entry
.id
);
3334 if (process
->attached
)
3335 detach_inferior (pid
);
3337 kill_inferior (pid
);
3339 discard_queued_stop_replies (pid_to_ptid (pid
));
3342 /* for_each_inferior callback for detach_or_kill_for_exit to print
3343 the pids of started inferiors. */
3346 print_started_pid (struct inferior_list_entry
*entry
)
3348 struct process_info
*process
= (struct process_info
*) entry
;
3350 if (! process
->attached
)
3352 int pid
= ptid_get_pid (process
->entry
.id
);
3353 fprintf (stderr
, " %d", pid
);
3357 /* for_each_inferior callback for detach_or_kill_for_exit to print
3358 the pids of attached inferiors. */
3361 print_attached_pid (struct inferior_list_entry
*entry
)
3363 struct process_info
*process
= (struct process_info
*) entry
;
3365 if (process
->attached
)
3367 int pid
= ptid_get_pid (process
->entry
.id
);
3368 fprintf (stderr
, " %d", pid
);
3372 /* Call this when exiting gdbserver with possible inferiors that need
3373 to be killed or detached from. */
3376 detach_or_kill_for_exit (void)
3378 /* First print a list of the inferiors we will be killing/detaching.
3379 This is to assist the user, for example, in case the inferior unexpectedly
3380 dies after we exit: did we screw up or did the inferior exit on its own?
3381 Having this info will save some head-scratching. */
3383 if (have_started_inferiors_p ())
3385 fprintf (stderr
, "Killing process(es):");
3386 for_each_inferior (&all_processes
, print_started_pid
);
3387 fprintf (stderr
, "\n");
3389 if (have_attached_inferiors_p ())
3391 fprintf (stderr
, "Detaching process(es):");
3392 for_each_inferior (&all_processes
, print_attached_pid
);
3393 fprintf (stderr
, "\n");
3396 /* Now we can kill or detach the inferiors. */
3398 for_each_inferior (&all_processes
, detach_or_kill_inferior_callback
);
3401 /* Value that will be passed to exit(3) when gdbserver exits. */
3402 static int exit_code
;
3404 /* Cleanup version of detach_or_kill_for_exit. */
3407 detach_or_kill_for_exit_cleanup (void *ignore
)
3412 detach_or_kill_for_exit ();
3415 CATCH (exception
, RETURN_MASK_ALL
)
3418 fprintf (stderr
, "Detach or kill failed: %s\n", exception
.message
);
3424 /* Main function. This is called by the real "main" function,
3425 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3427 static void ATTRIBUTE_NORETURN
3428 captured_main (int argc
, char *argv
[])
3432 char *arg_end
, *port
;
3433 char **next_arg
= &argv
[1];
3434 volatile int multi_mode
= 0;
3435 volatile int attach
= 0;
3438 while (*next_arg
!= NULL
&& **next_arg
== '-')
3440 if (strcmp (*next_arg
, "--version") == 0)
3442 gdbserver_version ();
3445 else if (strcmp (*next_arg
, "--help") == 0)
3447 gdbserver_usage (stdout
);
3450 else if (strcmp (*next_arg
, "--attach") == 0)
3452 else if (strcmp (*next_arg
, "--multi") == 0)
3454 else if (strcmp (*next_arg
, "--wrapper") == 0)
3458 wrapper_argv
= next_arg
;
3459 while (*next_arg
!= NULL
&& strcmp (*next_arg
, "--") != 0)
3462 if (next_arg
== wrapper_argv
|| *next_arg
== NULL
)
3464 gdbserver_usage (stderr
);
3468 /* Consume the "--". */
3471 else if (strcmp (*next_arg
, "--debug") == 0)
3473 else if (startswith (*next_arg
, "--debug-format="))
3476 = parse_debug_format_options ((*next_arg
)
3477 + sizeof ("--debug-format=") - 1, 0);
3479 if (error_msg
!= NULL
)
3481 fprintf (stderr
, "%s", error_msg
);
3485 else if (strcmp (*next_arg
, "--remote-debug") == 0)
3487 else if (strcmp (*next_arg
, "--disable-packet") == 0)
3489 gdbserver_show_disableable (stdout
);
3492 else if (startswith (*next_arg
, "--disable-packet="))
3494 char *packets
, *tok
;
3496 packets
= *next_arg
+= sizeof ("--disable-packet=") - 1;
3497 for (tok
= strtok (packets
, ",");
3499 tok
= strtok (NULL
, ","))
3501 if (strcmp ("vCont", tok
) == 0)
3502 disable_packet_vCont
= 1;
3503 else if (strcmp ("Tthread", tok
) == 0)
3504 disable_packet_Tthread
= 1;
3505 else if (strcmp ("qC", tok
) == 0)
3506 disable_packet_qC
= 1;
3507 else if (strcmp ("qfThreadInfo", tok
) == 0)
3508 disable_packet_qfThreadInfo
= 1;
3509 else if (strcmp ("threads", tok
) == 0)
3511 disable_packet_vCont
= 1;
3512 disable_packet_Tthread
= 1;
3513 disable_packet_qC
= 1;
3514 disable_packet_qfThreadInfo
= 1;
3518 fprintf (stderr
, "Don't know how to disable \"%s\".\n\n",
3520 gdbserver_show_disableable (stderr
);
3525 else if (strcmp (*next_arg
, "-") == 0)
3527 /* "-" specifies a stdio connection and is a form of port
3529 *next_arg
= STDIO_CONNECTION_NAME
;
3532 else if (strcmp (*next_arg
, "--disable-randomization") == 0)
3533 disable_randomization
= 1;
3534 else if (strcmp (*next_arg
, "--no-disable-randomization") == 0)
3535 disable_randomization
= 0;
3536 else if (strcmp (*next_arg
, "--once") == 0)
3540 fprintf (stderr
, "Unknown argument: %s\n", *next_arg
);
3550 if (port
== NULL
|| (!attach
&& !multi_mode
&& *next_arg
== NULL
))
3552 gdbserver_usage (stderr
);
3556 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3557 opened by remote_prepare. */
3560 /* We need to know whether the remote connection is stdio before
3561 starting the inferior. Inferiors created in this scenario have
3562 stdin,stdout redirected. So do this here before we call
3564 remote_prepare (port
);
3569 /* --attach used to come after PORT, so allow it there for
3571 if (*next_arg
!= NULL
&& strcmp (*next_arg
, "--attach") == 0)
3578 && (*next_arg
== NULL
3579 || (*next_arg
)[0] == '\0'
3580 || (pid
= strtoul (*next_arg
, &arg_end
, 0)) == 0
3582 || next_arg
[1] != NULL
))
3587 gdbserver_usage (stderr
);
3591 initialize_async_io ();
3593 initialize_event_loop ();
3594 if (target_supports_tracepoints ())
3595 initialize_tracepoint ();
3596 initialize_notif ();
3598 own_buf
= (char *) xmalloc (PBUFSIZ
+ 1);
3599 mem_buf
= (unsigned char *) xmalloc (PBUFSIZ
);
3601 if (pid
== 0 && *next_arg
!= NULL
)
3605 n
= argc
- (next_arg
- argv
);
3606 program_argv
= XNEWVEC (char *, n
+ 1);
3607 for (i
= 0; i
< n
; i
++)
3608 program_argv
[i
] = xstrdup (next_arg
[i
]);
3609 program_argv
[i
] = NULL
;
3611 /* Wait till we are at first instruction in program. */
3612 start_inferior (program_argv
);
3614 /* We are now (hopefully) stopped at the first instruction of
3615 the target process. This assumes that the target process was
3616 successfully created. */
3620 if (attach_inferior (pid
) == -1)
3621 error ("Attaching not supported on this target");
3623 /* Otherwise succeeded. */
3627 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3628 last_status
.value
.integer
= 0;
3629 last_ptid
= minus_one_ptid
;
3631 make_cleanup (detach_or_kill_for_exit_cleanup
, NULL
);
3633 /* Don't report shared library events on the initial connection,
3634 even if some libraries are preloaded. Avoids the "stopped by
3635 shared library event" notice on gdb side. */
3638 if (last_status
.kind
== TARGET_WAITKIND_EXITED
3639 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
3644 if (!was_running
&& !multi_mode
)
3645 error ("No program to debug");
3652 report_fork_events
= 0;
3653 report_vfork_events
= 0;
3654 report_exec_events
= 0;
3655 /* Be sure we're out of tfind mode. */
3656 current_traceframe
= -1;
3657 cont_thread
= null_ptid
;
3658 swbreak_feature
= 0;
3659 hwbreak_feature
= 0;
3660 vCont_supported
= 0;
3666 /* Wait for events. This will return when all event sources
3667 are removed from the event loop. */
3668 start_event_loop ();
3670 /* If an exit was requested (using the "monitor exit"
3671 command), terminate now. */
3673 throw_quit ("Quit");
3675 /* The only other way to get here is for getpkt to fail:
3677 - If --once was specified, we're done.
3679 - If not in extended-remote mode, and we're no longer
3680 debugging anything, simply exit: GDB has disconnected
3681 after processing the last process exit.
3683 - Otherwise, close the connection and reopen it at the
3685 if (run_once
|| (!extended_protocol
&& !target_running ()))
3686 throw_quit ("Quit");
3689 "Remote side has terminated connection. "
3690 "GDBserver will reopen the connection.\n");
3692 /* Get rid of any pending statuses. An eventual reconnection
3693 (by the same GDB instance or another) will refresh all its
3694 state from scratch. */
3695 discard_queued_stop_replies (minus_one_ptid
);
3696 for_each_inferior (&all_threads
,
3697 clear_pending_status_callback
);
3701 if (disconnected_tracing
)
3703 /* Try to enable non-stop/async mode, so we we can
3704 both wait for an async socket accept, and handle
3705 async target events simultaneously. There's also
3706 no point either in having the target always stop
3707 all threads, when we're going to pass signals
3708 down without informing GDB. */
3711 if (start_non_stop (1))
3714 /* Detaching implicitly resumes all threads;
3715 simply disconnecting does not. */
3721 "Disconnected tracing disabled; "
3722 "stopping trace run.\n");
3727 CATCH (exception
, RETURN_MASK_ERROR
)
3730 fprintf (stderr
, "gdbserver: %s\n", exception
.message
);
3732 if (response_needed
)
3734 write_enn (own_buf
);
3739 throw_quit ("Quit");
3745 /* Main function. */
3748 main (int argc
, char *argv
[])
3753 captured_main (argc
, argv
);
3755 CATCH (exception
, RETURN_MASK_ALL
)
3757 if (exception
.reason
== RETURN_ERROR
)
3760 fprintf (stderr
, "%s\n", exception
.message
);
3761 fprintf (stderr
, "Exiting\n");
3769 gdb_assert_not_reached ("captured_main should never return");
3772 /* Skip PACKET until the next semi-colon (or end of string). */
3775 skip_to_semicolon (char **packet
)
3777 while (**packet
!= '\0' && **packet
!= ';')
3781 /* Process options coming from Z packets for a breakpoint. PACKET is
3782 the packet buffer. *PACKET is updated to point to the first char
3783 after the last processed option. */
3786 process_point_options (struct breakpoint
*bp
, char **packet
)
3788 char *dataptr
= *packet
;
3791 /* Check if data has the correct format. */
3792 if (*dataptr
!= ';')
3799 if (*dataptr
== ';')
3802 if (*dataptr
== 'X')
3804 /* Conditional expression. */
3806 debug_printf ("Found breakpoint condition.\n");
3807 if (!add_breakpoint_condition (bp
, &dataptr
))
3808 skip_to_semicolon (&dataptr
);
3810 else if (startswith (dataptr
, "cmds:"))
3812 dataptr
+= strlen ("cmds:");
3814 debug_printf ("Found breakpoint commands %s.\n", dataptr
);
3815 persist
= (*dataptr
== '1');
3817 if (add_breakpoint_commands (bp
, &dataptr
, persist
))
3818 skip_to_semicolon (&dataptr
);
3822 fprintf (stderr
, "Unknown token %c, ignoring.\n",
3824 /* Skip tokens until we find one that we recognize. */
3825 skip_to_semicolon (&dataptr
);
3831 /* Event loop callback that handles a serial event. The first byte in
3832 the serial buffer gets us here. We expect characters to arrive at
3833 a brisk pace, so we read the rest of the packet with a blocking
3837 process_serial_event (void)
3848 int new_packet_len
= -1;
3850 disable_async_io ();
3852 response_needed
= 0;
3853 packet_len
= getpkt (own_buf
);
3854 if (packet_len
<= 0)
3857 /* Force an event loop break. */
3860 response_needed
= 1;
3867 handle_query (own_buf
, packet_len
, &new_packet_len
);
3870 handle_general_set (own_buf
);
3873 require_running (own_buf
);
3878 pid
= strtol (&own_buf
[i
], NULL
, 16);
3881 pid
= ptid_get_pid (current_ptid
);
3883 if ((tracing
&& disconnected_tracing
) || any_persistent_commands ())
3885 struct thread_resume resume_info
;
3886 struct process_info
*process
= find_process_pid (pid
);
3888 if (process
== NULL
)
3890 write_enn (own_buf
);
3894 if (tracing
&& disconnected_tracing
)
3896 "Disconnected tracing in effect, "
3897 "leaving gdbserver attached to the process\n");
3899 if (any_persistent_commands ())
3901 "Persistent commands are present, "
3902 "leaving gdbserver attached to the process\n");
3904 /* Make sure we're in non-stop/async mode, so we we can both
3905 wait for an async socket accept, and handle async target
3906 events simultaneously. There's also no point either in
3907 having the target stop all threads, when we're going to
3908 pass signals down without informing GDB. */
3912 debug_printf ("Forcing non-stop mode\n");
3918 process
->gdb_detached
= 1;
3920 /* Detaching implicitly resumes all threads. */
3921 resume_info
.thread
= minus_one_ptid
;
3922 resume_info
.kind
= resume_continue
;
3923 resume_info
.sig
= 0;
3924 (*the_target
->resume
) (&resume_info
, 1);
3927 break; /* from switch/case */
3930 fprintf (stderr
, "Detaching from process %d\n", pid
);
3932 if (detach_inferior (pid
) != 0)
3933 write_enn (own_buf
);
3936 discard_queued_stop_replies (pid_to_ptid (pid
));
3939 if (extended_protocol
|| target_running ())
3941 /* There is still at least one inferior remaining or
3942 we are in extended mode, so don't terminate gdbserver,
3943 and instead treat this like a normal program exit. */
3944 last_status
.kind
= TARGET_WAITKIND_EXITED
;
3945 last_status
.value
.integer
= 0;
3946 last_ptid
= pid_to_ptid (pid
);
3948 current_thread
= NULL
;
3955 /* If we are attached, then we can exit. Otherwise, we
3956 need to hang around doing nothing, until the child is
3958 join_inferior (pid
);
3964 extended_protocol
= 1;
3968 handle_status (own_buf
);
3971 if (own_buf
[1] == 'c' || own_buf
[1] == 'g' || own_buf
[1] == 's')
3973 ptid_t gdb_id
, thread_id
;
3976 require_running (own_buf
);
3978 gdb_id
= read_ptid (&own_buf
[2], NULL
);
3980 pid
= ptid_get_pid (gdb_id
);
3982 if (ptid_equal (gdb_id
, null_ptid
)
3983 || ptid_equal (gdb_id
, minus_one_ptid
))
3984 thread_id
= null_ptid
;
3986 && ptid_equal (pid_to_ptid (pid
),
3989 struct thread_info
*thread
=
3990 (struct thread_info
*) find_inferior (&all_threads
,
3995 write_enn (own_buf
);
3999 thread_id
= thread
->entry
.id
;
4003 thread_id
= gdb_id_to_thread_id (gdb_id
);
4004 if (ptid_equal (thread_id
, null_ptid
))
4006 write_enn (own_buf
);
4011 if (own_buf
[1] == 'g')
4013 if (ptid_equal (thread_id
, null_ptid
))
4015 /* GDB is telling us to choose any thread. Check if
4016 the currently selected thread is still valid. If
4017 it is not, select the first available. */
4018 struct thread_info
*thread
=
4019 (struct thread_info
*) find_inferior_id (&all_threads
,
4022 thread
= get_first_thread ();
4023 thread_id
= thread
->entry
.id
;
4026 general_thread
= thread_id
;
4027 set_desired_thread (1);
4028 gdb_assert (current_thread
!= NULL
);
4030 else if (own_buf
[1] == 'c')
4031 cont_thread
= thread_id
;
4037 /* Silently ignore it so that gdb can extend the protocol
4038 without compatibility headaches. */
4043 require_running (own_buf
);
4044 if (current_traceframe
>= 0)
4046 struct regcache
*regcache
4047 = new_register_cache (current_target_desc ());
4049 if (fetch_traceframe_registers (current_traceframe
,
4051 registers_to_string (regcache
, own_buf
);
4053 write_enn (own_buf
);
4054 free_register_cache (regcache
);
4058 struct regcache
*regcache
;
4060 if (!set_desired_thread (1))
4061 write_enn (own_buf
);
4064 regcache
= get_thread_regcache (current_thread
, 1);
4065 registers_to_string (regcache
, own_buf
);
4070 require_running (own_buf
);
4071 if (current_traceframe
>= 0)
4072 write_enn (own_buf
);
4075 struct regcache
*regcache
;
4077 if (!set_desired_thread (1))
4078 write_enn (own_buf
);
4081 regcache
= get_thread_regcache (current_thread
, 1);
4082 registers_from_string (regcache
, &own_buf
[1]);
4088 require_running (own_buf
);
4089 decode_m_packet (&own_buf
[1], &mem_addr
, &len
);
4090 res
= gdb_read_memory (mem_addr
, mem_buf
, len
);
4092 write_enn (own_buf
);
4094 bin2hex (mem_buf
, own_buf
, res
);
4097 require_running (own_buf
);
4098 decode_M_packet (&own_buf
[1], &mem_addr
, &len
, &mem_buf
);
4099 if (gdb_write_memory (mem_addr
, mem_buf
, len
) == 0)
4102 write_enn (own_buf
);
4105 require_running (own_buf
);
4106 if (decode_X_packet (&own_buf
[1], packet_len
- 1,
4107 &mem_addr
, &len
, &mem_buf
) < 0
4108 || gdb_write_memory (mem_addr
, mem_buf
, len
) != 0)
4109 write_enn (own_buf
);
4114 require_running (own_buf
);
4115 hex2bin (own_buf
+ 1, &sig
, 1);
4116 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4117 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4120 myresume (own_buf
, 0, signal
);
4123 require_running (own_buf
);
4124 hex2bin (own_buf
+ 1, &sig
, 1);
4125 if (gdb_signal_to_host_p ((enum gdb_signal
) sig
))
4126 signal
= gdb_signal_to_host ((enum gdb_signal
) sig
);
4129 myresume (own_buf
, 1, signal
);
4132 require_running (own_buf
);
4134 myresume (own_buf
, 0, signal
);
4137 require_running (own_buf
);
4139 myresume (own_buf
, 1, signal
);
4141 case 'Z': /* insert_ ... */
4143 case 'z': /* remove_ ... */
4148 char type
= own_buf
[1];
4150 const int insert
= ch
== 'Z';
4151 char *p
= &own_buf
[3];
4153 p
= unpack_varlen_hex (p
, &addr
);
4154 kind
= strtol (p
+ 1, &dataptr
, 16);
4158 struct breakpoint
*bp
;
4160 bp
= set_gdb_breakpoint (type
, addr
, kind
, &res
);
4165 /* GDB may have sent us a list of *point parameters to
4166 be evaluated on the target's side. Read such list
4167 here. If we already have a list of parameters, GDB
4168 is telling us to drop that list and use this one
4170 clear_breakpoint_conditions_and_commands (bp
);
4171 process_point_options (bp
, &dataptr
);
4175 res
= delete_gdb_breakpoint (type
, addr
, kind
);
4183 write_enn (own_buf
);
4187 response_needed
= 0;
4188 if (!target_running ())
4189 /* The packet we received doesn't make sense - but we can't
4190 reply to it, either. */
4193 fprintf (stderr
, "Killing all inferiors\n");
4194 for_each_inferior (&all_processes
, kill_inferior_callback
);
4196 /* When using the extended protocol, we wait with no program
4197 running. The traditional protocol will exit instead. */
4198 if (extended_protocol
)
4200 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4201 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4209 ptid_t gdb_id
, thread_id
;
4211 require_running (own_buf
);
4213 gdb_id
= read_ptid (&own_buf
[1], NULL
);
4214 thread_id
= gdb_id_to_thread_id (gdb_id
);
4215 if (ptid_equal (thread_id
, null_ptid
))
4217 write_enn (own_buf
);
4221 if (mythread_alive (thread_id
))
4224 write_enn (own_buf
);
4228 response_needed
= 0;
4230 /* Restarting the inferior is only supported in the extended
4232 if (extended_protocol
)
4234 if (target_running ())
4235 for_each_inferior (&all_processes
,
4236 kill_inferior_callback
);
4237 fprintf (stderr
, "GDBserver restarting\n");
4239 /* Wait till we are at 1st instruction in prog. */
4240 if (program_argv
!= NULL
)
4242 start_inferior (program_argv
);
4243 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4245 /* Stopped at the first instruction of the target
4247 general_thread
= last_ptid
;
4251 /* Something went wrong. */
4252 general_thread
= null_ptid
;
4257 last_status
.kind
= TARGET_WAITKIND_EXITED
;
4258 last_status
.value
.sig
= GDB_SIGNAL_KILL
;
4264 /* It is a request we don't understand. Respond with an
4265 empty packet so that gdb knows that we don't support this
4271 /* Extended (long) request. */
4272 handle_v_requests (own_buf
, packet_len
, &new_packet_len
);
4276 /* It is a request we don't understand. Respond with an empty
4277 packet so that gdb knows that we don't support this
4283 if (new_packet_len
!= -1)
4284 putpkt_binary (own_buf
, new_packet_len
);
4288 response_needed
= 0;
4296 /* Event-loop callback for serial events. */
4299 handle_serial_event (int err
, gdb_client_data client_data
)
4302 debug_printf ("handling possible serial event\n");
4304 /* Really handle it. */
4305 if (process_serial_event () < 0)
4308 /* Be sure to not change the selected thread behind GDB's back.
4309 Important in the non-stop mode asynchronous protocol. */
4310 set_desired_thread (1);
4315 /* Push a stop notification on the notification queue. */
4318 push_stop_notification (ptid_t ptid
, struct target_waitstatus
*status
)
4320 struct vstop_notif
*vstop_notif
= XNEW (struct vstop_notif
);
4322 vstop_notif
->status
= *status
;
4323 vstop_notif
->ptid
= ptid
;
4324 /* Push Stop notification. */
4325 notif_push (¬if_stop
, (struct notif_event
*) vstop_notif
);
4328 /* Event-loop callback for target events. */
4331 handle_target_event (int err
, gdb_client_data client_data
)
4334 debug_printf ("handling possible target event\n");
4336 last_ptid
= mywait (minus_one_ptid
, &last_status
,
4339 if (last_status
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4341 if (gdb_connected () && report_no_resumed
)
4342 push_stop_notification (null_ptid
, &last_status
);
4344 else if (last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4346 int pid
= ptid_get_pid (last_ptid
);
4347 struct process_info
*process
= find_process_pid (pid
);
4348 int forward_event
= !gdb_connected () || process
->gdb_detached
;
4350 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4351 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
)
4353 mark_breakpoints_out (process
);
4354 mourn_inferior (process
);
4356 else if (last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4360 /* We're reporting this thread as stopped. Update its
4361 "want-stopped" state to what the client wants, until it
4362 gets a new resume action. */
4363 current_thread
->last_resume_kind
= resume_stop
;
4364 current_thread
->last_status
= last_status
;
4369 if (!target_running ())
4371 /* The last process exited. We're done. */
4375 if (last_status
.kind
== TARGET_WAITKIND_EXITED
4376 || last_status
.kind
== TARGET_WAITKIND_SIGNALLED
4377 || last_status
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
4381 /* A thread stopped with a signal, but gdb isn't
4382 connected to handle it. Pass it down to the
4383 inferior, as if it wasn't being traced. */
4384 struct thread_resume resume_info
;
4387 debug_printf ("GDB not connected; forwarding event %d for"
4389 (int) last_status
.kind
,
4390 target_pid_to_str (last_ptid
));
4392 resume_info
.thread
= last_ptid
;
4393 resume_info
.kind
= resume_continue
;
4394 if (last_status
.kind
== TARGET_WAITKIND_STOPPED
)
4395 resume_info
.sig
= gdb_signal_to_host (last_status
.value
.sig
);
4397 resume_info
.sig
= 0;
4398 (*the_target
->resume
) (&resume_info
, 1);
4402 push_stop_notification (last_ptid
, &last_status
);
4405 /* Be sure to not change the selected thread behind GDB's back.
4406 Important in the non-stop mode asynchronous protocol. */
4407 set_desired_thread (1);