Disk cache: Fix handling of invalid entries that are detected...

net/disk_cache/eviction.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy ads re-use as a factor to evict
@@ skipping 55 matching lines @@
   new_eviction_ = backend->new_eviction_;
   first_trim_ = true;
   trimming_ = false;
   delay_trim_ = false;
 }
 
 void Eviction::TrimCache(bool empty) {
   if (new_eviction_)
     return TrimCacheV2(empty);
 
-  Trace("*** Trim Cache ***");
   if (backend_->disabled_ || trimming_)
     return;
 
   if (!empty && backend_->IsLoaded())
     return PostDelayedTrim();
 
+  Trace("*** Trim Cache ***");
   trimming_ = true;
   Time start = Time::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
       rankings_->GetPrev(node.get(), Rankings::NO_USE));
-  DCHECK(next.get());
   int target_size = empty ? 0 : max_size_;
   while (header_->num_bytes > target_size && next.get()) {
+    // The iterator could be invalidated within EvictEntry().
+    if (!next->HasData())
+      break;
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::NO_USE));
     if (!node->Data()->pointer || empty) {
       // This entry is not being used by anybody.
+      // Do NOT use node as an iterator after this point.
+      rankings_->TrackRankingsBlock(node.get(), false);
       if (!EvictEntry(node.get(), empty))
         continue;
 
       if (!empty) {
         backend_->OnEvent(Stats::TRIM_ENTRY);
 
         if ((Time::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
@@ skipping 79 matching lines @@
       header_->create_time = Time::FromLocalExploded(old).ToInternalValue();
     }
   }
 }
 
 Rankings::List Eviction::GetListForEntry(EntryImpl* entry) {
   return Rankings::NO_USE;
 }
 
 bool Eviction::EvictEntry(CacheRankingsBlock* node, bool empty) {
-  EntryImpl* entry;
-  bool dirty;
-  if (backend_->NewEntry(Addr(node->Data()->contents), &entry, &dirty)) {
+  EntryImpl* entry = backend_->GetEnumeratedEntry(node, true);
+  if (!entry) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
-  if (node->Data()->pointer) {
-    // We ignore the failure; we're removing the entry anyway.
-    entry->Update();
-  }
   ReportTrimTimes(entry);
   if (empty || !new_eviction_) {
     entry->Doom();
   } else {
     entry->DeleteEntryData(false);
     EntryStore* info = entry->entry()->Data();
     DCHECK(ENTRY_NORMAL == info->state);
 
     rankings_->Remove(entry->rankings(), GetListForEntryV2(entry));
     info->state = ENTRY_EVICTED;
     entry->entry()->Store();
     rankings_->Insert(entry->rankings(), true, Rankings::DELETED);
     backend_->OnEvent(Stats::TRIM_ENTRY);
   }
   entry->Release();
 
   return true;
 }
 
 // -----------------------------------------------------------------------
 
 void Eviction::TrimCacheV2(bool empty) {
-  Trace("*** Trim Cache ***");
   if (backend_->disabled_ || trimming_)
     return;
 
   if (!empty && backend_->IsLoaded())
     return PostDelayedTrim();
 
+  Trace("*** Trim Cache ***");
   trimming_ = true;
   Time start = Time::Now();
 
   const int kListsToSearch = 3;
   Rankings::ScopedRankingsBlock next[kListsToSearch];
   int list = Rankings::LAST_ELEMENT;
 
   // Get a node from each list.
   for (int i = 0; i < kListsToSearch; i++) {
     bool done = false;
@@ skipping 19 matching lines @@
   }
 
   if (empty)
     list = 0;
 
   Rankings::ScopedRankingsBlock node(rankings_);
 
   int target_size = empty ? 0 : max_size_;
   for (; list < kListsToSearch; list++) {
     while (header_->num_bytes > target_size && next[list].get()) {
+      // The iterator could be invalidated within EvictEntry().
+      if (!next[list]->HasData())
+        break;
       node.reset(next[list].release());
       next[list].reset(rankings_->GetPrev(node.get(),
                                           static_cast<Rankings::List>(list)));
       if (!node->Data()->pointer || empty) {
         // This entry is not being used by anybody.
+        // Do NOT use node as an iterator after this point.
+        rankings_->TrackRankingsBlock(node.get(), false);
         if (!EvictEntry(node.get(), empty))
           continue;
 
         if (!empty && (Time::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
@@ skipping 124 matching lines @@
 }
 
 bool Eviction::RemoveDeletedNode(CacheRankingsBlock* node) {
   EntryImpl* entry;
   bool dirty;
   if (backend_->NewEntry(Addr(node->Data()->contents), &entry, &dirty)) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
+  // TODO(rvargas): figure out how to deal with corruption at this point (dirty
+  // entries that live in this list).
   if (node->Data()->pointer) {
     // We ignore the failure; we're removing the entry anyway.
     entry->Update();
   }
   entry->entry()->Data()->state = ENTRY_DOOMED;
   entry->Doom();
   entry->Release();
   return true;
 }
 
@@ skipping 41 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", header_->experiment,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", header_->experiment,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache