The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/tty_ttydisc.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
    3  * All rights reserved.
    4  *
    5  * Portions of this software were developed under sponsorship from Snow
    6  * B.V., the Netherlands.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: releng/8.3/sys/kern/tty_ttydisc.c 201337 2009-12-31 10:53:04Z ed $");
   32 
   33 #include <sys/param.h>
   34 #include <sys/fcntl.h>
   35 #include <sys/filio.h>
   36 #include <sys/kernel.h>
   37 #include <sys/signal.h>
   38 #include <sys/sysctl.h>
   39 #include <sys/systm.h>
   40 #include <sys/tty.h>
   41 #include <sys/ttycom.h>
   42 #include <sys/ttydefaults.h>
   43 #include <sys/uio.h>
   44 #include <sys/vnode.h>
   45 
   46 /*
   47  * Standard TTYDISC `termios' line discipline.
   48  */
   49 
   50 /* Statistics. */
   51 static unsigned long tty_nin = 0;
   52 SYSCTL_ULONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD,
   53         &tty_nin, 0, "Total amount of bytes received");
   54 static unsigned long tty_nout = 0;
   55 SYSCTL_ULONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD,
   56         &tty_nout, 0, "Total amount of bytes transmitted");
   57 
   58 /* termios comparison macro's. */
   59 #define CMP_CC(v,c) (tp->t_termios.c_cc[v] != _POSIX_VDISABLE && \
   60                         tp->t_termios.c_cc[v] == (c))
   61 #define CMP_FLAG(field,opt) (tp->t_termios.c_ ## field ## flag & (opt))
   62 
   63 /* Characters that cannot be modified through c_cc. */
   64 #define CTAB    '\t'
   65 #define CNL     '\n'
   66 #define CCR     '\r'
   67 
   68 /* Character is a control character. */
   69 #define CTL_VALID(c)    ((c) == 0x7f || (unsigned char)(c) < 0x20)
   70 /* Control character should be processed on echo. */
   71 #define CTL_ECHO(c,q)   (!(q) && ((c) == CERASE2 || (c) == CTAB || \
   72     (c) == CNL || (c) == CCR))
   73 /* Control character should be printed using ^X notation. */
   74 #define CTL_PRINT(c,q)  ((c) == 0x7f || ((unsigned char)(c) < 0x20 && \
   75     ((q) || ((c) != CTAB && (c) != CNL))))
   76 /* Character is whitespace. */
   77 #define CTL_WHITE(c)    ((c) == ' ' || (c) == CTAB)
   78 /* Character is alphanumeric. */
   79 #define CTL_ALNUM(c)    (((c) >= '' && (c) <= '9') || \
   80     ((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
   81 
   82 #define TTY_STACKBUF    256
   83 
   84 void
   85 ttydisc_open(struct tty *tp)
   86 {
   87         ttydisc_optimize(tp);
   88 }
   89 
   90 void
   91 ttydisc_close(struct tty *tp)
   92 {
   93 
   94         /* Clean up our flags when leaving the discipline. */
   95         tp->t_flags &= ~(TF_STOPPED|TF_HIWAT|TF_ZOMBIE);
   96 
   97         /* POSIX states we should flush when close() is called. */
   98         ttyinq_flush(&tp->t_inq);
   99         ttyoutq_flush(&tp->t_outq);
  100 
  101         if (!tty_gone(tp)) {
  102                 ttydevsw_inwakeup(tp);
  103                 ttydevsw_outwakeup(tp);
  104         }
  105 
  106         if (ttyhook_hashook(tp, close))
  107                 ttyhook_close(tp);
  108 }
  109 
  110 static int
  111 ttydisc_read_canonical(struct tty *tp, struct uio *uio, int ioflag)
  112 {
  113         char breakc[4] = { CNL }; /* enough to hold \n, VEOF and VEOL. */
  114         int error;
  115         size_t clen, flen = 0, n = 1;
  116         unsigned char lastc = _POSIX_VDISABLE;
  117 
  118 #define BREAK_ADD(c) do { \
  119         if (tp->t_termios.c_cc[c] != _POSIX_VDISABLE)   \
  120                 breakc[n++] = tp->t_termios.c_cc[c];    \
  121 } while (0)
  122         /* Determine which characters we should trigger on. */
  123         BREAK_ADD(VEOF);
  124         BREAK_ADD(VEOL);
  125 #undef BREAK_ADD
  126         breakc[n] = '\0';
  127 
  128         do {
  129                 /*
  130                  * Quite a tricky case: unlike the old TTY
  131                  * implementation, this implementation copies data back
  132                  * to userspace in large chunks. Unfortunately, we can't
  133                  * calculate the line length on beforehand if it crosses
  134                  * ttyinq_block boundaries, because multiple reads could
  135                  * then make this code read beyond the newline.
  136                  *
  137                  * This is why we limit the read to:
  138                  * - The size the user has requested
  139                  * - The blocksize (done in tty_inq.c)
  140                  * - The amount of bytes until the newline
  141                  *
  142                  * This causes the line length to be recalculated after
  143                  * each block has been copied to userspace. This will
  144                  * cause the TTY layer to return data in chunks using
  145                  * the blocksize (except the first and last blocks).
  146                  */
  147                 clen = ttyinq_findchar(&tp->t_inq, breakc, uio->uio_resid,
  148                     &lastc);
  149 
  150                 /* No more data. */
  151                 if (clen == 0) {
  152                         if (ioflag & IO_NDELAY)
  153                                 return (EWOULDBLOCK);
  154                         else if (tp->t_flags & TF_ZOMBIE)
  155                                 return (0);
  156 
  157                         error = tty_wait(tp, &tp->t_inwait);
  158                         if (error)
  159                                 return (error);
  160                         continue;
  161                 }
  162 
  163                 /* Don't send the EOF char back to userspace. */
  164                 if (CMP_CC(VEOF, lastc))
  165                         flen = 1;
  166 
  167                 MPASS(flen <= clen);
  168 
  169                 /* Read and throw away the EOF character. */
  170                 error = ttyinq_read_uio(&tp->t_inq, tp, uio, clen, flen);
  171                 if (error)
  172                         return (error);
  173 
  174         } while (uio->uio_resid > 0 && lastc == _POSIX_VDISABLE);
  175 
  176         return (0);
  177 }
  178 
  179 static int
  180 ttydisc_read_raw_no_timer(struct tty *tp, struct uio *uio, int ioflag)
  181 {
  182         size_t vmin = tp->t_termios.c_cc[VMIN];
  183         int oresid = uio->uio_resid;
  184         int error;
  185 
  186         MPASS(tp->t_termios.c_cc[VTIME] == 0);
  187 
  188         /*
  189          * This routine implements the easy cases of read()s while in
  190          * non-canonical mode, namely case B and D, where we don't have
  191          * any timers at all.
  192          */
  193 
  194         for (;;) {
  195                 error = ttyinq_read_uio(&tp->t_inq, tp, uio,
  196                     uio->uio_resid, 0);
  197                 if (error)
  198                         return (error);
  199                 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin)
  200                         return (0);
  201 
  202                 /* We have to wait for more. */
  203                 if (ioflag & IO_NDELAY)
  204                         return (EWOULDBLOCK);
  205                 else if (tp->t_flags & TF_ZOMBIE)
  206                         return (0);
  207 
  208                 error = tty_wait(tp, &tp->t_inwait);
  209                 if (error)
  210                         return (error);
  211         }
  212 }
  213 
  214 static int
  215 ttydisc_read_raw_read_timer(struct tty *tp, struct uio *uio, int ioflag,
  216     int oresid)
  217 {
  218         size_t vmin = MAX(tp->t_termios.c_cc[VMIN], 1);
  219         unsigned int vtime = tp->t_termios.c_cc[VTIME];
  220         struct timeval end, now, left;
  221         int error, hz;
  222 
  223         MPASS(tp->t_termios.c_cc[VTIME] != 0);
  224 
  225         /* Determine when the read should be expired. */
  226         end.tv_sec = vtime / 10;
  227         end.tv_usec = (vtime % 10) * 100000;
  228         getmicrotime(&now);
  229         timevaladd(&end, &now);
  230 
  231         for (;;) {
  232                 error = ttyinq_read_uio(&tp->t_inq, tp, uio,
  233                     uio->uio_resid, 0);
  234                 if (error)
  235                         return (error);
  236                 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin)
  237                         return (0);
  238 
  239                 /* Calculate how long we should wait. */
  240                 getmicrotime(&now);
  241                 if (timevalcmp(&now, &end, >))
  242                         return (0);
  243                 left = end;
  244                 timevalsub(&left, &now);
  245                 hz = tvtohz(&left);
  246 
  247                 /*
  248                  * We have to wait for more. If the timer expires, we
  249                  * should return a 0-byte read.
  250                  */
  251                 if (ioflag & IO_NDELAY)
  252                         return (EWOULDBLOCK);
  253                 else if (tp->t_flags & TF_ZOMBIE)
  254                         return (0);
  255 
  256                 error = tty_timedwait(tp, &tp->t_inwait, hz);
  257                 if (error)
  258                         return (error == EWOULDBLOCK ? 0 : error);
  259         }
  260 
  261         return (0);
  262 }
  263 
  264 static int
  265 ttydisc_read_raw_interbyte_timer(struct tty *tp, struct uio *uio, int ioflag)
  266 {
  267         size_t vmin = tp->t_termios.c_cc[VMIN];
  268         int oresid = uio->uio_resid;
  269         int error;
  270 
  271         MPASS(tp->t_termios.c_cc[VMIN] != 0);
  272         MPASS(tp->t_termios.c_cc[VTIME] != 0);
  273         
  274         /*
  275          * When using the interbyte timer, the timer should be started
  276          * after the first byte has been received. We just call into the
  277          * generic read timer code after we've received the first byte.
  278          */
  279         
  280         for (;;) {
  281                 error = ttyinq_read_uio(&tp->t_inq, tp, uio,
  282                     uio->uio_resid, 0);
  283                 if (error)
  284                         return (error);
  285                 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin)
  286                         return (0);
  287 
  288                 /*
  289                  * Not enough data, but we did receive some, which means
  290                  * we'll now start using the interbyte timer.
  291                  */
  292                 if (oresid != uio->uio_resid)
  293                         break;
  294 
  295                 /* We have to wait for more. */
  296                 if (ioflag & IO_NDELAY)
  297                         return (EWOULDBLOCK);
  298                 else if (tp->t_flags & TF_ZOMBIE)
  299                         return (0);
  300 
  301                 error = tty_wait(tp, &tp->t_inwait);
  302                 if (error)
  303                         return (error);
  304         }
  305 
  306         return ttydisc_read_raw_read_timer(tp, uio, ioflag, oresid);
  307 }
  308 
  309 int
  310 ttydisc_read(struct tty *tp, struct uio *uio, int ioflag)
  311 {
  312         int error;
  313 
  314         tty_lock_assert(tp, MA_OWNED);
  315 
  316         if (uio->uio_resid == 0)
  317                 return (0);
  318 
  319         if (CMP_FLAG(l, ICANON))
  320                 error = ttydisc_read_canonical(tp, uio, ioflag);
  321         else if (tp->t_termios.c_cc[VTIME] == 0)
  322                 error = ttydisc_read_raw_no_timer(tp, uio, ioflag);
  323         else if (tp->t_termios.c_cc[VMIN] == 0)
  324                 error = ttydisc_read_raw_read_timer(tp, uio, ioflag,
  325                     uio->uio_resid);
  326         else
  327                 error = ttydisc_read_raw_interbyte_timer(tp, uio, ioflag);
  328 
  329         if (ttyinq_bytesleft(&tp->t_inq) >= tp->t_inlow ||
  330             ttyinq_bytescanonicalized(&tp->t_inq) == 0) {
  331                 /* Unset the input watermark when we've got enough space. */
  332                 tty_hiwat_in_unblock(tp);
  333         }
  334         
  335         return (error);
  336 }
  337 
  338 static __inline unsigned int
  339 ttydisc_findchar(const char *obstart, unsigned int oblen)
  340 {
  341         const char *c = obstart;
  342 
  343         while (oblen--) {
  344                 if (CTL_VALID(*c))
  345                         break;
  346                 c++;
  347         }
  348 
  349         return (c - obstart);
  350 }
  351 
  352 static int
  353 ttydisc_write_oproc(struct tty *tp, char c)
  354 {
  355         unsigned int scnt, error;
  356 
  357         MPASS(CMP_FLAG(o, OPOST));
  358         MPASS(CTL_VALID(c));
  359 
  360 #define PRINT_NORMAL() ttyoutq_write_nofrag(&tp->t_outq, &c, 1)
  361         switch (c) {
  362         case CEOF:
  363                 /* End-of-text dropping. */
  364                 if (CMP_FLAG(o, ONOEOT))
  365                         return (0);
  366                 return PRINT_NORMAL();
  367 
  368         case CERASE2:
  369                 /* Handle backspace to fix tab expansion. */
  370                 if (PRINT_NORMAL() != 0)
  371                         return (-1);
  372                 if (tp->t_column > 0)
  373                         tp->t_column--;
  374                 return (0);
  375 
  376         case CTAB:
  377                 /* Tab expansion. */
  378                 scnt = 8 - (tp->t_column & 7);
  379                 if (CMP_FLAG(o, TAB3)) {
  380                         error = ttyoutq_write_nofrag(&tp->t_outq,
  381                             "        ", scnt);
  382                 } else {
  383                         error = PRINT_NORMAL();
  384                 }
  385                 if (error)
  386                         return (-1);
  387 
  388                 tp->t_column += scnt;
  389                 MPASS((tp->t_column % 8) == 0);
  390                 return (0);
  391 
  392         case CNL:
  393                 /* Newline conversion. */
  394                 if (CMP_FLAG(o, ONLCR)) {
  395                         /* Convert \n to \r\n. */
  396                         error = ttyoutq_write_nofrag(&tp->t_outq, "\r\n", 2);
  397                 } else {
  398                         error = PRINT_NORMAL();
  399                 }
  400                 if (error)
  401                         return (-1);
  402 
  403                 if (CMP_FLAG(o, ONLCR|ONLRET)) {
  404                         tp->t_column = tp->t_writepos = 0;
  405                         ttyinq_reprintpos_set(&tp->t_inq);
  406                 }
  407                 return (0);
  408 
  409         case CCR:
  410                 /* Carriage return to newline conversion. */
  411                 if (CMP_FLAG(o, OCRNL))
  412                         c = CNL;
  413                 /* Omit carriage returns on column 0. */
  414                 if (CMP_FLAG(o, ONOCR) && tp->t_column == 0)
  415                         return (0);
  416                 if (PRINT_NORMAL() != 0)
  417                         return (-1);
  418 
  419                 tp->t_column = tp->t_writepos = 0;
  420                 ttyinq_reprintpos_set(&tp->t_inq);
  421                 return (0);
  422         }
  423 
  424         /*
  425          * Invisible control character. Print it, but don't
  426          * increase the column count.
  427          */
  428         return PRINT_NORMAL();
  429 #undef PRINT_NORMAL
  430 }
  431 
  432 /*
  433  * Just like the old TTY implementation, we need to copy data in chunks
  434  * into a temporary buffer. One of the reasons why we need to do this,
  435  * is because output processing (only TAB3 though) may allow the buffer
  436  * to grow eight times.
  437  */
  438 int
  439 ttydisc_write(struct tty *tp, struct uio *uio, int ioflag)
  440 {
  441         char ob[TTY_STACKBUF];
  442         char *obstart;
  443         int error = 0;
  444         unsigned int oblen = 0;
  445 
  446         tty_lock_assert(tp, MA_OWNED);
  447 
  448         if (tp->t_flags & TF_ZOMBIE)
  449                 return (EIO);
  450 
  451         /*
  452          * We don't need to check whether the process is the foreground
  453          * process group or if we have a carrier. This is already done
  454          * in ttydev_write().
  455          */
  456 
  457         while (uio->uio_resid > 0) {
  458                 unsigned int nlen;
  459 
  460                 MPASS(oblen == 0);
  461 
  462                 /* Step 1: read data. */
  463                 obstart = ob;
  464                 nlen = MIN(uio->uio_resid, sizeof ob);
  465                 tty_unlock(tp);
  466                 error = uiomove(ob, nlen, uio);
  467                 tty_lock(tp);
  468                 if (error != 0)
  469                         break;
  470                 oblen = nlen;
  471 
  472                 if (tty_gone(tp)) {
  473                         error = ENXIO;
  474                         break;
  475                 }
  476 
  477                 MPASS(oblen > 0);
  478 
  479                 /* Step 2: process data. */
  480                 do {
  481                         unsigned int plen, wlen;
  482 
  483                         /* Search for special characters for post processing. */
  484                         if (CMP_FLAG(o, OPOST)) {
  485                                 plen = ttydisc_findchar(obstart, oblen);
  486                         } else {
  487                                 plen = oblen;
  488                         }
  489 
  490                         if (plen == 0) {
  491                                 /*
  492                                  * We're going to process a character
  493                                  * that needs processing
  494                                  */
  495                                 if (ttydisc_write_oproc(tp, *obstart) == 0) {
  496                                         obstart++;
  497                                         oblen--;
  498 
  499                                         tp->t_writepos = tp->t_column;
  500                                         ttyinq_reprintpos_set(&tp->t_inq);
  501                                         continue;
  502                                 }
  503                         } else {
  504                                 /* We're going to write regular data. */
  505                                 wlen = ttyoutq_write(&tp->t_outq, obstart, plen);
  506                                 obstart += wlen;
  507                                 oblen -= wlen;
  508                                 tp->t_column += wlen;
  509 
  510                                 tp->t_writepos = tp->t_column;
  511                                 ttyinq_reprintpos_set(&tp->t_inq);
  512 
  513                                 if (wlen == plen)
  514                                         continue;
  515                         }
  516 
  517                         /* Watermark reached. Try to sleep. */
  518                         tp->t_flags |= TF_HIWAT_OUT;
  519 
  520                         if (ioflag & IO_NDELAY) {
  521                                 error = EWOULDBLOCK;
  522                                 goto done;
  523                         }
  524                         
  525                         /*
  526                          * The driver may write back the data
  527                          * synchronously. Be sure to check the high
  528                          * water mark before going to sleep.
  529                          */
  530                         ttydevsw_outwakeup(tp);
  531                         if ((tp->t_flags & TF_HIWAT_OUT) == 0)
  532                                 continue;
  533 
  534                         error = tty_wait(tp, &tp->t_outwait);
  535                         if (error)
  536                                 goto done;
  537 
  538                         if (tp->t_flags & TF_ZOMBIE) {
  539                                 error = EIO;
  540                                 goto done;
  541                         }
  542                 } while (oblen > 0);
  543         }
  544 
  545 done:
  546         if (!tty_gone(tp))
  547                 ttydevsw_outwakeup(tp);
  548 
  549         /*
  550          * Add the amount of bytes that we didn't process back to the
  551          * uio counters. We need to do this to make sure write() doesn't
  552          * count the bytes we didn't store in the queue.
  553          */
  554         uio->uio_resid += oblen;
  555         return (error);
  556 }
  557 
  558 void
  559 ttydisc_optimize(struct tty *tp)
  560 {
  561         tty_lock_assert(tp, MA_OWNED);
  562 
  563         if (ttyhook_hashook(tp, rint_bypass)) {
  564                 tp->t_flags |= TF_BYPASS;
  565         } else if (ttyhook_hashook(tp, rint)) {
  566                 tp->t_flags &= ~TF_BYPASS;
  567         } else if (!CMP_FLAG(i, ICRNL|IGNCR|IMAXBEL|INLCR|ISTRIP|IXON) &&
  568             (!CMP_FLAG(i, BRKINT) || CMP_FLAG(i, IGNBRK)) &&
  569             (!CMP_FLAG(i, PARMRK) ||
  570                 CMP_FLAG(i, IGNPAR|IGNBRK) == (IGNPAR|IGNBRK)) &&
  571             !CMP_FLAG(l, ECHO|ICANON|IEXTEN|ISIG|PENDIN)) {
  572                 tp->t_flags |= TF_BYPASS;
  573         } else {
  574                 tp->t_flags &= ~TF_BYPASS;
  575         }
  576 }
  577 
  578 void
  579 ttydisc_modem(struct tty *tp, int open)
  580 {
  581 
  582         tty_lock_assert(tp, MA_OWNED);
  583 
  584         if (open)
  585                 cv_broadcast(&tp->t_dcdwait);
  586         
  587         /*
  588          * Ignore modem status lines when CLOCAL is turned on, but don't
  589          * enter the zombie state when the TTY isn't opened, because
  590          * that would cause the TTY to be in zombie state after being
  591          * opened.
  592          */
  593         if (!tty_opened(tp) || CMP_FLAG(c, CLOCAL))
  594                 return;
  595 
  596         if (open == 0) {
  597                 /*
  598                  * Lost carrier.
  599                  */
  600                 tp->t_flags |= TF_ZOMBIE;
  601 
  602                 tty_signal_sessleader(tp, SIGHUP);
  603                 tty_flush(tp, FREAD|FWRITE);
  604         } else {
  605                 /*
  606                  * Carrier is back again.
  607                  */
  608 
  609                 /* XXX: what should we do here? */
  610         }
  611 }
  612 
  613 static int
  614 ttydisc_echo_force(struct tty *tp, char c, int quote)
  615 {
  616 
  617         if (CMP_FLAG(o, OPOST) && CTL_ECHO(c, quote)) {
  618                 /*
  619                  * Only perform postprocessing when OPOST is turned on
  620                  * and the character is an unquoted BS/TB/NL/CR.
  621                  */
  622                 return ttydisc_write_oproc(tp, c);
  623         } else if (CMP_FLAG(l, ECHOCTL) && CTL_PRINT(c, quote)) {
  624                 /*
  625                  * Only use ^X notation when ECHOCTL is turned on and
  626                  * we've got an quoted control character.
  627                  *
  628                  * Print backspaces when echoing an end-of-file.
  629                  */
  630                 char ob[4] = "^?\b\b";
  631 
  632                 /* Print ^X notation. */
  633                 if (c != 0x7f)
  634                         ob[1] = c + 'A' - 1;
  635 
  636                 if (!quote && CMP_CC(VEOF, c)) {
  637                         return ttyoutq_write_nofrag(&tp->t_outq, ob, 4);
  638                 } else {
  639                         tp->t_column += 2;
  640                         return ttyoutq_write_nofrag(&tp->t_outq, ob, 2);
  641                 }
  642         } else {
  643                 /* Can just be printed. */
  644                 tp->t_column++;
  645                 return ttyoutq_write_nofrag(&tp->t_outq, &c, 1);
  646         }
  647 }
  648 
  649 static int
  650 ttydisc_echo(struct tty *tp, char c, int quote)
  651 {
  652 
  653         /*
  654          * Only echo characters when ECHO is turned on, or ECHONL when
  655          * the character is an unquoted newline.
  656          */
  657         if (!CMP_FLAG(l, ECHO) &&
  658             (!CMP_FLAG(l, ECHONL) || c != CNL || quote))
  659                 return (0);
  660 
  661         return ttydisc_echo_force(tp, c, quote);
  662 }
  663 
  664 
  665 static void
  666 ttydisc_reprint_char(void *d, char c, int quote)
  667 {
  668         struct tty *tp = d;
  669 
  670         ttydisc_echo(tp, c, quote);
  671 }
  672 
  673 static void
  674 ttydisc_reprint(struct tty *tp)
  675 {
  676         cc_t c;
  677 
  678         /* Print  ^R\n, followed by the line. */
  679         c = tp->t_termios.c_cc[VREPRINT];
  680         if (c != _POSIX_VDISABLE)
  681                 ttydisc_echo(tp, c, 0);
  682         ttydisc_echo(tp, CNL, 0);
  683         ttyinq_reprintpos_reset(&tp->t_inq);
  684 
  685         ttyinq_line_iterate_from_linestart(&tp->t_inq, ttydisc_reprint_char, tp);
  686 }
  687 
  688 struct ttydisc_recalc_length {
  689         struct tty *tp;
  690         unsigned int curlen;
  691 };
  692 
  693 static void
  694 ttydisc_recalc_charlength(void *d, char c, int quote)
  695 {
  696         struct ttydisc_recalc_length *data = d;
  697         struct tty *tp = data->tp;
  698 
  699         if (CTL_PRINT(c, quote)) {
  700                 if (CMP_FLAG(l, ECHOCTL))
  701                         data->curlen += 2;
  702         } else if (c == CTAB) {
  703                 data->curlen += 8 - (data->curlen & 7);
  704         } else {
  705                 data->curlen++;
  706         }
  707 }
  708 
  709 static unsigned int
  710 ttydisc_recalc_linelength(struct tty *tp)
  711 {
  712         struct ttydisc_recalc_length data = { tp, tp->t_writepos };
  713 
  714         ttyinq_line_iterate_from_reprintpos(&tp->t_inq,
  715             ttydisc_recalc_charlength, &data);
  716         return (data.curlen);
  717 }
  718 
  719 static int
  720 ttydisc_rubchar(struct tty *tp)
  721 {
  722         char c;
  723         int quote;
  724         unsigned int prevpos, tablen;
  725 
  726         if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
  727                 return (-1);
  728         ttyinq_unputchar(&tp->t_inq);
  729 
  730         if (CMP_FLAG(l, ECHO)) {
  731                 /*
  732                  * Remove the character from the screen. This is even
  733                  * safe for characters that span multiple characters
  734                  * (tabs, quoted, etc).
  735                  */
  736                 if (tp->t_writepos >= tp->t_column) {
  737                         /* Retype the sentence. */
  738                         ttydisc_reprint(tp);
  739                 } else if (CMP_FLAG(l, ECHOE)) {
  740                         if (CTL_PRINT(c, quote)) {
  741                                 /* Remove ^X formatted chars. */
  742                                 if (CMP_FLAG(l, ECHOCTL)) {
  743                                         tp->t_column -= 2;
  744                                         ttyoutq_write_nofrag(&tp->t_outq,
  745                                             "\b\b  \b\b", 6);
  746                                 }
  747                         } else if (c == ' ') {
  748                                 /* Space character needs no rubbing. */
  749                                 tp->t_column -= 1;
  750                                 ttyoutq_write_nofrag(&tp->t_outq, "\b", 1);
  751                         } else if (c == CTAB) {
  752                                 /*
  753                                  * Making backspace work with tabs is
  754                                  * quite hard. Recalculate the length of
  755                                  * this character and remove it.
  756                                  *
  757                                  * Because terminal settings could be
  758                                  * changed while the line is being
  759                                  * inserted, the calculations don't have
  760                                  * to be correct. Make sure we keep the
  761                                  * tab length within proper bounds.
  762                                  */
  763                                 prevpos = ttydisc_recalc_linelength(tp);
  764                                 if (prevpos >= tp->t_column)
  765                                         tablen = 1;
  766                                 else
  767                                         tablen = tp->t_column - prevpos;
  768                                 if (tablen > 8)
  769                                         tablen = 8;
  770 
  771                                 tp->t_column = prevpos;
  772                                 ttyoutq_write_nofrag(&tp->t_outq,
  773                                     "\b\b\b\b\b\b\b\b", tablen);
  774                                 return (0);
  775                         } else {
  776                                 /*
  777                                  * Remove a regular character by
  778                                  * punching a space over it.
  779                                  */
  780                                 tp->t_column -= 1;
  781                                 ttyoutq_write_nofrag(&tp->t_outq, "\b \b", 3);
  782                         }
  783                 } else {
  784                         /* Don't print spaces. */
  785                         ttydisc_echo(tp, tp->t_termios.c_cc[VERASE], 0);
  786                 }
  787         }
  788 
  789         return (0);
  790 }
  791 
  792 static void
  793 ttydisc_rubword(struct tty *tp)
  794 {
  795         char c;
  796         int quote, alnum;
  797 
  798         /* Strip whitespace first. */
  799         for (;;) {
  800                 if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
  801                         return;
  802                 if (!CTL_WHITE(c))
  803                         break;
  804                 ttydisc_rubchar(tp);
  805         }
  806 
  807         /*
  808          * Record whether the last character from the previous iteration
  809          * was alphanumeric or not. We need this to implement ALTWERASE.
  810          */
  811         alnum = CTL_ALNUM(c);
  812         for (;;) {
  813                 ttydisc_rubchar(tp);
  814 
  815                 if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
  816                         return;
  817                 if (CTL_WHITE(c))
  818                         return;
  819                 if (CMP_FLAG(l, ALTWERASE) && CTL_ALNUM(c) != alnum)
  820                         return;
  821         }
  822 }
  823 
  824 int
  825 ttydisc_rint(struct tty *tp, char c, int flags)
  826 {
  827         int signal, quote = 0;
  828         char ob[3] = { 0xff, 0x00 };
  829         size_t ol;
  830 
  831         tty_lock_assert(tp, MA_OWNED);
  832 
  833         atomic_add_long(&tty_nin, 1);
  834 
  835         if (ttyhook_hashook(tp, rint))
  836                 return ttyhook_rint(tp, c, flags);
  837         
  838         if (tp->t_flags & TF_BYPASS)
  839                 goto processed;
  840 
  841         if (flags) {
  842                 if (flags & TRE_BREAK) {
  843                         if (CMP_FLAG(i, IGNBRK)) {
  844                                 /* Ignore break characters. */
  845                                 return (0);
  846                         } else if (CMP_FLAG(i, BRKINT)) {
  847                                 /* Generate SIGINT on break. */
  848                                 tty_flush(tp, FREAD|FWRITE);
  849                                 tty_signal_pgrp(tp, SIGINT);
  850                                 return (0);
  851                         } else {
  852                                 /* Just print it. */
  853                                 goto parmrk;
  854                         }
  855                 } else if (flags & TRE_FRAMING ||
  856                     (flags & TRE_PARITY && CMP_FLAG(i, INPCK))) {
  857                         if (CMP_FLAG(i, IGNPAR)) {
  858                                 /* Ignore bad characters. */
  859                                 return (0);
  860                         } else {
  861                                 /* Just print it. */
  862                                 goto parmrk;
  863                         }
  864                 }
  865         }
  866 
  867         /* Allow any character to perform a wakeup. */
  868         if (CMP_FLAG(i, IXANY))
  869                 tp->t_flags &= ~TF_STOPPED;
  870 
  871         /* Remove the top bit. */
  872         if (CMP_FLAG(i, ISTRIP))
  873                 c &= ~0x80;
  874 
  875         /* Skip input processing when we want to print it literally. */
  876         if (tp->t_flags & TF_LITERAL) {
  877                 tp->t_flags &= ~TF_LITERAL;
  878                 quote = 1;
  879                 goto processed;
  880         }
  881 
  882         /* Special control characters that are implementation dependent. */
  883         if (CMP_FLAG(l, IEXTEN)) {
  884                 /* Accept the next character as literal. */
  885                 if (CMP_CC(VLNEXT, c)) {
  886                         if (CMP_FLAG(l, ECHO)) {
  887                                 if (CMP_FLAG(l, ECHOE))
  888                                         ttyoutq_write_nofrag(&tp->t_outq, "^\b", 2);
  889                                 else
  890                                         ttydisc_echo(tp, c, 0);
  891                         }
  892                         tp->t_flags |= TF_LITERAL;
  893                         return (0);
  894                 }
  895         }
  896 
  897         /*
  898          * Handle signal processing.
  899          */
  900         if (CMP_FLAG(l, ISIG)) {
  901                 if (CMP_FLAG(l, ICANON|IEXTEN) == (ICANON|IEXTEN)) {
  902                         if (CMP_CC(VSTATUS, c)) {
  903                                 tty_signal_pgrp(tp, SIGINFO);
  904                                 return (0);
  905                         }
  906                 }
  907 
  908                 /*
  909                  * When compared to the old implementation, this
  910                  * implementation also flushes the output queue. POSIX
  911                  * is really brief about this, but does makes us assume
  912                  * we have to do so.
  913                  */
  914                 signal = 0;
  915                 if (CMP_CC(VINTR, c)) {
  916                         signal = SIGINT;
  917                 } else if (CMP_CC(VQUIT, c)) {
  918                         signal = SIGQUIT;
  919                 } else if (CMP_CC(VSUSP, c)) {
  920                         signal = SIGTSTP;
  921                 }
  922 
  923                 if (signal != 0) {
  924                         /*
  925                          * Echo the character before signalling the
  926                          * processes.
  927                          */
  928                         if (!CMP_FLAG(l, NOFLSH))
  929                                 tty_flush(tp, FREAD|FWRITE);
  930                         ttydisc_echo(tp, c, 0);
  931                         tty_signal_pgrp(tp, signal);
  932                         return (0);
  933                 }
  934         }
  935 
  936         /*
  937          * Handle start/stop characters.
  938          */
  939         if (CMP_FLAG(i, IXON)) {
  940                 if (CMP_CC(VSTOP, c)) {
  941                         /* Stop it if we aren't stopped yet. */
  942                         if ((tp->t_flags & TF_STOPPED) == 0) {
  943                                 tp->t_flags |= TF_STOPPED;
  944                                 return (0);
  945                         }
  946                         /*
  947                          * Fallthrough:
  948                          * When VSTART == VSTOP, we should make this key
  949                          * toggle it.
  950                          */
  951                         if (!CMP_CC(VSTART, c))
  952                                 return (0);
  953                 }
  954                 if (CMP_CC(VSTART, c)) {
  955                         tp->t_flags &= ~TF_STOPPED;
  956                         return (0);
  957                 }
  958         }
  959 
  960         /* Conversion of CR and NL. */
  961         switch (c) {
  962         case CCR:
  963                 if (CMP_FLAG(i, IGNCR))
  964                         return (0);
  965                 if (CMP_FLAG(i, ICRNL))
  966                         c = CNL;
  967                 break;
  968         case CNL:
  969                 if (CMP_FLAG(i, INLCR))
  970                         c = CCR;
  971                 break;
  972         }
  973 
  974         /* Canonical line editing. */
  975         if (CMP_FLAG(l, ICANON)) {
  976                 if (CMP_CC(VERASE, c) || CMP_CC(VERASE2, c)) {
  977                         ttydisc_rubchar(tp);
  978                         return (0);
  979                 } else if (CMP_CC(VKILL, c)) {
  980                         while (ttydisc_rubchar(tp) == 0);
  981                         return (0);
  982                 } else if (CMP_FLAG(l, IEXTEN)) {
  983                         if (CMP_CC(VWERASE, c)) {
  984                                 ttydisc_rubword(tp);
  985                                 return (0);
  986                         } else if (CMP_CC(VREPRINT, c)) {
  987                                 ttydisc_reprint(tp);
  988                                 return (0);
  989                         }
  990                 }
  991         }
  992 
  993 processed:
  994         if (CMP_FLAG(i, PARMRK) && (unsigned char)c == 0xff) {
  995                 /* Print 0xff 0xff. */
  996                 ob[1] = 0xff;
  997                 ol = 2;
  998                 quote = 1;
  999         } else {
 1000                 ob[0] = c;
 1001                 ol = 1;
 1002         }
 1003 
 1004         goto print;
 1005 
 1006 parmrk:
 1007         if (CMP_FLAG(i, PARMRK)) {
 1008                 /* Prepend 0xff 0x00 0x.. */
 1009                 ob[2] = c;
 1010                 ol = 3;
 1011                 quote = 1;
 1012         } else {
 1013                 ob[0] = c;
 1014                 ol = 1;
 1015         }
 1016 
 1017 print:
 1018         /* See if we can store this on the input queue. */
 1019         if (ttyinq_write_nofrag(&tp->t_inq, ob, ol, quote) != 0) {
 1020                 if (CMP_FLAG(i, IMAXBEL))
 1021                         ttyoutq_write_nofrag(&tp->t_outq, "\a", 1);
 1022 
 1023                 /*
 1024                  * Prevent a deadlock here. It may be possible that a
 1025                  * user has entered so much data, there is no data
 1026                  * available to read(), but the buffers are full anyway.
 1027                  *
 1028                  * Only enter the high watermark if the device driver
 1029                  * can actually transmit something.
 1030                  */
 1031                 if (ttyinq_bytescanonicalized(&tp->t_inq) == 0)
 1032                         return (0);
 1033 
 1034                 tty_hiwat_in_block(tp);
 1035                 return (-1);
 1036         }
 1037 
 1038         /*
 1039          * In raw mode, we canonicalize after receiving a single
 1040          * character. Otherwise, we canonicalize when we receive a
 1041          * newline, VEOL or VEOF, but only when it isn't quoted.
 1042          */
 1043         if (!CMP_FLAG(l, ICANON) ||
 1044             (!quote && (c == CNL || CMP_CC(VEOL, c) || CMP_CC(VEOF, c)))) {
 1045                 ttyinq_canonicalize(&tp->t_inq);
 1046         }
 1047 
 1048         ttydisc_echo(tp, c, quote);
 1049 
 1050         return (0);
 1051 }
 1052 
 1053 size_t
 1054 ttydisc_rint_bypass(struct tty *tp, const void *buf, size_t len)
 1055 {
 1056         size_t ret;
 1057 
 1058         tty_lock_assert(tp, MA_OWNED);
 1059         
 1060         MPASS(tp->t_flags & TF_BYPASS);
 1061 
 1062         atomic_add_long(&tty_nin, len);
 1063 
 1064         if (ttyhook_hashook(tp, rint_bypass))
 1065                 return ttyhook_rint_bypass(tp, buf, len);
 1066 
 1067         ret = ttyinq_write(&tp->t_inq, buf, len, 0);
 1068         ttyinq_canonicalize(&tp->t_inq);
 1069         if (ret < len)
 1070                 tty_hiwat_in_block(tp);
 1071 
 1072         return (ret);
 1073 }
 1074 
 1075 void
 1076 ttydisc_rint_done(struct tty *tp)
 1077 {
 1078 
 1079         tty_lock_assert(tp, MA_OWNED);
 1080 
 1081         if (ttyhook_hashook(tp, rint_done))
 1082                 ttyhook_rint_done(tp);
 1083 
 1084         /* Wake up readers. */
 1085         tty_wakeup(tp, FREAD);
 1086         /* Wake up driver for echo. */
 1087         ttydevsw_outwakeup(tp);
 1088 }
 1089 
 1090 size_t
 1091 ttydisc_rint_poll(struct tty *tp)
 1092 {
 1093         size_t l;
 1094 
 1095         tty_lock_assert(tp, MA_OWNED);
 1096 
 1097         if (ttyhook_hashook(tp, rint_poll))
 1098                 return ttyhook_rint_poll(tp);
 1099 
 1100         /*
 1101          * XXX: Still allow character input when there's no space in the
 1102          * buffers, but we haven't entered the high watermark. This is
 1103          * to allow backspace characters to be inserted when in
 1104          * canonical mode.
 1105          */
 1106         l = ttyinq_bytesleft(&tp->t_inq);
 1107         if (l == 0 && (tp->t_flags & TF_HIWAT_IN) == 0)
 1108                 return (1);
 1109         
 1110         return (l);
 1111 }
 1112 
 1113 static void
 1114 ttydisc_wakeup_watermark(struct tty *tp)
 1115 {
 1116         size_t c;
 1117 
 1118         c = ttyoutq_bytesleft(&tp->t_outq);
 1119         if (tp->t_flags & TF_HIWAT_OUT) {
 1120                 /* Only allow us to run when we're below the watermark. */
 1121                 if (c < tp->t_outlow)
 1122                         return;
 1123 
 1124                 /* Reset the watermark. */
 1125                 tp->t_flags &= ~TF_HIWAT_OUT;
 1126         } else {
 1127                 /* Only run when we have data at all. */
 1128                 if (c == 0)
 1129                         return;
 1130         }
 1131         tty_wakeup(tp, FWRITE);
 1132 }
 1133 
 1134 size_t
 1135 ttydisc_getc(struct tty *tp, void *buf, size_t len)
 1136 {
 1137 
 1138         tty_lock_assert(tp, MA_OWNED);
 1139 
 1140         if (tp->t_flags & TF_STOPPED)
 1141                 return (0);
 1142 
 1143         if (ttyhook_hashook(tp, getc_inject))
 1144                 return ttyhook_getc_inject(tp, buf, len);
 1145 
 1146         len = ttyoutq_read(&tp->t_outq, buf, len);
 1147 
 1148         if (ttyhook_hashook(tp, getc_capture))
 1149                 ttyhook_getc_capture(tp, buf, len);
 1150 
 1151         ttydisc_wakeup_watermark(tp);
 1152         atomic_add_long(&tty_nout, len);
 1153 
 1154         return (len);
 1155 }
 1156 
 1157 int
 1158 ttydisc_getc_uio(struct tty *tp, struct uio *uio)
 1159 {
 1160         int error = 0;
 1161         int obytes = uio->uio_resid;
 1162         size_t len;
 1163         char buf[TTY_STACKBUF];
 1164 
 1165         tty_lock_assert(tp, MA_OWNED);
 1166 
 1167         if (tp->t_flags & TF_STOPPED)
 1168                 return (0);
 1169 
 1170         /*
 1171          * When a TTY hook is attached, we cannot perform unbuffered
 1172          * copying to userspace. Just call ttydisc_getc() and
 1173          * temporarily store data in a shadow buffer.
 1174          */
 1175         if (ttyhook_hashook(tp, getc_capture) ||
 1176             ttyhook_hashook(tp, getc_inject)) {
 1177                 while (uio->uio_resid > 0) {
 1178                         /* Read to shadow buffer. */
 1179                         len = ttydisc_getc(tp, buf,
 1180                             MIN(uio->uio_resid, sizeof buf));
 1181                         if (len == 0)
 1182                                 break;
 1183 
 1184                         /* Copy to userspace. */
 1185                         tty_unlock(tp);
 1186                         error = uiomove(buf, len, uio);
 1187                         tty_lock(tp);
 1188                         
 1189                         if (error != 0)
 1190                                 break;
 1191                 }
 1192         } else {
 1193                 error = ttyoutq_read_uio(&tp->t_outq, tp, uio);
 1194 
 1195                 ttydisc_wakeup_watermark(tp);
 1196                 atomic_add_long(&tty_nout, obytes - uio->uio_resid);
 1197         }
 1198 
 1199         return (error);
 1200 }
 1201 
 1202 size_t
 1203 ttydisc_getc_poll(struct tty *tp)
 1204 {
 1205 
 1206         tty_lock_assert(tp, MA_OWNED);
 1207 
 1208         if (tp->t_flags & TF_STOPPED)
 1209                 return (0);
 1210 
 1211         if (ttyhook_hashook(tp, getc_poll))
 1212                 return ttyhook_getc_poll(tp);
 1213 
 1214         return ttyoutq_bytesused(&tp->t_outq);
 1215 }
 1216 
 1217 /*
 1218  * XXX: not really related to the TTYDISC, but we'd better put
 1219  * tty_putchar() here, because we need to perform proper output
 1220  * processing.
 1221  */
 1222 
 1223 int
 1224 tty_putchar(struct tty *tp, char c)
 1225 {
 1226         tty_lock_assert(tp, MA_OWNED);
 1227 
 1228         if (tty_gone(tp))
 1229                 return (-1);
 1230 
 1231         ttydisc_echo_force(tp, c, 0);
 1232         tp->t_writepos = tp->t_column;
 1233         ttyinq_reprintpos_set(&tp->t_inq);
 1234 
 1235         ttydevsw_outwakeup(tp);
 1236         return (0);
 1237 }

Cache object: 07923f1b94326874e6543d891cb7761c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.