GDBserver
event-loop.c
Go to the documentation of this file.
1 /* Event loop machinery for the remote server for GDB.
2  Copyright (C) 1999-2015 Free Software Foundation, Inc.
3 
4  This file is part of GDB.
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 3 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 
19 /* Based on src/gdb/event-loop.c. */
20 
21 #include "server.h"
22 #include "queue.h"
23 
24 #include <sys/types.h>
25 #include <sys/time.h>
26 
27 #ifdef USE_WIN32API
28 #include <windows.h>
29 #include <io.h>
30 #endif
31 
32 #include <unistd.h>
33 
34 typedef struct gdb_event gdb_event;
36 
37 /* Tell create_file_handler what events we are interested in. */
38 
39 #define GDB_READABLE (1<<1)
40 #define GDB_WRITABLE (1<<2)
41 #define GDB_EXCEPTION (1<<3)
42 
43 /* Events are queued by calling 'QUEUE_enque (gdb_event_p, event_queue,
44  file_event_ptr)' and serviced later
45  on by do_one_event. An event can be, for instance, a file
46  descriptor becoming ready to be read. Servicing an event simply
47  means that the procedure PROC will be called. We have 2 queues,
48  one for file handlers that we listen to in the event loop, and one
49  for the file handlers+events that are ready. The procedure PROC
50  associated with each event is always the same (handle_file_event).
51  Its duty is to invoke the handler associated with the file
52  descriptor whose state change generated the event, plus doing other
53  cleanups and such. */
54 
55 typedef struct gdb_event
56  {
57  /* Procedure to call to service this event. */
59 
60  /* File descriptor that is ready. */
62  } *gdb_event_p;
63 
64 /* Information about each file descriptor we register with the event
65  loop. */
66 
67 typedef struct file_handler
68  {
69  /* File descriptor. */
71 
72  /* Events we want to monitor. */
73  int mask;
74 
75  /* Events that have been seen since the last time. */
77 
78  /* Procedure to call when fd is ready. */
80 
81  /* Argument to pass to proc. */
83 
84  /* Was an error detected on this fd? */
85  int error;
86 
87  /* Next registered file descriptor. */
89  }
91 
93 static QUEUE(gdb_event_p) *event_queue = NULL;
95 
96 /* Gdb_notifier is just a list of file descriptors gdb is interested
97  in. These are the input file descriptor, and the target file
98  descriptor. Each of the elements in the gdb_notifier list is
99  basically a description of what kind of events gdb is interested
100  in, for each fd. */
101 
102 static struct
103  {
104  /* Ptr to head of file handler list. */
105  file_handler *first_file_handler;
106 
107  /* Masks to be used in the next call to select. Bits are set in
108  response to calls to create_file_handler. */
109  fd_set check_masks[3];
110 
111  /* What file descriptors were found ready by select. */
112  fd_set ready_masks[3];
113 
114  /* Number of valid bits (highest fd value + 1). (for select) */
115  int num_fds;
116  }
118 
119 /* Callbacks are just routines that are executed before waiting for the
120  next event. In GDB this is struct gdb_timer. We don't need timers
121  so rather than copy all that complexity in gdbserver, we provide what
122  we need, but we do so in a way that if/when the day comes that we need
123  that complexity, it'll be easier to add - replace callbacks with timers
124  and use a delta of zero (which is all gdb currently uses timers for anyway).
125 
126  PROC will be executed before gdbserver goes to sleep to wait for the
127  next event. */
128 
130  {
131  int id;
135  };
136 
137 /* Table of registered callbacks. */
138 
139 static struct
140  {
143 
144  /* Id of the last callback created. */
146  }
148 
149 /* Free EVENT. */
150 
151 static void
152 gdb_event_xfree (struct gdb_event *event)
153 {
154  xfree (event);
155 }
156 
157 void
159 {
160  event_queue = QUEUE_alloc (gdb_event_p, gdb_event_xfree);
161 }
162 
163 /* Process one event. If an event was processed, 1 is returned
164  otherwise 0 is returned. Scan the queue from head to tail,
165  processing therefore the high priority events first, by invoking
166  the associated event handler procedure. */
167 
168 static int
170 {
171  /* Let's get rid of the event from the event queue. We need to
172  do this now because while processing the event, since the
173  proc function could end up jumping out to the caller of this
174  function. In that case, we would have on the event queue an
175  event which has been processed, but not deleted. */
176  if (!QUEUE_is_empty (gdb_event_p, event_queue))
177  {
178  gdb_event *event_ptr = QUEUE_deque (gdb_event_p, event_queue);
179  event_handler_func *proc = event_ptr->proc;
180  gdb_fildes_t fd = event_ptr->fd;
181 
182  gdb_event_xfree (event_ptr);
183  /* Now call the procedure associated with the event. */
184  if ((*proc) (fd))
185  return -1;
186  return 1;
187  }
188 
189  /* This is the case if there are no event on the event queue. */
190  return 0;
191 }
192 
193 /* Append PROC to the callback list.
194  The result is the "id" of the callback that can be passed back to
195  delete_callback_event. */
196 
197 int
199 {
200  struct callback_event *event_ptr;
201 
202  event_ptr = xmalloc (sizeof (*event_ptr));
203  event_ptr->id = callback_list.num_callbacks++;
204  event_ptr->proc = proc;
205  event_ptr->data = data;
206  event_ptr->next = NULL;
207  if (callback_list.first == NULL)
208  callback_list.first = event_ptr;
209  if (callback_list.last != NULL)
210  callback_list.last->next = event_ptr;
211  callback_list.last = event_ptr;
212  return event_ptr->id;
213 }
214 
215 /* Delete callback ID.
216  It is not an error callback ID doesn't exist. */
217 
218 void
220 {
221  struct callback_event **p;
222 
223  for (p = &callback_list.first; *p != NULL; p = &(*p)->next)
224  {
225  struct callback_event *event_ptr = *p;
226 
227  if (event_ptr->id == id)
228  {
229  *p = event_ptr->next;
230  if (event_ptr == callback_list.last)
231  callback_list.last = NULL;
232  free (event_ptr);
233  break;
234  }
235  }
236 }
237 
238 /* Run the next callback.
239  The result is 1 if a callback was called and event processing
240  should continue, -1 if the callback wants the event loop to exit,
241  and 0 if there are no more callbacks. */
242 
243 static int
245 {
246  struct callback_event *event_ptr;
247 
248  event_ptr = callback_list.first;
249  if (event_ptr != NULL)
250  {
251  callback_handler_func *proc = event_ptr->proc;
252  gdb_client_data *data = event_ptr->data;
253 
254  /* Remove the event before calling PROC,
255  more events may get added by PROC. */
256  callback_list.first = event_ptr->next;
257  if (callback_list.first == NULL)
258  callback_list.last = NULL;
259  free (event_ptr);
260  if ((*proc) (data))
261  return -1;
262  return 1;
263  }
264 
265  return 0;
266 }
267 
268 /* Add a file handler/descriptor to the list of descriptors we are
269  interested in. FD is the file descriptor for the file/stream to be
270  listened to. MASK is a combination of READABLE, WRITABLE,
271  EXCEPTION. PROC is the procedure that will be called when an event
272  occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
273 
274 static void
276  gdb_client_data client_data)
277 {
278  file_handler *file_ptr;
279 
280  /* Do we already have a file handler for this file? (We may be
281  changing its associated procedure). */
282  for (file_ptr = gdb_notifier.first_file_handler;
283  file_ptr != NULL;
284  file_ptr = file_ptr->next_file)
285  if (file_ptr->fd == fd)
286  break;
287 
288  /* It is a new file descriptor. Add it to the list. Otherwise,
289  just change the data associated with it. */
290  if (file_ptr == NULL)
291  {
292  file_ptr = xmalloc (sizeof (*file_ptr));
293  file_ptr->fd = fd;
294  file_ptr->ready_mask = 0;
295  file_ptr->next_file = gdb_notifier.first_file_handler;
296  gdb_notifier.first_file_handler = file_ptr;
297 
298  if (mask & GDB_READABLE)
299  FD_SET (fd, &gdb_notifier.check_masks[0]);
300  else
301  FD_CLR (fd, &gdb_notifier.check_masks[0]);
302 
303  if (mask & GDB_WRITABLE)
304  FD_SET (fd, &gdb_notifier.check_masks[1]);
305  else
306  FD_CLR (fd, &gdb_notifier.check_masks[1]);
307 
308  if (mask & GDB_EXCEPTION)
309  FD_SET (fd, &gdb_notifier.check_masks[2]);
310  else
311  FD_CLR (fd, &gdb_notifier.check_masks[2]);
312 
313  if (gdb_notifier.num_fds <= fd)
314  gdb_notifier.num_fds = fd + 1;
315  }
316 
317  file_ptr->proc = proc;
318  file_ptr->client_data = client_data;
319  file_ptr->mask = mask;
320 }
321 
322 /* Wrapper function for create_file_handler. */
323 
324 void
326  handler_func *proc, gdb_client_data client_data)
327 {
328  create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
329 }
330 
331 /* Remove the file descriptor FD from the list of monitored fd's:
332  i.e. we don't care anymore about events on the FD. */
333 
334 void
336 {
337  file_handler *file_ptr, *prev_ptr = NULL;
338  int i;
339 
340  /* Find the entry for the given file. */
341 
342  for (file_ptr = gdb_notifier.first_file_handler;
343  file_ptr != NULL;
344  file_ptr = file_ptr->next_file)
345  if (file_ptr->fd == fd)
346  break;
347 
348  if (file_ptr == NULL)
349  return;
350 
351  if (file_ptr->mask & GDB_READABLE)
352  FD_CLR (fd, &gdb_notifier.check_masks[0]);
353  if (file_ptr->mask & GDB_WRITABLE)
354  FD_CLR (fd, &gdb_notifier.check_masks[1]);
355  if (file_ptr->mask & GDB_EXCEPTION)
356  FD_CLR (fd, &gdb_notifier.check_masks[2]);
357 
358  /* Find current max fd. */
359 
360  if ((fd + 1) == gdb_notifier.num_fds)
361  {
362  gdb_notifier.num_fds--;
363  for (i = gdb_notifier.num_fds; i; i--)
364  {
365  if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
366  || FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
367  || FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
368  break;
369  }
370  gdb_notifier.num_fds = i;
371  }
372 
373  /* Deactivate the file descriptor, by clearing its mask, so that it
374  will not fire again. */
375 
376  file_ptr->mask = 0;
377 
378  /* Get rid of the file handler in the file handler list. */
379  if (file_ptr == gdb_notifier.first_file_handler)
380  gdb_notifier.first_file_handler = file_ptr->next_file;
381  else
382  {
383  for (prev_ptr = gdb_notifier.first_file_handler;
384  prev_ptr->next_file != file_ptr;
385  prev_ptr = prev_ptr->next_file)
386  ;
387  prev_ptr->next_file = file_ptr->next_file;
388  }
389  free (file_ptr);
390 }
391 
392 /* Handle the given event by calling the procedure associated to the
393  corresponding file handler. Called by process_event indirectly,
394  through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
395  event in the front of the event queue. */
396 
397 static int
399 {
400  file_handler *file_ptr;
401  int mask;
402 
403  /* Search the file handler list to find one that matches the fd in
404  the event. */
405  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
406  file_ptr = file_ptr->next_file)
407  {
408  if (file_ptr->fd == event_file_desc)
409  {
410  /* See if the desired events (mask) match the received
411  events (ready_mask). */
412 
413  if (file_ptr->ready_mask & GDB_EXCEPTION)
414  {
415  fprintf (stderr, "Exception condition detected on fd %s\n",
416  pfildes (file_ptr->fd));
417  file_ptr->error = 1;
418  }
419  else
420  file_ptr->error = 0;
421  mask = file_ptr->ready_mask & file_ptr->mask;
422 
423  /* Clear the received events for next time around. */
424  file_ptr->ready_mask = 0;
425 
426  /* If there was a match, then call the handler. */
427  if (mask != 0)
428  {
429  if ((*file_ptr->proc) (file_ptr->error,
430  file_ptr->client_data) < 0)
431  return -1;
432  }
433  break;
434  }
435  }
436 
437  return 0;
438 }
439 
440 /* Create a file event, to be enqueued in the event queue for
441  processing. The procedure associated to this event is always
442  handle_file_event, which will in turn invoke the one that was
443  associated to FD when it was registered with the event loop. */
444 
445 static gdb_event *
447 {
448  gdb_event *file_event_ptr;
449 
450  file_event_ptr = xmalloc (sizeof (gdb_event));
451  file_event_ptr->proc = handle_file_event;
452  file_event_ptr->fd = fd;
453  return file_event_ptr;
454 }
455 
456 /* Called by do_one_event to wait for new events on the monitored file
457  descriptors. Queue file events as they are detected by the poll.
458  If there are no events, this function will block in the call to
459  select. Return -1 if there are no files descriptors to monitor,
460  otherwise return 0. */
461 
462 static int
464 {
465  file_handler *file_ptr;
466  int num_found = 0;
467 
468  /* Make sure all output is done before getting another event. */
469  fflush (stdout);
470  fflush (stderr);
471 
472  if (gdb_notifier.num_fds == 0)
473  return -1;
474 
475  gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
476  gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
477  gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
478  num_found = select (gdb_notifier.num_fds,
479  &gdb_notifier.ready_masks[0],
480  &gdb_notifier.ready_masks[1],
481  &gdb_notifier.ready_masks[2],
482  NULL);
483 
484  /* Clear the masks after an error from select. */
485  if (num_found == -1)
486  {
487  FD_ZERO (&gdb_notifier.ready_masks[0]);
488  FD_ZERO (&gdb_notifier.ready_masks[1]);
489  FD_ZERO (&gdb_notifier.ready_masks[2]);
490 #ifdef EINTR
491  /* Dont print anything if we got a signal, let gdb handle
492  it. */
493  if (errno != EINTR)
494  perror_with_name ("select");
495 #endif
496  }
497 
498  /* Enqueue all detected file events. */
499 
500  for (file_ptr = gdb_notifier.first_file_handler;
501  file_ptr != NULL && num_found > 0;
502  file_ptr = file_ptr->next_file)
503  {
504  int mask = 0;
505 
506  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
507  mask |= GDB_READABLE;
508  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
509  mask |= GDB_WRITABLE;
510  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
511  mask |= GDB_EXCEPTION;
512 
513  if (!mask)
514  continue;
515  else
516  num_found--;
517 
518  /* Enqueue an event only if this is still a new event for this
519  fd. */
520 
521  if (file_ptr->ready_mask == 0)
522  {
523  gdb_event *file_event_ptr = create_file_event (file_ptr->fd);
524 
525  QUEUE_enque (gdb_event_p, event_queue, file_event_ptr);
526  }
527  file_ptr->ready_mask = mask;
528  }
529 
530  return 0;
531 }
532 
533 /* Start up the event loop. This is the entry point to the event
534  loop. */
535 
536 void
538 {
539  /* Loop until there is nothing to do. This is the entry point to
540  the event loop engine. If nothing is ready at this time, wait
541  for something to happen (via wait_for_event), then process it.
542  Return when there are no longer event sources to wait for. */
543 
544  while (1)
545  {
546  /* Any events already waiting in the queue? */
547  int res = process_event ();
548 
549  /* Did the event handler want the event loop to stop? */
550  if (res == -1)
551  return;
552 
553  if (res)
554  continue;
555 
556  /* Process any queued callbacks before we go to sleep. */
557  res = process_callback ();
558 
559  /* Did the callback want the event loop to stop? */
560  if (res == -1)
561  return;
562 
563  if (res)
564  continue;
565 
566  /* Wait for a new event. If wait_for_event returns -1, we
567  should get out because this means that there are no event
568  sources left. This will make the event loop stop, and the
569  application exit. */
570 
571  if (wait_for_event () < 0)
572  return;
573  }
574 
575  /* We are done with the event loop. There are no more event sources
576  to listen to. So we exit gdbserver. */
577 }
void delete_callback_event(int id)
Definition: event-loop.c:219
int( handler_func)(int, gdb_client_data)
Definition: event-loop.h:23
void start_event_loop(void)
Definition: event-loop.c:537
char * pfildes(gdb_fildes_t fd)
Definition: utils.c:132
static void create_file_handler(gdb_fildes_t fd, int mask, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:275
gdb_fildes_t fd
Definition: event-loop.c:70
#define QUEUE_enque(TYPE, Q, V)
Definition: queue.h:55
#define GDB_WRITABLE
Definition: event-loop.c:40
#define QUEUE_is_empty(TYPE, Q)
Definition: queue.h:66
static int wait_for_event(void)
Definition: event-loop.c:463
static QUEUE(gdb_event_p)
Definition: event-loop.c:93
struct file_handler * next_file
Definition: event-loop.c:88
DECLARE_QUEUE_P(gdb_event_p)
int num_callbacks
Definition: event-loop.c:145
gdb_notifier
Definition: event-loop.c:117
void initialize_event_loop(void)
Definition: event-loop.c:158
gdb_client_data * data
Definition: event-loop.c:133
static int process_callback(void)
Definition: event-loop.c:244
callback_handler_func * proc
Definition: event-loop.c:132
void delete_file_handler(gdb_fildes_t fd)
Definition: event-loop.c:335
DEFINE_QUEUE_P(notif_event_p)
int ready_mask
Definition: event-loop.c:76
struct callback_event * last
Definition: event-loop.c:142
#define GDB_EXCEPTION
Definition: event-loop.c:41
struct gdb_event * gdb_event_p
handler_func * proc
Definition: event-loop.c:79
event_handler_func * proc
Definition: event-loop.c:58
#define QUEUE_deque(TYPE, Q)
Definition: queue.h:59
static int handle_file_event(gdb_fildes_t event_file_desc)
Definition: event-loop.c:398
struct file_handler file_handler
static void gdb_event_xfree(struct gdb_event *event)
Definition: event-loop.c:152
void * gdb_client_data
Definition: event-loop.h:22
int append_callback_event(callback_handler_func *proc, gdb_client_data data)
Definition: event-loop.c:198
#define errno
Definition: wincecompat.h:24
gdb_fildes_t fd
Definition: event-loop.c:61
#define QUEUE_alloc(TYPE, FREE_FUNC)
Definition: queue.h:70
void add_file_handler(gdb_fildes_t fd, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:325
void xfree(void *ptr)
Definition: common-utils.c:97
gdb_client_data client_data
Definition: event-loop.c:82
static struct @0 callback_list
void perror_with_name(const char *string)
Definition: utils.c:57
PTR xmalloc(size_t size)
Definition: common-utils.c:34
struct callback_event * first
Definition: event-loop.c:141
struct callback_event * next
Definition: event-loop.c:134
int gdb_fildes_t
Definition: server.h:108
#define GDB_READABLE
Definition: event-loop.c:39
int( event_handler_func)(gdb_fildes_t)
Definition: event-loop.c:35
static int process_event(void)
Definition: event-loop.c:169
static gdb_event * create_file_event(gdb_fildes_t fd)
Definition: event-loop.c:446
int( callback_handler_func)(gdb_client_data)
Definition: event-loop.h:24