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

net/tools/dump_cache/dump_files.cc

 // Copyright (c) 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.
 
 // Performs basic inspection of the disk cache files with minimal disruption
 // to the actual files (they still may change if an error is detected on the
 // files).
 
+#include <set>
 #include <stdio.h>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "net/base/file_stream.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_format.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/storage_block.h"
@@ skipping 41 matching lines @@
   printf("entries: %d\n", header.num_entries);
   printf("total bytes: %d\n", header.num_bytes);
   printf("last file number: %d\n", header.last_file);
   printf("current id: %d\n", header.this_id);
   printf("table length: %d\n", header.table_len);
   printf("last crash: %d\n", header.crash);
   printf("experiment: %d\n", header.experiment);
   for (int i = 0; i < 5; i++) {
     printf("head %d: 0x%x\n", i, header.lru.heads[i]);
     printf("tail %d: 0x%x\n", i, header.lru.tails[i]);
+    printf("size %d: 0x%x\n", i, header.lru.sizes[i]);
   }
   printf("transaction: 0x%x\n", header.lru.transaction);
   printf("operation: %d\n", header.lru.operation);
   printf("operation list: %d\n", header.lru.operation_list);
   printf("-------------------------\n\n");
 }
 
 // Dumps the contents of a block-file header.
 void DumpBlockHeader(const std::wstring& name) {
   disk_cache::BlockFileHeader header;
@@ skipping 44 matching lines @@
   bool LoadRankings(disk_cache::CacheAddr addr,
                     disk_cache::RankingsNode* rankings);
 
  private:
   std::wstring path_;
   disk_cache::BlockFiles block_files_;
   scoped_refptr<disk_cache::MappedFile> index_file_;
   disk_cache::Index* index_;
   int current_hash_;
   disk_cache::CacheAddr next_addr_;
+  std::set<disk_cache::CacheAddr> dumped_entries_;
   DISALLOW_COPY_AND_ASSIGN(CacheDumper);
 };
 
 bool CacheDumper::Init() {
   if (!block_files_.Init(false)) {
     printf("Unable to init block files\n");
     return false;
   }
 
   std::wstring index_name(path_);
   file_util::AppendToPath(&index_name, kIndexName);
   index_file_ = new disk_cache::MappedFile;
   index_ = reinterpret_cast<disk_cache::Index*>(index_file_->Init(
       FilePath::FromWStringHack(index_name), 0));
   if (!index_) {
     printf("Unable to map index\n");
     return false;
   }
 
   return true;
 }
 
 bool CacheDumper::GetEntry(disk_cache::EntryStore* entry) {
+  if (dumped_entries_.find(next_addr_) != dumped_entries_.end()) {
+    printf("Loop detected\n");
+    next_addr_ = 0;
+    current_hash_++;
+  }
+
   if (next_addr_) {
-    if (LoadEntry(next_addr_, entry)) {
-      next_addr_ = entry->next;
-      if (!next_addr_)
-        current_hash_++;
+    if (LoadEntry(next_addr_, entry))
       return true;
-    } else {
-      printf("Unable to load entry at address 0x%x\n", next_addr_);
-      next_addr_ = 0;
-      current_hash_++;
-    }
+
+    printf("Unable to load entry at address 0x%x\n", next_addr_);
+    next_addr_ = 0;
+    current_hash_++;
   }
 
   for (int i = current_hash_; i < index_->header.table_len; i++) {
     // Yes, we'll crash if the table is shorter than expected, but only after
     // dumping every entry that we can find.
     if (index_->table[i]) {
       current_hash_ = i;
-      if (LoadEntry(index_->table[i], entry)) {
-        next_addr_ = entry->next;
-        if (!next_addr_)
-          current_hash_++;
+      if (LoadEntry(index_->table[i], entry))
         return true;
-      } else {
-        printf("Unable to load entry at address 0x%x\n", index_->table[i]);
-      }
+
+      printf("Unable to load entry at address 0x%x\n", index_->table[i]);
     }
   }
   return false;
 }
 
 bool CacheDumper::LoadEntry(disk_cache::CacheAddr addr,
                             disk_cache::EntryStore* entry) {
   disk_cache::Addr address(addr);
   disk_cache::MappedFile* file = block_files_.GetFile(address);
   if (!file)
     return false;
 
   disk_cache::CacheEntryBlock entry_block(file, address);
   if (!entry_block.Load())
     return false;
 
   memcpy(entry, entry_block.Data(), sizeof(*entry));
   printf("Entry at 0x%x\n", addr);
+
+  // Prepare for the next entry to load.
+  next_addr_ = entry->next;
+  if (next_addr_) {
+    dumped_entries_.insert(addr);
+  } else {
+    current_hash_++;
+    dumped_entries_.clear();
+  }
   return true;
 }
 
 bool CacheDumper::LoadRankings(disk_cache::CacheAddr addr,
                                disk_cache::RankingsNode* rankings) {
   disk_cache::Addr address(addr);
   disk_cache::MappedFile* file = block_files_.GetFile(address);
   if (!file)
     return false;
 
@@ skipping 97 matching lines @@
     DumpEntry(entry);
     disk_cache::RankingsNode rankings;
     if (dumper.LoadRankings(entry.rankings_node, &rankings))
       DumpRankings(rankings);
   }
 
   printf("Done.\n");
 
   return 0;
 }