import gdb-1999-09-21
[platform/upstream/binutils.git] / gdb / event-loop.c
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.
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 2 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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA. */
21
22 #include "defs.h"
23 #include "top.h"
24 #include "event-loop.h"
25 #include "event-top.h"
26 #include "inferior.h"   /* For fetch_inferior_event. */
27 #ifdef HAVE_POLL
28 #include <poll.h>
29 #else
30 #include <sys/types.h>
31 #endif
32 #include <errno.h>
33 #include <setjmp.h>
34 #include <sys/time.h>
35
36 /* Type of the mask arguments to select. */
37
38 #ifndef NO_FD_SET
39 #define SELECT_MASK fd_set
40 #else
41 #ifndef _AIX
42 typedef long fd_mask;
43 #endif
44 #if defined(_IBMR2)
45 #define SELECT_MASK void
46 #else
47 #define SELECT_MASK int
48 #endif
49 #endif
50
51 /* Define "NBBY" (number of bits per byte) if it's not already defined. */
52
53 #ifndef NBBY
54 #define NBBY 8
55 #endif
56
57
58 /* Define the number of fd_masks in an fd_set */
59
60 #ifndef FD_SETSIZE
61 #ifdef OPEN_MAX
62 #define FD_SETSIZE OPEN_MAX
63 #else
64 #define FD_SETSIZE 256
65 #endif
66 #endif
67 #if !defined(howmany)
68 #define howmany(x, y) (((x)+((y)-1))/(y))
69 #endif
70 #ifndef NFDBITS
71 #define NFDBITS NBBY*sizeof(fd_mask)
72 #endif
73 #define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
74
75
76 typedef struct gdb_event gdb_event;
77 typedef void (event_handler_func) (int);
78
79 /* Event for the GDB event system.  Events are queued by calling
80    async_queue_event and serviced later on by gdb_do_one_event. An
81    event can be, for instance, a file descriptor becoming ready to be
82    read. Servicing an event simply means that the procedure PROC will
83    be called.  We have 2 queues, one for file handlers that we listen
84    to in the event loop, and one for the file handlers+events that are
85    ready. The procedure PROC associated with each event is always the
86    same (handle_file_event).  Its duty is to invoke the handler
87    associated with the file descriptor whose state change generated
88    the event, plus doing other cleanups adn such. */
89
90 struct gdb_event
91   {
92     event_handler_func *proc;   /* Procedure to call to service this event. */
93     int fd;                     /* File descriptor that is ready. */
94     struct gdb_event *next_event;       /* Next in list of events or NULL. */
95   };
96
97 /* Information about each file descriptor we register with the event
98    loop. */
99
100 typedef struct file_handler
101   {
102     int fd;                     /* File descriptor. */
103     int mask;                   /* Events we want to monitor: POLLIN, etc. */
104     int ready_mask;             /* Events that have been seen since
105                                    the last time. */
106     handler_func *proc;         /* Procedure to call when fd is ready. */
107     gdb_client_data client_data;        /* Argument to pass to proc. */
108     int error;                          /* Was an error detected on this fd? */
109     struct file_handler *next_file;     /* Next registered file descriptor. */
110   }
111 file_handler;
112
113 /* PROC is a function to be invoked when the READY flag is set. This
114    happens when there has been a signal and the corresponding signal
115    handler has 'triggered' this async_signal_handler for
116    execution. The actual work to be done in response to a signal will
117    be carried out by PROC at a later time, within process_event. This
118    provides a deferred execution of signal handlers.
119    Async_init_signals takes care of setting up such an
120    asyn_signal_handler for each interesting signal. */
121 typedef struct async_signal_handler
122   {
123     int ready;                  /* If ready, call this handler from the main event loop, 
124                                    using invoke_async_handler. */
125     struct async_signal_handler *next_handler;  /* Ptr to next handler */
126     sig_handler_func *proc;                     /* Function to call to do the work */
127     gdb_client_data client_data;        /* Argument to async_handler_func */
128   }
129 async_signal_handler;
130
131
132 /* Event queue:  
133    - the first event in the queue is the head of the queue. 
134    It will be the next to be serviced.
135    - the last event in the queue 
136
137    Events can be inserted at the front of the queue or at the end of
138    the queue.  Events will be extracted from the queue for processing
139    starting from the head.  Therefore, events inserted at the head of
140    the queue will be processed in a last in first out fashion, while
141    those inserted at the tail of the queue will be processed in a first
142    in first out manner.  All the fields are NULL if the queue is
143    empty. */
144
145 static struct
146   {
147     gdb_event *first_event;     /* First pending event */
148     gdb_event *last_event;      /* Last pending event */
149   }
150 event_queue;
151
152 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
153    These are the input file descriptor, and the target file
154    descriptor. We have two flavors of the notifier, one for platforms
155    that have the POLL function, the other for those that don't, and
156    only support SELECT. Each of the elements in the gdb_notifier list is
157    basically a description of what kind of events gdb is interested
158    in, for each fd. */
159
160 /* As of 1999-04-30 only the input file descriptor is registered with the
161    event loop. */
162
163 #ifdef HAVE_POLL
164 /* Poll based implementation of the notifier. */
165
166 static struct
167   {
168     /* Ptr to head of file handler list. */
169     file_handler *first_file_handler;
170
171     /* Ptr to array of pollfd structures. */
172     struct pollfd *poll_fds;
173
174     /* Number of file descriptors to monitor. */
175     int num_fds;
176
177     /* Timeout in milliseconds for calls to poll(). */
178     int timeout;
179
180     /* Flag to tell whether the timeout value shuld be used. */
181     int timeout_valid;
182   }
183 gdb_notifier;
184
185 #else /* ! HAVE_POLL */
186
187 /* Select based implementation of the notifier. */
188
189 static struct
190   {
191     /* Ptr to head of file handler list. */
192     file_handler *first_file_handler;
193
194     /* Masks to be used in the next call to select.
195        Bits are set in response to calls to create_file_handler. */
196     fd_mask check_masks[3 * MASK_SIZE];
197
198     /* What file descriptors were found ready by select. */
199     fd_mask ready_masks[3 * MASK_SIZE];
200
201     /* Number of valid bits (highest fd value + 1). */
202     int num_fds;
203
204     /* Time structure for calls to select(). */
205     struct timeval timeout;
206
207     /* Flag to tell whether the timeout struct should be used. */
208     int timeout_valid;
209    }
210 gdb_notifier;
211
212 #endif /* HAVE_POLL */
213
214 /* Structure associated with a timer. PROC will be executed at the
215    first occasion after WHEN. */
216 struct gdb_timer
217   {
218     struct timeval when;
219     int timer_id;
220     struct gdb_timer *next;
221     timer_handler_func *proc;         /* Function to call to do the work */
222     gdb_client_data client_data;      /* Argument to async_handler_func */
223   }
224 gdb_timer;
225
226 /* List of currently active timers. It is sorted in order of
227    increasing timers.*/
228 static struct
229   {
230     /* Pointer to first in timer list. */
231     struct gdb_timer *first_timer;
232
233     /* Length of timer list. */
234     int num_timers;
235   }
236 timer_list;
237
238 /* All the async_signal_handlers gdb is interested in are kept onto
239    this list. */
240 static struct
241   {
242     /* Pointer to first in handler list. */
243     async_signal_handler *first_handler;
244
245     /* Pointer to last in handler list. */
246     async_signal_handler *last_handler;
247   }
248 sighandler_list;
249
250 /* Is any of the handlers ready?  Check this variable using
251    check_async_ready. This is used by process_event, to determine
252    whether or not to invoke the invoke_async_signal_handler
253    function. */
254 static int async_handler_ready = 0;
255
256 static void create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data);
257 static void invoke_async_signal_handler (void);
258 static void handle_file_event (int event_file_desc);
259 static int gdb_wait_for_event (void);
260 static int gdb_do_one_event (void);
261 static int check_async_ready (void);
262 static void async_queue_event (gdb_event *event_ptr, queue_position position);
263 static gdb_event * create_file_event (int fd);
264 static int process_event (void);
265 static void handle_timer_event (int dummy);
266 static void poll_timers (void);
267 \f
268
269 /* Insert an event object into the gdb event queue at 
270    the specified position.
271    POSITION can be head or tail, with values TAIL, HEAD.
272    EVENT_PTR points to the event to be inserted into the queue.
273    The caller must allocate memory for the event. It is freed
274    after the event has ben handled.
275    Events in the queue will be processed head to tail, therefore,
276    events inserted at the head of the queue will be processed
277    as last in first out. Event appended at the tail of the queue
278    will be processed first in first out. */
279 static void
280 async_queue_event (gdb_event *event_ptr, queue_position position)
281 {
282   if (position == TAIL)
283     {
284       /* The event will become the new last_event. */
285
286       event_ptr->next_event = NULL;
287       if (event_queue.first_event == NULL)
288         event_queue.first_event = event_ptr;
289       else
290         event_queue.last_event->next_event = event_ptr;
291       event_queue.last_event = event_ptr;
292     }
293   else if (position == HEAD)
294     {
295       /* The event becomes the new first_event. */
296
297       event_ptr->next_event = event_queue.first_event;
298       if (event_queue.first_event == NULL)
299         event_queue.last_event = event_ptr;
300       event_queue.first_event = event_ptr;
301     }
302 }
303
304 /* Create a file event, to be enqueued in the event queue for
305    processing. The procedure associated to this event is always
306    handle_file_event, which will in turn invoke the one that was
307    associated to FD when it was registered with the event loop. */
308 static gdb_event *
309 create_file_event (int fd)
310 {
311   gdb_event *file_event_ptr;
312
313   file_event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
314   file_event_ptr->proc = handle_file_event;
315   file_event_ptr->fd = fd;
316   return (file_event_ptr);
317 }
318
319 /* Process one event.
320    The event can be the next one to be serviced in the event queue,
321    or an asynchronous event handler can be invoked in response to
322    the reception of a signal.
323    If an event was processed (either way), 1 is returned otherwise
324    0 is returned.   
325    Scan the queue from head to tail, processing therefore the high
326    priority events first, by invoking the associated event handler
327    procedure. */
328 static int
329 process_event (void)
330 {
331   gdb_event *event_ptr, *prev_ptr;
332   event_handler_func *proc;
333   int fd;
334
335   /* First let's see if there are any asynchronous event handlers that
336      are ready. These would be the result of invoking any of the
337      signal handlers. */
338
339   if (check_async_ready ())
340     {
341       invoke_async_signal_handler ();
342       return 1;
343     }
344
345   /* Look in the event queue to find an event that is ready
346      to be processed. */
347
348   for (event_ptr = event_queue.first_event; event_ptr != NULL;
349        event_ptr = event_ptr->next_event)
350     {
351       /* Call the handler for the event. */
352
353       proc = event_ptr->proc;
354       fd = event_ptr->fd;
355
356       /* Let's get rid of the event from the event queue.  We need to
357          do this now because while processing the event, the proc
358          function could end up calling 'error' and therefore jump out
359          to the caller of this function, gdb_do_one_event. In that
360          case, we would have on the event queue an event wich has been
361          processed, but not deleted. */
362
363       if (event_queue.first_event == event_ptr)
364         {
365           event_queue.first_event = event_ptr->next_event;
366           if (event_ptr->next_event == NULL)
367             event_queue.last_event = NULL;
368         }
369       else
370         {
371           prev_ptr = event_queue.first_event;
372           while (prev_ptr->next_event != event_ptr)
373             prev_ptr = prev_ptr->next_event;
374
375           prev_ptr->next_event = event_ptr->next_event;
376           if (event_ptr->next_event == NULL)
377             event_queue.last_event = prev_ptr;
378         }
379       free ((char *) event_ptr);
380
381       /* Now call the procedure associted with the event. */
382       (*proc) (fd);
383       return 1;
384     }
385
386   /* this is the case if there are no event on the event queue. */
387   return 0;
388 }
389
390 /* Process one high level event.  If nothing is ready at this time,
391    wait for something to happen (via gdb_wait_for_event), then process
392    it.  Returns 1 if something was done otherwise returns 0 (this can
393    happen if there are no event sources to wait for). */
394 static int
395 gdb_do_one_event (void)
396 {
397   int result = 0;
398
399   while (1)
400     {
401       if (!SET_TOP_LEVEL ())
402         {
403           /* Any events already waiting in the queue? */
404           if (process_event ())
405             {
406               result = 1;
407               break;
408             }
409
410           /* Are any timers that are ready? If so, put an event on the queue.*/
411           poll_timers ();
412
413           /* Wait for a new event.  If gdb_wait_for_event returns -1,
414              we should get out because this means that there are no
415              event sources left. This will make the event loop stop,
416              and the application exit. */
417
418           result = gdb_wait_for_event ();
419           if (result < 0)
420             {
421               result = 0;
422               break;
423             }
424
425           /* Handle any new events occurred while waiting. */
426           if (process_event ())
427             {
428               result = 1;
429               break;
430             }
431
432           /* If gdb_wait_for_event has returned 1, it means that one
433              event has been handled. We break out of the loop. */
434           if (result)
435             break;
436         }                       /* end of if !set_top_level */
437       else
438         {
439           /* FIXME: this should really be a call to a hook that is
440              interface specific, because interfaces can display the
441              prompt in their own way. */
442           display_gdb_prompt (0);
443           /* Maybe better to set a flag to be checked somewhere as to
444              whether display the prompt or not. */
445         }
446     }
447   return result;
448 }
449 \f
450
451 /* Start up the event loop. This is the entry point to the event loop
452    from the command loop. */
453 void
454 start_event_loop (void)
455 {
456   /* Loop until there is something to do. This is the entry point to
457      the event loop engine. gdb_do_one_event will process one event
458      for each invocation.  It always returns 1, unless there are no
459      more event sources registered. In this case it returns 0.  */
460   while (gdb_do_one_event () != 0)
461     ;
462
463   /* We are done with the event loop. There are no more event sources
464      to listen to.  So we exit GDB. */
465   return;
466 }
467 \f
468
469 /* Wrapper function for create_file_handler, so that the caller
470    doesn't have to know implementation details about the use of poll
471    vs. select. */
472 void
473 add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
474 {
475 #ifdef HAVE_POLL
476   create_file_handler (fd, POLLIN, proc, client_data);
477 #else
478   create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
479 #endif
480 }
481
482 /* Add a file handler/descriptor to the list of descriptors we are
483    interested in.  
484    FD is the file descriptor for the file/stream to be listened to.  
485    For the poll case, MASK is a combination (OR) of
486    POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
487    POLLWRBAND: these are the events we are interested in. If any of them 
488    occurs, proc should be called.
489    For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
490    PROC is the procedure that will be called when an event occurs for
491    FD.  CLIENT_DATA is the argument to pass to PROC. */
492 static void
493 create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data)
494 {
495   file_handler *file_ptr;
496
497 #ifndef HAVE_POLL
498   int index, bit;
499 #endif
500
501   /* Do we already have a file handler for this file? (We may be
502      changing its associated procedure). */
503   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
504        file_ptr = file_ptr->next_file)
505     {
506       if (file_ptr->fd == fd)
507         break;
508     }
509
510   /* It is a new file descriptor. Add it to the list. Otherwise, just
511      change the data associated with it.*/
512   if (file_ptr == NULL)
513     {
514       file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
515       file_ptr->fd = fd;
516       file_ptr->ready_mask = 0;
517       file_ptr->next_file = gdb_notifier.first_file_handler;
518       gdb_notifier.first_file_handler = file_ptr;
519 #ifdef HAVE_POLL
520       gdb_notifier.num_fds++;
521 #endif
522     }
523   file_ptr->proc = proc;
524   file_ptr->client_data = client_data;
525   file_ptr->mask = mask;
526
527 #ifdef HAVE_POLL
528
529   if (gdb_notifier.poll_fds)
530     gdb_notifier.poll_fds =
531       (struct pollfd *) realloc (gdb_notifier.poll_fds,
532                            (gdb_notifier.num_fds) * sizeof (struct pollfd));
533   else
534     gdb_notifier.poll_fds =
535       (struct pollfd *) xmalloc (sizeof (struct pollfd));
536   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
537   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
538   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
539
540 #else /* ! HAVE_POLL */
541
542   index = fd / (NBBY * sizeof (fd_mask));
543   bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
544
545   if (mask & GDB_READABLE)
546     gdb_notifier.check_masks[index] |= bit;
547   else
548     gdb_notifier.check_masks[index] &= ~bit;
549
550   if (mask & GDB_WRITABLE)
551     (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
552   else
553     (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
554
555   if (mask & GDB_EXCEPTION)
556     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
557   else
558     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
559
560   if (gdb_notifier.num_fds <= fd)
561     gdb_notifier.num_fds = fd + 1;
562
563 #endif /* HAVE_POLL */
564 }
565
566 /* Remove the file descriptor FD from the list of monitored fd's: 
567    i.e. we don't care anymore about events on the FD. */
568 void
569 delete_file_handler (int fd)
570 {
571   file_handler *file_ptr, *prev_ptr = NULL;
572   int i, j;
573   struct pollfd *new_poll_fds;
574 #ifndef HAVE_POLL
575   int index, bit;
576   unsigned long flags;
577 #endif
578
579   /* Find the entry for the given file. */
580
581   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
582        file_ptr = file_ptr->next_file)
583     {
584       if (file_ptr->fd == fd)
585         break;
586     }
587
588   if (file_ptr == NULL)
589     return;
590
591 #ifdef HAVE_POLL
592   /* Create a new poll_fds array by copying every fd's information but the
593      one we want to get rid of. */
594
595   new_poll_fds =
596     (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
597
598   for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
599     {
600       if ((gdb_notifier.poll_fds + i)->fd != fd)
601         {
602           (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
603           (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
604           (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
605           j++;
606         }
607     }
608   free (gdb_notifier.poll_fds);
609   gdb_notifier.poll_fds = new_poll_fds;
610   gdb_notifier.num_fds--;
611
612 #else /* ! HAVE_POLL */
613
614   index = fd / (NBBY * sizeof (fd_mask));
615   bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
616
617   if (file_ptr->mask & GDB_READABLE)
618     gdb_notifier.check_masks[index] &= ~bit;
619   if (file_ptr->mask & GDB_WRITABLE)
620     (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
621   if (file_ptr->mask & GDB_EXCEPTION)
622     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
623
624   /* Find current max fd. */
625
626   if ((fd + 1) == gdb_notifier.num_fds)
627     {
628       for (gdb_notifier.num_fds = 0; index >= 0; index--)
629         {
630           flags = gdb_notifier.check_masks[index]
631             | (gdb_notifier.check_masks + MASK_SIZE)[index]
632             | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
633           if (flags)
634             {
635               for (i = (NBBY * sizeof (fd_mask)); i > 0; i--)
636                 {
637                   if (flags & (((unsigned long) 1) << (i - 1)))
638                     break;
639                 }
640               gdb_notifier.num_fds = index * (NBBY * sizeof (fd_mask)) + i;
641               break;
642             }
643         }
644     }
645 #endif /* HAVE_POLL */
646
647   /* Deactivate the file descriptor, by clearing its mask, 
648      so that it will not fire again. */
649
650   file_ptr->mask = 0;
651
652   /* Get rid of the file handler in the file handler list. */
653   if (file_ptr == gdb_notifier.first_file_handler)
654     gdb_notifier.first_file_handler = file_ptr->next_file;
655   else
656     {
657       for (prev_ptr = gdb_notifier.first_file_handler;
658            prev_ptr->next_file != file_ptr;
659            prev_ptr = prev_ptr->next_file)
660         ;
661       prev_ptr->next_file = file_ptr->next_file;
662     }
663   free ((char *) file_ptr);
664 }
665
666 /* Handle the given event by calling the procedure associated to the
667    corresponding file handler.  Called by process_event indirectly,
668    through event_ptr->proc.  EVENT_FILE_DESC is file descriptor of the
669    event in the front of the event queue. */
670 static void
671 handle_file_event (int event_file_desc)
672 {
673   file_handler *file_ptr;
674   int mask;
675 #ifdef HAVE_POLL
676   int error_mask;
677   int error_mask_returned;
678 #endif
679
680   /* Search the file handler list to find one that matches the fd in
681      the event. */
682   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
683        file_ptr = file_ptr->next_file)
684     {
685       if (file_ptr->fd == event_file_desc)
686         {
687           /* With poll, the ready_mask could have any of three events
688              set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot
689              be used in the requested event mask (events), but they
690              can be returned in the return mask (revents). We need to
691              check for those event too, and add them to the mask which
692              will be passed to the handler. */
693
694           /* See if the desired events (mask) match the received
695              events (ready_mask). */
696
697 #ifdef HAVE_POLL
698           error_mask = POLLHUP | POLLERR | POLLNVAL;
699           mask = (file_ptr->ready_mask & file_ptr->mask) |
700             (file_ptr->ready_mask & error_mask);
701           error_mask_returned = mask & error_mask;
702
703           if (error_mask_returned != 0)
704             {
705               /* Work in progress. We may need to tell somebody what
706                  kind of error we had. */
707               /*if (error_mask_returned & POLLHUP)
708                 printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
709               if (error_mask_returned & POLLERR)
710                 printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
711               if (error_mask_returned & POLLNVAL)
712                 printf_unfiltered ("Invalid fd %d\n", file_ptr->fd);*/
713               file_ptr->error = 1;
714            }
715           else 
716             file_ptr->error = 0;
717 #else /* ! HAVE_POLL */
718           if (file_ptr->ready_mask & GDB_EXCEPTION)
719             {
720               printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
721               file_ptr->error = 1;
722             }
723           else
724             file_ptr->error = 0;
725           mask = file_ptr->ready_mask & file_ptr->mask;
726 #endif /* HAVE_POLL */
727
728           /* Clear the received events for next time around. */
729           file_ptr->ready_mask = 0;
730
731           /* If there was a match, then call the handler. */
732           if (mask != 0)
733             (*file_ptr->proc) (file_ptr->error, file_ptr->fd, file_ptr->client_data);
734           break;
735         }
736     }
737 }
738
739 /* Called by gdb_do_one_event to wait for new events on the 
740    monitored file descriptors. Queue file events as they are 
741    detected by the poll. 
742    If there are no events, this function will block in the 
743    call to poll.
744    Return -1 if there are no files descriptors to monitor, 
745    otherwise return 0. */
746 static int
747 gdb_wait_for_event (void)
748 {
749   file_handler *file_ptr;
750   gdb_event *file_event_ptr;
751   int num_found = 0;
752   int i;
753
754 #ifndef HAVE_POLL
755   int mask, bit, index;
756 #endif
757
758   /* Make sure all output is done before getting another event. */
759   gdb_flush (gdb_stdout);
760   gdb_flush (gdb_stderr);
761
762   if (gdb_notifier.num_fds == 0)
763     return -1;
764
765 #ifdef HAVE_POLL
766   num_found =
767     poll (gdb_notifier.poll_fds, 
768           (unsigned long) gdb_notifier.num_fds, 
769           gdb_notifier.timeout_valid ? gdb_notifier.timeout : -1);
770
771   /* Don't print anything if we get out of poll because of a
772      signal.*/
773   if (num_found == -1 && errno != EINTR)
774     perror_with_name ("Poll");
775
776 #else /* ! HAVE_POLL */
777   memcpy (gdb_notifier.ready_masks,
778           gdb_notifier.check_masks,
779           3 * MASK_SIZE * sizeof (fd_mask));
780   num_found = select (gdb_notifier.num_fds,
781                       (SELECT_MASK *) & gdb_notifier.ready_masks[0],
782                       (SELECT_MASK *) & gdb_notifier.ready_masks[MASK_SIZE],
783                       (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
784                       gdb_notifier.timeout_valid ? gdb_notifier.timeout : NULL);
785
786   /* Clear the masks after an error from select. */
787   if (num_found == -1)
788     {
789       memset (gdb_notifier.ready_masks,
790               0, 3 * MASK_SIZE * sizeof (fd_mask));
791       /* Dont print anything is we got a signal, let gdb handle it. */
792       if (errno != EINTR)
793         perror_with_name ("Select");
794     }
795 #endif /* HAVE_POLL */
796
797   /* Enqueue all detected file events. */
798
799 #ifdef HAVE_POLL
800
801   for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
802     {
803       if ((gdb_notifier.poll_fds + i)->revents)
804         num_found--;
805       else
806         continue;
807
808       for (file_ptr = gdb_notifier.first_file_handler;
809            file_ptr != NULL;
810            file_ptr = file_ptr->next_file)
811         {
812           if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
813             break;
814         }
815
816       if (file_ptr)
817         {
818           /* Enqueue an event only if this is still a new event for
819              this fd. */
820           if (file_ptr->ready_mask == 0)
821             {
822               file_event_ptr = create_file_event (file_ptr->fd);
823               async_queue_event (file_event_ptr, TAIL);
824             }
825         }
826
827       file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
828     }
829
830 #else /* ! HAVE_POLL */
831   for (file_ptr = gdb_notifier.first_file_handler;
832        (file_ptr != NULL) && (num_found > 0);
833        file_ptr = file_ptr->next_file)
834     {
835       index = file_ptr->fd / (NBBY * sizeof (fd_mask));
836       bit = 1 << (file_ptr->fd % (NBBY * sizeof (fd_mask)));
837       mask = 0;
838
839       if (gdb_notifier.ready_masks[index] & bit)
840         mask |= GDB_READABLE;
841       if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
842         mask |= GDB_WRITABLE;
843       if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
844         mask |= GDB_EXCEPTION;
845
846       if (!mask)
847         continue;
848       else
849         num_found--;
850
851       /* Enqueue an event only if this is still a new event for
852          this fd. */
853
854       if (file_ptr->ready_mask == 0)
855         {
856           file_event_ptr = create_file_event (file_ptr->fd);
857           async_queue_event (file_event_ptr, TAIL);
858         }
859       file_ptr->ready_mask = mask;
860     }
861 #endif /* HAVE_POLL */
862
863   return 0;
864 }
865 \f
866
867 /* Create an asynchronous handler, allocating memory for it. 
868    Return a pointer to the newly created handler.
869    This pointer will be used to invoke the handler by 
870    invoke_async_signal_handler.
871    PROC is the function to call with CLIENT_DATA argument 
872    whenever the handler is invoked. */
873 async_signal_handler *
874 create_async_signal_handler (sig_handler_func *proc, gdb_client_data client_data)
875 {
876   async_signal_handler *async_handler_ptr;
877
878   async_handler_ptr =
879     (async_signal_handler *) xmalloc (sizeof (async_signal_handler));
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 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will
893    be used when the handlers are invoked, after we have waited for
894    some event.  The caller of this function is the interrupt handler
895    associated with a signal. */
896 void
897 mark_async_signal_handler (async_signal_handler *async_handler_ptr)
898 {
899   ((async_signal_handler *) async_handler_ptr)->ready = 1;
900   async_handler_ready = 1;
901 }
902
903 /* Call all the handlers that are ready. */
904 static void
905 invoke_async_signal_handler (void)
906 {
907   async_signal_handler *async_handler_ptr;
908
909   if (async_handler_ready == 0)
910     return;
911   async_handler_ready = 0;
912
913   /* Invoke ready handlers. */
914
915   while (1)
916     {
917       for (async_handler_ptr = sighandler_list.first_handler;
918            async_handler_ptr != NULL;
919            async_handler_ptr = async_handler_ptr->next_handler)
920         {
921           if (async_handler_ptr->ready)
922             break;
923         }
924       if (async_handler_ptr == NULL)
925         break;
926       async_handler_ptr->ready = 0;
927       (*async_handler_ptr->proc) (async_handler_ptr->client_data);
928     }
929
930   return;
931 }
932
933 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR). 
934    Free the space allocated for it.  */
935 void
936 delete_async_signal_handler (async_signal_handler **async_handler_ptr)
937 {
938   async_signal_handler *prev_ptr;
939
940   if (sighandler_list.first_handler == (*async_handler_ptr))
941     {
942       sighandler_list.first_handler = (*async_handler_ptr)->next_handler;
943       if (sighandler_list.first_handler == NULL)
944         sighandler_list.last_handler = NULL;
945     }
946   else
947     {
948       prev_ptr = sighandler_list.first_handler;
949       while (prev_ptr->next_handler != (*async_handler_ptr) && prev_ptr)
950         prev_ptr = prev_ptr->next_handler;
951       prev_ptr->next_handler = (*async_handler_ptr)->next_handler;
952       if (sighandler_list.last_handler == (*async_handler_ptr))
953         sighandler_list.last_handler = prev_ptr;
954     }
955   free ((char *) (*async_handler_ptr));
956   (*async_handler_ptr) = NULL;
957 }
958
959 /* Is it necessary to call invoke_async_signal_handler? */
960 static int
961 check_async_ready (void)
962 {
963   return async_handler_ready;
964 }
965
966 /* FIXME: where does this function belong? */
967 /* General function to handle events in the inferior. So far it just
968    takes care of detecting errors reported by select() or poll(),
969    otherwise it assumes that all is OK, and goes on reading data from
970    the fd. This however may not always be what we want to do. */
971 void
972 inferior_event_handler (int error, gdb_client_data client_data, int fd)
973 {
974   if (error == 1)
975     {
976       printf_unfiltered ("error detected on fd %d\n", fd);
977       delete_file_handler (fd);
978       discard_all_continuations ();
979     }
980   else
981     fetch_inferior_event (client_data);
982 }
983
984 /* Create a timer that will expire in MILLISECONDS from now. When the
985    timer is ready, PROC will be executed. At creation, the timer is
986    aded to the timers queue.  This queue is kept sorted in order of
987    increasing timers. Return a handle to the timer struct.*/
988 int
989 create_timer (int milliseconds, timer_handler_func *proc, gdb_client_data client_data)
990 {
991   struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
992   struct timeval time_now, delta;
993
994   /* compute seconds */
995   delta.tv_sec = milliseconds / 1000;
996   /* compute microseconds */
997   delta.tv_usec = (milliseconds % 1000) * 1000; 
998   
999   gettimeofday (&time_now, NULL);
1000
1001   timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer));
1002   timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
1003   timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
1004   /* carry? */
1005   if (timer_ptr->when.tv_usec >= 1000000 )
1006     {
1007       timer_ptr->when.tv_sec += 1;
1008       timer_ptr->when.tv_usec -= 1000000;
1009     }
1010   timer_ptr->proc = proc;
1011   timer_ptr->client_data = client_data;
1012   timer_list.num_timers ++;
1013   timer_ptr->timer_id = timer_list.num_timers;
1014
1015   /* Now add the timer to the timer queue, making sure it is sorted in
1016      increasing order of expiration. */
1017
1018   for (timer_index = timer_list.first_timer; 
1019        timer_index != NULL; 
1020        timer_index = timer_index->next)
1021     {
1022       /* If the seconds field is greater or if it is the same, but the
1023          microsecond field is greater. */
1024       if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) || 
1025           ((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
1026            && (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
1027         break;
1028     }
1029   
1030   if (timer_index == timer_list.first_timer)
1031     {
1032       timer_ptr->next = timer_list.first_timer;
1033       timer_list.first_timer = timer_ptr;
1034
1035     }
1036   else
1037     {
1038       for (prev_timer = timer_list.first_timer; 
1039            prev_timer->next != timer_index; 
1040            prev_timer = prev_timer->next)
1041         ;
1042       
1043       prev_timer->next = timer_ptr;
1044       timer_ptr->next = timer_index;
1045     }
1046
1047   gdb_notifier.timeout_valid = 0;
1048   return timer_ptr->timer_id;
1049 }
1050
1051 /* There is a chance that the creator of the timer wants to get rid of
1052    it before it expires. */
1053 void
1054 delete_timer (int id)
1055 {
1056   struct gdb_timer *timer_ptr, *prev_timer = NULL;
1057
1058   /* Find the entry for the given timer. */
1059
1060   for (timer_ptr = timer_list.first_timer; timer_ptr != NULL;
1061        timer_ptr = timer_ptr->next)
1062     {
1063       if (timer_ptr->timer_id == id)
1064         break;
1065     }
1066
1067   if (timer_ptr == NULL)
1068     return;
1069   /* Get rid of the timer in the timer list. */
1070   if (timer_ptr == timer_list.first_timer)
1071     timer_list.first_timer = timer_ptr->next;
1072   else
1073     {
1074       for (prev_timer = timer_list.first_timer;
1075            prev_timer->next != timer_ptr;
1076            prev_timer = prev_timer->next)
1077         ;
1078       prev_timer->next = timer_ptr->next;
1079     }
1080   free ((char *) timer_ptr);
1081
1082   gdb_notifier.timeout_valid = 0;
1083 }
1084
1085 /* When a timer event is put on the event queue, it will be handled by
1086    this function.  Just call the assiciated procedure and delete the
1087    timer event from the event queue. Repeat this for each timer that
1088    has expired.*/
1089 static void
1090 handle_timer_event (int dummy)
1091 {
1092   struct timeval time_now;
1093   struct gdb_timer *timer_ptr, *saved_timer;
1094  
1095   gettimeofday (&time_now, NULL);
1096   timer_ptr = timer_list.first_timer;
1097
1098   while (timer_ptr != NULL)
1099     {
1100       if ((timer_ptr->when.tv_sec > time_now.tv_sec) || 
1101           ((timer_ptr->when.tv_sec == time_now.tv_sec) && 
1102            (timer_ptr->when.tv_usec > time_now.tv_usec)))
1103         break;
1104
1105       /* Get rid of the timer from the beginning of the list. */
1106       timer_list.first_timer = timer_ptr->next;
1107       saved_timer = timer_ptr;
1108       timer_ptr = timer_ptr->next;
1109       /* Call the procedure associated with that timer. */
1110       (*saved_timer->proc) (timer_ptr->client_data);
1111       free (saved_timer);
1112     }
1113
1114   gdb_notifier.timeout_valid = 0;
1115 }
1116  
1117 /* Check whether any timers in the timers queue are ready. If at least
1118    one timer is ready, stick an event onto the event queue.  Even in
1119    case more than one timer is ready, one event is enough, because the
1120    handle_timer_event() will go through the timers list and call the
1121    procedures associated with all that have expired. Update the
1122    timeout for the select() or poll() as well.*/
1123 static void
1124 poll_timers (void)
1125 {
1126   struct timeval time_now, delta;
1127   gdb_event *event_ptr;
1128  
1129   if (timer_list.num_timers)
1130     {
1131       gettimeofday (&time_now, NULL);
1132       delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
1133       delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec;
1134       /* borrow? */
1135       if (delta.tv_usec < 0)
1136         {
1137           delta.tv_sec -= 1;
1138           delta.tv_usec += 1000000;
1139         }
1140  
1141       /* Oops it expired already. Tell select / poll to return
1142          immediately. */
1143       if (delta.tv_sec < 0)
1144         {
1145           delta.tv_sec = 0;
1146           delta.tv_usec = 0;
1147         }
1148
1149       if (delta.tv_sec == 0 && delta.tv_usec == 0)
1150         {
1151           event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
1152           event_ptr->proc = handle_timer_event;
1153           event_ptr->fd = timer_list.first_timer->timer_id;
1154           async_queue_event (event_ptr, TAIL);
1155         }
1156
1157       /* Now we need to update the timeout for select/ poll, because we
1158          don't want to sit there while this timer is expiring. */
1159 #ifdef HAVE_POLL
1160       gdb_notifier.timeout = delta.tv_sec * 1000; 
1161 #else
1162       gdb_notifier.timeout.sec = delta.tv_sec;
1163       gdb_notifier.timeout.usec = delta.tv_usec;
1164 #endif
1165       gdb_notifier.timeout_valid = 1;
1166     }
1167   else 
1168     gdb_notifier.timeout_valid = 0;
1169 }