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

net/disk_cache/rankings.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/rankings.h"
 
 #include "base/histogram.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
@@ skipping 302 matching lines @@
 //
 // D. Remove tail:
 //    1. a(x, r), r(a, r), head(x), tail(r)           initial state
 //    2. a(x, r), r(a, r), head(x), tail(a)           WriteTail()
 //    3. a(x, a), r(a, r), head(x), tail(a)           prev.Store()
 //    4. a(x, a), r(0, 0), head(x), tail(a)           next.Store()
 void Rankings::Remove(CacheRankingsBlock* node, List list) {
   Trace("Remove 0x%x (0x%x 0x%x)", node->address().value(), node->Data()->next,
         node->Data()->prev);
   DCHECK(node->HasData());
+  InvalidateIterators(node);
   Addr next_addr(node->Data()->next);
   Addr prev_addr(node->Data()->prev);
   if (!next_addr.is_initialized() || next_addr.is_separate_file() ||
       !prev_addr.is_initialized() || prev_addr.is_separate_file()) {
     LOG(WARNING) << "Invalid rankings info.";
     return;
   }
 
   CacheRankingsBlock next(backend_->File(next_addr), next_addr);
   CacheRankingsBlock prev(backend_->File(prev_addr), prev_addr);
@@ skipping 54 matching lines @@
   UpdateIterators(&next);
   UpdateIterators(&prev);
 }
 
 // A crash in between Remove and Insert will lead to a dirty entry not on the
 // list. We want to avoid that case as much as we can (as while waiting for IO),
 // but the net effect is just an assert on debug when attempting to remove the
 // entry. Otherwise we'll need reentrant transactions, which is an overkill.
 void Rankings::UpdateRank(CacheRankingsBlock* node, bool modified, List list) {
   Time start = Time::Now();
-  NotAnIterator(node);
   Remove(node, list);
   Insert(node, modified, list);
   CACHE_UMA(AGE_MS, "UpdateRank", 0, start);
 }
 
 void Rankings::CompleteTransaction() {
   Addr node_addr(static_cast<CacheAddr>(control_data_->transaction));
   if (!node_addr.is_initialized() || node_addr.is_separate_file()) {
     NOTREACHED();
     LOG(ERROR) << "Invalid rankings info.";
@@ skipping 159 matching lines @@
   if (node && !CheckSingleLink(prev.get(), node))
     return NULL;
 
   return prev.release();
 }
 
 void Rankings::FreeRankingsBlock(CacheRankingsBlock* node) {
   TrackRankingsBlock(node, false);
 }
 
+void Rankings::TrackRankingsBlock(CacheRankingsBlock* node,
+                                  bool start_tracking) {
+  if (!node)
+    return;
+
+  IteratorPair current(node->address().value(), node);
+
+  if (start_tracking)
+    iterators_.push_back(current);
+  else
+    iterators_.remove(current);
+}
+
 int Rankings::SelfCheck() {
   int total = 0;
   for (int i = 0; i < LAST_ELEMENT; i++) {
     int partial = CheckList(static_cast<List>(i));
     if (partial < 0)
       return partial;
     total += partial;
   }
   return total;
 }
@@ skipping 133 matching lines @@
   return false;
 }
 
 bool Rankings::IsTail(CacheAddr addr) {
   for (int i = 0; i < LAST_ELEMENT; i++)
     if (addr == tails_[i].value())
       return true;
   return false;
 }
 
-void Rankings::TrackRankingsBlock(CacheRankingsBlock* node,
-                                  bool start_tracking) {
-  if (!node)
-    return;
-
-  IteratorPair current(node->address().value(), node);
-
-  if (start_tracking)
-    iterators_.push_back(current);
-  else
-    iterators_.remove(current);
-}
-
 // We expect to have just a few iterators at any given time, maybe two or three,
 // But we could have more than one pointing at the same mode. We walk the list
 // of cache iterators and update all that are pointing to the given node.
 void Rankings::UpdateIterators(CacheRankingsBlock* node) {
   CacheAddr address = node->address().value();
   for (IteratorList::iterator it = iterators_.begin(); it != iterators_.end();
        ++it) {
-    if (it->first == address) {
+    if (it->first == address && it->second->HasData()) {
       CacheRankingsBlock* other = it->second;
       other->Data()->next = node->Data()->next;
       other->Data()->prev = node->Data()->prev;
     }
   }
 }
 
-void Rankings::NotAnIterator(CacheRankingsBlock* node) {
-#ifdef NDEBUG
-  // This method is only enabled for debug builds.
-  return;
-#endif
+void Rankings::InvalidateIterators(CacheRankingsBlock* node) {
   CacheAddr address = node->address().value();
   for (IteratorList::iterator it = iterators_.begin(); it != iterators_.end();
        ++it) {
-    if (it->first == address)
-      NOTREACHED();
+    if (it->first == address) {
+      LOG(WARNING) << "Invalidating iterator at 0x" << std::hex << address;
+      it->second->Discard();
+    }
   }
 }
 
 void Rankings::IncrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] < kint32max);
   if (control_data_->sizes[list] < kint32max)
     control_data_->sizes[list]++;
 }
 
 void Rankings::DecrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] > 0);
   if (control_data_->sizes[list] > 0)
     control_data_->sizes[list]--;
 }
 
 }  // namespace disk_cache