1/* Event loop machinery for GDB, the GNU debugger. 2 Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007 3 Free Software Foundation, Inc. 4 Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 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 41typedef struct gdb_event gdb_event; 42typedef 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 55struct 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 65typedef 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 } 76file_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. */ 86typedef 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 } 94async_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 110static struct 111 { 112 gdb_event *first_event; /* First pending event */ 113 gdb_event *last_event; /* Last pending event */ 114 } 115event_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 135static unsigned char use_poll = USE_POLL; 136 137#ifdef USE_WIN32API 138#include <windows.h> 139#include <io.h> 140#endif 141 142static 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 } 172gdb_notifier; 173 174/* Structure associated with a timer. PROC will be executed at the 175 first occasion after WHEN. */ 176struct 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 } 184gdb_timer; 185 186/* List of currently active timers. It is sorted in order of 187 increasing timers. */ 188static 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 } 196timer_list; 197 198/* All the async_signal_handlers gdb is interested in are kept onto 199 this list. */ 200static 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 } 208sighandler_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. */ 214static int async_handler_ready = 0; 215 216static void create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data); 217static void invoke_async_signal_handler (void); 218static void handle_file_event (int event_file_desc); 219static int gdb_wait_for_event (void); 220static int check_async_ready (void); 221static void async_queue_event (gdb_event * event_ptr, queue_position position); 222static gdb_event *create_file_event (int fd); 223static int process_event (void); 224static void handle_timer_event (int dummy); 225static void poll_timers (void); 226 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. */ 238static void 239async_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. */ 267static gdb_event * 268create_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. */ 287static int 288process_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 355int 356gdb_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 391void 392start_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 /* FIXME: this should really be a call to a hook that is 415 interface specific, because interfaces can display the 416 prompt in their own way. */ 417 display_gdb_prompt (0); 418 /* This call looks bizarre, but it is required. If the user 419 entered a command that caused an error, 420 after_char_processing_hook won't be called from 421 rl_callback_read_char_wrapper. Using a cleanup there 422 won't work, since we want this function to be called 423 after a new prompt is printed. */ 424 if (after_char_processing_hook) 425 (*after_char_processing_hook) (); 426 /* Maybe better to set a flag to be checked somewhere as to 427 whether display the prompt or not. */ 428 } 429 } 430 431 /* We are done with the event loop. There are no more event sources 432 to listen to. So we exit GDB. */ 433 return; 434} 435 436 437/* Wrapper function for create_file_handler, so that the caller 438 doesn't have to know implementation details about the use of poll 439 vs. select. */ 440void 441add_file_handler (int fd, handler_func * proc, gdb_client_data client_data) 442{ 443#ifdef HAVE_POLL 444 struct pollfd fds; 445#endif 446 447 if (use_poll) 448 { 449#ifdef HAVE_POLL 450 /* Check to see if poll () is usable. If not, we'll switch to 451 use select. This can happen on systems like 452 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'. 453 On m68k-motorola-sysv, tty's are not stream-based and not 454 `poll'able. */ 455 fds.fd = fd; 456 fds.events = POLLIN; 457 if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL)) 458 use_poll = 0; 459#else 460 internal_error (__FILE__, __LINE__, 461 _("use_poll without HAVE_POLL")); 462#endif /* HAVE_POLL */ 463 } 464 if (use_poll) 465 { 466#ifdef HAVE_POLL 467 create_file_handler (fd, POLLIN, proc, client_data); 468#else 469 internal_error (__FILE__, __LINE__, 470 _("use_poll without HAVE_POLL")); 471#endif 472 } 473 else 474 create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data); 475} 476 477/* Add a file handler/descriptor to the list of descriptors we are 478 interested in. 479 FD is the file descriptor for the file/stream to be listened to. 480 For the poll case, MASK is a combination (OR) of 481 POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, 482 POLLWRBAND: these are the events we are interested in. If any of them 483 occurs, proc should be called. 484 For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION. 485 PROC is the procedure that will be called when an event occurs for 486 FD. CLIENT_DATA is the argument to pass to PROC. */ 487static void 488create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data) 489{ 490 file_handler *file_ptr; 491 492 /* Do we already have a file handler for this file? (We may be 493 changing its associated procedure). */ 494 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL; 495 file_ptr = file_ptr->next_file) 496 { 497 if (file_ptr->fd == fd) 498 break; 499 } 500 501 /* It is a new file descriptor. Add it to the list. Otherwise, just 502 change the data associated with it. */ 503 if (file_ptr == NULL) 504 { 505 file_ptr = (file_handler *) xmalloc (sizeof (file_handler)); 506 file_ptr->fd = fd; 507 file_ptr->ready_mask = 0; 508 file_ptr->next_file = gdb_notifier.first_file_handler; 509 gdb_notifier.first_file_handler = file_ptr; 510 511 if (use_poll) 512 { 513#ifdef HAVE_POLL 514 gdb_notifier.num_fds++; 515 if (gdb_notifier.poll_fds) 516 gdb_notifier.poll_fds = 517 (struct pollfd *) xrealloc (gdb_notifier.poll_fds, 518 (gdb_notifier.num_fds 519 * sizeof (struct pollfd))); 520 else 521 gdb_notifier.poll_fds = 522 (struct pollfd *) xmalloc (sizeof (struct pollfd)); 523 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd; 524 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask; 525 (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0; 526#else 527 internal_error (__FILE__, __LINE__, 528 _("use_poll without HAVE_POLL")); 529#endif /* HAVE_POLL */ 530 } 531 else 532 { 533 if (mask & GDB_READABLE) 534 FD_SET (fd, &gdb_notifier.check_masks[0]); 535 else 536 FD_CLR (fd, &gdb_notifier.check_masks[0]); 537 538 if (mask & GDB_WRITABLE) 539 FD_SET (fd, &gdb_notifier.check_masks[1]); 540 else 541 FD_CLR (fd, &gdb_notifier.check_masks[1]); 542 543 if (mask & GDB_EXCEPTION) 544 FD_SET (fd, &gdb_notifier.check_masks[2]); 545 else 546 FD_CLR (fd, &gdb_notifier.check_masks[2]); 547 548 if (gdb_notifier.num_fds <= fd) 549 gdb_notifier.num_fds = fd + 1; 550 } 551 } 552 553 file_ptr->proc = proc; 554 file_ptr->client_data = client_data; 555 file_ptr->mask = mask; 556} 557 558/* Remove the file descriptor FD from the list of monitored fd's: 559 i.e. we don't care anymore about events on the FD. */ 560void 561delete_file_handler (int fd) 562{ 563 file_handler *file_ptr, *prev_ptr = NULL; 564 int i; 565#ifdef HAVE_POLL 566 int j; 567 struct pollfd *new_poll_fds; 568#endif 569 570 /* Find the entry for the given file. */ 571 572 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL; 573 file_ptr = file_ptr->next_file) 574 { 575 if (file_ptr->fd == fd) 576 break; 577 } 578 579 if (file_ptr == NULL) 580 return; 581 582 if (use_poll) 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 xfree (gdb_notifier.poll_fds); 602 gdb_notifier.poll_fds = new_poll_fds; 603 gdb_notifier.num_fds--; 604#else 605 internal_error (__FILE__, __LINE__, 606 _("use_poll without HAVE_POLL")); 607#endif /* HAVE_POLL */ 608 } 609 else 610 { 611 if (file_ptr->mask & GDB_READABLE) 612 FD_CLR (fd, &gdb_notifier.check_masks[0]); 613 if (file_ptr->mask & GDB_WRITABLE) 614 FD_CLR (fd, &gdb_notifier.check_masks[1]); 615 if (file_ptr->mask & GDB_EXCEPTION) 616 FD_CLR (fd, &gdb_notifier.check_masks[2]); 617 618 /* Find current max fd. */ 619 620 if ((fd + 1) == gdb_notifier.num_fds) 621 { 622 gdb_notifier.num_fds--; 623 for (i = gdb_notifier.num_fds; i; i--) 624 { 625 if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0]) 626 || FD_ISSET (i - 1, &gdb_notifier.check_masks[1]) 627 || FD_ISSET (i - 1, &gdb_notifier.check_masks[2])) 628 break; 629 } 630 gdb_notifier.num_fds = i; 631 } 632 } 633 634 /* Deactivate the file descriptor, by clearing its mask, 635 so that it will not fire again. */ 636 637 file_ptr->mask = 0; 638 639 /* Get rid of the file handler in the file handler list. */ 640 if (file_ptr == gdb_notifier.first_file_handler) 641 gdb_notifier.first_file_handler = file_ptr->next_file; 642 else 643 { 644 for (prev_ptr = gdb_notifier.first_file_handler; 645 prev_ptr->next_file != file_ptr; 646 prev_ptr = prev_ptr->next_file) 647 ; 648 prev_ptr->next_file = file_ptr->next_file; 649 } 650 xfree (file_ptr); 651} 652 653/* Handle the given event by calling the procedure associated to the 654 corresponding file handler. Called by process_event indirectly, 655 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the 656 event in the front of the event queue. */ 657static void 658handle_file_event (int event_file_desc) 659{ 660 file_handler *file_ptr; 661 int mask; 662#ifdef HAVE_POLL 663 int error_mask; 664 int error_mask_returned; 665#endif 666 667 /* Search the file handler list to find one that matches the fd in 668 the event. */ 669 for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL; 670 file_ptr = file_ptr->next_file) 671 { 672 if (file_ptr->fd == event_file_desc) 673 { 674 /* With poll, the ready_mask could have any of three events 675 set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot 676 be used in the requested event mask (events), but they 677 can be returned in the return mask (revents). We need to 678 check for those event too, and add them to the mask which 679 will be passed to the handler. */ 680 681 /* See if the desired events (mask) match the received 682 events (ready_mask). */ 683 684 if (use_poll) 685 { 686#ifdef HAVE_POLL 687 error_mask = POLLHUP | POLLERR | POLLNVAL; 688 mask = (file_ptr->ready_mask & file_ptr->mask) | 689 (file_ptr->ready_mask & error_mask); 690 error_mask_returned = mask & error_mask; 691 692 if (error_mask_returned != 0) 693 { 694 /* Work in progress. We may need to tell somebody what 695 kind of error we had. */ 696 if (error_mask_returned & POLLHUP) 697 printf_unfiltered (_("Hangup detected on fd %d\n"), file_ptr->fd); 698 if (error_mask_returned & POLLERR) 699 printf_unfiltered (_("Error detected on fd %d\n"), file_ptr->fd); 700 if (error_mask_returned & POLLNVAL) 701 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"), file_ptr->fd); 702 file_ptr->error = 1; 703 } 704 else 705 file_ptr->error = 0; 706#else 707 internal_error (__FILE__, __LINE__, 708 _("use_poll without HAVE_POLL")); 709#endif /* HAVE_POLL */ 710 } 711 else 712 { 713 if (file_ptr->ready_mask & GDB_EXCEPTION) 714 { 715 printf_unfiltered (_("Exception condition detected on fd %d\n"), file_ptr->fd); 716 file_ptr->error = 1; 717 } 718 else 719 file_ptr->error = 0; 720 mask = file_ptr->ready_mask & file_ptr->mask; 721 } 722 723 /* Clear the received events for next time around. */ 724 file_ptr->ready_mask = 0; 725 726 /* If there was a match, then call the handler. */ 727 if (mask != 0) 728 (*file_ptr->proc) (file_ptr->error, file_ptr->client_data); 729 break; 730 } 731 } 732} 733 734/* Called by gdb_do_one_event to wait for new events on the 735 monitored file descriptors. Queue file events as they are 736 detected by the poll. 737 If there are no events, this function will block in the 738 call to poll. 739 Return -1 if there are no files descriptors to monitor, 740 otherwise return 0. */ 741static int 742gdb_wait_for_event (void) 743{ 744 file_handler *file_ptr; 745 gdb_event *file_event_ptr; 746 int num_found = 0; 747 int i; 748 749 /* Make sure all output is done before getting another event. */ 750 gdb_flush (gdb_stdout); 751 gdb_flush (gdb_stderr); 752 753 if (gdb_notifier.num_fds == 0) 754 return -1; 755 756 if (use_poll) 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.poll_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#else 769 internal_error (__FILE__, __LINE__, 770 _("use_poll without HAVE_POLL")); 771#endif /* HAVE_POLL */ 772 } 773 else 774 { 775 gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0]; 776 gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1]; 777 gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2]; 778 num_found = gdb_select (gdb_notifier.num_fds, 779 &gdb_notifier.ready_masks[0], 780 &gdb_notifier.ready_masks[1], 781 &gdb_notifier.ready_masks[2], 782 gdb_notifier.timeout_valid 783 ? &gdb_notifier.select_timeout : NULL); 784 785 /* Clear the masks after an error from select. */ 786 if (num_found == -1) 787 { 788 FD_ZERO (&gdb_notifier.ready_masks[0]); 789 FD_ZERO (&gdb_notifier.ready_masks[1]); 790 FD_ZERO (&gdb_notifier.ready_masks[2]); 791 /* Dont print anything is we got a signal, let gdb handle it. */ 792 if (errno != EINTR) 793 perror_with_name (("select")); 794 } 795 } 796 797 /* Enqueue all detected file events. */ 798 799 if (use_poll) 800 { 801#ifdef HAVE_POLL 802 for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++) 803 { 804 if ((gdb_notifier.poll_fds + i)->revents) 805 num_found--; 806 else 807 continue; 808 809 for (file_ptr = gdb_notifier.first_file_handler; 810 file_ptr != NULL; 811 file_ptr = file_ptr->next_file) 812 { 813 if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd) 814 break; 815 } 816 817 if (file_ptr) 818 { 819 /* Enqueue an event only if this is still a new event for 820 this fd. */ 821 if (file_ptr->ready_mask == 0) 822 { 823 file_event_ptr = create_file_event (file_ptr->fd); 824 async_queue_event (file_event_ptr, TAIL); 825 } 826 file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents; 827 } 828 } 829#else 830 internal_error (__FILE__, __LINE__, 831 _("use_poll without HAVE_POLL")); 832#endif /* HAVE_POLL */ 833 } 834 else 835 { 836 for (file_ptr = gdb_notifier.first_file_handler; 837 (file_ptr != NULL) && (num_found > 0); 838 file_ptr = file_ptr->next_file) 839 { 840 int mask = 0; 841 842 if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0])) 843 mask |= GDB_READABLE; 844 if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1])) 845 mask |= GDB_WRITABLE; 846 if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2])) 847 mask |= GDB_EXCEPTION; 848 849 if (!mask) 850 continue; 851 else 852 num_found--; 853 854 /* Enqueue an event only if this is still a new event for 855 this fd. */ 856 857 if (file_ptr->ready_mask == 0) 858 { 859 file_event_ptr = create_file_event (file_ptr->fd); 860 async_queue_event (file_event_ptr, TAIL); 861 } 862 file_ptr->ready_mask = mask; 863 } 864 } 865 return 0; 866} 867 868 869/* Create an asynchronous handler, allocating memory for it. 870 Return a pointer to the newly created handler. 871 This pointer will be used to invoke the handler by 872 invoke_async_signal_handler. 873 PROC is the function to call with CLIENT_DATA argument 874 whenever the handler is invoked. */ 875async_signal_handler * 876create_async_signal_handler (sig_handler_func * proc, gdb_client_data client_data) 877{ 878 async_signal_handler *async_handler_ptr; 879 880 async_handler_ptr = 881 (async_signal_handler *) xmalloc (sizeof (async_signal_handler)); 882 async_handler_ptr->ready = 0; 883 async_handler_ptr->next_handler = NULL; 884 async_handler_ptr->proc = proc; 885 async_handler_ptr->client_data = client_data; 886 if (sighandler_list.first_handler == NULL) 887 sighandler_list.first_handler = async_handler_ptr; 888 else 889 sighandler_list.last_handler->next_handler = async_handler_ptr; 890 sighandler_list.last_handler = async_handler_ptr; 891 return async_handler_ptr; 892} 893 894/* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will 895 be used when the handlers are invoked, after we have waited for 896 some event. The caller of this function is the interrupt handler 897 associated with a signal. */ 898void 899mark_async_signal_handler (async_signal_handler * async_handler_ptr) 900{ 901 ((async_signal_handler *) async_handler_ptr)->ready = 1; 902 async_handler_ready = 1; 903} 904 905/* Call all the handlers that are ready. */ 906static void 907invoke_async_signal_handler (void) 908{ 909 async_signal_handler *async_handler_ptr; 910 911 if (async_handler_ready == 0) 912 return; 913 async_handler_ready = 0; 914 915 /* Invoke ready handlers. */ 916 917 while (1) 918 { 919 for (async_handler_ptr = sighandler_list.first_handler; 920 async_handler_ptr != NULL; 921 async_handler_ptr = async_handler_ptr->next_handler) 922 { 923 if (async_handler_ptr->ready) 924 break; 925 } 926 if (async_handler_ptr == NULL) 927 break; 928 async_handler_ptr->ready = 0; 929 (*async_handler_ptr->proc) (async_handler_ptr->client_data); 930 } 931 932 return; 933} 934 935/* Delete an asynchronous handler (ASYNC_HANDLER_PTR). 936 Free the space allocated for it. */ 937void 938delete_async_signal_handler (async_signal_handler ** async_handler_ptr) 939{ 940 async_signal_handler *prev_ptr; 941 942 if (sighandler_list.first_handler == (*async_handler_ptr)) 943 { 944 sighandler_list.first_handler = (*async_handler_ptr)->next_handler; 945 if (sighandler_list.first_handler == NULL) 946 sighandler_list.last_handler = NULL; 947 } 948 else 949 { 950 prev_ptr = sighandler_list.first_handler; 951 while (prev_ptr && prev_ptr->next_handler != (*async_handler_ptr)) 952 prev_ptr = prev_ptr->next_handler; 953 prev_ptr->next_handler = (*async_handler_ptr)->next_handler; 954 if (sighandler_list.last_handler == (*async_handler_ptr)) 955 sighandler_list.last_handler = prev_ptr; 956 } 957 xfree ((*async_handler_ptr)); 958 (*async_handler_ptr) = NULL; 959} 960 961/* Is it necessary to call invoke_async_signal_handler? */ 962static int 963check_async_ready (void) 964{ 965 return async_handler_ready; 966} 967 968/* Create a timer that will expire in MILLISECONDS from now. When the 969 timer is ready, PROC will be executed. At creation, the timer is 970 aded to the timers queue. This queue is kept sorted in order of 971 increasing timers. Return a handle to the timer struct. */ 972int 973create_timer (int milliseconds, timer_handler_func * proc, gdb_client_data client_data) 974{ 975 struct gdb_timer *timer_ptr, *timer_index, *prev_timer; 976 struct timeval time_now, delta; 977 978 /* compute seconds */ 979 delta.tv_sec = milliseconds / 1000; 980 /* compute microseconds */ 981 delta.tv_usec = (milliseconds % 1000) * 1000; 982 983 gettimeofday (&time_now, NULL); 984 985 timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer)); 986 timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec; 987 timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec; 988 /* carry? */ 989 if (timer_ptr->when.tv_usec >= 1000000) 990 { 991 timer_ptr->when.tv_sec += 1; 992 timer_ptr->when.tv_usec -= 1000000; 993 } 994 timer_ptr->proc = proc; 995 timer_ptr->client_data = client_data; 996 timer_list.num_timers++; 997 timer_ptr->timer_id = timer_list.num_timers; 998 999 /* Now add the timer to the timer queue, making sure it is sorted in 1000 increasing order of expiration. */ 1001 1002 for (timer_index = timer_list.first_timer; 1003 timer_index != NULL; 1004 timer_index = timer_index->next) 1005 { 1006 /* If the seconds field is greater or if it is the same, but the 1007 microsecond field is greater. */ 1008 if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) || 1009 ((timer_index->when.tv_sec == timer_ptr->when.tv_sec) 1010 && (timer_index->when.tv_usec > timer_ptr->when.tv_usec))) 1011 break; 1012 } 1013 1014 if (timer_index == timer_list.first_timer) 1015 { 1016 timer_ptr->next = timer_list.first_timer; 1017 timer_list.first_timer = timer_ptr; 1018 1019 } 1020 else 1021 { 1022 for (prev_timer = timer_list.first_timer; 1023 prev_timer->next != timer_index; 1024 prev_timer = prev_timer->next) 1025 ; 1026 1027 prev_timer->next = timer_ptr; 1028 timer_ptr->next = timer_index; 1029 } 1030 1031 gdb_notifier.timeout_valid = 0; 1032 return timer_ptr->timer_id; 1033} 1034 1035/* There is a chance that the creator of the timer wants to get rid of 1036 it before it expires. */ 1037void 1038delete_timer (int id) 1039{ 1040 struct gdb_timer *timer_ptr, *prev_timer = NULL; 1041 1042 /* Find the entry for the given timer. */ 1043 1044 for (timer_ptr = timer_list.first_timer; timer_ptr != NULL; 1045 timer_ptr = timer_ptr->next) 1046 { 1047 if (timer_ptr->timer_id == id) 1048 break; 1049 } 1050 1051 if (timer_ptr == NULL) 1052 return; 1053 /* Get rid of the timer in the timer list. */ 1054 if (timer_ptr == timer_list.first_timer) 1055 timer_list.first_timer = timer_ptr->next; 1056 else 1057 { 1058 for (prev_timer = timer_list.first_timer; 1059 prev_timer->next != timer_ptr; 1060 prev_timer = prev_timer->next) 1061 ; 1062 prev_timer->next = timer_ptr->next; 1063 } 1064 xfree (timer_ptr); 1065 1066 gdb_notifier.timeout_valid = 0; 1067} 1068 1069/* When a timer event is put on the event queue, it will be handled by 1070 this function. Just call the assiciated procedure and delete the 1071 timer event from the event queue. Repeat this for each timer that 1072 has expired. */ 1073static void 1074handle_timer_event (int dummy) 1075{ 1076 struct timeval time_now; 1077 struct gdb_timer *timer_ptr, *saved_timer; 1078 1079 gettimeofday (&time_now, NULL); 1080 timer_ptr = timer_list.first_timer; 1081 1082 while (timer_ptr != NULL) 1083 { 1084 if ((timer_ptr->when.tv_sec > time_now.tv_sec) || 1085 ((timer_ptr->when.tv_sec == time_now.tv_sec) && 1086 (timer_ptr->when.tv_usec > time_now.tv_usec))) 1087 break; 1088 1089 /* Get rid of the timer from the beginning of the list. */ 1090 timer_list.first_timer = timer_ptr->next; 1091 saved_timer = timer_ptr; 1092 timer_ptr = timer_ptr->next; 1093 /* Call the procedure associated with that timer. */ 1094 (*saved_timer->proc) (saved_timer->client_data); 1095 xfree (saved_timer); 1096 } 1097 1098 gdb_notifier.timeout_valid = 0; 1099} 1100 1101/* Check whether any timers in the timers queue are ready. If at least 1102 one timer is ready, stick an event onto the event queue. Even in 1103 case more than one timer is ready, one event is enough, because the 1104 handle_timer_event() will go through the timers list and call the 1105 procedures associated with all that have expired. Update the 1106 timeout for the select() or poll() as well. */ 1107static void 1108poll_timers (void) 1109{ 1110 struct timeval time_now, delta; 1111 gdb_event *event_ptr; 1112 1113 if (timer_list.first_timer != NULL) 1114 { 1115 gettimeofday (&time_now, NULL); 1116 delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec; 1117 delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec; 1118 /* borrow? */ 1119 if (delta.tv_usec < 0) 1120 { 1121 delta.tv_sec -= 1; 1122 delta.tv_usec += 1000000; 1123 } 1124 1125 /* Oops it expired already. Tell select / poll to return 1126 immediately. (Cannot simply test if delta.tv_sec is negative 1127 because time_t might be unsigned.) */ 1128 if (timer_list.first_timer->when.tv_sec < time_now.tv_sec 1129 || (timer_list.first_timer->when.tv_sec == time_now.tv_sec 1130 && timer_list.first_timer->when.tv_usec < time_now.tv_usec)) 1131 { 1132 delta.tv_sec = 0; 1133 delta.tv_usec = 0; 1134 } 1135 1136 if (delta.tv_sec == 0 && delta.tv_usec == 0) 1137 { 1138 event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event)); 1139 event_ptr->proc = handle_timer_event; 1140 event_ptr->fd = timer_list.first_timer->timer_id; 1141 async_queue_event (event_ptr, TAIL); 1142 } 1143 1144 /* Now we need to update the timeout for select/ poll, because we 1145 don't want to sit there while this timer is expiring. */ 1146 if (use_poll) 1147 { 1148#ifdef HAVE_POLL 1149 gdb_notifier.poll_timeout = delta.tv_sec * 1000; 1150#else 1151 internal_error (__FILE__, __LINE__, 1152 _("use_poll without HAVE_POLL")); 1153#endif /* HAVE_POLL */ 1154 } 1155 else 1156 { 1157 gdb_notifier.select_timeout.tv_sec = delta.tv_sec; 1158 gdb_notifier.select_timeout.tv_usec = delta.tv_usec; 1159 } 1160 gdb_notifier.timeout_valid = 1; 1161 } 1162 else 1163 gdb_notifier.timeout_valid = 0; 1164} 1165