17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
5facf4a8dSllai * Common Development and Distribution License (the "License").
6facf4a8dSllai * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
2294c894bbSVikram Hegde * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
237c478bd9Sstevel@tonic-gate */
247c478bd9Sstevel@tonic-gate
253fe80ca4SDan Cross /*
263fe80ca4SDan Cross * Copyright 2023 Oxide Computer Company
273fe80ca4SDan Cross */
283fe80ca4SDan Cross
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * miscellaneous routines for the devfs
317c478bd9Sstevel@tonic-gate */
327c478bd9Sstevel@tonic-gate
337c478bd9Sstevel@tonic-gate #include <sys/types.h>
347c478bd9Sstevel@tonic-gate #include <sys/param.h>
357c478bd9Sstevel@tonic-gate #include <sys/t_lock.h>
367c478bd9Sstevel@tonic-gate #include <sys/systm.h>
377c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
387c478bd9Sstevel@tonic-gate #include <sys/user.h>
397c478bd9Sstevel@tonic-gate #include <sys/time.h>
407c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
417c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
427c478bd9Sstevel@tonic-gate #include <sys/file.h>
437c478bd9Sstevel@tonic-gate #include <sys/fcntl.h>
447c478bd9Sstevel@tonic-gate #include <sys/flock.h>
457c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
467c478bd9Sstevel@tonic-gate #include <sys/uio.h>
477c478bd9Sstevel@tonic-gate #include <sys/errno.h>
487c478bd9Sstevel@tonic-gate #include <sys/stat.h>
497c478bd9Sstevel@tonic-gate #include <sys/cred.h>
507c478bd9Sstevel@tonic-gate #include <sys/dirent.h>
517c478bd9Sstevel@tonic-gate #include <sys/pathname.h>
527c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
537c478bd9Sstevel@tonic-gate #include <sys/debug.h>
547c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
557c478bd9Sstevel@tonic-gate #include <fs/fs_subr.h>
567c478bd9Sstevel@tonic-gate #include <sys/fs/dv_node.h>
577c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
587c478bd9Sstevel@tonic-gate #include <sys/sunndi.h>
597c478bd9Sstevel@tonic-gate #include <sys/sunmdi.h>
607c478bd9Sstevel@tonic-gate #include <sys/conf.h>
617c478bd9Sstevel@tonic-gate
627c478bd9Sstevel@tonic-gate #ifdef DEBUG
637c478bd9Sstevel@tonic-gate int devfs_debug = 0x0;
647c478bd9Sstevel@tonic-gate #endif
657c478bd9Sstevel@tonic-gate
667c478bd9Sstevel@tonic-gate const char dvnm[] = "devfs";
677c478bd9Sstevel@tonic-gate kmem_cache_t *dv_node_cache; /* dv_node cache */
68f94a2171Sdf
69f94a2171Sdf /*
70f94a2171Sdf * The devfs_clean_key is taken during a devfs_clean operation: it is used to
71f94a2171Sdf * prevent unnecessary code execution and for detection of potential deadlocks.
72f94a2171Sdf */
737c478bd9Sstevel@tonic-gate uint_t devfs_clean_key;
74f94a2171Sdf
757c478bd9Sstevel@tonic-gate struct dv_node *dvroot;
767c478bd9Sstevel@tonic-gate
777c478bd9Sstevel@tonic-gate /* prototype memory vattrs */
787c478bd9Sstevel@tonic-gate vattr_t dv_vattr_dir = {
79*d5ebc493SDan Cross AT_TYPE|AT_MODE|AT_UID|AT_GID, /* va_mask */
807c478bd9Sstevel@tonic-gate VDIR, /* va_type */
817c478bd9Sstevel@tonic-gate DV_DIRMODE_DEFAULT, /* va_mode */
827c478bd9Sstevel@tonic-gate DV_UID_DEFAULT, /* va_uid */
837c478bd9Sstevel@tonic-gate DV_GID_DEFAULT, /* va_gid */
847c478bd9Sstevel@tonic-gate 0, /* va_fsid; */
857c478bd9Sstevel@tonic-gate 0, /* va_nodeid; */
867c478bd9Sstevel@tonic-gate 0, /* va_nlink; */
877c478bd9Sstevel@tonic-gate 0, /* va_size; */
887c478bd9Sstevel@tonic-gate 0, /* va_atime; */
897c478bd9Sstevel@tonic-gate 0, /* va_mtime; */
907c478bd9Sstevel@tonic-gate 0, /* va_ctime; */
917c478bd9Sstevel@tonic-gate 0, /* va_rdev; */
927c478bd9Sstevel@tonic-gate 0, /* va_blksize; */
937c478bd9Sstevel@tonic-gate 0, /* va_nblocks; */
947c478bd9Sstevel@tonic-gate 0, /* va_seq; */
957c478bd9Sstevel@tonic-gate };
967c478bd9Sstevel@tonic-gate
977c478bd9Sstevel@tonic-gate vattr_t dv_vattr_file = {
987c478bd9Sstevel@tonic-gate AT_TYPE|AT_MODE|AT_SIZE|AT_UID|AT_GID|AT_RDEV, /* va_mask */
997c478bd9Sstevel@tonic-gate 0, /* va_type */
1007c478bd9Sstevel@tonic-gate DV_DEVMODE_DEFAULT, /* va_mode */
1017c478bd9Sstevel@tonic-gate DV_UID_DEFAULT, /* va_uid */
1027c478bd9Sstevel@tonic-gate DV_GID_DEFAULT, /* va_gid */
1037c478bd9Sstevel@tonic-gate 0, /* va_fsid; */
1047c478bd9Sstevel@tonic-gate 0, /* va_nodeid; */
1057c478bd9Sstevel@tonic-gate 0, /* va_nlink; */
1067c478bd9Sstevel@tonic-gate 0, /* va_size; */
1077c478bd9Sstevel@tonic-gate 0, /* va_atime; */
1087c478bd9Sstevel@tonic-gate 0, /* va_mtime; */
1097c478bd9Sstevel@tonic-gate 0, /* va_ctime; */
1107c478bd9Sstevel@tonic-gate 0, /* va_rdev; */
1117c478bd9Sstevel@tonic-gate 0, /* va_blksize; */
1127c478bd9Sstevel@tonic-gate 0, /* va_nblocks; */
1137c478bd9Sstevel@tonic-gate 0, /* va_seq; */
1147c478bd9Sstevel@tonic-gate };
1157c478bd9Sstevel@tonic-gate
1167c478bd9Sstevel@tonic-gate vattr_t dv_vattr_priv = {
1177c478bd9Sstevel@tonic-gate AT_TYPE|AT_MODE|AT_SIZE|AT_UID|AT_GID|AT_RDEV, /* va_mask */
1187c478bd9Sstevel@tonic-gate 0, /* va_type */
1197c478bd9Sstevel@tonic-gate DV_DEVMODE_PRIV, /* va_mode */
1207c478bd9Sstevel@tonic-gate DV_UID_DEFAULT, /* va_uid */
1217c478bd9Sstevel@tonic-gate DV_GID_DEFAULT, /* va_gid */
1227c478bd9Sstevel@tonic-gate 0, /* va_fsid; */
1237c478bd9Sstevel@tonic-gate 0, /* va_nodeid; */
1247c478bd9Sstevel@tonic-gate 0, /* va_nlink; */
1257c478bd9Sstevel@tonic-gate 0, /* va_size; */
1267c478bd9Sstevel@tonic-gate 0, /* va_atime; */
1277c478bd9Sstevel@tonic-gate 0, /* va_mtime; */
1287c478bd9Sstevel@tonic-gate 0, /* va_ctime; */
1297c478bd9Sstevel@tonic-gate 0, /* va_rdev; */
1307c478bd9Sstevel@tonic-gate 0, /* va_blksize; */
1317c478bd9Sstevel@tonic-gate 0, /* va_nblocks; */
1327c478bd9Sstevel@tonic-gate 0, /* va_seq; */
1337c478bd9Sstevel@tonic-gate };
1347c478bd9Sstevel@tonic-gate
1357c478bd9Sstevel@tonic-gate extern dev_info_t *clone_dip;
1367c478bd9Sstevel@tonic-gate extern major_t clone_major;
1377c478bd9Sstevel@tonic-gate extern struct dev_ops *ddi_hold_driver(major_t);
1387c478bd9Sstevel@tonic-gate
139027021c7SChris Horne /* dv_node node constructor for kmem cache */
1407c478bd9Sstevel@tonic-gate static int
i_dv_node_ctor(void * buf,void * cfarg,int flag)1417c478bd9Sstevel@tonic-gate i_dv_node_ctor(void *buf, void *cfarg, int flag)
1427c478bd9Sstevel@tonic-gate {
143027021c7SChris Horne _NOTE(ARGUNUSED(cfarg, flag))
1447c478bd9Sstevel@tonic-gate struct dv_node *dv = (struct dv_node *)buf;
1457c478bd9Sstevel@tonic-gate struct vnode *vp;
1467c478bd9Sstevel@tonic-gate
1477c478bd9Sstevel@tonic-gate bzero(buf, sizeof (struct dv_node));
148b5fca8f8Stomee vp = dv->dv_vnode = vn_alloc(flag);
149b5fca8f8Stomee if (vp == NULL) {
150b5fca8f8Stomee return (-1);
151b5fca8f8Stomee }
152b5fca8f8Stomee vp->v_data = dv;
1537c478bd9Sstevel@tonic-gate rw_init(&dv->dv_contents, NULL, RW_DEFAULT, NULL);
1547c478bd9Sstevel@tonic-gate return (0);
1557c478bd9Sstevel@tonic-gate }
1567c478bd9Sstevel@tonic-gate
157027021c7SChris Horne /* dv_node node destructor for kmem cache */
1587c478bd9Sstevel@tonic-gate static void
i_dv_node_dtor(void * buf,void * arg)1597c478bd9Sstevel@tonic-gate i_dv_node_dtor(void *buf, void *arg)
1607c478bd9Sstevel@tonic-gate {
161027021c7SChris Horne _NOTE(ARGUNUSED(arg))
1627c478bd9Sstevel@tonic-gate struct dv_node *dv = (struct dv_node *)buf;
1637c478bd9Sstevel@tonic-gate struct vnode *vp = DVTOV(dv);
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate rw_destroy(&dv->dv_contents);
1667c478bd9Sstevel@tonic-gate vn_invalid(vp);
1677c478bd9Sstevel@tonic-gate vn_free(vp);
1687c478bd9Sstevel@tonic-gate }
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate
171027021c7SChris Horne /* initialize dv_node node cache */
1727c478bd9Sstevel@tonic-gate void
dv_node_cache_init()1737c478bd9Sstevel@tonic-gate dv_node_cache_init()
1747c478bd9Sstevel@tonic-gate {
1757c478bd9Sstevel@tonic-gate ASSERT(dv_node_cache == NULL);
1767c478bd9Sstevel@tonic-gate dv_node_cache = kmem_cache_create("dv_node_cache",
1777c478bd9Sstevel@tonic-gate sizeof (struct dv_node), 0, i_dv_node_ctor, i_dv_node_dtor,
1787c478bd9Sstevel@tonic-gate NULL, NULL, NULL, 0);
1797c478bd9Sstevel@tonic-gate
1807c478bd9Sstevel@tonic-gate tsd_create(&devfs_clean_key, NULL);
1817c478bd9Sstevel@tonic-gate }
1827c478bd9Sstevel@tonic-gate
183027021c7SChris Horne /* destroy dv_node node cache */
1847c478bd9Sstevel@tonic-gate void
dv_node_cache_fini()1857c478bd9Sstevel@tonic-gate dv_node_cache_fini()
1867c478bd9Sstevel@tonic-gate {
1877c478bd9Sstevel@tonic-gate ASSERT(dv_node_cache != NULL);
1887c478bd9Sstevel@tonic-gate kmem_cache_destroy(dv_node_cache);
1897c478bd9Sstevel@tonic-gate dv_node_cache = NULL;
1907c478bd9Sstevel@tonic-gate
1917c478bd9Sstevel@tonic-gate tsd_destroy(&devfs_clean_key);
1927c478bd9Sstevel@tonic-gate }
1937c478bd9Sstevel@tonic-gate
1947c478bd9Sstevel@tonic-gate /*
1957c478bd9Sstevel@tonic-gate * dv_mkino - Generate a unique inode number for devfs nodes.
1967c478bd9Sstevel@tonic-gate *
1977c478bd9Sstevel@tonic-gate * Although ino_t is 64 bits, the inode number is truncated to 32 bits for 32
1987c478bd9Sstevel@tonic-gate * bit non-LARGEFILE applications. This means that there is a requirement to
1997c478bd9Sstevel@tonic-gate * maintain the inode number as a 32 bit value or applications will have
2007c478bd9Sstevel@tonic-gate * stat(2) calls fail with EOVERFLOW. We form a 32 bit inode number from the
2017c478bd9Sstevel@tonic-gate * dev_t. but if the minor number is larger than L_MAXMIN32 we fold extra minor
2027c478bd9Sstevel@tonic-gate *
2037c478bd9Sstevel@tonic-gate * To generate inode numbers for directories, we assume that we will never use
2047c478bd9Sstevel@tonic-gate * more than half the major space - this allows for ~8190 drivers. We use this
2057c478bd9Sstevel@tonic-gate * upper major number space to allocate inode numbers for directories by
2067c478bd9Sstevel@tonic-gate * encoding the major and instance into this space.
2077c478bd9Sstevel@tonic-gate *
2087c478bd9Sstevel@tonic-gate * We also skew the result so that inode 2 is reserved for the root of the file
2097c478bd9Sstevel@tonic-gate * system.
2107c478bd9Sstevel@tonic-gate *
2117c478bd9Sstevel@tonic-gate * As part of the future support for 64-bit dev_t APIs, the upper minor bits
2127c478bd9Sstevel@tonic-gate * should be folded into the high inode bits by adding the following code
2137c478bd9Sstevel@tonic-gate * after "ino |= 1":
2147c478bd9Sstevel@tonic-gate *
2157c478bd9Sstevel@tonic-gate * #if (L_BITSMINOR32 != L_BITSMINOR)
2167c478bd9Sstevel@tonic-gate * |* fold overflow minor bits into high bits of inode number *|
2177c478bd9Sstevel@tonic-gate * ino |= ((ino_t)(minor >> L_BITSMINOR32)) << L_BITSMINOR;
2187c478bd9Sstevel@tonic-gate * #endif |* (L_BITSMINOR32 != L_BITSMINOR) *|
2197c478bd9Sstevel@tonic-gate *
2207c478bd9Sstevel@tonic-gate * This way only applications that use devices that overflow their minor
2217c478bd9Sstevel@tonic-gate * space will have an application level impact.
2227c478bd9Sstevel@tonic-gate */
2237c478bd9Sstevel@tonic-gate static ino_t
dv_mkino(dev_info_t * devi,vtype_t typ,dev_t dev)2247c478bd9Sstevel@tonic-gate dv_mkino(dev_info_t *devi, vtype_t typ, dev_t dev)
2257c478bd9Sstevel@tonic-gate {
2267c478bd9Sstevel@tonic-gate major_t major;
2277c478bd9Sstevel@tonic-gate minor_t minor;
2287c478bd9Sstevel@tonic-gate ino_t ino;
2297c478bd9Sstevel@tonic-gate static int warn;
2307c478bd9Sstevel@tonic-gate
2317c478bd9Sstevel@tonic-gate if (typ == VDIR) {
2327c478bd9Sstevel@tonic-gate major = ((L_MAXMAJ32 + 1) >> 1) + DEVI(devi)->devi_major;
2337c478bd9Sstevel@tonic-gate minor = ddi_get_instance(devi);
2347c478bd9Sstevel@tonic-gate
2357c478bd9Sstevel@tonic-gate /* makedevice32 in high half of major number space */
2367c478bd9Sstevel@tonic-gate ino = (ino_t)((major << L_BITSMINOR32) | (minor & L_MAXMIN32));
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate major = DEVI(devi)->devi_major;
2397c478bd9Sstevel@tonic-gate } else {
2407c478bd9Sstevel@tonic-gate major = getmajor(dev);
2417c478bd9Sstevel@tonic-gate minor = getminor(dev);
2427c478bd9Sstevel@tonic-gate
2437c478bd9Sstevel@tonic-gate /* makedevice32 */
2447c478bd9Sstevel@tonic-gate ino = (ino_t)((major << L_BITSMINOR32) | (minor & L_MAXMIN32));
2457c478bd9Sstevel@tonic-gate
2467c478bd9Sstevel@tonic-gate /* make ino for VCHR different than VBLK */
2477c478bd9Sstevel@tonic-gate ino <<= 1;
2487c478bd9Sstevel@tonic-gate if (typ == VCHR)
2497c478bd9Sstevel@tonic-gate ino |= 1;
2507c478bd9Sstevel@tonic-gate }
2517c478bd9Sstevel@tonic-gate
2527c478bd9Sstevel@tonic-gate ino += DV_ROOTINO + 1; /* skew */
2537c478bd9Sstevel@tonic-gate
2547c478bd9Sstevel@tonic-gate /*
2557c478bd9Sstevel@tonic-gate * diagnose things a little early because adding the skew to a large
2567c478bd9Sstevel@tonic-gate * minor number could roll over the major.
2577c478bd9Sstevel@tonic-gate */
2587c478bd9Sstevel@tonic-gate if ((major >= (L_MAXMAJ32 >> 1)) && (warn == 0)) {
2597c478bd9Sstevel@tonic-gate warn = 1;
2607c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s: inode numbers are not unique", dvnm);
2617c478bd9Sstevel@tonic-gate }
2627c478bd9Sstevel@tonic-gate
2637c478bd9Sstevel@tonic-gate return (ino);
2647c478bd9Sstevel@tonic-gate }
2657c478bd9Sstevel@tonic-gate
266aac43a5fSjg /*
267aac43a5fSjg * Compare two nodes lexographically to balance avl tree
268aac43a5fSjg */
269aac43a5fSjg static int
dv_compare_nodes(const struct dv_node * dv1,const struct dv_node * dv2)270aac43a5fSjg dv_compare_nodes(const struct dv_node *dv1, const struct dv_node *dv2)
271aac43a5fSjg {
272b9ccdc5aScth int rv;
273b9ccdc5aScth
274aac43a5fSjg if ((rv = strcmp(dv1->dv_name, dv2->dv_name)) == 0)
275aac43a5fSjg return (0);
276aac43a5fSjg return ((rv < 0) ? -1 : 1);
277aac43a5fSjg }
278aac43a5fSjg
2797c478bd9Sstevel@tonic-gate /*
2807c478bd9Sstevel@tonic-gate * dv_mkroot
2817c478bd9Sstevel@tonic-gate *
2827c478bd9Sstevel@tonic-gate * Build the first VDIR dv_node.
2837c478bd9Sstevel@tonic-gate */
2847c478bd9Sstevel@tonic-gate struct dv_node *
dv_mkroot(struct vfs * vfsp,dev_t devfsdev)2857c478bd9Sstevel@tonic-gate dv_mkroot(struct vfs *vfsp, dev_t devfsdev)
2867c478bd9Sstevel@tonic-gate {
287b9ccdc5aScth struct dv_node *dv;
288b9ccdc5aScth struct vnode *vp;
2897c478bd9Sstevel@tonic-gate
2907c478bd9Sstevel@tonic-gate ASSERT(ddi_root_node() != NULL);
2917c478bd9Sstevel@tonic-gate ASSERT(dv_node_cache != NULL);
2927c478bd9Sstevel@tonic-gate
2937c478bd9Sstevel@tonic-gate dcmn_err3(("dv_mkroot\n"));
2947c478bd9Sstevel@tonic-gate dv = kmem_cache_alloc(dv_node_cache, KM_SLEEP);
2957c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
2967c478bd9Sstevel@tonic-gate vn_reinit(vp);
2977c478bd9Sstevel@tonic-gate vp->v_flag = VROOT;
2987c478bd9Sstevel@tonic-gate vp->v_vfsp = vfsp;
2997c478bd9Sstevel@tonic-gate vp->v_type = VDIR;
3007c478bd9Sstevel@tonic-gate vp->v_rdev = devfsdev;
3017c478bd9Sstevel@tonic-gate vn_setops(vp, dv_vnodeops);
3027c478bd9Sstevel@tonic-gate vn_exists(vp);
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate dvroot = dv;
3057c478bd9Sstevel@tonic-gate
3067c478bd9Sstevel@tonic-gate dv->dv_name = NULL; /* not needed */
3077c478bd9Sstevel@tonic-gate dv->dv_namelen = 0;
3087c478bd9Sstevel@tonic-gate
3097c478bd9Sstevel@tonic-gate dv->dv_devi = ddi_root_node();
3107c478bd9Sstevel@tonic-gate
3117c478bd9Sstevel@tonic-gate dv->dv_ino = DV_ROOTINO;
3127c478bd9Sstevel@tonic-gate dv->dv_nlink = 2; /* name + . (no dv_insert) */
3137c478bd9Sstevel@tonic-gate dv->dv_dotdot = dv; /* .. == self */
3147c478bd9Sstevel@tonic-gate dv->dv_attrvp = NULLVP;
3157c478bd9Sstevel@tonic-gate dv->dv_attr = NULL;
3167c478bd9Sstevel@tonic-gate dv->dv_flags = DV_BUILD;
3177c478bd9Sstevel@tonic-gate dv->dv_priv = NULL;
3187c478bd9Sstevel@tonic-gate dv->dv_busy = 0;
3197c478bd9Sstevel@tonic-gate dv->dv_dflt_mode = 0;
3207c478bd9Sstevel@tonic-gate
321aac43a5fSjg avl_create(&dv->dv_entries,
322aac43a5fSjg (int (*)(const void *, const void *))dv_compare_nodes,
323aac43a5fSjg sizeof (struct dv_node), offsetof(struct dv_node, dv_avllink));
324aac43a5fSjg
3257c478bd9Sstevel@tonic-gate return (dv);
3267c478bd9Sstevel@tonic-gate }
3277c478bd9Sstevel@tonic-gate
3287c478bd9Sstevel@tonic-gate /*
3297c478bd9Sstevel@tonic-gate * dv_mkdir
3307c478bd9Sstevel@tonic-gate *
3317c478bd9Sstevel@tonic-gate * Given an probed or attached nexus node, create a VDIR dv_node.
3327c478bd9Sstevel@tonic-gate * No dv_attrvp is created at this point.
3337c478bd9Sstevel@tonic-gate */
3347c478bd9Sstevel@tonic-gate struct dv_node *
dv_mkdir(struct dv_node * ddv,dev_info_t * devi,char * nm)3357c478bd9Sstevel@tonic-gate dv_mkdir(struct dv_node *ddv, dev_info_t *devi, char *nm)
3367c478bd9Sstevel@tonic-gate {
337b9ccdc5aScth struct dv_node *dv;
338b9ccdc5aScth struct vnode *vp;
339b9ccdc5aScth size_t nmlen;
3407c478bd9Sstevel@tonic-gate
3417c478bd9Sstevel@tonic-gate ASSERT((devi));
3427c478bd9Sstevel@tonic-gate dcmn_err4(("dv_mkdir: %s\n", nm));
3437c478bd9Sstevel@tonic-gate
3447c478bd9Sstevel@tonic-gate dv = kmem_cache_alloc(dv_node_cache, KM_SLEEP);
3457c478bd9Sstevel@tonic-gate nmlen = strlen(nm) + 1;
3467c478bd9Sstevel@tonic-gate dv->dv_name = kmem_alloc(nmlen, KM_SLEEP);
3477c478bd9Sstevel@tonic-gate bcopy(nm, dv->dv_name, nmlen);
3487c478bd9Sstevel@tonic-gate dv->dv_namelen = nmlen - 1; /* '\0' not included */
349aac43a5fSjg
3507c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
3517c478bd9Sstevel@tonic-gate vn_reinit(vp);
3527c478bd9Sstevel@tonic-gate vp->v_flag = 0;
3537c478bd9Sstevel@tonic-gate vp->v_vfsp = DVTOV(ddv)->v_vfsp;
3547c478bd9Sstevel@tonic-gate vp->v_type = VDIR;
3557c478bd9Sstevel@tonic-gate vp->v_rdev = DVTOV(ddv)->v_rdev;
3567c478bd9Sstevel@tonic-gate vn_setops(vp, vn_getops(DVTOV(ddv)));
3577c478bd9Sstevel@tonic-gate vn_exists(vp);
3587c478bd9Sstevel@tonic-gate
3597c478bd9Sstevel@tonic-gate dv->dv_devi = devi;
3607c478bd9Sstevel@tonic-gate ndi_hold_devi(devi);
3617c478bd9Sstevel@tonic-gate
3627c478bd9Sstevel@tonic-gate dv->dv_ino = dv_mkino(devi, VDIR, NODEV);
3637c478bd9Sstevel@tonic-gate dv->dv_nlink = 0; /* updated on insert */
3647c478bd9Sstevel@tonic-gate dv->dv_dotdot = ddv;
3657c478bd9Sstevel@tonic-gate dv->dv_attrvp = NULLVP;
3667c478bd9Sstevel@tonic-gate dv->dv_attr = NULL;
3677c478bd9Sstevel@tonic-gate dv->dv_flags = DV_BUILD;
3687c478bd9Sstevel@tonic-gate dv->dv_priv = NULL;
3697c478bd9Sstevel@tonic-gate dv->dv_busy = 0;
3707c478bd9Sstevel@tonic-gate dv->dv_dflt_mode = 0;
3717c478bd9Sstevel@tonic-gate
372aac43a5fSjg avl_create(&dv->dv_entries,
373aac43a5fSjg (int (*)(const void *, const void *))dv_compare_nodes,
374aac43a5fSjg sizeof (struct dv_node), offsetof(struct dv_node, dv_avllink));
375aac43a5fSjg
3767c478bd9Sstevel@tonic-gate return (dv);
3777c478bd9Sstevel@tonic-gate }
3787c478bd9Sstevel@tonic-gate
3797c478bd9Sstevel@tonic-gate /*
3807c478bd9Sstevel@tonic-gate * dv_mknod
3817c478bd9Sstevel@tonic-gate *
3827c478bd9Sstevel@tonic-gate * Given a minor node, create a VCHR or VBLK dv_node.
3837c478bd9Sstevel@tonic-gate * No dv_attrvp is created at this point.
3847c478bd9Sstevel@tonic-gate */
3857c478bd9Sstevel@tonic-gate static struct dv_node *
dv_mknod(struct dv_node * ddv,dev_info_t * devi,char * nm,struct ddi_minor_data * dmd)3867c478bd9Sstevel@tonic-gate dv_mknod(struct dv_node *ddv, dev_info_t *devi, char *nm,
387*d5ebc493SDan Cross struct ddi_minor_data *dmd)
3887c478bd9Sstevel@tonic-gate {
389b9ccdc5aScth struct dv_node *dv;
390b9ccdc5aScth struct vnode *vp;
391b9ccdc5aScth size_t nmlen;
3927c478bd9Sstevel@tonic-gate
3937c478bd9Sstevel@tonic-gate dcmn_err4(("dv_mknod: %s\n", nm));
3947c478bd9Sstevel@tonic-gate
3957c478bd9Sstevel@tonic-gate dv = kmem_cache_alloc(dv_node_cache, KM_SLEEP);
3967c478bd9Sstevel@tonic-gate nmlen = strlen(nm) + 1;
3977c478bd9Sstevel@tonic-gate dv->dv_name = kmem_alloc(nmlen, KM_SLEEP);
3987c478bd9Sstevel@tonic-gate bcopy(nm, dv->dv_name, nmlen);
3997c478bd9Sstevel@tonic-gate dv->dv_namelen = nmlen - 1; /* no '\0' */
400aac43a5fSjg
4017c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
4027c478bd9Sstevel@tonic-gate vn_reinit(vp);
4037c478bd9Sstevel@tonic-gate vp->v_flag = 0;
4047c478bd9Sstevel@tonic-gate vp->v_vfsp = DVTOV(ddv)->v_vfsp;
4057c478bd9Sstevel@tonic-gate vp->v_type = dmd->ddm_spec_type == S_IFCHR ? VCHR : VBLK;
4067c478bd9Sstevel@tonic-gate vp->v_rdev = dmd->ddm_dev;
4077c478bd9Sstevel@tonic-gate vn_setops(vp, vn_getops(DVTOV(ddv)));
4087c478bd9Sstevel@tonic-gate vn_exists(vp);
4097c478bd9Sstevel@tonic-gate
410b9ccdc5aScth /* increment dev_ref with devi_lock held */
411b9ccdc5aScth ASSERT(DEVI_BUSY_OWNED(devi));
412b9ccdc5aScth mutex_enter(&DEVI(devi)->devi_lock);
4137c478bd9Sstevel@tonic-gate dv->dv_devi = devi;
414027021c7SChris Horne DEVI(devi)->devi_ref++; /* ndi_hold_devi(dip) */
415b9ccdc5aScth mutex_exit(&DEVI(devi)->devi_lock);
4167c478bd9Sstevel@tonic-gate
4177c478bd9Sstevel@tonic-gate dv->dv_ino = dv_mkino(devi, vp->v_type, vp->v_rdev);
4187c478bd9Sstevel@tonic-gate dv->dv_nlink = 0; /* updated on insert */
4197c478bd9Sstevel@tonic-gate dv->dv_dotdot = ddv;
4207c478bd9Sstevel@tonic-gate dv->dv_attrvp = NULLVP;
4217c478bd9Sstevel@tonic-gate dv->dv_attr = NULL;
4227c478bd9Sstevel@tonic-gate dv->dv_flags = 0;
4237c478bd9Sstevel@tonic-gate
4247c478bd9Sstevel@tonic-gate if (dmd->type == DDM_INTERNAL_PATH)
4257c478bd9Sstevel@tonic-gate dv->dv_flags |= DV_INTERNAL;
4267c478bd9Sstevel@tonic-gate if (dmd->ddm_flags & DM_NO_FSPERM)
4277c478bd9Sstevel@tonic-gate dv->dv_flags |= DV_NO_FSPERM;
4287c478bd9Sstevel@tonic-gate
4297c478bd9Sstevel@tonic-gate dv->dv_priv = dmd->ddm_node_priv;
4307c478bd9Sstevel@tonic-gate if (dv->dv_priv)
4317c478bd9Sstevel@tonic-gate dphold(dv->dv_priv);
4327c478bd9Sstevel@tonic-gate
4337c478bd9Sstevel@tonic-gate /*
4347c478bd9Sstevel@tonic-gate * Minors created with ddi_create_priv_minor_node can specify
4357c478bd9Sstevel@tonic-gate * a default mode permission other than the devfs default.
4367c478bd9Sstevel@tonic-gate */
4377c478bd9Sstevel@tonic-gate if (dv->dv_priv || dv->dv_flags & DV_NO_FSPERM) {
4387c478bd9Sstevel@tonic-gate dcmn_err5(("%s: dv_mknod default priv mode 0%o\n",
4397c478bd9Sstevel@tonic-gate dv->dv_name, dmd->ddm_priv_mode));
4407c478bd9Sstevel@tonic-gate dv->dv_flags |= DV_DFLT_MODE;
4417c478bd9Sstevel@tonic-gate dv->dv_dflt_mode = dmd->ddm_priv_mode & S_IAMB;
4427c478bd9Sstevel@tonic-gate }
4437c478bd9Sstevel@tonic-gate
4447c478bd9Sstevel@tonic-gate return (dv);
4457c478bd9Sstevel@tonic-gate }
4467c478bd9Sstevel@tonic-gate
4477c478bd9Sstevel@tonic-gate /*
4487c478bd9Sstevel@tonic-gate * dv_destroy
4497c478bd9Sstevel@tonic-gate *
4507c478bd9Sstevel@tonic-gate * Destroy what we created in dv_mkdir or dv_mknod.
4517c478bd9Sstevel@tonic-gate * In the case of a *referenced* directory, do nothing.
4527c478bd9Sstevel@tonic-gate */
4537c478bd9Sstevel@tonic-gate void
dv_destroy(struct dv_node * dv,uint_t flags)4547c478bd9Sstevel@tonic-gate dv_destroy(struct dv_node *dv, uint_t flags)
4557c478bd9Sstevel@tonic-gate {
4567c478bd9Sstevel@tonic-gate vnode_t *vp = DVTOV(dv);
4577c478bd9Sstevel@tonic-gate ASSERT(dv->dv_nlink == 0); /* no references */
4587c478bd9Sstevel@tonic-gate
4597c478bd9Sstevel@tonic-gate dcmn_err4(("dv_destroy: %s\n", dv->dv_name));
4607c478bd9Sstevel@tonic-gate
4617c478bd9Sstevel@tonic-gate /*
4627c478bd9Sstevel@tonic-gate * We may be asked to unlink referenced directories.
4637c478bd9Sstevel@tonic-gate * In this case, there is nothing to be done.
4647c478bd9Sstevel@tonic-gate * The eventual memory free will be done in
4657c478bd9Sstevel@tonic-gate * devfs_inactive.
4667c478bd9Sstevel@tonic-gate */
4677c478bd9Sstevel@tonic-gate if (vp->v_count != 0) {
4687c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VDIR);
4697c478bd9Sstevel@tonic-gate ASSERT(flags & DV_CLEAN_FORCE);
4707c478bd9Sstevel@tonic-gate ASSERT(DV_STALE(dv));
4717c478bd9Sstevel@tonic-gate return;
4727c478bd9Sstevel@tonic-gate }
4737c478bd9Sstevel@tonic-gate
474aac43a5fSjg if (vp->v_type == VDIR) {
475aac43a5fSjg ASSERT(DV_FIRST_ENTRY(dv) == NULL);
476aac43a5fSjg avl_destroy(&dv->dv_entries);
477aac43a5fSjg }
478aac43a5fSjg
4797c478bd9Sstevel@tonic-gate if (dv->dv_attrvp != NULLVP)
4807c478bd9Sstevel@tonic-gate VN_RELE(dv->dv_attrvp);
4817c478bd9Sstevel@tonic-gate if (dv->dv_attr != NULL)
4827c478bd9Sstevel@tonic-gate kmem_free(dv->dv_attr, sizeof (struct vattr));
4837c478bd9Sstevel@tonic-gate if (dv->dv_name != NULL)
4847c478bd9Sstevel@tonic-gate kmem_free(dv->dv_name, dv->dv_namelen + 1);
4857c478bd9Sstevel@tonic-gate if (dv->dv_devi != NULL) {
4867c478bd9Sstevel@tonic-gate ndi_rele_devi(dv->dv_devi);
4877c478bd9Sstevel@tonic-gate }
4887c478bd9Sstevel@tonic-gate if (dv->dv_priv != NULL) {
4897c478bd9Sstevel@tonic-gate dpfree(dv->dv_priv);
4907c478bd9Sstevel@tonic-gate }
4917c478bd9Sstevel@tonic-gate
4927c478bd9Sstevel@tonic-gate kmem_cache_free(dv_node_cache, dv);
4937c478bd9Sstevel@tonic-gate }
4947c478bd9Sstevel@tonic-gate
4957c478bd9Sstevel@tonic-gate /*
4967c478bd9Sstevel@tonic-gate * Find and hold dv_node by name
4977c478bd9Sstevel@tonic-gate */
498aac43a5fSjg static struct dv_node *
dv_findbyname(struct dv_node * ddv,char * nm)4997c478bd9Sstevel@tonic-gate dv_findbyname(struct dv_node *ddv, char *nm)
5007c478bd9Sstevel@tonic-gate {
501aac43a5fSjg struct dv_node *dv;
502aac43a5fSjg avl_index_t where;
503aac43a5fSjg struct dv_node dvtmp;
5047c478bd9Sstevel@tonic-gate
5057c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&ddv->dv_contents));
5067c478bd9Sstevel@tonic-gate dcmn_err3(("dv_findbyname: %s\n", nm));
507aac43a5fSjg
508aac43a5fSjg dvtmp.dv_name = nm;
509aac43a5fSjg dv = avl_find(&ddv->dv_entries, &dvtmp, &where);
510aac43a5fSjg if (dv) {
511aac43a5fSjg ASSERT(dv->dv_dotdot == ddv);
512aac43a5fSjg ASSERT(strcmp(dv->dv_name, nm) == 0);
513aac43a5fSjg VN_HOLD(DVTOV(dv));
514aac43a5fSjg return (dv);
5157c478bd9Sstevel@tonic-gate }
5167c478bd9Sstevel@tonic-gate return (NULL);
5177c478bd9Sstevel@tonic-gate }
5187c478bd9Sstevel@tonic-gate
5197c478bd9Sstevel@tonic-gate /*
5207c478bd9Sstevel@tonic-gate * Inserts a new dv_node in a parent directory
5217c478bd9Sstevel@tonic-gate */
5227c478bd9Sstevel@tonic-gate void
dv_insert(struct dv_node * ddv,struct dv_node * dv)5237c478bd9Sstevel@tonic-gate dv_insert(struct dv_node *ddv, struct dv_node *dv)
5247c478bd9Sstevel@tonic-gate {
525b9ccdc5aScth avl_index_t where;
526aac43a5fSjg
5277c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&ddv->dv_contents));
5287c478bd9Sstevel@tonic-gate ASSERT(DVTOV(ddv)->v_type == VDIR);
5297c478bd9Sstevel@tonic-gate ASSERT(ddv->dv_nlink >= 2);
5307c478bd9Sstevel@tonic-gate ASSERT(dv->dv_nlink == 0);
5317c478bd9Sstevel@tonic-gate
5327c478bd9Sstevel@tonic-gate dcmn_err3(("dv_insert: %s\n", dv->dv_name));
5337c478bd9Sstevel@tonic-gate
5347c478bd9Sstevel@tonic-gate dv->dv_dotdot = ddv;
5357c478bd9Sstevel@tonic-gate if (DVTOV(dv)->v_type == VDIR) {
5367c478bd9Sstevel@tonic-gate ddv->dv_nlink++; /* .. to containing directory */
5377c478bd9Sstevel@tonic-gate dv->dv_nlink = 2; /* name + . */
5387c478bd9Sstevel@tonic-gate } else {
5397c478bd9Sstevel@tonic-gate dv->dv_nlink = 1; /* name */
5407c478bd9Sstevel@tonic-gate }
541aac43a5fSjg
542aac43a5fSjg /* enter node in the avl tree */
543aac43a5fSjg VERIFY(avl_find(&ddv->dv_entries, dv, &where) == NULL);
544aac43a5fSjg avl_insert(&ddv->dv_entries, dv, where);
5457c478bd9Sstevel@tonic-gate }
5467c478bd9Sstevel@tonic-gate
54745a9d961Scth /*
54845a9d961Scth * Unlink a dv_node from a perent directory
54945a9d961Scth */
55045a9d961Scth void
dv_unlink(struct dv_node * ddv,struct dv_node * dv)551aac43a5fSjg dv_unlink(struct dv_node *ddv, struct dv_node *dv)
55245a9d961Scth {
55345a9d961Scth /* verify linkage of arguments */
554aac43a5fSjg ASSERT(ddv && dv);
55545a9d961Scth ASSERT(dv->dv_dotdot == ddv);
55645a9d961Scth ASSERT(RW_WRITE_HELD(&ddv->dv_contents));
55745a9d961Scth ASSERT(DVTOV(ddv)->v_type == VDIR);
55845a9d961Scth
55945a9d961Scth dcmn_err3(("dv_unlink: %s\n", dv->dv_name));
56045a9d961Scth
56145a9d961Scth if (DVTOV(dv)->v_type == VDIR) {
56245a9d961Scth ddv->dv_nlink--; /* .. to containing directory */
56345a9d961Scth dv->dv_nlink -= 2; /* name + . */
56445a9d961Scth } else {
56545a9d961Scth dv->dv_nlink -= 1; /* name */
56645a9d961Scth }
56745a9d961Scth ASSERT(ddv->dv_nlink >= 2);
56845a9d961Scth ASSERT(dv->dv_nlink == 0);
56945a9d961Scth
57045a9d961Scth dv->dv_dotdot = NULL;
571aac43a5fSjg
572aac43a5fSjg /* remove from avl tree */
573aac43a5fSjg avl_remove(&ddv->dv_entries, dv);
57445a9d961Scth }
57545a9d961Scth
5767c478bd9Sstevel@tonic-gate /*
5777c478bd9Sstevel@tonic-gate * Merge devfs node specific information into an attribute structure.
5787c478bd9Sstevel@tonic-gate *
5797c478bd9Sstevel@tonic-gate * NOTE: specfs provides ATIME,MTIME,CTIME,SIZE,BLKSIZE,NBLOCKS on leaf node.
5807c478bd9Sstevel@tonic-gate */
5817c478bd9Sstevel@tonic-gate void
dv_vattr_merge(struct dv_node * dv,struct vattr * vap)5827c478bd9Sstevel@tonic-gate dv_vattr_merge(struct dv_node *dv, struct vattr *vap)
5837c478bd9Sstevel@tonic-gate {
584b9ccdc5aScth struct vnode *vp = DVTOV(dv);
5857c478bd9Sstevel@tonic-gate
5867c478bd9Sstevel@tonic-gate vap->va_nodeid = dv->dv_ino;
5877c478bd9Sstevel@tonic-gate vap->va_nlink = dv->dv_nlink;
5887c478bd9Sstevel@tonic-gate
5897c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) {
5907c478bd9Sstevel@tonic-gate vap->va_rdev = 0;
5917c478bd9Sstevel@tonic-gate vap->va_fsid = vp->v_rdev;
5927c478bd9Sstevel@tonic-gate } else {
5937c478bd9Sstevel@tonic-gate vap->va_rdev = vp->v_rdev;
5947c478bd9Sstevel@tonic-gate vap->va_fsid = DVTOV(dv->dv_dotdot)->v_rdev;
5957c478bd9Sstevel@tonic-gate vap->va_type = vp->v_type;
5967c478bd9Sstevel@tonic-gate /* don't trust the shadow file type */
5977c478bd9Sstevel@tonic-gate vap->va_mode &= ~S_IFMT;
5987c478bd9Sstevel@tonic-gate if (vap->va_type == VCHR)
5997c478bd9Sstevel@tonic-gate vap->va_mode |= S_IFCHR;
6007c478bd9Sstevel@tonic-gate else
6017c478bd9Sstevel@tonic-gate vap->va_mode |= S_IFBLK;
6027c478bd9Sstevel@tonic-gate }
6037c478bd9Sstevel@tonic-gate }
6047c478bd9Sstevel@tonic-gate
605facf4a8dSllai /*
606facf4a8dSllai * Get default device permission by consulting rules in
607facf4a8dSllai * privilege specification in minor node and /etc/minor_perm.
608facf4a8dSllai *
609facf4a8dSllai * This function is called from the devname filesystem to get default
610facf4a8dSllai * permissions for a device exported to a non-global zone.
611facf4a8dSllai */
612facf4a8dSllai void
devfs_get_defattr(struct vnode * vp,struct vattr * vap,int * no_fs_perm)613facf4a8dSllai devfs_get_defattr(struct vnode *vp, struct vattr *vap, int *no_fs_perm)
614facf4a8dSllai {
615b9ccdc5aScth mperm_t mp;
616b9ccdc5aScth struct dv_node *dv;
617facf4a8dSllai
618facf4a8dSllai /* If vp isn't a dv_node, return something sensible */
619facf4a8dSllai if (!vn_matchops(vp, dv_vnodeops)) {
620facf4a8dSllai if (no_fs_perm)
621facf4a8dSllai *no_fs_perm = 0;
622facf4a8dSllai *vap = dv_vattr_file;
623facf4a8dSllai return;
624facf4a8dSllai }
625facf4a8dSllai
626facf4a8dSllai /*
627facf4a8dSllai * For minors not created by ddi_create_priv_minor_node(),
628facf4a8dSllai * use devfs defaults.
629facf4a8dSllai */
630facf4a8dSllai dv = VTODV(vp);
631facf4a8dSllai if (vp->v_type == VDIR) {
632facf4a8dSllai *vap = dv_vattr_dir;
633facf4a8dSllai } else if (dv->dv_flags & DV_NO_FSPERM) {
634facf4a8dSllai if (no_fs_perm)
635facf4a8dSllai *no_fs_perm = 1;
636facf4a8dSllai *vap = dv_vattr_priv;
637facf4a8dSllai } else {
638facf4a8dSllai /*
639facf4a8dSllai * look up perm bits from minor_perm
640facf4a8dSllai */
641facf4a8dSllai *vap = dv_vattr_file;
642facf4a8dSllai if (dev_minorperm(dv->dv_devi, dv->dv_name, &mp) == 0) {
643facf4a8dSllai VATTR_MP_MERGE((*vap), mp);
644facf4a8dSllai dcmn_err5(("%s: minor perm mode 0%o\n",
645facf4a8dSllai dv->dv_name, vap->va_mode));
646facf4a8dSllai } else if (dv->dv_flags & DV_DFLT_MODE) {
647facf4a8dSllai ASSERT((dv->dv_dflt_mode & ~S_IAMB) == 0);
648facf4a8dSllai vap->va_mode &= ~S_IAMB;
649facf4a8dSllai vap->va_mode |= dv->dv_dflt_mode;
650facf4a8dSllai dcmn_err5(("%s: priv mode 0%o\n",
651facf4a8dSllai dv->dv_name, vap->va_mode));
652facf4a8dSllai }
653facf4a8dSllai }
654facf4a8dSllai }
655facf4a8dSllai
6567c478bd9Sstevel@tonic-gate /*
6577c478bd9Sstevel@tonic-gate * dv_shadow_node
6587c478bd9Sstevel@tonic-gate *
6597c478bd9Sstevel@tonic-gate * Given a VDIR dv_node, find/create the associated VDIR
6607c478bd9Sstevel@tonic-gate * node in the shadow attribute filesystem.
6617c478bd9Sstevel@tonic-gate *
6627c478bd9Sstevel@tonic-gate * Given a VCHR/VBLK dv_node, find the associated VREG
6637c478bd9Sstevel@tonic-gate * node in the shadow attribute filesystem. These nodes
6647c478bd9Sstevel@tonic-gate * are only created to persist non-default attributes.
6657c478bd9Sstevel@tonic-gate * Lack of such a node implies the default permissions
6667c478bd9Sstevel@tonic-gate * are sufficient.
6677c478bd9Sstevel@tonic-gate *
6687c478bd9Sstevel@tonic-gate * Managing the attribute file entries is slightly tricky (mostly
6697c478bd9Sstevel@tonic-gate * because we can't intercept VN_HOLD and VN_RELE except on the last
6707c478bd9Sstevel@tonic-gate * release).
6717c478bd9Sstevel@tonic-gate *
6727c478bd9Sstevel@tonic-gate * We assert that if the dv_attrvp pointer is non-NULL, it points
6737c478bd9Sstevel@tonic-gate * to a singly-held (by us) vnode that represents the shadow entry
6747c478bd9Sstevel@tonic-gate * in the underlying filesystem. To avoid store-ordering issues,
6757c478bd9Sstevel@tonic-gate * we assert that the pointer can only be tested under the dv_contents
6767c478bd9Sstevel@tonic-gate * READERS lock.
6777c478bd9Sstevel@tonic-gate */
6787c478bd9Sstevel@tonic-gate
6797c478bd9Sstevel@tonic-gate void
dv_shadow_node(struct vnode * dvp,char * nm,struct vnode * vp,struct pathname * pnp,struct vnode * rdir,struct cred * cred,int flags)6807c478bd9Sstevel@tonic-gate dv_shadow_node(
6817c478bd9Sstevel@tonic-gate struct vnode *dvp, /* devfs parent directory vnode */
6827c478bd9Sstevel@tonic-gate char *nm, /* name component */
6837c478bd9Sstevel@tonic-gate struct vnode *vp, /* devfs vnode */
6847c478bd9Sstevel@tonic-gate struct pathname *pnp, /* the path .. */
6857c478bd9Sstevel@tonic-gate struct vnode *rdir, /* the root .. */
6867c478bd9Sstevel@tonic-gate struct cred *cred, /* who's asking? */
6877c478bd9Sstevel@tonic-gate int flags) /* optionally create shadow node */
6887c478bd9Sstevel@tonic-gate {
6897c478bd9Sstevel@tonic-gate struct dv_node *dv; /* dv_node of named directory */
6907c478bd9Sstevel@tonic-gate struct vnode *rdvp; /* shadow parent directory vnode */
6917c478bd9Sstevel@tonic-gate struct vnode *rvp; /* shadow vnode */
6927c478bd9Sstevel@tonic-gate struct vnode *rrvp; /* realvp of shadow vnode */
6937c478bd9Sstevel@tonic-gate struct vattr vattr;
6947c478bd9Sstevel@tonic-gate int create_tried;
6957c478bd9Sstevel@tonic-gate int error;
6967c478bd9Sstevel@tonic-gate
6977c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VDIR || vp->v_type == VCHR || vp->v_type == VBLK);
6987c478bd9Sstevel@tonic-gate dv = VTODV(vp);
6997c478bd9Sstevel@tonic-gate dcmn_err3(("dv_shadow_node: name %s attr %p\n",
7007c478bd9Sstevel@tonic-gate nm, (void *)dv->dv_attrvp));
7017c478bd9Sstevel@tonic-gate
7027c478bd9Sstevel@tonic-gate if ((flags & DV_SHADOW_WRITE_HELD) == 0) {
7037c478bd9Sstevel@tonic-gate ASSERT(RW_READ_HELD(&dv->dv_contents));
7047c478bd9Sstevel@tonic-gate if (dv->dv_attrvp != NULLVP)
7057c478bd9Sstevel@tonic-gate return;
7067c478bd9Sstevel@tonic-gate if (!rw_tryupgrade(&dv->dv_contents)) {
7077c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
7087c478bd9Sstevel@tonic-gate rw_enter(&dv->dv_contents, RW_WRITER);
7097c478bd9Sstevel@tonic-gate if (dv->dv_attrvp != NULLVP) {
7107c478bd9Sstevel@tonic-gate rw_downgrade(&dv->dv_contents);
7117c478bd9Sstevel@tonic-gate return;
7127c478bd9Sstevel@tonic-gate }
7137c478bd9Sstevel@tonic-gate }
7147c478bd9Sstevel@tonic-gate } else {
7157c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&dv->dv_contents));
7167c478bd9Sstevel@tonic-gate if (dv->dv_attrvp != NULLVP)
7177c478bd9Sstevel@tonic-gate return;
7187c478bd9Sstevel@tonic-gate }
7197c478bd9Sstevel@tonic-gate
7207c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&dv->dv_contents) && dv->dv_attrvp == NULL);
7217c478bd9Sstevel@tonic-gate
7227c478bd9Sstevel@tonic-gate rdvp = VTODV(dvp)->dv_attrvp;
7237c478bd9Sstevel@tonic-gate create_tried = 0;
7247c478bd9Sstevel@tonic-gate lookup:
7257c478bd9Sstevel@tonic-gate if (rdvp && (dv->dv_flags & DV_NO_FSPERM) == 0) {
726da6c28aaSamw error = VOP_LOOKUP(rdvp, nm, &rvp, pnp, LOOKUP_DIR, rdir, cred,
727da6c28aaSamw NULL, NULL, NULL);
7287c478bd9Sstevel@tonic-gate
7297c478bd9Sstevel@tonic-gate /* factor out the snode since we only want the attribute node */
730da6c28aaSamw if ((error == 0) && (VOP_REALVP(rvp, &rrvp, NULL) == 0)) {
7317c478bd9Sstevel@tonic-gate VN_HOLD(rrvp);
7327c478bd9Sstevel@tonic-gate VN_RELE(rvp);
7337c478bd9Sstevel@tonic-gate rvp = rrvp;
7347c478bd9Sstevel@tonic-gate }
7357c478bd9Sstevel@tonic-gate } else
7367c478bd9Sstevel@tonic-gate error = EROFS; /* no parent, no entry */
7377c478bd9Sstevel@tonic-gate
7387c478bd9Sstevel@tonic-gate /*
7397c478bd9Sstevel@tonic-gate * All we want is the permissions (and maybe ACLs and
7407c478bd9Sstevel@tonic-gate * extended attributes), and we want to perform lookups
7417c478bd9Sstevel@tonic-gate * by name. Drivers occasionally change their minor
7427c478bd9Sstevel@tonic-gate * number space. If something changes, there's no
7437c478bd9Sstevel@tonic-gate * much we can do about it here.
7447c478bd9Sstevel@tonic-gate */
7457c478bd9Sstevel@tonic-gate
7467c478bd9Sstevel@tonic-gate /* The shadow node checks out. We are done */
7477c478bd9Sstevel@tonic-gate if (error == 0) {
7487c478bd9Sstevel@tonic-gate dv->dv_attrvp = rvp; /* with one hold */
7497c478bd9Sstevel@tonic-gate
7507c478bd9Sstevel@tonic-gate /*
751fa9e4066Sahrens * Determine if we have non-trivial ACLs on this node.
752fa9e4066Sahrens * It is not necessary to VOP_RWLOCK since fs_acl_nontrivial
753fa9e4066Sahrens * only does VOP_GETSECATTR.
7547c478bd9Sstevel@tonic-gate */
7557c478bd9Sstevel@tonic-gate dv->dv_flags &= ~DV_ACL;
756fa9e4066Sahrens
757fa9e4066Sahrens if (fs_acl_nontrivial(rvp, cred))
758fa9e4066Sahrens dv->dv_flags |= DV_ACL;
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate /*
7617c478bd9Sstevel@tonic-gate * If we have synced out the memory attributes, free
7627c478bd9Sstevel@tonic-gate * them and switch back to using the persistent store.
7637c478bd9Sstevel@tonic-gate */
7647c478bd9Sstevel@tonic-gate if (rvp && dv->dv_attr) {
7657c478bd9Sstevel@tonic-gate kmem_free(dv->dv_attr, sizeof (struct vattr));
7667c478bd9Sstevel@tonic-gate dv->dv_attr = NULL;
7677c478bd9Sstevel@tonic-gate }
7687c478bd9Sstevel@tonic-gate if ((flags & DV_SHADOW_WRITE_HELD) == 0)
7697c478bd9Sstevel@tonic-gate rw_downgrade(&dv->dv_contents);
7707c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&dv->dv_contents));
7717c478bd9Sstevel@tonic-gate return;
7727c478bd9Sstevel@tonic-gate }
7737c478bd9Sstevel@tonic-gate
7747c478bd9Sstevel@tonic-gate /*
7757c478bd9Sstevel@tonic-gate * Failed to find attribute in persistent backing store,
776facf4a8dSllai * get default permission bits.
7777c478bd9Sstevel@tonic-gate */
778facf4a8dSllai devfs_get_defattr(vp, &vattr, NULL);
7797c478bd9Sstevel@tonic-gate
7807c478bd9Sstevel@tonic-gate dv_vattr_merge(dv, &vattr);
7817c478bd9Sstevel@tonic-gate gethrestime(&vattr.va_atime);
7827c478bd9Sstevel@tonic-gate vattr.va_mtime = vattr.va_atime;
7837c478bd9Sstevel@tonic-gate vattr.va_ctime = vattr.va_atime;
7847c478bd9Sstevel@tonic-gate
7857c478bd9Sstevel@tonic-gate /*
7867c478bd9Sstevel@tonic-gate * Try to create shadow dir. This is necessary in case
7877c478bd9Sstevel@tonic-gate * we need to create a shadow leaf node later, when user
7887c478bd9Sstevel@tonic-gate * executes chmod.
7897c478bd9Sstevel@tonic-gate */
7907c478bd9Sstevel@tonic-gate if ((error == ENOENT) && !create_tried) {
7917c478bd9Sstevel@tonic-gate switch (vp->v_type) {
7927c478bd9Sstevel@tonic-gate case VDIR:
793da6c28aaSamw error = VOP_MKDIR(rdvp, nm, &vattr, &rvp, kcred,
794da6c28aaSamw NULL, 0, NULL);
7957c478bd9Sstevel@tonic-gate dsysdebug(error, ("vop_mkdir %s %s %d\n",
7967c478bd9Sstevel@tonic-gate VTODV(dvp)->dv_name, nm, error));
7977c478bd9Sstevel@tonic-gate create_tried = 1;
7987c478bd9Sstevel@tonic-gate break;
7997c478bd9Sstevel@tonic-gate
8007c478bd9Sstevel@tonic-gate case VCHR:
8017c478bd9Sstevel@tonic-gate case VBLK:
8027c478bd9Sstevel@tonic-gate /*
8037c478bd9Sstevel@tonic-gate * Shadow nodes are only created on demand
8047c478bd9Sstevel@tonic-gate */
8057c478bd9Sstevel@tonic-gate if (flags & DV_SHADOW_CREATE) {
8067c478bd9Sstevel@tonic-gate error = VOP_CREATE(rdvp, nm, &vattr, NONEXCL,
807da6c28aaSamw VREAD|VWRITE, &rvp, kcred, 0, NULL, NULL);
8087c478bd9Sstevel@tonic-gate dsysdebug(error, ("vop_create %s %s %d\n",
8097c478bd9Sstevel@tonic-gate VTODV(dvp)->dv_name, nm, error));
8107c478bd9Sstevel@tonic-gate create_tried = 1;
8117c478bd9Sstevel@tonic-gate }
8127c478bd9Sstevel@tonic-gate break;
8137c478bd9Sstevel@tonic-gate
8147c478bd9Sstevel@tonic-gate default:
8157c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "devfs: %s: create", dvnm);
8167c478bd9Sstevel@tonic-gate /*NOTREACHED*/
8177c478bd9Sstevel@tonic-gate }
8187c478bd9Sstevel@tonic-gate
8197c478bd9Sstevel@tonic-gate if (create_tried &&
8207c478bd9Sstevel@tonic-gate (error == 0) || (error == EEXIST)) {
8217c478bd9Sstevel@tonic-gate VN_RELE(rvp);
8227c478bd9Sstevel@tonic-gate goto lookup;
8237c478bd9Sstevel@tonic-gate }
8247c478bd9Sstevel@tonic-gate }
8257c478bd9Sstevel@tonic-gate
8267c478bd9Sstevel@tonic-gate /* Store attribute in memory */
8277c478bd9Sstevel@tonic-gate if (dv->dv_attr == NULL) {
8287c478bd9Sstevel@tonic-gate dv->dv_attr = kmem_alloc(sizeof (struct vattr), KM_SLEEP);
8297c478bd9Sstevel@tonic-gate *(dv->dv_attr) = vattr;
8307c478bd9Sstevel@tonic-gate }
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate if ((flags & DV_SHADOW_WRITE_HELD) == 0)
8337c478bd9Sstevel@tonic-gate rw_downgrade(&dv->dv_contents);
8347c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&dv->dv_contents));
8357c478bd9Sstevel@tonic-gate }
8367c478bd9Sstevel@tonic-gate
8377c478bd9Sstevel@tonic-gate /*
8387c478bd9Sstevel@tonic-gate * Given a devinfo node, and a name, returns the appropriate
8397c478bd9Sstevel@tonic-gate * minor information for that named node, if it exists.
8407c478bd9Sstevel@tonic-gate */
8417c478bd9Sstevel@tonic-gate static int
dv_find_leafnode(dev_info_t * devi,char * minor_nm,struct ddi_minor_data * r_mi)8427c478bd9Sstevel@tonic-gate dv_find_leafnode(dev_info_t *devi, char *minor_nm, struct ddi_minor_data *r_mi)
8437c478bd9Sstevel@tonic-gate {
844b9ccdc5aScth struct ddi_minor_data *dmd;
8457c478bd9Sstevel@tonic-gate
846737d277aScth ASSERT(i_ddi_devi_attached(devi));
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate dcmn_err3(("dv_find_leafnode: %s\n", minor_nm));
849b9ccdc5aScth ASSERT(DEVI_BUSY_OWNED(devi));
8507c478bd9Sstevel@tonic-gate for (dmd = DEVI(devi)->devi_minor; dmd; dmd = dmd->next) {
8517c478bd9Sstevel@tonic-gate
8527c478bd9Sstevel@tonic-gate /*
8537c478bd9Sstevel@tonic-gate * Skip alias nodes and nodes without a name.
8547c478bd9Sstevel@tonic-gate */
8557c478bd9Sstevel@tonic-gate if ((dmd->type == DDM_ALIAS) || (dmd->ddm_name == NULL))
856aac43a5fSjg continue;
8577c478bd9Sstevel@tonic-gate
8587c478bd9Sstevel@tonic-gate dcmn_err4(("dv_find_leafnode: (%s,%s)\n",
859aac43a5fSjg minor_nm, dmd->ddm_name));
8607c478bd9Sstevel@tonic-gate if (strcmp(minor_nm, dmd->ddm_name) == 0) {
8617c478bd9Sstevel@tonic-gate r_mi->ddm_dev = dmd->ddm_dev;
8627c478bd9Sstevel@tonic-gate r_mi->ddm_spec_type = dmd->ddm_spec_type;
8637c478bd9Sstevel@tonic-gate r_mi->type = dmd->type;
8647c478bd9Sstevel@tonic-gate r_mi->ddm_flags = dmd->ddm_flags;
8657c478bd9Sstevel@tonic-gate r_mi->ddm_node_priv = dmd->ddm_node_priv;
8667c478bd9Sstevel@tonic-gate r_mi->ddm_priv_mode = dmd->ddm_priv_mode;
8677c478bd9Sstevel@tonic-gate if (r_mi->ddm_node_priv)
8687c478bd9Sstevel@tonic-gate dphold(r_mi->ddm_node_priv);
8697c478bd9Sstevel@tonic-gate return (0);
8707c478bd9Sstevel@tonic-gate }
8717c478bd9Sstevel@tonic-gate }
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate dcmn_err3(("dv_find_leafnode: %s: ENOENT\n", minor_nm));
8747c478bd9Sstevel@tonic-gate return (ENOENT);
8757c478bd9Sstevel@tonic-gate }
8767c478bd9Sstevel@tonic-gate
8777c478bd9Sstevel@tonic-gate /*
8787c478bd9Sstevel@tonic-gate * Special handling for clone node:
8797c478bd9Sstevel@tonic-gate * Clone minor name is a driver name, the minor number will
8807c478bd9Sstevel@tonic-gate * be the major number of the driver. There is no minor
8817c478bd9Sstevel@tonic-gate * node under the clone driver, so we'll manufacture the
8827c478bd9Sstevel@tonic-gate * dev_t.
8837c478bd9Sstevel@tonic-gate */
8847c478bd9Sstevel@tonic-gate static struct dv_node *
dv_clone_mknod(struct dv_node * ddv,char * drvname)8857c478bd9Sstevel@tonic-gate dv_clone_mknod(struct dv_node *ddv, char *drvname)
8867c478bd9Sstevel@tonic-gate {
887b9ccdc5aScth major_t major;
888b9ccdc5aScth struct dv_node *dvp;
889b9ccdc5aScth char *devnm;
890b9ccdc5aScth struct ddi_minor_data *dmd;
8917c478bd9Sstevel@tonic-gate
8927c478bd9Sstevel@tonic-gate /*
8937c478bd9Sstevel@tonic-gate * Make sure drvname is a STREAMS driver. We load the driver,
8947c478bd9Sstevel@tonic-gate * but don't attach to any instances. This makes stat(2)
8957c478bd9Sstevel@tonic-gate * relatively cheap.
8967c478bd9Sstevel@tonic-gate */
8977c478bd9Sstevel@tonic-gate major = ddi_name_to_major(drvname);
898a204de77Scth if (major == DDI_MAJOR_T_NONE)
8997c478bd9Sstevel@tonic-gate return (NULL);
9007c478bd9Sstevel@tonic-gate
9017c478bd9Sstevel@tonic-gate if (ddi_hold_driver(major) == NULL)
9027c478bd9Sstevel@tonic-gate return (NULL);
9037c478bd9Sstevel@tonic-gate
9047c478bd9Sstevel@tonic-gate if (STREAMSTAB(major) == NULL) {
9057c478bd9Sstevel@tonic-gate ddi_rele_driver(major);
9067c478bd9Sstevel@tonic-gate return (NULL);
9077c478bd9Sstevel@tonic-gate }
9087c478bd9Sstevel@tonic-gate
9097c478bd9Sstevel@tonic-gate ddi_rele_driver(major);
9107c478bd9Sstevel@tonic-gate devnm = kmem_alloc(MAXNAMELEN, KM_SLEEP);
9117c478bd9Sstevel@tonic-gate (void) snprintf(devnm, MAXNAMELEN, "clone@0:%s", drvname);
9127c478bd9Sstevel@tonic-gate dmd = kmem_zalloc(sizeof (*dmd), KM_SLEEP);
9137c478bd9Sstevel@tonic-gate dmd->ddm_dev = makedevice(clone_major, (minor_t)major);
9147c478bd9Sstevel@tonic-gate dmd->ddm_spec_type = S_IFCHR;
9157c478bd9Sstevel@tonic-gate dvp = dv_mknod(ddv, clone_dip, devnm, dmd);
9167c478bd9Sstevel@tonic-gate kmem_free(dmd, sizeof (*dmd));
9177c478bd9Sstevel@tonic-gate kmem_free(devnm, MAXNAMELEN);
9187c478bd9Sstevel@tonic-gate return (dvp);
9197c478bd9Sstevel@tonic-gate }
9207c478bd9Sstevel@tonic-gate
9217c478bd9Sstevel@tonic-gate /*
9227c478bd9Sstevel@tonic-gate * Given the parent directory node, and a name in it, returns the
9237c478bd9Sstevel@tonic-gate * named dv_node to the caller (as a vnode).
9247c478bd9Sstevel@tonic-gate *
9257c478bd9Sstevel@tonic-gate * (We need pnp and rdir for doing shadow lookups; they can be NULL)
9267c478bd9Sstevel@tonic-gate */
9277c478bd9Sstevel@tonic-gate int
dv_find(struct dv_node * ddv,char * nm,struct vnode ** vpp,struct pathname * pnp,struct vnode * rdir,struct cred * cred,uint_t ndi_flags)9287c478bd9Sstevel@tonic-gate dv_find(struct dv_node *ddv, char *nm, struct vnode **vpp, struct pathname *pnp,
929*d5ebc493SDan Cross struct vnode *rdir, struct cred *cred, uint_t ndi_flags)
9307c478bd9Sstevel@tonic-gate {
9317c478bd9Sstevel@tonic-gate extern int isminiroot; /* see modctl.c */
9327c478bd9Sstevel@tonic-gate
933b9ccdc5aScth int rv = 0, was_busy = 0, nmlen, write_held = 0;
934b9ccdc5aScth struct vnode *vp;
935b9ccdc5aScth struct dv_node *dv, *dup;
936b9ccdc5aScth dev_info_t *pdevi, *devi = NULL;
937b9ccdc5aScth char *mnm;
938b9ccdc5aScth struct ddi_minor_data *dmd;
9397c478bd9Sstevel@tonic-gate
9407c478bd9Sstevel@tonic-gate dcmn_err3(("dv_find %s\n", nm));
9417c478bd9Sstevel@tonic-gate
9429f787237SJakub Jermar if (!rw_tryenter(&ddv->dv_contents, RW_READER)) {
9439f787237SJakub Jermar if (tsd_get(devfs_clean_key))
9449f787237SJakub Jermar return (EBUSY);
9459f787237SJakub Jermar rw_enter(&ddv->dv_contents, RW_READER);
9469f787237SJakub Jermar }
9477c478bd9Sstevel@tonic-gate start:
9487c478bd9Sstevel@tonic-gate if (DV_STALE(ddv)) {
9497c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
9507c478bd9Sstevel@tonic-gate return (ESTALE);
9517c478bd9Sstevel@tonic-gate }
9527c478bd9Sstevel@tonic-gate
9537c478bd9Sstevel@tonic-gate /*
9547c478bd9Sstevel@tonic-gate * Empty name or ., return node itself.
9557c478bd9Sstevel@tonic-gate */
9567c478bd9Sstevel@tonic-gate nmlen = strlen(nm);
9577c478bd9Sstevel@tonic-gate if ((nmlen == 0) || ((nmlen == 1) && (nm[0] == '.'))) {
9587c478bd9Sstevel@tonic-gate *vpp = DVTOV(ddv);
9597c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
9607c478bd9Sstevel@tonic-gate VN_HOLD(*vpp);
9617c478bd9Sstevel@tonic-gate return (0);
9627c478bd9Sstevel@tonic-gate }
9637c478bd9Sstevel@tonic-gate
9647c478bd9Sstevel@tonic-gate /*
9657c478bd9Sstevel@tonic-gate * .., return the parent directory
9667c478bd9Sstevel@tonic-gate */
9677c478bd9Sstevel@tonic-gate if ((nmlen == 2) && (strcmp(nm, "..") == 0)) {
9687c478bd9Sstevel@tonic-gate *vpp = DVTOV(ddv->dv_dotdot);
9697c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
9707c478bd9Sstevel@tonic-gate VN_HOLD(*vpp);
9717c478bd9Sstevel@tonic-gate return (0);
9727c478bd9Sstevel@tonic-gate }
9737c478bd9Sstevel@tonic-gate
9747c478bd9Sstevel@tonic-gate /*
9757c478bd9Sstevel@tonic-gate * Fail anything without a valid device name component
9767c478bd9Sstevel@tonic-gate */
9777c478bd9Sstevel@tonic-gate if (nm[0] == '@' || nm[0] == ':') {
9787c478bd9Sstevel@tonic-gate dcmn_err3(("devfs: no driver '%s'\n", nm));
9797c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
9807c478bd9Sstevel@tonic-gate return (ENOENT);
9817c478bd9Sstevel@tonic-gate }
9827c478bd9Sstevel@tonic-gate
9837c478bd9Sstevel@tonic-gate /*
9847c478bd9Sstevel@tonic-gate * So, now we have to deal with the trickier stuff.
9857c478bd9Sstevel@tonic-gate *
9867c478bd9Sstevel@tonic-gate * (a) search the existing list of dv_nodes on this directory
9877c478bd9Sstevel@tonic-gate */
9887c478bd9Sstevel@tonic-gate if ((dv = dv_findbyname(ddv, nm)) != NULL) {
9897c478bd9Sstevel@tonic-gate founddv:
9907c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&ddv->dv_contents));
991f94a2171Sdf
992f94a2171Sdf if (!rw_tryenter(&dv->dv_contents, RW_READER)) {
993f94a2171Sdf if (tsd_get(devfs_clean_key)) {
994f94a2171Sdf VN_RELE(DVTOV(dv));
995f94a2171Sdf rw_exit(&ddv->dv_contents);
996f94a2171Sdf return (EBUSY);
997f94a2171Sdf }
998f94a2171Sdf rw_enter(&dv->dv_contents, RW_READER);
999f94a2171Sdf }
1000f94a2171Sdf
10017c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
10027c478bd9Sstevel@tonic-gate if ((dv->dv_attrvp != NULLVP) ||
10037c478bd9Sstevel@tonic-gate (vp->v_type != VDIR && dv->dv_attr != NULL)) {
10047c478bd9Sstevel@tonic-gate /*
10057c478bd9Sstevel@tonic-gate * Common case - we already have attributes
10067c478bd9Sstevel@tonic-gate */
10077c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
10087c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
10097c478bd9Sstevel@tonic-gate goto found;
10107c478bd9Sstevel@tonic-gate }
10117c478bd9Sstevel@tonic-gate
10127c478bd9Sstevel@tonic-gate /*
10137c478bd9Sstevel@tonic-gate * No attribute vp, try and build one.
1014f94a2171Sdf *
1015f94a2171Sdf * dv_shadow_node() can briefly drop &dv->dv_contents lock
1016f94a2171Sdf * if it is unable to upgrade it to a write lock. If the
1017f94a2171Sdf * current thread has come in through the bottom-up device
1018f94a2171Sdf * configuration devfs_clean() path, we may deadlock against
1019f94a2171Sdf * a thread performing top-down device configuration if it
1020f94a2171Sdf * grabs the contents lock. To avoid this, when we are on the
1021f94a2171Sdf * devfs_clean() path we attempt to upgrade the dv_contents
1022f94a2171Sdf * lock before we call dv_shadow_node().
10237c478bd9Sstevel@tonic-gate */
1024f94a2171Sdf if (tsd_get(devfs_clean_key)) {
1025f94a2171Sdf if (!rw_tryupgrade(&dv->dv_contents)) {
1026f94a2171Sdf VN_RELE(DVTOV(dv));
1027f94a2171Sdf rw_exit(&dv->dv_contents);
1028f94a2171Sdf rw_exit(&ddv->dv_contents);
1029f94a2171Sdf return (EBUSY);
1030f94a2171Sdf }
1031f94a2171Sdf
1032f94a2171Sdf write_held = DV_SHADOW_WRITE_HELD;
1033f94a2171Sdf }
1034f94a2171Sdf
1035f94a2171Sdf dv_shadow_node(DVTOV(ddv), nm, vp, pnp, rdir, cred,
1036f94a2171Sdf write_held);
1037f94a2171Sdf
10387c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
10397c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
10407c478bd9Sstevel@tonic-gate goto found;
10417c478bd9Sstevel@tonic-gate }
10427c478bd9Sstevel@tonic-gate
10437c478bd9Sstevel@tonic-gate /*
10447c478bd9Sstevel@tonic-gate * (b) Search the child devinfo nodes of our parent directory,
10457c478bd9Sstevel@tonic-gate * looking for the named node. If we find it, build a new
10467c478bd9Sstevel@tonic-gate * node, then grab the writers lock, search the directory
10477c478bd9Sstevel@tonic-gate * if it's still not there, then insert it.
10487c478bd9Sstevel@tonic-gate *
10497c478bd9Sstevel@tonic-gate * We drop the devfs locks before accessing the device tree.
10507c478bd9Sstevel@tonic-gate * Take care to mark the node BUSY so that a forced devfs_clean
10517c478bd9Sstevel@tonic-gate * doesn't mark the directory node stale.
10527c478bd9Sstevel@tonic-gate *
10537c478bd9Sstevel@tonic-gate * Also, check if we are called as part of devfs_clean or
10547c478bd9Sstevel@tonic-gate * reset_perm. If so, simply return not found because there
10557c478bd9Sstevel@tonic-gate * is nothing to clean.
10567c478bd9Sstevel@tonic-gate */
10577c478bd9Sstevel@tonic-gate if (tsd_get(devfs_clean_key)) {
10587c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
10597c478bd9Sstevel@tonic-gate return (ENOENT);
10607c478bd9Sstevel@tonic-gate }
10617c478bd9Sstevel@tonic-gate
10627c478bd9Sstevel@tonic-gate /*
10637c478bd9Sstevel@tonic-gate * We could be either READ or WRITE locked at
10647c478bd9Sstevel@tonic-gate * this point. Upgrade if we are read locked.
10657c478bd9Sstevel@tonic-gate */
10667c478bd9Sstevel@tonic-gate ASSERT(RW_LOCK_HELD(&ddv->dv_contents));
10677c478bd9Sstevel@tonic-gate if (rw_read_locked(&ddv->dv_contents) &&
10687c478bd9Sstevel@tonic-gate !rw_tryupgrade(&ddv->dv_contents)) {
10697c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
10707c478bd9Sstevel@tonic-gate rw_enter(&ddv->dv_contents, RW_WRITER);
10717c478bd9Sstevel@tonic-gate /*
10727c478bd9Sstevel@tonic-gate * Things may have changed when we dropped
10737c478bd9Sstevel@tonic-gate * the contents lock, so start from top again
10747c478bd9Sstevel@tonic-gate */
10757c478bd9Sstevel@tonic-gate goto start;
10767c478bd9Sstevel@tonic-gate }
10777c478bd9Sstevel@tonic-gate ddv->dv_busy++; /* mark busy before dropping lock */
10787c478bd9Sstevel@tonic-gate was_busy++;
10797c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
10807c478bd9Sstevel@tonic-gate
10817c478bd9Sstevel@tonic-gate pdevi = ddv->dv_devi;
10827c478bd9Sstevel@tonic-gate ASSERT(pdevi != NULL);
10837c478bd9Sstevel@tonic-gate
10847c478bd9Sstevel@tonic-gate mnm = strchr(nm, ':');
10857c478bd9Sstevel@tonic-gate if (mnm)
10867c478bd9Sstevel@tonic-gate *mnm = (char)0;
10877c478bd9Sstevel@tonic-gate
10887c478bd9Sstevel@tonic-gate /*
10897c478bd9Sstevel@tonic-gate * Configure one nexus child, will call nexus's bus_ops
10907c478bd9Sstevel@tonic-gate * If successful, devi is held upon returning.
10917c478bd9Sstevel@tonic-gate * Note: devfs lookup should not be configuring grandchildren.
10927c478bd9Sstevel@tonic-gate */
10937c478bd9Sstevel@tonic-gate ASSERT((ndi_flags & NDI_CONFIG) == 0);
10947c478bd9Sstevel@tonic-gate
10957c478bd9Sstevel@tonic-gate rv = ndi_devi_config_one(pdevi, nm, &devi, ndi_flags | NDI_NO_EVENT);
10967c478bd9Sstevel@tonic-gate if (mnm)
10977c478bd9Sstevel@tonic-gate *mnm = ':';
10987c478bd9Sstevel@tonic-gate if (rv != NDI_SUCCESS) {
10997c478bd9Sstevel@tonic-gate rv = ENOENT;
11007c478bd9Sstevel@tonic-gate goto notfound;
11017c478bd9Sstevel@tonic-gate }
11027c478bd9Sstevel@tonic-gate
110394c894bbSVikram Hegde ASSERT(devi);
110494c894bbSVikram Hegde
110594c894bbSVikram Hegde /* Check if this is a path alias */
110694c894bbSVikram Hegde if (ddi_aliases_present == B_TRUE && ddi_get_parent(devi) != pdevi) {
110794c894bbSVikram Hegde char *curr = kmem_alloc(MAXPATHLEN, KM_SLEEP);
110894c894bbSVikram Hegde
110994c894bbSVikram Hegde (void) ddi_pathname(devi, curr);
111094c894bbSVikram Hegde
111194c894bbSVikram Hegde vp = NULL;
111294c894bbSVikram Hegde if (devfs_lookupname(curr, NULL, &vp) == 0 && vp) {
111394c894bbSVikram Hegde dv = VTODV(vp);
111494c894bbSVikram Hegde kmem_free(curr, MAXPATHLEN);
111594c894bbSVikram Hegde goto found;
111694c894bbSVikram Hegde }
111794c894bbSVikram Hegde kmem_free(curr, MAXPATHLEN);
111894c894bbSVikram Hegde }
111994c894bbSVikram Hegde
1120027021c7SChris Horne /*
1121027021c7SChris Horne * If we configured a hidden node, consider it notfound.
1122027021c7SChris Horne */
1123027021c7SChris Horne if (ndi_dev_is_hidden_node(devi)) {
1124027021c7SChris Horne ndi_rele_devi(devi);
1125027021c7SChris Horne rv = ENOENT;
1126027021c7SChris Horne goto notfound;
1127027021c7SChris Horne }
1128027021c7SChris Horne
11297c478bd9Sstevel@tonic-gate /*
11307c478bd9Sstevel@tonic-gate * Don't make vhci clients visible under phci, unless we
11317c478bd9Sstevel@tonic-gate * are in miniroot.
11327c478bd9Sstevel@tonic-gate */
11337c478bd9Sstevel@tonic-gate if (isminiroot == 0 && ddi_get_parent(devi) != pdevi) {
11347c478bd9Sstevel@tonic-gate ndi_rele_devi(devi);
11357c478bd9Sstevel@tonic-gate rv = ENOENT;
11367c478bd9Sstevel@tonic-gate goto notfound;
11377c478bd9Sstevel@tonic-gate }
11387c478bd9Sstevel@tonic-gate
1139737d277aScth ASSERT(devi && i_ddi_devi_attached(devi));
11407c478bd9Sstevel@tonic-gate
11417c478bd9Sstevel@tonic-gate /*
11427c478bd9Sstevel@tonic-gate * Invalidate cache to notice newly created minor nodes.
11437c478bd9Sstevel@tonic-gate */
11447c478bd9Sstevel@tonic-gate rw_enter(&ddv->dv_contents, RW_WRITER);
11457c478bd9Sstevel@tonic-gate ddv->dv_flags |= DV_BUILD;
11467c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
11477c478bd9Sstevel@tonic-gate
11487c478bd9Sstevel@tonic-gate /*
11497c478bd9Sstevel@tonic-gate * mkdir for nexus drivers and leaf nodes as well. If we are racing
11507c478bd9Sstevel@tonic-gate * and create a duplicate, the duplicate will be destroyed below.
11517c478bd9Sstevel@tonic-gate */
11527c478bd9Sstevel@tonic-gate if (mnm == NULL) {
11537c478bd9Sstevel@tonic-gate dv = dv_mkdir(ddv, devi, nm);
11547c478bd9Sstevel@tonic-gate } else {
11557c478bd9Sstevel@tonic-gate /*
1156b9ccdc5aScth * Allocate dmd first to avoid KM_SLEEP with active
1157b9ccdc5aScth * ndi_devi_enter.
11587c478bd9Sstevel@tonic-gate */
1159b9ccdc5aScth dmd = kmem_zalloc(sizeof (*dmd), KM_SLEEP);
11603fe80ca4SDan Cross ndi_devi_enter(devi);
11617c478bd9Sstevel@tonic-gate if (devi == clone_dip) {
1162b9ccdc5aScth /*
1163b9ccdc5aScth * For clone minors, load the driver indicated by
1164b9ccdc5aScth * minor name.
1165b9ccdc5aScth */
11667c478bd9Sstevel@tonic-gate dv = dv_clone_mknod(ddv, mnm + 1);
11677c478bd9Sstevel@tonic-gate } else {
11687c478bd9Sstevel@tonic-gate /*
11697c478bd9Sstevel@tonic-gate * Find minor node and make a dv_node
11707c478bd9Sstevel@tonic-gate */
11717c478bd9Sstevel@tonic-gate if (dv_find_leafnode(devi, mnm + 1, dmd) == 0) {
11727c478bd9Sstevel@tonic-gate dv = dv_mknod(ddv, devi, nm, dmd);
11737c478bd9Sstevel@tonic-gate if (dmd->ddm_node_priv)
11747c478bd9Sstevel@tonic-gate dpfree(dmd->ddm_node_priv);
11757c478bd9Sstevel@tonic-gate }
11767c478bd9Sstevel@tonic-gate }
11773fe80ca4SDan Cross ndi_devi_exit(devi);
1178b9ccdc5aScth kmem_free(dmd, sizeof (*dmd));
11797c478bd9Sstevel@tonic-gate }
11807c478bd9Sstevel@tonic-gate /*
11817c478bd9Sstevel@tonic-gate * Release hold from ndi_devi_config_one()
11827c478bd9Sstevel@tonic-gate */
11837c478bd9Sstevel@tonic-gate ndi_rele_devi(devi);
11847c478bd9Sstevel@tonic-gate
11857c478bd9Sstevel@tonic-gate if (dv == NULL) {
11867c478bd9Sstevel@tonic-gate rv = ENOENT;
11877c478bd9Sstevel@tonic-gate goto notfound;
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate
11907c478bd9Sstevel@tonic-gate /*
11917c478bd9Sstevel@tonic-gate * We have released the dv_contents lock, need to check
11927c478bd9Sstevel@tonic-gate * if another thread already created a duplicate node
11937c478bd9Sstevel@tonic-gate */
11947c478bd9Sstevel@tonic-gate rw_enter(&ddv->dv_contents, RW_WRITER);
11957c478bd9Sstevel@tonic-gate if ((dup = dv_findbyname(ddv, nm)) == NULL) {
11967c478bd9Sstevel@tonic-gate dv_insert(ddv, dv);
11977c478bd9Sstevel@tonic-gate } else {
11987c478bd9Sstevel@tonic-gate /*
11997c478bd9Sstevel@tonic-gate * Duplicate found, use the existing node
12007c478bd9Sstevel@tonic-gate */
12017c478bd9Sstevel@tonic-gate VN_RELE(DVTOV(dv));
12027c478bd9Sstevel@tonic-gate dv_destroy(dv, 0);
12037c478bd9Sstevel@tonic-gate dv = dup;
12047c478bd9Sstevel@tonic-gate }
12057c478bd9Sstevel@tonic-gate goto founddv;
12067c478bd9Sstevel@tonic-gate /*NOTREACHED*/
12077c478bd9Sstevel@tonic-gate
12087c478bd9Sstevel@tonic-gate found:
12094c06356bSdh /*
12104c06356bSdh * Fail lookup of device that has now become hidden (typically via
12114c06356bSdh * hot removal of open device).
12124c06356bSdh */
12134c06356bSdh if (dv->dv_devi && ndi_dev_is_hidden_node(dv->dv_devi)) {
12144c06356bSdh dcmn_err2(("dv_find: nm %s failed: hidden/removed\n", nm));
12154c06356bSdh VN_RELE(vp);
12164c06356bSdh rv = ENOENT;
12174c06356bSdh goto notfound;
12184c06356bSdh }
12194c06356bSdh
12207c478bd9Sstevel@tonic-gate /*
12217c478bd9Sstevel@tonic-gate * Skip non-kernel lookups of internal nodes.
12227c478bd9Sstevel@tonic-gate * This use of kcred to distinguish between user and
12237c478bd9Sstevel@tonic-gate * internal kernel lookups is unfortunate. The information
12247c478bd9Sstevel@tonic-gate * provided by the seg argument to lookupnameat should
12257c478bd9Sstevel@tonic-gate * evolve into a lookup flag for filesystems that need
12267c478bd9Sstevel@tonic-gate * this distinction.
12277c478bd9Sstevel@tonic-gate */
12287c478bd9Sstevel@tonic-gate if ((dv->dv_flags & DV_INTERNAL) && (cred != kcred)) {
12294c06356bSdh dcmn_err2(("dv_find: nm %s failed: internal\n", nm));
12307c478bd9Sstevel@tonic-gate VN_RELE(vp);
12317c478bd9Sstevel@tonic-gate rv = ENOENT;
12327c478bd9Sstevel@tonic-gate goto notfound;
12337c478bd9Sstevel@tonic-gate }
12347c478bd9Sstevel@tonic-gate
12357c478bd9Sstevel@tonic-gate dcmn_err2(("dv_find: returning vp for nm %s\n", nm));
12367c478bd9Sstevel@tonic-gate if (vp->v_type == VCHR || vp->v_type == VBLK) {
12377c478bd9Sstevel@tonic-gate /*
12387c478bd9Sstevel@tonic-gate * If vnode is a device, return special vnode instead
12397c478bd9Sstevel@tonic-gate * (though it knows all about -us- via sp->s_realvp,
12407c478bd9Sstevel@tonic-gate * sp->s_devvp, and sp->s_dip)
12417c478bd9Sstevel@tonic-gate */
12427c478bd9Sstevel@tonic-gate *vpp = specvp_devfs(vp, vp->v_rdev, vp->v_type, cred,
1243aac43a5fSjg dv->dv_devi);
12447c478bd9Sstevel@tonic-gate VN_RELE(vp);
12457c478bd9Sstevel@tonic-gate if (*vpp == NULLVP)
12467c478bd9Sstevel@tonic-gate rv = ENOSYS;
12477c478bd9Sstevel@tonic-gate } else
12487c478bd9Sstevel@tonic-gate *vpp = vp;
12497c478bd9Sstevel@tonic-gate
12507c478bd9Sstevel@tonic-gate notfound:
12519f787237SJakub Jermar if (was_busy) {
12529f787237SJakub Jermar /*
12539f787237SJakub Jermar * Non-zero was_busy tells us that we are not in the
12549f787237SJakub Jermar * devfs_clean() path which in turn means that we can afford
12559f787237SJakub Jermar * to take the contents lock unconditionally.
12569f787237SJakub Jermar */
12579f787237SJakub Jermar rw_enter(&ddv->dv_contents, RW_WRITER);
12587c478bd9Sstevel@tonic-gate ddv->dv_busy--;
12599f787237SJakub Jermar rw_exit(&ddv->dv_contents);
12609f787237SJakub Jermar }
12617c478bd9Sstevel@tonic-gate return (rv);
12627c478bd9Sstevel@tonic-gate }
12637c478bd9Sstevel@tonic-gate
12647c478bd9Sstevel@tonic-gate /*
12657c478bd9Sstevel@tonic-gate * The given directory node is out-of-date; that is, it has been
12667c478bd9Sstevel@tonic-gate * marked as needing to be rebuilt, possibly because some new devinfo
12677c478bd9Sstevel@tonic-gate * node has come into existence, or possibly because this is the first
12687c478bd9Sstevel@tonic-gate * time we've been here.
12697c478bd9Sstevel@tonic-gate */
12707c478bd9Sstevel@tonic-gate void
dv_filldir(struct dv_node * ddv)12717c478bd9Sstevel@tonic-gate dv_filldir(struct dv_node *ddv)
12727c478bd9Sstevel@tonic-gate {
1273b9ccdc5aScth struct dv_node *dv;
1274b9ccdc5aScth dev_info_t *devi, *pdevi;
1275b9ccdc5aScth struct ddi_minor_data *dmd;
1276b9ccdc5aScth char devnm[MAXNAMELEN];
12777c478bd9Sstevel@tonic-gate
12787c478bd9Sstevel@tonic-gate ASSERT(DVTOV(ddv)->v_type == VDIR);
12797c478bd9Sstevel@tonic-gate ASSERT(RW_WRITE_HELD(&ddv->dv_contents));
12807c478bd9Sstevel@tonic-gate ASSERT(ddv->dv_flags & DV_BUILD);
12817c478bd9Sstevel@tonic-gate
12827c478bd9Sstevel@tonic-gate dcmn_err3(("dv_filldir: %s\n", ddv->dv_name));
12837c478bd9Sstevel@tonic-gate if (DV_STALE(ddv))
12847c478bd9Sstevel@tonic-gate return;
12857c478bd9Sstevel@tonic-gate pdevi = ddv->dv_devi;
12867c478bd9Sstevel@tonic-gate
12877c478bd9Sstevel@tonic-gate if (ndi_devi_config(pdevi, NDI_NO_EVENT) != NDI_SUCCESS) {
1288b5fca8f8Stomee dcmn_err3(("dv_filldir: config error %s\n", ddv->dv_name));
12897c478bd9Sstevel@tonic-gate }
12907c478bd9Sstevel@tonic-gate
12913fe80ca4SDan Cross ndi_devi_enter(pdevi);
12927c478bd9Sstevel@tonic-gate for (devi = ddi_get_child(pdevi); devi;
12937c478bd9Sstevel@tonic-gate devi = ddi_get_next_sibling(devi)) {
129467027fa7SMark Logan /*
129567027fa7SMark Logan * While we know enough to create a directory at DS_INITIALIZED,
129667027fa7SMark Logan * the directory will be empty until DS_ATTACHED. The existence
129767027fa7SMark Logan * of an empty directory dv_node will cause a devi_ref, which
129867027fa7SMark Logan * has caused problems for existing code paths doing offline/DR
129967027fa7SMark Logan * type operations - making devfs_clean coordination even more
130067027fa7SMark Logan * sensitive and error prone. Given this, the 'continue' below
130167027fa7SMark Logan * is checking for DS_ATTACHED instead of DS_INITIALIZED.
130267027fa7SMark Logan */
130367027fa7SMark Logan if (i_ddi_node_state(devi) < DS_ATTACHED)
13047c478bd9Sstevel@tonic-gate continue;
13057c478bd9Sstevel@tonic-gate
1306027021c7SChris Horne /* skip hidden nodes */
1307027021c7SChris Horne if (ndi_dev_is_hidden_node(devi))
1308027021c7SChris Horne continue;
1309027021c7SChris Horne
13107c478bd9Sstevel@tonic-gate dcmn_err3(("dv_filldir: node %s\n", ddi_node_name(devi)));
13117c478bd9Sstevel@tonic-gate
13123fe80ca4SDan Cross ndi_devi_enter(devi);
13137c478bd9Sstevel@tonic-gate for (dmd = DEVI(devi)->devi_minor; dmd; dmd = dmd->next) {
13147c478bd9Sstevel@tonic-gate char *addr;
13157c478bd9Sstevel@tonic-gate
13167c478bd9Sstevel@tonic-gate /*
13177c478bd9Sstevel@tonic-gate * Skip alias nodes, internal nodes, and nodes
13187c478bd9Sstevel@tonic-gate * without a name. We allow DDM_DEFAULT nodes
13197c478bd9Sstevel@tonic-gate * to appear in readdir.
13207c478bd9Sstevel@tonic-gate */
13217c478bd9Sstevel@tonic-gate if ((dmd->type == DDM_ALIAS) ||
13227c478bd9Sstevel@tonic-gate (dmd->type == DDM_INTERNAL_PATH) ||
13237c478bd9Sstevel@tonic-gate (dmd->ddm_name == NULL))
13247c478bd9Sstevel@tonic-gate continue;
13257c478bd9Sstevel@tonic-gate
13267c478bd9Sstevel@tonic-gate addr = ddi_get_name_addr(devi);
13277c478bd9Sstevel@tonic-gate if (addr && *addr)
13287c478bd9Sstevel@tonic-gate (void) sprintf(devnm, "%s@%s:%s",
13297c478bd9Sstevel@tonic-gate ddi_node_name(devi), addr, dmd->ddm_name);
13307c478bd9Sstevel@tonic-gate else
13317c478bd9Sstevel@tonic-gate (void) sprintf(devnm, "%s:%s",
13327c478bd9Sstevel@tonic-gate ddi_node_name(devi), dmd->ddm_name);
13337c478bd9Sstevel@tonic-gate
13347c478bd9Sstevel@tonic-gate if ((dv = dv_findbyname(ddv, devnm)) != NULL) {
13357c478bd9Sstevel@tonic-gate /* dv_node already exists */
13367c478bd9Sstevel@tonic-gate VN_RELE(DVTOV(dv));
13377c478bd9Sstevel@tonic-gate continue;
13387c478bd9Sstevel@tonic-gate }
13397c478bd9Sstevel@tonic-gate
13407c478bd9Sstevel@tonic-gate dv = dv_mknod(ddv, devi, devnm, dmd);
13417c478bd9Sstevel@tonic-gate dv_insert(ddv, dv);
13427c478bd9Sstevel@tonic-gate VN_RELE(DVTOV(dv));
13437c478bd9Sstevel@tonic-gate }
13443fe80ca4SDan Cross ndi_devi_exit(devi);
13457c478bd9Sstevel@tonic-gate
13467c478bd9Sstevel@tonic-gate (void) ddi_deviname(devi, devnm);
13477c478bd9Sstevel@tonic-gate if ((dv = dv_findbyname(ddv, devnm + 1)) == NULL) {
13487c478bd9Sstevel@tonic-gate /* directory doesn't exist */
13497c478bd9Sstevel@tonic-gate dv = dv_mkdir(ddv, devi, devnm + 1);
13507c478bd9Sstevel@tonic-gate dv_insert(ddv, dv);
13517c478bd9Sstevel@tonic-gate }
13527c478bd9Sstevel@tonic-gate VN_RELE(DVTOV(dv));
13537c478bd9Sstevel@tonic-gate }
13543fe80ca4SDan Cross ndi_devi_exit(pdevi);
13557c478bd9Sstevel@tonic-gate
13567c478bd9Sstevel@tonic-gate ddv->dv_flags &= ~DV_BUILD;
13577c478bd9Sstevel@tonic-gate }
13587c478bd9Sstevel@tonic-gate
13597c478bd9Sstevel@tonic-gate /*
13607c478bd9Sstevel@tonic-gate * Given a directory node, clean out all the nodes beneath.
13617c478bd9Sstevel@tonic-gate *
13627c478bd9Sstevel@tonic-gate * VDIR: Reinvoke to clean them, then delete the directory.
13637c478bd9Sstevel@tonic-gate * VCHR, VBLK: Just blow them away.
13647c478bd9Sstevel@tonic-gate *
13657c478bd9Sstevel@tonic-gate * Mark the directories touched as in need of a rebuild, in case
13667c478bd9Sstevel@tonic-gate * we fall over part way through. When DV_CLEAN_FORCE is specified,
13677c478bd9Sstevel@tonic-gate * we mark referenced empty directories as stale to facilitate DR.
13687c478bd9Sstevel@tonic-gate */
13697c478bd9Sstevel@tonic-gate int
dv_cleandir(struct dv_node * ddv,char * devnm,uint_t flags)13707c478bd9Sstevel@tonic-gate dv_cleandir(struct dv_node *ddv, char *devnm, uint_t flags)
13717c478bd9Sstevel@tonic-gate {
1372b9ccdc5aScth struct dv_node *dv;
1373b9ccdc5aScth struct dv_node *next;
1374b9ccdc5aScth struct vnode *vp;
1375b9ccdc5aScth int busy = 0;
13767c478bd9Sstevel@tonic-gate
1377f94a2171Sdf /*
1378f94a2171Sdf * We should always be holding the tsd_clean_key here: dv_cleandir()
1379f94a2171Sdf * will be called as a result of a devfs_clean request and the
1380f94a2171Sdf * tsd_clean_key will be set in either in devfs_clean() itself or in
1381f94a2171Sdf * devfs_clean_vhci().
1382f94a2171Sdf *
1383f94a2171Sdf * Since we are on the devfs_clean path, we return EBUSY if we cannot
1384f94a2171Sdf * get the contents lock: if we blocked here we might deadlock against
1385f94a2171Sdf * a thread performing top-down device configuration.
1386f94a2171Sdf */
1387f94a2171Sdf ASSERT(tsd_get(devfs_clean_key));
1388f94a2171Sdf
13897c478bd9Sstevel@tonic-gate dcmn_err3(("dv_cleandir: %s\n", ddv->dv_name));
13907c478bd9Sstevel@tonic-gate
1391f94a2171Sdf if (!(flags & DV_CLEANDIR_LCK) &&
1392f94a2171Sdf !rw_tryenter(&ddv->dv_contents, RW_WRITER))
1393f94a2171Sdf return (EBUSY);
1394f94a2171Sdf
1395aac43a5fSjg for (dv = DV_FIRST_ENTRY(ddv); dv; dv = next) {
1396aac43a5fSjg next = DV_NEXT_ENTRY(ddv, dv);
13977c478bd9Sstevel@tonic-gate
139845a9d961Scth /*
139945a9d961Scth * If devnm is specified, the non-minor portion of the
140045a9d961Scth * name must match devnm.
140145a9d961Scth */
140245a9d961Scth if (devnm &&
140345a9d961Scth (strncmp(devnm, dv->dv_name, strlen(devnm)) ||
14047c478bd9Sstevel@tonic-gate (dv->dv_name[strlen(devnm)] != ':' &&
14057c478bd9Sstevel@tonic-gate dv->dv_name[strlen(devnm)] != '\0')))
14067c478bd9Sstevel@tonic-gate continue;
14077c478bd9Sstevel@tonic-gate
140845a9d961Scth /* check type of what we are cleaning */
14097c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
14107c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) {
141145a9d961Scth /* recurse on directories */
141245a9d961Scth rw_enter(&dv->dv_contents, RW_WRITER);
141345a9d961Scth if (dv_cleandir(dv, NULL,
141445a9d961Scth flags | DV_CLEANDIR_LCK) == EBUSY) {
141545a9d961Scth rw_exit(&dv->dv_contents);
141645a9d961Scth goto set_busy;
141745a9d961Scth }
141845a9d961Scth
141945a9d961Scth /* A clean directory is an empty directory... */
142045a9d961Scth ASSERT(dv->dv_nlink == 2);
142145a9d961Scth mutex_enter(&vp->v_lock);
142245a9d961Scth if (vp->v_count > 0) {
14237c478bd9Sstevel@tonic-gate /*
142445a9d961Scth * ... but an empty directory can still have
142545a9d961Scth * references to it. If we have dv_busy or
142645a9d961Scth * DV_CLEAN_FORCE is *not* specified then a
142745a9d961Scth * referenced directory is considered busy.
14287c478bd9Sstevel@tonic-gate */
142945a9d961Scth if (dv->dv_busy || !(flags & DV_CLEAN_FORCE)) {
143045a9d961Scth mutex_exit(&vp->v_lock);
14317c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
143245a9d961Scth goto set_busy;
14337c478bd9Sstevel@tonic-gate }
143445a9d961Scth
143545a9d961Scth /*
143645a9d961Scth * Mark referenced directory stale so that DR
143745a9d961Scth * will succeed even if a shell has
143845a9d961Scth * /devices/xxx as current directory (causing
143945a9d961Scth * VN_HOLD reference to an empty directory).
144045a9d961Scth */
144145a9d961Scth ASSERT(!DV_STALE(dv));
144245a9d961Scth ndi_rele_devi(dv->dv_devi);
144345a9d961Scth dv->dv_devi = NULL; /* mark DV_STALE */
14447c478bd9Sstevel@tonic-gate }
14457c478bd9Sstevel@tonic-gate } else {
144645a9d961Scth ASSERT((vp->v_type == VCHR) || (vp->v_type == VBLK));
144745a9d961Scth ASSERT(dv->dv_nlink == 1); /* no hard links */
14487c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock);
14497c478bd9Sstevel@tonic-gate if (vp->v_count > 0) {
145045a9d961Scth mutex_exit(&vp->v_lock);
145145a9d961Scth goto set_busy;
14527c478bd9Sstevel@tonic-gate }
14537c478bd9Sstevel@tonic-gate }
14547c478bd9Sstevel@tonic-gate
14557c478bd9Sstevel@tonic-gate /* unlink from directory */
1456aac43a5fSjg dv_unlink(ddv, dv);
14577c478bd9Sstevel@tonic-gate
145845a9d961Scth /* drop locks */
145945a9d961Scth mutex_exit(&vp->v_lock);
146045a9d961Scth if (vp->v_type == VDIR)
146145a9d961Scth rw_exit(&dv->dv_contents);
14627c478bd9Sstevel@tonic-gate
146345a9d961Scth /* destroy vnode if ref count is zero */
146445a9d961Scth if (vp->v_count == 0)
14657c478bd9Sstevel@tonic-gate dv_destroy(dv, flags);
146645a9d961Scth
146745a9d961Scth continue;
146845a9d961Scth
146945a9d961Scth /*
147045a9d961Scth * If devnm is not NULL we return immediately on busy,
147145a9d961Scth * otherwise we continue destroying unused dv_node's.
147245a9d961Scth */
147345a9d961Scth set_busy: busy++;
147445a9d961Scth if (devnm)
147545a9d961Scth break;
14767c478bd9Sstevel@tonic-gate }
147745a9d961Scth
14787c478bd9Sstevel@tonic-gate /*
14797c478bd9Sstevel@tonic-gate * This code may be invoked to inform devfs that a new node has
14807c478bd9Sstevel@tonic-gate * been created in the kernel device tree. So we always set
14817c478bd9Sstevel@tonic-gate * the DV_BUILD flag to allow the next dv_filldir() to pick
14827c478bd9Sstevel@tonic-gate * the new devinfo nodes.
14837c478bd9Sstevel@tonic-gate */
14847c478bd9Sstevel@tonic-gate ddv->dv_flags |= DV_BUILD;
14857c478bd9Sstevel@tonic-gate
148645a9d961Scth if (!(flags & DV_CLEANDIR_LCK))
148745a9d961Scth rw_exit(&ddv->dv_contents);
14887c478bd9Sstevel@tonic-gate
148945a9d961Scth return (busy ? EBUSY : 0);
14907c478bd9Sstevel@tonic-gate }
14917c478bd9Sstevel@tonic-gate
14927c478bd9Sstevel@tonic-gate /*
14937c478bd9Sstevel@tonic-gate * Walk through the devfs hierarchy, correcting the permissions of
14947c478bd9Sstevel@tonic-gate * devices with default permissions that do not match those specified
14957c478bd9Sstevel@tonic-gate * by minor perm. This can only be done for all drivers for now.
14967c478bd9Sstevel@tonic-gate */
14977c478bd9Sstevel@tonic-gate static int
dv_reset_perm_dir(struct dv_node * ddv,uint_t flags)14987c478bd9Sstevel@tonic-gate dv_reset_perm_dir(struct dv_node *ddv, uint_t flags)
14997c478bd9Sstevel@tonic-gate {
1500b9ccdc5aScth struct dv_node *dv;
1501b9ccdc5aScth struct vnode *vp;
1502b9ccdc5aScth int retval = 0;
1503b9ccdc5aScth struct vattr *attrp;
1504b9ccdc5aScth mperm_t mp;
1505b9ccdc5aScth char *nm;
1506b9ccdc5aScth uid_t old_uid;
1507b9ccdc5aScth gid_t old_gid;
1508b9ccdc5aScth mode_t old_mode;
15097c478bd9Sstevel@tonic-gate
15107c478bd9Sstevel@tonic-gate rw_enter(&ddv->dv_contents, RW_WRITER);
1511aac43a5fSjg for (dv = DV_FIRST_ENTRY(ddv); dv; dv = DV_NEXT_ENTRY(ddv, dv)) {
15127c478bd9Sstevel@tonic-gate int error = 0;
15137c478bd9Sstevel@tonic-gate nm = dv->dv_name;
15147c478bd9Sstevel@tonic-gate
15157c478bd9Sstevel@tonic-gate rw_enter(&dv->dv_contents, RW_READER);
15167c478bd9Sstevel@tonic-gate vp = DVTOV(dv);
15177c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) {
15187c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
15197c478bd9Sstevel@tonic-gate if (dv_reset_perm_dir(dv, flags) != 0) {
15207c478bd9Sstevel@tonic-gate error = EBUSY;
15217c478bd9Sstevel@tonic-gate }
15227c478bd9Sstevel@tonic-gate } else {
15237c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VCHR || vp->v_type == VBLK);
15247c478bd9Sstevel@tonic-gate
15257c478bd9Sstevel@tonic-gate /*
15267c478bd9Sstevel@tonic-gate * Check for permissions from minor_perm
15277c478bd9Sstevel@tonic-gate * If there are none, we're done
15287c478bd9Sstevel@tonic-gate */
15297c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
15307c478bd9Sstevel@tonic-gate if (dev_minorperm(dv->dv_devi, nm, &mp) != 0)
15317c478bd9Sstevel@tonic-gate continue;
15327c478bd9Sstevel@tonic-gate
15337c478bd9Sstevel@tonic-gate rw_enter(&dv->dv_contents, RW_READER);
15347c478bd9Sstevel@tonic-gate
15357c478bd9Sstevel@tonic-gate /*
15367c478bd9Sstevel@tonic-gate * Allow a node's permissions to be altered
15377c478bd9Sstevel@tonic-gate * permanently from the defaults by chmod,
15387c478bd9Sstevel@tonic-gate * using the shadow node as backing store.
15397c478bd9Sstevel@tonic-gate * Otherwise, update node to minor_perm permissions.
15407c478bd9Sstevel@tonic-gate */
15417c478bd9Sstevel@tonic-gate if (dv->dv_attrvp == NULLVP) {
15427c478bd9Sstevel@tonic-gate /*
15437c478bd9Sstevel@tonic-gate * No attribute vp, try to find one.
15447c478bd9Sstevel@tonic-gate */
15457c478bd9Sstevel@tonic-gate dv_shadow_node(DVTOV(ddv), nm, vp,
1546aac43a5fSjg NULL, NULLVP, kcred, 0);
15477c478bd9Sstevel@tonic-gate }
15487c478bd9Sstevel@tonic-gate if (dv->dv_attrvp != NULLVP || dv->dv_attr == NULL) {
15497c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
15507c478bd9Sstevel@tonic-gate continue;
15517c478bd9Sstevel@tonic-gate }
15527c478bd9Sstevel@tonic-gate
15537c478bd9Sstevel@tonic-gate attrp = dv->dv_attr;
15547c478bd9Sstevel@tonic-gate
15557c478bd9Sstevel@tonic-gate if (VATTRP_MP_CMP(attrp, mp) == 0) {
15567c478bd9Sstevel@tonic-gate dcmn_err5(("%s: no perm change: "
15577c478bd9Sstevel@tonic-gate "%d %d 0%o\n", nm, attrp->va_uid,
15587c478bd9Sstevel@tonic-gate attrp->va_gid, attrp->va_mode));
15597c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
15607c478bd9Sstevel@tonic-gate continue;
15617c478bd9Sstevel@tonic-gate }
15627c478bd9Sstevel@tonic-gate
15637c478bd9Sstevel@tonic-gate old_uid = attrp->va_uid;
15647c478bd9Sstevel@tonic-gate old_gid = attrp->va_gid;
15657c478bd9Sstevel@tonic-gate old_mode = attrp->va_mode;
15667c478bd9Sstevel@tonic-gate
15677c478bd9Sstevel@tonic-gate VATTRP_MP_MERGE(attrp, mp);
15687c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock);
15697c478bd9Sstevel@tonic-gate if (vp->v_count > 0) {
15707c478bd9Sstevel@tonic-gate error = EBUSY;
15717c478bd9Sstevel@tonic-gate }
15727c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock);
15737c478bd9Sstevel@tonic-gate
15747c478bd9Sstevel@tonic-gate dcmn_err5(("%s: perm %d/%d/0%o -> %d/%d/0%o (%d)\n",
15757c478bd9Sstevel@tonic-gate nm, old_uid, old_gid, old_mode, attrp->va_uid,
15767c478bd9Sstevel@tonic-gate attrp->va_gid, attrp->va_mode, error));
15777c478bd9Sstevel@tonic-gate
15787c478bd9Sstevel@tonic-gate rw_exit(&dv->dv_contents);
15797c478bd9Sstevel@tonic-gate }
15807c478bd9Sstevel@tonic-gate
15817c478bd9Sstevel@tonic-gate if (error != 0) {
15827c478bd9Sstevel@tonic-gate retval = error;
15837c478bd9Sstevel@tonic-gate }
15847c478bd9Sstevel@tonic-gate }
15857c478bd9Sstevel@tonic-gate
15867c478bd9Sstevel@tonic-gate ddv->dv_flags |= DV_BUILD;
15877c478bd9Sstevel@tonic-gate
15887c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
15897c478bd9Sstevel@tonic-gate
15907c478bd9Sstevel@tonic-gate return (retval);
15917c478bd9Sstevel@tonic-gate }
15927c478bd9Sstevel@tonic-gate
15937c478bd9Sstevel@tonic-gate int
devfs_reset_perm(uint_t flags)15947c478bd9Sstevel@tonic-gate devfs_reset_perm(uint_t flags)
15957c478bd9Sstevel@tonic-gate {
1596b9ccdc5aScth struct dv_node *dvp;
1597b9ccdc5aScth int rval;
15987c478bd9Sstevel@tonic-gate
15997c478bd9Sstevel@tonic-gate if ((dvp = devfs_dip_to_dvnode(ddi_root_node())) == NULL)
16007c478bd9Sstevel@tonic-gate return (0);
16017c478bd9Sstevel@tonic-gate
16027c478bd9Sstevel@tonic-gate VN_HOLD(DVTOV(dvp));
16037c478bd9Sstevel@tonic-gate rval = dv_reset_perm_dir(dvp, flags);
16047c478bd9Sstevel@tonic-gate VN_RELE(DVTOV(dvp));
16057c478bd9Sstevel@tonic-gate return (rval);
16067c478bd9Sstevel@tonic-gate }
16077c478bd9Sstevel@tonic-gate
16087c478bd9Sstevel@tonic-gate /*
16097c478bd9Sstevel@tonic-gate * Clean up dangling devfs shadow nodes for removed
16107c478bd9Sstevel@tonic-gate * drivers so that, in the event the driver is re-added
16117c478bd9Sstevel@tonic-gate * to the system, newly created nodes won't incorrectly
16127c478bd9Sstevel@tonic-gate * pick up these stale shadow node permissions.
16137c478bd9Sstevel@tonic-gate *
16147c478bd9Sstevel@tonic-gate * This is accomplished by walking down the pathname
16157c478bd9Sstevel@tonic-gate * to the directory, starting at the root's attribute
16167c478bd9Sstevel@tonic-gate * node, then removing all minors matching the specified
16177c478bd9Sstevel@tonic-gate * node name. Care must be taken to remove all entries
16187c478bd9Sstevel@tonic-gate * in a directory before the directory itself, so that
16197c478bd9Sstevel@tonic-gate * the clean-up associated with rem_drv'ing a nexus driver
16207c478bd9Sstevel@tonic-gate * does not inadvertently result in an inconsistent
16217c478bd9Sstevel@tonic-gate * filesystem underlying devfs.
16227c478bd9Sstevel@tonic-gate */
16237c478bd9Sstevel@tonic-gate
16247c478bd9Sstevel@tonic-gate static int
devfs_remdrv_rmdir(vnode_t * dirvp,const char * dir,vnode_t * rvp)16250466df59Sjg devfs_remdrv_rmdir(vnode_t *dirvp, const char *dir, vnode_t *rvp)
16267c478bd9Sstevel@tonic-gate {
1627b9ccdc5aScth int error;
1628b9ccdc5aScth vnode_t *vp;
1629b9ccdc5aScth int eof;
1630b9ccdc5aScth struct iovec iov;
1631b9ccdc5aScth struct uio uio;
1632b9ccdc5aScth struct dirent64 *dp;
1633b9ccdc5aScth dirent64_t *dbuf;
1634b9ccdc5aScth size_t dlen;
1635b9ccdc5aScth size_t dbuflen;
1636b9ccdc5aScth int ndirents = 64;
1637b9ccdc5aScth char *nm;
16387c478bd9Sstevel@tonic-gate
16397c478bd9Sstevel@tonic-gate VN_HOLD(dirvp);
16407c478bd9Sstevel@tonic-gate
16417c478bd9Sstevel@tonic-gate dlen = ndirents * (sizeof (*dbuf));
16427c478bd9Sstevel@tonic-gate dbuf = kmem_alloc(dlen, KM_SLEEP);
16437c478bd9Sstevel@tonic-gate
16447c478bd9Sstevel@tonic-gate uio.uio_iov = &iov;
16457c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1;
16467c478bd9Sstevel@tonic-gate uio.uio_segflg = UIO_SYSSPACE;
16477c478bd9Sstevel@tonic-gate uio.uio_fmode = 0;
16487c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED;
16497c478bd9Sstevel@tonic-gate uio.uio_loffset = 0;
16507c478bd9Sstevel@tonic-gate uio.uio_llimit = MAXOFFSET_T;
16517c478bd9Sstevel@tonic-gate
16527c478bd9Sstevel@tonic-gate eof = 0;
16537c478bd9Sstevel@tonic-gate error = 0;
16547c478bd9Sstevel@tonic-gate while (!error && !eof) {
16557c478bd9Sstevel@tonic-gate uio.uio_resid = dlen;
16567c478bd9Sstevel@tonic-gate iov.iov_base = (char *)dbuf;
16577c478bd9Sstevel@tonic-gate iov.iov_len = dlen;
16587c478bd9Sstevel@tonic-gate
16597c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(dirvp, V_WRITELOCK_FALSE, NULL);
1660da6c28aaSamw error = VOP_READDIR(dirvp, &uio, kcred, &eof, NULL, 0);
16617c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(dirvp, V_WRITELOCK_FALSE, NULL);
16627c478bd9Sstevel@tonic-gate
16637c478bd9Sstevel@tonic-gate dbuflen = dlen - uio.uio_resid;
16647c478bd9Sstevel@tonic-gate
16657c478bd9Sstevel@tonic-gate if (error || dbuflen == 0)
16667c478bd9Sstevel@tonic-gate break;
16677c478bd9Sstevel@tonic-gate
16687c478bd9Sstevel@tonic-gate for (dp = dbuf; ((intptr_t)dp < (intptr_t)dbuf + dbuflen);
1669aac43a5fSjg dp = (dirent64_t *)((intptr_t)dp + dp->d_reclen)) {
16707c478bd9Sstevel@tonic-gate
16717c478bd9Sstevel@tonic-gate nm = dp->d_name;
16727c478bd9Sstevel@tonic-gate
16737c478bd9Sstevel@tonic-gate if (strcmp(nm, ".") == 0 || strcmp(nm, "..") == 0)
16747c478bd9Sstevel@tonic-gate continue;
16757c478bd9Sstevel@tonic-gate
1676da6c28aaSamw error = VOP_LOOKUP(dirvp, nm,
1677da6c28aaSamw &vp, NULL, 0, NULL, kcred, NULL, NULL, NULL);
16787c478bd9Sstevel@tonic-gate
16797c478bd9Sstevel@tonic-gate dsysdebug(error,
16807c478bd9Sstevel@tonic-gate ("rem_drv %s/%s lookup (%d)\n",
16817c478bd9Sstevel@tonic-gate dir, nm, error));
16827c478bd9Sstevel@tonic-gate
16837c478bd9Sstevel@tonic-gate if (error)
16847c478bd9Sstevel@tonic-gate continue;
16857c478bd9Sstevel@tonic-gate
16867c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VDIR ||
1687aac43a5fSjg vp->v_type == VCHR || vp->v_type == VBLK);
16887c478bd9Sstevel@tonic-gate
16897c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) {
16900466df59Sjg error = devfs_remdrv_rmdir(vp, nm, rvp);
16917c478bd9Sstevel@tonic-gate if (error == 0) {
16927c478bd9Sstevel@tonic-gate error = VOP_RMDIR(dirvp,
1693da6c28aaSamw (char *)nm, rvp, kcred, NULL, 0);
16947c478bd9Sstevel@tonic-gate dsysdebug(error,
16957c478bd9Sstevel@tonic-gate ("rem_drv %s/%s rmdir (%d)\n",
16967c478bd9Sstevel@tonic-gate dir, nm, error));
16977c478bd9Sstevel@tonic-gate }
16987c478bd9Sstevel@tonic-gate } else {
1699da6c28aaSamw error = VOP_REMOVE(dirvp, (char *)nm, kcred,
1700da6c28aaSamw NULL, 0);
17017c478bd9Sstevel@tonic-gate dsysdebug(error,
17027c478bd9Sstevel@tonic-gate ("rem_drv %s/%s remove (%d)\n",
17037c478bd9Sstevel@tonic-gate dir, nm, error));
17047c478bd9Sstevel@tonic-gate }
17057c478bd9Sstevel@tonic-gate
17067c478bd9Sstevel@tonic-gate VN_RELE(vp);
17077c478bd9Sstevel@tonic-gate if (error) {
17087c478bd9Sstevel@tonic-gate goto exit;
17097c478bd9Sstevel@tonic-gate }
17107c478bd9Sstevel@tonic-gate }
17117c478bd9Sstevel@tonic-gate }
17127c478bd9Sstevel@tonic-gate
17137c478bd9Sstevel@tonic-gate exit:
17147c478bd9Sstevel@tonic-gate VN_RELE(dirvp);
17157c478bd9Sstevel@tonic-gate kmem_free(dbuf, dlen);
17167c478bd9Sstevel@tonic-gate
17177c478bd9Sstevel@tonic-gate return (error);
17187c478bd9Sstevel@tonic-gate }
17197c478bd9Sstevel@tonic-gate
17207c478bd9Sstevel@tonic-gate int
devfs_remdrv_cleanup(const char * dir,const char * nodename)17217c478bd9Sstevel@tonic-gate devfs_remdrv_cleanup(const char *dir, const char *nodename)
17227c478bd9Sstevel@tonic-gate {
1723b9ccdc5aScth int error;
1724b9ccdc5aScth vnode_t *vp;
1725b9ccdc5aScth vnode_t *dirvp;
1726b9ccdc5aScth int eof;
1727b9ccdc5aScth struct iovec iov;
1728b9ccdc5aScth struct uio uio;
1729b9ccdc5aScth struct dirent64 *dp;
1730b9ccdc5aScth dirent64_t *dbuf;
1731b9ccdc5aScth size_t dlen;
1732b9ccdc5aScth size_t dbuflen;
1733b9ccdc5aScth int ndirents = 64;
1734b9ccdc5aScth int nodenamelen = strlen(nodename);
1735b9ccdc5aScth char *nm;
1736b9ccdc5aScth struct pathname pn;
1737b9ccdc5aScth vnode_t *rvp; /* root node of the underlying attribute fs */
17387c478bd9Sstevel@tonic-gate
17397c478bd9Sstevel@tonic-gate dcmn_err5(("devfs_remdrv_cleanup: %s %s\n", dir, nodename));
17407c478bd9Sstevel@tonic-gate
17417c478bd9Sstevel@tonic-gate if (error = pn_get((char *)dir, UIO_SYSSPACE, &pn))
17427c478bd9Sstevel@tonic-gate return (0);
17437c478bd9Sstevel@tonic-gate
17440466df59Sjg rvp = dvroot->dv_attrvp;
17450466df59Sjg ASSERT(rvp != NULL);
17460466df59Sjg VN_HOLD(rvp);
17477c478bd9Sstevel@tonic-gate
17487c478bd9Sstevel@tonic-gate pn_skipslash(&pn);
17490466df59Sjg dirvp = rvp;
17507c478bd9Sstevel@tonic-gate VN_HOLD(dirvp);
17517c478bd9Sstevel@tonic-gate
17527c478bd9Sstevel@tonic-gate nm = kmem_alloc(MAXNAMELEN, KM_SLEEP);
17537c478bd9Sstevel@tonic-gate
17547c478bd9Sstevel@tonic-gate while (pn_pathleft(&pn)) {
17557c478bd9Sstevel@tonic-gate ASSERT(dirvp->v_type == VDIR);
17567c478bd9Sstevel@tonic-gate (void) pn_getcomponent(&pn, nm);
17577c478bd9Sstevel@tonic-gate ASSERT((strcmp(nm, ".") != 0) && (strcmp(nm, "..") != 0));
1758da6c28aaSamw error = VOP_LOOKUP(dirvp, nm, &vp, NULL, 0, rvp, kcred,
1759da6c28aaSamw NULL, NULL, NULL);
17607c478bd9Sstevel@tonic-gate if (error) {
17617c478bd9Sstevel@tonic-gate dcmn_err5(("remdrv_cleanup %s lookup error %d\n",
17627c478bd9Sstevel@tonic-gate nm, error));
17637c478bd9Sstevel@tonic-gate VN_RELE(dirvp);
17640466df59Sjg if (dirvp != rvp)
17650466df59Sjg VN_RELE(rvp);
17667c478bd9Sstevel@tonic-gate pn_free(&pn);
17677c478bd9Sstevel@tonic-gate kmem_free(nm, MAXNAMELEN);
17687c478bd9Sstevel@tonic-gate return (0);
17697c478bd9Sstevel@tonic-gate }
17707c478bd9Sstevel@tonic-gate VN_RELE(dirvp);
17717c478bd9Sstevel@tonic-gate dirvp = vp;
17727c478bd9Sstevel@tonic-gate pn_skipslash(&pn);
17737c478bd9Sstevel@tonic-gate }
17747c478bd9Sstevel@tonic-gate
17757c478bd9Sstevel@tonic-gate ASSERT(dirvp->v_type == VDIR);
17760466df59Sjg if (dirvp != rvp)
17770466df59Sjg VN_RELE(rvp);
17787c478bd9Sstevel@tonic-gate pn_free(&pn);
17797c478bd9Sstevel@tonic-gate kmem_free(nm, MAXNAMELEN);
17807c478bd9Sstevel@tonic-gate
17817c478bd9Sstevel@tonic-gate dlen = ndirents * (sizeof (*dbuf));
17827c478bd9Sstevel@tonic-gate dbuf = kmem_alloc(dlen, KM_SLEEP);
17837c478bd9Sstevel@tonic-gate
17847c478bd9Sstevel@tonic-gate uio.uio_iov = &iov;
17857c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1;
17867c478bd9Sstevel@tonic-gate uio.uio_segflg = UIO_SYSSPACE;
17877c478bd9Sstevel@tonic-gate uio.uio_fmode = 0;
17887c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED;
17897c478bd9Sstevel@tonic-gate uio.uio_loffset = 0;
17907c478bd9Sstevel@tonic-gate uio.uio_llimit = MAXOFFSET_T;
17917c478bd9Sstevel@tonic-gate
17927c478bd9Sstevel@tonic-gate eof = 0;
17937c478bd9Sstevel@tonic-gate error = 0;
17947c478bd9Sstevel@tonic-gate while (!error && !eof) {
17957c478bd9Sstevel@tonic-gate uio.uio_resid = dlen;
17967c478bd9Sstevel@tonic-gate iov.iov_base = (char *)dbuf;
17977c478bd9Sstevel@tonic-gate iov.iov_len = dlen;
17987c478bd9Sstevel@tonic-gate
17997c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(dirvp, V_WRITELOCK_FALSE, NULL);
1800da6c28aaSamw error = VOP_READDIR(dirvp, &uio, kcred, &eof, NULL, 0);
18017c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(dirvp, V_WRITELOCK_FALSE, NULL);
18027c478bd9Sstevel@tonic-gate
18037c478bd9Sstevel@tonic-gate dbuflen = dlen - uio.uio_resid;
18047c478bd9Sstevel@tonic-gate
18057c478bd9Sstevel@tonic-gate if (error || dbuflen == 0)
18067c478bd9Sstevel@tonic-gate break;
18077c478bd9Sstevel@tonic-gate
18087c478bd9Sstevel@tonic-gate for (dp = dbuf; ((intptr_t)dp < (intptr_t)dbuf + dbuflen);
1809aac43a5fSjg dp = (dirent64_t *)((intptr_t)dp + dp->d_reclen)) {
18107c478bd9Sstevel@tonic-gate
18117c478bd9Sstevel@tonic-gate nm = dp->d_name;
18127c478bd9Sstevel@tonic-gate
18137c478bd9Sstevel@tonic-gate if (strcmp(nm, ".") == 0 || strcmp(nm, "..") == 0)
18147c478bd9Sstevel@tonic-gate continue;
18157c478bd9Sstevel@tonic-gate
18167c478bd9Sstevel@tonic-gate if (strncmp(nm, nodename, nodenamelen) != 0)
18177c478bd9Sstevel@tonic-gate continue;
18187c478bd9Sstevel@tonic-gate
18197c478bd9Sstevel@tonic-gate error = VOP_LOOKUP(dirvp, nm, &vp,
1820da6c28aaSamw NULL, 0, NULL, kcred, NULL, NULL, NULL);
18217c478bd9Sstevel@tonic-gate
18227c478bd9Sstevel@tonic-gate dsysdebug(error,
18237c478bd9Sstevel@tonic-gate ("rem_drv %s/%s lookup (%d)\n",
18247c478bd9Sstevel@tonic-gate dir, nm, error));
18257c478bd9Sstevel@tonic-gate
18267c478bd9Sstevel@tonic-gate if (error)
18277c478bd9Sstevel@tonic-gate continue;
18287c478bd9Sstevel@tonic-gate
18297c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VDIR ||
1830aac43a5fSjg vp->v_type == VCHR || vp->v_type == VBLK);
18317c478bd9Sstevel@tonic-gate
18327c478bd9Sstevel@tonic-gate if (vp->v_type == VDIR) {
18330466df59Sjg error = devfs_remdrv_rmdir(vp, nm, rvp);
18347c478bd9Sstevel@tonic-gate if (error == 0) {
1835da6c28aaSamw error = VOP_RMDIR(dirvp, (char *)nm,
1836da6c28aaSamw rvp, kcred, NULL, 0);
18377c478bd9Sstevel@tonic-gate dsysdebug(error,
18387c478bd9Sstevel@tonic-gate ("rem_drv %s/%s rmdir (%d)\n",
18397c478bd9Sstevel@tonic-gate dir, nm, error));
18407c478bd9Sstevel@tonic-gate }
18417c478bd9Sstevel@tonic-gate } else {
1842da6c28aaSamw error = VOP_REMOVE(dirvp, (char *)nm, kcred,
1843da6c28aaSamw NULL, 0);
18447c478bd9Sstevel@tonic-gate dsysdebug(error,
18457c478bd9Sstevel@tonic-gate ("rem_drv %s/%s remove (%d)\n",
18467c478bd9Sstevel@tonic-gate dir, nm, error));
18477c478bd9Sstevel@tonic-gate }
18487c478bd9Sstevel@tonic-gate
18497c478bd9Sstevel@tonic-gate VN_RELE(vp);
18507c478bd9Sstevel@tonic-gate if (error)
18517c478bd9Sstevel@tonic-gate goto exit;
18527c478bd9Sstevel@tonic-gate }
18537c478bd9Sstevel@tonic-gate }
18547c478bd9Sstevel@tonic-gate
18557c478bd9Sstevel@tonic-gate exit:
18567c478bd9Sstevel@tonic-gate VN_RELE(dirvp);
18577c478bd9Sstevel@tonic-gate
18587c478bd9Sstevel@tonic-gate kmem_free(dbuf, dlen);
18597c478bd9Sstevel@tonic-gate
18607c478bd9Sstevel@tonic-gate return (0);
18617c478bd9Sstevel@tonic-gate }
18627c478bd9Sstevel@tonic-gate
18637c478bd9Sstevel@tonic-gate struct dv_list {
18647c478bd9Sstevel@tonic-gate struct dv_node *dv;
18657c478bd9Sstevel@tonic-gate struct dv_list *next;
18667c478bd9Sstevel@tonic-gate };
18677c478bd9Sstevel@tonic-gate
18687c478bd9Sstevel@tonic-gate void
dv_walk(struct dv_node * ddv,char * devnm,void (* callback)(struct dv_node *,void *),void * arg)18697c478bd9Sstevel@tonic-gate dv_walk(
18707c478bd9Sstevel@tonic-gate struct dv_node *ddv,
18717c478bd9Sstevel@tonic-gate char *devnm,
18727c478bd9Sstevel@tonic-gate void (*callback)(struct dv_node *, void *),
18737c478bd9Sstevel@tonic-gate void *arg)
18747c478bd9Sstevel@tonic-gate {
18757c478bd9Sstevel@tonic-gate struct vnode *dvp;
18767c478bd9Sstevel@tonic-gate struct dv_node *dv;
18777c478bd9Sstevel@tonic-gate struct dv_list *head, *tail, *next;
187845a9d961Scth int len;
18797c478bd9Sstevel@tonic-gate
18807c478bd9Sstevel@tonic-gate dcmn_err3(("dv_walk: ddv = %s, devnm = %s\n",
18817c478bd9Sstevel@tonic-gate ddv->dv_name, devnm ? devnm : "<null>"));
18827c478bd9Sstevel@tonic-gate
18837c478bd9Sstevel@tonic-gate dvp = DVTOV(ddv);
18847c478bd9Sstevel@tonic-gate
18857c478bd9Sstevel@tonic-gate ASSERT(dvp->v_type == VDIR);
18867c478bd9Sstevel@tonic-gate
18877c478bd9Sstevel@tonic-gate head = tail = next = NULL;
18887c478bd9Sstevel@tonic-gate
18897c478bd9Sstevel@tonic-gate rw_enter(&ddv->dv_contents, RW_READER);
189045a9d961Scth mutex_enter(&dvp->v_lock);
1891aac43a5fSjg for (dv = DV_FIRST_ENTRY(ddv); dv; dv = DV_NEXT_ENTRY(ddv, dv)) {
18927c478bd9Sstevel@tonic-gate /*
18937c478bd9Sstevel@tonic-gate * If devnm is not NULL and is not the empty string,
18947c478bd9Sstevel@tonic-gate * select only dv_nodes with matching non-minor name
18957c478bd9Sstevel@tonic-gate */
18967c478bd9Sstevel@tonic-gate if (devnm && (len = strlen(devnm)) &&
18977c478bd9Sstevel@tonic-gate (strncmp(devnm, dv->dv_name, len) ||
18987c478bd9Sstevel@tonic-gate (dv->dv_name[len] != ':' && dv->dv_name[len] != '\0')))
18997c478bd9Sstevel@tonic-gate continue;
19007c478bd9Sstevel@tonic-gate
19017c478bd9Sstevel@tonic-gate callback(dv, arg);
19027c478bd9Sstevel@tonic-gate
19037c478bd9Sstevel@tonic-gate if (DVTOV(dv)->v_type != VDIR)
19047c478bd9Sstevel@tonic-gate continue;
19057c478bd9Sstevel@tonic-gate
19067c478bd9Sstevel@tonic-gate next = kmem_zalloc(sizeof (*next), KM_SLEEP);
19077c478bd9Sstevel@tonic-gate next->dv = dv;
19087c478bd9Sstevel@tonic-gate
19097c478bd9Sstevel@tonic-gate if (tail)
19107c478bd9Sstevel@tonic-gate tail->next = next;
19117c478bd9Sstevel@tonic-gate else
19127c478bd9Sstevel@tonic-gate head = next;
19137c478bd9Sstevel@tonic-gate
19147c478bd9Sstevel@tonic-gate tail = next;
19157c478bd9Sstevel@tonic-gate }
19167c478bd9Sstevel@tonic-gate
19177c478bd9Sstevel@tonic-gate while (head) {
19187c478bd9Sstevel@tonic-gate dv_walk(head->dv, NULL, callback, arg);
19197c478bd9Sstevel@tonic-gate next = head->next;
19207c478bd9Sstevel@tonic-gate kmem_free(head, sizeof (*head));
19217c478bd9Sstevel@tonic-gate head = next;
19227c478bd9Sstevel@tonic-gate }
19237c478bd9Sstevel@tonic-gate rw_exit(&ddv->dv_contents);
19247c478bd9Sstevel@tonic-gate mutex_exit(&dvp->v_lock);
19257c478bd9Sstevel@tonic-gate }
1926