Mercurial > illumos > illumos-gate
view usr/src/uts/common/fs/dev/sdev_vtops.c @ 14140:1652c59077c6
3978 renaming dynamic sdev nodes is problematic
3979 sdev dynamic directories can be created multiple times
3980 sdev vfs refcount assertion violation
3981 sdev backing store nodes not always present
3982 sdev could use some theory statements
3983 sdev_shadow_node slept through a vn_rele
Reviewed by: Keith M Wesolowski <wesolows@foobazco.org>
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Reviewed by: Gordon Ross <gwr@nexenta.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Approved by: Garrett D'Amore <garrett@damore.org>
author | Robert Mustacchi <rm@joyent.com> |
---|---|
date | Wed, 08 May 2013 01:46:41 +0000 |
parents | 1cb0b42b763e |
children |
line wrap: on
line source
/* * 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * vnode ops for the /dev/vt directory */ #include <sys/types.h> #include <sys/param.h> #include <sys/sysmacros.h> #include <sys/sunndi.h> #include <fs/fs_subr.h> #include <sys/fs/dv_node.h> #include <sys/fs/sdev_impl.h> #include <sys/policy.h> #include <sys/stat.h> #include <sys/vfs_opreg.h> #include <sys/tty.h> #include <sys/vt_impl.h> #include <sys/note.h> /* warlock in this file only cares about variables shared by vt and devfs */ _NOTE(SCHEME_PROTECTS_DATA("Do not care", sdev_node vattr vnode)) #define DEVVT_UID_DEFAULT SDEV_UID_DEFAULT #define DEVVT_GID_DEFAULT (0) #define DEVVT_DEVMODE_DEFAULT (0600) #define DEVVT_ACTIVE_NAME "active" #define DEVVT_CONSUSER_NAME "console_user" #define isdigit(ch) ((ch) >= '0' && (ch) <= '9') /* attributes for VT nodes */ static vattr_t devvt_vattr = { AT_TYPE|AT_MODE|AT_UID|AT_GID, /* va_mask */ VCHR, /* va_type */ S_IFCHR | DEVVT_DEVMODE_DEFAULT, /* va_mode */ DEVVT_UID_DEFAULT, /* va_uid */ DEVVT_GID_DEFAULT, /* va_gid */ 0 /* 0 hereafter */ }; struct vnodeops *devvt_vnodeops; struct vnodeops * devvt_getvnodeops(void) { return (devvt_vnodeops); } static int devvt_str2minor(const char *nm, minor_t *mp) { long uminor = 0; char *endptr = NULL; if (nm == NULL || !isdigit(*nm)) return (EINVAL); *mp = 0; if (ddi_strtol(nm, &endptr, 10, &uminor) != 0 || *endptr != '\0' || uminor < 0) { return (EINVAL); } *mp = (minor_t)uminor; return (0); } /* * Validate that a node is up-to-date and correct. * A validator may not update the node state or * contents as a read lock permits entry by * multiple threads. */ int devvt_validate(struct sdev_node *dv) { minor_t min; char *nm = dv->sdev_name; int rval; ASSERT(dv->sdev_state == SDEV_READY); ASSERT(RW_LOCK_HELD(&(dv->sdev_dotdot)->sdev_contents)); /* validate only READY nodes */ if (dv->sdev_state != SDEV_READY) { sdcmn_err(("dev fs: skipping: node not ready %s(%p)", nm, (void *)dv)); return (SDEV_VTOR_SKIP); } if (vt_wc_attached() == (major_t)-1) return (SDEV_VTOR_INVALID); if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) { char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP); (void) vt_getactive(link, MAXPATHLEN); rval = (strcmp(link, dv->sdev_symlink) == 0) ? SDEV_VTOR_VALID : SDEV_VTOR_STALE; kmem_free(link, MAXPATHLEN); return (rval); } if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) { char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP); (void) vt_getconsuser(link, MAXPATHLEN); rval = (strcmp(link, dv->sdev_symlink) == 0) ? SDEV_VTOR_VALID : SDEV_VTOR_STALE; kmem_free(link, MAXPATHLEN); return (rval); } if (devvt_str2minor(nm, &min) != 0) { return (SDEV_VTOR_INVALID); } if (vt_minor_valid(min) == B_FALSE) return (SDEV_VTOR_INVALID); return (SDEV_VTOR_VALID); } /* * This callback is invoked from devname_lookup_func() to create * a entry when the node is not found in the cache. */ /*ARGSUSED*/ static int devvt_create_rvp(struct sdev_node *ddv, char *nm, void **arg, cred_t *cred, void *whatever, char *whichever) { minor_t min; major_t maj; struct vattr *vap = (struct vattr *)arg; if ((maj = vt_wc_attached()) == (major_t)-1) return (SDEV_VTOR_INVALID); if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) { (void) vt_getactive((char *)*arg, MAXPATHLEN); return (0); } if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) { (void) vt_getconsuser((char *)*arg, MAXPATHLEN); return (0); } if (devvt_str2minor(nm, &min) != 0) return (-1); if (vt_minor_valid(min) == B_FALSE) return (-1); *vap = devvt_vattr; vap->va_rdev = makedevice(maj, min); return (0); } /*ARGSUSED3*/ static int devvt_lookup(struct vnode *dvp, char *nm, struct vnode **vpp, struct pathname *pnp, int flags, struct vnode *rdir, struct cred *cred, caller_context_t *ct, int *direntflags, pathname_t *realpnp) { struct sdev_node *sdvp = VTOSDEV(dvp); struct sdev_node *dv; struct vnode *rvp = NULL; int type, error; if ((strcmp(nm, DEVVT_ACTIVE_NAME) == 0) || (strcmp(nm, DEVVT_CONSUSER_NAME) == 0)) { type = SDEV_VLINK; } else { type = SDEV_VATTR; } /* Give warlock a more clear call graph */ #ifndef __lock_lint error = devname_lookup_func(sdvp, nm, vpp, cred, devvt_create_rvp, type); #else devvt_create_rvp(0, 0, 0, 0, 0, 0); #endif if (error == 0) { switch ((*vpp)->v_type) { case VCHR: dv = VTOSDEV(VTOS(*vpp)->s_realvp); ASSERT(VOP_REALVP(SDEVTOV(dv), &rvp, NULL) == ENOSYS); break; case VDIR: case VLNK: dv = VTOSDEV(*vpp); break; default: cmn_err(CE_PANIC, "devvt_lookup: Unsupported node " "type: %p: %d", (void *)(*vpp), (*vpp)->v_type); break; } ASSERT(SDEV_HELD(dv)); } return (error); } static void devvt_create_snode(struct sdev_node *ddv, char *nm, struct cred *cred, int type) { int error; struct sdev_node *sdv = NULL; struct vattr vattr; struct vattr *vap = &vattr; major_t maj; minor_t min; ASSERT(RW_WRITE_HELD(&ddv->sdev_contents)); if ((maj = vt_wc_attached()) == (major_t)-1) return; if (strcmp(nm, DEVVT_ACTIVE_NAME) != 0 && strcmp(nm, DEVVT_CONSUSER_NAME) != 0 && devvt_str2minor(nm, &min) != 0) return; error = sdev_mknode(ddv, nm, &sdv, NULL, NULL, NULL, cred, SDEV_INIT); if (error || !sdv) { return; } mutex_enter(&sdv->sdev_lookup_lock); SDEV_BLOCK_OTHERS(sdv, SDEV_LOOKUP); mutex_exit(&sdv->sdev_lookup_lock); if (type & SDEV_VATTR) { *vap = devvt_vattr; vap->va_rdev = makedevice(maj, min); error = sdev_mknode(ddv, nm, &sdv, vap, NULL, NULL, cred, SDEV_READY); } else if (type & SDEV_VLINK) { char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP); (void) vt_getactive(link, MAXPATHLEN); *vap = sdev_vattr_lnk; vap->va_size = strlen(link); error = sdev_mknode(ddv, nm, &sdv, vap, NULL, (void *)link, cred, SDEV_READY); kmem_free(link, MAXPATHLEN); } if (error != 0) { SDEV_RELE(sdv); return; } mutex_enter(&sdv->sdev_lookup_lock); SDEV_UNBLOCK_OTHERS(sdv, SDEV_LOOKUP); mutex_exit(&sdv->sdev_lookup_lock); } static void devvt_rebuild_stale_link(struct sdev_node *ddv, struct sdev_node *dv) { char *link; ASSERT(RW_WRITE_HELD(&ddv->sdev_contents)); ASSERT((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) || (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0)); link = kmem_zalloc(MAXPATHLEN, KM_SLEEP); if (strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) { (void) vt_getactive(link, MAXPATHLEN); } else if (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0) { (void) vt_getconsuser(link, MAXPATHLEN); } if (strcmp(link, dv->sdev_symlink) != 0) { strfree(dv->sdev_symlink); dv->sdev_symlink = strdup(link); dv->sdev_attr->va_size = strlen(link); } kmem_free(link, MAXPATHLEN); } /* * First step in refreshing directory contents. * Remove each invalid entry and rebuild the link * reference for each stale entry. */ static void devvt_prunedir(struct sdev_node *ddv) { struct vnode *vp; struct sdev_node *dv, *next = NULL; int (*vtor)(struct sdev_node *) = NULL; ASSERT(ddv->sdev_flags & SDEV_VTOR); vtor = (int (*)(struct sdev_node *))sdev_get_vtor(ddv); ASSERT(vtor); for (dv = SDEV_FIRST_ENTRY(ddv); dv; dv = next) { next = SDEV_NEXT_ENTRY(ddv, dv); switch (vtor(dv)) { case SDEV_VTOR_VALID: break; case SDEV_VTOR_SKIP: break; case SDEV_VTOR_INVALID: vp = SDEVTOV(dv); if (vp->v_count != 0) break; /* remove the cached node */ SDEV_HOLD(dv); (void) sdev_cache_update(ddv, &dv, dv->sdev_name, SDEV_CACHE_DELETE); SDEV_RELE(dv); break; case SDEV_VTOR_STALE: devvt_rebuild_stale_link(ddv, dv); break; } } } static void devvt_cleandir(struct vnode *dvp, struct cred *cred) { struct sdev_node *sdvp = VTOSDEV(dvp); struct sdev_node *dv, *next = NULL; int min, cnt; char found = 0; mutex_enter(&vc_lock); cnt = VC_INSTANCES_COUNT; mutex_exit(&vc_lock); /* We have to fool warlock this way, otherwise it will complain */ #ifndef __lock_lint if (rw_tryupgrade(&sdvp->sdev_contents) == NULL) { rw_exit(&sdvp->sdev_contents); rw_enter(&sdvp->sdev_contents, RW_WRITER); } #else rw_enter(&sdvp->sdev_contents, RW_WRITER); #endif /* 1. prune invalid nodes and rebuild stale symlinks */ devvt_prunedir(sdvp); /* 2. create missing nodes */ for (min = 0; min < cnt; min++) { char nm[16]; if (vt_minor_valid(min) == B_FALSE) continue; (void) snprintf(nm, sizeof (nm), "%d", min); found = 0; for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) { next = SDEV_NEXT_ENTRY(sdvp, dv); /* validate only ready nodes */ if (dv->sdev_state != SDEV_READY) continue; if (strcmp(nm, dv->sdev_name) == 0) { found = 1; break; } } if (!found) { devvt_create_snode(sdvp, nm, cred, SDEV_VATTR); } } /* 3. create active link node and console user link node */ found = 0; for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) { next = SDEV_NEXT_ENTRY(sdvp, dv); /* validate only ready nodes */ if (dv->sdev_state != SDEV_READY) continue; if ((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == NULL)) found |= 0x01; if ((strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == NULL)) found |= 0x02; if ((found & 0x01) && (found & 0x02)) break; } if (!(found & 0x01)) devvt_create_snode(sdvp, DEVVT_ACTIVE_NAME, cred, SDEV_VLINK); if (!(found & 0x02)) devvt_create_snode(sdvp, DEVVT_CONSUSER_NAME, cred, SDEV_VLINK); #ifndef __lock_lint rw_downgrade(&sdvp->sdev_contents); #else rw_exit(&sdvp->sdev_contents); #endif } /*ARGSUSED4*/ static int devvt_readdir(struct vnode *dvp, struct uio *uiop, struct cred *cred, int *eofp, caller_context_t *ct, int flags) { if (uiop->uio_offset == 0) { devvt_cleandir(dvp, cred); } return (devname_readdir_func(dvp, uiop, cred, eofp, 0)); } /* * We allow create to find existing nodes * - if the node doesn't exist - EROFS * - creating an existing dir read-only succeeds, otherwise EISDIR * - exclusive creates fail - EEXIST */ /*ARGSUSED2*/ static int devvt_create(struct vnode *dvp, char *nm, struct vattr *vap, vcexcl_t excl, int mode, struct vnode **vpp, struct cred *cred, int flag, caller_context_t *ct, vsecattr_t *vsecp) { int error; struct vnode *vp; *vpp = NULL; if ((error = devvt_lookup(dvp, nm, &vp, NULL, 0, NULL, cred, ct, NULL, NULL)) != 0) { if (error == ENOENT) error = EROFS; return (error); } if (excl == EXCL) error = EEXIST; else if (vp->v_type == VDIR && (mode & VWRITE)) error = EISDIR; else error = VOP_ACCESS(vp, mode, 0, cred, ct); if (error) { VN_RELE(vp); } else *vpp = vp; return (error); } const fs_operation_def_t devvt_vnodeops_tbl[] = { VOPNAME_READDIR, { .vop_readdir = devvt_readdir }, VOPNAME_LOOKUP, { .vop_lookup = devvt_lookup }, VOPNAME_CREATE, { .vop_create = devvt_create }, VOPNAME_REMOVE, { .error = fs_nosys }, VOPNAME_MKDIR, { .error = fs_nosys }, VOPNAME_RMDIR, { .error = fs_nosys }, VOPNAME_SYMLINK, { .error = fs_nosys }, VOPNAME_SETSECATTR, { .error = fs_nosys }, NULL, NULL };