Disk cache v3 ref2

net/tools/dump_cache/dump_files.cc

 // Copyright (c) 2012 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 "net/tools/dump_cache/dump_files.h"
 
 #include <stdio.h>
 
 #include <set>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/format_macros.h"
 #include "base/message_loop/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/stats.h"
+#include "net/disk_cache/storage_block.h"
 #include "net/disk_cache/storage_block-inl.h"
-#include "net/disk_cache/storage_block.h"
+
+namespace disk_cache {
+typedef StorageBlock<EntryStore> CacheEntryBlock;
+typedef StorageBlock<RankingsNode> CacheRankingsBlock;
+}
 
 namespace {
 
 const base::FilePath::CharType kIndexName[] = FILE_PATH_LITERAL("index");
 
 // Reads the |header_size| bytes from the beginning of file |name|.
 bool ReadHeader(const base::FilePath& name, char* header, int header_size) {
+  if (name.value().back() == FILE_PATH_LITERAL('d'))
+    return false;
+
   net::FileStream file(NULL);
   file.OpenSync(name, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   if (!file.IsOpen()) {
     printf("Unable to open file %s\n", name.MaybeAsASCII().c_str());
     return false;
   }
 
   int read = file.ReadSync(header, header_size);
   if (read != header_size) {
     printf("Unable to read file %s\n", name.MaybeAsASCII().c_str());
     return false;
   }
   return true;
 }
 
 int GetMajorVersionFromFile(const base::FilePath& name) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return 0;
 
   return header.version >> 16;
 }
 
 // Dumps the contents of the Stats record.
-void DumpStats(const base::FilePath& path, disk_cache::CacheAddr addr) {
+void DumpStats(const base::FilePath& path, disk_cache::CacheAddr addr,
+               int version) {
   // We need a message loop, although we really don't run any task.
   base::MessageLoop loop(base::MessageLoop::TYPE_IO);
 
   disk_cache::BlockFiles block_files(path);
-  if (!block_files.Init(false)) {
+  int num_files = (version == 2) ? disk_cache::kFirstAdditionalBlockFile :
+                                   disk_cache::kFirstAdditionalBlockFileV3;
+  if (!block_files.Init(false, num_files)) {
     printf("Unable to init block files\n");
     return;
   }
 
   disk_cache::Addr address(addr);
   disk_cache::MappedFile* file = block_files.GetFile(address);
   if (!file)
     return;
 
   size_t length = (2 + disk_cache::Stats::kDataSizesLength) * sizeof(int32) +
@@ skipping 11 matching lines @@
   for (int i = 0; i < disk_cache::Stats::kDataSizesLength; i++)
     printf("Size(%d): %d\n", i, buffer[i + 2]);
 
   int64* counters = reinterpret_cast<int64*>(
                         buffer.get() + 2 + disk_cache::Stats::kDataSizesLength);
   for (int i = 0; i < disk_cache::Stats::MAX_COUNTER; i++)
     printf("Count(%d): %" PRId64 "\n", i, *counters++);
   printf("-------------------------\n\n");
 }
 
-// Dumps the contents of the Index-file header.
-void DumpIndexHeader(const base::FilePath& name,
-                     disk_cache::CacheAddr* stats_addr) {
+// Dumps the contents of the Index-file header. Returns the major version.
+int DumpIndexHeader(const base::FilePath& name,
+                    disk_cache::CacheAddr* stats_addr) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
-    return;
+    return 0;
 
   printf("Index file:\n");
   printf("magic: %x\n", header.magic);
   printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff);
   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);
   printf("stats: %x\n", header.stats);
-  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]);
+
+  if (header.version >> 16 == 2) {
+    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);
+  } else {
+    DumpIndexHeaderPart2(&header);
   }
-  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");
 
   *stats_addr = header.stats;
+  return header.version >> 16;
 }
 
 // Dumps the contents of a block-file header.
 void DumpBlockHeader(const base::FilePath& name) {
   disk_cache::BlockFileHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return;
 
   printf("Block file: %s\n", name.BaseName().MaybeAsASCII().c_str());
   printf("magic: %x\n", header.magic);
@@ skipping 42 matching lines @@
   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)) {
+  if (!block_files_.Init(false, disk_cache::kFirstAdditionalBlockFile)) {
     printf("Unable to init block files\n");
     return false;
   }
 
   base::FilePath index_name(path_.Append(kIndexName));
   index_file_ = new disk_cache::MappedFile;
   index_ = reinterpret_cast<disk_cache::Index*>(
       index_file_->Init(index_name, 0));
   if (!index_) {
     printf("Unable to map index\n");
@@ skipping 33 matching lines @@
   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::StorageBlock<disk_cache::EntryStore> entry_block(file, address);
+  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;
 
-  disk_cache::StorageBlock<disk_cache::RankingsNode> rank_block(file, address);
+  disk_cache::CacheRankingsBlock rank_block(file, address);
   if (!rank_block.Load())
     return false;
 
   memcpy(rankings, rank_block.Data(), sizeof(*rankings));
   printf("Rankings at 0x%x\n", addr);
   return true;
 }
 
 void DumpEntry(const disk_cache::EntryStore& entry) {
   std::string key;
@@ skipping 55 matching lines @@
   if (version != GetMajorVersionFromFile(data_name))
     return 0;
 
   return version;
 }
 
 // Dumps the headers of all files.
 int DumpHeaders(const base::FilePath& input_path) {
   base::FilePath index_name(input_path.Append(kIndexName));
   disk_cache::CacheAddr stats_addr = 0;
-  DumpIndexHeader(index_name, &stats_addr);
+  int version = DumpIndexHeader(index_name, &stats_addr);
 
   base::FileEnumerator iter(input_path, false,
                             base::FileEnumerator::FILES,
                             FILE_PATH_LITERAL("data_*"));
   for (base::FilePath file = iter.Next(); !file.empty(); file = iter.Next())
     DumpBlockHeader(file);
 
-  DumpStats(input_path, stats_addr);
+  DumpStats(input_path, stats_addr, version);
   return 0;
 }
 
 // Dumps all entries from the cache.
-int DumpContents(const base::FilePath& input_path) {
+int DumpContentsV2(const base::FilePath& input_path) {
   DumpHeaders(input_path);
 
   // We need a message loop, although we really don't run any task.
   base::MessageLoop loop(base::MessageLoop::TYPE_IO);
   CacheDumper dumper(input_path);
   if (!dumper.Init())
     return -1;
 
   disk_cache::EntryStore entry;
   while (dumper.GetEntry(&entry)) {
     DumpEntry(entry);
     disk_cache::RankingsNode rankings;
     if (dumper.LoadRankings(entry.rankings_node, &rankings))
       DumpRankings(rankings);
   }
 
   printf("Done.\n");
 
   return 0;
 }