darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 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
Show stats 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>
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 \
utils.o version.o \
mem-break.o hostio.o \
mem-break.o hostio.o event-loop.o \
$(XML_BUILTIN) \
$(DEPFILES) $(LIBOBJS)
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
event-loop.o: event-loop.c $(server_h)
hostio.o: hostio.c $(server_h)
hostio-errno.o: hostio-errno.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. */
}

917
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;
#define pid_of(proc) ((proc)->head.id)
#define lwpid_of(proc) ((proc)->head.id)
#define get_lwp(inf) ((struct lwp_info *)(inf))
#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
#define get_lwp_thread(proc) ((struct thread_info *) \
find_inferior_id (&all_threads, \
get_lwp (proc)->lwpid))
lwpid_of (get_lwp (proc))))
struct lwp_info
{
struct inferior_list_entry head;
unsigned long lwpid;
/* If this flag is set, the next SIGSTOP will be ignored (the
process will be immediately resumed). This means that either we
@ -97,11 +99,14 @@ struct lwp_info
yet. */
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()). */
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;
/* If this flag is set, STATUS_PENDING is a waitstatus that has not yet

38
gdb/gdbserver/remote-utils.c
View file

@ -286,11 +286,16 @@ remote_open (char *name)
fcntl (remote_desc, F_SETOWN, getpid ());
#endif
#endif
/* Register the event loop handler. */
add_file_handler (remote_desc, handle_serial_event, NULL);
}
void
remote_close (void)
{
delete_file_handler (remote_desc);
#ifdef USE_WIN32API
closesocket (remote_desc);
#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
packet is in CNT. Returns >= 0 on success, -1 otherwise. */
int
putpkt_binary (char *buf, int cnt)
static int
putpkt_binary_1 (char *buf, int cnt, int is_notif)
{
int i;
unsigned char csum = 0;
@ -537,7 +542,10 @@ putpkt_binary (char *buf, int cnt)
and giving it a checksum. */
p = buf2;
*p++ = '$';
if (is_notif)
*p++ = '%';
else
*p++ = '$';
for (i = 0; i < cnt;)
i += try_rle (buf + i, cnt - i, &csum, &p);
@ -561,12 +569,15 @@ putpkt_binary (char *buf, int cnt)
return -1;
}
if (noack_mode)
if (noack_mode || is_notif)
{
/* Don't expect an ack then. */
if (remote_debug)
{
fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
if (is_notif)
fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
else
fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
fflush (stderr);
}
break;
@ -605,6 +616,12 @@ putpkt_binary (char *buf, int cnt)
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
of the packet is in BUF, and the packet should be a NUL-terminated
string. Returns >= 0 on success, -1 otherwise. */
@ -615,6 +632,12 @@ putpkt (char *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
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
@ -1000,7 +1023,10 @@ prepare_resume_reply (char *buf, unsigned long ptid,
gdbserver to know what inferior_ptid is. */
if (1 || general_thread != ptid)
{
general_thread = ptid;
/* In non-stop, don't change the general thread behind
GDB's back. */
if (!non_stop)
general_thread = ptid;
sprintf (buf, "thread:%lx;", ptid);
buf += strlen (buf);
}

1108
gdb/gdbserver/server.c
View file

File diff suppressed because it is too large Load diff

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_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. */
extern int handle_vFile (char *, int, int *);
@ -187,6 +205,7 @@ extern int transport_is_reliable;
int putpkt (char *buf);
int putpkt_binary (char *buf, int len);
int putpkt_notif (char *buf);
int getpkt (char *buf);
void remote_open (char *name);
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
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");
regcache_invalidate ();
@ -372,7 +372,7 @@ spu_resume (struct thread_resume *resume_info, size_t n)
/* Wait for process, returns status. */
static unsigned long
spu_wait (struct target_waitstatus *ourstatus)
spu_wait (struct target_waitstatus *ourstatus, int options)
{
int tid = current_tid;
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
mywait (struct target_waitstatus *ourstatus, int connected_wait)
mywait (struct target_waitstatus *ourstatus, int options,
int connected_wait)
{
unsigned long ret;
if (connected_wait)
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)
server_waiting = 0;
@ -104,6 +117,20 @@ mywait (struct target_waitstatus *ourstatus, int connected_wait)
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
set_target_ops (struct target_ops *target)
{

52
gdb/gdbserver/target.h
View file

@ -22,6 +22,20 @@
#ifndef 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
threads) based on the client's request. If thread is -1, then this
entry applies to all threads. These are passed around as an
@ -31,10 +45,13 @@ struct thread_resume
{
unsigned long thread;
/* If non-zero, we want to single-step. */
int step;
/* How to "resume". */
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;
};
@ -85,6 +102,10 @@ struct target_waitstatus
value;
};
/* Options that can be passed to target_ops->wait. */
#define TARGET_WNOHANG 1
struct target_ops
{
/* Start a new process.
@ -132,7 +153,7 @@ struct target_ops
/* Wait for the inferior process or thread to change state. Store
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.
@ -237,6 +258,16 @@ struct target_ops
int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf,
unsigned const char *writebuf,
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;
@ -267,7 +298,18 @@ void set_target_ops (struct target_ops *);
#define join_inferior() \
(*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);

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

@ -155,7 +155,7 @@ thread_db_create_event (CORE_ADDR where)
created threads. */
lwp = get_thread_lwp (current_inferior);
if (lwp->thread_known == 0)
find_one_thread (lwp->lwpid);
find_one_thread (lwpid_of (lwp));
/* msg.event == TD_EVENT_CREATE */
@ -245,7 +245,7 @@ find_one_thread (int lwpid)
return 1;
/* 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)
error ("Cannot get thread handle for LWP %d: %s",
lwpid, thread_db_err_str (err));
@ -259,10 +259,10 @@ find_one_thread (int lwpid)
fprintf (stderr, "Found thread %ld (LWP %d)\n",
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",
(long) lwp->lwpid, (long) ti.ti_lid);
(long) lwpid_of (lwp), (long) ti.ti_lid);
return 0;
}
@ -388,7 +388,7 @@ thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
lwp = get_thread_lwp (thread);
if (!lwp->thread_known)
find_one_thread (lwp->lwpid);
find_one_thread (lwpid_of (lwp));
if (!lwp->thread_known)
return TD_NOTHR;

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

@ -685,7 +685,7 @@ win32_detach (void)
{
struct thread_resume resume;
resume.thread = -1;
resume.step = 0;
resume.kind = resume_continue;
resume.sig = 0;
win32_resume (&resume, 1);
}
@ -754,7 +754,7 @@ win32_resume (struct thread_resume *resume_info, size_t n)
if (resume_info[0].thread != -1)
{
sig = resume_info[0].sig;
step = resume_info[0].step;
step = resume_info[0].kind == resume_step;
}
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.
Returns the signal which caused the process to stop. */
static unsigned long
win32_wait (struct target_waitstatus *ourstatus)
win32_wait (struct target_waitstatus *ourstatus, int options)
{
while (1)
{