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.
5 This file is part of GDB.
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.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "event-loop.h"
25 #include "event-top.h"
29 #include <sys/types.h>
35 /* Type of the mask arguments to select. */
38 #define SELECT_MASK fd_set
44 #define SELECT_MASK void
46 #define SELECT_MASK int
50 /* Define "NBBY" (number of bits per byte) if it's not already defined. */
57 /* Define the number of fd_masks in an fd_set */
61 #define FD_SETSIZE OPEN_MAX
63 #define FD_SETSIZE 256
67 #define howmany(x, y) (((x)+((y)-1))/(y))
70 #define NFDBITS NBBY*sizeof(fd_mask)
72 #define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
75 typedef struct gdb_event gdb_event
;
76 typedef void (event_handler_func
) (int);
78 /* Event for the GDB event system. Events are queued by calling
79 async_queue_event and serviced later on by gdb_do_one_event. An
80 event can be, for instance, a file descriptor becoming ready to be
81 read. Servicing an event simply means that the procedure PROC will
82 be called. We have 2 queues, one for file handlers that we listen
83 to in the event loop, and one for the file handlers+events that are
84 ready. The procedure PROC associated with each event is always the
85 same (handle_file_event). Its duty is to invoke the handler
86 associated with the file descriptor whose state change generated
87 the event, plus doing other cleanups adn such. */
91 event_handler_func
*proc
; /* Procedure to call to service this event. */
92 int fd
; /* File descriptor that is ready. */
93 struct gdb_event
*next_event
; /* Next in list of events or NULL. */
96 /* Information about each file descriptor we register with the event
99 typedef struct file_handler
101 int fd
; /* File descriptor. */
102 int mask
; /* Events we want to monitor: POLLIN, etc. */
103 int ready_mask
; /* Events that have been seen since
105 handler_func
*proc
; /* Procedure to call when fd is ready. */
106 gdb_client_data client_data
; /* Argument to pass to proc. */
107 int error
; /* Was an error detected on this fd? */
108 struct file_handler
*next_file
; /* Next registered file descriptor. */
112 /* PROC is a function to be invoked when the READY flag is set. This
113 happens when there has been a signal and the corresponding signal
114 handler has 'triggered' this async_signal_handler for
115 execution. The actual work to be done in response to a signal will
116 be carried out by PROC at a later time, within process_event. This
117 provides a deferred execution of signal handlers.
118 Async_init_signals takes care of setting up such an
119 asyn_signal_handler for each interesting signal. */
120 typedef struct async_signal_handler
122 int ready
; /* If ready, call this handler from the main event loop,
123 using invoke_async_handler. */
124 struct async_signal_handler
*next_handler
; /* Ptr to next handler */
125 sig_handler_func
*proc
; /* Function to call to do the work */
126 gdb_client_data client_data
; /* Argument to async_handler_func */
128 async_signal_handler
;
132 - the first event in the queue is the head of the queue.
133 It will be the next to be serviced.
134 - the last event in the queue
136 Events can be inserted at the front of the queue or at the end of
137 the queue. Events will be extracted from the queue for processing
138 starting from the head. Therefore, events inserted at the head of
139 the queue will be processed in a last in first out fashion, while
140 those inserted at the tail of the queue will be processed in a first
141 in first out manner. All the fields are NULL if the queue is
146 gdb_event
*first_event
; /* First pending event */
147 gdb_event
*last_event
; /* Last pending event */
151 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
152 These are the input file descriptor, and the target file
153 descriptor. We have two flavors of the notifier, one for platforms
154 that have the POLL function, the other for those that don't, and
155 only support SELECT. Each of the elements in the gdb_notifier list is
156 basically a description of what kind of events gdb is interested
159 /* As of 1999-04-30 only the input file descriptor is registered with the
163 /* Poll based implementation of the notifier. */
167 /* Ptr to head of file handler list. */
168 file_handler
*first_file_handler
;
170 /* Ptr to array of pollfd structures. */
171 struct pollfd
*poll_fds
;
173 /* Number of file descriptors to monitor. */
176 /* Timeout in milliseconds for calls to poll(). */
179 /* Flag to tell whether the timeout value shuld be used. */
184 #else /* ! HAVE_POLL */
186 /* Select based implementation of the notifier. */
190 /* Ptr to head of file handler list. */
191 file_handler
*first_file_handler
;
193 /* Masks to be used in the next call to select.
194 Bits are set in response to calls to create_file_handler. */
195 fd_mask check_masks
[3 * MASK_SIZE
];
197 /* What file descriptors were found ready by select. */
198 fd_mask ready_masks
[3 * MASK_SIZE
];
200 /* Number of valid bits (highest fd value + 1). */
203 /* Time structure for calls to select(). */
204 struct timeval timeout
;
206 /* Flag to tell whether the timeout struct should be used. */
211 #endif /* HAVE_POLL */
213 /* Structure associated with a timer. PROC will be executed at the
214 first occasion after WHEN. */
219 struct gdb_timer
*next
;
220 timer_handler_func
*proc
; /* Function to call to do the work */
221 gdb_client_data client_data
; /* Argument to async_handler_func */
225 /* List of currently active timers. It is sorted in order of
226 increasing timers. */
229 /* Pointer to first in timer list. */
230 struct gdb_timer
*first_timer
;
232 /* Id of the last timer created. */
237 /* All the async_signal_handlers gdb is interested in are kept onto
241 /* Pointer to first in handler list. */
242 async_signal_handler
*first_handler
;
244 /* Pointer to last in handler list. */
245 async_signal_handler
*last_handler
;
249 /* Is any of the handlers ready? Check this variable using
250 check_async_ready. This is used by process_event, to determine
251 whether or not to invoke the invoke_async_signal_handler
253 static int async_handler_ready
= 0;
255 static void create_file_handler (int fd
, int mask
, handler_func
* proc
, gdb_client_data client_data
);
256 static void invoke_async_signal_handler (void);
257 static void handle_file_event (int event_file_desc
);
258 static int gdb_wait_for_event (void);
259 static int gdb_do_one_event (void);
260 static int check_async_ready (void);
261 static void async_queue_event (gdb_event
* event_ptr
, queue_position position
);
262 static gdb_event
*create_file_event (int fd
);
263 static int process_event (void);
264 static void handle_timer_event (int dummy
);
265 static void poll_timers (void);
268 /* Insert an event object into the gdb event queue at
269 the specified position.
270 POSITION can be head or tail, with values TAIL, HEAD.
271 EVENT_PTR points to the event to be inserted into the queue.
272 The caller must allocate memory for the event. It is freed
273 after the event has ben handled.
274 Events in the queue will be processed head to tail, therefore,
275 events inserted at the head of the queue will be processed
276 as last in first out. Event appended at the tail of the queue
277 will be processed first in first out. */
279 async_queue_event (gdb_event
* event_ptr
, queue_position position
)
281 if (position
== TAIL
)
283 /* The event will become the new last_event. */
285 event_ptr
->next_event
= NULL
;
286 if (event_queue
.first_event
== NULL
)
287 event_queue
.first_event
= event_ptr
;
289 event_queue
.last_event
->next_event
= event_ptr
;
290 event_queue
.last_event
= event_ptr
;
292 else if (position
== HEAD
)
294 /* The event becomes the new first_event. */
296 event_ptr
->next_event
= event_queue
.first_event
;
297 if (event_queue
.first_event
== NULL
)
298 event_queue
.last_event
= event_ptr
;
299 event_queue
.first_event
= event_ptr
;
303 /* Create a file event, to be enqueued in the event queue for
304 processing. The procedure associated to this event is always
305 handle_file_event, which will in turn invoke the one that was
306 associated to FD when it was registered with the event loop. */
308 create_file_event (int fd
)
310 gdb_event
*file_event_ptr
;
312 file_event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
313 file_event_ptr
->proc
= handle_file_event
;
314 file_event_ptr
->fd
= fd
;
315 return (file_event_ptr
);
318 /* Process one event.
319 The event can be the next one to be serviced in the event queue,
320 or an asynchronous event handler can be invoked in response to
321 the reception of a signal.
322 If an event was processed (either way), 1 is returned otherwise
324 Scan the queue from head to tail, processing therefore the high
325 priority events first, by invoking the associated event handler
330 gdb_event
*event_ptr
, *prev_ptr
;
331 event_handler_func
*proc
;
334 /* First let's see if there are any asynchronous event handlers that
335 are ready. These would be the result of invoking any of the
338 if (check_async_ready ())
340 invoke_async_signal_handler ();
344 /* Look in the event queue to find an event that is ready
347 for (event_ptr
= event_queue
.first_event
; event_ptr
!= NULL
;
348 event_ptr
= event_ptr
->next_event
)
350 /* Call the handler for the event. */
352 proc
= event_ptr
->proc
;
355 /* Let's get rid of the event from the event queue. We need to
356 do this now because while processing the event, the proc
357 function could end up calling 'error' and therefore jump out
358 to the caller of this function, gdb_do_one_event. In that
359 case, we would have on the event queue an event wich has been
360 processed, but not deleted. */
362 if (event_queue
.first_event
== event_ptr
)
364 event_queue
.first_event
= event_ptr
->next_event
;
365 if (event_ptr
->next_event
== NULL
)
366 event_queue
.last_event
= NULL
;
370 prev_ptr
= event_queue
.first_event
;
371 while (prev_ptr
->next_event
!= event_ptr
)
372 prev_ptr
= prev_ptr
->next_event
;
374 prev_ptr
->next_event
= event_ptr
->next_event
;
375 if (event_ptr
->next_event
== NULL
)
376 event_queue
.last_event
= prev_ptr
;
378 free ((char *) event_ptr
);
380 /* Now call the procedure associted with the event. */
385 /* this is the case if there are no event on the event queue. */
389 /* Process one high level event. If nothing is ready at this time,
390 wait for something to happen (via gdb_wait_for_event), then process
391 it. Returns 1 if something was done otherwise returns 0 (this can
392 happen if there are no event sources to wait for). */
394 gdb_do_one_event (void)
400 if (!SET_TOP_LEVEL ())
402 /* Any events already waiting in the queue? */
403 if (process_event ())
409 /* Are any timers that are ready? If so, put an event on the queue. */
412 /* Wait for a new event. If gdb_wait_for_event returns -1,
413 we should get out because this means that there are no
414 event sources left. This will make the event loop stop,
415 and the application exit. */
417 result
= gdb_wait_for_event ();
424 /* Handle any new events occurred while waiting. */
425 if (process_event ())
431 /* If gdb_wait_for_event has returned 1, it means that one
432 event has been handled. We break out of the loop. */
435 } /* end of if !set_top_level */
438 /* FIXME: this should really be a call to a hook that is
439 interface specific, because interfaces can display the
440 prompt in their own way. */
441 display_gdb_prompt (0);
442 /* Maybe better to set a flag to be checked somewhere as to
443 whether display the prompt or not. */
450 /* Start up the event loop. This is the entry point to the event loop
451 from the command loop. */
453 start_event_loop (void)
455 /* Loop until there is something to do. This is the entry point to
456 the event loop engine. gdb_do_one_event will process one event
457 for each invocation. It always returns 1, unless there are no
458 more event sources registered. In this case it returns 0. */
459 while (gdb_do_one_event () != 0)
462 /* We are done with the event loop. There are no more event sources
463 to listen to. So we exit GDB. */
468 /* Wrapper function for create_file_handler, so that the caller
469 doesn't have to know implementation details about the use of poll
472 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
475 create_file_handler (fd
, POLLIN
, proc
, client_data
);
477 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
, proc
, client_data
);
481 /* Add a file handler/descriptor to the list of descriptors we are
483 FD is the file descriptor for the file/stream to be listened to.
484 For the poll case, MASK is a combination (OR) of
485 POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
486 POLLWRBAND: these are the events we are interested in. If any of them
487 occurs, proc should be called.
488 For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
489 PROC is the procedure that will be called when an event occurs for
490 FD. CLIENT_DATA is the argument to pass to PROC. */
492 create_file_handler (int fd
, int mask
, handler_func
* proc
, gdb_client_data client_data
)
494 file_handler
*file_ptr
;
500 /* Do we already have a file handler for this file? (We may be
501 changing its associated procedure). */
502 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
503 file_ptr
= file_ptr
->next_file
)
505 if (file_ptr
->fd
== fd
)
509 /* It is a new file descriptor. Add it to the list. Otherwise, just
510 change the data associated with it. */
511 if (file_ptr
== NULL
)
513 file_ptr
= (file_handler
*) xmalloc (sizeof (file_handler
));
515 file_ptr
->ready_mask
= 0;
516 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
517 gdb_notifier
.first_file_handler
= file_ptr
;
519 gdb_notifier
.num_fds
++;
522 file_ptr
->proc
= proc
;
523 file_ptr
->client_data
= client_data
;
524 file_ptr
->mask
= mask
;
528 if (gdb_notifier
.poll_fds
)
529 gdb_notifier
.poll_fds
=
530 (struct pollfd
*) realloc (gdb_notifier
.poll_fds
,
531 (gdb_notifier
.num_fds
) * sizeof (struct pollfd
));
533 gdb_notifier
.poll_fds
=
534 (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
535 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
536 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
537 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
539 #else /* ! HAVE_POLL */
541 index
= fd
/ (NBBY
* sizeof (fd_mask
));
542 bit
= 1 << (fd
% (NBBY
* sizeof (fd_mask
)));
544 if (mask
& GDB_READABLE
)
545 gdb_notifier
.check_masks
[index
] |= bit
;
547 gdb_notifier
.check_masks
[index
] &= ~bit
;
549 if (mask
& GDB_WRITABLE
)
550 (gdb_notifier
.check_masks
+ MASK_SIZE
)[index
] |= bit
;
552 (gdb_notifier
.check_masks
+ MASK_SIZE
)[index
] &= ~bit
;
554 if (mask
& GDB_EXCEPTION
)
555 (gdb_notifier
.check_masks
+ 2 * (MASK_SIZE
))[index
] |= bit
;
557 (gdb_notifier
.check_masks
+ 2 * (MASK_SIZE
))[index
] &= ~bit
;
559 if (gdb_notifier
.num_fds
<= fd
)
560 gdb_notifier
.num_fds
= fd
+ 1;
562 #endif /* HAVE_POLL */
565 /* Remove the file descriptor FD from the list of monitored fd's:
566 i.e. we don't care anymore about events on the FD. */
568 delete_file_handler (int fd
)
570 file_handler
*file_ptr
, *prev_ptr
= NULL
;
572 struct pollfd
*new_poll_fds
;
578 /* Find the entry for the given file. */
580 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
581 file_ptr
= file_ptr
->next_file
)
583 if (file_ptr
->fd
== fd
)
587 if (file_ptr
== NULL
)
591 /* Create a new poll_fds array by copying every fd's information but the
592 one we want to get rid of. */
595 (struct pollfd
*) xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
597 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
599 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
601 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
602 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
603 (new_poll_fds
+ j
)->revents
= (gdb_notifier
.poll_fds
+ i
)->revents
;
607 free (gdb_notifier
.poll_fds
);
608 gdb_notifier
.poll_fds
= new_poll_fds
;
609 gdb_notifier
.num_fds
--;
611 #else /* ! HAVE_POLL */
613 index
= fd
/ (NBBY
* sizeof (fd_mask
));
614 bit
= 1 << (fd
% (NBBY
* sizeof (fd_mask
)));
616 if (file_ptr
->mask
& GDB_READABLE
)
617 gdb_notifier
.check_masks
[index
] &= ~bit
;
618 if (file_ptr
->mask
& GDB_WRITABLE
)
619 (gdb_notifier
.check_masks
+ MASK_SIZE
)[index
] &= ~bit
;
620 if (file_ptr
->mask
& GDB_EXCEPTION
)
621 (gdb_notifier
.check_masks
+ 2 * (MASK_SIZE
))[index
] &= ~bit
;
623 /* Find current max fd. */
625 if ((fd
+ 1) == gdb_notifier
.num_fds
)
627 for (gdb_notifier
.num_fds
= 0; index
>= 0; index
--)
629 flags
= gdb_notifier
.check_masks
[index
]
630 | (gdb_notifier
.check_masks
+ MASK_SIZE
)[index
]
631 | (gdb_notifier
.check_masks
+ 2 * (MASK_SIZE
))[index
];
634 for (i
= (NBBY
* sizeof (fd_mask
)); i
> 0; i
--)
636 if (flags
& (((unsigned long) 1) << (i
- 1)))
639 gdb_notifier
.num_fds
= index
* (NBBY
* sizeof (fd_mask
)) + i
;
644 #endif /* HAVE_POLL */
646 /* Deactivate the file descriptor, by clearing its mask,
647 so that it will not fire again. */
651 /* Get rid of the file handler in the file handler list. */
652 if (file_ptr
== gdb_notifier
.first_file_handler
)
653 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
656 for (prev_ptr
= gdb_notifier
.first_file_handler
;
657 prev_ptr
->next_file
!= file_ptr
;
658 prev_ptr
= prev_ptr
->next_file
)
660 prev_ptr
->next_file
= file_ptr
->next_file
;
662 free ((char *) file_ptr
);
665 /* Handle the given event by calling the procedure associated to the
666 corresponding file handler. Called by process_event indirectly,
667 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
668 event in the front of the event queue. */
670 handle_file_event (int event_file_desc
)
672 file_handler
*file_ptr
;
676 int error_mask_returned
;
679 /* Search the file handler list to find one that matches the fd in
681 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
682 file_ptr
= file_ptr
->next_file
)
684 if (file_ptr
->fd
== event_file_desc
)
686 /* With poll, the ready_mask could have any of three events
687 set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot
688 be used in the requested event mask (events), but they
689 can be returned in the return mask (revents). We need to
690 check for those event too, and add them to the mask which
691 will be passed to the handler. */
693 /* See if the desired events (mask) match the received
694 events (ready_mask). */
697 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
698 mask
= (file_ptr
->ready_mask
& file_ptr
->mask
) |
699 (file_ptr
->ready_mask
& error_mask
);
700 error_mask_returned
= mask
& error_mask
;
702 if (error_mask_returned
!= 0)
704 /* Work in progress. We may need to tell somebody what
705 kind of error we had. */
706 /*if (error_mask_returned & POLLHUP)
707 printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
708 if (error_mask_returned & POLLERR)
709 printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
710 if (error_mask_returned & POLLNVAL)
711 printf_unfiltered ("Invalid fd %d\n", file_ptr->fd); */
716 #else /* ! HAVE_POLL */
717 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
719 printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr
->fd
);
724 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
725 #endif /* HAVE_POLL */
727 /* Clear the received events for next time around. */
728 file_ptr
->ready_mask
= 0;
730 /* If there was a match, then call the handler. */
732 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
738 /* Called by gdb_do_one_event to wait for new events on the
739 monitored file descriptors. Queue file events as they are
740 detected by the poll.
741 If there are no events, this function will block in the
743 Return -1 if there are no files descriptors to monitor,
744 otherwise return 0. */
746 gdb_wait_for_event (void)
748 file_handler
*file_ptr
;
749 gdb_event
*file_event_ptr
;
754 int mask
, bit
, index
;
757 /* Make sure all output is done before getting another event. */
758 gdb_flush (gdb_stdout
);
759 gdb_flush (gdb_stderr
);
761 if (gdb_notifier
.num_fds
== 0)
766 poll (gdb_notifier
.poll_fds
,
767 (unsigned long) gdb_notifier
.num_fds
,
768 gdb_notifier
.timeout_valid
? gdb_notifier
.timeout
: -1);
770 /* Don't print anything if we get out of poll because of a
772 if (num_found
== -1 && errno
!= EINTR
)
773 perror_with_name ("Poll");
775 #else /* ! HAVE_POLL */
776 memcpy (gdb_notifier
.ready_masks
,
777 gdb_notifier
.check_masks
,
778 3 * MASK_SIZE
* sizeof (fd_mask
));
779 num_found
= select (gdb_notifier
.num_fds
,
780 (SELECT_MASK
*) & gdb_notifier
.ready_masks
[0],
781 (SELECT_MASK
*) & gdb_notifier
.ready_masks
[MASK_SIZE
],
782 (SELECT_MASK
*) & gdb_notifier
.ready_masks
[2 * MASK_SIZE
],
783 gdb_notifier
.timeout_valid
? &gdb_notifier
.timeout
: NULL
);
785 /* Clear the masks after an error from select. */
788 memset (gdb_notifier
.ready_masks
,
789 0, 3 * MASK_SIZE
* sizeof (fd_mask
));
790 /* Dont print anything is we got a signal, let gdb handle it. */
792 perror_with_name ("Select");
794 #endif /* HAVE_POLL */
796 /* Enqueue all detected file events. */
800 for (i
= 0; (i
< gdb_notifier
.num_fds
) && (num_found
> 0); i
++)
802 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
807 for (file_ptr
= gdb_notifier
.first_file_handler
;
809 file_ptr
= file_ptr
->next_file
)
811 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
817 /* Enqueue an event only if this is still a new event for
819 if (file_ptr
->ready_mask
== 0)
821 file_event_ptr
= create_file_event (file_ptr
->fd
);
822 async_queue_event (file_event_ptr
, TAIL
);
826 file_ptr
->ready_mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
829 #else /* ! HAVE_POLL */
830 for (file_ptr
= gdb_notifier
.first_file_handler
;
831 (file_ptr
!= NULL
) && (num_found
> 0);
832 file_ptr
= file_ptr
->next_file
)
834 index
= file_ptr
->fd
/ (NBBY
* sizeof (fd_mask
));
835 bit
= 1 << (file_ptr
->fd
% (NBBY
* sizeof (fd_mask
)));
838 if (gdb_notifier
.ready_masks
[index
] & bit
)
839 mask
|= GDB_READABLE
;
840 if ((gdb_notifier
.ready_masks
+ MASK_SIZE
)[index
] & bit
)
841 mask
|= GDB_WRITABLE
;
842 if ((gdb_notifier
.ready_masks
+ 2 * (MASK_SIZE
))[index
] & bit
)
843 mask
|= GDB_EXCEPTION
;
850 /* Enqueue an event only if this is still a new event for
853 if (file_ptr
->ready_mask
== 0)
855 file_event_ptr
= create_file_event (file_ptr
->fd
);
856 async_queue_event (file_event_ptr
, TAIL
);
858 file_ptr
->ready_mask
= mask
;
860 #endif /* HAVE_POLL */
866 /* Create an asynchronous handler, allocating memory for it.
867 Return a pointer to the newly created handler.
868 This pointer will be used to invoke the handler by
869 invoke_async_signal_handler.
870 PROC is the function to call with CLIENT_DATA argument
871 whenever the handler is invoked. */
872 async_signal_handler
*
873 create_async_signal_handler (sig_handler_func
* proc
, gdb_client_data client_data
)
875 async_signal_handler
*async_handler_ptr
;
878 (async_signal_handler
*) xmalloc (sizeof (async_signal_handler
));
879 async_handler_ptr
->ready
= 0;
880 async_handler_ptr
->next_handler
= NULL
;
881 async_handler_ptr
->proc
= proc
;
882 async_handler_ptr
->client_data
= client_data
;
883 if (sighandler_list
.first_handler
== NULL
)
884 sighandler_list
.first_handler
= async_handler_ptr
;
886 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
887 sighandler_list
.last_handler
= async_handler_ptr
;
888 return async_handler_ptr
;
891 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will
892 be used when the handlers are invoked, after we have waited for
893 some event. The caller of this function is the interrupt handler
894 associated with a signal. */
896 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
898 ((async_signal_handler
*) async_handler_ptr
)->ready
= 1;
899 async_handler_ready
= 1;
902 /* Call all the handlers that are ready. */
904 invoke_async_signal_handler (void)
906 async_signal_handler
*async_handler_ptr
;
908 if (async_handler_ready
== 0)
910 async_handler_ready
= 0;
912 /* Invoke ready handlers. */
916 for (async_handler_ptr
= sighandler_list
.first_handler
;
917 async_handler_ptr
!= NULL
;
918 async_handler_ptr
= async_handler_ptr
->next_handler
)
920 if (async_handler_ptr
->ready
)
923 if (async_handler_ptr
== NULL
)
925 async_handler_ptr
->ready
= 0;
926 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
932 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
933 Free the space allocated for it. */
935 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
937 async_signal_handler
*prev_ptr
;
939 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
941 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
942 if (sighandler_list
.first_handler
== NULL
)
943 sighandler_list
.last_handler
= NULL
;
947 prev_ptr
= sighandler_list
.first_handler
;
948 while (prev_ptr
->next_handler
!= (*async_handler_ptr
) && prev_ptr
)
949 prev_ptr
= prev_ptr
->next_handler
;
950 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
951 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
952 sighandler_list
.last_handler
= prev_ptr
;
954 free ((char *) (*async_handler_ptr
));
955 (*async_handler_ptr
) = NULL
;
958 /* Is it necessary to call invoke_async_signal_handler? */
960 check_async_ready (void)
962 return async_handler_ready
;
965 /* Create a timer that will expire in MILLISECONDS from now. When the
966 timer is ready, PROC will be executed. At creation, the timer is
967 aded to the timers queue. This queue is kept sorted in order of
968 increasing timers. Return a handle to the timer struct. */
970 create_timer (int milliseconds
, timer_handler_func
* proc
, gdb_client_data client_data
)
972 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
973 struct timeval time_now
, delta
;
975 /* compute seconds */
976 delta
.tv_sec
= milliseconds
/ 1000;
977 /* compute microseconds */
978 delta
.tv_usec
= (milliseconds
% 1000) * 1000;
980 gettimeofday (&time_now
, NULL
);
982 timer_ptr
= (struct gdb_timer
*) xmalloc (sizeof (gdb_timer
));
983 timer_ptr
->when
.tv_sec
= time_now
.tv_sec
+ delta
.tv_sec
;
984 timer_ptr
->when
.tv_usec
= time_now
.tv_usec
+ delta
.tv_usec
;
986 if (timer_ptr
->when
.tv_usec
>= 1000000)
988 timer_ptr
->when
.tv_sec
+= 1;
989 timer_ptr
->when
.tv_usec
-= 1000000;
991 timer_ptr
->proc
= proc
;
992 timer_ptr
->client_data
= client_data
;
993 timer_list
.num_timers
++;
994 timer_ptr
->timer_id
= timer_list
.num_timers
;
996 /* Now add the timer to the timer queue, making sure it is sorted in
997 increasing order of expiration. */
999 for (timer_index
= timer_list
.first_timer
;
1000 timer_index
!= NULL
;
1001 timer_index
= timer_index
->next
)
1003 /* If the seconds field is greater or if it is the same, but the
1004 microsecond field is greater. */
1005 if ((timer_index
->when
.tv_sec
> timer_ptr
->when
.tv_sec
) ||
1006 ((timer_index
->when
.tv_sec
== timer_ptr
->when
.tv_sec
)
1007 && (timer_index
->when
.tv_usec
> timer_ptr
->when
.tv_usec
)))
1011 if (timer_index
== timer_list
.first_timer
)
1013 timer_ptr
->next
= timer_list
.first_timer
;
1014 timer_list
.first_timer
= timer_ptr
;
1019 for (prev_timer
= timer_list
.first_timer
;
1020 prev_timer
->next
!= timer_index
;
1021 prev_timer
= prev_timer
->next
)
1024 prev_timer
->next
= timer_ptr
;
1025 timer_ptr
->next
= timer_index
;
1028 gdb_notifier
.timeout_valid
= 0;
1029 return timer_ptr
->timer_id
;
1032 /* There is a chance that the creator of the timer wants to get rid of
1033 it before it expires. */
1035 delete_timer (int id
)
1037 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1039 /* Find the entry for the given timer. */
1041 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1042 timer_ptr
= timer_ptr
->next
)
1044 if (timer_ptr
->timer_id
== id
)
1048 if (timer_ptr
== NULL
)
1050 /* Get rid of the timer in the timer list. */
1051 if (timer_ptr
== timer_list
.first_timer
)
1052 timer_list
.first_timer
= timer_ptr
->next
;
1055 for (prev_timer
= timer_list
.first_timer
;
1056 prev_timer
->next
!= timer_ptr
;
1057 prev_timer
= prev_timer
->next
)
1059 prev_timer
->next
= timer_ptr
->next
;
1061 free ((char *) timer_ptr
);
1063 gdb_notifier
.timeout_valid
= 0;
1066 /* When a timer event is put on the event queue, it will be handled by
1067 this function. Just call the assiciated procedure and delete the
1068 timer event from the event queue. Repeat this for each timer that
1071 handle_timer_event (int dummy
)
1073 struct timeval time_now
;
1074 struct gdb_timer
*timer_ptr
, *saved_timer
;
1076 gettimeofday (&time_now
, NULL
);
1077 timer_ptr
= timer_list
.first_timer
;
1079 while (timer_ptr
!= NULL
)
1081 if ((timer_ptr
->when
.tv_sec
> time_now
.tv_sec
) ||
1082 ((timer_ptr
->when
.tv_sec
== time_now
.tv_sec
) &&
1083 (timer_ptr
->when
.tv_usec
> time_now
.tv_usec
)))
1086 /* Get rid of the timer from the beginning of the list. */
1087 timer_list
.first_timer
= timer_ptr
->next
;
1088 saved_timer
= timer_ptr
;
1089 timer_ptr
= timer_ptr
->next
;
1090 /* Call the procedure associated with that timer. */
1091 (*saved_timer
->proc
) (timer_ptr
->client_data
);
1095 gdb_notifier
.timeout_valid
= 0;
1098 /* Check whether any timers in the timers queue are ready. If at least
1099 one timer is ready, stick an event onto the event queue. Even in
1100 case more than one timer is ready, one event is enough, because the
1101 handle_timer_event() will go through the timers list and call the
1102 procedures associated with all that have expired. Update the
1103 timeout for the select() or poll() as well. */
1107 struct timeval time_now
, delta
;
1108 gdb_event
*event_ptr
;
1110 if (timer_list
.first_timer
!= NULL
)
1112 gettimeofday (&time_now
, NULL
);
1113 delta
.tv_sec
= timer_list
.first_timer
->when
.tv_sec
- time_now
.tv_sec
;
1114 delta
.tv_usec
= timer_list
.first_timer
->when
.tv_usec
- time_now
.tv_usec
;
1116 if (delta
.tv_usec
< 0)
1119 delta
.tv_usec
+= 1000000;
1122 /* Oops it expired already. Tell select / poll to return
1124 if (delta
.tv_sec
< 0)
1130 if (delta
.tv_sec
== 0 && delta
.tv_usec
== 0)
1132 event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
1133 event_ptr
->proc
= handle_timer_event
;
1134 event_ptr
->fd
= timer_list
.first_timer
->timer_id
;
1135 async_queue_event (event_ptr
, TAIL
);
1138 /* Now we need to update the timeout for select/ poll, because we
1139 don't want to sit there while this timer is expiring. */
1141 gdb_notifier
.timeout
= delta
.tv_sec
* 1000;
1143 gdb_notifier
.timeout
.tv_sec
= delta
.tv_sec
;
1144 gdb_notifier
.timeout
.tv_usec
= delta
.tv_usec
;
1146 gdb_notifier
.timeout_valid
= 1;
1149 gdb_notifier
.timeout_valid
= 0;