xref: /titanic_51/usr/src/uts/common/io/gentty.c (revision 193974072f41a843678abf5f61979c748687e66b)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


					/* from S5R4 1.22 */

/*
 * Indirect driver for controlling tty.
 */
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/conf.h>
#include <sys/proc.h>
#include <sys/tty.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/cred.h>
#include <sys/uio.h>
#include <sys/session.h>
#include <sys/ddi.h>
#include <sys/debug.h>
#include <sys/stat.h>
#include <sys/sunddi.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/fs/snode.h>
#include <sys/file.h>

#define	IS_STREAM(dev) (devopsp[getmajor(dev)]->devo_cb_ops->cb_str != NULL)

int syopen(dev_t *, int, int, cred_t *);
int syclose(dev_t, int, int, cred_t *);
int syread(dev_t, struct uio *, cred_t *);
int sywrite(dev_t, struct uio *, cred_t *);
int sypoll(dev_t, short, int, short *, struct pollhead **);
int syioctl(dev_t, int, intptr_t, int, cred_t *, int *);

static int sy_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sy_attach(dev_info_t *, ddi_attach_cmd_t);
static dev_info_t *sy_dip;		/* private copy of devinfo pointer */

struct cb_ops	sy_cb_ops = {

	syopen,			/* open */
	syclose,		/* close */
	nodev,			/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	syread,			/* read */
	sywrite,		/* write */
	syioctl,		/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev, 			/* segmap */
	sypoll,			/* poll */
	ddi_prop_op,		/* cb_prop_op */
	0,			/* streamtab  */
	D_NEW | D_MP		/* Driver compatibility flag */

};

struct dev_ops	sy_ops = {

	DEVO_REV,		/* devo_rev, */
	0,			/* refcnt  */
	sy_info,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	sy_attach,		/* attach */
	nodev,			/* detach */
	nodev,			/* reset */
	&sy_cb_ops,		/* driver operations */
	(struct bus_ops *)0,	/* bus operations */
	NULL,			/* power */
	ddi_quiesce_not_needed,		/* quiesce */
};


extern int nodev(void);
extern int nulldev(void);
extern int dseekneg_flag;
extern struct mod_ops mod_driverops;
extern struct dev_ops sy_ops;

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
	&mod_driverops, /* Type of module.  This one is a pseudo driver */
	"Indirect driver for tty 'sy'",
	&sy_ops,	/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};


int
_init(void)
{
	return (mod_install(&modlinkage));
}


int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/* ARGSUSED */
static int
sy_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
	if (ddi_create_minor_node(devi, "tty", S_IFCHR,
	    0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
		ddi_remove_minor_node(devi, NULL);
		return (-1);
	}
	sy_dip = devi;
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
sy_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	dev_t dev = (dev_t)arg;
	int error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (sy_dip == NULL) {
			*result = (void *)NULL;
			error = DDI_FAILURE;
		} else {
			*result = (void *) sy_dip;
			error = DDI_SUCCESS;
		}
		break;
	case DDI_INFO_DEVT2INSTANCE:
		if (getminor(dev) != 0) {
			*result = (void *)-1;
			error = DDI_FAILURE;
		} else {
			*result = (void *)0;
			error = DDI_SUCCESS;
		}
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}


/* ARGSUSED */
int
syopen(dev_t *devp, int flag, int otyp, struct cred *cr)
{
	dev_t	ttyd;
	vnode_t	*ttyvp;
	sess_t	*sp;
	int	error;

	if ((sp = tty_hold()) == NULL)
		return (EINTR);

	if (sp->s_dev == NODEV) {
		tty_rele(sp);
		return (ENXIO);
	}

	ttyd = sp->s_dev;
	ttyvp = sp->s_vp;

	/*
	 * Open the control terminal. The control terminal may be
	 * opened multiple times and it is closed in freectty().
	 * The multi-open, single-clone means that no cloning
	 * can happen via this open, hence the assertion.
	 */
	error = VOP_OPEN(&ttyvp, FNOCTTY | flag, cr, NULL);
	if (error == 0) {
		struct snode *csp;

		/*
		 * XXX: This driver binds a single minor number to the
		 * current controlling tty of the process issueing the
		 * open / close.  If we implement a traditional close
		 * for this driver then specfs will only invoke this driver
		 * on the last close of our one minor number - which is not
		 * what we want.  Since we already get the open / close
		 * semantic that we want from makectty and freectty, we reach
		 * back into the common snode and decrease the open count so
		 * that the specfs filtering of all but the last close
		 * does not get in our way.  To clean this up, a new cb_flag
		 * that causes specfs to call the driver on each close
		 * should be considered.
		 */
		ASSERT(ttyd == ttyvp->v_rdev);
		ASSERT(vn_matchops(ttyvp, spec_getvnodeops()));
		csp = VTOS(VTOS(ttyvp)->s_commonvp);
		mutex_enter(&csp->s_lock);
		ASSERT(csp->s_count > 1);
		csp->s_count--;
		mutex_exit(&csp->s_lock);
	}

	tty_rele(sp);
	return (error);
}

/* ARGSUSED */
int
syclose(dev_t dev, int flag, int otyp, struct cred *cr)
{
	return (0);
}

/* ARGSUSED */
int
syread(dev_t dev, struct uio *uiop, struct cred *cr)
{
	sess_t	*sp;
	int	error;

	if ((sp = tty_hold()) == NULL)
		return (EINTR);

	if (sp->s_dev == NODEV) {
		tty_rele(sp);
		return (ENXIO);
	}

	error = VOP_READ(sp->s_vp, uiop, 0, cr, NULL);

	tty_rele(sp);
	return (error);
}

/* ARGSUSED */
int
sywrite(dev_t dev, struct uio *uiop, struct cred *cr)
{
	sess_t	*sp;
	int	error;

	if ((sp = tty_hold()) == NULL)
		return (EINTR);

	if (sp->s_dev == NODEV) {
		tty_rele(sp);
		return (ENXIO);
	}

	error = VOP_WRITE(sp->s_vp, uiop, 0, cr, NULL);

	tty_rele(sp);
	return (error);
}


/* ARGSUSED */
int
syioctl(dev_t dev, int cmd, intptr_t arg, int mode, struct cred *cr,
	int *rvalp)
{
	sess_t	*sp;
	int	error;

	if (cmd == TIOCNOTTY) {
		/*
		 * we can't allow this ioctl.  the reason is that it
		 * attempts to remove the ctty for a session.  to do
		 * this the ctty can't be in use  but we grab a hold on
		 * the current ctty (via tty_hold) to perform this ioctl.
		 * if we were to allow this ioctl to pass through we
		 * would deadlock with ourselves.
		 */
		return (EINVAL);
	}

	if ((sp = tty_hold()) == NULL)
		return (EINTR);

	if (sp->s_dev == NODEV) {
		tty_rele(sp);
		return (ENXIO);
	}

	error = VOP_IOCTL(sp->s_vp, cmd, arg, mode, cr, rvalp, NULL);

	tty_rele(sp);
	return (error);
}



/* ARGSUSED */
int
sypoll(dev_t dev, short events, int anyyet, short *reventsp,
	struct pollhead **phpp)
{
	sess_t  *sp;
	int	error;

	if ((sp = tty_hold()) == NULL)
		return (EINTR);

	if (sp->s_dev == NODEV) {
		tty_rele(sp);
		return (ENXIO);
	}

	error = VOP_POLL(sp->s_vp, events, anyyet, reventsp, phpp, NULL);

	tty_rele(sp);
	return (error);
}