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