sys/nfs/nfs_kq.c

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