OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

gdb/gdbserver 

* event-loop.c: Include "queue.h".
	(gdb_event_p): New typedef.
	(struct gdb_event) <next_event>: Remove.
	(event_queue): Change to QUEUE(gdb_event_p).
	(async_queue_event): Remove.
	(gdb_event_xfree): New.
	(initialize_event_loop): New.
	(process_event): Use API from QUEUE.
	(wait_for_event): Likewise.
	* server.c (main): Call initialize_event_loop.
	* server.h (initialize_event_loop): Declare.
This commit is contained in:
Yao Qi 2013-01-25 14:12:02 +00:00
parent 0a4e6638da
commit 60f662b0e8
4 changed files with 45 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
gdb/gdbserver/ChangeLog
View File

@ -1,3 +1,17 @@
2013-01-25 Yao Qi <yao@codesourcery.com>
* event-loop.c: Include "queue.h".
(gdb_event_p): New typedef.
(struct gdb_event) <next_event>: Remove.
(event_queue): Change to QUEUE(gdb_event_p).
(async_queue_event): Remove.
(gdb_event_xfree): New.
(initialize_event_loop): New.
(process_event): Use API from QUEUE.
(wait_for_event): Likewise.
* server.c (main): Call initialize_event_loop.
* server.h (initialize_event_loop): Declare.
2013-01-18 Yao Qi <yao@codesourcery.com>
* ax.h (struct eval_agent_expr_context): New.

110
gdb/gdbserver/event-loop.c
View File

@ -19,6 +19,7 @@
/* Based on src/gdb/event-loop.c. */
#include "server.h"
#include "queue.h"
#include <sys/types.h>
#include <string.h>
@ -46,7 +47,8 @@ typedef int (event_handler_func) (gdb_fildes_t);
#define GDB_WRITABLE (1<<2)
#define GDB_EXCEPTION (1<<3)
/* Events are queued by calling async_queue_event and serviced later
/* Events are queued by calling 'QUEUE_enque (gdb_event_p, event_queue,
file_event_ptr)' 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,
@ -57,17 +59,14 @@ typedef int (event_handler_func) (gdb_fildes_t);
descriptor whose state change generated the event, plus doing other
cleanups and such. */
struct gdb_event
typedef struct gdb_event
{
/* Procedure to call to service this event. */
event_handler_func *proc;
/* File descriptor that is ready. */
gdb_fildes_t fd;
/* Next in list of events or NULL. */
struct gdb_event *next_event;
};
} *gdb_event_p;
/* Information about each file descriptor we register with the event
loop. */
@ -97,25 +96,9 @@ typedef struct file_handler
}
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;
DECLARE_QUEUE_P(gdb_event_p);
static QUEUE(gdb_event_p) *event_queue = NULL;
DEFINE_QUEUE_P(gdb_event_p);
/* Gdb_notifier is just a list of file descriptors gdb is interested
in. These are the input file descriptor, and the target file
@ -170,25 +153,18 @@ static struct
}
callback_list;
/* 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. */
/* Free EVENT. */
static void
async_queue_event (gdb_event *event_ptr)
gdb_event_xfree (struct gdb_event *event)
{
/* The event will become the new last_event. */
xfree (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;
void
initialize_event_loop (void)
{
event_queue = QUEUE_alloc (gdb_event_p, gdb_event_xfree);
}
/* Process one event. If an event was processed, 1 is returned
@ -199,46 +175,18 @@ async_queue_event (gdb_event *event_ptr)
static int
process_event (void)
{
gdb_event *event_ptr, *prev_ptr;
event_handler_func *proc;
gdb_fildes_t 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)
/* 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 (!QUEUE_is_empty (gdb_event_p, event_queue))
{
/* 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);
gdb_event *event_ptr = QUEUE_deque (gdb_event_p, event_queue);
event_handler_func *proc = event_ptr->proc;
gdb_fildes_t fd = event_ptr->fd;
gdb_event_xfree (event_ptr);
/* Now call the procedure associated with the event. */
if ((*proc) (fd))
return -1;
@ -522,7 +470,6 @@ 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. */
@ -580,8 +527,9 @@ wait_for_event (void)
if (file_ptr->ready_mask == 0)
{
file_event_ptr = create_file_event (file_ptr->fd);
async_queue_event (file_event_ptr);
gdb_event *file_event_ptr = create_file_event (file_ptr->fd);
QUEUE_enque (gdb_event_p, event_queue, file_event_ptr);
}
file_ptr->ready_mask = mask;
}

1
gdb/gdbserver/server.c
View File

@ -2687,6 +2687,7 @@ main (int argc, char *argv[])
initialize_async_io ();
initialize_low ();
initialize_event_loop ();
if (target_supports_tracepoints ())
initialize_tracepoint ();

1
gdb/gdbserver/server.h
View File

@ -259,6 +259,7 @@ extern int append_callback_event (callback_handler_func *proc,
extern void delete_callback_event (int id);
extern void start_event_loop (void);
extern void initialize_event_loop (void);
/* Functions from server.c. */
extern int handle_serial_event (int err, gdb_client_data client_data);