Home | History | Annotate | Download | only in io
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 
     22 /*
     23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
     24  * Use is subject to license terms.
     25  */
     26 
     27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
     28 /*	  All Rights Reserved  	*/
     29 
     30 
     31 					/* from S5R4 1.22 */
     32 
     33 /*
     34  * Indirect driver for controlling tty.
     35  */
     36 #include <sys/types.h>
     37 #include <sys/errno.h>
     38 #include <sys/conf.h>
     39 #include <sys/proc.h>
     40 #include <sys/tty.h>
     41 #include <sys/stream.h>
     42 #include <sys/strsubr.h>
     43 #include <sys/cred.h>
     44 #include <sys/uio.h>
     45 #include <sys/session.h>
     46 #include <sys/ddi.h>
     47 #include <sys/debug.h>
     48 #include <sys/stat.h>
     49 #include <sys/sunddi.h>
     50 #include <sys/param.h>
     51 #include <sys/systm.h>
     52 #include <sys/modctl.h>
     53 #include <sys/fs/snode.h>
     54 #include <sys/file.h>
     55 
     56 #define	IS_STREAM(dev) (devopsp[getmajor(dev)]->devo_cb_ops->cb_str != NULL)
     57 
     58 int syopen(dev_t *, int, int, cred_t *);
     59 int syclose(dev_t, int, int, cred_t *);
     60 int syread(dev_t, struct uio *, cred_t *);
     61 int sywrite(dev_t, struct uio *, cred_t *);
     62 int sypoll(dev_t, short, int, short *, struct pollhead **);
     63 int syioctl(dev_t, int, intptr_t, int, cred_t *, int *);
     64 
     65 static int sy_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
     66 static int sy_attach(dev_info_t *, ddi_attach_cmd_t);
     67 static dev_info_t *sy_dip;		/* private copy of devinfo pointer */
     68 
     69 struct cb_ops	sy_cb_ops = {
     70 
     71 	syopen,			/* open */
     72 	syclose,		/* close */
     73 	nodev,			/* strategy */
     74 	nodev,			/* print */
     75 	nodev,			/* dump */
     76 	syread,			/* read */
     77 	sywrite,		/* write */
     78 	syioctl,		/* ioctl */
     79 	nodev,			/* devmap */
     80 	nodev,			/* mmap */
     81 	nodev, 			/* segmap */
     82 	sypoll,			/* poll */
     83 	ddi_prop_op,		/* cb_prop_op */
     84 	0,			/* streamtab  */
     85 	D_NEW | D_MP		/* Driver compatibility flag */
     86 
     87 };
     88 
     89 struct dev_ops	sy_ops = {
     90 
     91 	DEVO_REV,		/* devo_rev, */
     92 	0,			/* refcnt  */
     93 	sy_info,		/* info */
     94 	nulldev,		/* identify */
     95 	nulldev,		/* probe */
     96 	sy_attach,		/* attach */
     97 	nodev,			/* detach */
     98 	nodev,			/* reset */
     99 	&sy_cb_ops,		/* driver operations */
    100 	(struct bus_ops *)0,	/* bus operations */
    101 	NULL,			/* power */
    102 	ddi_quiesce_not_needed,		/* quiesce */
    103 };
    104 
    105 
    106 extern int nodev(void);
    107 extern int nulldev(void);
    108 extern int dseekneg_flag;
    109 extern struct mod_ops mod_driverops;
    110 extern struct dev_ops sy_ops;
    111 
    112 /*
    113  * Module linkage information for the kernel.
    114  */
    115 
    116 static struct modldrv modldrv = {
    117 	&mod_driverops, /* Type of module.  This one is a pseudo driver */
    118 	"Indirect driver for tty 'sy'",
    119 	&sy_ops,	/* driver ops */
    120 };
    121 
    122 static struct modlinkage modlinkage = {
    123 	MODREV_1,
    124 	&modldrv,
    125 	NULL
    126 };
    127 
    128 
    129 int
    130 _init(void)
    131 {
    132 	return (mod_install(&modlinkage));
    133 }
    134 
    135 
    136 int
    137 _fini(void)
    138 {
    139 	return (mod_remove(&modlinkage));
    140 }
    141 
    142 int
    143 _info(struct modinfo *modinfop)
    144 {
    145 	return (mod_info(&modlinkage, modinfop));
    146 }
    147 
    148 /* ARGSUSED */
    149 static int
    150 sy_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
    151 {
    152 	if (ddi_create_minor_node(devi, "tty", S_IFCHR,
    153 	    0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
    154 		ddi_remove_minor_node(devi, NULL);
    155 		return (-1);
    156 	}
    157 	sy_dip = devi;
    158 	return (DDI_SUCCESS);
    159 }
    160 
    161 /* ARGSUSED */
    162 static int
    163 sy_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
    164 {
    165 	dev_t dev = (dev_t)arg;
    166 	int error;
    167 
    168 	switch (infocmd) {
    169 	case DDI_INFO_DEVT2DEVINFO:
    170 		if (sy_dip == NULL) {
    171 			*result = (void *)NULL;
    172 			error = DDI_FAILURE;
    173 		} else {
    174 			*result = (void *) sy_dip;
    175 			error = DDI_SUCCESS;
    176 		}
    177 		break;
    178 	case DDI_INFO_DEVT2INSTANCE:
    179 		if (getminor(dev) != 0) {
    180 			*result = (void *)-1;
    181 			error = DDI_FAILURE;
    182 		} else {
    183 			*result = (void *)0;
    184 			error = DDI_SUCCESS;
    185 		}
    186 		break;
    187 	default:
    188 		error = DDI_FAILURE;
    189 	}
    190 	return (error);
    191 }
    192 
    193 
    194 /* ARGSUSED */
    195 int
    196 syopen(dev_t *devp, int flag, int otyp, struct cred *cr)
    197 {
    198 	dev_t	ttyd;
    199 	vnode_t	*ttyvp;
    200 	sess_t	*sp;
    201 	int	error;
    202 
    203 	if ((sp = tty_hold()) == NULL)
    204 		return (EINTR);
    205 
    206 	if (sp->s_dev == NODEV) {
    207 		tty_rele(sp);
    208 		return (ENXIO);
    209 	}
    210 
    211 	ttyd = sp->s_dev;
    212 	ttyvp = sp->s_vp;
    213 
    214 	/*
    215 	 * Open the control terminal. The control terminal may be
    216 	 * opened multiple times and it is closed in freectty().
    217 	 * The multi-open, single-clone means that no cloning
    218 	 * can happen via this open, hence the assertion.
    219 	 */
    220 	error = VOP_OPEN(&ttyvp, FNOCTTY | flag, cr, NULL);
    221 	if (error == 0) {
    222 		struct snode *csp;
    223 
    224 		/*
    225 		 * XXX: This driver binds a single minor number to the
    226 		 * current controlling tty of the process issueing the
    227 		 * open / close.  If we implement a traditional close
    228 		 * for this driver then specfs will only invoke this driver
    229 		 * on the last close of our one minor number - which is not
    230 		 * what we want.  Since we already get the open / close
    231 		 * semantic that we want from makectty and freectty, we reach
    232 		 * back into the common snode and decrease the open count so
    233 		 * that the specfs filtering of all but the last close
    234 		 * does not get in our way.  To clean this up, a new cb_flag
    235 		 * that causes specfs to call the driver on each close
    236 		 * should be considered.
    237 		 */
    238 		ASSERT(ttyd == ttyvp->v_rdev);
    239 		ASSERT(vn_matchops(ttyvp, spec_getvnodeops()));
    240 		csp = VTOS(VTOS(ttyvp)->s_commonvp);
    241 		mutex_enter(&csp->s_lock);
    242 		ASSERT(csp->s_count > 1);
    243 		csp->s_count--;
    244 		mutex_exit(&csp->s_lock);
    245 	}
    246 
    247 	tty_rele(sp);
    248 	return (error);
    249 }
    250 
    251 /* ARGSUSED */
    252 int
    253 syclose(dev_t dev, int flag, int otyp, struct cred *cr)
    254 {
    255 	return (0);
    256 }
    257 
    258 /* ARGSUSED */
    259 int
    260 syread(dev_t dev, struct uio *uiop, struct cred *cr)
    261 {
    262 	sess_t	*sp;
    263 	int	error;
    264 
    265 	if ((sp = tty_hold()) == NULL)
    266 		return (EINTR);
    267 
    268 	if (sp->s_dev == NODEV) {
    269 		tty_rele(sp);
    270 		return (ENXIO);
    271 	}
    272 
    273 	error = VOP_READ(sp->s_vp, uiop, 0, cr, NULL);
    274 
    275 	tty_rele(sp);
    276 	return (error);
    277 }
    278 
    279 /* ARGSUSED */
    280 int
    281 sywrite(dev_t dev, struct uio *uiop, struct cred *cr)
    282 {
    283 	sess_t	*sp;
    284 	int	error;
    285 
    286 	if ((sp = tty_hold()) == NULL)
    287 		return (EINTR);
    288 
    289 	if (sp->s_dev == NODEV) {
    290 		tty_rele(sp);
    291 		return (ENXIO);
    292 	}
    293 
    294 	error = VOP_WRITE(sp->s_vp, uiop, 0, cr, NULL);
    295 
    296 	tty_rele(sp);
    297 	return (error);
    298 }
    299 
    300 
    301 /* ARGSUSED */
    302 int
    303 syioctl(dev_t dev, int cmd, intptr_t arg, int mode, struct cred *cr,
    304 	int *rvalp)
    305 {
    306 	sess_t	*sp;
    307 	int	error;
    308 
    309 	if (cmd == TIOCNOTTY) {
    310 		/*
    311 		 * we can't allow this ioctl.  the reason is that it
    312 		 * attempts to remove the ctty for a session.  to do
    313 		 * this the ctty can't be in use  but we grab a hold on
    314 		 * the current ctty (via tty_hold) to perform this ioctl.
    315 		 * if we were to allow this ioctl to pass through we
    316 		 * would deadlock with ourselves.
    317 		 */
    318 		return (EINVAL);
    319 	}
    320 
    321 	if ((sp = tty_hold()) == NULL)
    322 		return (EINTR);
    323 
    324 	if (sp->s_dev == NODEV) {
    325 		tty_rele(sp);
    326 		return (ENXIO);
    327 	}
    328 
    329 	error = VOP_IOCTL(sp->s_vp, cmd, arg, mode, cr, rvalp, NULL);
    330 
    331 	tty_rele(sp);
    332 	return (error);
    333 }
    334 
    335 
    336 
    337 /* ARGSUSED */
    338 int
    339 sypoll(dev_t dev, short events, int anyyet, short *reventsp,
    340 	struct pollhead **phpp)
    341 {
    342 	sess_t  *sp;
    343 	int	error;
    344 
    345 	if ((sp = tty_hold()) == NULL)
    346 		return (EINTR);
    347 
    348 	if (sp->s_dev == NODEV) {
    349 		tty_rele(sp);
    350 		return (ENXIO);
    351 	}
    352 
    353 	error = VOP_POLL(sp->s_vp, events, anyyet, reventsp, phpp, NULL);
    354 
    355 	tty_rele(sp);
    356 	return (error);
    357 }
    358