1*982ae832Sthorpej /* $NetBSD: nfs_kq.c,v 1.32 2021/10/20 03:08:18 thorpej Exp $ */
2e0cc03a0Sjdolecek
3e0cc03a0Sjdolecek /*-
422c6a20eSad * Copyright (c) 2002, 2008 The NetBSD Foundation, Inc.
5e0cc03a0Sjdolecek * All rights reserved.
6e0cc03a0Sjdolecek *
7e0cc03a0Sjdolecek * This code is derived from software contributed to The NetBSD Foundation
8e0cc03a0Sjdolecek * by Jaromir Dolecek.
9e0cc03a0Sjdolecek *
10e0cc03a0Sjdolecek * Redistribution and use in source and binary forms, with or without
11e0cc03a0Sjdolecek * modification, are permitted provided that the following conditions
12e0cc03a0Sjdolecek * are met:
13e0cc03a0Sjdolecek * 1. Redistributions of source code must retain the above copyright
14e0cc03a0Sjdolecek * notice, this list of conditions and the following disclaimer.
15e0cc03a0Sjdolecek * 2. Redistributions in binary form must reproduce the above copyright
16e0cc03a0Sjdolecek * notice, this list of conditions and the following disclaimer in the
17e0cc03a0Sjdolecek * documentation and/or other materials provided with the distribution.
18e0cc03a0Sjdolecek *
19e0cc03a0Sjdolecek * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20e0cc03a0Sjdolecek * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21e0cc03a0Sjdolecek * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22e0cc03a0Sjdolecek * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23e0cc03a0Sjdolecek * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24e0cc03a0Sjdolecek * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25e0cc03a0Sjdolecek * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26e0cc03a0Sjdolecek * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27e0cc03a0Sjdolecek * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28e0cc03a0Sjdolecek * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29e0cc03a0Sjdolecek * POSSIBILITY OF SUCH DAMAGE.
30e0cc03a0Sjdolecek */
31e0cc03a0Sjdolecek
32e0cc03a0Sjdolecek #include <sys/cdefs.h>
33*982ae832Sthorpej __KERNEL_RCSID(0, "$NetBSD: nfs_kq.c,v 1.32 2021/10/20 03:08:18 thorpej Exp $");
34e0cc03a0Sjdolecek
35e0cc03a0Sjdolecek #include <sys/param.h>
36e0cc03a0Sjdolecek #include <sys/systm.h>
37fbee155dSyamt #include <sys/condvar.h>
38e0cc03a0Sjdolecek #include <sys/kernel.h>
39e0cc03a0Sjdolecek #include <sys/proc.h>
40677860cbSyamt #include <sys/kmem.h>
41e0cc03a0Sjdolecek #include <sys/mount.h>
42fbee155dSyamt #include <sys/mutex.h>
43e0cc03a0Sjdolecek #include <sys/vnode.h>
44e0cc03a0Sjdolecek #include <sys/unistd.h>
45e0cc03a0Sjdolecek #include <sys/file.h>
46e0cc03a0Sjdolecek #include <sys/kthread.h>
47e0cc03a0Sjdolecek
48e0cc03a0Sjdolecek #include <nfs/rpcv2.h>
49e0cc03a0Sjdolecek #include <nfs/nfsproto.h>
50e0cc03a0Sjdolecek #include <nfs/nfs.h>
51e0cc03a0Sjdolecek #include <nfs/nfsnode.h>
52e0cc03a0Sjdolecek #include <nfs/nfs_var.h>
53e0cc03a0Sjdolecek
54e0cc03a0Sjdolecek struct kevq {
55e0cc03a0Sjdolecek SLIST_ENTRY(kevq) kev_link;
56e0cc03a0Sjdolecek struct vnode *vp;
57e0cc03a0Sjdolecek u_int usecount;
58e0cc03a0Sjdolecek u_int flags;
59e0cc03a0Sjdolecek #define KEVQ_BUSY 0x01 /* currently being processed */
60e0cc03a0Sjdolecek struct timespec omtime; /* old modification time */
61e0cc03a0Sjdolecek struct timespec octime; /* old change time */
62e0cc03a0Sjdolecek nlink_t onlink; /* old number of references to file */
63fbee155dSyamt kcondvar_t cv;
64e0cc03a0Sjdolecek };
65e0cc03a0Sjdolecek SLIST_HEAD(kevqlist, kevq);
66e0cc03a0Sjdolecek
6792ce8c6aSad static kmutex_t nfskq_lock;
6888ab7da9Sad static struct lwp *nfskq_thread;
69fbee155dSyamt static kcondvar_t nfskq_cv;
70e0cc03a0Sjdolecek static struct kevqlist kevlist = SLIST_HEAD_INITIALIZER(kevlist);
7192ce8c6aSad static bool nfskq_thread_exit;
72e0cc03a0Sjdolecek
73e0cc03a0Sjdolecek void
nfs_kqinit(void)74e0cc03a0Sjdolecek nfs_kqinit(void)
75e0cc03a0Sjdolecek {
76fbee155dSyamt
7792ce8c6aSad mutex_init(&nfskq_lock, MUTEX_DEFAULT, IPL_NONE);
78fbee155dSyamt cv_init(&nfskq_cv, "nfskqpw");
79e0cc03a0Sjdolecek }
80e0cc03a0Sjdolecek
8192ce8c6aSad void
nfs_kqfini(void)8292ce8c6aSad nfs_kqfini(void)
8392ce8c6aSad {
8492ce8c6aSad
8592ce8c6aSad if (nfskq_thread != NULL) {
8692ce8c6aSad mutex_enter(&nfskq_lock);
8792ce8c6aSad nfskq_thread_exit = true;
8892ce8c6aSad cv_broadcast(&nfskq_cv);
8992ce8c6aSad do {
9092ce8c6aSad cv_wait(&nfskq_cv, &nfskq_lock);
9192ce8c6aSad } while (nfskq_thread != NULL);
9292ce8c6aSad mutex_exit(&nfskq_lock);
9392ce8c6aSad }
9492ce8c6aSad mutex_destroy(&nfskq_lock);
9592ce8c6aSad cv_destroy(&nfskq_cv);
9692ce8c6aSad }
9792ce8c6aSad
98e0cc03a0Sjdolecek /*
99e0cc03a0Sjdolecek * This quite simplistic routine periodically checks for server changes
100c2793620Sjdolecek * of any of the watched files every NFS_MINATTRTIMO/2 seconds.
101e0cc03a0Sjdolecek * Only changes in size, modification time, change time and nlinks
102e0cc03a0Sjdolecek * are being checked, everything else is ignored.
103e0cc03a0Sjdolecek * The routine only calls VOP_GETATTR() when it's likely it would get
104e0cc03a0Sjdolecek * some new data, i.e. when the vnode expires from attrcache. This
105e0cc03a0Sjdolecek * should give same result as periodically running stat(2) from userland,
106e0cc03a0Sjdolecek * while keeping CPU/network usage low, and still provide proper kevent
107e0cc03a0Sjdolecek * semantics.
108e0cc03a0Sjdolecek * The poller thread is created when first vnode is added to watch list,
109e0cc03a0Sjdolecek * and exits when the watch list is empty. The overhead of thread creation
110e0cc03a0Sjdolecek * isn't really important, neither speed of attach and detach of knote.
111e0cc03a0Sjdolecek */
112e0cc03a0Sjdolecek /* ARGSUSED */
113e0cc03a0Sjdolecek static void
nfs_kqpoll(void * arg)11489682b24Syamt nfs_kqpoll(void *arg)
115e0cc03a0Sjdolecek {
116e0cc03a0Sjdolecek struct kevq *ke;
117e0cc03a0Sjdolecek struct vattr attr;
118f474dcebSad struct lwp *l = curlwp;
119e0cc03a0Sjdolecek u_quad_t osize;
120e0cc03a0Sjdolecek
12192ce8c6aSad mutex_enter(&nfskq_lock);
12292ce8c6aSad while (!nfskq_thread_exit) {
123e0cc03a0Sjdolecek SLIST_FOREACH(ke, &kevlist, kev_link) {
124e0cc03a0Sjdolecek /* skip if still in attrcache */
125e0cc03a0Sjdolecek if (nfs_getattrcache(ke->vp, &attr) != ENOENT)
126e0cc03a0Sjdolecek continue;
127e0cc03a0Sjdolecek
128e0cc03a0Sjdolecek /*
129e0cc03a0Sjdolecek * Mark entry busy, release lock and check
130e0cc03a0Sjdolecek * for changes.
131e0cc03a0Sjdolecek */
132e0cc03a0Sjdolecek ke->flags |= KEVQ_BUSY;
13392ce8c6aSad mutex_exit(&nfskq_lock);
134e0cc03a0Sjdolecek
135e0cc03a0Sjdolecek /* save v_size, nfs_getattr() updates it */
136e0cc03a0Sjdolecek osize = ke->vp->v_size;
137e0cc03a0Sjdolecek
13868660b46Shannken memset(&attr, 0, sizeof(attr));
13968660b46Shannken vn_lock(ke->vp, LK_SHARED | LK_RETRY);
14061e8303eSpooka (void) VOP_GETATTR(ke->vp, &attr, l->l_cred);
14168660b46Shannken VOP_UNLOCK(ke->vp);
142e0cc03a0Sjdolecek
143e0cc03a0Sjdolecek /* following is a bit fragile, but about best
144e0cc03a0Sjdolecek * we can get */
145e0cc03a0Sjdolecek if (attr.va_size != osize) {
146e0cc03a0Sjdolecek int extended = (attr.va_size > osize);
147e0cc03a0Sjdolecek VN_KNOTE(ke->vp, NOTE_WRITE
148e0cc03a0Sjdolecek | (extended ? NOTE_EXTEND : 0));
149e0cc03a0Sjdolecek ke->omtime = attr.va_mtime;
150e0cc03a0Sjdolecek } else if (attr.va_mtime.tv_sec != ke->omtime.tv_sec
151e0cc03a0Sjdolecek || attr.va_mtime.tv_nsec != ke->omtime.tv_nsec) {
152e0cc03a0Sjdolecek VN_KNOTE(ke->vp, NOTE_WRITE);
153e0cc03a0Sjdolecek ke->omtime = attr.va_mtime;
154e0cc03a0Sjdolecek }
155e0cc03a0Sjdolecek
156e0cc03a0Sjdolecek if (attr.va_ctime.tv_sec != ke->octime.tv_sec
157e0cc03a0Sjdolecek || attr.va_ctime.tv_nsec != ke->octime.tv_nsec) {
158e0cc03a0Sjdolecek VN_KNOTE(ke->vp, NOTE_ATTRIB);
159e0cc03a0Sjdolecek ke->octime = attr.va_ctime;
160e0cc03a0Sjdolecek }
161e0cc03a0Sjdolecek
162e0cc03a0Sjdolecek if (attr.va_nlink != ke->onlink) {
163e0cc03a0Sjdolecek VN_KNOTE(ke->vp, NOTE_LINK);
164e0cc03a0Sjdolecek ke->onlink = attr.va_nlink;
165e0cc03a0Sjdolecek }
166e0cc03a0Sjdolecek
16792ce8c6aSad mutex_enter(&nfskq_lock);
168e0cc03a0Sjdolecek ke->flags &= ~KEVQ_BUSY;
169fbee155dSyamt cv_signal(&ke->cv);
170e0cc03a0Sjdolecek }
171e0cc03a0Sjdolecek
172e0cc03a0Sjdolecek if (SLIST_EMPTY(&kevlist)) {
173e0cc03a0Sjdolecek /* Nothing more to watch, exit */
17488ab7da9Sad nfskq_thread = NULL;
17592ce8c6aSad mutex_exit(&nfskq_lock);
176e0cc03a0Sjdolecek kthread_exit(0);
177e0cc03a0Sjdolecek }
178e0cc03a0Sjdolecek
179e0cc03a0Sjdolecek /* wait a while before checking for changes again */
18092ce8c6aSad cv_timedwait(&nfskq_cv, &nfskq_lock,
181e0cc03a0Sjdolecek NFS_MINATTRTIMO * hz / 2);
182e0cc03a0Sjdolecek }
18392ce8c6aSad nfskq_thread = NULL;
18492ce8c6aSad cv_broadcast(&nfskq_cv);
18592ce8c6aSad mutex_exit(&nfskq_lock);
186e0cc03a0Sjdolecek }
187e0cc03a0Sjdolecek
188e0cc03a0Sjdolecek static void
filt_nfsdetach(struct knote * kn)189e0cc03a0Sjdolecek filt_nfsdetach(struct knote *kn)
190e0cc03a0Sjdolecek {
191e0cc03a0Sjdolecek struct vnode *vp = (struct vnode *)kn->kn_hook;
192e0cc03a0Sjdolecek struct kevq *ke;
193e0cc03a0Sjdolecek
194*982ae832Sthorpej vn_knote_detach(vp, kn);
195e0cc03a0Sjdolecek
196e0cc03a0Sjdolecek /* Remove the vnode from watch list */
19792ce8c6aSad mutex_enter(&nfskq_lock);
198e0cc03a0Sjdolecek SLIST_FOREACH(ke, &kevlist, kev_link) {
199e0cc03a0Sjdolecek if (ke->vp == vp) {
200e0cc03a0Sjdolecek while (ke->flags & KEVQ_BUSY) {
20192ce8c6aSad cv_wait(&ke->cv, &nfskq_lock);
202e0cc03a0Sjdolecek }
203e0cc03a0Sjdolecek
204e0cc03a0Sjdolecek if (ke->usecount > 1) {
205e0cc03a0Sjdolecek /* keep, other kevents need this */
206e0cc03a0Sjdolecek ke->usecount--;
207e0cc03a0Sjdolecek } else {
208e0cc03a0Sjdolecek /* last user, g/c */
209fbee155dSyamt cv_destroy(&ke->cv);
210e0cc03a0Sjdolecek SLIST_REMOVE(&kevlist, ke, kevq, kev_link);
211677860cbSyamt kmem_free(ke, sizeof(*ke));
212e0cc03a0Sjdolecek }
213e0cc03a0Sjdolecek break;
214e0cc03a0Sjdolecek }
215e0cc03a0Sjdolecek }
21692ce8c6aSad mutex_exit(&nfskq_lock);
217e0cc03a0Sjdolecek }
218e0cc03a0Sjdolecek
219e0cc03a0Sjdolecek static int
filt_nfsread(struct knote * kn,long hint)220e0cc03a0Sjdolecek filt_nfsread(struct knote *kn, long hint)
221e0cc03a0Sjdolecek {
222e0cc03a0Sjdolecek struct vnode *vp = (struct vnode *)kn->kn_hook;
22322c6a20eSad int rv;
224e0cc03a0Sjdolecek
225e0cc03a0Sjdolecek /*
226e0cc03a0Sjdolecek * filesystem is gone, so set the EOF flag and schedule
227e0cc03a0Sjdolecek * the knote for deletion.
228e0cc03a0Sjdolecek */
22922c6a20eSad switch (hint) {
23022c6a20eSad case NOTE_REVOKE:
231e225b7bdSrmind KASSERT(mutex_owned(vp->v_interlock));
232e305e37aSthorpej knote_set_eof(kn, EV_ONESHOT);
233e0cc03a0Sjdolecek return (1);
23422c6a20eSad case 0:
235e225b7bdSrmind mutex_enter(vp->v_interlock);
236a9ca7a37Sad kn->kn_data = vp->v_size - ((file_t *)kn->kn_obj)->f_offset;
23722c6a20eSad rv = (kn->kn_data != 0);
238e225b7bdSrmind mutex_exit(vp->v_interlock);
23922c6a20eSad return rv;
24022c6a20eSad default:
241e225b7bdSrmind KASSERT(mutex_owned(vp->v_interlock));
242a9ca7a37Sad kn->kn_data = vp->v_size - ((file_t *)kn->kn_obj)->f_offset;
243e0cc03a0Sjdolecek return (kn->kn_data != 0);
244e0cc03a0Sjdolecek }
24522c6a20eSad }
246e0cc03a0Sjdolecek
247e0cc03a0Sjdolecek static int
filt_nfsvnode(struct knote * kn,long hint)248e0cc03a0Sjdolecek filt_nfsvnode(struct knote *kn, long hint)
249e0cc03a0Sjdolecek {
25022c6a20eSad struct vnode *vp = (struct vnode *)kn->kn_hook;
25122c6a20eSad int fflags;
252e0cc03a0Sjdolecek
25322c6a20eSad switch (hint) {
25422c6a20eSad case NOTE_REVOKE:
255e225b7bdSrmind KASSERT(mutex_owned(vp->v_interlock));
256e305e37aSthorpej knote_set_eof(kn, 0);
25722c6a20eSad if ((kn->kn_sfflags & hint) != 0)
25822c6a20eSad kn->kn_fflags |= hint;
259e0cc03a0Sjdolecek return (1);
26022c6a20eSad case 0:
261e225b7bdSrmind mutex_enter(vp->v_interlock);
26222c6a20eSad fflags = kn->kn_fflags;
263e225b7bdSrmind mutex_exit(vp->v_interlock);
26422c6a20eSad break;
26522c6a20eSad default:
266e225b7bdSrmind KASSERT(mutex_owned(vp->v_interlock));
26722c6a20eSad if ((kn->kn_sfflags & hint) != 0)
26822c6a20eSad kn->kn_fflags |= hint;
26922c6a20eSad fflags = kn->kn_fflags;
27022c6a20eSad break;
271e0cc03a0Sjdolecek }
27222c6a20eSad
27322c6a20eSad return (fflags != 0);
274e0cc03a0Sjdolecek }
275e0cc03a0Sjdolecek
27622c6a20eSad
27718b796d4Smaya static const struct filterops nfsread_filtops = {
278bc827931Sthorpej .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
27918b796d4Smaya .f_attach = NULL,
28018b796d4Smaya .f_detach = filt_nfsdetach,
28118b796d4Smaya .f_event = filt_nfsread,
28218b796d4Smaya };
28318b796d4Smaya
28418b796d4Smaya static const struct filterops nfsvnode_filtops = {
285bc827931Sthorpej .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
28618b796d4Smaya .f_attach = NULL,
28718b796d4Smaya .f_detach = filt_nfsdetach,
28818b796d4Smaya .f_event = filt_nfsvnode,
28918b796d4Smaya };
290e0cc03a0Sjdolecek
291e0cc03a0Sjdolecek int
nfs_kqfilter(void * v)292e0cc03a0Sjdolecek nfs_kqfilter(void *v)
293e0cc03a0Sjdolecek {
294e0cc03a0Sjdolecek struct vop_kqfilter_args /* {
295e0cc03a0Sjdolecek struct vnode *a_vp;
296e0cc03a0Sjdolecek struct knote *a_kn;
297e0cc03a0Sjdolecek } */ *ap = v;
298e0cc03a0Sjdolecek struct vnode *vp;
299e0cc03a0Sjdolecek struct knote *kn;
300e0cc03a0Sjdolecek struct kevq *ke;
301e0cc03a0Sjdolecek int error = 0;
302e0cc03a0Sjdolecek struct vattr attr;
30361e8303eSpooka struct lwp *l = curlwp;
304e0cc03a0Sjdolecek
305e0cc03a0Sjdolecek vp = ap->a_vp;
306e0cc03a0Sjdolecek kn = ap->a_kn;
307e0cc03a0Sjdolecek switch (kn->kn_filter) {
308e0cc03a0Sjdolecek case EVFILT_READ:
309e0cc03a0Sjdolecek kn->kn_fop = &nfsread_filtops;
310e0cc03a0Sjdolecek break;
311e0cc03a0Sjdolecek case EVFILT_VNODE:
312e0cc03a0Sjdolecek kn->kn_fop = &nfsvnode_filtops;
313e0cc03a0Sjdolecek break;
314e0cc03a0Sjdolecek default:
3154e38160dSpooka return (EINVAL);
316e0cc03a0Sjdolecek }
317e0cc03a0Sjdolecek
318e0cc03a0Sjdolecek /*
319e0cc03a0Sjdolecek * Put the vnode to watched list.
320e0cc03a0Sjdolecek */
321e0cc03a0Sjdolecek
322e0cc03a0Sjdolecek /*
323e0cc03a0Sjdolecek * Fetch current attributes. It's only needed when the vnode
324e0cc03a0Sjdolecek * is not watched yet, but we need to do this without lock
325e0cc03a0Sjdolecek * held. This is likely cheap due to attrcache, so do it now.
326e0cc03a0Sjdolecek */
327e0cc03a0Sjdolecek memset(&attr, 0, sizeof(attr));
32868660b46Shannken vn_lock(vp, LK_SHARED | LK_RETRY);
32961e8303eSpooka (void) VOP_GETATTR(vp, &attr, l->l_cred);
33068660b46Shannken VOP_UNLOCK(vp);
331e0cc03a0Sjdolecek
33292ce8c6aSad mutex_enter(&nfskq_lock);
333e0cc03a0Sjdolecek
334e0cc03a0Sjdolecek /* ensure the poller is running */
33588ab7da9Sad if (!nfskq_thread) {
33688ab7da9Sad error = kthread_create(PRI_NONE, 0, NULL, nfs_kqpoll,
33788ab7da9Sad NULL, &nfskq_thread, "nfskqpoll");
33822c6a20eSad if (error) {
33992ce8c6aSad mutex_exit(&nfskq_lock);
34022c6a20eSad return error;
34122c6a20eSad }
342e0cc03a0Sjdolecek }
343e0cc03a0Sjdolecek
344e0cc03a0Sjdolecek SLIST_FOREACH(ke, &kevlist, kev_link) {
345e0cc03a0Sjdolecek if (ke->vp == vp)
346e0cc03a0Sjdolecek break;
347e0cc03a0Sjdolecek }
348e0cc03a0Sjdolecek
349e0cc03a0Sjdolecek if (ke) {
350e0cc03a0Sjdolecek /* already watched, so just bump usecount */
351e0cc03a0Sjdolecek ke->usecount++;
352e0cc03a0Sjdolecek } else {
353e0cc03a0Sjdolecek /* need a new one */
354677860cbSyamt ke = kmem_alloc(sizeof(*ke), KM_SLEEP);
355e0cc03a0Sjdolecek ke->vp = vp;
356e0cc03a0Sjdolecek ke->usecount = 1;
357e0cc03a0Sjdolecek ke->flags = 0;
358e0cc03a0Sjdolecek ke->omtime = attr.va_mtime;
359e0cc03a0Sjdolecek ke->octime = attr.va_ctime;
360e0cc03a0Sjdolecek ke->onlink = attr.va_nlink;
361fbee155dSyamt cv_init(&ke->cv, "nfskqdet");
362e0cc03a0Sjdolecek SLIST_INSERT_HEAD(&kevlist, ke, kev_link);
363e0cc03a0Sjdolecek }
364e0cc03a0Sjdolecek
36522c6a20eSad kn->kn_hook = vp;
366*982ae832Sthorpej
367*982ae832Sthorpej vn_knote_attach(vp, kn);
36822c6a20eSad
369e0cc03a0Sjdolecek /* kick the poller */
370fbee155dSyamt cv_signal(&nfskq_cv);
37192ce8c6aSad mutex_exit(&nfskq_lock);
37222c6a20eSad
373e0cc03a0Sjdolecek return (error);
374e0cc03a0Sjdolecek }
375