afs: Fix some dcache-related comments

[openafs.git] / src / afs / afs_dcache.c

diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c
index b398cf5..872757a 100644 (file)
--- a/src/afs/afs_dcache.c
+++ b/src/afs/afs_dcache.c
@@ -1,6 +1,6 @@
 /*
  * Copyright 2000, International Business Machines Corporation and others.
- *$All Rights Reserved.
+ * All Rights Reserved.
  *
  * This software has been released under the terms of the IBM Public
  * License.  For details, see the LICENSE file in the top-level source
@@ -22,7 +22,7 @@
 
 /* Forward declarations. */
 static void afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint);
-static void afs_FreeDiscardedDCache(void);
+static int afs_FreeDiscardedDCache(void);
 static void afs_DiscardDCache(struct dcache *);
 static void afs_FreeDCache(struct dcache *);
 /* For split cache */
@@ -396,6 +396,27 @@ static struct CTD_stats {
 u_int afs_min_cache = 0;
 
 /*!
+ * If there are waiters for the cache to drain, wake them if
+ * the number of free or discarded cache blocks reaches the
+ * CM_CACHESIZEDDRAINEDPCT limit.
+ *
+ * \note Environment:
+ *     This routine must be called with the afs_xdcache lock held
+ *     (in write mode).
+ */
+static void
+afs_WakeCacheWaitersIfDrained(void)
+{
+    if (afs_WaitForCacheDrain) {
+       if ((afs_blocksUsed - afs_blocksDiscarded) <=
+           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
+           afs_WaitForCacheDrain = 0;
+           afs_osi_Wakeup(&afs_WaitForCacheDrain);
+       }
+    }
+}
+
+/*!
  * Keeps the cache clean and free by truncating uneeded files, when used.
  * \param
  * \return
@@ -416,7 +437,7 @@ afs_CacheTruncateDaemon(void)
     while (1) {
        cb_lowat = PERCENT((CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT), afs_cacheBlocks);
        ObtainWriteLock(&afs_xdcache, 266);
-       if (afs_CacheTooFull) {
+       if (afs_CacheTooFull || afs_WaitForCacheDrain) {
            int space_needed, slots_needed;
            /* if we get woken up, we should try to clean something out */
            for (counter = 0; counter < 10; counter++) {
@@ -437,8 +458,10 @@ afs_CacheTruncateDaemon(void)
                if (afs_termState == AFSOP_STOP_TRUNCDAEMON)
                    break;
            }
-           if (!afs_CacheIsTooFull())
+           if (!afs_CacheIsTooFull()) {
                afs_CacheTooFull = 0;
+               afs_WakeCacheWaitersIfDrained();
+           }
        }       /* end of cache cleanup */
        ReleaseWriteLock(&afs_xdcache);
 
@@ -459,7 +482,16 @@ afs_CacheTruncateDaemon(void)
         */
        while (afs_blocksDiscarded && !afs_WaitForCacheDrain
               && (afs_termState != AFSOP_STOP_TRUNCDAEMON)) {
-           afs_FreeDiscardedDCache();
+           int code = afs_FreeDiscardedDCache();
+           if (code) {
+               /* If we can't free any discarded dcache entries, that's okay.
+                * We're just doing this in the background; if someone needs
+                * discarded entries freed, they will try it themselves and/or
+                * signal us that the cache is too full. In any case, we'll
+                * try doing this again the next time we run through the loop.
+                */
+               break;
+           }
        }
 
        /* See if we need to continue to run. Someone may have
@@ -978,14 +1010,6 @@ afs_FlushDCache(struct dcache *adc)
     } else {
        afs_FreeDCache(adc);
     }
-
-    if (afs_WaitForCacheDrain) {
-       if (afs_blocksUsed <=
-           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
-           afs_WaitForCacheDrain = 0;
-           afs_osi_Wakeup(&afs_WaitForCacheDrain);
-       }
-    }
 }                              /*afs_FlushDCache */
 
 
@@ -1010,13 +1034,7 @@ afs_FreeDCache(struct dcache *adc)
     afs_indexFlags[adc->index] |= IFFree;
     adc->dflags |= DFEntryMod;
 
-    if (afs_WaitForCacheDrain) {
-       if ((afs_blocksUsed - afs_blocksDiscarded) <=
-           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
-           afs_WaitForCacheDrain = 0;
-           afs_osi_Wakeup(&afs_WaitForCacheDrain);
-       }
-    }
+    afs_WakeCacheWaitersIfDrained();
 }                              /* afs_FreeDCache */
 
 /*!
@@ -1056,14 +1074,7 @@ afs_DiscardDCache(struct dcache *adc)
     adc->dflags |= DFEntryMod;
     afs_indexFlags[adc->index] |= IFDiscarded;
 
-    if (afs_WaitForCacheDrain) {
-       if ((afs_blocksUsed - afs_blocksDiscarded) <=
-           PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
-           afs_WaitForCacheDrain = 0;
-           afs_osi_Wakeup(&afs_WaitForCacheDrain);
-       }
-    }
-
+    afs_WakeCacheWaitersIfDrained();
 }                              /*afs_DiscardDCache */
 
 /**
@@ -1096,8 +1107,11 @@ afs_GetDSlotFromList(afs_int32 *indexp)
 
 /*!
  * Free the next element on the list of discarded cache elements.
+ *
+ * Returns -1 if we encountered an error preventing us from freeing a
+ * discarded dcache, or 0 on success.
  */
-static void
+static int
 afs_FreeDiscardedDCache(void)
 {
     struct dcache *tdc;
@@ -1109,14 +1123,17 @@ afs_FreeDiscardedDCache(void)
     ObtainWriteLock(&afs_xdcache, 510);
     if (!afs_blocksDiscarded) {
        ReleaseWriteLock(&afs_xdcache);
-       return;
+       return 0;
     }
 
     /*
      * Get an entry from the list of discarded cache elements
      */
     tdc = afs_GetDSlotFromList(&afs_discardDCList);
-    osi_Assert(tdc);
+    if (!tdc) {
+       ReleaseWriteLock(&afs_xdcache);
+       return -1;
+    }
 
     afs_discardDCCount--;
     size = ((tdc->f.chunkBytes + afs_fsfragsize) ^ afs_fsfragsize) >> 10;      /* round up */
@@ -1145,6 +1162,8 @@ afs_FreeDiscardedDCache(void)
     ReleaseWriteLock(&tdc->lock);
     afs_PutDCache(tdc);
     ReleaseWriteLock(&afs_xdcache);
+
+    return 0;
 }
 
 /*!
@@ -1162,7 +1181,14 @@ afs_MaybeFreeDiscardedDCache(void)
     while (afs_blocksDiscarded
           && (afs_blocksUsed >
               PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks))) {
-       afs_FreeDiscardedDCache();
+       int code = afs_FreeDiscardedDCache();
+       if (code) {
+           /* Callers depend on us to get the afs_blocksDiscarded count down.
+            * If we cannot do that, the callers can spin by calling us over
+            * and over. Panic for now until we can figure out something
+            * better. */
+           osi_Panic("Error freeing discarded dcache");
+       }
     }
     return 0;
 }
@@ -2875,7 +2901,15 @@ afs_UFSGetDSlot(afs_int32 aslot, int indexvalid, int datavalid)
                  (int)aslot, off);
     }
 
-    if (!entryok || !datavalid) {
+    if (indexvalid && !datavalid) {
+       /* we know that the given dslot does exist, but the data in it is not
+        * valid. this only occurs when we pull a dslot from the free or
+        * discard list, so be sure not to re-use the data; force invalidation.
+        */
+       entryok = 0;
+    }
+
+    if (!entryok) {
        tdc->f.fid.Cell = 0;
        tdc->f.fid.Fid.Volume = 0;
        tdc->f.chunk = -1;
@@ -3295,7 +3329,6 @@ afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk, int aflags)
            afs_warn("afsd: memory cache too large for available memory.\n");
            afs_warn("afsd: AFS files cannot be accessed.\n\n");
            dcacheDisabled = 1;
-           afiles = ablocks = 0;
        } else
            afs_warn("Memory cache: Allocating %d dcache entries...",
                   aDentries);