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/netgraph/ng_tty.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  * ng_tty.c
    3  */
    4 
    5 /*-
    6  * Copyright (c) 1996-1999 Whistle Communications, Inc.
    7  * All rights reserved.
    8  * 
    9  * Subject to the following obligations and disclaimer of warranty, use and
   10  * redistribution of this software, in source or object code forms, with or
   11  * without modifications are expressly permitted by Whistle Communications;
   12  * provided, however, that:
   13  * 1. Any and all reproductions of the source or object code must include the
   14  *    copyright notice above and the following disclaimer of warranties; and
   15  * 2. No rights are granted, in any manner or form, to use Whistle
   16  *    Communications, Inc. trademarks, including the mark "WHISTLE
   17  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
   18  *    such appears in the above copyright notice or in the software.
   19  * 
   20  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
   21  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
   22  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
   23  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
   24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
   25  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
   26  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
   27  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
   28  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
   29  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
   30  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
   31  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
   32  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
   33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   35  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
   36  * OF SUCH DAMAGE.
   37  *
   38  * Author: Archie Cobbs <archie@freebsd.org>
   39  *
   40  * Updated by Andrew Thompson <thompsa@FreeBSD.org> for MPSAFE TTY.
   41  *
   42  * $FreeBSD: stable/8/sys/netgraph/ng_tty.c 215342 2010-11-15 17:48:13Z sobomax $
   43  * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
   44  */
   45 
   46 /*
   47  * This file implements TTY hooks to link in to the netgraph system.  The node
   48  * is created and then passed the callers opened TTY file descriptor number to
   49  * NGM_TTY_SET_TTY, this will hook the tty via ttyhook_register().
   50  *
   51  * Incoming data is delivered directly to ng_tty via the TTY bypass hook as a
   52  * buffer pointer and length, this is converted to a mbuf and passed to the
   53  * peer.
   54  *
   55  * If the TTY device does not support bypass then incoming characters are
   56  * delivered to the hook one at a time, each in its own mbuf. You may
   57  * optionally define a ``hotchar,'' which causes incoming characters to be
   58  * buffered up until either the hotchar is seen or the mbuf is full (MHLEN
   59  * bytes). Then all buffered characters are immediately delivered.
   60  */
   61 
   62 #include <sys/param.h>
   63 #include <sys/systm.h>
   64 #include <sys/conf.h>
   65 #include <sys/errno.h>
   66 #include <sys/fcntl.h>
   67 #include <sys/ioccom.h>
   68 #include <sys/kernel.h>
   69 #include <sys/malloc.h>
   70 #include <sys/mbuf.h>
   71 #include <sys/priv.h>
   72 #include <sys/socket.h>
   73 #include <sys/syslog.h>
   74 #include <sys/tty.h>
   75 #include <sys/ttycom.h>
   76 #include <sys/proc.h>
   77 
   78 #include <net/if.h>
   79 #include <net/if_var.h>
   80 
   81 #include <netgraph/ng_message.h>
   82 #include <netgraph/netgraph.h>
   83 #include <netgraph/ng_tty.h>
   84 
   85 /* Per-node private info */
   86 struct ngt_softc {
   87         struct tty      *tp;            /* Terminal device */
   88         node_p          node;           /* Netgraph node */
   89         hook_p          hook;           /* Netgraph hook */
   90         struct ifqueue  outq;           /* Queue of outgoing data */
   91         size_t          outqlen;        /* Number of bytes in outq */
   92         struct mbuf     *m;             /* Incoming non-bypass data buffer */
   93         short           hotchar;        /* Hotchar, or -1 if none */
   94         u_int           flags;          /* Flags */
   95 };
   96 typedef struct ngt_softc *sc_p;
   97 
   98 /* Flags */
   99 #define FLG_DEBUG               0x0002
  100 
  101 /* Netgraph methods */
  102 static ng_constructor_t         ngt_constructor;
  103 static ng_rcvmsg_t              ngt_rcvmsg;
  104 static ng_shutdown_t            ngt_shutdown;
  105 static ng_newhook_t             ngt_newhook;
  106 static ng_connect_t             ngt_connect;
  107 static ng_rcvdata_t             ngt_rcvdata;
  108 static ng_disconnect_t          ngt_disconnect;
  109 
  110 #define ERROUT(x)               do { error = (x); goto done; } while (0)
  111 
  112 static th_getc_inject_t         ngt_getc_inject;
  113 static th_getc_poll_t           ngt_getc_poll;
  114 static th_rint_t                ngt_rint;
  115 static th_rint_bypass_t         ngt_rint_bypass;
  116 static th_rint_poll_t           ngt_rint_poll;
  117 
  118 static struct ttyhook ngt_hook = {
  119         .th_getc_inject = ngt_getc_inject,
  120         .th_getc_poll = ngt_getc_poll,
  121         .th_rint = ngt_rint,
  122         .th_rint_bypass = ngt_rint_bypass,
  123         .th_rint_poll = ngt_rint_poll,
  124 };
  125 
  126 /* Netgraph node type descriptor */
  127 static struct ng_type typestruct = {
  128         .version =      NG_ABI_VERSION,
  129         .name =         NG_TTY_NODE_TYPE,
  130         .constructor =  ngt_constructor,
  131         .rcvmsg =       ngt_rcvmsg,
  132         .shutdown =     ngt_shutdown,
  133         .newhook =      ngt_newhook,
  134         .connect =      ngt_connect,
  135         .rcvdata =      ngt_rcvdata,
  136         .disconnect =   ngt_disconnect,
  137 };
  138 NETGRAPH_INIT(tty, &typestruct);
  139 
  140 #define NGTLOCK(sc)     IF_LOCK(&sc->outq)
  141 #define NGTUNLOCK(sc)   IF_UNLOCK(&sc->outq)
  142 
  143 /******************************************************************
  144                     NETGRAPH NODE METHODS
  145 ******************************************************************/
  146 
  147 /*
  148  * Initialize a new node of this type.
  149  *
  150  * We only allow nodes to be created as a result of setting
  151  * the line discipline on a tty, so always return an error if not.
  152  */
  153 static int
  154 ngt_constructor(node_p node)
  155 {
  156         sc_p sc;
  157 
  158         /* Allocate private structure */
  159         sc = malloc(sizeof(*sc), M_NETGRAPH, M_NOWAIT | M_ZERO);
  160         if (sc == NULL)
  161                 return (ENOMEM);
  162 
  163         NG_NODE_SET_PRIVATE(node, sc);
  164         sc->node = node;
  165 
  166         mtx_init(&sc->outq.ifq_mtx, "ng_tty node+queue", NULL, MTX_DEF);
  167         IFQ_SET_MAXLEN(&sc->outq, ifqmaxlen);
  168 
  169         return (0);
  170 }
  171 
  172 /*
  173  * Add a new hook. There can only be one.
  174  */
  175 static int
  176 ngt_newhook(node_p node, hook_p hook, const char *name)
  177 {
  178         const sc_p sc = NG_NODE_PRIVATE(node);
  179 
  180         if (strcmp(name, NG_TTY_HOOK))
  181                 return (EINVAL);
  182 
  183         if (sc->hook)
  184                 return (EISCONN);
  185 
  186         NGTLOCK(sc);
  187         sc->hook = hook;
  188         NGTUNLOCK(sc);
  189 
  190         return (0);
  191 }
  192 
  193 /*
  194  * Set the hook into queueing mode (for outgoing packets),
  195  * so that we wont deliver mbuf thru the whole graph holding
  196  * tty locks.
  197  */
  198 static int
  199 ngt_connect(hook_p hook)
  200 {
  201         NG_HOOK_FORCE_QUEUE(hook);
  202         return (0);
  203 }
  204 
  205 /*
  206  * Disconnect the hook
  207  */
  208 static int
  209 ngt_disconnect(hook_p hook)
  210 {
  211         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  212 
  213         if (hook != sc->hook)
  214                 panic(__func__);
  215 
  216         NGTLOCK(sc);
  217         sc->hook = NULL;
  218         NGTUNLOCK(sc);
  219 
  220         return (0);
  221 }
  222 
  223 /*
  224  * Remove this node. The does the netgraph portion of the shutdown.
  225  */
  226 static int
  227 ngt_shutdown(node_p node)
  228 {
  229         const sc_p sc = NG_NODE_PRIVATE(node);
  230         struct tty *tp;
  231 
  232         tp = sc->tp;
  233         if (tp != NULL) {
  234                 tty_lock(tp);
  235                 ttyhook_unregister(tp);
  236         }
  237         /* Free resources */
  238         IF_DRAIN(&sc->outq);
  239         mtx_destroy(&(sc)->outq.ifq_mtx);
  240         NG_NODE_UNREF(sc->node);
  241         free(sc, M_NETGRAPH);
  242 
  243         return (0);
  244 }
  245 
  246 /*
  247  * Receive control message
  248  */
  249 static int
  250 ngt_rcvmsg(node_p node, item_p item, hook_p lasthook)
  251 {
  252         struct proc *p;
  253         const sc_p sc = NG_NODE_PRIVATE(node);
  254         struct ng_mesg *msg, *resp = NULL;
  255         int error = 0;
  256 
  257         NGI_GET_MSG(item, msg);
  258         switch (msg->header.typecookie) {
  259         case NGM_TTY_COOKIE:
  260                 switch (msg->header.cmd) {
  261                 case NGM_TTY_SET_TTY:
  262                         if (sc->tp != NULL)
  263                                 return (EBUSY);
  264                         
  265                         p = pfind(((int *)msg->data)[0]);
  266                         if (p == NULL || (p->p_flag & P_WEXIT))
  267                                 return (ESRCH);
  268                         _PHOLD(p);
  269                         PROC_UNLOCK(p);
  270                         error = ttyhook_register(&sc->tp, p, ((int *)msg->data)[1],
  271                             &ngt_hook, sc);
  272                         PRELE(p);
  273                         if (error != 0)
  274                                 return (error);
  275                         break;
  276                 case NGM_TTY_SET_HOTCHAR:
  277                     {
  278                         int     hotchar;
  279 
  280                         if (msg->header.arglen != sizeof(int))
  281                                 ERROUT(EINVAL);
  282                         hotchar = *((int *) msg->data);
  283                         if (hotchar != (u_char) hotchar && hotchar != -1)
  284                                 ERROUT(EINVAL);
  285                         sc->hotchar = hotchar;  /* race condition is OK */
  286                         break;
  287                     }
  288                 case NGM_TTY_GET_HOTCHAR:
  289                         NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
  290                         if (!resp)
  291                                 ERROUT(ENOMEM);
  292                         /* Race condition here is OK */
  293                         *((int *) resp->data) = sc->hotchar;
  294                         break;
  295                 default:
  296                         ERROUT(EINVAL);
  297                 }
  298                 break;
  299         default:
  300                 ERROUT(EINVAL);
  301         }
  302 done:
  303         NG_RESPOND_MSG(error, node, item, resp);
  304         NG_FREE_MSG(msg);
  305         return (error);
  306 }
  307 
  308 /*
  309  * Receive incoming data from netgraph system. Put it on our
  310  * output queue and start output if necessary.
  311  */
  312 static int
  313 ngt_rcvdata(hook_p hook, item_p item)
  314 {
  315         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  316         struct tty *tp = sc->tp;
  317         struct mbuf *m;
  318 
  319         if (hook != sc->hook)
  320                 panic(__func__);
  321 
  322         NGI_GET_M(item, m);
  323         NG_FREE_ITEM(item);
  324 
  325         if (tp == NULL) {
  326                 NG_FREE_M(m);
  327                 return (ENXIO);
  328         }
  329 
  330         IF_LOCK(&sc->outq);
  331         if (_IF_QFULL(&sc->outq)) {
  332                 _IF_DROP(&sc->outq);
  333                 IF_UNLOCK(&sc->outq);
  334                 NG_FREE_M(m);
  335                 return (ENOBUFS);
  336         }
  337 
  338         _IF_ENQUEUE(&sc->outq, m);
  339         sc->outqlen += m->m_pkthdr.len;
  340         IF_UNLOCK(&sc->outq);
  341 
  342         /* notify the TTY that data is ready */
  343         tty_lock(tp);
  344         if (!tty_gone(tp))
  345                 ttydevsw_outwakeup(tp);
  346         tty_unlock(tp);
  347 
  348         return (0);
  349 }
  350 
  351 static size_t
  352 ngt_getc_inject(struct tty *tp, void *buf, size_t len)
  353 {
  354         sc_p sc = ttyhook_softc(tp);
  355         size_t total = 0;
  356         int length;
  357 
  358         while (len) {
  359                 struct mbuf *m;
  360 
  361                 /* Remove first mbuf from queue */
  362                 IF_DEQUEUE(&sc->outq, m);
  363                 if (m == NULL)
  364                         break;
  365 
  366                 /* Send as much of it as possible */
  367                 while (m != NULL) {
  368                         length = min(m->m_len, len);
  369                         memcpy((char *)buf + total, mtod(m, char *), length);
  370 
  371                         m->m_data += length;
  372                         m->m_len -= length;
  373                         total += length;
  374                         len -= length;
  375 
  376                         if (m->m_len > 0)
  377                                 break;  /* device can't take any more */
  378                         m = m_free(m);
  379                 }
  380 
  381                 /* Put remainder of mbuf chain (if any) back on queue */
  382                 if (m != NULL) {
  383                         IF_PREPEND(&sc->outq, m);
  384                         break;
  385                 }
  386         }
  387         IF_LOCK(&sc->outq);
  388         sc->outqlen -= total;
  389         IF_UNLOCK(&sc->outq);
  390         MPASS(sc->outqlen >= 0);
  391 
  392         return (total);
  393 }
  394 
  395 static size_t
  396 ngt_getc_poll(struct tty *tp)
  397 {
  398         sc_p sc = ttyhook_softc(tp);
  399 
  400         return (sc->outqlen);
  401 }
  402 
  403 /*
  404  * Optimised TTY input.
  405  *
  406  * We get a buffer pointer to hopefully a complete data frame. Do not check for
  407  * the hotchar, just pass it on.
  408  */
  409 static size_t
  410 ngt_rint_bypass(struct tty *tp, const void *buf, size_t len)
  411 {
  412         sc_p sc = ttyhook_softc(tp);
  413         node_p node = sc->node;
  414         struct mbuf *m, *mb;
  415         size_t total = 0;
  416         int error = 0, length;
  417 
  418         tty_lock_assert(tp, MA_OWNED);
  419 
  420         if (sc->hook == NULL)
  421                 return (0);
  422 
  423         m = m_getm2(NULL, len, M_DONTWAIT, MT_DATA, M_PKTHDR);
  424         if (m == NULL) {
  425                 if (sc->flags & FLG_DEBUG)
  426                         log(LOG_ERR,
  427                             "%s: can't get mbuf\n", NG_NODE_NAME(node));
  428                 return (0);
  429         }
  430         m->m_pkthdr.rcvif = NULL;
  431 
  432         for (mb = m; mb != NULL; mb = mb->m_next) {
  433                 length = min(M_TRAILINGSPACE(mb), len - total);
  434 
  435                 memcpy(mtod(m, char *), (const char *)buf + total, length);
  436                 mb->m_len = length;
  437                 total += length;
  438                 m->m_pkthdr.len += length;
  439         }
  440         if (sc->m != NULL) {
  441                 /*
  442                  * Odd, we have changed from non-bypass to bypass. It is
  443                  * unlikely but not impossible, flush the data first.
  444                  */
  445                 sc->m->m_data = sc->m->m_pktdat;
  446                 NG_SEND_DATA_ONLY(error, sc->hook, sc->m);
  447                 sc->m = NULL;
  448         }
  449         NG_SEND_DATA_ONLY(error, sc->hook, m);
  450 
  451         return (total);
  452 }
  453 
  454 /*
  455  * Receive data coming from the device one char at a time, when it is not in
  456  * bypass mode.
  457  */
  458 static int
  459 ngt_rint(struct tty *tp, char c, int flags)
  460 {
  461         sc_p sc = ttyhook_softc(tp);
  462         node_p node = sc->node;
  463         struct mbuf *m;
  464         int error = 0;
  465 
  466         tty_lock_assert(tp, MA_OWNED);
  467 
  468         if (sc->hook == NULL)
  469                 return (0);
  470 
  471         if (flags != 0) {
  472                 /* framing error or overrun on this char */
  473                 if (sc->flags & FLG_DEBUG)
  474                         log(LOG_DEBUG, "%s: line error %x\n",
  475                             NG_NODE_NAME(node), flags);
  476                 return (0);
  477         }
  478 
  479         /* Get a new header mbuf if we need one */
  480         if (!(m = sc->m)) {
  481                 MGETHDR(m, M_DONTWAIT, MT_DATA);
  482                 if (!m) {
  483                         if (sc->flags & FLG_DEBUG)
  484                                 log(LOG_ERR,
  485                                     "%s: can't get mbuf\n", NG_NODE_NAME(node));
  486                         return (ENOBUFS);
  487                 }
  488                 m->m_len = m->m_pkthdr.len = 0;
  489                 m->m_pkthdr.rcvif = NULL;
  490                 sc->m = m;
  491         }
  492 
  493         /* Add char to mbuf */
  494         *mtod(m, u_char *) = c;
  495         m->m_data++;
  496         m->m_len++;
  497         m->m_pkthdr.len++;
  498 
  499         /* Ship off mbuf if it's time */
  500         if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
  501                 m->m_data = m->m_pktdat;
  502                 sc->m = NULL;
  503                 NG_SEND_DATA_ONLY(error, sc->hook, m);  /* Will queue */
  504         }
  505 
  506         return (error);
  507 }
  508 
  509 static size_t
  510 ngt_rint_poll(struct tty *tp)
  511 {
  512         /* We can always accept input */
  513         return (1);
  514 }
  515 

Cache object: f19d1cbe924fabf0cdc74dcb7cadf9c6


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