gdb/ser-base.c

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