1 /* Generic serial interface functions.
3 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
4 2003, 2004, 2005 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
26 #include "event-loop.h"
28 #include "gdb_string.h"
35 static timer_handler_func push_event
;
36 static handler_func fd_event
;
38 /* Event handling for ASYNC serial code.
40 At any time the SERIAL device either: has an empty FIFO and is
41 waiting on a FD event; or has a non-empty FIFO/error condition and
42 is constantly scheduling timer events.
44 ASYNC only stops pestering its client when it is de-async'ed or it
45 is told to go away. */
47 /* Value of scb->async_state: */
49 /* >= 0 (TIMER_SCHEDULED) */
50 /* The ID of the currently scheduled timer event. This state is
51 rarely encountered. Timer events are one-off so as soon as the
52 event is delivered the state is shanged to NOTHING_SCHEDULED. */
54 /* The fd_event() handler is scheduled. It is called when ever the
55 file descriptor becomes ready. */
56 NOTHING_SCHEDULED
= -2
57 /* Either no task is scheduled (just going into ASYNC mode) or a
58 timer event has just gone off and the current state has been
59 forced into nothing scheduled. */
62 /* Identify and schedule the next ASYNC task based on scb->async_state
63 and scb->buf* (the input FIFO). A state machine is used to avoid
64 the need to make redundant calls into the event-loop - the next
65 scheduled task is only changed when needed. */
68 reschedule (struct serial
*scb
)
70 if (serial_is_async_p (scb
))
73 switch (scb
->async_state
)
77 next_state
= FD_SCHEDULED
;
80 delete_file_handler (scb
->fd
);
81 next_state
= create_timer (0, push_event
, scb
);
84 case NOTHING_SCHEDULED
:
87 add_file_handler (scb
->fd
, fd_event
, scb
);
88 next_state
= FD_SCHEDULED
;
92 next_state
= create_timer (0, push_event
, scb
);
95 default: /* TIMER SCHEDULED */
98 delete_timer (scb
->async_state
);
99 add_file_handler (scb
->fd
, fd_event
, scb
);
100 next_state
= FD_SCHEDULED
;
103 next_state
= scb
->async_state
;
106 if (serial_debug_p (scb
))
111 if (scb
->async_state
!= FD_SCHEDULED
)
112 fprintf_unfiltered (gdb_stdlog
, "[fd%d->fd-scheduled]\n",
115 default: /* TIMER SCHEDULED */
116 if (scb
->async_state
== FD_SCHEDULED
)
117 fprintf_unfiltered (gdb_stdlog
, "[fd%d->timer-scheduled]\n",
122 scb
->async_state
= next_state
;
126 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
127 is no pending error). As soon as data arrives, it is read into the
128 input FIFO and the client notified. The client should then drain
129 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
130 push_event() is used to nag the client until it is. */
133 fd_event (int error
, void *context
)
135 struct serial
*scb
= context
;
138 scb
->bufcnt
= SERIAL_ERROR
;
140 else if (scb
->bufcnt
== 0)
142 /* Prime the input FIFO. The readchar() function is used to
143 pull characters out of the buffer. See also
144 generic_readchar(). */
146 nr
= scb
->ops
->read_prim (scb
, BUFSIZ
);
149 scb
->bufcnt
= SERIAL_EOF
;
154 scb
->bufp
= scb
->buf
;
158 scb
->bufcnt
= SERIAL_ERROR
;
161 scb
->async_handler (scb
, scb
->async_context
);
165 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
166 error). Nag the client until all the data has been read. In the
167 case of errors, the client will need to close or de-async the
168 device before naging stops. */
171 push_event (void *context
)
173 struct serial
*scb
= context
;
174 scb
->async_state
= NOTHING_SCHEDULED
; /* Timers are one-off */
175 scb
->async_handler (scb
, scb
->async_context
);
180 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
181 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
184 ser_base_wait_for (struct serial
*scb
, int timeout
)
190 fd_set readfds
, exceptfds
;
192 /* NOTE: Some OS's can scramble the READFDS when the select()
193 call fails (ex the kernel with Red Hat 5.2). Initialize all
194 arguments before each call. */
200 FD_ZERO (&exceptfds
);
201 FD_SET (scb
->fd
, &readfds
);
202 FD_SET (scb
->fd
, &exceptfds
);
205 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, &tv
);
207 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, 0);
212 return SERIAL_TIMEOUT
;
213 else if (errno
== EINTR
)
216 return SERIAL_ERROR
; /* Got an error from select or poll */
223 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
224 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
225 char if successful. Returns -2 if timeout expired, EOF if line dropped
226 dead, or -3 for any other error (see errno in that case). */
229 do_ser_base_readchar (struct serial
*scb
, int timeout
)
234 /* We have to be able to keep the GUI alive here, so we break the
235 original timeout into steps of 1 second, running the "keep the
236 GUI alive" hook each time through the loop.
238 Also, timeout = 0 means to poll, so we just set the delta to 0,
239 so we will only go through the loop once. */
241 delta
= (timeout
== 0 ? 0 : 1);
244 /* N.B. The UI may destroy our world (for instance by calling
245 remote_stop,) in which case we want to get out of here as
246 quickly as possible. It is not safe to touch scb, since
247 someone else might have freed it. The
248 deprecated_ui_loop_hook signals that we should exit by
251 if (deprecated_ui_loop_hook
)
253 if (deprecated_ui_loop_hook (0))
254 return SERIAL_TIMEOUT
;
257 status
= ser_base_wait_for (scb
, delta
);
261 /* If we got a character or an error back from wait_for, then we can
262 break from the loop before the timeout is completed. */
263 if (status
!= SERIAL_TIMEOUT
)
266 /* If we have exhausted the original timeout, then generate
267 a SERIAL_TIMEOUT, and pass it out of the loop. */
268 else if (timeout
== 0)
270 status
= SERIAL_TIMEOUT
;
278 status
= scb
->ops
->read_prim (scb
, BUFSIZ
);
283 /* 0 chars means timeout. (We may need to distinguish between EOF
284 & timeouts someday.) */
285 return SERIAL_TIMEOUT
;
287 /* Got an error from read. */
291 scb
->bufcnt
= status
;
293 scb
->bufp
= scb
->buf
;
297 /* Perform operations common to both old and new readchar. */
299 /* Return the next character from the input FIFO. If the FIFO is
300 empty, call the SERIAL specific routine to try and read in more
303 Initially data from the input FIFO is returned (fd_event()
304 pre-reads the input into that FIFO. Once that has been emptied,
305 further data is obtained by polling the input FD using the device
306 specific readchar() function. Note: reschedule() is called after
307 every read. This is because there is no guarentee that the lower
308 level fd_event() poll_event() code (which also calls reschedule())
312 generic_readchar (struct serial
*scb
, int timeout
,
313 int (do_readchar
) (struct serial
*scb
, int timeout
))
322 else if (scb
->bufcnt
< 0)
324 /* Some errors/eof are are sticky. */
329 ch
= do_readchar (scb
, timeout
);
332 switch ((enum serial_rc
) ch
)
336 /* Make the error/eof stick. */
350 ser_base_readchar (struct serial
*scb
, int timeout
)
352 return generic_readchar (scb
, timeout
, do_ser_base_readchar
);
356 ser_base_write (struct serial
*scb
, const char *str
, int len
)
362 cc
= scb
->ops
->write_prim (scb
, str
, len
);
373 ser_base_flush_output (struct serial
*scb
)
379 ser_base_flush_input (struct serial
*scb
)
381 if (scb
->bufcnt
>= 0)
384 scb
->bufp
= scb
->buf
;
392 ser_base_send_break (struct serial
*scb
)
398 ser_base_drain_output (struct serial
*scb
)
404 ser_base_raw (struct serial
*scb
)
406 return; /* Always in raw mode */
410 ser_base_get_tty_state (struct serial
*scb
)
412 /* allocate a dummy */
413 return (serial_ttystate
) XMALLOC (int);
417 ser_base_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
423 ser_base_noflush_set_tty_state (struct serial
*scb
,
424 serial_ttystate new_ttystate
,
425 serial_ttystate old_ttystate
)
431 ser_base_print_tty_state (struct serial
*scb
,
432 serial_ttystate ttystate
,
433 struct ui_file
*stream
)
435 /* Nothing to print. */
440 ser_base_setbaudrate (struct serial
*scb
, int rate
)
442 return 0; /* Never fails! */
446 ser_base_setstopbits (struct serial
*scb
, int num
)
448 return 0; /* Never fails! */
451 /* Put the SERIAL device into/out-of ASYNC mode. */
454 ser_base_async (struct serial
*scb
,
459 /* Force a re-schedule. */
460 scb
->async_state
= NOTHING_SCHEDULED
;
461 if (serial_debug_p (scb
))
462 fprintf_unfiltered (gdb_stdlog
, "[fd%d->asynchronous]\n",
468 if (serial_debug_p (scb
))
469 fprintf_unfiltered (gdb_stdlog
, "[fd%d->synchronous]\n",
471 /* De-schedule whatever tasks are currently scheduled. */
472 switch (scb
->async_state
)
475 delete_file_handler (scb
->fd
);
477 case NOTHING_SCHEDULED
:
479 default: /* TIMER SCHEDULED */
480 delete_timer (scb
->async_state
);