gdb/ser-base.c

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