GDB (xrefs)
/tmp/gdb-7.10/gdb/event-loop.c
Go to the documentation of this file.
1 /* Event loop machinery for GDB, the GNU debugger.
2  Copyright (C) 1999-2015 Free Software Foundation, Inc.
3  Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "event-loop.h"
22 #include "event-top.h"
23 #include "queue.h"
24 
25 #ifdef HAVE_POLL
26 #if defined (HAVE_POLL_H)
27 #include <poll.h>
28 #elif defined (HAVE_SYS_POLL_H)
29 #include <sys/poll.h>
30 #endif
31 #endif
32 
33 #include <sys/types.h>
34 #include <sys/time.h>
35 #include "gdb_select.h"
36 #include "observer.h"
37 
38 /* Tell create_file_handler what events we are interested in.
39  This is used by the select version of the event loop. */
40 
41 #define GDB_READABLE (1<<1)
42 #define GDB_WRITABLE (1<<2)
43 #define GDB_EXCEPTION (1<<3)
44 
45 /* Data point to pass to the event handler. */
46 typedef union event_data
47 {
48  void *ptr;
49  int integer;
50 } event_data;
51 
52 typedef struct gdb_event gdb_event;
53 typedef void (event_handler_func) (event_data);
54 
55 /* Event for the GDB event system. Events are queued by calling
56  async_queue_event and serviced later on by gdb_do_one_event. An
57  event can be, for instance, a file descriptor becoming ready to be
58  read. Servicing an event simply means that the procedure PROC will
59  be called. We have 2 queues, one for file handlers that we listen
60  to in the event loop, and one for the file handlers+events that are
61  ready. The procedure PROC associated with each event is dependant
62  of the event source. In the case of monitored file descriptors, it
63  is always the same (handle_file_event). Its duty is to invoke the
64  handler associated with the file descriptor whose state change
65  generated the event, plus doing other cleanups and such. In the
66  case of async signal handlers, it is
67  invoke_async_signal_handler. */
68 
69 typedef struct gdb_event
70  {
71  /* Procedure to call to service this event. */
73 
74  /* Data to pass to the event handler. */
76  } *gdb_event_p;
77 
78 /* Information about each file descriptor we register with the event
79  loop. */
80 
81 typedef struct file_handler
82  {
83  int fd; /* File descriptor. */
84  int mask; /* Events we want to monitor: POLLIN, etc. */
85  int ready_mask; /* Events that have been seen since
86  the last time. */
87  handler_func *proc; /* Procedure to call when fd is ready. */
88  gdb_client_data client_data; /* Argument to pass to proc. */
89  int error; /* Was an error detected on this fd? */
90  struct file_handler *next_file; /* Next registered file descriptor. */
91  }
93 
94 /* PROC is a function to be invoked when the READY flag is set. This
95  happens when there has been a signal and the corresponding signal
96  handler has 'triggered' this async_signal_handler for execution.
97  The actual work to be done in response to a signal will be carried
98  out by PROC at a later time, within process_event. This provides a
99  deferred execution of signal handlers.
100 
101  Async_init_signals takes care of setting up such an
102  async_signal_handler for each interesting signal. */
103 
104 typedef struct async_signal_handler
105  {
106  int ready; /* If ready, call this handler
107  from the main event loop, using
108  invoke_async_handler. */
109  struct async_signal_handler *next_handler; /* Ptr to next handler. */
110  sig_handler_func *proc; /* Function to call to do the work. */
111  gdb_client_data client_data; /* Argument to async_handler_func. */
112  }
114 
115 /* PROC is a function to be invoked when the READY flag is set. This
116  happens when the event has been marked with
117  MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
118  to an event will be carried out by PROC at a later time, within
119  process_event. This provides a deferred execution of event
120  handlers. */
121 typedef struct async_event_handler
122  {
123  /* If ready, call this handler from the main event loop, using
124  invoke_event_handler. */
125  int ready;
126 
127  /* Point to next handler. */
129 
130  /* Function to call to do the work. */
132 
133  /* Argument to PROC. */
135  }
137 
138 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
139  These are the input file descriptor, and the target file
140  descriptor. We have two flavors of the notifier, one for platforms
141  that have the POLL function, the other for those that don't, and
142  only support SELECT. Each of the elements in the gdb_notifier list is
143  basically a description of what kind of events gdb is interested
144  in, for each fd. */
145 
146 /* As of 1999-04-30 only the input file descriptor is registered with the
147  event loop. */
148 
149 /* Do we use poll or select ? */
150 #ifdef HAVE_POLL
151 #define USE_POLL 1
152 #else
153 #define USE_POLL 0
154 #endif /* HAVE_POLL */
155 
156 static unsigned char use_poll = USE_POLL;
157 
158 #ifdef USE_WIN32API
159 #include <windows.h>
160 #include <io.h>
161 #endif
162 
163 static struct
164  {
165  /* Ptr to head of file handler list. */
167 
168  /* Next file handler to handle, for the select variant. To level
169  the fairness across event sources, we serve file handlers in a
170  round-robin-like fashion. The number and order of the polled
171  file handlers may change between invocations, but this is good
172  enough. */
174 
175 #ifdef HAVE_POLL
176  /* Ptr to array of pollfd structures. */
177  struct pollfd *poll_fds;
178 
179  /* Next file descriptor to handle, for the poll variant. To level
180  the fairness across event sources, we poll the file descriptors
181  in a round-robin-like fashion. The number and order of the
182  polled file descriptors may change between invocations, but
183  this is good enough. */
185 
186  /* Timeout in milliseconds for calls to poll(). */
188 #endif
189 
190  /* Masks to be used in the next call to select.
191  Bits are set in response to calls to create_file_handler. */
192  fd_set check_masks[3];
193 
194  /* What file descriptors were found ready by select. */
195  fd_set ready_masks[3];
196 
197  /* Number of file descriptors to monitor (for poll). */
198  /* Number of valid bits (highest fd value + 1) (for select). */
199  int num_fds;
200 
201  /* Time structure for calls to select(). */
202  struct timeval select_timeout;
203 
204  /* Flag to tell whether the timeout should be used. */
206  }
208 
209 /* Structure associated with a timer. PROC will be executed at the
210  first occasion after WHEN. */
211 struct gdb_timer
212  {
213  struct timeval when;
214  int timer_id;
215  struct gdb_timer *next;
216  timer_handler_func *proc; /* Function to call to do the work. */
217  gdb_client_data client_data; /* Argument to async_handler_func. */
218  };
219 
220 /* List of currently active timers. It is sorted in order of
221  increasing timers. */
222 static struct
223  {
224  /* Pointer to first in timer list. */
226 
227  /* Id of the last timer created. */
229  }
230 timer_list;
231 
232 /* All the async_signal_handlers gdb is interested in are kept onto
233  this list. */
234 static struct
235  {
236  /* Pointer to first in handler list. */
238 
239  /* Pointer to last in handler list. */
241  }
243 
244 /* All the async_event_handlers gdb is interested in are kept onto
245  this list. */
246 static struct
247  {
248  /* Pointer to first in handler list. */
250 
251  /* Pointer to last in handler list. */
253  }
255 
256 static int invoke_async_signal_handlers (void);
257 static void create_file_handler (int fd, int mask, handler_func *proc,
259 static int check_async_event_handlers (void);
260 static int gdb_wait_for_event (int);
261 static int update_wait_timeout (void);
262 static int poll_timers (void);
263 
264 
265 /* Process one high level event. If nothing is ready at this time,
266  wait for something to happen (via gdb_wait_for_event), then process
267  it. Returns >0 if something was done otherwise returns <0 (this
268  can happen if there are no event sources to wait for). */
269 
270 int
272 {
273  static int event_source_head = 0;
274  const int number_of_sources = 3;
275  int current = 0;
276 
277  /* First let's see if there are any asynchronous signal handlers
278  that are ready. These would be the result of invoking any of the
279  signal handlers. */
281  return 1;
282 
283  /* To level the fairness across event sources, we poll them in a
284  round-robin fashion. */
285  for (current = 0; current < number_of_sources; current++)
286  {
287  int res;
288 
289  switch (event_source_head)
290  {
291  case 0:
292  /* Are any timers that are ready? */
293  res = poll_timers ();
294  break;
295  case 1:
296  /* Are there events already waiting to be collected on the
297  monitored file descriptors? */
298  res = gdb_wait_for_event (0);
299  break;
300  case 2:
301  /* Are there any asynchronous event handlers ready? */
303  break;
304  default:
305  internal_error (__FILE__, __LINE__,
306  "unexpected event_source_head %d",
307  event_source_head);
308  }
309 
310  event_source_head++;
311  if (event_source_head == number_of_sources)
312  event_source_head = 0;
313 
314  if (res > 0)
315  return 1;
316  }
317 
318  /* Block waiting for a new event. If gdb_wait_for_event returns -1,
319  we should get out because this means that there are no event
320  sources left. This will make the event loop stop, and the
321  application exit. */
322 
323  if (gdb_wait_for_event (1) < 0)
324  return -1;
325 
326  /* If gdb_wait_for_event has returned 1, it means that one event has
327  been handled. We break out of the loop. */
328  return 1;
329 }
330 
331 /* Start up the event loop. This is the entry point to the event loop
332  from the command loop. */
333 
334 void
336 {
337  /* Loop until there is nothing to do. This is the entry point to
338  the event loop engine. gdb_do_one_event will process one event
339  for each invocation. It blocks waiting for an event and then
340  processes it. */
341  while (1)
342  {
343  int result = 0;
344 
345  TRY
346  {
347  result = gdb_do_one_event ();
348  }
349  CATCH (ex, RETURN_MASK_ALL)
350  {
352 
353  /* If any exception escaped to here, we better enable
354  stdin. Otherwise, any command that calls async_disable_stdin,
355  and then throws, will leave stdin inoperable. */
357  /* If we long-jumped out of do_one_event, we probably didn't
358  get around to resetting the prompt, which leaves readline
359  in a messed-up state. Reset it here. */
361  /* This call looks bizarre, but it is required. If the user
362  entered a command that caused an error,
363  after_char_processing_hook won't be called from
364  rl_callback_read_char_wrapper. Using a cleanup there
365  won't work, since we want this function to be called
366  after a new prompt is printed. */
368  (*after_char_processing_hook) ();
369  /* Maybe better to set a flag to be checked somewhere as to
370  whether display the prompt or not. */
371  }
372  END_CATCH
373 
374  if (result < 0)
375  break;
376  }
377 
378  /* We are done with the event loop. There are no more event sources
379  to listen to. So we exit GDB. */
380  return;
381 }
382 
383 
384 /* Wrapper function for create_file_handler, so that the caller
385  doesn't have to know implementation details about the use of poll
386  vs. select. */
387 void
389 {
390 #ifdef HAVE_POLL
391  struct pollfd fds;
392 #endif
393 
394  if (use_poll)
395  {
396 #ifdef HAVE_POLL
397  /* Check to see if poll () is usable. If not, we'll switch to
398  use select. This can happen on systems like
399  m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
400  On m68k-motorola-sysv, tty's are not stream-based and not
401  `poll'able. */
402  fds.fd = fd;
403  fds.events = POLLIN;
404  if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
405  use_poll = 0;
406 #else
407  internal_error (__FILE__, __LINE__,
408  _("use_poll without HAVE_POLL"));
409 #endif /* HAVE_POLL */
410  }
411  if (use_poll)
412  {
413 #ifdef HAVE_POLL
414  create_file_handler (fd, POLLIN, proc, client_data);
415 #else
416  internal_error (__FILE__, __LINE__,
417  _("use_poll without HAVE_POLL"));
418 #endif
419  }
420  else
422  proc, client_data);
423 }
424 
425 /* Add a file handler/descriptor to the list of descriptors we are
426  interested in.
427 
428  FD is the file descriptor for the file/stream to be listened to.
429 
430  For the poll case, MASK is a combination (OR) of POLLIN,
431  POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
432  these are the events we are interested in. If any of them occurs,
433  proc should be called.
434 
435  For the select case, MASK is a combination of READABLE, WRITABLE,
436  EXCEPTION. PROC is the procedure that will be called when an event
437  occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
438 
439 static void
440 create_file_handler (int fd, int mask, handler_func * proc,
441  gdb_client_data client_data)
442 {
443  file_handler *file_ptr;
444 
445  /* Do we already have a file handler for this file? (We may be
446  changing its associated procedure). */
447  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
448  file_ptr = file_ptr->next_file)
449  {
450  if (file_ptr->fd == fd)
451  break;
452  }
453 
454  /* It is a new file descriptor. Add it to the list. Otherwise, just
455  change the data associated with it. */
456  if (file_ptr == NULL)
457  {
458  file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
459  file_ptr->fd = fd;
460  file_ptr->ready_mask = 0;
461  file_ptr->next_file = gdb_notifier.first_file_handler;
462  gdb_notifier.first_file_handler = file_ptr;
463 
464  if (use_poll)
465  {
466 #ifdef HAVE_POLL
467  gdb_notifier.num_fds++;
468  if (gdb_notifier.poll_fds)
469  gdb_notifier.poll_fds =
470  (struct pollfd *) xrealloc (gdb_notifier.poll_fds,
471  (gdb_notifier.num_fds
472  * sizeof (struct pollfd)));
473  else
474  gdb_notifier.poll_fds =
475  (struct pollfd *) xmalloc (sizeof (struct pollfd));
476  (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
477  (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
478  (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
479 #else
480  internal_error (__FILE__, __LINE__,
481  _("use_poll without HAVE_POLL"));
482 #endif /* HAVE_POLL */
483  }
484  else
485  {
486  if (mask & GDB_READABLE)
487  FD_SET (fd, &gdb_notifier.check_masks[0]);
488  else
489  FD_CLR (fd, &gdb_notifier.check_masks[0]);
490 
491  if (mask & GDB_WRITABLE)
492  FD_SET (fd, &gdb_notifier.check_masks[1]);
493  else
494  FD_CLR (fd, &gdb_notifier.check_masks[1]);
495 
496  if (mask & GDB_EXCEPTION)
497  FD_SET (fd, &gdb_notifier.check_masks[2]);
498  else
499  FD_CLR (fd, &gdb_notifier.check_masks[2]);
500 
501  if (gdb_notifier.num_fds <= fd)
502  gdb_notifier.num_fds = fd + 1;
503  }
504  }
505 
506  file_ptr->proc = proc;
507  file_ptr->client_data = client_data;
508  file_ptr->mask = mask;
509 }
510 
511 /* Return the next file handler to handle, and advance to the next
512  file handler, wrapping around if the end of the list is
513  reached. */
514 
515 static file_handler *
517 {
518  file_handler *curr_next;
519 
520  /* The first time around, this is still NULL. */
521  if (gdb_notifier.next_file_handler == NULL)
522  gdb_notifier.next_file_handler = gdb_notifier.first_file_handler;
523 
524  curr_next = gdb_notifier.next_file_handler;
525  gdb_assert (curr_next != NULL);
526 
527  /* Advance. */
528  gdb_notifier.next_file_handler = curr_next->next_file;
529  /* Wrap around, if necessary. */
530  if (gdb_notifier.next_file_handler == NULL)
531  gdb_notifier.next_file_handler = gdb_notifier.first_file_handler;
532 
533  return curr_next;
534 }
535 
536 /* Remove the file descriptor FD from the list of monitored fd's:
537  i.e. we don't care anymore about events on the FD. */
538 void
540 {
541  file_handler *file_ptr, *prev_ptr = NULL;
542  int i;
543 #ifdef HAVE_POLL
544  int j;
545  struct pollfd *new_poll_fds;
546 #endif
547 
548  /* Find the entry for the given file. */
549 
550  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
551  file_ptr = file_ptr->next_file)
552  {
553  if (file_ptr->fd == fd)
554  break;
555  }
556 
557  if (file_ptr == NULL)
558  return;
559 
560  if (use_poll)
561  {
562 #ifdef HAVE_POLL
563  /* Create a new poll_fds array by copying every fd's information
564  but the one we want to get rid of. */
565 
566  new_poll_fds = (struct pollfd *)
567  xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
568 
569  for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
570  {
571  if ((gdb_notifier.poll_fds + i)->fd != fd)
572  {
573  (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
574  (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
575  (new_poll_fds + j)->revents
576  = (gdb_notifier.poll_fds + i)->revents;
577  j++;
578  }
579  }
580  xfree (gdb_notifier.poll_fds);
581  gdb_notifier.poll_fds = new_poll_fds;
582  gdb_notifier.num_fds--;
583 #else
584  internal_error (__FILE__, __LINE__,
585  _("use_poll without HAVE_POLL"));
586 #endif /* HAVE_POLL */
587  }
588  else
589  {
590  if (file_ptr->mask & GDB_READABLE)
591  FD_CLR (fd, &gdb_notifier.check_masks[0]);
592  if (file_ptr->mask & GDB_WRITABLE)
593  FD_CLR (fd, &gdb_notifier.check_masks[1]);
594  if (file_ptr->mask & GDB_EXCEPTION)
595  FD_CLR (fd, &gdb_notifier.check_masks[2]);
596 
597  /* Find current max fd. */
598 
599  if ((fd + 1) == gdb_notifier.num_fds)
600  {
601  gdb_notifier.num_fds--;
602  for (i = gdb_notifier.num_fds; i; i--)
603  {
604  if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
605  || FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
606  || FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
607  break;
608  }
609  gdb_notifier.num_fds = i;
610  }
611  }
612 
613  /* Deactivate the file descriptor, by clearing its mask,
614  so that it will not fire again. */
615 
616  file_ptr->mask = 0;
617 
618  /* If this file handler was going to be the next one to be handled,
619  advance to the next's next, if any. */
620  if (gdb_notifier.next_file_handler == file_ptr)
621  {
622  if (file_ptr->next_file == NULL
623  && file_ptr == gdb_notifier.first_file_handler)
624  gdb_notifier.next_file_handler = NULL;
625  else
627  }
628 
629  /* Get rid of the file handler in the file handler list. */
630  if (file_ptr == gdb_notifier.first_file_handler)
631  gdb_notifier.first_file_handler = file_ptr->next_file;
632  else
633  {
634  for (prev_ptr = gdb_notifier.first_file_handler;
635  prev_ptr->next_file != file_ptr;
636  prev_ptr = prev_ptr->next_file)
637  ;
638  prev_ptr->next_file = file_ptr->next_file;
639  }
640  xfree (file_ptr);
641 }
642 
643 /* Handle the given event by calling the procedure associated to the
644  corresponding file handler. */
645 
646 static void
647 handle_file_event (file_handler *file_ptr, int ready_mask)
648 {
649  int mask;
650 #ifdef HAVE_POLL
651  int error_mask;
652 #endif
653 
654  {
655  {
656  /* With poll, the ready_mask could have any of three events
657  set to 1: POLLHUP, POLLERR, POLLNVAL. These events
658  cannot be used in the requested event mask (events), but
659  they can be returned in the return mask (revents). We
660  need to check for those event too, and add them to the
661  mask which will be passed to the handler. */
662 
663  /* See if the desired events (mask) match the received
664  events (ready_mask). */
665 
666  if (use_poll)
667  {
668 #ifdef HAVE_POLL
669  /* POLLHUP means EOF, but can be combined with POLLIN to
670  signal more data to read. */
671  error_mask = POLLHUP | POLLERR | POLLNVAL;
672  mask = ready_mask & (file_ptr->mask | error_mask);
673 
674  if ((mask & (POLLERR | POLLNVAL)) != 0)
675  {
676  /* Work in progress. We may need to tell somebody
677  what kind of error we had. */
678  if (mask & POLLERR)
679  printf_unfiltered (_("Error detected on fd %d\n"),
680  file_ptr->fd);
681  if (mask & POLLNVAL)
682  printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
683  file_ptr->fd);
684  file_ptr->error = 1;
685  }
686  else
687  file_ptr->error = 0;
688 #else
689  internal_error (__FILE__, __LINE__,
690  _("use_poll without HAVE_POLL"));
691 #endif /* HAVE_POLL */
692  }
693  else
694  {
695  if (ready_mask & GDB_EXCEPTION)
696  {
697  printf_unfiltered (_("Exception condition detected "
698  "on fd %d\n"), file_ptr->fd);
699  file_ptr->error = 1;
700  }
701  else
702  file_ptr->error = 0;
703  mask = ready_mask & file_ptr->mask;
704  }
705 
706  /* If there was a match, then call the handler. */
707  if (mask != 0)
708  (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
709  }
710  }
711 }
712 
713 /* Wait for new events on the monitored file descriptors. Run the
714  event handler if the first descriptor that is detected by the poll.
715  If BLOCK and if there are no events, this function will block in
716  the call to poll. Return 1 if an event was handled. Return -1 if
717  there are no file descriptors to monitor. Return 1 if an event was
718  handled, otherwise returns 0. */
719 
720 static int
722 {
723  file_handler *file_ptr;
724  int num_found = 0;
725 
726  /* Make sure all output is done before getting another event. */
729 
730  if (gdb_notifier.num_fds == 0)
731  return -1;
732 
733  if (block)
735 
736  if (use_poll)
737  {
738 #ifdef HAVE_POLL
739  int timeout;
740 
741  if (block)
742  timeout = gdb_notifier.timeout_valid ? gdb_notifier.poll_timeout : -1;
743  else
744  timeout = 0;
745 
746  num_found = poll (gdb_notifier.poll_fds,
747  (unsigned long) gdb_notifier.num_fds, timeout);
748 
749  /* Don't print anything if we get out of poll because of a
750  signal. */
751  if (num_found == -1 && errno != EINTR)
752  perror_with_name (("poll"));
753 #else
754  internal_error (__FILE__, __LINE__,
755  _("use_poll without HAVE_POLL"));
756 #endif /* HAVE_POLL */
757  }
758  else
759  {
760  struct timeval select_timeout;
761  struct timeval *timeout_p;
762 
763  if (block)
764  timeout_p = gdb_notifier.timeout_valid
765  ? &gdb_notifier.select_timeout : NULL;
766  else
767  {
768  memset (&select_timeout, 0, sizeof (select_timeout));
769  timeout_p = &select_timeout;
770  }
771 
772  gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
773  gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
774  gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
775  num_found = gdb_select (gdb_notifier.num_fds,
776  &gdb_notifier.ready_masks[0],
777  &gdb_notifier.ready_masks[1],
778  &gdb_notifier.ready_masks[2],
779  timeout_p);
780 
781  /* Clear the masks after an error from select. */
782  if (num_found == -1)
783  {
784  FD_ZERO (&gdb_notifier.ready_masks[0]);
785  FD_ZERO (&gdb_notifier.ready_masks[1]);
786  FD_ZERO (&gdb_notifier.ready_masks[2]);
787 
788  /* Dont print anything if we got a signal, let gdb handle
789  it. */
790  if (errno != EINTR)
791  perror_with_name (("select"));
792  }
793  }
794 
795  /* Avoid looking at poll_fds[i]->revents if no event fired. */
796  if (num_found <= 0)
797  return 0;
798 
799  /* Run event handlers. We always run just one handler and go back
800  to polling, in case a handler changes the notifier list. Since
801  events for sources we haven't consumed yet wake poll/select
802  immediately, no event is lost. */
803 
804  /* To level the fairness across event descriptors, we handle them in
805  a round-robin-like fashion. The number and order of descriptors
806  may change between invocations, but this is good enough. */
807  if (use_poll)
808  {
809 #ifdef HAVE_POLL
810  int i;
811  int mask;
812 
813  while (1)
814  {
815  if (gdb_notifier.next_poll_fds_index >= gdb_notifier.num_fds)
816  gdb_notifier.next_poll_fds_index = 0;
817  i = gdb_notifier.next_poll_fds_index++;
818 
819  gdb_assert (i < gdb_notifier.num_fds);
820  if ((gdb_notifier.poll_fds + i)->revents)
821  break;
822  }
823 
824  for (file_ptr = gdb_notifier.first_file_handler;
825  file_ptr != NULL;
826  file_ptr = file_ptr->next_file)
827  {
828  if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
829  break;
830  }
831  gdb_assert (file_ptr != NULL);
832 
833  mask = (gdb_notifier.poll_fds + i)->revents;
834  handle_file_event (file_ptr, mask);
835  return 1;
836 #else
837  internal_error (__FILE__, __LINE__,
838  _("use_poll without HAVE_POLL"));
839 #endif /* HAVE_POLL */
840  }
841  else
842  {
843  /* See comment about even source fairness above. */
844  int mask = 0;
845 
846  do
847  {
849 
850  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
851  mask |= GDB_READABLE;
852  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
853  mask |= GDB_WRITABLE;
854  if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
855  mask |= GDB_EXCEPTION;
856  }
857  while (mask == 0);
858 
859  handle_file_event (file_ptr, mask);
860  return 1;
861  }
862  return 0;
863 }
864 
865 
866 /* Create an asynchronous handler, allocating memory for it.
867  Return a pointer to the newly created handler.
868  This pointer will be used to invoke the handler by
869  invoke_async_signal_handler.
870  PROC is the function to call with CLIENT_DATA argument
871  whenever the handler is invoked. */
874  gdb_client_data client_data)
875 {
876  async_signal_handler *async_handler_ptr;
877 
878  async_handler_ptr =
880  async_handler_ptr->ready = 0;
881  async_handler_ptr->next_handler = NULL;
882  async_handler_ptr->proc = proc;
883  async_handler_ptr->client_data = client_data;
884  if (sighandler_list.first_handler == NULL)
885  sighandler_list.first_handler = async_handler_ptr;
886  else
887  sighandler_list.last_handler->next_handler = async_handler_ptr;
888  sighandler_list.last_handler = async_handler_ptr;
889  return async_handler_ptr;
890 }
891 
892 /* Call the handler from HANDLER immediately. This function runs
893  signal handlers when returning to the event loop would be too
894  slow. */
895 void
897 {
898  (*handler->proc) (handler->client_data);
899 }
900 
901 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
902  will be used when the handlers are invoked, after we have waited
903  for some event. The caller of this function is the interrupt
904  handler associated with a signal. */
905 void
907 {
908  async_handler_ptr->ready = 1;
909 }
910 
911 /* See event-loop.h. */
912 
913 void
915 {
916  async_handler_ptr->ready = 0;
917 }
918 
919 /* See event-loop.h. */
920 
921 int
923 {
924  return async_handler_ptr->ready;
925 }
926 
927 /* Call all the handlers that are ready. Returns true if any was
928  indeed ready. */
929 static int
931 {
932  async_signal_handler *async_handler_ptr;
933  int any_ready = 0;
934 
935  /* Invoke ready handlers. */
936 
937  while (1)
938  {
939  for (async_handler_ptr = sighandler_list.first_handler;
940  async_handler_ptr != NULL;
941  async_handler_ptr = async_handler_ptr->next_handler)
942  {
943  if (async_handler_ptr->ready)
944  break;
945  }
946  if (async_handler_ptr == NULL)
947  break;
948  any_ready = 1;
949  async_handler_ptr->ready = 0;
950  (*async_handler_ptr->proc) (async_handler_ptr->client_data);
951  }
952 
953  return any_ready;
954 }
955 
956 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
957  Free the space allocated for it. */
958 void
960 {
961  async_signal_handler *prev_ptr;
962 
963  if (sighandler_list.first_handler == (*async_handler_ptr))
964  {
965  sighandler_list.first_handler = (*async_handler_ptr)->next_handler;
966  if (sighandler_list.first_handler == NULL)
967  sighandler_list.last_handler = NULL;
968  }
969  else
970  {
971  prev_ptr = sighandler_list.first_handler;
972  while (prev_ptr && prev_ptr->next_handler != (*async_handler_ptr))
973  prev_ptr = prev_ptr->next_handler;
974  gdb_assert (prev_ptr);
975  prev_ptr->next_handler = (*async_handler_ptr)->next_handler;
976  if (sighandler_list.last_handler == (*async_handler_ptr))
977  sighandler_list.last_handler = prev_ptr;
978  }
979  xfree ((*async_handler_ptr));
980  (*async_handler_ptr) = NULL;
981 }
982 
983 /* Create an asynchronous event handler, allocating memory for it.
984  Return a pointer to the newly created handler. PROC is the
985  function to call with CLIENT_DATA argument whenever the handler is
986  invoked. */
989  gdb_client_data client_data)
990 {
992 
993  h = xmalloc (sizeof (*h));
994  h->ready = 0;
995  h->next_handler = NULL;
996  h->proc = proc;
997  h->client_data = client_data;
998  if (async_event_handler_list.first_handler == NULL)
999  async_event_handler_list.first_handler = h;
1000  else
1001  async_event_handler_list.last_handler->next_handler = h;
1002  async_event_handler_list.last_handler = h;
1003  return h;
1004 }
1005 
1006 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1007  will be used by gdb_do_one_event. The caller will be whoever
1008  created the event source, and wants to signal that the event is
1009  ready to be handled. */
1010 void
1012 {
1013  async_handler_ptr->ready = 1;
1014 }
1015 
1016 /* See event-loop.h. */
1017 
1018 void
1020 {
1021  async_handler_ptr->ready = 0;
1022 }
1023 
1024 /* Check if asynchronous event handlers are ready, and call the
1025  handler function for one that is. */
1026 
1027 static int
1029 {
1030  async_event_handler *async_handler_ptr;
1031 
1032  for (async_handler_ptr = async_event_handler_list.first_handler;
1033  async_handler_ptr != NULL;
1034  async_handler_ptr = async_handler_ptr->next_handler)
1035  {
1036  if (async_handler_ptr->ready)
1037  {
1038  async_handler_ptr->ready = 0;
1039  (*async_handler_ptr->proc) (async_handler_ptr->client_data);
1040  return 1;
1041  }
1042  }
1043 
1044  return 0;
1045 }
1046 
1047 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1048  Free the space allocated for it. */
1049 void
1051 {
1052  async_event_handler *prev_ptr;
1053 
1054  if (async_event_handler_list.first_handler == *async_handler_ptr)
1055  {
1056  async_event_handler_list.first_handler
1057  = (*async_handler_ptr)->next_handler;
1058  if (async_event_handler_list.first_handler == NULL)
1059  async_event_handler_list.last_handler = NULL;
1060  }
1061  else
1062  {
1063  prev_ptr = async_event_handler_list.first_handler;
1064  while (prev_ptr && prev_ptr->next_handler != *async_handler_ptr)
1065  prev_ptr = prev_ptr->next_handler;
1066  gdb_assert (prev_ptr);
1067  prev_ptr->next_handler = (*async_handler_ptr)->next_handler;
1068  if (async_event_handler_list.last_handler == (*async_handler_ptr))
1069  async_event_handler_list.last_handler = prev_ptr;
1070  }
1071  xfree (*async_handler_ptr);
1072  *async_handler_ptr = NULL;
1073 }
1074 
1075 /* Create a timer that will expire in MILLISECONDS from now. When the
1076  timer is ready, PROC will be executed. At creation, the timer is
1077  aded to the timers queue. This queue is kept sorted in order of
1078  increasing timers. Return a handle to the timer struct. */
1079 int
1080 create_timer (int milliseconds, timer_handler_func * proc,
1081  gdb_client_data client_data)
1082 {
1083  struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
1084  struct timeval time_now, delta;
1085 
1086  /* Compute seconds. */
1087  delta.tv_sec = milliseconds / 1000;
1088  /* Compute microseconds. */
1089  delta.tv_usec = (milliseconds % 1000) * 1000;
1090 
1091  gettimeofday (&time_now, NULL);
1092 
1093  timer_ptr = (struct gdb_timer *) xmalloc (sizeof (*timer_ptr));
1094  timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
1095  timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
1096  /* Carry? */
1097  if (timer_ptr->when.tv_usec >= 1000000)
1098  {
1099  timer_ptr->when.tv_sec += 1;
1100  timer_ptr->when.tv_usec -= 1000000;
1101  }
1102  timer_ptr->proc = proc;
1103  timer_ptr->client_data = client_data;
1104  timer_list.num_timers++;
1105  timer_ptr->timer_id = timer_list.num_timers;
1106 
1107  /* Now add the timer to the timer queue, making sure it is sorted in
1108  increasing order of expiration. */
1109 
1110  for (timer_index = timer_list.first_timer;
1111  timer_index != NULL;
1112  timer_index = timer_index->next)
1113  {
1114  /* If the seconds field is greater or if it is the same, but the
1115  microsecond field is greater. */
1116  if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec)
1117  || ((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
1118  && (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
1119  break;
1120  }
1121 
1122  if (timer_index == timer_list.first_timer)
1123  {
1124  timer_ptr->next = timer_list.first_timer;
1125  timer_list.first_timer = timer_ptr;
1126 
1127  }
1128  else
1129  {
1130  for (prev_timer = timer_list.first_timer;
1131  prev_timer->next != timer_index;
1132  prev_timer = prev_timer->next)
1133  ;
1134 
1135  prev_timer->next = timer_ptr;
1136  timer_ptr->next = timer_index;
1137  }
1138 
1139  gdb_notifier.timeout_valid = 0;
1140  return timer_ptr->timer_id;
1141 }
1142 
1143 /* There is a chance that the creator of the timer wants to get rid of
1144  it before it expires. */
1145 void
1147 {
1148  struct gdb_timer *timer_ptr, *prev_timer = NULL;
1149 
1150  /* Find the entry for the given timer. */
1151 
1152  for (timer_ptr = timer_list.first_timer; timer_ptr != NULL;
1153  timer_ptr = timer_ptr->next)
1154  {
1155  if (timer_ptr->timer_id == id)
1156  break;
1157  }
1158 
1159  if (timer_ptr == NULL)
1160  return;
1161  /* Get rid of the timer in the timer list. */
1162  if (timer_ptr == timer_list.first_timer)
1163  timer_list.first_timer = timer_ptr->next;
1164  else
1165  {
1166  for (prev_timer = timer_list.first_timer;
1167  prev_timer->next != timer_ptr;
1168  prev_timer = prev_timer->next)
1169  ;
1170  prev_timer->next = timer_ptr->next;
1171  }
1172  xfree (timer_ptr);
1173 
1174  gdb_notifier.timeout_valid = 0;
1175 }
1176 
1177 /* Update the timeout for the select() or poll(). Returns true if the
1178  timer has already expired, false otherwise. */
1179 
1180 static int
1182 {
1183  struct timeval time_now, delta;
1184 
1185  if (timer_list.first_timer != NULL)
1186  {
1187  gettimeofday (&time_now, NULL);
1188  delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
1189  delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec;
1190  /* Borrow? */
1191  if (delta.tv_usec < 0)
1192  {
1193  delta.tv_sec -= 1;
1194  delta.tv_usec += 1000000;
1195  }
1196 
1197  /* Cannot simply test if delta.tv_sec is negative because time_t
1198  might be unsigned. */
1199  if (timer_list.first_timer->when.tv_sec < time_now.tv_sec
1200  || (timer_list.first_timer->when.tv_sec == time_now.tv_sec
1201  && timer_list.first_timer->when.tv_usec < time_now.tv_usec))
1202  {
1203  /* It expired already. */
1204  delta.tv_sec = 0;
1205  delta.tv_usec = 0;
1206  }
1207 
1208  /* Update the timeout for select/ poll. */
1209  if (use_poll)
1210  {
1211 #ifdef HAVE_POLL
1212  gdb_notifier.poll_timeout = delta.tv_sec * 1000;
1213 #else
1214  internal_error (__FILE__, __LINE__,
1215  _("use_poll without HAVE_POLL"));
1216 #endif /* HAVE_POLL */
1217  }
1218  else
1219  {
1220  gdb_notifier.select_timeout.tv_sec = delta.tv_sec;
1221  gdb_notifier.select_timeout.tv_usec = delta.tv_usec;
1222  }
1223  gdb_notifier.timeout_valid = 1;
1224 
1225  if (delta.tv_sec == 0 && delta.tv_usec == 0)
1226  return 1;
1227  }
1228  else
1229  gdb_notifier.timeout_valid = 0;
1230 
1231  return 0;
1232 }
1233 
1234 /* Check whether a timer in the timers queue is ready. If a timer is
1235  ready, call its handler and return. Update the timeout for the
1236  select() or poll() as well. Return 1 if an event was handled,
1237  otherwise returns 0.*/
1238 
1239 static int
1241 {
1242  if (update_wait_timeout ())
1243  {
1244  struct gdb_timer *timer_ptr = timer_list.first_timer;
1245  timer_handler_func *proc = timer_ptr->proc;
1247 
1248  /* Get rid of the timer from the beginning of the list. */
1249  timer_list.first_timer = timer_ptr->next;
1250 
1251  /* Delete the timer before calling the callback, not after, in
1252  case the callback itself decides to try deleting the timer
1253  too. */
1254  xfree (timer_ptr);
1255 
1256  /* Call the procedure associated with that timer. */
1257  (proc) (client_data);
1258 
1259  return 1;
1260  }
1261 
1262  return 0;
1263 }
void( sig_handler_func)(gdb_client_data)
Definition: event-loop.h:74
void( event_handler_func)(event_data)
Definition: event-loop.c:53
void start_event_loop(void)
Definition: event-loop.c:335
void( timer_handler_func)(gdb_client_data)
Definition: event-loop.h:76
void(* after_char_processing_hook)(void)
Definition: event-top.c:162
async_event_handler_func * proc
Definition: event-loop.c:131
void clear_async_signal_handler(async_signal_handler *async_handler_ptr)
Definition: event-loop.c:914
void xfree(void *)
Definition: common-utils.c:97
static void handle_file_event(file_handler *file_ptr, int ready_mask)
Definition: event-loop.c:647
async_signal_handler * last_handler
Definition: event-loop.c:240
file_handler * next_file_handler
Definition: event-loop.c:173
void async_enable_stdin(void)
Definition: event-top.c:442
void mark_async_signal_handler(async_signal_handler *async_handler_ptr)
Definition: event-loop.c:906
fd_set ready_masks[3]
Definition: event-loop.c:195
event_data data
Definition: event-loop.c:75
struct gdb_timer * first_timer
Definition: event-loop.c:225
static struct @65 gdb_notifier
#define GDB_WRITABLE
Definition: event-loop.c:42
struct ui_file * gdb_stdout
Definition: main.c:71
void call_async_signal_handler(struct async_signal_handler *handler)
Definition: event-loop.c:896
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
void delete_async_event_handler(async_event_handler **async_handler_ptr)
Definition: event-loop.c:1050
struct file_handler * next_file
Definition: event-loop.c:90
static struct @68 async_event_handler_list
void mark_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1011
#define _(String)
Definition: gdb_locale.h:40
void( async_event_handler_func)(gdb_client_data)
Definition: event-loop.h:75
struct timeval when
Definition: event-loop.c:213
static int update_wait_timeout(void)
Definition: event-loop.c:1181
#define END_CATCH
struct gdb_timer * next
Definition: event-loop.c:215
void add_file_handler(int fd, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:388
fd_set check_masks[3]
Definition: event-loop.c:192
struct timeval select_timeout
Definition: event-loop.c:202
#define TRY
static int timeout
Definition: monitor.c:75
int poll_timeout
Definition: event-loop.c:187
static file_handler * get_next_file_handler_to_handle_and_advance(void)
Definition: event-loop.c:516
#define CATCH(EXCEPTION, MASK)
int timeout_valid
Definition: event-loop.c:205
Definition: gnu-nat.h:42
file_handler * first_file_handler
Definition: event-loop.c:166
int ready_mask
Definition: event-loop.c:85
int async_signal_handler_is_marked(async_signal_handler *async_handler_ptr)
Definition: event-loop.c:922
sig_handler_func * proc
Definition: event-loop.c:110
int num_fds
Definition: event-loop.c:199
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
static unsigned char use_poll
Definition: event-loop.c:156
#define GDB_EXCEPTION
Definition: event-loop.c:43
async_event_handler * create_async_event_handler(async_event_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:988
static int gdb_wait_for_event(int)
Definition: event-loop.c:721
struct gdb_event * gdb_event_p
int next_poll_fds_index
Definition: event-loop.c:184
handler_func * proc
Definition: event-loop.c:87
event_handler_func * proc
Definition: event-loop.c:72
async_signal_handler * create_async_signal_handler(sig_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:873
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int gdb_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
Definition: mingw-hdep.c:59
static int poll_timers(void)
Definition: event-loop.c:1240
#define USE_POLL
Definition: event-loop.c:151
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
void * xmalloc(YYSIZE_T)
struct file_handler file_handler
void * gdb_client_data
Definition: event-loop.h:70
int timer_id
Definition: event-loop.c:214
struct pollfd * poll_fds
Definition: event-loop.c:177
Definition: block.h:60
struct async_signal_handler * next_handler
Definition: event-loop.c:109
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int integer
Definition: event-loop.c:49
void( handler_func)(int, gdb_client_data)
Definition: event-loop.h:73
int num_timers
Definition: event-loop.c:228
static void create_file_handler(int fd, int mask, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:440
int create_timer(int milliseconds, timer_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:1080
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
gdb_client_data client_data
Definition: event-loop.c:88
struct async_event_handler * next_handler
Definition: event-loop.c:128
int gdb_do_one_event(void)
Definition: event-loop.c:271
struct ui_file * gdb_stderr
Definition: main.c:72
static int invoke_async_signal_handlers(void)
Definition: event-loop.c:930
async_signal_handler * first_handler
Definition: event-loop.c:237
struct async_signal_handler async_signal_handler
gdb_client_data client_data
Definition: event-loop.c:217
void delete_timer(int id)
Definition: event-loop.c:1146
union event_data event_data
void clear_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1019
void observer_notify_command_error(void)
timer_handler_func * proc
Definition: event-loop.c:216
#define GDB_READABLE
Definition: event-loop.c:41
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
static int check_async_event_handlers(void)
Definition: event-loop.c:1028
void delete_async_signal_handler(async_signal_handler **async_handler_ptr)
Definition: event-loop.c:959
gdb_client_data client_data
Definition: event-loop.c:134
void delete_file_handler(int fd)
Definition: event-loop.c:539
gdb_client_data client_data
Definition: event-loop.c:111
struct async_event_handler async_event_handler
void * ptr
Definition: event-loop.c:48
static struct @67 sighandler_list
static struct @66 timer_list