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"
31 static timer_handler_func push_event
;
32 static handler_func fd_event
;
34 /* Event handling for ASYNC serial code.
36 At any time the SERIAL device either: has an empty FIFO and is
37 waiting on a FD event; or has a non-empty FIFO/error condition and
38 is constantly scheduling timer events.
40 ASYNC only stops pestering its client when it is de-async'ed or it
41 is told to go away. */
43 /* Value of scb->async_state: */
45 /* >= 0 (TIMER_SCHEDULED) */
46 /* The ID of the currently scheduled timer event. This state is
47 rarely encountered. Timer events are one-off so as soon as the
48 event is delivered the state is shanged to NOTHING_SCHEDULED. */
50 /* The fd_event() handler is scheduled. It is called when ever the
51 file descriptor becomes ready. */
52 NOTHING_SCHEDULED
= -2
53 /* Either no task is scheduled (just going into ASYNC mode) or a
54 timer event has just gone off and the current state has been
55 forced into nothing scheduled. */
58 /* Identify and schedule the next ASYNC task based on scb->async_state
59 and scb->buf* (the input FIFO). A state machine is used to avoid
60 the need to make redundant calls into the event-loop - the next
61 scheduled task is only changed when needed. */
64 reschedule (struct serial
*scb
)
66 if (serial_is_async_p (scb
))
69 switch (scb
->async_state
)
73 next_state
= FD_SCHEDULED
;
76 delete_file_handler (scb
->fd
);
77 next_state
= create_timer (0, push_event
, scb
);
80 case NOTHING_SCHEDULED
:
83 add_file_handler (scb
->fd
, fd_event
, scb
);
84 next_state
= FD_SCHEDULED
;
88 next_state
= create_timer (0, push_event
, scb
);
91 default: /* TIMER SCHEDULED */
94 delete_timer (scb
->async_state
);
95 add_file_handler (scb
->fd
, fd_event
, scb
);
96 next_state
= FD_SCHEDULED
;
99 next_state
= scb
->async_state
;
102 if (serial_debug_p (scb
))
107 if (scb
->async_state
!= FD_SCHEDULED
)
108 fprintf_unfiltered (gdb_stdlog
, "[fd%d->fd-scheduled]\n",
111 default: /* TIMER SCHEDULED */
112 if (scb
->async_state
== FD_SCHEDULED
)
113 fprintf_unfiltered (gdb_stdlog
, "[fd%d->timer-scheduled]\n",
118 scb
->async_state
= next_state
;
122 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
123 is no pending error). As soon as data arrives, it is read into the
124 input FIFO and the client notified. The client should then drain
125 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
126 push_event() is used to nag the client until it is. */
129 fd_event (int error
, void *context
)
131 struct serial
*scb
= context
;
134 scb
->bufcnt
= SERIAL_ERROR
;
136 else if (scb
->bufcnt
== 0)
138 /* Prime the input FIFO. The readchar() function is used to
139 pull characters out of the buffer. See also
140 generic_readchar(). */
142 nr
= scb
->ops
->read_prim (scb
, BUFSIZ
);
145 scb
->bufcnt
= SERIAL_EOF
;
150 scb
->bufp
= scb
->buf
;
154 scb
->bufcnt
= SERIAL_ERROR
;
157 scb
->async_handler (scb
, scb
->async_context
);
161 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
162 error). Nag the client until all the data has been read. In the
163 case of errors, the client will need to close or de-async the
164 device before naging stops. */
167 push_event (void *context
)
169 struct serial
*scb
= context
;
170 scb
->async_state
= NOTHING_SCHEDULED
; /* Timers are one-off */
171 scb
->async_handler (scb
, scb
->async_context
);
176 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
177 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
180 ser_base_wait_for (struct serial
*scb
, int timeout
)
186 fd_set readfds
, exceptfds
;
188 /* NOTE: Some OS's can scramble the READFDS when the select()
189 call fails (ex the kernel with Red Hat 5.2). Initialize all
190 arguments before each call. */
196 FD_ZERO (&exceptfds
);
197 FD_SET (scb
->fd
, &readfds
);
198 FD_SET (scb
->fd
, &exceptfds
);
201 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, &tv
);
203 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, 0);
208 return SERIAL_TIMEOUT
;
209 else if (errno
== EINTR
)
212 return SERIAL_ERROR
; /* Got an error from select or poll */
219 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
220 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
221 char if successful. Returns -2 if timeout expired, EOF if line dropped
222 dead, or -3 for any other error (see errno in that case). */
225 do_ser_base_readchar (struct serial
*scb
, int timeout
)
230 /* We have to be able to keep the GUI alive here, so we break the
231 original timeout into steps of 1 second, running the "keep the
232 GUI alive" hook each time through the loop.
234 Also, timeout = 0 means to poll, so we just set the delta to 0,
235 so we will only go through the loop once. */
237 delta
= (timeout
== 0 ? 0 : 1);
240 /* N.B. The UI may destroy our world (for instance by calling
241 remote_stop,) in which case we want to get out of here as
242 quickly as possible. It is not safe to touch scb, since
243 someone else might have freed it. The
244 deprecated_ui_loop_hook signals that we should exit by
247 if (deprecated_ui_loop_hook
)
249 if (deprecated_ui_loop_hook (0))
250 return SERIAL_TIMEOUT
;
253 status
= ser_base_wait_for (scb
, delta
);
257 /* If we got a character or an error back from wait_for, then we can
258 break from the loop before the timeout is completed. */
259 if (status
!= SERIAL_TIMEOUT
)
262 /* If we have exhausted the original timeout, then generate
263 a SERIAL_TIMEOUT, and pass it out of the loop. */
264 else if (timeout
== 0)
266 status
= SERIAL_TIMEOUT
;
274 status
= scb
->ops
->read_prim (scb
, BUFSIZ
);
279 /* 0 chars means timeout. (We may need to distinguish between EOF
280 & timeouts someday.) */
281 return SERIAL_TIMEOUT
;
283 /* Got an error from read. */
287 scb
->bufcnt
= status
;
289 scb
->bufp
= scb
->buf
;
293 /* Perform operations common to both old and new readchar. */
295 /* Return the next character from the input FIFO. If the FIFO is
296 empty, call the SERIAL specific routine to try and read in more
299 Initially data from the input FIFO is returned (fd_event()
300 pre-reads the input into that FIFO. Once that has been emptied,
301 further data is obtained by polling the input FD using the device
302 specific readchar() function. Note: reschedule() is called after
303 every read. This is because there is no guarentee that the lower
304 level fd_event() poll_event() code (which also calls reschedule())
308 generic_readchar (struct serial
*scb
, int timeout
,
309 int (do_readchar
) (struct serial
*scb
, int timeout
))
318 else if (scb
->bufcnt
< 0)
320 /* Some errors/eof are are sticky. */
325 ch
= do_readchar (scb
, timeout
);
328 switch ((enum serial_rc
) ch
)
332 /* Make the error/eof stick. */
346 ser_base_readchar (struct serial
*scb
, int timeout
)
348 return generic_readchar (scb
, timeout
, do_ser_base_readchar
);
352 ser_base_write (struct serial
*scb
, const char *str
, int len
)
358 cc
= scb
->ops
->write_prim (scb
, str
, len
);
369 ser_base_flush_output (struct serial
*scb
)
375 ser_base_flush_input (struct serial
*scb
)
377 if (scb
->bufcnt
>= 0)
380 scb
->bufp
= scb
->buf
;
388 ser_base_send_break (struct serial
*scb
)
394 ser_base_drain_output (struct serial
*scb
)
400 ser_base_raw (struct serial
*scb
)
402 return; /* Always in raw mode */
406 ser_base_get_tty_state (struct serial
*scb
)
408 /* allocate a dummy */
409 return (serial_ttystate
) XMALLOC (int);
413 ser_base_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
419 ser_base_noflush_set_tty_state (struct serial
*scb
,
420 serial_ttystate new_ttystate
,
421 serial_ttystate old_ttystate
)
427 ser_base_print_tty_state (struct serial
*scb
,
428 serial_ttystate ttystate
,
429 struct ui_file
*stream
)
431 /* Nothing to print. */
436 ser_base_setbaudrate (struct serial
*scb
, int rate
)
438 return 0; /* Never fails! */
442 ser_base_setstopbits (struct serial
*scb
, int num
)
444 return 0; /* Never fails! */
447 /* Put the SERIAL device into/out-of ASYNC mode. */
450 ser_base_async (struct serial
*scb
,
455 /* Force a re-schedule. */
456 scb
->async_state
= NOTHING_SCHEDULED
;
457 if (serial_debug_p (scb
))
458 fprintf_unfiltered (gdb_stdlog
, "[fd%d->asynchronous]\n",
464 if (serial_debug_p (scb
))
465 fprintf_unfiltered (gdb_stdlog
, "[fd%d->synchronous]\n",
467 /* De-schedule whatever tasks are currently scheduled. */
468 switch (scb
->async_state
)
471 delete_file_handler (scb
->fd
);
473 case NOTHING_SCHEDULED
:
475 default: /* TIMER SCHEDULED */
476 delete_timer (scb
->async_state
);