1 /* $OpenBSD: nfs_node.c,v 1.48 2009/08/14 17:52:18 thib Exp $ */ 2 /* $NetBSD: nfs_node.c,v 1.16 1996/02/18 11:53:42 fvdl Exp $ */ 3 4 /* 5 * Copyright (c) 1989, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by 9 * Rick Macklem at The University of Guelph. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)nfs_node.c 8.6 (Berkeley) 5/22/95 36 */ 37 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/proc.h> 42 #include <sys/mount.h> 43 #include <sys/namei.h> 44 #include <sys/vnode.h> 45 #include <sys/kernel.h> 46 #include <sys/malloc.h> 47 #include <sys/pool.h> 48 #include <sys/rwlock.h> 49 #include <sys/queue.h> 50 51 #include <nfs/rpcv2.h> 52 #include <nfs/nfsproto.h> 53 #include <nfs/nfs.h> 54 #include <nfs/nfsnode.h> 55 #include <nfs/nfsmount.h> 56 #include <nfs/nfs_var.h> 57 58 struct pool nfs_node_pool; 59 extern int prtactive; 60 61 struct rwlock nfs_hashlock = RWLOCK_INITIALIZER("nfshshlk"); 62 63 /* filehandle to node lookup. */ 64 static __inline int 65 nfsnode_cmp(const struct nfsnode *a, const struct nfsnode *b) 66 { 67 if (a->n_fhsize != b->n_fhsize) 68 return (a->n_fhsize - b->n_fhsize); 69 return (memcmp(a->n_fhp, b->n_fhp, a->n_fhsize)); 70 } 71 72 RB_PROTOTYPE(nfs_nodetree, nfsnode, n_entry, nfsnode_cmp); 73 RB_GENERATE(nfs_nodetree, nfsnode, n_entry, nfsnode_cmp); 74 75 /* 76 * Look up a vnode/nfsnode by file handle. 77 * Callers must check for mount points!! 78 * In all cases, a pointer to a 79 * nfsnode structure is returned. 80 */ 81 int 82 nfs_nget(struct mount *mnt, nfsfh_t *fh, int fhsize, struct nfsnode **npp) 83 { 84 extern int (**nfsv2_vnodeop_p)(void *); /* XXX */ 85 struct nfsmount *nmp; 86 struct nfsnode *np, find, *np2; 87 struct vnode *vp, *nvp; 88 struct proc *p = curproc; /* XXX */ 89 int error; 90 91 nmp = VFSTONFS(mnt); 92 93 loop: 94 rw_enter_write(&nfs_hashlock); 95 find.n_fhp = fh; 96 find.n_fhsize = fhsize; 97 np = RB_FIND(nfs_nodetree, &nmp->nm_ntree, &find); 98 if (np != NULL) { 99 rw_exit_write(&nfs_hashlock); 100 vp = NFSTOV(np); 101 error = vget(vp, LK_EXCLUSIVE, p); 102 if (error) 103 goto loop; 104 *npp = np; 105 return (0); 106 } 107 108 /* 109 * getnewvnode() could recycle a vnode, potentially formerly 110 * owned by NFS. This will cause a VOP_RECLAIM() to happen, 111 * which will cause recursive locking, so we unlock before 112 * calling getnewvnode() lock again afterwards, but must check 113 * to see if this nfsnode has been added while we did not hold 114 * the lock. 115 */ 116 rw_exit_write(&nfs_hashlock); 117 error = getnewvnode(VT_NFS, mnt, nfsv2_vnodeop_p, &nvp); 118 rw_enter_write(&nfs_hashlock); 119 if (error) { 120 *npp = NULL; 121 rw_exit_write(&nfs_hashlock); 122 return (error); 123 } 124 125 np = RB_FIND(nfs_nodetree, &nmp->nm_ntree, &find); 126 if (np != NULL) { 127 rw_exit_write(&nfs_hashlock); 128 goto loop; 129 } 130 131 vp = nvp; 132 np = pool_get(&nfs_node_pool, PR_WAITOK | PR_ZERO); 133 vp->v_data = np; 134 np->n_vnode = vp; 135 136 rw_init(&np->n_commitlock, "nfs_commitlk"); 137 138 /* 139 * Are we getting the root? If so, make sure the vnode flags 140 * are correct 141 */ 142 if ((fhsize == nmp->nm_fhsize) && !bcmp(fh, nmp->nm_fh, fhsize)) { 143 if (vp->v_type == VNON) 144 vp->v_type = VDIR; 145 vp->v_flag |= VROOT; 146 } 147 148 np->n_fhp = &np->n_fh; 149 bcopy(fh, np->n_fhp, fhsize); 150 np->n_fhsize = fhsize; 151 np2 = RB_INSERT(nfs_nodetree, &nmp->nm_ntree, np); 152 KASSERT(np2 == NULL); 153 np->n_accstamp = -1; 154 rw_exit(&nfs_hashlock); 155 *npp = np; 156 157 return (0); 158 } 159 160 int 161 nfs_inactive(void *v) 162 { 163 struct vop_inactive_args *ap = v; 164 struct nfsnode *np = VTONFS(ap->a_vp); 165 struct sillyrename *sp; 166 167 #ifdef DIAGNOSTIC 168 if (prtactive && ap->a_vp->v_usecount != 0) 169 vprint("nfs_inactive: pushing active", ap->a_vp); 170 #endif 171 172 if (ap->a_vp->v_type != VDIR) { 173 sp = np->n_sillyrename; 174 np->n_sillyrename = NULL; 175 } else 176 sp = NULL; 177 if (sp) { 178 /* 179 * Remove the silly file that was rename'd earlier 180 */ 181 nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, curproc); 182 nfs_removeit(sp); 183 crfree(sp->s_cred); 184 vrele(sp->s_dvp); 185 free(sp, M_NFSREQ); 186 } 187 np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT); 188 189 VOP_UNLOCK(ap->a_vp, 0, ap->a_p); 190 return (0); 191 } 192 193 /* 194 * Reclaim an nfsnode so that it can be used for other purposes. 195 */ 196 int 197 nfs_reclaim(void *v) 198 { 199 struct vop_reclaim_args *ap = v; 200 struct vnode *vp = ap->a_vp; 201 struct nfsmount *nmp = VFSTONFS(vp->v_mount); 202 struct nfsnode *np = VTONFS(vp); 203 204 #ifdef DIAGNOSTIC 205 if (prtactive && vp->v_usecount != 0) 206 vprint("nfs_reclaim: pushing active", vp); 207 #endif 208 209 rw_enter_write(&nfs_hashlock); 210 RB_REMOVE(nfs_nodetree, &nmp->nm_ntree, np); 211 rw_exit_write(&nfs_hashlock); 212 213 if (np->n_rcred) 214 crfree(np->n_rcred); 215 if (np->n_wcred) 216 crfree(np->n_wcred); 217 218 cache_purge(vp); 219 pool_put(&nfs_node_pool, vp->v_data); 220 vp->v_data = NULL; 221 222 return (0); 223 } 224