X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/1c79356b52d46aa6b508fb032f5ae709b1f2897b..060df5ea7c632b1ac8cc8aac1fb59758165c2084:/bsd/nfs/nfs_node.c diff --git a/bsd/nfs/nfs_node.c b/bsd/nfs/nfs_node.c index 383428171..7d1926787 100644 --- a/bsd/nfs/nfs_node.c +++ b/bsd/nfs/nfs_node.c @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2009 Apple Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ /* @@ -61,55 +67,66 @@ #include +#include #include #include -#include -#include +#include +#include #include +#include #include #include #include #include #include +#include #include -#ifdef MALLOC_DEFINE -static MALLOC_DEFINE(M_NFSNODE, "NFS node", "NFS vnode private part"); -#endif - -LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl; -u_long nfsnodehash; +#define NFSNOHASH(fhsum) \ + (&nfsnodehashtbl[(fhsum) & nfsnodehash]) +static LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl; +static u_long nfsnodehash; -#define TRUE 1 -#define FALSE 0 +static lck_grp_t *nfs_node_hash_lck_grp; +static lck_grp_t *nfs_node_lck_grp; +static lck_grp_t *nfs_data_lck_grp; +lck_mtx_t *nfs_node_hash_mutex; /* * Initialize hash links for nfsnodes * and build nfsnode free list. */ void -nfs_nhinit() +nfs_nhinit(void) +{ + nfs_node_hash_lck_grp = lck_grp_alloc_init("nfs_node_hash", LCK_GRP_ATTR_NULL); + nfs_node_hash_mutex = lck_mtx_alloc_init(nfs_node_hash_lck_grp, LCK_ATTR_NULL); + nfs_node_lck_grp = lck_grp_alloc_init("nfs_node", LCK_GRP_ATTR_NULL); + nfs_data_lck_grp = lck_grp_alloc_init("nfs_data", LCK_GRP_ATTR_NULL); +} + +void +nfs_nhinit_finish(void) { - nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash); + lck_mtx_lock(nfs_node_hash_mutex); + if (!nfsnodehashtbl) + nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash); + lck_mtx_unlock(nfs_node_hash_mutex); } /* * Compute an entry in the NFS hash table structure */ u_long -nfs_hash(fhp, fhsize) - register nfsfh_t *fhp; - int fhsize; +nfs_hash(u_char *fhp, int fhsize) { - register u_char *fhpp; - register u_long fhsum; - register int i; + u_long fhsum; + int i; - fhpp = &fhp->fh_bytes[0]; fhsum = 0; for (i = 0; i < fhsize; i++) - fhsum += *fhpp++; + fhsum += *fhp++; return (fhsum); } @@ -119,167 +136,523 @@ nfs_hash(fhp, fhsize) * In all cases, a pointer to a * nfsnode structure is returned. */ -int nfs_node_hash_lock; - int -nfs_nget(mntp, fhp, fhsize, npp) - struct mount *mntp; - register nfsfh_t *fhp; - int fhsize; - struct nfsnode **npp; +nfs_nget( + mount_t mp, + nfsnode_t dnp, + struct componentname *cnp, + u_char *fhp, + int fhsize, + struct nfs_vattr *nvap, + u_int64_t *xidp, + int flags, + nfsnode_t *npp) { - struct proc *p = current_proc(); /* XXX */ - struct nfsnode *np; + nfsnode_t np; struct nfsnodehashhead *nhpp; - register struct vnode *vp; - struct vnode *nvp; - int error; + vnode_t vp; + int error, nfsvers; + mount_t mp2; + struct vnode_fsparam vfsp; + uint32_t vid; + + FSDBG_TOP(263, mp, dnp, flags, npp); /* Check for unmount in progress */ - if (mntp->mnt_kern_flag & MNTK_UNMOUNT) { - *npp = 0; - return (EPERM); + if (!mp || (mp->mnt_kern_flag & MNTK_FRCUNMOUNT)) { + *npp = NULL; + error = ENXIO; + FSDBG_BOT(263, mp, dnp, 0xd1e, error); + return (error); } + nfsvers = VFSTONFS(mp)->nm_vers; nhpp = NFSNOHASH(nfs_hash(fhp, fhsize)); loop: + lck_mtx_lock(nfs_node_hash_mutex); for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) { - if (mntp != NFSTOV(np)->v_mount || np->n_fhsize != fhsize || - bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize)) + mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np); + if (mp != mp2 || np->n_fhsize != fhsize || + bcmp(fhp, np->n_fhp, fhsize)) continue; + FSDBG(263, dnp, np, np->n_flag, 0xcace0000); + /* if the node is locked, sleep on it */ + if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) { + np->n_hflag |= NHLOCKWANT; + FSDBG(263, dnp, np, np->n_flag, 0xcace2222); + msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL); + FSDBG(263, dnp, np, np->n_flag, 0xcace3333); + goto loop; + } vp = NFSTOV(np); - if (vget(vp, LK_EXCLUSIVE, p)) + vid = vnode_vid(vp); + lck_mtx_unlock(nfs_node_hash_mutex); + if ((error = vnode_getwithvid(vp, vid))) { + /* + * If vnode is being reclaimed or has already + * changed identity, no need to wait. + */ + FSDBG_BOT(263, dnp, *npp, 0xcace0d1e, error); + return (error); + } + if ((error = nfs_node_lock(np))) { + /* this only fails if the node is now unhashed */ + /* so let's see if we can find/create it again */ + FSDBG(263, dnp, *npp, 0xcaced1e2, error); + vnode_put(vp); + if (flags & NG_NOCREATE) { + *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0xcaced1e0, ENOENT); + return (ENOENT); + } goto loop; - *npp = np; - return(0); + } + /* update attributes */ + if (nvap) + error = nfs_loadattrcache(np, nvap, xidp, 0); + if (error) { + nfs_node_unlock(np); + vnode_put(vp); + } else { + if (dnp && cnp && (flags & NG_MAKEENTRY)) + cache_enter(NFSTOV(dnp), vp, cnp); + *npp = np; + } + FSDBG_BOT(263, dnp, *npp, 0xcace0000, error); + return(error); + } + + FSDBG(263, mp, dnp, npp, 0xaaaaaaaa); + + if (flags & NG_NOCREATE) { + lck_mtx_unlock(nfs_node_hash_mutex); + *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOENT); + return (ENOENT); } + /* - * Obtain a lock to prevent a race condition if the getnewvnode() - * or MALLOC() below happens to block. + * allocate and initialize nfsnode and stick it in the hash + * before calling getnewvnode(). Anyone finding it in the + * hash before initialization is complete will wait for it. */ - if (nfs_node_hash_lock) { - while (nfs_node_hash_lock) { - nfs_node_hash_lock = -1; - tsleep(&nfs_node_hash_lock, PVM, "nfsngt", 0); + MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK); + if (!np) { + lck_mtx_unlock(nfs_node_hash_mutex); + *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOMEM); + return (ENOMEM); + } + bzero(np, sizeof *np); + np->n_hflag |= (NHINIT | NHLOCKED); + np->n_mount = mp; + TAILQ_INIT(&np->n_opens); + TAILQ_INIT(&np->n_lock_owners); + TAILQ_INIT(&np->n_locks); + np->n_dlink.tqe_next = NFSNOLIST; + + if (dnp && cnp && ((cnp->cn_namelen != 2) || + (cnp->cn_nameptr[0] != '.') || (cnp->cn_nameptr[1] != '.'))) { + vnode_t dvp = NFSTOV(dnp); + if (!vnode_get(dvp)) { + if (!vnode_ref(dvp)) + np->n_parent = dvp; + vnode_put(dvp); } - goto loop; } - nfs_node_hash_lock = 1; - /* - * Do the MALLOC before the getnewvnode since doing so afterward - * might cause a bogus v_data pointer to get dereferenced - * elsewhere if MALLOC should block. - */ - MALLOC_ZONE(np, struct nfsnode *, sizeof *np, M_NFSNODE, M_WAITOK); - - error = getnewvnode(VT_NFS, mntp, nfsv2_vnodeop_p, &nvp); + /* setup node's file handle */ + if (fhsize > NFS_SMALLFH) { + MALLOC_ZONE(np->n_fhp, u_char *, + fhsize, M_NFSBIGFH, M_WAITOK); + if (!np->n_fhp) { + lck_mtx_unlock(nfs_node_hash_mutex); + FREE_ZONE(np, sizeof *np, M_NFSNODE); + *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0x80000002, ENOMEM); + return (ENOMEM); + } + } else { + np->n_fhp = &np->n_fh[0]; + } + bcopy(fhp, np->n_fhp, fhsize); + np->n_fhsize = fhsize; + + /* Insert the nfsnode in the hash queue for its new file handle */ + LIST_INSERT_HEAD(nhpp, np, n_hash); + np->n_hflag |= NHHASHED; + FSDBG(266, 0, np, np->n_flag, np->n_hflag); + + /* lock the new nfsnode */ + lck_mtx_init(&np->n_lock, nfs_node_lck_grp, LCK_ATTR_NULL); + lck_rw_init(&np->n_datalock, nfs_data_lck_grp, LCK_ATTR_NULL); + lck_mtx_init(&np->n_openlock, nfs_open_grp, LCK_ATTR_NULL); + lck_mtx_lock(&np->n_lock); + + /* release lock on hash table */ + lck_mtx_unlock(nfs_node_hash_mutex); + + /* do initial loading of attributes */ + error = nfs_loadattrcache(np, nvap, xidp, 1); if (error) { - if (nfs_node_hash_lock < 0) - wakeup(&nfs_node_hash_lock); - nfs_node_hash_lock = 0; + FSDBG(266, 0, np, np->n_flag, 0xb1eb1e); + nfs_node_unlock(np); + lck_mtx_lock(nfs_node_hash_mutex); + LIST_REMOVE(np, n_hash); + np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED); + if (np->n_hflag & NHLOCKWANT) { + np->n_hflag &= ~NHLOCKWANT; + wakeup(np); + } + lck_mtx_unlock(nfs_node_hash_mutex); + if (np->n_parent) { + if (!vnode_get(np->n_parent)) { + vnode_rele(np->n_parent); + vnode_put(np->n_parent); + } + np->n_parent = NULL; + } + lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp); + lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp); + lck_mtx_destroy(&np->n_openlock, nfs_open_grp); + if (np->n_fhsize > NFS_SMALLFH) + FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH); + FREE_ZONE(np, sizeof *np, M_NFSNODE); *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0x80000003, error); + return (error); + } + NFS_CHANGED_UPDATE(nfsvers, np, nvap); + if (nvap->nva_type == VDIR) + NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap); + NMODEINVALIDATE(np); + + /* now, attempt to get a new vnode */ + vfsp.vnfs_mp = mp; + vfsp.vnfs_vtype = nvap->nva_type; + vfsp.vnfs_str = "nfs"; + vfsp.vnfs_dvp = dnp ? NFSTOV(dnp) : NULL; + vfsp.vnfs_fsnode = np; + if (nfsvers == NFS_VER4) { +#if FIFO + if (nvap->nva_type == VFIFO) + vfsp.vnfs_vops = fifo_nfsv4nodeop_p; + else +#endif /* FIFO */ + if (nvap->nva_type == VBLK || nvap->nva_type == VCHR) + vfsp.vnfs_vops = spec_nfsv4nodeop_p; + else + vfsp.vnfs_vops = nfsv4_vnodeop_p; + } else { +#if FIFO + if (nvap->nva_type == VFIFO) + vfsp.vnfs_vops = fifo_nfsv2nodeop_p; + else +#endif /* FIFO */ + if (nvap->nva_type == VBLK || nvap->nva_type == VCHR) + vfsp.vnfs_vops = spec_nfsv2nodeop_p; + else + vfsp.vnfs_vops = nfsv2_vnodeop_p; + } + vfsp.vnfs_markroot = (flags & NG_MARKROOT) ? 1 : 0; + vfsp.vnfs_marksystem = 0; + vfsp.vnfs_rdev = 0; + vfsp.vnfs_filesize = nvap->nva_size; + vfsp.vnfs_cnp = cnp; + vfsp.vnfs_flags = VNFS_ADDFSREF; + if (!dnp || !cnp || !(flags & NG_MAKEENTRY)) + vfsp.vnfs_flags |= VNFS_NOCACHE; + + error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &np->n_vnode); + if (error) { + FSDBG(266, 0, np, np->n_flag, 0xb1eb1e); + nfs_node_unlock(np); + lck_mtx_lock(nfs_node_hash_mutex); + LIST_REMOVE(np, n_hash); + np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED); + if (np->n_hflag & NHLOCKWANT) { + np->n_hflag &= ~NHLOCKWANT; + wakeup(np); + } + lck_mtx_unlock(nfs_node_hash_mutex); + if (np->n_parent) { + if (!vnode_get(np->n_parent)) { + vnode_rele(np->n_parent); + vnode_put(np->n_parent); + } + np->n_parent = NULL; + } + lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp); + lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp); + lck_mtx_destroy(&np->n_openlock, nfs_open_grp); + if (np->n_fhsize > NFS_SMALLFH) + FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH); FREE_ZONE(np, sizeof *np, M_NFSNODE); + *npp = 0; + FSDBG_BOT(263, dnp, *npp, 0x80000004, error); return (error); } - vp = nvp; - bzero((caddr_t)np, sizeof *np); - vp->v_data = np; - np->n_vnode = vp; - /* - * Insert the nfsnode in the hash queue for its new file handle - */ - LIST_INSERT_HEAD(nhpp, np, n_hash); - if (fhsize > NFS_SMALLFH) { - MALLOC_ZONE(np->n_fhp, nfsfh_t *, - fhsize, M_NFSBIGFH, M_WAITOK); - } else - np->n_fhp = &np->n_fh; - bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize); - np->n_fhsize = fhsize; - *npp = np; + vp = np->n_vnode; + vnode_settag(vp, VT_NFS); + /* node is now initialized */ - if (nfs_node_hash_lock < 0) - wakeup(&nfs_node_hash_lock); - nfs_node_hash_lock = 0; + /* check if anyone's waiting on this node */ + lck_mtx_lock(nfs_node_hash_mutex); + np->n_hflag &= ~(NHINIT|NHLOCKED); + if (np->n_hflag & NHLOCKWANT) { + np->n_hflag &= ~NHLOCKWANT; + wakeup(np); + } + lck_mtx_unlock(nfs_node_hash_mutex); - /* - * Lock the new nfsnode. - */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + *npp = np; - return (0); + FSDBG_BOT(263, dnp, vp, *npp, error); + return (error); } + int -nfs_inactive(ap) - struct vop_inactive_args /* { - struct vnode *a_vp; - struct proc *a_p; +nfs_vnop_inactive(ap) + struct vnop_inactive_args /* { + struct vnodeop_desc *a_desc; + vnode_t a_vp; + vfs_context_t a_context; } */ *ap; { - register struct nfsnode *np; - register struct sillyrename *sp; - struct proc *p = current_proc(); /* XXX */ - extern int prtactive; - struct ucred *cred; - - np = VTONFS(ap->a_vp); - if (prtactive && ap->a_vp->v_usecount != 0) - vprint("nfs_inactive: pushing active", ap->a_vp); - if (ap->a_vp->v_type != VDIR) { - sp = np->n_sillyrename; - np->n_sillyrename = (struct sillyrename *)0; - } else - sp = (struct sillyrename *)0; - - if (sp) { + vnode_t vp = ap->a_vp; + vfs_context_t ctx = ap->a_context; + nfsnode_t np = VTONFS(ap->a_vp); + struct nfs_sillyrename *nsp; + struct nfs_vattr nvattr; + int unhash, attrerr, busyerror, error, inuse, busied; + struct nfs_open_file *nofp; + const char *vname = NULL; + struct componentname cn; + struct nfsmount *nmp = NFSTONMP(np); + +restart: + error = 0; + inuse = ((nmp->nm_vers >= NFS_VER4) && (nfs_mount_state_in_use_start(nmp) == 0)); + + /* There shouldn't be any open or lock state at this point */ + lck_mtx_lock(&np->n_openlock); + if (np->n_openrefcnt) { + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: still open: %d %s\n", np->n_openrefcnt, vname ? vname : "//"); + } + TAILQ_FOREACH(nofp, &np->n_opens, nof_link) { + lck_mtx_lock(&nofp->nof_lock); + if (nofp->nof_flags & NFS_OPEN_FILE_BUSY) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: open file busy: %s\n", vname ? vname : "//"); + busied = 0; + } else { + nofp->nof_flags |= NFS_OPEN_FILE_BUSY; + busied = 1; + } + lck_mtx_unlock(&nofp->nof_lock); /* - * Remove the silly file that was rename'd earlier + * If we just created the file, we already had it open in + * anticipation of getting a subsequent open call. If the + * node has gone inactive without being open, we need to + * clean up (close) the open done in the create. */ -#if DIAGNOSTIC - kprintf("nfs_inactive removing %s, dvp=%x, a_vp=%x, ap=%x, np=%x, sp=%x\n", &sp->s_name[0], (unsigned)sp->s_dvp, (unsigned)ap->a_vp, (unsigned)ap, (unsigned)np, (unsigned)sp); -#endif + if ((nofp->nof_flags & NFS_OPEN_FILE_CREATE) && nofp->nof_creator) { + if (nofp->nof_flags & NFS_OPEN_FILE_REOPEN) { + lck_mtx_unlock(&np->n_openlock); + if (busied) + nfs_open_file_clear_busy(nofp); + if (inuse) + nfs_mount_state_in_use_end(nmp, 0); + nfs4_reopen(nofp, vfs_context_thread(ctx)); + goto restart; + } + nofp->nof_flags &= ~NFS_OPEN_FILE_CREATE; + lck_mtx_unlock(&np->n_openlock); + error = nfs4_close(np, nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, ctx); + if (error) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: create close error: %d, %s\n", error, vname); + nofp->nof_flags |= NFS_OPEN_FILE_CREATE; + } + if (busied) + nfs_open_file_clear_busy(nofp); + if (inuse) + nfs_mount_state_in_use_end(nmp, error); + goto restart; + } + if (nofp->nof_flags & NFS_OPEN_FILE_NEEDCLOSE) { + /* + * If the file is marked as needing reopen, but this was the only + * open on the file, just drop the open. + */ + nofp->nof_flags &= ~NFS_OPEN_FILE_NEEDCLOSE; + if ((nofp->nof_flags & NFS_OPEN_FILE_REOPEN) && (nofp->nof_opencnt == 1)) { + nofp->nof_flags &= ~NFS_OPEN_FILE_REOPEN; + nofp->nof_r--; + nofp->nof_opencnt--; + nofp->nof_access = 0; + } else { + lck_mtx_unlock(&np->n_openlock); + if (nofp->nof_flags & NFS_OPEN_FILE_REOPEN) { + if (busied) + nfs_open_file_clear_busy(nofp); + if (inuse) + nfs_mount_state_in_use_end(nmp, 0); + nfs4_reopen(nofp, vfs_context_thread(ctx)); + goto restart; + } + error = nfs4_close(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx); + if (error) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: need close error: %d, %s\n", error, vname); + nofp->nof_flags |= NFS_OPEN_FILE_NEEDCLOSE; + } + if (busied) + nfs_open_file_clear_busy(nofp); + if (inuse) + nfs_mount_state_in_use_end(nmp, error); + goto restart; + } + } + if (nofp->nof_opencnt) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: file still open: %d %s\n", nofp->nof_opencnt, vname ? vname : "//"); + } + if (nofp->nof_access || nofp->nof_deny || + nofp->nof_mmap_access || nofp->nof_mmap_deny || + nofp->nof_r || nofp->nof_w || nofp->nof_rw || + nofp->nof_r_dw || nofp->nof_w_dw || nofp->nof_rw_dw || + nofp->nof_r_drw || nofp->nof_w_drw || nofp->nof_rw_drw) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_inactive: non-zero access: %d %d %d %d # %u %u %u dw %u %u %u drw %u %u %u %s\n", + nofp->nof_access, nofp->nof_deny, + nofp->nof_mmap_access, nofp->nof_mmap_deny, + nofp->nof_r, nofp->nof_w, nofp->nof_rw, + nofp->nof_r_dw, nofp->nof_w_dw, nofp->nof_rw_dw, + nofp->nof_r_drw, nofp->nof_w_drw, nofp->nof_rw_drw, + vname ? vname : "//"); + } + if (busied) + nfs_open_file_clear_busy(nofp); + } + lck_mtx_unlock(&np->n_openlock); + if (vname) + vnode_putname(vname); + + if (inuse && nfs_mount_state_in_use_end(nmp, error)) + goto restart; + + nfs_node_lock_force(np); + + if (vnode_vtype(vp) != VDIR) { + nsp = np->n_sillyrename; + np->n_sillyrename = NULL; + } else { + nsp = NULL; + } + + FSDBG_TOP(264, vp, np, np->n_flag, nsp); + + if (!nsp) { + /* no silly file to clean up... */ + /* clear all flags other than these */ + np->n_flag &= (NMODIFIED); + nfs_node_unlock(np); + FSDBG_BOT(264, vp, np, np->n_flag, 0); + return (0); + } + nfs_node_unlock(np); + + /* Remove the silly file that was rename'd earlier */ + + /* flush all the buffers */ + nfs_vinvalbuf2(vp, V_SAVE, vfs_context_thread(ctx), nsp->nsr_cred, 1); + + /* try to get the latest attributes */ + attrerr = nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED); + + /* Check if we should remove it from the node hash. */ + /* Leave it if inuse or it has multiple hard links. */ + if (vnode_isinuse(vp, 0) || (!attrerr && (nvattr.nva_nlink > 1))) { + unhash = 0; + } else { + unhash = 1; + ubc_setsize(vp, 0); + } + + /* mark this node and the directory busy while we do the remove */ + busyerror = nfs_node_set_busy2(nsp->nsr_dnp, np, vfs_context_thread(ctx)); + + /* lock the node while we remove the silly file */ + lck_mtx_lock(nfs_node_hash_mutex); + while (np->n_hflag & NHLOCKED) { + np->n_hflag |= NHLOCKWANT; + msleep(np, nfs_node_hash_mutex, PINOD, "nfs_inactive", NULL); + } + np->n_hflag |= NHLOCKED; + lck_mtx_unlock(nfs_node_hash_mutex); + + /* purge the name cache to deter others from finding it */ + bzero(&cn, sizeof(cn)); + cn.cn_nameptr = nsp->nsr_name; + cn.cn_namelen = nsp->nsr_namlen; + nfs_name_cache_purge(nsp->nsr_dnp, np, &cn, ctx); + + FSDBG(264, np, np->n_size, np->n_vattr.nva_size, 0xf00d00f1); + + /* now remove the silly file */ + nfs_removeit(nsp); + + /* clear all flags other than these */ + nfs_node_lock_force(np); + np->n_flag &= (NMODIFIED); + nfs_node_unlock(np); + + if (!busyerror) + nfs_node_clear_busy2(nsp->nsr_dnp, np); + + if (unhash && vnode_isinuse(vp, 0)) { + /* vnode now inuse after silly remove? */ + unhash = 0; + ubc_setsize(vp, np->n_size); + } + + lck_mtx_lock(nfs_node_hash_mutex); + if (unhash) { /* - * We get a reference (vget) to ensure getnewvnode() - * doesn't recycle vp while we're asleep awaiting I/O. - * Note we don't need the reference unless usecount is - * already zero. In the case of a forcible unmount it - * wont be zero and doing a vget would fail because - * vclean holds VXLOCK. + * remove nfsnode from hash now so we can't accidentally find it + * again if another object gets created with the same filehandle + * before this vnode gets reclaimed */ - if (ap->a_vp->v_usecount > 0) { - VREF(ap->a_vp); - } else if (vget(ap->a_vp, 0, ap->a_p)) - panic("nfs_inactive: vget failed"); - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1); - ubc_setsize(ap->a_vp, (off_t)0); - - /* We have a problem. The dvp could have gone away on us - * while in the unmount path. Thus it appears as VBAD and we - * cannot use it. If we tried locking the parent (future), for silly - * rename files, it is unclear where we would lock. The unmount - * code just pulls unlocked vnodes as it goes thru its list and - * yanks them. Could unmount be smarter to see if a busy reg vnode has - * a parent, and not yank it yet? Put in more passes at unmount - * time? In the meantime, just check if it went away on us. Could - * have gone away during the nfs_vinvalbuf or ubc_setsize which block. - * Or perhaps even before nfs_inactive got called. - */ - if ((sp->s_dvp)->v_type != VBAD) - nfs_removeit(sp); /* uses the dvp */ - cred = sp->s_cred; - if (cred != NOCRED) { - sp->s_cred = NOCRED; - crfree(cred); + if (np->n_hflag & NHHASHED) { + LIST_REMOVE(np, n_hash); + np->n_hflag &= ~NHHASHED; + FSDBG(266, 0, np, np->n_flag, 0xb1eb1e); } - vrele(sp->s_dvp); - FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ); - vrele(ap->a_vp); + vnode_recycle(vp); + } + /* unlock the node */ + np->n_hflag &= ~NHLOCKED; + if (np->n_hflag & NHLOCKWANT) { + np->n_hflag &= ~NHLOCKWANT; + wakeup(np); } - np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED | - NQNFSNONCACHE | NQNFSWRITE); - VOP_UNLOCK(ap->a_vp, 0, ap->a_p); + lck_mtx_unlock(nfs_node_hash_mutex); + + /* cleanup sillyrename info */ + if (nsp->nsr_cred != NOCRED) + kauth_cred_unref(&nsp->nsr_cred); + vnode_rele(NFSTOV(nsp->nsr_dnp)); + FREE_ZONE(nsp, sizeof(*nsp), M_NFSREQ); + + FSDBG_BOT(264, vp, np, np->n_flag, 0); return (0); } @@ -287,165 +660,451 @@ nfs_inactive(ap) * Reclaim an nfsnode so that it can be used for other purposes. */ int -nfs_reclaim(ap) - struct vop_reclaim_args /* { - struct vnode *a_vp; +nfs_vnop_reclaim(ap) + struct vnop_reclaim_args /* { + struct vnodeop_desc *a_desc; + vnode_t a_vp; + vfs_context_t a_context; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct nfsnode *np = VTONFS(vp); - register struct nfsmount *nmp = VFSTONFS(vp->v_mount); - register struct nfsdmap *dp, *dp2; - extern int prtactive; + vnode_t vp = ap->a_vp; + nfsnode_t np = VTONFS(vp); + vfs_context_t ctx = ap->a_context; + struct nfs_open_file *nofp, *nextnofp; + struct nfs_file_lock *nflp, *nextnflp; + struct nfs_lock_owner *nlop, *nextnlop; + const char *vname = NULL; + struct nfsmount *nmp = np->n_mount ? VFSTONFS(np->n_mount) : NFSTONMP(np); - if (prtactive && vp->v_usecount != 0) - vprint("nfs_reclaim: pushing active", vp); + FSDBG_TOP(265, vp, np, np->n_flag, 0); - LIST_REMOVE(np, n_hash); + /* There shouldn't be any open or lock state at this point */ + lck_mtx_lock(&np->n_openlock); - /* - * In case we block during FREE_ZONEs below, get the entry out - * of tbe name cache now so subsequent lookups won't find it. - */ - cache_purge(vp); - - /* - * For nqnfs, take it off the timer queue as required. - */ - if ((nmp->nm_flag & NFSMNT_NQNFS) && np->n_timer.cqe_next != 0) { - CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer); + if (nmp && (nmp->nm_vers >= NFS_VER4)) { + /* need to drop a delegation */ + if (np->n_dlink.tqe_next != NFSNOLIST) { + /* remove this node from the recall list */ + lck_mtx_lock(&nmp->nm_lock); + if (np->n_dlink.tqe_next != NFSNOLIST) { + TAILQ_REMOVE(&nmp->nm_recallq, np, n_dlink); + np->n_dlink.tqe_next = NFSNOLIST; + } + lck_mtx_unlock(&nmp->nm_lock); + } + if (np->n_openflags & N_DELEG_MASK) { + np->n_openflags &= ~N_DELEG_MASK; + nfs4_delegreturn_rpc(nmp, np->n_fhp, np->n_fhsize, &np->n_dstateid, + vfs_context_thread(ctx), vfs_context_ucred(ctx)); + } } - /* - * Free up any directory cookie structures and - * large file handle structures that might be associated with - * this nfs node. - */ - if (vp->v_type == VDIR) { - dp = np->n_cookies.lh_first; - while (dp) { - dp2 = dp; - dp = dp->ndm_list.le_next; - FREE_ZONE((caddr_t)dp2, - sizeof (struct nfsdmap), M_NFSDIROFF); + /* clean up file locks */ + TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) { + if (!(nflp->nfl_flags & NFS_FILE_LOCK_DEAD)) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: lock 0x%llx 0x%llx 0x%x (bc %d) %s\n", + nflp->nfl_start, nflp->nfl_end, nflp->nfl_flags, + nflp->nfl_blockcnt, vname ? vname : "//"); + } + if (!(nflp->nfl_flags & NFS_FILE_LOCK_BLOCKED)) { + lck_mtx_lock(&nflp->nfl_owner->nlo_lock); + TAILQ_REMOVE(&nflp->nfl_owner->nlo_locks, nflp, nfl_lolink); + lck_mtx_unlock(&nflp->nfl_owner->nlo_lock); + } + TAILQ_REMOVE(&np->n_locks, nflp, nfl_link); + nfs_file_lock_destroy(nflp); + } + /* clean up lock owners */ + TAILQ_FOREACH_SAFE(nlop, &np->n_lock_owners, nlo_link, nextnlop) { + if (!TAILQ_EMPTY(&nlop->nlo_locks)) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: lock owner with locks %s\n", + vname ? vname : "//"); } + TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link); + nfs_lock_owner_destroy(nlop); } - if (np->n_fhsize > NFS_SMALLFH) { - FREE_ZONE((caddr_t)np->n_fhp, np->n_fhsize, M_NFSBIGFH); + /* clean up open state */ + if (np->n_openrefcnt) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: still open: %d %s\n", + np->n_openrefcnt, vname ? vname : "//"); } + TAILQ_FOREACH_SAFE(nofp, &np->n_opens, nof_link, nextnofp) { + if (nofp->nof_flags & NFS_OPEN_FILE_BUSY) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: open file busy: %s\n", + vname ? vname : "//"); + } + if (nofp->nof_opencnt) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: file still open: %d %s\n", + nofp->nof_opencnt, vname ? vname : "//"); + } + if (nofp->nof_access || nofp->nof_deny || + nofp->nof_mmap_access || nofp->nof_mmap_deny || + nofp->nof_r || nofp->nof_w || nofp->nof_rw || + nofp->nof_r_dw || nofp->nof_w_dw || nofp->nof_rw_dw || + nofp->nof_r_drw || nofp->nof_w_drw || nofp->nof_rw_drw) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_vnop_reclaim: non-zero access: %d %d %d %d # %u %u %u dw %u %u %u drw %u %u %u %s\n", + nofp->nof_access, nofp->nof_deny, + nofp->nof_mmap_access, nofp->nof_mmap_deny, + nofp->nof_r, nofp->nof_w, nofp->nof_rw, + nofp->nof_r_dw, nofp->nof_w_dw, nofp->nof_rw_dw, + nofp->nof_r_drw, nofp->nof_w_drw, nofp->nof_rw_drw, + vname ? vname : "//"); + } + TAILQ_REMOVE(&np->n_opens, nofp, nof_link); + nfs_open_file_destroy(nofp); + } + lck_mtx_unlock(&np->n_openlock); - FREE_ZONE(vp->v_data, sizeof (struct nfsnode), M_NFSNODE); - vp->v_data = (void *)0; - return (0); -} + lck_mtx_lock(nfs_buf_mutex); + if (!LIST_EMPTY(&np->n_dirtyblkhd) || !LIST_EMPTY(&np->n_cleanblkhd)) { + if (!vname) + vname = vnode_getname(vp); + printf("nfs_reclaim: dropping %s buffers for file %s\n", + (!LIST_EMPTY(&np->n_dirtyblkhd) ? "dirty" : "clean"), + (vname ? vname : "//")); + } + lck_mtx_unlock(nfs_buf_mutex); + if (vname) + vnode_putname(vname); + nfs_vinvalbuf(vp, V_IGNORE_WRITEERR, ap->a_context, 0); -#if 0 -/* - * Lock an nfsnode - */ -int -nfs_lock(ap) - struct vop_lock_args /* { - struct vnode *a_vp; - } */ *ap; -{ - register struct vnode *vp = ap->a_vp; + lck_mtx_lock(nfs_node_hash_mutex); - /* - * Ugh, another place where interruptible mounts will get hung. - * If you make this sleep interruptible, then you have to fix all - * the VOP_LOCK() calls to expect interruptibility. - */ - while (vp->v_flag & VXLOCK) { - vp->v_flag |= VXWANT; - (void) tsleep((caddr_t)vp, PINOD, "nfslck", 0); + if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename) { + printf("nfs_reclaim: leaving unlinked file %s\n", np->n_sillyrename->nsr_name); + if (np->n_sillyrename->nsr_cred != NOCRED) + kauth_cred_unref(&np->n_sillyrename->nsr_cred); + vnode_rele(NFSTOV(np->n_sillyrename->nsr_dnp)); + FREE_ZONE(np->n_sillyrename, sizeof(*np->n_sillyrename), M_NFSREQ); } - if (vp->v_tag == VT_NON) - return (ENOENT); -#if 0 + vnode_removefsref(vp); + + if (np->n_hflag & NHHASHED) { + LIST_REMOVE(np, n_hash); + np->n_hflag &= ~NHHASHED; + FSDBG(266, 0, np, np->n_flag, 0xb1eb1e); + } + lck_mtx_unlock(nfs_node_hash_mutex); + /* - * Only lock regular files. If a server crashed while we were - * holding a directory lock, we could easily end up sleeping - * until the server rebooted while holding a lock on the root. - * Locks are only needed for protecting critical sections in - * VMIO at the moment. - * New vnodes will have type VNON but they should be locked - * since they may become VREG. This is checked in loadattrcache - * and unwanted locks are released there. + * Free up any directory cookie structures and large file handle + * structures that might be associated with this nfs node. */ - if (vp->v_type == VREG || vp->v_type == VNON) { - while (np->n_flag & NLOCKED) { - np->n_flag |= NWANTED; - (void) tsleep((caddr_t) np, PINOD, "nfslck2", 0); - /* - * If the vnode has transmuted into a VDIR while we - * were asleep, then skip the lock. - */ - if (vp->v_type != VREG && vp->v_type != VNON) - return (0); + nfs_node_lock_force(np); + if ((vnode_vtype(vp) == VDIR) && np->n_cookiecache) + FREE_ZONE(np->n_cookiecache, sizeof(struct nfsdmap), M_NFSDIROFF); + if (np->n_fhsize > NFS_SMALLFH) + FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH); + nfs_node_unlock(np); + vnode_clearfsnode(vp); + + if (np->n_parent) { + if (!vnode_get(np->n_parent)) { + vnode_rele(np->n_parent); + vnode_put(np->n_parent); } - np->n_flag |= NLOCKED; + np->n_parent = NULL; } -#endif + lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp); + lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp); + lck_mtx_destroy(&np->n_openlock, nfs_open_grp); + + FSDBG_BOT(265, vp, np, np->n_flag, 0xd1ed1e); + FREE_ZONE(np, sizeof(struct nfsnode), M_NFSNODE); return (0); } /* - * Unlock an nfsnode + * Acquire an NFS node lock */ + int -nfs_unlock(ap) - struct vop_unlock_args /* { - struct vnode *a_vp; - } */ *ap; +nfs_node_lock_internal(nfsnode_t np, int force) { -#if 0 - struct vnode* vp = ap->a_vp; - struct nfsnode* np = VTONFS(vp); - - if (vp->v_type == VREG || vp->v_type == VNON) { - if (!(np->n_flag & NLOCKED)) - panic("nfs_unlock: nfsnode not locked"); - np->n_flag &= ~NLOCKED; - if (np->n_flag & NWANTED) { - np->n_flag &= ~NWANTED; - wakeup((caddr_t) np); - } + FSDBG_TOP(268, np, force, 0, 0); + lck_mtx_lock(&np->n_lock); + if (!force && !(np->n_hflag && NHHASHED)) { + FSDBG_BOT(268, np, 0xdead, 0, 0); + lck_mtx_unlock(&np->n_lock); + return (ENOENT); } -#endif - + FSDBG_BOT(268, np, force, 0, 0); return (0); } +int +nfs_node_lock(nfsnode_t np) +{ + return nfs_node_lock_internal(np, 0); +} + +void +nfs_node_lock_force(nfsnode_t np) +{ + nfs_node_lock_internal(np, 1); +} + /* - * Check for a locked nfsnode + * Release an NFS node lock + */ +void +nfs_node_unlock(nfsnode_t np) +{ + FSDBG(269, np, current_thread(), 0, 0); + lck_mtx_unlock(&np->n_lock); +} + +/* + * Acquire 2 NFS node locks + * - locks taken in reverse address order + * - both or neither of the locks are taken + * - only one lock taken per node (dup nodes are skipped) */ int -nfs_islocked(ap) - struct vop_islocked_args /* { - struct vnode *a_vp; - } */ *ap; +nfs_node_lock2(nfsnode_t np1, nfsnode_t np2) { - return VTONFS(ap->a_vp)->n_flag & NLOCKED ? 1 : 0; + nfsnode_t first, second; + int error; + + first = (np1 > np2) ? np1 : np2; + second = (np1 > np2) ? np2 : np1; + if ((error = nfs_node_lock(first))) + return (error); + if (np1 == np2) + return (error); + if ((error = nfs_node_lock(second))) + nfs_node_unlock(first); + return (error); +} + +void +nfs_node_unlock2(nfsnode_t np1, nfsnode_t np2) +{ + nfs_node_unlock(np1); + if (np1 != np2) + nfs_node_unlock(np2); } -#endif /* - * Nfs abort op, called after namei() when a CREATE/DELETE isn't actually - * done. Currently nothing to do. + * Manage NFS node busy state. + * (Similar to NFS node locks above) */ -/* ARGSUSED */ int -nfs_abortop(ap) - struct vop_abortop_args /* { - struct vnode *a_dvp; - struct componentname *a_cnp; - } */ *ap; +nfs_node_set_busy(nfsnode_t np, thread_t thd) +{ + struct timespec ts = { 2, 0 }; + int error; + + if ((error = nfs_node_lock(np))) + return (error); + while (ISSET(np->n_flag, NBUSY)) { + SET(np->n_flag, NBUSYWANT); + msleep(np, &np->n_lock, PZERO-1, "nfsbusywant", &ts); + if ((error = nfs_sigintr(NFSTONMP(np), NULL, thd, 0))) + break; + } + if (!error) + SET(np->n_flag, NBUSY); + nfs_node_unlock(np); + return (error); +} + +void +nfs_node_clear_busy(nfsnode_t np) +{ + int wanted; + + nfs_node_lock_force(np); + wanted = ISSET(np->n_flag, NBUSYWANT); + CLR(np->n_flag, NBUSY|NBUSYWANT); + nfs_node_unlock(np); + if (wanted) + wakeup(np); +} + +int +nfs_node_set_busy2(nfsnode_t np1, nfsnode_t np2, thread_t thd) +{ + nfsnode_t first, second; + int error; + + first = (np1 > np2) ? np1 : np2; + second = (np1 > np2) ? np2 : np1; + if ((error = nfs_node_set_busy(first, thd))) + return (error); + if (np1 == np2) + return (error); + if ((error = nfs_node_set_busy(second, thd))) + nfs_node_clear_busy(first); + return (error); +} + +void +nfs_node_clear_busy2(nfsnode_t np1, nfsnode_t np2) +{ + nfs_node_clear_busy(np1); + if (np1 != np2) + nfs_node_clear_busy(np2); +} + +/* helper function to sort four nodes in reverse address order (no dupes) */ +static void +nfs_node_sort4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4, nfsnode_t *list, int *lcntp) +{ + nfsnode_t na[2], nb[2]; + int a, b, i, lcnt; + + /* sort pairs then merge */ + na[0] = (np1 > np2) ? np1 : np2; + na[1] = (np1 > np2) ? np2 : np1; + nb[0] = (np3 > np4) ? np3 : np4; + nb[1] = (np3 > np4) ? np4 : np3; + for (a = b = i = lcnt = 0; i < 4; i++) { + if (a >= 2) + list[lcnt] = nb[b++]; + else if ((b >= 2) || (na[a] >= nb[b])) + list[lcnt] = na[a++]; + else + list[lcnt] = nb[b++]; + if ((lcnt <= 0) || (list[lcnt] != list[lcnt-1])) + lcnt++; /* omit dups */ + } + if (list[lcnt-1] == NULL) + lcnt--; + *lcntp = lcnt; +} + +int +nfs_node_set_busy4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4, thread_t thd) { + nfsnode_t list[4]; + int i, lcnt, error; - if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) - FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI); + nfs_node_sort4(np1, np2, np3, np4, list, &lcnt); + + /* Now we can lock using list[0 - lcnt-1] */ + for (i = 0; i < lcnt; ++i) + if ((error = nfs_node_set_busy(list[i], thd))) { + /* Drop any locks we acquired. */ + while (--i >= 0) + nfs_node_clear_busy(list[i]); + return (error); + } return (0); } + +void +nfs_node_clear_busy4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4) +{ + nfsnode_t list[4]; + int lcnt; + + nfs_node_sort4(np1, np2, np3, np4, list, &lcnt); + while (--lcnt >= 0) + nfs_node_clear_busy(list[lcnt]); +} + +/* + * Acquire an NFS node data lock + */ +void +nfs_data_lock(nfsnode_t np, int locktype) +{ + nfs_data_lock_internal(np, locktype, 1); +} +void +nfs_data_lock_noupdate(nfsnode_t np, int locktype) +{ + nfs_data_lock_internal(np, locktype, 0); +} +void +nfs_data_lock_internal(nfsnode_t np, int locktype, int updatesize) +{ + FSDBG_TOP(270, np, locktype, np->n_datalockowner, 0); + if (locktype == NFS_DATA_LOCK_SHARED) { + if (updatesize && ISSET(np->n_flag, NUPDATESIZE)) + nfs_data_update_size(np, 0); + lck_rw_lock_shared(&np->n_datalock); + } else { + lck_rw_lock_exclusive(&np->n_datalock); + np->n_datalockowner = current_thread(); + if (updatesize && ISSET(np->n_flag, NUPDATESIZE)) + nfs_data_update_size(np, 1); + } + FSDBG_BOT(270, np, locktype, np->n_datalockowner, 0); +} + +/* + * Release an NFS node data lock + */ +void +nfs_data_unlock(nfsnode_t np) +{ + nfs_data_unlock_internal(np, 1); +} +void +nfs_data_unlock_noupdate(nfsnode_t np) +{ + nfs_data_unlock_internal(np, 0); +} +void +nfs_data_unlock_internal(nfsnode_t np, int updatesize) +{ + int mine = (np->n_datalockowner == current_thread()); + FSDBG_TOP(271, np, np->n_datalockowner, current_thread(), 0); + if (updatesize && mine && ISSET(np->n_flag, NUPDATESIZE)) + nfs_data_update_size(np, 1); + np->n_datalockowner = NULL; + lck_rw_done(&np->n_datalock); + if (updatesize && !mine && ISSET(np->n_flag, NUPDATESIZE)) + nfs_data_update_size(np, 0); + FSDBG_BOT(271, np, np->n_datalockowner, current_thread(), 0); +} + + +/* + * update an NFS node's size + */ +void +nfs_data_update_size(nfsnode_t np, int datalocked) +{ + int error; + + FSDBG_TOP(272, np, np->n_flag, np->n_size, np->n_newsize); + if (!datalocked) { + nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE); + /* grabbing data lock will automatically update size */ + nfs_data_unlock(np); + FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize); + return; + } + error = nfs_node_lock(np); + if (error || !ISSET(np->n_flag, NUPDATESIZE)) { + if (!error) + nfs_node_unlock(np); + FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize); + return; + } + CLR(np->n_flag, NUPDATESIZE); + np->n_size = np->n_newsize; + /* make sure we invalidate buffers the next chance we get */ + SET(np->n_flag, NNEEDINVALIDATE); + nfs_node_unlock(np); + ubc_setsize(NFSTOV(np), (off_t)np->n_size); /* XXX error? */ + FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize); +} +