1 /* $OpenBSD: nfs_node.c,v 1.76 2024/05/01 13:15:59 jsg 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/timeout.h>
42 #include <sys/mount.h>
43 #include <sys/namei.h>
44 #include <sys/vnode.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/pool.h>
48 #include <sys/rwlock.h>
49
50 #include <nfs/nfsproto.h>
51 #include <nfs/nfsnode.h>
52 #include <nfs/nfsmount.h>
53 #include <nfs/nfs_var.h>
54
55 struct pool nfs_node_pool;
56 extern int prtactive;
57
58 /* XXX */
59 extern const struct vops nfs_vops;
60
61 /* filehandle to node lookup. */
62 static __inline int
nfsnode_cmp(const struct nfsnode * a,const struct nfsnode * b)63 nfsnode_cmp(const struct nfsnode *a, const struct nfsnode *b)
64 {
65 if (a->n_fhsize != b->n_fhsize)
66 return (a->n_fhsize - b->n_fhsize);
67 return (memcmp(a->n_fhp, b->n_fhp, a->n_fhsize));
68 }
69
70 RBT_PROTOTYPE(nfs_nodetree, nfsnode, n_entry, nfsnode_cmp);
71 RBT_GENERATE(nfs_nodetree, nfsnode, n_entry, nfsnode_cmp);
72
73 void
nfs_ninit(struct nfsmount * nmp)74 nfs_ninit(struct nfsmount *nmp)
75 {
76 RBT_INIT(nfs_nodetree, &nmp->nm_ntree);
77 }
78
79 /*
80 * Look up a vnode/nfsnode by file handle and store the pointer in *npp.
81 * Callers must check for mount points!!
82 * An error number is returned.
83 */
84 int
nfs_nget(struct mount * mnt,nfsfh_t * fh,int fhsize,struct nfsnode ** npp)85 nfs_nget(struct mount *mnt, nfsfh_t *fh, int fhsize, struct nfsnode **npp)
86 {
87 struct nfsmount *nmp;
88 struct nfsnode *np, find, *np2;
89 struct vnode *vp, *nvp;
90 int error;
91
92 nmp = VFSTONFS(mnt);
93
94 loop:
95 find.n_fhp = fh;
96 find.n_fhsize = fhsize;
97 np = RBT_FIND(nfs_nodetree, &nmp->nm_ntree, &find);
98 if (np != NULL) {
99 vp = NFSTOV(np);
100 error = vget(vp, LK_EXCLUSIVE);
101 if (error)
102 goto loop;
103 *npp = np;
104 return (0);
105 }
106
107 /*
108 * getnewvnode() could recycle a vnode, potentially formerly
109 * owned by NFS. This will cause a VOP_RECLAIM() to happen,
110 * which will cause recursive locking, so we unlock before
111 * calling getnewvnode() lock again afterwards, but must check
112 * to see if this nfsnode has been added while we did not hold
113 * the lock.
114 */
115 error = getnewvnode(VT_NFS, mnt, &nfs_vops, &nvp);
116 /* note that we don't have this vnode set up completely yet */
117 if (error) {
118 *npp = NULL;
119 return (error);
120 }
121 nvp->v_flag |= VLARVAL;
122 np = pool_get(&nfs_node_pool, PR_WAITOK | PR_ZERO);
123 /*
124 * getnewvnode() and pool_get() can sleep, check for race.
125 */
126 if (RBT_FIND(nfs_nodetree, &nmp->nm_ntree, &find) != NULL) {
127 pool_put(&nfs_node_pool, np);
128 vgone(nvp);
129 goto loop;
130 }
131
132 vp = nvp;
133 #ifdef VFSLCKDEBUG
134 vp->v_flag |= VLOCKSWORK;
135 #endif
136 rrw_init_flags(&np->n_lock, "nfsnode", RWL_DUPOK | RWL_IS_VNODE);
137 vp->v_data = np;
138 /* we now have an nfsnode on this vnode */
139 vp->v_flag &= ~VLARVAL;
140 np->n_vnode = vp;
141 rw_init(&np->n_commitlock, "nfs_commitlk");
142 np->n_fhp = &np->n_fh;
143 bcopy(fh, np->n_fhp, fhsize);
144 np->n_fhsize = fhsize;
145 /* lock the nfsnode, then put it on the rbtree */
146 VOP_LOCK(vp, LK_EXCLUSIVE);
147 np2 = RBT_INSERT(nfs_nodetree, &nmp->nm_ntree, np);
148 KASSERT(np2 == NULL);
149 np->n_accstamp = -1;
150 *npp = np;
151
152 return (0);
153 }
154
155 int
nfs_inactive(void * v)156 nfs_inactive(void *v)
157 {
158 struct vop_inactive_args *ap = v;
159 struct nfsnode *np;
160 struct sillyrename *sp;
161
162 #ifdef DIAGNOSTIC
163 if (prtactive && ap->a_vp->v_usecount != 0)
164 vprint("nfs_inactive: pushing active", ap->a_vp);
165 #endif
166 if (ap->a_vp->v_flag & VLARVAL)
167 /*
168 * vnode was incompletely set up, just return
169 * as we are throwing it away.
170 */
171 return(0);
172 #ifdef DIAGNOSTIC
173 if (ap->a_vp->v_data == NULL)
174 panic("NULL v_data (no nfsnode set up?) in vnode %p",
175 ap->a_vp);
176 #endif
177 np = VTONFS(ap->a_vp);
178 if (ap->a_vp->v_type != VDIR) {
179 sp = np->n_sillyrename;
180 np->n_sillyrename = NULL;
181 } else
182 sp = NULL;
183 if (sp != NULL)
184 nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, curproc);
185 np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT);
186
187 VOP_UNLOCK(ap->a_vp);
188
189 if (sp != NULL) {
190 /*
191 * Remove the silly file that was rename'd earlier
192 */
193 vn_lock(sp->s_dvp, LK_EXCLUSIVE | LK_RETRY);
194 nfs_removeit(sp);
195 crfree(sp->s_cred);
196 vput(sp->s_dvp);
197 free(sp, M_NFSREQ, sizeof(*sp));
198 }
199
200 return (0);
201 }
202
203 /*
204 * Reclaim an nfsnode so that it can be used for other purposes.
205 */
206 int
nfs_reclaim(void * v)207 nfs_reclaim(void *v)
208 {
209 struct vop_reclaim_args *ap = v;
210 struct vnode *vp = ap->a_vp;
211 struct nfsmount *nmp;
212 struct nfsnode *np = VTONFS(vp);
213
214 #ifdef DIAGNOSTIC
215 if (prtactive && vp->v_usecount != 0)
216 vprint("nfs_reclaim: pushing active", vp);
217 #endif
218 if (ap->a_vp->v_flag & VLARVAL)
219 /*
220 * vnode was incompletely set up, just return
221 * as we are throwing it away.
222 */
223 return(0);
224 #ifdef DIAGNOSTIC
225 if (ap->a_vp->v_data == NULL)
226 panic("NULL v_data (no nfsnode set up?) in vnode %p",
227 ap->a_vp);
228 #endif
229 nmp = VFSTONFS(vp->v_mount);
230 RBT_REMOVE(nfs_nodetree, &nmp->nm_ntree, np);
231
232 if (np->n_rcred)
233 crfree(np->n_rcred);
234 if (np->n_wcred)
235 crfree(np->n_wcred);
236
237 cache_purge(vp);
238 pool_put(&nfs_node_pool, vp->v_data);
239 vp->v_data = NULL;
240
241 return (0);
242 }
243