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, Boston, MA 02111-1307, USA. */
  20
  21 #include "defs.h"
  22 #include "top.h"
  23 #include "event-loop.h"
  24 #ifdef HAVE_POLL
  25 #include <poll.h>
  26 #else
  27 #include <sys/types.h>
  28 #endif
  29 #include <errno.h>
  30 #include <setjmp.h>
  31
  32 /* Event queue:
  33    - the first event in the queue is the head of the queue.
  34    It will be the next to be serviced.
  35    - the last event in the queue
  36
  37    Events can be inserted at the front of the queue or at the end of
  38    the queue.  Events will be extracted from the queue for processing
  39    starting from the head.  Therefore, events inserted at the head of
  40    the queue will be processed in a last in first out fashoin, while
  41    those inserted at the tail of the queue will be processed in a first
  42    in first out manner.  All the fields are NULL if the queue is
  43    empty. */
  44
  45 static struct
  46   {
  47     gdb_event *first_event;     /* First pending event */
  48     gdb_event *last_event;      /* Last pending event */
  49   }
  50 event_queue;
  51
  52 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
  53    These are the input file descriptor, and the target file
  54    descriptor. We have two flavors of the notifier, one for platforms
  55    that have the POLL function, the other for those that don't, and
  56    only support SELECT. Each of the elements in the gdb_notifier list is
  57    basically a description of what kind of events gdb is interested
  58    in, for each fd. */
  59
  60 /* As of 1999-04-30 only the input file descriptor is registered with the
  61    event loop. */
  62
  63 #ifdef HAVE_POLL
  64 /* Poll based implementation of the notifier. */
  65
  66 static struct
  67   {
  68     /* Ptr to head of file handler list. */
  69     file_handler *first_file_handler;
  70
  71     /* Ptr to array of pollfd structures. */
  72     struct pollfd *poll_fds;
  73
  74     /* Number of file descriptors to monitor. */
  75     int num_fds;
  76
  77   }
  78 gdb_notifier;
  79
  80 #else /* ! HAVE_POLL */
  81
  82 /* Select based implementation of the notifier. */
  83
  84 static struct
  85   {
  86     /* Ptr to head of file handler list. */
  87     file_handler *first_file_handler;
  88
  89     /* Masks to be used in the next call to select.
  90        Bits are set in response to calls to create_file_handler. */
  91     fd_mask check_masks[3 * MASK_SIZE];
  92
  93     /* What file descriptors were found ready by select. */
  94     fd_mask ready_masks[3 * MASK_SIZE];
  95
  96     /* Number of valid bits (highest fd value + 1). */
  97     int num_fds;
  98
  99   }
 100 gdb_notifier;
 101
 102 #endif /* HAVE_POLL */
 103
 104 /* All the async_signal_handlers gdb is interested in are kept onto
 105    this list. */
 106 static struct
 107   {
 108     /* Pointer to first in handler list. */
 109     async_signal_handler *first_handler;
 110
 111     /* Pointer to last in handler list. */
 112     async_signal_handler *last_handler;
 113   }
 114 sighandler_list;
 115
 116 /* Is any of the handlers ready?  Check this variable using
 117    check_async_ready. This is used by process_event, to determine
 118    whether or not to invoke the invoke_async_signal_handler
 119    function. */
 120 static int async_handler_ready = 0;
 121
 122 static void create_file_handler PARAMS ((int, int, file_handler_func *, gdb_client_data));
 123 static void invoke_async_signal_handler PARAMS ((void));
 124 static int gdb_wait_for_event PARAMS ((void));
 125 static int gdb_do_one_event PARAMS ((void));
 126 static int check_async_ready PARAMS ((void));
 127 \f
 128
 129 /* Insert an event object into the gdb event queue at
 130    the specified position.
 131    POSITION can be head or tail, with values TAIL, HEAD.
 132    EVENT_PTR points to the event to be inserted into the queue.
 133    The caller must allocate memory for the event. It is freed
 134    after the event has ben handled.
 135    Events in the queue will be processed head to tail, therefore,
 136    events inserted at the head of the queue will be processed
 137    as last in first out. Event appended at the tail of the queue
 138    will be processed first in first out. */
 139 static void
 140 async_queue_event (event_ptr, position)
 141      gdb_event *event_ptr;
 142      queue_position position;
 143 {
 144   if (position == TAIL)
 145     {
 146       /* The event will become the new last_event. */
 147
 148       event_ptr->next_event = NULL;
 149       if (event_queue.first_event == NULL)
 150         event_queue.first_event = event_ptr;
 151       else
 152         event_queue.last_event->next_event = event_ptr;
 153       event_queue.last_event = event_ptr;
 154     }
 155   else if (position == HEAD)
 156     {
 157       /* The event becomes the new first_event. */
 158
 159       event_ptr->next_event = event_queue.first_event;
 160       if (event_queue.first_event == NULL)
 161         event_queue.last_event = event_ptr;
 162       event_queue.first_event = event_ptr;
 163     }
 164 }
 165
 166 /* Process one event.
 167    The event can be the next one to be serviced in the event queue,
 168    or an asynchronous event handler can be invoked in response to
 169    the reception of a signal.
 170    If an event was processed (either way), 1 is returned otherwise
 171    0 is returned.
 172    Scan the queue from head to tail, processing therefore the high
 173    priority events first, by invoking the associated event handler
 174    procedure. */
 175 static int
 176 process_event ()
 177 {
 178   gdb_event *event_ptr, *prev_ptr;
 179   event_handler_func *proc;
 180   int fd;
 181
 182   /* First let's see if there are any asynchronous event handlers that
 183      are ready. These would be the result of invoking any of the
 184      signal handlers. */
 185
 186   if (check_async_ready ())
 187     {
 188       invoke_async_signal_handler ();
 189       return 1;
 190     }
 191
 192   /* Look in the event queue to find an event that is ready
 193      to be processed. */
 194
 195   for (event_ptr = event_queue.first_event; event_ptr != NULL;
 196        event_ptr = event_ptr->next_event)
 197     {
 198       /* Call the handler for the event. */
 199
 200       proc = event_ptr->proc;
 201       fd = event_ptr->fd;
 202
 203       /* Let's get rid of the event from the event queue.  We need to
 204          do this now because while processing the event, the proc
 205          function could end up calling 'error' and therefore jump out
 206          to the caller of this function, gdb_do_one_event. In that
 207          case, we would have on the event queue an event wich has been
 208          processed, but not deleted. */
 209
 210       if (event_queue.first_event == event_ptr)
 211         {
 212           event_queue.first_event = event_ptr->next_event;
 213           if (event_ptr->next_event == NULL)
 214             event_queue.last_event = NULL;
 215         }
 216       else
 217         {
 218           prev_ptr = event_queue.first_event;
 219           while (prev_ptr->next_event != event_ptr)
 220             prev_ptr = prev_ptr->next_event;
 221
 222           prev_ptr->next_event = event_ptr->next_event;
 223           if (event_ptr->next_event == NULL)
 224             event_queue.last_event = prev_ptr;
 225         }
 226       free ((char *) event_ptr);
 227
 228       /* Now call the procedure associted with the event. */
 229       (*proc) (fd);
 230       return 1;
 231     }
 232
 233   /* this is the case if there are no event on the event queue. */
 234   return 0;
 235 }
 236
 237 /* Process one high level event.  If nothing is ready at this time,
 238    wait for something to happen (via gdb_wait_for_event), then process
 239    it.  Returns 1 if something was done otherwise returns 0 (this can
 240    happen if there are no event sources to wait for). */
 241 static int
 242 gdb_do_one_event ()
 243 {
 244   int result = 0;
 245
 246   while (1)
 247     {
 248       if (!SET_TOP_LEVEL ())
 249         {
 250           /* Any events already waiting in the queue? */
 251           if (process_event ())
 252             {
 253               result = 1;
 254               break;
 255             }
 256
 257           /* Wait for a new event.  If gdb_wait_for_event returns -1,
 258              we should get out because this means that there are no
 259              event sources left. This will make the event loop stop,
 260              and the application exit. */
 261
 262           result = gdb_wait_for_event ();
 263           if (result < 0)
 264             {
 265               result = 0;
 266               break;
 267             }
 268
 269           /* Handle any new events occurred while waiting. */
 270           if (process_event ())
 271             {
 272               result = 1;
 273               break;
 274             }
 275
 276           /* If gdb_wait_for_event has returned 1, it means that one
 277              event has been handled. We break out of the loop. */
 278           if (result)
 279             break;
 280         }                       /* end of if !set_top_level */
 281       else
 282         {
 283           /* FIXME: this should really be a call to a hook that is
 284              interface specific, because interfaces can display the
 285              prompt in their own way. */
 286           display_gdb_prompt (0);
 287           /* Maybe better to set a flag to be checked somewhere as to
 288              whether display the prompt or not. */
 289         }
 290     }
 291   return result;
 292 }
 293
 294 /* Start up the event loop. This is the entry point to the event loop
 295    from the command loop. */
 296 void
 297 start_event_loop ()
 298 {
 299   /* Loop until there is something to do. This is the entry point to
 300      the event loop engine. gdb_do_one_event will process one event
 301      for each invocation.  It always returns 1, unless there are no
 302      more event sources registered. In this case it returns 0.  */
 303   while (gdb_do_one_event () != 0)
 304     ;
 305
 306   /* We are done with the event loop. There are no more event sources
 307      to listen to.  So we exit GDB. */
 308   return;
 309 }
 310
 311 \f
 312
 313 /* Wrapper function for create_file_handler, so that the caller
 314    doesn't have to know implementation details about the use of poll
 315    vs. select. */
 316 void
 317 add_file_handler (fd, proc, client_data)
 318      int fd;
 319      file_handler_func *proc;
 320      gdb_client_data client_data;
 321 {
 322 #ifdef HAVE_POLL
 323   create_file_handler (fd, POLLIN, (file_handler_func *) proc, client_data);
 324 #else
 325   create_file_handler (fd, GDB_READABLE, (file_handler_func *) proc, client_data);
 326 #endif
 327 }
 328
 329 /* Add a file handler/descriptor to the list of descriptors we are
 330    interested in.
 331    FD is the file descriptor for the file/stream to be listened to.
 332    For the poll case, MASK is a combination (OR) of
 333    POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
 334    POLLWRBAND: these are the events we are interested in. If any of them
 335    occurs, proc should be called.
 336    For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
 337    PROC is the procedure that will be called when an event occurs for
 338    FD.  CLIENT_DATA is the argument to pass to PROC. */
 339 static void
 340 create_file_handler (fd, mask, proc, client_data)
 341      int fd;
 342      int mask;
 343      file_handler_func *proc;
 344      gdb_client_data client_data;
 345 {
 346   file_handler *file_ptr;
 347
 348 #ifndef HAVE_POLL
 349   int index, bit;
 350 #endif
 351
 352   /* Do we already have a file handler for this file? (We may be
 353      changing its associated procedure). */
 354   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
 355        file_ptr = file_ptr->next_file)
 356     {
 357       if (file_ptr->fd == fd)
 358         break;
 359     }
 360
 361   /* It is a new file descriptor. */
 362   if (file_ptr == NULL)
 363     {
 364       file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
 365       file_ptr->fd = fd;
 366       file_ptr->ready_mask = 0;
 367       file_ptr->next_file = gdb_notifier.first_file_handler;
 368       gdb_notifier.first_file_handler = file_ptr;
 369     }
 370   file_ptr->proc = proc;
 371   file_ptr->client_data = client_data;
 372   file_ptr->mask = mask;
 373
 374 #ifdef HAVE_POLL
 375
 376   gdb_notifier.num_fds++;
 377   if (gdb_notifier.poll_fds)
 378     gdb_notifier.poll_fds =
 379       (struct pollfd *) realloc (gdb_notifier.poll_fds,
 380                                  (gdb_notifier.num_fds) * sizeof (struct pollfd));
 381   else
 382      gdb_notifier.poll_fds =
 383        (struct pollfd *) xmalloc (sizeof (struct pollfd));
 384   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
 385   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
 386   (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
 387
 388 #else /* ! HAVE_POLL */
 389
 390   index = fd / (NBBY * sizeof (fd_mask));
 391   bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
 392
 393   if (mask & GDB_READABLE)
 394     gdb_notifier.check_masks[index] |= bit;
 395   else
 396     gdb_notifier.check_masks[index] &= ~bit;
 397
 398   if (mask & GDB_WRITABLE)
 399     (gdb_notifier.check_masks + MASK_SIZE)[index] |= bit;
 400   else
 401     (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
 402
 403   if (mask & GDB_EXCEPTION)
 404     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] |= bit;
 405   else
 406     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
 407
 408   if (gdb_notifier.num_fds <= fd)
 409     gdb_notifier.num_fds = fd + 1;
 410
 411 #endif /* HAVE_POLL */
 412 }
 413
 414 /* Remove the file descriptor FD from the list of monitored fd's:
 415    i.e. we don't care anymore about events on the FD. */
 416 void
 417 delete_file_handler (fd)
 418      int fd;
 419 {
 420   file_handler *file_ptr, *prev_ptr = NULL;
 421   int i, j;
 422   struct pollfd *new_poll_fds;
 423 #ifndef HAVE_POLL
 424   int index, bit;
 425   unsigned long flags;
 426 #endif
 427
 428   /* Find the entry for the given file. */
 429
 430   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
 431        file_ptr = file_ptr->next_file)
 432     {
 433       if (file_ptr->fd == fd)
 434         break;
 435     }
 436
 437   if (file_ptr == NULL)
 438     return;
 439
 440   /* Deactivate the file descriptor, by clearing its mask,
 441      so that it will not fire again. */
 442
 443   file_ptr->mask = 0;
 444
 445 #ifdef HAVE_POLL
 446   /* Create a new poll_fds array by copying every fd's information but the
 447      one we want to get rid of. */
 448
 449   new_poll_fds =
 450     (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
 451
 452   for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
 453     {
 454       if ((gdb_notifier.poll_fds + i)->fd != fd)
 455         {
 456           (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
 457           (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
 458           (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
 459           j++;
 460         }
 461     }
 462   free (gdb_notifier.poll_fds);
 463   gdb_notifier.poll_fds = new_poll_fds;
 464   gdb_notifier.num_fds--;
 465
 466 #else /* ! HAVE_POLL */
 467
 468   index = fd / (NBBY * sizeof (fd_mask));
 469   bit = 1 << (fd % (NBBY * sizeof (fd_mask)));
 470
 471   if (file_ptr->mask & GDB_READABLE)
 472     gdb_notifier.check_masks[index] &= ~bit;
 473   if (file_ptr->mask & GDB_WRITABLE)
 474     (gdb_notifier.check_masks + MASK_SIZE)[index] &= ~bit;
 475   if (file_ptr->mask & GDB_EXCEPTION)
 476     (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index] &= ~bit;
 477
 478   /* Find current max fd. */
 479
 480   if ((fd + 1) == gdb_notifier.num_fds)
 481     {
 482       for (gdb_notifier.num_fds = 0; index >= 0; index--)
 483         {
 484           flags = gdb_notifier.check_masks[index]
 485             | (gdb_notifier.check_masks + MASK_SIZE)[index]
 486             | (gdb_notifier.check_masks + 2 * (MASK_SIZE))[index];
 487           if (flags)
 488             {
 489               for (i = (NBBY * sizeof (fd_mask)); i > 0; i--)
 490                 {
 491                   if (flags & (((unsigned long) 1) << (i - 1)))
 492                     break;
 493                 }
 494               gdb_notifier.num_fds = index * (NBBY * sizeof (fd_mask)) + i;
 495               break;
 496             }
 497         }
 498     }
 499 #endif /* HAVE_POLL */
 500
 501   /* Get rid of the file handler in the file handler list. */
 502   if (file_ptr == gdb_notifier.first_file_handler)
 503     gdb_notifier.first_file_handler = file_ptr->next_file;
 504   else
 505     {
 506       for (prev_ptr = gdb_notifier.first_file_handler;
 507            prev_ptr->next_file != file_ptr;
 508            prev_ptr = prev_ptr->next_file)
 509         ;
 510       prev_ptr->next_file = file_ptr->next_file;
 511     }
 512   free ((char *) file_ptr);
 513 }
 514
 515 /* Handle the given event by calling the procedure associated to the
 516    corresponding file handler.  Called by process_event indirectly,
 517    through event_ptr->proc.  EVENT_FILE_DESC is file descriptor of the
 518    event in the front of the event queue. */
 519 static void
 520 handle_file_event (event_file_desc)
 521      int event_file_desc;
 522 {
 523   file_handler *file_ptr;
 524   int mask, error_mask;
 525
 526   /* Search the file handler list to find one that matches the fd in
 527      the event. */
 528   for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
 529        file_ptr = file_ptr->next_file)
 530     {
 531       if (file_ptr->fd == event_file_desc)
 532         {
 533           /* With poll, the ready_mask could have any of three events
 534              set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot
 535              be used in the requested event mask (events), but they
 536              can be returned in the return mask (revents). We need to
 537              check for those event too, and add them to the mask which
 538              will be passed to the handler. */
 539
 540           /* See if the desired events (mask) match the received
 541              events (ready_mask). */
 542
 543 #ifdef HAVE_POLL
 544           error_mask = POLLHUP | POLLERR | POLLNVAL;
 545           mask = (file_ptr->ready_mask & file_ptr->mask) |
 546             (file_ptr->ready_mask & error_mask);
 547
 548 #else /* ! HAVE_POLL */
 549           mask = file_ptr->ready_mask & file_ptr->mask;
 550 #endif /* HAVE_POLL */
 551
 552           /* Clear the received events for next time around. */
 553           file_ptr->ready_mask = 0;
 554
 555           /* If there was a match, then call the handler. */
 556           if (mask != 0)
 557             (*file_ptr->proc) (file_ptr->client_data, mask);
 558           break;
 559         }
 560     }
 561 }
 562
 563 /* Called by gdb_do_one_event to wait for new events on the
 564    monitored file descriptors. Queue file events as they are
 565    detected by the poll.
 566    If there are no events, this function will block in the
 567    call to poll.
 568    Return -1 if there are no files descriptors to monitor,
 569    otherwise return 0. */
 570 static int
 571 gdb_wait_for_event ()
 572 {
 573   file_handler *file_ptr;
 574   gdb_event *file_event_ptr;
 575   int num_found = 0;
 576   int i;
 577
 578 #ifndef HAVE_POLL
 579   int mask, bit, index;
 580 #endif
 581
 582   if (gdb_notifier.num_fds == 0)
 583     return -1;
 584
 585 #ifdef HAVE_POLL
 586   num_found =
 587     poll (gdb_notifier.poll_fds, (unsigned long) gdb_notifier.num_fds, -1);
 588
 589 #else /* ! HAVE_POLL */
 590   memcpy (gdb_notifier.ready_masks,
 591           gdb_notifier.check_masks,
 592           3 * MASK_SIZE * sizeof (fd_mask));
 593   num_found = select (gdb_notifier.num_fds,
 594                       (SELECT_MASK *) & gdb_notifier.ready_masks[0],
 595                       (SELECT_MASK *) & gdb_notifier.ready_masks[MASK_SIZE],
 596                   (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
 597                       NULL);
 598
 599   /* Clear the masks after an error from select. */
 600   if (num_found == -1)
 601     memset (gdb_notifier.ready_masks,
 602             0, 3 * MASK_SIZE * sizeof (fd_mask));
 603
 604 #endif /* HAVE_POLL */
 605
 606   /* Enqueue all detected file events. */
 607
 608 #ifdef HAVE_POLL
 609
 610   for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
 611     {
 612       if ((gdb_notifier.poll_fds + i)->revents)
 613         num_found--;
 614       else
 615         continue;
 616
 617       for (file_ptr = gdb_notifier.first_file_handler;
 618            file_ptr != NULL;
 619            file_ptr = file_ptr->next_file)
 620         {
 621           if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
 622             break;
 623         }
 624
 625       if (file_ptr)
 626         {
 627           /* Enqueue an event only if this is still a new event for
 628              this fd. */
 629           if (file_ptr->ready_mask == 0)
 630             {
 631               file_event_ptr =
 632                 (gdb_event *) xmalloc (sizeof (gdb_event));
 633               file_event_ptr->proc = handle_file_event;
 634               file_event_ptr->fd = file_ptr->fd;
 635               async_queue_event (file_event_ptr, TAIL);
 636             }
 637         }
 638
 639       file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
 640     }
 641
 642 #else /* ! HAVE_POLL */
 643   for (file_ptr = gdb_notifier.first_file_handler;
 644        (file_ptr != NULL) && (num_found > 0);
 645        file_ptr = file_ptr->next_file)
 646     {
 647       index = file_ptr->fd / (NBBY * sizeof (fd_mask));
 648       bit = 1 << (file_ptr->fd % (NBBY * sizeof (fd_mask)));
 649       mask = 0;
 650
 651       if (gdb_notifier.ready_masks[index] & bit)
 652         mask |= GDB_READABLE;
 653       if ((gdb_notifier.ready_masks + MASK_SIZE)[index] & bit)
 654         mask |= GDB_WRITABLE;
 655       if ((gdb_notifier.ready_masks + 2 * (MASK_SIZE))[index] & bit)
 656         mask |= GDB_EXCEPTION;
 657
 658       if (!mask)
 659         continue;
 660       else
 661         num_found--;
 662
 663       /* Enqueue an event only if this is still a new event for
 664          this fd. */
 665
 666       if (file_ptr->ready_mask == 0)
 667         {
 668           file_event_ptr =
 669             (gdb_event *) xmalloc (sizeof (gdb_event));
 670           file_event_ptr->proc = handle_file_event;
 671           file_event_ptr->fd = file_ptr->fd;
 672           async_queue_event (file_event_ptr, TAIL);
 673         }
 674       file_ptr->ready_mask = mask;
 675     }
 676 #endif /* HAVE_POLL */
 677
 678   return 0;
 679 }
 680 \f
 681
 682 /* Create an asynchronous handler, allocating memory for it.
 683    Return a pointer to the newly created handler.
 684    This pointer will be used to invoke the handler by
 685    invoke_async_signal_handler.
 686    PROC is the function to call with CLIENT_DATA argument
 687    whenever the handler is invoked. */
 688 async_signal_handler *
 689 create_async_signal_handler (proc, client_data)
 690      async_handler_func *proc;
 691      gdb_client_data client_data;
 692 {
 693   async_signal_handler *async_handler_ptr;
 694
 695   async_handler_ptr =
 696     (async_signal_handler *) xmalloc (sizeof (async_signal_handler));
 697   async_handler_ptr->ready = 0;
 698   async_handler_ptr->next_handler = NULL;
 699   async_handler_ptr->proc = proc;
 700   async_handler_ptr->client_data = client_data;
 701   if (sighandler_list.first_handler == NULL)
 702     sighandler_list.first_handler = async_handler_ptr;
 703   else
 704     sighandler_list.last_handler->next_handler = async_handler_ptr;
 705   sighandler_list.last_handler = async_handler_ptr;
 706   return async_handler_ptr;
 707 }
 708
 709 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will
 710    be used when the handlers are invoked, after we have waited for
 711    some event.  The caller of this function is the interrupt handler
 712    associated with a signal. */
 713 void
 714 mark_async_signal_handler (async_handler_ptr)
 715      async_signal_handler *async_handler_ptr;
 716 {
 717   ((async_signal_handler *) async_handler_ptr)->ready = 1;
 718   async_handler_ready = 1;
 719 }
 720
 721 /* Call all the handlers that are ready. */
 722 static void
 723 invoke_async_signal_handler ()
 724 {
 725   async_signal_handler *async_handler_ptr;
 726
 727   if (async_handler_ready == 0)
 728     return;
 729   async_handler_ready = 0;
 730
 731   /* Invoke ready handlers. */
 732
 733   while (1)
 734     {
 735       for (async_handler_ptr = sighandler_list.first_handler;
 736            async_handler_ptr != NULL;
 737            async_handler_ptr = async_handler_ptr->next_handler)
 738         {
 739           if (async_handler_ptr->ready)
 740             break;
 741         }
 742       if (async_handler_ptr == NULL)
 743         break;
 744       async_handler_ptr->ready = 0;
 745       (*async_handler_ptr->proc) (async_handler_ptr->client_data);
 746     }
 747
 748   return;
 749 }
 750
 751 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
 752    Free the space allocated for it.  */
 753 void
 754 delete_async_signal_handler (async_handler_ptr)
 755      async_signal_handler *async_handler_ptr;
 756 {
 757   async_signal_handler *prev_ptr;
 758
 759   if (sighandler_list.first_handler == async_handler_ptr)
 760     {
 761       sighandler_list.first_handler = async_handler_ptr->next_handler;
 762       if (sighandler_list.first_handler == NULL)
 763         sighandler_list.last_handler = NULL;
 764     }
 765   else
 766     {
 767       prev_ptr = sighandler_list.first_handler;
 768       while (prev_ptr->next_handler != async_handler_ptr)
 769         prev_ptr = prev_ptr->next_handler;
 770       prev_ptr->next_handler = async_handler_ptr->next_handler;
 771       if (sighandler_list.last_handler == async_handler_ptr)
 772         sighandler_list.last_handler = prev_ptr;
 773     }
 774   free ((char *) async_handler_ptr);
 775 }
 776
 777 /* Is it necessary to call invoke_async_signal_handler? */
 778 static int
 779 check_async_ready ()
 780 {
 781   return async_handler_ready;
 782 }