src/afs/FBSD/osi_vm.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10
  11 /* osi_vm.c implements:
  12  *
  13  * osi_VM_FlushVCache(avc, slept)
  14  * osi_ubc_flush_dirty_and_wait(vp, flags)
  15  * osi_VM_StoreAllSegments(avc)
  16  * osi_VM_TryToSmush(avc, acred, sync)
  17  * osi_VM_FlushPages(avc, credp)
  18  * osi_VM_Truncate(avc, alen, acred)
  19  */
  20
  21 #include <afsconfig.h>
  22 #include "afs/param.h"
  23 #include <sys/param.h>
  24 #include <sys/vnode.h>
  25
  26
  27 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  28 #include "afsincludes.h"        /* Afs-based standard headers */
  29 #include "afs/afs_stats.h"      /* statistics */
  30 #include <vm/vm_object.h>
  31 #include <vm/vm_map.h>
  32 #include <limits.h>
  33 #include <float.h>
  34
  35 /*
  36  * FreeBSD implementation notes:
  37  * Most of these operations require us to frob vm_objects.  Most
  38  * functions require that the object be locked (with VM_OBJECT_LOCK)
  39  * on entry and leave it locked on exit.  In order to get the
  40  * vm_object itself we call VOP_GETVOBJECT on the vnode; the
  41  * locking protocol requires that we do so with the heavy vnode lock
  42  * held and the vnode interlock unlocked, and it returns the same
  43  * way.
  44  *
  45  * The locking protocol for vnodes is defined in
  46  * kern/vnode_if.src and sys/vnode.h; the locking is still a work in
  47  * progress, so some fields are (as of 5.1) still protected by Giant
  48  * rather than an explicit lock.
  49  */
  50
  51 #ifdef AFS_FBSD60_ENV
  52 #define VOP_GETVOBJECT(vp, objp) (*(objp) = (vp)->v_object)
  53 #endif
  54
  55 #if defined(AFS_FBSD80_ENV)
  56 #define lock_vnode(v, f)        vn_lock((v), (f))
  57 #define ilock_vnode(v)  vn_lock((v), LK_INTERLOCK|LK_EXCLUSIVE|LK_RETRY);
  58 #define unlock_vnode(v) VOP_UNLOCK((v), 0)
  59 #define islocked_vnode(v)       VOP_ISLOCKED((v))
  60 #else
  61 #define lock_vnode(v, f)        vn_lock((v), (f), curthread)
  62 #define ilock_vnode(v)  vn_lock((v), LK_INTERLOCK|LK_EXCLUSIVE|LK_RETRY, curthread);
  63 #define unlock_vnode(v) VOP_UNLOCK((v), 0, curthread)
  64 #define islocked_vnode(v)       VOP_ISLOCKED((v), curthread)
  65 #endif
  66
  67 /* Try to discard pages, in order to recycle a vcache entry.
  68  *
  69  * We also make some sanity checks:  ref count, open count, held locks.
  70  *
  71  * We also do some non-VM-related chores, such as releasing the cred pointer
  72  * (for AIX and Solaris) and releasing the gnode (for AIX).
  73  *
  74  * Locking:  afs_xvcache lock is held.  If it is dropped and re-acquired,
  75  *   *slept should be set to warn the caller.
  76  *
  77  * Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it
  78  * is not dropped and re-acquired for any platform.  It may be that *slept is
  79  * therefore obsolescent.
  80  *
  81  */
  82 int
  83 osi_VM_FlushVCache(struct vcache *avc, int *slept)
  84 {
  85     struct vnode *vp = AFSTOV(avc);
  86
  87     if (!VI_TRYLOCK(vp)) /* need interlock to check usecount */
  88         return EBUSY;
  89
  90     if (vp->v_usecount > 0) {
  91         VI_UNLOCK(vp);
  92         return EBUSY;
  93     }
  94
  95     /* XXX
  96      * The value of avc->opens here came to be, at some point,
  97      * typically -1.  This was caused by incorrectly performing afs_close
  98      * processing on vnodes being recycled */
  99     if (avc->opens) {
 100         VI_UNLOCK(vp);
 101         return EBUSY;
 102     }
 103
 104     /* if a lock is held, give up */
 105     if (CheckLock(&avc->lock)) {
 106         VI_UNLOCK(vp);
 107         return EBUSY;
 108     }
 109
 110     if ((vp->v_iflag & VI_DOOMED) != 0) {
 111         VI_UNLOCK(vp);
 112         return (0);
 113     }
 114
 115     /* must hold the vnode before calling vgone()
 116      * This code largely copied from vfs_subr.c:vlrureclaim() */
 117     vholdl(vp);
 118     AFS_GUNLOCK();
 119     *slept = 1;
 120     /* use the interlock while locking, so no one else can DOOM this */
 121     ilock_vnode(vp);
 122     vgone(vp);
 123     unlock_vnode(vp);
 124     vdrop(vp);
 125
 126     AFS_GLOCK();
 127     return 0;
 128 }
 129
 130 /* Try to store pages to cache, in order to store a file back to the server.
 131  *
 132  * Locking:  the vcache entry's lock is held.  It will usually be dropped and
 133  * re-obtained.
 134  */
 135 void
 136 osi_VM_StoreAllSegments(struct vcache *avc)
 137 {
 138     struct vnode *vp;
 139     struct vm_object *obj;
 140     int anyio, tries;
 141
 142     ReleaseWriteLock(&avc->lock);
 143     AFS_GUNLOCK();
 144     tries = 5;
 145     vp = AFSTOV(avc);
 146
 147     /*
 148      * I don't understand this.  Why not just call vm_object_page_clean()
 149      * and be done with it?  I particularly don't understand why we're calling
 150      * vget() here.  Is there some reason to believe that the vnode might
 151      * be being recycled at this point?  I don't think there's any need for
 152      * this loop, either -- if we keep the vnode locked all the time,
 153      * that and the object lock will prevent any new pages from appearing.
 154      * The loop is what causes the race condition.  -GAW
 155      */
 156     do {
 157         anyio = 0;
 158         if (VOP_GETVOBJECT(vp, &obj) == 0 && (obj->flags & OBJ_MIGHTBEDIRTY)) {
 159             if (!vget(vp, LK_EXCLUSIVE | LK_RETRY, curthread)) {
 160                     if (VOP_GETVOBJECT(vp, &obj) == 0) {
 161                         VM_OBJECT_LOCK(obj);
 162                         vm_object_page_clean(obj, 0, 0, OBJPC_SYNC);
 163                         VM_OBJECT_UNLOCK(obj);
 164                         anyio = 1;
 165                     }
 166                     vput(vp);
 167                 }
 168             }
 169     } while (anyio && (--tries > 0));
 170     AFS_GLOCK();
 171     ObtainWriteLock(&avc->lock, 94);
 172 }
 173
 174 /* Try to invalidate pages, for "fs flush" or "fs flushv"; or
 175  * try to free pages, when deleting a file.
 176  *
 177  * Locking:  the vcache entry's lock is held.  It may be dropped and
 178  * re-obtained.
 179  *
 180  * Since we drop and re-obtain the lock, we can't guarantee that there won't
 181  * be some pages around when we return, newly created by concurrent activity.
 182  */
 183 void
 184 osi_VM_TryToSmush(struct vcache *avc, afs_ucred_t *acred, int sync)
 185 {
 186     struct vnode *vp;
 187     int tries, code;
 188     int islocked;
 189
 190     vp = AFSTOV(avc);
 191
 192     VI_LOCK(vp);
 193     if (vp->v_iflag & VI_DOOMED) {
 194         VI_UNLOCK(vp);
 195         return;
 196     }
 197     VI_UNLOCK(vp);
 198
 199     islocked = islocked_vnode(vp);
 200     if (islocked == LK_EXCLOTHER)
 201         panic("Trying to Smush over someone else's lock");
 202     else if (islocked == LK_SHARED) {
 203         afs_warn("Trying to Smush with a shared lock");
 204         lock_vnode(vp, LK_UPGRADE);
 205     } else if (!islocked)
 206         lock_vnode(vp, LK_EXCLUSIVE);
 207
 208     if (vp->v_bufobj.bo_object != NULL) {
 209         VM_OBJECT_LOCK(vp->v_bufobj.bo_object);
 210         /*
 211          * Do we really want OBJPC_SYNC?  OBJPC_INVAL would be
 212          * faster, if invalidation is really what we are being
 213          * asked to do.  (It would make more sense, too, since
 214          * otherwise this function is practically identical to
 215          * osi_VM_StoreAllSegments().)  -GAW
 216          */
 217
 218         /*
 219          * Dunno.  We no longer resemble osi_VM_StoreAllSegments,
 220          * though maybe that's wrong, now.  And OBJPC_SYNC is the
 221          * common thing in 70 file systems, it seems.  Matt.
 222          */
 223
 224         vm_object_page_clean(vp->v_bufobj.bo_object, 0, 0, OBJPC_SYNC);
 225         VM_OBJECT_UNLOCK(vp->v_bufobj.bo_object);
 226     }
 227
 228     tries = 5;
 229     code = osi_vinvalbuf(vp, V_SAVE, PCATCH, 0);
 230     while (code && (tries > 0)) {
 231         afs_warn("TryToSmush retrying vinvalbuf");
 232         code = osi_vinvalbuf(vp, V_SAVE, PCATCH, 0);
 233         --tries;
 234     }
 235     if (islocked == LK_SHARED)
 236         lock_vnode(vp, LK_DOWNGRADE);
 237     else if (!islocked)
 238         unlock_vnode(vp);
 239 }
 240
 241 /* Purge VM for a file when its callback is revoked.
 242  *
 243  * Locking:  No lock is held, not even the global lock.
 244  */
 245 void
 246 osi_VM_FlushPages(struct vcache *avc, afs_ucred_t *credp)
 247 {
 248     struct vnode *vp;
 249     struct vm_object *obj;
 250
 251     vp = AFSTOV(avc);
 252     ASSERT_VOP_LOCKED(vp, __func__);
 253     if (VOP_GETVOBJECT(vp, &obj) == 0) {
 254         VM_OBJECT_LOCK(obj);
 255         vm_object_page_remove(obj, 0, 0, FALSE);
 256         VM_OBJECT_UNLOCK(obj);
 257     }
 258     osi_vinvalbuf(vp, 0, 0, 0);
 259 }
 260
 261 /* Purge pages beyond end-of-file, when truncating a file.
 262  *
 263  * Locking:  no lock is held, not even the global lock.
 264  * activeV is raised.  This is supposed to block pageins, but at present
 265  * it only works on Solaris.
 266  */
 267 void
 268 osi_VM_Truncate(struct vcache *avc, int alen, afs_ucred_t *acred)
 269 {
 270     vnode_pager_setsize(AFSTOV(avc), alen);
 271 }