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