usr/src/uts/common/io/gentty.c

   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         NULL,   /* 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, 0) == 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 = 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 = NULL;
 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 = fop_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 = fop_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 = fop_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 = fop_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 = fop_poll(sp->s_vp, events, anyyet, reventsp, phpp, NULL);
 354
 355         tty_rele(sp);
 356         return (error);
 357 }