gdb/ser-base.c

   1 /* Generic serial interface functions.
   2
   3    Copyright (C) 1992-2017 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               close (scb->error_fd);
 292               scb->error_fd = -1;
 293               break;
 294             }
 295
 296           /* In theory, embedded newlines are not a problem.
 297              But for MI, we want each output line to have just
 298              one newline for legibility.  So output things
 299              in newline chunks.  */
 300           gdb_assert (s > 0 && s <= GDB_MI_MSG_WIDTH);
 301           buf[s] = '\0';
 302           current = buf;
 303           while ((newline = strstr (current, "\n")) != NULL)
 304             {
 305               *newline = '\0';
 306               fputs_unfiltered (current, gdb_stderr);
 307               fputs_unfiltered ("\n", gdb_stderr);
 308               current = newline + 1;
 309             }
 310
 311           fputs_unfiltered (current, gdb_stderr);
 312        }
 313     }
 314 }
 315
 316 /* Read a character with user-specified timeout.  TIMEOUT is number of
 317    seconds to wait, or -1 to wait forever.  Use timeout of 0 to effect
 318    a poll.  Returns char if successful.  Returns SERIAL_TIMEOUT if
 319    timeout expired, SERIAL_EOF if line dropped dead, or SERIAL_ERROR
 320    for any other error (see errno in that case).  */
 321
 322 static int
 323 do_ser_base_readchar (struct serial *scb, int timeout)
 324 {
 325   int status;
 326   int delta;
 327
 328   /* We have to be able to keep the GUI alive here, so we break the
 329      original timeout into steps of 1 second, running the "keep the
 330      GUI alive" hook each time through the loop.
 331
 332      Also, timeout = 0 means to poll, so we just set the delta to 0,
 333      so we will only go through the loop once.  */
 334
 335   delta = (timeout == 0 ? 0 : 1);
 336   while (1)
 337     {
 338       /* N.B. The UI may destroy our world (for instance by calling
 339          remote_stop,) in which case we want to get out of here as
 340          quickly as possible.  It is not safe to touch scb, since
 341          someone else might have freed it.  The
 342          deprecated_ui_loop_hook signals that we should exit by
 343          returning 1.  */
 344
 345       if (deprecated_ui_loop_hook)
 346         {
 347           if (deprecated_ui_loop_hook (0))
 348             return SERIAL_TIMEOUT;
 349         }
 350
 351       status = ser_base_wait_for (scb, delta);
 352       if (timeout > 0)
 353         timeout -= delta;
 354
 355       /* If we got a character or an error back from wait_for, then we can
 356          break from the loop before the timeout is completed.  */
 357       if (status != SERIAL_TIMEOUT)
 358         break;
 359
 360       /* If we have exhausted the original timeout, then generate
 361          a SERIAL_TIMEOUT, and pass it out of the loop.  */
 362       else if (timeout == 0)
 363         {
 364           status = SERIAL_TIMEOUT;
 365           break;
 366         }
 367
 368       /* We also need to check and consume the stderr because it could
 369          come before the stdout for some stubs.  If we just sit and wait
 370          for stdout, we would hit a deadlock for that case.  */
 371       ser_base_read_error_fd (scb, 0);
 372     }
 373
 374   if (status < 0)
 375     return status;
 376
 377   do
 378     {
 379       status = scb->ops->read_prim (scb, BUFSIZ);
 380     }
 381   while (status < 0 && errno == EINTR);
 382
 383   if (status <= 0)
 384     {
 385       if (status == 0)
 386         return SERIAL_EOF;
 387       else
 388         /* Got an error from read.  */
 389         return SERIAL_ERROR;
 390     }
 391
 392   scb->bufcnt = status;
 393   scb->bufcnt--;
 394   scb->bufp = scb->buf;
 395   return *scb->bufp++;
 396 }
 397
 398 /* Perform operations common to both old and new readchar.  */
 399
 400 /* Return the next character from the input FIFO.  If the FIFO is
 401    empty, call the SERIAL specific routine to try and read in more
 402    characters.
 403
 404    Initially data from the input FIFO is returned (fd_event()
 405    pre-reads the input into that FIFO.  Once that has been emptied,
 406    further data is obtained by polling the input FD using the device
 407    specific readchar() function.  Note: reschedule() is called after
 408    every read.  This is because there is no guarentee that the lower
 409    level fd_event() poll_event() code (which also calls reschedule())
 410    will be called.  */
 411
 412 int
 413 generic_readchar (struct serial *scb, int timeout,
 414                   int (do_readchar) (struct serial *scb, int timeout))
 415 {
 416   int ch;
 417   if (scb->bufcnt > 0)
 418     {
 419       ch = *scb->bufp;
 420       scb->bufcnt--;
 421       scb->bufp++;
 422     }
 423   else if (scb->bufcnt < 0)
 424     {
 425       /* Some errors/eof are are sticky.  */
 426       ch = scb->bufcnt;
 427     }
 428   else
 429     {
 430       ch = do_readchar (scb, timeout);
 431       if (ch < 0)
 432         {
 433           switch ((enum serial_rc) ch)
 434             {
 435             case SERIAL_EOF:
 436             case SERIAL_ERROR:
 437               /* Make the error/eof stick.  */
 438               scb->bufcnt = ch;
 439               break;
 440             case SERIAL_TIMEOUT:
 441               scb->bufcnt = 0;
 442               break;
 443             }
 444         }
 445     }
 446
 447   /* Read any error output we might have.  */
 448   ser_base_read_error_fd (scb, 1);
 449
 450   reschedule (scb);
 451   return ch;
 452 }
 453
 454 int
 455 ser_base_readchar (struct serial *scb, int timeout)
 456 {
 457   return generic_readchar (scb, timeout, do_ser_base_readchar);
 458 }
 459
 460 int
 461 ser_base_write (struct serial *scb, const void *buf, size_t count)
 462 {
 463   const char *str = (const char *) buf;
 464   int cc;
 465
 466   while (count > 0)
 467     {
 468       QUIT;
 469
 470       cc = scb->ops->write_prim (scb, str, count);
 471
 472       if (cc < 0)
 473         {
 474           if (errno == EINTR)
 475             continue;
 476           return 1;
 477         }
 478       count -= cc;
 479       str += cc;
 480     }
 481   return 0;
 482 }
 483
 484 int
 485 ser_base_flush_output (struct serial *scb)
 486 {
 487   return 0;
 488 }
 489
 490 int
 491 ser_base_flush_input (struct serial *scb)
 492 {
 493   if (scb->bufcnt >= 0)
 494     {
 495       scb->bufcnt = 0;
 496       scb->bufp = scb->buf;
 497       return 0;
 498     }
 499   else
 500     return SERIAL_ERROR;
 501 }
 502
 503 int
 504 ser_base_send_break (struct serial *scb)
 505 {
 506   return 0;
 507 }
 508
 509 int
 510 ser_base_drain_output (struct serial *scb)
 511 {
 512   return 0;
 513 }
 514
 515 void
 516 ser_base_raw (struct serial *scb)
 517 {
 518   return;                       /* Always in raw mode.  */
 519 }
 520
 521 serial_ttystate
 522 ser_base_get_tty_state (struct serial *scb)
 523 {
 524   /* Allocate a dummy.  */
 525   return (serial_ttystate) XNEW (int);
 526 }
 527
 528 serial_ttystate
 529 ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
 530 {
 531   /* Allocate another dummy.  */
 532   return (serial_ttystate) XNEW (int);
 533 }
 534
 535 int
 536 ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 537 {
 538   return 0;
 539 }
 540
 541 int
 542 ser_base_noflush_set_tty_state (struct serial *scb,
 543                                 serial_ttystate new_ttystate,
 544                                 serial_ttystate old_ttystate)
 545 {
 546   return 0;
 547 }
 548
 549 void
 550 ser_base_print_tty_state (struct serial *scb,
 551                           serial_ttystate ttystate,
 552                           struct ui_file *stream)
 553 {
 554   /* Nothing to print.  */
 555   return;
 556 }
 557
 558 int
 559 ser_base_setbaudrate (struct serial *scb, int rate)
 560 {
 561   return 0;                     /* Never fails!  */
 562 }
 563
 564 int
 565 ser_base_setstopbits (struct serial *scb, int num)
 566 {
 567   return 0;                     /* Never fails!  */
 568 }
 569
 570 /* Implement the "setparity" serial_ops callback.  */
 571
 572 int
 573 ser_base_setparity (struct serial *scb, int parity)
 574 {
 575   return 0;                     /* Never fails!  */
 576 }
 577
 578 /* Put the SERIAL device into/out-of ASYNC mode.  */
 579
 580 void
 581 ser_base_async (struct serial *scb,
 582                 int async_p)
 583 {
 584   if (async_p)
 585     {
 586       /* Force a re-schedule.  */
 587       scb->async_state = NOTHING_SCHEDULED;
 588       if (serial_debug_p (scb))
 589         fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
 590                             scb->fd);
 591       reschedule (scb);
 592     }
 593   else
 594     {
 595       if (serial_debug_p (scb))
 596         fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
 597                             scb->fd);
 598       /* De-schedule whatever tasks are currently scheduled.  */
 599       switch (scb->async_state)
 600         {
 601         case FD_SCHEDULED:
 602           delete_file_handler (scb->fd);
 603           break;
 604         case NOTHING_SCHEDULED:
 605           break;
 606         default: /* TIMER SCHEDULED */
 607           delete_timer (scb->async_state);
 608           break;
 609         }
 610     }
 611 }