contrib/gdb-7/gdb/event-loop.c

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