gdb/event-loop.c

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