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"
28 #include "gdb_assert.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
))
74 switch (scb
->async_state
)
78 next_state
= FD_SCHEDULED
;
81 delete_file_handler (scb
->fd
);
82 next_state
= create_timer (0, push_event
, scb
);
85 case NOTHING_SCHEDULED
:
88 add_file_handler (scb
->fd
, fd_event
, scb
);
89 next_state
= FD_SCHEDULED
;
93 next_state
= create_timer (0, push_event
, scb
);
96 default: /* TIMER SCHEDULED */
99 delete_timer (scb
->async_state
);
100 add_file_handler (scb
->fd
, fd_event
, scb
);
101 next_state
= FD_SCHEDULED
;
104 next_state
= scb
->async_state
;
107 if (serial_debug_p (scb
))
112 if (scb
->async_state
!= FD_SCHEDULED
)
113 fprintf_unfiltered (gdb_stdlog
, "[fd%d->fd-scheduled]\n",
116 default: /* TIMER SCHEDULED */
117 if (scb
->async_state
== FD_SCHEDULED
)
118 fprintf_unfiltered (gdb_stdlog
, "[fd%d->timer-scheduled]\n",
123 scb
->async_state
= next_state
;
127 /* Run the SCB's async handle, and reschedule, if the handler doesn't
131 run_async_handler_and_reschedule (struct serial
*scb
)
135 /* Take a reference, so a serial_close call within the handler
136 doesn't make SCB a dangling pointer. */
139 /* Run the handler. */
140 scb
->async_handler (scb
, scb
->async_context
);
142 is_open
= serial_is_open (scb
);
145 /* Get ready for more, if not already closed. */
150 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
151 is no pending error). As soon as data arrives, it is read into the
152 input FIFO and the client notified. The client should then drain
153 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
154 push_event() is used to nag the client until it is. */
157 fd_event (int error
, void *context
)
159 struct serial
*scb
= context
;
162 scb
->bufcnt
= SERIAL_ERROR
;
164 else if (scb
->bufcnt
== 0)
166 /* Prime the input FIFO. The readchar() function is used to
167 pull characters out of the buffer. See also
168 generic_readchar(). */
170 nr
= scb
->ops
->read_prim (scb
, BUFSIZ
);
173 scb
->bufcnt
= SERIAL_EOF
;
178 scb
->bufp
= scb
->buf
;
182 scb
->bufcnt
= SERIAL_ERROR
;
185 run_async_handler_and_reschedule (scb
);
188 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
189 error). Nag the client until all the data has been read. In the
190 case of errors, the client will need to close or de-async the
191 device before naging stops. */
194 push_event (void *context
)
196 struct serial
*scb
= context
;
198 scb
->async_state
= NOTHING_SCHEDULED
; /* Timers are one-off */
199 run_async_handler_and_reschedule (scb
);
202 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
203 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
206 ser_base_wait_for (struct serial
*scb
, int timeout
)
212 fd_set readfds
, exceptfds
;
214 /* NOTE: Some OS's can scramble the READFDS when the select()
215 call fails (ex the kernel with Red Hat 5.2). Initialize all
216 arguments before each call. */
222 FD_ZERO (&exceptfds
);
223 FD_SET (scb
->fd
, &readfds
);
224 FD_SET (scb
->fd
, &exceptfds
);
227 numfds
= gdb_select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, &tv
);
229 numfds
= gdb_select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, 0);
234 return SERIAL_TIMEOUT
;
235 else if (errno
== EINTR
)
238 return SERIAL_ERROR
; /* Got an error from select or
246 /* Read any error output we might have. */
249 ser_base_read_error_fd (struct serial
*scb
, int close_fd
)
251 if (scb
->error_fd
!= -1)
254 char buf
[GDB_MI_MSG_WIDTH
+ 1];
260 int to_read
= GDB_MI_MSG_WIDTH
;
264 num_bytes
= (scb
->ops
->avail
)(scb
, scb
->error_fd
);
267 to_read
= (num_bytes
< to_read
) ? num_bytes
: to_read
;
272 s
= read (scb
->error_fd
, &buf
, to_read
);
273 if ((s
== -1) || (s
== 0 && !close_fd
))
276 if (s
== 0 && close_fd
)
279 close (scb
->error_fd
);
284 /* In theory, embedded newlines are not a problem.
285 But for MI, we want each output line to have just
286 one newline for legibility. So output things
287 in newline chunks. */
288 gdb_assert (s
> 0 && s
<= GDB_MI_MSG_WIDTH
);
291 while ((newline
= strstr (current
, "\n")) != NULL
)
294 fputs_unfiltered (current
, gdb_stderr
);
295 fputs_unfiltered ("\n", gdb_stderr
);
296 current
= newline
+ 1;
299 fputs_unfiltered (current
, gdb_stderr
);
304 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
305 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
306 char if successful. Returns -2 if timeout expired, EOF if line dropped
307 dead, or -3 for any other error (see errno in that case). */
310 do_ser_base_readchar (struct serial
*scb
, int timeout
)
315 /* We have to be able to keep the GUI alive here, so we break the
316 original timeout into steps of 1 second, running the "keep the
317 GUI alive" hook each time through the loop.
319 Also, timeout = 0 means to poll, so we just set the delta to 0,
320 so we will only go through the loop once. */
322 delta
= (timeout
== 0 ? 0 : 1);
325 /* N.B. The UI may destroy our world (for instance by calling
326 remote_stop,) in which case we want to get out of here as
327 quickly as possible. It is not safe to touch scb, since
328 someone else might have freed it. The
329 deprecated_ui_loop_hook signals that we should exit by
332 if (deprecated_ui_loop_hook
)
334 if (deprecated_ui_loop_hook (0))
335 return SERIAL_TIMEOUT
;
338 status
= ser_base_wait_for (scb
, delta
);
342 /* If we got a character or an error back from wait_for, then we can
343 break from the loop before the timeout is completed. */
344 if (status
!= SERIAL_TIMEOUT
)
347 /* If we have exhausted the original timeout, then generate
348 a SERIAL_TIMEOUT, and pass it out of the loop. */
349 else if (timeout
== 0)
351 status
= SERIAL_TIMEOUT
;
355 /* We also need to check and consume the stderr because it could
356 come before the stdout for some stubs. If we just sit and wait
357 for stdout, we would hit a deadlock for that case. */
358 ser_base_read_error_fd (scb
, 0);
364 status
= scb
->ops
->read_prim (scb
, BUFSIZ
);
371 /* Got an error from read. */
375 scb
->bufcnt
= status
;
377 scb
->bufp
= scb
->buf
;
381 /* Perform operations common to both old and new readchar. */
383 /* Return the next character from the input FIFO. If the FIFO is
384 empty, call the SERIAL specific routine to try and read in more
387 Initially data from the input FIFO is returned (fd_event()
388 pre-reads the input into that FIFO. Once that has been emptied,
389 further data is obtained by polling the input FD using the device
390 specific readchar() function. Note: reschedule() is called after
391 every read. This is because there is no guarentee that the lower
392 level fd_event() poll_event() code (which also calls reschedule())
396 generic_readchar (struct serial
*scb
, int timeout
,
397 int (do_readchar
) (struct serial
*scb
, int timeout
))
406 else if (scb
->bufcnt
< 0)
408 /* Some errors/eof are are sticky. */
413 ch
= do_readchar (scb
, timeout
);
416 switch ((enum serial_rc
) ch
)
420 /* Make the error/eof stick. */
430 /* Read any error output we might have. */
431 ser_base_read_error_fd (scb
, 1);
438 ser_base_readchar (struct serial
*scb
, int timeout
)
440 return generic_readchar (scb
, timeout
, do_ser_base_readchar
);
444 ser_base_write (struct serial
*scb
, const char *str
, int len
)
450 cc
= scb
->ops
->write_prim (scb
, str
, len
);
461 ser_base_flush_output (struct serial
*scb
)
467 ser_base_flush_input (struct serial
*scb
)
469 if (scb
->bufcnt
>= 0)
472 scb
->bufp
= scb
->buf
;
480 ser_base_send_break (struct serial
*scb
)
486 ser_base_drain_output (struct serial
*scb
)
492 ser_base_raw (struct serial
*scb
)
494 return; /* Always in raw mode. */
498 ser_base_get_tty_state (struct serial
*scb
)
500 /* Allocate a dummy. */
501 return (serial_ttystate
) XMALLOC (int);
505 ser_base_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
507 /* Allocate another dummy. */
508 return (serial_ttystate
) XMALLOC (int);
512 ser_base_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
518 ser_base_noflush_set_tty_state (struct serial
*scb
,
519 serial_ttystate new_ttystate
,
520 serial_ttystate old_ttystate
)
526 ser_base_print_tty_state (struct serial
*scb
,
527 serial_ttystate ttystate
,
528 struct ui_file
*stream
)
530 /* Nothing to print. */
535 ser_base_setbaudrate (struct serial
*scb
, int rate
)
537 return 0; /* Never fails! */
541 ser_base_setstopbits (struct serial
*scb
, int num
)
543 return 0; /* Never fails! */
546 /* Put the SERIAL device into/out-of ASYNC mode. */
549 ser_base_async (struct serial
*scb
,
554 /* Force a re-schedule. */
555 scb
->async_state
= NOTHING_SCHEDULED
;
556 if (serial_debug_p (scb
))
557 fprintf_unfiltered (gdb_stdlog
, "[fd%d->asynchronous]\n",
563 if (serial_debug_p (scb
))
564 fprintf_unfiltered (gdb_stdlog
, "[fd%d->synchronous]\n",
566 /* De-schedule whatever tasks are currently scheduled. */
567 switch (scb
->async_state
)
570 delete_file_handler (scb
->fd
);
572 case NOTHING_SCHEDULED
:
574 default: /* TIMER SCHEDULED */
575 delete_timer (scb
->async_state
);