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 <sys/time.h>
  39
  40 /* Type of the mask arguments to select. */
  41
  42 #ifndef HAVE_POLL
  43 #ifdef NO_FD_SET
  44 /* All this stuff below is not required if select is used as God(tm)
  45    intended, with the FD_* macros.  Are there any implementations of
  46    select which don't have FD_SET and other standard FD_* macros?  I
  47    don't think there are, but if I'm wrong, we need to catch them.  */
  48 #error FD_SET must be defined if select function is to be used!
  49
  50 #ifndef _AIX
  51 typedef long fd_mask;
  52 #endif
  53 #if defined(_IBMR2)
  54 #define SELECT_MASK void
  55 #else
  56 #define SELECT_MASK int
  57 #endif /* !_IBMR2 */
  58
  59 /* Define "NBBY" (number of bits per byte) if it's not already defined. */
  60
  61 #ifndef NBBY
  62 #define NBBY 8
  63 #endif
  64
  65 /* Define the number of fd_masks in an fd_set */
  66
  67 #ifndef FD_SETSIZE
  68 #ifdef OPEN_MAX
  69 #define FD_SETSIZE OPEN_MAX
  70 #else
  71 #define FD_SETSIZE 256
  72 #endif
  73 #endif
  74 #if !defined(howmany)
  75 #define howmany(x, y) (((x)+((y)-1))/(y))
  76 #endif
  77 #ifndef NFDBITS
  78 #define NFDBITS NBBY*sizeof(fd_mask)
  79 #endif
  80 #define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
  81
  82 #endif /* NO_FD_SET */
  83 #endif /* !HAVE_POLL */
  84
  85
  86 typedef struct gdb_event gdb_event;
  87 typedef void (event_handler_func) (int);
  88
  89 /* Event for the GDB event system.  Events are queued by calling
  90    async_queue_event and serviced later on by gdb_do_one_event. An
  91    event can be, for instance, a file descriptor becoming ready to be
  92    read. Servicing an event simply means that the procedure PROC will
  93    be called.  We have 2 queues, one for file handlers that we listen
  94    to in the event loop, and one for the file handlers+events that are
  95    ready. The procedure PROC associated with each event is always the
  96    same (handle_file_event).  Its duty is to invoke the handler
  97    associated with the file descriptor whose state change generated
  98    the event, plus doing other cleanups and such. */
  99
 100 struct gdb_event
 101   {
 102     event_handler_func *proc;   /* Procedure to call to service this event. */
 103     int fd;                     /* File descriptor that is ready. */
 104     struct gdb_event *next_event;       /* Next in list of events or NULL. */
 105   };
 106
 107 /* Information about each file descriptor we register with the event
 108    loop. */
 109
 110 typedef struct file_handler
 111   {
 112     int fd;                     /* File descriptor. */
 113     int mask;                   /* Events we want to monitor: POLLIN, etc. */
 114     int ready_mask;             /* Events that have been seen since
 115                                    the last time. */
 116     handler_func *proc;         /* Procedure to call when fd is ready. */
 117     gdb_client_data client_data;        /* Argument to pass to proc. */
 118     int error;                  /* Was an error detected on this fd? */
 119     struct file_handler *next_file;     /* Next registered file descriptor. */
 120   }
 121 file_handler;
 122
 123 /* PROC is a function to be invoked when the READY flag is set. This
 124    happens when there has been a signal and the corresponding signal
 125    handler has 'triggered' this async_signal_handler for
 126    execution. The actual work to be done in response to a signal will
 127    be carried out by PROC at a later time, within process_event. This
 128    provides a deferred execution of signal handlers.
 129    Async_init_signals takes care of setting up such an
 130    asyn_signal_handler for each interesting signal. */
 131 typedef struct async_signal_handler
 132   {
 133     int ready;                  /* If ready, call this handler from the main event loop,
 134                                    using invoke_async_handler. */
 135     struct async_signal_handler *next_handler;  /* Ptr to next handler */
 136     sig_handler_func *proc;     /* Function to call to do the work */
 137     gdb_client_data client_data;        /* Argument to async_handler_func */
 138   }
 139 async_signal_handler;
 140
 141
 142 /* Event queue:
 143    - the first event in the queue is the head of the queue.
 144    It will be the next to be serviced.
 145    - the last event in the queue
 146
 147    Events can be inserted at the front of the queue or at the end of
 148    the queue.  Events will be extracted from the queue for processing
 149    starting from the head.  Therefore, events inserted at the head of
 150    the queue will be processed in a last in first out fashion, while
 151    those inserted at the tail of the queue will be processed in a first
 152    in first out manner.  All the fields are NULL if the queue is
 153    empty. */
 154
 155 static struct
 156   {
 157     gdb_event *first_event;     /* First pending event */
 158     gdb_event *last_event;      /* Last pending event */
 159   }
 160 event_queue;
 161
 162 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
 163    These are the input file descriptor, and the target file
 164    descriptor. We have two flavors of the notifier, one for platforms
 165    that have the POLL function, the other for those that don't, and
 166    only support SELECT. Each of the elements in the gdb_notifier list is
 167    basically a description of what kind of events gdb is interested
 168    in, for each fd. */
 169
 170 /* As of 1999-04-30 only the input file descriptor is registered with the
 171    event loop. */
 172
 173 /* Do we use poll or select ? */
 174 #ifdef HAVE_POLL
 175 #define USE_POLL 1
 176 #else
 177 #define USE_POLL 0
 178 #endif /* HAVE_POLL */
 179
 180 static unsigned char use_poll = USE_POLL;
 181
 182 static struct
 183   {
 184     /* Ptr to head of file handler list. */
 185     file_handler *first_file_handler;
 186
 187 #ifdef HAVE_POLL
 188     /* Ptr to array of pollfd structures. */
 189     struct pollfd *poll_fds;
 190
 191     /* Timeout in milliseconds for calls to poll(). */
 192     int poll_timeout;
 193 #endif
 194
 195     /* Masks to be used in the next call to select.
 196        Bits are set in response to calls to create_file_handler. */
 197     fd_set check_masks[3];
 198
 199     /* What file descriptors were found ready by select. */
 200     fd_set ready_masks[3];
 201
 202     /* Number of file descriptors to monitor. (for poll) */
 203     /* Number of valid bits (highest fd value + 1). (for select) */
 204     int num_fds;
 205
 206     /* Time structure for calls to select(). */
 207     struct timeval select_timeout;
 208
 209     /* Flag to tell whether the timeout should be used. */
 210     int timeout_valid;
 211   }
 212 gdb_notifier;
 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     /* Id of the last timer created. */
 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 /* Are 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 *data);
 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       xfree (event_ptr);
 380
 381       /* Now call the procedure associated 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 >0 if something was done otherwise returns <0 (this
 393    can happen if there are no event sources to wait for).  If an error
 394    occurs catch_errors() which calls this function returns zero. */
 395
 396 static int
 397 gdb_do_one_event (void *data)
 398 {
 399   /* Any events already waiting in the queue? */
 400   if (process_event ())
 401     {
 402       return 1;
 403     }
 404
 405   /* Are any timers that are ready? If so, put an event on the queue. */
 406   poll_timers ();
 407
 408   /* Wait for a new event.  If gdb_wait_for_event returns -1,
 409      we should get out because this means that there are no
 410      event sources left. This will make the event loop stop,
 411      and the application exit. */
 412
 413   if (gdb_wait_for_event () < 0)
 414     {
 415       return -1;
 416     }
 417
 418   /* Handle any new events occurred while waiting. */
 419   if (process_event ())
 420     {
 421       return 1;
 422     }
 423
 424   /* If gdb_wait_for_event has returned 1, it means that one
 425      event has been handled. We break out of the loop. */
 426   return 1;
 427 }
 428
 429 /* Start up the event loop. This is the entry point to the event loop
 430    from the command loop. */
 431
 432 void
 433 start_event_loop (void)
 434 {
 435   /* Loop until there is nothing to do. This is the entry point to the
 436      event loop engine. gdb_do_one_event, called via catch_errors()
 437      will process one event for each invocation.  It blocks waits for
 438      an event and then processes it.  >0 when an event is processed, 0
 439      when catch_errors() caught an error and <0 when there are no
 440      longer any event sources registered. */
 441   while (1)
 442     {
 443       int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
 444       if (result < 0)
 445         break;
 446       if (result == 0)
 447         {
 448           /* FIXME: this should really be a call to a hook that is
 449              interface specific, because interfaces can display the
 450              prompt in their own way. */
 451           display_gdb_prompt (0);
 452           /* Maybe better to set a flag to be checked somewhere as to
 453              whether display the prompt or not. */
 454         }
 455     }
 456
 457   /* We are done with the event loop. There are no more event sources
 458      to listen to.  So we exit GDB. */
 459   return;
 460 }
 461 \f
 462
 463 /* Wrapper function for create_file_handler, so that the caller
 464    doesn't have to know implementation details about the use of poll
 465    vs. select. */
 466 void
 467 add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
 468 {
 469 #ifdef HAVE_POLL
 470   struct pollfd fds;
 471 #endif
 472
 473   if (use_poll)
 474     {
 475 #ifdef HAVE_POLL
 476       /* Check to see if poll () is usable. If not, we'll switch to
 477          use select. This can happen on systems like
 478          m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
 479          On m68k-motorola-sysv, tty's are not stream-based and not
 480          `poll'able. */
 481       fds.fd = fd;
 482       fds.events = POLLIN;
 483       if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
 484         use_poll = 0;
 485 #else
 486       internal_error (__FILE__, __LINE__,
 487                       "use_poll without HAVE_POLL");
 488 #endif /* HAVE_POLL */
 489     }
 490   if (use_poll)
 491     {
 492 #ifdef HAVE_POLL
 493       create_file_handler (fd, POLLIN, proc, client_data);
 494 #else
 495       internal_error (__FILE__, __LINE__,
 496                       "use_poll without HAVE_POLL");
 497 #endif
 498     }
 499   else
 500     create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
 501 }
 502
 503 /* Add a file handler/descriptor to the list of descriptors we are
 504    interested in.
 505    FD is the file descriptor for the file/stream to be listened to.
 506    For the poll case, MASK is a combination (OR) of
 507    POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
 508    POLLWRBAND: these are the events we are interested in. If any of them
 509    occurs, proc should be called.
 510    For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
 511    PROC is the procedure that will be called when an event occurs for
 512    FD.  CLIENT_DATA is the argument to pass to PROC. */
 513 static void
 514 create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data)
 515 {
 516   file_handler *file_ptr;
 517
 518   /* Do we already have a file handler for this file? (We may be
 519      changing its associated procedure). */
 520   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
 521        file_ptr = file_ptr->next_file)
 522     {
 523       if (file_ptr->fd == fd)
 524         break;
 525     }
 526
 527   /* It is a new file descriptor. Add it to the list. Otherwise, just
 528      change the data associated with it. */
 529   if (file_ptr == NULL)
 530     {
 531       file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
 532       file_ptr->fd = fd;
 533       file_ptr->ready_mask = 0;
 534       file_ptr->next_file = gdb_notifier.first_file_handler;
 535       gdb_notifier.first_file_handler = file_ptr;
 536     }
 537   file_ptr->proc = proc;
 538   file_ptr->client_data = client_data;
 539   file_ptr->mask = mask;
 540
 541   if (use_poll)
 542     {
 543 #ifdef HAVE_POLL
 544       gdb_notifier.num_fds++;
 545       if (gdb_notifier.poll_fds)
 546         gdb_notifier.poll_fds =
 547           (struct pollfd *) xrealloc (gdb_notifier.poll_fds,
 548                                       (gdb_notifier.num_fds
 549                                        * 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 }