137488Smckusick /* 263180Sbostic * Copyright (c) 1989, 1993 363180Sbostic * The Regents of the University of California. All rights reserved. 465771Sbostic * (c) UNIX System Laboratories, Inc. 565771Sbostic * All or some portions of this file are derived from material licensed 665771Sbostic * to the University of California by American Telephone and Telegraph 765771Sbostic * Co. or Unix System Laboratories, Inc. and are reproduced herein with 865771Sbostic * the permission of UNIX System Laboratories, Inc. 937488Smckusick * 1044458Sbostic * %sccs.include.redist.c% 1137488Smckusick * 12*69523Spendry * @(#)vfs_subr.c 8.25 (Berkeley) 05/17/95 1337488Smckusick */ 1437488Smckusick 1537488Smckusick /* 1637488Smckusick * External virtual filesystem routines 1737488Smckusick */ 1837488Smckusick 1951460Sbostic #include <sys/param.h> 2053829Spendry #include <sys/systm.h> 2151460Sbostic #include <sys/proc.h> 2251460Sbostic #include <sys/mount.h> 2351460Sbostic #include <sys/time.h> 2451460Sbostic #include <sys/vnode.h> 2552415Smckusick #include <sys/stat.h> 2651460Sbostic #include <sys/namei.h> 2751460Sbostic #include <sys/ucred.h> 2851460Sbostic #include <sys/buf.h> 2951460Sbostic #include <sys/errno.h> 3051460Sbostic #include <sys/malloc.h> 3165679Shibler #include <sys/domain.h> 3265679Shibler #include <sys/mbuf.h> 3337488Smckusick 3460930Smckusick #include <vm/vm.h> 3560930Smckusick #include <sys/sysctl.h> 3660930Smckusick 3755050Spendry #include <miscfs/specfs/specdev.h> 3855050Spendry 3952415Smckusick enum vtype iftovt_tab[16] = { 4052415Smckusick VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, 4152415Smckusick VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, 4252415Smckusick }; 4352415Smckusick int vttoif_tab[9] = { 4452415Smckusick 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, 4552415Smckusick S_IFSOCK, S_IFIFO, S_IFMT, 4652415Smckusick }; 4752415Smckusick 4837488Smckusick /* 4956608Smckusick * Insq/Remq for the vnode usage lists. 5056608Smckusick */ 5165260Smckusick #define bufinsvn(bp, dp) LIST_INSERT_HEAD(dp, bp, b_vnbufs) 5268319Scgd #define bufremvn(bp) { \ 5368319Scgd LIST_REMOVE(bp, b_vnbufs); \ 5468319Scgd (bp)->b_vnbufs.le_next = NOLIST; \ 5565260Smckusick } 5665260Smckusick TAILQ_HEAD(freelst, vnode) vnode_free_list; /* vnode free list */ 5765260Smckusick struct mntlist mountlist; /* mounted filesystem list */ 5869408Smckusick static struct simplelock mntid_slock; 5969408Smckusick struct simplelock mntvnode_slock; 6069408Smckusick static struct simplelock spechash_slock; 6169408Smckusick static struct simplelock vnode_free_list_slock; 6265260Smckusick 6356608Smckusick /* 6465260Smckusick * Initialize the vnode management data structures. 6537488Smckusick */ 6668319Scgd void 6765260Smckusick vntblinit() 6837488Smckusick { 6937488Smckusick 7069408Smckusick simple_lock_init(&mntvnode_slock); 7169408Smckusick simple_lock_init(&mntid_slock); 7269408Smckusick simple_lock_init(&spechash_slock); 7365260Smckusick TAILQ_INIT(&vnode_free_list); 7469408Smckusick simple_lock_init(&vnode_free_list_slock); 7569325Smckusick CIRCLEQ_INIT(&mountlist); 7637488Smckusick } 7737488Smckusick 7837488Smckusick /* 7937488Smckusick * Lock a filesystem. 8037488Smckusick * Used to prevent access to it while mounting and unmounting. 8137488Smckusick */ 8268319Scgd int 8337488Smckusick vfs_lock(mp) 8437488Smckusick register struct mount *mp; 8537488Smckusick { 8637488Smckusick 8768319Scgd while (mp->mnt_flag & MNT_MLOCK) { 8841400Smckusick mp->mnt_flag |= MNT_MWAIT; 8968319Scgd tsleep((caddr_t)mp, PVFS, "vfslock", 0); 9039045Smckusick } 9141400Smckusick mp->mnt_flag |= MNT_MLOCK; 9237488Smckusick return (0); 9337488Smckusick } 9437488Smckusick 9537488Smckusick /* 9637488Smckusick * Unlock a locked filesystem. 9737488Smckusick * Panic if filesystem is not locked. 9837488Smckusick */ 9937488Smckusick void 10037488Smckusick vfs_unlock(mp) 10137488Smckusick register struct mount *mp; 10237488Smckusick { 10337488Smckusick 10441400Smckusick if ((mp->mnt_flag & MNT_MLOCK) == 0) 10541300Smckusick panic("vfs_unlock: not locked"); 10641400Smckusick mp->mnt_flag &= ~MNT_MLOCK; 10741400Smckusick if (mp->mnt_flag & MNT_MWAIT) { 10841400Smckusick mp->mnt_flag &= ~MNT_MWAIT; 10937488Smckusick wakeup((caddr_t)mp); 11037488Smckusick } 11137488Smckusick } 11237488Smckusick 11337488Smckusick /* 11441300Smckusick * Mark a mount point as busy. 11541300Smckusick * Used to synchronize access and to delay unmounting. 11641300Smckusick */ 11768319Scgd int 11841300Smckusick vfs_busy(mp) 11941300Smckusick register struct mount *mp; 12041300Smckusick { 12141300Smckusick 12268319Scgd while (mp->mnt_flag & MNT_MPBUSY) { 12341400Smckusick mp->mnt_flag |= MNT_MPWANT; 12468319Scgd tsleep((caddr_t)&mp->mnt_flag, PVFS, "vfsbusy", 0); 12541300Smckusick } 12641419Smckusick if (mp->mnt_flag & MNT_UNMOUNT) 12741419Smckusick return (1); 12841400Smckusick mp->mnt_flag |= MNT_MPBUSY; 12941300Smckusick return (0); 13041300Smckusick } 13141300Smckusick 13241300Smckusick /* 13341300Smckusick * Free a busy filesystem. 13441300Smckusick * Panic if filesystem is not busy. 13541300Smckusick */ 13668319Scgd void 13741300Smckusick vfs_unbusy(mp) 13841300Smckusick register struct mount *mp; 13941300Smckusick { 14041300Smckusick 14141400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 14241300Smckusick panic("vfs_unbusy: not busy"); 14341400Smckusick mp->mnt_flag &= ~MNT_MPBUSY; 14441400Smckusick if (mp->mnt_flag & MNT_MPWANT) { 14541400Smckusick mp->mnt_flag &= ~MNT_MPWANT; 14641400Smckusick wakeup((caddr_t)&mp->mnt_flag); 14741300Smckusick } 14841300Smckusick } 14941300Smckusick 15041300Smckusick /* 15169378Smckusick * Lookup a filesystem type, and if found allocate and initialize 15269378Smckusick * a mount structure for it. 15369378Smckusick * 15469378Smckusick * Devname is usually updated by mount(8) after booting. 15569378Smckusick */ 15669378Smckusick int 15769378Smckusick vfs_rootmountalloc(fstypename, devname, mpp) 15869378Smckusick char *fstypename; 15969378Smckusick char *devname; 16069378Smckusick struct mount **mpp; 16169378Smckusick { 16269378Smckusick struct vfsconf *vfsp; 16369378Smckusick struct mount *mp; 16469378Smckusick 16569378Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) 16669378Smckusick if (!strcmp(vfsp->vfc_name, fstypename)) 16769378Smckusick break; 16869378Smckusick if (vfsp == NULL) 16969378Smckusick return (ENODEV); 17069378Smckusick mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK); 17169378Smckusick bzero((char *)mp, (u_long)sizeof(struct mount)); 17269378Smckusick LIST_INIT(&mp->mnt_vnodelist); 17369378Smckusick mp->mnt_vfc = vfsp; 17469378Smckusick mp->mnt_op = vfsp->vfc_vfsops; 17569378Smckusick mp->mnt_flag = MNT_RDONLY; 17669378Smckusick mp->mnt_vnodecovered = NULLVP; 17769378Smckusick vfsp->vfc_refcount++; 17869378Smckusick mp->mnt_stat.f_type = vfsp->vfc_typenum; 17969378Smckusick mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK; 18069378Smckusick strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN); 18169378Smckusick mp->mnt_stat.f_mntonname[0] = '/'; 18269378Smckusick (void) copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0); 18369378Smckusick *mpp = mp; 18469378Smckusick return (0); 18569378Smckusick } 18669378Smckusick 18769378Smckusick /* 18869378Smckusick * Find an appropriate filesystem to use for the root. If a filesystem 18969378Smckusick * has not been preselected, walk through the list of known filesystems 19069378Smckusick * trying those that have mountroot routines, and try them until one 19169378Smckusick * works or we have tried them all. 19269378Smckusick */ 19369378Smckusick int 19469378Smckusick vfs_mountroot() 19569378Smckusick { 19669378Smckusick struct vfsconf *vfsp; 19769378Smckusick extern int (*mountroot)(void); 19869378Smckusick int error; 19969378Smckusick 20069378Smckusick if (mountroot != NULL) 20169378Smckusick return ((*vfsp->vfc_mountroot)()); 20269378Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) { 20369378Smckusick if (vfsp->vfc_mountroot == NULL) 20469378Smckusick continue; 20569378Smckusick if ((error = (*vfsp->vfc_mountroot)()) == 0) 20669378Smckusick return (0); 20769378Smckusick printf("%s_mountroot failed: %d\n", vfsp->vfc_name, error); 20869378Smckusick } 20969378Smckusick return (ENODEV); 21069378Smckusick } 21169378Smckusick 21269378Smckusick /* 21337488Smckusick * Lookup a mount point by filesystem identifier. 21437488Smckusick */ 21537488Smckusick struct mount * 21668659Smckusick vfs_getvfs(fsid) 21737488Smckusick fsid_t *fsid; 21837488Smckusick { 21937488Smckusick register struct mount *mp; 22037488Smckusick 22169325Smckusick for (mp = mountlist.cqh_first; mp != (void *)&mountlist; 22269325Smckusick mp = mp->mnt_list.cqe_next) { 22341400Smckusick if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && 22465260Smckusick mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) 22538288Smckusick return (mp); 22665260Smckusick } 22738288Smckusick return ((struct mount *)0); 22837488Smckusick } 22937488Smckusick 23037488Smckusick /* 23153829Spendry * Get a new unique fsid 23253829Spendry */ 23353829Spendry void 23468659Smckusick vfs_getnewfsid(mp) 23553829Spendry struct mount *mp; 23653829Spendry { 23753829Spendry static u_short xxxfs_mntid; 23853829Spendry 23953829Spendry fsid_t tfsid; 24068659Smckusick int mtype; 24153829Spendry 24269408Smckusick simple_lock(&mntid_slock); 24368659Smckusick mtype = mp->mnt_vfc->vfc_typenum; 24465507Spendry mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + mtype, 0); 24553829Spendry mp->mnt_stat.f_fsid.val[1] = mtype; 24653829Spendry if (xxxfs_mntid == 0) 24753829Spendry ++xxxfs_mntid; 24865507Spendry tfsid.val[0] = makedev(nblkdev + mtype, xxxfs_mntid); 24953829Spendry tfsid.val[1] = mtype; 25069325Smckusick if (mountlist.cqh_first != (void *)&mountlist) { 25168659Smckusick while (vfs_getvfs(&tfsid)) { 25253936Spendry tfsid.val[0]++; 25353936Spendry xxxfs_mntid++; 25453936Spendry } 25553829Spendry } 25653829Spendry mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; 25769408Smckusick simple_unlock(&mntid_slock); 25853829Spendry } 25953829Spendry 26053829Spendry /* 26137488Smckusick * Set vnode attributes to VNOVAL 26237488Smckusick */ 26368319Scgd void 26468319Scgd vattr_null(vap) 26537488Smckusick register struct vattr *vap; 26637488Smckusick { 26737488Smckusick 26837488Smckusick vap->va_type = VNON; 26952005Smckusick vap->va_size = vap->va_bytes = VNOVAL; 27037488Smckusick vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = 27152005Smckusick vap->va_fsid = vap->va_fileid = 27252005Smckusick vap->va_blocksize = vap->va_rdev = 27354347Smckusick vap->va_atime.ts_sec = vap->va_atime.ts_nsec = 27454347Smckusick vap->va_mtime.ts_sec = vap->va_mtime.ts_nsec = 27554347Smckusick vap->va_ctime.ts_sec = vap->va_ctime.ts_nsec = 27638258Smckusick vap->va_flags = vap->va_gen = VNOVAL; 27758548Sbostic vap->va_vaflags = 0; 27837488Smckusick } 27938265Smckusick 28038265Smckusick /* 28139397Smckusick * Routines having to do with the management of the vnode table. 28239397Smckusick */ 28353547Sheideman extern int (**dead_vnodeop_p)(); 28469408Smckusick static void vclean __P((struct vnode *vp, int flag, struct proc *p)); 28569408Smckusick extern void vgonel __P((struct vnode *vp, struct proc *p)); 28640883Smckusick long numvnodes; 28753493Sheideman extern struct vattr va_null; 28839397Smckusick 28939397Smckusick /* 29039397Smckusick * Return the next vnode from the free list. 29139397Smckusick */ 29268319Scgd int 29339397Smckusick getnewvnode(tag, mp, vops, vpp) 29439397Smckusick enum vtagtype tag; 29539397Smckusick struct mount *mp; 29653495Sheideman int (**vops)(); 29739397Smckusick struct vnode **vpp; 29839397Smckusick { 29969408Smckusick struct proc *p = curproc; /* XXX */ 30069408Smckusick struct vnode *vp; 30157042Smargo int s; 30269408Smckusick int cnt; 30339397Smckusick 30469408Smckusick top: 30569408Smckusick simple_lock(&vnode_free_list_slock); 30665260Smckusick if ((vnode_free_list.tqh_first == NULL && 30765260Smckusick numvnodes < 2 * desiredvnodes) || 30854347Smckusick numvnodes < desiredvnodes) { 30969408Smckusick simple_unlock(&vnode_free_list_slock); 31045118Smckusick vp = (struct vnode *)malloc((u_long)sizeof *vp, 31145118Smckusick M_VNODE, M_WAITOK); 31240883Smckusick bzero((char *)vp, sizeof *vp); 31340883Smckusick numvnodes++; 31440883Smckusick } else { 31569408Smckusick for (vp = vnode_free_list.tqh_first; 31669408Smckusick vp != NULLVP; vp = vp->v_freelist.tqe_next) { 31769408Smckusick if (simple_lock_try(&vp->v_interlock)) 31869408Smckusick break; 31969408Smckusick } 32069408Smckusick /* 32169408Smckusick * Unless this is a bad time of the month, at most 32269408Smckusick * the first NCPUS items on the free list are 32369408Smckusick * locked, so this is close enough to being empty. 32469408Smckusick */ 32569408Smckusick if (vp == NULLVP) { 32669408Smckusick simple_unlock(&vnode_free_list_slock); 32740883Smckusick tablefull("vnode"); 32840883Smckusick *vpp = 0; 32940883Smckusick return (ENFILE); 33040883Smckusick } 33140883Smckusick if (vp->v_usecount) 33240883Smckusick panic("free vnode isn't"); 33365260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 33465505Smckusick /* see comment on why 0xdeadb is set at end of vgone (below) */ 33565505Smckusick vp->v_freelist.tqe_prev = (struct vnode **)0xdeadb; 33669408Smckusick simple_unlock(&vnode_free_list_slock); 33752190Smckusick vp->v_lease = NULL; 33840883Smckusick if (vp->v_type != VBAD) 33969408Smckusick vgonel(vp, p); 34069408Smckusick else 34169408Smckusick simple_unlock(&vp->v_interlock); 34257042Smargo #ifdef DIAGNOSTIC 34352006Smckusick if (vp->v_data) 34452006Smckusick panic("cleaned vnode isn't"); 34557042Smargo s = splbio(); 34657042Smargo if (vp->v_numoutput) 34757042Smargo panic("Clean vnode has pending I/O's"); 34857042Smargo splx(s); 34957042Smargo #endif 35040883Smckusick vp->v_flag = 0; 35140883Smckusick vp->v_lastr = 0; 35265745Shibler vp->v_ralen = 0; 35365745Shibler vp->v_maxra = 0; 35457042Smargo vp->v_lastw = 0; 35557042Smargo vp->v_lasta = 0; 35657042Smargo vp->v_cstart = 0; 35757042Smargo vp->v_clen = 0; 35840883Smckusick vp->v_socket = 0; 35939397Smckusick } 36039512Smckusick vp->v_type = VNON; 36139397Smckusick cache_purge(vp); 36239397Smckusick vp->v_tag = tag; 36339433Smckusick vp->v_op = vops; 36439397Smckusick insmntque(vp, mp); 36539397Smckusick *vpp = vp; 36665505Smckusick vp->v_usecount = 1; 36765260Smckusick vp->v_data = 0; 36839397Smckusick return (0); 36939397Smckusick } 37065679Shibler 37139397Smckusick /* 37239397Smckusick * Move a vnode from one mount queue to another. 37339397Smckusick */ 37468319Scgd void 37539397Smckusick insmntque(vp, mp) 37669408Smckusick struct vnode *vp; 37769408Smckusick struct mount *mp; 37839397Smckusick { 37939397Smckusick 38069408Smckusick simple_lock(&mntvnode_slock); 38139397Smckusick /* 38239397Smckusick * Delete from old mount point vnode list, if on one. 38339397Smckusick */ 38465679Shibler if (vp->v_mount != NULL) 38565260Smckusick LIST_REMOVE(vp, v_mntvnodes); 38639397Smckusick /* 38739397Smckusick * Insert into list of vnodes for the new mount point, if available. 38839397Smckusick */ 38969408Smckusick if ((vp->v_mount = mp) != NULL) 39069408Smckusick LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes); 39169408Smckusick simple_unlock(&mntvnode_slock); 39239397Smckusick } 39339397Smckusick 39439397Smckusick /* 39549232Smckusick * Update outstanding I/O count and do wakeup if requested. 39649232Smckusick */ 39768319Scgd void 39849232Smckusick vwakeup(bp) 39949232Smckusick register struct buf *bp; 40049232Smckusick { 40149232Smckusick register struct vnode *vp; 40249232Smckusick 40357810Smckusick bp->b_flags &= ~B_WRITEINPROG; 40449232Smckusick if (vp = bp->b_vp) { 40568319Scgd if (--vp->v_numoutput < 0) 40657042Smargo panic("vwakeup: neg numoutput"); 40749232Smckusick if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { 40849232Smckusick if (vp->v_numoutput < 0) 40968319Scgd panic("vwakeup: neg numoutput 2"); 41049232Smckusick vp->v_flag &= ~VBWAIT; 41149232Smckusick wakeup((caddr_t)&vp->v_numoutput); 41249232Smckusick } 41349232Smckusick } 41449232Smckusick } 41549232Smckusick 41649232Smckusick /* 41749232Smckusick * Flush out and invalidate all buffers associated with a vnode. 41849232Smckusick * Called with the underlying object locked. 41949232Smckusick */ 42054442Smckusick int 42157792Smckusick vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) 42249232Smckusick register struct vnode *vp; 42356459Smargo int flags; 42454442Smckusick struct ucred *cred; 42554442Smckusick struct proc *p; 42657792Smckusick int slpflag, slptimeo; 42749232Smckusick { 42849232Smckusick register struct buf *bp; 42949232Smckusick struct buf *nbp, *blist; 43054442Smckusick int s, error; 43149232Smckusick 43256459Smargo if (flags & V_SAVE) { 43354442Smckusick if (error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) 43454442Smckusick return (error); 43565260Smckusick if (vp->v_dirtyblkhd.lh_first != NULL) 43654442Smckusick panic("vinvalbuf: dirty bufs"); 43754442Smckusick } 43849232Smckusick for (;;) { 43965260Smckusick if ((blist = vp->v_cleanblkhd.lh_first) && flags & V_SAVEMETA) 44056459Smargo while (blist && blist->b_lblkno < 0) 44165260Smckusick blist = blist->b_vnbufs.le_next; 44268319Scgd if (!blist && (blist = vp->v_dirtyblkhd.lh_first) && 44356608Smckusick (flags & V_SAVEMETA)) 44456459Smargo while (blist && blist->b_lblkno < 0) 44565260Smckusick blist = blist->b_vnbufs.le_next; 44656459Smargo if (!blist) 44749232Smckusick break; 44856459Smargo 44949232Smckusick for (bp = blist; bp; bp = nbp) { 45065260Smckusick nbp = bp->b_vnbufs.le_next; 45156459Smargo if (flags & V_SAVEMETA && bp->b_lblkno < 0) 45256459Smargo continue; 45349232Smckusick s = splbio(); 45449232Smckusick if (bp->b_flags & B_BUSY) { 45549232Smckusick bp->b_flags |= B_WANTED; 45657792Smckusick error = tsleep((caddr_t)bp, 45757792Smckusick slpflag | (PRIBIO + 1), "vinvalbuf", 45857792Smckusick slptimeo); 45949232Smckusick splx(s); 46057792Smckusick if (error) 46157792Smckusick return (error); 46249232Smckusick break; 46349232Smckusick } 46449232Smckusick bremfree(bp); 46549232Smckusick bp->b_flags |= B_BUSY; 46649232Smckusick splx(s); 46757792Smckusick /* 46857792Smckusick * XXX Since there are no node locks for NFS, I believe 46957792Smckusick * there is a slight chance that a delayed write will 47057792Smckusick * occur while sleeping just above, so check for it. 47157792Smckusick */ 47257792Smckusick if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) { 47357792Smckusick (void) VOP_BWRITE(bp); 47457792Smckusick break; 47557792Smckusick } 47656459Smargo bp->b_flags |= B_INVAL; 47749232Smckusick brelse(bp); 47849232Smckusick } 47949232Smckusick } 48056608Smckusick if (!(flags & V_SAVEMETA) && 48165260Smckusick (vp->v_dirtyblkhd.lh_first || vp->v_cleanblkhd.lh_first)) 48249232Smckusick panic("vinvalbuf: flush failed"); 48354442Smckusick return (0); 48449232Smckusick } 48549232Smckusick 48649232Smckusick /* 48749232Smckusick * Associate a buffer with a vnode. 48849232Smckusick */ 48968319Scgd void 49049232Smckusick bgetvp(vp, bp) 49149232Smckusick register struct vnode *vp; 49249232Smckusick register struct buf *bp; 49349232Smckusick { 49449232Smckusick 49549232Smckusick if (bp->b_vp) 49649232Smckusick panic("bgetvp: not free"); 49749232Smckusick VHOLD(vp); 49849232Smckusick bp->b_vp = vp; 49949232Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) 50049232Smckusick bp->b_dev = vp->v_rdev; 50149232Smckusick else 50249232Smckusick bp->b_dev = NODEV; 50349232Smckusick /* 50449232Smckusick * Insert onto list for new vnode. 50549232Smckusick */ 50656608Smckusick bufinsvn(bp, &vp->v_cleanblkhd); 50749232Smckusick } 50849232Smckusick 50949232Smckusick /* 51049232Smckusick * Disassociate a buffer from a vnode. 51149232Smckusick */ 51268319Scgd void 51349232Smckusick brelvp(bp) 51449232Smckusick register struct buf *bp; 51549232Smckusick { 51649232Smckusick struct vnode *vp; 51749232Smckusick 51849232Smckusick if (bp->b_vp == (struct vnode *) 0) 51949232Smckusick panic("brelvp: NULL"); 52049232Smckusick /* 52149232Smckusick * Delete from old vnode list, if on one. 52249232Smckusick */ 52365260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 52456608Smckusick bufremvn(bp); 52549232Smckusick vp = bp->b_vp; 52649232Smckusick bp->b_vp = (struct vnode *) 0; 52749232Smckusick HOLDRELE(vp); 52849232Smckusick } 52949232Smckusick 53049232Smckusick /* 53149232Smckusick * Reassign a buffer from one vnode to another. 53249232Smckusick * Used to assign file specific control information 53349232Smckusick * (indirect blocks) to the vnode to which they belong. 53449232Smckusick */ 53568319Scgd void 53649232Smckusick reassignbuf(bp, newvp) 53749232Smckusick register struct buf *bp; 53849232Smckusick register struct vnode *newvp; 53949232Smckusick { 54065260Smckusick register struct buflists *listheadp; 54149232Smckusick 54252655Smckusick if (newvp == NULL) { 54352655Smckusick printf("reassignbuf: NULL"); 54452655Smckusick return; 54552655Smckusick } 54649232Smckusick /* 54749232Smckusick * Delete from old vnode list, if on one. 54849232Smckusick */ 54965260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 55056608Smckusick bufremvn(bp); 55149232Smckusick /* 55249232Smckusick * If dirty, put on list of dirty buffers; 55349232Smckusick * otherwise insert onto list of clean buffers. 55449232Smckusick */ 55549232Smckusick if (bp->b_flags & B_DELWRI) 55649232Smckusick listheadp = &newvp->v_dirtyblkhd; 55749232Smckusick else 55849232Smckusick listheadp = &newvp->v_cleanblkhd; 55956608Smckusick bufinsvn(bp, listheadp); 56049232Smckusick } 56149232Smckusick 56249232Smckusick /* 56339433Smckusick * Create a vnode for a block device. 56439433Smckusick * Used for root filesystem, argdev, and swap areas. 56539433Smckusick * Also used for memory file system special devices. 56639397Smckusick */ 56768319Scgd int 56839433Smckusick bdevvp(dev, vpp) 56939433Smckusick dev_t dev; 57039433Smckusick struct vnode **vpp; 57139433Smckusick { 57239433Smckusick register struct vnode *vp; 57339433Smckusick struct vnode *nvp; 57439433Smckusick int error; 57539433Smckusick 57669378Smckusick if (dev == NODEV) { 57769378Smckusick *vpp = NULLVP; 57869378Smckusick return (ENODEV); 57969378Smckusick } 58053547Sheideman error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp); 58139433Smckusick if (error) { 58268319Scgd *vpp = NULLVP; 58339433Smckusick return (error); 58439433Smckusick } 58539433Smckusick vp = nvp; 58639433Smckusick vp->v_type = VBLK; 58739615Smckusick if (nvp = checkalias(vp, dev, (struct mount *)0)) { 58839433Smckusick vput(vp); 58939433Smckusick vp = nvp; 59039433Smckusick } 59139433Smckusick *vpp = vp; 59239433Smckusick return (0); 59339433Smckusick } 59439433Smckusick 59539433Smckusick /* 59639433Smckusick * Check to see if the new vnode represents a special device 59739433Smckusick * for which we already have a vnode (either because of 59839433Smckusick * bdevvp() or because of a different vnode representing 59939433Smckusick * the same block device). If such an alias exists, deallocate 60039509Smckusick * the existing contents and return the aliased vnode. The 60139433Smckusick * caller is responsible for filling it with its new contents. 60239433Smckusick */ 60339433Smckusick struct vnode * 60439615Smckusick checkalias(nvp, nvp_rdev, mp) 60539433Smckusick register struct vnode *nvp; 60639615Smckusick dev_t nvp_rdev; 60739433Smckusick struct mount *mp; 60839433Smckusick { 60969408Smckusick struct proc *p = curproc; /* XXX */ 61069408Smckusick struct vnode *vp; 61139615Smckusick struct vnode **vpp; 61239433Smckusick 61339433Smckusick if (nvp->v_type != VBLK && nvp->v_type != VCHR) 61441400Smckusick return (NULLVP); 61539615Smckusick 61639615Smckusick vpp = &speclisth[SPECHASH(nvp_rdev)]; 61739433Smckusick loop: 61869408Smckusick simple_lock(&spechash_slock); 61939615Smckusick for (vp = *vpp; vp; vp = vp->v_specnext) { 62039615Smckusick if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type) 62139433Smckusick continue; 62239615Smckusick /* 62339615Smckusick * Alias, but not in use, so flush it out. 62439615Smckusick */ 62569408Smckusick simple_lock(&vp->v_interlock); 62639809Smckusick if (vp->v_usecount == 0) { 62769408Smckusick simple_unlock(&spechash_slock); 62869408Smckusick vgonel(vp, p); 62939615Smckusick goto loop; 63039615Smckusick } 63169408Smckusick if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { 63269408Smckusick simple_unlock(&spechash_slock); 63339633Smckusick goto loop; 63469408Smckusick } 63539433Smckusick break; 63639433Smckusick } 63739615Smckusick if (vp == NULL || vp->v_tag != VT_NON) { 63839615Smckusick MALLOC(nvp->v_specinfo, struct specinfo *, 63939615Smckusick sizeof(struct specinfo), M_VNODE, M_WAITOK); 64039615Smckusick nvp->v_rdev = nvp_rdev; 64139809Smckusick nvp->v_hashchain = vpp; 64239615Smckusick nvp->v_specnext = *vpp; 64342152Smckusick nvp->v_specflags = 0; 64469408Smckusick simple_unlock(&spechash_slock); 64539615Smckusick *vpp = nvp; 64669408Smckusick if (vp != NULLVP) { 64740640Smckusick nvp->v_flag |= VALIASED; 64840640Smckusick vp->v_flag |= VALIASED; 64940640Smckusick vput(vp); 65040640Smckusick } 65141400Smckusick return (NULLVP); 65239433Smckusick } 65369408Smckusick simple_unlock(&spechash_slock); 65469408Smckusick VOP_UNLOCK(vp, 0, p); 65569408Smckusick simple_lock(&vp->v_interlock); 65669408Smckusick vclean(vp, 0, p); 65739433Smckusick vp->v_op = nvp->v_op; 65839433Smckusick vp->v_tag = nvp->v_tag; 65939433Smckusick nvp->v_type = VNON; 66039433Smckusick insmntque(vp, mp); 66139433Smckusick return (vp); 66239433Smckusick } 66339433Smckusick 66439433Smckusick /* 66539433Smckusick * Grab a particular vnode from the free list, increment its 66639433Smckusick * reference count and lock it. The vnode lock bit is set the 66739433Smckusick * vnode is being eliminated in vgone. The process is awakened 66839433Smckusick * when the transition is completed, and an error returned to 66939433Smckusick * indicate that the vnode is no longer usable (possibly having 67039433Smckusick * been changed to a new file system type). 67139433Smckusick */ 67268319Scgd int 67369408Smckusick vget(vp, flags, p) 67469408Smckusick struct vnode *vp; 67569408Smckusick int flags; 67669408Smckusick struct proc *p; 67739397Smckusick { 67839397Smckusick 67966897Smckusick /* 68066897Smckusick * If the vnode is in the process of being cleaned out for 68166897Smckusick * another use, we wait for the cleaning to finish and then 68269408Smckusick * return failure. Cleaning is determined by checking that 68369408Smckusick * the VXLOCK flag is set. 68466897Smckusick */ 68569408Smckusick if ((flags & LK_INTERLOCK) == 0) 68669408Smckusick simple_lock(&vp->v_interlock); 68769408Smckusick if (vp->v_flag & VXLOCK) { 68839433Smckusick vp->v_flag |= VXWANT; 68969408Smckusick simple_unlock(&vp->v_interlock); 69068319Scgd tsleep((caddr_t)vp, PINOD, "vget", 0); 69169408Smckusick return (ENOENT); 69239433Smckusick } 69369408Smckusick if (vp->v_usecount == 0) { 69469408Smckusick simple_lock(&vnode_free_list_slock); 69565260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 69669408Smckusick simple_unlock(&vnode_free_list_slock); 69769408Smckusick } 69859450Smckusick vp->v_usecount++; 69969408Smckusick if (flags & LK_TYPE_MASK) 70069408Smckusick return (vn_lock(vp, flags | LK_INTERLOCK, p)); 70169408Smckusick simple_unlock(&vp->v_interlock); 70239433Smckusick return (0); 70339397Smckusick } 70439397Smckusick 70539397Smckusick /* 70669408Smckusick * Stubs to use when there is no locking to be done on the underlying object. 70769408Smckusick * 70869408Smckusick * Getting a lock just clears the interlock if necessary. 70939397Smckusick */ 71069408Smckusick int 71169408Smckusick vop_nolock(ap) 71269408Smckusick struct vop_lock_args /* { 71369408Smckusick struct vnode *a_vp; 71469408Smckusick int a_flags; 71569408Smckusick struct proc *a_p; 71669408Smckusick } */ *ap; 71769408Smckusick { 71869408Smckusick struct vnode *vp = ap->a_vp; 71969408Smckusick 72069408Smckusick /* 72169408Smckusick * Since we are not using the lock manager, we must clear 72269408Smckusick * the interlock here. 72369408Smckusick */ 72469408Smckusick if (ap->a_flags & LK_INTERLOCK) 72569408Smckusick simple_unlock(&vp->v_interlock); 72669408Smckusick return (0); 72769408Smckusick } 72869408Smckusick 72969408Smckusick /* 73069408Smckusick * Unlock has nothing to do. 73169408Smckusick */ 73269408Smckusick int 73369408Smckusick vop_nounlock(ap) 73469408Smckusick struct vop_unlock_args /* { 73569408Smckusick struct vnode *a_vp; 73669408Smckusick int a_flags; 73769408Smckusick struct proc *a_p; 73869408Smckusick } */ *ap; 73969408Smckusick { 74069408Smckusick 74169408Smckusick return (0); 74269408Smckusick } 74369408Smckusick 74469408Smckusick /* 74569408Smckusick * Nothing is ever locked. 74669408Smckusick */ 74769408Smckusick int 74869408Smckusick vop_noislocked(ap) 74969408Smckusick struct vop_islocked_args /* { 75069408Smckusick struct vnode *a_vp; 75169408Smckusick } */ *ap; 75269408Smckusick { 75369408Smckusick 75469408Smckusick return (0); 75569408Smckusick } 75669408Smckusick 75769408Smckusick /* 75869408Smckusick * Vnode reference. 75969408Smckusick */ 76068319Scgd void 76168319Scgd vref(vp) 76239397Smckusick struct vnode *vp; 76339397Smckusick { 76439397Smckusick 76569408Smckusick simple_lock(&vp->v_interlock); 76659450Smckusick if (vp->v_usecount <= 0) 76759450Smckusick panic("vref used where vget required"); 76839809Smckusick vp->v_usecount++; 76969408Smckusick simple_unlock(&vp->v_interlock); 77039397Smckusick } 77139397Smckusick 77239397Smckusick /* 77339397Smckusick * vput(), just unlock and vrele() 77439397Smckusick */ 77568319Scgd void 77668319Scgd vput(vp) 77769408Smckusick struct vnode *vp; 77839397Smckusick { 77969408Smckusick struct proc *p = curproc; /* XXX */ 78052416Storek 781*69523Spendry #ifdef DIGANOSTIC 782*69523Spendry if (vp == NULL) 783*69523Spendry panic("vput: null vp"); 784*69523Spendry #endif 785*69523Spendry simple_lock(&vp->v_interlock); 786*69523Spendry vp->v_usecount--; 787*69523Spendry if (vp->v_usecount > 0) { 788*69523Spendry simple_unlock(&vp->v_interlock); 789*69523Spendry VOP_UNLOCK(vp, 0, p); 790*69523Spendry return; 791*69523Spendry } 792*69523Spendry #ifdef DIAGNOSTIC 793*69523Spendry if (vp->v_usecount < 0 || vp->v_writecount != 0) { 794*69523Spendry vprint("vput: bad ref count", vp); 795*69523Spendry panic("vput: ref cnt"); 796*69523Spendry } 797*69523Spendry #endif 798*69523Spendry /* 799*69523Spendry * insert at tail of LRU list 800*69523Spendry */ 801*69523Spendry simple_lock(&vnode_free_list_slock); 802*69523Spendry TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 803*69523Spendry simple_unlock(&vnode_free_list_slock); 804*69523Spendry simple_unlock(&vp->v_interlock); 805*69523Spendry VOP_INACTIVE(vp, p); 80639397Smckusick } 80739397Smckusick 80839397Smckusick /* 80939397Smckusick * Vnode release. 81039397Smckusick * If count drops to zero, call inactive routine and return to freelist. 81139397Smckusick */ 81268319Scgd void 81368319Scgd vrele(vp) 81469408Smckusick struct vnode *vp; 81539397Smckusick { 81669408Smckusick struct proc *p = curproc; /* XXX */ 81739397Smckusick 81850109Smckusick #ifdef DIAGNOSTIC 81939397Smckusick if (vp == NULL) 82039433Smckusick panic("vrele: null vp"); 82150109Smckusick #endif 82269408Smckusick simple_lock(&vp->v_interlock); 82339809Smckusick vp->v_usecount--; 82469408Smckusick if (vp->v_usecount > 0) { 82569408Smckusick simple_unlock(&vp->v_interlock); 82639397Smckusick return; 82769408Smckusick } 82850109Smckusick #ifdef DIAGNOSTIC 82969408Smckusick if (vp->v_usecount < 0 || vp->v_writecount != 0) { 83050109Smckusick vprint("vrele: bad ref count", vp); 83150109Smckusick panic("vrele: ref cnt"); 83250109Smckusick } 83350109Smckusick #endif 83455468Smckusick /* 83555468Smckusick * insert at tail of LRU list 83655468Smckusick */ 83769408Smckusick simple_lock(&vnode_free_list_slock); 83865260Smckusick TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 83969408Smckusick simple_unlock(&vnode_free_list_slock); 84069408Smckusick if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0) 84169408Smckusick VOP_INACTIVE(vp, p); 84239397Smckusick } 84339433Smckusick 84469408Smckusick #ifdef DIAGNOSTIC 84539433Smckusick /* 84639809Smckusick * Page or buffer structure gets a reference. 84739809Smckusick */ 84868319Scgd void 84968319Scgd vhold(vp) 85039809Smckusick register struct vnode *vp; 85139809Smckusick { 85239809Smckusick 85369408Smckusick simple_lock(&vp->v_interlock); 85439809Smckusick vp->v_holdcnt++; 85569408Smckusick simple_unlock(&vp->v_interlock); 85639809Smckusick } 85739809Smckusick 85839809Smckusick /* 85939809Smckusick * Page or buffer structure frees a reference. 86039809Smckusick */ 86168319Scgd void 86268319Scgd holdrele(vp) 86339809Smckusick register struct vnode *vp; 86439809Smckusick { 86539809Smckusick 86669408Smckusick simple_lock(&vp->v_interlock); 86739809Smckusick if (vp->v_holdcnt <= 0) 86839809Smckusick panic("holdrele: holdcnt"); 86939809Smckusick vp->v_holdcnt--; 87069408Smckusick simple_unlock(&vp->v_interlock); 87139809Smckusick } 87269408Smckusick #endif /* DIAGNOSTIC */ 87339809Smckusick 87439809Smckusick /* 87539509Smckusick * Remove any vnodes in the vnode table belonging to mount point mp. 87639509Smckusick * 87739509Smckusick * If MNT_NOFORCE is specified, there should not be any active ones, 87839509Smckusick * return error if any are found (nb: this is a user error, not a 87939509Smckusick * system error). If MNT_FORCE is specified, detach any active vnodes 88039509Smckusick * that are found. 88139509Smckusick */ 88265679Shibler #ifdef DIAGNOSTIC 88360930Smckusick int busyprt = 0; /* print out busy vnodes */ 88460930Smckusick struct ctldebug debug1 = { "busyprt", &busyprt }; 88565679Shibler #endif 88639509Smckusick 88768319Scgd int 88839509Smckusick vflush(mp, skipvp, flags) 88939509Smckusick struct mount *mp; 89039509Smckusick struct vnode *skipvp; 89139509Smckusick int flags; 89239509Smckusick { 89369408Smckusick struct proc *p = curproc; /* XXX */ 89469408Smckusick struct vnode *vp, *nvp; 89539509Smckusick int busy = 0; 89639509Smckusick 89769408Smckusick #ifdef DIAGNOSTIC 89841400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 89941300Smckusick panic("vflush: not busy"); 90069408Smckusick #endif 90169408Smckusick 90269408Smckusick simple_lock(&mntvnode_slock); 90341421Smckusick loop: 90465260Smckusick for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) { 90541421Smckusick if (vp->v_mount != mp) 90641421Smckusick goto loop; 90765260Smckusick nvp = vp->v_mntvnodes.le_next; 90839509Smckusick /* 90939509Smckusick * Skip over a selected vnode. 91039509Smckusick */ 91139509Smckusick if (vp == skipvp) 91239509Smckusick continue; 91369408Smckusick 91469408Smckusick simple_lock(&vp->v_interlock); 91539509Smckusick /* 91641300Smckusick * Skip over a vnodes marked VSYSTEM. 91741300Smckusick */ 91869408Smckusick if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) { 91969408Smckusick simple_unlock(&vp->v_interlock); 92041300Smckusick continue; 92169408Smckusick } 92241300Smckusick /* 92357040Smckusick * If WRITECLOSE is set, only flush out regular file 92457040Smckusick * vnodes open for writing. 92557040Smckusick */ 92657040Smckusick if ((flags & WRITECLOSE) && 92769408Smckusick (vp->v_writecount == 0 || vp->v_type != VREG)) { 92869408Smckusick simple_unlock(&vp->v_interlock); 92957040Smckusick continue; 93069408Smckusick } 93157040Smckusick /* 93239809Smckusick * With v_usecount == 0, all we need to do is clear 93339509Smckusick * out the vnode data structures and we are done. 93439509Smckusick */ 93539809Smckusick if (vp->v_usecount == 0) { 93669408Smckusick simple_unlock(&mntvnode_slock); 93769408Smckusick vgonel(vp, p); 93869408Smckusick simple_lock(&mntvnode_slock); 93939509Smckusick continue; 94039509Smckusick } 94139509Smckusick /* 94257040Smckusick * If FORCECLOSE is set, forcibly close the vnode. 94339509Smckusick * For block or character devices, revert to an 94439509Smckusick * anonymous device. For all other files, just kill them. 94539509Smckusick */ 94641300Smckusick if (flags & FORCECLOSE) { 94769408Smckusick simple_unlock(&mntvnode_slock); 94839509Smckusick if (vp->v_type != VBLK && vp->v_type != VCHR) { 94969408Smckusick vgonel(vp, p); 95039509Smckusick } else { 95169408Smckusick vclean(vp, 0, p); 95253547Sheideman vp->v_op = spec_vnodeop_p; 95339509Smckusick insmntque(vp, (struct mount *)0); 95439509Smckusick } 95569408Smckusick simple_lock(&mntvnode_slock); 95639509Smckusick continue; 95739509Smckusick } 95865679Shibler #ifdef DIAGNOSTIC 95939509Smckusick if (busyprt) 96039667Smckusick vprint("vflush: busy vnode", vp); 96165679Shibler #endif 96269408Smckusick simple_unlock(&vp->v_interlock); 96339509Smckusick busy++; 96439509Smckusick } 96569408Smckusick simple_unlock(&mntvnode_slock); 96639509Smckusick if (busy) 96739509Smckusick return (EBUSY); 96839509Smckusick return (0); 96939509Smckusick } 97039509Smckusick 97139509Smckusick /* 97239433Smckusick * Disassociate the underlying file system from a vnode. 97369408Smckusick * The vnode interlock is held on entry. 97439433Smckusick */ 97569408Smckusick static void 97669408Smckusick vclean(vp, flags, p) 97769408Smckusick struct vnode *vp; 97845118Smckusick int flags; 97969408Smckusick struct proc *p; 98039433Smckusick { 98139484Smckusick int active; 98239433Smckusick 98339484Smckusick /* 98439484Smckusick * Check to see if the vnode is in use. 98539667Smckusick * If so we have to reference it before we clean it out 98639667Smckusick * so that its count cannot fall to zero and generate a 98739667Smckusick * race against ourselves to recycle it. 98839484Smckusick */ 98939809Smckusick if (active = vp->v_usecount) 99069408Smckusick vp->v_usecount++; 99139484Smckusick /* 99269408Smckusick * Prevent the vnode from being recycled or 99369408Smckusick * brought into use while we clean it out. 99469408Smckusick */ 99569408Smckusick if (vp->v_flag & VXLOCK) 99669408Smckusick panic("vclean: deadlock"); 99769408Smckusick vp->v_flag |= VXLOCK; 99869408Smckusick /* 99956805Smckusick * Even if the count is zero, the VOP_INACTIVE routine may still 100056805Smckusick * have the object locked while it cleans it out. The VOP_LOCK 100156805Smckusick * ensures that the VOP_INACTIVE routine is done with its work. 100256805Smckusick * For active vnodes, it ensures that no other activity can 100356805Smckusick * occur while the underlying object is being cleaned out. 100456805Smckusick */ 100569408Smckusick VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p); 100656805Smckusick /* 100756805Smckusick * Clean out any buffers associated with the vnode. 100839667Smckusick */ 100941300Smckusick if (flags & DOCLOSE) 101057792Smckusick vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0); 101139667Smckusick /* 101256805Smckusick * If purging an active vnode, it must be closed and 101369408Smckusick * deactivated before being reclaimed. Note that the 101469408Smckusick * VOP_INACTIVE will unlock the vnode. 101539433Smckusick */ 101639484Smckusick if (active) { 101756805Smckusick if (flags & DOCLOSE) 101869408Smckusick VOP_CLOSE(vp, IO_NDELAY, NOCRED, p); 101969408Smckusick VOP_INACTIVE(vp, p); 102069408Smckusick } else { 102169408Smckusick /* 102269408Smckusick * Any other processes trying to obtain this lock must first 102369408Smckusick * wait for VXLOCK to clear, then call the new lock operation. 102469408Smckusick */ 102569408Smckusick VOP_UNLOCK(vp, 0, p); 102639433Smckusick } 102739433Smckusick /* 102839433Smckusick * Reclaim the vnode. 102939433Smckusick */ 103069408Smckusick if (VOP_RECLAIM(vp, p)) 103139433Smckusick panic("vclean: cannot reclaim"); 103239484Smckusick if (active) 103339484Smckusick vrele(vp); 103468784Smckusick cache_purge(vp); 103553580Sheideman 103639433Smckusick /* 103756805Smckusick * Done with purge, notify sleepers of the grim news. 103839433Smckusick */ 103956805Smckusick vp->v_op = dead_vnodeop_p; 104056805Smckusick vp->v_tag = VT_NON; 104139433Smckusick vp->v_flag &= ~VXLOCK; 104239433Smckusick if (vp->v_flag & VXWANT) { 104339433Smckusick vp->v_flag &= ~VXWANT; 104439433Smckusick wakeup((caddr_t)vp); 104539433Smckusick } 104639433Smckusick } 104739433Smckusick 104839433Smckusick /* 104939633Smckusick * Eliminate all activity associated with the requested vnode 105039633Smckusick * and with all vnodes aliased to the requested vnode. 105139633Smckusick */ 105268424Smckusick int 105368424Smckusick vop_revoke(ap) 105468424Smckusick struct vop_revoke_args /* { 105568424Smckusick struct vnode *a_vp; 105668424Smckusick int a_flags; 105768424Smckusick } */ *ap; 105839633Smckusick { 105969408Smckusick struct vnode *vp, *vq; 106069408Smckusick struct proc *p = curproc; /* XXX */ 106139633Smckusick 106269408Smckusick #ifdef DIAGNOSTIC 106369408Smckusick if ((ap->a_flags & REVOKEALL) == 0) 106469408Smckusick panic("vop_revoke"); 106569408Smckusick #endif 106669408Smckusick 106768424Smckusick vp = ap->a_vp; 106869408Smckusick simple_lock(&vp->v_interlock); 106969408Smckusick 107069408Smckusick if (vp->v_flag & VALIASED) { 107140665Smckusick /* 107240665Smckusick * If a vgone (or vclean) is already in progress, 107340665Smckusick * wait until it is done and return. 107440665Smckusick */ 107540665Smckusick if (vp->v_flag & VXLOCK) { 107640665Smckusick vp->v_flag |= VXWANT; 107769408Smckusick simple_unlock(&vp->v_interlock); 107868424Smckusick tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0); 107968424Smckusick return (0); 108039633Smckusick } 108140665Smckusick /* 108240665Smckusick * Ensure that vp will not be vgone'd while we 108340665Smckusick * are eliminating its aliases. 108440665Smckusick */ 108540665Smckusick vp->v_flag |= VXLOCK; 108669408Smckusick simple_unlock(&vp->v_interlock); 108740665Smckusick while (vp->v_flag & VALIASED) { 108869408Smckusick simple_lock(&spechash_slock); 108940665Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 109040665Smckusick if (vq->v_rdev != vp->v_rdev || 109140665Smckusick vq->v_type != vp->v_type || vp == vq) 109240665Smckusick continue; 109369408Smckusick simple_unlock(&spechash_slock); 109440665Smckusick vgone(vq); 109540665Smckusick break; 109640665Smckusick } 109769408Smckusick if (vq == NULLVP) 109869408Smckusick simple_unlock(&spechash_slock); 109940665Smckusick } 110040665Smckusick /* 110140665Smckusick * Remove the lock so that vgone below will 110240665Smckusick * really eliminate the vnode after which time 110340665Smckusick * vgone will awaken any sleepers. 110440665Smckusick */ 110569408Smckusick simple_lock(&vp->v_interlock); 110640665Smckusick vp->v_flag &= ~VXLOCK; 110739633Smckusick } 110869408Smckusick vgonel(vp, p); 110968424Smckusick return (0); 111039633Smckusick } 111139633Smckusick 111239633Smckusick /* 111369408Smckusick * Recycle an unused vnode to the front of the free list. 111469408Smckusick * Release the passed interlock if the vnode will be recycled. 111569408Smckusick */ 111669408Smckusick int 111769408Smckusick vrecycle(vp, inter_lkp, p) 111869408Smckusick struct vnode *vp; 111969408Smckusick struct simplelock *inter_lkp; 112069408Smckusick struct proc *p; 112169408Smckusick { 112269408Smckusick 112369408Smckusick simple_lock(&vp->v_interlock); 112469408Smckusick if (vp->v_usecount == 0) { 112569408Smckusick if (inter_lkp) 112669408Smckusick simple_unlock(inter_lkp); 112769408Smckusick vgonel(vp, p); 112869408Smckusick return (1); 112969408Smckusick } 113069408Smckusick simple_unlock(&vp->v_interlock); 113169408Smckusick return (0); 113269408Smckusick } 113369408Smckusick 113469408Smckusick /* 113539433Smckusick * Eliminate all activity associated with a vnode 113639433Smckusick * in preparation for reuse. 113739433Smckusick */ 113868319Scgd void 113968319Scgd vgone(vp) 114069408Smckusick struct vnode *vp; 114139433Smckusick { 114269408Smckusick struct proc *p = curproc; /* XXX */ 114369408Smckusick 114469408Smckusick simple_lock(&vp->v_interlock); 114569408Smckusick vgonel(vp, p); 114669408Smckusick } 114769408Smckusick 114869408Smckusick /* 114969408Smckusick * vgone, with the vp interlock held. 115069408Smckusick */ 115169408Smckusick void 115269408Smckusick vgonel(vp, p) 115369408Smckusick struct vnode *vp; 115469408Smckusick struct proc *p; 115569408Smckusick { 115669408Smckusick struct vnode *vq; 115739615Smckusick struct vnode *vx; 115839433Smckusick 115939433Smckusick /* 116040548Smckusick * If a vgone (or vclean) is already in progress, 116140548Smckusick * wait until it is done and return. 116240548Smckusick */ 116340548Smckusick if (vp->v_flag & VXLOCK) { 116440548Smckusick vp->v_flag |= VXWANT; 116569408Smckusick simple_unlock(&vp->v_interlock); 116668319Scgd tsleep((caddr_t)vp, PINOD, "vgone", 0); 116740548Smckusick return; 116840548Smckusick } 116940548Smckusick /* 117039433Smckusick * Clean out the filesystem specific data. 117139433Smckusick */ 117269408Smckusick vclean(vp, DOCLOSE, p); 117339433Smckusick /* 117439433Smckusick * Delete from old mount point vnode list, if on one. 117539433Smckusick */ 117669408Smckusick if (vp->v_mount != NULL) 117769408Smckusick insmntque(vp, (struct mount *)0); 117839433Smckusick /* 117968592Smckusick * If special device, remove it from special device alias list 118068592Smckusick * if it is on one. 118139433Smckusick */ 118268592Smckusick if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_specinfo != 0) { 118369408Smckusick simple_lock(&spechash_slock); 118439809Smckusick if (*vp->v_hashchain == vp) { 118539809Smckusick *vp->v_hashchain = vp->v_specnext; 118639433Smckusick } else { 118739809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 118839615Smckusick if (vq->v_specnext != vp) 118939433Smckusick continue; 119039615Smckusick vq->v_specnext = vp->v_specnext; 119139433Smckusick break; 119239433Smckusick } 119339615Smckusick if (vq == NULL) 119439433Smckusick panic("missing bdev"); 119539433Smckusick } 119639615Smckusick if (vp->v_flag & VALIASED) { 119752416Storek vx = NULL; 119839809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 119940108Smckusick if (vq->v_rdev != vp->v_rdev || 120040108Smckusick vq->v_type != vp->v_type) 120139615Smckusick continue; 120252416Storek if (vx) 120352416Storek break; 120439615Smckusick vx = vq; 120539615Smckusick } 120652416Storek if (vx == NULL) 120739615Smckusick panic("missing alias"); 120852416Storek if (vq == NULL) 120939615Smckusick vx->v_flag &= ~VALIASED; 121039615Smckusick vp->v_flag &= ~VALIASED; 121139615Smckusick } 121269408Smckusick simple_unlock(&spechash_slock); 121339615Smckusick FREE(vp->v_specinfo, M_VNODE); 121439615Smckusick vp->v_specinfo = NULL; 121539433Smckusick } 121639433Smckusick /* 121756932Smckusick * If it is on the freelist and not already at the head, 121865505Smckusick * move it to the head of the list. The test of the back 121965505Smckusick * pointer and the reference count of zero is because 122065505Smckusick * it will be removed from the free list by getnewvnode, 122165505Smckusick * but will not have its reference count incremented until 122265505Smckusick * after calling vgone. If the reference count were 122365505Smckusick * incremented first, vgone would (incorrectly) try to 122465505Smckusick * close the previous instance of the underlying object. 122565505Smckusick * So, the back pointer is explicitly set to `0xdeadb' in 122665505Smckusick * getnewvnode after removing it from the freelist to ensure 122765505Smckusick * that we do not try to move it here. 122839433Smckusick */ 122969408Smckusick if (vp->v_usecount == 0) { 123069408Smckusick simple_lock(&vnode_free_list_slock); 123169408Smckusick if ((vp->v_freelist.tqe_prev != (struct vnode **)0xdeadb) && 123269408Smckusick vnode_free_list.tqh_first != vp) { 123369408Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 123469408Smckusick TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 123569408Smckusick } 123669408Smckusick simple_unlock(&vnode_free_list_slock); 123739433Smckusick } 123839484Smckusick vp->v_type = VBAD; 123939433Smckusick } 124039633Smckusick 124139633Smckusick /* 124239821Smckusick * Lookup a vnode by device number. 124339821Smckusick */ 124468319Scgd int 124539821Smckusick vfinddev(dev, type, vpp) 124639821Smckusick dev_t dev; 124739821Smckusick enum vtype type; 124839821Smckusick struct vnode **vpp; 124939821Smckusick { 125069408Smckusick struct vnode *vp; 125169408Smckusick int rc = 0; 125239821Smckusick 125369408Smckusick simple_lock(&spechash_slock); 125439821Smckusick for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { 125539821Smckusick if (dev != vp->v_rdev || type != vp->v_type) 125639821Smckusick continue; 125739821Smckusick *vpp = vp; 125869408Smckusick rc = 1; 125969408Smckusick break; 126039821Smckusick } 126169408Smckusick simple_unlock(&spechash_slock); 126269408Smckusick return (rc); 126339821Smckusick } 126439821Smckusick 126539821Smckusick /* 126639633Smckusick * Calculate the total number of references to a special device. 126739633Smckusick */ 126868319Scgd int 126939633Smckusick vcount(vp) 127069408Smckusick struct vnode *vp; 127139633Smckusick { 127269408Smckusick struct vnode *vq, *vnext; 127339633Smckusick int count; 127439633Smckusick 127566742Smckusick loop: 127639633Smckusick if ((vp->v_flag & VALIASED) == 0) 127739809Smckusick return (vp->v_usecount); 127869408Smckusick simple_lock(&spechash_slock); 127966742Smckusick for (count = 0, vq = *vp->v_hashchain; vq; vq = vnext) { 128066742Smckusick vnext = vq->v_specnext; 128140108Smckusick if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) 128239633Smckusick continue; 128339633Smckusick /* 128439633Smckusick * Alias, but not in use, so flush it out. 128539633Smckusick */ 128666742Smckusick if (vq->v_usecount == 0 && vq != vp) { 128769408Smckusick simple_unlock(&spechash_slock); 128839633Smckusick vgone(vq); 128939633Smckusick goto loop; 129039633Smckusick } 129139809Smckusick count += vq->v_usecount; 129239633Smckusick } 129369408Smckusick simple_unlock(&spechash_slock); 129439633Smckusick return (count); 129539633Smckusick } 129639667Smckusick 129739667Smckusick /* 129839667Smckusick * Print out a description of a vnode. 129939667Smckusick */ 130039667Smckusick static char *typename[] = 130140286Smckusick { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; 130239667Smckusick 130368171Scgd void 130439667Smckusick vprint(label, vp) 130539667Smckusick char *label; 130639667Smckusick register struct vnode *vp; 130739667Smckusick { 130839913Smckusick char buf[64]; 130939667Smckusick 131039667Smckusick if (label != NULL) 131139667Smckusick printf("%s: ", label); 131250109Smckusick printf("type %s, usecount %d, writecount %d, refcount %d,", 131350109Smckusick typename[vp->v_type], vp->v_usecount, vp->v_writecount, 131450109Smckusick vp->v_holdcnt); 131539913Smckusick buf[0] = '\0'; 131639913Smckusick if (vp->v_flag & VROOT) 131739913Smckusick strcat(buf, "|VROOT"); 131839913Smckusick if (vp->v_flag & VTEXT) 131939913Smckusick strcat(buf, "|VTEXT"); 132041300Smckusick if (vp->v_flag & VSYSTEM) 132141300Smckusick strcat(buf, "|VSYSTEM"); 132241300Smckusick if (vp->v_flag & VXLOCK) 132341300Smckusick strcat(buf, "|VXLOCK"); 132441300Smckusick if (vp->v_flag & VXWANT) 132541300Smckusick strcat(buf, "|VXWANT"); 132641300Smckusick if (vp->v_flag & VBWAIT) 132741300Smckusick strcat(buf, "|VBWAIT"); 132839913Smckusick if (vp->v_flag & VALIASED) 132939913Smckusick strcat(buf, "|VALIASED"); 133039913Smckusick if (buf[0] != '\0') 133139913Smckusick printf(" flags (%s)", &buf[1]); 133265260Smckusick if (vp->v_data == NULL) { 133365260Smckusick printf("\n"); 133465260Smckusick } else { 133565260Smckusick printf("\n\t"); 133665260Smckusick VOP_PRINT(vp); 133765260Smckusick } 133839667Smckusick } 133941110Smarc 134049691Smckusick #ifdef DEBUG 134149691Smckusick /* 134249691Smckusick * List all of the locked vnodes in the system. 134349691Smckusick * Called when debugging the kernel. 134449691Smckusick */ 134568319Scgd void 134649691Smckusick printlockedvnodes() 134749691Smckusick { 134849691Smckusick register struct mount *mp; 134949691Smckusick register struct vnode *vp; 135049691Smckusick 135149691Smckusick printf("Locked vnodes\n"); 135269325Smckusick for (mp = mountlist.cqh_first; mp != (void *)&mountlist; 135369325Smckusick mp = mp->mnt_list.cqe_next) { 135465260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 135565260Smckusick vp != NULL; 135669325Smckusick vp = vp->v_mntvnodes.le_next) { 135749691Smckusick if (VOP_ISLOCKED(vp)) 135849691Smckusick vprint((char *)0, vp); 135969325Smckusick } 136065260Smckusick } 136149691Smckusick } 136249691Smckusick #endif 136349691Smckusick 136468659Smckusick /* 136568659Smckusick * Top level filesystem related information gathering. 136668659Smckusick */ 136768659Smckusick int 136868659Smckusick vfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 136968659Smckusick int *name; 137068659Smckusick u_int namelen; 137168659Smckusick void *oldp; 137268659Smckusick size_t *oldlenp; 137368659Smckusick void *newp; 137468659Smckusick size_t newlen; 137568659Smckusick struct proc *p; 137668659Smckusick { 137768659Smckusick struct ctldebug *cdp; 137868659Smckusick struct vfsconf *vfsp; 137968659Smckusick 138068659Smckusick /* all sysctl names at this level are at least name and field */ 138168659Smckusick if (namelen < 2) 138268659Smckusick return (ENOTDIR); /* overloaded */ 138368659Smckusick if (name[0] != VFS_GENERIC) { 138468659Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) 138568659Smckusick if (vfsp->vfc_typenum == name[0]) 138668659Smckusick break; 138768659Smckusick if (vfsp == NULL) 138868659Smckusick return (EOPNOTSUPP); 138968659Smckusick return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1, 139068659Smckusick oldp, oldlenp, newp, newlen, p)); 139168659Smckusick } 139268659Smckusick switch (name[1]) { 139368659Smckusick case VFS_MAXTYPENUM: 139468659Smckusick return (sysctl_rdint(oldp, oldlenp, newp, maxvfsconf)); 139568659Smckusick case VFS_CONF: 139668659Smckusick if (namelen < 3) 139768659Smckusick return (ENOTDIR); /* overloaded */ 139868659Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) 139968659Smckusick if (vfsp->vfc_typenum == name[2]) 140068659Smckusick break; 140168659Smckusick if (vfsp == NULL) 140268659Smckusick return (EOPNOTSUPP); 140368659Smckusick return (sysctl_rdstruct(oldp, oldlenp, newp, vfsp, 140468659Smckusick sizeof(struct vfsconf))); 140568659Smckusick } 140668659Smckusick return (EOPNOTSUPP); 140768659Smckusick } 140868659Smckusick 140941110Smarc int kinfo_vdebug = 1; 141041110Smarc int kinfo_vgetfailed; 141141110Smarc #define KINFO_VNODESLOP 10 141241110Smarc /* 141357841Smckusick * Dump vnode list (via sysctl). 141441110Smarc * Copyout address of vnode followed by vnode. 141541110Smarc */ 141645118Smckusick /* ARGSUSED */ 141768319Scgd int 141857841Smckusick sysctl_vnode(where, sizep) 141941110Smarc char *where; 142058465Sbostic size_t *sizep; 142141110Smarc { 142265260Smckusick register struct mount *mp, *nmp; 142369408Smckusick struct vnode *nvp, *vp; 142441110Smarc register char *bp = where, *savebp; 142553818Smckusick char *ewhere; 142641110Smarc int error; 142741110Smarc 142841110Smarc #define VPTRSZ sizeof (struct vnode *) 142941110Smarc #define VNODESZ sizeof (struct vnode) 143041110Smarc if (where == NULL) { 143157841Smckusick *sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 143241110Smarc return (0); 143341110Smarc } 143457841Smckusick ewhere = where + *sizep; 143541110Smarc 143669325Smckusick for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { 143769325Smckusick nmp = mp->mnt_list.cqe_next; 143865260Smckusick if (vfs_busy(mp)) 143941300Smckusick continue; 144041110Smarc savebp = bp; 144141110Smarc again: 144269408Smckusick simple_lock(&mntvnode_slock); 144365260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 144465260Smckusick vp != NULL; 144569408Smckusick vp = nvp) { 144641422Smckusick /* 144741422Smckusick * Check that the vp is still associated with 144841422Smckusick * this filesystem. RACE: could have been 144941422Smckusick * recycled onto the same filesystem. 145041422Smckusick */ 145141421Smckusick if (vp->v_mount != mp) { 145269408Smckusick simple_unlock(&mntvnode_slock); 145341421Smckusick if (kinfo_vdebug) 145441421Smckusick printf("kinfo: vp changed\n"); 145541421Smckusick bp = savebp; 145641421Smckusick goto again; 145741421Smckusick } 145869408Smckusick nvp = vp->v_mntvnodes.le_next; 145957841Smckusick if (bp + VPTRSZ + VNODESZ > ewhere) { 146069408Smckusick simple_unlock(&mntvnode_slock); 146157841Smckusick *sizep = bp - where; 146257841Smckusick return (ENOMEM); 146357841Smckusick } 146469408Smckusick simple_unlock(&mntvnode_slock); 146557841Smckusick if ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || 146657841Smckusick (error = copyout((caddr_t)vp, bp + VPTRSZ, VNODESZ))) 146741110Smarc return (error); 146841110Smarc bp += VPTRSZ + VNODESZ; 146969408Smckusick simple_lock(&mntvnode_slock); 147041110Smarc } 147169408Smckusick simple_unlock(&mntvnode_slock); 147265260Smckusick vfs_unbusy(mp); 147365260Smckusick } 147441110Smarc 147557841Smckusick *sizep = bp - where; 147641110Smarc return (0); 147741110Smarc } 147865679Shibler 147965679Shibler /* 148065679Shibler * Check to see if a filesystem is mounted on a block device. 148165679Shibler */ 148265679Shibler int 148365679Shibler vfs_mountedon(vp) 148469408Smckusick struct vnode *vp; 148565679Shibler { 148669408Smckusick struct vnode *vq; 148769408Smckusick int error = 0; 148865679Shibler 148965679Shibler if (vp->v_specflags & SI_MOUNTEDON) 149065679Shibler return (EBUSY); 149165679Shibler if (vp->v_flag & VALIASED) { 149269408Smckusick simple_lock(&spechash_slock); 149365679Shibler for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 149465679Shibler if (vq->v_rdev != vp->v_rdev || 149565679Shibler vq->v_type != vp->v_type) 149665679Shibler continue; 149769408Smckusick if (vq->v_specflags & SI_MOUNTEDON) { 149869408Smckusick error = EBUSY; 149969408Smckusick break; 150069408Smckusick } 150165679Shibler } 150269408Smckusick simple_unlock(&spechash_slock); 150365679Shibler } 150469408Smckusick return (error); 150565679Shibler } 150665679Shibler 150765679Shibler /* 150869325Smckusick * Unmount all filesystems. The list is traversed in reverse order 150969325Smckusick * of mounting to avoid dependencies. 151069325Smckusick */ 151169325Smckusick void 151269325Smckusick vfs_unmountall() 151369325Smckusick { 151469325Smckusick struct mount *mp, *nmp; 151569325Smckusick 151669325Smckusick for (mp = mountlist.cqh_last; mp != (void *)&mountlist; mp = nmp) { 151769325Smckusick nmp = mp->mnt_list.cqe_prev; 151869325Smckusick (void) dounmount(mp, MNT_FORCE, &proc0); 151969325Smckusick } 152069325Smckusick } 152169325Smckusick 152269325Smckusick /* 152365679Shibler * Build hash lists of net addresses and hang them off the mount point. 152465679Shibler * Called by ufs_mount() to set up the lists of export addresses. 152565679Shibler */ 152665679Shibler static int 152765679Shibler vfs_hang_addrlist(mp, nep, argp) 152865679Shibler struct mount *mp; 152965679Shibler struct netexport *nep; 153065679Shibler struct export_args *argp; 153165679Shibler { 153265679Shibler register struct netcred *np; 153365679Shibler register struct radix_node_head *rnh; 153465679Shibler register int i; 153565679Shibler struct radix_node *rn; 153665679Shibler struct sockaddr *saddr, *smask = 0; 153765679Shibler struct domain *dom; 153865679Shibler int error; 153965679Shibler 154065679Shibler if (argp->ex_addrlen == 0) { 154165679Shibler if (mp->mnt_flag & MNT_DEFEXPORTED) 154265679Shibler return (EPERM); 154365679Shibler np = &nep->ne_defexported; 154465679Shibler np->netc_exflags = argp->ex_flags; 154565679Shibler np->netc_anon = argp->ex_anon; 154665679Shibler np->netc_anon.cr_ref = 1; 154765679Shibler mp->mnt_flag |= MNT_DEFEXPORTED; 154865679Shibler return (0); 154965679Shibler } 155065679Shibler i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen; 155165679Shibler np = (struct netcred *)malloc(i, M_NETADDR, M_WAITOK); 155265679Shibler bzero((caddr_t)np, i); 155365679Shibler saddr = (struct sockaddr *)(np + 1); 155465679Shibler if (error = copyin(argp->ex_addr, (caddr_t)saddr, argp->ex_addrlen)) 155565679Shibler goto out; 155665679Shibler if (saddr->sa_len > argp->ex_addrlen) 155765679Shibler saddr->sa_len = argp->ex_addrlen; 155865679Shibler if (argp->ex_masklen) { 155965679Shibler smask = (struct sockaddr *)((caddr_t)saddr + argp->ex_addrlen); 156065679Shibler error = copyin(argp->ex_addr, (caddr_t)smask, argp->ex_masklen); 156165679Shibler if (error) 156265679Shibler goto out; 156365679Shibler if (smask->sa_len > argp->ex_masklen) 156465679Shibler smask->sa_len = argp->ex_masklen; 156565679Shibler } 156665679Shibler i = saddr->sa_family; 156765679Shibler if ((rnh = nep->ne_rtable[i]) == 0) { 156865679Shibler /* 156965679Shibler * Seems silly to initialize every AF when most are not 157065679Shibler * used, do so on demand here 157165679Shibler */ 157265679Shibler for (dom = domains; dom; dom = dom->dom_next) 157365679Shibler if (dom->dom_family == i && dom->dom_rtattach) { 157465679Shibler dom->dom_rtattach((void **)&nep->ne_rtable[i], 157565679Shibler dom->dom_rtoffset); 157665679Shibler break; 157765679Shibler } 157865679Shibler if ((rnh = nep->ne_rtable[i]) == 0) { 157965679Shibler error = ENOBUFS; 158065679Shibler goto out; 158165679Shibler } 158265679Shibler } 158365679Shibler rn = (*rnh->rnh_addaddr)((caddr_t)saddr, (caddr_t)smask, rnh, 158465679Shibler np->netc_rnodes); 158569140Smckusick if (rn == 0) { 158669140Smckusick /* 158769140Smckusick * One of the reasons that rnh_addaddr may fail is that 158869140Smckusick * the entry already exists. To check for this case, we 158969140Smckusick * look up the entry to see if it is there. If so, we 159069140Smckusick * do not need to make a new entry but do return success. 159169140Smckusick */ 159269140Smckusick free(np, M_NETADDR); 159369140Smckusick rn = (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh); 159469140Smckusick if (rn != 0 && (rn->rn_flags & RNF_ROOT) == 0 && 159569140Smckusick ((struct netcred *)rn)->netc_exflags == argp->ex_flags && 159669140Smckusick !bcmp((caddr_t)&((struct netcred *)rn)->netc_anon, 159769140Smckusick (caddr_t)&argp->ex_anon, sizeof(struct ucred))) 159869140Smckusick return (0); 159969140Smckusick return (EPERM); 160065679Shibler } 160165679Shibler np->netc_exflags = argp->ex_flags; 160265679Shibler np->netc_anon = argp->ex_anon; 160365679Shibler np->netc_anon.cr_ref = 1; 160465679Shibler return (0); 160565679Shibler out: 160665679Shibler free(np, M_NETADDR); 160765679Shibler return (error); 160865679Shibler } 160965679Shibler 161065679Shibler /* ARGSUSED */ 161165679Shibler static int 161265679Shibler vfs_free_netcred(rn, w) 161365679Shibler struct radix_node *rn; 161465679Shibler caddr_t w; 161565679Shibler { 161665679Shibler register struct radix_node_head *rnh = (struct radix_node_head *)w; 161765679Shibler 161865679Shibler (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh); 161965679Shibler free((caddr_t)rn, M_NETADDR); 162065679Shibler return (0); 162165679Shibler } 162268319Scgd 162365679Shibler /* 162465679Shibler * Free the net address hash lists that are hanging off the mount points. 162565679Shibler */ 162665679Shibler static void 162765679Shibler vfs_free_addrlist(nep) 162865679Shibler struct netexport *nep; 162965679Shibler { 163065679Shibler register int i; 163165679Shibler register struct radix_node_head *rnh; 163265679Shibler 163365679Shibler for (i = 0; i <= AF_MAX; i++) 163465679Shibler if (rnh = nep->ne_rtable[i]) { 163565679Shibler (*rnh->rnh_walktree)(rnh, vfs_free_netcred, 163665679Shibler (caddr_t)rnh); 163765679Shibler free((caddr_t)rnh, M_RTABLE); 163865679Shibler nep->ne_rtable[i] = 0; 163965679Shibler } 164065679Shibler } 164165679Shibler 164265679Shibler int 164365679Shibler vfs_export(mp, nep, argp) 164465679Shibler struct mount *mp; 164565679Shibler struct netexport *nep; 164665679Shibler struct export_args *argp; 164765679Shibler { 164865679Shibler int error; 164965679Shibler 165065679Shibler if (argp->ex_flags & MNT_DELEXPORT) { 165165679Shibler vfs_free_addrlist(nep); 165265679Shibler mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED); 165365679Shibler } 165465679Shibler if (argp->ex_flags & MNT_EXPORTED) { 165565679Shibler if (error = vfs_hang_addrlist(mp, nep, argp)) 165665679Shibler return (error); 165765679Shibler mp->mnt_flag |= MNT_EXPORTED; 165865679Shibler } 165965679Shibler return (0); 166065679Shibler } 166165679Shibler 166265679Shibler struct netcred * 166365679Shibler vfs_export_lookup(mp, nep, nam) 166465679Shibler register struct mount *mp; 166565679Shibler struct netexport *nep; 166665679Shibler struct mbuf *nam; 166765679Shibler { 166865679Shibler register struct netcred *np; 166965679Shibler register struct radix_node_head *rnh; 167065679Shibler struct sockaddr *saddr; 167165679Shibler 167265679Shibler np = NULL; 167365679Shibler if (mp->mnt_flag & MNT_EXPORTED) { 167465679Shibler /* 167565679Shibler * Lookup in the export list first. 167665679Shibler */ 167765679Shibler if (nam != NULL) { 167865679Shibler saddr = mtod(nam, struct sockaddr *); 167965679Shibler rnh = nep->ne_rtable[saddr->sa_family]; 168065679Shibler if (rnh != NULL) { 168165679Shibler np = (struct netcred *) 168265679Shibler (*rnh->rnh_matchaddr)((caddr_t)saddr, 168365679Shibler rnh); 168465679Shibler if (np && np->netc_rnodes->rn_flags & RNF_ROOT) 168565679Shibler np = NULL; 168665679Shibler } 168765679Shibler } 168865679Shibler /* 168965679Shibler * If no address match, use the default if it exists. 169065679Shibler */ 169165679Shibler if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED) 169265679Shibler np = &nep->ne_defexported; 169365679Shibler } 169465679Shibler return (np); 169565679Shibler } 1696