usr/src/uts/common/fs/dev/sdev_vtops.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  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 /*
  26  * vnode ops for the /dev/vt directory
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/param.h>
  31 #include <sys/sysmacros.h>
  32 #include <sys/sunndi.h>
  33 #include <fs/fs_subr.h>
  34 #include <sys/fs/dv_node.h>
  35 #include <sys/fs/sdev_impl.h>
  36 #include <sys/policy.h>
  37 #include <sys/stat.h>
  38 #include <sys/vfs_opreg.h>
  39 #include <sys/tty.h>
  40 #include <sys/vt_impl.h>
  41 #include <sys/note.h>
  42
  43 /* warlock in this file only cares about variables shared by vt and devfs */
  44 _NOTE(SCHEME_PROTECTS_DATA("Do not care", sdev_node vattr vnode))
  45
  46 #define DEVVT_UID_DEFAULT       SDEV_UID_DEFAULT
  47 #define DEVVT_GID_DEFAULT       (0)
  48 #define DEVVT_DEVMODE_DEFAULT   (0600)
  49 #define DEVVT_ACTIVE_NAME       "active"
  50 #define DEVVT_CONSUSER_NAME     "console_user"
  51
  52 #define isdigit(ch)     ((ch) >= '0' && (ch) <= '9')
  53
  54 /* attributes for VT nodes */
  55 static vattr_t devvt_vattr = {
  56         AT_TYPE|AT_MODE|AT_UID|AT_GID,          /* va_mask */
  57         VCHR,                                   /* va_type */
  58         S_IFCHR | DEVVT_DEVMODE_DEFAULT,        /* va_mode */
  59         DEVVT_UID_DEFAULT,                      /* va_uid */
  60         DEVVT_GID_DEFAULT,                      /* va_gid */
  61         0                                       /* 0 hereafter */
  62 };
  63
  64 struct vnodeops         *devvt_vnodeops;
  65
  66 struct vnodeops *
  67 devvt_getvnodeops(void)
  68 {
  69         return (devvt_vnodeops);
  70 }
  71
  72 static int
  73 devvt_str2minor(const char *nm, minor_t *mp)
  74 {
  75         long uminor = 0;
  76         char *endptr = NULL;
  77
  78         if (nm == NULL || !isdigit(*nm))
  79                 return (EINVAL);
  80
  81         *mp = 0;
  82         if (ddi_strtol(nm, &endptr, 10, &uminor) != 0 ||
  83             *endptr != '\0' || uminor < 0) {
  84                 return (EINVAL);
  85         }
  86
  87         *mp = (minor_t)uminor;
  88         return (0);
  89 }
  90
  91 /*
  92  * Validate that a node is up-to-date and correct.
  93  * A validator may not update the node state or
  94  * contents as a read lock permits entry by
  95  * multiple threads.
  96  */
  97 int
  98 devvt_validate(struct sdev_node *dv)
  99 {
 100         minor_t min;
 101         char *nm = dv->sdev_name;
 102         int rval;
 103
 104         ASSERT(dv->sdev_state == SDEV_READY);
 105         ASSERT(RW_LOCK_HELD(&(dv->sdev_dotdot)->sdev_contents));
 106
 107         /* validate only READY nodes */
 108         if (dv->sdev_state != SDEV_READY) {
 109                 sdcmn_err(("dev fs: skipping: node not ready %s(%p)",
 110                     nm, (void *)dv));
 111                 return (SDEV_VTOR_SKIP);
 112         }
 113
 114         if (vt_wc_attached() == (major_t)-1)
 115                 return (SDEV_VTOR_INVALID);
 116
 117         if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) {
 118                 char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 119                 (void) vt_getactive(link, MAXPATHLEN);
 120                 rval = (strcmp(link, dv->sdev_symlink) == 0) ?
 121                     SDEV_VTOR_VALID : SDEV_VTOR_STALE;
 122                 kmem_free(link, MAXPATHLEN);
 123                 return (rval);
 124         }
 125
 126         if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) {
 127                 char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 128                 (void) vt_getconsuser(link, MAXPATHLEN);
 129                 rval = (strcmp(link, dv->sdev_symlink) == 0) ?
 130                     SDEV_VTOR_VALID : SDEV_VTOR_STALE;
 131                 kmem_free(link, MAXPATHLEN);
 132                 return (rval);
 133         }
 134
 135         if (devvt_str2minor(nm, &min) != 0) {
 136                 return (SDEV_VTOR_INVALID);
 137         }
 138
 139         if (vt_minor_valid(min) == B_FALSE)
 140                 return (SDEV_VTOR_INVALID);
 141
 142         return (SDEV_VTOR_VALID);
 143 }
 144
 145 /*
 146  * This callback is invoked from devname_lookup_func() to create
 147  * a entry when the node is not found in the cache.
 148  */
 149 /*ARGSUSED*/
 150 static int
 151 devvt_create_rvp(struct sdev_node *ddv, char *nm,
 152     void **arg, cred_t *cred, void *whatever, char *whichever)
 153 {
 154         minor_t min;
 155         major_t maj;
 156         struct vattr *vap = (struct vattr *)arg;
 157
 158         if ((maj = vt_wc_attached()) == (major_t)-1)
 159                 return (SDEV_VTOR_INVALID);
 160
 161         if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) {
 162                 (void) vt_getactive((char *)*arg, MAXPATHLEN);
 163                 return (0);
 164         }
 165
 166         if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) {
 167                 (void) vt_getconsuser((char *)*arg, MAXPATHLEN);
 168                 return (0);
 169         }
 170         if (devvt_str2minor(nm, &min) != 0)
 171                 return (-1);
 172
 173         if (vt_minor_valid(min) == B_FALSE)
 174                 return (-1);
 175
 176         *vap = devvt_vattr;
 177         vap->va_rdev = makedevice(maj, min);
 178
 179         return (0);
 180 }
 181
 182 /*ARGSUSED3*/
 183 static int
 184 devvt_lookup(struct vnode *dvp, char *nm, struct vnode **vpp,
 185     struct pathname *pnp, int flags, struct vnode *rdir, struct cred *cred,
 186     caller_context_t *ct, int *direntflags, pathname_t *realpnp)
 187 {
 188         struct sdev_node *sdvp = VTOSDEV(dvp);
 189         struct sdev_node *dv;
 190         struct vnode *rvp = NULL;
 191         int type, error;
 192
 193         if ((strcmp(nm, DEVVT_ACTIVE_NAME) == 0) ||
 194             (strcmp(nm, DEVVT_CONSUSER_NAME) == 0)) {
 195                 type = SDEV_VLINK;
 196         } else {
 197                 type = SDEV_VATTR;
 198         }
 199
 200 /* Give warlock a more clear call graph */
 201 #ifndef __lock_lint
 202         error = devname_lookup_func(sdvp, nm, vpp, cred,
 203             devvt_create_rvp, type);
 204 #else
 205         devvt_create_rvp(0, 0, 0, 0, 0, 0);
 206 #endif
 207
 208         if (error == 0) {
 209                 switch ((*vpp)->v_type) {
 210                 case VCHR:
 211                         dv = VTOSDEV(VTOS(*vpp)->s_realvp);
 212                         ASSERT(VOP_REALVP(SDEVTOV(dv), &rvp, NULL) == ENOSYS);
 213                         break;
 214                 case VDIR:
 215                 case VLNK:
 216                         dv = VTOSDEV(*vpp);
 217                         break;
 218                 default:
 219                         cmn_err(CE_PANIC, "devvt_lookup: Unsupported node "
 220                             "type: %p: %d", (void *)(*vpp), (*vpp)->v_type);
 221                         break;
 222                 }
 223                 ASSERT(SDEV_HELD(dv));
 224         }
 225
 226         return (error);
 227 }
 228
 229 static void
 230 devvt_create_snode(struct sdev_node *ddv, char *nm, struct cred *cred, int type)
 231 {
 232         int error;
 233         struct sdev_node *sdv = NULL;
 234         struct vattr vattr;
 235         struct vattr *vap = &vattr;
 236         major_t maj;
 237         minor_t min;
 238
 239         ASSERT(RW_WRITE_HELD(&ddv->sdev_contents));
 240
 241         if ((maj = vt_wc_attached()) == (major_t)-1)
 242                 return;
 243
 244         if (strcmp(nm, DEVVT_ACTIVE_NAME) != 0 &&
 245             strcmp(nm, DEVVT_CONSUSER_NAME) != 0 &&
 246             devvt_str2minor(nm, &min) != 0)
 247                 return;
 248
 249         error = sdev_mknode(ddv, nm, &sdv, NULL, NULL, NULL, cred, SDEV_INIT);
 250         if (error || !sdv) {
 251                 return;
 252         }
 253
 254         mutex_enter(&sdv->sdev_lookup_lock);
 255         SDEV_BLOCK_OTHERS(sdv, SDEV_LOOKUP);
 256         mutex_exit(&sdv->sdev_lookup_lock);
 257
 258         if (type & SDEV_VATTR) {
 259                 *vap = devvt_vattr;
 260                 vap->va_rdev = makedevice(maj, min);
 261                 error = sdev_mknode(ddv, nm, &sdv, vap, NULL,
 262                     NULL, cred, SDEV_READY);
 263         } else if (type & SDEV_VLINK) {
 264                 char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 265
 266                 (void) vt_getactive(link, MAXPATHLEN);
 267                 *vap = sdev_vattr_lnk;
 268                 vap->va_size = strlen(link);
 269                 error = sdev_mknode(ddv, nm, &sdv, vap, NULL,
 270                     (void *)link, cred, SDEV_READY);
 271
 272                 kmem_free(link, MAXPATHLEN);
 273         }
 274
 275         if (error != 0) {
 276                 SDEV_RELE(sdv);
 277                 return;
 278         }
 279
 280         mutex_enter(&sdv->sdev_lookup_lock);
 281         SDEV_UNBLOCK_OTHERS(sdv, SDEV_LOOKUP);
 282         mutex_exit(&sdv->sdev_lookup_lock);
 283
 284 }
 285
 286 static void
 287 devvt_rebuild_stale_link(struct sdev_node *ddv, struct sdev_node *dv)
 288 {
 289         char *link;
 290
 291         ASSERT(RW_WRITE_HELD(&ddv->sdev_contents));
 292
 293         ASSERT((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) ||
 294             (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0));
 295
 296         link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 297         if (strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) {
 298                 (void) vt_getactive(link, MAXPATHLEN);
 299         } else if (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0) {
 300                 (void) vt_getconsuser(link, MAXPATHLEN);
 301         }
 302
 303         if (strcmp(link, dv->sdev_symlink) != 0) {
 304                 strfree(dv->sdev_symlink);
 305                 dv->sdev_symlink = strdup(link);
 306                 dv->sdev_attr->va_size = strlen(link);
 307         }
 308         kmem_free(link, MAXPATHLEN);
 309 }
 310
 311 /*
 312  * First step in refreshing directory contents.
 313  * Remove each invalid entry and rebuild the link
 314  * reference for each stale entry.
 315  */
 316 static void
 317 devvt_prunedir(struct sdev_node *ddv)
 318 {
 319         struct vnode *vp;
 320         struct sdev_node *dv, *next = NULL;
 321         int (*vtor)(struct sdev_node *) = NULL;
 322
 323         ASSERT(ddv->sdev_flags & SDEV_VTOR);
 324
 325         vtor = (int (*)(struct sdev_node *))sdev_get_vtor(ddv);
 326         ASSERT(vtor);
 327
 328         for (dv = SDEV_FIRST_ENTRY(ddv); dv; dv = next) {
 329                 next = SDEV_NEXT_ENTRY(ddv, dv);
 330
 331                 switch (vtor(dv)) {
 332                 case SDEV_VTOR_VALID:
 333                         break;
 334                 case SDEV_VTOR_SKIP:
 335                         break;
 336                 case SDEV_VTOR_INVALID:
 337                         vp = SDEVTOV(dv);
 338                         if (vp->v_count != 0)
 339                                 break;
 340                         /* remove the cached node */
 341                         SDEV_HOLD(dv);
 342                         (void) sdev_cache_update(ddv, &dv,
 343                             dv->sdev_name, SDEV_CACHE_DELETE);
 344                         SDEV_RELE(dv);
 345                         break;
 346                 case SDEV_VTOR_STALE:
 347                         devvt_rebuild_stale_link(ddv, dv);
 348                         break;
 349                 }
 350         }
 351 }
 352
 353 static void
 354 devvt_cleandir(struct vnode *dvp, struct cred *cred)
 355 {
 356         struct sdev_node *sdvp = VTOSDEV(dvp);
 357         struct sdev_node *dv, *next = NULL;
 358         int min, cnt;
 359         char found = 0;
 360
 361         mutex_enter(&vc_lock);
 362         cnt = VC_INSTANCES_COUNT;
 363         mutex_exit(&vc_lock);
 364
 365 /* We have to fool warlock this way, otherwise it will complain */
 366 #ifndef __lock_lint
 367         if (rw_tryupgrade(&sdvp->sdev_contents) == NULL) {
 368                 rw_exit(&sdvp->sdev_contents);
 369                 rw_enter(&sdvp->sdev_contents, RW_WRITER);
 370         }
 371 #else
 372         rw_enter(&sdvp->sdev_contents, RW_WRITER);
 373 #endif
 374
 375         /* 1.  prune invalid nodes and rebuild stale symlinks */
 376         devvt_prunedir(sdvp);
 377
 378         /* 2. create missing nodes */
 379         for (min = 0; min < cnt; min++) {
 380                 char nm[16];
 381
 382                 if (vt_minor_valid(min) == B_FALSE)
 383                         continue;
 384
 385                 (void) snprintf(nm, sizeof (nm), "%d", min);
 386                 found = 0;
 387                 for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) {
 388                         next = SDEV_NEXT_ENTRY(sdvp, dv);
 389
 390                         /* validate only ready nodes */
 391                         if (dv->sdev_state != SDEV_READY)
 392                                 continue;
 393                         if (strcmp(nm, dv->sdev_name) == 0) {
 394                                 found = 1;
 395                                 break;
 396                         }
 397                 }
 398                 if (!found) {
 399                         devvt_create_snode(sdvp, nm, cred, SDEV_VATTR);
 400                 }
 401         }
 402
 403         /* 3. create active link node and console user link node */
 404         found = 0;
 405         for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) {
 406                 next = SDEV_NEXT_ENTRY(sdvp, dv);
 407
 408                 /* validate only ready nodes */
 409                 if (dv->sdev_state != SDEV_READY)
 410                         continue;
 411                 if ((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == NULL))
 412                         found |= 0x01;
 413                 if ((strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == NULL))
 414                         found |= 0x02;
 415
 416                 if ((found & 0x01) && (found & 0x02))
 417                         break;
 418         }
 419         if (!(found & 0x01))
 420                 devvt_create_snode(sdvp, DEVVT_ACTIVE_NAME, cred, SDEV_VLINK);
 421         if (!(found & 0x02))
 422                 devvt_create_snode(sdvp, DEVVT_CONSUSER_NAME, cred, SDEV_VLINK);
 423
 424 #ifndef __lock_lint
 425         rw_downgrade(&sdvp->sdev_contents);
 426 #else
 427         rw_exit(&sdvp->sdev_contents);
 428 #endif
 429 }
 430
 431 /*ARGSUSED4*/
 432 static int
 433 devvt_readdir(struct vnode *dvp, struct uio *uiop, struct cred *cred,
 434     int *eofp, caller_context_t *ct, int flags)
 435 {
 436         if (uiop->uio_offset == 0) {
 437                 devvt_cleandir(dvp, cred);
 438         }
 439
 440         return (devname_readdir_func(dvp, uiop, cred, eofp, 0));
 441 }
 442
 443 /*
 444  * We allow create to find existing nodes
 445  *      - if the node doesn't exist - EROFS
 446  *      - creating an existing dir read-only succeeds, otherwise EISDIR
 447  *      - exclusive creates fail - EEXIST
 448  */
 449 /*ARGSUSED2*/
 450 static int
 451 devvt_create(struct vnode *dvp, char *nm, struct vattr *vap, vcexcl_t excl,
 452     int mode, struct vnode **vpp, struct cred *cred, int flag,
 453     caller_context_t *ct, vsecattr_t *vsecp)
 454 {
 455         int error;
 456         struct vnode *vp;
 457
 458         *vpp = NULL;
 459
 460         if ((error = devvt_lookup(dvp, nm, &vp, NULL, 0, NULL, cred, ct, NULL,
 461             NULL)) != 0) {
 462                 if (error == ENOENT)
 463                         error = EROFS;
 464                 return (error);
 465         }
 466
 467         if (excl == EXCL)
 468                 error = EEXIST;
 469         else if (vp->v_type == VDIR && (mode & VWRITE))
 470                 error = EISDIR;
 471         else
 472                 error = VOP_ACCESS(vp, mode, 0, cred, ct);
 473
 474         if (error) {
 475                 VN_RELE(vp);
 476         } else
 477                 *vpp = vp;
 478
 479         return (error);
 480 }
 481
 482 const fs_operation_def_t devvt_vnodeops_tbl[] = {
 483         VOPNAME_READDIR,        { .vop_readdir = devvt_readdir },
 484         VOPNAME_LOOKUP,         { .vop_lookup = devvt_lookup },
 485         VOPNAME_CREATE,         { .vop_create = devvt_create },
 486         VOPNAME_REMOVE,         { .error = fs_nosys },
 487         VOPNAME_MKDIR,          { .error = fs_nosys },
 488         VOPNAME_RMDIR,          { .error = fs_nosys },
 489         VOPNAME_SYMLINK,        { .error = fs_nosys },
 490         VOPNAME_SETSECATTR,     { .error = fs_nosys },
 491         NULL,                   NULL
 492 };