![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_node.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / nfs|
Return to nfs_node.c CVS log | Up to [Net/2] / Net2 / nfs |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Rick Macklem at The University of Guelph.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)nfs_node.c 7.34 (Berkeley) 5/15/91
37: */
38:
39: #include "param.h"
40: #include "systm.h"
41: #include "proc.h"
42: #include "mount.h"
43: #include "namei.h"
44: #include "vnode.h"
45: #include "kernel.h"
46: #include "malloc.h"
47:
48: #include "nfsv2.h"
49: #include "nfs.h"
50: #include "nfsnode.h"
51: #include "nfsmount.h"
52:
53: /* The request list head */
54: extern struct nfsreq nfsreqh;
55:
56: #define NFSNOHSZ 512
57: #if ((NFSNOHSZ&(NFSNOHSZ-1)) == 0)
58: #define NFSNOHASH(fhsum) ((fhsum)&(NFSNOHSZ-1))
59: #else
60: #define NFSNOHASH(fhsum) (((unsigned)(fhsum))%NFSNOHSZ)
61: #endif
62:
63: union nhead {
64: union nhead *nh_head[2];
65: struct nfsnode *nh_chain[2];
66: } nhead[NFSNOHSZ];
67:
68: #define TRUE 1
69: #define FALSE 0
70:
71: /*
72: * Initialize hash links for nfsnodes
73: * and build nfsnode free list.
74: */
75: nfs_nhinit()
76: {
77: register int i;
78: register union nhead *nh = nhead;
79:
80: #ifndef lint
81: if (VN_MAXPRIVATE < sizeof(struct nfsnode))
82: panic("nfs_nhinit: too small");
83: #endif /* not lint */
84: for (i = NFSNOHSZ; --i >= 0; nh++) {
85: nh->nh_head[0] = nh;
86: nh->nh_head[1] = nh;
87: }
88: }
89:
90: /*
91: * Compute an entry in the NFS hash table structure
92: */
93: union nhead *
94: nfs_hash(fhp)
95: register nfsv2fh_t *fhp;
96: {
97: register u_char *fhpp;
98: register u_long fhsum;
99: int i;
100:
101: fhpp = &fhp->fh_bytes[0];
102: fhsum = 0;
103: for (i = 0; i < NFSX_FH; i++)
104: fhsum += *fhpp++;
105: return (&nhead[NFSNOHASH(fhsum)]);
106: }
107:
108: /*
109: * Look up a vnode/nfsnode by file handle.
110: * Callers must check for mount points!!
111: * In all cases, a pointer to a
112: * nfsnode structure is returned.
113: */
114: nfs_nget(mntp, fhp, npp)
115: struct mount *mntp;
116: register nfsv2fh_t *fhp;
117: struct nfsnode **npp;
118: {
119: register struct nfsnode *np;
120: register struct vnode *vp;
121: extern struct vnodeops nfsv2_vnodeops;
122: struct vnode *nvp;
123: union nhead *nh;
124: int error;
125:
126: nh = nfs_hash(fhp);
127: loop:
128: for (np = nh->nh_chain[0]; np != (struct nfsnode *)nh; np = np->n_forw) {
129: if (mntp != NFSTOV(np)->v_mount ||
130: bcmp((caddr_t)fhp, (caddr_t)&np->n_fh, NFSX_FH))
131: continue;
132: if ((np->n_flag & NLOCKED) != 0) {
133: np->n_flag |= NWANT;
134: (void) tsleep((caddr_t)np, PINOD, "nfsnode", 0);
135: goto loop;
136: }
137: vp = NFSTOV(np);
138: if (vget(vp))
139: goto loop;
140: *npp = np;
141: return(0);
142: }
143: if (error = getnewvnode(VT_NFS, mntp, &nfsv2_vnodeops, &nvp)) {
144: *npp = 0;
145: return (error);
146: }
147: vp = nvp;
148: np = VTONFS(vp);
149: np->n_vnode = vp;
150: /*
151: * Insert the nfsnode in the hash queue for its new file handle
152: */
153: np->n_flag = 0;
154: insque(np, nh);
155: nfs_lock(vp);
156: bcopy((caddr_t)fhp, (caddr_t)&np->n_fh, NFSX_FH);
157: np->n_attrstamp = 0;
158: np->n_direofoffset = 0;
159: np->n_sillyrename = (struct sillyrename *)0;
160: np->n_size = 0;
161: np->n_mtime = 0;
162: *npp = np;
163: return (0);
164: }
165:
166: nfs_inactive(vp, p)
167: struct vnode *vp;
168: struct proc *p;
169: {
170: register struct nfsnode *np;
171: register struct sillyrename *sp;
172: struct nfsnode *dnp;
173: extern int prtactive;
174:
175: np = VTONFS(vp);
176: if (prtactive && vp->v_usecount != 0)
177: vprint("nfs_inactive: pushing active", vp);
178: nfs_lock(vp);
179: sp = np->n_sillyrename;
180: np->n_sillyrename = (struct sillyrename *)0;
181: if (sp) {
182: /*
183: * Remove the silly file that was rename'd earlier
184: */
185: if (!nfs_nget(vp->v_mount, &sp->s_fh, &dnp)) {
186: sp->s_dvp = NFSTOV(dnp);
187: nfs_removeit(sp, p);
188: nfs_nput(sp->s_dvp);
189: }
190: crfree(sp->s_cred);
191: vrele(sp->s_dvp);
192: free((caddr_t)sp, M_NFSREQ);
193: }
194: nfs_unlock(vp);
195: np->n_flag &= NMODIFIED;
196: #ifdef notdef
197: /*
198: * Scan the request list for any requests left hanging about
199: */
200: s = splnet();
201: rep = nfsreqh.r_next;
202: while (rep && rep != &nfsreqh) {
203: if (rep->r_vp == vp) {
204: rep->r_prev->r_next = rep2 = rep->r_next;
205: rep->r_next->r_prev = rep->r_prev;
206: m_freem(rep->r_mreq);
207: if (rep->r_mrep != NULL)
208: m_freem(rep->r_mrep);
209: free((caddr_t)rep, M_NFSREQ);
210: rep = rep2;
211: } else
212: rep = rep->r_next;
213: }
214: splx(s);
215: #endif
216: return (0);
217: }
218:
219: /*
220: * Reclaim an nfsnode so that it can be used for other purposes.
221: */
222: nfs_reclaim(vp)
223: register struct vnode *vp;
224: {
225: register struct nfsnode *np = VTONFS(vp);
226: extern int prtactive;
227:
228: if (prtactive && vp->v_usecount != 0)
229: vprint("nfs_reclaim: pushing active", vp);
230: /*
231: * Remove the nfsnode from its hash chain.
232: */
233: remque(np);
234: np->n_forw = np;
235: np->n_back = np;
236: cache_purge(vp);
237: np->n_flag = 0;
238: np->n_direofoffset = 0;
239: return (0);
240: }
241:
242: /*
243: * In theory, NFS does not need locking, but we make provision
244: * for doing it just in case it is needed.
245: */
246: int donfslocking = 0;
247: /*
248: * Lock an nfsnode
249: */
250:
251: nfs_lock(vp)
252: struct vnode *vp;
253: {
254: register struct nfsnode *np = VTONFS(vp);
255:
256: if (!donfslocking)
257: return;
258: while (np->n_flag & NLOCKED) {
259: np->n_flag |= NWANT;
260: if (np->n_lockholder == curproc->p_pid)
261: panic("locking against myself");
262: np->n_lockwaiter = curproc->p_pid;
263: (void) tsleep((caddr_t)np, PINOD, "nfslock", 0);
264: }
265: np->n_lockwaiter = 0;
266: np->n_lockholder = curproc->p_pid;
267: np->n_flag |= NLOCKED;
268: }
269:
270: /*
271: * Unlock an nfsnode
272: */
273: nfs_unlock(vp)
274: struct vnode *vp;
275: {
276: register struct nfsnode *np = VTONFS(vp);
277:
278: np->n_lockholder = 0;
279: np->n_flag &= ~NLOCKED;
280: if (np->n_flag & NWANT) {
281: np->n_flag &= ~NWANT;
282: wakeup((caddr_t)np);
283: }
284: }
285:
286: /*
287: * Check for a locked nfsnode
288: */
289: nfs_islocked(vp)
290: struct vnode *vp;
291: {
292:
293: if (VTONFS(vp)->n_flag & NLOCKED)
294: return (1);
295: return (0);
296: }
297:
298: /*
299: * Unlock and vrele()
300: * since I can't decide if dirs. should be locked, I will check for
301: * the lock and be flexible
302: */
303: nfs_nput(vp)
304: struct vnode *vp;
305: {
306: register struct nfsnode *np = VTONFS(vp);
307:
308: if (np->n_flag & NLOCKED)
309: nfs_unlock(vp);
310: vrele(vp);
311: }
312:
313: /*
314: * Nfs abort op, called after namei() when a CREATE/DELETE isn't actually
315: * done. Currently nothing to do.
316: */
317: /* ARGSUSED */
318: nfs_abortop(ndp)
319: struct nameidata *ndp;
320: {
321:
322: if ((ndp->ni_nameiop & (HASBUF | SAVESTART)) == HASBUF)
323: FREE(ndp->ni_pnbuf, M_NAMEI);
324: return (0);
325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.