root/kern/tty_pty.c

DEFINITIONS

1. ptydevname
2. ptyarralloc
3. check_pty
4. ptyattach
5. ptsopen
6. ptsclose
7. ptsread
8. ptswrite
9. ptsstart
10. ptsstop
11. ptcwakeup
12. ptcopen
13. ptcclose
14. ptcread
15. ptcwrite
16. ptcpoll
17. filt_ptcrdetach
18. filt_ptcread
19. filt_ptcwdetach
20. filt_ptcwrite
21. ptckqfilter
22. ptytty
23. ptyioctl
24. sysctl_pty
25. pty_isfree_locked
26. pty_isfree
27. pty_getfree
28. ptm_vn_open
29. ptmattach
30. ptmopen
31. ptmclose
32. ptmread
33. ptmwrite
34. ptmioctl
35. ptmpoll

    1 /*      $OpenBSD: tty_pty.c,v 1.34 2007/05/29 00:17:32 thib Exp $       */
    2 /*      $NetBSD: tty_pty.c,v 1.33.4.1 1996/06/02 09:08:11 mrg Exp $     */
    4 /*
    5  * Copyright (c) 1982, 1986, 1989, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)tty_pty.c   8.4 (Berkeley) 2/20/95
   33  */
   35 /*
   36  * Pseudo-teletype Driver
   37  * (Actually two drivers, requiring two entries in 'cdevsw')
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/namei.h>
   43 #include <sys/mount.h>
   44 #include <sys/ioctl.h>
   45 #include <sys/proc.h>
   46 #include <sys/tty.h>
   47 #include <sys/file.h>
   48 #include <sys/filedesc.h>
   49 #include <sys/uio.h>
   50 #include <sys/kernel.h>
   51 #include <sys/malloc.h>
   52 #include <sys/vnode.h>
   53 #include <sys/signalvar.h>
   54 #include <sys/uio.h>
   55 #include <sys/conf.h>
   56 #include <sys/stat.h>
   57 #include <sys/sysctl.h>
   58 #include <sys/poll.h>
   59 #include <sys/rwlock.h>
   61 #define BUFSIZ 100              /* Chunk size iomoved to/from user */
   63 /*
   64  * pts == /dev/tty[p-zP-T][0-9a-zA-Z]
   65  * ptc == /dev/pty[p-zP-T][0-9a-zA-Z]
   66  */
   68 /* XXX this needs to come from somewhere sane, and work with MAKEDEV */
   69 #define TTY_LETTERS "pqrstuvwxyzPQRST"
   70 #define TTY_SUFFIX "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   72 static int pts_major;
   74 struct  pt_softc {
   75         struct  tty *pt_tty;
   76         int     pt_flags;
   77         struct  selinfo pt_selr, pt_selw;
u_char  pt_send;
u_char  pt_ucntl;
   80         char    pty_pn[11];
   81         char    pty_sn[11];
   82 };
   84 #define NPTY_MIN                8       /* number of initial ptys */
   85 #define NPTY_MAX                992     /* maximum number of ptys supported */
   87 static struct pt_softc **pt_softc = NULL;       /* pty array */
   88 static int npty = 0;                            /* size of pty array */
   89 static int maxptys = NPTY_MAX;                  /* maximum number of ptys */
   90 /* for pty array */
   91 struct rwlock pt_softc_lock = RWLOCK_INITIALIZER("ptarrlk");
   93 #define PF_PKT          0x08            /* packet mode */
   94 #define PF_STOPPED      0x10            /* user told stopped */
   95 #define PF_REMOTE       0x20            /* remote and flow controlled input */
   96 #define PF_NOSTOP       0x40
   97 #define PF_UCNTL        0x80            /* user control mode */
   99 void    ptyattach(int);
  100 void    ptcwakeup(struct tty *, int);
  101 struct tty *ptytty(dev_t);
  102 void    ptsstart(struct tty *);
  103 int     sysctl_pty(int *, u_int, void *, size_t *, void *, size_t);
  105 void    filt_ptcrdetach(struct knote *);
  106 int     filt_ptcread(struct knote *, long);
  107 void    filt_ptcwdetach(struct knote *);
  108 int     filt_ptcwrite(struct knote *, long);
  110 static struct pt_softc **ptyarralloc(int);
  111 static int check_pty(int);
  113 static gid_t tty_gid = TTY_GID;
  115 void    ptydevname(int, struct pt_softc *);
dev_t   pty_getfree(void);
  118 void    ptmattach(int);
  119 int     ptmopen(dev_t, int, int, struct proc *);
  120 int     ptmclose(dev_t, int, int, struct proc *);
  121 int     ptmread(dev_t, struct uio *, int);
  122 int     ptmwrite(dev_t, struct uio *, int);
  123 int     ptmwrite(dev_t, struct uio *, int);
  124 int     ptmioctl(dev_t, u_long, caddr_t, int, struct proc *p);
  125 int     ptmpoll(dev_t, int, struct proc *p);
  126 static int ptm_vn_open(struct nameidata *);
  128 void
ptydevname(int minor, struct pt_softc *pti)
  130 {
  131         char buf[11] = "/dev/XtyXX";
  132         int i, j;
i = minor / (sizeof(TTY_SUFFIX) - 1);
j = minor % (sizeof(TTY_SUFFIX) - 1);
  136         if (i >= sizeof(TTY_LETTERS) - 1) {
pti->pty_pn[0] = '\0';
pti->pty_sn[0] = '\0';
  139                 return;
  140         }
buf[5] = 'p';
buf[8] = TTY_LETTERS[i];
buf[9] = TTY_SUFFIX[j];
memcpy(pti->pty_pn, buf, sizeof(buf));
buf[5] = 't';
memcpy(pti->pty_sn, buf, sizeof(buf));
  147 }
  149 /*
  150  * Allocate and zero array of nelem elements.
  151  */
  152 struct pt_softc **
ptyarralloc(int nelem)
  154 {
  155         struct pt_softc **pt;
pt = malloc(nelem * sizeof(struct pt_softc *), M_DEVBUF, M_WAITOK);
bzero(pt, nelem * sizeof(struct pt_softc *));
  159         return pt;
  160 }
  162 /*
  163  * Check if the minor is correct and ensure necessary structures
  164  * are properly allocated.
  165  */
  166 int
check_pty(int minor)
  168 {
  169         struct pt_softc *pti;
rw_enter_write(&pt_softc_lock);
  172         if (minor >= npty) {
  173                 struct pt_softc **newpt;
  174                 int newnpty;
  176                 /* check if the requested pty can be granted */
  177                 if (minor >= maxptys)
  178                         goto limit_reached;
  180                 /* grow pty array by powers of two, up to maxptys */
  181                 for (newnpty = npty; newnpty <= minor; newnpty *= 2)
  182                         ;
  184                 if (newnpty > maxptys)
newnpty = maxptys;
newpt = ptyarralloc(newnpty);
  188                 if (maxptys == npty) {
  189                         goto limit_reached;
  190                 }
memcpy(newpt, pt_softc, npty * sizeof(struct pt_softc *));
free(pt_softc, M_DEVBUF);
pt_softc = newpt;
npty = newnpty;
  196         }
  198         /*
  199          * If the entry is not yet allocated, allocate one.
  200          */
  201         if (!pt_softc[minor]) {
MALLOC(pti, struct pt_softc *, sizeof(struct pt_softc),
M_DEVBUF, M_WAITOK);
bzero(pti, sizeof(struct pt_softc));
pti->pt_tty = ttymalloc();
ptydevname(minor, pti);
pt_softc[minor] = pti;
  208         }
rw_exit_write(&pt_softc_lock);
  210         return (0);
limit_reached:
rw_exit_write(&pt_softc_lock);
tablefull("pty");
  214         return (ENXIO);
  215 }
  217 /*
  218  * Establish n (or default if n is 1) ptys in the system.
  219  */
  220 void
ptyattach(int n)
  222 {
  223         /* maybe should allow 0 => none? */
  224         if (n <= 1)
n = NPTY_MIN;
pt_softc = ptyarralloc(n);
npty = n;
  229         /*
  230          * If we have pty, we need ptm too.
  231          */
ptmattach(1);
  233 }
  235 /*ARGSUSED*/
  236 int
ptsopen(dev_t dev, int flag, int devtype, struct proc *p)
  238 {
  239         struct pt_softc *pti;
  240         struct tty *tp;
  241         int error;
  243         if ((error = check_pty(minor(dev))))
  244                 return (error);
pti = pt_softc[minor(dev)];
  247         if (!pti->pt_tty) {
tp = pti->pt_tty = ttymalloc();
  249         } else
tp = pti->pt_tty;
  251         if ((tp->t_state & TS_ISOPEN) == 0) {
tp->t_state |= TS_WOPEN;
ttychars(tp);           /* Set up default chars */
tp->t_iflag = TTYDEF_IFLAG;
tp->t_oflag = TTYDEF_OFLAG;
tp->t_lflag = TTYDEF_LFLAG;
tp->t_cflag = TTYDEF_CFLAG;
tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
ttsetwater(tp);         /* would be done in xxparam() */
  260         } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
  261                 return (EBUSY);
  262         if (tp->t_oproc)                        /* Ctrlr still around. */
tp->t_state |= TS_CARR_ON;
  264         while ((tp->t_state & TS_CARR_ON) == 0) {
tp->t_state |= TS_WOPEN;
  266                 if (flag&FNONBLOCK)
  267                         break;
error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
ttopen, 0);
  270                 if (error)
  271                         return (error);
  272         }
error = (*linesw[tp->t_line].l_open)(dev, tp);
ptcwakeup(tp, FREAD|FWRITE);
  275         return (error);
  276 }
  278 int
  279 ptsclose(dev_t dev, int flag, int mode, struct proc *p)
  280 {
  281         struct pt_softc *pti = pt_softc[minor(dev)];
  282         struct tty *tp = pti->pt_tty;
  283         int error;
error = (*linesw[tp->t_line].l_close)(tp, flag);
error |= ttyclose(tp);
ptcwakeup(tp, FREAD|FWRITE);
  288         return (error);
  289 }
  291 int
  292 ptsread(dev_t dev, struct uio *uio, int flag)
  293 {
  294         struct proc *p = curproc;
  295         struct pt_softc *pti = pt_softc[minor(dev)];
  296         struct tty *tp = pti->pt_tty;
  297         int error = 0;
again:
  300         if (pti->pt_flags & PF_REMOTE) {
  301                 while (isbackground(p, tp)) {
  302                         if ((p->p_sigignore & sigmask(SIGTTIN)) ||
  303                             (p->p_sigmask & sigmask(SIGTTIN)) ||
p->p_pgrp->pg_jobc == 0 ||
p->p_flag & P_PPWAIT)
  306                                 return (EIO);
pgsignal(p->p_pgrp, SIGTTIN, 1);
error = ttysleep(tp, &lbolt,
TTIPRI | PCATCH, ttybg, 0);
  310                         if (error)
  311                                 return (error);
  312                 }
  313                 if (tp->t_canq.c_cc == 0) {
  314                         if (flag & IO_NDELAY)
  315                                 return (EWOULDBLOCK);
error = ttysleep(tp, &tp->t_canq,
TTIPRI | PCATCH, ttyin, 0);
  318                         if (error)
  319                                 return (error);
  320                         goto again;
  321                 }
  322                 while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0)
  323                         if (ureadc(getc(&tp->t_canq), uio) < 0) {
error = EFAULT;
  325                                 break;
  326                         }
  327                 if (tp->t_canq.c_cc == 1)
  328                         (void) getc(&tp->t_canq);
  329                 if (tp->t_canq.c_cc)
  330                         return (error);
  331         } else
  332                 if (tp->t_oproc)
error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
ptcwakeup(tp, FWRITE);
  335         return (error);
  336 }
  338 /*
  339  * Write to pseudo-tty.
  340  * Wakeups of controlling tty will happen
  341  * indirectly, when tty driver calls ptsstart.
  342  */
  343 int
  344 ptswrite(dev_t dev, struct uio *uio, int flag)
  345 {
  346         struct pt_softc *pti = pt_softc[minor(dev)];
  347         struct tty *tp = pti->pt_tty;
  349         if (tp->t_oproc == 0)
  350                 return (EIO);
  351         return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
  352 }
  354 /*
  355  * Start output on pseudo-tty.
  356  * Wake up process polling or sleeping for input from controlling tty.
  357  */
  358 void
ptsstart(struct tty *tp)
  360 {
  361         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  363         if (tp->t_state & TS_TTSTOP)
  364                 return;
  365         if (pti->pt_flags & PF_STOPPED) {
pti->pt_flags &= ~PF_STOPPED;
pti->pt_send = TIOCPKT_START;
  368         }
ptcwakeup(tp, FREAD);
  370 }
  372 int
  373 ptsstop(struct tty *tp, int flush)
  374 {
  375         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  376         int flag;
  378         /* note: FLUSHREAD and FLUSHWRITE already ok */
  379         if (flush == 0) {
flush = TIOCPKT_STOP;
pti->pt_flags |= PF_STOPPED;
  382         } else
pti->pt_flags &= ~PF_STOPPED;
pti->pt_send |= flush;
  385         /* change of perspective */
flag = 0;
  387         if (flush & FREAD)
flag |= FWRITE;
  389         if (flush & FWRITE)
flag |= FREAD;
ptcwakeup(tp, flag);
  392         return 0;
  393 }
  395 void
ptcwakeup(struct tty *tp, int flag)
  397 {
  398         struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
  400         if (flag & FREAD) {
selwakeup(&pti->pt_selr);
wakeup(&tp->t_outq.c_cf);
KNOTE(&pti->pt_selr.si_note, 0);
  404         }
  405         if (flag & FWRITE) {
selwakeup(&pti->pt_selw);
wakeup(&tp->t_rawq.c_cf);
KNOTE(&pti->pt_selw.si_note, 0);
  409         }
  410 }
  412 int ptcopen(dev_t, int, int, struct proc *);
  414 /*ARGSUSED*/
  415 int
ptcopen(dev_t dev, int flag, int devtype, struct proc *p)
  417 {
  418         struct pt_softc *pti;
  419         struct tty *tp;
  420         int error;
  422         if ((error = check_pty(minor(dev))))
  423                 return (error);
pti = pt_softc[minor(dev)];
  426         if (!pti->pt_tty) {
tp = pti->pt_tty = ttymalloc();
  428         } else
tp = pti->pt_tty;
  430         if (tp->t_oproc)
  431                 return (EIO);
tp->t_oproc = ptsstart;
  433         (void)(*linesw[tp->t_line].l_modem)(tp, 1);
tp->t_lflag &= ~EXTPROC;
pti->pt_flags = 0;
pti->pt_send = 0;
pti->pt_ucntl = 0;
  438         return (0);
  439 }
  441 /*ARGSUSED*/
  442 int
  443 ptcclose(dev_t dev, int flag, int devtype, struct proc *p)
  444 {
  445         struct pt_softc *pti = pt_softc[minor(dev)];
  446         struct tty *tp = pti->pt_tty;
  448         (void)(*linesw[tp->t_line].l_modem)(tp, 0);
tp->t_state &= ~TS_CARR_ON;
tp->t_oproc = 0;                /* mark closed */
  451         return (0);
  452 }
  454 int
  455 ptcread(dev_t dev, struct uio *uio, int flag)
  456 {
  457         struct pt_softc *pti = pt_softc[minor(dev)];
  458         struct tty *tp = pti->pt_tty;
  459         char buf[BUFSIZ];
  460         int error = 0, cc;
  462         /*
  463          * We want to block until the slave
  464          * is open, and there's something to read;
  465          * but if we lost the slave or we're NBIO,
  466          * then return the appropriate error instead.
  467          */
  468         for (;;) {
  469                 if (tp->t_state&TS_ISOPEN) {
  470                         if (pti->pt_flags&PF_PKT && pti->pt_send) {
error = ureadc((int)pti->pt_send, uio);
  472                                 if (error)
  473                                         return (error);
  474                                 if (pti->pt_send & TIOCPKT_IOCTL) {
cc = min(uio->uio_resid,
  476                                                 sizeof(tp->t_termios));
uiomove(&tp->t_termios, cc, uio);
  478                                 }
pti->pt_send = 0;
  480                                 return (0);
  481                         }
  482                         if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) {
error = ureadc((int)pti->pt_ucntl, uio);
  484                                 if (error)
  485                                         return (error);
pti->pt_ucntl = 0;
  487                                 return (0);
  488                         }
  489                         if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
  490                                 break;
  491                 }
  492                 if ((tp->t_state&TS_CARR_ON) == 0)
  493                         return (0);     /* EOF */
  494                 if (flag & IO_NDELAY)
  495                         return (EWOULDBLOCK);
error = tsleep(&tp->t_outq.c_cf, TTIPRI | PCATCH,
ttyin, 0);
  498                 if (error)
  499                         return (error);
  500         }
  501         if (pti->pt_flags & (PF_PKT|PF_UCNTL))
error = ureadc(0, uio);
  503         while (uio->uio_resid > 0 && error == 0) {
cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ));
  505                 if (cc <= 0)
  506                         break;
error = uiomove(buf, cc, uio);
  508         }
  509         if (tp->t_outq.c_cc <= tp->t_lowat) {
  510                 if (tp->t_state&TS_ASLEEP) {
tp->t_state &= ~TS_ASLEEP;
wakeup(&tp->t_outq);
  513                 }
selwakeup(&tp->t_wsel);
  515         }
  516         return (error);
  517 }
  520 int
  521 ptcwrite(dev_t dev, struct uio *uio, int flag)
  522 {
  523         struct pt_softc *pti = pt_softc[minor(dev)];
  524         struct tty *tp = pti->pt_tty;
u_char *cp = NULL;
  526         int cc = 0;
u_char locbuf[BUFSIZ];
  528         int cnt = 0;
  529         int error = 0;
again:
  532         if ((tp->t_state&TS_ISOPEN) == 0)
  533                 goto block;
  534         if (pti->pt_flags & PF_REMOTE) {
  535                 if (tp->t_canq.c_cc)
  536                         goto block;
  537                 while (uio->uio_resid > 0 && tp->t_canq.c_cc < TTYHOG - 1) {
  538                         if (cc == 0) {
cc = min(uio->uio_resid, BUFSIZ);
cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc);
cp = locbuf;
error = uiomove(cp, cc, uio);
  543                                 if (error)
  544                                         return (error);
  545                                 /* check again for safety */
  546                                 if ((tp->t_state&TS_ISOPEN) == 0)
  547                                         return (EIO);
  548                         }
  549                         if (cc)
  550                                 (void) b_to_q((char *)cp, cc, &tp->t_canq);
cc = 0;
  552                 }
  553                 (void) putc(0, &tp->t_canq);
ttwakeup(tp);
wakeup(&tp->t_canq);
  556                 return (0);
  557         }
  558         while (uio->uio_resid > 0) {
  559                 if (cc == 0) {
cc = min(uio->uio_resid, BUFSIZ);
cp = locbuf;
error = uiomove(cp, cc, uio);
  563                         if (error)
  564                                 return (error);
  565                         /* check again for safety */
  566                         if ((tp->t_state&TS_ISOPEN) == 0)
  567                                 return (EIO);
  568                 }
  569                 while (cc > 0) {
  570                         if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
  571                            (tp->t_canq.c_cc > 0 || !ISSET(tp->t_lflag, ICANON))) {
wakeup(&tp->t_rawq);
  573                                 goto block;
  574                         }
  575                         (*linesw[tp->t_line].l_rint)(*cp++, tp);
cnt++;
cc--;
  578                 }
cc = 0;
  580         }
  581         return (0);
block:
  583         /*
  584          * Come here to wait for slave to open, for space
  585          * in outq, or space in rawq.
  586          */
  587         if ((tp->t_state&TS_CARR_ON) == 0)
  588                 return (EIO);
  589         if (flag & IO_NDELAY) {
  590                 /* adjust for data copied in but not written */
uio->uio_resid += cc;
  592                 if (cnt == 0)
  593                         return (EWOULDBLOCK);
  594                 return (0);
  595         }
error = tsleep(&tp->t_rawq.c_cf, TTOPRI | PCATCH,
ttyout, 0);
  598         if (error) {
  599                 /* adjust for data copied in but not written */
uio->uio_resid += cc;
  601                 return (error);
  602         }
  603         goto again;
  604 }
  606 int
  607 ptcpoll(dev_t dev, int events, struct proc *p)
  608 {
  609         struct pt_softc *pti = pt_softc[minor(dev)];
  610         struct tty *tp = pti->pt_tty;
  611         int revents = 0, s;
  613         if (!ISSET(tp->t_state, TS_CARR_ON))
  614                 return (POLLHUP);
  616         if (!ISSET(tp->t_state, TS_ISOPEN))
  617                 goto notopen;
  619         if (events & (POLLIN | POLLRDNORM)) {
  620                 /*
  621                  * Need to protect access to t_outq
  622                  */
s = spltty();
  624                 if ((tp->t_outq.c_cc && !ISSET(tp->t_state, TS_TTSTOP)) ||
  625                     ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  626                     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
revents |= events & (POLLIN | POLLRDNORM);
splx(s);
  629         }
  630         if (events & (POLLOUT | POLLWRNORM)) {
  631                 if ((pti->pt_flags & PF_REMOTE) ?
  632                     (tp->t_canq.c_cc == 0) :
  633                     ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
  634                     (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON))))
revents |= events & (POLLOUT | POLLWRNORM);
  636         }
  637         if (events & (POLLPRI | POLLRDBAND)) {
  638                 /* If in packet or user control mode, check for data. */
  639                 if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  640                     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
revents |= events & (POLLPRI | POLLRDBAND);
  642         }
  644         if (revents == 0) {
notopen:
  646                 if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND))
selrecord(p, &pti->pt_selr);
  648                 if (events & (POLLOUT | POLLWRNORM))
selrecord(p, &pti->pt_selw);
  650         }
  652         return (revents);
  653 }
  655 void
filt_ptcrdetach(struct knote *kn)
  657 {
  658         struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
  659         int s;
s = spltty();
SLIST_REMOVE(&pti->pt_selr.si_note, kn, knote, kn_selnext);
splx(s);
  664 }
  666 int
filt_ptcread(struct knote *kn, long hint)
  668 {
  669         struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
  670         struct tty *tp;
tp = pti->pt_tty;
kn->kn_data = 0;
  675         if (ISSET(tp->t_state, TS_ISOPEN)) {
  676                 if (!ISSET(tp->t_state, TS_TTSTOP))
kn->kn_data = tp->t_outq.c_cc;
  678                 if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
  679                     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
kn->kn_data++;
  681         }
  682         return (kn->kn_data > 0);
  683 }
  685 void
filt_ptcwdetach(struct knote *kn)
  687 {
  688         struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
  689         int s;
s = spltty();
SLIST_REMOVE(&pti->pt_selw.si_note, kn, knote, kn_selnext);
splx(s);
  694 }
  696 int
filt_ptcwrite(struct knote *kn, long hint)
  698 {
  699         struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
  700         struct tty *tp;
tp = pti->pt_tty;
kn->kn_data = 0;
  705         if (ISSET(tp->t_state, TS_ISOPEN)) {
  706                 if (ISSET(pti->pt_flags, PF_REMOTE)) {
  707                         if (tp->t_canq.c_cc == 0)
kn->kn_data = tp->t_canq.c_cn;
  709                 } else if (tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2)
kn->kn_data = tp->t_canq.c_cn -
  711                             (tp->t_rawq.c_cc + tp->t_canq.c_cc);
  712         }
  714         return (kn->kn_data > 0);
  715 }
  717 struct filterops ptcread_filtops =
  718         { 1, NULL, filt_ptcrdetach, filt_ptcread };
  719 struct filterops ptcwrite_filtops =
  720         { 1, NULL, filt_ptcwdetach, filt_ptcwrite };
  722 int
  723 ptckqfilter(dev_t dev, struct knote *kn)
  724 {
  725         struct pt_softc *pti = pt_softc[minor(dev)];
  726         struct klist *klist;
  727         int s;
  729         switch (kn->kn_filter) {
  730         case EVFILT_READ:
klist = &pti->pt_selr.si_note;
kn->kn_fop = &ptcread_filtops;
  733                 break;
  734         case EVFILT_WRITE:
klist = &pti->pt_selw.si_note;
kn->kn_fop = &ptcwrite_filtops;
  737                 break;
  738         default:
  739                 return (1);
  740         }
kn->kn_hook = (caddr_t)pti;
s = spltty();
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
splx(s);
  748         return (0);
  749 }
  751 struct tty *
ptytty(dev_t dev)
  753 {
  754         struct pt_softc *pti = pt_softc[minor(dev)];
  755         struct tty *tp = pti->pt_tty;
  757         return (tp);
  758 }
  760 /*ARGSUSED*/
  761 int
ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  763 {
  764         struct pt_softc *pti = pt_softc[minor(dev)];
  765         struct tty *tp = pti->pt_tty;
u_char *cc = tp->t_cc;
  767         int stop, error;
  769         /*
  770          * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
  771          * ttywflush(tp) will hang if there are characters in the outq.
  772          */
  773         if (cmd == TIOCEXT) {
  774                 /*
  775                  * When the EXTPROC bit is being toggled, we need
  776                  * to send an TIOCPKT_IOCTL if the packet driver
  777                  * is turned on.
  778                  */
  779                 if (*(int *)data) {
  780                         if (pti->pt_flags & PF_PKT) {
pti->pt_send |= TIOCPKT_IOCTL;
ptcwakeup(tp, FREAD);
  783                         }
tp->t_lflag |= EXTPROC;
  785                 } else {
  786                         if ((tp->t_lflag & EXTPROC) &&
  787                             (pti->pt_flags & PF_PKT)) {
pti->pt_send |= TIOCPKT_IOCTL;
ptcwakeup(tp, FREAD);
  790                         }
tp->t_lflag &= ~EXTPROC;
  792                 }
  793                 return(0);
  794         } else
  795         if (cdevsw[major(dev)].d_open == ptcopen)
  796                 switch (cmd) {
  798                 case TIOCGPGRP:
  799 #ifdef COMPAT_SUNOS
  800                     {
  801                         /*
  802                          * I'm not sure about SunOS TIOCGPGRP semantics
  803                          * on PTYs, but it's something like this:
  804                          */
  805                         extern struct emul emul_sunos;
  806                         if (p->p_emul == &emul_sunos) {
  807                                 if (tp->t_pgrp == 0)
  808                                         return (EIO);
  809                                 *(int *)data = tp->t_pgrp->pg_id;
  810                                 return (0);
  811                         }
  812                     }
  813 #endif
  814                         /*
  815                          * We avoid calling ttioctl on the controller since,
  816                          * in that case, tp must be the controlling terminal.
  817                          */
  818                         *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
  819                         return (0);
  821                 case TIOCPKT:
  822                         if (*(int *)data) {
  823                                 if (pti->pt_flags & PF_UCNTL)
  824                                         return (EINVAL);
pti->pt_flags |= PF_PKT;
  826                         } else
pti->pt_flags &= ~PF_PKT;
  828                         return (0);
  830                 case TIOCUCNTL:
  831                         if (*(int *)data) {
  832                                 if (pti->pt_flags & PF_PKT)
  833                                         return (EINVAL);
pti->pt_flags |= PF_UCNTL;
  835                         } else
pti->pt_flags &= ~PF_UCNTL;
  837                         return (0);
  839                 case TIOCREMOTE:
  840                         if (*(int *)data)
pti->pt_flags |= PF_REMOTE;
  842                         else
pti->pt_flags &= ~PF_REMOTE;
ttyflush(tp, FREAD|FWRITE);
  845                         return (0);
  847 #ifdef COMPAT_OLDTTY
  848                 case TIOCSETP:
  849                 case TIOCSETN:
  850 #endif
  851                 case TIOCSETD:
  852                 case TIOCSETA:
  853                 case TIOCSETAW:
  854                 case TIOCSETAF:
ndflush(&tp->t_outq, tp->t_outq.c_cc);
  856                         break;
  858                 case TIOCSIG:
  859                         if (*(unsigned int *)data >= NSIG)
  860                                 return(EINVAL);
  861                         if ((tp->t_lflag&NOFLSH) == 0)
ttyflush(tp, FREAD|FWRITE);
pgsignal(tp->t_pgrp, *(unsigned int *)data, 1);
  864                         if ((*(unsigned int *)data == SIGINFO) &&
  865                             ((tp->t_lflag&NOKERNINFO) == 0))
ttyinfo(tp);
  867                         return(0);
  868                 }
error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
  870         if (error < 0)
error = ttioctl(tp, cmd, data, flag, p);
  872         if (error < 0) {
  873                 if (pti->pt_flags & PF_UCNTL &&
  874                     (cmd & ~0xff) == UIOCCMD(0)) {
  875                         if (cmd & 0xff) {
pti->pt_ucntl = (u_char)cmd;
ptcwakeup(tp, FREAD);
  878                         }
  879                         return (0);
  880                 }
error = ENOTTY;
  882         }
  883         /*
  884          * If external processing and packet mode send ioctl packet.
  885          */
  886         if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) {
  887                 switch (cmd) {
  888                 case TIOCSETA:
  889                 case TIOCSETAW:
  890                 case TIOCSETAF:
  891 #ifdef COMPAT_OLDTTY
  892                 case TIOCSETP:
  893                 case TIOCSETN:
  894                 case TIOCSETC:
  895                 case TIOCSLTC:
  896                 case TIOCLBIS:
  897                 case TIOCLBIC:
  898                 case TIOCLSET:
  899 #endif
pti->pt_send |= TIOCPKT_IOCTL;
ptcwakeup(tp, FREAD);
  902                 default:
  903                         break;
  904                 }
  905         }
stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) &&
CCEQ(cc[VSTART], CTRL('q'));
  908         if (pti->pt_flags & PF_NOSTOP) {
  909                 if (stop) {
pti->pt_send &= ~TIOCPKT_NOSTOP;
pti->pt_send |= TIOCPKT_DOSTOP;
pti->pt_flags &= ~PF_NOSTOP;
ptcwakeup(tp, FREAD);
  914                 }
  915         } else {
  916                 if (!stop) {
pti->pt_send &= ~TIOCPKT_DOSTOP;
pti->pt_send |= TIOCPKT_NOSTOP;
pti->pt_flags |= PF_NOSTOP;
ptcwakeup(tp, FREAD);
  921                 }
  922         }
  923         return (error);
  924 }
  926 /*
  927  * Return pty-related information.
  928  */
  929 int
sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
  932 {
  933         int error, oldmax;
  935         if (namelen != 1)
  936                 return (ENOTDIR);
  938         switch (name[0]) {
  939         case KERN_TTY_MAXPTYS:
  940                 if (!newp)
  941                         return (sysctl_rdint(oldp, oldlenp, newp, maxptys));
rw_enter_write(&pt_softc_lock);
oldmax = maxptys;
error = sysctl_int(oldp, oldlenp, newp, newlen, &maxptys);
  945                 /*
  946                  * We can't set the max lower than the current active
  947                  * value or to a value bigger than NPTY_MAX.
  948                  */
  949                 if (error == 0 && (maxptys > NPTY_MAX || maxptys < npty)) {
maxptys = oldmax;
error = ERANGE;
  952                 }
rw_exit_write(&pt_softc_lock);
  954                 return (error);
  955         case KERN_TTY_NPTYS:
  956                 return (sysctl_rdint(oldp, oldlenp, newp, npty));
  957 #ifdef notyet
  958         case KERN_TTY_GID:
  959                 return (sysctl_int(oldp, oldlenp, newp, newlen, &tty_gid));
  960 #endif
  961         default:
  962                 return (EOPNOTSUPP);
  963         }
  964         /* NOTREACHED */
  965 }
  967 /*
  968  * Check if a pty is free to use.
  969  */
  970 static __inline int
pty_isfree_locked(int minor)
  972 {
  973         struct pt_softc *pt = pt_softc[minor];
  974         return (pt == NULL || pt->pt_tty == NULL ||
pt->pt_tty->t_oproc == NULL);
  976 }
  978 static int
pty_isfree(int minor)
  980 {
  981         int isfree;
rw_enter_read(&pt_softc_lock);
isfree = pty_isfree_locked(minor);
rw_exit_read(&pt_softc_lock);
  986         return(isfree);
  987 }
dev_t
pty_getfree(void)
  991 {
  992         int i;
rw_enter_read(&pt_softc_lock);
  995         for (i = 0; i < npty; i++) {
  996                 if (pty_isfree_locked(i))
  997                         break;
  998         }
rw_exit_read(&pt_softc_lock);
 1000         return (makedev(pts_major, i));
 1001 }
 1003 /*
 1004  * Hacked up version of vn_open. We _only_ handle ptys and only open
 1005  * them with FREAD|FWRITE and never deal with creat or stuff like that.
 1006  *
 1007  * We need it because we have to fake up root credentials to open the pty.
 1008  */
 1009 static int
ptm_vn_open(struct nameidata *ndp)
 1011 {
 1012         struct proc *p = ndp->ni_cnd.cn_proc;
 1013         struct ucred *cred;
 1014         struct vattr vattr;
 1015         struct vnode *vp;
 1016         int error;
 1018         if ((error = namei(ndp)) != 0)
 1019                 return (error);
vp = ndp->ni_vp;
 1021         if (vp->v_type != VCHR) {
error = EINVAL;
 1023                 goto bad;
 1024         }
 1026         /*
 1027          * Get us a fresh cred with root privileges.
 1028          */
cred = crget();
error = VOP_OPEN(vp, FREAD|FWRITE, cred, p);
 1031         if (!error) {
 1032                 /* update atime/mtime */
VATTR_NULL(&vattr);
getnanotime(&vattr.va_atime);
vattr.va_mtime = vattr.va_atime;
vattr.va_vaflags |= VA_UTIMES_NULL;
 1037                 (void)VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1038         }
crfree(cred);
 1041         if (error)
 1042                 goto bad;
vp->v_writecount++;
 1046         return (0);
bad:
vput(vp);
 1049         return (error);
 1050 }
 1052 void
ptmattach(int n)
 1054 {
 1055         /* find the major and minor of the pty devices */
 1056         int i;
 1058         for (i = 0; i < nchrdev; i++)
 1059                 if (cdevsw[i].d_open == ptsopen)
 1060                         break;
 1062         if (i == nchrdev)
panic("ptmattach: Can't find pty slave in cdevsw");
pts_major = i;
 1066 }
 1068 int
ptmopen(dev_t dev, int flag, int mode, struct proc *p)
 1070 {
 1071         return(0);
 1072 }
 1075 int
ptmclose(dev_t dev, int flag, int mode, struct proc *p)
 1077 {
 1078         return (0);
 1079 }
 1081 int
ptmread(dev_t dev, struct uio *uio, int ioflag)
 1083 {
 1084         return (EIO);
 1085 }
 1087 int
ptmwrite(dev_t dev, struct uio *uio, int ioflag)
 1089 {
 1090         return (EIO);
 1091 }
 1093 int
ptmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 1095 {
dev_t newdev, error;
 1097         struct pt_softc * pti;
 1098         struct nameidata cnd, snd;
 1099         struct filedesc *fdp = p->p_fd;
 1100         struct file *cfp = NULL, *sfp = NULL;
 1101         int cindx, sindx;
uid_t uid;
gid_t gid;
 1104         struct vattr vattr;
 1105         struct ucred *cred;
 1106         struct ptmget *ptm = (struct ptmget *)data;
error = 0;
 1109         switch (cmd) {
 1110         case PTMGET:
fdplock(fdp);
 1112                 /* Grab two filedescriptors. */
 1113                 if ((error = falloc(p, &cfp, &cindx)) != 0) {
fdpunlock(fdp);
 1115                         break;
 1116                 }
 1117                 if ((error = falloc(p, &sfp, &sindx)) != 0) {
fdremove(fdp, cindx);
closef(cfp, p);
fdpunlock(fdp);
 1121                         break;
 1122                 }
retry:
 1125                 /* Find and open a free master pty. */
newdev = pty_getfree();
 1127                 if ((error = check_pty(minor(newdev))))
 1128                         goto bad;
pti = pt_softc[minor(newdev)];
NDINIT(&cnd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
pti->pty_pn, p);
 1132                 if ((error = ptm_vn_open(&cnd)) != 0) {
 1133                         /*
 1134                          * Check if the master open failed because we lost
 1135                          * the race to grab it.
 1136                          */
 1137                         if (error == EIO && !pty_isfree(minor(newdev)))
 1138                                 goto retry;
 1139                         goto bad;
 1140                 }
cfp->f_flag = FREAD|FWRITE;
cfp->f_type = DTYPE_VNODE;
cfp->f_ops = &vnops;
cfp->f_data = (caddr_t) cnd.ni_vp;
VOP_UNLOCK(cnd.ni_vp, 0, p);
 1147                 /*
 1148                  * Open the slave.
 1149                  * namei -> setattr -> unlock -> revoke -> vrele ->
 1150                  * namei -> open -> unlock
 1151                  * Three stage rocket:
 1152                  * 1. Change the owner and permissions on the slave.
 1153                  * 2. Revoke all the users of the slave.
 1154                  * 3. open the slave.
 1155                  */
NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
pti->pty_sn, p);
 1158                 if ((error = namei(&snd)) != 0)
 1159                         goto bad;
 1160                 if ((snd.ni_vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
gid = tty_gid;
 1162                         /* get real uid */
uid = p->p_cred->p_ruid;
VATTR_NULL(&vattr);
vattr.va_uid = uid;
vattr.va_gid = gid;
vattr.va_mode = (S_IRUSR|S_IWUSR|S_IWGRP) & ALLPERMS;
 1169                         /* Get a fake cred to pretend we're root. */
cred = crget();
error = VOP_SETATTR(snd.ni_vp, &vattr, cred, p);
crfree(cred);
 1173                         if (error) {
vput(snd.ni_vp);
 1175                                 goto bad;
 1176                         }
 1177                 }
VOP_UNLOCK(snd.ni_vp, 0, p);
 1179                 if (snd.ni_vp->v_usecount > 1 ||
 1180                     (snd.ni_vp->v_flag & (VALIASED)))
VOP_REVOKE(snd.ni_vp, REVOKEALL);
 1183                 /*
 1184                  * The vnode is useless after the revoke, we need to
 1185                  * namei again.
 1186                  */
vrele(snd.ni_vp);
NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
pti->pty_sn, p);
 1191                 /* now open it */
 1192                 if ((error = ptm_vn_open(&snd)) != 0)
 1193                         goto bad;
sfp->f_flag = FREAD|FWRITE;
sfp->f_type = DTYPE_VNODE;
sfp->f_ops = &vnops;
sfp->f_data = (caddr_t) snd.ni_vp;
VOP_UNLOCK(snd.ni_vp, 0, p);
 1200                 /* now, put the indexen and names into struct ptmget */
ptm->cfd = cindx;
ptm->sfd = sindx;
memcpy(ptm->cn, pti->pty_pn, sizeof(pti->pty_pn));
memcpy(ptm->sn, pti->pty_sn, sizeof(pti->pty_sn));
 1206                 /* mark the files mature now that we've passed all errors */
FILE_SET_MATURE(cfp);
FILE_SET_MATURE(sfp);
fdpunlock(fdp);
 1211                 break;
 1212         default:
error = EINVAL;
 1214                 break;
 1215         }
 1216         return (error);
bad:
fdremove(fdp, cindx);
closef(cfp, p);
fdremove(fdp, sindx);
closef(sfp, p);
fdpunlock(fdp);
 1223         return (error);
 1224 }
 1226 int
ptmpoll(dev_t dev, int events, struct proc *p)
 1228 {
 1229         return (seltrue(dev, events, p));
 1230 }