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