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 /*
    3  * ng_tty.c
    4  *
    5  * Copyright (c) 1996-1999 Whistle Communications, Inc.
    6  * All rights reserved.
    7  * 
    8  * Subject to the following obligations and disclaimer of warranty, use and
    9  * redistribution of this software, in source or object code forms, with or
   10  * without modifications are expressly permitted by Whistle Communications;
   11  * provided, however, that:
   12  * 1. Any and all reproductions of the source or object code must include the
   13  *    copyright notice above and the following disclaimer of warranties; and
   14  * 2. No rights are granted, in any manner or form, to use Whistle
   15  *    Communications, Inc. trademarks, including the mark "WHISTLE
   16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
   17  *    such appears in the above copyright notice or in the software.
   18  * 
   19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
   20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
   21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
   22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
   23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
   24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
   25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
   26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
   27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
   28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
   29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
   30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
   31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
   32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
   35  * OF SUCH DAMAGE.
   36  *
   37  * Author: Archie Cobbs <archie@freebsd.org>
   38  *
   39  * $FreeBSD: stable/3/sys/netgraph/ng_tty.c 67532 2000-10-24 22:45:12Z julian $
   40  * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
   41  */
   42 
   43 /*
   44  * This file implements a terminal line discipline that is also a
   45  * netgraph node. Installing this line discipline on a terminal device
   46  * instantiates a new netgraph node of this type, which allows access
   47  * to the device via the "hook" hook of the node.
   48  *
   49  * Once the line discipline is installed, you can find out the name
   50  * of the corresponding netgraph node via a NGIOCGINFO ioctl().
   51  *
   52  * Incoming characters are delievered to the hook one at a time, each
   53  * in its own mbuf. You may optionally define a ``hotchar,'' which causes
   54  * incoming characters to be buffered up until either the hotchar is
   55  * seen or the mbuf is full (MHLEN bytes). Then all buffered characters
   56  * are immediately delivered.
   57  *
   58  * NOTE: This node operates at spltty().
   59  */
   60 
   61 #include <sys/param.h>
   62 #include <sys/systm.h>
   63 #include <sys/kernel.h>
   64 #include <sys/conf.h>
   65 #include <sys/proc.h>
   66 #include <sys/mbuf.h>
   67 #include <sys/malloc.h>
   68 #include <sys/fcntl.h>
   69 #include <sys/tty.h>
   70 #include <sys/ttycom.h>
   71 #include <sys/syslog.h>
   72 #include <sys/errno.h>
   73 #include <sys/ioccom.h>
   74 
   75 #include <netgraph/ng_message.h>
   76 #include <netgraph/netgraph.h>
   77 #include <netgraph/ng_tty.h>
   78 
   79 #ifdef __i386__                 /* fiddle with the spl locking */
   80 #include <machine/ipl.h>
   81 #include <i386/isa/intr_machdep.h>
   82 #endif
   83 
   84 /* Misc defs */
   85 #define MAX_MBUFQ               3       /* Max number of queued mbufs */
   86 #define NGT_HIWATER             400     /* High water mark on output */
   87 
   88 /* Per-node private info */
   89 struct ngt_sc {
   90         struct  tty *tp;                /* Terminal device */
   91         node_p  node;                   /* Netgraph node */
   92         hook_p  hook;                   /* Netgraph hook */
   93         struct  mbuf *m;                /* Incoming data buffer */
   94         struct  mbuf *qhead, **qtail;   /* Queue of outgoing mbuf's */
   95         short   qlen;                   /* Length of queue */
   96         short   hotchar;                /* Hotchar, or -1 if none */
   97         u_int   flags;                  /* Flags */
   98         struct  callout_handle chand;   /* See man timeout(9) */
   99 };
  100 typedef struct ngt_sc *sc_p;
  101 
  102 /* Flags */
  103 #define FLG_TIMEOUT             0x0001  /* A timeout is pending */
  104 #define FLG_DEBUG               0x0002
  105 
  106 /* Debugging */
  107 #ifdef INVARIANTS
  108 #define QUEUECHECK(sc)                                                  \
  109     do {                                                                \
  110       struct mbuf       **mp;                                           \
  111       int               k;                                              \
  112                                                                         \
  113       for (k = 0, mp = &sc->qhead;                                      \
  114         k <= MAX_MBUFQ && *mp;                                          \
  115         k++, mp = &(*mp)->m_nextpkt);                                   \
  116       if (k != sc->qlen || k > MAX_MBUFQ || *mp || mp != sc->qtail)     \
  117         panic(__FUNCTION__ ": queue");                                  \
  118     } while (0)
  119 #else
  120 #define QUEUECHECK(sc)  do {} while (0)
  121 #endif
  122 
  123 /* Line discipline methods */
  124 static int      ngt_open(dev_t dev, struct tty *tp);
  125 static int      ngt_close(struct tty *tp, int flag);
  126 static int      ngt_read(struct tty *tp, struct uio *uio, int flag);
  127 static int      ngt_write(struct tty *tp, struct uio *uio, int flag);
  128 static int      ngt_tioctl(struct tty *tp,
  129                     u_long cmd, caddr_t data, int flag, struct proc *);
  130 static int      ngt_input(int c, struct tty *tp);
  131 static int      ngt_start(struct tty *tp);
  132 
  133 /* Netgraph methods */
  134 static ng_constructor_t ngt_constructor;
  135 static ng_rcvmsg_t      ngt_rcvmsg;
  136 static ng_shutdown_t    ngt_shutdown;
  137 static ng_newhook_t     ngt_newhook;
  138 static ng_rcvdata_t     ngt_rcvdata;
  139 static ng_disconnect_t  ngt_disconnect;
  140 static int      ngt_mod_event(module_t mod, int event, void *data);
  141 
  142 /* Other stuff */
  143 static void     ngt_timeout(void *arg);
  144 
  145 #define ERROUT(x)               do { error = (x); goto done; } while (0)
  146 
  147 /* Line discipline descriptor */
  148 static struct linesw ngt_disc = {
  149         ngt_open,
  150         ngt_close,
  151         ngt_read,
  152         ngt_write,
  153         ngt_tioctl,
  154         ngt_input,
  155         ngt_start,
  156         ttymodem,
  157         NG_TTY_DFL_HOTCHAR      /* XXX can't change this in serial driver */
  158 };
  159 
  160 /* Netgraph node type descriptor */
  161 static struct ng_type typestruct = {
  162         NG_VERSION,
  163         NG_TTY_NODE_TYPE,
  164         ngt_mod_event,
  165         ngt_constructor,
  166         ngt_rcvmsg,
  167         ngt_shutdown,
  168         ngt_newhook,
  169         NULL,
  170         NULL,
  171         ngt_rcvdata,
  172         ngt_rcvdata,
  173         ngt_disconnect,
  174         NULL
  175 };
  176 NETGRAPH_INIT(tty, &typestruct);
  177 
  178 static int ngt_unit;
  179 static int ngt_nodeop_ok;       /* OK to create/remove node */
  180 static int ngt_ldisc;
  181 
  182 /******************************************************************
  183                     LINE DISCIPLINE METHODS
  184 ******************************************************************/
  185 
  186 /*
  187  * Set our line discipline on the tty.
  188  * Called from device open routine or ttioctl() at >= splsofttty()
  189  */
  190 static int
  191 ngt_open(dev_t dev, struct tty *tp)
  192 {
  193         struct proc *const p = curproc; /* XXX */
  194         char name[sizeof(NG_TTY_NODE_TYPE) + 8];
  195         sc_p sc;
  196         int s, error;
  197 
  198         /* Super-user only */
  199         if ((error = suser(p->p_ucred, &p->p_acflag)))
  200                 return (error);
  201         s = splnet();
  202         (void) spltty();        /* XXX is this necessary? */
  203 
  204         /* Already installed? */
  205         if (tp->t_line == NETGRAPHDISC) {
  206                 sc = (sc_p) tp->t_sc;
  207                 if (sc != NULL && sc->tp == tp)
  208                         goto done;
  209         }
  210 
  211         /* Initialize private struct */
  212         MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK);
  213         if (sc == NULL) {
  214                 error = ENOMEM;
  215                 goto done;
  216         }
  217         bzero(sc, sizeof(*sc));
  218         sc->tp = tp;
  219         sc->hotchar = NG_TTY_DFL_HOTCHAR;
  220         sc->qtail = &sc->qhead;
  221         QUEUECHECK(sc);
  222         callout_handle_init(&sc->chand);
  223 
  224         /* Setup netgraph node */
  225         ngt_nodeop_ok = 1;
  226         error = ng_make_node_common(&typestruct, &sc->node);
  227         ngt_nodeop_ok = 0;
  228         if (error) {
  229                 FREE(sc, M_NETGRAPH);
  230                 goto done;
  231         }
  232         snprintf(name, sizeof(name), "%s%d", typestruct.name, ngt_unit++);
  233 
  234         /* Set back pointers */
  235         sc->node->private = sc;
  236         tp->t_sc = (caddr_t) sc;
  237 
  238         /* Assign node its name */
  239         if ((error = ng_name_node(sc->node, name))) {
  240                 log(LOG_ERR, "%s: node name exists?\n", name);
  241                 ngt_nodeop_ok = 1;
  242                 ng_rmnode(sc->node);
  243                 ngt_nodeop_ok = 0;
  244                 goto done;
  245         }
  246 
  247         /*
  248          * Pre-allocate cblocks to the an appropriate amount.
  249          * I'm not sure what is appropriate.
  250          */
  251         ttyflush(tp, FREAD | FWRITE);
  252         clist_alloc_cblocks(&tp->t_canq, 0, 0);
  253         clist_alloc_cblocks(&tp->t_rawq, 0, 0);
  254         clist_alloc_cblocks(&tp->t_outq,
  255             MLEN + NGT_HIWATER, MLEN + NGT_HIWATER);
  256 
  257 done:
  258         /* Done */
  259         splx(s);
  260         return (error);
  261 }
  262 
  263 /*
  264  * Line specific close routine, called from device close routine
  265  * and from ttioctl at >= splsofttty(). This causes the node to
  266  * be destroyed as well.
  267  */
  268 static int
  269 ngt_close(struct tty *tp, int flag)
  270 {
  271         const sc_p sc = (sc_p) tp->t_sc;
  272         int s;
  273 
  274         s = spltty();
  275         ttyflush(tp, FREAD | FWRITE);
  276         clist_free_cblocks(&tp->t_outq);
  277         tp->t_line = 0;
  278         if (sc != NULL) {
  279                 if (sc->flags & FLG_TIMEOUT) {
  280                         untimeout(ngt_timeout, sc, sc->chand);
  281                         sc->flags &= ~FLG_TIMEOUT;
  282                 }
  283                 ngt_nodeop_ok = 1;
  284                 ng_rmnode(sc->node);
  285                 ngt_nodeop_ok = 0;
  286                 tp->t_sc = NULL;
  287         }
  288         splx(s);
  289         return (0);
  290 }
  291 
  292 /*
  293  * Once the device has been turned into a node, we don't allow reading.
  294  */
  295 static int
  296 ngt_read(struct tty *tp, struct uio *uio, int flag)
  297 {
  298         return (EIO);
  299 }
  300 
  301 /*
  302  * Once the device has been turned into a node, we don't allow writing.
  303  */
  304 static int
  305 ngt_write(struct tty *tp, struct uio *uio, int flag)
  306 {
  307         return (EIO);
  308 }
  309 
  310 /*
  311  * We implement the NGIOCGINFO ioctl() defined in ng_message.h.
  312  */
  313 static int
  314 ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p)
  315 {
  316         const sc_p sc = (sc_p) tp->t_sc;
  317         int s, error = 0;
  318 
  319         s = spltty();
  320         switch (cmd) {
  321         case NGIOCGINFO:
  322             {
  323                 struct nodeinfo *const ni = (struct nodeinfo *) data;
  324                 const node_p node = sc->node;
  325 
  326                 bzero(ni, sizeof(*ni));
  327                 if (node->name)
  328                         strncpy(ni->name, node->name, sizeof(ni->name) - 1);
  329                 strncpy(ni->type, node->type->name, sizeof(ni->type) - 1);
  330                 ni->id = (u_int32_t) node;
  331                 ni->hooks = node->numhooks;
  332                 break;
  333             }
  334         default:
  335                 ERROUT(ENOIOCTL);
  336         }
  337 done:
  338         splx(s);
  339         return (error);
  340 }
  341 
  342 /*
  343  * Receive data coming from the device. We get one character at
  344  * a time, which is kindof silly.
  345  * Only guaranteed to be at splsofttty() or spltty().
  346  */
  347 static int
  348 ngt_input(int c, struct tty *tp)
  349 {
  350         const sc_p sc = (sc_p) tp->t_sc;
  351         const node_p node = sc->node;
  352         struct mbuf *m;
  353         int s, error = 0;
  354 
  355         if (!sc || tp != sc->tp)
  356                 return (0);
  357         s = spltty();
  358         if (!sc->hook)
  359                 ERROUT(0);
  360 
  361         /* Check for error conditions */
  362         if ((tp->t_state & TS_CONNECTED) == 0) {
  363                 if (sc->flags & FLG_DEBUG)
  364                         log(LOG_DEBUG, "%s: no carrier\n", node->name);
  365                 ERROUT(0);
  366         }
  367         if (c & TTY_ERRORMASK) {
  368                 /* framing error or overrun on this char */
  369                 if (sc->flags & FLG_DEBUG)
  370                         log(LOG_DEBUG, "%s: line error %x\n",
  371                             node->name, c & TTY_ERRORMASK);
  372                 ERROUT(0);
  373         }
  374         c &= TTY_CHARMASK;
  375 
  376         /* Get a new header mbuf if we need one */
  377         if (!(m = sc->m)) {
  378                 MGETHDR(m, M_DONTWAIT, MT_DATA);
  379                 if (!m) {
  380                         if (sc->flags & FLG_DEBUG)
  381                                 log(LOG_ERR,
  382                                     "%s: can't get mbuf\n", node->name);
  383                         ERROUT(ENOBUFS);
  384                 }
  385                 m->m_len = m->m_pkthdr.len = 0;
  386                 m->m_pkthdr.rcvif = NULL;
  387                 sc->m = m;
  388         }
  389 
  390         /* Add char to mbuf */
  391         *mtod(m, u_char *) = c;
  392         m->m_data++;
  393         m->m_len++;
  394         m->m_pkthdr.len++;
  395 
  396         /* Ship off mbuf if it's time */
  397         if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
  398                 m->m_data = m->m_pktdat;
  399                 error = ng_queue_data(sc->hook, m, NULL);
  400                 sc->m = NULL;
  401         }
  402 done:
  403         splx(s);
  404         return (error);
  405 }
  406 
  407 /*
  408  * This is called when the device driver is ready for more output.
  409  * Called from tty system at splsofttty() or spltty().
  410  * Also call from ngt_rcv_data() when a new mbuf is available for output.
  411  */
  412 static int
  413 ngt_start(struct tty *tp)
  414 {
  415         const sc_p sc = (sc_p) tp->t_sc;
  416         int s;
  417 
  418         s = spltty();
  419         while (tp->t_outq.c_cc < NGT_HIWATER) { /* XXX 2.2 specific ? */
  420                 struct mbuf *m = sc->qhead;
  421 
  422                 /* Remove first mbuf from queue */
  423                 if (!m)
  424                         break;
  425                 if ((sc->qhead = m->m_nextpkt) == NULL)
  426                         sc->qtail = &sc->qhead;
  427                 sc->qlen--;
  428                 QUEUECHECK(sc);
  429 
  430                 /* Send as much of it as possible */
  431                 while (m) {
  432                         struct mbuf *m2;
  433                         int     sent;
  434 
  435                         sent = m->m_len
  436                             - b_to_q(mtod(m, u_char *), m->m_len, &tp->t_outq);
  437                         m->m_data += sent;
  438                         m->m_len -= sent;
  439                         if (m->m_len > 0)
  440                                 break;  /* device can't take no more */
  441                         MFREE(m, m2);
  442                         m = m2;
  443                 }
  444 
  445                 /* Put remainder of mbuf chain (if any) back on queue */
  446                 if (m) {
  447                         m->m_nextpkt = sc->qhead;
  448                         sc->qhead = m;
  449                         if (sc->qtail == &sc->qhead)
  450                                 sc->qtail = &m->m_nextpkt;
  451                         sc->qlen++;
  452                         QUEUECHECK(sc);
  453                         break;
  454                 }
  455         }
  456 
  457         /* Call output process whether or not there is any output. We are
  458          * being called in lieu of ttstart and must do what it would. */
  459         if (tp->t_oproc != NULL)
  460                 (*tp->t_oproc) (tp);
  461 
  462         /* This timeout is needed for operation on a pseudo-tty, because the
  463          * pty code doesn't call pppstart after it has drained the t_outq. */
  464         if (sc->qhead && (sc->flags & FLG_TIMEOUT) == 0) {
  465                 sc->chand = timeout(ngt_timeout, sc, 1);
  466                 sc->flags |= FLG_TIMEOUT;
  467         }
  468         splx(s);
  469         return (0);
  470 }
  471 
  472 /*
  473  * We still have data to output to the device, so try sending more.
  474  */
  475 static void
  476 ngt_timeout(void *arg)
  477 {
  478         const sc_p sc = (sc_p) arg;
  479         int s;
  480 
  481         s = spltty();
  482         sc->flags &= ~FLG_TIMEOUT;
  483         ngt_start(sc->tp);
  484         splx(s);
  485 }
  486 
  487 /******************************************************************
  488                     NETGRAPH NODE METHODS
  489 ******************************************************************/
  490 
  491 /*
  492  * Initialize a new node of this type.
  493  *
  494  * We only allow nodes to be created as a result of setting
  495  * the line discipline on a tty, so always return an error if not.
  496  */
  497 static int
  498 ngt_constructor(node_p *nodep)
  499 {
  500         if (!ngt_nodeop_ok)
  501                 return (EOPNOTSUPP);
  502         return (ng_make_node_common(&typestruct, nodep));
  503 }
  504 
  505 /*
  506  * Add a new hook. There can only be one.
  507  */
  508 static int
  509 ngt_newhook(node_p node, hook_p hook, const char *name)
  510 {
  511         const sc_p sc = node->private;
  512         int s, error = 0;
  513 
  514         if (strcmp(name, NG_TTY_HOOK))
  515                 return (EINVAL);
  516         s = spltty();
  517         if (sc->hook)
  518                 ERROUT(EISCONN);
  519         sc->hook = hook;
  520 done:
  521         splx(s);
  522         return (error);
  523 }
  524 
  525 /*
  526  * Disconnect the hook
  527  */
  528 static int
  529 ngt_disconnect(hook_p hook)
  530 {
  531         const sc_p sc = hook->node->private;
  532         int s;
  533 
  534         s = spltty();
  535         if (hook != sc->hook)
  536                 panic(__FUNCTION__);
  537         sc->hook = NULL;
  538         m_freem(sc->m);
  539         sc->m = NULL;
  540         splx(s);
  541         return (0);
  542 }
  543 
  544 /*
  545  * Remove this node. The does the netgraph portion of the shutdown.
  546  * This should only be called indirectly from ngt_close().
  547  */
  548 static int
  549 ngt_shutdown(node_p node)
  550 {
  551         const sc_p sc = node->private;
  552 
  553         if (!ngt_nodeop_ok)
  554                 return (EOPNOTSUPP);
  555         ng_unname(node);
  556         ng_cutlinks(node);
  557         node->private = NULL;
  558         ng_unref(sc->node);
  559         m_freem(sc->qhead);
  560         m_freem(sc->m);
  561         bzero(sc, sizeof(*sc));
  562         FREE(sc, M_NETGRAPH);
  563         return (0);
  564 }
  565 
  566 /*
  567  * Receive incoming data from netgraph system. Put it on our
  568  * output queue and start output if necessary.
  569  */
  570 static int
  571 ngt_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
  572 {
  573         const sc_p sc = hook->node->private;
  574         int s, error = 0;
  575 
  576         if (hook != sc->hook)
  577                 panic(__FUNCTION__);
  578         NG_FREE_META(meta);
  579         s = spltty();
  580         if (sc->qlen >= MAX_MBUFQ)
  581                 ERROUT(ENOBUFS);
  582         m->m_nextpkt = NULL;
  583         *sc->qtail = m;
  584         sc->qtail = &m->m_nextpkt;
  585         sc->qlen++;
  586         QUEUECHECK(sc);
  587         m = NULL;
  588         if (sc->qlen == 1)
  589                 ngt_start(sc->tp);
  590 done:
  591         splx(s);
  592         if (m)
  593                 m_freem(m);
  594         return (error);
  595 }
  596 
  597 /*
  598  * Receive control message
  599  */
  600 static int
  601 ngt_rcvmsg(node_p node, struct ng_mesg *msg, const char *retaddr,
  602            struct ng_mesg **rptr)
  603 {
  604         const sc_p sc = (sc_p) node->private;
  605         struct ng_mesg *resp = NULL;
  606         int error = 0;
  607 
  608         switch (msg->header.typecookie) {
  609         case NGM_TTY_COOKIE:
  610                 switch (msg->header.cmd) {
  611                 case NGM_TTY_SET_HOTCHAR:
  612                     {
  613                         int     hotchar;
  614 
  615                         if (msg->header.arglen != sizeof(int))
  616                                 ERROUT(EINVAL);
  617                         hotchar = *((int *) msg->data);
  618                         if (hotchar != (u_char) hotchar && hotchar != -1)
  619                                 ERROUT(EINVAL);
  620                         sc->hotchar = hotchar;  /* race condition is OK */
  621                         break;
  622                     }
  623                 case NGM_TTY_GET_HOTCHAR:
  624                         NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
  625                         if (!resp)
  626                                 ERROUT(ENOMEM);
  627                         /* Race condition here is OK */
  628                         *((int *) resp->data) = sc->hotchar;
  629                         break;
  630                 default:
  631                         ERROUT(EINVAL);
  632                 }
  633                 break;
  634         default:
  635                 ERROUT(EINVAL);
  636         }
  637         if (rptr)
  638                 *rptr = resp;
  639         else if (resp)
  640                 FREE(resp, M_NETGRAPH);
  641 
  642 done:
  643         FREE(msg, M_NETGRAPH);
  644         return (error);
  645 }
  646 
  647 /******************************************************************
  648                         INITIALIZATION
  649 ******************************************************************/
  650 
  651 /*
  652  * Handle loading and unloading for this node type
  653  */
  654 static int
  655 ngt_mod_event(module_t mod, int event, void *data)
  656 {
  657         /* struct ng_type *const type = data;*/
  658         int s, error = 0;
  659 
  660         switch (event) {
  661         case MOD_LOAD:
  662 #ifdef __i386__
  663                 /* Insure the soft net "engine" can't run during spltty code */
  664                 s = splhigh();
  665                 tty_imask |= softnet_imask; /* spltty() block spl[soft]net() */
  666                 net_imask |= softtty_imask; /* splimp() block splsofttty() */
  667                 net_imask |= tty_imask;     /* splimp() block spltty() */
  668                 update_intr_masks();
  669                 splx(s);
  670 
  671                 if (bootverbose)
  672                         log(LOG_DEBUG, "new masks: bio %x, tty %x, net %x\n",
  673                             bio_imask, tty_imask, net_imask);
  674 #endif
  675 
  676                 /* Register line discipline */
  677                 s = spltty();
  678                 if ((ngt_ldisc = ldisc_register(NETGRAPHDISC, &ngt_disc)) < 0) {
  679                         splx(s);
  680                         log(LOG_ERR, "%s: can't register line discipline",
  681                             __FUNCTION__);
  682                         return (EIO);
  683                 }
  684                 splx(s);
  685                 break;
  686 
  687         case MOD_UNLOAD:
  688 
  689                 /* Unregister line discipline */
  690                 s = spltty();
  691                 ldisc_deregister(ngt_ldisc);
  692                 splx(s);
  693                 break;
  694 
  695         default:
  696                 error = EOPNOTSUPP;
  697                 break;
  698         }
  699         return (error);
  700 }
  701 

Cache object: 917e706eace77162e71afc0b62f64d49


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