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

net/disk_cache/backend_impl.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.
 
 #include "net/disk_cache/backend_impl.h"
 
 #include "base/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 129 matching lines @@
 
 // Sets |current_group| for the current experiment. Returns false if the files
 // should be discarded.
 bool InitExperiment(int* current_group) {
   if (*current_group == 3 || *current_group == 4) {
     // Discard current cache for groups 3 and 4.
     return false;
   }
 
   if (*current_group <= 5) {
+#if defined(UNIT_TEST)
+    // The unit test controls directly what to test.
+    *current_group = 0;
+    return true;
+#endif
+
     // Re-load the two groups.
     int option = base::RandInt(0, 9);
 
     if (option > 1) {
       // 80% will be out of the experiment.
       *current_group = 9;
     } else {
       *current_group = option + 6;
     }
   }
@@ skipping 1010 matching lines @@
       if (parent_entry) {
         parent_entry->SetNextAddress(child);
         parent_entry = NULL;
       } else {
         data_->table[hash & mask_] = child.value();
       }
 
       if (!error) {
         // It is important to call DestroyInvalidEntry after removing this
         // entry from the table.
-        DestroyInvalidEntry(address, cache_entry);
+        DestroyInvalidEntry(cache_entry);
         cache_entry = NULL;
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
       }
 
       // Restart the search.
       address.set_value(data_->table[hash & mask_]);
       continue;
     }
 
@@ skipping 54 matching lines @@
       return false;
   } else {
     // Get the next entry from the last list, and the actual entries for the
     // elements on the other lists.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       if (iterator->list == i) {
           OpenFollowingEntryFromList(forward, iterator->list,
                                      &iterator->nodes[i], &temp);
       } else {
-        temp = GetEnumeratedEntry(iterator->nodes[i]);
+        temp = GetEnumeratedEntry(iterator->nodes[i], false);
       }
 
       entries[i].swap(&temp);  // The entry was already addref'd.
     }
   }
 
   int newest = -1;
   int oldest = -1;
   Time access_times[kListsToSearch];
   for (int i = 0; i < kListsToSearch; i++) {
@@ skipping 35 matching lines @@
   if (!new_eviction_ && Rankings::NO_USE != list)
     return false;
 
   Rankings::ScopedRankingsBlock rankings(&rankings_, *from_entry);
   CacheRankingsBlock* next_block = forward ?
       rankings_.GetNext(rankings.get(), list) :
       rankings_.GetPrev(rankings.get(), list);
   Rankings::ScopedRankingsBlock next(&rankings_, next_block);
   *from_entry = NULL;
 
-  *next_entry = GetEnumeratedEntry(next.get());
+  *next_entry = GetEnumeratedEntry(next.get(), false);
   if (!*next_entry)
     return false;
 
   *from_entry = next.release();
   return true;
 }
 
-EntryImpl* BackendImpl::GetEnumeratedEntry(CacheRankingsBlock* next) {
+EntryImpl* BackendImpl::GetEnumeratedEntry(CacheRankingsBlock* next,
+                                           bool to_evict) {
   if (!next)
     return NULL;
 
-  scoped_refptr<EntryImpl> entry;
-  EntryImpl* temp = NULL;
+  EntryImpl* entry;
+  bool dirty;
+  if (NewEntry(Addr(next->Data()->contents), &entry, &dirty))
+    return NULL;
 
-  if (next->Data()->pointer) {
-    entry = reinterpret_cast<EntryImpl*>(next->Data()->pointer);
-    entry.swap(&temp);
-    return temp;
+  if (dirty) {
+    // We cannot trust this entry. This code also releases the reference.
+    DestroyInvalidEntryFromEnumeration(entry);
+    return NULL;
   }
 
-  bool dirty;
-  if (NewEntry(Addr(next->Data()->contents), &temp, &dirty))
-    return NULL;
-  entry.swap(&temp);
-
-  if (dirty) {
-    // We cannot trust this entry. Call MatchEntry to go through the regular
-    // path and take the appropriate action.
-    std::string key = entry->GetKey();
-    uint32 hash = entry->GetHash();
-    entry = NULL;  // Release the entry.
-    temp = MatchEntry(key, hash, false);
-    if (temp)
-      temp->Release();
-
+  // There is no need to store the entry to disk if we want to delete it.
+  if (!to_evict && !entry->Update()) {
+    entry->Release();
     return NULL;
   }
-  if (!entry->Update())
-    return NULL;
 
-  entry.swap(&temp);
-  return temp;
+  return entry;
 }
 
 bool BackendImpl::ResurrectEntry(EntryImpl* deleted_entry, Entry** entry) {
   if (ENTRY_NORMAL == deleted_entry->entry()->Data()->state) {
     deleted_entry->Release();
     stats_.OnEvent(Stats::CREATE_MISS);
     Trace("create entry miss ");
     return false;
   }
 
   // We are attempting to create an entry and found out that the entry was
   // previously deleted.
 
   eviction_.OnCreateEntry(deleted_entry);
   *entry = deleted_entry;
 
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("Resurrect entry hit ");
   return true;
 }
 
-void BackendImpl::DestroyInvalidEntry(Addr address, EntryImpl* entry) {
+void BackendImpl::DestroyInvalidEntry(EntryImpl* entry) {
   LOG(WARNING) << "Destroying invalid entry.";
   Trace("Destroying invalid entry 0x%p", entry);
 
   entry->SetPointerForInvalidEntry(GetCurrentEntryId());
 
   eviction_.OnDoomEntry(entry);
   entry->InternalDoom();
 
   if (!new_eviction_)
     DecreaseNumEntries();
   stats_.OnEvent(Stats::INVALID_ENTRY);
 }
 
+// This is kind of ugly. The entry may or may not be part of the cache index
+// table, and it may even have corrupt fields. If we just doom it, we may end up
+// deleting it twice (if all fields are right, and when looking up the parent of
+// chained entries wee see this one... and we delete it because it is dirty). If
+// we ignore it, we may leave it here forever. So we're going to attempt to
+// delete it through the provided object, without touching the index table
+// (because we cannot jus call MatchEntry()), and also attempt to delete it from
+// the table through the key: this may find a new entry (too bad), or an entry
+// that was just deleted and consider it a very corrupt entry.
+void BackendImpl::DestroyInvalidEntryFromEnumeration(EntryImpl* entry) {
+  std::string key = entry->GetKey();
+  entry->SetPointerForInvalidEntry(GetCurrentEntryId());
+  CacheAddr next_entry = entry->entry()->Data()->next;
+  if (!next_entry) {
+    DestroyInvalidEntry(entry);
+    entry->Release();
+  }
+  DoomEntry(key);
+
+  if (!next_entry)
+    return;
+
+  // We have a chained entry so instead of destroying first this entry and then
+  // anything with this key, we just called DoomEntry() first. If that call
+  // deleted everything, |entry| has invalid data. Let's see if there is
+  // something else to do. We started with just a rankings node (we come from
+  // an enumeration), so that one may still be there.
+  CacheRankingsBlock* rankings = entry->rankings();
+  rankings->Load();
+  if (rankings->Data()->contents) {
+    // We still have something. Clean this up.
+    DestroyInvalidEntry(entry);
+  }
+  entry->Release();
+}
+
 void BackendImpl::AddStorageSize(int32 bytes) {
   data_->header.num_bytes += bytes;
   DCHECK(data_->header.num_bytes >= 0);
 
   if (data_->header.num_bytes > max_size_)
     eviction_.TrimCache(false);
 }
 
 void BackendImpl::SubstractStorageSize(int32 bytes) {
   data_->header.num_bytes -= bytes;
@@ skipping 203 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache