Disk cache: Prevent obscure file corruption and deal...

net/disk_cache/eviction.cc

 // Copyright (c) 2006-2010 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 adds re-use as a factor to evict
@@ skipping 64 matching lines @@
   backend_ = backend;
   rankings_ = &backend->rankings_;
   header_ = &backend_->data_->header;
   max_size_ = LowWaterAdjust(backend_->max_size_);
   new_eviction_ = backend->new_eviction_;
   first_trim_ = true;
   trimming_ = false;
   delay_trim_ = false;
   trim_delays_ = 0;
   init_ = true;
+  test_mode_ = false;
   in_experiment_ = (header_->experiment == EXPERIMENT_DELETED_LIST_IN);
 }
 
 void Eviction::Stop() {
   // It is possible for the backend initialization to fail, in which case this
   // object was never initialized... and there is nothing to do.
   if (!init_)
     return;
 
   // We want to stop further evictions, so let's pretend that we are busy from
@@ skipping 23 matching lines @@
   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()->dirty != backend_->GetCurrentEntryId() || 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))
+      if (!EvictEntry(node.get(), empty) && !test_mode_)
         continue;
 
       if (!empty) {
         backend_->OnEvent(Stats::TRIM_ENTRY);
+        if (test_mode_)
+          break;
 
         if ((TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
   }
 
@@ skipping 32 matching lines @@
     return OnDoomEntryV2(entry);
 
   rankings_->Remove(entry->rankings(), GetListForEntry(entry));
 }
 
 void Eviction::OnDestroyEntry(EntryImpl* entry) {
   if (new_eviction_)
     return OnDestroyEntryV2(entry);
 }
 
+void Eviction::SetTestMode() {
+  test_mode_ = true;
+}
+
+void Eviction::TrimDeletedList(bool empty) {
+  DCHECK(test_mode_ && new_eviction_);
+  TrimDeleted(empty);
+}
+
 void Eviction::PostDelayedTrim() {
   // Prevent posting multiple tasks.
   if (delay_trim_)
     return;
   delay_trim_ = true;
   trim_delays_++;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       factory_.NewRunnableMethod(&Eviction::DelayedTrim), 1000);
 }
 
@@ skipping 40 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 = backend_->GetEnumeratedEntry(node, true);
+  EntryImpl* entry = backend_->GetEnumeratedEntry(node);
   if (!entry) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
   ReportTrimTimes(entry);
   if (empty || !new_eviction_) {
     entry->DoomImpl();
   } else {
     entry->DeleteEntryData(false);
@@ skipping 57 matching lines @@
       // 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()->dirty != backend_->GetCurrentEntryId() || 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))
+        if (!EvictEntry(node.get(), empty) && !test_mode_)
           continue;
 
+        if (!empty && test_mode_)
+          break;
+
         if (!empty && (TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
     if (!empty)
       list = kListsToSearch;
   }
 
   if (empty) {
     TrimDeleted(true);
-  } else if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4) {
+  } else if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4 &&
+             !test_mode_) {
     MessageLoop::current()->PostTask(FROM_HERE,
         factory_.NewRunnableMethod(&Eviction::TrimDeleted, empty));
   }
 
   if (empty) {
     CACHE_UMA(AGE_MS, "TotalClearTimeV2", 0, start);
   } else {
     CACHE_UMA(AGE_MS, "TotalTrimTimeV2", backend_->GetSizeGroup(), start);
   }
 
@@ skipping 94 matching lines @@
 
   TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
     rankings_->GetPrev(node.get(), Rankings::DELETED));
   bool deleted = false;
   for (int i = 0; (i < 4 || empty) && next.get(); i++) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     deleted |= RemoveDeletedNode(node.get());
+    if (test_mode_)
+      break;
   }
 
   // Normally we use 25% for each list. The experiment doubles the number of
   // deleted entries, so the total number of entries increases by 25%. Using
   // 40% of that value for deleted entries leaves the size of the other three
   // lists intact.
   int max_length = in_experiment_ ? header_->num_entries * 2 / 5 :
                                     header_->num_entries / 4;
-  if (deleted && !empty &&
-      header_->lru.sizes[Rankings::DELETED] > max_length)
+  if (deleted && !empty && !test_mode_ &&
+      header_->lru.sizes[Rankings::DELETED] > max_length) {
     MessageLoop::current()->PostTask(FROM_HERE,
         factory_.NewRunnableMethod(&Eviction::TrimDeleted, false));
+  }
 
   CACHE_UMA(AGE_MS, "TotalTrimDeletedTime", 0, start);
   Trace("*** Trim Deleted end ***");
   return;
 }
 
 bool Eviction::RemoveDeletedNode(CacheRankingsBlock* node) {
-  EntryImpl* entry;
-  bool dirty;
-  if (backend_->NewEntry(Addr(node->Data()->contents), &entry, &dirty)) {
+  EntryImpl* entry = backend_->GetEnumeratedEntry(node);
+  if (!entry) {
     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).

[gavinp, 2011/01/25 20:23:51]

Awesome!  I'm always happy to see TODOs go.

-  if (node->Data()->dirty) {
-    // We ignore the failure; we're removing the entry anyway.
-    entry->Update();
-  }
   bool doomed = (entry->entry()->Data()->state == ENTRY_DOOMED);
   entry->entry()->Data()->state = ENTRY_DOOMED;
   entry->DoomImpl();
   entry->Release();
   return !doomed;
 }
 
 bool Eviction::NodeIsOldEnough(CacheRankingsBlock* node, int list) {
   if (!node)
     return false;
@@ skipping 38 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", 0,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", 0,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache