GDB (xrefs)

/tmp/gdb-8.1/gdb/ser-base.c
Go to the documentation of this file.
1 /* Generic serial interface functions.
2
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "serial.h"
22 #include "ser-base.h"
23 #include "event-loop.h"
24
25 #include "gdb_select.h"
26 #include "gdb_sys_time.h"
27 #ifdef USE_WIN32API
28 #include <winsock2.h>
29 #endif
30
31
32 static timer_handler_func push_event;
33 static handler_func fd_event;
34
35 /* Event handling for ASYNC serial code.
36
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.
40
41 ASYNC only stops pestering its client when it is de-async'ed or it
42 is told to go away. */
43
44 /* Value of scb->async_state: */
45 enum {
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. */
50 FD_SCHEDULED = -1,
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. */
57 };
58
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. */
63
64 static void
65 reschedule (struct serial *scb)
66 {
67 if (serial_is_async_p (scb))
68 {
69 int next_state;
70
71 switch (scb->async_state)
72 {
73 case FD_SCHEDULED:
74 if (scb->bufcnt == 0)
75 next_state = FD_SCHEDULED;
76 else
77 {
78 delete_file_handler (scb->fd);
79 next_state = create_timer (0, push_event, scb);
80 }
81 break;
82 case NOTHING_SCHEDULED:
83 if (scb->bufcnt == 0)
84 {
85 add_file_handler (scb->fd, fd_event, scb);
86 next_state = FD_SCHEDULED;
87 }
88 else
89 {
90 next_state = create_timer (0, push_event, scb);
91 }
92 break;
93 default: /* TIMER SCHEDULED */
94 if (scb->bufcnt == 0)
95 {
96 delete_timer (scb->async_state);
97 add_file_handler (scb->fd, fd_event, scb);
98 next_state = FD_SCHEDULED;
99 }
100 else
101 next_state = scb->async_state;
102 break;
103 }
104 if (serial_debug_p (scb))
105 {
106 switch (next_state)
107 {
108 case FD_SCHEDULED:
109 if (scb->async_state != FD_SCHEDULED)
110 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
111 scb->fd);
112 break;
113 default: /* TIMER SCHEDULED */
114 if (scb->async_state == FD_SCHEDULED)
115 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
116 scb->fd);
117 break;
118 }
119 }
120 scb->async_state = next_state;
121 }
122 }
123
124 /* Run the SCB's async handle, and reschedule, if the handler doesn't
125 close SCB. */
126
127 static void
128 run_async_handler_and_reschedule (struct serial *scb)
129 {
130 int is_open;
131
132 /* Take a reference, so a serial_close call within the handler
133 doesn't make SCB a dangling pointer. */
134 serial_ref (scb);
135
136 /* Run the handler. */
137 scb->async_handler (scb, scb->async_context);
138
139 is_open = serial_is_open (scb);
140 serial_unref (scb);
141
142 /* Get ready for more, if not already closed. */
143 if (is_open)
144 reschedule (scb);
145 }
146
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. */
152
153 static void
154 fd_event (int error, void *context)
155 {
156 struct serial *scb = (struct serial *) context;
157 if (error != 0)
158 {
159 scb->bufcnt = SERIAL_ERROR;
160 }
161 else if (scb->bufcnt == 0)
162 {
163 /* Prime the input FIFO. The readchar() function is used to
164 pull characters out of the buffer. See also
165 generic_readchar(). */
166 int nr;
167
168 do
169 {
170 nr = scb->ops->read_prim (scb, BUFSIZ);
171 }
172 while (nr < 0 && errno == EINTR);
173
174 if (nr == 0)
175 {
176 scb->bufcnt = SERIAL_EOF;
177 }
178 else if (nr > 0)
179 {
180 scb->bufcnt = nr;
181 scb->bufp = scb->buf;
182 }
183 else
184 {
185 scb->bufcnt = SERIAL_ERROR;
186 }
187 }
188 run_async_handler_and_reschedule (scb);
189 }
190
191 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
192 error). Nag the client until all the data has been read. In the
193 case of errors, the client will need to close or de-async the
194 device before naging stops. */
195
196 static void
197 push_event (void *context)
198 {
199 struct serial *scb = (struct serial *) context;
200
201 scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
202 run_async_handler_and_reschedule (scb);
203 }
204
205 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
206 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
207
208 /* NOTE: Some of the code below is dead. The only possible values of
209 the TIMEOUT parameter are ONE and ZERO. OTOH, we should probably
210 get rid of the deprecated_ui_loop_hook call in do_ser_base_readchar
211 instead and support infinite time outs here. */
212
213 static int
214 ser_base_wait_for (struct serial *scb, int timeout)
215 {
216 while (1)
217 {
218 int numfds;
219 struct timeval tv;
220 fd_set readfds, exceptfds;
221 int nfds;
222
223 /* NOTE: Some OS's can scramble the READFDS when the select()
224 call fails (ex the kernel with Red Hat 5.2). Initialize all
225 arguments before each call. */
226
227 tv.tv_sec = timeout;
228 tv.tv_usec = 0;
229
230 FD_ZERO (&readfds);
231 FD_ZERO (&exceptfds);
232 FD_SET (scb->fd, &readfds);
233 FD_SET (scb->fd, &exceptfds);
234
235 QUIT;
236
237 nfds = scb->fd + 1;
238 if (timeout >= 0)
239 numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, &tv);
240 else
241 numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, 0);
242
243 if (numfds <= 0)
244 {
245 if (numfds == 0)
246 return SERIAL_TIMEOUT;
247 else if (errno == EINTR)
248 continue;
249 else
250 return SERIAL_ERROR; /* Got an error from select or
251 poll. */
252 }
253
254 return 0;
255 }
256 }
257
258 /* Read any error output we might have. */
259
260 static void
261 ser_base_read_error_fd (struct serial *scb, int close_fd)
262 {
263 if (scb->error_fd != -1)
264 {
265 ssize_t s;
266 char buf[GDB_MI_MSG_WIDTH + 1];
267
268 for (;;)
269 {
270 char *current;
271 char *newline;
272 int to_read = GDB_MI_MSG_WIDTH;
273 int num_bytes = -1;
274
275 if (scb->ops->avail)
276 num_bytes = (scb->ops->avail)(scb, scb->error_fd);
277
278 if (num_bytes != -1)
279 to_read = (num_bytes < to_read) ? num_bytes : to_read;
280
281 if (to_read == 0)
282 break;
283
284 s = read (scb->error_fd, &buf, to_read);
285 if ((s == -1) || (s == 0 && !close_fd))
286 break;
287
288 if (s == 0 && close_fd)
289 {
290 /* End of file. */
291 if (serial_is_async_p (scb))
292 delete_file_handler (scb->error_fd);
293 close (scb->error_fd);
294 scb->error_fd = -1;
295 break;
296 }
297
298 /* In theory, embedded newlines are not a problem.
299 But for MI, we want each output line to have just
300 one newline for legibility. So output things
301 in newline chunks. */
302 gdb_assert (s > 0 && s <= GDB_MI_MSG_WIDTH);
303 buf[s] = '\0';
304 current = buf;
305 while ((newline = strstr (current, "\n")) != NULL)
306 {
307 *newline = '\0';
308 fputs_unfiltered (current, gdb_stderr);
309 fputs_unfiltered ("\n", gdb_stderr);
310 current = newline + 1;
311 }
312
313 fputs_unfiltered (current, gdb_stderr);
314 }
315 }
316 }
317
318 /* Event-loop callback for a serial's error_fd. Flushes any error
319 output we might have. */
320
321 static void
322 handle_error_fd (int error, gdb_client_data client_data)
323 {
324 serial *scb = (serial *) client_data;
325
326 ser_base_read_error_fd (scb, 0);
327 }
328
329 /* Read a character with user-specified timeout. TIMEOUT is number of
330 seconds to wait, or -1 to wait forever. Use timeout of 0 to effect
331 a poll. Returns char if successful. Returns SERIAL_TIMEOUT if
332 timeout expired, SERIAL_EOF if line dropped dead, or SERIAL_ERROR
333 for any other error (see errno in that case). */
334
335 static int
336 do_ser_base_readchar (struct serial *scb, int timeout)
337 {
338 int status;
339 int delta;
340
341 /* We have to be able to keep the GUI alive here, so we break the
342 original timeout into steps of 1 second, running the "keep the
343 GUI alive" hook each time through the loop.
344
345 Also, timeout = 0 means to poll, so we just set the delta to 0,
346 so we will only go through the loop once. */
347
348 delta = (timeout == 0 ? 0 : 1);
349 while (1)
350 {
351 /* N.B. The UI may destroy our world (for instance by calling
352 remote_stop,) in which case we want to get out of here as
353 quickly as possible. It is not safe to touch scb, since
354 someone else might have freed it. The
355 deprecated_ui_loop_hook signals that we should exit by
356 returning 1. */
357
358 if (deprecated_ui_loop_hook)
359 {
360 if (deprecated_ui_loop_hook (0))
361 return SERIAL_TIMEOUT;
362 }
363
364 status = ser_base_wait_for (scb, delta);
365 if (timeout > 0)
366 timeout -= delta;
367
368 /* If we got a character or an error back from wait_for, then we can
369 break from the loop before the timeout is completed. */
370 if (status != SERIAL_TIMEOUT)
371 break;
372
373 /* If we have exhausted the original timeout, then generate
374 a SERIAL_TIMEOUT, and pass it out of the loop. */
375 else if (timeout == 0)
376 {
377 status = SERIAL_TIMEOUT;
378 break;
379 }
380
381 /* We also need to check and consume the stderr because it could
382 come before the stdout for some stubs. If we just sit and wait
383 for stdout, we would hit a deadlock for that case. */
384 ser_base_read_error_fd (scb, 0);
385 }
386
387 if (status < 0)
388 return status;
389
390 do
391 {
392 status = scb->ops->read_prim (scb, BUFSIZ);
393 }
394 while (status < 0 && errno == EINTR);
395
396 if (status <= 0)
397 {
398 if (status == 0)
399 return SERIAL_EOF;
400 else
401 /* Got an error from read. */
402 return SERIAL_ERROR;
403 }
404
405 scb->bufcnt = status;
406 scb->bufcnt--;
407 scb->bufp = scb->buf;
408 return *scb->bufp++;
409 }
410
411 /* Perform operations common to both old and new readchar. */
412
413 /* Return the next character from the input FIFO. If the FIFO is
414 empty, call the SERIAL specific routine to try and read in more
415 characters.
416
417 Initially data from the input FIFO is returned (fd_event()
418 pre-reads the input into that FIFO. Once that has been emptied,
419 further data is obtained by polling the input FD using the device
420 specific readchar() function. Note: reschedule() is called after
421 every read. This is because there is no guarentee that the lower
422 level fd_event() poll_event() code (which also calls reschedule())
423 will be called. */
424
425 int
426 generic_readchar (struct serial *scb, int timeout,
427 int (do_readchar) (struct serial *scb, int timeout))
428 {
429 int ch;
430 if (scb->bufcnt > 0)
431 {
432 ch = *scb->bufp;
433 scb->bufcnt--;
434 scb->bufp++;
435 }
436 else if (scb->bufcnt < 0)
437 {
438 /* Some errors/eof are are sticky. */
439 ch = scb->bufcnt;
440 }
441 else
442 {
443 ch = do_readchar (scb, timeout);
444 if (ch < 0)
445 {
446 switch ((enum serial_rc) ch)
447 {
448 case SERIAL_EOF:
449 case SERIAL_ERROR:
450 /* Make the error/eof stick. */
451 scb->bufcnt = ch;
452 break;
453 case SERIAL_TIMEOUT:
454 scb->bufcnt = 0;
455 break;
456 }
457 }
458 }
459
460 /* Read any error output we might have. */
461 ser_base_read_error_fd (scb, 1);
462
463 reschedule (scb);
464 return ch;
465 }
466
467 int
468 ser_base_readchar (struct serial *scb, int timeout)
469 {
470 return generic_readchar (scb, timeout, do_ser_base_readchar);
471 }
472
473 int
474 ser_base_write (struct serial *scb, const void *buf, size_t count)
475 {
476 const char *str = (const char *) buf;
477 int cc;
478
479 while (count > 0)
480 {
481 QUIT;
482
483 cc = scb->ops->write_prim (scb, str, count);
484
485 if (cc < 0)
486 {
487 if (errno == EINTR)
488 continue;
489 return 1;
490 }
491 count -= cc;
492 str += cc;
493 }
494 return 0;
495 }
496
497 int
498 ser_base_flush_output (struct serial *scb)
499 {
500 return 0;
501 }
502
503 int
504 ser_base_flush_input (struct serial *scb)
505 {
506 if (scb->bufcnt >= 0)
507 {
508 scb->bufcnt = 0;
509 scb->bufp = scb->buf;
510 return 0;
511 }
512 else
513 return SERIAL_ERROR;
514 }
515
516 int
517 ser_base_send_break (struct serial *scb)
518 {
519 return 0;
520 }
521
522 int
523 ser_base_drain_output (struct serial *scb)
524 {
525 return 0;
526 }
527
528 void
529 ser_base_raw (struct serial *scb)
530 {
531 return; /* Always in raw mode. */
532 }
533
534 serial_ttystate
535 ser_base_get_tty_state (struct serial *scb)
536 {
537 /* Allocate a dummy. */
538 return (serial_ttystate) XNEW (int);
539 }
540
541 serial_ttystate
542 ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
543 {
544 /* Allocate another dummy. */
545 return (serial_ttystate) XNEW (int);
546 }
547
548 int
549 ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
550 {
551 return 0;
552 }
553
554 void
555 ser_base_print_tty_state (struct serial *scb,
556 serial_ttystate ttystate,
557 struct ui_file *stream)
558 {
559 /* Nothing to print. */
560 return;
561 }
562
563 int
564 ser_base_setbaudrate (struct serial *scb, int rate)
565 {
566 return 0; /* Never fails! */
567 }
568
569 int
570 ser_base_setstopbits (struct serial *scb, int num)
571 {
572 return 0; /* Never fails! */
573 }
574
575 /* Implement the "setparity" serial_ops callback. */
576
577 int
578 ser_base_setparity (struct serial *scb, int parity)
579 {
580 return 0; /* Never fails! */
581 }
582
583 /* Put the SERIAL device into/out-of ASYNC mode. */
584
585 void
586 ser_base_async (struct serial *scb,
587 int async_p)
588 {
589 if (async_p)
590 {
591 /* Force a re-schedule. */
592 scb->async_state = NOTHING_SCHEDULED;
593 if (serial_debug_p (scb))
594 fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
595 scb->fd);
596 reschedule (scb);
597
598 if (scb->error_fd != -1)
599 add_file_handler (scb->error_fd, handle_error_fd, scb);
600 }
601 else
602 {
603 if (serial_debug_p (scb))
604 fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
605 scb->fd);
606 /* De-schedule whatever tasks are currently scheduled. */
607 switch (scb->async_state)
608 {
609 case FD_SCHEDULED:
610 delete_file_handler (scb->fd);
611 break;
612 case NOTHING_SCHEDULED:
613 break;
614 default: /* TIMER SCHEDULED */
615 delete_timer (scb->async_state);
616 break;
617 }
618
619 if (scb->error_fd != -1)
620 delete_file_handler (scb->error_fd);
621 }
622 }
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
serial_is_async_p
int serial_is_async_p(struct serial *scb)
Definition: serial.c:542
generic_readchar
int generic_readchar(struct serial *scb, int timeout, int(do_readchar)(struct serial *scb, int timeout))
Definition: ser-base.c:426
serial::async_handler
serial_event_ftype * async_handler
Definition: serial.h:247
ser_base_set_tty_state
int ser_base_set_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:549
handler_func
void() handler_func(int, gdb_client_data)
Definition: event-loop.h:73
fputs_unfiltered
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:127
ser_base_flush_output
int ser_base_flush_output(struct serial *scb)
Definition: ser-base.c:498
SERIAL_EOF
Definition: serial.h:107
push_event
static timer_handler_func push_event
Definition: ser-base.c:32
serial::async_state
int async_state
Definition: serial.h:245
NOTHING_SCHEDULED
Definition: ser-base.c:53
serial::error_fd
int error_fd
Definition: serial.h:235
SERIAL_ERROR
Definition: serial.h:102
ser_base_setbaudrate
int ser_base_setbaudrate(struct serial *scb, int rate)
Definition: ser-base.c:564
create_timer
int create_timer(int ms, timer_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:1106
ui_file
Definition: ui-file.h:26
defs.h
ser_base_setstopbits
int ser_base_setstopbits(struct serial *scb, int num)
Definition: ser-base.c:570
reschedule
static void reschedule(struct serial *scb)
Definition: ser-base.c:65
serial_ops::read_prim
int(* read_prim)(struct serial *scb, size_t count)
Definition: serial.h:282
serial::async_context
void * async_context
Definition: serial.h:246
serial_debug_p
int serial_debug_p(struct serial *scb)
Definition: serial.c:568
add_file_handler
void add_file_handler(int fd, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:413
XNEW
#define XNEW(T)
Definition: poison.h:109
ser_base_read_error_fd
static void ser_base_read_error_fd(struct serial *scb, int close_fd)
Definition: ser-base.c:261
SERIAL_TIMEOUT
Definition: serial.h:103
ser_base_raw
void ser_base_raw(struct serial *scb)
Definition: ser-base.c:529
event-loop.h
ser_base_async
void ser_base_async(struct serial *scb, int async_p)
Definition: ser-base.c:586
serial::bufp
unsigned char * bufp
Definition: serial.h:241
handle_error_fd
static void handle_error_fd(int error, gdb_client_data client_data)
Definition: ser-base.c:322
serial_unref
void serial_unref(struct serial *scb)
Definition: serial.c:372
gdb_sys_time.h
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
serial_ops::write_prim
int(* write_prim)(struct serial *scb, const void *buf, size_t count)
Definition: serial.h:285
timer_handler_func
void() timer_handler_func(gdb_client_data)
Definition: event-loop.h:76
fd_event
static handler_func fd_event
Definition: ser-base.c:33
parity
static const char * parity
Definition: serial.c:658
serial.h
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
GDB_MI_MSG_WIDTH
#define GDB_MI_MSG_WIDTH
Definition: defs.h:675
serial
Definition: serial.h:224
ser_base_drain_output
int ser_base_drain_output(struct serial *scb)
Definition: ser-base.c:523
serial::buf
unsigned char buf[BUFSIZ]
Definition: serial.h:242
gdb_client_data
void * gdb_client_data
Definition: event-loop.h:70
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
serial_rc
serial_rc
Definition: serial.h:101
gdb_select.h
ser_base_print_tty_state
void ser_base_print_tty_state(struct serial *scb, serial_ttystate ttystate, struct ui_file *stream)
Definition: ser-base.c:555
ser_base_setparity
int ser_base_setparity(struct serial *scb, int parity)
Definition: ser-base.c:578
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
serial_ops::avail
int(* avail)(struct serial *scb, int fd)
Definition: serial.h:290
ser_base_flush_input
int ser_base_flush_input(struct serial *scb)
Definition: ser-base.c:504
ser_base_readchar
int ser_base_readchar(struct serial *scb, int timeout)
Definition: ser-base.c:468
serial::fd
int fd
Definition: serial.h:230
ser_base_send_break
int ser_base_send_break(struct serial *scb)
Definition: ser-base.c:517
ser_base_write
int ser_base_write(struct serial *scb, const void *buf, size_t count)
Definition: ser-base.c:474
serial::bufcnt
int bufcnt
Definition: serial.h:239
delete_timer
void delete_timer(int id)
Definition: event-loop.c:1156
run_async_handler_and_reschedule
static void run_async_handler_and_reschedule(struct serial *scb)
Definition: ser-base.c:128
ser-base.h
serial_ref
void serial_ref(struct serial *scb)
Definition: serial.c:366
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
ser_base_copy_tty_state
serial_ttystate ser_base_copy_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:542
serial_ttystate
void * serial_ttystate
Definition: serial.h:27
FD_SCHEDULED
Definition: ser-base.c:50
interruptible_select
int interruptible_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
Definition: event-top.c:985
serial_is_open
int serial_is_open(struct serial *scb)
Definition: serial.c:360
QUIT
#define QUIT
Definition: defs.h:179
do_ser_base_readchar
static int do_ser_base_readchar(struct serial *scb, int timeout)
Definition: ser-base.c:336
serial::ops
const struct serial_ops * ops
Definition: serial.h:236
error
void error(const char *fmt,...)
Definition: errors.c:38
delete_file_handler
void delete_file_handler(int fd)
Definition: event-loop.c:564
ser_base_wait_for
static int ser_base_wait_for(struct serial *scb, int timeout)
Definition: ser-base.c:214
deprecated_ui_loop_hook
int(* deprecated_ui_loop_hook)(int signo)
Definition: top.c:185
ser_base_get_tty_state
serial_ttystate ser_base_get_tty_state(struct serial *scb)
Definition: ser-base.c:535
rate
int rate
Definition: ser-unix.c:238