espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-20 01:50:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Non-stop mode support.

Browse Source 
* server.h (non_stop): Declare.
	(gdb_client_data, handler_func): Declare.
	(delete_file_handler, add_file_handler, start_event_loop):
	Declare.
	(handle_serial_event, handle_target_event, push_event)
	(putpkt_notif): Declare.
	* target.h (enum resume_kind): New.
	(struct thread_resume): Replace `step' field by `kind' field.
	(TARGET_WNOHANG): Define.
	(struct target_ops) <wait>: Add `options' argument.
	<supports_non_stop, async, start_non_stop>: New fields.
	(target_supports_non_stop, target_async): New.
	(start_non_stop): Declare.
	(mywait): Add `options' argument.
	* target.c (mywait): Add `options' argument.  Print child exit
	notifications here.
	(start_non_stop): New.
	* server.c (non_stop, own_buf, mem_buf): New globals.
	(struct vstop_notif): New.
	(notif_queue): New global.
	(queue_stop_reply, push_event, discard_queued_stop_replies)
	(send_next_stop_reply): New.
	(start_inferior): Adjust to use resume_kind.  Adjust to mywait
	interface changes.
	(attach_inferior): In non-stop mode, don't wait for the target
	here.
	(handle_general_set): Handle QNonStop.
	(handle_query): When handling qC, return the current general
	thread, instead of the first thread of the list.
	(handle_query): If the backend supports non-stop mode, include
	QNonStop+ in the qSupported query response.
	(handle_v_cont): Adjust to use resume_kind.  Handle resume_stop
	and non-stop mode.
	(handle_v_attach, handle_v_run): Handle non-stop mode.
	(handle_v_stopped): New.
	(handle_v_requests): Report support for vCont;t.  Handle vStopped.
	(myresume): Adjust to use resume_kind.  Handle non-stop.
	(queue_stop_reply_callback): New.
	(handle_status): Handle non-stop mode.
	(main): Clear non_stop flag on reconnection.  Use the event-loop.
	Refactor serial protocol handling from here ...
	(process_serial_event): ... to this new function.  When GDB
	selects any thread, select one here.  In non-stop mode, wait until
	GDB acks all pending events before exiting.
	(handle_serial_event, handle_target_event): New.
	* remote-utils.c (remote_open): Install remote_desc in the event
	loop.
	(remote_close): Remove remote_desc from the event loop.
	(putpkt_binary): Rename to...
	(putpkt_binary_1): ... this.  Add `is_notic' argument.  Handle it.
	(putpkt_binary): New as wrapper around putpkt_binary_1.
	(putpkt_notif): New.
	(prepare_resume_reply): In non-stop mode, don't change the
	general_thread.
	* event-loop.c: New.
	* Makefile.in (OBJ): Add event-loop.o.
	(event-loop.o): New rule.

	* linux-low.h (pid_of): Moved here.
	(lwpid_of): New.
	(get_lwp_thread): Use lwpid_of.
	(struct lwp_info): Delete `lwpid' field.  Add `suspended' field.
	* linux-low.c (pid_of): Delete.
	(inferior_pid): Use lwpid_of.
	(linux_event_pipe): New.
	(target_is_async_p): New.
	(delete_lwp): New.
	(handle_extended_wait): Use lwpid_of.
	(add_lwp): Don't set lwpid field.
	(linux_attach_lwp): Adjust debug output.  Use lwpid_of.
	(linux_kill_one_lwp): If killing a running lwp, stop it first.
	Use lwpid_of.  Adjust to linux_wait_for_event interface changes.
	(linux_detach_one_lwp): If detaching from a running lwp, stop it
	first.  Adjust to linux_wait_for_event interface changes.  Use
	lwpid_of.
	(linux_detach): Don't delete the main lwp here.
	(linux_join): Use my_waitpid.  Avoid signal_pid.  Use lwpid_of.
	(status_pending_p): Don't consider explicitly suspended lwps.
	(linux_wait_for_lwp): Take an integer pid instead of a lwp_info
	pointer.  Add OPTIONS argument.  Change return type to int.  Use
	my_waitpid instead of sleeping.  Handle WNOHANG.  Use lwpid_of.
	(linux_wait_for_event): Take an integer pid instead of a lwp_info
	pointer.  Add status pointer argument.  Return a pid instead of a
	status.  Use lwpid_of.  Adjust to linux_wait_for_lwp interface
	changes.  In non-stop mode, don't switch to a random thread.
	(linux_wait): Rename to...
	(linux_wait_1): ... this.  Add target_options argument, and handle
	it.  Adjust to use resume_kind.  Use lwpid_of.  In non-stop mode,
	don't handle the continue thread.  Handle TARGET_WNOHANG.  Merge
	clean exit and signal exit code.  Don't stop all threads in
	non-stop mode.  In all-stop mode, only stop all threads when
	reporting a stop to GDB.  Handle explicit thread stop requests.
	(async_file_flush, async_file_mark): New.
	(linux_wait): New.
	(send_sigstop): Use lwpid_of.
	(wait_for_sigstop): Use lwpid_of.  Adjust to linux_wait_for_event
	interface changes.  In non-stop mode, don't switch to a random
	thread.
	(linux_resume_one_lwp): Use lwpid_of.
	(linux_continue_one_thread, linux_queue_one_thread): Merge into ...
	(linux_resume_one_thread): ... this.  Handle resume_stop.  In
	non-stop mode, don't look for pending flag in all threads.
	(resume_status_pending_p): Don't consider explicitly suspended
	threads.
	(my_waitpid): Reimplement.  Emulate __WALL.
	(linux_request_interrupt, linux_read_offsets, linux_xfer_siginfo):
	Use lwpid_of.
	(sigchld_handler, linux_supports_non_stop, linux_async)
	(linux_start_non_stop): New.
	(linux_target_ops): Register linux_supports_non_stop, linux_async
	and linux_start_non_stop.
	(initialize_low): Install SIGCHLD handler.
	* thread-db.c (thread_db_create_event, find_one_thread)
	(thread_db_get_tls_address): Use lwpid_of.
	* win32-low.c (win32_detach): Adjust to use resume_kind.
	(win32_wait): Add `options' argument.
	* spu-low.c (spu_resume): Adjust to use resume_kind.
	(spu_wait): Add `options' argument.
This commit is contained in:
Pedro Alves
2009-04-01 22:48:05 +00:00
parent 5b1c542ea1
commit bd99dc8583
13 changed files with 2140 additions and 688 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
gdb/gdbserver/ChangeLog
View File

@ -1,3 +1,126 @@
2009-04-01 Pedro Alves <pedro@codesourcery.com>
Non-stop mode support.
* server.h (non_stop): Declare.
(gdb_client_data, handler_func): Declare.
(delete_file_handler, add_file_handler, start_event_loop):
Declare.
(handle_serial_event, handle_target_event, push_event)
(putpkt_notif): Declare.
* target.h (enum resume_kind): New.
(struct thread_resume): Replace `step' field by `kind' field.
(TARGET_WNOHANG): Define.
(struct target_ops) <wait>: Add `options' argument.
<supports_non_stop, async, start_non_stop>: New fields.
(target_supports_non_stop, target_async): New.
(start_non_stop): Declare.
(mywait): Add `options' argument.
* target.c (mywait): Add `options' argument. Print child exit
notifications here.
(start_non_stop): New.
* server.c (non_stop, own_buf, mem_buf): New globals.
(struct vstop_notif): New.
(notif_queue): New global.
(queue_stop_reply, push_event, discard_queued_stop_replies)
(send_next_stop_reply): New.
(start_inferior): Adjust to use resume_kind. Adjust to mywait
interface changes.
(attach_inferior): In non-stop mode, don't wait for the target
here.
(handle_general_set): Handle QNonStop.
(handle_query): When handling qC, return the current general
thread, instead of the first thread of the list.
(handle_query): If the backend supports non-stop mode, include
QNonStop+ in the qSupported query response.
(handle_v_cont): Adjust to use resume_kind. Handle resume_stop
and non-stop mode.
(handle_v_attach, handle_v_run): Handle non-stop mode.
(handle_v_stopped): New.
(handle_v_requests): Report support for vCont;t. Handle vStopped.
(myresume): Adjust to use resume_kind. Handle non-stop.
(queue_stop_reply_callback): New.
(handle_status): Handle non-stop mode.
(main): Clear non_stop flag on reconnection. Use the event-loop.
Refactor serial protocol handling from here ...
(process_serial_event): ... to this new function. When GDB
selects any thread, select one here. In non-stop mode, wait until
GDB acks all pending events before exiting.
(handle_serial_event, handle_target_event): New.
* remote-utils.c (remote_open): Install remote_desc in the event
loop.
(remote_close): Remove remote_desc from the event loop.
(putpkt_binary): Rename to...
(putpkt_binary_1): ... this. Add `is_notic' argument. Handle it.
(putpkt_binary): New as wrapper around putpkt_binary_1.
(putpkt_notif): New.
(prepare_resume_reply): In non-stop mode, don't change the
general_thread.
* event-loop.c: New.
* Makefile.in (OBJ): Add event-loop.o.
(event-loop.o): New rule.
* linux-low.h (pid_of): Moved here.
(lwpid_of): New.
(get_lwp_thread): Use lwpid_of.
(struct lwp_info): Delete `lwpid' field. Add `suspended' field.
* linux-low.c (pid_of): Delete.
(inferior_pid): Use lwpid_of.
(linux_event_pipe): New.
(target_is_async_p): New.
(delete_lwp): New.
(handle_extended_wait): Use lwpid_of.
(add_lwp): Don't set lwpid field.
(linux_attach_lwp): Adjust debug output. Use lwpid_of.
(linux_kill_one_lwp): If killing a running lwp, stop it first.
Use lwpid_of. Adjust to linux_wait_for_event interface changes.
(linux_detach_one_lwp): If detaching from a running lwp, stop it
first. Adjust to linux_wait_for_event interface changes. Use
lwpid_of.
(linux_detach): Don't delete the main lwp here.
(linux_join): Use my_waitpid. Avoid signal_pid. Use lwpid_of.
(status_pending_p): Don't consider explicitly suspended lwps.
(linux_wait_for_lwp): Take an integer pid instead of a lwp_info
pointer. Add OPTIONS argument. Change return type to int. Use
my_waitpid instead of sleeping. Handle WNOHANG. Use lwpid_of.
(linux_wait_for_event): Take an integer pid instead of a lwp_info
pointer. Add status pointer argument. Return a pid instead of a
status. Use lwpid_of. Adjust to linux_wait_for_lwp interface
changes. In non-stop mode, don't switch to a random thread.
(linux_wait): Rename to...
(linux_wait_1): ... this. Add target_options argument, and handle
it. Adjust to use resume_kind. Use lwpid_of. In non-stop mode,
don't handle the continue thread. Handle TARGET_WNOHANG. Merge
clean exit and signal exit code. Don't stop all threads in
non-stop mode. In all-stop mode, only stop all threads when
reporting a stop to GDB. Handle explicit thread stop requests.
(async_file_flush, async_file_mark): New.
(linux_wait): New.
(send_sigstop): Use lwpid_of.
(wait_for_sigstop): Use lwpid_of. Adjust to linux_wait_for_event
interface changes. In non-stop mode, don't switch to a random
thread.
(linux_resume_one_lwp): Use lwpid_of.
(linux_continue_one_thread, linux_queue_one_thread): Merge into ...
(linux_resume_one_thread): ... this. Handle resume_stop. In
non-stop mode, don't look for pending flag in all threads.
(resume_status_pending_p): Don't consider explicitly suspended
threads.
(my_waitpid): Reimplement. Emulate __WALL.
(linux_request_interrupt, linux_read_offsets, linux_xfer_siginfo):
Use lwpid_of.
(sigchld_handler, linux_supports_non_stop, linux_async)
(linux_start_non_stop): New.
(linux_target_ops): Register linux_supports_non_stop, linux_async
and linux_start_non_stop.
(initialize_low): Install SIGCHLD handler.
* thread-db.c (thread_db_create_event, find_one_thread)
(thread_db_get_tls_address): Use lwpid_of.
* win32-low.c (win32_detach): Adjust to use resume_kind.
(win32_wait): Add `options' argument.
* spu-low.c (spu_resume): Adjust to use resume_kind.
(spu_wait): Add `options' argument.
2009-04-01 Pedro Alves <pedro@codesourcery.com> 2009-04-01 Pedro Alves <pedro@codesourcery.com>
Decouple target code from remote protocol. Decouple target code from remote protocol.

3
gdb/gdbserver/Makefile.in
View File

@ -126,7 +126,7 @@ TAGFILES = $(SOURCES) ${HFILES} ${ALLPARAM} ${POSSLIBS}
OBS = inferiors.o regcache.o remote-utils.o server.o signals.o target.o \ OBS = inferiors.o regcache.o remote-utils.o server.o signals.o target.o \
utils.o version.o \ utils.o version.o \
mem-break.o hostio.o \ mem-break.o hostio.o event-loop.o \
$(XML_BUILTIN) \ $(XML_BUILTIN) \
$(DEPFILES) $(LIBOBJS) $(DEPFILES) $(LIBOBJS)
GDBREPLAY_OBS = gdbreplay.o version.o GDBREPLAY_OBS = gdbreplay.o version.o
@ -267,6 +267,7 @@ server_h = $(srcdir)/server.h $(regcache_h) config.h $(srcdir)/target.h \
linux_low_h = $(srcdir)/linux-low.h linux_low_h = $(srcdir)/linux-low.h
event-loop.o: event-loop.c $(server_h)
hostio.o: hostio.c $(server_h) hostio.o: hostio.c $(server_h)
hostio-errno.o: hostio-errno.c $(server_h) hostio-errno.o: hostio-errno.c $(server_h)
inferiors.o: inferiors.c $(server_h) inferiors.o: inferiors.c $(server_h)

504
gdb/gdbserver/event-loop.c Normal file
View File

@ -0,0 +1,504 @@
/* Event loop machinery for the remote server for GDB.
Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Based on src/gdb/event-loop.c. */
#include "server.h"
#include <sys/types.h>
#include <string.h>
#include <sys/time.h>
#ifdef USE_WIN32API
#include <windows.h>
#include <io.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
typedef struct gdb_event gdb_event;
typedef void (event_handler_func) (int);
/* Tell create_file_handler what events we are interested in. */
#define GDB_READABLE (1<<1)
#define GDB_WRITABLE (1<<2)
#define GDB_EXCEPTION (1<<3)
/* Events are queued by calling async_queue_event and serviced later
on by do_one_event. An event can be, for instance, a file
descriptor becoming ready to be read. Servicing an event simply
means that the procedure PROC will be called. We have 2 queues,
one for file handlers that we listen to in the event loop, and one
for the file handlers+events that are ready. The procedure PROC
associated with each event is always the same (handle_file_event).
Its duty is to invoke the handler associated with the file
descriptor whose state change generated the event, plus doing other
cleanups and such. */
struct gdb_event
{
/* Procedure to call to service this event. */
event_handler_func *proc;
/* File descriptor that is ready. */
int fd;
/* Next in list of events or NULL. */
struct gdb_event *next_event;
};
/* Information about each file descriptor we register with the event
loop. */
typedef struct file_handler
{
/* File descriptor. */
int fd;
/* Events we want to monitor. */
int mask;
/* Events that have been seen since the last time. */
int ready_mask;
/* Procedure to call when fd is ready. */
handler_func *proc;
/* Argument to pass to proc. */
gdb_client_data client_data;
/* Was an error detected on this fd? */
int error;
/* Next registered file descriptor. */
struct file_handler *next_file;
}
file_handler;
/* Event queue:
Events can be inserted at the front of the queue or at the end of
the queue. Events will be extracted from the queue for processing
starting from the head. Therefore, events inserted at the head of
the queue will be processed in a last in first out fashion, while
those inserted at the tail of the queue will be processed in a
first in first out manner. All the fields are NULL if the queue is
empty. */
static struct
{
/* The first pending event. */
gdb_event *first_event;
/* The last pending event. */
gdb_event *last_event;
}
event_queue;
/* Gdb_notifier is just a list of file descriptors gdb is interested
in. These are the input file descriptor, and the target file
descriptor. Each of the elements in the gdb_notifier list is
basically a description of what kind of events gdb is interested
in, for each fd. */
static struct
{
/* Ptr to head of file handler list. */
file_handler *first_file_handler;
/* Masks to be used in the next call to select. Bits are set in
response to calls to create_file_handler. */
fd_set check_masks[3];
/* What file descriptors were found ready by select. */
fd_set ready_masks[3];
/* Number of valid bits (highest fd value + 1). (for select) */
int num_fds;
}
gdb_notifier;
/* Insert an event object into the gdb event queue.
EVENT_PTR points to the event to be inserted into the queue. The
caller must allocate memory for the event. It is freed after the
event has ben handled. Events in the queue will be processed head
to tail, therefore, events will be processed first in first
out. */
static void
async_queue_event (gdb_event *event_ptr)
{
/* The event will become the new last_event. */
event_ptr->next_event = NULL;
if (event_queue.first_event == NULL)
event_queue.first_event = event_ptr;
else
event_queue.last_event->next_event = event_ptr;
event_queue.last_event = event_ptr;
}
/* Process one event. If an event was processed, 1 is returned
otherwise 0 is returned. Scan the queue from head to tail,
processing therefore the high priority events first, by invoking
the associated event handler procedure. */
static int
process_event (void)
{
gdb_event *event_ptr, *prev_ptr;
event_handler_func *proc;
int fd;
/* Look in the event queue to find an event that is ready
to be processed. */
for (event_ptr = event_queue.first_event;
event_ptr != NULL;
event_ptr = event_ptr->next_event)
{
/* Call the handler for the event. */
proc = event_ptr->proc;
fd = event_ptr->fd;
/* Let's get rid of the event from the event queue. We need to
do this now because while processing the event, since the
proc function could end up jumping out to the caller of this
function. In that case, we would have on the event queue an
event which has been processed, but not deleted. */
if (event_queue.first_event == event_ptr)
{
event_queue.first_event = event_ptr->next_event;
if (event_ptr->next_event == NULL)
event_queue.last_event = NULL;
}
else
{
prev_ptr = event_queue.first_event;
while (prev_ptr->next_event != event_ptr)
prev_ptr = prev_ptr->next_event;
prev_ptr->next_event = event_ptr->next_event;
if (event_ptr->next_event == NULL)
event_queue.last_event = prev_ptr;
}
free (event_ptr);
/* Now call the procedure associated with the event. */
(*proc) (fd);
return 1;
}
/* This is the case if there are no event on the event queue. */
return 0;
}
/* Add a file handler/descriptor to the list of descriptors we are
interested in. FD is the file descriptor for the file/stream to be
listened to. MASK is a combination of READABLE, WRITABLE,
EXCEPTION. PROC is the procedure that will be called when an event
occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
static void
create_file_handler (int fd, int mask, handler_func *proc,
gdb_client_data client_data)
{
file_handler *file_ptr;
/* Do we already have a file handler for this file? (We may be
changing its associated procedure). */
for (file_ptr = gdb_notifier.first_file_handler;
file_ptr != NULL;
file_ptr = file_ptr->next_file)
if (file_ptr->fd == fd)
break;
/* It is a new file descriptor. Add it to the list. Otherwise,
just change the data associated with it. */
if (file_ptr == NULL)
{
file_ptr = xmalloc (sizeof (*file_ptr));
file_ptr->fd = fd;
file_ptr->ready_mask = 0;
file_ptr->next_file = gdb_notifier.first_file_handler;
gdb_notifier.first_file_handler = file_ptr;
if (mask & GDB_READABLE)
FD_SET (fd, &gdb_notifier.check_masks[0]);
else
FD_CLR (fd, &gdb_notifier.check_masks[0]);
if (mask & GDB_WRITABLE)
FD_SET (fd, &gdb_notifier.check_masks[1]);
else
FD_CLR (fd, &gdb_notifier.check_masks[1]);
if (mask & GDB_EXCEPTION)
FD_SET (fd, &gdb_notifier.check_masks[2]);
else
FD_CLR (fd, &gdb_notifier.check_masks[2]);
if (gdb_notifier.num_fds <= fd)
gdb_notifier.num_fds = fd + 1;
}
file_ptr->proc = proc;
file_ptr->client_data = client_data;
file_ptr->mask = mask;
}
/* Wrapper function for create_file_handler. */
void
add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
{
create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
}
/* Remove the file descriptor FD from the list of monitored fd's:
i.e. we don't care anymore about events on the FD. */
void
delete_file_handler (int fd)
{
file_handler *file_ptr, *prev_ptr = NULL;
int i;
/* Find the entry for the given file. */
for (file_ptr = gdb_notifier.first_file_handler;
file_ptr != NULL;
file_ptr = file_ptr->next_file)
if (file_ptr->fd == fd)
break;
if (file_ptr == NULL)
return;
if (file_ptr->mask & GDB_READABLE)
FD_CLR (fd, &gdb_notifier.check_masks[0]);
if (file_ptr->mask & GDB_WRITABLE)
FD_CLR (fd, &gdb_notifier.check_masks[1]);
if (file_ptr->mask & GDB_EXCEPTION)
FD_CLR (fd, &gdb_notifier.check_masks[2]);
/* Find current max fd. */
if ((fd + 1) == gdb_notifier.num_fds)
{
gdb_notifier.num_fds--;
for (i = gdb_notifier.num_fds; i; i--)
{
if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
|| FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
|| FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
break;
}
gdb_notifier.num_fds = i;
}
/* Deactivate the file descriptor, by clearing its mask, so that it
will not fire again. */
file_ptr->mask = 0;
/* Get rid of the file handler in the file handler list. */
if (file_ptr == gdb_notifier.first_file_handler)
gdb_notifier.first_file_handler = file_ptr->next_file;
else
{
for (prev_ptr = gdb_notifier.first_file_handler;
prev_ptr->next_file != file_ptr;
prev_ptr = prev_ptr->next_file)
;
prev_ptr->next_file = file_ptr->next_file;
}
free (file_ptr);
}
/* Handle the given event by calling the procedure associated to the
corresponding file handler. Called by process_event indirectly,
through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
event in the front of the event queue. */
static void
handle_file_event (int event_file_desc)
{
file_handler *file_ptr;
int mask;
/* Search the file handler list to find one that matches the fd in
the event. */
for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
file_ptr = file_ptr->next_file)
{
if (file_ptr->fd == event_file_desc)
{
/* See if the desired events (mask) match the received
events (ready_mask). */
if (file_ptr->ready_mask & GDB_EXCEPTION)
{
fprintf (stderr, "Exception condition detected on fd %d\n",
file_ptr->fd);
file_ptr->error = 1;
}
else
file_ptr->error = 0;
mask = file_ptr->ready_mask & file_ptr->mask;
/* Clear the received events for next time around. */
file_ptr->ready_mask = 0;
/* If there was a match, then call the handler. */
if (mask != 0)
(*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
break;
}
}
}
/* Create a file event, to be enqueued in the event queue for
processing. The procedure associated to this event is always
handle_file_event, which will in turn invoke the one that was
associated to FD when it was registered with the event loop. */
static gdb_event *
create_file_event (int fd)
{
gdb_event *file_event_ptr;
file_event_ptr = xmalloc (sizeof (gdb_event));
file_event_ptr->proc = handle_file_event;
file_event_ptr->fd = fd;
return file_event_ptr;
}
/* Called by do_one_event to wait for new events on the monitored file
descriptors. Queue file events as they are detected by the poll.
If there are no events, this function will block in the call to
select. Return -1 if there are no files descriptors to monitor,
otherwise return 0. */
static int
wait_for_event (void)
{
file_handler *file_ptr;
gdb_event *file_event_ptr;
int num_found = 0;
/* Make sure all output is done before getting another event. */
fflush (stdout);
fflush (stderr);
if (gdb_notifier.num_fds == 0)
return -1;
gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
num_found = select (gdb_notifier.num_fds,
&gdb_notifier.ready_masks[0],
&gdb_notifier.ready_masks[1],
&gdb_notifier.ready_masks[2],
NULL);
/* Clear the masks after an error from select. */
if (num_found == -1)
{
FD_ZERO (&gdb_notifier.ready_masks[0]);
FD_ZERO (&gdb_notifier.ready_masks[1]);
FD_ZERO (&gdb_notifier.ready_masks[2]);
#ifdef EINTR
/* Dont print anything if we got a signal, let gdb handle
it. */
if (errno != EINTR)
perror_with_name ("select");
#endif
}
/* Enqueue all detected file events. */
for (file_ptr = gdb_notifier.first_file_handler;
file_ptr != NULL && num_found > 0;
file_ptr = file_ptr->next_file)
{
int mask = 0;
if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
mask |= GDB_READABLE;
if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
mask |= GDB_WRITABLE;
if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
mask |= GDB_EXCEPTION;
if (!mask)
continue;
else
num_found--;
/* Enqueue an event only if this is still a new event for this
fd. */
if (file_ptr->ready_mask == 0)
{
file_event_ptr = create_file_event (file_ptr->fd);
async_queue_event (file_event_ptr);
}
file_ptr->ready_mask = mask;
}
return 0;
}
/* Start up the event loop. This is the entry point to the event
loop. */
void
start_event_loop (void)
{
/* Loop until there is nothing to do. This is the entry point to
the event loop engine. If nothing is ready at this time, wait
for something to happen (via wait_for_event), then process it.
Return when there are no longer event sources to wait for. */
while (1)
{
/* Any events already waiting in the queue? */
if (process_event ())
continue;
/* Wait for a new event. If wait_for_event returns -1, we
should get out because this means that there are no event
sources left. This will make the event loop stop, and the
application exit. */
if (wait_for_event () < 0)
return;
}
/* We are done with the event loop. There are no more event sources
to listen to. So we exit gdbserver. */
}

883
gdb/gdbserver/linux-low.c
View File

File diff suppressed because it is too large Load Diff

13
gdb/gdbserver/linux-low.h
View File

@ -78,16 +78,18 @@ struct linux_target_ops
extern struct linux_target_ops the_low_target; extern struct linux_target_ops the_low_target;
#define pid_of(proc) ((proc)->head.id)
#define lwpid_of(proc) ((proc)->head.id)
#define get_lwp(inf) ((struct lwp_info *)(inf)) #define get_lwp(inf) ((struct lwp_info *)(inf))
#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr))) #define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
#define get_lwp_thread(proc) ((struct thread_info *) \ #define get_lwp_thread(proc) ((struct thread_info *) \
find_inferior_id (&all_threads, \ find_inferior_id (&all_threads, \
get_lwp (proc)->lwpid)) lwpid_of (get_lwp (proc))))
struct lwp_info struct lwp_info
{ {
struct inferior_list_entry head; struct inferior_list_entry head;
unsigned long lwpid;
/* If this flag is set, the next SIGSTOP will be ignored (the /* If this flag is set, the next SIGSTOP will be ignored (the
process will be immediately resumed). This means that either we process will be immediately resumed). This means that either we
@ -97,11 +99,14 @@ struct lwp_info
yet. */ yet. */
int stop_expected; int stop_expected;
/* If this flag is set, the process is known to be stopped right now (stop /* True if this thread was suspended (with vCont;t). */
int suspended;
/* If this flag is set, the lwp is known to be stopped right now (stop
event already received in a wait()). */ event already received in a wait()). */
int stopped; int stopped;
/* When stopped is set, the last wait status recorded for this process. */ /* When stopped is set, the last wait status recorded for this lwp. */
int last_status; int last_status;
/* If this flag is set, STATUS_PENDING is a waitstatus that has not yet /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet

32
gdb/gdbserver/remote-utils.c
View File

@ -286,11 +286,16 @@ remote_open (char *name)
fcntl (remote_desc, F_SETOWN, getpid ()); fcntl (remote_desc, F_SETOWN, getpid ());
#endif #endif
#endif #endif
/* Register the event loop handler. */
add_file_handler (remote_desc, handle_serial_event, NULL);
} }
void void
remote_close (void) remote_close (void)
{ {
delete_file_handler (remote_desc);
#ifdef USE_WIN32API #ifdef USE_WIN32API
closesocket (remote_desc); closesocket (remote_desc);
#else #else
@ -522,8 +527,8 @@ try_rle (char *buf, int remaining, unsigned char *csum, char **p)
The data of the packet is in BUF, and the length of the The data of the packet is in BUF, and the length of the
packet is in CNT. Returns >= 0 on success, -1 otherwise. */ packet is in CNT. Returns >= 0 on success, -1 otherwise. */
int static int
putpkt_binary (char *buf, int cnt) putpkt_binary_1 (char *buf, int cnt, int is_notif)
{ {
int i; int i;
unsigned char csum = 0; unsigned char csum = 0;
@ -537,6 +542,9 @@ putpkt_binary (char *buf, int cnt)
and giving it a checksum. */ and giving it a checksum. */
p = buf2; p = buf2;
if (is_notif)
*p++ = '%';
else
*p++ = '$'; *p++ = '$';
for (i = 0; i < cnt;) for (i = 0; i < cnt;)
@ -561,11 +569,14 @@ putpkt_binary (char *buf, int cnt)
return -1; return -1;
} }
if (noack_mode) if (noack_mode || is_notif)
{ {
/* Don't expect an ack then. */ /* Don't expect an ack then. */
if (remote_debug) if (remote_debug)
{ {
if (is_notif)
fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
else
fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2); fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
fflush (stderr); fflush (stderr);
} }
@ -605,6 +616,12 @@ putpkt_binary (char *buf, int cnt)
return 1; /* Success! */ return 1; /* Success! */
} }
int
putpkt_binary (char *buf, int cnt)
{
return putpkt_binary_1 (buf, cnt, 0);
}
/* Send a packet to the remote machine, with error checking. The data /* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF, and the packet should be a NUL-terminated of the packet is in BUF, and the packet should be a NUL-terminated
string. Returns >= 0 on success, -1 otherwise. */ string. Returns >= 0 on success, -1 otherwise. */
@ -615,6 +632,12 @@ putpkt (char *buf)
return putpkt_binary (buf, strlen (buf)); return putpkt_binary (buf, strlen (buf));
} }
int
putpkt_notif (char *buf)
{
return putpkt_binary_1 (buf, strlen (buf), 1);
}
/* Come here when we get an input interrupt from the remote side. This /* Come here when we get an input interrupt from the remote side. This
interrupt should only be active while we are waiting for the child to do interrupt should only be active while we are waiting for the child to do
something. About the only thing that should come through is a ^C, which something. About the only thing that should come through is a ^C, which
@ -1000,6 +1023,9 @@ prepare_resume_reply (char *buf, unsigned long ptid,
gdbserver to know what inferior_ptid is. */ gdbserver to know what inferior_ptid is. */
if (1 || general_thread != ptid) if (1 || general_thread != ptid)
{ {
/* In non-stop, don't change the general thread behind
GDB's back. */
if (!non_stop)
general_thread = ptid; general_thread = ptid;
sprintf (buf, "thread:%lx;", ptid); sprintf (buf, "thread:%lx;", ptid);
buf += strlen (buf); buf += strlen (buf);

490
gdb/gdbserver/server.c
View File

@ -43,6 +43,8 @@ static int attached;
static int response_needed; static int response_needed;
static int exit_requested; static int exit_requested;
int non_stop;
static char **program_argv, **wrapper_argv; static char **program_argv, **wrapper_argv;
/* Enable miscellaneous debugging output. The name is historical - it /* Enable miscellaneous debugging output. The name is historical - it
@ -90,6 +92,113 @@ int disable_packet_qfThreadInfo;
static struct target_waitstatus last_status; static struct target_waitstatus last_status;
static unsigned long last_ptid; static unsigned long last_ptid;
static char *own_buf;
static unsigned char *mem_buf;
/* Structure holding information relative to a single stop reply. We
keep a queue of these (really a singly-linked list) to push to GDB
in non-stop mode. */
struct vstop_notif
{
/* Pointer to next in list. */
struct vstop_notif *next;
/* Thread or process that got the event. */
unsigned long ptid;
/* Event info. */
struct target_waitstatus status;
};
/* The pending stop replies list head. */
static struct vstop_notif *notif_queue = NULL;
/* Put a stop reply to the stop reply queue. */
static void
queue_stop_reply (unsigned long ptid, struct target_waitstatus *status)
{
struct vstop_notif *new_notif;
new_notif = malloc (sizeof (*new_notif));
new_notif->next = NULL;
new_notif->ptid = ptid;
new_notif->status = *status;
if (notif_queue)
{
struct vstop_notif *tail;
for (tail = notif_queue;
tail && tail->next;
tail = tail->next)
;
tail->next = new_notif;
}
else
notif_queue = new_notif;
if (remote_debug)
{
int i = 0;
struct vstop_notif *n;
for (n = notif_queue; n; n = n->next)
i++;
fprintf (stderr, "pending stop replies: %d\n", i);
}
}
/* Place an event in the stop reply queue, and push a notification if
we aren't sending one yet. */
void
push_event (unsigned long ptid, struct target_waitstatus *status)
{
queue_stop_reply (ptid, status);
/* If this is the first stop reply in the queue, then inform GDB
about it, by sending a Stop notification. */
if (notif_queue->next == NULL)
{
char *p = own_buf;
strcpy (p, "Stop:");
p += strlen (p);
prepare_resume_reply (p,
notif_queue->ptid, &notif_queue->status);
putpkt_notif (own_buf);
}
}
/* Get rid of the currently pending stop replies. */
static void
discard_queued_stop_replies (void)
{
struct vstop_notif *next;
while (notif_queue)
{
next = notif_queue->next;
notif_queue = next;
free (next);
}
}
/* If there are more stop replies to push, push one now. */
static void
send_next_stop_reply (char *own_buf)
{
if (notif_queue)
prepare_resume_reply (own_buf,
notif_queue->ptid,
&notif_queue->status);
else
write_ok (own_buf);
}
static int static int
target_running (void) target_running (void)
{ {
@ -147,10 +256,11 @@ start_inferior (char **argv)
unsigned long ptid; unsigned long ptid;
resume_info.thread = -1; resume_info.thread = -1;
resume_info.step = 0; resume_info.kind = resume_continue;
resume_info.sig = 0; resume_info.sig = 0;
ptid = mywait (&last_status, 0); ptid = mywait (&last_status, 0, 0);
if (last_status.kind != TARGET_WAITKIND_STOPPED) if (last_status.kind != TARGET_WAITKIND_STOPPED)
return signal_pid; return signal_pid;
@ -158,7 +268,7 @@ start_inferior (char **argv)
{ {
(*the_target->resume) (&resume_info, 1); (*the_target->resume) (&resume_info, 1);
mywait (&last_status, 0); mywait (&last_status, 0, 0);
if (last_status.kind != TARGET_WAITKIND_STOPPED) if (last_status.kind != TARGET_WAITKIND_STOPPED)
return signal_pid; return signal_pid;
} }
@ -169,7 +279,7 @@ start_inferior (char **argv)
/* Wait till we are at 1st instruction in program, return new pid /* Wait till we are at 1st instruction in program, return new pid
(assuming success). */ (assuming success). */
last_ptid = mywait (&last_status, 0); last_ptid = mywait (&last_status, 0, 0);
return signal_pid; return signal_pid;
} }
@ -193,7 +303,9 @@ attach_inferior (int pid)
whichever we were told to attach to. */ whichever we were told to attach to. */
signal_pid = pid; signal_pid = pid;
last_ptid = mywait (&last_status, 0); if (!non_stop)
{
last_ptid = mywait (&last_status, 0, 0);
/* GDB knows to ignore the first SIGSTOP after attaching to a running /* GDB knows to ignore the first SIGSTOP after attaching to a running
process using the "attach" command, but this is different; it's process using the "attach" command, but this is different; it's
@ -201,6 +313,7 @@ attach_inferior (int pid)
if (last_status.kind == TARGET_WAITKIND_STOPPED if (last_status.kind == TARGET_WAITKIND_STOPPED
&& last_status.value.sig == TARGET_SIGNAL_STOP) && last_status.value.sig == TARGET_SIGNAL_STOP)
last_status.value.sig = TARGET_SIGNAL_TRAP; last_status.value.sig = TARGET_SIGNAL_TRAP;
}
return 0; return 0;
} }
@ -288,6 +401,43 @@ handle_general_set (char *own_buf)
return; return;
} }
if (strncmp (own_buf, "QNonStop:", 9) == 0)
{
char *mode = own_buf + 9;
int req = -1;
char *req_str;
if (strcmp (mode, "0") == 0)
req = 0;
else if (strcmp (mode, "1") == 0)
req = 1;
else
{
/* We don't know what this mode is, so complain to
GDB. */
fprintf (stderr, "Unknown non-stop mode requested: %s\n",
own_buf);
write_enn (own_buf);
return;
}
req_str = req ? "non-stop" : "all-stop";
if (start_non_stop (req) != 0)
{
fprintf (stderr, "Setting %s mode failed\n", req_str);
write_enn (own_buf);
return;
}
non_stop = req;
if (remote_debug)
fprintf (stderr, "[%s mode enabled]\n", req_str);
write_ok (own_buf);
return;
}
/* Otherwise we didn't know what packet it was. Say we didn't /* Otherwise we didn't know what packet it was. Say we didn't
understand it. */ understand it. */
own_buf[0] = 0; own_buf[0] = 0;
@ -506,10 +656,18 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
/* Reply the current thread id. */ /* Reply the current thread id. */
if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC) if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
{ {
unsigned long gdb_id;
require_running (own_buf); require_running (own_buf);
if (general_thread != 0 && general_thread != -1)
gdb_id = general_thread;
else
{
thread_ptr = all_threads.head; thread_ptr = all_threads.head;
sprintf (own_buf, "QC%x", gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
thread_to_gdb_id ((struct thread_info *)thread_ptr)); }
sprintf (own_buf, "QC%lx", gdb_id);
return; return;
} }
@ -915,6 +1073,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
if (the_target->qxfer_osdata != NULL) if (the_target->qxfer_osdata != NULL)
strcat (own_buf, ";qXfer:osdata:read+"); strcat (own_buf, ";qXfer:osdata:read+");
if (target_supports_non_stop ())
strcat (own_buf, ";QNonStop+");
return; return;
} }
@ -925,7 +1086,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
char *p = own_buf + 12; char *p = own_buf + 12;
CORE_ADDR parts[2], address = 0; CORE_ADDR parts[2], address = 0;
int i, err; int i, err;
unsigned long ptid; unsigned long ptid = 0;
require_running (own_buf); require_running (own_buf);
@ -1088,9 +1249,11 @@ handle_v_cont (char *own_buf)
p++; p++;
if (p[0] == 's' || p[0] == 'S') if (p[0] == 's' || p[0] == 'S')
resume_info[i].step = 1; resume_info[i].kind = resume_step;
else if (p[0] == 'c' || p[0] == 'C') else if (p[0] == 'c' || p[0] == 'C')
resume_info[i].step = 0; resume_info[i].kind = resume_continue;
else if (p[0] == 't')
resume_info[i].kind = resume_stop;
else else
goto err; goto err;
@ -1145,20 +1308,29 @@ handle_v_cont (char *own_buf)
resume_info[i] = default_action; resume_info[i] = default_action;
/* Still used in occasional places in the backend. */ /* Still used in occasional places in the backend. */
if (n == 1 && resume_info[0].thread != -1) if (n == 1
&& resume_info[0].thread != -1
&& resume_info[0].kind != resume_stop)
cont_thread = resume_info[0].thread; cont_thread = resume_info[0].thread;
else else
cont_thread = -1; cont_thread = -1;
set_desired_inferior (0); set_desired_inferior (0);
if (!non_stop)
enable_async_io (); enable_async_io ();
(*the_target->resume) (resume_info, n); (*the_target->resume) (resume_info, n);
free (resume_info); free (resume_info);
last_ptid = mywait (&last_status, 1); if (non_stop)
write_ok (own_buf);
else
{
last_ptid = mywait (&last_status, 0, 1);
prepare_resume_reply (own_buf, last_ptid, &last_status); prepare_resume_reply (own_buf, last_ptid, &last_status);
disable_async_io (); disable_async_io ();
}
return; return;
err: err:
@ -1181,7 +1353,17 @@ handle_v_attach (char *own_buf)
library list. Avoids the "stopped by shared library event" library list. Avoids the "stopped by shared library event"
notice on the GDB side. */ notice on the GDB side. */
dlls_changed = 0; dlls_changed = 0;
if (non_stop)
{
/* In non-stop, we don't send a resume reply. Stop events
will follow up using the normal notification
mechanism. */
write_ok (own_buf);
}
else
prepare_resume_reply (own_buf, last_ptid, &last_status); prepare_resume_reply (own_buf, last_ptid, &last_status);
return 1; return 1;
} }
else else
@ -1264,6 +1446,13 @@ handle_v_run (char *own_buf)
if (last_status.kind == TARGET_WAITKIND_STOPPED) if (last_status.kind == TARGET_WAITKIND_STOPPED)
{ {
prepare_resume_reply (own_buf, last_ptid, &last_status); prepare_resume_reply (own_buf, last_ptid, &last_status);
/* In non-stop, sending a resume reply doesn't set the general
thread, but GDB assumes a vRun sets it (this is so GDB can
query which is the main thread of the new inferior. */
if (non_stop)
general_thread = last_ptid;
return 1; return 1;
} }
else else
@ -1273,6 +1462,28 @@ handle_v_run (char *own_buf)
} }
} }
/* Handle a 'vStopped' packet. */
static void
handle_v_stopped (char *own_buf)
{
/* If we're waiting for GDB to acknowledge a pending stop reply,
consider that done. */
if (notif_queue)
{
struct vstop_notif *head;
if (remote_debug)
fprintf (stderr, "vStopped: acking %ld\n", notif_queue->ptid);
head = notif_queue;
notif_queue = notif_queue->next;
free (head);
}
/* Push another stop reply, or if there are no more left, an OK. */
send_next_stop_reply (own_buf);
}
/* Handle all of the extended 'v' packets. */ /* Handle all of the extended 'v' packets. */
void void
handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
@ -1288,7 +1499,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
if (strncmp (own_buf, "vCont?", 6) == 0) if (strncmp (own_buf, "vCont?", 6) == 0)
{ {
strcpy (own_buf, "vCont;c;C;s;S"); strcpy (own_buf, "vCont;c;C;s;S;t");
return; return;
} }
} }
@ -1321,12 +1532,21 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
return; return;
} }
if (strncmp (own_buf, "vStopped", 8) == 0)
{
handle_v_stopped (own_buf);
return;
}
/* Otherwise we didn't know what packet it was. Say we didn't /* Otherwise we didn't know what packet it was. Say we didn't
understand it. */ understand it. */
own_buf[0] = 0; own_buf[0] = 0;
return; return;
} }
/* Resume inferior and wait for another event. In non-stop mode,
don't really wait here, but return immediatelly to the event
loop. */
void void
myresume (char *own_buf, int step, int sig) myresume (char *own_buf, int step, int sig)
{ {
@ -1342,7 +1562,10 @@ myresume (char *own_buf, int step, int sig)
{ {
resume_info[0].thread resume_info[0].thread
= ((struct inferior_list_entry *) current_inferior)->id; = ((struct inferior_list_entry *) current_inferior)->id;
resume_info[0].step = step; if (step)
resume_info[0].kind = resume_step;
else
resume_info[0].kind = resume_continue;
resume_info[0].sig = sig; resume_info[0].sig = sig;
n++; n++;
} }
@ -1350,16 +1573,39 @@ myresume (char *own_buf, int step, int sig)
if (!valid_cont_thread) if (!valid_cont_thread)
{ {
resume_info[n].thread = -1; resume_info[n].thread = -1;
resume_info[n].step = 0; resume_info[n].kind = resume_continue;
resume_info[n].sig = 0; resume_info[n].sig = 0;
n++; n++;
} }
if (!non_stop)
enable_async_io (); enable_async_io ();
(*the_target->resume) (resume_info, n); (*the_target->resume) (resume_info, n);
last_ptid = mywait (&last_status, 1);
if (non_stop)
write_ok (own_buf);
else
{
last_ptid = mywait (&last_status, 0, 1);
prepare_resume_reply (own_buf, last_ptid, &last_status); prepare_resume_reply (own_buf, last_ptid, &last_status);
disable_async_io (); disable_async_io ();
}
}
/* Callback for for_each_inferior. Make a new stop reply for each
stopped thread. */
static void
queue_stop_reply_callback (struct inferior_list_entry *entry)
{
struct target_waitstatus status;
status.kind = TARGET_WAITKIND_STOPPED;
status.value.sig = TARGET_SIGNAL_TRAP;
/* Pass the last stop reply back to GDB, but don't notify. */
queue_stop_reply (entry->id, &status);
} }
/* Status handler for the '?' packet. */ /* Status handler for the '?' packet. */
@ -1367,11 +1613,32 @@ myresume (char *own_buf, int step, int sig)
static void static void
handle_status (char *own_buf) handle_status (char *own_buf)
{ {
struct target_waitstatus status;
status.kind = TARGET_WAITKIND_STOPPED;
status.value.sig = TARGET_SIGNAL_TRAP;
/* In non-stop mode, we must send a stop reply for each stopped
thread. In all-stop mode, just send one for the first stopped
thread we find. */
if (non_stop)
{
discard_queued_stop_replies ();
for_each_inferior (&all_threads, queue_stop_reply_callback);
/* The first is sent immediatly. OK is sent if there is no
stopped thread, which is the same handling of the vStopped
packet (by design). */
send_next_stop_reply (own_buf);
}
else
{
if (all_threads.head) if (all_threads.head)
prepare_resume_reply (own_buf, prepare_resume_reply (own_buf,
all_threads.head->id, &last_status); all_threads.head->id, &status);
else else
strcpy (own_buf, "W00"); strcpy (own_buf, "W00");
}
} }
static void static void
@ -1426,12 +1693,6 @@ gdbserver_show_disableable (FILE *stream)
int int
main (int argc, char *argv[]) main (int argc, char *argv[])
{ {
char ch, *own_buf;
unsigned char *mem_buf;
int i = 0;
int signal;
unsigned int len;
CORE_ADDR mem_addr;
int bad_attach; int bad_attach;
int pid; int pid;
char *arg_end, *port; char *arg_end, *port;
@ -1630,9 +1891,10 @@ main (int argc, char *argv[])
while (1) while (1)
{ {
noack_mode = 0; noack_mode = 0;
non_stop = 0;
remote_open (port); remote_open (port);
restart:
if (setjmp (toplevel) != 0) if (setjmp (toplevel) != 0)
{ {
/* An error occurred. */ /* An error occurred. */
@ -1643,17 +1905,63 @@ main (int argc, char *argv[])
} }
} }
disable_async_io (); /* Wait for events. This will return when all event sources are
while (!exit_requested) removed from the event loop. */
start_event_loop ();
/* If an exit was requested (using the "monitor exit" command),
terminate now. The only other way to get here is for
getpkt to fail; close the connection and reopen it at the
top of the loop. */
if (exit_requested)
{ {
if (attached)
detach_inferior ();
else
kill_inferior ();
exit (0);
}
else
fprintf (stderr, "Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
}
}
/* Event loop callback that handles a serial event. The first byte in
the serial buffer gets us here. We expect characters to arrive at
a brisk pace, so we read the rest of the packet with a blocking
getpkt call. */
static void
process_serial_event (void)
{
char ch;
int i = 0;
int signal;
unsigned int len;
CORE_ADDR mem_addr;
unsigned char sig; unsigned char sig;
int packet_len; int packet_len;
int new_packet_len = -1; int new_packet_len = -1;
/* Used to decide when gdbserver should exit in
multi-mode/remote. */
static int have_ran = 0;
if (!have_ran)
have_ran = target_running ();
disable_async_io ();
response_needed = 0; response_needed = 0;
packet_len = getpkt (own_buf); packet_len = getpkt (own_buf);
if (packet_len <= 0) if (packet_len <= 0)
break; {
target_async (0);
remote_close ();
return;
}
response_needed = 1; response_needed = 1;
i = 0; i = 0;
@ -1673,6 +1981,7 @@ main (int argc, char *argv[])
write_enn (own_buf); write_enn (own_buf);
else else
{ {
discard_queued_stop_replies ();
write_ok (own_buf); write_ok (own_buf);
if (extended_protocol) if (extended_protocol)
@ -1681,6 +1990,8 @@ main (int argc, char *argv[])
last_status.kind = TARGET_WAITKIND_EXITED; last_status.kind = TARGET_WAITKIND_EXITED;
last_status.value.integer = 0; last_status.value.integer = 0;
last_ptid = signal_pid; last_ptid = signal_pid;
current_inferior = NULL;
} }
else else
{ {
@ -1688,8 +1999,8 @@ main (int argc, char *argv[])
remote_close (); remote_close ();
/* If we are attached, then we can exit. Otherwise, we /* If we are attached, then we can exit. Otherwise, we
need to hang around doing nothing, until the child need to hang around doing nothing, until the child is
is gone. */ gone. */
if (!attached) if (!attached)
join_inferior (); join_inferior ();
@ -1725,6 +2036,18 @@ main (int argc, char *argv[])
if (own_buf[1] == 'g') if (own_buf[1] == 'g')
{ {
if (thread_id == 0)
{
/* GDB is telling us to choose any thread. Check if
the currently selected thread is still valid. If
it is not, select the first available. */
struct thread_info *thread =
(struct thread_info *) find_inferior_id (&all_threads,
general_thread);
if (thread == NULL)
thread_id = all_threads.head->id;
}
general_thread = thread_id; general_thread = thread_id;
set_desired_inferior (1); set_desired_inferior (1);
} }
@ -1873,20 +2196,19 @@ main (int argc, char *argv[])
if (!target_running ()) if (!target_running ())
/* The packet we received doesn't make sense - but we /* The packet we received doesn't make sense - but we
can't reply to it, either. */ can't reply to it, either. */
goto restart; return;
fprintf (stderr, "Killing inferior\n"); fprintf (stderr, "Killing inferior\n");
kill_inferior (); kill_inferior ();
discard_queued_stop_replies ();
/* When using the extended protocol, we wait with no /* When using the extended protocol, we wait with no program
program running. The traditional protocol will exit running. The traditional protocol will exit instead. */
instead. */
if (extended_protocol) if (extended_protocol)
{ {
last_status.kind = TARGET_WAITKIND_EXITED; last_status.kind = TARGET_WAITKIND_EXITED;
last_status.value.sig = TARGET_SIGNAL_KILL; last_status.value.sig = TARGET_SIGNAL_KILL;
was_running = 0; return;
goto restart;
} }
else else
{ {
@ -1915,12 +2237,15 @@ main (int argc, char *argv[])
case 'R': case 'R':
response_needed = 0; response_needed = 0;
/* Restarting the inferior is only supported in the /* Restarting the inferior is only supported in the extended
extended protocol. */ protocol. */
if (extended_protocol) if (extended_protocol)
{ {
if (target_running ()) if (target_running ())
{
kill_inferior (); kill_inferior ();
discard_queued_stop_replies ();
}
fprintf (stderr, "GDBserver restarting\n"); fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */ /* Wait till we are at 1st instruction in prog. */
@ -1931,7 +2256,7 @@ main (int argc, char *argv[])
last_status.kind = TARGET_WAITKIND_EXITED; last_status.kind = TARGET_WAITKIND_EXITED;
last_status.value.sig = TARGET_SIGNAL_KILL; last_status.value.sig = TARGET_SIGNAL_KILL;
} }
goto restart; return;
} }
else else
{ {
@ -1947,8 +2272,8 @@ main (int argc, char *argv[])
break; break;
default: default:
/* It is a request we don't understand. Respond with an /* It is a request we don't understand. Respond with an empty
empty packet so that gdb knows that we don't support this packet so that gdb knows that we don't support this
request. */ request. */
own_buf[0] = '\0'; own_buf[0] = '\0';
break; break;
@ -1961,55 +2286,52 @@ main (int argc, char *argv[])
response_needed = 0; response_needed = 0;
if (was_running if (!extended_protocol && have_ran && !target_running ())
&& (last_status.kind == TARGET_WAITKIND_EXITED
|| last_status.kind == TARGET_WAITKIND_SIGNALLED))
{ {
was_running = 0; /* In non-stop, defer exiting until GDB had a chance to query
the whole vStopped list (until it gets an OK). */
if (last_status.kind == TARGET_WAITKIND_EXITED) if (!notif_queue)
fprintf (stderr,
"\nChild exited with status %d\n",
last_status.value.integer);
else if (last_status.kind == TARGET_WAITKIND_SIGNALLED)
fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (last_status.value.sig),
target_signal_to_name (last_status.value.sig));
if (extended_protocol)
goto restart;
else
{ {
fprintf (stderr, "GDBserver exiting\n"); fprintf (stderr, "GDBserver exiting\n");
remote_close (); remote_close ();
exit (0); exit (0);
} }
} }
}
if (last_status.kind != TARGET_WAITKIND_EXITED
&& last_status.kind != TARGET_WAITKIND_SIGNALLED) /* Event-loop callback for serial events. */
was_running = 1;
} void
handle_serial_event (int err, gdb_client_data client_data)
/* If an exit was requested (using the "monitor exit" command), {
terminate now. The only other way to get here is for if (debug_threads)
getpkt to fail; close the connection and reopen it at the fprintf (stderr, "handling possible serial event\n");
top of the loop. */
/* Really handle it. */
if (exit_requested) process_serial_event ();
{
remote_close (); /* Be sure to not change the selected inferior behind GDB's back.
if (attached && target_running ()) Important in the non-stop mode asynchronous protocol. */
detach_inferior (); set_desired_inferior (1);
else if (target_running ()) }
kill_inferior ();
exit (0); /* Event-loop callback for target events. */
}
else void
{ handle_target_event (int err, gdb_client_data client_data)
fprintf (stderr, "Remote side has terminated connection. " {
"GDBserver will reopen the connection.\n"); if (debug_threads)
remote_close (); fprintf (stderr, "handling possible target event\n");
}
} last_ptid = mywait (&last_status, TARGET_WNOHANG, 1);
if (last_status.kind != TARGET_WAITKIND_IGNORE)
{
/* Something interesting. Tell GDB about it. */
push_event (last_ptid, &last_status);
}
/* Be sure to not change the selected inferior behind GDB's back.
Important in the non-stop mode asynchronous protocol. */
set_desired_inferior (1);
} }

19
gdb/gdbserver/server.h
View File

@ -172,6 +172,24 @@ extern int disable_packet_Tthread;
extern int disable_packet_qC; extern int disable_packet_qC;
extern int disable_packet_qfThreadInfo; extern int disable_packet_qfThreadInfo;
extern int non_stop;
/* Functions from event-loop.c. */
typedef void *gdb_client_data;
typedef void (handler_func) (int, gdb_client_data);
extern void delete_file_handler (int fd);
extern void add_file_handler (int fd, handler_func *proc,
gdb_client_data client_data);
extern void start_event_loop (void);
/* Functions from server.c. */
extern void handle_serial_event (int err, gdb_client_data client_data);
extern void handle_target_event (int err, gdb_client_data client_data);
extern void push_event (unsigned long ptid, struct target_waitstatus *status);
/* Functions from hostio.c. */ /* Functions from hostio.c. */
extern int handle_vFile (char *, int, int *); extern int handle_vFile (char *, int, int *);
@ -187,6 +205,7 @@ extern int transport_is_reliable;
int putpkt (char *buf); int putpkt (char *buf);
int putpkt_binary (char *buf, int len); int putpkt_binary (char *buf, int len);
int putpkt_notif (char *buf);
int getpkt (char *buf); int getpkt (char *buf);
void remote_open (char *name); void remote_open (char *name);
void remote_close (void); void remote_close (void);

4
gdb/gdbserver/spu-low.c
View File

@ -359,7 +359,7 @@ spu_resume (struct thread_resume *resume_info, size_t n)
/* We don't support hardware single-stepping right now, assume /* We don't support hardware single-stepping right now, assume
GDB knows to use software single-stepping. */ GDB knows to use software single-stepping. */
if (resume_info[i].step) if (resume_info[i].kind == resume_step)
fprintf (stderr, "Hardware single-step not supported.\n"); fprintf (stderr, "Hardware single-step not supported.\n");
regcache_invalidate (); regcache_invalidate ();
@ -372,7 +372,7 @@ spu_resume (struct thread_resume *resume_info, size_t n)
/* Wait for process, returns status. */ /* Wait for process, returns status. */
static unsigned long static unsigned long
spu_wait (struct target_waitstatus *ourstatus) spu_wait (struct target_waitstatus *ourstatus, int options)
{ {
int tid = current_tid; int tid = current_tid;
int w; int w;

31
gdb/gdbserver/target.c
View File

@ -89,14 +89,27 @@ write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
} }
unsigned long unsigned long
mywait (struct target_waitstatus *ourstatus, int connected_wait) mywait (struct target_waitstatus *ourstatus, int options,
int connected_wait)
{ {
unsigned long ret; unsigned long ret;
if (connected_wait) if (connected_wait)
server_waiting = 1; server_waiting = 1;
ret = (*the_target->wait) (ourstatus); ret = (*the_target->wait) (ourstatus, options);
if (ourstatus->kind == TARGET_WAITKIND_EXITED
|| ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
{
if (ourstatus->kind == TARGET_WAITKIND_EXITED)
fprintf (stderr,
"\nChild exited with status %d\n", ourstatus->value.sig);
if (ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (ourstatus->value.sig),
target_signal_to_name (ourstatus->value.sig));
}
if (connected_wait) if (connected_wait)
server_waiting = 0; server_waiting = 0;
@ -104,6 +117,20 @@ mywait (struct target_waitstatus *ourstatus, int connected_wait)
return ret; return ret;
} }
int
start_non_stop (int nonstop)
{
if (the_target->start_non_stop == NULL)
{
if (nonstop)
return -1;
else
return 0;
}
return (*the_target->start_non_stop) (nonstop);
}
void void
set_target_ops (struct target_ops *target) set_target_ops (struct target_ops *target)
{ {

52
gdb/gdbserver/target.h
View File

@ -22,6 +22,20 @@
#ifndef TARGET_H #ifndef TARGET_H
#define TARGET_H #define TARGET_H
/* Ways to "resume" a thread. */
enum resume_kind
{
/* Thread should continue. */
resume_continue,
/* Thread should single-step. */
resume_step,
/* Thread should be stopped. */
resume_stop
};
/* This structure describes how to resume a particular thread (or all /* This structure describes how to resume a particular thread (or all
threads) based on the client's request. If thread is -1, then this threads) based on the client's request. If thread is -1, then this
entry applies to all threads. These are passed around as an entry applies to all threads. These are passed around as an
@ -31,10 +45,13 @@ struct thread_resume
{ {
unsigned long thread; unsigned long thread;
/* If non-zero, we want to single-step. */ /* How to "resume". */
int step; enum resume_kind kind;
/* If non-zero, send this signal when we resume. */ /* If non-zero, send this signal when we resume, or to stop the
thread. If stopping a thread, and this is 0, the target should
stop the thread however it best decides to (e.g., SIGSTOP on
linux; SuspendThread on win32). */
int sig; int sig;
}; };
@ -85,6 +102,10 @@ struct target_waitstatus
value; value;
}; };
/* Options that can be passed to target_ops->wait. */
#define TARGET_WNOHANG 1
struct target_ops struct target_ops
{ {
/* Start a new process. /* Start a new process.
@ -132,7 +153,7 @@ struct target_ops
/* Wait for the inferior process or thread to change state. Store /* Wait for the inferior process or thread to change state. Store
status through argument pointer STATUS. */ status through argument pointer STATUS. */
unsigned long (*wait) (struct target_waitstatus *status); unsigned long (*wait) (struct target_waitstatus *status, int options);
/* Fetch registers from the inferior process. /* Fetch registers from the inferior process.
@ -237,6 +258,16 @@ struct target_ops
int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf, int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf,
unsigned const char *writebuf, unsigned const char *writebuf,
CORE_ADDR offset, int len); CORE_ADDR offset, int len);
int (*supports_non_stop) (void);
/* Enables async target events. Returns the previous enable
state. */
int (*async) (int enable);
/* Switch to non-stop (1) or all-stop (0) mode. Return 0 on
success, -1 otherwise. */
int (*start_non_stop) (int);
}; };
extern struct target_ops *the_target; extern struct target_ops *the_target;
@ -267,7 +298,18 @@ void set_target_ops (struct target_ops *);
#define join_inferior() \ #define join_inferior() \
(*the_target->join) () (*the_target->join) ()
unsigned long mywait (struct target_waitstatus *ourstatus, int connected_wait); #define target_supports_non_stop() \
(the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0)
#define target_async(enable) \
(the_target->async ? (*the_target->async) (enable) : 0)
/* Start non-stop mode, returns 0 on success, -1 on failure. */
int start_non_stop (int nonstop);
unsigned long mywait (struct target_waitstatus *ourstatus, int options,
int connected_wait);
int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len); int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);

10
gdb/gdbserver/thread-db.c
View File

@ -155,7 +155,7 @@ thread_db_create_event (CORE_ADDR where)
created threads. */ created threads. */
lwp = get_thread_lwp (current_inferior); lwp = get_thread_lwp (current_inferior);
if (lwp->thread_known == 0) if (lwp->thread_known == 0)
find_one_thread (lwp->lwpid); find_one_thread (lwpid_of (lwp));
/* msg.event == TD_EVENT_CREATE */ /* msg.event == TD_EVENT_CREATE */
@ -245,7 +245,7 @@ find_one_thread (int lwpid)
return 1; return 1;
/* Get information about this thread. */ /* Get information about this thread. */
err = td_ta_map_lwp2thr (thread_agent, lwp->lwpid, &th); err = td_ta_map_lwp2thr (thread_agent, lwpid_of (lwp), &th);
if (err != TD_OK) if (err != TD_OK)
error ("Cannot get thread handle for LWP %d: %s", error ("Cannot get thread handle for LWP %d: %s",
lwpid, thread_db_err_str (err)); lwpid, thread_db_err_str (err));
@ -259,10 +259,10 @@ find_one_thread (int lwpid)
fprintf (stderr, "Found thread %ld (LWP %d)\n", fprintf (stderr, "Found thread %ld (LWP %d)\n",
ti.ti_tid, ti.ti_lid); ti.ti_tid, ti.ti_lid);
if (lwp->lwpid != ti.ti_lid) if (lwpid_of (lwp) != ti.ti_lid)
{ {
warning ("PID mismatch! Expected %ld, got %ld", warning ("PID mismatch! Expected %ld, got %ld",
(long) lwp->lwpid, (long) ti.ti_lid); (long) lwpid_of (lwp), (long) ti.ti_lid);
return 0; return 0;
} }
@ -388,7 +388,7 @@ thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
lwp = get_thread_lwp (thread); lwp = get_thread_lwp (thread);
if (!lwp->thread_known) if (!lwp->thread_known)
find_one_thread (lwp->lwpid); find_one_thread (lwpid_of (lwp));
if (!lwp->thread_known) if (!lwp->thread_known)
return TD_NOTHR; return TD_NOTHR;

6
gdb/gdbserver/win32-low.c
View File

@ -685,7 +685,7 @@ win32_detach (void)
{ {
struct thread_resume resume; struct thread_resume resume;
resume.thread = -1; resume.thread = -1;
resume.step = 0; resume.kind = resume_continue;
resume.sig = 0; resume.sig = 0;
win32_resume (&resume, 1); win32_resume (&resume, 1);
} }
@ -754,7 +754,7 @@ win32_resume (struct thread_resume *resume_info, size_t n)
if (resume_info[0].thread != -1) if (resume_info[0].thread != -1)
{ {
sig = resume_info[0].sig; sig = resume_info[0].sig;
step = resume_info[0].step; step = resume_info[0].kind == resume_step;
} }
else else
{ {
@ -1476,7 +1476,7 @@ get_child_debug_event (struct target_waitstatus *ourstatus)
STATUS will be filled in with a response code to send to GDB. STATUS will be filled in with a response code to send to GDB.
Returns the signal which caused the process to stop. */ Returns the signal which caused the process to stop. */
static unsigned long static unsigned long
win32_wait (struct target_waitstatus *ourstatus) win32_wait (struct target_waitstatus *ourstatus, int options)
{ {
while (1) while (1)
{ {