1 /* Event loop machinery for GDB, the GNU debugger.
2 Copyright 1999 Free Software Foundation, Inc.
3 Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "event-loop.h"
25 #include "event-top.h"
29 #include <sys/types.h>
35 /* Type of the mask arguments to select. */
38 #define SELECT_MASK fd_set
44 #define SELECT_MASK void
46 #define SELECT_MASK int
50 /* Define "NBBY" (number of bits per byte) if it's not already defined. */
57 /* Define the number of fd_masks in an fd_set */
61 #define FD_SETSIZE OPEN_MAX
63 #define FD_SETSIZE 256
67 #define howmany(x, y) (((x)+((y)-1))/(y))
70 #define NFDBITS NBBY*sizeof(fd_mask)
72 #define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
75 typedef struct gdb_event gdb_event;
76 typedef void (event_handler_func) (int);
78 /* Event for the GDB event system. Events are queued by calling
79 async_queue_event and serviced later on by gdb_do_one_event. An
80 event can be, for instance, a file descriptor becoming ready to be
81 read. Servicing an event simply means that the procedure PROC will
82 be called. We have 2 queues, one for file handlers that we listen
83 to in the event loop, and one for the file handlers+events that are
84 ready. The procedure PROC associated with each event is always the
85 same (handle_file_event). Its duty is to invoke the handler
86 associated with the file descriptor whose state change generated
87 the event, plus doing other cleanups adn such. */
91 event_handler_func *proc; /* Procedure to call to service this event. */
92 int fd; /* File descriptor that is ready. */
93 struct gdb_event *next_event; /* Next in list of events or NULL. */
96 /* Information about each file descriptor we register with the event
99 typedef struct file_handler
101 int fd; /* File descriptor. */
102 int mask; /* Events we want to monitor: POLLIN, etc. */
103 int ready_mask; /* Events that have been seen since
105 handler_func *proc; /* Procedure to call when fd is ready. */
106 gdb_client_data client_data; /* Argument to pass to proc. */
107 int error; /* Was an error detected on this fd? */
108 struct file_handler *next_file; /* Next registered file descriptor. */
112 /* PROC is a function to be invoked when the READY flag is set. This
113 happens when there has been a signal and the corresponding signal
114 handler has 'triggered' this async_signal_handler for
115 execution. The actual work to be done in response to a signal will
116 be carried out by PROC at a later time, within process_event. This
117 provides a deferred execution of signal handlers.
118 Async_init_signals takes care of setting up such an
119 asyn_signal_handler for each interesting signal. */
120 typedef struct async_signal_handler
122 int ready; /* If ready, call this handler from the main event loop,
123 using invoke_async_handler. */
124 struct async_signal_handler *next_handler; /* Ptr to next handler */
125 sig_handler_func *proc; /* Function to call to do the work */
126 gdb_client_data client_data; /* Argument to async_handler_func */
128 async_signal_handler;
132 - the first event in the queue is the head of the queue.
133 It will be the next to be serviced.
134 - the last event in the queue
136 Events can be inserted at the front of the queue or at the end of
137 the queue. Events will be extracted from the queue for processing
138 starting from the head. Therefore, events inserted at the head of
139 the queue will be processed in a last in first out fashion, while
140 those inserted at the tail of the queue will be processed in a first
141 in first out manner. All the fields are NULL if the queue is
146 gdb_event *first_event; /* First pending event */
147 gdb_event *last_event; /* Last pending event */
151 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
152 These are the input file descriptor, and the target file
153 descriptor. We have two flavors of the notifier, one for platforms
154 that have the POLL function, the other for those that don't, and
155 only support SELECT. Each of the elements in the gdb_notifier list is
156 basically a description of what kind of events gdb is interested
159 /* As of 1999-04-30 only the input file descriptor is registered with the
163 /* Poll based implementation of the notifier. */
167 /* Ptr to head of file handler list. */
168 file_handler *first_file_handler;
170 /* Ptr to array of pollfd structures. */
171 struct pollfd *poll_fds;
173 /* Number of file descriptors to monitor. */
176 /* Timeout in milliseconds for calls to poll(). */
179 /* Flag to tell whether the timeout value shuld be used. */
184 #else /* ! HAVE_POLL */
186 /* Select based implementation of the notifier. */
190 /* Ptr to head of file handler list. */
191 file_handler *first_file_handler;
193 /* Masks to be used in the next call to select.
194 Bits are set in response to calls to create_file_handler. */
195 fd_mask check_masks[3 * MASK_SIZE];
197 /* What file descriptors were found ready by select. */
198 fd_mask ready_masks[3 * MASK_SIZE];
200 /* Number of valid bits (highest fd value + 1). */
203 /* Time structure for calls to select(). */
204 struct timeval timeout;
206 /* Flag to tell whether the timeout struct should be used. */
211 #endif /* HAVE_POLL */
213 /* Structure associated with a timer. PROC will be executed at the
214 first occasion after WHEN. */
219 struct gdb_timer *next;
220 timer_handler_func *proc; /* Function to call to do the work */
221 gdb_client_data client_data; /* Argument to async_handler_func */
225 /* List of currently active timers. It is sorted in order of
226 increasing timers. */
229 /* Pointer to first in timer list. */
230 struct gdb_timer *first_timer;
232 /* Id of the last timer created. */
237 /* All the async_signal_handlers gdb is interested in are kept onto
241 /* Pointer to first in handler list. */
242 async_signal_handler *first_handler;
244 /* Pointer to last in handler list. */
245 async_signal_handler *last_handler;
249 /* Is any of the handlers ready? Check this variable using
250 check_async_ready. This is used by process_event, to determine
251 whether or not to invoke the invoke_async_signal_handler
253 static int async_handler_ready = 0;
255 static void create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data);
256 static void invoke_async_signal_handler (void);
257 static void handle_file_event (int event_file_desc);
258 static int gdb_wait_for_event (void);
259 static int gdb_do_one_event (void *data);
260 static int check_async_ready (void);
261 static void async_queue_event (gdb_event * event_ptr, queue_position position);
262 static gdb_event *create_file_event (int fd);
263 static int process_event (void);
264 static void handle_timer_event (int dummy);
265 static void poll_timers (void);
268 /* Insert an event object into the gdb event queue at
269 the specified position.
270 POSITION can be head or tail, with values TAIL, HEAD.
271 EVENT_PTR points to the event to be inserted into the queue.
272 The caller must allocate memory for the event. It is freed
273 after the event has ben handled.
274 Events in the queue will be processed head to tail, therefore,
275 events inserted at the head of the queue will be processed
276 as last in first out. Event appended at the tail of the queue
277 will be processed first in first out. */
279 async_queue_event (gdb_event * event_ptr, queue_position position)
281 if (position == TAIL)
283 /* The event will become the new last_event. */
285 event_ptr->next_event = NULL;
286 if (event_queue.first_event == NULL)
287 event_queue.first_event = event_ptr;
289 event_queue.last_event->next_event = event_ptr;
290 event_queue.last_event = event_ptr;
292 else if (position == HEAD)
294 /* The event becomes the new first_event. */
296 event_ptr->next_event = event_queue.first_event;
297 if (event_queue.first_event == NULL)
298 event_queue.last_event = event_ptr;
299 event_queue.first_event = event_ptr;
303 /* Create a file event, to be enqueued in the event queue for
304 processing. The procedure associated to this event is always
305 handle_file_event, which will in turn invoke the one that was
306 associated to FD when it was registered with the event loop. */
308 create_file_event (int fd)
310 gdb_event *file_event_ptr;
312 file_event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
313 file_event_ptr->proc = handle_file_event;
314 file_event_ptr->fd = fd;
315 return (file_event_ptr);
318 /* Process one event.
319 The event can be the next one to be serviced in the event queue,
320 or an asynchronous event handler can be invoked in response to
321 the reception of a signal.
322 If an event was processed (either way), 1 is returned otherwise
324 Scan the queue from head to tail, processing therefore the high
325 priority events first, by invoking the associated event handler
330 gdb_event *event_ptr, *prev_ptr;
331 event_handler_func *proc;
334 /* First let's see if there are any asynchronous event handlers that
335 are ready. These would be the result of invoking any of the
338 if (check_async_ready ())
340 invoke_async_signal_handler ();
344 /* Look in the event queue to find an event that is ready
347 for (event_ptr = event_queue.first_event; event_ptr != NULL;
348 event_ptr = event_ptr->next_event)
350 /* Call the handler for the event. */
352 proc = event_ptr->proc;
355 /* Let's get rid of the event from the event queue. We need to
356 do this now because while processing the event, the proc
357 function could end up calling 'error' and therefore jump out
358 to the caller of this function, gdb_do_one_event. In that
359 case, we would have on the event queue an event wich has been
360 processed, but not deleted. */
362 if (event_queue.first_event == event_ptr)
364 event_queue.first_event = event_ptr->next_event;
365 if (event_ptr->next_event == NULL)
366 event_queue.last_event = NULL;
370 prev_ptr = event_queue.first_event;
371 while (prev_ptr->next_event != event_ptr)
372 prev_ptr = prev_ptr->next_event;
374 prev_ptr->next_event = event_ptr->next_event;
375 if (event_ptr->next_event == NULL)
376 event_queue.last_event = prev_ptr;
378 free ((char *) event_ptr);
380 /* Now call the procedure associted with the event. */
385 /* this is the case if there are no event on the event queue. */
389 /* Process one high level event. If nothing is ready at this time,
390 wait for something to happen (via gdb_wait_for_event), then process
391 it. Returns >0 if something was done otherwise returns <0 (this
392 can happen if there are no event sources to wait for). If an error
393 occures catch_errors() which calls this function returns zero. */
396 gdb_do_one_event (void *data)
398 /* Any events already waiting in the queue? */
399 if (process_event ())
404 /* Are any timers that are ready? If so, put an event on the queue. */
407 /* Wait for a new event. If gdb_wait_for_event returns -1,
408 we should get out because this means that there are no
409 event sources left. This will make the event loop stop,
410 and the application exit. */
412 if (gdb_wait_for_event () < 0)
417 /* Handle any new events occurred while waiting. */
418 if (process_event ())
423 /* If gdb_wait_for_event has returned 1, it means that one
424 event has been handled. We break out of the loop. */
428 /* Start up the event loop. This is the entry point to the event loop
429 from the command loop. */
432 start_event_loop (void)
434 /* Loop until there is nothing to do. This is the entry point to the
435 event loop engine. gdb_do_one_event, called via catch_errors()
436 will process one event for each invocation. It blocks waits for
437 an event and then processes it. >0 when an event is processed, 0
438 when catch_errors() caught an error and <0 when there are no
439 longer any event sources registered. */
442 int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
447 /* FIXME: this should really be a call to a hook that is
448 interface specific, because interfaces can display the
449 prompt in their own way. */
450 display_gdb_prompt (0);
451 /* Maybe better to set a flag to be checked somewhere as to
452 whether display the prompt or not. */
456 /* We are done with the event loop. There are no more event sources
457 to listen to. So we exit GDB. */
462 /* Wrapper function for create_file_handler, so that the caller
463 doesn't have to know implementation details about the use of poll
466 add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
469 create_file_handler (fd, POLLIN, proc, client_data);
471 create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
475 /* Add a file handler/descriptor to the list of descriptors we are
477 FD is the file descriptor for the file/stream to be listened to.
478 For the poll case, MASK is a combination (OR) of
479 POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
480 POLLWRBAND: these are the events we are interested in. If any of them
481 occurs, proc should be called.
482 For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
483 PROC is the procedure that will be called when an event occurs for
484 FD. CLIENT_DATA is the argument to pass to PROC. */
486 create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data)
488 file_handler *file_ptr;
494 /* Do we already have a file handler for this file? (We may be
495 changing its associated procedure). */
496 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
497 file_ptr = file_ptr->next_file)
499 if (file_ptr->fd == fd)
503 /* It is a new file descriptor. Add it to the list. Otherwise, just
504 change the data associated with it. */
505 if (file_ptr == NULL)
507 file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
509 file_ptr->ready_mask = 0;
510 file_ptr->next_file = gdb_notifier.first_file_handler;
511 gdb_notifier.first_file_handler = file_ptr;
513 gdb_notifier.num_fds++;
516 file_ptr->proc = proc;
517 file_ptr->client_data = client_data;
518 file_ptr->mask = mask;
522 if (gdb_notifier.poll_fds)
523 gdb_notifier.poll_fds =
524 (struct pollfd *) realloc (gdb_notifier.poll_fds,
525 (gdb_notifier.num_fds) * sizeof (struct pollfd));
527 gdb_notifier.poll_fds =
528 (struct pollfd *) xmalloc (sizeof (struct pollfd));
529 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
530 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
531 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
533 #else /* ! HAVE_POLL */
535 index = fd / (NBBY * sizeof (fd_mask));
536 bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
538 if (mask & GDB_READABLE)
539 gdb_notifier.check_masks[index] |= bit;
541 gdb_notifier.check_masks[index] &= ~bit;
543 if (mask & GDB_WRITABLE)
544 (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
546 (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
548 if (mask & GDB_EXCEPTION)
549 (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
551 (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
553 if (gdb_notifier.num_fds <= fd)
554 gdb_notifier.num_fds = fd + 1;
556 #endif /* HAVE_POLL */
559 /* Remove the file descriptor FD from the list of monitored fd's:
560 i.e. we don't care anymore about events on the FD. */
562 delete_file_handler (int fd)
564 file_handler *file_ptr, *prev_ptr = NULL;
566 struct pollfd *new_poll_fds;
572 /* Find the entry for the given file. */
574 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
575 file_ptr = file_ptr->next_file)
577 if (file_ptr->fd == fd)
581 if (file_ptr == NULL)
585 /* Create a new poll_fds array by copying every fd's information but the
586 one we want to get rid of. */
589 (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
591 for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
593 if ((gdb_notifier.poll_fds + i)->fd != fd)
595 (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
596 (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
597 (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
601 free (gdb_notifier.poll_fds);
602 gdb_notifier.poll_fds = new_poll_fds;
603 gdb_notifier.num_fds--;
605 #else /* ! HAVE_POLL */
607 index = fd / (NBBY * sizeof (fd_mask));
608 bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
610 if (file_ptr->mask & GDB_READABLE)
611 gdb_notifier.check_masks[index] &= ~bit;
612 if (file_ptr->mask & GDB_WRITABLE)
613 (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
614 if (file_ptr->mask & GDB_EXCEPTION)
615 (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
617 /* Find current max fd. */
619 if ((fd + 1) == gdb_notifier.num_fds)
621 for (gdb_notifier.num_fds = 0; index >= 0; index--)
623 flags = gdb_notifier.check_masks[index]
624 | (gdb_notifier.check_masks + MASK_SIZE)[index]
625 | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
628 for (i = (NBBY * sizeof (fd_mask)); i > 0; i--)
630 if (flags & (((unsigned long) 1) << (i - 1)))
633 gdb_notifier.num_fds = index * (NBBY * sizeof (fd_mask)) + i;
638 #endif /* HAVE_POLL */
640 /* Deactivate the file descriptor, by clearing its mask,
641 so that it will not fire again. */
645 /* Get rid of the file handler in the file handler list. */
646 if (file_ptr == gdb_notifier.first_file_handler)
647 gdb_notifier.first_file_handler = file_ptr->next_file;
650 for (prev_ptr = gdb_notifier.first_file_handler;
651 prev_ptr->next_file != file_ptr;
652 prev_ptr = prev_ptr->next_file)
654 prev_ptr->next_file = file_ptr->next_file;
656 free ((char *) file_ptr);
659 /* Handle the given event by calling the procedure associated to the
660 corresponding file handler. Called by process_event indirectly,
661 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
662 event in the front of the event queue. */
664 handle_file_event (int event_file_desc)
666 file_handler *file_ptr;
670 int error_mask_returned;
673 /* Search the file handler list to find one that matches the fd in
675 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
676 file_ptr = file_ptr->next_file)
678 if (file_ptr->fd == event_file_desc)
680 /* With poll, the ready_mask could have any of three events
681 set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot
682 be used in the requested event mask (events), but they
683 can be returned in the return mask (revents). We need to
684 check for those event too, and add them to the mask which
685 will be passed to the handler. */
687 /* See if the desired events (mask) match the received
688 events (ready_mask). */
691 error_mask = POLLHUP | POLLERR | POLLNVAL;
692 mask = (file_ptr->ready_mask & file_ptr->mask) |
693 (file_ptr->ready_mask & error_mask);
694 error_mask_returned = mask & error_mask;
696 if (error_mask_returned != 0)
698 /* Work in progress. We may need to tell somebody what
699 kind of error we had. */
700 if (error_mask_returned & POLLHUP)
701 printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
702 if (error_mask_returned & POLLERR)
703 printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
704 if (error_mask_returned & POLLNVAL)
705 printf_unfiltered ("Invalid or non-`poll'able fd %d\n", file_ptr->fd);
710 #else /* ! HAVE_POLL */
711 if (file_ptr->ready_mask & GDB_EXCEPTION)
713 printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
718 mask = file_ptr->ready_mask & file_ptr->mask;
719 #endif /* HAVE_POLL */
721 /* Clear the received events for next time around. */
722 file_ptr->ready_mask = 0;
724 /* If there was a match, then call the handler. */
726 (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
732 /* Called by gdb_do_one_event to wait for new events on the
733 monitored file descriptors. Queue file events as they are
734 detected by the poll.
735 If there are no events, this function will block in the
737 Return -1 if there are no files descriptors to monitor,
738 otherwise return 0. */
740 gdb_wait_for_event (void)
742 file_handler *file_ptr;
743 gdb_event *file_event_ptr;
748 int mask, bit, index;
751 /* Make sure all output is done before getting another event. */
752 gdb_flush (gdb_stdout);
753 gdb_flush (gdb_stderr);
755 if (gdb_notifier.num_fds == 0)
760 poll (gdb_notifier.poll_fds,
761 (unsigned long) gdb_notifier.num_fds,
762 gdb_notifier.timeout_valid ? gdb_notifier.timeout : -1);
764 /* Don't print anything if we get out of poll because of a
766 if (num_found == -1 && errno != EINTR)
767 perror_with_name ("Poll");
769 #else /* ! HAVE_POLL */
770 memcpy (gdb_notifier.ready_masks,
771 gdb_notifier.check_masks,
772 3 * MASK_SIZE * sizeof (fd_mask));
773 num_found = select (gdb_notifier.num_fds,
774 (SELECT_MASK *) & gdb_notifier.ready_masks[0],
775 (SELECT_MASK *) & gdb_notifier.ready_masks[MASK_SIZE],
776 (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
777 gdb_notifier.timeout_valid ? &gdb_notifier.timeout : NULL);
779 /* Clear the masks after an error from select. */
782 memset (gdb_notifier.ready_masks,
783 0, 3 * MASK_SIZE * sizeof (fd_mask));
784 /* Dont print anything is we got a signal, let gdb handle it. */
786 perror_with_name ("Select");
788 #endif /* HAVE_POLL */
790 /* Enqueue all detected file events. */
794 for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
796 if ((gdb_notifier.poll_fds + i)->revents)
801 for (file_ptr = gdb_notifier.first_file_handler;
803 file_ptr = file_ptr->next_file)
805 if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
811 /* Enqueue an event only if this is still a new event for
813 if (file_ptr->ready_mask == 0)
815 file_event_ptr = create_file_event (file_ptr->fd);
816 async_queue_event (file_event_ptr, TAIL);
820 file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
823 #else /* ! HAVE_POLL */
824 for (file_ptr = gdb_notifier.first_file_handler;
825 (file_ptr != NULL) && (num_found > 0);
826 file_ptr = file_ptr->next_file)
828 index = file_ptr->fd / (NBBY * sizeof (fd_mask));
829 bit = 1 << (file_ptr->fd % (NBBY * sizeof (fd_mask)));
832 if (gdb_notifier.ready_masks[index] & bit)
833 mask |= GDB_READABLE;
834 if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
835 mask |= GDB_WRITABLE;
836 if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
837 mask |= GDB_EXCEPTION;
844 /* Enqueue an event only if this is still a new event for
847 if (file_ptr->ready_mask == 0)
849 file_event_ptr = create_file_event (file_ptr->fd);
850 async_queue_event (file_event_ptr, TAIL);
852 file_ptr->ready_mask = mask;
854 #endif /* HAVE_POLL */
860 /* Create an asynchronous handler, allocating memory for it.
861 Return a pointer to the newly created handler.
862 This pointer will be used to invoke the handler by
863 invoke_async_signal_handler.
864 PROC is the function to call with CLIENT_DATA argument
865 whenever the handler is invoked. */
866 async_signal_handler *
867 create_async_signal_handler (sig_handler_func * proc, gdb_client_data client_data)
869 async_signal_handler *async_handler_ptr;
872 (async_signal_handler *) xmalloc (sizeof (async_signal_handler));
873 async_handler_ptr->ready = 0;
874 async_handler_ptr->next_handler = NULL;
875 async_handler_ptr->proc = proc;
876 async_handler_ptr->client_data = client_data;
877 if (sighandler_list.first_handler == NULL)
878 sighandler_list.first_handler = async_handler_ptr;
880 sighandler_list.last_handler->next_handler = async_handler_ptr;
881 sighandler_list.last_handler = async_handler_ptr;
882 return async_handler_ptr;
885 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will
886 be used when the handlers are invoked, after we have waited for
887 some event. The caller of this function is the interrupt handler
888 associated with a signal. */
890 mark_async_signal_handler (async_signal_handler * async_handler_ptr)
892 ((async_signal_handler *) async_handler_ptr)->ready = 1;
893 async_handler_ready = 1;
896 /* Call all the handlers that are ready. */
898 invoke_async_signal_handler (void)
900 async_signal_handler *async_handler_ptr;
902 if (async_handler_ready == 0)
904 async_handler_ready = 0;
906 /* Invoke ready handlers. */
910 for (async_handler_ptr = sighandler_list.first_handler;
911 async_handler_ptr != NULL;
912 async_handler_ptr = async_handler_ptr->next_handler)
914 if (async_handler_ptr->ready)
917 if (async_handler_ptr == NULL)
919 async_handler_ptr->ready = 0;
920 (*async_handler_ptr->proc) (async_handler_ptr->client_data);
926 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
927 Free the space allocated for it. */
929 delete_async_signal_handler (async_signal_handler ** async_handler_ptr)
931 async_signal_handler *prev_ptr;
933 if (sighandler_list.first_handler == (*async_handler_ptr))
935 sighandler_list.first_handler = (*async_handler_ptr)->next_handler;
936 if (sighandler_list.first_handler == NULL)
937 sighandler_list.last_handler = NULL;
941 prev_ptr = sighandler_list.first_handler;
942 while (prev_ptr->next_handler != (*async_handler_ptr) && prev_ptr)
943 prev_ptr = prev_ptr->next_handler;
944 prev_ptr->next_handler = (*async_handler_ptr)->next_handler;
945 if (sighandler_list.last_handler == (*async_handler_ptr))
946 sighandler_list.last_handler = prev_ptr;
948 free ((char *) (*async_handler_ptr));
949 (*async_handler_ptr) = NULL;
952 /* Is it necessary to call invoke_async_signal_handler? */
954 check_async_ready (void)
956 return async_handler_ready;
959 /* Create a timer that will expire in MILLISECONDS from now. When the
960 timer is ready, PROC will be executed. At creation, the timer is
961 aded to the timers queue. This queue is kept sorted in order of
962 increasing timers. Return a handle to the timer struct. */
964 create_timer (int milliseconds, timer_handler_func * proc, gdb_client_data client_data)
966 struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
967 struct timeval time_now, delta;
969 /* compute seconds */
970 delta.tv_sec = milliseconds / 1000;
971 /* compute microseconds */
972 delta.tv_usec = (milliseconds % 1000) * 1000;
974 gettimeofday (&time_now, NULL);
976 timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer));
977 timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
978 timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
980 if (timer_ptr->when.tv_usec >= 1000000)
982 timer_ptr->when.tv_sec += 1;
983 timer_ptr->when.tv_usec -= 1000000;
985 timer_ptr->proc = proc;
986 timer_ptr->client_data = client_data;
987 timer_list.num_timers++;
988 timer_ptr->timer_id = timer_list.num_timers;
990 /* Now add the timer to the timer queue, making sure it is sorted in
991 increasing order of expiration. */
993 for (timer_index = timer_list.first_timer;
995 timer_index = timer_index->next)
997 /* If the seconds field is greater or if it is the same, but the
998 microsecond field is greater. */
999 if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
1000 ((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
1001 && (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
1005 if (timer_index == timer_list.first_timer)
1007 timer_ptr->next = timer_list.first_timer;
1008 timer_list.first_timer = timer_ptr;
1013 for (prev_timer = timer_list.first_timer;
1014 prev_timer->next != timer_index;
1015 prev_timer = prev_timer->next)
1018 prev_timer->next = timer_ptr;
1019 timer_ptr->next = timer_index;
1022 gdb_notifier.timeout_valid = 0;
1023 return timer_ptr->timer_id;
1026 /* There is a chance that the creator of the timer wants to get rid of
1027 it before it expires. */
1029 delete_timer (int id)
1031 struct gdb_timer *timer_ptr, *prev_timer = NULL;
1033 /* Find the entry for the given timer. */
1035 for (timer_ptr = timer_list.first_timer; timer_ptr != NULL;
1036 timer_ptr = timer_ptr->next)
1038 if (timer_ptr->timer_id == id)
1042 if (timer_ptr == NULL)
1044 /* Get rid of the timer in the timer list. */
1045 if (timer_ptr == timer_list.first_timer)
1046 timer_list.first_timer = timer_ptr->next;
1049 for (prev_timer = timer_list.first_timer;
1050 prev_timer->next != timer_ptr;
1051 prev_timer = prev_timer->next)
1053 prev_timer->next = timer_ptr->next;
1055 free ((char *) timer_ptr);
1057 gdb_notifier.timeout_valid = 0;
1060 /* When a timer event is put on the event queue, it will be handled by
1061 this function. Just call the assiciated procedure and delete the
1062 timer event from the event queue. Repeat this for each timer that
1065 handle_timer_event (int dummy)
1067 struct timeval time_now;
1068 struct gdb_timer *timer_ptr, *saved_timer;
1070 gettimeofday (&time_now, NULL);
1071 timer_ptr = timer_list.first_timer;
1073 while (timer_ptr != NULL)
1075 if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
1076 ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
1077 (timer_ptr->when.tv_usec > time_now.tv_usec)))
1080 /* Get rid of the timer from the beginning of the list. */
1081 timer_list.first_timer = timer_ptr->next;
1082 saved_timer = timer_ptr;
1083 timer_ptr = timer_ptr->next;
1084 /* Call the procedure associated with that timer. */
1085 (*saved_timer->proc) (saved_timer->client_data);
1089 gdb_notifier.timeout_valid = 0;
1092 /* Check whether any timers in the timers queue are ready. If at least
1093 one timer is ready, stick an event onto the event queue. Even in
1094 case more than one timer is ready, one event is enough, because the
1095 handle_timer_event() will go through the timers list and call the
1096 procedures associated with all that have expired. Update the
1097 timeout for the select() or poll() as well. */
1101 struct timeval time_now, delta;
1102 gdb_event *event_ptr;
1104 if (timer_list.first_timer != NULL)
1106 gettimeofday (&time_now, NULL);
1107 delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
1108 delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec;
1110 if (delta.tv_usec < 0)
1113 delta.tv_usec += 1000000;
1116 /* Oops it expired already. Tell select / poll to return
1117 immediately. (Cannot simply test if delta.tv_sec is negative
1118 because time_t might be unsigned.) */
1119 if (timer_list.first_timer->when.tv_sec < time_now.tv_sec
1120 || (timer_list.first_timer->when.tv_sec == time_now.tv_sec
1121 && timer_list.first_timer->when.tv_usec < time_now.tv_usec))
1127 if (delta.tv_sec == 0 && delta.tv_usec == 0)
1129 event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
1130 event_ptr->proc = handle_timer_event;
1131 event_ptr->fd = timer_list.first_timer->timer_id;
1132 async_queue_event (event_ptr, TAIL);
1135 /* Now we need to update the timeout for select/ poll, because we
1136 don't want to sit there while this timer is expiring. */
1138 gdb_notifier.timeout = delta.tv_sec * 1000;
1140 gdb_notifier.timeout.tv_sec = delta.tv_sec;
1141 gdb_notifier.timeout.tv_usec = delta.tv_usec;
1143 gdb_notifier.timeout_valid = 1;
1146 gdb_notifier.timeout_valid = 0;