tty_pty.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: tty_pty.c,v 1.83 2005/02/26 21:34:55 perry Exp $       */
    2 
    3 /*
    4  * Copyright (c) 1982, 1986, 1989, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)tty_pty.c   8.4 (Berkeley) 2/20/95
   32  */
   33 
   34 /*
   35  * Pseudo-teletype Driver
   36  * (Actually two drivers, requiring two entries in 'cdevsw')
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __KERNEL_RCSID(0, "$NetBSD: tty_pty.c,v 1.83 2005/02/26 21:34:55 perry Exp $");
   41 
   42 #include "opt_compat_sunos.h"
   43 #include "opt_ptm.h"
   44 
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/ioctl.h>
   48 #include <sys/proc.h>
   49 #include <sys/tty.h>
   50 #include <sys/stat.h>
   51 #include <sys/file.h>
   52 #include <sys/uio.h>
   53 #include <sys/kernel.h>
   54 #include <sys/vnode.h>
   55 #include <sys/namei.h>
   56 #include <sys/signalvar.h>
   57 #include <sys/uio.h>
   58 #include <sys/filedesc.h>
   59 #include <sys/conf.h>
   60 #include <sys/poll.h>
   61 #include <sys/malloc.h>
   62 #include <sys/pty.h>
   63 
   64 #define DEFAULT_NPTYS           16      /* default number of initial ptys */
   65 #define DEFAULT_MAXPTYS         992     /* default maximum number of ptys */
   66 
   67 /* Macros to clear/set/test flags. */
   68 #define SET(t, f)       (t) |= (f)
   69 #define CLR(t, f)       (t) &= ~((unsigned)(f))
   70 #define ISSET(t, f)     ((t) & (f))
   71 
   72 #define BUFSIZ 100              /* Chunk size iomoved to/from user */
   73 
   74 struct  pt_softc {
   75         struct  tty *pt_tty;
   76         int     pt_flags;
   77         struct  selinfo pt_selr, pt_selw;
   78         u_char  pt_send;
   79         u_char  pt_ucntl;
   80 };
   81 
   82 static struct pt_softc **pt_softc = NULL;       /* pty array */
   83 static int maxptys = DEFAULT_MAXPTYS;   /* maximum number of ptys (sysctable) */
   84 struct simplelock pt_softc_mutex = SIMPLELOCK_INITIALIZER;
   85 int npty = 0;                   /* for pstat -t */
   86 
   87 #define PF_PKT          0x08            /* packet mode */
   88 #define PF_STOPPED      0x10            /* user told stopped */
   89 #define PF_REMOTE       0x20            /* remote and flow controlled input */
   90 #define PF_NOSTOP       0x40
   91 #define PF_UCNTL        0x80            /* user control mode */
   92 
   93 void    ptyattach(int);
   94 void    ptcwakeup(struct tty *, int);
   95 void    ptsstart(struct tty *);
   96 int     pty_maxptys(int, int);
   97 
   98 static struct pt_softc **ptyarralloc(int);
   99 
  100 dev_type_open(ptcopen);
  101 dev_type_close(ptcclose);
  102 dev_type_read(ptcread);
  103 dev_type_write(ptcwrite);
  104 dev_type_poll(ptcpoll);
  105 dev_type_kqfilter(ptckqfilter);
  106 
  107 dev_type_open(ptsopen);
  108 dev_type_close(ptsclose);
  109 dev_type_read(ptsread);
  110 dev_type_write(ptswrite);
  111 dev_type_stop(ptsstop);
  112 dev_type_poll(ptspoll);
  113 
  114 dev_type_ioctl(ptyioctl);
  115 dev_type_tty(ptytty);
  116 
  117 const struct cdevsw ptc_cdevsw = {
  118         ptcopen, ptcclose, ptcread, ptcwrite, ptyioctl,
  119         nullstop, ptytty, ptcpoll, nommap, ptckqfilter, D_TTY
  120 };
  121 
  122 const struct cdevsw pts_cdevsw = {
  123         ptsopen, ptsclose, ptsread, ptswrite, ptyioctl,
  124         ptsstop, ptytty, ptspoll, nommap, ttykqfilter, D_TTY
  125 };
  126 
  127 #if defined(pmax)
  128 const struct cdevsw ptc_ultrix_cdevsw = {
  129         ptcopen, ptcclose, ptcread, ptcwrite, ptyioctl,
  130         nullstop, ptytty, ptcpoll, nommap, ptckqfilter, D_TTY
  131 };
  132 
  133 const struct cdevsw pts_ultrix_cdevsw = {
  134         ptsopen, ptsclose, ptsread, ptswrite, ptyioctl,
  135         ptsstop, ptytty, ptspoll, nommap, ttykqfilter, D_TTY
  136 };
  137 #endif /* defined(pmax) */
  138 
  139 /*
  140  * Check if a pty is free to use.
  141  */
  142 int
  143 pty_isfree(int minor, int lock)
  144 {
  145         struct pt_softc *pt = pt_softc[minor];
  146         if (lock)
  147                 simple_lock(&pt_softc_mutex);
  148         minor = pt == NULL || pt->pt_tty == NULL ||
  149             pt->pt_tty->t_oproc == NULL;
  150         if (lock)
  151                 simple_unlock(&pt_softc_mutex);
  152         return minor;
  153 }
  154 
  155 /*
  156  * Allocate and zero array of nelem elements.
  157  */
  158 static struct pt_softc **
  159 ptyarralloc(nelem)
  160         int nelem;
  161 {
  162         struct pt_softc **pt;
  163         nelem += 10;
  164         pt = malloc(nelem * sizeof *pt, M_DEVBUF, M_WAITOK | M_ZERO);
  165         return pt;
  166 }
  167 
  168 /*
  169  * Check if the minor is correct and ensure necessary structures
  170  * are properly allocated.
  171  */
  172 int
  173 pty_check(int ptn)
  174 {
  175         struct pt_softc *pti;
  176 
  177         if (ptn >= npty) {
  178                 struct pt_softc **newpt, **oldpt;
  179                 int newnpty;
  180 
  181                 /* check if the requested pty can be granted */
  182                 if (ptn >= maxptys) {
  183             limit_reached:
  184                         tablefull("pty", "increase kern.maxptys");
  185                         return (ENXIO);
  186                 }
  187 
  188                 /* Allocate a larger pty array */
  189                 for (newnpty = npty; newnpty <= ptn;)
  190                         newnpty *= 2;
  191                 if (newnpty > maxptys)
  192                         newnpty = maxptys;
  193                 newpt = ptyarralloc(newnpty);
  194 
  195                 /*
  196                  * Now grab the pty array mutex - we need to ensure
  197                  * that the pty array is consistent while copying it's
  198                  * content to newly allocated, larger space; we also
  199                  * need to be safe against pty_maxptys().
  200                  */
  201                 simple_lock(&pt_softc_mutex);
  202 
  203                 if (newnpty >= maxptys) {
  204                         /* limit cut away beneath us... */
  205                         newnpty = maxptys;
  206                         if (ptn >= newnpty) {
  207                                 simple_unlock(&pt_softc_mutex);
  208                                 free(newpt, M_DEVBUF);
  209                                 goto limit_reached;
  210                         }
  211                 }
  212 
  213                 /*
  214                  * If the pty array was not enlarged while we were waiting
  215                  * for mutex, copy current contents of pt_softc[] to newly
  216                  * allocated array and start using the new bigger array.
  217                  */
  218                 if (newnpty > npty) {
  219                         memcpy(newpt, pt_softc, npty*sizeof(struct pt_softc *));
  220                         oldpt = pt_softc;
  221                         pt_softc = newpt;
  222                         npty = newnpty;
  223                 } else {
  224                         /* was enlarged when waited for lock, free new space */
  225                         oldpt = newpt;
  226                 }
  227 
  228                 simple_unlock(&pt_softc_mutex);
  229                 free(oldpt, M_DEVBUF);
  230         }
  231 
  232         /*
  233          * If the entry is not yet allocated, allocate one. The mutex is
  234          * needed so that the state of pt_softc[] array is consistant
  235          * in case it has been lengthened above.
  236          */
  237         if (!pt_softc[ptn]) {
  238                 MALLOC(pti, struct pt_softc *, sizeof(struct pt_softc),
  239                         M_DEVBUF, M_WAITOK);
  240                 memset(pti, 0, sizeof(struct pt_softc));
  241 
  242                 pti->pt_tty = ttymalloc();
  243 
  244                 simple_lock(&pt_softc_mutex);
  245 
  246                 /*
  247                  * Check the entry again - it might have been
  248                  * added while we were waiting for mutex.
  249                  */
  250                 if (!pt_softc[ptn]) {
  251                         tty_attach(pti->pt_tty);
  252                         pt_softc[ptn] = pti;
  253                 } else {
  254                         ttyfree(pti->pt_tty);
  255                         free(pti, M_DEVBUF);
  256                 }
  257 
  258                 simple_unlock(&pt_softc_mutex);
  259         }
  260 
  261         return (0);
  262 }
  263 
  264 /*
  265  * Set maxpty in thread-safe way. Returns 0 in case of error, otherwise
  266  * new value of maxptys.
  267  */
  268 int
  269 pty_maxptys(newmax, set)
  270         int newmax, set;
  271 {
  272         if (!set)
  273                 return (maxptys);
  274 
  275         /*
  276          * We have to grab the pt_softc lock, so that we would pick correct
  277          * value of npty (might be modified in pty_check()).
  278          */
  279         simple_lock(&pt_softc_mutex);
  280 
  281         /*
  282          * The value cannot be set to value lower than the highest pty
  283          * number ever allocated.
  284          */
  285         if (newmax >= npty)
  286                 maxptys = newmax;
  287         else
  288                 newmax = 0;
  289 
  290         simple_unlock(&pt_softc_mutex);
  291 
  292         return newmax;
  293 }
  294 
  295 /*
  296  * Establish n (or default if n is 1) ptys in the system.
  297  */
  298 void
  299 ptyattach(n)
  300         int n;
  301 {
  302         /* maybe should allow 0 => none? */
  303         if (n <= 1)
  304                 n = DEFAULT_NPTYS;
  305         pt_softc = ptyarralloc(n);
  306         npty = n;
  307 #ifndef NO_DEV_PTM
  308         ptmattach(1);
  309 #endif
  310 }
  311 
  312 /*ARGSUSED*/
  313 int
  314 ptsopen(dev, flag, devtype, p)
  315         dev_t dev;
  316         int flag, devtype;
  317         struct proc *p;
  318 {
  319         struct pt_softc *pti;
  320         struct tty *tp;
  321         int error;
  322         int ptn = minor(dev);
  323         int s;
  324 
  325         if ((error = pty_check(ptn)) != 0)
  326                 return (error);
  327 
  328         pti = pt_softc[ptn];
  329         tp = pti->pt_tty;
  330 
  331         if (!ISSET(tp->t_state, TS_ISOPEN)) {
  332                 ttychars(tp);           /* Set up default chars */
  333                 tp->t_iflag = TTYDEF_IFLAG;
  334                 tp->t_oflag = TTYDEF_OFLAG;
  335                 tp->t_lflag = TTYDEF_LFLAG;
  336                 tp->t_cflag = TTYDEF_CFLAG;
  337                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
  338                 ttsetwater(tp);         /* would be done in xxparam() */
  339         } else if (ISSET(tp->t_state, TS_XCLUDE) && p->p_ucred->cr_uid != 0)
  340                 return (EBUSY);
  341         if (tp->t_oproc)                        /* Ctrlr still around. */
  342                 SET(tp->t_state, TS_CARR_ON);
  343 
  344         if (!ISSET(flag, O_NONBLOCK)) {
  345                 s = spltty();
  346                 TTY_LOCK(tp);
  347                 while (!ISSET(tp->t_state, TS_CARR_ON)) {
  348                         tp->t_wopen++;
  349                         error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
  350                             ttopen, 0);
  351                         tp->t_wopen--;
  352                         if (error) {
  353                                 TTY_UNLOCK(tp);
  354                                 splx(s);
  355                                 return (error);
  356                         }
  357                 }
  358                 TTY_UNLOCK(tp);
  359                 splx(s);
  360         }
  361         error = (*tp->t_linesw->l_open)(dev, tp);
  362         ptcwakeup(tp, FREAD|FWRITE);
  363         return (error);
  364 }
  365 
  366 int
  367 ptsclose(dev, flag, mode, p)
  368         dev_t dev;
  369         int flag, mode;
  370         struct proc *p;
  371 {
  372         struct pt_softc *pti = pt_softc[minor(dev)];
  373         struct tty *tp = pti->pt_tty;
  374         int error;
  375 
  376         error = (*tp->t_linesw->l_close)(tp, flag);
  377         error |= ttyclose(tp);
  378         ptcwakeup(tp, FREAD|FWRITE);
  379         return (error);
  380 }
  381 
  382 int
  383 ptsread(dev, uio, flag)
  384         dev_t dev;
  385         struct uio *uio;
  386         int flag;
  387 {
  388         struct proc *p = curproc;
  389         struct pt_softc *pti = pt_softc[minor(dev)];
  390         struct tty *tp = pti->pt_tty;
  391         int error = 0;
  392         int cc;
  393         int s;
  394 
  395 again:
  396         if (pti->pt_flags & PF_REMOTE) {
  397                 while (isbackground(p, tp)) {
  398                         if (sigismasked(p, SIGTTIN) ||
  399                             p->p_pgrp->pg_jobc == 0 ||
  400                             p->p_flag & P_PPWAIT)
  401                                 return (EIO);
  402                         pgsignal(p->p_pgrp, SIGTTIN, 1);
  403                         s = spltty();
  404                         TTY_LOCK(tp);
  405                         error = ttysleep(tp, (caddr_t)&lbolt,
  406                                          TTIPRI | PCATCH | PNORELOCK, ttybg, 0);
  407                         splx(s);
  408                         if (error)
  409                                 return (error);
  410                 }
  411                 s = spltty();
  412                 TTY_LOCK(tp);
  413                 if (tp->t_canq.c_cc == 0) {
  414                         if (flag & IO_NDELAY) {
  415                                 TTY_UNLOCK(tp);
  416                                 splx(s);
  417                                 return (EWOULDBLOCK);
  418                         }
  419                         error = ttysleep(tp, (caddr_t)&tp->t_canq,
  420                                          TTIPRI | PCATCH | PNORELOCK, ttyin, 0);
  421                         splx(s);
  422                         if (error)
  423                                 return (error);
  424                         goto again;
  425                 }
  426                 while(error == 0 && tp->t_canq.c_cc > 1 && uio->uio_resid > 0) {
  427                         TTY_UNLOCK(tp);
  428                         splx(s);
  429                         error = ureadc(getc(&tp->t_canq), uio);
  430                         s = spltty();
  431                         TTY_LOCK(tp);
  432                         /* Re-check terminal state here? */
  433                 }
  434                 if (tp->t_canq.c_cc == 1)
  435                         (void) getc(&tp->t_canq);
  436                 cc = tp->t_canq.c_cc;
  437                 TTY_UNLOCK(tp);
  438                 splx(s);
  439                 if (cc)
  440                         return (error);
  441         } else
  442                 if (tp->t_oproc)
  443                         error = (*tp->t_linesw->l_read)(tp, uio, flag);
  444         ptcwakeup(tp, FWRITE);
  445         return (error);
  446 }
  447 
  448 /*
  449  * Write to pseudo-tty.
  450  * Wakeups of controlling tty will happen
  451  * indirectly, when tty driver calls ptsstart.
  452  */
  453 int
  454 ptswrite(dev, uio, flag)
  455         dev_t dev;
  456         struct uio *uio;
  457         int flag;
  458 {
  459         struct pt_softc *pti = pt_softc[minor(dev)];
  460         struct tty *tp = pti->pt_tty;
  461 
  462         if (tp->t_oproc == 0)
  463                 return (EIO);
  464         return ((*tp->t_linesw->l_write)(tp, uio, flag));
  465 }
  466 
  467 /*
  468  * Poll pseudo-tty.
  469  */
  470 int
  471 ptspoll(dev, events, p)
  472         dev_t dev;
  473         int events;
  474         struct proc *p;
  475 {
  476         struct pt_softc *pti = pt_softc[minor(dev)];
  477         struct tty *tp = pti->pt_tty;
  478 
  479         if (tp->t_oproc == 0)
  480                 return (EIO);
  481 
  482         return ((*tp->t_linesw->l_poll)(tp, events, p));
  483 }
  484 
  485 /*
  486  * Start output on pseudo-tty.
  487  * Wake up process polling or sleeping for input from controlling tty.
  488  * Called with tty slock held.
  489  */
  490 void
  491 ptsstart(tp)
  492         struct tty *tp;
  493 {
  494         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  495 
  496         if (ISSET(tp->t_state, TS_TTSTOP))
  497                 return;
  498         if (pti->pt_flags & PF_STOPPED) {
  499                 pti->pt_flags &= ~PF_STOPPED;
  500                 pti->pt_send = TIOCPKT_START;
  501         }
  502 
  503         selnotify(&pti->pt_selr, NOTE_SUBMIT);
  504         wakeup((caddr_t)&tp->t_outq.c_cf);
  505 }
  506 
  507 /*
  508  * Stop output.
  509  * Called with tty slock held.
  510  */
  511 void
  512 ptsstop(tp, flush)
  513         struct tty *tp;
  514         int flush;
  515 {
  516         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  517 
  518         /* note: FLUSHREAD and FLUSHWRITE already ok */
  519         if (flush == 0) {
  520                 flush = TIOCPKT_STOP;
  521                 pti->pt_flags |= PF_STOPPED;
  522         } else
  523                 pti->pt_flags &= ~PF_STOPPED;
  524         pti->pt_send |= flush;
  525 
  526         /* change of perspective */
  527         if (flush & FREAD) {
  528                 selnotify(&pti->pt_selw, NOTE_SUBMIT);
  529                 wakeup((caddr_t)&tp->t_rawq.c_cf);
  530         }
  531         if (flush & FWRITE) {
  532                 selnotify(&pti->pt_selr, NOTE_SUBMIT);
  533                 wakeup((caddr_t)&tp->t_outq.c_cf);
  534         }
  535 }
  536 
  537 void
  538 ptcwakeup(tp, flag)
  539         struct tty *tp;
  540         int flag;
  541 {
  542         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  543         int s;
  544 
  545         s = spltty();
  546         TTY_LOCK(tp);
  547         if (flag & FREAD) {
  548                 selnotify(&pti->pt_selr, NOTE_SUBMIT);
  549                 wakeup((caddr_t)&tp->t_outq.c_cf);
  550         }
  551         if (flag & FWRITE) {
  552                 selnotify(&pti->pt_selw, NOTE_SUBMIT);
  553                 wakeup((caddr_t)&tp->t_rawq.c_cf);
  554         }
  555         TTY_UNLOCK(tp);
  556         splx(s);
  557 }
  558 
  559 /*ARGSUSED*/
  560 int
  561 ptcopen(dev, flag, devtype, p)
  562         dev_t dev;
  563         int flag, devtype;
  564         struct proc *p;
  565 {
  566         struct pt_softc *pti;
  567         struct tty *tp;
  568         int error;
  569         int ptn = minor(dev);
  570         int s;
  571 
  572         if ((error = pty_check(ptn)) != 0)
  573                 return (error);
  574 
  575         pti = pt_softc[ptn];
  576         tp = pti->pt_tty;
  577 
  578         s = spltty();
  579         TTY_LOCK(tp);
  580         if (tp->t_oproc) {
  581                 TTY_UNLOCK(tp);
  582                 splx(s);
  583                 return (EIO);
  584         }
  585         tp->t_oproc = ptsstart;
  586         TTY_UNLOCK(tp);
  587         splx(s);
  588         (void)(*tp->t_linesw->l_modem)(tp, 1);
  589         CLR(tp->t_lflag, EXTPROC);
  590         pti->pt_flags = 0;
  591         pti->pt_send = 0;
  592         pti->pt_ucntl = 0;
  593         return (0);
  594 }
  595 
  596 /*ARGSUSED*/
  597 int
  598 ptcclose(dev, flag, devtype, p)
  599         dev_t dev;
  600         int flag, devtype;
  601         struct proc *p;
  602 {
  603         struct pt_softc *pti = pt_softc[minor(dev)];
  604         struct tty *tp = pti->pt_tty;
  605         int s;
  606 
  607         (void)(*tp->t_linesw->l_modem)(tp, 0);
  608         CLR(tp->t_state, TS_CARR_ON);
  609         s = spltty();
  610         TTY_LOCK(tp);
  611         tp->t_oproc = 0;                /* mark closed */
  612         TTY_UNLOCK(tp);
  613         splx(s);
  614         return (0);
  615 }
  616 
  617 int
  618 ptcread(dev, uio, flag)
  619         dev_t dev;
  620         struct uio *uio;
  621         int flag;
  622 {
  623         struct pt_softc *pti = pt_softc[minor(dev)];
  624         struct tty *tp = pti->pt_tty;
  625         u_char buf[BUFSIZ];
  626         int error = 0, cc;
  627         int s;
  628 
  629         /*
  630          * We want to block until the slave
  631          * is open, and there's something to read;
  632          * but if we lost the slave or we're NBIO,
  633          * then return the appropriate error instead.
  634          */
  635         s = spltty();
  636         TTY_LOCK(tp);
  637         for (;;) {
  638                 if (ISSET(tp->t_state, TS_ISOPEN)) {
  639                         if (pti->pt_flags & PF_PKT && pti->pt_send) {
  640                                 TTY_UNLOCK(tp);
  641                                 splx(s);
  642                                 error = ureadc((int)pti->pt_send, uio);
  643                                 if (error)
  644                                         return (error);
  645                                 /*
  646                                  * Since we don't have the tty locked, there's
  647                                  * a risk of messing up `t_termios'. This is
  648                                  * relevant only if the tty got closed and then
  649                                  * opened again while we were out uiomoving.
  650                                  */
  651                                 if (pti->pt_send & TIOCPKT_IOCTL) {
  652                                         cc = min(uio->uio_resid,
  653                                                 sizeof(tp->t_termios));
  654                                         uiomove((caddr_t) &tp->t_termios,
  655                                                 cc, uio);
  656                                 }
  657                                 pti->pt_send = 0;
  658                                 return (0);
  659                         }
  660                         if (pti->pt_flags & PF_UCNTL && pti->pt_ucntl) {
  661                                 TTY_UNLOCK(tp);
  662                                 splx(s);
  663                                 error = ureadc((int)pti->pt_ucntl, uio);
  664                                 if (error)
  665                                         return (error);
  666                                 pti->pt_ucntl = 0;
  667                                 return (0);
  668                         }
  669                         if (tp->t_outq.c_cc && !ISSET(tp->t_state, TS_TTSTOP))
  670                                 break;
  671                 }
  672                 if (!ISSET(tp->t_state, TS_CARR_ON)) {
  673                         error = 0;      /* EOF */
  674                         goto out;
  675                 }
  676                 if (flag & IO_NDELAY) {
  677                         error = EWOULDBLOCK;
  678                         goto out;
  679                 }
  680                 error = ltsleep((caddr_t)&tp->t_outq.c_cf, TTIPRI | PCATCH,
  681                                 ttyin, 0, &tp->t_slock);
  682                 if (error)
  683                         goto out;
  684         }
  685 
  686         if (pti->pt_flags & (PF_PKT|PF_UCNTL)) {
  687                 TTY_UNLOCK(tp);
  688                 splx(s);
  689                 error = ureadc(0, uio);
  690                 s = spltty();
  691                 TTY_LOCK(tp);
  692                 if (error == 0 && !ISSET(tp->t_state, TS_ISOPEN))
  693                         error = EIO;
  694         }
  695         while (uio->uio_resid > 0 && error == 0) {
  696                 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ));
  697                 if (cc <= 0)
  698                         break;
  699                 TTY_UNLOCK(tp);
  700                 splx(s);
  701                 error = uiomove(buf, cc, uio);
  702                 s = spltty();
  703                 TTY_LOCK(tp);
  704                 if (error == 0 && !ISSET(tp->t_state, TS_ISOPEN))
  705                         error = EIO;
  706         }
  707 
  708         if (tp->t_outq.c_cc <= tp->t_lowat) {
  709                 if (ISSET(tp->t_state, TS_ASLEEP)) {
  710                         CLR(tp->t_state, TS_ASLEEP);
  711                         wakeup((caddr_t)&tp->t_outq);
  712                 }
  713                 selnotify(&tp->t_wsel, NOTE_SUBMIT);
  714         }
  715 out:
  716         TTY_UNLOCK(tp);
  717         splx(s);
  718         return (error);
  719 }
  720 
  721 
  722 int
  723 ptcwrite(dev, uio, flag)
  724         dev_t dev;
  725         struct uio *uio;
  726         int flag;
  727 {
  728         struct pt_softc *pti = pt_softc[minor(dev)];
  729         struct tty *tp = pti->pt_tty;
  730         u_char *cp = NULL;
  731         int cc = 0;
  732         u_char locbuf[BUFSIZ];
  733         int cnt = 0;
  734         int error = 0;
  735         int s;
  736 
  737 again:
  738         s = spltty();
  739         TTY_LOCK(tp);
  740         if (!ISSET(tp->t_state, TS_ISOPEN))
  741                 goto block;
  742         if (pti->pt_flags & PF_REMOTE) {
  743                 if (tp->t_canq.c_cc)
  744                         goto block;
  745                 while (uio->uio_resid > 0 && tp->t_canq.c_cc < TTYHOG - 1) {
  746                         if (cc == 0) {
  747                                 cc = min(uio->uio_resid, BUFSIZ);
  748                                 cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc);
  749                                 cp = locbuf;
  750                                 TTY_UNLOCK(tp);
  751                                 splx(s);
  752                                 error = uiomove((caddr_t)cp, cc, uio);
  753                                 if (error)
  754                                         return (error);
  755                                 s = spltty();
  756                                 TTY_LOCK(tp);
  757                                 /* check again for safety */
  758                                 if (!ISSET(tp->t_state, TS_ISOPEN)) {
  759                                         error = EIO;
  760                                         goto out;
  761                                 }
  762                         }
  763                         if (cc)
  764                                 (void) b_to_q(cp, cc, &tp->t_canq);
  765                         cc = 0;
  766                 }
  767                 (void) putc(0, &tp->t_canq);
  768                 ttwakeup(tp);
  769                 wakeup((caddr_t)&tp->t_canq);
  770                 error = 0;
  771                 goto out;
  772         }
  773         while (uio->uio_resid > 0) {
  774                 if (cc == 0) {
  775                         cc = min(uio->uio_resid, BUFSIZ);
  776                         cp = locbuf;
  777                         TTY_UNLOCK(tp);
  778                         splx(s);
  779                         error = uiomove((caddr_t)cp, cc, uio);
  780                         if (error)
  781                                 return (error);
  782                         s = spltty();
  783                         TTY_LOCK(tp);
  784                         /* check again for safety */
  785                         if (!ISSET(tp->t_state, TS_ISOPEN)) {
  786                                 error = EIO;
  787                                 goto out;
  788                         }
  789                 }
  790                 while (cc > 0) {
  791                         if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
  792                            (tp->t_canq.c_cc > 0 || !ISSET(tp->t_lflag, ICANON))) {
  793                                 wakeup((caddr_t)&tp->t_rawq);
  794                                 goto block;
  795                         }
  796                         /* XXX - should change l_rint to be called with lock
  797                          *       see also tty.c:ttyinput_wlock()
  798                          */
  799                         TTY_UNLOCK(tp);
  800                         splx(s);
  801                         (*tp->t_linesw->l_rint)(*cp++, tp);
  802                         s = spltty();
  803                         TTY_LOCK(tp);
  804                         cnt++;
  805                         cc--;
  806                 }
  807                 cc = 0;
  808         }
  809         error = 0;
  810         goto out;
  811 
  812 block:
  813         /*
  814          * Come here to wait for slave to open, for space
  815          * in outq, or space in rawq.
  816          */
  817         if (!ISSET(tp->t_state, TS_CARR_ON)) {
  818                 error = EIO;
  819                 goto out;
  820         }
  821         if (flag & IO_NDELAY) {
  822                 /* adjust for data copied in but not written */
  823                 uio->uio_resid += cc;
  824                 error = cnt == 0 ? EWOULDBLOCK : 0;
  825                 goto out;
  826         }
  827         error = ltsleep((caddr_t)&tp->t_rawq.c_cf, TTOPRI | PCATCH | PNORELOCK,
  828                        ttyout, 0, &tp->t_slock);
  829         splx(s);
  830         if (error) {
  831                 /* adjust for data copied in but not written */
  832                 uio->uio_resid += cc;
  833                 return (error);
  834         }
  835         goto again;
  836 
  837 out:
  838         TTY_UNLOCK(tp);
  839         splx(s);
  840         return (error);
  841 }
  842 
  843 int
  844 ptcpoll(dev, events, p)
  845         dev_t dev;
  846         int events;
  847         struct proc *p;
  848 {
  849         struct pt_softc *pti = pt_softc[minor(dev)];
  850         struct tty *tp = pti->pt_tty;
  851         int revents = 0;
  852         int s = splsoftclock();
  853 
  854         if (events & (POLLIN | POLLRDNORM))
  855                 if (ISSET(tp->t_state, TS_ISOPEN) &&
  856                     ((tp->t_outq.c_cc > 0 && !ISSET(tp->t_state, TS_TTSTOP)) ||
  857                      ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  858                      ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)))
  859                         revents |= events & (POLLIN | POLLRDNORM);
  860 
  861         if (events & (POLLOUT | POLLWRNORM))
  862                 if (ISSET(tp->t_state, TS_ISOPEN) &&
  863                     ((pti->pt_flags & PF_REMOTE) ?
  864                      (tp->t_canq.c_cc == 0) :
  865                      ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2) ||
  866                       (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON)))))
  867                         revents |= events & (POLLOUT | POLLWRNORM);
  868 
  869         if (events & POLLHUP)
  870                 if (!ISSET(tp->t_state, TS_CARR_ON))
  871                         revents |= POLLHUP;
  872 
  873         if (revents == 0) {
  874                 if (events & (POLLIN | POLLHUP | POLLRDNORM))
  875                         selrecord(p, &pti->pt_selr);
  876 
  877                 if (events & (POLLOUT | POLLWRNORM))
  878                         selrecord(p, &pti->pt_selw);
  879         }
  880 
  881         splx(s);
  882         return (revents);
  883 }
  884 
  885 static void
  886 filt_ptcrdetach(struct knote *kn)
  887 {
  888         struct pt_softc *pti;
  889         int             s;
  890 
  891         pti = kn->kn_hook;
  892         s = spltty();
  893         SLIST_REMOVE(&pti->pt_selr.sel_klist, kn, knote, kn_selnext);
  894         splx(s);
  895 }
  896 
  897 static int
  898 filt_ptcread(struct knote *kn, long hint)
  899 {
  900         struct pt_softc *pti;
  901         struct tty      *tp;
  902         int canread;
  903 
  904         pti = kn->kn_hook;
  905         tp = pti->pt_tty;
  906 
  907         canread = (ISSET(tp->t_state, TS_ISOPEN) &&
  908                     ((tp->t_outq.c_cc > 0 && !ISSET(tp->t_state, TS_TTSTOP)) ||
  909                      ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  910                      ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)));
  911 
  912         if (canread) {
  913                 /*
  914                  * c_cc is number of characters after output post-processing;
  915                  * the amount of data actually read(2) depends on
  916                  * setting of input flags for the terminal.
  917                  */
  918                 kn->kn_data = tp->t_outq.c_cc;
  919                 if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  920                     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
  921                         kn->kn_data++;
  922         }
  923 
  924         return (canread);
  925 }
  926 
  927 static void
  928 filt_ptcwdetach(struct knote *kn)
  929 {
  930         struct pt_softc *pti;
  931         int             s;
  932 
  933         pti = kn->kn_hook;
  934         s = spltty();
  935         SLIST_REMOVE(&pti->pt_selw.sel_klist, kn, knote, kn_selnext);
  936         splx(s);
  937 }
  938 
  939 static int
  940 filt_ptcwrite(struct knote *kn, long hint)
  941 {
  942         struct pt_softc *pti;
  943         struct tty      *tp;
  944         int canwrite;
  945         int nwrite;
  946 
  947         pti = kn->kn_hook;
  948         tp = pti->pt_tty;
  949 
  950         canwrite = (ISSET(tp->t_state, TS_ISOPEN) &&
  951                     ((pti->pt_flags & PF_REMOTE) ?
  952                      (tp->t_canq.c_cc == 0) :
  953                      ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2) ||
  954                       (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON)))));
  955 
  956         if (canwrite) {
  957                 if (pti->pt_flags & PF_REMOTE)
  958                         nwrite = tp->t_canq.c_cn;
  959                 else {
  960                         /* this is guaranteed to be > 0 due to above check */
  961                         nwrite = tp->t_canq.c_cn
  962                                 - (tp->t_rawq.c_cc + tp->t_canq.c_cc);
  963                 }
  964                 kn->kn_data = nwrite;
  965         }
  966 
  967         return (canwrite);
  968 }
  969 
  970 static const struct filterops ptcread_filtops =
  971         { 1, NULL, filt_ptcrdetach, filt_ptcread };
  972 static const struct filterops ptcwrite_filtops =
  973         { 1, NULL, filt_ptcwdetach, filt_ptcwrite };
  974 
  975 int
  976 ptckqfilter(dev_t dev, struct knote *kn)
  977 {
  978         struct pt_softc *pti = pt_softc[minor(dev)];
  979         struct klist    *klist;
  980         int             s;
  981 
  982         switch (kn->kn_filter) {
  983         case EVFILT_READ:
  984                 klist = &pti->pt_selr.sel_klist;
  985                 kn->kn_fop = &ptcread_filtops;
  986                 break;
  987         case EVFILT_WRITE:
  988                 klist = &pti->pt_selw.sel_klist;
  989                 kn->kn_fop = &ptcwrite_filtops;
  990                 break;
  991         default:
  992                 return (1);
  993         }
  994 
  995         kn->kn_hook = pti;
  996 
  997         s = spltty();
  998         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
  999         splx(s);
 1000 
 1001         return (0);
 1002 }
 1003 
 1004 struct tty *
 1005 ptytty(dev)
 1006         dev_t dev;
 1007 {
 1008         struct pt_softc *pti = pt_softc[minor(dev)];
 1009         struct tty *tp = pti->pt_tty;
 1010 
 1011         return (tp);
 1012 }
 1013 
 1014 /*ARGSUSED*/
 1015 int
 1016 ptyioctl(dev, cmd, data, flag, p)
 1017         dev_t dev;
 1018         u_long cmd;
 1019         caddr_t data;
 1020         int flag;
 1021         struct proc *p;
 1022 {
 1023         struct pt_softc *pti = pt_softc[minor(dev)];
 1024         struct tty *tp = pti->pt_tty;
 1025         const struct cdevsw *cdev;
 1026         u_char *cc = tp->t_cc;
 1027         int stop, error, sig;
 1028         int s;
 1029 
 1030         /*
 1031          * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
 1032          * ttywflush(tp) will hang if there are characters in the outq.
 1033          */
 1034         if (cmd == TIOCEXT) {
 1035                 /*
 1036                  * When the EXTPROC bit is being toggled, we need
 1037                  * to send an TIOCPKT_IOCTL if the packet driver
 1038                  * is turned on.
 1039                  */
 1040                 if (*(int *)data) {
 1041                         if (pti->pt_flags & PF_PKT) {
 1042                                 pti->pt_send |= TIOCPKT_IOCTL;
 1043                                 ptcwakeup(tp, FREAD);
 1044                         }
 1045                         SET(tp->t_lflag, EXTPROC);
 1046                 } else {
 1047                         if (ISSET(tp->t_lflag, EXTPROC) &&
 1048                             (pti->pt_flags & PF_PKT)) {
 1049                                 pti->pt_send |= TIOCPKT_IOCTL;
 1050                                 ptcwakeup(tp, FREAD);
 1051                         }
 1052                         CLR(tp->t_lflag, EXTPROC);
 1053                 }
 1054                 return(0);
 1055         }
 1056 
 1057 #ifndef NO_DEV_PTM
 1058         /* Allow getting the name from either the master or the slave */
 1059         if (cmd == TIOCPTSNAME)
 1060                 return pty_fill_ptmget(dev, -1, -1, data);
 1061 #endif
 1062 
 1063         cdev = cdevsw_lookup(dev);
 1064         if (cdev != NULL && cdev->d_open == ptcopen)
 1065                 switch (cmd) {
 1066 #ifndef NO_DEV_PTM
 1067                 case TIOCGRANTPT:
 1068                         return pty_grant_slave(p, dev);
 1069 #endif
 1070 
 1071                 case TIOCGPGRP:
 1072                         /*
 1073                          * We avoid calling ttioctl on the controller since,
 1074                          * in that case, tp must be the controlling terminal.
 1075                          */
 1076                         *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
 1077                         return (0);
 1078 
 1079                 case TIOCPKT:
 1080                         if (*(int *)data) {
 1081                                 if (pti->pt_flags & PF_UCNTL)
 1082                                         return (EINVAL);
 1083                                 pti->pt_flags |= PF_PKT;
 1084                         } else
 1085                                 pti->pt_flags &= ~PF_PKT;
 1086                         return (0);
 1087 
 1088                 case TIOCUCNTL:
 1089                         if (*(int *)data) {
 1090                                 if (pti->pt_flags & PF_PKT)
 1091                                         return (EINVAL);
 1092                                 pti->pt_flags |= PF_UCNTL;
 1093                         } else
 1094                                 pti->pt_flags &= ~PF_UCNTL;
 1095                         return (0);
 1096 
 1097                 case TIOCREMOTE:
 1098                         if (*(int *)data)
 1099                                 pti->pt_flags |= PF_REMOTE;
 1100                         else
 1101                                 pti->pt_flags &= ~PF_REMOTE;
 1102                         s = spltty();
 1103                         TTY_LOCK(tp);
 1104                         ttyflush(tp, FREAD|FWRITE);
 1105                         TTY_UNLOCK(tp);
 1106                         splx(s);
 1107                         return (0);
 1108 
 1109 #ifdef COMPAT_OLDTTY
 1110                 case TIOCSETP:
 1111                 case TIOCSETN:
 1112 #endif
 1113                 case TIOCSETD:
 1114                 case TIOCSETA:
 1115                 case TIOCSETAW:
 1116                 case TIOCSETAF:
 1117                         TTY_LOCK(tp);
 1118                         ndflush(&tp->t_outq, tp->t_outq.c_cc);
 1119                         TTY_UNLOCK(tp);
 1120                         break;
 1121 
 1122                 case TIOCSIG:
 1123                         sig = (int)(long)*(caddr_t *)data;
 1124                         if (sig <= 0 || sig >= NSIG)
 1125                                 return (EINVAL);
 1126                         TTY_LOCK(tp);
 1127                         if (!ISSET(tp->t_lflag, NOFLSH))
 1128                                 ttyflush(tp, FREAD|FWRITE);
 1129                         if ((sig == SIGINFO) &&
 1130                             (!ISSET(tp->t_lflag, NOKERNINFO)))
 1131                                 ttyinfo(tp);
 1132                         TTY_UNLOCK(tp);
 1133                         pgsignal(tp->t_pgrp, sig, 1);
 1134                         return(0);
 1135                 }
 1136 
 1137         error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p);
 1138         if (error == EPASSTHROUGH)
 1139                  error = ttioctl(tp, cmd, data, flag, p);
 1140         if (error == EPASSTHROUGH) {
 1141                 if (pti->pt_flags & PF_UCNTL &&
 1142                     (cmd & ~0xff) == UIOCCMD(0)) {
 1143                         if (cmd & 0xff) {
 1144                                 pti->pt_ucntl = (u_char)cmd;
 1145                                 ptcwakeup(tp, FREAD);
 1146                         }
 1147                         return (0);
 1148                 }
 1149         }
 1150         /*
 1151          * If external processing and packet mode send ioctl packet.
 1152          */
 1153         if (ISSET(tp->t_lflag, EXTPROC) && (pti->pt_flags & PF_PKT)) {
 1154                 switch(cmd) {
 1155                 case TIOCSETA:
 1156                 case TIOCSETAW:
 1157                 case TIOCSETAF:
 1158 #ifdef COMPAT_OLDTTY
 1159                 case TIOCSETP:
 1160                 case TIOCSETN:
 1161                 case TIOCSETC:
 1162                 case TIOCSLTC:
 1163                 case TIOCLBIS:
 1164                 case TIOCLBIC:
 1165                 case TIOCLSET:
 1166 #endif
 1167                         pti->pt_send |= TIOCPKT_IOCTL;
 1168                         ptcwakeup(tp, FREAD);
 1169                 default:
 1170                         break;
 1171                 }
 1172         }
 1173         stop = ISSET(tp->t_iflag, IXON) && CCEQ(cc[VSTOP], CTRL('s'))
 1174                 && CCEQ(cc[VSTART], CTRL('q'));
 1175         if (pti->pt_flags & PF_NOSTOP) {
 1176                 if (stop) {
 1177                         pti->pt_send &= ~TIOCPKT_NOSTOP;
 1178                         pti->pt_send |= TIOCPKT_DOSTOP;
 1179                         pti->pt_flags &= ~PF_NOSTOP;
 1180                         ptcwakeup(tp, FREAD);
 1181                 }
 1182         } else {
 1183                 if (!stop) {
 1184                         pti->pt_send &= ~TIOCPKT_DOSTOP;
 1185                         pti->pt_send |= TIOCPKT_NOSTOP;
 1186                         pti->pt_flags |= PF_NOSTOP;
 1187                         ptcwakeup(tp, FREAD);
 1188                 }
 1189         }
 1190         return (error);
 1191 }
Cache object: 981694c6392bc8a27e6622b38f27e66f
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/kern/tty_pty.c

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