sys/kern/tty_tty.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)tty_tty.c   8.2 (Berkeley) 9/23/93
  34  * $FreeBSD: src/sys/kern/tty_tty.c,v 1.30 1999/09/25 18:24:24 phk Exp $
  35  * $DragonFly: src/sys/kern/tty_tty.c,v 1.19 2007/07/03 17:22:14 dillon Exp $
  36  */
  37
  38 /*
  39  * Indirect driver for controlling tty.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/conf.h>
  45 #include <sys/device.h>
  46 #include <sys/lock.h>
  47 #include <sys/fcntl.h>
  48 #include <sys/proc.h>
  49 #include <sys/ttycom.h>
  50 #include <sys/vnode.h>
  51 #include <sys/kernel.h>
  52
  53 static  d_open_t        cttyopen;
  54 static  d_close_t       cttyclose;
  55 static  d_read_t        cttyread;
  56 static  d_write_t       cttywrite;
  57 static  d_ioctl_t       cttyioctl;
  58 static  d_poll_t        cttypoll;
  59
  60 #define CDEV_MAJOR      1
  61 /* Don't make this static, since fdesc_vnops uses it. */
  62 struct dev_ops ctty_ops = {
  63         { "ctty", CDEV_MAJOR, D_TTY },
  64         .d_open =       cttyopen,
  65         .d_close =      cttyclose,
  66         .d_read =       cttyread,
  67         .d_write =      cttywrite,
  68         .d_ioctl =      cttyioctl,
  69         .d_poll =       cttypoll,
  70 };
  71
  72 #define cttyvp(p) ((p)->p_flag & P_CONTROLT ? (p)->p_session->s_ttyvp : NULL)
  73
  74 /*
  75  * This opens /dev/tty.  Because multiple opens of /dev/tty only
  76  * generate a single open to the actual tty, the file modes are
  77  * locked to FREAD|FWRITE.
  78  */
  79 static  int
  80 cttyopen(struct dev_open_args *ap)
  81 {
  82         struct proc *p = curproc;
  83         struct vnode *ttyvp;
  84         int error;
  85
  86         KKASSERT(p);
  87 retry:
  88         if ((ttyvp = cttyvp(p)) == NULL)
  89                 return (ENXIO);
  90         if (ttyvp->v_flag & VCTTYISOPEN)
  91                 return (0);
  92
  93         /*
  94          * Messy interlock, don't let the vnode go away while we try to
  95          * lock it and check for race after we might have blocked.
  96          */
  97         vhold(ttyvp);
  98         vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY);
  99         if (ttyvp != cttyvp(p) || (ttyvp->v_flag & VCTTYISOPEN)) {
 100                 kprintf("Warning: cttyopen: race avoided\n");
 101                 vn_unlock(ttyvp);
 102                 vdrop(ttyvp);
 103                 goto retry;
 104         }
 105         vsetflags(ttyvp, VCTTYISOPEN);
 106         error = VOP_OPEN(ttyvp, FREAD|FWRITE, ap->a_cred, NULL);
 107         if (error)
 108                 vclrflags(ttyvp, VCTTYISOPEN);
 109         vn_unlock(ttyvp);
 110         vdrop(ttyvp);
 111         return(error);
 112 }
 113
 114 /*
 115  * This closes /dev/tty.  Because multiple opens of /dev/tty only
 116  * generate a single open to the actual tty, the file modes are
 117  * locked to FREAD|FWRITE.
 118  */
 119 static int
 120 cttyclose(struct dev_close_args *ap)
 121 {
 122         struct proc *p = curproc;
 123         struct vnode *ttyvp;
 124         int error;
 125
 126         KKASSERT(p);
 127 retry:
 128         /*
 129          * The tty may have been TIOCNOTTY'd, don't return an
 130          * error on close.  We just have nothing to do.
 131          */
 132         if ((ttyvp = cttyvp(p)) == NULL)
 133                 return(0);
 134         if (ttyvp->v_flag & VCTTYISOPEN) {
 135                 /*
 136                  * Avoid a nasty race if we block while getting the lock.
 137                  */
 138                 vhold(ttyvp);
 139                 error = vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY);
 140                 if (error) {
 141                         vdrop(ttyvp);
 142                         goto retry;
 143                 }
 144                 if (ttyvp != cttyvp(p) || (ttyvp->v_flag & VCTTYISOPEN) == 0) {
 145                         kprintf("Warning: cttyclose: race avoided\n");
 146                         vn_unlock(ttyvp);
 147                         vdrop(ttyvp);
 148                         goto retry;
 149                 }
 150                 vclrflags(ttyvp, VCTTYISOPEN);
 151                 error = VOP_CLOSE(ttyvp, FREAD|FWRITE);
 152                 vn_unlock(ttyvp);
 153                 vdrop(ttyvp);
 154         } else {
 155                 error = 0;
 156         }
 157         return(error);
 158 }
 159
 160 /*
 161  * Read from the controlling terminal (/dev/tty).  The tty is refed as
 162  * of the cttyvp(), but the ref can get ripped out from under us if
 163  * the controlling terminal is revoked while we are blocked on the lock,
 164  * so use vget() instead of vn_lock().
 165  */
 166 static  int
 167 cttyread(struct dev_read_args *ap)
 168 {
 169         struct proc *p = curproc;
 170         struct vnode *ttyvp;
 171         int error;
 172
 173         KKASSERT(p);
 174         ttyvp = cttyvp(p);
 175         if (ttyvp == NULL)
 176                 return (EIO);
 177         if ((error = vget(ttyvp, LK_EXCLUSIVE | LK_RETRY)) == 0) {
 178                 error = VOP_READ(ttyvp, ap->a_uio, ap->a_ioflag, NOCRED);
 179                 vput(ttyvp);
 180         }
 181         return (error);
 182 }
 183
 184 /*
 185  * Read from the controlling terminal (/dev/tty).  The tty is refed as
 186  * of the cttyvp(), but the ref can get ripped out from under us if
 187  * the controlling terminal is revoked while we are blocked on the lock,
 188  * so use vget() instead of vn_lock().
 189  */
 190 static  int
 191 cttywrite(struct dev_write_args *ap)
 192 {
 193         struct proc *p = curproc;
 194         struct vnode *ttyvp;
 195         int error;
 196
 197         KKASSERT(p);
 198         ttyvp = cttyvp(p);
 199         if (ttyvp == NULL)
 200                 return (EIO);
 201         if ((error = vget(ttyvp, LK_EXCLUSIVE | LK_RETRY)) == 0) {
 202                 error = VOP_WRITE(ttyvp, ap->a_uio, ap->a_ioflag, NOCRED);
 203                 vput(ttyvp);
 204         }
 205         return (error);
 206 }
 207
 208 /*ARGSUSED*/
 209 static  int
 210 cttyioctl(struct dev_ioctl_args *ap)
 211 {
 212         struct vnode *ttyvp;
 213         struct proc *p = curproc;
 214
 215         KKASSERT(p);
 216         ttyvp = cttyvp(p);
 217         if (ttyvp == NULL)
 218                 return (EIO);
 219         /*
 220          * Don't allow controlling tty to be set to the controlling tty
 221          * (infinite recursion).
 222          */
 223         if (ap->a_cmd == TIOCSCTTY)
 224                 return EINVAL;
 225         if (ap->a_cmd == TIOCNOTTY) {
 226                 if (!SESS_LEADER(p)) {
 227                         p->p_flag &= ~P_CONTROLT;
 228                         return (0);
 229                 } else {
 230                         return (EINVAL);
 231                 }
 232         }
 233         return (VOP_IOCTL(ttyvp, ap->a_cmd, ap->a_data, ap->a_fflag, ap->a_cred));
 234 }
 235
 236 /*ARGSUSED*/
 237 static  int
 238 cttypoll(struct dev_poll_args *ap)
 239 {
 240         cdev_t dev = ap->a_head.a_dev;
 241         struct vnode *ttyvp;
 242         struct proc *p = curproc;
 243
 244         KKASSERT(p);
 245         ttyvp = cttyvp(p);
 246         /*
 247          * try operation to get EOF/failure
 248          */
 249         if (ttyvp == NULL)
 250                 ap->a_events = seltrue(dev, ap->a_events);
 251         else
 252                 ap->a_events = VOP_POLL(ttyvp, ap->a_events, p->p_ucred);
 253         return(0);
 254 }
 255
 256 static void
 257 ctty_drvinit(void *unused __unused)
 258 {
 259         dev_ops_add(&ctty_ops, 0, 0);
 260         make_dev(&ctty_ops, 0, 0, 0, 0666, "tty");
 261 }
 262
 263 SYSINIT(cttydev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,ctty_drvinit,NULL)