1 /* Generic serial interface routines
3 Copyright (C) 1992-2013 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 "gdb_string.h"
25 #include "cli/cli-utils.h"
27 extern void _initialize_serial (void);
29 /* Is serial being debugged? */
31 static unsigned int global_serial_debug_p
;
33 /* Linked list of serial I/O handlers. */
35 static struct serial_ops
*serial_ops_list
= NULL
;
37 /* Pointer to list of scb's. */
39 static struct serial
*scb_base
;
41 /* Non-NULL gives filename which contains a recording of the remote session,
42 suitable for playback by gdbserver. */
44 static char *serial_logfile
= NULL
;
45 static struct ui_file
*serial_logfp
= NULL
;
47 static 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
;
58 static int serial_current_type
= 0;
60 /* Log char CH of type CHTYPE, with TIMEOUT. */
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
67 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
69 if (ch_type
!= serial_current_type
)
71 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
72 serial_current_type
= ch_type
;
75 if (serial_logbase
!= logbase_ascii
)
76 fputc_unfiltered (' ', stream
);
81 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
84 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
87 fputs_unfiltered ("<Eof>", stream
);
90 fputs_unfiltered ("<Break>", stream
);
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);
101 fputs_unfiltered ("\\\\", stream
);
104 fputs_unfiltered ("\\b", stream
);
107 fputs_unfiltered ("\\f", stream
);
110 fputs_unfiltered ("\\n", stream
);
113 fputs_unfiltered ("\\r", stream
);
116 fputs_unfiltered ("\\t", stream
);
119 fputs_unfiltered ("\\v", stream
);
122 fprintf_unfiltered (stream
,
123 isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
130 serial_log_command (const char *cmd
)
135 serial_current_type
= 'c';
137 fputs_unfiltered ("\nc ", serial_logfp
);
138 fputs_unfiltered (cmd
, serial_logfp
);
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
);
146 static struct serial_ops
*
147 serial_interface_lookup (const char *name
)
149 struct serial_ops
*ops
;
151 for (ops
= serial_ops_list
; ops
; ops
= ops
->next
)
152 if (strcmp (name
, ops
->name
) == 0)
159 serial_add_interface (struct serial_ops
*optable
)
161 optable
->next
= serial_ops_list
;
162 serial_ops_list
= optable
;
165 /* Return the open serial device for FD, if found, or NULL if FD is
166 not already opened. */
169 serial_for_fd (int fd
)
173 for (scb
= scb_base
; scb
; scb
= scb
->next
)
180 /* Open up a device or a network socket, depending upon the syntax of NAME. */
183 serial_open (const char *name
)
186 struct serial_ops
*ops
;
187 const char *open_name
= name
;
189 if (strcmp (name
, "pc") == 0)
190 ops
= serial_interface_lookup ("pc");
191 else if (strncmp (name
, "lpt", 3) == 0)
192 ops
= serial_interface_lookup ("parallel");
193 else if (strncmp (name
, "|", 1) == 0)
195 ops
= serial_interface_lookup ("pipe");
196 /* Discard ``|'' and any space before the command itself. */
198 open_name
= skip_spaces_const (open_name
);
200 /* Check for a colon, suggesting an IP address/port pair.
201 Do this *after* checking for all the interesting prefixes. We
202 don't want to constrain the syntax of what can follow them. */
203 else if (strchr (name
, ':'))
204 ops
= serial_interface_lookup ("tcp");
206 ops
= serial_interface_lookup ("hardwire");
211 scb
= XMALLOC (struct serial
);
216 scb
->bufp
= scb
->buf
;
220 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
221 if ((*scb
->ops
->open
) (scb
, open_name
))
227 scb
->name
= xstrdup (name
);
228 scb
->next
= scb_base
;
230 scb
->async_state
= 0;
231 scb
->async_handler
= NULL
;
232 scb
->async_context
= NULL
;
235 if (serial_logfile
!= NULL
)
237 serial_logfp
= gdb_fopen (serial_logfile
, "w");
238 if (serial_logfp
== NULL
)
239 perror_with_name (serial_logfile
);
245 /* Open a new serial stream using a file handle, using serial
246 interface ops OPS. */
248 static struct serial
*
249 serial_fdopen_ops (const int fd
, struct serial_ops
*ops
)
255 ops
= serial_interface_lookup ("terminal");
257 ops
= serial_interface_lookup ("hardwire");
263 scb
= XCALLOC (1, struct serial
);
268 scb
->bufp
= scb
->buf
;
273 scb
->next
= scb_base
;
275 scb
->async_state
= 0;
276 scb
->async_handler
= NULL
;
277 scb
->async_context
= NULL
;
280 if ((ops
->fdopen
) != NULL
)
281 (*ops
->fdopen
) (scb
, fd
);
289 serial_fdopen (const int fd
)
291 return serial_fdopen_ops (fd
, NULL
);
295 do_serial_close (struct serial
*scb
, int really_close
)
297 struct serial
*tmp_scb
;
301 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
302 serial_current_type
= 0;
304 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
305 ui_file_delete (serial_logfp
);
309 /* ensure that the FD has been taken out of async mode. */
310 if (scb
->async_handler
!= NULL
)
311 serial_async (scb
, NULL
, NULL
);
314 scb
->ops
->close (scb
);
319 /* For serial_is_open. */
323 scb_base
= scb_base
->next
;
325 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
327 if (tmp_scb
->next
!= scb
)
330 tmp_scb
->next
= tmp_scb
->next
->next
;
338 serial_close (struct serial
*scb
)
340 do_serial_close (scb
, 1);
344 serial_un_fdopen (struct serial
*scb
)
346 do_serial_close (scb
, 0);
350 serial_is_open (struct serial
*scb
)
352 return scb
->bufp
!= NULL
;
356 serial_ref (struct serial
*scb
)
362 serial_unref (struct serial
*scb
)
365 if (scb
->refcnt
== 0)
370 serial_readchar (struct serial
*scb
, int timeout
)
374 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
376 if (0 && serial_is_async_p (scb
) && timeout
< 0)
377 internal_error (__FILE__
, __LINE__
,
378 _("serial_readchar: blocking read in async mode"));
380 ch
= scb
->ops
->readchar (scb
, timeout
);
381 if (serial_logfp
!= NULL
)
383 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
385 /* Make sure that the log file is as up-to-date as possible,
386 in case we are getting ready to dump core or something. */
387 gdb_flush (serial_logfp
);
389 if (serial_debug_p (scb
))
391 fprintf_unfiltered (gdb_stdlog
, "[");
392 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
393 fprintf_unfiltered (gdb_stdlog
, "]");
394 gdb_flush (gdb_stdlog
);
401 serial_write (struct serial
*scb
, const void *buf
, size_t count
)
403 if (serial_logfp
!= NULL
)
405 const char *str
= buf
;
408 for (c
= 0; c
< count
; c
++)
409 serial_logchar (serial_logfp
, 'w', str
[c
] & 0xff, 0);
411 /* Make sure that the log file is as up-to-date as possible,
412 in case we are getting ready to dump core or something. */
413 gdb_flush (serial_logfp
);
415 if (serial_debug_p (scb
))
417 const char *str
= buf
;
420 for (c
= 0; c
< count
; c
++)
422 fprintf_unfiltered (gdb_stdlog
, "[");
423 serial_logchar (gdb_stdlog
, 'w', str
[count
] & 0xff, 0);
424 fprintf_unfiltered (gdb_stdlog
, "]");
426 gdb_flush (gdb_stdlog
);
429 return (scb
->ops
->write (scb
, buf
, count
));
433 serial_printf (struct serial
*desc
, const char *format
,...)
437 va_start (args
, format
);
439 buf
= xstrvprintf (format
, args
);
440 serial_write (desc
, buf
, strlen (buf
));
447 serial_drain_output (struct serial
*scb
)
449 return scb
->ops
->drain_output (scb
);
453 serial_flush_output (struct serial
*scb
)
455 return scb
->ops
->flush_output (scb
);
459 serial_flush_input (struct serial
*scb
)
461 return scb
->ops
->flush_input (scb
);
465 serial_send_break (struct serial
*scb
)
467 if (serial_logfp
!= NULL
)
468 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
470 return (scb
->ops
->send_break (scb
));
474 serial_raw (struct serial
*scb
)
476 scb
->ops
->go_raw (scb
);
480 serial_get_tty_state (struct serial
*scb
)
482 return scb
->ops
->get_tty_state (scb
);
486 serial_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
488 return scb
->ops
->copy_tty_state (scb
, ttystate
);
492 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
494 return scb
->ops
->set_tty_state (scb
, ttystate
);
498 serial_print_tty_state (struct serial
*scb
,
499 serial_ttystate ttystate
,
500 struct ui_file
*stream
)
502 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
506 serial_noflush_set_tty_state (struct serial
*scb
,
507 serial_ttystate new_ttystate
,
508 serial_ttystate old_ttystate
)
510 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
514 serial_setbaudrate (struct serial
*scb
, int rate
)
516 return scb
->ops
->setbaudrate (scb
, rate
);
520 serial_setstopbits (struct serial
*scb
, int num
)
522 return scb
->ops
->setstopbits (scb
, num
);
526 serial_can_async_p (struct serial
*scb
)
528 return (scb
->ops
->async
!= NULL
);
532 serial_is_async_p (struct serial
*scb
)
534 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
538 serial_async (struct serial
*scb
,
539 serial_event_ftype
*handler
,
542 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
544 scb
->async_handler
= handler
;
545 scb
->async_context
= context
;
546 /* Only change mode if there is a need. */
548 scb
->ops
->async (scb
, handler
!= NULL
);
552 serial_debug (struct serial
*scb
, int debug_p
)
554 scb
->debug_p
= debug_p
;
558 serial_debug_p (struct serial
*scb
)
560 return scb
->debug_p
|| global_serial_debug_p
;
565 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
567 if (scb
->ops
->wait_handle
)
568 scb
->ops
->wait_handle (scb
, read
, except
);
571 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
577 serial_done_wait_handle (struct serial
*scb
)
579 if (scb
->ops
->done_wait_handle
)
580 scb
->ops
->done_wait_handle (scb
);
585 serial_pipe (struct serial
*scbs
[2])
587 struct serial_ops
*ops
;
590 ops
= serial_interface_lookup ("pipe");
597 if (gdb_pipe (fildes
) == -1)
600 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
601 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
605 /* Serial set/show framework. */
607 static struct cmd_list_element
*serial_set_cmdlist
;
608 static struct cmd_list_element
*serial_show_cmdlist
;
611 serial_set_cmd (char *args
, int from_tty
)
613 printf_unfiltered ("\"set serial\" must be followed "
614 "by the name of a command.\n");
615 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
619 serial_show_cmd (char *args
, int from_tty
)
621 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
624 /* Baud rate specified for talking to serial target systems. Default
625 is left as -1, so targets can choose their own defaults. */
626 /* FIXME: This means that "show serial baud" and gr_files_info can
627 print -1 or (unsigned int)-1. This is a Bad User Interface. */
632 serial_baud_show_cmd (struct ui_file
*file
, int from_tty
,
633 struct cmd_list_element
*c
, const char *value
)
635 fprintf_filtered (file
, _("Baud rate for remote serial I/O is %s.\n"),
640 _initialize_serial (void)
643 add_com ("connect", class_obscure
, connect_command
, _("\
644 Connect the terminal directly up to the command monitor.\n\
645 Use <CR>~. or <CR>~^D to break out."));
648 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
649 Set default serial/parallel port configuration."),
650 &serial_set_cmdlist
, "set serial ",
654 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
655 Show default serial/parallel port configuration."),
656 &serial_show_cmdlist
, "show serial ",
660 /* If target is open when baud changes, it doesn't take effect until
661 the next open (I think, not sure). */
662 add_setshow_zinteger_cmd ("baud", no_class
, &baud_rate
, _("\
663 Set baud rate for remote serial I/O."), _("\
664 Show baud rate for remote serial I/O."), _("\
665 This value is used to set the speed of the serial port when debugging\n\
666 using remote targets."),
668 serial_baud_show_cmd
,
669 &serial_set_cmdlist
, &serial_show_cmdlist
);
671 /* The commands "set/show serial baud" used to have a different name.
672 Add aliases to those names to facilitate the transition, and mark
673 them as deprecated, in order to make users aware of the fact that
674 the command names have been changed. */
676 const char *cmd_name
;
677 struct cmd_list_element
*cmd
;
679 /* FIXME: There is a limitation in the deprecation mechanism,
680 and the warning ends up not being displayed for prefixed
681 aliases. So use a real command instead of an alias. */
682 add_setshow_zinteger_cmd ("remotebaud", class_alias
, &baud_rate
, _("\
683 Set baud rate for remote serial I/O."), _("\
684 Show baud rate for remote serial I/O."), _("\
685 This value is used to set the speed of the serial port when debugging\n\
686 using remote targets."),
688 serial_baud_show_cmd
,
689 &setlist
, &showlist
);
690 cmd_name
= "remotebaud";
691 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
692 deprecate_cmd (cmd
, "set serial baud");
694 = "remotebaud"; /* needed because lookup_cmd updates the pointer */
695 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
696 deprecate_cmd (cmd
, "show serial baud");
699 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
700 Set filename for remote session recording."), _("\
701 Show filename for remote session recording."), _("\
702 This file is used to record the remote session for future playback\n\
705 NULL
, /* FIXME: i18n: */
706 &setlist
, &showlist
);
708 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
709 &serial_logbase
, _("\
710 Set numerical base for remote session logging"), _("\
711 Show numerical base for remote session logging"), NULL
,
713 NULL
, /* FIXME: i18n: */
714 &setlist
, &showlist
);
716 add_setshow_zuinteger_cmd ("serial", class_maintenance
,
717 &global_serial_debug_p
, _("\
718 Set serial debugging."), _("\
719 Show serial debugging."), _("\
720 When non-zero, serial port debugging is enabled."),
722 NULL
, /* FIXME: i18n: */
723 &setdebuglist
, &showdebuglist
);