The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/tty_pts.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 /*
    2  * Copyright (c) 2003 Networks Associates Technology, Inc.
    3  * Copyright (c) 2006 Robert N. M. Watson
    4  * Copyright (c) 2006 Olivier Houchard
    5  * All rights reserved.
    6  *
    7  * This software was developed for the FreeBSD Project in part by Network
    8  * Associates Laboratories, the Security Research Division of Network
    9  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"),
   10  * as part of the DARPA CHATS research program.
   11  *
   12  * Copyright (c) 1982, 1986, 1989, 1993
   13  *      The Regents of the University of California.  All rights reserved.
   14  *
   15  * Redistribution and use in source and binary forms, with or without
   16  * modification, are permitted provided that the following conditions
   17  * are met:
   18  * 1. Redistributions of source code must retain the above copyright
   19  *    notice, this list of conditions and the following disclaimer.
   20  * 2. Redistributions in binary form must reproduce the above copyright
   21  *    notice, this list of conditions and the following disclaimer in the
   22  *    documentation and/or other materials provided with the distribution.
   23  * 4. Neither the name of the University nor the names of its contributors
   24  *    may be used to endorse or promote products derived from this software
   25  *    without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   37  * SUCH DAMAGE.
   38  *
   39  *      @(#)tty_pty.c   8.4 (Berkeley) 2/20/95
   40  */
   41 
   42 #include <sys/cdefs.h>
   43 __FBSDID("$FreeBSD$");
   44 
   45 /*
   46  * Pseudo-teletype Driver
   47  * (Actually two drivers, requiring two entries in 'cdevsw')
   48  */
   49 #include "opt_compat.h"
   50 #include "opt_tty.h"
   51 #include <sys/param.h>
   52 #include <sys/systm.h>
   53 #include <sys/lock.h>
   54 #include <sys/mutex.h>
   55 #include <sys/sx.h>
   56 #if defined(COMPAT_43TTY)
   57 #include <sys/ioctl_compat.h>
   58 #endif
   59 #include <sys/priv.h>
   60 #include <sys/proc.h>
   61 #include <sys/queue.h>
   62 #include <sys/tty.h>
   63 #include <sys/fcntl.h>
   64 #include <sys/poll.h>
   65 #include <sys/kernel.h>
   66 #include <sys/vnode.h>
   67 #include <sys/signalvar.h>
   68 #include <sys/malloc.h>
   69 #include <sys/conf.h>
   70 #include <sys/sysctl.h>
   71 #include <sys/filio.h>
   72 
   73 static MALLOC_DEFINE(M_PTY, "ptys", "pty data structures");
   74 
   75 static void ptsstart(struct tty *tp);
   76 static void ptsstop(struct tty *tp, int rw);
   77 static void ptcwakeup(struct tty *tp, int flag);
   78 
   79 static d_open_t         ptsopen;
   80 static d_close_t        ptsclose;
   81 static d_read_t         ptsread;
   82 static d_write_t        ptswrite;
   83 static d_ioctl_t        ptsioctl;
   84 static d_ioctl_t        ptcioctl;
   85 static d_open_t         ptcopen;
   86 static d_close_t        ptcclose;
   87 static d_read_t         ptcread;
   88 static d_write_t        ptcwrite;
   89 static d_poll_t         ptcpoll;
   90 
   91 static struct cdevsw pts_cdevsw = {
   92         .d_version =    D_VERSION,
   93         .d_open =       ptsopen,
   94         .d_close =      ptsclose,
   95         .d_read =       ptsread,
   96         .d_write =      ptswrite,
   97         .d_ioctl =      ptsioctl,
   98         .d_poll =       ttypoll,
   99         .d_name =       "pts",
  100         .d_flags =      D_TTY | D_NEEDGIANT,
  101         .d_kqfilter =   ttykqfilter,
  102 };
  103 
  104 static struct cdevsw ptc_cdevsw = {
  105         .d_version =    D_VERSION,
  106         .d_open =       ptcopen,
  107         .d_close =      ptcclose,
  108         .d_read =       ptcread,
  109         .d_write =      ptcwrite,
  110         .d_ioctl =      ptcioctl,
  111         .d_poll =       ptcpoll,
  112         .d_name =       "ptc",
  113         .d_flags =      D_TTY | D_NEEDGIANT,
  114         .d_kqfilter =   ttykqfilter,
  115 };
  116 
  117 #define BUFSIZ 100              /* Chunk size iomoved to/from user */
  118 
  119 #define TSA_PTC_READ(tp)        ((void *)&(tp)->t_outq.c_cf)
  120 #define TSA_PTC_WRITE(tp)       ((void *)&(tp)->t_rawq.c_cl)
  121 #define TSA_PTS_READ(tp)        ((void *)&(tp)->t_canq)
  122 
  123 #define NUM_TO_MINOR(c)         ((c & 0xff) | ((c & ~0xff) << 16))
  124 /*-
  125  * Once a tty is allocated, it cannot (currently) be freed.  As such,
  126  * we keep a global list of ptys that have been used so we can recycle
  127  * them.  Another list is provided for released pts, which are 
  128  * not currently allocated, permitting reuse.  pt_flags holds state
  129  * associated with a particular session, so isn't overloaded for this.
  130  * When a pty descriptor is unused, its number is set to -1 giving
  131  * more consistent and traditional allocation orders to pty numbers.
  132  *
  133  * Locking: (p) indicates that the field is locked by the global pt_mtx.
  134  * (c) indicates the value is constant after allocation.   Other fields
  135  * await tty locking generally, and are protected by Giant.
  136  */
  137 struct  pt_desc {
  138         int                      pt_num;        /* (c) pty number */
  139         LIST_ENTRY(pt_desc)      pt_list;       /* (p) global pty list */
  140 
  141         int                      pt_flags;
  142         struct selinfo           pt_selr, pt_selw;
  143         u_char                   pt_send;
  144         u_char                   pt_ucntl;
  145         struct tty               *pt_tty;
  146         struct cdev              *pt_devs, *pt_devc;
  147         int                      pt_pts_open, pt_ptc_open;
  148         struct prison           *pt_prison;
  149 };
  150 
  151 static struct mtx               pt_mtx;
  152 static LIST_HEAD(,pt_desc)      pt_list;
  153 static LIST_HEAD(,pt_desc)      pt_free_list;
  154 
  155 #define PF_PKT          0x008           /* packet mode */
  156 #define PF_STOPPED      0x010           /* user told stopped */
  157 #define PF_NOSTOP       0x040
  158 #define PF_UCNTL        0x080           /* user control mode */
  159 
  160 static unsigned int next_avail_nb;
  161 
  162 static int use_pts = 0;
  163 
  164 static unsigned int max_pts = 1000;
  165 
  166 static unsigned int nb_allocated;
  167 
  168 TUNABLE_INT("kern.pts.enable", &use_pts);
  169 
  170 SYSCTL_NODE(_kern, OID_AUTO, pts, CTLFLAG_RD, 0, "pts");
  171 
  172 SYSCTL_INT(_kern_pts, OID_AUTO, enable, CTLFLAG_RW, &use_pts, 0,
  173     "enable pts");
  174 
  175 SYSCTL_INT(_kern_pts, OID_AUTO, max, CTLFLAG_RW, &max_pts, 0, "max pts");
  176 
  177 /*
  178  * If there's a free pty descriptor in the pty descriptor list, retrieve it.
  179  * Otherwise, allocate a new one, initialize it, and hook it up.  If there's
  180  * not a tty number, reject.
  181  */
  182 static struct pt_desc *
  183 pty_new(void)
  184 {
  185         struct pt_desc *pt;
  186         int nb;
  187 
  188         mtx_lock(&pt_mtx);
  189         if (nb_allocated >= max_pts || nb_allocated == 0xffffff) {
  190                 mtx_unlock(&pt_mtx);
  191                 return (NULL);
  192         }
  193         nb_allocated++;
  194         pt = LIST_FIRST(&pt_free_list);
  195         if (pt) {
  196                 LIST_REMOVE(pt, pt_list);
  197                 LIST_INSERT_HEAD(&pt_list, pt, pt_list);
  198                 mtx_unlock(&pt_mtx);
  199         } else {
  200                 nb = next_avail_nb++;
  201                 mtx_unlock(&pt_mtx);
  202                 pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO);
  203                 mtx_lock(&pt_mtx);
  204                 pt->pt_num = nb;
  205                 LIST_INSERT_HEAD(&pt_list, pt, pt_list);
  206                 mtx_unlock(&pt_mtx);
  207                 pt->pt_tty = ttyalloc();
  208         }
  209         return (pt);
  210 }
  211 
  212 /*
  213  * Release a pty descriptor back to the pool for reuse.  The pty number
  214  * remains allocated.
  215  */
  216 static void
  217 pty_release(void *v)
  218 {
  219         struct pt_desc *pt = (struct pt_desc *)v;
  220 
  221         mtx_lock(&pt_mtx);
  222         KASSERT(pt->pt_ptc_open == 0 && pt->pt_pts_open == 0,
  223             ("pty_release: pts/%d freed while open\n", pt->pt_num));
  224         KASSERT(pt->pt_devs == NULL && pt->pt_devc == NULL,
  225             ("pty_release: pts/%d freed whith non-null struct cdev\n", pt->pt_num));
  226         nb_allocated--;
  227         LIST_REMOVE(pt, pt_list);
  228         LIST_INSERT_HEAD(&pt_free_list, pt, pt_list);
  229         mtx_unlock(&pt_mtx);
  230 }
  231 
  232 /*
  233  * Given a pty descriptor, if both endpoints are closed, release all
  234  * resources and destroy the device nodes to flush file system level
  235  * state for the tty (owner, avoid races, etc).
  236  */
  237 static void
  238 pty_maybecleanup(struct pt_desc *pt)
  239 {
  240         struct cdev *pt_devs, *pt_devc;
  241 
  242         if (pt->pt_ptc_open || pt->pt_pts_open)
  243                 return;
  244 
  245         if (pt->pt_tty->t_refcnt > 1)
  246                 return;
  247 
  248         if (bootverbose)
  249                 printf("destroying pty %d\n", pt->pt_num);
  250 
  251         pt_devs = pt->pt_devs;
  252         pt_devc = pt->pt_devc;
  253         pt->pt_devs = pt->pt_devc = NULL;
  254         pt->pt_tty->t_dev = NULL;
  255         pt_devc->si_drv1 = NULL;
  256         ttyrel(pt->pt_tty);
  257         pt->pt_tty = NULL;
  258         destroy_dev_sched(pt_devs);
  259         destroy_dev_sched_cb(pt_devc, pty_release, pt);
  260 }
  261 
  262 /*ARGSUSED*/
  263 static int
  264 ptsopen(struct cdev *dev, int flag, int devtype, struct thread *td)
  265 {
  266         struct tty *tp;
  267         int error;
  268         struct pt_desc *pt;
  269 
  270         pt = dev->si_drv1;
  271         tp = dev->si_tty;
  272         if ((tp->t_state & TS_ISOPEN) == 0)
  273                 ttyinitmode(tp, 1, 0);
  274         else if (tp->t_state & TS_XCLUDE && priv_check(td,
  275             PRIV_TTY_EXCLUSIVE)) {
  276                 return (EBUSY);
  277         } else if (pt->pt_prison != td->td_ucred->cr_prison &&
  278             priv_check(td, PRIV_TTY_PRISON)) {
  279                 return (EBUSY);
  280         }
  281         if (tp->t_oproc)                        /* Ctrlr still around. */
  282                 ttyld_modem(tp, 1);
  283         while ((tp->t_state & TS_CARR_ON) == 0) {
  284                 if (flag & FNONBLOCK)
  285                         break;
  286                 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
  287                                  "ptsopn", 0);
  288                 if (error)
  289                         return (error);
  290         }
  291         error = ttyld_open(tp, dev);
  292         if (error == 0) {
  293                 ptcwakeup(tp, FREAD|FWRITE);
  294                 pt->pt_pts_open = 1;
  295         }
  296         return (error);
  297 }
  298 
  299 static int
  300 ptsclose(struct cdev *dev, int flag, int mode, struct thread *td)
  301 {
  302         struct pt_desc *pt = dev->si_drv1;
  303         struct tty *tp;
  304         int err;
  305 
  306         tp = dev->si_tty;
  307         err = ttyld_close(tp, flag);
  308         ptsstop(tp, FREAD|FWRITE);
  309         (void) tty_close(tp);
  310         pt->pt_pts_open = 0;
  311         pty_maybecleanup(pt);
  312         return (err);
  313 }
  314 
  315 static int
  316 ptsread(struct cdev *dev, struct uio *uio, int flag)
  317 {
  318         struct tty *tp = dev->si_tty;
  319         int error = 0;
  320 
  321         if (tp->t_oproc)
  322                 error = ttyld_read(tp, uio, flag);
  323         ptcwakeup(tp, FWRITE);
  324         return (error);
  325 }
  326 
  327 /*
  328  * Write to pseudo-tty.
  329  * Wakeups of controlling tty will happen
  330  * indirectly, when tty driver calls ptsstart.
  331  */
  332 static int
  333 ptswrite(struct cdev *dev, struct uio *uio, int flag)
  334 {
  335         struct tty *tp;
  336 
  337         tp = dev->si_tty;
  338         if (tp->t_oproc == 0)
  339                 return (EIO);
  340         return (ttyld_write(tp, uio, flag));
  341 }
  342 
  343 /*
  344  * Start output on pseudo-tty.
  345  * Wake up process selecting or sleeping for input from controlling tty.
  346  */
  347 static void
  348 ptsstart(struct tty *tp)
  349 {
  350         struct pt_desc *pt = tp->t_dev->si_drv1;
  351 
  352         if (tp->t_state & TS_TTSTOP)
  353                 return;
  354         if (pt->pt_flags & PF_STOPPED) {
  355                 pt->pt_flags &= ~PF_STOPPED;
  356                 pt->pt_send = TIOCPKT_START;
  357         }
  358         ptcwakeup(tp, FREAD);
  359 }
  360 
  361 static void
  362 ptcwakeup(struct tty *tp, int flag)
  363 {
  364         struct pt_desc *pt = tp->t_dev->si_drv1;
  365 
  366         if (flag & FREAD) {
  367                 selwakeup(&pt->pt_selr);
  368                 wakeup(TSA_PTC_READ(tp));
  369         }
  370         if (flag & FWRITE) {
  371                 selwakeup(&pt->pt_selw);
  372                 wakeup(TSA_PTC_WRITE(tp));
  373         }
  374 }
  375 
  376 /*
  377  * ptcopen implementes exclusive access to the master/control device
  378  * as well as creating the slave device based on the credential of the
  379  * process opening the master.  By creating the slave here, we avoid
  380  * a race to access the master in terms of having a process with access
  381  * to an incorrectly owned slave, but it does create the possibility
  382  * that a racing process can cause a ptmx user to get EIO if it gets
  383  * there first.  Consumers of ptmx must look for EIO and retry if it
  384  * happens.  VFS locking may actually prevent this from occurring due
  385  * to the lookup into devfs holding the vnode lock through open, but
  386  * it's better to be careful.
  387  */
  388 static int
  389 ptcopen(struct cdev *dev, int flag, int devtype, struct thread *td)
  390 {
  391         struct pt_desc *pt;
  392         struct tty *tp;
  393         struct cdev *devs;
  394 
  395         pt = dev->si_drv1;
  396         if (pt == NULL)
  397                 return (EIO);
  398         /*
  399          * In case we have destroyed the struct tty at the last connect time,
  400          * we need to recreate it.
  401          */
  402         if (pt->pt_tty == NULL) {
  403                 pt->pt_tty = ttyalloc();
  404                 dev->si_tty = pt->pt_tty;
  405         }
  406         tp = dev->si_tty;
  407         if (tp->t_oproc)
  408                 return (EIO);
  409 
  410         /*
  411          * XXX: Might want to make the ownership/permissions here more
  412          * configurable.
  413          */
  414         if (pt->pt_devs)
  415                 devs = pt->pt_devs;
  416         else
  417                 pt->pt_devs = devs = make_dev_cred(&pts_cdevsw, 
  418                     NUM_TO_MINOR(pt->pt_num), 
  419                     td->td_ucred, UID_ROOT, GID_WHEEL, 0666, "pts/%d",
  420                     pt->pt_num);
  421         devs->si_drv1 = pt;
  422         devs->si_tty = pt->pt_tty;
  423         pt->pt_tty->t_dev = devs;
  424 
  425         tp->t_timeout = -1;
  426         tp->t_oproc = ptsstart;
  427         tp->t_stop = ptsstop;
  428         ttyld_modem(tp, 1);
  429         tp->t_lflag &= ~EXTPROC;
  430         pt = dev->si_drv1;
  431         pt->pt_prison = td->td_ucred->cr_prison;
  432         pt->pt_flags = 0;
  433         pt->pt_send = 0;
  434         pt->pt_ucntl = 0;
  435         pt->pt_ptc_open = 1;
  436         return (0);
  437 }
  438 
  439 static int
  440 ptcclose(struct cdev *dev, int flags, int fmt, struct thread *td)
  441 {
  442         struct pt_desc *pt = dev->si_drv1;
  443         struct tty *tp;
  444 
  445         tp = dev->si_tty;
  446         ttyld_modem(tp, 0);
  447 
  448         /*
  449          * XXX MDMBUF makes no sense for ptys but would inhibit the above
  450          * l_modem().  CLOCAL makes sense but isn't supported.   Special
  451          * l_modem()s that ignore carrier drop make no sense for ptys but
  452          * may be in use because other parts of the line discipline make
  453          * sense for ptys.  Recover by doing everything that a normal
  454          * ttymodem() would have done except for sending a SIGHUP.
  455          */
  456         if (tp->t_state & TS_ISOPEN) {
  457                 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED);
  458                 tp->t_state |= TS_ZOMBIE;
  459                 ttyflush(tp, FREAD | FWRITE);
  460         }
  461 
  462         tp->t_oproc = 0;                /* mark closed */
  463         pt->pt_ptc_open = 0;
  464         pty_maybecleanup(pt);
  465         return (0);
  466 }
  467 
  468 static int
  469 ptcread(struct cdev *dev, struct uio *uio, int flag)
  470 {
  471         struct tty *tp = dev->si_tty;
  472         struct pt_desc *pt = dev->si_drv1;
  473         char buf[BUFSIZ];
  474         int error = 0, cc;
  475 
  476         /*
  477          * We want to block until the slave
  478          * is open, and there's something to read;
  479          * but if we lost the slave or we're NBIO,
  480          * then return the appropriate error instead.
  481          */
  482         for (;;) {
  483                 if (tp->t_state&TS_ISOPEN) {
  484                         if (pt->pt_flags&PF_PKT && pt->pt_send) {
  485                                 error = ureadc((int)pt->pt_send, uio);
  486                                 if (error)
  487                                         return (error);
  488                                 if (pt->pt_send & TIOCPKT_IOCTL) {
  489                                         cc = min(uio->uio_resid,
  490                                                 sizeof(tp->t_termios));
  491                                         uiomove(&tp->t_termios, cc, uio);
  492                                 }
  493                                 pt->pt_send = 0;
  494                                 return (0);
  495                         }
  496                         if (pt->pt_flags&PF_UCNTL && pt->pt_ucntl) {
  497                                 error = ureadc((int)pt->pt_ucntl, uio);
  498                                 if (error)
  499                                         return (error);
  500                                 pt->pt_ucntl = 0;
  501                                 return (0);
  502                         }
  503                         if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
  504                                 break;
  505                 }
  506                 if ((tp->t_state & TS_CONNECTED) == 0)
  507                         return (0);     /* EOF */
  508                 if (flag & O_NONBLOCK)
  509                         return (EWOULDBLOCK);
  510                 error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0);
  511                 if (error)
  512                         return (error);
  513         }
  514         if (pt->pt_flags & (PF_PKT|PF_UCNTL))
  515                 error = ureadc(0, uio);
  516         while (uio->uio_resid > 0 && error == 0) {
  517                 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ));
  518                 if (cc <= 0)
  519                         break;
  520                 error = uiomove(buf, cc, uio);
  521         }
  522         ttwwakeup(tp);
  523         return (error);
  524 }
  525 
  526 static void
  527 ptsstop(struct tty *tp, int flush)
  528 {
  529         struct pt_desc *pt = tp->t_dev->si_drv1;
  530         int flag;
  531 
  532         /* note: FLUSHREAD and FLUSHWRITE already ok */
  533         if (flush == 0) {
  534                 flush = TIOCPKT_STOP;
  535                 pt->pt_flags |= PF_STOPPED;
  536         } else
  537                 pt->pt_flags &= ~PF_STOPPED;
  538         pt->pt_send |= flush;
  539         /* change of perspective */
  540         flag = 0;
  541         if (flush & FREAD)
  542                 flag |= FWRITE;
  543         if (flush & FWRITE)
  544                 flag |= FREAD;
  545         ptcwakeup(tp, flag);
  546 }
  547 
  548 static int
  549 ptcpoll(struct cdev *dev, int events, struct thread *td)
  550 {
  551         struct tty *tp = dev->si_tty;
  552         struct pt_desc *pt = dev->si_drv1;
  553         int revents = 0;
  554         int s;
  555 
  556         if ((tp->t_state & TS_CONNECTED) == 0)
  557                 return (events & 
  558                    (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM));
  559 
  560         /*
  561          * Need to block timeouts (ttrstart).
  562          */
  563         s = spltty();
  564 
  565         if (events & (POLLIN | POLLRDNORM))
  566                 if ((tp->t_state & TS_ISOPEN) &&
  567                     ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) ||
  568                      ((pt->pt_flags & PF_PKT) && pt->pt_send) ||
  569                      ((pt->pt_flags & PF_UCNTL) && pt->pt_ucntl)))
  570                         revents |= events & (POLLIN | POLLRDNORM);
  571 
  572         if (events & (POLLOUT | POLLWRNORM))
  573                 if (tp->t_state & TS_ISOPEN &&
  574                      (((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
  575                       (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON)))))
  576                         revents |= events & (POLLOUT | POLLWRNORM);
  577 
  578         if (events & POLLHUP)
  579                 if ((tp->t_state & TS_CARR_ON) == 0)
  580                         revents |= POLLHUP;
  581 
  582         if (revents == 0) {
  583                 if (events & (POLLIN | POLLRDNORM))
  584                         selrecord(td, &pt->pt_selr);
  585 
  586                 if (events & (POLLOUT | POLLWRNORM))
  587                         selrecord(td, &pt->pt_selw);
  588         }
  589         splx(s);
  590 
  591         return (revents);
  592 }
  593 
  594 static int
  595 ptcwrite(struct cdev *dev, struct uio *uio, int flag)
  596 {
  597         struct tty *tp = dev->si_tty;
  598         u_char *cp = 0;
  599         int cc = 0;
  600         u_char locbuf[BUFSIZ];
  601         int cnt = 0;
  602         int error = 0;
  603 
  604 again:
  605         if ((tp->t_state&TS_ISOPEN) == 0)
  606                 goto block;
  607         while (uio->uio_resid > 0 || cc > 0) {
  608                 if (cc == 0) {
  609                         cc = min(uio->uio_resid, BUFSIZ);
  610                         cp = locbuf;
  611                         error = uiomove(cp, cc, uio);
  612                         if (error)
  613                                 return (error);
  614                         /* check again for safety */
  615                         if ((tp->t_state & TS_ISOPEN) == 0) {
  616                                 /* adjust for data copied in but not written */
  617                                 uio->uio_resid += cc;
  618                                 return (EIO);
  619                         }
  620                 }
  621                 while (cc > 0) {
  622                         if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
  623                            (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) {
  624                                 wakeup(TSA_HUP_OR_INPUT(tp));
  625                                 goto block;
  626                         }
  627                         ttyld_rint(tp, *cp++);
  628                         cnt++;
  629                         cc--;
  630                 }
  631                 cc = 0;
  632         }
  633         return (0);
  634 block:
  635         /*
  636          * Come here to wait for slave to open, for space
  637          * in outq, or space in rawq, or an empty canq.
  638          */
  639         if ((tp->t_state & TS_CONNECTED) == 0) {
  640                 /* adjust for data copied in but not written */
  641                 uio->uio_resid += cc;
  642                 return (EIO);
  643         }
  644         if (flag & IO_NDELAY) {
  645                 /* adjust for data copied in but not written */
  646                 uio->uio_resid += cc;
  647                 if (cnt == 0)
  648                         return (EWOULDBLOCK);
  649                 return (0);
  650         }
  651         error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0);
  652         if (error) {
  653                 /* adjust for data copied in but not written */
  654                 uio->uio_resid += cc;
  655                 return (error);
  656         }
  657         goto again;
  658 }
  659 
  660 static int
  661 ptcioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
  662 {
  663         struct tty *tp = dev->si_tty;
  664         struct pt_desc *pt = dev->si_drv1;
  665 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
  666     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
  667         int ival;
  668 #endif
  669 
  670         switch (cmd) {
  671                 
  672         case TIOCGPGRP:
  673                 /*
  674                  * We avoid calling ttioctl on the controller since,
  675                  * in that case, tp must be the controlling terminal.
  676                  */
  677                 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
  678                 return (0);
  679                 
  680         case TIOCPKT:
  681                 if (*(int *)data) {
  682                         if (pt->pt_flags & PF_UCNTL)
  683                                 return (EINVAL);
  684                         pt->pt_flags |= PF_PKT;
  685                 } else
  686                         pt->pt_flags &= ~PF_PKT;
  687                 return (0);
  688                 
  689         case TIOCUCNTL:
  690                 if (*(int *)data) {
  691                         if (pt->pt_flags & PF_PKT)
  692                                 return (EINVAL);
  693                         pt->pt_flags |= PF_UCNTL;
  694                 } else
  695                         pt->pt_flags &= ~PF_UCNTL;
  696                 return (0);
  697         case TIOCGPTN:
  698                 *(unsigned int *)data = pt->pt_num;
  699                 return (0);
  700         }
  701         
  702         /*
  703          * The rest of the ioctls shouldn't be called until
  704          * the slave is open.
  705          */
  706         if ((tp->t_state & TS_ISOPEN) == 0) {
  707                 if (cmd == TIOCGETA) {
  708                         /* 
  709                          * TIOCGETA is used by isatty() to make sure it's
  710                          * a tty. Linux openpty() calls isatty() very early,
  711                          * before the slave is opened, so don't actually
  712                          * fill the struct termios, but just let isatty()
  713                          * know it's a tty.
  714                          */
  715                         return (0);
  716                 }
  717                 if (cmd != FIONBIO && cmd != FIOASYNC)
  718                         return (EAGAIN);
  719         }
  720         
  721         switch (cmd) {
  722 #ifdef COMPAT_43TTY
  723         case TIOCSETP:
  724         case TIOCSETN:
  725 #endif
  726         case TIOCSETD:
  727         case TIOCSETA:
  728         case TIOCSETAW:
  729         case TIOCSETAF:
  730                 /*
  731                  * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
  732                  * ttywflush(tp) will hang if there are characters in
  733                  * the outq.
  734                  */
  735                 ndflush(&tp->t_outq, tp->t_outq.c_cc);
  736                 break;
  737                 
  738 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
  739     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
  740         case _IO('t', 95):
  741                 ival = IOCPARM_IVAL(data);
  742                 data = (caddr_t)&ival;
  743                 /* FALLTHROUGH */
  744 #endif
  745         case TIOCSIG:
  746                 if (*(unsigned int *)data >= NSIG ||
  747                     *(unsigned int *)data == 0)
  748                         return(EINVAL);
  749                 if ((tp->t_lflag&NOFLSH) == 0)
  750                         ttyflush(tp, FREAD|FWRITE);
  751                 if (tp->t_pgrp != NULL) {
  752                         PGRP_LOCK(tp->t_pgrp);
  753                         pgsignal(tp->t_pgrp, *(unsigned int *)data, 1);
  754                         PGRP_UNLOCK(tp->t_pgrp);
  755                 }
  756                 if ((*(unsigned int *)data == SIGINFO) &&
  757                     ((tp->t_lflag&NOKERNINFO) == 0))
  758                         ttyinfo(tp);
  759                 return(0);
  760         }
  761         return (ptsioctl(dev, cmd, data, flag, td));
  762 }
  763 /*ARGSUSED*/
  764 static int
  765 ptsioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
  766 {
  767         struct tty *tp = dev->si_tty;
  768         struct pt_desc *pt = dev->si_drv1;
  769         u_char *cc = tp->t_cc;
  770         int stop, error;
  771 
  772         if (cmd == TIOCEXT) {
  773                 /*
  774                  * When the EXTPROC bit is being toggled, we need
  775                  * to send an TIOCPKT_IOCTL if the packet driver
  776                  * is turned on.
  777                  */
  778                 if (*(int *)data) {
  779                         if (pt->pt_flags & PF_PKT) {
  780                                 pt->pt_send |= TIOCPKT_IOCTL;
  781                                 ptcwakeup(tp, FREAD);
  782                         }
  783                         tp->t_lflag |= EXTPROC;
  784                 } else {
  785                         if ((tp->t_lflag & EXTPROC) &&
  786                             (pt->pt_flags & PF_PKT)) {
  787                                 pt->pt_send |= TIOCPKT_IOCTL;
  788                                 ptcwakeup(tp, FREAD);
  789                         }
  790                         tp->t_lflag &= ~EXTPROC;
  791                 }
  792                 return(0);
  793         }
  794         error = ttioctl(tp, cmd, data, flag);
  795         if (error == ENOTTY) {
  796                 if (pt->pt_flags & PF_UCNTL &&
  797                     (cmd & ~0xff) == UIOCCMD(0)) {
  798                         if (cmd & 0xff) {
  799                                 pt->pt_ucntl = (u_char)cmd;
  800                                 ptcwakeup(tp, FREAD);
  801                         }
  802                         return (0);
  803                 }
  804                 error = ENOTTY;
  805         }
  806         /*
  807          * If external processing and packet mode send ioctl packet.
  808          */
  809         if ((tp->t_lflag&EXTPROC) && (pt->pt_flags & PF_PKT)) {
  810                 switch(cmd) {
  811                 case TIOCSETA:
  812                 case TIOCSETAW:
  813                 case TIOCSETAF:
  814 #ifdef COMPAT_43TTY
  815                 case TIOCSETP:
  816                 case TIOCSETN:
  817                 case TIOCSETC:
  818                 case TIOCSLTC:
  819                 case TIOCLBIS:
  820                 case TIOCLBIC:
  821                 case TIOCLSET:
  822 #endif
  823                         pt->pt_send |= TIOCPKT_IOCTL;
  824                         ptcwakeup(tp, FREAD);
  825                         break;
  826                 default:
  827                         break;
  828                 }
  829         }
  830         stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s'))
  831                 && CCEQ(cc[VSTART], CTRL('q'));
  832         if (pt->pt_flags & PF_NOSTOP) {
  833                 if (stop) {
  834                         pt->pt_send &= ~TIOCPKT_NOSTOP;
  835                         pt->pt_send |= TIOCPKT_DOSTOP;
  836                         pt->pt_flags &= ~PF_NOSTOP;
  837                         ptcwakeup(tp, FREAD);
  838                 }
  839         } else {
  840                 if (!stop) {
  841                         pt->pt_send &= ~TIOCPKT_DOSTOP;
  842                         pt->pt_send |= TIOCPKT_NOSTOP;
  843                         pt->pt_flags |= PF_NOSTOP;
  844                         ptcwakeup(tp, FREAD);
  845                 }
  846         }
  847         return (error);
  848 }
  849 
  850 /*
  851  * Match lookups on /dev/ptmx, find the next free pty (if any), set up
  852  * the pty descriptor, register it, and return a reference to the master.
  853  *
  854  * pts == /dev/pts/xxx (oldstyle: ttyp...)
  855  * ptc == /dev/pty/xxx (oldstyle: ptyp...)
  856  */
  857 static void
  858 pty_clone(void *arg, struct ucred *cred, char *name, int namelen,
  859     struct cdev **dev)
  860 {
  861         struct pt_desc *pt;
  862         struct cdev *devc;
  863 
  864         if (!use_pts)
  865                 return;
  866 
  867         if (*dev != NULL)
  868                 return;
  869 
  870         if (strcmp(name, "ptmx") != 0)
  871                 return;
  872 
  873         mtx_lock(&Giant);
  874         pt = pty_new();
  875         if (pt == NULL) {
  876                 mtx_unlock(&Giant);
  877                 return;
  878         }
  879 
  880         /*
  881          * XXX: Lack of locking here considered worrying.  We expose the
  882          * pts/pty device nodes before they are fully initialized, although
  883          * Giant likely protects us (unless make_dev blocks...?).
  884          *
  885          * XXX: If a process performs a lookup on /dev/ptmx but never an
  886          * open, we won't GC the device node.  We should have a callout
  887          * sometime later that GC's device instances that were never
  888          * opened, or some way to tell devfs that "this had better be for
  889          * an open() or we won't create a device".
  890          */
  891         pt->pt_devc = devc = make_dev_credf(MAKEDEV_REF, &ptc_cdevsw, 
  892             NUM_TO_MINOR(pt->pt_num), cred, UID_ROOT, GID_WHEEL, 0666,
  893             "pty/%d", pt->pt_num);
  894 
  895         devc->si_drv1 = pt;
  896         devc->si_tty = pt->pt_tty;
  897         *dev = devc;
  898         mtx_unlock(&Giant);
  899 
  900         if (bootverbose)
  901                 printf("pty_clone: allocated pty %d to uid %d\n", pt->pt_num,
  902             cred->cr_ruid);
  903 
  904         return;
  905 }
  906 
  907 static void
  908 pty_drvinit(void *unused)
  909 {
  910 
  911         mtx_init(&pt_mtx, "pt_mtx", NULL, MTX_DEF);
  912         LIST_INIT(&pt_list);
  913         LIST_INIT(&pt_free_list);
  914         EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000);
  915 }
  916 
  917 SYSINIT(ptydev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,pty_drvinit,NULL)

Cache object: 894d924589a47df3ce8c80b330598820


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