1 /* Generic serial interface functions.
3 Copyright (C) 1992-1996, 1998-2001, 2003-2012 Free Software
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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "event-loop.h"
26 #include "gdb_select.h"
27 #include "gdb_string.h"
34 static timer_handler_func push_event
;
35 static handler_func fd_event
;
37 /* Event handling for ASYNC serial code.
39 At any time the SERIAL device either: has an empty FIFO and is
40 waiting on a FD event; or has a non-empty FIFO/error condition and
41 is constantly scheduling timer events.
43 ASYNC only stops pestering its client when it is de-async'ed or it
44 is told to go away. */
46 /* Value of scb->async_state: */
48 /* >= 0 (TIMER_SCHEDULED) */
49 /* The ID of the currently scheduled timer event. This state is
50 rarely encountered. Timer events are one-off so as soon as the
51 event is delivered the state is shanged to NOTHING_SCHEDULED. */
53 /* The fd_event() handler is scheduled. It is called when ever the
54 file descriptor becomes ready. */
55 NOTHING_SCHEDULED
= -2
56 /* Either no task is scheduled (just going into ASYNC mode) or a
57 timer event has just gone off and the current state has been
58 forced into nothing scheduled. */
61 /* Identify and schedule the next ASYNC task based on scb->async_state
62 and scb->buf* (the input FIFO). A state machine is used to avoid
63 the need to make redundant calls into the event-loop - the next
64 scheduled task is only changed when needed. */
67 reschedule (struct serial
*scb
)
69 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 /* Run the SCB's async handle, and reschedule, if the handler doesn't
130 run_async_handler_and_reschedule (struct serial
*scb
)
134 /* Take a reference, so a serial_close call within the handler
135 doesn't make SCB a dangling pointer. */
138 /* Run the handler. */
139 scb
->async_handler (scb
, scb
->async_context
);
141 is_open
= serial_is_open (scb
);
144 /* Get ready for more, if not already closed. */
149 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
150 is no pending error). As soon as data arrives, it is read into the
151 input FIFO and the client notified. The client should then drain
152 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
153 push_event() is used to nag the client until it is. */
156 fd_event (int error
, void *context
)
158 struct serial
*scb
= context
;
161 scb
->bufcnt
= SERIAL_ERROR
;
163 else if (scb
->bufcnt
== 0)
165 /* Prime the input FIFO. The readchar() function is used to
166 pull characters out of the buffer. See also
167 generic_readchar(). */
169 nr
= scb
->ops
->read_prim (scb
, BUFSIZ
);
172 scb
->bufcnt
= SERIAL_EOF
;
177 scb
->bufp
= scb
->buf
;
181 scb
->bufcnt
= SERIAL_ERROR
;
184 run_async_handler_and_reschedule (scb
);
187 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
188 error). Nag the client until all the data has been read. In the
189 case of errors, the client will need to close or de-async the
190 device before naging stops. */
193 push_event (void *context
)
195 struct serial
*scb
= context
;
197 scb
->async_state
= NOTHING_SCHEDULED
; /* Timers are one-off */
198 run_async_handler_and_reschedule (scb
);
201 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
202 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
205 ser_base_wait_for (struct serial
*scb
, int timeout
)
211 fd_set readfds
, exceptfds
;
213 /* NOTE: Some OS's can scramble the READFDS when the select()
214 call fails (ex the kernel with Red Hat 5.2). Initialize all
215 arguments before each call. */
221 FD_ZERO (&exceptfds
);
222 FD_SET (scb
->fd
, &readfds
);
223 FD_SET (scb
->fd
, &exceptfds
);
226 numfds
= gdb_select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, &tv
);
228 numfds
= gdb_select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, 0);
233 return SERIAL_TIMEOUT
;
234 else if (errno
== EINTR
)
237 return SERIAL_ERROR
; /* Got an error from select or
245 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
246 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
247 char if successful. Returns -2 if timeout expired, EOF if line dropped
248 dead, or -3 for any other error (see errno in that case). */
251 do_ser_base_readchar (struct serial
*scb
, int timeout
)
256 /* We have to be able to keep the GUI alive here, so we break the
257 original timeout into steps of 1 second, running the "keep the
258 GUI alive" hook each time through the loop.
260 Also, timeout = 0 means to poll, so we just set the delta to 0,
261 so we will only go through the loop once. */
263 delta
= (timeout
== 0 ? 0 : 1);
266 /* N.B. The UI may destroy our world (for instance by calling
267 remote_stop,) in which case we want to get out of here as
268 quickly as possible. It is not safe to touch scb, since
269 someone else might have freed it. The
270 deprecated_ui_loop_hook signals that we should exit by
273 if (deprecated_ui_loop_hook
)
275 if (deprecated_ui_loop_hook (0))
276 return SERIAL_TIMEOUT
;
279 status
= ser_base_wait_for (scb
, delta
);
283 /* If we got a character or an error back from wait_for, then we can
284 break from the loop before the timeout is completed. */
285 if (status
!= SERIAL_TIMEOUT
)
288 /* If we have exhausted the original timeout, then generate
289 a SERIAL_TIMEOUT, and pass it out of the loop. */
290 else if (timeout
== 0)
292 status
= SERIAL_TIMEOUT
;
300 status
= scb
->ops
->read_prim (scb
, BUFSIZ
);
307 /* Got an error from read. */
311 scb
->bufcnt
= status
;
313 scb
->bufp
= scb
->buf
;
317 /* Perform operations common to both old and new readchar. */
319 /* Return the next character from the input FIFO. If the FIFO is
320 empty, call the SERIAL specific routine to try and read in more
323 Initially data from the input FIFO is returned (fd_event()
324 pre-reads the input into that FIFO. Once that has been emptied,
325 further data is obtained by polling the input FD using the device
326 specific readchar() function. Note: reschedule() is called after
327 every read. This is because there is no guarentee that the lower
328 level fd_event() poll_event() code (which also calls reschedule())
332 generic_readchar (struct serial
*scb
, int timeout
,
333 int (do_readchar
) (struct serial
*scb
, int timeout
))
342 else if (scb
->bufcnt
< 0)
344 /* Some errors/eof are are sticky. */
349 ch
= do_readchar (scb
, timeout
);
352 switch ((enum serial_rc
) ch
)
356 /* Make the error/eof stick. */
365 /* Read any error output we might have. */
366 if (scb
->error_fd
!= -1)
379 num_bytes
= (scb
->ops
->avail
)(scb
, scb
->error_fd
);
381 to_read
= (num_bytes
< to_read
) ? num_bytes
: to_read
;
386 s
= read (scb
->error_fd
, &buf
, to_read
);
392 close (scb
->error_fd
);
397 /* In theory, embedded newlines are not a problem.
398 But for MI, we want each output line to have just
399 one newline for legibility. So output things
400 in newline chunks. */
403 while ((newline
= strstr (current
, "\n")) != NULL
)
406 fputs_unfiltered (current
, gdb_stderr
);
407 fputs_unfiltered ("\n", gdb_stderr
);
408 current
= newline
+ 1;
410 fputs_unfiltered (current
, gdb_stderr
);
419 ser_base_readchar (struct serial
*scb
, int timeout
)
421 return generic_readchar (scb
, timeout
, do_ser_base_readchar
);
425 ser_base_write (struct serial
*scb
, const char *str
, int len
)
431 cc
= scb
->ops
->write_prim (scb
, str
, len
);
442 ser_base_flush_output (struct serial
*scb
)
448 ser_base_flush_input (struct serial
*scb
)
450 if (scb
->bufcnt
>= 0)
453 scb
->bufp
= scb
->buf
;
461 ser_base_send_break (struct serial
*scb
)
467 ser_base_drain_output (struct serial
*scb
)
473 ser_base_raw (struct serial
*scb
)
475 return; /* Always in raw mode. */
479 ser_base_get_tty_state (struct serial
*scb
)
481 /* Allocate a dummy. */
482 return (serial_ttystate
) XMALLOC (int);
486 ser_base_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
488 /* Allocate another dummy. */
489 return (serial_ttystate
) XMALLOC (int);
493 ser_base_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
499 ser_base_noflush_set_tty_state (struct serial
*scb
,
500 serial_ttystate new_ttystate
,
501 serial_ttystate old_ttystate
)
507 ser_base_print_tty_state (struct serial
*scb
,
508 serial_ttystate ttystate
,
509 struct ui_file
*stream
)
511 /* Nothing to print. */
516 ser_base_setbaudrate (struct serial
*scb
, int rate
)
518 return 0; /* Never fails! */
522 ser_base_setstopbits (struct serial
*scb
, int num
)
524 return 0; /* Never fails! */
527 /* Put the SERIAL device into/out-of ASYNC mode. */
530 ser_base_async (struct serial
*scb
,
535 /* Force a re-schedule. */
536 scb
->async_state
= NOTHING_SCHEDULED
;
537 if (serial_debug_p (scb
))
538 fprintf_unfiltered (gdb_stdlog
, "[fd%d->asynchronous]\n",
544 if (serial_debug_p (scb
))
545 fprintf_unfiltered (gdb_stdlog
, "[fd%d->synchronous]\n",
547 /* De-schedule whatever tasks are currently scheduled. */
548 switch (scb
->async_state
)
551 delete_file_handler (scb
->fd
);
553 case NOTHING_SCHEDULED
:
555 default: /* TIMER SCHEDULED */
556 delete_timer (scb
->async_state
);