1 /* Generic serial interface functions.
3 Copyright (C) 1992-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "event-loop.h"
25 #include "gdb_select.h"
26 #include "gdb_sys_time.h"
32 static timer_handler_func push_event;
33 static handler_func fd_event;
35 /* Event handling for ASYNC serial code.
37 At any time the SERIAL device either: has an empty FIFO and is
38 waiting on a FD event; or has a non-empty FIFO/error condition and
39 is constantly scheduling timer events.
41 ASYNC only stops pestering its client when it is de-async'ed or it
42 is told to go away. */
44 /* Value of scb->async_state: */
46 /* >= 0 (TIMER_SCHEDULED) */
47 /* The ID of the currently scheduled timer event. This state is
48 rarely encountered. Timer events are one-off so as soon as the
49 event is delivered the state is shanged to NOTHING_SCHEDULED. */
51 /* The fd_event() handler is scheduled. It is called when ever the
52 file descriptor becomes ready. */
53 NOTHING_SCHEDULED = -2
54 /* Either no task is scheduled (just going into ASYNC mode) or a
55 timer event has just gone off and the current state has been
56 forced into nothing scheduled. */
59 /* Identify and schedule the next ASYNC task based on scb->async_state
60 and scb->buf* (the input FIFO). A state machine is used to avoid
61 the need to make redundant calls into the event-loop - the next
62 scheduled task is only changed when needed. */
65 reschedule (struct serial *scb)
67 if (serial_is_async_p (scb))
71 switch (scb->async_state)
75 next_state = FD_SCHEDULED;
78 delete_file_handler (scb->fd);
79 next_state = create_timer (0, push_event, scb);
82 case NOTHING_SCHEDULED:
85 add_file_handler (scb->fd, fd_event, scb);
86 next_state = FD_SCHEDULED;
90 next_state = create_timer (0, push_event, scb);
93 default: /* TIMER SCHEDULED */
96 delete_timer (scb->async_state);
97 add_file_handler (scb->fd, fd_event, scb);
98 next_state = FD_SCHEDULED;
101 next_state = scb->async_state;
104 if (serial_debug_p (scb))
109 if (scb->async_state != FD_SCHEDULED)
110 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
113 default: /* TIMER SCHEDULED */
114 if (scb->async_state == FD_SCHEDULED)
115 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
120 scb->async_state = next_state;
124 /* Run the SCB's async handle, and reschedule, if the handler doesn't
128 run_async_handler_and_reschedule (struct serial *scb)
132 /* Take a reference, so a serial_close call within the handler
133 doesn't make SCB a dangling pointer. */
136 /* Run the handler. */
137 scb->async_handler (scb, scb->async_context);
139 is_open = serial_is_open (scb);
142 /* Get ready for more, if not already closed. */
147 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
148 is no pending error). As soon as data arrives, it is read into the
149 input FIFO and the client notified. The client should then drain
150 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
151 push_event() is used to nag the client until it is. */
154 fd_event (int error, void *context)
156 struct serial *scb = (struct serial *) context;
159 scb->bufcnt = SERIAL_ERROR;
161 else if (scb->bufcnt == 0)
163 /* Prime the input FIFO. The readchar() function is used to
164 pull characters out of the buffer. See also
165 generic_readchar(). */
167 nr = scb->ops->read_prim (scb, BUFSIZ);
170 scb->bufcnt = SERIAL_EOF;
175 scb->bufp = scb->buf;
179 scb->bufcnt = SERIAL_ERROR;
182 run_async_handler_and_reschedule (scb);
185 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
186 error). Nag the client until all the data has been read. In the
187 case of errors, the client will need to close or de-async the
188 device before naging stops. */
191 push_event (void *context)
193 struct serial *scb = (struct serial *) context;
195 scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
196 run_async_handler_and_reschedule (scb);
199 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
200 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
203 ser_base_wait_for (struct serial *scb, int timeout)
209 fd_set readfds, exceptfds;
211 /* NOTE: Some OS's can scramble the READFDS when the select()
212 call fails (ex the kernel with Red Hat 5.2). Initialize all
213 arguments before each call. */
219 FD_ZERO (&exceptfds);
220 FD_SET (scb->fd, &readfds);
221 FD_SET (scb->fd, &exceptfds);
224 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
226 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
231 return SERIAL_TIMEOUT;
232 else if (errno == EINTR)
235 return SERIAL_ERROR; /* Got an error from select or
243 /* Read any error output we might have. */
246 ser_base_read_error_fd (struct serial *scb, int close_fd)
248 if (scb->error_fd != -1)
251 char buf[GDB_MI_MSG_WIDTH + 1];
257 int to_read = GDB_MI_MSG_WIDTH;
261 num_bytes = (scb->ops->avail)(scb, scb->error_fd);
264 to_read = (num_bytes < to_read) ? num_bytes : to_read;
269 s = read (scb->error_fd, &buf, to_read);
270 if ((s == -1) || (s == 0 && !close_fd))
273 if (s == 0 && close_fd)
276 close (scb->error_fd);
281 /* In theory, embedded newlines are not a problem.
282 But for MI, we want each output line to have just
283 one newline for legibility. So output things
284 in newline chunks. */
285 gdb_assert (s > 0 && s <= GDB_MI_MSG_WIDTH);
288 while ((newline = strstr (current, "\n")) != NULL)
291 fputs_unfiltered (current, gdb_stderr);
292 fputs_unfiltered ("\n", gdb_stderr);
293 current = newline + 1;
296 fputs_unfiltered (current, gdb_stderr);
301 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
302 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
303 char if successful. Returns -2 if timeout expired, EOF if line dropped
304 dead, or -3 for any other error (see errno in that case). */
307 do_ser_base_readchar (struct serial *scb, int timeout)
312 /* We have to be able to keep the GUI alive here, so we break the
313 original timeout into steps of 1 second, running the "keep the
314 GUI alive" hook each time through the loop.
316 Also, timeout = 0 means to poll, so we just set the delta to 0,
317 so we will only go through the loop once. */
319 delta = (timeout == 0 ? 0 : 1);
322 /* N.B. The UI may destroy our world (for instance by calling
323 remote_stop,) in which case we want to get out of here as
324 quickly as possible. It is not safe to touch scb, since
325 someone else might have freed it. The
326 deprecated_ui_loop_hook signals that we should exit by
329 if (deprecated_ui_loop_hook)
331 if (deprecated_ui_loop_hook (0))
332 return SERIAL_TIMEOUT;
335 status = ser_base_wait_for (scb, delta);
339 /* If we got a character or an error back from wait_for, then we can
340 break from the loop before the timeout is completed. */
341 if (status != SERIAL_TIMEOUT)
344 /* If we have exhausted the original timeout, then generate
345 a SERIAL_TIMEOUT, and pass it out of the loop. */
346 else if (timeout == 0)
348 status = SERIAL_TIMEOUT;
352 /* We also need to check and consume the stderr because it could
353 come before the stdout for some stubs. If we just sit and wait
354 for stdout, we would hit a deadlock for that case. */
355 ser_base_read_error_fd (scb, 0);
361 status = scb->ops->read_prim (scb, BUFSIZ);
368 /* Got an error from read. */
372 scb->bufcnt = status;
374 scb->bufp = scb->buf;
378 /* Perform operations common to both old and new readchar. */
380 /* Return the next character from the input FIFO. If the FIFO is
381 empty, call the SERIAL specific routine to try and read in more
384 Initially data from the input FIFO is returned (fd_event()
385 pre-reads the input into that FIFO. Once that has been emptied,
386 further data is obtained by polling the input FD using the device
387 specific readchar() function. Note: reschedule() is called after
388 every read. This is because there is no guarentee that the lower
389 level fd_event() poll_event() code (which also calls reschedule())
393 generic_readchar (struct serial *scb, int timeout,
394 int (do_readchar) (struct serial *scb, int timeout))
403 else if (scb->bufcnt < 0)
405 /* Some errors/eof are are sticky. */
410 ch = do_readchar (scb, timeout);
413 switch ((enum serial_rc) ch)
417 /* Make the error/eof stick. */
427 /* Read any error output we might have. */
428 ser_base_read_error_fd (scb, 1);
435 ser_base_readchar (struct serial *scb, int timeout)
437 return generic_readchar (scb, timeout, do_ser_base_readchar);
441 ser_base_write (struct serial *scb, const void *buf, size_t count)
443 const char *str = (const char *) buf;
448 cc = scb->ops->write_prim (scb, str, count);
459 ser_base_flush_output (struct serial *scb)
465 ser_base_flush_input (struct serial *scb)
467 if (scb->bufcnt >= 0)
470 scb->bufp = scb->buf;
478 ser_base_send_break (struct serial *scb)
484 ser_base_drain_output (struct serial *scb)
490 ser_base_raw (struct serial *scb)
492 return; /* Always in raw mode. */
496 ser_base_get_tty_state (struct serial *scb)
498 /* Allocate a dummy. */
499 return (serial_ttystate) XNEW (int);
503 ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
505 /* Allocate another dummy. */
506 return (serial_ttystate) XNEW (int);
510 ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
516 ser_base_noflush_set_tty_state (struct serial *scb,
517 serial_ttystate new_ttystate,
518 serial_ttystate old_ttystate)
524 ser_base_print_tty_state (struct serial *scb,
525 serial_ttystate ttystate,
526 struct ui_file *stream)
528 /* Nothing to print. */
533 ser_base_setbaudrate (struct serial *scb, int rate)
535 return 0; /* Never fails! */
539 ser_base_setstopbits (struct serial *scb, int num)
541 return 0; /* Never fails! */
544 /* Implement the "setparity" serial_ops callback. */
547 ser_base_setparity (struct serial *scb, int parity)
549 return 0; /* Never fails! */
552 /* Put the SERIAL device into/out-of ASYNC mode. */
555 ser_base_async (struct serial *scb,
560 /* Force a re-schedule. */
561 scb->async_state = NOTHING_SCHEDULED;
562 if (serial_debug_p (scb))
563 fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
569 if (serial_debug_p (scb))
570 fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
572 /* De-schedule whatever tasks are currently scheduled. */
573 switch (scb->async_state)
576 delete_file_handler (scb->fd);
578 case NOTHING_SCHEDULED:
580 default: /* TIMER SCHEDULED */
581 delete_timer (scb->async_state);