Annotation of sys/nfs/nfs_kq.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: nfs_kq.c,v 1.9 2007/06/01 23:47:57 deraadt Exp $ */
2: /* $NetBSD: nfs_kq.c,v 1.7 2003/10/30 01:43:10 simonb Exp $ */
3:
4: /*-
5: * Copyright (c) 2002 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Jaromir Dolecek.
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. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/cdefs.h>
41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/kernel.h>
45: #include <sys/proc.h>
46: #include <sys/mount.h>
47: #include <sys/malloc.h>
48: #include <sys/vnode.h>
49: #include <sys/unistd.h>
50: #include <sys/file.h>
51: #include <sys/kthread.h>
52: #include <sys/rwlock.h>
53:
54: #include <uvm/uvm_extern.h>
55: #include <uvm/uvm.h>
56:
57: #include <nfs/rpcv2.h>
58: #include <nfs/nfsproto.h>
59: #include <nfs/nfs.h>
60: #include <nfs/nfsnode.h>
61: #include <nfs/nfs_var.h>
62:
63: void nfs_kqpoll(void *);
64:
65: void filt_nfsdetach(struct knote *);
66: int filt_nfsread(struct knote *, long);
67: int filt_nfsvnode(struct knote *, long);
68:
69: struct kevq {
70: SLIST_ENTRY(kevq) kev_link;
71: struct vnode *vp;
72: u_int usecount;
73: u_int flags;
74: #define KEVQ_BUSY 0x01 /* currently being processed */
75: #define KEVQ_WANT 0x02 /* want to change this entry */
76: struct timespec omtime; /* old modification time */
77: struct timespec octime; /* old change time */
78: nlink_t onlink; /* old number of references to file */
79: };
80: SLIST_HEAD(kevqlist, kevq);
81:
82: struct rwlock nfskevq_lock = RWLOCK_INITIALIZER("nfskqlk");
83: struct proc *pnfskq;
84: struct kevqlist kevlist = SLIST_HEAD_INITIALIZER(kevlist);
85:
86: /*
87: * This quite simplistic routine periodically checks for server changes
88: * of any of the watched files every NFS_MINATTRTIMO/2 seconds.
89: * Only changes in size, modification time, change time and nlinks
90: * are being checked, everything else is ignored.
91: * The routine only calls VOP_GETATTR() when it's likely it would get
92: * some new data, i.e. when the vnode expires from attrcache. This
93: * should give same result as periodically running stat(2) from userland,
94: * while keeping CPU/network usage low, and still provide proper kevent
95: * semantics.
96: * The poller thread is created when first vnode is added to watch list,
97: * and exits when the watch list is empty. The overhead of thread creation
98: * isn't really important, neither speed of attach and detach of knote.
99: */
100: /* ARGSUSED */
101: void
102: nfs_kqpoll(void *arg)
103: {
104: struct kevq *ke;
105: struct vattr attr;
106: struct proc *p = pnfskq;
107: u_quad_t osize;
108: int error;
109:
110: for(;;) {
111: rw_enter_write(&nfskevq_lock);
112: SLIST_FOREACH(ke, &kevlist, kev_link) {
113: struct nfsnode *np = VTONFS(ke->vp);
114:
115: #ifdef DEBUG
116: printf("nfs_kqpoll on: ");
117: VOP_PRINT(ke->vp);
118: #endif
119: /* skip if still in attrcache */
120: if (nfs_getattrcache(ke->vp, &attr) != ENOENT)
121: continue;
122:
123: /*
124: * Mark entry busy, release lock and check
125: * for changes.
126: */
127: ke->flags |= KEVQ_BUSY;
128: rw_exit_write(&nfskevq_lock);
129:
130: /* save v_size, nfs_getattr() updates it */
131: osize = np->n_size;
132:
133: error = VOP_GETATTR(ke->vp, &attr, p->p_ucred, p);
134: if (error == ESTALE) {
135: np->n_attrstamp = 0;
136: VN_KNOTE(ke->vp, NOTE_DELETE);
137: goto next;
138: }
139:
140: /* following is a bit fragile, but about best
141: * we can get */
142: if (attr.va_size != osize) {
143: int extended = (attr.va_size > osize);
144: VN_KNOTE(ke->vp, NOTE_WRITE
145: | (extended ? NOTE_EXTEND : 0));
146: ke->omtime = attr.va_mtime;
147: } else if (attr.va_mtime.tv_sec != ke->omtime.tv_sec
148: || attr.va_mtime.tv_nsec != ke->omtime.tv_nsec) {
149: VN_KNOTE(ke->vp, NOTE_WRITE);
150: ke->omtime = attr.va_mtime;
151: }
152:
153: if (attr.va_ctime.tv_sec != ke->octime.tv_sec
154: || attr.va_ctime.tv_nsec != ke->octime.tv_nsec) {
155: VN_KNOTE(ke->vp, NOTE_ATTRIB);
156: ke->octime = attr.va_ctime;
157: }
158:
159: if (attr.va_nlink != ke->onlink) {
160: VN_KNOTE(ke->vp, NOTE_LINK);
161: ke->onlink = attr.va_nlink;
162: }
163:
164: next:
165: rw_enter_write(&nfskevq_lock);
166: ke->flags &= ~KEVQ_BUSY;
167: if (ke->flags & KEVQ_WANT) {
168: ke->flags &= ~KEVQ_WANT;
169: wakeup(ke);
170: }
171: }
172:
173: if (SLIST_EMPTY(&kevlist)) {
174: /* Nothing more to watch, exit */
175: pnfskq = NULL;
176: rw_exit_write(&nfskevq_lock);
177: kthread_exit(0);
178: }
179: rw_exit_write(&nfskevq_lock);
180:
181: /* wait a while before checking for changes again */
182: tsleep(pnfskq, PSOCK, "nfskqpw", NFS_MINATTRTIMO * hz / 2);
183:
184: }
185: }
186:
187: void
188: filt_nfsdetach(struct knote *kn)
189: {
190: struct vnode *vp = (struct vnode *)kn->kn_hook;
191: struct kevq *ke;
192:
193: SLIST_REMOVE(&vp->v_selectinfo.si_note, kn, knote, kn_selnext);
194:
195: /* Remove the vnode from watch list */
196: rw_enter_write(&nfskevq_lock);
197: SLIST_FOREACH(ke, &kevlist, kev_link) {
198: if (ke->vp == vp) {
199: while (ke->flags & KEVQ_BUSY) {
200: ke->flags |= KEVQ_WANT;
201: rw_exit_write(&nfskevq_lock);
202: (void) tsleep(ke, PSOCK, "nfskqdet", 0);
203: rw_enter_write(&nfskevq_lock);
204: }
205:
206: if (ke->usecount > 1) {
207: /* keep, other kevents need this */
208: ke->usecount--;
209: } else {
210: /* last user, g/c */
211: SLIST_REMOVE(&kevlist, ke, kevq, kev_link);
212: FREE(ke, M_KEVENT);
213: }
214: break;
215: }
216: }
217: rw_exit_write(&nfskevq_lock);
218: }
219:
220: int
221: filt_nfsread(struct knote *kn, long hint)
222: {
223: struct vnode *vp = (struct vnode *)kn->kn_hook;
224: struct nfsnode *np = VTONFS(vp);
225:
226: /*
227: * filesystem is gone, so set the EOF flag and schedule
228: * the knote for deletion.
229: */
230: if (hint == NOTE_REVOKE) {
231: kn->kn_flags |= (EV_EOF | EV_ONESHOT);
232: return (1);
233: }
234:
235: kn->kn_data = np->n_size - kn->kn_fp->f_offset;
236: #ifdef DEBUG
237: printf("nfsread event. %d\n", kn->kn_data);
238: #endif
239: return (kn->kn_data != 0);
240: }
241:
242: int
243: filt_nfsvnode(struct knote *kn, long hint)
244: {
245: if (kn->kn_sfflags & hint)
246: kn->kn_fflags |= hint;
247: if (hint == NOTE_REVOKE) {
248: kn->kn_flags |= EV_EOF;
249: return (1);
250: }
251: return (kn->kn_fflags != 0);
252: }
253:
254: static const struct filterops nfsread_filtops =
255: { 1, NULL, filt_nfsdetach, filt_nfsread };
256: static const struct filterops nfsvnode_filtops =
257: { 1, NULL, filt_nfsdetach, filt_nfsvnode };
258:
259: int
260: nfs_kqfilter(void *v)
261: {
262: struct vop_kqfilter_args *ap = v;
263: struct vnode *vp;
264: struct knote *kn;
265: struct kevq *ke;
266: int error = 0;
267: struct vattr attr;
268: struct proc *p = curproc; /* XXX */
269:
270: vp = ap->a_vp;
271: kn = ap->a_kn;
272:
273: #ifdef DEBUG
274: printf("nfs_kqfilter(%d) on: ", kn->kn_filter);
275: VOP_PRINT(vp);
276: #endif
277:
278: switch (kn->kn_filter) {
279: case EVFILT_READ:
280: kn->kn_fop = &nfsread_filtops;
281: break;
282: case EVFILT_VNODE:
283: kn->kn_fop = &nfsvnode_filtops;
284: break;
285: default:
286: return (1);
287: }
288:
289: kn->kn_hook = vp;
290:
291: /*
292: * Put the vnode to watched list.
293: */
294:
295: /*
296: * Fetch current attributes. It's only needed when the vnode
297: * is not watched yet, but we need to do this without lock
298: * held. This is likely cheap due to attrcache, so do it now.
299: */
300: memset(&attr, 0, sizeof(attr));
301: (void) VOP_GETATTR(vp, &attr, p->p_ucred, p);
302:
303: rw_enter_write(&nfskevq_lock);
304:
305: /* ensure the poller is running */
306: if (!pnfskq) {
307: error = kthread_create(nfs_kqpoll, NULL, &pnfskq,
308: "nfskqpoll");
309: if (error)
310: goto out;
311: }
312:
313: SLIST_FOREACH(ke, &kevlist, kev_link)
314: if (ke->vp == vp)
315: break;
316:
317: if (ke) {
318: /* already watched, so just bump usecount */
319: ke->usecount++;
320: } else {
321: /* need a new one */
322: MALLOC(ke, struct kevq *,
323: sizeof(struct kevq), M_KEVENT, M_WAITOK);
324: ke->vp = vp;
325: ke->usecount = 1;
326: ke->flags = 0;
327: ke->omtime = attr.va_mtime;
328: ke->octime = attr.va_ctime;
329: ke->onlink = attr.va_nlink;
330: SLIST_INSERT_HEAD(&kevlist, ke, kev_link);
331: }
332:
333: /* kick the poller */
334: wakeup(pnfskq);
335:
336: SLIST_INSERT_HEAD(&vp->v_selectinfo.si_note, kn, kn_selnext);
337:
338: out:
339: rw_exit_write(&nfskevq_lock);
340: return (error);
341: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to nfs_kq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / nfs