gdb/event-loop.c

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