GDB (xrefs)

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