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