gdb/event-loop.c

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