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_outq.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: stable/10/sys/kern/tty_outq.c 223575 2011-06-26 18:26:20Z ed $");
   32 
   33 #include <sys/param.h>
   34 #include <sys/kernel.h>
   35 #include <sys/lock.h>
   36 #include <sys/queue.h>
   37 #include <sys/systm.h>
   38 #include <sys/tty.h>
   39 #include <sys/uio.h>
   40 
   41 #include <vm/uma.h>
   42 
   43 /*
   44  * TTY output queue buffering.
   45  *
   46  * The previous design of the TTY layer offered the so-called clists.
   47  * These clists were used for both the input queues and the output
   48  * queue. We don't use certain features on the output side, like quoting
   49  * bits for parity marking and such. This mechanism is similar to the
   50  * old clists, but only contains the features we need to buffer the
   51  * output.
   52  */
   53 
   54 struct ttyoutq_block {
   55         struct ttyoutq_block    *tob_next;
   56         char                    tob_data[TTYOUTQ_DATASIZE];
   57 };
   58 
   59 static uma_zone_t ttyoutq_zone;
   60 
   61 #define TTYOUTQ_INSERT_TAIL(to, tob) do {                               \
   62         if (to->to_end == 0) {                                          \
   63                 tob->tob_next = to->to_firstblock;                      \
   64                 to->to_firstblock = tob;                                \
   65         } else {                                                        \
   66                 tob->tob_next = to->to_lastblock->tob_next;             \
   67                 to->to_lastblock->tob_next = tob;                       \
   68         }                                                               \
   69         to->to_nblocks++;                                               \
   70 } while (0)
   71 
   72 #define TTYOUTQ_REMOVE_HEAD(to) do {                                    \
   73         to->to_firstblock = to->to_firstblock->tob_next;                \
   74         to->to_nblocks--;                                               \
   75 } while (0)
   76 
   77 #define TTYOUTQ_RECYCLE(to, tob) do {                                   \
   78         if (to->to_quota <= to->to_nblocks)                             \
   79                 uma_zfree(ttyoutq_zone, tob);                           \
   80         else                                                            \
   81                 TTYOUTQ_INSERT_TAIL(to, tob);                           \
   82 } while(0)
   83 
   84 void
   85 ttyoutq_flush(struct ttyoutq *to)
   86 {
   87 
   88         to->to_begin = 0;
   89         to->to_end = 0;
   90 }
   91 
   92 void
   93 ttyoutq_setsize(struct ttyoutq *to, struct tty *tp, size_t size)
   94 {
   95         struct ttyoutq_block *tob;
   96 
   97         to->to_quota = howmany(size, TTYOUTQ_DATASIZE);
   98 
   99         while (to->to_quota > to->to_nblocks) {
  100                 /*
  101                  * List is getting bigger.
  102                  * Add new blocks to the tail of the list.
  103                  *
  104                  * We must unlock the TTY temporarily, because we need
  105                  * to allocate memory. This won't be a problem, because
  106                  * in the worst case, another thread ends up here, which
  107                  * may cause us to allocate too many blocks, but this
  108                  * will be caught by the loop below.
  109                  */
  110                 tty_unlock(tp);
  111                 tob = uma_zalloc(ttyoutq_zone, M_WAITOK);
  112                 tty_lock(tp);
  113 
  114                 TTYOUTQ_INSERT_TAIL(to, tob);
  115         }
  116 }
  117 
  118 void
  119 ttyoutq_free(struct ttyoutq *to)
  120 {
  121         struct ttyoutq_block *tob;
  122 
  123         ttyoutq_flush(to);
  124         to->to_quota = 0;
  125 
  126         while ((tob = to->to_firstblock) != NULL) {
  127                 TTYOUTQ_REMOVE_HEAD(to);
  128                 uma_zfree(ttyoutq_zone, tob);
  129         }
  130 
  131         MPASS(to->to_nblocks == 0);
  132 }
  133 
  134 size_t
  135 ttyoutq_read(struct ttyoutq *to, void *buf, size_t len)
  136 {
  137         char *cbuf = buf;
  138 
  139         while (len > 0) {
  140                 struct ttyoutq_block *tob;
  141                 size_t cbegin, cend, clen;
  142 
  143                 /* See if there still is data. */
  144                 if (to->to_begin == to->to_end)
  145                         break;
  146                 tob = to->to_firstblock;
  147                 if (tob == NULL)
  148                         break;
  149 
  150                 /*
  151                  * The end address should be the lowest of these three:
  152                  * - The write pointer
  153                  * - The blocksize - we can't read beyond the block
  154                  * - The end address if we could perform the full read
  155                  */
  156                 cbegin = to->to_begin;
  157                 cend = MIN(MIN(to->to_end, to->to_begin + len),
  158                     TTYOUTQ_DATASIZE);
  159                 clen = cend - cbegin;
  160 
  161                 /* Copy the data out of the buffers. */
  162                 memcpy(cbuf, tob->tob_data + cbegin, clen);
  163                 cbuf += clen;
  164                 len -= clen;
  165 
  166                 if (cend == to->to_end) {
  167                         /* Read the complete queue. */
  168                         to->to_begin = 0;
  169                         to->to_end = 0;
  170                 } else if (cend == TTYOUTQ_DATASIZE) {
  171                         /* Read the block until the end. */
  172                         TTYOUTQ_REMOVE_HEAD(to);
  173                         to->to_begin = 0;
  174                         to->to_end -= TTYOUTQ_DATASIZE;
  175                         TTYOUTQ_RECYCLE(to, tob);
  176                 } else {
  177                         /* Read the block partially. */
  178                         to->to_begin += clen;
  179                 }
  180         }
  181 
  182         return (cbuf - (char *)buf);
  183 }
  184 
  185 /*
  186  * An optimized version of ttyoutq_read() which can be used in pseudo
  187  * TTY drivers to directly copy data from the outq to userspace, instead
  188  * of buffering it.
  189  *
  190  * We can only copy data directly if we need to read the entire block
  191  * back to the user, because we temporarily remove the block from the
  192  * queue. Otherwise we need to copy it to a temporary buffer first, to
  193  * make sure data remains in the correct order.
  194  */
  195 int
  196 ttyoutq_read_uio(struct ttyoutq *to, struct tty *tp, struct uio *uio)
  197 {
  198 
  199         while (uio->uio_resid > 0) {
  200                 int error;
  201                 struct ttyoutq_block *tob;
  202                 size_t cbegin, cend, clen;
  203 
  204                 /* See if there still is data. */
  205                 if (to->to_begin == to->to_end)
  206                         return (0);
  207                 tob = to->to_firstblock;
  208                 if (tob == NULL)
  209                         return (0);
  210 
  211                 /*
  212                  * The end address should be the lowest of these three:
  213                  * - The write pointer
  214                  * - The blocksize - we can't read beyond the block
  215                  * - The end address if we could perform the full read
  216                  */
  217                 cbegin = to->to_begin;
  218                 cend = MIN(MIN(to->to_end, to->to_begin + uio->uio_resid),
  219                     TTYOUTQ_DATASIZE);
  220                 clen = cend - cbegin;
  221 
  222                 /*
  223                  * We can prevent buffering in some cases:
  224                  * - We need to read the block until the end.
  225                  * - We don't need to read the block until the end, but
  226                  *   there is no data beyond it, which allows us to move
  227                  *   the write pointer to a new block.
  228                  */
  229                 if (cend == TTYOUTQ_DATASIZE || cend == to->to_end) {
  230                         /*
  231                          * Fast path: zero copy. Remove the first block,
  232                          * so we can unlock the TTY temporarily.
  233                          */
  234                         TTYOUTQ_REMOVE_HEAD(to);
  235                         to->to_begin = 0;
  236                         if (to->to_end <= TTYOUTQ_DATASIZE)
  237                                 to->to_end = 0;
  238                         else
  239                                 to->to_end -= TTYOUTQ_DATASIZE;
  240 
  241                         /* Temporary unlock and copy the data to userspace. */
  242                         tty_unlock(tp);
  243                         error = uiomove(tob->tob_data + cbegin, clen, uio);
  244                         tty_lock(tp);
  245 
  246                         /* Block can now be readded to the list. */
  247                         TTYOUTQ_RECYCLE(to, tob);
  248                 } else {
  249                         char ob[TTYOUTQ_DATASIZE - 1];
  250 
  251                         /*
  252                          * Slow path: store data in a temporary buffer.
  253                          */
  254                         memcpy(ob, tob->tob_data + cbegin, clen);
  255                         to->to_begin += clen;
  256                         MPASS(to->to_begin < TTYOUTQ_DATASIZE);
  257 
  258                         /* Temporary unlock and copy the data to userspace. */
  259                         tty_unlock(tp);
  260                         error = uiomove(ob, clen, uio);
  261                         tty_lock(tp);
  262                 }
  263 
  264                 if (error != 0)
  265                         return (error);
  266         }
  267 
  268         return (0);
  269 }
  270 
  271 size_t
  272 ttyoutq_write(struct ttyoutq *to, const void *buf, size_t nbytes)
  273 {
  274         const char *cbuf = buf;
  275         struct ttyoutq_block *tob;
  276         unsigned int boff;
  277         size_t l;
  278 
  279         while (nbytes > 0) {
  280                 boff = to->to_end % TTYOUTQ_DATASIZE;
  281 
  282                 if (to->to_end == 0) {
  283                         /* First time we're being used or drained. */
  284                         MPASS(to->to_begin == 0);
  285                         tob = to->to_firstblock;
  286                         if (tob == NULL) {
  287                                 /* Queue has no blocks. */
  288                                 break;
  289                         }
  290                         to->to_lastblock = tob;
  291                 } else if (boff == 0) {
  292                         /* We reached the end of this block on last write. */
  293                         tob = to->to_lastblock->tob_next;
  294                         if (tob == NULL) {
  295                                 /* We've reached the watermark. */
  296                                 break;
  297                         }
  298                         to->to_lastblock = tob;
  299                 } else {
  300                         tob = to->to_lastblock;
  301                 }
  302 
  303                 /* Don't copy more than was requested. */
  304                 l = MIN(nbytes, TTYOUTQ_DATASIZE - boff);
  305                 MPASS(l > 0);
  306                 memcpy(tob->tob_data + boff, cbuf, l);
  307 
  308                 cbuf += l;
  309                 nbytes -= l;
  310                 to->to_end += l;
  311         }
  312 
  313         return (cbuf - (const char *)buf);
  314 }
  315 
  316 int
  317 ttyoutq_write_nofrag(struct ttyoutq *to, const void *buf, size_t nbytes)
  318 {
  319         size_t ret;
  320 
  321         if (ttyoutq_bytesleft(to) < nbytes)
  322                 return (-1);
  323 
  324         /* We should always be able to write it back. */
  325         ret = ttyoutq_write(to, buf, nbytes);
  326         MPASS(ret == nbytes);
  327 
  328         return (0);
  329 }
  330 
  331 static void
  332 ttyoutq_startup(void *dummy)
  333 {
  334 
  335         ttyoutq_zone = uma_zcreate("ttyoutq", sizeof(struct ttyoutq_block),
  336             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
  337 }
  338 
  339 SYSINIT(ttyoutq, SI_SUB_DRIVERS, SI_ORDER_FIRST, ttyoutq_startup, NULL);

Cache object: 5f30ba62a262faa5c65dc58babba1451


[ 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.