GDB (xrefs)

/tmp/gdb-8.1/gdb/serial.c
Go to the documentation of this file.
1 /* Generic serial interface routines
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 <ctype.h>
22 #include "serial.h"
23 #include "gdbcmd.h"
24 #include "cli/cli-utils.h"
25
26 /* Is serial being debugged? */
27
28 static unsigned int global_serial_debug_p;
29
30 typedef const struct serial_ops *serial_ops_p;
31 DEF_VEC_P (serial_ops_p);
32
33 /* Serial I/O handlers. */
34
35 VEC (serial_ops_p) *serial_ops_list = NULL;
36
37 /* Pointer to list of scb's. */
38
39 static struct serial *scb_base;
40
41 /* Non-NULL gives filename which contains a recording of the remote session,
42 suitable for playback by gdbserver. */
43
44 static char *serial_logfile = NULL;
45 static struct ui_file *serial_logfp = NULL;
46
47 static const struct serial_ops *serial_interface_lookup (const char *);
48 static void serial_logchar (struct ui_file *stream,
49 int ch_type, int ch, int timeout);
50 static const char logbase_hex[] = "hex";
51 static const char logbase_octal[] = "octal";
52 static const char logbase_ascii[] = "ascii";
53 static const char *const logbase_enums[] =
54 {logbase_hex, logbase_octal, logbase_ascii, NULL};
55 static const char *serial_logbase = logbase_ascii;
56
57
58 static int serial_current_type = 0;
59
60 /* Log char CH of type CHTYPE, with TIMEOUT. */
61
62 /* Define bogus char to represent a BREAK. Should be careful to choose a value
63 that can't be confused with a normal char, or an error code. */
64 #define SERIAL_BREAK 1235
65
66 static void
67 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
68 {
69 if (ch_type != serial_current_type)
70 {
71 fprintf_unfiltered (stream, "\n%c ", ch_type);
72 serial_current_type = ch_type;
73 }
74
75 if (serial_logbase != logbase_ascii)
76 fputc_unfiltered (' ', stream);
77
78 switch (ch)
79 {
80 case SERIAL_TIMEOUT:
81 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
82 return;
83 case SERIAL_ERROR:
84 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
85 return;
86 case SERIAL_EOF:
87 fputs_unfiltered ("<Eof>", stream);
88 return;
89 case SERIAL_BREAK:
90 fputs_unfiltered ("<Break>", stream);
91 return;
92 default:
93 if (serial_logbase == logbase_hex)
94 fprintf_unfiltered (stream, "%02x", ch & 0xff);
95 else if (serial_logbase == logbase_octal)
96 fprintf_unfiltered (stream, "%03o", ch & 0xff);
97 else
98 switch (ch)
99 {
100 case '\\':
101 fputs_unfiltered ("\\\\", stream);
102 break;
103 case '\b':
104 fputs_unfiltered ("\\b", stream);
105 break;
106 case '\f':
107 fputs_unfiltered ("\\f", stream);
108 break;
109 case '\n':
110 fputs_unfiltered ("\\n", stream);
111 break;
112 case '\r':
113 fputs_unfiltered ("\\r", stream);
114 break;
115 case '\t':
116 fputs_unfiltered ("\\t", stream);
117 break;
118 case '\v':
119 fputs_unfiltered ("\\v", stream);
120 break;
121 default:
122 fprintf_unfiltered (stream,
123 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
124 break;
125 }
126 }
127 }
128
129 void
130 serial_log_command (struct target_ops *self, const char *cmd)
131 {
132 if (!serial_logfp)
133 return;
134
135 serial_current_type = 'c';
136
137 fputs_unfiltered ("\nc ", serial_logfp);
138 fputs_unfiltered (cmd, serial_logfp);
139
140 /* Make sure that the log file is as up-to-date as possible,
141 in case we are getting ready to dump core or something. */
142 gdb_flush (serial_logfp);
143 }
144
145
146 static const struct serial_ops *
147 serial_interface_lookup (const char *name)
148 {
149 const struct serial_ops *ops;
150 int i;
151
152 for (i = 0; VEC_iterate (serial_ops_p, serial_ops_list, i, ops); ++i)
153 if (strcmp (name, ops->name) == 0)
154 return ops;
155
156 return NULL;
157 }
158
159 void
160 serial_add_interface (const struct serial_ops *optable)
161 {
162 VEC_safe_push (serial_ops_p, serial_ops_list, optable);
163 }
164
165 /* Return the open serial device for FD, if found, or NULL if FD is
166 not already opened. */
167
168 struct serial *
169 serial_for_fd (int fd)
170 {
171 struct serial *scb;
172
173 for (scb = scb_base; scb; scb = scb->next)
174 if (scb->fd == fd)
175 return scb;
176
177 return NULL;
178 }
179
180 /* Create a new serial for OPS. */
181
182 static struct serial *
183 new_serial (const struct serial_ops *ops)
184 {
185 struct serial *scb;
186
187 scb = XCNEW (struct serial);
188
189 scb->ops = ops;
190
191 scb->bufp = scb->buf;
192 scb->error_fd = -1;
193 scb->refcnt = 1;
194
195 return scb;
196 }
197
198 static struct serial *serial_open_ops_1 (const struct serial_ops *ops,
199 const char *open_name);
200
201 /* Open up a device or a network socket, depending upon the syntax of NAME. */
202
203 struct serial *
204 serial_open (const char *name)
205 {
206 const struct serial_ops *ops;
207 const char *open_name = name;
208
209 if (startswith (name, "|"))
210 {
211 ops = serial_interface_lookup ("pipe");
212 /* Discard ``|'' and any space before the command itself. */
213 ++open_name;
214 open_name = skip_spaces (open_name);
215 }
216 /* Check for a colon, suggesting an IP address/port pair.
217 Do this *after* checking for all the interesting prefixes. We
218 don't want to constrain the syntax of what can follow them. */
219 else if (strchr (name, ':'))
220 ops = serial_interface_lookup ("tcp");
221 else
222 ops = serial_interface_lookup ("hardwire");
223
224 if (!ops)
225 return NULL;
226
227 return serial_open_ops_1 (ops, open_name);
228 }
229
230 /* Open up a serial for OPS, passing OPEN_NAME to the open method. */
231
232 static struct serial *
233 serial_open_ops_1 (const struct serial_ops *ops, const char *open_name)
234 {
235 struct serial *scb;
236
237 scb = new_serial (ops);
238
239 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
240 if ((*scb->ops->open) (scb, open_name))
241 {
242 xfree (scb);
243 return NULL;
244 }
245
246 scb->next = scb_base;
247 scb_base = scb;
248
249 if (serial_logfile != NULL)
250 {
251 stdio_file_up file (new stdio_file ());
252
253 if (!file->open (serial_logfile, "w"))
254 perror_with_name (serial_logfile);
255
256 serial_logfp = file.release ();
257 }
258
259 return scb;
260 }
261
262 /* See serial.h. */
263
264 struct serial *
265 serial_open_ops (const struct serial_ops *ops)
266 {
267 return serial_open_ops_1 (ops, NULL);
268 }
269
270 /* Open a new serial stream using a file handle, using serial
271 interface ops OPS. */
272
273 static struct serial *
274 serial_fdopen_ops (const int fd, const struct serial_ops *ops)
275 {
276 struct serial *scb;
277
278 if (!ops)
279 {
280 ops = serial_interface_lookup ("terminal");
281 if (!ops)
282 ops = serial_interface_lookup ("hardwire");
283 }
284
285 if (!ops)
286 return NULL;
287
288 scb = new_serial (ops);
289
290 scb->next = scb_base;
291 scb_base = scb;
292
293 if ((ops->fdopen) != NULL)
294 (*ops->fdopen) (scb, fd);
295 else
296 scb->fd = fd;
297
298 return scb;
299 }
300
301 struct serial *
302 serial_fdopen (const int fd)
303 {
304 return serial_fdopen_ops (fd, NULL);
305 }
306
307 static void
308 do_serial_close (struct serial *scb, int really_close)
309 {
310 struct serial *tmp_scb;
311
312 if (serial_logfp)
313 {
314 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
315 serial_current_type = 0;
316
317 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
318 delete serial_logfp;
319 serial_logfp = NULL;
320 }
321
322 /* ensure that the FD has been taken out of async mode. */
323 if (scb->async_handler != NULL)
324 serial_async (scb, NULL, NULL);
325
326 if (really_close)
327 scb->ops->close (scb);
328
329 /* For serial_is_open. */
330 scb->bufp = NULL;
331
332 if (scb_base == scb)
333 scb_base = scb_base->next;
334 else
335 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
336 {
337 if (tmp_scb->next != scb)
338 continue;
339
340 tmp_scb->next = tmp_scb->next->next;
341 break;
342 }
343
344 serial_unref (scb);
345 }
346
347 void
348 serial_close (struct serial *scb)
349 {
350 do_serial_close (scb, 1);
351 }
352
353 void
354 serial_un_fdopen (struct serial *scb)
355 {
356 do_serial_close (scb, 0);
357 }
358
359 int
360 serial_is_open (struct serial *scb)
361 {
362 return scb->bufp != NULL;
363 }
364
365 void
366 serial_ref (struct serial *scb)
367 {
368 scb->refcnt++;
369 }
370
371 void
372 serial_unref (struct serial *scb)
373 {
374 --scb->refcnt;
375 if (scb->refcnt == 0)
376 xfree (scb);
377 }
378
379 int
380 serial_readchar (struct serial *scb, int timeout)
381 {
382 int ch;
383
384 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
385 code is finished. */
386 if (0 && serial_is_async_p (scb) && timeout < 0)
387 internal_error (__FILE__, __LINE__,
388 _("serial_readchar: blocking read in async mode"));
389
390 ch = scb->ops->readchar (scb, timeout);
391 if (serial_logfp != NULL)
392 {
393 serial_logchar (serial_logfp, 'r', ch, timeout);
394
395 /* Make sure that the log file is as up-to-date as possible,
396 in case we are getting ready to dump core or something. */
397 gdb_flush (serial_logfp);
398 }
399 if (serial_debug_p (scb))
400 {
401 fprintf_unfiltered (gdb_stdlog, "[");
402 serial_logchar (gdb_stdlog, 'r', ch, timeout);
403 fprintf_unfiltered (gdb_stdlog, "]");
404 gdb_flush (gdb_stdlog);
405 }
406
407 return (ch);
408 }
409
410 int
411 serial_write (struct serial *scb, const void *buf, size_t count)
412 {
413 if (serial_logfp != NULL)
414 {
415 const char *str = (const char *) buf;
416 size_t c;
417
418 for (c = 0; c < count; c++)
419 serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0);
420
421 /* Make sure that the log file is as up-to-date as possible,
422 in case we are getting ready to dump core or something. */
423 gdb_flush (serial_logfp);
424 }
425 if (serial_debug_p (scb))
426 {
427 const char *str = (const char *) buf;
428 size_t c;
429
430 for (c = 0; c < count; c++)
431 {
432 fprintf_unfiltered (gdb_stdlog, "[");
433 serial_logchar (gdb_stdlog, 'w', str[c] & 0xff, 0);
434 fprintf_unfiltered (gdb_stdlog, "]");
435 }
436 gdb_flush (gdb_stdlog);
437 }
438
439 return (scb->ops->write (scb, buf, count));
440 }
441
442 void
443 serial_printf (struct serial *desc, const char *format,...)
444 {
445 va_list args;
446 char *buf;
447 va_start (args, format);
448
449 buf = xstrvprintf (format, args);
450 serial_write (desc, buf, strlen (buf));
451
452 xfree (buf);
453 va_end (args);
454 }
455
456 int
457 serial_drain_output (struct serial *scb)
458 {
459 return scb->ops->drain_output (scb);
460 }
461
462 int
463 serial_flush_output (struct serial *scb)
464 {
465 return scb->ops->flush_output (scb);
466 }
467
468 int
469 serial_flush_input (struct serial *scb)
470 {
471 return scb->ops->flush_input (scb);
472 }
473
474 int
475 serial_send_break (struct serial *scb)
476 {
477 if (serial_logfp != NULL)
478 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
479
480 return (scb->ops->send_break (scb));
481 }
482
483 void
484 serial_raw (struct serial *scb)
485 {
486 scb->ops->go_raw (scb);
487 }
488
489 serial_ttystate
490 serial_get_tty_state (struct serial *scb)
491 {
492 return scb->ops->get_tty_state (scb);
493 }
494
495 serial_ttystate
496 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
497 {
498 return scb->ops->copy_tty_state (scb, ttystate);
499 }
500
501 int
502 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
503 {
504 return scb->ops->set_tty_state (scb, ttystate);
505 }
506
507 void
508 serial_print_tty_state (struct serial *scb,
509 serial_ttystate ttystate,
510 struct ui_file *stream)
511 {
512 scb->ops->print_tty_state (scb, ttystate, stream);
513 }
514
515 int
516 serial_setbaudrate (struct serial *scb, int rate)
517 {
518 return scb->ops->setbaudrate (scb, rate);
519 }
520
521 int
522 serial_setstopbits (struct serial *scb, int num)
523 {
524 return scb->ops->setstopbits (scb, num);
525 }
526
527 /* See serial.h. */
528
529 int
530 serial_setparity (struct serial *scb, int parity)
531 {
532 return scb->ops->setparity (scb, parity);
533 }
534
535 int
536 serial_can_async_p (struct serial *scb)
537 {
538 return (scb->ops->async != NULL);
539 }
540
541 int
542 serial_is_async_p (struct serial *scb)
543 {
544 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
545 }
546
547 void
548 serial_async (struct serial *scb,
549 serial_event_ftype *handler,
550 void *context)
551 {
552 int changed = ((scb->async_handler == NULL) != (handler == NULL));
553
554 scb->async_handler = handler;
555 scb->async_context = context;
556 /* Only change mode if there is a need. */
557 if (changed)
558 scb->ops->async (scb, handler != NULL);
559 }
560
561 void
562 serial_debug (struct serial *scb, int debug_p)
563 {
564 scb->debug_p = debug_p;
565 }
566
567 int
568 serial_debug_p (struct serial *scb)
569 {
570 return scb->debug_p || global_serial_debug_p;
571 }
572
573 #ifdef USE_WIN32API
574 void
575 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
576 {
577 if (scb->ops->wait_handle)
578 scb->ops->wait_handle (scb, read, except);
579 else
580 {
581 *read = (HANDLE) _get_osfhandle (scb->fd);
582 *except = NULL;
583 }
584 }
585
586 void
587 serial_done_wait_handle (struct serial *scb)
588 {
589 if (scb->ops->done_wait_handle)
590 scb->ops->done_wait_handle (scb);
591 }
592 #endif
593
594 int
595 serial_pipe (struct serial *scbs[2])
596 {
597 const struct serial_ops *ops;
598 int fildes[2];
599
600 ops = serial_interface_lookup ("pipe");
601 if (!ops)
602 {
603 errno = ENOSYS;
604 return -1;
605 }
606
607 if (gdb_pipe (fildes) == -1)
608 return -1;
609
610 scbs[0] = serial_fdopen_ops (fildes[0], ops);
611 scbs[1] = serial_fdopen_ops (fildes[1], ops);
612 return 0;
613 }
614
615 /* Serial set/show framework. */
616
617 static struct cmd_list_element *serial_set_cmdlist;
618 static struct cmd_list_element *serial_show_cmdlist;
619
620 static void
621 serial_set_cmd (const char *args, int from_tty)
622 {
623 printf_unfiltered ("\"set serial\" must be followed "
624 "by the name of a command.\n");
625 help_list (serial_set_cmdlist, "set serial ", all_commands, gdb_stdout);
626 }
627
628 static void
629 serial_show_cmd (const char *args, int from_tty)
630 {
631 cmd_show_list (serial_show_cmdlist, from_tty, "");
632 }
633
634 /* Baud rate specified for talking to serial target systems. Default
635 is left as -1, so targets can choose their own defaults. */
636 /* FIXME: This means that "show serial baud" and gr_files_info can
637 print -1 or (unsigned int)-1. This is a Bad User Interface. */
638
639 int baud_rate = -1;
640
641 static void
642 serial_baud_show_cmd (struct ui_file *file, int from_tty,
643 struct cmd_list_element *c, const char *value)
644 {
645 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
646 value);
647 }
648
649 /* Parity for serial port. */
650
651 int serial_parity = GDBPARITY_NONE;
652
653 static const char parity_none[] = "none";
654 static const char parity_odd[] = "odd";
655 static const char parity_even[] = "even";
656 static const char *const parity_enums[] =
657 {parity_none, parity_odd, parity_even, NULL};
658 static const char *parity = parity_none;
659
660 /* Set serial_parity value. */
661
662 static void
663 set_parity (const char *ignore_args, int from_tty, struct cmd_list_element *c)
664 {
665 if (parity == parity_odd)
666 serial_parity = GDBPARITY_ODD;
667 else if (parity == parity_even)
668 serial_parity = GDBPARITY_EVEN;
669 else
670 serial_parity = GDBPARITY_NONE;
671 }
672
673 void
674 _initialize_serial (void)
675 {
676 #if 0
677 add_com ("connect", class_obscure, connect_command, _("\
678 Connect the terminal directly up to the command monitor.\n\
679 Use <CR>~. or <CR>~^D to break out."));
680 #endif /* 0 */
681
682 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
683 Set default serial/parallel port configuration."),
684 &serial_set_cmdlist, "set serial ",
685 0/*allow-unknown*/,
686 &setlist);
687
688 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
689 Show default serial/parallel port configuration."),
690 &serial_show_cmdlist, "show serial ",
691 0/*allow-unknown*/,
692 &showlist);
693
694 /* If target is open when baud changes, it doesn't take effect until
695 the next open (I think, not sure). */
696 add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\
697 Set baud rate for remote serial I/O."), _("\
698 Show baud rate for remote serial I/O."), _("\
699 This value is used to set the speed of the serial port when debugging\n\
700 using remote targets."),
701 NULL,
702 serial_baud_show_cmd,
703 &serial_set_cmdlist, &serial_show_cmdlist);
704
705 add_setshow_enum_cmd ("parity", no_class, parity_enums,
706 &parity, _("\
707 Set parity for remote serial I/O"), _("\
708 Show parity for remote serial I/O"), NULL,
709 set_parity,
710 NULL, /* FIXME: i18n: */
711 &serial_set_cmdlist, &serial_show_cmdlist);
712
713 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
714 Set filename for remote session recording."), _("\
715 Show filename for remote session recording."), _("\
716 This file is used to record the remote session for future playback\n\
717 by gdbserver."),
718 NULL,
719 NULL, /* FIXME: i18n: */
720 &setlist, &showlist);
721
722 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
723 &serial_logbase, _("\
724 Set numerical base for remote session logging"), _("\
725 Show numerical base for remote session logging"), NULL,
726 NULL,
727 NULL, /* FIXME: i18n: */
728 &setlist, &showlist);
729
730 add_setshow_zuinteger_cmd ("serial", class_maintenance,
731 &global_serial_debug_p, _("\
732 Set serial debugging."), _("\
733 Show serial debugging."), _("\
734 When non-zero, serial port debugging is enabled."),
735 NULL,
736 NULL, /* FIXME: i18n: */
737 &setdebuglist, &showdebuglist);
738 }
add_setshow_filename_cmd
void add_setshow_filename_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:591
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
serial_pipe
int serial_pipe(struct serial *scbs[2])
Definition: serial.c:595
serial_drain_output
int serial_drain_output(struct serial *scb)
Definition: serial.c:457
serial_ops_p
const struct serial_ops * serial_ops_p
Definition: serial.c:30
serial::async_handler
serial_event_ftype * async_handler
Definition: serial.h:247
GDBPARITY_EVEN
#define GDBPARITY_EVEN
Definition: serial.h:188
serial_ops::flush_output
int(* flush_output)(struct serial *)
Definition: serial.h:259
serial_fdopen_ops
static struct serial * serial_fdopen_ops(const int fd, const struct serial_ops *ops)
Definition: serial.c:274
serial_debug
void serial_debug(struct serial *scb, int debug_p)
Definition: serial.c:562
serial_print_tty_state
void serial_print_tty_state(struct serial *scb, serial_ttystate ttystate, struct ui_file *stream)
Definition: serial.c:508
fputs_unfiltered
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:127
xfree
void xfree(void *)
serial_open_ops_1
static struct serial * serial_open_ops_1(const struct serial_ops *ops, const char *open_name)
Definition: serial.c:233
serial_interface_lookup
static const struct serial_ops * serial_interface_lookup(const char *name)
Definition: serial.c:147
no_class
Definition: command.h:41
cmd_list_element
Definition: cli-decode.h:46
serial_for_fd
struct serial * serial_for_fd(int fd)
Definition: serial.c:169
xstrvprintf
char * xstrvprintf(const char *format, va_list ap)
Definition: common-utils.c:119
serial_ops::print_tty_state
void(* print_tty_state)(struct serial *, serial_ttystate, struct ui_file *)
Definition: serial.h:267
SERIAL_EOF
Definition: serial.h:107
VEC
VEC(serial_ops_p)
Definition: serial.c:35
serial_ops::copy_tty_state
serial_ttystate(* copy_tty_state)(struct serial *, serial_ttystate)
Definition: serial.h:265
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
serial_ops::flush_input
int(* flush_input)(struct serial *)
Definition: serial.h:261
serial_ops::name
const char * name
Definition: serial.h:252
serial_setstopbits
int serial_setstopbits(struct serial *scb, int num)
Definition: serial.c:522
add_setshow_enum_cmd
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:515
serial_write
int serial_write(struct serial *scb, const void *buf, size_t count)
Definition: serial.c:411
serial_logbase
static const char * serial_logbase
Definition: serial.c:55
serial::error_fd
int error_fd
Definition: serial.h:235
SERIAL_ERROR
Definition: serial.h:102
serial_ops::send_break
int(* send_break)(struct serial *)
Definition: serial.h:262
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
serial::next
struct serial * next
Definition: serial.h:243
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
parity_even
static const char parity_even[]
Definition: serial.c:655
defs.h
serial_async
void serial_async(struct serial *scb, serial_event_ftype *handler, void *context)
Definition: serial.c:548
serial::async_context
void * async_context
Definition: serial.h:246
serial_debug_p
int serial_debug_p(struct serial *scb)
Definition: serial.c:568
serial_ops
Definition: serial.h:250
serial_ops::fdopen
int(* fdopen)(struct serial *, int fd)
Definition: serial.h:255
serial_set_tty_state
int serial_set_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: serial.c:502
parity_none
static const char parity_none[]
Definition: serial.c:653
stdio_file
Definition: ui-file.h:152
serial_show_cmd
static void serial_show_cmd(const char *args, int from_tty)
Definition: serial.c:629
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
SERIAL_TIMEOUT
Definition: serial.h:103
serial_set_cmd
static void serial_set_cmd(const char *args, int from_tty)
Definition: serial.c:621
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
DEF_VEC_P
DEF_VEC_P(serial_ops_p)
serial::bufp
unsigned char * bufp
Definition: serial.h:241
serial_printf
void serial_printf(struct serial *desc, const char *format,...)
Definition: serial.c:443
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
serial_fdopen
struct serial * serial_fdopen(const int fd)
Definition: serial.c:302
serial_log_command
void serial_log_command(struct target_ops *self, const char *cmd)
Definition: serial.c:130
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
serial_open_ops
struct serial * serial_open_ops(const struct serial_ops *ops)
Definition: serial.c:265
serial_ops::readchar
int(* readchar)(struct serial *, int timeout)
Definition: serial.h:256
GDBPARITY_NONE
#define GDBPARITY_NONE
Definition: serial.h:186
fputc_unfiltered
int fputc_unfiltered(int c, struct ui_file *stream)
Definition: utils.c:1835
serial_unref
void serial_unref(struct serial *scb)
Definition: serial.c:372
serial::refcnt
int refcnt
Definition: serial.h:228
target_ops
Definition: target.h:412
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
baud_rate
int baud_rate
Definition: serial.c:639
serial_un_fdopen
void serial_un_fdopen(struct serial *scb)
Definition: serial.c:354
add_setshow_zinteger_cmd
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:748
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
cli-utils.h
serial_setbaudrate
int serial_setbaudrate(struct serial *scb, int rate)
Definition: serial.c:516
serial_flush_input
int serial_flush_input(struct serial *scb)
Definition: serial.c:469
serial_ops::write
int(* write)(struct serial *, const void *buf, size_t count)
Definition: serial.h:257
set_parity
static void set_parity(const char *ignore_args, int from_tty, struct cmd_list_element *c)
Definition: serial.c:663
stdio_file_up
std::unique_ptr< stdio_file > stdio_file_up
Definition: ui-file.h:200
serial_send_break
int serial_send_break(struct serial *scb)
Definition: serial.c:475
parity
static const char * parity
Definition: serial.c:658
serial.h
serial_raw
void serial_raw(struct serial *scb)
Definition: serial.c:484
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
serial
Definition: serial.h:224
serial_ops::setstopbits
int(* setstopbits)(struct serial *, int num)
Definition: serial.h:270
serial::buf
unsigned char buf[BUFSIZ]
Definition: serial.h:242
serial_show_cmdlist
static struct cmd_list_element * serial_show_cmdlist
Definition: serial.c:618
_initialize_serial
void _initialize_serial(void)
Definition: serial.c:674
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
serial_ops::open
int(* open)(struct serial *, const char *name)
Definition: serial.h:253
serial_ops::close
void(* close)(struct serial *)
Definition: serial.h:254
cmd_show_list
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:657
serial_close
void serial_close(struct serial *scb)
Definition: serial.c:348
serial_get_tty_state
serial_ttystate serial_get_tty_state(struct serial *scb)
Definition: serial.c:490
serial_open
struct serial * serial_open(const char *name)
Definition: serial.c:204
serial_ops::set_tty_state
int(* set_tty_state)(struct serial *, serial_ttystate)
Definition: serial.h:266
value
Definition: value.c:169
serial_ops::setparity
int(* setparity)(struct serial *, int parity)
Definition: serial.h:273
SERIAL_BREAK
#define SERIAL_BREAK
Definition: serial.c:64
gdb_pipe
int gdb_pipe(int pdes[2])
Definition: ser-go32.c:882
serial::ttystate
serial_ttystate ttystate
Definition: serial.h:238
parity_odd
static const char parity_odd[]
Definition: serial.c:654
serial_ops::get_tty_state
serial_ttystate(* get_tty_state)(struct serial *)
Definition: serial.h:264
serial_copy_tty_state
serial_ttystate serial_copy_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: serial.c:496
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
perror_with_name
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:692
new_serial
static struct serial * new_serial(const struct serial_ops *ops)
Definition: serial.c:183
serial_can_async_p
int serial_can_async_p(struct serial *scb)
Definition: serial.c:536
serial_add_interface
void serial_add_interface(const struct serial_ops *optable)
Definition: serial.c:160
serial_set_cmdlist
static struct cmd_list_element * serial_set_cmdlist
Definition: serial.c:617
XCNEW
#define XCNEW(T)
Definition: poison.h:121
serial_current_type
static int serial_current_type
Definition: serial.c:58
serial_baud_show_cmd
static void serial_baud_show_cmd(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: serial.c:642
serial_flush_output
int serial_flush_output(struct serial *scb)
Definition: serial.c:463
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
serial::fd
int fd
Definition: serial.h:230
serial_parity
int serial_parity
Definition: serial.c:651
serial_ops::async
void(* async)(struct serial *scb, int async_p)
Definition: serial.h:279
serial_event_ftype
void() serial_event_ftype(struct serial *scb, void *context)
Definition: serial.h:208
serial_logchar
static void serial_logchar(struct ui_file *stream, int ch_type, int ch, int timeout)
Definition: serial.c:67
serial_setparity
int serial_setparity(struct serial *scb, int parity)
Definition: serial.c:530
serial_ref
void serial_ref(struct serial *scb)
Definition: serial.c:366
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
all_commands
Definition: command.h:39
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
serial_ttystate
void * serial_ttystate
Definition: serial.h:27
class_maintenance
Definition: command.h:43
serial_readchar
int serial_readchar(struct serial *scb, int timeout)
Definition: serial.c:380
serial::debug_p
int debug_p
Definition: serial.h:244
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
serial_is_open
int serial_is_open(struct serial *scb)
Definition: serial.c:360
serial_ops::go_raw
void(* go_raw)(struct serial *)
Definition: serial.h:263
GDBPARITY_ODD
#define GDBPARITY_ODD
Definition: serial.h:187
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
serial_ops::setbaudrate
int(* setbaudrate)(struct serial *, int rate)
Definition: serial.h:269
serial_ops::drain_output
int(* drain_output)(struct serial *)
Definition: serial.h:275
global_serial_debug_p
static unsigned int global_serial_debug_p
Definition: serial.c:28
class_obscure
Definition: command.h:43
gdbcmd.h
serial::ops
const struct serial_ops * ops
Definition: serial.h:236
do_serial_close
static void do_serial_close(struct serial *scb, int really_close)
Definition: serial.c:308
parity_enums
static const char *const parity_enums[]
Definition: serial.c:656
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
rate
int rate
Definition: ser-unix.c:238