GDB (xrefs)

/tmp/gdb-8.1/gdb/ser-unix.c
Go to the documentation of this file.
1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
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 "ser-unix.h"
24
25 #include <fcntl.h>
26 #include <sys/types.h>
27 #include "terminal.h"
28 #include <sys/socket.h>
29 #include "gdb_sys_time.h"
30
31 #include "gdb_select.h"
32 #include "gdbcmd.h"
33 #include "filestuff.h"
34 #include <termios.h>
35
36 struct hardwire_ttystate
37 {
38 struct termios termios;
39 };
40
41 #ifdef CRTSCTS
42 /* Boolean to explicitly enable or disable h/w flow control. */
43 static int serial_hwflow;
44 static void
45 show_serial_hwflow (struct ui_file *file, int from_tty,
46 struct cmd_list_element *c, const char *value)
47 {
48 fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
49 }
50 #endif
51
52 static int hardwire_open (struct serial *scb, const char *name);
53 static void hardwire_raw (struct serial *scb);
54 static int rate_to_code (int rate);
55 static int hardwire_setbaudrate (struct serial *scb, int rate);
56 static int hardwire_setparity (struct serial *scb, int parity);
57 static void hardwire_close (struct serial *scb);
58 static int get_tty_state (struct serial *scb,
59 struct hardwire_ttystate * state);
60 static int set_tty_state (struct serial *scb,
61 struct hardwire_ttystate * state);
62 static serial_ttystate hardwire_get_tty_state (struct serial *scb);
63 static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
64 static void hardwire_print_tty_state (struct serial *, serial_ttystate,
65 struct ui_file *);
66 static int hardwire_drain_output (struct serial *);
67 static int hardwire_flush_output (struct serial *);
68 static int hardwire_flush_input (struct serial *);
69 static int hardwire_send_break (struct serial *);
70 static int hardwire_setstopbits (struct serial *, int);
71
72 /* Open up a real live device for serial I/O. */
73
74 static int
75 hardwire_open (struct serial *scb, const char *name)
76 {
77 scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
78 if (scb->fd < 0)
79 return -1;
80
81 return 0;
82 }
83
84 static int
85 get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
86 {
87 if (tcgetattr (scb->fd, &state->termios) < 0)
88 return -1;
89
90 return 0;
91 }
92
93 static int
94 set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
95 {
96 if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
97 return -1;
98
99 return 0;
100 }
101
102 static serial_ttystate
103 hardwire_get_tty_state (struct serial *scb)
104 {
105 struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
106
107 if (get_tty_state (scb, state))
108 {
109 xfree (state);
110 return NULL;
111 }
112
113 return (serial_ttystate) state;
114 }
115
116 static serial_ttystate
117 hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
118 {
119 struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
120
121 *state = *(struct hardwire_ttystate *) ttystate;
122
123 return (serial_ttystate) state;
124 }
125
126 static int
127 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
128 {
129 struct hardwire_ttystate *state;
130
131 state = (struct hardwire_ttystate *) ttystate;
132
133 return set_tty_state (scb, state);
134 }
135
136 static void
137 hardwire_print_tty_state (struct serial *scb,
138 serial_ttystate ttystate,
139 struct ui_file *stream)
140 {
141 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
142 int i;
143
144 fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
145 (int) state->termios.c_iflag,
146 (int) state->termios.c_oflag);
147 fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
148 (int) state->termios.c_cflag,
149 (int) state->termios.c_lflag);
150 #if 0
151 /* This not in POSIX, and is not really documented by those systems
152 which have it (at least not Sun). */
153 fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
154 #endif
155 fprintf_filtered (stream, "c_cc: ");
156 for (i = 0; i < NCCS; i += 1)
157 fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
158 fprintf_filtered (stream, "\n");
159 }
160
161 /* Wait for the output to drain away, as opposed to flushing
162 (discarding) it. */
163
164 static int
165 hardwire_drain_output (struct serial *scb)
166 {
167 return tcdrain (scb->fd);
168 }
169
170 static int
171 hardwire_flush_output (struct serial *scb)
172 {
173 return tcflush (scb->fd, TCOFLUSH);
174 }
175
176 static int
177 hardwire_flush_input (struct serial *scb)
178 {
179 ser_base_flush_input (scb);
180
181 return tcflush (scb->fd, TCIFLUSH);
182 }
183
184 static int
185 hardwire_send_break (struct serial *scb)
186 {
187 return tcsendbreak (scb->fd, 0);
188 }
189
190 static void
191 hardwire_raw (struct serial *scb)
192 {
193 struct hardwire_ttystate state;
194
195 if (get_tty_state (scb, &state))
196 fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
197 safe_strerror (errno));
198
199 state.termios.c_iflag = 0;
200 state.termios.c_oflag = 0;
201 state.termios.c_lflag = 0;
202 state.termios.c_cflag &= ~CSIZE;
203 state.termios.c_cflag |= CLOCAL | CS8;
204 #ifdef CRTSCTS
205 /* h/w flow control. */
206 if (serial_hwflow)
207 state.termios.c_cflag |= CRTSCTS;
208 else
209 state.termios.c_cflag &= ~CRTSCTS;
210 #ifdef CRTS_IFLOW
211 if (serial_hwflow)
212 state.termios.c_cflag |= CRTS_IFLOW;
213 else
214 state.termios.c_cflag &= ~CRTS_IFLOW;
215 #endif
216 #endif
217 state.termios.c_cc[VMIN] = 0;
218 state.termios.c_cc[VTIME] = 0;
219
220 if (set_tty_state (scb, &state))
221 fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
222 safe_strerror (errno));
223 }
224
225 #ifndef B19200
226 #define B19200 EXTA
227 #endif
228
229 #ifndef B38400
230 #define B38400 EXTB
231 #endif
232
233 /* Translate baud rates from integers to damn B_codes. Unix should
234 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
235
236 static struct
237 {
238 int rate;
239 int code;
240 }
241 baudtab[] =
242 {
243 {
244 50, B50
245 }
246 ,
247 {
248 75, B75
249 }
250 ,
251 {
252 110, B110
253 }
254 ,
255 {
256 134, B134
257 }
258 ,
259 {
260 150, B150
261 }
262 ,
263 {
264 200, B200
265 }
266 ,
267 {
268 300, B300
269 }
270 ,
271 {
272 600, B600
273 }
274 ,
275 {
276 1200, B1200
277 }
278 ,
279 {
280 1800, B1800
281 }
282 ,
283 {
284 2400, B2400
285 }
286 ,
287 {
288 4800, B4800
289 }
290 ,
291 {
292 9600, B9600
293 }
294 ,
295 {
296 19200, B19200
297 }
298 ,
299 {
300 38400, B38400
301 }
302 ,
303 #ifdef B57600
304 {
305 57600, B57600
306 }
307 ,
308 #endif
309 #ifdef B115200
310 {
311 115200, B115200
312 }
313 ,
314 #endif
315 #ifdef B230400
316 {
317 230400, B230400
318 }
319 ,
320 #endif
321 #ifdef B460800
322 {
323 460800, B460800
324 }
325 ,
326 #endif
327 {
328 -1, -1
329 }
330 ,
331 };
332
333 static int
334 rate_to_code (int rate)
335 {
336 int i;
337
338 for (i = 0; baudtab[i].rate != -1; i++)
339 {
340 /* test for perfect macth. */
341 if (rate == baudtab[i].rate)
342 return baudtab[i].code;
343 else
344 {
345 /* check if it is in between valid values. */
346 if (rate < baudtab[i].rate)
347 {
348 if (i)
349 {
350 warning (_("Invalid baud rate %d. "
351 "Closest values are %d and %d."),
352 rate, baudtab[i - 1].rate, baudtab[i].rate);
353 }
354 else
355 {
356 warning (_("Invalid baud rate %d. Minimum value is %d."),
357 rate, baudtab[0].rate);
358 }
359 return -1;
360 }
361 }
362 }
363
364 /* The requested speed was too large. */
365 warning (_("Invalid baud rate %d. Maximum value is %d."),
366 rate, baudtab[i - 1].rate);
367 return -1;
368 }
369
370 static int
371 hardwire_setbaudrate (struct serial *scb, int rate)
372 {
373 struct hardwire_ttystate state;
374 int baud_code = rate_to_code (rate);
375
376 if (baud_code < 0)
377 {
378 /* The baud rate was not valid.
379 A warning has already been issued. */
380 errno = EINVAL;
381 return -1;
382 }
383
384 if (get_tty_state (scb, &state))
385 return -1;
386
387 cfsetospeed (&state.termios, baud_code);
388 cfsetispeed (&state.termios, baud_code);
389
390 return set_tty_state (scb, &state);
391 }
392
393 static int
394 hardwire_setstopbits (struct serial *scb, int num)
395 {
396 struct hardwire_ttystate state;
397 int newbit;
398
399 if (get_tty_state (scb, &state))
400 return -1;
401
402 switch (num)
403 {
404 case SERIAL_1_STOPBITS:
405 newbit = 0;
406 break;
407 case SERIAL_1_AND_A_HALF_STOPBITS:
408 case SERIAL_2_STOPBITS:
409 newbit = 1;
410 break;
411 default:
412 return 1;
413 }
414
415 if (!newbit)
416 state.termios.c_cflag &= ~CSTOPB;
417 else
418 state.termios.c_cflag |= CSTOPB; /* two bits */
419
420 return set_tty_state (scb, &state);
421 }
422
423 /* Implement the "setparity" serial_ops callback. */
424
425 static int
426 hardwire_setparity (struct serial *scb, int parity)
427 {
428 struct hardwire_ttystate state;
429 int newparity = 0;
430
431 if (get_tty_state (scb, &state))
432 return -1;
433
434 switch (parity)
435 {
436 case GDBPARITY_NONE:
437 newparity = 0;
438 break;
439 case GDBPARITY_ODD:
440 newparity = PARENB | PARODD;
441 break;
442 case GDBPARITY_EVEN:
443 newparity = PARENB;
444 break;
445 default:
446 internal_warning (__FILE__, __LINE__,
447 "Incorrect parity value: %d", parity);
448 return -1;
449 }
450
451 state.termios.c_cflag &= ~(PARENB | PARODD);
452 state.termios.c_cflag |= newparity;
453
454 return set_tty_state (scb, &state);
455 }
456
457
458 static void
459 hardwire_close (struct serial *scb)
460 {
461 if (scb->fd < 0)
462 return;
463
464 close (scb->fd);
465 scb->fd = -1;
466 }
467
468
469
470 /* The hardwire ops. */
471
472 static const struct serial_ops hardwire_ops =
473 {
474 "hardwire",
475 hardwire_open,
476 hardwire_close,
477 NULL,
478 ser_base_readchar,
479 ser_base_write,
480 hardwire_flush_output,
481 hardwire_flush_input,
482 hardwire_send_break,
483 hardwire_raw,
484 hardwire_get_tty_state,
485 hardwire_copy_tty_state,
486 hardwire_set_tty_state,
487 hardwire_print_tty_state,
488 hardwire_setbaudrate,
489 hardwire_setstopbits,
490 hardwire_setparity,
491 hardwire_drain_output,
492 ser_base_async,
493 ser_unix_read_prim,
494 ser_unix_write_prim
495 };
496
497 void
498 _initialize_ser_hardwire (void)
499 {
500 serial_add_interface (&hardwire_ops);
501
502 #ifdef CRTSCTS
503 add_setshow_boolean_cmd ("remoteflow", no_class,
504 &serial_hwflow, _("\
505 Set use of hardware flow control for remote serial I/O."), _("\
506 Show use of hardware flow control for remote serial I/O."), _("\
507 Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
508 when debugging using remote targets."),
509 NULL,
510 show_serial_hwflow,
511 &setlist, &showlist);
512 #endif
513 }
514
515 int
516 ser_unix_read_prim (struct serial *scb, size_t count)
517 {
518 return read (scb->fd, scb->buf, count);
519 }
520
521 int
522 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
523 {
524 return write (scb->fd, buf, len);
525 }
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
hardwire_close
static void hardwire_close(struct serial *scb)
Definition: ser-unix.c:459
GDBPARITY_EVEN
#define GDBPARITY_EVEN
Definition: serial.h:188
hardwire_setstopbits
static int hardwire_setstopbits(struct serial *, int)
Definition: ser-unix.c:394
set_tty_state
static int set_tty_state(struct serial *scb, struct hardwire_ttystate *state)
Definition: ser-unix.c:94
xfree
void xfree(void *)
no_class
Definition: command.h:41
hardwire_drain_output
static int hardwire_drain_output(struct serial *)
Definition: ser-unix.c:165
cmd_list_element
Definition: cli-decode.h:46
warning
void warning(const char *fmt,...)
Definition: errors.c:26
hardwire_ttystate
Definition: ser-unix.c:36
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
ser_unix_write_prim
int ser_unix_write_prim(struct serial *scb, const void *buf, size_t len)
Definition: ser-unix.c:522
defs.h
hardwire_get_tty_state
static serial_ttystate hardwire_get_tty_state(struct serial *scb)
Definition: ser-unix.c:103
ser-unix.h
serial_ops
Definition: serial.h:250
terminal.h
ser_unix_read_prim
int ser_unix_read_prim(struct serial *scb, size_t count)
Definition: ser-unix.c:516
XNEW
#define XNEW(T)
Definition: poison.h:109
hardwire_copy_tty_state
static serial_ttystate hardwire_copy_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-unix.c:117
ser_base_async
void ser_base_async(struct serial *scb, int async_p)
Definition: ser-base.c:586
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
hardwire_setbaudrate
static int hardwire_setbaudrate(struct serial *scb, int rate)
Definition: ser-unix.c:371
GDBPARITY_NONE
#define GDBPARITY_NONE
Definition: serial.h:186
hardwire_setparity
static int hardwire_setparity(struct serial *scb, int parity)
Definition: ser-unix.c:426
hardwire_ttystate::termios
struct termios termios
Definition: ser-unix.c:38
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
hardwire_flush_output
static int hardwire_flush_output(struct serial *)
Definition: ser-unix.c:171
B38400
#define B38400
Definition: ser-unix.c:230
gdb_sys_time.h
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
hardwire_send_break
static int hardwire_send_break(struct serial *)
Definition: ser-unix.c:185
serial_ops::write
int(* write)(struct serial *, const void *buf, size_t count)
Definition: serial.h:257
parity
static const char * parity
Definition: serial.c:658
serial.h
serial
Definition: serial.h:224
hardwire_ops
static const struct serial_ops hardwire_ops
Definition: ser-unix.c:472
hardwire_set_tty_state
static int hardwire_set_tty_state(struct serial *scb, serial_ttystate state)
Definition: ser-unix.c:127
serial::buf
unsigned char buf[BUFSIZ]
Definition: serial.h:242
hardwire_open
static int hardwire_open(struct serial *scb, const char *name)
Definition: ser-unix.c:75
value
Definition: value.c:169
gdb_select.h
SERIAL_1_AND_A_HALF_STOPBITS
#define SERIAL_1_AND_A_HALF_STOPBITS
Definition: serial.h:181
hardwire_flush_input
static int hardwire_flush_input(struct serial *)
Definition: ser-unix.c:177
SERIAL_1_STOPBITS
#define SERIAL_1_STOPBITS
Definition: serial.h:180
SERIAL_2_STOPBITS
#define SERIAL_2_STOPBITS
Definition: serial.h:182
serial_add_interface
void serial_add_interface(const struct serial_ops *optable)
Definition: serial.c:160
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
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
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
add_setshow_boolean_cmd
void add_setshow_boolean_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:569
serial::fd
int fd
Definition: serial.h:230
code
int code
Definition: ser-unix.c:239
ser_base_write
int ser_base_write(struct serial *scb, const void *buf, size_t count)
Definition: ser-base.c:474
gdb_open_cloexec
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:283
_initialize_ser_hardwire
void _initialize_ser_hardwire(void)
Definition: ser-unix.c:498
ser-base.h
serial_ttystate
void * serial_ttystate
Definition: serial.h:27
baudtab
static struct @162 baudtab[]
B19200
#define B19200
Definition: ser-unix.c:226
filestuff.h
GDBPARITY_ODD
#define GDBPARITY_ODD
Definition: serial.h:187
hardwire_print_tty_state
static void hardwire_print_tty_state(struct serial *, serial_ttystate, struct ui_file *)
Definition: ser-unix.c:137
internal_warning
void internal_warning(const char *file, int line, const char *fmt,...)
Definition: errors.c:62
gdbcmd.h
hardwire_raw
static void hardwire_raw(struct serial *scb)
Definition: ser-unix.c:191
get_tty_state
static int get_tty_state(struct serial *scb, struct hardwire_ttystate *state)
Definition: ser-unix.c:85
rate_to_code
static int rate_to_code(int rate)
Definition: ser-unix.c:334
rate
int rate
Definition: ser-unix.c:238