gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2
   3    Copyright (C) 1992-2024 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 "serial.h"
  21 #include "ser-base.h"
  22 #include "ser-unix.h"
  23
  24 #include <fcntl.h>
  25 #include <sys/types.h>
  26 #include "terminal.h"
  27 #include <sys/socket.h>
  28 #include "gdbsupport/gdb_sys_time.h"
  29
  30 #include "gdbsupport/gdb_select.h"
  31 #include "cli/cli-cmds.h"
  32 #include "gdbsupport/filestuff.h"
  33 #include <termios.h>
  34 #include "gdbsupport/scoped_ignore_sigttou.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 bool 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   gdb_printf (file, _("Hardware flow control is %s.\n"), value);
  49 }
  50 #endif
  51
  52 static void hardwire_raw (struct serial *scb);
  53 static int rate_to_code (int rate);
  54 static void hardwire_setbaudrate (struct serial *scb, int rate);
  55 static int hardwire_setparity (struct serial *scb, int parity);
  56 static void hardwire_close (struct serial *scb);
  57 static int get_tty_state (struct serial *scb,
  58                           struct hardwire_ttystate * state);
  59 static int set_tty_state (struct serial *scb,
  60                           struct hardwire_ttystate * state);
  61 static serial_ttystate hardwire_get_tty_state (struct serial *scb);
  62 static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
  63 static void hardwire_print_tty_state (struct serial *, serial_ttystate,
  64                                       struct ui_file *);
  65 static int hardwire_drain_output (struct serial *);
  66 static int hardwire_flush_output (struct serial *);
  67 static int hardwire_flush_input (struct serial *);
  68 static void hardwire_send_break (struct serial *);
  69 static int hardwire_setstopbits (struct serial *, int);
  70
  71 /* Open up a real live device for serial I/O.  */
  72
  73 static void
  74 hardwire_open (struct serial *scb, const char *name)
  75 {
  76   scb->fd = gdb_open_cloexec (name, O_RDWR, 0).release ();
  77   if (scb->fd < 0)
  78     perror_with_name ("could not open device");
  79 }
  80
  81 static int
  82 get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
  83 {
  84   if (tcgetattr (scb->fd, &state->termios) < 0)
  85     return -1;
  86
  87   return 0;
  88 }
  89
  90 static int
  91 set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
  92 {
  93   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
  94     return -1;
  95
  96   return 0;
  97 }
  98
  99 static serial_ttystate
 100 hardwire_get_tty_state (struct serial *scb)
 101 {
 102   struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
 103
 104   if (get_tty_state (scb, state))
 105     {
 106       xfree (state);
 107       return NULL;
 108     }
 109
 110   return (serial_ttystate) state;
 111 }
 112
 113 static serial_ttystate
 114 hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
 115 {
 116   struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
 117
 118   *state = *(struct hardwire_ttystate *) ttystate;
 119
 120   return (serial_ttystate) state;
 121 }
 122
 123 static int
 124 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 125 {
 126   struct hardwire_ttystate *state;
 127
 128   state = (struct hardwire_ttystate *) ttystate;
 129
 130   return set_tty_state (scb, state);
 131 }
 132
 133 static void
 134 hardwire_print_tty_state (struct serial *scb,
 135                           serial_ttystate ttystate,
 136                           struct ui_file *stream)
 137 {
 138   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
 139   int i;
 140
 141   gdb_printf (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 142               (int) state->termios.c_iflag,
 143               (int) state->termios.c_oflag);
 144   gdb_printf (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
 145               (int) state->termios.c_cflag,
 146               (int) state->termios.c_lflag);
 147 #if 0
 148   /* This not in POSIX, and is not really documented by those systems
 149      which have it (at least not Sun).  */
 150   gdb_printf (stream, "c_line = 0x%x.\n", state->termios.c_line);
 151 #endif
 152   gdb_printf (stream, "c_cc: ");
 153   for (i = 0; i < NCCS; i += 1)
 154     gdb_printf (stream, "0x%x ", state->termios.c_cc[i]);
 155   gdb_printf (stream, "\n");
 156 }
 157
 158 /* Wait for the output to drain away, as opposed to flushing
 159    (discarding) it.  */
 160
 161 static int
 162 hardwire_drain_output (struct serial *scb)
 163 {
 164   /* Ignore SIGTTOU which may occur during the drain.  */
 165   scoped_ignore_sigttou ignore_sigttou;
 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 void
 185 hardwire_send_break (struct serial *scb)
 186 {
 187   if (tcsendbreak (scb->fd, 0) == -1)
 188     perror_with_name ("sending break");
 189 }
 190
 191 static void
 192 hardwire_raw (struct serial *scb)
 193 {
 194   struct hardwire_ttystate state;
 195
 196   if (get_tty_state (scb, &state))
 197     gdb_printf (gdb_stderr, "get_tty_state failed: %s\n",
 198                 safe_strerror (errno));
 199
 200   state.termios.c_iflag = 0;
 201   state.termios.c_oflag = 0;
 202   state.termios.c_lflag = 0;
 203   state.termios.c_cflag &= ~CSIZE;
 204   state.termios.c_cflag |= CLOCAL | CS8;
 205 #ifdef CRTSCTS
 206   /* h/w flow control.  */
 207   if (serial_hwflow)
 208     state.termios.c_cflag |= CRTSCTS;
 209   else
 210     state.termios.c_cflag &= ~CRTSCTS;
 211 #ifdef CRTS_IFLOW
 212   if (serial_hwflow)
 213     state.termios.c_cflag |= CRTS_IFLOW;
 214   else
 215     state.termios.c_cflag &= ~CRTS_IFLOW;
 216 #endif
 217 #endif
 218   state.termios.c_cc[VMIN] = 0;
 219   state.termios.c_cc[VTIME] = 0;
 220
 221   if (set_tty_state (scb, &state))
 222     gdb_printf (gdb_stderr, "set_tty_state failed: %s\n",
 223                 safe_strerror (errno));
 224 }
 225
 226 #ifndef B19200
 227 #define B19200 EXTA
 228 #endif
 229
 230 #ifndef B38400
 231 #define B38400 EXTB
 232 #endif
 233
 234 /* Translate baud rates from integers to damn B_codes.  Unix should
 235    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 236
 237 static struct
 238 {
 239   int rate;
 240   int code;
 241 }
 242 baudtab[] =
 243 {
 244   {
 245     50, B50
 246   }
 247   ,
 248   {
 249     75, B75
 250   }
 251   ,
 252   {
 253     110, B110
 254   }
 255   ,
 256   {
 257     134, B134
 258   }
 259   ,
 260   {
 261     150, B150
 262   }
 263   ,
 264   {
 265     200, B200
 266   }
 267   ,
 268   {
 269     300, B300
 270   }
 271   ,
 272   {
 273     600, B600
 274   }
 275   ,
 276   {
 277     1200, B1200
 278   }
 279   ,
 280   {
 281     1800, B1800
 282   }
 283   ,
 284   {
 285     2400, B2400
 286   }
 287   ,
 288   {
 289     4800, B4800
 290   }
 291   ,
 292   {
 293     9600, B9600
 294   }
 295   ,
 296   {
 297     19200, B19200
 298   }
 299   ,
 300   {
 301     38400, B38400
 302   }
 303   ,
 304 #ifdef B57600
 305   {
 306     57600, B57600
 307   }
 308   ,
 309 #endif
 310 #ifdef B115200
 311   {
 312     115200, B115200
 313   }
 314   ,
 315 #endif
 316 #ifdef B230400
 317   {
 318     230400, B230400
 319   }
 320   ,
 321 #endif
 322 #ifdef B460800
 323   {
 324     460800, B460800
 325   }
 326   ,
 327 #endif
 328 #ifdef B500000
 329   {
 330     500000, B500000
 331   }
 332   ,
 333 #endif
 334 #ifdef B576000
 335   {
 336     576000, B576000
 337   }
 338   ,
 339 #endif
 340 #ifdef B921600
 341   {
 342     921600, B921600
 343   }
 344   ,
 345 #endif
 346 #ifdef B1000000
 347   {
 348     1000000, B1000000
 349   }
 350   ,
 351 #endif
 352 #ifdef B1152000
 353   {
 354     1152000, B1152000
 355   }
 356   ,
 357 #endif
 358 #ifdef B1500000
 359   {
 360     1500000, B1500000
 361   }
 362   ,
 363 #endif
 364 #ifdef B2000000
 365   {
 366     2000000, B2000000
 367   }
 368   ,
 369 #endif
 370 #ifdef B2500000
 371   {
 372     2500000, B2500000
 373   }
 374   ,
 375 #endif
 376 #ifdef B3000000
 377   {
 378     3000000, B3000000
 379   }
 380   ,
 381 #endif
 382 #ifdef B3500000
 383   {
 384     3500000, B3500000
 385   }
 386   ,
 387 #endif
 388 #ifdef B4000000
 389   {
 390     4000000, B4000000
 391   }
 392   ,
 393 #endif
 394   {
 395     -1, -1
 396   }
 397   ,
 398 };
 399
 400 static int
 401 rate_to_code (int rate)
 402 {
 403   int i;
 404
 405   for (i = 0; baudtab[i].rate != -1; i++)
 406     {
 407       /* test for perfect macth.  */
 408       if (rate == baudtab[i].rate)
 409         return baudtab[i].code;
 410       else
 411         {
 412           /* check if it is in between valid values.  */
 413           if (rate < baudtab[i].rate)
 414             {
 415               if (i)
 416                 {
 417                   error (_("Invalid baud rate %d.  "
 418                            "Closest values are %d and %d."),
 419                          rate, baudtab[i - 1].rate, baudtab[i].rate);
 420                 }
 421               else
 422                 {
 423                   error (_("Invalid baud rate %d.  Minimum value is %d."),
 424                          rate, baudtab[0].rate);
 425                 }
 426             }
 427         }
 428     }
 429
 430   /* The requested speed was too large.  */
 431   error (_("Invalid baud rate %d.  Maximum value is %d."),
 432          rate, baudtab[i - 1].rate);
 433 }
 434
 435 static void
 436 hardwire_setbaudrate (struct serial *scb, int rate)
 437 {
 438   struct hardwire_ttystate state;
 439   int baud_code = rate_to_code (rate);
 440
 441   if (get_tty_state (scb, &state))
 442     perror_with_name ("could not get tty state");
 443
 444   cfsetospeed (&state.termios, baud_code);
 445   cfsetispeed (&state.termios, baud_code);
 446
 447   if (set_tty_state (scb, &state))
 448     perror_with_name ("could not set tty state");
 449 }
 450
 451 static int
 452 hardwire_setstopbits (struct serial *scb, int num)
 453 {
 454   struct hardwire_ttystate state;
 455   int newbit;
 456
 457   if (get_tty_state (scb, &state))
 458     return -1;
 459
 460   switch (num)
 461     {
 462     case SERIAL_1_STOPBITS:
 463       newbit = 0;
 464       break;
 465     case SERIAL_1_AND_A_HALF_STOPBITS:
 466     case SERIAL_2_STOPBITS:
 467       newbit = 1;
 468       break;
 469     default:
 470       return 1;
 471     }
 472
 473   if (!newbit)
 474     state.termios.c_cflag &= ~CSTOPB;
 475   else
 476     state.termios.c_cflag |= CSTOPB;    /* two bits */
 477
 478   return set_tty_state (scb, &state);
 479 }
 480
 481 /* Implement the "setparity" serial_ops callback.  */
 482
 483 static int
 484 hardwire_setparity (struct serial *scb, int parity)
 485 {
 486   struct hardwire_ttystate state;
 487   int newparity = 0;
 488
 489   if (get_tty_state (scb, &state))
 490     return -1;
 491
 492   switch (parity)
 493     {
 494     case GDBPARITY_NONE:
 495       newparity = 0;
 496       break;
 497     case GDBPARITY_ODD:
 498       newparity = PARENB | PARODD;
 499       break;
 500     case GDBPARITY_EVEN:
 501       newparity = PARENB;
 502       break;
 503     default:
 504       internal_warning ("Incorrect parity value: %d", parity);
 505       return -1;
 506     }
 507
 508   state.termios.c_cflag &= ~(PARENB | PARODD);
 509   state.termios.c_cflag |= newparity;
 510
 511   return set_tty_state (scb, &state);
 512 }
 513
 514
 515 static void
 516 hardwire_close (struct serial *scb)
 517 {
 518   if (scb->fd < 0)
 519     return;
 520
 521   close (scb->fd);
 522   scb->fd = -1;
 523 }
 524 \f
 525 \f
 526
 527 /* The hardwire ops.  */
 528
 529 static const struct serial_ops hardwire_ops =
 530 {
 531   "hardwire",
 532   hardwire_open,
 533   hardwire_close,
 534   NULL,
 535   ser_base_readchar,
 536   ser_base_write,
 537   hardwire_flush_output,
 538   hardwire_flush_input,
 539   hardwire_send_break,
 540   hardwire_raw,
 541   hardwire_get_tty_state,
 542   hardwire_copy_tty_state,
 543   hardwire_set_tty_state,
 544   hardwire_print_tty_state,
 545   hardwire_setbaudrate,
 546   hardwire_setstopbits,
 547   hardwire_setparity,
 548   hardwire_drain_output,
 549   ser_base_async,
 550   ser_unix_read_prim,
 551   ser_unix_write_prim
 552 };
 553
 554 void _initialize_ser_hardwire ();
 555 void
 556 _initialize_ser_hardwire ()
 557 {
 558   serial_add_interface (&hardwire_ops);
 559
 560 #ifdef CRTSCTS
 561   add_setshow_boolean_cmd ("remoteflow", no_class,
 562                            &serial_hwflow, _("\
 563 Set use of hardware flow control for remote serial I/O."), _("\
 564 Show use of hardware flow control for remote serial I/O."), _("\
 565 Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
 566 when debugging using remote targets."),
 567                            NULL,
 568                            show_serial_hwflow,
 569                            &setlist, &showlist);
 570 #endif
 571 }
 572
 573 int
 574 ser_unix_read_prim (struct serial *scb, size_t count)
 575 {
 576   int result = read (scb->fd, scb->buf, count);
 577   if (result == -1 && errno != EINTR)
 578     perror_with_name ("error while reading");
 579   return result;
 580 }
 581
 582 int
 583 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
 584 {
 585   int result = write (scb->fd, buf, len);
 586   if (result == -1 && errno != EINTR)
 587     perror_with_name ("error while writing");
 588   return result;
 589 }