![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_nqlease.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_nqlease.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1992, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Rick Macklem at The University of Guelph.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)nfs_nqlease.c 8.9 (Berkeley) 5/20/95
62: * FreeBSD-Id: nfs_nqlease.c,v 1.32 1997/11/07 08:53:23 phk Exp $
63: */
64:
65:
66: /*
67: * References:
68: * Cary G. Gray and David R. Cheriton, "Leases: An Efficient Fault-Tolerant
69: * Mechanism for Distributed File Cache Consistency",
70: * In Proc. of the Twelfth ACM Symposium on Operating Systems
71: * Principals, pg. 202-210, Litchfield Park, AZ, Dec. 1989.
72: * Michael N. Nelson, Brent B. Welch and John K. Ousterhout, "Caching
73: * in the Sprite Network File System", ACM TOCS 6(1),
74: * pages 134-154, February 1988.
75: * V. Srinivasan and Jeffrey C. Mogul, "Spritely NFS: Implementation and
76: * Performance of Cache-Consistency Protocols", Digital
77: * Equipment Corporation WRL Research Report 89/5, May 1989.
78: */
79: #include <sys/param.h>
80: #include <sys/vnode.h>
81: #include <sys/mount.h>
82: #include <sys/kernel.h>
83: #include <sys/proc.h>
84: #include <sys/systm.h>
85: #include <sys/malloc.h>
86: #include <sys/mbuf.h>
87: #include <sys/socket.h>
88: #include <sys/socketvar.h>
89: #include <sys/protosw.h>
90: #include <machine/spl.h>
91:
92: #include <netinet/in.h>
93: #include <nfs/rpcv2.h>
94: #include <nfs/nfsproto.h>
95: #include <nfs/nfs.h>
96: #include <nfs/nfsm_subs.h>
97: #include <nfs/xdr_subs.h>
98: #include <nfs/nqnfs.h>
99: #include <nfs/nfsnode.h>
100: #include <nfs/nfsmount.h>
101:
102: time_t nqnfsstarttime = (time_t)0;
103: int nqsrv_clockskew = NQ_CLOCKSKEW;
104: int nqsrv_writeslack = NQ_WRITESLACK;
105: int nqsrv_maxlease = NQ_MAXLEASE;
106: static int nqsrv_maxnumlease = NQ_MAXNUMLEASE;
107:
108: struct vop_lease_args;
109:
110: static int nqsrv_cmpnam __P((struct nfssvc_sock *, struct mbuf *,
111: struct nqhost *));
112: extern void nqnfs_lease_updatetime __P((int deltat));
113: static int nqnfs_vacated __P((struct vnode *vp, struct ucred *cred));
114: static void nqsrv_addhost __P((struct nqhost *lph, struct nfssvc_sock *slp,
115: struct mbuf *nam));
116: static void nqsrv_instimeq __P((struct nqlease *lp, u_long duration));
117: static void nqsrv_locklease __P((struct nqlease *lp));
118: static void nqsrv_send_eviction __P((struct vnode *vp, struct nqlease *lp,
119: struct nfssvc_sock *slp,
120: struct mbuf *nam, struct ucred *cred));
121: static void nqsrv_unlocklease __P((struct nqlease *lp));
122: static void nqsrv_waitfor_expiry __P((struct nqlease *lp));
123:
124: /*
125: * Signifies which rpcs can have piggybacked lease requests
126: */
127: int nqnfs_piggy[NFS_NPROCS] = {
128: 0,
129: 0,
130: ND_WRITE,
131: ND_READ,
132: 0,
133: ND_READ,
134: ND_READ,
135: ND_WRITE,
136: 0,
137: 0,
138: 0,
139: 0,
140: 0,
141: 0,
142: 0,
143: 0,
144: ND_READ,
145: ND_READ,
146: 0,
147: 0,
148: 0,
149: 0,
150: 0,
151: 0,
152: 0,
153: 0,
154: };
155:
156: extern nfstype nfsv2_type[9];
157: extern nfstype nfsv3_type[9];
158: extern struct nfssvc_sock *nfs_udpsock, *nfs_cltpsock;
159: extern int nfsd_waiting;
160: extern struct nfsstats nfsstats;
161: extern int nfs_mount_type;
162:
163: #define TRUE 1
164: #define FALSE 0
165:
166: #ifndef NFS_NOSERVER
167: /*
168: * Get or check for a lease for "vp", based on ND_CHECK flag.
169: * The rules are as follows:
170: * - if a current non-caching lease, reply non-caching
171: * - if a current lease for same host only, extend lease
172: * - if a read cachable lease and a read lease request
173: * add host to list any reply cachable
174: * - else { set non-cachable for read-write sharing }
175: * send eviction notice messages to all other hosts that have lease
176: * wait for lease termination { either by receiving vacated messages
177: * from all the other hosts or expiry
178: * via. timeout }
179: * modify lease to non-cachable
180: * - else if no current lease, issue new one
181: * - reply
182: * - return boolean TRUE iff nam should be m_freem()'d
183: * NB: Since nqnfs_serverd() is called from a timer, any potential tsleep()
184: * in here must be framed by nqsrv_locklease() and nqsrv_unlocklease().
185: * nqsrv_locklease() is coded such that at least one of LC_LOCKED and
186: * LC_WANTED is set whenever a process is tsleeping in it. The exception
187: * is when a new lease is being allocated, since it is not in the timer
188: * queue yet. (Ditto for the splsoftclock() and splx(s) calls)
189: */
190: int
191: nqsrv_getlease(vp, duration, flags, slp, procp, nam, cachablep, frev, cred)
192: struct vnode *vp;
193: u_long *duration;
194: int flags;
195: struct nfssvc_sock *slp;
196: struct proc *procp;
197: struct mbuf *nam;
198: int *cachablep;
199: u_quad_t *frev;
200: struct ucred *cred;
201: {
202: register struct nqlease *lp;
203: register struct nqfhhashhead *lpp = 0;
204: register struct nqhost *lph = 0;
205: struct nqlease *tlp;
206: struct nqm **lphp;
207: struct vattr vattr;
208: fhandle_t fh;
209: int i, ok, error, s;
210:
211: if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK)
212: return (0);
213: if (*duration > nqsrv_maxlease)
214: *duration = nqsrv_maxlease;
215: error = VOP_GETATTR(vp, &vattr, cred, procp);
216: if (error)
217: return (error);
218: *frev = vattr.va_filerev;
219: s = splsoftclock();
220: tlp = vp->v_lease;
221: if ((flags & ND_CHECK) == 0)
222: nfsstats.srvnqnfs_getleases++;
223: if (tlp == (struct nqlease *)0) {
224:
225: /*
226: * Find the lease by searching the hash list.
227: */
228: fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
229: error = VFS_VPTOFH(vp, &fh.fh_fid);
230: if (error) {
231: splx(s);
232: return (error);
233: }
234: lpp = NQFHHASH(fh.fh_fid.fid_data);
235: for (lp = lpp->lh_first; lp != 0; lp = lp->lc_hash.le_next)
236: if (fh.fh_fsid.val[0] == lp->lc_fsid.val[0] &&
237: fh.fh_fsid.val[1] == lp->lc_fsid.val[1] &&
238: !bcmp(fh.fh_fid.fid_data, lp->lc_fiddata,
239: fh.fh_fid.fid_len - sizeof (long))) {
240: /* Found it */
241: lp->lc_vp = vp;
242: vp->v_lease = lp;
243: tlp = lp;
244: break;
245: }
246: } else
247: lp = tlp;
248: if (lp) {
249: if ((lp->lc_flag & LC_NONCACHABLE) ||
250: (lp->lc_morehosts == (struct nqm *)0 &&
251: nqsrv_cmpnam(slp, nam, &lp->lc_host)))
252: goto doreply;
253: if ((flags & ND_READ) && (lp->lc_flag & LC_WRITE) == 0) {
254: if (flags & ND_CHECK)
255: goto doreply;
256: if (nqsrv_cmpnam(slp, nam, &lp->lc_host))
257: goto doreply;
258: i = 0;
259: if (lp->lc_morehosts) {
260: lph = lp->lc_morehosts->lpm_hosts;
261: lphp = &lp->lc_morehosts->lpm_next;
262: ok = 1;
263: } else {
264: lphp = &lp->lc_morehosts;
265: ok = 0;
266: }
267: while (ok && (lph->lph_flag & LC_VALID)) {
268: if (nqsrv_cmpnam(slp, nam, lph))
269: goto doreply;
270: if (++i == LC_MOREHOSTSIZ) {
271: i = 0;
272: if (*lphp) {
273: lph = (*lphp)->lpm_hosts;
274: lphp = &((*lphp)->lpm_next);
275: } else
276: ok = 0;
277: } else
278: lph++;
279: }
280: nqsrv_locklease(lp);
281: if (!ok) {
282: MALLOC_ZONE(*lphp, struct nqm *,
283: sizeof(struct nqm),
284: M_NQMHOST, M_WAITOK);
285: bzero((caddr_t)*lphp, sizeof (struct nqm));
286: lph = (*lphp)->lpm_hosts;
287: }
288: nqsrv_addhost(lph, slp, nam);
289: nqsrv_unlocklease(lp);
290: } else {
291: lp->lc_flag |= LC_NONCACHABLE;
292: nqsrv_locklease(lp);
293: nqsrv_send_eviction(vp, lp, slp, nam, cred);
294: nqsrv_waitfor_expiry(lp);
295: nqsrv_unlocklease(lp);
296: }
297: doreply:
298: /*
299: * Update the lease and return
300: */
301: if ((flags & ND_CHECK) == 0)
302: nqsrv_instimeq(lp, *duration);
303: if (lp->lc_flag & LC_NONCACHABLE)
304: *cachablep = 0;
305: else {
306: *cachablep = 1;
307: if (flags & ND_WRITE)
308: lp->lc_flag |= LC_WRITTEN;
309: }
310: splx(s);
311: return (0);
312: }
313: splx(s);
314: if (flags & ND_CHECK)
315: return (0);
316:
317: /*
318: * Allocate new lease
319: * The value of nqsrv_maxnumlease should be set generously, so that
320: * the following "printf" happens infrequently.
321: */
322: if (nfsstats.srvnqnfs_leases > nqsrv_maxnumlease) {
323: printf("Nqnfs server, too many leases\n");
324: do {
325: (void) tsleep((caddr_t)&lbolt, PSOCK,
326: "nqsrvnuml", 0);
327: } while (nfsstats.srvnqnfs_leases > nqsrv_maxnumlease);
328: }
329: MALLOC_ZONE(lp, struct nqlease *,
330: sizeof (struct nqlease), M_NQLEASE, M_WAITOK);
331: bzero((caddr_t)lp, sizeof (struct nqlease));
332: if (flags & ND_WRITE)
333: lp->lc_flag |= (LC_WRITE | LC_WRITTEN);
334: nqsrv_addhost(&lp->lc_host, slp, nam);
335: lp->lc_vp = vp;
336: lp->lc_fsid = fh.fh_fsid;
337: bcopy(fh.fh_fid.fid_data, lp->lc_fiddata,
338: fh.fh_fid.fid_len - sizeof (long));
339: if(!lpp)
340: panic("nfs_nqlease.c: Phoney lpp");
341: LIST_INSERT_HEAD(lpp, lp, lc_hash);
342: vp->v_lease = lp;
343: s = splsoftclock();
344: nqsrv_instimeq(lp, *duration);
345: splx(s);
346: *cachablep = 1;
347: if (++nfsstats.srvnqnfs_leases > nfsstats.srvnqnfs_maxleases)
348: nfsstats.srvnqnfs_maxleases = nfsstats.srvnqnfs_leases;
349: return (0);
350: }
351:
352: /*
353: * Local lease check for server syscalls.
354: * Just set up args and let nqsrv_getlease() do the rest.
355: * nqnfs_vop_lease_check() is the VOP_LEASE() form of the same routine.
356: * Ifdef'd code in nfsnode.h renames these routines to whatever a particular
357: * OS needs.
358: */
359: void
360: nqnfs_lease_check(vp, p, cred, flag)
361: struct vnode *vp;
362: struct proc *p;
363: struct ucred *cred;
364: int flag;
365: {
366: u_long duration = 0;
367: int cache;
368: u_quad_t frev;
369:
370: (void) nqsrv_getlease(vp, &duration, ND_CHECK | flag, NQLOCALSLP,
371: p, (struct mbuf *)0, &cache, &frev, cred);
372: }
373:
374: int
375: nqnfs_vop_lease_check(ap)
376: struct vop_lease_args /* {
377: struct vnode *a_vp;
378: struct proc *a_p;
379: struct ucred *a_cred;
380: int a_flag;
381: } */ *ap;
382: {
383: u_long duration = 0;
384: int cache;
385: u_quad_t frev;
386:
387: (void) nqsrv_getlease(ap->a_vp, &duration, ND_CHECK | ap->a_flag,
388: NQLOCALSLP, ap->a_p, (struct mbuf *)0, &cache, &frev, ap->a_cred);
389: return (0);
390: }
391:
392: #endif /* NFS_NOSERVER */
393:
394: /*
395: * Add a host to an nqhost structure for a lease.
396: */
397: static void
398: nqsrv_addhost(lph, slp, nam)
399: register struct nqhost *lph;
400: struct nfssvc_sock *slp;
401: struct mbuf *nam;
402: {
403: register struct sockaddr_in *saddr;
404:
405: if (slp == NQLOCALSLP)
406: lph->lph_flag |= (LC_VALID | LC_LOCAL);
407: else if (slp == nfs_udpsock) {
408: saddr = mtod(nam, struct sockaddr_in *);
409: lph->lph_flag |= (LC_VALID | LC_UDP);
410: lph->lph_inetaddr = saddr->sin_addr.s_addr;
411: lph->lph_port = saddr->sin_port;
412: } else if (slp == nfs_cltpsock) {
413: lph->lph_nam = m_copym(nam, 0, M_COPYALL, M_WAIT);
414: lph->lph_flag |= (LC_VALID | LC_CLTP);
415: } else {
416: lph->lph_flag |= (LC_VALID | LC_SREF);
417: lph->lph_slp = slp;
418: slp->ns_sref++;
419: }
420: }
421:
422: /*
423: * Update the lease expiry time and position it in the timer queue correctly.
424: */
425: static void
426: nqsrv_instimeq(lp, duration)
427: register struct nqlease *lp;
428: u_long duration;
429: {
430: register struct nqlease *tlp;
431: time_t newexpiry;
432:
433: newexpiry = time.tv_sec + duration + nqsrv_clockskew;
434: if (lp->lc_expiry == newexpiry)
435: return;
436: if (lp->lc_timer.cqe_next != 0) {
437: CIRCLEQ_REMOVE(&nqtimerhead, lp, lc_timer);
438: }
439: lp->lc_expiry = newexpiry;
440:
441: /*
442: * Find where in the queue it should be.
443: */
444: tlp = nqtimerhead.cqh_last;
445: while (tlp != (void *)&nqtimerhead && tlp->lc_expiry > newexpiry)
446: tlp = tlp->lc_timer.cqe_prev;
447: #ifdef HASNVRAM
448: if (tlp == nqtimerhead.cqh_last)
449: NQSTORENOVRAM(newexpiry);
450: #endif /* HASNVRAM */
451: if (tlp == (void *)&nqtimerhead) {
452: CIRCLEQ_INSERT_HEAD(&nqtimerhead, lp, lc_timer);
453: } else {
454: CIRCLEQ_INSERT_AFTER(&nqtimerhead, tlp, lp, lc_timer);
455: }
456: }
457:
458: /*
459: * Compare the requesting host address with the lph entry in the lease.
460: * Return true iff it is the same.
461: * This is somewhat messy due to the union in the nqhost structure.
462: * The local host is indicated by the special value of NQLOCALSLP for slp.
463: */
464: static int
465: nqsrv_cmpnam(slp, nam, lph)
466: register struct nfssvc_sock *slp;
467: struct mbuf *nam;
468: register struct nqhost *lph;
469: {
470: register struct sockaddr_in *saddr;
471: struct mbuf *addr;
472: union nethostaddr lhaddr;
473: int ret;
474:
475: if (slp == NQLOCALSLP) {
476: if (lph->lph_flag & LC_LOCAL)
477: return (1);
478: else
479: return (0);
480: }
481: if (slp == nfs_udpsock || slp == nfs_cltpsock)
482: addr = nam;
483: else
484: addr = slp->ns_nam;
485: if (lph->lph_flag & LC_UDP)
486: ret = netaddr_match(AF_INET, &lph->lph_haddr, addr);
487: else if (lph->lph_flag & LC_CLTP)
488: ret = netaddr_match(AF_ISO, &lph->lph_claddr, addr);
489: else {
490: if ((lph->lph_slp->ns_flag & SLP_VALID) == 0)
491: return (0);
492: saddr = mtod(lph->lph_slp->ns_nam, struct sockaddr_in *);
493: if (saddr->sin_family == AF_INET)
494: lhaddr.had_inetaddr = saddr->sin_addr.s_addr;
495: else
496: lhaddr.had_nam = lph->lph_slp->ns_nam;
497: ret = netaddr_match(saddr->sin_family, &lhaddr, addr);
498: }
499: return (ret);
500: }
501:
502: /*
503: * Send out eviction notice messages to all other hosts for the lease.
504: */
505: static void
506: nqsrv_send_eviction(vp, lp, slp, nam, cred)
507: struct vnode *vp;
508: register struct nqlease *lp;
509: struct nfssvc_sock *slp;
510: struct mbuf *nam;
511: struct ucred *cred;
512: {
513: register struct nqhost *lph = &lp->lc_host;
514: register struct mbuf *m;
515: register int siz;
516: struct nqm *lphnext = lp->lc_morehosts;
517: struct mbuf *mreq, *mb, *mb2, *mheadend;
518: struct socket *so;
519: struct mbuf *nam2;
520: struct sockaddr_in *saddr;
521: nfsfh_t nfh;
522: fhandle_t *fhp;
523: caddr_t bpos, cp;
524: u_long xid, *tl;
525: int len = 1, ok = 1, i = 0;
526: int sotype, *solockp;
527:
528: while (ok && (lph->lph_flag & LC_VALID)) {
529: if (nqsrv_cmpnam(slp, nam, lph))
530: lph->lph_flag |= LC_VACATED;
531: else if ((lph->lph_flag & (LC_LOCAL | LC_VACATED)) == 0) {
532: if (lph->lph_flag & LC_UDP) {
533: MGET(nam2, M_WAIT, MT_SONAME);
534: saddr = mtod(nam2, struct sockaddr_in *);
535: nam2->m_len = saddr->sin_len =
536: sizeof (struct sockaddr_in);
537: saddr->sin_family = AF_INET;
538: saddr->sin_addr.s_addr = lph->lph_inetaddr;
539: saddr->sin_port = lph->lph_port;
540: so = nfs_udpsock->ns_so;
541: } else if (lph->lph_flag & LC_CLTP) {
542: nam2 = lph->lph_nam;
543: so = nfs_cltpsock->ns_so;
544: } else if (lph->lph_slp->ns_flag & SLP_VALID) {
545: nam2 = (struct mbuf *)0;
546: so = lph->lph_slp->ns_so;
547: } else
548: goto nextone;
549: sotype = so->so_type;
550: if (so->so_proto->pr_flags & PR_CONNREQUIRED)
551: solockp = &lph->lph_slp->ns_solock;
552: else
553: solockp = (int *)0;
554: nfsm_reqhead((struct vnode *)0, NQNFSPROC_EVICTED,
555: NFSX_V3FH + NFSX_UNSIGNED);
556: fhp = &nfh.fh_generic;
557: bzero((caddr_t)fhp, sizeof(nfh));
558: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
559: VFS_VPTOFH(vp, &fhp->fh_fid);
560: nfsm_srvfhtom(fhp, 1);
561: m = mreq;
562: siz = 0;
563: while (m) {
564: siz += m->m_len;
565: m = m->m_next;
566: }
567: if (siz <= 0 || siz > NFS_MAXPACKET) {
568: printf("mbuf siz=%d\n",siz);
569: panic("Bad nfs svc reply");
570: }
571: m = nfsm_rpchead(cred, (NFSMNT_NFSV3 | NFSMNT_NQNFS),
572: NQNFSPROC_EVICTED,
573: RPCAUTH_UNIX, 5 * NFSX_UNSIGNED, (char *)0,
574: 0, (char *)NULL, mreq, siz, &mheadend, &xid);
575: /*
576: * For stream protocols, prepend a Sun RPC
577: * Record Mark.
578: */
579: if (sotype == SOCK_STREAM) {
580: M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
581: *mtod(m, u_long *) = htonl(0x80000000 |
582: (m->m_pkthdr.len - NFSX_UNSIGNED));
583: }
584: if (((lph->lph_flag & (LC_UDP | LC_CLTP)) == 0 &&
585: (lph->lph_slp->ns_flag & SLP_VALID) == 0) ||
586: (solockp && (*solockp & NFSMNT_SNDLOCK)))
587: m_freem(m);
588: else {
589: if (solockp)
590: *solockp |= NFSMNT_SNDLOCK;
591: (void) nfs_send(so, nam2, m,
592: (struct nfsreq *)0);
593: if (solockp)
594: nfs_sndunlock(solockp);
595: }
596: if (lph->lph_flag & LC_UDP)
597: MFREE(nam2, m);
598: }
599: nextone:
600: if (++i == len) {
601: if (lphnext) {
602: i = 0;
603: len = LC_MOREHOSTSIZ;
604: lph = lphnext->lpm_hosts;
605: lphnext = lphnext->lpm_next;
606: } else
607: ok = 0;
608: } else
609: lph++;
610: }
611: }
612:
613: /*
614: * Wait for the lease to expire.
615: * This will occur when all clients have sent "vacated" messages to
616: * this server OR when it expires do to timeout.
617: */
618: static void
619: nqsrv_waitfor_expiry(lp)
620: register struct nqlease *lp;
621: {
622: register struct nqhost *lph;
623: register int i;
624: struct nqm *lphnext;
625: int len, ok;
626:
627: tryagain:
628: if (time.tv_sec > lp->lc_expiry)
629: return;
630: lph = &lp->lc_host;
631: lphnext = lp->lc_morehosts;
632: len = 1;
633: i = 0;
634: ok = 1;
635: while (ok && (lph->lph_flag & LC_VALID)) {
636: if ((lph->lph_flag & (LC_LOCAL | LC_VACATED)) == 0) {
637: lp->lc_flag |= LC_EXPIREDWANTED;
638: (void) tsleep((caddr_t)&lp->lc_flag, PSOCK,
639: "nqexp", 0);
640: goto tryagain;
641: }
642: if (++i == len) {
643: if (lphnext) {
644: i = 0;
645: len = LC_MOREHOSTSIZ;
646: lph = lphnext->lpm_hosts;
647: lphnext = lphnext->lpm_next;
648: } else
649: ok = 0;
650: } else
651: lph++;
652: }
653: }
654:
655: #ifndef NFS_NOSERVER
656:
657: /*
658: * Nqnfs server timer that maintains the server lease queue.
659: * Scan the lease queue for expired entries:
660: * - when one is found, wakeup anyone waiting for it
661: * else dequeue and free
662: */
663: void
664: nqnfs_serverd()
665: {
666: register struct nqlease *lp;
667: register struct nqhost *lph;
668: struct nqlease *nextlp;
669: struct nqm *lphnext, *olphnext;
670: struct mbuf *n;
671: int i, len, ok;
672:
673: for (lp = nqtimerhead.cqh_first; lp != (void *)&nqtimerhead;
674: lp = nextlp) {
675: if (lp->lc_expiry >= time.tv_sec)
676: break;
677: nextlp = lp->lc_timer.cqe_next;
678: if (lp->lc_flag & LC_EXPIREDWANTED) {
679: lp->lc_flag &= ~LC_EXPIREDWANTED;
680: wakeup((caddr_t)&lp->lc_flag);
681: } else if ((lp->lc_flag & (LC_LOCKED | LC_WANTED)) == 0) {
682: /*
683: * Make a best effort at keeping a write caching lease long
684: * enough by not deleting it until it has been explicitly
685: * vacated or there have been no writes in the previous
686: * write_slack seconds since expiry and the nfsds are not
687: * all busy. The assumption is that if the nfsds are not
688: * all busy now (no queue of nfs requests), then the client
689: * would have been able to do at least one write to the
690: * file during the last write_slack seconds if it was still
691: * trying to push writes to the server.
692: */
693: if ((lp->lc_flag & (LC_WRITE | LC_VACATED)) == LC_WRITE &&
694: ((lp->lc_flag & LC_WRITTEN) || nfsd_waiting == 0)) {
695: lp->lc_flag &= ~LC_WRITTEN;
696: nqsrv_instimeq(lp, nqsrv_writeslack);
697: } else {
698: CIRCLEQ_REMOVE(&nqtimerhead, lp, lc_timer);
699: LIST_REMOVE(lp, lc_hash);
700: /*
701: * This soft reference may no longer be valid, but
702: * no harm done. The worst case is if the vnode was
703: * recycled and has another valid lease reference,
704: * which is dereferenced prematurely.
705: */
706: lp->lc_vp->v_lease = (struct nqlease *)0;
707: lph = &lp->lc_host;
708: lphnext = lp->lc_morehosts;
709: olphnext = (struct nqm *)0;
710: len = 1;
711: i = 0;
712: ok = 1;
713: while (ok && (lph->lph_flag & LC_VALID)) {
714: if (lph->lph_flag & LC_CLTP)
715: MFREE(lph->lph_nam, n);
716: if (lph->lph_flag & LC_SREF)
717: nfsrv_slpderef(lph->lph_slp);
718: if (++i == len) {
719: if (olphnext) {
720: _FREE_ZONE((caddr_t)olphnext,
721: sizeof (struct nqm),
722: M_NQMHOST);
723: olphnext = (struct nqm *)0;
724: }
725: if (lphnext) {
726: olphnext = lphnext;
727: i = 0;
728: len = LC_MOREHOSTSIZ;
729: lph = lphnext->lpm_hosts;
730: lphnext = lphnext->lpm_next;
731: } else
732: ok = 0;
733: } else
734: lph++;
735: }
736: FREE_ZONE((caddr_t)lp,
737: sizeof (struct nqlease), M_NQLEASE);
738: if (olphnext)
739: _FREE_ZONE((caddr_t)olphnext,
740: sizeof (struct nqm), M_NQMHOST);
741: nfsstats.srvnqnfs_leases--;
742: }
743: }
744: }
745: }
746:
747: /*
748: * Called from nfssvc_nfsd() for a getlease rpc request.
749: * Do the from/to xdr translation and call nqsrv_getlease() to
750: * do the real work.
751: */
752: int
753: nqnfsrv_getlease(nfsd, slp, procp, mrq)
754: struct nfsrv_descript *nfsd;
755: struct nfssvc_sock *slp;
756: struct proc *procp;
757: struct mbuf **mrq;
758: {
759: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
760: struct mbuf *nam = nfsd->nd_nam;
761: caddr_t dpos = nfsd->nd_dpos;
762: struct ucred *cred = &nfsd->nd_cr;
763: register struct nfs_fattr *fp;
764: struct vattr va;
765: register struct vattr *vap = &va;
766: struct vnode *vp;
767: nfsfh_t nfh;
768: fhandle_t *fhp;
769: register u_long *tl;
770: register long t1;
771: u_quad_t frev;
772: caddr_t bpos;
773: int error = 0;
774: char *cp2;
775: struct mbuf *mb, *mb2, *mreq;
776: int flags, rdonly, cache;
777:
778: fhp = &nfh.fh_generic;
779: nfsm_srvmtofh(fhp);
780: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
781: flags = fxdr_unsigned(int, *tl++);
782: nfsd->nd_duration = fxdr_unsigned(int, *tl);
783: error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly,
784: (nfsd->nd_flag & ND_KERBAUTH), TRUE);
785: if (error)
786: nfsm_reply(0);
787: if (rdonly && flags == ND_WRITE) {
788: error = EROFS;
789: vput(vp);
790: nfsm_reply(0);
791: }
792: (void) nqsrv_getlease(vp, &nfsd->nd_duration, flags, slp, procp,
793: nam, &cache, &frev, cred);
794: error = VOP_GETATTR(vp, vap, cred, procp);
795: vput(vp);
796: nfsm_reply(NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
797: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
798: *tl++ = txdr_unsigned(cache);
799: *tl++ = txdr_unsigned(nfsd->nd_duration);
800: txdr_hyper(&frev, tl);
801: nfsm_build(fp, struct nfs_fattr *, NFSX_V3FATTR);
802: nfsm_srvfillattr(vap, fp);
803: nfsm_srvdone;
804: }
805:
806: /*
807: * Called from nfssvc_nfsd() when a "vacated" message is received from a
808: * client. Find the entry and expire it.
809: */
810: int
811: nqnfsrv_vacated(nfsd, slp, procp, mrq)
812: struct nfsrv_descript *nfsd;
813: struct nfssvc_sock *slp;
814: struct proc *procp;
815: struct mbuf **mrq;
816: {
817: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
818: struct mbuf *nam = nfsd->nd_nam;
819: caddr_t dpos = nfsd->nd_dpos;
820: register struct nqlease *lp;
821: register struct nqhost *lph;
822: struct nqlease *tlp = (struct nqlease *)0;
823: nfsfh_t nfh;
824: fhandle_t *fhp;
825: register u_long *tl;
826: register long t1;
827: struct nqm *lphnext;
828: struct mbuf *mreq, *mb;
829: int error = 0, i, len, ok, gotit = 0, cache = 0;
830: char *cp2, *bpos;
831: u_quad_t frev;
832:
833: fhp = &nfh.fh_generic;
834: nfsm_srvmtofh(fhp);
835: m_freem(mrep);
836: /*
837: * Find the lease by searching the hash list.
838: */
839: for (lp = NQFHHASH(fhp->fh_fid.fid_data)->lh_first; lp != 0;
840: lp = lp->lc_hash.le_next)
841: if (fhp->fh_fsid.val[0] == lp->lc_fsid.val[0] &&
842: fhp->fh_fsid.val[1] == lp->lc_fsid.val[1] &&
843: !bcmp(fhp->fh_fid.fid_data, lp->lc_fiddata,
844: MAXFIDSZ)) {
845: /* Found it */
846: tlp = lp;
847: break;
848: }
849: if (tlp) {
850: lp = tlp;
851: len = 1;
852: i = 0;
853: lph = &lp->lc_host;
854: lphnext = lp->lc_morehosts;
855: ok = 1;
856: while (ok && (lph->lph_flag & LC_VALID)) {
857: if (nqsrv_cmpnam(slp, nam, lph)) {
858: lph->lph_flag |= LC_VACATED;
859: gotit++;
860: break;
861: }
862: if (++i == len) {
863: if (lphnext) {
864: len = LC_MOREHOSTSIZ;
865: i = 0;
866: lph = lphnext->lpm_hosts;
867: lphnext = lphnext->lpm_next;
868: } else
869: ok = 0;
870: } else
871: lph++;
872: }
873: if ((lp->lc_flag & LC_EXPIREDWANTED) && gotit) {
874: lp->lc_flag &= ~LC_EXPIREDWANTED;
875: wakeup((caddr_t)&lp->lc_flag);
876: }
877: nfsmout:
878: return (EPERM);
879: }
880: return (EPERM);
881: }
882:
883: #endif /* NFS_NOSERVER */
884:
885: /*
886: * Client get lease rpc function.
887: */
888: int
889: nqnfs_getlease(vp, rwflag, cred, p)
890: register struct vnode *vp;
891: int rwflag;
892: struct ucred *cred;
893: struct proc *p;
894: {
895: register u_long *tl;
896: register caddr_t cp;
897: register long t1, t2;
898: register struct nfsnode *np;
899: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
900: caddr_t bpos, dpos, cp2;
901: time_t reqtime;
902: int error = 0;
903: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
904: int cachable;
905: u_quad_t frev;
906:
907: nfsstats.rpccnt[NQNFSPROC_GETLEASE]++;
908: mb = mreq = nfsm_reqh(vp, NQNFSPROC_GETLEASE, NFSX_V3FH+2*NFSX_UNSIGNED,
909: &bpos);
910: nfsm_fhtom(vp, 1);
911: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
912: *tl++ = txdr_unsigned(rwflag);
913: *tl = txdr_unsigned(nmp->nm_leaseterm);
914: reqtime = time.tv_sec;
915: nfsm_request(vp, NQNFSPROC_GETLEASE, p, cred);
916: np = VTONFS(vp);
917: nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
918: cachable = fxdr_unsigned(int, *tl++);
919: reqtime += fxdr_unsigned(int, *tl++);
920: if (reqtime > time.tv_sec) {
921: fxdr_hyper(tl, &frev);
922: nqnfs_clientlease(nmp, np, rwflag, cachable, reqtime, frev);
923: nfsm_loadattr(vp, (struct vattr *)0);
924: } else
925: error = NQNFS_EXPIRED;
926: nfsm_reqdone;
927: return (error);
928: }
929:
930: /*
931: * Client vacated message function.
932: */
933: static int
934: nqnfs_vacated(vp, cred)
935: register struct vnode *vp;
936: struct ucred *cred;
937: {
938: register caddr_t cp;
939: register struct mbuf *m;
940: register int i;
941: register u_long *tl;
942: register long t2;
943: caddr_t bpos;
944: u_long xid;
945: int error = 0;
946: struct mbuf *mreq, *mb, *mb2, *mheadend;
947: struct nfsmount *nmp;
948: struct nfsreq myrep;
949:
950: nmp = VFSTONFS(vp->v_mount);
951: nfsstats.rpccnt[NQNFSPROC_VACATED]++;
952: nfsm_reqhead(vp, NQNFSPROC_VACATED, NFSX_FH(1));
953: nfsm_fhtom(vp, 1);
954: m = mreq;
955: i = 0;
956: while (m) {
957: i += m->m_len;
958: m = m->m_next;
959: }
960: m = nfsm_rpchead(cred, nmp->nm_flag, NQNFSPROC_VACATED,
961: RPCAUTH_UNIX, 5 * NFSX_UNSIGNED, (char *)0,
962: 0, (char *)NULL, mreq, i, &mheadend, &xid);
963: if (nmp->nm_sotype == SOCK_STREAM) {
964: M_PREPEND(m, NFSX_UNSIGNED, M_WAIT);
965: *mtod(m, u_long *) = htonl(0x80000000 | (m->m_pkthdr.len -
966: NFSX_UNSIGNED));
967: }
968: myrep.r_flags = 0;
969: myrep.r_nmp = nmp;
970: if (nmp->nm_soflags & PR_CONNREQUIRED)
971: (void) nfs_sndlock(&nmp->nm_flag, (struct nfsreq *)0);
972: (void) nfs_send(nmp->nm_so, nmp->nm_nam, m, &myrep);
973: if (nmp->nm_soflags & PR_CONNREQUIRED)
974: nfs_sndunlock(&nmp->nm_flag);
975: nfsmout:
976: return (error);
977: }
978:
979: #ifndef NFS_NOSERVER
980:
981: /*
982: * Called for client side callbacks
983: */
984: int
985: nqnfs_callback(nmp, mrep, md, dpos)
986: struct nfsmount *nmp;
987: struct mbuf *mrep, *md;
988: caddr_t dpos;
989: {
990: register struct vnode *vp;
991: register u_long *tl;
992: register long t1;
993: nfsfh_t nfh;
994: fhandle_t *fhp;
995: struct nfsnode *np;
996: struct nfsd tnfsd;
997: struct nfssvc_sock *slp;
998: struct nfsrv_descript ndesc;
999: register struct nfsrv_descript *nfsd = &ndesc;
1000: struct mbuf **mrq = (struct mbuf **)0, *mb, *mreq;
1001: int error = 0, cache = 0;
1002: char *cp2, *bpos;
1003: u_quad_t frev;
1004:
1005: #ifndef nolint
1006: slp = NULL;
1007: #endif
1008: nfsd->nd_mrep = mrep;
1009: nfsd->nd_md = md;
1010: nfsd->nd_dpos = dpos;
1011: error = nfs_getreq(nfsd, &tnfsd, FALSE);
1012: if (error)
1013: return (error);
1014: md = nfsd->nd_md;
1015: dpos = nfsd->nd_dpos;
1016: if (nfsd->nd_procnum != NQNFSPROC_EVICTED) {
1017: m_freem(mrep);
1018: return (EPERM);
1019: }
1020: fhp = &nfh.fh_generic;
1021: nfsm_srvmtofh(fhp);
1022: m_freem(mrep);
1023: error = nfs_nget(nmp->nm_mountp, (nfsfh_t *)fhp, NFSX_V3FH, &np);
1024: if (error)
1025: return (error);
1026: vp = NFSTOV(np);
1027: if (np->n_timer.cqe_next != 0) {
1028: np->n_expiry = 0;
1029: np->n_flag |= NQNFSEVICTED;
1030: if (nmp->nm_timerhead.cqh_first != np) {
1031: CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
1032: CIRCLEQ_INSERT_HEAD(&nmp->nm_timerhead, np, n_timer);
1033: }
1034: }
1035: vput(vp);
1036: nfsm_srvdone;
1037: }
1038:
1039:
1040: /*
1041: * Nqnfs client helper daemon. Runs once a second to expire leases.
1042: * It also get authorization strings for "kerb" mounts.
1043: * It must start at the beginning of the list again after any potential
1044: * "sleep" since nfs_reclaim() called from vclean() can pull a node off
1045: * the list asynchronously.
1046: */
1047: int
1048: nqnfs_clientd(nmp, cred, ncd, flag, argp, p)
1049: register struct nfsmount *nmp;
1050: struct ucred *cred;
1051: struct nfsd_cargs *ncd;
1052: int flag;
1053: caddr_t argp;
1054: struct proc *p;
1055: {
1056: register struct nfsnode *np;
1057: struct vnode *vp;
1058: struct nfsreq myrep;
1059: struct nfsuid *nuidp, *nnuidp;
1060: int error = 0, vpid;
1061: register struct nfsreq *rp;
1062:
1063: /*
1064: * First initialize some variables
1065: */
1066:
1067: /*
1068: * If an authorization string is being passed in, get it.
1069: */
1070: if ((flag & NFSSVC_GOTAUTH) &&
1071: (nmp->nm_flag & (NFSMNT_WAITAUTH | NFSMNT_DISMNT)) == 0) {
1072: if (nmp->nm_flag & NFSMNT_HASAUTH)
1073: panic("cld kerb");
1074: if ((flag & NFSSVC_AUTHINFAIL) == 0) {
1075: if (ncd->ncd_authlen <= nmp->nm_authlen &&
1076: ncd->ncd_verflen <= nmp->nm_verflen &&
1077: !copyin(ncd->ncd_authstr,nmp->nm_authstr,ncd->ncd_authlen)&&
1078: !copyin(ncd->ncd_verfstr,nmp->nm_verfstr,ncd->ncd_verflen)){
1079: nmp->nm_authtype = ncd->ncd_authtype;
1080: nmp->nm_authlen = ncd->ncd_authlen;
1081: nmp->nm_verflen = ncd->ncd_verflen;
1082: #if NFSKERB
1083: nmp->nm_key = ncd->ncd_key;
1084: #endif
1085: } else
1086: nmp->nm_flag |= NFSMNT_AUTHERR;
1087: } else
1088: nmp->nm_flag |= NFSMNT_AUTHERR;
1089: nmp->nm_flag |= NFSMNT_HASAUTH;
1090: wakeup((caddr_t)&nmp->nm_authlen);
1091: } else
1092: nmp->nm_flag |= NFSMNT_WAITAUTH;
1093:
1094: /*
1095: * Loop every second updating queue until there is a termination sig.
1096: */
1097: while ((nmp->nm_flag & NFSMNT_DISMNT) == 0) {
1098: if (nmp->nm_flag & NFSMNT_NQNFS) {
1099: /*
1100: * If there are no outstanding requests (and therefore no
1101: * processes in nfs_reply) and there is data in the receive
1102: * queue, poke for callbacks.
1103: */
1104: if (nfs_reqq.tqh_first == 0 && nmp->nm_so &&
1105: nmp->nm_so->so_rcv.sb_cc > 0) {
1106: myrep.r_flags = R_GETONEREP;
1107: myrep.r_nmp = nmp;
1108: myrep.r_mrep = (struct mbuf *)0;
1109: myrep.r_procp = (struct proc *)0;
1110: (void) nfs_reply(&myrep);
1111: }
1112:
1113: /*
1114: * Loop through the leases, updating as required.
1115: */
1116: np = nmp->nm_timerhead.cqh_first;
1117: while (np != (void *)&nmp->nm_timerhead &&
1118: (nmp->nm_flag & NFSMNT_DISMINPROG) == 0) {
1119: vp = NFSTOV(np);
1120: vpid = vp->v_id;
1121: if (np->n_expiry < time.tv_sec) {
1122: if (vget(vp, LK_EXCLUSIVE, p) == 0) {
1123: nmp->nm_inprog = vp;
1124: if (vpid == vp->v_id) {
1125: CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
1126: np->n_timer.cqe_next = 0;
1127: if (np->n_flag & (NMODIFIED | NQNFSEVICTED)) {
1128: if (np->n_flag & NQNFSEVICTED) {
1129: if (vp->v_type == VDIR)
1130: nfs_invaldir(vp);
1131: cache_purge(vp);
1132: (void) nfs_vinvalbuf(vp,
1133: V_SAVE, cred, p, 0);
1134: np->n_flag &= ~NQNFSEVICTED;
1135: (void) nqnfs_vacated(vp, cred);
1136: } else if (vp->v_type == VREG) {
1137: (void) VOP_FSYNC(vp, cred,
1138: MNT_WAIT, p);
1139: np->n_flag &= ~NMODIFIED;
1140: }
1141: }
1142: }
1143: vrele(vp);
1144: nmp->nm_inprog = NULLVP;
1145: }
1146: } else if ((np->n_expiry - NQ_RENEWAL) < time.tv_sec) {
1147: if ((np->n_flag & (NQNFSWRITE | NQNFSNONCACHE))
1148: == NQNFSWRITE && vp->v_dirtyblkhd.lh_first &&
1149: vget(vp, LK_EXCLUSIVE, p) == 0) {
1150: nmp->nm_inprog = vp;
1151: if (vpid == vp->v_id &&
1152: nqnfs_getlease(vp, ND_WRITE, cred, p)==0)
1153: np->n_brev = np->n_lrev;
1154: vrele(vp);
1155: nmp->nm_inprog = NULLVP;
1156: }
1157: } else
1158: break;
1159: if (np == nmp->nm_timerhead.cqh_first)
1160: break;
1161: np = nmp->nm_timerhead.cqh_first;
1162: }
1163: }
1164:
1165: /*
1166: * Get an authorization string, if required.
1167: */
1168: if ((nmp->nm_flag & (NFSMNT_WAITAUTH | NFSMNT_DISMNT | NFSMNT_HASAUTH)) == 0) {
1169: ncd->ncd_authuid = nmp->nm_authuid;
1170: if (copyout((caddr_t)ncd, argp, sizeof (struct nfsd_cargs)))
1171: nmp->nm_flag |= NFSMNT_WAITAUTH;
1172: else
1173: return (ENEEDAUTH);
1174: }
1175:
1176: /*
1177: * Wait a bit (no pun) and do it again.
1178: */
1179: if ((nmp->nm_flag & NFSMNT_DISMNT) == 0 &&
1180: (nmp->nm_flag & (NFSMNT_WAITAUTH | NFSMNT_HASAUTH))) {
1181: error = tsleep((caddr_t)&nmp->nm_authstr, PSOCK | PCATCH,
1182: "nqnfstimr", hz / 3);
1183: if (error == EINTR || error == ERESTART)
1184: (void) dounmount(nmp->nm_mountp, 0, p);
1185: }
1186: }
1187:
1188: /*
1189: * Finally, we can free up the mount structure.
1190: */
1191: for (nuidp = nmp->nm_uidlruhead.tqh_first; nuidp != 0; nuidp = nnuidp) {
1192: nnuidp = nuidp->nu_lru.tqe_next;
1193: LIST_REMOVE(nuidp, nu_hash);
1194: TAILQ_REMOVE(&nmp->nm_uidlruhead, nuidp, nu_lru);
1195: _FREE_ZONE((caddr_t)nuidp, sizeof (struct nfsuid), M_NFSUID);
1196: }
1197: /*
1198: * Loop through outstanding request list and remove dangling
1199: * references to defunct nfsmount struct
1200: */
1201: for (rp = nfs_reqq.tqh_first; rp; rp = rp->r_chain.tqe_next)
1202: if (rp->r_nmp == nmp)
1203: rp->r_nmp = (struct nfsmount *)0;
1204: _FREE_ZONE((caddr_t)nmp, sizeof (struct nfsmount), M_NFSMNT);
1205: if (error == EWOULDBLOCK)
1206: error = 0;
1207: return (error);
1208: }
1209:
1210: #endif /* NFS_NOSERVER */
1211:
1212: /*
1213: * Adjust all timer queue expiry times when the time of day clock is changed.
1214: * Called from the settimeofday() syscall.
1215: */
1216: void
1217: nqnfs_lease_updatetime(deltat)
1218: register int deltat;
1219: {
1220: struct proc *p = current_proc(); /* XXX */
1221: struct nqlease *lp;
1222: struct nfsnode *np;
1223: struct mount *mp, *nxtmp;
1224: struct nfsmount *nmp;
1225: int s;
1226:
1227: if (nqnfsstarttime != 0)
1228: nqnfsstarttime += deltat;
1229: s = splsoftclock();
1230: for (lp = nqtimerhead.cqh_first; lp != (void *)&nqtimerhead;
1231: lp = lp->lc_timer.cqe_next)
1232: lp->lc_expiry += deltat;
1233: splx(s);
1234:
1235: /*
1236: * Search the mount list for all nqnfs mounts and do their timer
1237: * queues.
1238: */
1239: simple_lock(&mountlist_slock);
1240: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nxtmp) {
1241: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
1242: nxtmp = mp->mnt_list.cqe_next;
1243: continue;
1244: }
1245: if (mp->mnt_stat.f_type == nfs_mount_type) {
1246: nmp = VFSTONFS(mp);
1247: if (nmp->nm_flag & NFSMNT_NQNFS) {
1248: for (np = nmp->nm_timerhead.cqh_first;
1249: np != (void *)&nmp->nm_timerhead;
1250: np = np->n_timer.cqe_next) {
1251: np->n_expiry += deltat;
1252: }
1253: }
1254: }
1255: simple_lock(&mountlist_slock);
1256: nxtmp = mp->mnt_list.cqe_next;
1257: vfs_unbusy(mp, p);
1258: }
1259: simple_unlock(&mountlist_slock);
1260: }
1261:
1262: /*
1263: * Lock a server lease.
1264: */
1265: static void
1266: nqsrv_locklease(lp)
1267: struct nqlease *lp;
1268: {
1269:
1270: while (lp->lc_flag & LC_LOCKED) {
1271: lp->lc_flag |= LC_WANTED;
1272: (void) tsleep((caddr_t)lp, PSOCK, "nqlc", 0);
1273: }
1274: lp->lc_flag |= LC_LOCKED;
1275: lp->lc_flag &= ~LC_WANTED;
1276: }
1277:
1278: /*
1279: * Unlock a server lease.
1280: */
1281: static void
1282: nqsrv_unlocklease(lp)
1283: struct nqlease *lp;
1284: {
1285:
1286: lp->lc_flag &= ~LC_LOCKED;
1287: if (lp->lc_flag & LC_WANTED)
1288: wakeup((caddr_t)lp);
1289: }
1290:
1291: /*
1292: * Update a client lease.
1293: */
1294: void
1295: nqnfs_clientlease(nmp, np, rwflag, cachable, expiry, frev)
1296: register struct nfsmount *nmp;
1297: register struct nfsnode *np;
1298: int rwflag, cachable;
1299: time_t expiry;
1300: u_quad_t frev;
1301: {
1302: register struct nfsnode *tp;
1303:
1304: if (np->n_timer.cqe_next != 0) {
1305: CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
1306: if (rwflag == ND_WRITE)
1307: np->n_flag |= NQNFSWRITE;
1308: } else if (rwflag == ND_READ)
1309: np->n_flag &= ~NQNFSWRITE;
1310: else
1311: np->n_flag |= NQNFSWRITE;
1312: if (cachable)
1313: np->n_flag &= ~NQNFSNONCACHE;
1314: else
1315: np->n_flag |= NQNFSNONCACHE;
1316: np->n_expiry = expiry;
1317: np->n_lrev = frev;
1318: tp = nmp->nm_timerhead.cqh_last;
1319: while (tp != (void *)&nmp->nm_timerhead && tp->n_expiry > np->n_expiry)
1320: tp = tp->n_timer.cqe_prev;
1321: if (tp == (void *)&nmp->nm_timerhead) {
1322: CIRCLEQ_INSERT_HEAD(&nmp->nm_timerhead, np, n_timer);
1323: } else {
1324: CIRCLEQ_INSERT_AFTER(&nmp->nm_timerhead, tp, np, n_timer);
1325: }
1326: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.