src/afs/DARWIN/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 #include <afsconfig.h>
  11 #include "afs/param.h"
  12
  13 RCSID
  14     ("$Header$");
  15
  16 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  17 #include "afsincludes.h"        /* Afs-based standard headers */
  18 #include "afs/afs_stats.h"      /* statistics */
  19 #include <sys/ubc.h>
  20
  21 /* Try to discard pages, in order to recycle a vcache entry.
  22  *
  23  * We also make some sanity checks:  ref count, open count, held locks.
  24  *
  25  * We also do some non-VM-related chores, such as releasing the cred pointer
  26  * (for AIX and Solaris) and releasing the gnode (for AIX).
  27  *
  28  * Locking:  afs_xvcache lock is held.  If it is dropped and re-acquired,
  29  *   *slept should be set to warn the caller.
  30  *
  31  * Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it
  32  * is not dropped and re-acquired for any platform.  It may be that *slept is
  33  * therefore obsolescent.
  34  *
  35  * OSF/1 Locking:  VN_LOCK has been called.
  36  */
  37 int
  38 osi_VM_FlushVCache(struct vcache *avc, int *slept)
  39 {
  40     struct vnode *vp = AFSTOV(avc);
  41 #ifdef AFS_DARWIN14_ENV
  42     if (UBCINFOEXISTS(vp))
  43         return EBUSY;
  44 #endif
  45     if (avc->vrefCount)
  46         return EBUSY;
  47
  48     if (avc->opens)
  49         return EBUSY;
  50
  51     /* if a lock is held, give up */
  52     if (CheckLock(&avc->lock) || afs_CheckBozonLock(&avc->pvnLock))
  53         return EBUSY;
  54
  55     AFS_GUNLOCK();
  56     cache_purge(vp);
  57 #ifndef AFS_DARWIN14_ENV
  58     if (UBCINFOEXISTS(vp)) {
  59         ubc_clean(vp, 1);
  60         ubc_uncache(vp);
  61         ubc_release(vp);
  62         ubc_info_free(vp);
  63     }
  64 #else
  65     /* This is literally clean_up_name_parent_ptrs() */
  66     /* Critical to clean up any state attached to the vnode here since it's
  67        being recycled, and we're not letting refcnt drop to 0 to trigger
  68        normal recycling. */
  69     if (VNAME(vp) || VPARENT(vp)) {
  70         char *tmp1;
  71         struct vnode *tmp2;
  72
  73         /* do it this way so we don't block before clearing
  74            these fields. */
  75         tmp1 = VNAME(vp);
  76         tmp2 = VPARENT(vp);
  77         VNAME(vp) = NULL;
  78         VPARENT(vp) = NULL;
  79
  80         if (tmp1) {
  81             remove_name(tmp1);
  82         }
  83
  84         if (tmp2) {
  85             vrele(tmp2);
  86         }
  87     }
  88 #endif
  89
  90     AFS_GLOCK();
  91
  92     return 0;
  93 }
  94
  95
  96 /* Try to store pages to cache, in order to store a file back to the server.
  97  *
  98  * Locking:  the vcache entry's lock is held.  It will usually be dropped and
  99  * re-obtained.
 100  */
 101 void
 102 osi_VM_StoreAllSegments(struct vcache *avc)
 103 {
 104     struct vnode *vp = AFSTOV(avc);
 105     ReleaseWriteLock(&avc->lock);
 106     AFS_GUNLOCK();
 107     if (UBCINFOEXISTS(vp)) {
 108         ubc_pushdirty(vp);
 109     }
 110     AFS_GLOCK();
 111     ObtainWriteLock(&avc->lock, 94);
 112 }
 113
 114 /* Try to invalidate pages, for "fs flush" or "fs flushv"; or
 115  * try to free pages, when deleting a file.
 116  *
 117  * Locking:  the vcache entry's lock is held.  It may be dropped and
 118  * re-obtained.
 119  *
 120  * Since we drop and re-obtain the lock, we can't guarantee that there won't
 121  * be some pages around when we return, newly created by concurrent activity.
 122  */
 123 void
 124 osi_VM_TryToSmush(struct vcache *avc, struct AFS_UCRED *acred, int sync)
 125 {
 126     struct vnode *vp = AFSTOV(avc);
 127     void *object;
 128     kern_return_t kret;
 129     off_t size, lastpg;
 130
 131     ReleaseWriteLock(&avc->lock);
 132     AFS_GUNLOCK();
 133     if (UBCINFOEXISTS(vp)) {
 134         size = ubc_getsize(vp);
 135         kret = ubc_invalidate(vp, 0, size);
 136         if (kret != 1)          /* should be KERN_SUCCESS */
 137             printf("TryToSmush: invalidate failed (error = %d)\n", kret);
 138     }
 139     AFS_GLOCK();
 140     ObtainWriteLock(&avc->lock, 59);
 141 }
 142
 143 /* Purge VM for a file when its callback is revoked.
 144  *
 145  * Locking:  No lock is held, not even the global lock.
 146  */
 147 /* XXX this seems to not be referenced anywhere. *somebody* ought to be calling
 148    this, and also making sure that ubc's idea of the filesize is right more
 149    often */
 150 void
 151 osi_VM_FlushPages(struct vcache *avc, struct AFS_UCRED *credp)
 152 {
 153     struct vnode *vp = AFSTOV(avc);
 154     void *object;
 155     kern_return_t kret;
 156     off_t size;
 157     if (UBCINFOEXISTS(vp)) {
 158         size = ubc_getsize(vp);
 159         kret = ubc_invalidate(vp, 0, size);
 160         if (kret != 1)          /* Should be KERN_SUCCESS */
 161             printf("VMFlushPages: invalidate failed (error = %d)\n", kret);
 162         /* XXX what about when not CStatd */
 163         if (avc->states & CStatd && size != avc->m.Length)
 164             ubc_setsize(vp, avc->m.Length);
 165     }
 166 }
 167
 168 /* Purge pages beyond end-of-file, when truncating a file.
 169  *
 170  * Locking:  no lock is held, not even the global lock.
 171  * activeV is raised.  This is supposed to block pageins, but at present
 172  * it only works on Solaris.
 173  */
 174 void
 175 osi_VM_Truncate(struct vcache *avc, int alen, struct AFS_UCRED *acred)
 176 {
 177     struct vnode *vp = AFSTOV(avc);
 178     if (UBCINFOEXISTS(vp)) {
 179         ubc_setsize(vp, alen);
 180     }
 181 }
 182
 183 /* vnreclaim and vinactive are probably not aggressive enough to keep
 184    enough afs vcaches free, so we try to do some of it ourselves */
 185 /* XXX there's probably not nearly enough locking here */
 186 void
 187 osi_VM_TryReclaim(struct vcache *avc, int *slept)
 188 {
 189     struct proc *p = current_proc();
 190     struct vnode *vp = AFSTOV(avc);
 191     void *obj;
 192
 193     if (slept)
 194         *slept = 0;
 195     VN_HOLD(vp);                /* remove from inactive list */
 196     if (!simple_lock_try(&vp->v_interlock)) {
 197         AFS_RELE(vp);
 198         return;
 199     }
 200     if (!UBCINFOEXISTS(vp) || vp->v_count != 2) {
 201         simple_unlock(&vp->v_interlock);
 202         AFS_RELE(vp);
 203         return;
 204     }
 205     if (ISSET(vp->v_flag, VUINACTIVE)) {
 206         simple_unlock(&vp->v_interlock);
 207         AFS_RELE(vp);
 208         printf("vnode %x still inactive!", vp);
 209         return;
 210     }
 211 #ifdef AFS_DARWIN14_ENV
 212     if (vp->v_ubcinfo->ui_refcount > 1 || vp->v_ubcinfo->ui_mapped) {
 213         simple_unlock(&vp->v_interlock);
 214         AFS_RELE(vp);
 215         return;
 216     }
 217 #else
 218     if (vp->v_ubcinfo->ui_holdcnt) {
 219         simple_unlock(&vp->v_interlock);
 220         AFS_RELE(vp);
 221         return;
 222     }
 223 #endif
 224     if (slept && ubc_issetflags(vp, UI_WASMAPPED)) {
 225         /* We can't possibly release this in time for this NewVCache to get it */
 226         simple_unlock(&vp->v_interlock);
 227         AFS_RELE(vp);
 228         return;
 229     }
 230
 231     vp->v_usecount--;           /* we want the usecount to be 1 */
 232
 233     if (slept) {
 234         ReleaseWriteLock(&afs_xvcache);
 235         *slept = 1;
 236     } else
 237         ReleaseReadLock(&afs_xvcache);
 238     AFS_GUNLOCK();
 239     obj = 0;
 240     if (ubc_issetflags(vp, UI_WASMAPPED)) {
 241         simple_unlock(&vp->v_interlock);
 242 #ifdef  AFS_DARWIN14_ENV
 243         ubc_release_named(vp);
 244 #else
 245         ubc_release(vp);
 246 #endif
 247         if (ubc_issetflags(vp, UI_HASOBJREF))
 248             printf("ubc_release didn't release the reference?!\n");
 249     } else if (!vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, current_proc())) {
 250 #ifdef AFS_DARWIN14_ENV
 251         obj = ubc_getobject(vp, UBC_HOLDOBJECT);
 252 #else
 253 #ifdef AFS_DARWIN13_ENV
 254         obj = ubc_getobject(vp, (UBC_NOREACTIVATE | UBC_HOLDOBJECT));
 255 #else
 256         obj = ubc_getobject(vp);
 257 #endif
 258 #endif
 259         (void)ubc_clean(vp, 1);
 260         vinvalbuf(vp, V_SAVE, &afs_osi_cred, p, 0, 0);
 261         if (vp->v_usecount == 1)
 262             VOP_INACTIVE(vp, p);
 263         else
 264             VOP_UNLOCK(vp, 0, p);
 265         if (obj) {
 266             if (ISSET(vp->v_flag, VTERMINATE))
 267                 panic("afs_vnreclaim: already teminating");
 268             SET(vp->v_flag, VTERMINATE);
 269             memory_object_destroy(obj, 0);
 270             while (ISSET(vp->v_flag, VTERMINATE)) {
 271                 SET(vp->v_flag, VTERMWANT);
 272                 tsleep((caddr_t) & vp->v_ubcinfo, PINOD, "afs_vnreclaim", 0);
 273             }
 274         }
 275     } else {
 276         if (simple_lock_try(&vp->v_interlock))
 277             panic("afs_vnreclaim: slept, but did no work :(");
 278         if (UBCINFOEXISTS(vp) && vp->v_count == 1) {
 279             vp->v_usecount++;
 280             simple_unlock(&vp->v_interlock);
 281             VN_RELE(vp);
 282         } else
 283             simple_unlock(&vp->v_interlock);
 284     }
 285     AFS_GLOCK();
 286     if (slept)
 287         ObtainWriteLock(&afs_xvcache, 175);
 288     else
 289         ObtainReadLock(&afs_xvcache);
 290 }
 291
 292 void
 293 osi_VM_NukePages(struct vnode *vp, off_t offset, off_t size)
 294 {
 295     void *object;
 296     struct vcache *avc = VTOAFS(vp);
 297
 298 #ifdef AFS_DARWIN14_ENV
 299     offset = trunc_page(offset);
 300     size = round_page(size + 1);
 301     while (size) {
 302         ubc_page_op(vp, (vm_offset_t) offset,
 303                     UPL_POP_SET | UPL_POP_BUSY | UPL_POP_DUMP, 0, 0);
 304         size -= PAGE_SIZE;
 305         offset += PAGE_SIZE;
 306     }
 307 #else
 308     object = NULL;
 309 #ifdef AFS_DARWIN13_ENV
 310     if (UBCINFOEXISTS(vp))
 311         object = ubc_getobject(vp, UBC_NOREACTIVATE);
 312 #else
 313     if (UBCINFOEXISTS(vp))
 314         object = ubc_getobject(vp);
 315 #endif
 316     if (!object)
 317         return;
 318
 319     offset = trunc_page(offset);
 320     size = round_page(size + 1);
 321
 322 #ifdef AFS_DARWIN13_ENV
 323     while (size) {
 324         memory_object_page_op(object, (vm_offset_t) offset,
 325                               UPL_POP_SET | UPL_POP_BUSY | UPL_POP_DUMP, 0,
 326                               0);
 327         size -= PAGE_SIZE;
 328         offset += PAGE_SIZE;
 329     }
 330 #else
 331     /* This is all we can do, and it's not enough. sucks to be us */
 332     ubc_setsize(vp, offset);
 333     size = (offset + size > avc->m.Length) ? offset + size : avc->m.Length;
 334     ubc_setsize(vp, size);
 335 #endif
 336 #endif
 337 }
 338
 339 int
 340 osi_VM_Setup(struct vcache *avc, int force)
 341 {
 342     int error;
 343     struct vnode *vp = AFSTOV(avc);
 344
 345     if (UBCISVALID(vp) && ((avc->states & CStatd) || force)) {
 346         if (!UBCINFOEXISTS(vp) && !ISSET(vp->v_flag, VTERMINATE)) {
 347             osi_vnhold(avc, 0);
 348             avc->states |= CUBCinit;
 349             AFS_GUNLOCK();
 350             if ((error = ubc_info_init(&avc->v))) {
 351                 AFS_GLOCK();
 352                 avc->states &= ~CUBCinit;
 353                 AFS_RELE(avc);
 354                 return error;
 355             }
 356 #ifndef AFS_DARWIN14_ENV
 357             simple_lock(&avc->v.v_interlock);
 358             if (!ubc_issetflags(&avc->v, UI_HASOBJREF))
 359 #ifdef AFS_DARWIN13_ENV
 360                 if (ubc_getobject
 361                     (&avc->v, (UBC_NOREACTIVATE | UBC_HOLDOBJECT)))
 362                     panic("VM_Setup: null object");
 363 #else
 364                 (void)_ubc_getobject(&avc->v, 1);       /* return value not used */
 365 #endif
 366             simple_unlock(&avc->v.v_interlock);
 367 #endif
 368             AFS_GLOCK();
 369             avc->states &= ~CUBCinit;
 370             AFS_RELE(avc);
 371         }
 372         if (UBCINFOEXISTS(&avc->v))
 373             ubc_setsize(&avc->v, avc->m.Length);
 374     }
 375     return 0;
 376 }